DtIndirectGeometryGrid.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/DtIndirectCellHasher.h>

#include <vrvMath/DtVector3.h>
#include <vrvMath/DtAxisAlignedBoundingBox.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>
#include <vrvCore/DtModelSetEnums.h>

#include <osg/Node>

#include <boost/thread.hpp>
#include <unordered_map>
#include <unordered_set>

#include <tbb/concurrent_hash_map.h>
#include <tbb/concurrent_vector.h>

namespace makVrv
{
   class DtDe;
   class DtIndirectEntityGeometry;
   class DtIndirectModelsContainer;
   class DtIndirectGeometryRenderer;

   class DtIndirectGeometryGrid;

   class DtIndirectLimitTextureStrategy;

   typedef DtVirtualBaseClassCreator<DtIndirectGeometryGrid, const DtModelSetId&> DtIndirectGeometryGridCreator;

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

   class DT_DLL_VRVOSG DtIndirectGeometryGrid
   {
   public:

      using MapCellIdsToIndirectGeometry = tbb::concurrent_hash_map<Vector3_int, osg::ref_ptr<DtIndirectEntityGeometry>, DtIndirectCellHasher> ;

      using MapCellIdsToDebugCellDrawables = std::unordered_map<Vector3_int, osg::ref_ptr<osg::Drawable>, DtIndirectCellHasher > ;

      enum InstanceTrackingType
      {
          // regular add
          INSTANCE_ADD_REGULAR

          // regular remove
         , INSTANCE_REMOVE_REGULAR

         // being added to new cell (part of move)
         , INSTANCE_ADD_MOVE_NEW_CELL

         // being removed from old cell (part of move)
         , INSTANCE_REMOVE_MOVE_OLD_CELL

         // being cancelled (removed) from new cell (part of move)
         , INSTANCE_REMOVE_MOVE_CANCEL_NEW_CELL

         // paged out. remove all
         , INSTANCE_REMOVE_CELL_PAGED_OUT
      };

      struct InstanceTrackingStruct
      {
         InstanceTrackingStruct( const Vector3_int& cellId, int modelId, InstanceTrackingType type );
         InstanceTrackingStruct( const InstanceTrackingStruct& );

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

         Vector3_int myCellId;
         int myModelId;
         InstanceTrackingType myType;
      };

      using InstanceTrackingRequestsVector = tbb::concurrent_vector<InstanceTrackingStruct>;
   public:
      friend DtIndirectGeometryGridCreator;

      virtual ~DtIndirectGeometryGrid();
   protected:
      DtIndirectGeometryGrid(DtDe& de, DtModelSetId modelSet);

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

   public:
      virtual DtIndirectEntityGeometry* ts_getOrCreateForCell(const Vector3_int& cellId, bool& created);

      virtual const DtIndirectEntityGeometry* findIndirectGeometryForCell( const Vector3_int& cellId ) const;

      virtual bool ts_removeCell(const Vector3_int& cellId);

      virtual Vector3_int cellIdFor(const Vector3_64& position) const;

      virtual Vector3_64 cellCenter(const Vector3_int& cellId) const;

      virtual AxisAlignedBoundingBox_64 axisAlignedBoundingBox(const Vector3_int& cellId) const;

      virtual AxisAlignedBoundingBox_64 axisAlignedBoundingBoxWithPadding(const Vector3_int& cellId) const;

      virtual DtIndirectModelsContainer* modelsContainer();

      virtual void setCellSize(const Vector3_64& cellSize);
      virtual const Vector3_64& cellSize(void) const;

      virtual void setCellPadding(const Vector3_64& padding);
      virtual const Vector3_64& cellPadding(void) const;

      virtual osg::ref_ptr<osg::Node> gridNode();

      virtual const MapCellIdsToIndirectGeometry& mapCellIdsToIndirectGeometry(void) const;

      virtual const MapCellIdsToDebugCellDrawables& mapCellIdsToDebugCellDrawables(void) const;

      virtual void concurrentAddInstanceTrackingRequest( const Vector3_int& cellId, int modelId, InstanceTrackingType type );

      virtual void processInstanceTrackingRequests();

      virtual void trackInstances(const Vector3_int& cellId, int modelId, InstanceTrackingType type);

      virtual const DtIndirectLimitTextureStrategy* limitTextureStrategy(void) const;

      virtual DtIndirectLimitTextureStrategy* limitTextureStrategy(void);

      DtModelSetId modelSet(void) const;

      virtual osg::ref_ptr<osg::Node> gridRenderer();

      virtual std::string modelSetString(void) const;

   protected:

      DtDe& myDe;

      // The parent group for all indirect geometries in the grid
      osg::ref_ptr<osg::Node> myGridNode;

      osg::ref_ptr<DtIndirectGeometryRenderer> myGridRenderer;

      MapCellIdsToIndirectGeometry myMapCellIdsToIndirectGeometry;

      boost::mutex myMapCellIdsToDebugCellDrawablesMutex;
      MapCellIdsToDebugCellDrawables myMapCellIdsToDebugCellDrawables;

      DtIndirectModelsContainer* myModelsContainer;

      Vector3_64 myCellSize;

      Vector3_64 myCellPadding;

      boost::mutex myMapCellIdsToIndirectGeometryMutex;

      std::unordered_map<Vector3_int, std::unordered_map<int, int>, DtIndirectCellHasher > myMapCellToModelInstances;

      std::unordered_map<int, int> myModelIdToNumInstances;

      DtIndirectLimitTextureStrategy* myLimitTextureStrategy;

      const DtModelSetId myModelSet = DtModelSetId::Unspecified;

      AxisAlignedBoundingBox_64 myInfiniteBoundingBox;

      InstanceTrackingRequestsVector myInstanceTrackingRequests;

      // XXX temporary until we finish testing and branch is QA approved.
      // Connected to cmdline arg enableMutexesOnIndirectStructures
      bool myMutexesEnabled;
   };

}