DtGeom3dLinesSystem.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 Dt3dLinesStagingBuffer;
   class DtGeom3dLinesComponent;
   class DtGeom3dLinesSystem;

   typedef DtVirtualBaseClassCreator<DtGeom3dLinesSystem> DtGeom3dLinesSystemCreator;

   template <>
   inline const char* creatorTypeName<DtGeom3dLinesSystem>() { return "DtGeom3dLinesSystemCreator"; }

   class DT_DLL_VRVCORE DtGeom3dLinesSystem
   {
      friend DtGeom3dLinesSystemCreator;

   public:

      virtual ~DtGeom3dLinesSystem();

      DtGeom3dLinesSystem() = delete;

      DtGeom3dLinesSystem(
         const DtGeom3dLinesSystem& other) = delete;

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

   public:

      virtual DtGeom3dLinesComponent* createComponent(DtModelSetId modelSet);

      virtual void registerComponent(DtGeom3dLinesComponent* component);

      virtual void unregisterComponent(DtGeom3dLinesComponent* component);

      virtual size_t registeredComponentCount(const DtModelSetId modelSetId) const;

      virtual double computeAltitude(const DtVector& point, bool& geoCentric) const;

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

      virtual void submit3dLinesForDraw(void* cameraContext,
         std::vector<Dt3dLinesStagingBuffer*>& buffers);

   protected:

      DtGeom3dLinesSystem(DtDe& de);

      virtual void slot_coordinateSystemChanged();

      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<DtGeom3dLinesComponent*>* myComponents = nullptr;
         size_t myBeginIndex = 0;
         size_t myEndIndex = 0;
         Dt3dLinesStagingBuffer* myBuffer = nullptr;
         const std::array<DtVector4<double>, 6>* myCullingPlanes = nullptr;
         unsigned int myCategoryFlags = 0;
      };

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

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

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

      DtDe& myDe;

      DtSignalConnectionManager myConnections;

      // Local clone of the system wide coordinate system.
      DtCoordinateSystem* myCoordinateSystem;

      // 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;
   };
}