DtOsgLightManager.h

Go to the documentation of this file.

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


#pragma once

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


#include <vrvOsg/DtOsgShaderManager.h>

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

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

class DtVector;

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

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

   typedef std::vector<DtLight> VectorLightObjects;

   class DT_DLL_VRVOSG DtOsgLightManager : public DtVirtualBaseClass
   {
   public:
      static DtOsgLightManager& instance(DtDe& de);

      virtual ~DtOsgLightManager();

      static std::string theClassName();

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

      void attachToStateSet(osg::StateSet* stateSet);

      void setPerPixelLightingEnabled(bool enabled);

      bool getPerPixelLightingEnabled() const;

      DtLightManager& lightManager();

      void setReservedID(int id);

      int reservedID() const;

      void cullReset();

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

      void deregisterLight(const osg::LightSource* light);

      // PPP: TO DO. How to deregister ligths?

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

      void deactivateLights();

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

      void releaseGLObjects(void);

   protected:
      DtOsgLightManager( DtDe& de );

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

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

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

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

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

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

   protected:
      void configurePerPixelLighting(osg::StateSet*);
     void setComponentVisualizationMode(int mode);

     void slot_reloadShader();

   protected:

      DtSignalConnectionManager mySignals;

      int myReservedID;
      DtDe& myDe;
      bool myPerPixelLightingEnabled;

      osg::ref_ptr<DtOsgLightingComponent> myLightingComponent;
      osg::ref_ptr<osg::Uniform> myComponentDebugUniform;
      bool myLightingComponentInstalled;
      osg::observer_ptr<osg::StateSet> myStateSet;
      VectorLights myActiveLights;

   private:
      DtOsgLightManager();



      DtLightManager* myLightManager;

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

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

      DtOsgLightsObserver* myOsgLightsObserver;

      bool existsInLightManager(const DtLight* light) const;
   };
}