DtOsgLightManager.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgLightingComponent.h>
#include <vrvOsg/DtOsgLightManagerTcsUserData.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <vrvGraphicsUtils/DtLight.h>

#include <matrix/vlVector.h>

#include <vrvMath/DtReusableMemoryVector.h>
#include <vrvGraphicsUtils/DtLight.h>

#include <osg/observer_ptr>
#include <osg/Node>
#include <osg/Light>

#include <boost/thread.hpp>
#include <unordered_map>
#include <mutex>

namespace osg
{
   class Light;
   class LightSource;
   class State;
   class StateSet;
   class Matrixd;
}

namespace makVrv
{
   // Implements GLSL lighting
   class DtOsgLightsObserver;
   class DtLightManager;
   class DtOsgSkyObject;
   class DtThreadCameraStreamDataManager;


   class DT_DLL_VRVOSG DtOsgLightManager : public DtVirtualBaseClass
   {
   public:
    
      //constant bit masks for the light source sensor masks. Used in the compute shader to determine
      // if a channel should apply a light source or not.
      static const int theMwirLightSourceSensorMask = 0b0100;
      static const int theLwirLightSourceSensorMask = 0b1000;
      static const int theIrLightSourceSensorMask = theMwirLightSourceSensorMask | theLwirLightSourceSensorMask;
      static const int theNvgLightSourceSensorMask = 0b0010;
      static const int theVisualLightSourceSensorMask = 0b0001;
      static const int theDefaultLightSourceSensorMask = theNvgLightSourceSensorMask | theVisualLightSourceSensorMask;

   public:
      virtual ~DtOsgLightManager();
      
   protected:
      DtOsgLightManager(DtDe& de);
   
   private:
      DtOsgLightManager() = delete;

      DtOsgLightManager(const DtOsgLightManager& rhs) = delete;

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

   public:

      virtual void initialize();

      virtual void attachToStateSet(osg::StateSet* stateSet);

      virtual void setPerPixelLightingEnabled(bool enabled);

      virtual bool perPixelLightingEnabled() const;

      virtual DtLightManager& lightManager();

      virtual void setReservedID(int id);

      virtual int reservedID() const;

      virtual bool registerLight(const osg::LightSource* light, const osg::NodePath& nodePath, const osg::Matrixd& modelingMatrix, bool globalLights
      , const osg::Camera* osgCamera);

      // De-register light?
      virtual void deregisterLight(const osg::LightSource* light);
      
      virtual void update(const osg::State& state, const osg::Camera* camera);

      virtual void releaseGLObjects(void);
      
      virtual unsigned int getOrCreateLightSourceTypeId(const osg::LightSource& lightSource);
      
      virtual unsigned int getOrCreateDynamicLightSourceTypeId(const DtLight* pDtLight);

      virtual void deleteDynamicLightSourceTypeId(const DtLight* pDtLight);

      virtual LightReusableVector lightSourceTypeLightVector() const;
      
      virtual void updateLightSourceType(unsigned int id, const DtLight* light);
      
      virtual const DtOsgLightingComponent* lightingComponent() const;

      virtual DtOsgLightingComponent* lightingComponent();

   public:
      static DtOsgLightManager& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      virtual bool computeLightStatusForTime(const DtLight* pDtLight, float ambientLightValue) const;

      virtual void updateShaderBasedLights(const osg::State& state, const osg::Camera* camera, DtOsgLightManagerTcsUserData* tcsUserData);

      virtual void computeFrustumLights(const osg::State &state, const osg::Camera* camera, DtOsgLightManagerTcsUserData* tcsUserData) const;

      virtual void computeActiveLights(DtOsgLightManagerTcsUserData* tcsUserData, const osg::Camera* camera) const;

      virtual void proccessLightPath(DtLight* inLight, const osg::NodePath& nodePath);

      virtual void configurePerPixelLighting(osg::StateSet*);

      virtual void slot_reloadShader();

      virtual bool existsInLightManager(const DtLight* light) const;

      virtual void convertOsgLightToDtLight(DtLight* pDtLight, const osg::LightSource& lightSource, const osg::Matrixd& modelingMatrix);

      virtual void getWorldPositionAndDirection(const osg::LightSource& lightSource, const osg::Matrixd& modelingMatrix, osg::Vec3d& vWorldPos, osg::Vec3d& vWorldDir) const;

      virtual unsigned int getOrCreateLightSourceTypeId(const DtLight* pDtLight);

      virtual unsigned int sensorMaskFromLightSource(const osg::LightSource& lightSource) const;

      virtual size_t getNodePathHashValue(const osg::NodePath& nodePath) const;

      virtual void printNodePath(const osg::NodePath& nodePath) const;

      virtual size_t computeHash(const DtLight* pDtLight) const;

      virtual LightType lightType(const osg::Light* light) const;

      virtual unsigned int getOrCreateLightSourceTypeId(const DtLight* pDtLight, size_t hash);

      virtual void slot_preTick(void);
   protected:

      DtDe& myDe;
      bool myInitialized;
      bool myDebugCallbackInitialized;
      int myReservedID;

      bool myPerPixelLightingEnabled;

      osg::ref_ptr<DtOsgLightingComponent> myLightingComponent;

      osg::observer_ptr<osg::StateSet> myStateSet;
      
      DtLightManager* myLightManager;

      typedef std::pair<const osg::LightSource*, const makVrv::DtLight*> LightSourceAndLight;

      typedef std::unordered_map<size_t, LightSourceAndLight> MapLightSourceHashToLights;
      MapLightSourceHashToLights myMapLightSourceHashToLights;
      std::unordered_set<const DtLight*> myLightsCreatedViaRegister;
      mutable std::mutex myRegisterUnRegisterPathMutex;

      DtOsgLightsObserver* myOsgLightsObserver;

      typedef std::map<size_t, unsigned int> MapLightSourceTypeToLightID;
      MapLightSourceTypeToLightID myLightSourceTypeMap;
      LightReusableVector myLightSourceTypeLightVector;

      //Mutable so it can protect const functions
      mutable boost::mutex myMutableLightSourceTypeMutex;

      DtThreadCameraStreamDataManager& myTcsDataManager;
      DtOsgLightManagerTcsUserDataCreator& myUserDataCreator;

      DtSignalConnectionManager myConnections;
   };
}