DtInstanceManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtInstanceState.h>
#include <vrvOsg/DtInstancedCullSet.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>

#include <osgUtil/LineSegmentIntersector>
#include <osgViewer/Renderer>

#include <osg/ref_ptr>
#include <osg/LightSource>

#include <boost/unordered_map.hpp>

#define DT_INSTANCE_MANAGER_CULL_IS_PARALLEL 1
#define DT_INSTANCE_MANAGER_FILLRENDERLIST_IS_PARALLEL 1

#if DT_INSTANCE_MANAGER_FILLRENDERLIST_IS_PARALLEL
#include <vrvGraphicsUtils/DtAtomicScalar.h>
#endif

#define DT_INSTANCE_MANAGER_UPDATEDISTANCESTOEYE_IS_PARALLEL 1

class DtTaitBryan;

namespace osg
{
   class Geometry;
   class Image;
   class Texture2D;
   class Vec2f;
   class Vec3f;
   class Geode;
   class View;
}

namespace osgEarth
{
   class VirtualProgram;
}

namespace makVrv
{
   class DtGlTextureBufferObject;
   class DtInstanceProcessor;
   class DtInstanceLpProcessor;
   class DtOsgIntersectorResult;
   class DtChannelManager;
   class DtChannel;
   class DtPerViewUniformCallback;
   class DtInstanceNode;
   class DtLight;
   class DtOsgCullVisitorParameters;
   class DtViewSpecificGroup;

   class DT_DLL_VRVOSG DtInstanceManager : public DtVirtualBaseClass, public DtSignalConnectionManager
   {
   public:
      typedef std::vector<osg::ref_ptr<osg::Geometry> > GeometryVec;
      typedef std::vector<char> BoolVec; // Using vec of chars for threadsafety
      typedef std::vector<char> ByteVec;
      typedef std::map<osg::ref_ptr< osgEarth::VirtualProgram >, osg::ref_ptr<osgEarth::VirtualProgram> > VpMap;
      typedef std::vector<osg::ref_ptr<osgEarth::VirtualProgram> > VpRefList;
      typedef std::vector<ArrayRange> DrawableRangeVec;
      typedef std::vector<osg::Vec2f> TextureCoordinateVec;
      typedef std::vector<float> FloatVec;

      static const unsigned int NumVec4PerInstance = 8;

      struct InstancedLod
      {
         double minRange;

         double maxRange;

         ArrayRange drawableRange;
      };

      struct InstancedSwitch
      {
         DrawableRangeVec switchRanges;

         BoolVec switchStates;

         BoolVec defaultSwitchStates;
      };

      struct InstancedSequence
      {
         enum SequenceMode { Play, Stop, Pause, Resume };

         DrawableRangeVec switchRanges;

         float timePerFrame;

         float startTime;

         float endTime;

         SequenceMode mode;

         float speed;

         int lastFrame;
      };

      struct InstancedLight
      {
         DtLight* light;
         osg::Vec3f position;
         osg::Vec3f direction;
         unsigned int drawableIx; // index to drawable the light is attached to
      };

      struct InstancedDof
      {
         InstanceMatrix transform;

         unsigned int numChildren;

         ArrayRange drawableRange;

         bool skipNextAnimationFrame;
      };

      struct ModelTypeDofData
      {
         InstanceMatrix putMatrix;

         InstanceMatrix putMatrixInverse;

         InstanceMatrix initialTransform;

         osg::Vec3f initialHpr;

         osg::Vec3f initialTranslate;

         unsigned int numChildren;

         ArrayRange drawableRange;
      };

      struct DofAnimation
      {
         osg::Vec3f trans;

         osg::Vec3f transVel;

         osg::Vec3f hpr;

         osg::Vec3f hprVel;


         float lastUpdate;
      };

      struct LightSource
      {
         osg::ref_ptr<osg::LightSource> lightSource;
         unsigned int attachDrawableIx;
         float range;
         bool isRangeScheme;
      };

      struct LightPoint
      {
         osg::ref_ptr<osg::Node> lightPoint;
         unsigned int attachDrawableIx;
         int groupId;
      };

      typedef std::vector<LightSource> LightSourceVec;
      typedef std::vector<ModelTypeDofData> PerDofDataVec;
      typedef std::vector<InstancedSwitch> InstancedSwitchVec;
      typedef std::vector<InstancedSequence> InstancedSequenceVec;
      typedef std::vector<DofAnimation> DofAnimations;
      typedef std::vector<osg::Node*> NodeVec;
      typedef std::vector<InstancedSwitch*> SwitchVec;
      typedef std::vector<InstancedSequence*> SequenceVec;
      typedef std::vector<InstancedLod*> LodVec;
      typedef std::vector<LightPoint> LightPointVec;

      struct InstanceTemplate
      {
         PerDofDataVec dofTemplate;

         LightSourceVec lightSources;

         LightPointVec lightPoints;

         InstancedSwitchVec switchTemplate;

         InstancedSequenceVec sequenceTemplate;

         ArrayRange drawableRange;

         ArrayRange lodRange;

         float boundingRadius;

         osg::Vec3f boundingCenter;

         unsigned int nodeMask;

         osg::ref_ptr<osg::Geode> modelGeode;

         bool daylightControlledLights;
      };


      boost::signal<void(const std::string&)> signal_modelTypeRegistered;

      boost::signal<void(const std::string&, DtUniqueID, DtElementID, osg::Node *)>  signal_instanceCreated;

      boost::signal<void(const CullSet&)> signal_updateFinished;

      bool intersect(const osg::Vec3d& start, const osg::Vec3d& end,
         const osg::Vec3d& reference, DtOsgIntersectorResult& result,
         std::list<DtUniqueID>* ignoreList = 0);

      bool intersect(const osg::Vec3d& start, const osg::Vec3d& end,
         std::vector<DtOsgIntersectorResult>& results,
         std::list<DtUniqueID>* ignoreList = 0);

      void setSequenceMode(const DtInstanceState& instance, unsigned int sequenceIndex, InstancedSequence::SequenceMode mode);

      void setSequenceSpeed(const DtInstanceState& instance, unsigned int sequenceIndex, float speed);

      void setSequencePlayTime(const DtInstanceState& instance, unsigned int sequenceIndex, float loopTime);

      InstanceMatrix dofState(const DtInstanceState& instanceState, unsigned int partIndex);

      void setDofState(InstanceMatrix& m, const DtInstanceState& state, unsigned int partIndex);

      void setDofAnimation(osg::Vec3f& hpr, const osg::Vec3f& hprVel, const DtInstanceState& state, unsigned int partIndex);

      void setDofTranslation(osg::Vec3f& trans, osg::Vec3f& transVel, const DtInstanceState& state, unsigned int partIndex);

      void setSwitchState(const DtInstanceState& instance, unsigned int partIndex, unsigned int childIndex, bool state);

      void setUVOffset(DtUniqueID id, unsigned int drawableIx, osg::Vec2f uvOffset);

      void setUserDefined(DtUniqueID id, float userDefined);

      void setLightpointRange(DtUniqueID id, float range);

      void setElementId(DtUniqueID id, DtUniqueID elementId);

      osg::StateSet* getModelTypeRootStateSet(const std::string &modelType);

      static DtInstanceManager& instance(DtDe& de);

      DtInstanceManager(DtDe& de);

      virtual ~DtInstanceManager();

      virtual void reset();

      virtual osg::Node* instanceRoot();

      bool isRegistered(const std::string& modelType);

      void registerModel(const std::string& modelType, GeometryVec& drawables, LodVec& lods,
         SwitchVec& switches, SequenceVec& sequences, PerDofDataVec& perDofData,
         LightSourceVec& lightSources, LightPointVec &lightPointNodes, float boundingRadius, const DtVector& boundingCenter,
         unsigned int nodeMask, osg::ref_ptr<osg::StateSet> rootNodeSS, bool daylightControlledLights = false);

      osg::Geode *setupModelGeode(const std::string& modelType, unsigned int nodeMask);

      void allocateImage(const osg::View* view);

      void freeInstance(DtUniqueID id);

      bool newInstance(const std::string& modelType, DtUniqueID id, DtElementID elementId, osg::Node* rootNode, const std::string &lightPointGroup, bool isSimpleModel);

      DtInstanceState* findInstanceState(DtUniqueID id);

      InstanceCullData* findInstanceCullData(DtUniqueID id);

      void setPosition(DtUniqueID uniqueID, const DtVector& vPosition);
      void setOrientation(DtUniqueID uniqueID, const DtTaitBryan& orientation);

      void setPosition(DtUniqueID uniqueID, const osg::Vec3d& vPosition);
      void setOrientation(DtUniqueID uniqueID, const osg::Quat& orientation);

      void setVisible(DtUniqueID uniqueID, bool bVisible);

      void setBlendColor(DtUniqueID uniqueID, float r, float g, float b, float a);

      void setModelScaling(DtUniqueID uniqueID, bool bModelScaling, float scale);

      void setCullParameters(DtUniqueID uniqueID, short modelSet, unsigned int nodeMask, bool visible);

      typedef std::vector<DtInstanceState> InstanceStateVec;
      typedef std::vector<InstancedLod> InstancedLodVec;
      typedef std::vector<InstancedDof> InstancedDofVec;
      typedef std::vector<InstanceCullData> InstanceCullDataVec;
      typedef std::vector<InstanceMatrix> InstanceMatrixVec;
      typedef std::vector<float> InstanceScaleVec;
      typedef std::vector<DtElementID> InstanceElementIdVec;
      typedef std::vector<InstancedLight> InstancedLightVec;

      inline InstanceElementIdVec& elementIds() { return myElementIds; }

      inline InstanceScaleVec& instanceScales() { return myInstanceScales; }

      inline ByteVec& instanceVisibleSet() { return myInstanceVisibleSet; }

      inline InstanceMatrixVec& drawableInstanceMatrix() { return myDrawableInstanceMatrix; }

      inline InstanceCullDataVec& instanceCullData() { return myInstanceCullData; }

      inline InstanceStateVec& instances() { return myInstances; }

      inline TextureCoordinateVec& uvOffsets() { return myUVOffsets; }

      inline InstancedLodVec& instancedLods() { return myInstancedLods; }

      inline InstancedSwitchVec& instancedSwitches() { return myInstancedSwitches; }

      inline InstancedSequenceVec& instancedSequences() { return myInstancedSequences; }

      inline InstancedDofVec& instancedDofs() { return myInstancedDofs; }

      typedef std::vector<InstanceTemplate> InstanceTemplateVec;

      inline InstanceTemplateVec& instanceTemplates() { return myInstanceTemplates; }

      inline std::vector<float>& distanceToEye() { return myDistanceToEye; }

      inline DofAnimations& dofAnimations() { return myDofAnimations; }

      inline double& lastUpdateTime() { return myLastUpdateTime; }

      inline const DtOsgCullVisitorParameters* lastCullParameters() { return myLastCullParameters.get(); }

      inline unsigned int visibleSetStride() { return myVisibleSetStride; }

      inline BoolVec& visibleSet() { return myVisibleSet; }

      inline osg::Vec3d& cameraPosition() { return myCameraPosition; }

      inline const osg::View* lastView() { return myLastView; }

      inline const osg::Camera* lastCamera() { return myLastCamera; }

      inline unsigned int drawableIndex(unsigned int instanceIx);

      void reloadShaders();

      inline GeometryVec &drawables(){ return myDrawables; }

#if DT_INSTANCE_MANAGER_FILLRENDERLIST_IS_PARALLEL
      inline unsigned int visibleCount() const { return myVisibleCount.get(); }

#else
      inline unsigned int visibleCount() const { return myVisibleCount; }
#endif

      inline unsigned int dynamicBufferDataSize() const { return myDynamicBufferDataSz; }

      virtual bool isDaylight();

      virtual void traverse(osg::NodeVisitor& nv);

      virtual void updateForIntersection(double simTime, const osg::View *view, osg::Camera *camera, unsigned int nodeMask, DtOsgCullVisitorParameters *params);
      
      virtual void updateForDrawing(osgUtil::CullVisitor *cv, const DtOsgCullVisitorParameters* params);
      
      virtual float lightpointRange(unsigned int instanceIx);

      virtual void setDefaultLightPointMaxDistance( float distance );

      virtual float defaultLightPointMaxDistance() const;

      virtual void setLightPointFadeBias( float bias );

      virtual bool cullDistanceEnabled();

      virtual float cullDistance();

      virtual std::string modelDefinitionNameProxy(const std::string& modelDefName);

      DtVirtualBaseClass* findCachedData(const std::string& modelType, const std::string& name);

      void setCachedData(const std::string& modelType, const std::string& name, DtVirtualBaseClass* data);

      void clearCachedData();

      void releaseGLObjects(void);

   protected:
      BoolVec myVisibleSet;

      ByteVec myInstanceVisibleSet;

      TextureCoordinateVec myUVOffsets;

      InstanceMatrixVec myDrawableInstanceMatrix;

      InstanceCullDataVec myInstanceCullData;

      InstanceScaleVec myInstanceScales;

      InstanceElementIdVec myElementIds;

      FloatVec myInstanceUserDefined;

      FloatVec myInstanceLightpointRange;

      InstanceStateVec myInstances;
      InstancedLodVec myInstancedLods;
      InstancedSwitchVec myInstancedSwitches;
      InstancedSequenceVec myInstancedSequences;
      InstancedDofVec myInstancedDofs;
      InstancedLightVec myInstancedLights;
      LightPointVec myInstancedLightPoints;

      InstanceTemplateVec myInstanceTemplates;

      std::vector<float> myDistanceToEye;

      DofAnimations myDofAnimations;

      double myLastUpdateTime;

      unsigned int myLastNodeMask;

      unsigned int myVisibleSetStride;

      osg::Vec3d myCameraPosition;

      const osg::View* myLastView;

      const osg::Camera* myLastCamera;

      CullSet myCullSet;

      typedef boost::unordered_map<std::string, DtVirtualBaseClass*> CacheMap;
      CacheMap myRuntimeCache;

   protected:

      friend class DtInstanceNode;

      struct Eyepoint
      {
         osg::Vec3d center;
         osg::Vec3d eye;
         osg::Vec3d up;
      };

      struct Frustum
      {
         double l, r, b, t, n, f;
      };

      struct InstancingHit
      {
         unsigned int instanceIx;
         unsigned int drawableIx;
         osg::Vec3f pos;
         osgUtil::LineSegmentIntersector::Intersection result;
      };

   protected:
      friend class DtInstanceManagerTBOUpdater;

      void update(double simTime, const osg::View *view, osg::Camera *camera,
         unsigned int nodeMask, osgUtil::CullVisitor *cv,
         const DtOsgCullVisitorParameters* params, bool suppressLastUpdateTime);

      void registerGeometry(unsigned int templateIx, osg::Geometry* geometry, VpMap& vpMap);

      float computeDistanceToEye(const Eyepoint& eye, const osg::Vec3d& pos) const;

      void updateDistancesToEye(const Eyepoint& eye);

      void _updateDistancesToEye(const Eyepoint& eye, unsigned int instanceOffset, unsigned int numInstances);

      void allocateRenderList();

      unsigned int updateDataAndDrawables(const osg::View* view, const ArrayRange& drawableRange,
         unsigned int bufferOffset, osg::Vec4* bufferStorage);

      unsigned int updateRenderList(const Eyepoint& eye, const osg::Matrixd& viewMat, unsigned int nodeMask);

      void updateLights(const osg::View* view);
      void resizeBuffersIfNecessary(const osg::View* view, int visibleCount);
      void resizeTBOIfNecessary(const osg::View* view, int visibleCount);
      void updateBuffers(const osg::View* view);

      void updateLightPoints(const osg::Camera *camera, const osg::FrameStamp *frameStamp, osgUtil::CullVisitor *cv, const osg::Camera *sceneCamera = NULL);

      void allocateInstanceData();

      unsigned int fillRenderList(unsigned visibleSetStride, unsigned int instanceOffset, unsigned int numInstances);

      void cullRange(const Eyepoint& eye
         , const std::vector<osg::Vec4d>& planes, bool useScale, unsigned int nodeMask
         , unsigned int instanceOffset, unsigned int instanceCount);

      void slot_channelAdded(DtChannelManager* mgr, DtChannel* channel);

      void slot_channelRemoved(DtChannelManager* mgr, DtChannel* channel);

      void createHitList(const osg::Vec3d& end, const osg::Vec3d& start, std::vector<InstancingHit>& hitList);

      void loadInstanceShaders(osg::ref_ptr<osgEarth::VirtualProgram> vp);

      bool isOnExcludeList(DtUniqueID elementId,
         const std::list<DtUniqueID>& ignoreList);

   protected:

      bool myIsDaylight;
      osg::Vec4* myDynamicBufferData;
      unsigned int myDynamicBufferDataSz;
      unsigned int myCurrentDynamicBufferDataSize;

      struct RenderState
      {
         InstanceMatrix l2w;
         float scale;
         float userDefined;
         osg::Vec2f uvOffset;
         osg::Vec3f filterColor;
         float lightpointRange;
      };

      typedef std::vector<RenderState> RenderStateVec;

      struct GeometryRenderList
      {
#if DT_INSTANCE_MANAGER_FILLRENDERLIST_IS_PARALLEL
         DtAtomicScalar<unsigned int> count;
         unsigned int getcount() const
         {
            return count.get();
         }
#else
         unsigned  count;
         unsigned  getcount()
         {
            return count;
         }
#endif

         RenderStateVec states;
      };

      typedef std::vector<GeometryRenderList> RenderList;

      RenderList myRenderList;

      bool myRenderListDirty;

      typedef boost::unordered_map<DtUniqueID, unsigned int> InstanceStateMap;


      InstanceStateMap myIdToInstances;

      struct InstanceBuffer
      {
         const osg::View* view;

         DtGlTextureBufferObject* image;
      };

      typedef std::vector<InstanceBuffer> InstanceBufferVec;

      InstanceBufferVec myInstanceBuffers;

      typedef boost::unordered_map<std::string, int> modelTypeToTemplateMap;

      modelTypeToTemplateMap myModelTypeToTemplate;

      DtDe& myDe;

      GeometryVec myDrawables;

      unsigned int myRequiredUvOffsets;

      unsigned int myNumThreads;

      typedef boost::unordered_map<unsigned int, unsigned int> PerTemplateCount;

      PerTemplateCount myTemplateMaxInstances;

      PerTemplateCount myTemplateActiveInstances;

      VpMap myVpMap;
      VpRefList myVpRefs;

      class DT_DLL_VRVOSG AlwaysCull : public osg::Drawable::CullCallback
      {
         virtual bool cull(osg::NodeVisitor* nv, osg::Drawable* drawable, osg::RenderInfo* renderInfo) const
         {
            return true;
         }
      };

      osg::ref_ptr<AlwaysCull> myAlwaysCullCallback;

      osg::ref_ptr<DtInstanceNode> myInstanceRoot;

      typedef std::vector<DtInstanceProcessor*> InstanceProcessorVec;

      InstanceProcessorVec myPostCullInstanceProcessors;

      InstanceProcessorVec myPreCullInstanceProcessors;

      typedef std::vector<osg::View*> ViewVec;
      ViewVec myKnownViews;

      typedef boost::unordered_map<const osg::View*, osg::ref_ptr<DtViewSpecificGroup> > ViewToGroup;
      ViewToGroup myViewToGroup;

      typedef boost::unordered_map<osg::Geometry*, osg::ref_ptr<DtPerViewUniformCallback> > GeometryToCallback;
      GeometryToCallback myGeometryToCallback;

      osg::ref_ptr<const DtOsgCullVisitorParameters> myLastCullParameters;
      DtInstanceLpProcessor* myLpProcessor;
      float myDefaultLightPointRange;
      float myLightPointFadeBias;

      void addInstanceRootToSceneGraphIfNecessary(void);

      void processNewInstanceLights(const InstanceTemplate& instanceTemplate);
      void processNewInstanceDOFs(const InstanceTemplate& instanceTemplate);
      void processNewInstanceSwitches(const InstanceTemplate& instanceTemplate, bool isSimpleModel);
      void processNewInstanceSequences(const InstanceTemplate& instanceTemplate);
      
      void processNewInstanceLightPoints(const InstanceTemplate& instanceTemplate, const std::string &lightPointGroup);

      void preCull(unsigned int maxChunkSize);
      void frustumCull(const osg::View* view, const Eyepoint& eye, unsigned int nodeMask);
      void postCull(unsigned int maxChunkSize);

      std::vector<osg::Vec4d> vecScratchPadPlanes;

      void _fillRenderList(bool globalScaling, unsigned int instanceOffset, unsigned int numInstances);

#if DT_INSTANCE_MANAGER_FILLRENDERLIST_IS_PARALLEL
      DtAtomicScalar<int> myVisibleCount;
#else
      unsigned int myVisibleCount;
#endif
      class DtInstanceManagerTBOUpdater * myDrawCallUpdater;
      int myNeedsMainThreadTextureUpdate;

      std::string myInstanceVS, myInstanceViewVS, myInstanceFS;

   };

   class DT_DLL_VRVOSG DtInstanceManagerCreator : public DtVirtualBaseClass
   {
   public:
      virtual ~DtInstanceManagerCreator();

      static DtInstanceManagerCreator& instance(DtDe& de);

      virtual DtInstanceManager* create();

   protected:
      DtInstanceManagerCreator(DtDe& de);

   protected:
      DtDe& myDe;
   };
}