terrainImplementation.h

Go to the documentation of this file.

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



#pragma once

#include "terrainInterface/terrainInterfaceDefines.h"
#include "terrainInterface/terrainIntersectOptions.h"
#include "terrainInterface/terrainInformation.h"
#include <geometry/intersectionRecord.h>
#include <geometry/chord.h>
#include <gdb/vectorNetworkRecord.h>
#include <gdb/vectorNetworkIntersectionRecord.h>
#include <vrfutil/vrfChordIntersectRecordList.h>
#include "tdbutil/stringKeyFactory.h"
#include "terrainInterface/terrainPagingGeometry.h"
#include "terrainInterface/terrainProcessPolygonsBox.h"
#include "features/feature.h"
#include "features/featureSet.h"
#include "features/featureContext.h"
#include "vrfutil/terrainInterfaceConfig.h"
#include <vlpi/appearance.h>

#include <string>
#include <boost/noncopyable.hpp>

class DtVrfChordIntersectionRecord;
class DtVrfChordIntersectRecordList;
class DtScenarioExplorer;
class DtString;
class Coordinate_System;
class DtConsoleCommandManager;
class DtTerrainCapabilities;
class DtTaitBryan;
class DtTerrainIntersectOptions;
class DtTerrainIntersectStatus;
class DtEntityType;

typedef void (*DtCacheProgressCallbackFunction)(int requestId, int current, bool completed, double elapsedTime, void* usr);

namespace makArchives
{
   class DtGenericTerrainRecord;
}

namespace MAKVRinTerra
{
   class DtProj;
}

namespace makVrv
{
   class DtDynamicTerrainGeometry;
   class DtDynamicTerrainChange;
   class DtDynamicTerrainFeature;
   class DtDynamicTerrainChanges;
}

class DT_DLL_terrainInterface DtDynamicTerrainRequestHandle
{
public:

   class RequestHandleImpl
   {
   public:
      RequestHandleImpl() {};
      virtual void removeTerrainChange() = 0;
      virtual void releaseOwnership() = 0;
   };

   DtDynamicTerrainRequestHandle();

   DtDynamicTerrainRequestHandle(const boost::shared_ptr<RequestHandleImpl>&);

   void removeTerrainChange();

   void releaseOwnership();

private:

   boost::shared_ptr<RequestHandleImpl> myImpl;
};

class DT_DLL_terrainInterface DtDynamicTerrainQueryHandle
{
public:

   class QueryHandleImpl
   {
   public:
      QueryHandleImpl() {};
      virtual void removeQuery() = 0;
      virtual void releaseOwnership() = 0;
   };

   DtDynamicTerrainQueryHandle();

   DtDynamicTerrainQueryHandle(const boost::shared_ptr<QueryHandleImpl>&);

   void removeQuery();

   void releaseOwnership();

private:

   boost::shared_ptr<QueryHandleImpl> myImpl;
};

typedef boost::function<void (const makVrv::DtDynamicTerrainFeature&)>
   DtDynamicTerrainQueryCallback;

class DT_DLL_terrainInterface DtTerrainGeometryHandle
{
public:
   virtual ~DtTerrainGeometryHandle();

   virtual bool isDisabled() const = 0;

   virtual void disable() = 0;

   virtual void setAppearance(DtAppearance app) = 0;

   virtual void setPosition(const DtPoint& location, const DtDcm& orientation) = 0;
};

class DT_DLL_terrainInterface DtTerrainImplementation
   : boost::noncopyable
{
public:
   DtTerrainImplementation(DtConsoleCommandManager* cmdManager);
   virtual ~DtTerrainImplementation();

   virtual MAKVRinTerra::DtFeatureDatabase& featureDatabase();
   virtual const MAKVRinTerra::DtFeatureDatabase& featureDatabase() const;

   virtual MAKVRinTerra::DtFeatureContext& featureContext();
   virtual const MAKVRinTerra::DtFeatureContext& featureContext() const;

   virtual void init();

   virtual void finishedLoading(const MAKVRinTerra::DtProj& proj);

   virtual bool loadTerrain(const makArchives::DtGenericTerrainRecord& rec) = 0;

   virtual void shutdown(bool block=true);

   virtual const Coordinate_System* coordinateSystem() const = 0;

   virtual double modelHeightDifferencesFromAppearances(int oldApp, int newApp) const;

   virtual bool createFromExtent(const Dt3dBoundingVolume&);

   virtual bool loadModel(const DtFilename&, const DtEntityType& t = DtEntityType());

   virtual DtTerrainInterfaceConfig& configurationOptions();
   virtual const DtTerrainInterfaceConfig& configurationOptions() const;

   virtual bool chordIntersect(
      DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectionRecord& record,
      const DtTerrainIntersectOptions& options) const = 0;

   virtual bool allIntersectsAlongChord(DtTerrainIntersectStatus& status,
      const DtChord& chord,
      DtVrfChordIntersectRecordList& intList,
      const DtTerrainIntersectOptions& options) const = 0;

   virtual void preloadTerrainAreas(
      const DtTerrainPagingGeometryList& preloadGeometry) {};

   virtual bool dataAvailable(
      const DtTerrainPagingGeometryList& geometry,
      DtTerrainIntersectOptions::Fidelity = DtTerrainIntersectOptions::MAX_FIDELITY) { return true; }

   virtual const DtTerrainCapabilities* terrainCapabilities() const = 0;

   virtual void setAssertOnBlockingTerrainCalls(bool assertBlock);
   virtual bool assertOnBlockingTerrainCalls() const;

   virtual void setWarnOnBlockingTerrainCalls(bool warnBlock);
   virtual bool warnOnBlockingTerrainCalls() const;

   virtual void setIntersectDataLoadExpireTime(const double& expireTime) {};

   virtual void expireDataLoadRequestsBeforeTime(const double& currentTime) {};

   virtual void processTrianglesInArea(DtTriangleOutputInterface&, const DtTerrainProcessPolygonsBox&) const = 0;

   virtual DtTerrainInformation* terrainInformation() { return NULL; };

   virtual void breakUpChords(const MAKVRinTerra::DtProj&, const DtChord& chord,
      std::vector<DtChord>& chords);

   virtual bool hasFeatureContext() const;

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtFilename& file) { return 0; }

   virtual DtTerrainGeometryHandle* createEntityGeometry(const DtEntityType& file) { return 0; }

   virtual void loadVisuals(const DtScenarioExplorer&) {};

   virtual DtDynamicTerrainRequestHandle addDynamicTerrainChangeRequest(
      double time,
      makVrv::DtDynamicTerrainChange* command) { return DtDynamicTerrainRequestHandle(); }

   typedef boost::function<void (const makVrv::DtDynamicTerrainFeature&)>
      DtDynamicTerrainQueryCallback;

   /*
   virtual DtDynamicTerrainRequestHandle addDynamicTerrainCraterRequest(
      double time,
      makVrv::DtDynamicTerrainChange* command,
      const std::map<DtString, DtString>& keyValueChanges,
      const DtVector& centerLocation,
      double radius) {
      return DtDynamicTerrainRequestHandle(); }
      */

   virtual DtDynamicTerrainQueryHandle queryDynamicTerrainFeatures(
      const DtDynamicTerrainQueryCallback& callback,
      makVrv::DtDynamicTerrainGeometry* geometry = 0,
      bool useOriginalGeometry = false) {
      return DtDynamicTerrainQueryHandle();
   };

   virtual void queryCurrentDynamicTerrainFeatures(
      const DtDynamicTerrainQueryCallback& callback,
      makVrv::DtDynamicTerrainGeometry* geometry = 0,
      bool useOriginalGeometry = false) { };

   virtual void cacheTerrainArea(int requestId,
      unsigned minLOD, unsigned maxLOD, const DtExtent& cacheArea,
      DtCacheProgressCallbackFunction fcn = 0, void* usr = 0);

   virtual void cancelCacheTerrainArea(int requestId);

   virtual void writeTerrainIndex(const DtString& name);

protected:
   DtTerrainInterfaceConfig myConfig;

   bool myAssertOnBlockingTerrainCalls;
   bool myWarnOnBlockingTerrainCalls;

   boost::scoped_ptr<MAKVRinTerra::DtFeatureDatabase> myFeatureDatabase;
   boost::scoped_ptr<MAKVRinTerra::DtFeatureContext> myFeatureContext;
};

typedef DtStringKeyFactoryWithParam<DtTerrainImplementation, 
   DtConsoleCommandManager*> DtTerrainImplementationFactory;
typedef DtTerrainImplementationFactory::DtCreatorFcn 
   DtTerrainImplementationCreatorFcn;