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 const DtGeodeticCoord& locationOffsetFromPrincipal() const;
      virtual void setLocationOffsetFromPrincipal( const DtGeodeticCoord& offset, bool resetLocation = true );
      
      virtual double headingOffsetFromPrincipal() const;
      virtual void setHeadingOffsetFromPrincipal( double offset );

      virtual const DtEntityType& entityType() const;
      
      virtual Dt3dBoundingVolume boundingVolume() const;

      virtual double altitudeOffsetFromPrincipal() const;
      virtual void setAltitudeOffsetFromPrincipal( double offset, bool resetLocation = true );
      
      virtual makVrv::DtUniqueID uniqueID() const = 0;
      virtual std::vector<makVrv::DtUniqueID> modelUniqueIDs() const = 0;

      virtual 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);
      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) 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;

   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);
      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 clampToGround( const DtVector& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes ) const;
      virtual DtGeodeticCoord clampToGround( const DtGeodeticCoord& localPosition, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes ) const;

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

      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;
      
      DtGeodeticCoord myLocationOffsetFromPrincipal; 
      double myHeadingOffsetFromPrincipal;
      double myAltitudeOffsetFromPrincipal;
      
      DtGeodeticCoord myCurrentGroundLocation;   
      double myCurrentHeading;

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

      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;
   };
}