DtDiGuyScenario.h

Go to the documentation of this file.

/****************************************************************************
*  Copyright (c) 2020 VT MAK
*  All rights reserved.
* ***************************************************************************/


#pragma once

#include <string>
#include <list>

#include <vrvDiGuy/vrvDiGuy.h>
#include <vrvDiGuy/DtDiGuyTypeMapFieldNode.h>

#include <vrvCore/DtUniqueID.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>

#include <vrvGraphicsUtils/DtOctree.h>
#include <vrvGraphicsUtils/DtOctreeNode.h>

#include <vlutil/vlString.h>
#include <matrix/vlVector.h>
#include <osg/Group>

#include <tbb/tbb.h>
#include <tbb/mutex.h>

class diguyScenario;
class diguyCharacter;
class DtCoordTransform;


namespace makArchives
{
   class DtDiGuySettings;
}

namespace makVrv
{
   class DtDe;
   class DtWindow;
   class DtDiGuyOsgRootNode;
   class DtDiGuyInstanceTboUpdaterJob;
   class DtDiGuyScenario;
   class DtDiGuyInstanceDrawable;

   struct DtDiGuyCullData;

   struct DtDiguyTransitionInfo
   {
      float myDistance;
      float mySpeed;
      float myDuration;

      DtVector32 myDeltaPos;
      float myRot;

      DtVector32 myBaseDeltaPos;
      float myBaseDeltaRot;
   };



   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();

      virtual void clearScene();

      virtual osg::Node* characterRoot();

      virtual int useGuides();
      virtual  float guideSyncGain();

      virtual int useInstancing();

      virtual bool useMultithreadedCull();

      virtual bool useOctree();

      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 getCharacterTypeTransitionInfo(const char* typeName, const char* actionFrom, const char* actionTo, DtDiguyTransitionInfo& info);


      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();

      static osg::Group* getDiGuyAttachGroup();

      static osg::Group* getDiGuyInstancingAttachGroup();

      virtual bool isGeocentric();
      

      virtual void createOctreeNode(DtDiGuyOsgRootNode* pChar);

      virtual void destroyOctreeNode(DtDiGuyOsgRootNode* pChar);

      virtual void characterOctreeNodeUpdated( DtDiGuyOsgRootNode* pChar);

      virtual Octree_64* octree() { return myOctree; }

      virtual DtDe& getDe() { return myDe; }

      // runs octree cull and finished instancing group generation
      virtual void cullAndUpdate(const Frustum_64& frustum, const DtDiGuyCullData& cullData);

      virtual DtDiGuyInstanceDrawable* instancedDrawable() { return myInstancedDrawable; }

      virtual void updateStats(int mask, double duration);

   protected:

      virtual void slot_terrainLoaded( const DtUnicode& terrain, bool reload );

      virtual void slot_windowDestroyed(DtWindow* window);

      virtual void slot_windowCreated(DtWindow* window);

      virtual void slot_ProfilingChanged(bool active);
      
      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_diGuyMaxMotionUpdateDistanceChanged(float distance);

      virtual void slot_diGuyMultiThreadUpdateChanged( bool enabled );


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


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

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

      void createDiGuyScenario();

      void reloadConfigInfo();

   protected:
      // 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);

   protected:

      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::MatrixTransform> myInstancingRoot;
      osg::ref_ptr<DtDiGuyInstanceDrawable> myInstancedDrawable;
      bool myIsGeocentric;
      double myFirstUpdateT;
      double myPreviousUpdateTime;

      // settings
      int myUseInstancing;
      int myUseGuides;
      bool myUseOctree;
      bool myUseMultithreadedCull;
      float myMaxMotionUpdateDistance;
      float myGuideSyncGain;


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

      DtDiGuyTypeMapFieldNode                   myTypeMapFieldsRootNode;
      bool                                    myHaveSetupTypeMapFieldsNodes;

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

       tbb::mutex myOctreeMutex;
       Octree_64* myOctree;
       Octree_64::NodeVector myVisibleOctreeNodes;
       // temp object, don't realloc every frame
       tbb::concurrent_vector< DtDiGuyOsgRootNode*> myNoninstancedNodeArray;

       // stats
       int myStatOctreeUpdate;
       float myStatOctreeUpdateTime;
       float myStatPreviousOctreeUpdateTime;
       float myStatCulltime;


     public:
       static int theStatNumCharDrawn;
       static tbb::atomic<int> theStatNumCharInstanced;
   };


   DtCoordTransform getTopoToGeoc(const DtVector& location);

}