taskVisualizationStateComponent.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/vrfStateDataDefines.h"
#include "vrfStateData/doubleBufferedDataStorage.h"
#include "vrfStateData/stateComponent.h"
#include "vrfStateData/taskVisualizationForwards.h"
#include "vlpi/entityIdentifier.h"
#include <vrfutil/rwUUID.h>

namespace makVrf
{
   struct DT_DLL_vrfStateData DtTaskVisualizationStateComponentData
   {
      enum VisualizationType
      {
         Unknown = 0,
         Line,
         Point,
         Area,
         Text
      };

      struct LineVertex
      {
      public:
         LineVertex() : attachedObject(DtUUID::nullUUID()) {};

         DtVector location;

         DtUUID attachedObject;

         bool operator==(const LineVertex& rhs) const
         {
            return (location == rhs.location && attachedObject == rhs.attachedObject);
         }
      };

      DtTaskVisualizationStateComponentData()
      : myVisualizationType(Unknown)
      , myRed(0)
      , myGreen(0)
      , myBlue(0)
      , myAlpha(255)
      , mySize(1)
      , myArrowAtStart(false)
      , myArrowAtEnd(false)
      , myIsSizeLimited(false)
      , myProjected(false)
      , myActive(false)
      , myUseDrawControlForTaskVisualizations(false)
      , myAttachedObject(DtUUID::nullUUID())
      , myHostId(DtUUID::nullUUID())
      , myNeedsPointVerticesUpdate(false)
      {
      }

      DtTaskVisualizationStateComponentData(const DtTaskVisualizationStateComponentData& orig)
      : myComponentName(orig.myComponentName)
      , myVisualizationName(orig.myVisualizationName)
      , myVisualizationType(orig.myVisualizationType)
      , myRed(orig.myRed)
      , myGreen(orig.myGreen)
      , myBlue(orig.myBlue)
      , myAlpha(orig.myAlpha)
      , myLocationOffset(orig.myLocationOffset)
      , myLocation(orig.myLocation)
      , mySize(orig.mySize)
      , myAttachedObject(orig.myAttachedObject)
      , myArrowAtStart(orig.myArrowAtStart)
      , myArrowAtEnd(orig.myArrowAtEnd)
      , myIsSizeLimited(orig.myIsSizeLimited)
      , myProjected(orig.myProjected)
      , myLineVertices(orig.myLineVertices)
      , myText(orig.myText)
      , myActive(orig.myActive)
      , myUseDrawControlForTaskVisualizations(orig.myUseDrawControlForTaskVisualizations)
      , myHostId(orig.myHostId)
      , myEntityId(orig.myEntityId)
      , myPointVertices(orig.myPointVertices)
      , myNeedsPointVerticesUpdate(orig.myNeedsPointVerticesUpdate)
      {
         if (myNeedsPointVerticesUpdate)
         {
            pointVertices();
         }
      }

      DtTaskVisualizationStateComponentData& operator=(const DtTaskVisualizationStateComponentData& rhs)
      {
         myComponentName = rhs.myComponentName;
         myVisualizationName = rhs.myVisualizationName;
         myVisualizationType = rhs.myVisualizationType;
         myRed = rhs.myRed;
         myGreen = rhs.myGreen;
         myBlue = rhs.myBlue;
         myAlpha = rhs.myAlpha;
         myLocationOffset = rhs.myLocationOffset;
         mySize = rhs.mySize;
         myLocation = rhs.myLocation;
         myAttachedObject = rhs.myAttachedObject;
         myArrowAtStart = rhs.myArrowAtStart;
         myArrowAtEnd = rhs.myArrowAtEnd;
         myIsSizeLimited = rhs.myIsSizeLimited;
         myProjected = rhs.myProjected;
         myLineVertices = rhs.myLineVertices;
         myText = rhs.myText;
         myActive = rhs.myActive;
         myUseDrawControlForTaskVisualizations = rhs.myUseDrawControlForTaskVisualizations;
         myHostId = rhs.myHostId;
         myEntityId = rhs.myEntityId;
         myPointVertices = rhs.myPointVertices;
         myNeedsPointVerticesUpdate = rhs.myNeedsPointVerticesUpdate;

         if (myNeedsPointVerticesUpdate)
         {
            pointVertices();
         }

         return *this;
      }

      DEFINE_ACCESSOR_MUTATOR(DtTaskVisualizationStateComponentData::VisualizationType, visualizationType, VisualizationType)
      DEFINE_ACCESSOR_MUTATOR(DtString, componentName, ComponentName)
      DEFINE_ACCESSOR_MUTATOR(DtString, visualizationName, VisualizationName)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, attachedObject, AttachedObject)
      DEFINE_ACCESSOR_MUTATOR(DtString, text, Text)
      DEFINE_ACCESSOR_MUTATOR(DtUUID, hostId, HostId)
      DEFINE_ACCESSOR_MUTATOR(DtEntityIdentifier, entityId, EntityId)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, red, Red)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, green, Green)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, blue, Blue)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, alpha, Alpha)
      DEFINE_ACCESSOR_MUTATOR(unsigned int, size, Size)
      DEFINE_ACCESSOR_MUTATOR(DtVector, locationOffset, LocationOffset)
      DEFINE_ACCESSOR_MUTATOR(DtVector, location, Location)
      DEFINE_REF_ACCESSORS(std::vector<LineVertex>, lineVertices, LineVertices)
      DEFINE_ACCESSOR_MUTATOR(bool, arrowAtStart, ArrowAtStart)
      DEFINE_ACCESSOR_MUTATOR(bool, arrowAtEnd, ArrowAtEnd)
      DEFINE_ACCESSOR_MUTATOR(bool, projected, Projected)
      DEFINE_ACCESSOR_MUTATOR(bool, isSizeLimited, IsSizeLimited)
      DEFINE_ACCESSOR_MUTATOR(bool, active, Active)
      DEFINE_ACCESSOR_MUTATOR(bool, useDrawControlForTaskVisualizations, UseDrawControlForTaskVisualizations)

      const std::vector<DtVector>& pointVertices() const
      {
         if (myNeedsPointVerticesUpdate)
         {
            myPointVertices.resize(myLineVertices.size());

            std::vector<LineVertex>::const_iterator iter = myLineVertices.begin();
            std::vector<LineVertex>::const_iterator end = myLineVertices.end();
            std::vector<DtVector>::iterator ptIter = myPointVertices.begin();
            while (iter != end)
            {
               (*ptIter) = iter->location;
               ++iter;
               ++ptIter;
            }

            myNeedsPointVerticesUpdate = false;
         }

         return myPointVertices;
      }

      void setVertices(const std::vector<LineVertex>& v) { myLineVertices = v; myNeedsPointVerticesUpdate = true;};
      void setVertices(const std::vector<DtVector>& v)
      {
         myLineVertices.resize(v.size());
         int i, iLimit = v.size();
         for (i = 0; i < iLimit; i++)
         {
            myLineVertices[i].location = v[i];
         }

         myPointVertices = v;
      }

      void setVertices(const std::vector<DtUUID>& v)
      {
         myLineVertices.resize(v.size());
         int i, iLimit = v.size();
         for (i = 0; i < iLimit; i++)
         {
            myLineVertices[i].attachedObject = v[i];
         }

         myNeedsPointVerticesUpdate = true;
      }

      void setVertex(int i, const DtVector& v)
      {
         if (i >= myLineVertices.size())
         {
            myLineVertices.resize(i+1);
            myPointVertices.resize(i + 1);
         }

         myPointVertices[i] = v;
         myLineVertices[i].location = v;
      }

      void setVertex(int i, const DtUUID& v)
      {
         if (i >= myLineVertices.size())
         {
            myLineVertices.resize(i+1);
            myPointVertices.resize(i + 1);
         }

         myLineVertices[i].attachedObject = v;
      }

      const std::vector<LineVertex>& linVertices() const { return myLineVertices; };

   protected:
      DtString myComponentName;
      DtString myVisualizationName;
      DtEntityIdentifier myEntityId;
      DtUUID myHostId;
      DtTaskVisualizationStateComponentData::VisualizationType myVisualizationType;
      unsigned int myRed;
      unsigned int myGreen;
      unsigned int myBlue;
      unsigned int myAlpha;
      bool myActive;
      bool myUseDrawControlForTaskVisualizations;

      DtVector myLocationOffset;
      mutable std::vector<DtVector> myPointVertices;

      unsigned int mySize;
      DtVector myLocation;
      DtUUID myAttachedObject;

      std::vector<LineVertex> myLineVertices;
      bool myArrowAtEnd;
      bool myArrowAtStart;
      bool myProjected;
      bool myIsSizeLimited;
      mutable bool myNeedsPointVerticesUpdate;

      DtString myText;
   };

   class DT_DLL_vrfStateData DtTaskVisualizationStateComponent : public DtFrameStateInterface
   {
   public:
      DEFINE_STATE_COMPONENT_TYPE(DtStateComponent::TaskVisualizationStateComponent)

      DtTaskVisualizationStateComponent(DtStateData* storage)
      : DtFrameStateInterface(storage)
      {
      }

      UNDEFINED_RETURNREF_ACCESSOR(DtTaskVisualizationStateComponentData::VisualizationType, visualizationType)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, componentName, ComponentName)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, visualizationName, VisualizationName)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, attachedObject, AttachedObject)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtString, text, Text)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, red, Red)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, green, Green)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, blue, Blu)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(unsigned int, alpha, Alpha)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, size, Size)
      UNDEFINED_RETURNVALUE_ACCESSOR_MUTATOR(unsigned int, thickness, Thickness)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, locationOffset, LocationOffset)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtVector, location, Location)
      UNDEFINED_RETURNREF_ACCESSORS(std::vector<DtTaskVisualizationStateComponentData::LineVertex>, vertices)
      UNDEFINED_RETURNVALUE_ACCESSOR(unsigned int, numberOfVertices)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, arrowAtStart, ArrowAtStart)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, arrowAtEnd, ArrowAtEnd)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, projected, Projected)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, isSizeLimited, IsSizeLimited)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, active, Active)
      UNDEFINED_METHOD(void, setVertices, const std::vector<DtTaskVisualizationStateComponentData::LineVertex>&)
      UNDEFINED_METHOD(void, setVertices, const std::vector<DtVector>&)
      UNDEFINED_METHOD(void, setVertices, const std::vector<DtUUID>&)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(bool, useDrawControlForTaskVisualizations, UseDrawControlForTaskVisualizations)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtUUID, hostId, HostId)
      UNDEFINED_RETURNREF_ACCESSOR_MUTATOR(DtEntityIdentifier, entityId, EntityId)

      virtual const std::vector<DtVector>& pointVertices() const { throw DtUnimplementedMethod("void pointVertices() is unimplemented by this class."); };
      virtual void setColor(unsigned int r, unsigned int g, unsigned int b, unsigned int a) { throw DtUnimplementedMethod("setColor(r, g, b, a) is unimplemented by this class."); };
      virtual void setVertex(unsigned int i, const DtVector&) { throw DtUnimplementedMethod("void setVertex(unsigned int i, const DtVector&) is unimplemented by this class."); };
      virtual void setVertex(unsigned int i, const DtUUID&) { throw DtUnimplementedMethod("void setVertex(unsigned int i, const DtUUID&) is unimplemented by this class."); };
      virtual void setupAsLineTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName)
         { throw DtUnimplementedMethod("void setupAsLineTaskVisualization is unimplemented by this class."); };
      virtual void setupAsAreaTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName)
         { throw DtUnimplementedMethod("void setupAsLineTaskVisualization is unimplemented by this class."); };
      virtual void setupAsTextTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName)
         { throw DtUnimplementedMethod("void setupAsLineTaskVisualization is unimplemented by this class."); };
      virtual void setupAsPointTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName)
         { throw DtUnimplementedMethod("void setupAsLineTaskVisualization is unimplemented by this class."); };
   };

   class DT_DLL_vrfStateData DtTaskVisualizationStateComponentNextFrame : public DtTaskVisualizationStateComponent
   {
   public:
      DtTaskVisualizationStateComponentNextFrame(DtStateData* storage);

      const DtTaskVisualizationStateComponentData& frameState() const { return myData; };
      DtTaskVisualizationStateComponentData& frameState() { return myData; };

      const DtTaskVisualizationStateComponentData::VisualizationType& visualizationType() const;

      const std::vector<DtTaskVisualizationStateComponentData::LineVertex>& vertices() const;
      std::vector<DtTaskVisualizationStateComponentData::LineVertex>& vertices();

      const unsigned int numberOfVertices() const;

      void setComponentName(const DtString&);
      const DtString& componentName() const;

      void setVisualizationName(const DtString&);
      const DtString& visualizationName() const;

      void setAttachedObject(const DtUUID&);
      const DtUUID& attachedObject() const;

      void setText(const DtString&);
      const DtString& text() const;

      void setRed(const unsigned int&);
      const unsigned int& red() const;

      void setGreen(const unsigned int&);
      const unsigned int& green() const;

      void setBlue(const unsigned int&);
      const unsigned int& blue() const;

      void setAlpha(const unsigned int&);
      const unsigned int& alpha() const;

      void setSize(const unsigned int&);
      const unsigned int size() const;

      void setThickness(const unsigned int& i) { setSize(i); };
      const unsigned int thickness() const { return size(); };

      void setLocationOffset(const DtVector&);
      const DtVector& locationOffset() const;

      void setLocation(const DtVector&);
      const DtVector& location() const;

      void setArrowAtStart(const bool&);
      const bool& arrowAtStart() const;

      void setArrowAtEnd(const bool&);
      const bool& arrowAtEnd() const;

      void setIsSizeLimited(const bool&);
      const bool& isSizeLimited() const;

      void setProjected(const bool&);
      const bool& projected() const;

      void setActive(const bool&);
      const bool& active() const;

      void setUseDrawControlForTaskVisualizations(const bool&);
      const bool& useDrawControlForTaskVisualizations() const;

      virtual void setColor(unsigned int r, unsigned int g, unsigned int b, unsigned int a);
      virtual void setVertices(const std::vector<DtTaskVisualizationStateComponentData::LineVertex>&);
      virtual void setVertices(const std::vector<DtVector>&);
      virtual void setVertices(const std::vector<DtUUID>&);
      virtual void setVertex(unsigned int i, const DtVector&);
      virtual void setVertex(unsigned int i, const DtUUID&);

      const DtUUID& hostId() const;
      void setHostId(const DtUUID&);

      const DtEntityIdentifier& entityId() const;
      void setEntityId(const DtEntityIdentifier&);

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

      virtual void makeWritable() {};

      virtual void makeReadOnly() {};

      void setupAsLineTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName);
      void setupAsTextTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName);
      void setupAsAreaTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName);
      void setupAsPointTaskVisualization(const DtEntityIdentifier& entityIdentifier, const DtString& visualizationName, const DtString& componentName);

   protected:
      friend class DtTaskVisualizationStateComponentImplementation;
      void setVisualizationType(DtTaskVisualizationStateComponentData::VisualizationType);

   protected:
      DtTaskVisualizationStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtTaskVisualizationStateComponentCurrentFrame : public DtTaskVisualizationStateComponent
   {
   public:
      DtTaskVisualizationStateComponentCurrentFrame(DtStateData* storage);

      const DtTaskVisualizationStateComponentData& frameState() const { return myData; };

      const DtTaskVisualizationStateComponentData::VisualizationType& visualizationType() const;

      const DtString& componentName() const;
      const DtString& visualizationName() const;
      const DtUUID& attachedObject() const;
      const DtString& text() const;

      const unsigned int& red() const;
      const unsigned int& green() const;
      const unsigned int& blue() const;
      const unsigned int& alpha() const;
      const unsigned int size() const;
      const unsigned int thickness() const
      {
         return size();
      }

      const DtVector& locationOffset() const;
      const DtVector& location() const;
      const std::vector<DtTaskVisualizationStateComponentData::LineVertex>& vertices() const;
      const unsigned int numberOfVertices() const;

      const bool& arrowAtStart() const;
      const bool& arrowAtEnd() const;
      const bool& isSizeLimited() const;
      const bool& projected() const;
      const bool& active() const;
      const bool& useDrawControlForTaskVisualizations() const;
      const DtUUID& hostId() const;
      const DtEntityIdentifier& entityId() const;
      virtual const std::vector<DtVector>& pointVertices() const;

   protected:
      friend class DtTaskVisualizationStateComponentImplementation;
      void advanceFrame(const DtTaskVisualizationStateComponentData& d)
      {
         myData = d;
      }

   protected:
      DtTaskVisualizationStateComponentData myData;
   };

   class DT_DLL_vrfStateData DtTaskVisualizationStateComponentImplementation : public DtDoubleBufferedStateComponent<DtTaskVisualizationStateComponent>
   {
   public:
      DtTaskVisualizationStateComponentImplementation(DtStateData* sd);

      bool isDoubleBuffered() { return true; };
      const DtFrameStateInterface* currentFrameState() const { return &myCurrentFrameState; }
      virtual DtFrameStateInterface* nextFrameState() { return &myNextFrameState; };
      virtual const DtFrameStateInterface* nextFrameState() const { return &myNextFrameState; };

      void updateDataStorage()
      {
         if (myNextFrameState.isWritable())
         {
            myCurrentFrameState.advanceFrame(myNextFrameState.frameState());
         }

         myCurrentFrameState.emitComponentUpdated();
      }

      void updateStateData(DtStateData* sd)
      {
         myCurrentFrameState.updateStateData(sd);
         myNextFrameState.updateStateData(sd);
      }

      static void setMaximumLineSegements(unsigned max);
      static unsigned maximumLineSegments();

      DtTaskVisualizationStateComponent* lineTaskVisualization(const DtString& v, const DtString& c);
      DtTaskVisualizationStateComponent* areaTaskVisualization(const DtString& v, const DtString& c);
      DtTaskVisualizationStateComponent* pointTaskVisualization(const DtString& v, const DtString& c);
      DtTaskVisualizationStateComponent* textTaskVisualization(const DtString& v, const DtString& c);

      virtual void aboutToBeDeleted() override
      {
         DtDoubleBufferedStateComponent<DtTaskVisualizationStateComponent>::aboutToBeDeleted();
         myCurrentFrameState.aboutToBeDeleted();
         myNextFrameState.aboutToBeDeleted();
      }

   protected:
      DtTaskVisualizationStateComponentCurrentFrame myCurrentFrameState;
      DtTaskVisualizationStateComponentNextFrame myNextFrameState;
      static int theMaximumLineSegments;
   };

   typedef DtStateComponentCreator<DtTaskVisualizationStateComponentImplementation> DtTaskVisualizationStateComponentCreator;
}