DtGroundFogPatch.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/vrvOsg.h>

#include <vrvCore/DtJobSplitter.h>

#include <vrvUtil/DtVirtualBaseClass.h>

#include <osg/RenderInfo>
#include <osg/Vec3d>


namespace makVrv
{

   class DT_DLL_VRVOSG DtGroundFogPatch
   {
   public:

      DtGroundFogPatch();

      virtual ~DtGroundFogPatch();

   private:

      DtGroundFogPatch(const DtGroundFogPatch &other);

      DtGroundFogPatch &operator=(const DtGroundFogPatch &other);

   public:

      virtual void init(int gridSize, float patchSize);

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

      virtual void updateAlphaFade(double time);

      virtual void cullUpdate(const osg::Vec3d& camPos, DtJobSplitter* jobSplitter);

      virtual void setTransform(const osg::Vec3d& position);

      virtual const osg::Vec3d& position() const;

      virtual const float* skeleton() const;

      virtual void getBonePosition(int boneIndex, float patchSize, osg::Vec3d& position);

      virtual void setBoneHeight(int boneIndex, float height);

      virtual void setDesiredAlphaFade(float value);

      virtual void setAlphaFade(float value);

      virtual float alphaFade() const;

      virtual void SetCulled(bool culled);

      virtual bool culled() const;

      virtual void setBoneHeightExtents(float min, float max);

      virtual void getBoneHeightExtents(float& min, float& max);

      virtual void computeBoneHeightExtents();

      virtual void runSort(const osg::Vec3& localCamPos);

   protected:

      virtual void computeSortDepth(const osg::Vec3& camPos);

      virtual void fillSortedIndices();

   private:

      void freeData(void);

      static int theSortBackToFront(const void* arg0, const void* arg1);

      static void theSortJob(void* data);

   public:

      int mySortDepth; // keep public for optimized sorting

   protected:
      
      struct Cell
      {
         Cell()
            : mySortDepth(0)
            , myVertexStart(0)
            , myCenter(0,0,0)
         {
            //intentional nop
         }

         int mySortDepth;
         unsigned short myVertexStart;
         osg::Vec3 myCenter;
      };

      struct SortJobData
      {
         SortJobData()
            : myPatch(0)
            , myCameraPos(0,0,0)
         {
            //intentional nop
         }

         DtGroundFogPatch* myPatch;
         osg::Vec3 myCameraPos;
      };

      unsigned short myIndiceCount;
      unsigned short* myIndices;

      Cell* myCells;
      int myCellCount;

      osg::Vec3d myPosition;
      double myLastTime;
      float myAlphaFade;
      float myAlphaFadeDesired;
      bool myCulled;
      float myBoneHeightMin;
      float myBoneHeightMax;

      float mySkeleton[9]; // a 3x3 skeletal grid used to bend the mesh

      SortJobData mySortJobData;
      DtJobSplitterJob mySortJob;
   };


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

      virtual ~DtGroundFogPatchCreator();

   private:
      DtGroundFogPatchCreator(const DtGroundFogPatchCreator& other);
      DtGroundFogPatchCreator &operator=(const DtGroundFogPatchCreator& other);

   public:
      virtual DtGroundFogPatch* create(int gridSize, float patchSize) const;

      static DtGroundFogPatchCreator& instance(DtDe& de);

      static const std::string& theClassName();

   protected:
      DtDe& myDe;
   };
}