DtOverlaySegmentedLineModelInstance.h

Go to the documentation of this file.

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


#pragma once

#include <vrvOsg/DtOsgModelInstance.h>
#include <vrvCore/DtTacticalGraphicModelUpdaterManager.h>

#include <vrvCore/DtTacticalGraphicUtilities.h>
#include <vrvCore/DtSharedDisplayUnitsSettings.h>
#include <vrvCore/DtQuadProxyInterface.h>
#include <vrvCore/DtTextProxyInterface.h>

#include <vrvMath/DtVector2.h>
#include <vrvMath/DtVector4.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvUtil/DtQuat.h>

namespace makVrv
{
   class DtSegmentedLineInterface;
   class DtChannelManager;
   class DtChannel;
   class DtTextureInterface;

   class DT_DLL_VRVOSG DtOverlaySegmentedLineModelInstance : public DtModelInstance
   {
   public:
      struct SegmentAttributes
      {
         float width;
         int group;
         bool startArrow;
         bool endArrow;
         bool lightning;
         unsigned int stipplePattern;
         int stippleRepeat;
         DtVector4<float> color[2];

         int endArrowSegments;
         int startArrowSegments;
      };

      typedef std::vector<SegmentAttributes> SegmentAttributesVector;

      typedef std::vector<DtVector> Points;

   public:

      DtOverlaySegmentedLineModelInstance(DtDe& de);

      virtual ~DtOverlaySegmentedLineModelInstance();

   private:

      DtOverlaySegmentedLineModelInstance();

      DtOverlaySegmentedLineModelInstance(const DtOverlaySegmentedLineModelInstance&);

      DtOverlaySegmentedLineModelInstance &operator=(const DtOverlaySegmentedLineModelInstance&);

   public:

      virtual void setPosition( int vtx, const DtVector& position );

      virtual DtVector position(int vtx = 0) const;

      virtual void removePosition( int vtx );

      virtual void setWidth(float width);

      virtual void setMeasurementTextFont(const std::string& fontFile, float pointSize);

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

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

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

      virtual void setAreSmartDistancesForMeasurementTextEnabled(bool);

      virtual void setMeasurementTextOffset(int x, int y);

      virtual void setStipplePattern( unsigned int pattern, int repeatFactor );

      virtual void setStyleSegments(const std::vector<double>& segmentPercentages);

      virtual void setSegmentColor(unsigned int segmentIndex,
         float r, float g, float b, float a);

      virtual void setSegmentLightningStyle(unsigned int segmentIndex,
         bool enableLightningStyle);

      virtual void setSegmentStartArrow(unsigned int segmentIndex,
         bool enableArrow);

      virtual void setSegmentEndArrow(unsigned int segmentIndex,
         bool enableArrow);

      virtual void setSegmentStipplePattern(unsigned int segmentIndex,
         unsigned int stipplePattern, int repeatFactor);

      virtual void setSegmentWidth(unsigned int segmentIndex, double width);

      virtual void setSegmentStartColor( unsigned int segmentIndex, float r, 
         float g, float b, float a );

      virtual void setSegmentEndColor( unsigned int segmentIndex, float r, 
         float g, float b, float a );

      virtual void setModelSet( DtModelSetId modelSet );

      virtual bool realize(const DtModelDefinition& definition);

      virtual void setVisible(bool isVisible);

      virtual void setEventsEnabled( bool enabled, unsigned long long userData );

      virtual void setEventWidth(float width);

      virtual void update();

      // @{
      virtual void setIsSuppressMagneticNorthNotationEnabled(bool isEnabled);
      virtual bool isSuppressMagneticNorthNotationEnabled() const;
      // @}

      // @{
      virtual void setNorthUnit(DtSharedDisplayUnitsSettings::NorthUnits unit);
      virtual DtSharedDisplayUnitsSettings::NorthUnits northUnit() const;
      // @}

      // @{
      virtual void setNorthUnitNotation(const DtUnicode& notation);
      virtual DtUnicode northUnitNotation() const;
      // @}

      // @{
      virtual void setDistanceUnit(DtSharedDisplayUnitsSettings::DistanceUnits unit);
      virtual DtSharedDisplayUnitsSettings::DistanceUnits distanceUnit() const;
      // @}

      // @{
      virtual void setDistanceUnitNotation(const DtUnicode& notation);
      virtual DtUnicode distanceUnitNotation() const;
      // @}

      // @{
      virtual void setDistanceDecimals(unsigned int decimals);
      virtual unsigned int distanceDecimals() const;
      // @}

      // @{
      virtual void setOrientationUnit(DtSharedDisplayUnitsSettings::OrientationUnits unit);
      virtual DtSharedDisplayUnitsSettings::OrientationUnits orientationUnit() const;
      // @}

      // @{
      virtual void setOrientationUnitNotation(const DtUnicode& notation);
      virtual DtUnicode orientationUnitNotation() const;
      // @}

      // @{
      virtual void setOrientationDecimals(unsigned int decimals);
      virtual unsigned int orientationDecimals() const;
      // @}

      virtual void setRotation(const DtQuat& quat);

      virtual void setArrowSize(double);

      virtual void setLineStyle(vrvTacticalGraphicUtilities::LineStyle);

      virtual void setArrowStyle(vrvTacticalGraphicUtilities::ArrowStyle);

      virtual void setTexture( std::string& textureFileName );

      virtual void setTexture( DtTextureInterface* textureInterface );

      virtual bool isTextured() const;

      virtual void setFixedWidthSizing(bool);

      virtual void setGroup( int );

      virtual void setChannelInstance(DtChannel*, DtModelSetId modelSet);

      virtual const std::vector<DtVector>& points() const;

      virtual void setPoints(const std::vector<DtVector>&);

      virtual const SegmentAttributesVector& segmentInformation() const;

      virtual void setSegmentInformation(const SegmentAttributesVector&);

      virtual void updateGeometry();

      virtual bool isMeasurementTextRenderingEnabled() const;
      virtual void setIsMeasurementTextRenderingEnabled(bool isMeasurementTextRenderingEnabled);

      virtual void setOverlay(unsigned int overlayId);

      virtual void deleteSegmentLabels();

   protected:
     virtual void updateSegmentsWithArrows(const std::vector<DtVector>& pts,
        std::vector<DtVector>& drawPoints, std::vector<DtVector>& twodOffsets);

   protected:

      virtual void createLineIfNecessary();

      virtual void updateSegments();

      virtual void updateLabels();

      virtual void createSegmentLabels();

      virtual void updateGeometryForLineStyle();

      virtual void resizeSegmentAttributes( int size );

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

      virtual void set3DPositionAux( double x, double y, double z, 
         float tempPackedCoords[4] );

      virtual void channelUpdated(const DtTacticalGraphicModelUpdaterManager::ChannelUpdateData&);

      void updatePointsForLineStyle(const std::vector<DtVector>&, std::vector<DtVector>& drawPoints,
         std::vector<DtVector>& twodOffsets, std::vector<int>& segmentsToErase) const;

      virtual void slot_onCoordinateSystemChanged();

   protected:
      DtUniqueID mySceneObjectId;

      DtSignalConnectionManager myConnections;
      DtCoordinateSystem* myCoordinateSystem;

      // These are the points as set by the model
      Points myPoints;
      Points myVertices;
      Points my2DOffsets;

      SegmentAttributesVector mySegmentAttributes;
      DtModelSetId myModelSet;
      DtSegmentedLineInterface* myLineInterface;
      bool myVisible;

      bool myIsMeasurementTextRenderingEnabled;
      bool myAreSmartDistancesForMeasurementTextEnabled;
      bool myIsScreenSpaceBasedRenderingForMeasurementTextEnabled;
      int myMeasurementTextOffsetX;
      int myMeasurementTextOffsetY;

      std::string myMeasurementTextFontFile;
      double myMinimumForMeasurementTextMaximumWorldWidth;
      float myMeasurementTextFontPointSize;
      DtVector4<float> myMeasurementTextColor;
      DtVector4<float> myMeasurementTextBackgroundColor;

      DtVector4<float> myColor;
      float myWidth;
      unsigned int myStipplePattern;
      int myStippleRepeat;
      std::vector<double> mySegmentPercentages;
      float myEventWidth;

      bool myGeometryDirty;
      bool mySegmentsDirty;
      bool myEventsEnabled;

      DtVector myOrigin;
      DtQuat myRotation;

      double myArrowSize;
      vrvTacticalGraphicUtilities::ArrowStyle myArrowStyle;

      DtTextureInterface* myTexture;

      vrvTacticalGraphicUtilities::LineStyle myLineStyle;
      bool myFixedWidthSizing;
      std::vector<int> mySegmentsToErase;

      DtChannel* myChannelInstance;
      int myGroup;

      std::vector<DtQuadProxyInterface*> myLabelBackgrounds;
      std::vector<DtTextProxyInterface*> myLabels;
      unsigned int myOverlay;
      
      bool mySuppressMagneticNorthNotationEnabled;

      DtSharedDisplayUnitsSettings::OrientationUnits myOrientationUnitToUse;
      DtUnicode myOrientationUnitNotation;
      unsigned int myOrientationDecimalsToUse;

      DtSharedDisplayUnitsSettings::DistanceUnits myDistanceUnitToUse;
      DtUnicode myDistanceUnitNotation;
      unsigned int myDistanceDecimalsToUse;

      DtSharedDisplayUnitsSettings::NorthUnits myNorthToUse;
      DtUnicode myNorthNotation;
   };
}