DtQuadRenderer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvGraphics/DtPrimitiveRenderer.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vector>

#include <tbb/mutex.h>

namespace makVrv
{

   class DtDe;
   class DtQuadProxy;
   class DtPrimitiveStyle;
   class DtOverlayResourceProvider;

   class DtQuadRenderer;

   typedef DtVirtualBaseClassCreator<DtQuadRenderer, DtOverlayResourceProvider&> DtQuadRendererCreator;

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

   class DT_DLL_VRVGRAPHICS DtQuadRenderer : public DtPrimitiveRenderer
   {
   public:

      enum Styles
      {
         Style_Flat = 0,               
         Style_Stippled,               
         Style_Textured,               
         Style_Textured_Repeating,     
         Styles_End
      };

      friend DtQuadRendererCreator;
      friend class DtQuadProxy;

      virtual ~DtQuadRenderer();

      virtual int numberOfPrimitives() const;

      virtual void render( bool geocentric, float geocentricAlpha,
         const double location[3], double cameraAltitude
       , const double positionMatrix[16]
       , const double projectionMatrix[16]);

      virtual void releaseResources();

      virtual bool isRenderModeSupported( int mode );

      DtQuadProxy* allocateProxy(Styles = Style_Flat);

   protected:

      DtQuadRenderer(DtDe& de, DtOverlayResourceProvider& provider);

      void add( DtQuadProxy* toAdd );

      void remove( const DtQuadProxy* const proxy, bool isBeingDeleted = false );

      void dirty( DtQuadProxy* proxy );

   protected:

      typedef std::vector<DtQuadProxy*> QuadProxyList;

      DtPrimitiveStyle* myStyles[Styles_End];
      bool myStyleDirty[Styles_End];
      QuadProxyList myQuads;

      tbb::mutex myUpdateMutex;

   };


   class DT_DLL_VRVGRAPHICS DtQuadProxy
   {
   public:

      friend class DtQuadRenderer;

      ~DtQuadProxy();

      void setGroup( float order );

      float group() const;

      void set3DPosition( int index, float x, float y, float z, float w);

      void set3DPosition( float x, float y, float z, float w = 0 );

      void get3DPosition( float& x, float& y, float& z, float& w ) const;

      void set2DRotation( float angle );

      void get2DRotation( float& angle ) const;

      void setPoints( const float points[8] );

      void getPoints(float points[8]) const;

      void setPointsByMinimumAltitude(const float points[8], double altitude);

      void setIsForcedPointsByAltitudeEnabled(bool isEnabled);

      void setAltitudeForForcedPoints(double minimumAltitudeForUse);

      void clearAltitudeSpecificConfigurations();

      void setBounds( const float bounds[4] );

      void getBounds( float bounds[4] ) const;

      void setStyle( int style );

      int style() const;

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

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

      void setStippleParameters( unsigned int fill,
         unsigned int fullStipplePattern[32] = 0 );

      void setTextureParameters( void* textureHangle,
         float left = 0.0f, float right = 1.0f,
         float bottom = 0.0f, float top = 1.0f );

      void* textureHandle() const;

      unsigned int index() const;

      void setIndex( unsigned int index );

      void setLodOutAltitude(double lodOutAltitude);

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

      bool isLodOutAltitudeEnabled() const;

   protected:

      DtQuadProxy( DtQuadRenderer& renderer, unsigned char effect );

      static void getBoundsFromPoints(float bounds[4], const float points[8]);

      bool hasAltitudeSpecificPoints() const;

      void updatePointsBasedOnAltitude(double cameraAltitude);

      bool updateLodVisibility(DtPrimitiveStyle* style, double cameraAltitude);

   protected:

      DtQuadRenderer* myParent;
      unsigned int myIndex;
      unsigned char myStyle;
 
      class DtAltitudeSpecificConfiguration
      {
      public:
         DtAltitudeSpecificConfiguration() = delete;

         DtAltitudeSpecificConfiguration(double altitude, const float points[8])
            : myAltitude(altitude)
         {
            memcpy(myPoints, points, sizeof(float) * 8);
         }

         double myAltitude;
         float myPoints[8];
      };

      typedef std::vector<DtAltitudeSpecificConfiguration> DtMinimumAltitudeToPointsVector;

      DtMinimumAltitudeToPointsVector myAltitudeToPointsMap;

      bool myIsForcedPointsByMinimumAltitudeEnabled;
      double myAltitudeToUseForForcedPoints;

      double myLodOutAltitude;
      bool myIsLodOutAltitudeEnabled;
   };

}