DtWeatherFogFroxelGrid.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>
#include <vrvOsg/DtOsgRenderer.h>
#include <vrvOsg/DtGpuOperation.h>

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

#include <osg/ref_ptr>
#include <osg/OperationThread>
#include <osg/Matrix>
#include <osg/Vec4>

#include <vector>

namespace osg
{
   class State;
   class Texture3D;
   class Object;
}

namespace makVrv
{
   // Forward declarations.
   class DtGlProgram;
   class DtWeatherFogFroxelGrid;
   class DtIndirectTexturePrototype;
   class DtIndirectGlTextureObject;
   class DtIndirectGlTextureObjectManager;

   typedef DtVirtualBaseClassCreator<DtWeatherFogFroxelGrid> DtWeatherFogFroxelGridCreator;

   template <>
   inline const char* creatorTypeName<DtWeatherFogFroxelGrid>(void) { return "DtWeatherFogFroxelGridCreator"; }

   class DT_DLL_VRVOSG DtWeatherFogFroxelGrid : public DtVirtualBaseClass
   {
   public:

      friend DtWeatherFogFroxelGridCreator;

      // Inner class for generating a 3d texture containing voxel information
      class FroxelGenerationOp : public DtGpuOperation
      {
      public:
         FroxelGenerationOp(DtWeatherFogFroxelGrid& weatherFogFroxelGrid, DtDe& de);
         
         virtual ~FroxelGenerationOp();

         FroxelGenerationOp() = delete;

         FroxelGenerationOp(const FroxelGenerationOp&) = delete;

         FroxelGenerationOp &operator=(const FroxelGenerationOp&) = delete;
      public:
         virtual void execute(void) override;
      protected:
         virtual DtGlProgram* genComputeProg();

      protected:

         DtDe& myDe;
         DtWeatherFogFroxelGrid& myWeatherFogFroxelGrid;

         DtGlProgram* myComputeProgram;
         int myOutputTextureUniformLoc;
         int myReverseZUniformLoc;
         int myProjMatUniformLoc;
         int myProjInvMatUniformLoc;
         int myViewInvMatUniformLoc;
         int myBoxPosUniformLoc;
         int myBoxRotUniformLoc;
         int myBoxSizeUniformLoc;
         int myCubeDataUniformLoc;
      };

   public:

      virtual ~DtWeatherFogFroxelGrid();

      DtWeatherFogFroxelGrid() = delete;

      DtWeatherFogFroxelGrid(const DtWeatherFogFroxelGrid&) = delete;

      DtWeatherFogFroxelGrid &operator=(const DtWeatherFogFroxelGrid&) = delete;

   protected:

      DtWeatherFogFroxelGrid(DtDe& de);

   public:

      // reload shaders is triggered reloads the shader changes if triggered from
      // reload shaders but the texture is not reloaded off disk due to osgFileCache
      virtual void initialize();

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

      virtual bool bindFogFroxelTexture(const int unit, const unsigned int renderContextId);

      virtual void resetVolumes();

      virtual void addVolume(const osg::Vec3d& position,
         const osg::Matrixf& rotation, const float width, const float length,
         const float height, const float density);

      virtual void updateForView(const osg::Matrixf& projMat, const osg::Matrixd& viewMat);

      virtual float maxGridDistance() const;

   protected:

      virtual FroxelGenerationOp* createOp();

      virtual void slot_reloadShaders();
      
   protected:

      struct Volume
      {
         Volume()
            : position(0,0,0)
            , width(1)
            , length(1)
            , height(1)
            , density(0)
         {
            // intentional noop
         }

         osg::Vec3d position;
         osg::Matrixf rotation;
         float width;
         float length;
         float height;
         float density;
      };

      DtDe& myDe;

      DtOsgRenderer& myOsgRenderer;

      const DtIndirectTexturePrototype* myVoxelTexturePrototype = nullptr;
      DtIndirectGlTextureObject* myVoxelTextureObject = nullptr;

      DtIndirectGlTextureObjectManager& myIndirectGlTextureObjectManager;
         
      FroxelGenerationOp* myFroxelGenerationOp = nullptr;

      osg::Matrixf myProjMat;
      osg::Matrixd myViewMat;

      std::vector<Volume*> myVolumes;
      int myActiveVolumes;

      float myMaxGridDistance;

      DtSignalConnectionManager myConnections;
   };

}