mgwrapper.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2011 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include "mgwrapper/mgwrapperDefines.h"
#include "flt/mgWrapperInterface.h"
#include "flt/fltTerrainInit.h"
#include "flt/tdbflt.h"
#include "geometry/gdbColor.h"
#include "geometry/point.h"
#include <string>
#include "vlutil/vlString.h"
#include "gdb/group.h"

struct mgrec;

class DT_DLL_mgwrapper DtMgWrapper : public DtMgWrapperInterface
{
public:
   DtMgWrapper();
   virtual ~DtMgWrapper();
   virtual bool readDfdFile(DtFilename filename, DtDfadData &data) const;
   // Given an OpenFlight filename, this returns the "translated" file.
   virtual DtGdbNode* xlateOpenFlightFile(const DtFilename& filename);

   static void initMGAPI();
   static void exitMGAPI();

   virtual void setUseFltPath(const DtString&);
   virtual const DtString& useFltPath() const;

protected:

   typedef enum
   {
      FlatEarth = 0,    // = 0
      Trapezoidal,      // = 1
      RoundEarth,       // = 2
      Lambert,          // = 3
      UTM,              // = 4
      Geocentric,       // = 5
      Geodetic          // = 6
   } DtFltProjectionType;

   typedef enum
   {
      Meters = 0,
      Kilometers = 1,
      Feet = 4,
      Inches = 5,
      NauticalMiles = 8
   } DtFltVertexCoordinateUnits;

   typedef enum
   {
      // The OpenFlight 15.8 docs claim that user defined is supposed to be 5,
      // but I just confirmed with their tech support that it is actually -1.
      UserDefinedEllipsoid = -1,
      WGS_1984 = 0,
      WGS_1972,
      Bessel,
      Clark,
      NAD_1927
   } DtFltEarthEllipsoidModel;

   // This routine will take a flt load path and translate it into a tree that 
   // can be referenced when loading flt nodes.  Any node that does not appear 
   // in the tree will not be loaded.  The results are placed into the myFltPath 
   // member
   virtual void parseFltPathIntoPathTree(const std::string& fltPath, 
      DtFltPathMap* fltPathMap);


   // The reason we index by name instead of pattern# is that I THINK
   // different externally-referenced databases may have different pattern#s
   // (palette indices) for a given texture, but are unlikely to use
   // different names.
   //
   bool rememberColorFromTextureName(const DtFilename& name, DtColor& color);

   // Book-keeping for already opened and translated databases.
   //   DtGdbNode* lookupAlreadyTranslatedDatabase(const DtFilename& filename,
   //      double lodDistance);

   //   void addTranslatedDatabase(const DtFilename& fname, DtGdbNode* n,
   //      double lodDistance);

   bool computeColorFromTexture(mgrec* mgdb, int texturePatternNumber,
      DtColor& color);
   bool computeAndRememberColorFromTexture(mgrec* mgdb,
      const DtFilename& tex_name, int texture_pattern_number, DtColor& color);
   FlightTextureNameToColorListItem* lookupAlreadyAveragedColor(const DtFilename&);

   // Performs color-averaging of texture, and sets color appropriately.
   bool setColorFromTexture(mgrec* mgdb, int texturePatternNumber, DtColor& color);

   // If you're using a TM projection that's not UTM and you made your
   // flight file with Creator, then you'll need this function;
   // Converts your garden variety UTM coord into an exotic coord as specified
   // by the mapdatum and projection scale you defined in you flight map file.
   void changeFromUTMToUserDefinedProjection(const DtPoint &v0, DtPoint &result);

   // Returns true if the node passes the path check (it has no children, 
   // there is no path, or it is in the path).  Pass in iterator if want to 
   // receive children of that node
   virtual bool passPathCheck(mgrec* node, const DtFltPathMap& fltPathMap, 
      DtFltPathMap::const_iterator* iter = 0);

   // Converts from source units to meters.  Supported types are inches, ft, km and nmi
   virtual void convertFromSourceToMeters(const DtPoint& in, DtPoint& out);

   // General entry point to process any primitive present in a mesh node
   // \return A boolean indicating whether or not the primitive could be processed.
   bool processPrimitive(mgrec* mgmesh, DtGroup* parentGroup, unsigned int ithPrimitive);

   // Processes a triangle strip primitive, which is typically present in mesh nodes
   bool processTriangleStrip(mgrec* mgmesh, DtGroup* parentGroup, unsigned int ithPrimitive);


   // Each of these translates a particular type of OpenFlight "bead" or record.

   DtGdbNode* xlate_eFltLod(mgrec* mgdb, mgrec* mglod, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltXref(mgrec* mgdb, mgrec* mgexternalref);
   DtGdbNode* xlate_eFltObject(mgrec* mgdb, mgrec* mgobject, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltGroup(mgrec* mgdb, mgrec* mggroup, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltSwitch(mgrec* mgdb, mgrec* mggroup, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltDof(mgrec* mgdb, mgrec* mggroup, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltHeader(mgrec* mgdb, mgrec* mgheader, const DtFltPathMap& path);
   DtGdbNode* xlate_eFltMesh(mgrec* mgdb, mgrec* mgnode);

   // returns a DtGdbNode because it may return either an indirect polygon or triangle 
   DtGdbNode* xlate_poly(mgrec* mgdb, 
      mgrec* mgpolygon,
      mgrec* mgv0, 
      mgrec* mgv1, 
      mgrec* mgv2, 
      mgrec* mgv3 = 0);

   DtGdbNode* xlate_eFltPolygon(mgrec* mgdb, mgrec* mgpolygon);
   DtGdbNode* xlate_eFltIbead(mgrec* mgdb, mgrec* mgpolygon, const DtFltPathMap&);

   // Given any OpenFlight bead we know about, this calls the right translator
   // routine.
   DtGdbNode* xlateOpenFlightNode(mgrec* mgdb, mgrec* node, const DtFltPathMap&);

   // Prepends static coord sys to already_translated_m if mgrec has general
   // transformation.

   DtGdbNode* xlate_fltMatrixIfAny(mgrec* m, DtGdbNode* already_translated_m);


   // If there are any group children, this function adds them as children of the
   // specified parentGroup.  If the parentGroup parameter is 0, then a new
   // DtGroup node is allocated.  If the desiredChildIndex is specifed to anything
   // other than 0, then only the child node at the specified index will be imported,
   // if it exists.  
   // 
   // \return The number of successfully imported children, if any.
   unsigned int xlateGroupChildrenIfAny(mgrec* mgdb, mgrec* mggroup, 
      DtGroup*& parentGroup, const DtFltPathMap& flightPathMap, 
      unsigned int desiredChildIndex = 0);

   // Tests the specified child index against the specified desired child index.
   // If the desired index is 0, or if the specified child index matches the 
   // specified non-zero desired index, then the child should be imported and the
   // function returns true.  If the child index does not match the desired index,
   // then the child is skipped.  
   // \note When importing normal group nodes, the desired index defaults to zero
   // so that we import all child nodes.  However, when importing switch nodes,
   // if the user has specified a specific child as the one to import, then that
   // is the only one imported.
   bool importChild(unsigned int childIndex, unsigned int desiredIndex) const;


   static bool myInitMgApi;
   unsigned char myUnits;

   //FlightTranslatedDatabaseListItem* myAlreadyXlatedDatabases;

   double myCurrentOffsetX;
   double myCurrentOffsetY;
   double myCurrentOffsetZ;
   // If path is specified in flt initializer, that will be used if this path is empty
   DtString       myUseFlightPath;
   DtFltPathMap   myFlightPath;
   // List of all surfaces that were not found during load
   std::map<DtString, int> myErrorSurfaces;

   std::map<DtString, bool> myAlreadyColorWarned;
};

extern "C" DT_DLL_mgwrapper DtMgWrapperInterface* DtCreateMgWrapperObject()
{
   return (DtMgWrapperInterface*) new DtMgWrapper();
}

extern "C" DT_DLL_mgwrapper void DtDestroyMgWrapperObject(DtMgWrapperInterface* mwi)
{
   delete mwi;
}