attachedTerrain.h

Go to the documentation of this file.

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



#pragma once


#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/platformSimObjectFacade.h"
#include "vrfobjcore/simObject.h"
#include <readerWriter/rwInt.h>
#include <readerWriter/rwString.h>
#include <readerWriter/rwBoolean.h>
#include <readerWriter/readerWriter.h>
#include <matrix/vlDcm.h>
#include <geometry/intersectionRecord.h>
#include <geometry/point.h>
#include <geometry/chord.h>
#include <matrix/topoCoord.h>
#include <matrix/geodeticCoord.h>
#include <matrix/coordTransform.h>
#include <matrix/3dBoundingVolume.h>
#include <tbb/spin_rw_mutex.h>
#include <vrfobjcore/rwSimObjectReference.h>

#include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>

class DtTerrainInterface;
class DtPhysicalWorld;
class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;
class DtSurface;
class Coordinate_System;
class DtSimObject;
class DtSimulationServices;

class DT_DLL_vrfobjcore DtAttachedTerrain : public DtReaderWriter
{
private:
   DtAttachedTerrain();

public:

   DtAttachedTerrain(const DtSimulationServices*, const DtString& name, 
      DtReaderWriterRegistry* const parentRegistry = 0, const DtSimObject* owner = 0);

   DtAttachedTerrain(const DtSimulationServices*, const DtSymbolString& name, 
      DtReaderWriterRegistry* const parentRegistry = 0, const DtSimObject* owner = 0);

   DtAttachedTerrain(const DtString& name, const DtAttachedTerrain& orig, 
                      DtReaderWriterRegistry* const parentRegistry = 0);

   DtAttachedTerrain(const DtSymbolString& name, const DtAttachedTerrain& 
      from, DtReaderWriterRegistry* const parentRegistry = 0);

   virtual ~DtAttachedTerrain();

   DtAttachedTerrain& operator=(const DtAttachedTerrain & orig);

   virtual const char* readerWriterType() const;


public:
   virtual const Coordinate_System* coordinateSystem() const;

   const DtSimObject* vrfObject() const;

   virtual void tick();

   virtual bool isHighFidelityTerrain() const;

   virtual bool skipThisObject() const;

   virtual void setStayAttachedEvenIfOff(bool);
   virtual bool stayAttachedEvenIfOff() const;


   void setIntersectsFallThroughToParent(bool val);
   bool intersectsFallThroughToParent() const;

   virtual double terrainHeight(const DtVector& localLocation, 
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;
   virtual bool terrainHeight(const DtVector& localLocation, 
      double& terrainHeight, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual bool terrainHeightAndSurface(double lat, double lon, 
      double& terrainHeight, DtSurface& surface, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;

   virtual bool terrainHeightAndSurface(const DtVector& localLocation, 
      double& terrainHeight, DtSurface& surface, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;


   virtual bool closestIntersection(const DtVector& localLocation, 
      DtPoint& intersectionPoint, 
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(const DtVector& localLocation, 
      DtVector& intersectionPoint,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(const DtVector& localLocation, 
      DtVrfChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   virtual bool intersect(const DtChord& chord, DtPoint& intersectionPoint, 
      double& intersectionTime,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;
    
   virtual bool intersect(const DtChord& chord, 
      DtVrfChordIntersectionRecord& record,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA,
      bool* dataAvailable = 0, bool overrideBlockingAssert = false) const;

   virtual bool closestIntersection(const DtVector& curPosition, 
      DtVector& intersection, bool ignoreWater, bool* dataAvailable = 0,
      bool overrideBlockingAssert = false) const;

   virtual bool allIntersectsAlongChord(const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      DtIntersectionRecord::DtIntersectionType irtFlag = 
      DtIntersectionRecord::INT_ALL_DATA, bool* dataAvailable = 0, 
      bool overrideBlockingAssert = false) const;

   virtual void embedInTerrainIfNeeded();

protected:
   virtual bool attachedEntityIsMobile() const;

   virtual void updateCoordTransforms();

   virtual void updateBoundingVolume();

   virtual DtVector convertLocalPointToModelPoint(const DtVector& source) const;

   virtual DtChord convertLocalChordToModelChord(const DtChord& source) const;

   virtual DtVector convertModelPointToDatabasePoint(const DtPoint&) const;

   virtual void convertModelPointToDatabasePoint(DtVrfChordIntersectionRecord&) const;
   virtual void processObjectAboutToBeRemovedCallback(const DtSimObject*);   

   virtual unsigned intersectChordWithBoundingVolume(const DtChord& chord,
      DtVrfChordIntersectionRecord* isect1 = 0,
      DtVrfChordIntersectionRecord* isect2 = 0) const;

   virtual unsigned intersectChordWithBoundingVolume(const DtChord& chord, bool calculateNormal,
      DtVrfChordIntersectionRecord* isect1 = 0,
      DtVrfChordIntersectionRecord* isect2 = 0) const;

   virtual bool boundingVolumeAltitude(const DtVector& p, double& alt) const;

   virtual void closestPointToBoundingVolume(const DtPoint& p, DtVrfChordIntersectionRecord& out) const;

   virtual void postGetSelf();

public:
   virtual bool entityIsValidAndAttached() const;

   virtual int appearanceFlags() const;

   void setObjectGeometricModel(boost::shared_ptr<DtTerrainInterface> newObjGeomModel);
   boost::shared_ptr<DtTerrainInterface> objectGeometricModel() const;

   void setEntity(DtSimObjectReference);
   DtSimObjectReference entity() const;

   void setPhysicalWorld(const DtPhysicalWorld* newPhysicalWorld);
   const DtPhysicalWorld* physicalWorld() const;

   void clear();

   virtual DtAttachedTerrain* clone(const DtString& name, DtReaderWriterRegistry* const parentRegistry = 0) const;

protected:
   friend class DtLocalObject;
   virtual void setEmbarkedOn(const DtUUID&);

protected:
   DtRwSimObjectReference     myEntity;
   DtPlatformSimObjectFacade   myPlatformSimObjectFacade;
   boost::shared_ptr<DtTerrainInterface>   myObjectGeometricModel;

   const DtPhysicalWorld*           myPhysicalWorld;

   DtCoordTransform   myGeocentricToTopographic;
   DtCoordTransform   myTopographicToGeocentric;
   DtCoordTransform   myModelNormalToLocalNormal;
   DtDcm myLastWorldOrientationMatrix;
   DtDcm myLastLocalOrientationMatrix;
   DtVector myLastWorldPosition;
   DtVector myLastLocalPosition;
   boost::optional<Dt3dBoundingVolume> myLastLocalBoundingVolume;

   const DtSimObject* mySimObject;
   DtRwBoolean myStayAttachedEvenIfOff;

   bool myIntersectsFallThroughToParent;
   int myAttachedEntityAppearance;
   bool myAttachedEntityIsMobile;
   bool myScenarioIsRunning;
   bool myCheckMovingToNonMoving;
   bool myBVChanged;
   bool myInitialPlacement;
   bool myMadeInitialPlacement;

   const DtSimulationServices* mySimulationServices;

   boost::signals2::scoped_connection mySimObjectDeletedConnection;

   mutable tbb::spin_rw_mutex myStayAttachedEvenIfOffMutex;

   DtUUID myEmbarkedOn;
   bool myIsMoveable;
};