DtDiGuyScenario.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once
#include <string>
#include <list>

#include <vrvDiGuy/vrvDiGuy.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtUniqueID.h>
#include <vlutil/vlString.h>
#include <matrix/vlVector.h>

#include <osg/Group>
#include <vrvUtil/DtSignalConnectionManager.h>

#define ENABLE_DIGUY_PARTICLE_RENDERING 0

class diguyScenario;
class diguyCharacter;
class DtCoordTransform;

namespace makArchives
{
   class DtDiGuySettings;
}

namespace makVrv
{
   class DtDe;
   class DtWindow;

   static const int numDiGuyTypeMapFields = 9;

   class DiGuyTypeMapFieldNode
   {
   public:
       DiGuyTypeMapFieldNode();
       ~DiGuyTypeMapFieldNode();

       void addType(const DtString &type);
       void addAppearance(const DtString &appearance);

       DiGuyTypeMapFieldNode *addNextFieldNode(const DtString &valueName);
       void addWildCardNode();
       DiGuyTypeMapFieldNode *getNextFieldNode(const DtString &valueName);

       // indicates the current level.
       void getAppearances(std::vector<DtString> &choiceValues, int depth, std::vector<DtString> &retAppearances);
       void getFieldValues(std::list<DtString> &retList);

       void deep_merge(DiGuyTypeMapFieldNode *source);

       int                                         fieldNum;
       // the name of this option
       DtString                                    optionName; 
       // for quick lookup
       std::map<DtString, DiGuyTypeMapFieldNode *> nextFieldNodesMap;
       // If this is the last node in the chain, these will contain the type and appearance
       // names that the full chain leads to.
       std::list<DtString>                         typeNameList; 
       std::list<DtString>                         appearanceNameList;
   };

   class DT_DLL_VRVDIGUY DtDiGuyScenario : public DtVirtualBaseClass
   {
   public:

      typedef std::list<DtString> StringList;
      typedef std::vector<StringList> StringListVec;

      // Static accessor: creates a new instance or, if one is already associated
      // with DtDe instance, return the existing instance. The visual component
      // (needed for graphical applications) can be initialized now or later.
      static DtDiGuyScenario& instance(DtDe& de, bool initVisualComponent = true);

      // For graphical applications, this must be called, but it can be called at
      // the last possible moment. It calls, or enables the calling of, functions
      // that are somewhat more time-consuming.
      void initializeVisualComponent();
    
      // This returns an instance of DtDiGuyScenario in which the visual component
      // has not been initialized. If this is not a graphical application, it will
      // not be possible to initialize the visual component.
      static DtDiGuyScenario *lightweight_instance( const std::string& dataPath );

      virtual ~DtDiGuyScenario();

      diguyScenario& scenario();

      void clearScene();

      virtual osg::Node* characterRoot();

      int getUseGuides(){return myUseGuides;}
      float getGuideSyncGain(){return myGuideSyncGain;}
      int getUseInstancing(){return myUseInstancing;}
      
      const char * mapEffect(const char * diguy_effect_name);

      std::string findCharacterName(DtElementID parentSceneObjectID);

      int getSupportsWeightVariations(DtElementID parentSceneObjectID);

      bool evalScript(const std::string & script);


      int getNumCharacterTypes();
      const char * getCharacterTypeAtIndex(int index);
      int getCharacterTypeNumAppearances(const char *typeName);
      const char *getCharacterTypeAppearanceAtIndex(const char *typeName, int index);
      int getCharacterTypeNumGestures(const char *typeName);
      const char *getCharacterTypeGestureAtIndex(const char *typeName, int index);
      
      const char *getHandItemClass(const char *typeName);
      int getNumHandItemsInClass(const char *className);
      const char *getHandItemFromClass(const char *className, int index);

      int getCharacterTypeNumHeads(const char *typeName, const char *appearanceName);
      const char *getCharacterTypeHeadAtIndex(const char *typeName, const char *appearanceName, int index);

      int getCharacterTypeNumActions(const char *typeName);
      const char *getCharacterTypeActionAtIndex(const char *typeName, int index);

      float getCharacterTypeActionDuration(const char *typeName, const char *actionName);
      float getCharacterTypeActionSpeed(const char *typeName, const char *actionName);
      const char *getCharacterTypeActionPosture(const char *typeName, const char *actionName);
      const char *getCharacterTypeActionDirection(const char *typeName, const char *actionName);
      const char *getCharacterTypeActionPrimaryVariant(const char *typeName, const char *actionName);


      int getNumTypeMapEntries();

      const char *getTypeMapCharacterType(int index);

      const char *getTypeMapCharacterAppearance(int index);
      
      const char *getTypeMapFieldValue(int index, const char *fieldName);
      const char *getTypeMapFieldValue(int index, int fieldIndex);

      // For finding out the total number of possible values for the first field of a character's type map
      // Class is something like: animal, effect, human, human_on_vehicle, object, vehicle
      int getNumTypeMapCharacterClasses();
      const char* getTypeMapCharacterClassAtIndex(int index);

      // For finding out the total number of possible values for the second field of a character's type map
      // Category depends on class (above)
      int getNumTypeMapCategories(const char* character_class);
      const char* getTypeMapCategoryAtIndex(const char* character_class, int index);

      // For finding out the total number of possible values for the third field of a character's type map
      int getNumTypeMapSubcategories(const char* character_class,
          const char* category);
      const char* getTypeMapSubcategoryAtIndex(const char* character_class,
          const char* category,
          int index);

      virtual void getAppearancesMatchingDiGuyTypeMap(const DtString &characterType, std::vector<DtString> &fields, std::vector<DtString> &retAppearances);
      virtual void getAppearancesMatchingPartialDiGuyTypeMap(const DtString &characterType, std::vector<DtString> &partialFields, 
          std::vector<int> &fieldIndices, std::vector<DtString> &retAppearances);
      virtual void getTypeMapFieldOptions(const DtString &characterType, std::vector<DtString> &fields, StringListVec &retValues);
      virtual void getTypeMapPartialFieldOptions(const DtString &characterType, std::vector<DtString> &partialFields, std::vector<int> &fieldIndices, 
          StringListVec &retValues);

      virtual void initTypeMapNodes();

   protected:
      virtual void slot_windowDestroyed(DtWindow* window);

      virtual void slot_windowCreated(DtWindow* window);

      virtual void slot_reloadShader();

      virtual void slot_preDraw();

      virtual void slot_postDraw();

      virtual void slot_postUpdate();
      
      virtual void syncToSharedDiGuySettings();

      virtual void slot_diGuyInstancingEnabledChanged( bool enabled );

      virtual void slot_diGuyInstancedLodChanged( int lod );

      virtual void slot_diGuyVisualizeInstancingChanged( bool enabled );

      virtual void slot_diGuyMaxDrawDistanceChanged( float distance );

      virtual void slot_diGuyMultiThreadUpdateChanged( bool enabled );

   protected:

      // Internal helper function to get pointer to specific DI-Guy character
      diguyCharacter *getCharacter(DtElementID parentSceneObjectID);

      // Helper function called by other instance functions. If this is a graphical application,
      // de must be set.
      static DtDiGuyScenario *createInstance(DtDe& de, bool initVisualComponent = true);
      static DtDiGuyScenario *createNonVisualInstance(const std::string& dataPath);

      static void slot_displayToBeDestroyed(const std::string& displayName, DtDe *de);


      void updateScenario(double simTime);
      void setComponentVisualizationMode(int mode);

      DtDiGuyScenario(DtDe& de);
      DtDiGuyScenario(const std::string& dataPth);

      void createDiGuyScenario();

      void reloadConfigInfo();

      DtDe& myDe;
      // True if myDe refers to a valid DtDe object, created by a graphical application, this will be true
      // It might not be true if this instance was created by lightweight_instance()
      bool myDeIsValid;
      diguyScenario* myScenario;

      osg::ref_ptr<osg::Group> myDiguyRoot;
      osg::ref_ptr<osg::Group> myCharacterRoot;
      osg::ref_ptr<osg::Group> myInstancingRoot;
      double myFirstUpdateT;
      double myPreviousUpdateTime;
      int myUseGuides;
      float myGuideSyncGain;

      int myUseInstancing;

      // True if initializeVisualComponent() has been called
      bool myVisualComponentInitialized;
      bool myLightweightInstance;

      DiGuyTypeMapFieldNode                   myTypeMapFieldsRootNode;
      bool                                    myHaveSetupTypeMapFieldsNodes;

      std::string myAlternateDataPath; // use this when the De is not valid

       DtSignalConnectionManager myConnections;
   };

   DtCoordTransform getTopoToGeoc(const DtVector& location);
}