DtLineRenderer.h

Go to the documentation of this file.

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


#pragma once

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

#include <vrvCore/DtLineSegmentInterface.h>

#include <vrvUtil/DtVirtualBaseClassCreator.h>

#include <matrix/vlMath.h>

#include <vector>
#include <map>
#include <unordered_map>

namespace makVrv
{
   class DtDe;
   class DtBufferObject;
   class DtFlat2DLineRenderer;
   class DtLineSegmentProxy;
   class DtLineSegmentProxyGroup;
   class DtOverlayResourceProvider;
   class DtProjected2DLineEffect;
   struct DtObserverRenderData;
   struct DtOverlayRenderData;

   class DtLineRenderer;

   typedef DtVirtualBaseClassCreator<DtLineRenderer, DtOverlayResourceProvider&> DtLineRendererCreator;

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

   class DT_DLL_VRVGRAPHICS DtLineRenderer : public DtPrimitiveRenderer
   {
      friend DtLineRendererCreator;
      friend class DtLineSegmentProxy;

   public:

      struct LineSegmentPrimitive
      {
         DtLineVertex p1;
         DtLineVertex p2;
      };

      const static unsigned short NoStipple = 0xFFFF;
      const static unsigned short NoLine = 0x0;

   public:

      virtual ~DtLineRenderer();

      DtLineRenderer() = delete;

      DtLineRenderer(
         const DtLineRenderer &other) = delete;

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

   public:

      virtual int numberOfPrimitives() const;

      virtual void render(const DtOverlayRenderData& overlayRenderData,
         const DtObserverRenderData& observerRenderData,
         const double projectionMatrix[16], bool picking);

      virtual void releaseResources();

      virtual bool isRenderModeSupported(int mode);

      virtual DtLineSegmentProxy* allocateNewSegment();

      virtual void initLineVertex(DtLineVertex& p);

   protected:

      typedef std::vector<LineSegmentPrimitive> LineSegments;
      typedef std::vector<DtLineSegmentProxy*> LineSegmentProxyList;

      struct LineSegmentSets
      {
         uint8_t* myToBeRenderedBuffer;
         LineSegmentProxyList mySimpleProxies;
         LineSegmentProxyList myStippledProxies;

         LineSegments mySimpleLines;
         LineSegments myStippledLines;

         LineSegmentSets();

         LineSegments& segmentsByIndex(unsigned int index)
         {
            if (index == 0)
               return mySimpleLines;
            else
               return myStippledLines;
         }

         LineSegmentProxyList& proxiesByIndex(unsigned int index)
         {
            if (index == 0)
               return mySimpleProxies;
            else
               return myStippledProxies;
         }

         void deleteToBeRenderedBuffer(void);

         void updateRenderData(double cameraAltitude);
         void releaseResources(void);

         DtBufferObject* myBufferObjectSimpleLines;
         DtBufferObject* myBufferObjectStippleLines;

         unsigned int myRenderedSimpleLineCount;
      };

      typedef std::unordered_map<float, LineSegmentSets> LineMap;

   protected:

      DtLineRenderer(DtDe& de, DtOverlayResourceProvider& provider);

      // Called when a proxy modified data.
      virtual void dirty(DtLineSegmentProxy*);

      //Called in proxy destructor.
      virtual void deallocateProxy(const DtLineSegmentProxy&);

      // Move Segment from one list to another.
      virtual int moveSegmentToOtherList(
         const float currentWidth,
         const int currentSegmentIndex,
         const int currentPrimativeIndex,
         const float desiredWidth,
         const int desiredSegmentIndex);

      virtual void setAltitudeBasedConfigurationsForProxy(
         DtLineSegmentProxy*, const DtLineSegmentInterface::DtLineSegmentAltitudeBasedConfigurationCollection&);
      virtual bool getAltitudeBasedConfigurationsForProxy(const DtLineSegmentProxy*, DtLineSegmentInterface::DtLineSegmentAltitudeBasedConfigurationCollection&) const;
      virtual void clearAltitudeBasedConfigurationsForProxy(DtLineSegmentProxy*);

      virtual void renderUsingVertexBufferObjects(DtFlat2DLineRenderer& renderer);
      virtual void renderStippledLineArrays(DtFlat2DLineRenderer& renderer, LineSegmentSets& lss);
      virtual void updateRenderData(double altitude);
      virtual void sortByStipple();

     protected:

      LineMap myLines;
      std::map<const DtLineSegmentProxy*, DtLineSegmentProxyGroup*> myLineSegmentProxyToGroupMap;
      std::vector<DtLineSegmentProxyGroup*> myLineSegmentProxyGroups;
      DtProjected2DLineEffect * myEffect;
      LineSegmentProxyList myDirtyList;
      unsigned int myPrimitiveCount;
   };

   class DT_DLL_VRVGRAPHICS DtLineSegmentProxy
   {
      friend class DtLineRenderer;
   public:   
      ~DtLineSegmentProxy();  

      const DtLineRenderer::LineSegmentPrimitive& mapReadOnly() const;
      DtLineRenderer::LineSegmentPrimitive& mapReadWrite();

      void enableStipple();

      void disableStipple();

      void setLodOutAltitude(double lodOutAltitude);

      double lodOutAltitude() const;
      
      void setIsLodOutAltitudeEnabled(bool isLodOutAltitudeEnabled);

      bool isLodOutAltitudeEnabled() const;

      void setWidth(float w);

      float width() const;

      void setAltitudeBasedLineLengths(
         const DtLineSegmentInterface::DtLineSegmentAltitudeBasedConfigurationCollection&);

      void clearAltitudeBasedLineLengths();

      void setIsUseForcedAltitudeEnabled(bool enabled);

      bool isUseForcedAltitudeEnabled() const;

      void setForcedAltitudeToUse(double minimumAltitudeForUse);

      double forcedAltitudeToUse() const;

      void setGroup(float group);

      float group() const;

      //Needed for sorting.
      static inline void swap(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         //Swap what they point to
         std::swap(v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex],
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex]);
         //Swap their indices
         std::swap(v1->myIndex,v2->myIndex);
         //Swap themselves
         std::swap(v1,v2);
      }

      //Needed for sorting.
      static inline bool less(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         DtLineRenderer::LineSegmentPrimitive& line1 = 
            v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex];
         DtLineRenderer::LineSegmentPrimitive& line2 =
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex];

         return (((unsigned int)line1.p1.lineParams[0]) << 16 |
                  (unsigned int)(line1.p1.lineParams[1])) 
                < 
                (((unsigned int)line2.p1.lineParams[0]) << 16 | 
                  (unsigned int)(line2.p1.lineParams[1]));
      }

      //Needed for sorting.
      static inline bool equal(DtLineSegmentProxy*& v1,DtLineSegmentProxy*& v2)
      {
         DtLineRenderer::LineSegmentPrimitive& line1 = 
            v1->myParent->myLines[v1->myWidth].segmentsByIndex(v1->mySegmentIndex)[v1->myIndex];
         DtLineRenderer::LineSegmentPrimitive& line2 =
            v2->myParent->myLines[v2->myWidth].segmentsByIndex(v2->mySegmentIndex)[v2->myIndex];

         return (((unsigned int)line1.p1.lineParams[0]) << 16 | 
                   (unsigned int)(line1.p1.lineParams[1])) 
                == 
                (((unsigned int)line2.p1.lineParams[0]) << 16 | 
                  (unsigned int)(line2.p1.lineParams[1]));
      }

   protected:
      DtLineSegmentProxy(DtLineRenderer& parent,int index);
      DtLineRenderer* myParent;

      bool myDirtyFlag;
      int mySegmentIndex;
      int myIndex;
      float myWidth;
      double myLodOutAltitude;
      bool myIsLodOutAltitudeEnabled;

      bool myIsForcedAltitudeEnabled;
      double myForcedAltitudeToUse;
   };

   class DT_DLL_VRVGRAPHICS DtLineSegmentProxyGroup
   {
      friend class DtLineRenderer;

   public:
      typedef std::vector<DtLineSegmentProxy*> DtLineSegmentProxyList;

   public:
      DtLineSegmentProxyGroup(DtLineSegmentInterface::DtLineSegmentAltitudeBasedConfigurationCollection);
      DtLineSegmentProxyGroup();

   public:
      void updateRenderData(double cameraMSLAltitude);

   protected:
      DtLineSegmentProxyList myProxies;

      DtLineSegmentInterface::DtLineSegmentAltitudeBasedConfigurationCollection myAltitudeBasedConfigurations;

   };

}