vrfObjectFacadeInterface.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>

#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtIntersector.h>

#include <boost/signal.hpp>
#include <matrix/vlVector.h>
#include <matrix/geodeticCoord.h>
#include <matrix/3dBoundingVolume.h>
#include <matrix/vlTaitBryan.h>
#include <string>
#include <vlpi/entityType.h>
#include <vrfutil/rwUUID.h>

class DtReferenceEllipsoid;

namespace makVrv
{
   class DtDe;
   class DtChannel;
   class DtWindow;
}

namespace makVrf
{
   enum DtAltitudeClampType
   {
      NoClamp = 0,
      AltitudeAboveSeaLevel = 1,
      AltitudeAboveTerrain = 2
   };

   class DtVrfObjectManipulationHandlerBaseClass;

   class DT_DLL_VRFGUICORE DtVrfObjectFacadeInterface
   {
   public:
      DtVrfObjectFacadeInterface( makVrv::DtDe& de, int modelSet = -1 );
      
      virtual ~DtVrfObjectFacadeInterface();

      virtual const std::string& entityId() const
      {
         return myEntityId;
      }

      virtual void setEntityId(const std::string& i)
      {
         myEntityId = i;
      }

      virtual void setTopographicOffsetBetweenPoints(const DtGeodeticCoord& origin, const DtGeodeticCoord& originWithOffset, bool resetLocation = true);
      virtual void setTopographicOffsetFromPrincipal(const DtVector&, bool resetLocation = true);
      const DtVector& topographicOffsetFromPrincipal() const;

      virtual DtVector convertGeodeticOffsetFromOriginToTopographicOffsetFromOrigin(const DtGeodeticCoord&) const;
      virtual DtGeodeticCoord locationFromTopographicOffsetFromCenterPoint(const DtGeodeticCoord& origin) const;
      virtual DtVector convertGeodeticOffsetToTopographicOffset(const DtGeodeticCoord& origin, const DtGeodeticCoord& position) const;
      
      virtual double headingOffsetFromPrincipal() const;
      virtual void setHeadingOffsetFromPrincipal( double offset );

      virtual const DtEntityType& entityType() const;
      
      virtual Dt3dBoundingVolume boundingVolume(int modelSet = 0) const;

      virtual DtGeodeticCoord modifyPointByTopographicOffset(const DtGeodeticCoord& origin, const DtVector& topographicOffset) const;
      virtual double altitudeOffsetFromPrincipal() const;
      virtual void setAltitudeOffsetFromPrincipal( double offset, bool resetLocation = true );
      
      virtual makVrv::DtUniqueID uniqueIDForModelSet(int set) const = 0;
      virtual makVrv::DtUniqueID uniqueID() const = 0;
      virtual std::vector<makVrv::DtUniqueID> modelUniqueIDs() const = 0;

      virtual void setOverrideIdsToIgnore(const std::vector<makVrv::DtUniqueID>& overrideIgnore);

      virtual const std::vector<makVrv::DtUniqueID>& idsToIgnore() const;

      virtual makVrv::DtUniqueID sceneObjectId() const;
      virtual void setSceneObjectId( const makVrv::DtUniqueID& id );
      
      virtual std::string displayName() const;
      virtual void setDisplayName( const std::string& displayName );
      
      virtual void setUUID(const DtUUID&);
      virtual const DtUUID& uuid() const;

      virtual DtGeodeticCoord currentGeodeticOrigin() const;

      virtual DtGeodeticCoord currentGeodeticPosition() const;

      virtual DtGeodeticCoord convertToGeodetic(const DtVector& v) const;
      
      virtual double currentHeading() const;
      virtual void setCurrentHeading( double currentHeading );
      virtual void setHeadingChanged(bool b);

      virtual void setSelected(bool);

      virtual void setAttachedTo(DtVrfObjectFacadeInterface*, const DtVector& offset, const DtTaitBryan& offsetOrientation);
      const DtVector& attachedPoint() const
      {
         return myAttachPoint;
      }

      const DtTaitBryan& attachedOrientation()
      {
         return myAttachOrientation;
      }

      DtVrfObjectFacadeInterface* attachedToObject() const
      {
         return myAttachedTo;
      }

      virtual bool attachedTo() const;
      virtual void detach();

      virtual std::string overlayName() const;

      virtual double currentAltitude() const;

      virtual DtVector centerOfMass() const;

      virtual DtVector geocentricLocation() const;
      virtual DtVector localLocation() const;
      virtual DtVector localLocation(const DtGeodeticCoord& geodLocation) const;

      virtual double initialAltitudeAboveTerrain() const;

      virtual DtVector reviseLocation(const DtVector& loc, int clampType = -1) const;
      
      virtual DtTaitBryan localOrientation() const;

      virtual void setExtendedData(const std::map<std::string, std::string>&)
      {
      }

      virtual void mergeExtendedData(const std::map<std::string, std::string>&)
      {
      }

      virtual std::map<std::string, std::string> extendedData() const
      {
         return std::map<std::string, std::string>();
      }
      virtual std::map<int, DtString> extendedLabels() const
      {
         return std::map<int, DtString>();
      }

      boost::signal<void (DtVrfObjectFacadeInterface*)> signal_visualized;
      boost::signal<void (DtVrfObjectFacadeInterface*)> signal_originChanged;

   public:
      
      virtual void setOrigin(const DtGeodeticCoord&);
      virtual void setOrigin(const DtVector&);

      virtual void setSymbolNameVisible(bool) = 0;

      virtual void setPickable(bool) = 0;
      virtual void setIndicatorVisible(bool) = 0;
      virtual void setWidgetEventsEnabled(bool) = 0;
      virtual void setHatLineVisible(bool) = 0;

      virtual void setVisible(bool, bool updateOffsets = true);
      virtual bool isVisible() const;

      virtual void setTopographicOrientation(const DtTaitBryan&) = 0;
      virtual void setLocalOrientation(const DtTaitBryan&) = 0;

      virtual void unrealizeFacades() = 0;

      virtual void realizeFacades() = 0;

      virtual bool hasNameChange() const
      {
         return myDisplayNameChanged;
      }

      virtual void clearLocationChange()
      {
         myLocationChanged = false;
      }

      virtual bool hasLocationChange() const
      {
         return myLocationChanged;
      }

      virtual bool hasAltitudeChange() const
      {
         return myAltitudeChanged;
      }

      virtual bool hasHeadingChange() const
      {
         return myHeadingChanged;
      }

      virtual void clearFlags();

      virtual void setAltitudeClampType(DtAltitudeClampType t);
      virtual DtAltitudeClampType altitudeClampType() const
      {
         return myAltitudeClampType;
      }

      virtual void setAltitudeAboveTerrain(double);
      virtual double altitudeAboveTerrain() const
      {
         return myAltitudeAboveGL;
      }

      virtual void setAltitudeAboveSeaLevel(double);
      virtual double altitudeAboveSeaLevel() const
      {
         return myAltitudeAboveSL;
      }

      virtual void setIsAnchor(bool);
      virtual bool isAnchor() const
      {
         return myAnchor;
      }

      virtual void setUserData(const std::string& userData);
      virtual std::string userData() const;
      bool userDataChanged() const
      {
         return myUserDataChanged;
      }

      int modelSet() const
      {
         return myModelSetOnly;
      }

      bool supportsModelSet(int i) const
      {
         return ((myModelSetOnly == -1) || (i == myModelSetOnly));
      }

      virtual makVrv::DtIntersector::IntersectProperties intersectorPickMask() const;

      virtual DtVector clampToLowestNonOceanPolygon( const DtVector& lp, makVrv::DtIntersector::IntersectProperties props ) const;
      virtual DtVector clampToGround( const DtVector& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, int clampType = -1 ) const;
      virtual DtGeodeticCoord clampToGround( const DtGeodeticCoord& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, int clampType = -1 ) const;

      virtual void setEmbarkationAllowed(bool);
      bool embarkationAllowed() const;

      virtual void setDoNotClamp(bool b)
      {
         if (b)
         {
            myAltitudeClampType = NoClamp;
         }
         else
         {
            myAltitudeClampType = AltitudeAboveTerrain;
         }
      }

      bool doNotClamp() const
      {
         return (myAltitudeClampType == NoClamp);
      }

      virtual void setClampToClosestPolygon(bool b)
      {
         myClampToClosestPolygon = b;
      }

      bool clampToClosestPolygon() const
      {
         return myClampToClosestPolygon;
      }

   protected:
      virtual void setCurrentGroundLocation( const DtGeodeticCoord& currentGroundLocation );

   protected:
      makVrv::DtDe& myDe;
      makVrv::DtUniqueID mySceneObjectId;
      std::string myDisplayName;
      std::string myEntityId;
      
      double myHeadingOffsetFromPrincipal;
      double myAltitudeOffsetFromPrincipal;
      
      DtGeodeticCoord myCurrentGroundLocation;   
      double myCurrentHeading;

      bool myDisplayNameChanged;
      bool myLocationChanged;
      bool myAltitudeChanged;
      bool myHeadingChanged;
      bool myUserDataChanged;

      mutable DtAltitudeClampType myAltitudeClampType;
      double         myAltitudeAboveSL;
      double         myAltitudeAboveGL;
      bool           myAnchor;
      std::string    myUserData;

      bool           myVisible;

      int myModelSetOnly;
      DtEntityType myEntityType;
      bool myClampToClosestPolygon;
      DtUUID myUUID;
      bool myEmbarkationAllowed;

      DtVrfObjectFacadeInterface* myAttachedTo;
      DtVector myAttachPoint;
      DtTaitBryan myAttachOrientation;

      mutable std::vector<makVrv::DtElementID> myUnifiedIgnoreList;
      mutable std::set<makVrv::DtUniqueID> myDIGuyIdsIgnored;
      mutable std::vector<makVrv::DtUniqueID> myModelIds;

      std::vector<makVrv::DtUniqueID> myOverrideIdsToIgnore;

      DtVector myTopographicOffsetFromPrincipal;
   };
}