DtOsgLightPointManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtLightPointManager.h>

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtLightPointDrawable.h>
#include <vrvOsg/DtLightPointNodeAndXform.h>

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

#include <vrvIndirectRendering/DtIndirectViewParameters.h>
#include <vrvIndirectRendering/DtIndirectFadeParameters.h>

#include <osgSim/LightPointNode>

#include <boost/thread.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include <boost/thread/shared_mutex.hpp>

#include <string>

namespace osgEarth
{
   class GeoPoint;
   class MapNode;
}

namespace makVrv
{
   class DtDe;

   class DtGlBuffer;

   class DtLightPointNode;
   class DtLightPointDrawable;


   typedef osg::observer_ptr<osg::Node> LightPointNodeObs;
   typedef osg::ref_ptr<osg::Node> LightPointNodeRef;
   typedef std::set<LightPointNodeObs> LightPointNodeObsSet;

   struct DtLightPointTextureLayout
   {
      float color[4];
      float intensity[4];
      float sectors[4];
      float pixelSize[4];
      float resIntensityDaylight2Unused[4];
   };

   //Needs to match LightPointNodeInfo in the shader
   struct DtLightPointNodeDataLayout
   {
      osg::Matrixf modelView;
      osg::Vec4f eyeLocal;
      int groupId;
      float posScale;
      float radiusScale;
      float isInstancedReflection;
      GLuint64 textureId;
      float fadeParametersMinRange;
      float fadeParametersAttenuationDistance;
   };

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

   typedef std::vector<LightPoint> LightPointVec;

   class DT_DLL_VRVOSG DtOsgLightPointManager : public DtLightPointManager
   {
   public:

      DtOsgLightPointManager(DtDe& de);

      static DtOsgLightPointManager& instanceAsDtOsgLightPointManager(DtDe& de);

   private:
      DtOsgLightPointManager() = delete;

      DtOsgLightPointManager(const DtOsgLightPointManager& other) = delete;
      DtOsgLightPointManager& operator=(const DtOsgLightPointManager& other) = delete;

   public:
      virtual void registerInstancedLightPoints(LightPointVec &lightPoints, bool daylightControlled);

      virtual void findAndRegisterLightPoints(osg::Node* node, const std::string& groupName, bool daylightControlled, const DtIndirectFadeParameters& fadeParameters, bool combineLightPoints);

      virtual void registerLightPoints(const DtLightPointNodeAndXformVector& lightPoints, 
         const std::string& groupName, bool daylightControlled, 
         const DtIndirectFadeParameters& fadeParameters, bool combineLightPoints);

      virtual LightPointNodeObsSet aggregateLightPoints(const DtLightPointNodeAndXformVector& lightPoints, 
                                                        const std::string& groupName, bool daylightControlled, 
                                                        const DtIndirectFadeParameters& fadeParameters, bool combineLightPoints);

      virtual DtLightPointNode *createLightPointNode(osg::Node *nodeRef, bool daylightControlled);

      virtual DtGlBuffer *lightPointTypeBuffer();

      virtual DtGlBuffer *lightPointGroupBuffer();

      virtual DtGlBuffer *lightPointNodeBuffer(osg::Camera* camera);

      // !\brief updates the ssbo for the light point vertex data. This contains the light point
      virtual void updateLightPointVertexBuffer(const std::vector<DtLightPointDrawable::LightPointVertexAttrib>& vertexAttribData, int minChanged, int maxChanged);

      virtual DtGlBuffer *lightPointVertexBufer();

      virtual int nodeId(DtLightPointNode *lpNode, int instanceId);

      virtual void slot_preTick();

      virtual void clearNodeBuffer(const osg::Camera* camera);

      unsigned int nodeBufferMaxNodeId(const osg::Camera *camera);

      virtual void setNodeBufferData(int nodeId, const osg::Camera *camera, const DtLightPointNodeDataLayout& nodeData);

      virtual void processImGui();

      virtual DtLightPointDrawable *masterLightPointDrawable();

      virtual bool debugLabelsEnabled() const;
      
      virtual bool debugDirectionEnabled() const;

      virtual bool softerLightPointsEnabled();

      virtual float softenIntensity();

      virtual void setShouldReplaceOsgSimLightPoints(bool enable);
      
      virtual bool shouldReplaceOsgSimLightPoints();

      virtual void freeNodeIds(std::vector<int> &nodeIds);

      virtual void releaseGLObjects(osg::State * state) const;

      virtual void setInstanceReflectionMatrix(const osg::Camera *camera, const osg::Matrixf &reflectMat);

      virtual const osg::Matrixf &instanceReflectionMatrix(const osg::Camera *camera);

      virtual bool drawLightPoints();
      
      boost::signalslib::signal<void(LightPointNodeObsSet&)> signal_lightPointsRegistered;

   protected:

      virtual ~DtOsgLightPointManager();

      virtual void slot_reloadShaders();

      virtual void setupShaders();

      int parseNodeGroupId(osg::Node *lightPointNode);

      std::string parseNodeGroupName(osg::Node *node);

      virtual void populateLightPointNode(osg::Node *nodeRef, DtLightPointNode *dtLpRef, bool daylightControlled, bool newNode);

      static void cleanupNodes(osg::Node* node);

   protected:

      DtGlBuffer *myLightPointTypeBuffer;
      DtGlBuffer *myLightPointGroupBuffer;

      typedef std::map<const osg::Camera*, std::vector<float> > CameraVectorMap;
      CameraVectorMap myLightPointNodeDataMap;
      DtGlBuffer *myLightPointNodeBuffer;
      DtGlBuffer *myLightPointVertexBuffer;


      typedef std::pair<DtLightPointNode*, int> nodeIntPair;
      typedef std::map<nodeIntPair, int> NodeIdMap;
      NodeIdMap myNodeIds;
      std::set<int> myFreeNodeIds;

      boost::mutex myMutex;
      boost::mutex myNodeIdMutex;
      boost::recursive_mutex myNodeBufferMutex;
      boost::shared_mutex myLightsTableMutex;

      osg::ref_ptr<DtLightPointDrawable> myMasterLightPointDrawable;
   
      bool myDebugLabelsEnabled;
      bool myDebugDirectionEnabled;
      bool myShouldReplaceOsgSimLightPoints;
      bool mySofterLightPointsEnabled;
      float mySoftenIntensity;
      bool myDrawLightPoints;

      GroupIdMap myImGuiProcessedGroupIds;

      typedef std::map<std::string, GroupIdMap> ParentGroupIdMap;
      ParentGroupIdMap myImGuiGroups;

      std::map<const osg::Camera*, osg::Matrixf> myInstanceReflectionMatrix;

      LightPointNodeObsSet myLightPointNodes;

      DtDe& myDtDe;
   };

} // namespace makVrv