DtGeom3dSpheresSystem.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtJobSplitter.h>
#include <vrvCore/DtModelSetEnums.h>

#include <vrvMath/DtCamera.h>
#include <vrvMath/DtCameraFwdDeclare.h>
#include <vrvMath/DtVector4.h>

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

#include <matrix/vlVector.h>

#include <array>
#include <unordered_map>
#include <vector>
#include <tbb/concurrent_vector.h>

namespace makVrv
{
   // forward Declarations
   class DtCoordinateSystem;
   class DtDe;
   class Dt3dSpheresStagingBuffer;
   class DtGeom3dSpheresComponent;
   class DtGeom3dSpheresSystem;

   typedef DtVirtualBaseClassCreator<DtGeom3dSpheresSystem> DtGeom3dSpheresSystemCreator;

   template <>
   inline const char* creatorTypeName<DtGeom3dSpheresSystem>() { return "DtGeom3dSpheresSystemCreator"; }

   class DT_DLL_VRVCORE DtGeom3dSpheresSystem
   {
      friend DtGeom3dSpheresSystemCreator;

   public:

      virtual ~DtGeom3dSpheresSystem();

      DtGeom3dSpheresSystem() = delete;

      DtGeom3dSpheresSystem(
         const DtGeom3dSpheresSystem& other) = delete;

      DtGeom3dSpheresSystem& operator=(
         const DtGeom3dSpheresSystem& other) = delete;

   public:

      virtual DtGeom3dSpheresComponent* createComponent(DtModelSetId modelSet);

      virtual void registerComponent(DtGeom3dSpheresComponent* component);

      virtual void unregisterComponent(DtGeom3dSpheresComponent* component);

      virtual size_t registeredComponentCount(const DtModelSetId modelSetId) const;

      virtual bool cull(void* cameraContext, const DtModelSetId modelSetId,
         const DtVector& cameraPos, const Frustum_64& frustum);

      virtual void submit3dSpheresForDraw(void* cameraContext,
         std::vector<Dt3dSpheresStagingBuffer*>& buffers);

   protected:

      DtGeom3dSpheresSystem(DtDe& de);

      virtual void slot_preTick();

      static bool isSphereVisible(
         const std::array<DtVector4<double>, 6>& cullingPlanes,
         const DtVector3<double>& center, double radiusSquared);

      static void theCullJob(void* data);

   protected:

      struct CullJobData
      {
         std::vector<DtGeom3dSpheresComponent*>* myComponents = nullptr;
         size_t myBeginIndex = 0;
         size_t myEndIndex = 0;
         Dt3dSpheresStagingBuffer* myBuffer = nullptr;
         const std::array<DtVector4<double>, 6>* myCullingPlanes = nullptr;
         unsigned int myCategoryFlags = 0;
      };

      struct Buffer
      {
         Dt3dSpheresStagingBuffer* myBuffer = nullptr;
         CullJobData myCullJobData;
         DtJobSplitterJob myCullJob;
      };

      struct PerCameraStaging
      {
         std::vector<Buffer*> myBuffers;
         bool myCameraWasUsedDuringCull = true;
         DtJobSplitter* myJobSplitter = nullptr;
      };

      struct PerModelSetComponents
      {
         std::vector<DtGeom3dSpheresComponent*> myComponents;
      };

      DtDe& myDe;

      DtSignalConnectionManager myConnections;

      // Flags that determine what categories of components are active.
      unsigned int myComponentCategoryFlags;

      // Components are registered with an associated DtModelSetId and this
      // map is used to map the DtModelSetId to the components associated with it.
      std::unordered_map<DtModelSetId, PerModelSetComponents*> myPerModelSetComponents;

      // This map is read only during cull and render.
      // It maps a cameraContext to associated staging data.
      std::unordered_map<void*, PerCameraStaging*> myPerCameraStagingMap;

      // This vector handles new camera's when they are encountered
      // during cull. The contents of the vector are handed to
      // myPerCameraStagingMap to be processed in a thread safe way
      // during update.
      tbb::concurrent_vector<void*> myPendingCameras;
   };
}