DtLightPointDrawable.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/DtGlDeleteObjectManager.h>

#include <vrvCore/DtDe.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <osg/Drawable>
#include <osg/Vec3>
#include <osg/Vec4>
#include <osg/Depth>
#include <osg/BlendFunc>
#include <osg/BlendEquation>
#include <osg/ColorMask>
#include <osg/Point>
#include <osg/Endian>
#include <osg/Texture>
#include <osg/PointSprite>
#include <osgSim/Export>

#include <vector>

namespace makVrv 
{

   class DtOsgLightPointManager;
   class DtGlBuffer;
   
   class DT_DLL_VRVOSG DtLightPointDrawable : public osg::Drawable
   {
   public:
      
      struct LightPointVertexAttrib
      {
         int myType;
         int myGroup;
         int myNode;
         float myPhase;
         osg::Matrix3 mySectorLocalToLp;
         osg::Vec3 myPos;
         LightPointVertexAttrib() :
            myType(-1),
            myGroup(-1),
            myNode(-1),
            mySectorLocalToLp(),
            myPhase(0.0),
            myPos(0, 0, 0)
         {
         }

         LightPointVertexAttrib(int type, int groupId, int nodeId, const osg::Matrix3 &sectorLocalToLp, float phase, const osg::Vec3& pos) :
            myType(type),
            myGroup(groupId),
            myNode(nodeId),
            mySectorLocalToLp(sectorLocalToLp),
            myPhase(phase),
            myPos(pos)
         {
         }
      };

   public:

      DtLightPointDrawable(DtDe &de);

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

   protected:
      virtual ~DtLightPointDrawable();

   public:
      virtual osg::Object* clone(const osg::CopyOp& copyop) const
      {
         return new DtLightPointDrawable(*this, copyop);
      }
      virtual osg::Object* cloneType() const
      {
         return NULL;
      }
      virtual bool isSameKindAs(const osg::Object* obj) const
      {
         return dynamic_cast<const DtLightPointDrawable *>(obj) != NULL;
      }
      virtual const char* className() const
      {
         return "DtLightPointDrawable";
      }
      virtual const char* libraryName() const
      {
         return "vrvOsg";
      }
      virtual void accept(osg::NodeVisitor& nv)
      {
         if (nv.validNodeMask(*this))
         {
            nv.pushOntoNodePath(this);
            nv.apply(*this);
            nv.popFromNodePath();
         }
      }

   public:

      virtual void releaseGLObjects(osg::State* state) const;

      virtual void accept(osg::PrimitiveFunctor &functor) const;

      virtual GLuint64 getTextureAddress(osg::Texture* myLightPointTexture);

      virtual void setLightPointManager(DtOsgLightPointManager *lpManager);

      virtual DtOsgLightPointManager *findLightPointManger();

      virtual void addLightPoint(const LightPointVertexAttrib& attribData);

      virtual void removeLightPoints(const std::vector<int>& nodeIds);


      virtual void drawImplementation(osg::RenderInfo& renderInfo) const;
      virtual void setSimulationTime(double time);

      virtual double simulationTime() const;

      virtual osg::BoundingBox computeBoundingBox() const;

   protected:

      virtual void init();

      virtual void setUpReverseZ(bool flag);

      virtual void processTextureAddresses(osg::RenderInfo &renderInfo) const;

      // When we make a texture resident, add it to our map to make is non-resident
      // when we releaseGLObjects
      virtual void addTextureToGCMap(osg::GraphicsContext* gContext, osg::Texture::TextureObject* texObj) const;

      // Check if we have already added a texture id to our list of textures id index by graphics context
      // if we have added already then return true
      virtual bool inTextureToGCMap(osg::GraphicsContext* gContext, osg::Texture::TextureObject* texObj) const;

   protected:
   
      double                          mySimulationTime;

      typedef std::vector<LightPointVertexAttrib>  LightPointList;
      LightPointList             myLightPointList;
      
      osg::ref_ptr<osg::Depth>        myDepthOn;
      osg::ref_ptr<osg::BlendFunc>    myBlendFunc;
      osg::ref_ptr<osg::BlendEquation>    myBlendEquation;

      DtOsgLightPointManager *myLightPointManager;

      //Texture for rendering the debug labels. Contains all 10 digits so that any number can be 
      // shown using the debug labels. The debug labels show the light point type for now.
      osg::ref_ptr<osg::Texture> myDigitTexture;

      DtDe &myDe;

      osg::ref_ptr<osg::Uniform> myTimeUniform;

      DtSignalConnectionManager mySignals;
      mutable int myMutableLightPointListMinChanged;
      mutable int myMutableLightPointListMaxChanged;

      bool myInitialized;

      osg::ref_ptr<osg::PointSprite>        mySprite;
      
      //These need to be mutable so they can be upded in draw implementation.
      typedef std::map< osg::ref_ptr<osg::Texture>, GLuint64> TextureToAddressMap;
      mutable TextureToAddressMap myMutableTextureToAddress;

      typedef std::set< osg::ref_ptr<osg::Texture> > TextureSet;
      mutable TextureSet myMutableTexturesToGetAddressesFor;

      // For keeping texture id's per context
      typedef std::set<osg::ref_ptr<osg::Texture::TextureObject> > SetOsgTextureObjects;
      typedef std::map<osg::observer_ptr<const osg::GraphicsContext>, SetOsgTextureObjects> MapGraphicsContextsToSetOsgTextureObjects;
      mutable MapGraphicsContextsToSetOsgTextureObjects myMapGraphicsContextToTexturesArray;

      DtGlDeleteObjectManager& myGlDeleteObjectManager;
   };

   class DT_DLL_VRVOSG DtLightPointDrawableCreator : public DtVirtualBaseClass
   {
   public:
      DtLightPointDrawableCreator(DtDe &de);

      virtual ~DtLightPointDrawableCreator();

      virtual DtLightPointDrawable* create() const;

      static DtLightPointDrawableCreator& instance(DtDe& de);

      static const std::string& theClassName();
   protected:

      DtDe& myDe;
   };


}