DtOverlaySecurityModel.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtModel.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtAltitudeBasedConfiguration.h>

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

#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlDcm.h>

#include <array>

namespace makVrv
{
   class DtDe;
   class DtSegmentedLineInterface;
   class DtTextProxyInterface;
   class DtCoordinateSystem;

   class DT_DLL_VRVCORE DtOverlaySecurityModel : public DtModel
   {
   public:
       enum class SecurityType
       {
             COVER
           , GUARD
           , SCREEN
       };

      DtOverlaySecurityModel(DtDe& de, DtUniqueID id);

      virtual ~DtOverlaySecurityModel();


      // @{
      virtual void setOrigin(const DtVector& position);
      virtual DtVector origin() const;
      // @}

      virtual void setOrientation(const DtTaitBryan& orientation);

      // @{
      virtual void setScale(float scale);
      virtual float scale() const;
      // @}

      // @{
      virtual void setVisible(bool isVisible);
      virtual bool isVisible() const;
      // @}

      // @{
      virtual void setStipplePattern(unsigned int stipplePattern);
      virtual unsigned int stipplePattern() const;
      // @}

      // @{
      virtual void setLineWidth(float);
      virtual float lineWidth() const;
      // @}

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

      // @{
      virtual void setEventsEnabled(bool enabled);
      virtual bool eventsEnabled() const;
      // @}

      // @{
      virtual void setGroup(int groupNum);
      virtual int group() const;
      // @}


      virtual void setSecurityType(DtOverlaySecurityModel::SecurityType type);
      virtual DtOverlaySecurityModel::SecurityType securityType() const;

      // @{
      virtual void setFontFile(std::string fontFile);
      virtual std::string fontFile() const;
      // @}

      // @{
      virtual void setFontPointSize(float pointSize);
      virtual float fontPointSize() const;
      // @}

      // @{
      virtual void setFontColor(float r, float g, float b, float a);
      virtual bool getFontColor(float& r, float& g, float& b, float& a) const;
      // @}

      
      // @name Inherited DtModel methods
      // @{

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

      virtual void setOrientation(int vtx, const DtTaitBryan& orientation) override;

      virtual void setModelDefinition(const std::string& str) override;

      // @}

   protected:

      struct Arrow;

      // @name Inherited DtModel methods
      // @{

      virtual void addToScene(const DtUniqueID& sceneObjectId,
         DtModelSetId modelSet, int visualizerType) override;

      virtual void removeFromScene() override;

      virtual void setIsSupportModel(bool isSupport) override;

      // @}

      virtual void needsUpdate();

      virtual void update();

      virtual void createSecurityModelIfNecessary();

      virtual void clearGeometry();

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

      virtual void updateColors();

      virtual void updateLineColor(DtSegmentedLineInterface* seg, float r, float g, float b, float a);

      virtual void updateLineWidth(DtSegmentedLineInterface* seg, float width);

      virtual void setEventsEnabledLine(DtSegmentedLineInterface* seg, bool b, unsigned long long userData);

      virtual void updateLineStipple(DtSegmentedLineInterface* seg, unsigned int stipple);

      virtual void updateArrow(Arrow* arrow, const DtVector& start, const DtVector& end, bool left, DtTextProxyInterface* label);

      virtual DtDcm calcOrientationDcm(const DtVector& startV, double angleMidPoint1);

      virtual void set3DPositionAuxDcm(DtDcm dcmOri, DtVector posOffset,
         double x, double y, double z, float packedCoords[4]);

      virtual void slot_coordinateSystemChanged();

      virtual void updateVertices();

      virtual void setDimensions(float x, float y);
      virtual bool getDimensions(float& x, float& y) const;

      virtual void forEachLine(const std::function<void(DtSegmentedLineInterface*)>& func);

      std::string securityTypeString(void) const;
   protected:
      std::array<DtVector, 4> myControlPoints;
      std::array<bool, 4> myControlPointsSet;
      
      bool myNeedsUpdate;

      boost::signalslib::connection mySignalPostUpdateConnection;

      DtModelSetId myModelSet;
      DtDcm myOrientationDcm;
      DtTaitBryan myOrientationTaitBryan;

      DtVector4<double> myColor;
      DtVector2<double> myDimensions;
      float myScale;

      float myLineWidth;
      bool myEventsEnabled;
      unsigned long long myUserData;

      bool myVisible;
      unsigned int myLineStipplePattern;
      int myGroup;

      int myOverlayId;

      struct Arrow
      {
      public:
         Arrow(DtDe& de, DtModelSetId modelSetId);
         virtual ~Arrow();
      public:
         DtSegmentedLineInterface* myPrimary = nullptr;
         DtSegmentedLineInterface* myAppendage = nullptr;
      };

      std::array<Arrow*, 2> myArrows;

      std::array<DtTextProxyInterface*, 2> myLabels;

      // An overall position
      DtVector myOrigin;

      SecurityType mySecurityType;

      int myNumberOfControlPoints;

      // local clone of the system wide coordinate system.
      // for thread safety.
      DtSignalConnectionManager myConnections;
      DtCoordinateSystem* myCoordinateSystem;

      std::string myFontFile;
      float myFontPointSize;
      DtVector4<float> myFontColor;

      DtAltitudeBasedConfigurationCollection myAltitudeBasedConfigurationCollection;
   private:

      DtOverlaySecurityModel() = delete;

      DtOverlaySecurityModel(const DtOverlaySecurityModel &) = delete;

      DtOverlaySecurityModel& operator=(const DtOverlaySecurityModel &) = delete;
   };
}