terrainGeometry.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2016 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************/
 
#pragma once
 
#include <vrfExtObjects/vrfExtObjectsDefines.h>

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

enum DtTerrainAreaTypeEnum32
{
   DtTerrainAreaTypeOther = 0,
   DtTerrainAreaTypeCircle = 1,
   DtTerrainAreaTypeLine = 2,
   DtTerrainAreaTypePolygon = 3,
   DtMaxDtTerrainAreaTypeEnum32
};
 
 
class DT_DLL_vrfExtObjects DtTerrainGeometry
{
public:
   DtTerrainGeometry();
 
   ~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 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
   {
      return VariantType::theTerrainAreaType();
   }

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

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

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

class DT_DLL_vrfExtObjects 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_vrfExtObjects std::ostream& operator<<(std::ostream& stream, const DtTerrainGeometry&);