DtOsgLightManager.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvGraphicsUtils/DtLight.h>


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

#include <matrix/vlVector.h>

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

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

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

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


   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 void cullReset();

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

      virtual DtLight* createDtLight(const osg::Light* osgLight);

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

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

      // PPP: TO DO. How to deregister ligths?
      virtual void deregisterLight(const osg::LightSource* light);

      virtual void getWorldPositionAndDirection(const osg::LightSource& lightSource, const osg::Matrixd& modelingMatrix, osg::Vec3d& vWorldPos, osg::Vec3d& vWorldDir) const;
      
      virtual void update(osg::State& state, DtDe& de, const osg::Camera* camera);

      virtual int getTextureStartOffset(void) const;

      virtual const Vector2_uint32& tileSize(void) const;

      virtual const Vector2_uint32& gridMaxDims(void) const;

      virtual void releaseGLObjects(void);

      virtual unsigned int getOrCreateLightSourceTypeId(DtLight* pDtLight);
      
      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();

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

   protected:
      virtual void updateLightOnOffStatus(const VectorLights& lights);

      virtual bool computeLightStatusForTime(const DtLight* pDtLight, DtOsgSkyObject* skyObject);

      virtual void updateFixedFunctionLights(const osg::State& state);

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

      virtual const VectorLights& computeFrustumLights(const osg::State &state, const osg::Camera* camera);

      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;

   protected:

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

      bool myPerPixelLightingEnabled;

      osg::ref_ptr<DtOsgLightingComponent> myLightingComponent;


      osg::observer_ptr<osg::StateSet> myStateSet;
      VectorLights myActiveLights;

      DtLightManager* myLightManager;

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

      typedef std::unordered_map<size_t, LightSourceAndLight> MapLightSourceHashToLights;
      MapLightSourceHashToLights myMapLightSourceHashToLights;

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