DtLightPointNode.h

Go to the documentation of this file.

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

#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvOsg/DtLightPointDrawable.h>

#include <vrvIndirectRendering/DtIndirectFadeParameters.h>

#include <boost/thread/recursive_mutex.hpp>

namespace osgUtil
{
   class CullVisitor;
}

namespace makVrv
{
   class DtDe;
   class DtOsgLightPointManager;

   typedef std::vector<osg::Node*> DtNodePointerStack;

   class DT_DLL_VRVOSG DtLightPointNode : public osg::Node
   {
   public:

      DtLightPointNode();

      DtLightPointNode(const DtLightPointNode& lpn, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY);

      virtual ~DtLightPointNode();

      META_Node(vrvOsg, DtLightPointNode);

   private:
      DtLightPointNode& operator=(const DtLightPointNode& other) = delete;

   public:
      virtual void traverse(osg::NodeVisitor& nv);

      virtual void updateDrawable(const osg::Camera* camera, int frameNum, double simTime, const osg::Matrixd &modelViewMatrix,
         osgUtil::CullVisitor* cv, int groupId, bool shouldCull, const DtIndirectFadeParameters& fadeParameters, float posScale, float radiusScale, bool isInstancedReflection = false);

      virtual void updateNodeInfo(bool isInstancedReflection = false, bool isForcedAdd = false);

      virtual int addTypedLightPoint(const osg::Vec3d& pos, int type, const std::string& id,
         const osg::Vec3& rotation, float phaseShift);
      
      virtual void removeTypedLightPoint(int index);

      virtual void setLightPointManager(DtOsgLightPointManager *lightPointManager);

      virtual DtOsgLightPointManager *findLightPointManager();

      virtual void setLightPointsEnabled(bool enabled);

      virtual bool lightPointsEnabled();

      virtual void setGroupId(int id);

      virtual int groupId();

      virtual void freeNodeIdIfNecessary(unsigned int maxNodeIds);

      virtual osg::BoundingSphere computeBound() const;

      virtual void applyMatrixToLightPoints(const osg::Matrix& adjustmentMatrix);

      virtual void applyMatrixToLightPointsIncremental(const osg::Matrix& adjustmentMatrix,
                                                       int firstNodeToChange);

      virtual void setFadeParameters(const DtIndirectFadeParameters& fadeParameters);

      virtual DtIndirectFadeParameters fadeParameters() const;

      // Return number of light points in this node
      virtual int lightPointCount() const;

      // Get the light point position for a particular light point
      virtual osg::Vec3d lightPointPosition(int index) const;
      
      // set the light point position for a particular light point requires setDynamicLightsMode 
      virtual void setLightPointPosition(int index, const osg::Vec3d & pos);

      // Get the light point type
      virtual int lightPointType(int index) const;

      // Get the light point node id
      virtual int lightPointNodeId() const;

      // Get the light point group id
      virtual int lightPointGroupId(int index) const;

      // Get the light point phase
      virtual float lightPointPhase(int index) const;

      // Get the light point sector direction
      virtual osg::Vec3 lightPointSectorDir(int index) const;

      // Get the light point sector transform
      virtual const osg::Matrix3& lightPointSectorLocalToLp(int index) const;

      virtual void setCameraRelativeLightsMode( bool mode = true);
      virtual bool cameraRelativeLightsMode( );

   protected:
      struct LightPointInfo
      {
      public:
      LightPointInfo(int type, std::string group, const osg::Vec3d& pos, const osg::Vec3& sectorDir, 
                     const osg::Matrix3& sectorLocalToLp, float phase)
            : myLightPointType(type)
            , myLightPointGroup(group)
            , myPosition(pos)
            , mySectorLocalToLp(sectorLocalToLp)
            , mySectorDir(sectorDir)
            , myPhaseShift(phase)
            , myActive(true)
         {
            /*intentionally nop*/
         }

         int myLightPointType;
         std::string myLightPointGroup;
         osg::Vec3d myPosition;
         osg::Matrix3 mySectorLocalToLp;
         osg::Vec3 mySectorDir;
         float myPhaseShift;
         bool myActive;
      };

      typedef std::vector< LightPointInfo > LightPointIntList;

      virtual osg::BoundingSphere computeBoundsIncremental(int firstNode) const;

   protected:
      mutable osg::BoundingBox myMutableBoundingBox; // Bounding box for all the points in the node
      mutable osg::Vec3 myMutableFurthestPoint; // Used for incremental bounds calculations.

      LightPointIntList myLightPointTypeList;

      DtOsgLightPointManager *myLightPointManager;

      osg::ref_ptr<DtLightPointDrawable> myLightPointDrawable;

      std::vector<int> myNodeIds;

      const osg::Camera* myLastCamera;
      int myFrameNum;

      int myCurrentInstance;
      int myAddedInstances;

      bool myLightPointsEnabled;

      int myGroupId;

      DtIndirectFadeParameters myFadeParameters;

      float myFirstFrameTime;

      bool myCameraRelativeLightsMode;

      std::vector<int> myFreeList;


   protected:

      mutable boost::recursive_mutex myMutableNodeIdMutex;

      static int theFrameNum;
      static const osg::Camera* theLastCamera;
   };
}