DtDiGuyScenario.h

Go to the documentation of this file.

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


#pragma once

#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 <vrvMath/DtOctree.h>
#include <vrvMath/DtOctreeNode.h>

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

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

#include <string>
#include <set>

class diguyScenario;
class diguyCharacter;
class diguyCharacterTypeMapFieldValues;
class diguyGestureMetadata;

class DtCoordTransform;

namespace makArchives
{
   class DtDiGuySettings;
}

namespace osg
{
   class RenderInfo;
}

namespace makVrv
{

   class DtDe;
   class DtLightPointNode;
   class DtWindow;

   class DtDiGuyOsgRootNode;
   class DtDiGuyInstanceTboUpdaterJob;
   class DtDiGuyScenario;
   class DtDiGuyInstanceDrawable;

   class DtOsgGizmoRenderer;

   struct DtDiGuyCullData;

   struct DtDiguyLightConfig
   {
      std::string myLinkName;
      int myLightType;
      int myDriver;
   };

   struct DtDiguyStationConfig
   {
      std::string myName;
      std::string myTargetName;
      std::string myIkTargetRightArm;
      std::string myIkTargetLeftArm;
      int myEnum;
   };

   class DT_DLL_VRVDIGUY DtDiGuyScenario : public DtVirtualBaseClass
   {
   public:

      typedef std::set<DtString> StringSet;
      typedef std::vector<StringSet> StringSetVec;
      typedef std::vector<DtDiguyLightConfig> LightConfigDataArray;
      typedef std::vector<DtDiguyStationConfig> StationConfigArray;

   public:

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

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

   protected:

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

   public:

      DtDiGuyScenario( const DtDiGuyScenario& rhs ) = delete;

      DtDiGuyScenario& operator = ( const DtDiGuyScenario& rhs ) = delete;

   public:

      virtual ~DtDiGuyScenario();

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

      diguyScenario& scenario();

      virtual void clearScene();

      virtual osg::Node* characterRoot();

      virtual bool useGuides() const;
      virtual float guideSyncGain() const;

      virtual bool useInstancing() const;

      virtual bool useTextureVariations() const;

      virtual bool useMultithreadedCull() const;

      virtual bool useOctree() const;

      std::string findCharacterName( DtElementID parentSceneObjectID );

      diguyCharacter* getCharacter(DtElementID parentSceneObjectID);

      int getSupportsWeightVariations( DtElementID parentSceneObjectID );

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

      static osg::Group* getDiGuyAttachGroup();

      static osg::Group* getDiGuyInstancingAttachGroup();

      virtual bool isGeocentric() const;


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

      virtual DtLightPointNode* lightPointNode();

      virtual const LightConfigDataArray& lightDataArray();

      virtual const StationConfigArray& stationDataArray();

      virtual void drawDebugLines( osg::RenderInfo& renderInfo, const osg::Vec3d& eyePoint,
         DtOsgGizmoRenderer* renderer );

      virtual bool debugUIActive() { return myDebugUIActive; }
   protected:


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

      virtual void slot_windowCreated( DtWindow* window );

      virtual void slot_windowDestroyed( DtWindow* window );

      virtual void slot_ProfilingChanged( bool active );
      
      virtual void slot_reloadShader();

      virtual void slot_displayConfigurationRealized();

      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_diGuyTextureVariationsEnabledChanged( bool enabled );

      virtual void slot_diGuyMaxDrawDistanceChanged( float distance );

      virtual void slot_diGuyMaxMotionUpdateDistanceChanged( float distance );

      virtual void slot_diGuyMultiThreadUpdateChanged( bool enabled );

      virtual void updateImgui(void);



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

      void createDiGuyScenario();

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

   public:

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

   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<DtLightPointNode> myLightPointNode;
      osg::ref_ptr<osg::MatrixTransform> myLightPointRoot;
      osg::ref_ptr<osg::MatrixTransform> myInstancingRoot;
      osg::ref_ptr<DtDiGuyInstanceDrawable> myInstancedDrawable;

      bool myIsGeocentric;
      double myFirstUpdateT;
      double myPreviousUpdateTime;

      // settings
      bool myUseInstancing;
      bool myUseGuides;
      bool myUseTextureVariations;
      bool myUseOctree;
      bool myUseMultithreadedCull;
      bool myDrawSkeletons;
      bool myDrawIKVisuals;
      bool myDrawMovementInfo;
      float myMaxMotionUpdateDistance;
      float myGuideSyncGain;

      // True if initializeVisualComponent() has been called
      bool myVisualComponentInitialized;
      bool myLightweightInstance;
      bool myDebugUIActive;
      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;

      LightConfigDataArray myLightDataArray;
      StationConfigArray myStationDataArray;

      // A dirty flag indicating that this must be reattached after RDE reconnection
      bool myReAddNodeToSceneGraph;
   };


   DtCoordTransform getTopoToGeoc( const DtVector& location );

}