DtOsgLightPointManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/DtLightPointManager.h>

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

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

#include <vrvIndirectRendering/DtGpuCullingAndLodDefines.h>

#include <osgSim/LightPointNode>

#include <boost/thread.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;
   };

   class DT_DLL_VRVOSG DtOsgLightPointManager : public DtLightPointManager
   {
   public:

      DtOsgLightPointManager(DtDe& de);

      static DtOsgLightPointManager& instanceAsDtOsgLightPointManager(DtDe& de);


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

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

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

      virtual DtGlBuffer *lightPointTypeBuffer();

      virtual DtGlBuffer *lightPointGroupBuffer();

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

      virtual DtGlBuffer *lightPointVertexBufer(const std::vector<DtLightPointDrawable::LightPointVertexAttrib>& vertexAttribData, int minChanged, int maxChanged);

      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();
      
      virtual bool debugDirectionEnabled();

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

   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;

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