DtOsgLightManager.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvGraphicsUtils/DtLight.h>
#include <boost/unordered_map.hpp>

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

#include <matrix/vlVector.h>

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

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

   typedef std::vector<DtLight> VectorLightObjects;

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

   protected:
      DtOsgLightManager(DtDe& de);

      DtOsgLightManager();

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

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

      virtual void update(const osg::State& state, DtDe& de);

      virtual int getTextureStartOffset(void) const;
      virtual const Vector2_uint32& GetTileSize(void) const;
      virtual const Vector2_uint32& GetGridMaxDims(void) const;

      virtual void releaseGLObjects(void);
   public:
      static DtOsgLightManager& instance(DtDe& de);

      static const std::string& theClassName();

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

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

      virtual bool computeLightStatusForTime(DtDe& de, DtLight* pDtLight, DtOsgSkyObject* skyObject);

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

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

      virtual const VectorLights& computeFrustumLights(const osg::State &state);

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

      virtual void configurePerPixelLighting(osg::StateSet*);

      virtual void setComponentVisualizationMode(int mode);

      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::ref_ptr<osg::Uniform> myComponentDebugUniform;
      bool myLightingComponentInstalled;
      osg::observer_ptr<osg::StateSet> myStateSet;
      VectorLights myActiveLights;

      DtLightManager* myLightManager;

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

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

      DtOsgLightsObserver* myOsgLightsObserver;
   };
}