DtTextRenderer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvGraphics/vrvGraphics.h>
#include <vrvGraphics/DtPrimitiveRenderer.h>
#include <vrvGraphics/DtBoundingBox.h>
#include <vrvGraphics/DtTextured2DRenderer.h>
#include <vrvGraphics/DtFont.h>

#include <vrvCore/DtVirtualBaseClassCreator.h>

#include <vrvUtil/DtUnicode.h>

#include <matrix/vlMath.h>

#include <utility>
#include <vector>
#include <limits>

namespace makVrv
{

   class DtDe;
   class Dt2DEffect;
   class DtTextProxy;
   class DtTextLayoutInterface;
   class DtTexturedGlyphRenderer;
   class DtOverlayResourceProvider;
   class DtProjected2DTexturedEffect;
   class DtTextProxyGroup;
   typedef boost::weak_ptr<DtFont> DtFontWP;
   typedef boost::shared_ptr<DtFont> DtFontSP;

   class DtBufferObject;

   class DtTextRenderer;

   typedef DtVirtualBaseClassCreator<DtTextRenderer, DtOverlayResourceProvider&> DtTextRendererCreator;

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

   class DT_DLL_VRVGRAPHICS DtTextRenderer : public DtPrimitiveRenderer
   {
      friend DtTextRendererCreator;

   public:
      class DtAltitudeBasedConfiguration
      {
      public:
         DtAltitudeBasedConfiguration()
            : myBaseAltitude(std::numeric_limits<double>::min())
            , myFont(0)
         {
            // intentional noop
         }

         DtAltitudeBasedConfiguration(double altitude, DtFontSP font)
            : myBaseAltitude(altitude)
            , myFont(font)
         {
            // intentional noop
         }

         ~DtAltitudeBasedConfiguration()
         {
            // intentional noop
         }

         DtAltitudeBasedConfiguration(
            const DtAltitudeBasedConfiguration &other) = default;

         DtAltitudeBasedConfiguration &operator=(
            const DtAltitudeBasedConfiguration &other) = default;

         DtAltitudeBasedConfiguration(DtAltitudeBasedConfiguration &&) = default;

      public:

         bool operator==(const DtAltitudeBasedConfiguration& config) const
         {
            return DtEq(myBaseAltitude, config.myBaseAltitude, DtEMilli) 
               && myFont == config.myFont;
         }

         double myBaseAltitude;
         DtFontSP myFont;
      };

      typedef std::vector<DtAltitudeBasedConfiguration> DtAltitudeBasedConfigurationCollection;

   public:
      
      virtual ~DtTextRenderer();

      DtTextRenderer() = delete;

      DtTextRenderer(
         const DtTextRenderer &other) = delete;

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

   public:

      virtual DtTextProxy* createProxy();

      virtual DtTextProxy* cloneProxy( const DtTextProxy* );

      virtual int numberOfPrimitives() const;

      virtual void releaseResources();

      virtual bool isRenderModeSupported( int mode );

      virtual bool forceTextShaping(void) const;

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

      virtual void addGroupRef( unsigned int );

      virtual void removeGroupRef( unsigned int );

      virtual void removeProxy( const  DtTextProxy* );

      virtual void setAltitudeBasedConfigurationsForProxy(DtTextProxy*, const DtAltitudeBasedConfigurationCollection&);

      virtual bool getAltitudeBasedConfigurationsForProxy(const DtTextProxy*, DtAltitudeBasedConfigurationCollection&) const;

      virtual void clearAltitudeSpecificConfigurationsForProxy(DtTextProxy*);

   protected:

      DtTextRenderer(DtDe& de, DtOverlayResourceProvider& provider);

   protected:

      std::map<const DtTextProxy*, DtTextProxyGroup*> myTextProxyToGroupMap;
      std::map<const DtTextProxyGroup*, DtTexturedGlyphRenderer*> myGlyphRenderers;
      std::vector<DtTextProxyGroup*> myTextProxyGroups;
      DtProjected2DTexturedEffect* myEffect;

      typedef std::vector<DtBufferObject*> BufferObjectList;
      BufferObjectList myBufferObjectList;
   };


   class DT_DLL_VRVGRAPHICS DtTextProxy
   {
   public:

      class DtAltitudeBasedBoundingBoxConfiguration
      {
      public:
         DtAltitudeBasedBoundingBoxConfiguration(double altitude, const DtBoundingBox& box)
            : myBaseAltitude(altitude)
            , myBoundingBox(box)
         {
            // intentional noop
         }

         DtAltitudeBasedBoundingBoxConfiguration()
            : myBaseAltitude(std::numeric_limits<double>::min())
            , myBoundingBox()
         {
            myBoundingBox.invalidate();
         }

         ~DtAltitudeBasedBoundingBoxConfiguration() = default;
         DtAltitudeBasedBoundingBoxConfiguration(
            const DtAltitudeBasedBoundingBoxConfiguration &other) = default;
         DtAltitudeBasedBoundingBoxConfiguration &operator=(
            const DtAltitudeBasedBoundingBoxConfiguration &other) = default;

         double myBaseAltitude;
         DtBoundingBox myBoundingBox;
      };

      typedef std::vector<DtAltitudeBasedBoundingBoxConfiguration> DtAltitudeBasedBoundingBoxConfigurationCollection;

   public:

      DtTextProxy( DtTextRenderer* parent );

      DtTextProxy* clone( DtTextRenderer* parent ) const;

      ~DtTextProxy();

   public:

      void setAlignment( DtFont::TextAlignement alignment );

      DtFont::TextAlignement alignment() const { return myAlignment; };

      void setParent(DtTextRenderer*);

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

      const float* position() const;

      void setRotation( float angle );

      float rotation() const;

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

      const float* color() const;

      void setString( const DtUnicode& str );

      const DtUnicode& string() const;

      void setFont(DtFontSP font);

      std::vector<double> fontConfigurationMinimumAltitudes() const;

      void setAltitudeSpecificFonts(const DtTextRenderer::DtAltitudeBasedConfigurationCollection&);

      void clearAltitudeSpecificFonts();

      void setIsForcedAltitudeBasedConfigurationEnabled(bool enabled);

      bool isForcedAltitudeBasedConfigurationEnabled() const;

      void setBaseAltitudeToUseForForcedAltitudeBasedConfigurations(double minimumAltitudeForUse);

      DtFontSP font(double altitude=std::numeric_limits<double>::min()) const;

      Dt2dPoint calculateGlyphSize(const DtPen& pen, 
         const DtUnicode& string, double minimumCameraAltitude=std::numeric_limits<double>::min(), 
         unsigned int pos = 0, int len = -1) const;

      DtBoundingBox calculateBoundingBox(const DtPen& pen, 
         const DtUnicode& string, double minimumCameraAltitude=std::numeric_limits<double>::min(), 
         unsigned int pos = 0, int len = -1) const;

      void setBounds( const DtBoundingBox& box );

      const DtBoundingBox& bounds(double cameraAltitude) const;

      void setBoundsByMinimumAltitude( const DtBoundingBox& box, double minimumAltitudeForUse );

      void setGroup( unsigned int group );

      void setLodOutAltitude( double lodOutAltitude );

      double lodOutAltitude() const;

      void setIsLodOutAltitudeEnabled(bool isLodOutAltitudeEnabled);

      bool isLodOutAltitudeEnabled() const;

      unsigned int group() const;

      void renderText(DtTexturedGlyphRenderer*, DtFontSP, double);

   protected:

      DtTextRenderer* myParent;

      float myRotation;
      float myPosition[4];
      float myColor[4];
      unsigned int myGroup;

      DtFont::TextAlignement myAlignment;
      DtUnicode myString;
      DtAltitudeBasedBoundingBoxConfigurationCollection myAltitudeBasedBounds;

      DtTextLayoutInterface* myTextLayout;

      bool myIsLodOutAltitudeEnabled;
      double myLodOutAltitude;

      bool myIsForcedAltitudeBasedConfigurationEnabled;
      double myAltitudeToUseForForcedAltitudeBasedConfiguration;

      void makeOrChangeTextLayout(const DtUnicode& str);
   };

   class DT_DLL_VRVGRAPHICS DtTextProxyGroup
   {
      friend class DtTextRenderer;

   public:
      typedef std::vector<DtTextProxy*> TextProxyList;

   public:
      DtTextProxyGroup(DtTextRenderer::DtAltitudeBasedConfigurationCollection);
      DtTextProxyGroup();
      ~DtTextProxyGroup();

      DtTextProxyGroup(
         const DtTextProxyGroup &other) = delete;

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

      DtTextProxyGroup(DtTextProxyGroup &&) = delete;

   public:
      void render(DtTexturedGlyphRenderer* renderer, double cameraAltitude);

   protected:
      TextProxyList myProxies;

      DtTextRenderer::DtAltitudeBasedConfigurationCollection myAltitudeBasedConfigurations;
   };

}