terrainGeometry.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2017 VT MAK
 * All rights reserved.
 ****************************************************************************/


#pragma once

#include <vrfExtProtocol/vrfExtProtocolDefines.h>
#include <vl/globalObjectDesignator.h>
#include <vlpi/entityIdentifier.h>
#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlString.h>
#include <matrix/vlVector.h>
#include <map>
#include <ostream>

enum DtTerrainAreaTypeEnum32
{
   DtTerrainAreaTypeOther = 0,
   DtTerrainAreaTypeCircle = 1,
   DtTerrainAreaTypeLine = 2,
   DtTerrainAreaTypePolygon = 3,
   DtTerrainAreaTypeCrater = 4,
   DtMaxDtTerrainAreaTypeEnum32
};

class DT_DLL_vrfExtProtocol DtTerrainGeometry
{
public:
   DtTerrainGeometry();

   virtual ~DtTerrainGeometry();

   DtTerrainGeometry(const DtTerrainGeometry& orig);

   DtTerrainGeometry& operator=(const DtTerrainGeometry& orig);

   bool operator==(const DtTerrainGeometry& other) const;
   bool operator!=(const DtTerrainGeometry& other) const;

   int netSize() const;

   virtual unsigned int getPaddingSize(DtU64 byteOffset, unsigned int boundary) const;

   void writeToBuffer( char* buffer ) const;
   void fillFromBuffer( const char* buffer, int bufferSize, int offset );


   template<class Variant>
   const Variant* variant() const
   {
      // Don't do an expensive dynamic cast unless we're pretty sure we have the right type here.
      if (Variant::theTerrainAreaType() == terrainAreaType())
      {
         return dynamic_cast<const Variant*>(this);
      }
      return 0;
   }

   template<class Variant>
   Variant* variant()
   {
      return const_cast<Variant*>(static_cast<const Variant*>(this));
   }



   virtual DtTerrainGeometry* clone() const = 0;

   virtual DtTerrainAreaTypeEnum32 terrainAreaType() const = 0;

   virtual bool approximatelyEqual(const DtTerrainGeometry& other, double tolerance = -1.0) const = 0;

   virtual int variantNetSize() const = 0;

   virtual int variantOctetBoundary() const = 0;

   virtual void writeVariantToBuffer( char* buffer ) const = 0;

   virtual void fillVariantFromBuffer( const char* buffer, int bufferSize, int offset ) = 0;


   virtual void printData() const;
   virtual void printDataToStream(std::ostream &) const;

   static DtTerrainAreaTypeEnum32 terrainAreaTypeFromBuffer(const char* buffer, int bufferSize, int offset);

   static int octetBoundary();

   static double defaultTolerance();

   static void setDefaultTolerance(double tolerance);

protected:

   static double theDefaultTolerance; // = 0.001

};

class DtTerrainGeometryVariantInfo
{
public:
   virtual ~DtTerrainGeometryVariantInfo() {};
   virtual DtTerrainAreaTypeEnum32 terrainAreaType() const = 0;
   virtual int variantOctetBoundary() const = 0;
   virtual DtTerrainGeometry* createVariant() const = 0;
   virtual DtTerrainGeometryVariantInfo* clone() const = 0;
};

template<class VariantType>
class DtTerrainGeometryVariantInfoTemplate : public DtTerrainGeometryVariantInfo
{
public:

   virtual DtTerrainAreaTypeEnum32 terrainAreaType() const override
   {
      return VariantType::theTerrainAreaType();
   }

   virtual int variantOctetBoundary() const override
   {
      return VariantType::theVariantOctetBoundary();
   }

   virtual DtTerrainGeometry* createVariant() const override
   {
      return new VariantType();
   }

   virtual DtTerrainGeometryVariantInfo* clone() const override
   {
      return new DtTerrainGeometryVariantInfoTemplate<VariantType>();
   }
};

class DT_DLL_vrfExtProtocol DtTerrainGeometryFactory
{
public:

   static void registerTerrainGeometryVariant(const DtTerrainGeometryVariantInfo& variantInfo);

   static void registerUnknownTerrainGeometryVariant(const DtTerrainGeometryVariantInfo& variantInfo);

   static DtTerrainGeometry* createTerrainGeometry(DtTerrainAreaTypeEnum32 terrainAreaType);

   static DtTerrainGeometry* createUnknownTerrainGeometry();

   static int octetBoundary(DtTerrainAreaTypeEnum32 terrainAreaType);

   static int  maximumOctetBoundary();

protected:

   static void registerDefaultTerrainGeometryVariants();

   static std::map<DtTerrainAreaTypeEnum32, DtTerrainGeometryVariantInfo*> theVariants;

   static DtTerrainGeometryVariantInfo* theUnknownVariant;

   static bool theFactoryIsInitialized;
};

DT_DLL_vrfExtProtocol std::ostream& operator<<(std::ostream& stream, const DtTerrainGeometry&);