DtDecalProjectorComponent.h

Go to the documentation of this file.

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


#pragma once

#include <vrvGraphics/vrvGraphics.h>
#include <vrvGraphics/DtPrimitiveRenderer.h>

#include <vrvCore/DtDecalProjectorComponentInterface.h>

#include <vrvMath/DtVector3.h>

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

#include <matrix/coordTransform.h>
#include <matrix/vlVector.h>

#include <vector>


namespace makVrv
{

   class DtCoordinateSystem;
   class DtDecalProjectorRenderer;
   class DtDe;
   struct DtObserverRenderData;
   struct DtOverlayRenderData;
   class DtOverlayResourceProvider;
   class DtPrimitiveStyle;
   class DtTextureInterface;


   class DT_DLL_VRVGRAPHICS DtDecalProjectorComponent : public DtDecalProjectorComponentInterface
   {
   public:

      friend class DtDecalProjectorComponentCreator;
      friend class DtDecalProjectorRenderer;
      friend class DtDecalProjectorLineRenderer;

      virtual ~DtDecalProjectorComponent();

      virtual void setProjectionRange(float projNear, float projFar);

      virtual void projectionRange(float& projNear, float& projFar) const;

      virtual void resizeStagingVertexCount(size_t size);

      virtual void setStagingVertexPosition(unsigned int index, double x, double y, double z);

      virtual void expandStagingPointsToLines();

      virtual void expandStagingPointsToLineQuads(float lineWidth);

      virtual void stagingGeometryUpdated();

      virtual void setColor(float r, float g, float b, float a);

      virtual void getColor(float& r, float& g, float& b, float& a) const;

      virtual void projectUVCoordinates(const DtVector& origin,
         const DtVector& axisU, const DtVector& axisV);

      virtual void getUVCoordinateProjection(DtVector3<float>& origin,
         DtVector3<float>& axisU, DtVector3<float>& axisV) const;

      virtual void setStipplePattern(unsigned int stipplePattern[32] = 0);

      virtual const unsigned int* getStipplePattern() const;

      virtual void setFillPatternFrequency(float frequency) override;

      virtual float fillPatternFrequency() const override;

      virtual void setAllowAltitudeTileMultiplier(bool allow);

      virtual bool allowAltitudeTileMultiplier() const;

      virtual bool allowSparseTiling() const;

      virtual void setTexture(DtTextureInterface* texture);

      virtual DtTextureInterface* texture() const;

      virtual bool pick(double x, double y, double z) const;

   protected:

      struct StagingPoint
      {
         double x = 0.0f;
         double y = 0.0f;
         double z = 0.0f;
         float u = 0.0f;
         float v = 0.0f;
      };

      DtDecalProjectorComponent(DtDecalProjectorRenderer& renderer);

      void setStagingPointFromVector(StagingPoint& outPoint, const DtVector& inPoint) const;

      virtual void computeTopoTransform(DtCoordTransform& geocToTopo,
         DtVector& geocentricOrigin, const DtVector& localOrigin, 
         DtCoordinateSystem& coordinateSystem) const;

      virtual void updateProjectedUVCoordinates();

      virtual void computeDrawPasses();

      virtual void computeDrawPassBounds();

      virtual void computeProjectionRangeFromArea(float boundsSizeX, float boundsSizeY);

      void drawPassTransform(DtVector3<double>& origin, float* rotation) const;

      void drawPassBoundingSphere(DtVector3<float>& center, float& radius) const;

      // Returns the number of draw passes.
      size_t drawPassCount() const;

      size_t passPointCount(unsigned int pass) const;

      const void* passPoints(unsigned int pass) const;

      const void* passPointsUVs(unsigned int pass) const;

      void passBounds(unsigned int pass, DtVector& boundsMin, DtVector& boundsMax);

      struct TopoPoint
      {
         float x = 0.0f;
         float y = 0.0f;
         float z = 0.0f;
         float w = 1.0f;
      };

      bool pickTriangles(const DtVector3<float>& localPoint) const;

      bool pickLines(const DtVector3<float>& localPoint, float radius) const;

      bool pointInTriangle(const DtVector3<float>& point,
         const DtDecalProjectorComponent::TopoPoint pointA,
         const DtDecalProjectorComponent::TopoPoint pointB,
         const DtDecalProjectorComponent::TopoPoint pointC) const;

      float squaredDistanceToLine(const DtVector3<float>& point,
         const DtDecalProjectorComponent::TopoPoint pointA,
         const DtDecalProjectorComponent::TopoPoint pointB) const;

      static void setPickLineRadius(float radius); 

   protected:

      static float thePickLineRadius;

      struct DrawPassData
      {
         size_t myPointCount = 0;
         void* myPointDataStart = nullptr;
         void* myPointUVsDataStart = nullptr;
         DtVector myBoundsMin;
         DtVector myBoundsMax;
      };

      DtDecalProjectorRenderer& myRenderer;

      float myProjectionRangeNear;
      float myProjectionRangeFar;
      bool myAutoProjectionRange;

      unsigned int myStipplePattern[32];
      float myColor[4];
      float myFillPatternFrequency;

      DtTextureInterface* myTexture;
      bool myAllowAltitudeTileMultiplier;

      bool myUseProjectedTextureCoordinates;
      DtVector3<float> myProjCoordsOrigin;
      DtVector3<float> myProjCoordsAxisU;
      DtVector3<float> myProjCoordsAxisV;

      DtVector myDrawPassOrigin;
      DtQuat myDrawPassRotationInvQuat;
      float myDrawPassRotation[16];
      DtVector3<float> myDrawPassBoundsCenter;
      float myDrawPassBoundsRadius;

      // 3D staging points local to the transform.
      std::vector<StagingPoint> myStagingPoints;

      // Topographic points used for rendering.
      std::vector<TopoPoint> myTopoPoints;
      std::vector<TopoPoint> myTopoPointsUVs;

      std::vector<DrawPassData> myDrawPasses;
   };



   class DT_DLL_VRVGRAPHICS DtDecalProjectorComponentCreator : public DtVirtualBaseClass
   {
   public:
      DtDecalProjectorComponentCreator();

      virtual ~DtDecalProjectorComponentCreator();

      DtDecalProjectorComponentCreator(
         const DtDecalProjectorComponentCreator& other) = delete;

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

   public:
      virtual DtDecalProjectorComponent* create(DtDecalProjectorRenderer& renderer) const;

      static DtDecalProjectorComponentCreator& instance(DtDe& de);

      static const std::string& theClassName();
   };

}