DtWeatherFogFroxelGrid.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/DtVirtualBaseClass.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;

   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 FroxelGenerationJob : public osg::Operation
      {
      public:
         FroxelGenerationJob(DtWeatherFogFroxelGrid& weatherFogFroxelGrid, DtDe& de);
         
         virtual ~FroxelGenerationJob();

         FroxelGenerationJob() = delete;

         FroxelGenerationJob(const FroxelGenerationJob&) = delete;

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

      protected:

         virtual void operator () (osg::Object* sv);

         virtual void release();

         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 FroxelGenerationJob* createJob();

      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;

      GLuint myVoxelTextureId;
      osg::ref_ptr<osg::Texture3D> myVoxelTexture;
         
      osg::ref_ptr<FroxelGenerationJob> myFroxelGenerationJob;

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

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

      float myMaxGridDistance;
   };

}