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/vrfObjectReference.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 <boost/shared_ptr.hpp>
#include <boost/optional.hpp>

class DtTerrainInterface;
class DtPhysicalWorld;
class DtVrfObject;
class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;
class DtSurface;
class Coordinate_System;

class DT_DLL_vrfobjcore DtAttachedTerrain : public DtReaderWriter
{
public:

   DtAttachedTerrain();

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

   DtAttachedTerrain(const DtSymbolString& name, 
      DtReaderWriterRegistry* const parentRegistry = 0, DtVrfObject* 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();

   virtual DtVrfObject* vrfObject() const;

   DtAttachedTerrain& operator=(const DtAttachedTerrain & orig);

   virtual const char* readerWriterType() const;

   static void objectAboutToBeRemovedCallback(const DtVrfObject * vrfObject, void * usr);
   virtual void processObjectAboutToBeRemovedCallback(const DtVrfObject * vrfObject);   

public:
   virtual const Coordinate_System* coordinateSystem() const;
   virtual Coordinate_System* coordinateSystem();

   virtual void tick();

   virtual bool isHighFidelityTerrain() const;

   virtual bool skipThisObject() const;

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

   void setFallThroughToPhysicalWorld(bool val);
   bool fallThroughToPhysicalWorld() 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;

protected:
   bool testInvariant() 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 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;

public:
   virtual bool entityIsValidAndAttached() const;

   virtual int appearanceFlags() const;

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

   void setEntity(const DtSharedVrfObjectReference);
   DtSharedVrfObjectReference entity();

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

   void clear();

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

protected:
   DtRwVrfObjectReference     myEntity;

   boost::shared_ptr<DtTerrainInterface>   myObjectGeometricModel;

   DtPhysicalWorld*           myPhysicalWorld;

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

   DtVrfObject* myVrfObject;
   DtRwBoolean myStayAttachedEvenIfOff;

   bool myFallThroughToPhysicalWorld;
   int myAttachedEntityAppearance;
   bool myAttachedEntityIsMobile;
   bool myScenarioIsRunning;
   bool myCheckMovingToNonMoving;
   bool myBVChanged;
   bool myInitialPlacement;
   bool myMadeInitialPlacement;
};