ciEntity.h

Go to the documentation of this file.

// Copyright JRM Enterprises, Inc. 2004 - 2012
// All rights reserved.
//
// This code is the intellectual property of JRM Enterprises, Inc.
// It may not be used or released as source or compiled binary form
// without the prior written consent of JRM Enterprises, Inc.
//
// Original Author:  Michael Ortalano
// Date:       Oct 2004
//
//
//
//

#if !defined(AFX_CIENTITY_H__DE81EF86_CAA9_471E_AE7A_9087CD4CB282__INCLUDED_)
#define AFX_CIENTITY_H__DE81EF86_CAA9_471E_AE7A_9087CD4CB282__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "ciApi.h"
#include "clXML.h"
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <fstream>
#include <memory.h>
#include <malloc.h>
#include <assert.h>
#include "clXMLNode.h"
#include "ciGreNrt.h"
#include "ciGreSTDomain.h"

class CI_API ciEntity  
{
public:     // enumerations & structs

    // Category
    enum Category
    {
        defaultCategory = 0,
        clouds,
        specialeffect,
        diguy,
        water,
        speedtree,
      rdg,
        ship,
        aircraft, 
      storm, 
      plume, 
      embedk,
      pointsource,
      emsig
    };


    // ClampingMode 
    enum ClampingMode
    {
        NONE         = 0,  
        TERRAIN_CLAMP,        
        TUNNEL_CLAMP       
    };

    // enumTextureType
    enum enumTextureType
    {
        MCM,   
        EMAT   
    };


   typedef struct
   {
      char  geomFileName[512];
      char    matSysFileName[512];
      char  pipFileName[512];
      char  rcsFileName[512];
      char  scFileName[512];
      Category category;
      double   r;                
      double   f;                
      double   u;                
      double   heading;          
      double   pitch;               
      double   roll;             
      double   velocity;            
      bool    impostorEnable;
      double  impostorTextureResolution;
      double  impostorPixelCoverage;
   }  structSubObjectData;



public:     // contructors, destructors and assignment operators

    // ciEntity
    ciEntity();

    // ciEntity
    ciEntity(ciEntity &obj);

    // ~ciEntity
    virtual ~ciEntity();

    // operator =
    ciEntity operator =(ciEntity &obj);

    // operator []
    ciEntity &operator [] (int idx);

public:     // methods

    // Add
    bool add(ciEntity entity);

    // Insert
    bool insert(ciEntity entity, int placeBeforeIdx);

    // Remove
    bool remove(int entityIdx);

    // Print
    void print();

    // archive
    bool archive(std::ofstream &outf);

    // serialize
    int serialize(char *filepath);

    //
    // loadXML
    //
    // \par Description:
    // Loads attributes from an XML node
    //
    // \param clXMLNode* childNode
    // \return bool
    //
    bool loadXML(clXMLNode* childNode);

    //
    // parseXML
    //
    // \par Description:
    // Parses an XML document for specific tags
    //
    // \param clXML xmlDocument
    // \return bool
    //
    bool parseXML(clXML& xmlDocument);

    //loadXMLNode
    bool loadXMLNode(std::string tag, char *nodeString);
    //loadXMLNode
    bool loadXMLNode(std::string tag, bool *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, int *nodeBool);
    //loadXMLNode
    bool loadXMLNode(std::string tag, double *nodeBool);

    //
    // saveXML
    //
    // \par Description:
    // Saves XML nodes to an XML document
    //
    // \param clXML* xmlDocument
    //
    void saveXML(clXML* xmlDocument, int index = -1, bool saveGFE = true);

    //serializeCheck
    int   serializeCheck(char *filepath);

    // setIndex
    void setIndex(int index) 
   {
      if(!m_entityList) return;
      m_entityList[0].index = index;
   }

    // getIndex
    int getIndex() 
   {
      if(!m_entityList) return(0);
      return m_entityList[0].index;
   }

    // getNumEntities
    int getNumEntities() {return m_nEntities;}
    //setNumEntities
    void setNumEntities(int count) {m_nEntities = count;}

    // Getters and Setters 

    // GetName
    char *getName(int index=0);


    // SetName
    void setName(const char *name, int index=0);
    double getVelocity(int index=0);
    void setVelocity(double velocity, int index=0);

    // GetGeomFileName
    char *getGeomFileName(int index=0);

    // SetGeomFileName
    void setGeomFileName(char *name, int index=0);

    // GetMatSysFileName
    char *getMatSysFileName(int index=0);

    // SetMatSysFileName
    void setMatSysFileName(char *name, int index=0);

   // GetMatSysFileNameMCM
   char *getMatSysFileNameMCM(int index = 0);

   // SetMatSysFileNameMCM
   void setMatSysFileNameMCM(char *name, int index = 0);

    // getSmokeGeomFileName
    char *getSmokeGeomFileName(int index=0);

    // setSmokeGeomFileName
    void setSmokeGeomFileName(char *name, int index=0);

    // getSmokeMatSysFileName
    char *getSmokeMatSysFileName(int index=0);

    // setSmokeMatSysFileName
    void setSmokeMatSysFileName(char *name, int index=0);

    // getTextureType
    int getTextureType(int idx=0);

    // setTextureType
    void setTextureType(int textureType, int idx=0);

    // GetTrackFileName
    char *getTrackFileName(int index=0);

    // SetTrackFileName
    void setTrackFileName(char *name, int index=0);

    // getCategory
    ciEntity::Category getCategory(int index=0);


    // setCategory
    void setCategory(ciEntity::Category category, int index=0);

    // GetThermalSpinUpPeriod
    double getThermalSpinUpPeriod(int index=0);

    // SetThermalSpinUpPeriod
    void setThermalSpinUpPeriod(double period, int index = 0);

    // setRenderEnable
    void setRenderEnable(bool render, int index = 0);

    // getRenderEnable
    bool getRenderEnable(int index = 0);

    // setClampMode
    void setClampMode(int clampMode, int index = 0);

    // getClampMode
    int getClampMode(int index = 0);

    // setUseTrackfile
    void setUseTrackfile(bool useTrackfile, int idx = 0);

    // getUseTrackfile
    bool getUseTrackfile(int idx = 0);

    // setWorldPosition
   void setWorldPosition(double x, double y, double z, int i = 0);

    // getWorldPosition
   void getWorldPosition(double& x, double& y, double& z, int i = 0);

    // setGeodeticPosition
    void setGeodeticPosition(double latitude, double longitude, double altitude, int idx = 0);

    // getGeodeticPosition
    void getGeodeticPosition(double &latitude, double &longitude, double &altitude, int idx = 0);

    // setNEDOrientation
    void setNEDOrientation(double heading, double pitch, double roll, int idx = 0);

    // getNEDOrientation
    void getNEDOrientation(double &heading, double &pitch, double &roll, int idx = 0);

    // getRCSfilename
    char *getRCSfilename(int idx = 0);

    // getRCSfilename
    void setRCSfilename(char *filename, int idx = 0);

    // getSCfilename
    char *getSCfilename(int idx = 0);

    // setSCfilename
    void setSCfilename(char *filename, int idx = 0);

    // getMSICfilename
    char *getMSICfilename(int idx = 0);

    // setMSICfilename
    void setMSICfilename(char *filename, int idx = 0);

    // getPIPfilename
    char *getPIPfilename(int idx = 0);

    // setPIPfilename
    void setPIPfilename(char *filename, int idx = 0);

    // getSmokePIPfilename
    char *getSmokePIPfilename(int idx = 0);

    // setSmokePIPfilename
    void setSmokePIPfilename(char *filename, int idx = 0);

    void setClampHeightOffset(double offset, int idx = 0);

    double getClampHeightOffset(int idx = 0);

    int getBrdf(int idx = 0);
    void setBrdf(int brdf, int idx = 0);
    double getRoughness(int idx = 0);
    void setRoughness(double roughness, int idx = 0);

   bool getMmlsReflect(int idx = 0);
   void setMmlsReflect(bool mmlsReflect, int idx = 0);
   bool getThermalReflect(int idx = 0);
   void setThermalReflect(bool thermalReflect, int idx = 0);
   double getThermalReflectTemp(int idx = 0);
   void setThermalReflectTemp(double thermalReflectTemp, int idx = 0);

   void getThermalReflectExtent(double &x, double &y, int idx = 0);
   void setThermalReflectExtent(double x, double y, int idx = 0);
   void getThermalReflectOffset(double &x, double &y, double &z, int idx = 0);
   void setThermalReflectOffset(double x, double y, double z, int idx = 0);

    void setImpostorEnable(bool enable = false, int idx = 0);
    bool getImpostorEnable(int idx = 0) const;
    void setImpostorResolution(double resolution = 512.0, int idx = 0);
    double getImpostorResolution(int idx = 0) const;
    void setImpostorPixelCoverage(double coverage = 40.0, int idx = 0);
    double getImpostorPixelCoverage(int idx = 0) const;

   // Sets the silverlining cloud type.
   void setSLCloudType(int type, int index = 0);

   // Gets the silverlining cloud type.
   int getSLCloudType(int index = 0);

   // Sets the silverlining cloud base alt.
   void setSLBaseAlt(double alt_m, int index = 0);

   // Gets the silverlining cloud base alt.
   double getSLBaseAlt(int index = 0);

   // Sets the silverlining cloud thickness.
   void setSLThickness(double thick_m, int index = 0);

   // Gets the silverlining cloud thickness.
   double getSLThickness(int index = 0);

   // Sets the silverlining cloud extents.
   void setSLExtent(double extent_m, int index = 0);

   // Gets the silverlining cloud extents.
   double getSLExtent(int index);

   // Sets the silverlining cloud coverage.
   void setSLCoverage(double coverage, int index = 0);

   // Gets the silverlining cloud coverage.
   double getSLCoverage(int index = 0);

    // setDIGuyCharacterType
    void setDIGuyCharacterType(char *characterType, int index = 0);

    // getDIGuyCharacterType
    char* getDIGuyCharacterType(int index = 0);

    // setDIGuyBaseAppearance
    void setDIGuyBaseAppearance(char *baseAppearance, int index = 0);

    // getDIGuyBaseAppearance
    char* getDIGuyBaseAppearance(int index = 0);

    // setDIGuyHeadAppearance
    void setDIGuyHeadAppearance(char *headAppearance, int index = 0);

    // getDIGuyHeadAppearance
    char* getDIGuyHeadAppearance(int index = 0);

    // setDIGuyHandItem
    void setDIGuyHandItem(char *handItem, int index = 0);

    // getDIGuyHandItem
    char* getDIGuyHandItem(int index = 0);

    // setDIGuyAppearance
    void setDIGuyAppearance(char *appearance, int index = 0);

    // getDIGuyAppearance
    char* getDIGuyAppearance(int index = 0);

    // sets the state of the search and rescue radar transponder
    void setTransponderEnable(bool flag, int index = 0);
    // gets the state of the search and rescue radar transponder
    bool getTransponderEnable(int index = 0) const;
    // sets the frequency of the search and rescue radar transponder
    void setTransponderFrequency(double freq, int index = 0);
    // gets the frequency of the search and rescue radar transponder
    double getTransponderFrequency(int index = 0) const;


   int getNumSubObjects(int index=0);
   bool loadXMLNode(ciEntity &currentEntity, int idx, int subObjIndex);
   bool validSubObjectIndex(int idx, int subObjectIndex);
   bool addSubObject(int idx, structSubObjectData subObject);
   bool removeSubObject(int idx, int subObjectIndex);
   ciEntity::Category getSubObjectCategory(int index=0, int subObjectIndex=0);
    void setSubObjectCategory(ciEntity::Category category, int index=0, int subObjectIndex=0);
   char *getSubObjectGeomFileName(int index=0, int subObjectIndex=0);
    void setSubObjectGeomFileName(char *name, int index=0, int subObjectIndex=0);
   char *getSubObjectPipFileName(int idx, int subObjectIndex);
   void setSubObjectPipFileName(char *name, int idx, int subObjectIndex);
   char *getSubObjectRcsFileName(int idx, int subObjectIndex);
   void setSubObjectRcsFileName(char *name, int idx, int subObjectIndex);
   char *getSubObjectScFileName(int idx, int subObjectIndex);
   void setSubObjectScFileName(char *name, int idx, int subObjectIndex);
   char *getSubObjectMatSysFileName(int index=0, int subObjectIndex=0);
    void setSubObjectMatSysFileName(char *name, int index=0, int subObjectIndex=0);
   void setSubObjectOffsetPosition(double r, double f, double u, int i = 0, int subObjectIndex=0);
   void getSubObjectOffsetPosition(double& r, double& f, double& u, int i = 0, int subObjectIndex=0);
   void setSubObjectOrientation(double heading, double pitch, double roll, int idx = 0, int subObjectIndex=0);
    void getSubObjectOrientation(double &heading, double &pitch, double &roll, int idx = 0, int subObjectIndex=0);
   void setSubObjectVelocity(double v, int i = 0, int subObjectIndex=0);
   void getSubObjectVelocity(double &v, int i = 0, int subObjectIndex=0);  
   bool getSubObjectImpostorEnable(int idx, int subObjectIndex=0);
   void setSubObjectImpostorEnable(bool enable, int idx, int subObjectIndex=0);
   void setSubObjectImpostorTextureResolution(double res, int idx, int subObjectIndex=0);
   void getSubObjectImpostorTextureResolution(double &res, int idx, int subObjectIndex=0);
   void setSubObjectImpostorPixelCoverage(double cov, int idx, int subObjectIndex=0);
   void getSubObjectImpostorPixelCoverage(double &cov, int idx, int subObjectIndex=0);

   void setGreNrt(ciGreNrt *gre, int index = 0);
   ciGreNrt *getGreNrt(int index = 0);

   void setGreSTDomain(ciGreSTDomain *gre, int index = 0);
   ciGreSTDomain * getGreSTDomain(int index = 0);

protected:  // methods

private: // methods

    // categoryStringToEnum
    Category stringToEnum(char* categoryString);

    // enumToCategoryString
    char* enumToCategoryString(ciEntity::Category categoryEnum);

private: // variables


    // structEntityData
    struct structEntityData
    {
        int index; 
        char   entityName[128];
        char   geomFileName[512];
        char    matSysFileName[512];
      char  matSysFileNameMCM[512];
      char  smokeGeomFileName[512];
        char    smokeMatSysFileName[512];
        int textureType;          
        Category     category; 
        double thermalSpinUp;
        bool   renderEnable;           
        int clampMode;           
        bool   useTrackfile;
        char   trackFileName[512];
        double worldX;
        double worldY;
        double worldZ;
        double latitude;            
        double longitude;           
        double altitude;            
        double heading;          
        double pitch;               
        double roll;             
        char   rcsFileName[512];
        char   scFileName[512];
        char   pipFileName[512];
      char  msicFileName[512];
        char   smokePipFileName[512];
        double  velocity;
        double clampHeightOffset;
        int     brdf;
        double  roughness;
      bool  mmlsReflect;
      bool  thermalReflect;
      double   thermalReflectTemp;
      double   thermalReflectExtentX;
      double   thermalReflectExtentY;
      double   thermalReflectOffsetX;
      double   thermalReflectOffsetY;
      double   thermalReflectOffsetZ;
        bool    impostorEnable;
        double  impostorTextureResolution;
        double  impostorPixelCoverage;
      int      slCloudType;
      double   slBaseAlt;
      double   slThickness;
      double   slExtent;
      double   slCoverage;
        char DIGuyCharacterType[512];
        char DIGuyBaseAppearance[512];
        char DIGuyHeadAppearance[512];
        char DIGuyHandItem[512];
        char DIGuyAppearance[512];
      int      m_nSubObjects;
        bool    m_transponderEnabled;
        double  m_transponderFrequency;
      ciGreNrt *greNrtData;
      ciGreSTDomain *greSTDomainData;
      structSubObjectData *m_subObjectList;
    } *m_entityList;             
    int     m_nEntities;            
    clXML m_xml;
    clXMLNode* m_parentNode;
    //   ciEntity *m_ciEntityList;     /*!< contiguous array of active ciEntity objects */

};

#endif // !defined(AFX_CIENTITY_H__DE81EF86_CAA9_471E_AE7A_9087CD4CB282__INCLUDED_)