gzDbManager_txp.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzDbManager_txp.h
// Module       : 
// Description  : Class definition of the TerraPage format
// Author       : Anders Modén      
// Product      : Gizmo3D 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    Gizmo3D is a high performance 3D Scene Graph and effect visualisation 
//          C++ toolkit for Linux, Mac OS X, Windows (Win32) and IRIX® for  
//          usage in Game or VisSim development.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  000226  Created file    
//
//******************************************************************************
#ifndef __GZ_DB_TXP_H__
#define __GZ_DB_TXP_H__

#include "gzNode.h"
#include "gzGroup.h"
#include "gzGeometry.h"

// UserData Db INFO attributes
const gzString GZ_DB_INFO_TYPE_TERRAPAGE    ="txp";

class gzTxpTileOffset
{
public:

    gzULong     fileID;
    gzULong     offset;
};

class gzTxpLodInfo
{
public:

    gzLongXY                    size;

    gzDouble                    range;

    gzDoubleXY                  tileSize;

    gzMatrix<gzTxpTileOffset>   offsetInfo;

    gzFloat                     elevMax;

    gzFloat                     elevMin;
};

class gzTxpMaterial : public gzReference
{
public:

    gzTxpMaterial():
        texID(-1),
        texEnvMode(3),
        minFilter(1),
        magFilter(1)
    {};

    virtual ~gzTxpMaterial(){};

    gzRefPointer<gzMaterial>    material;

    gzRefPointer<gzTexture>     texture;

    gzVec4                      color;

    gzLong                      texID;

    gzUByte                     texEnvMode:3;

    gzUByte                     minFilter:3;

    gzUByte                     magFilter:3;

    gzUByte                     repeatS:1;

    gzUByte                     repeatT:1;

    gzUByte                     cullMode:2;


};

class gzTxpLocalMaterial : public gzReference
{
public:

    gzTxpLocalMaterial(){};
    virtual ~gzTxpLocalMaterial(){};

    gzInt   baseMatTable;
    gzInt   baseMat;

    gzArray<gzULong>            file;
    gzArray<gzULong>            offset;

    gzRefPointer<gzTexture>     texture;

};

class gzTxpTexture : public gzReference
{
public:

    gzTxpTexture()          {};
    virtual ~gzTxpTexture() {};

    gzString                image;
    gzBool                  isMipMap;
    gzUByte                 mode;
    gzUByte                 type;
    gzUByte                 layers;

    gzULong                 sizeX;
    gzULong                 sizeY;

    gzULong                 file;
    gzULong                 offset;
    
};


class gzTxpInfo : public gzReference
{
public:

    gzTxpInfo(const gzString &dir): currentDirectory(dir)
                                    {};

    virtual ~gzTxpInfo(){};

    // All public valiables....

    gzLong                                      numberOfLodLevels;
    gzLong                                      numberOfMaterialTables;
    gzLong                                      numberOfMaterialInTable;
                            
    gzDoubleXYZ                                 origin;

    gzDoubleXY                                  sw;
    gzDoubleXY                                  ne;

    gzArray<gzTxpLodInfo>                       lodInfo;

    gzLong                                      numberOfSetLodLevels;

    gzString                                    currentDirectory;

    gzArray<gzRefPointer<gzTxpMaterial> >       materialArray;
    gzArray<gzRefPointer<gzTxpTexture> >        textureArray;
    gzArray<gzRefPointer<gzNode> >              modelArray;

    // Shared states created out of materials
    gzArray<gzRefPointer<gzState> >             stateArray;

    gzUByte                                     tileOriginType;

    gzBool                                      isArchived;

    gzULong                                     nodeIdBase;

    gzDouble                                    version;

    gzRoi                                       *roi;

    gzArray< gzMatrix<gzRefPointer<gzRoiNode> > >                   nodes;
    gzArray< gzMatrix<gzRefPointer<gzRoiDependancyInterface> >  >   dependencies;
};

class gzTptInfo : public gzReference
{
public:

    gzTptInfo(){};

    virtual ~gzTptInfo(){};

    gzULongXY                                   pos;

    gzDoubleXY                                  center;

    gzULong                                     lodLevel;

    gzDoubleXY                                  size;

    gzArray<gzRefPointer<gzTxpLocalMaterial> >  localMaterialArray;
    gzArray<gzRefPointer<gzState> >             stateArray;
    gzRefPointer<gzTxpLocalMaterial>            currentLocalMaterial;

    gzRoiNode                                   *roiNode;
};

class gzDbManager_txp_reader : public gzProgressInterface
{
public:

    gzDbManager_txp_reader(gzSerializeAdapter *adapter);
    
    virtual ~gzDbManager_txp_reader(){};

    gzNode  *loadDB();

    gzNode  *loadTile();

    gzVoid  setTxpInfo(gzTxpInfo *info);

private:

    gzNode *buildRoiGroup();

    gzSerializeAdapter *m_adapter;
    gzULong             m_fileSize;

    // Common private methods

    gzVoid processTokens(const gzULong & size);
    gzVoid processHeader(const gzULong & size);
    gzVoid processLodInfo(const gzULong & size);

    gzVoid processMaterialTable(const gzULong & size);
    gzVoid processMaterialTable2(const gzULong & size);

    gzVoid processBasicMaterial(const gzULong & size);
    gzVoid processShadeMaterial(const gzULong & size);
    gzVoid processSizeMaterial(const gzULong & size);
    gzVoid processCullMaterial(const gzULong & size);
    gzVoid processAlphaMaterial(const gzULong & size);
    gzVoid processNormalMaterial(const gzULong & size);
    gzVoid processTextureMaterial(const gzULong & size);
    gzVoid processBumpMaterial(const gzULong & size);
    gzVoid processAttrMaterial(const gzULong & size);

    gzVoid processModeTexEnv(const gzULong & size);
    gzVoid processFilterTexEnv(const gzULong & size);
    gzVoid processWrapTexEnv(const gzULong & size);
    gzVoid processBorderTexEnv(const gzULong & size);

    gzVoid processTexTable(const gzULong & size);
    gzVoid processTexture(const gzULong & size);

    gzVoid processTexTable2(const gzULong & size);
    gzVoid processTexture2(const gzULong & size);

    gzVoid processModelTable(const gzULong & size);
    gzVoid processModelRef(const gzULong & size);
    gzVoid processModelRefDef1(const gzULong & size);
    gzVoid processModelRefDef2(const gzULong & size);
    gzVoid processLight(const gzULong & size);
    gzVoid processLabel(const gzULong & size);
    gzVoid processTileTable2(const gzULong & size);
    gzVoid processLightTable(const gzULong & size);
    gzVoid processRangeTable(const gzULong & size);
    gzVoid processRange(const gzULong & size);
    gzVoid processTextStyleTable(const gzULong & size);
    gzVoid processTextStyle(const gzULong & size);

    gzVoid processTileHeader(const gzULong & size);
    gzVoid processTileMaterialList(const gzULong & size);
    gzVoid processTileModelList(const gzULong & size);
    gzVoid processTileDate(const gzULong & size);
    gzVoid processTileLocalMaterialList(const gzULong & size);
    gzVoid processLocalMaterial(const gzULong & size);
    gzVoid processChildReference(const gzULong & size);

    gzVoid processGroup(const gzULong & size);
    gzVoid processBillboard(const gzULong & size);
    gzVoid processAttach(const gzULong & size);
    gzVoid processLod(const gzULong & size);

    gzVoid  processGeometry(const gzULong & size);
    gzVoid  processGeometryPrim(const gzULong & size);
    gzVoid  processGeometryMaterial(const gzULong & size);
    gzVoid  processGeometryVert32(const gzULong & size);
    gzVoid  processGeometryVert64(const gzULong & size);
    gzVoid  processGeometryNorm32(const gzULong & size);
    gzVoid  processGeometryNorm64(const gzULong & size);
    gzVoid  processGeometryColor(const gzULong & size);
    gzVoid  processGeometryTex32(const gzULong & size);
    gzVoid  processGeometryTex64(const gzULong & size);


    gzVoid  processPush();
    gzVoid  processPop();


    // Common serializers

    gzSerializeBinary<gzULong>      s_ulong;
    gzSerializeBinary<gzULongLong>  s_ulonglong;
    gzSerializeBinary<gzULong>      s_long;
    gzSerializeBinary<gzDouble>     s_double;
    gzSerializeBinary<gzFloat>      s_float;
    gzSerializeBinary<gzUByte>      s_ubyte;

    gzArray<gzUByte>                s_data;
    gzSerializeString               s_string;

    // processed data

    gzRefPointer<gzTxpInfo>     m_txpInfo;

    gzRefPointer<gzTptInfo>     m_tptInfo;

    // Work Data

    gzVoid clean();

    gzRefPointer<gzGroup>           currentParent;

    gzRefPointer<gzNode>            currentNode;

    gzRefPointer<gzGroup>           topGroup;

    gzRefList<gzGroup>              stack;

    // Current geometry info

    gzDynamicArray<gzULong>                 geoPrimLens;

    gzDynamicArray<gzLong>                  geoPrimMaterials;

    gzDynamicArray<gzVec3>                  geoPrimCoordinates;

    gzDynamicArray<gzVec3>                  geoPrimNormals;

    gzDynamicArray<gzVec4>                  geoPrimColors;

    gzDynamicArray<gzDynamicArray<gzVec2> > geoPrimTexCoords;

    gzGeoPrimType                           geoPrimType;

    // State & Material

    gzRefPointer<gzTxpMaterial>     m_currentMaterial;
    gzRefPointer<gzTxpTexture>      m_currentTexture;

};

class gzDbManager_txp : public gzDbManager  
{
public:

    GZ_DB_EXPORT gzDbManager_txp();
    GZ_DB_EXPORT virtual ~gzDbManager_txp(){};

    GZ_DB_EXPORT virtual gzNode *   loadDB(gzSerializeAdapter *adapter);

    //GZ_DB_EXPORT virtual gzBool       saveDB(gzNode *node ,gzSerializeAdapter *adapter);

    GZ_DB_EXPORT virtual gzString   getExtensions();

    GZ_DB_EXPORT virtual gzULong    getVersion(const gzString &extension);
};

class gzDbManager_tpt : public gzDbManager  
{
public:

    GZ_DB_EXPORT gzDbManager_tpt();
    GZ_DB_EXPORT virtual ~gzDbManager_tpt(){};

    GZ_DB_EXPORT virtual gzNode *   loadDB(gzSerializeAdapter *adapter);

    //GZ_DB_EXPORT virtual gzBool       saveDB(gzNode *node ,gzSerializeAdapter *adapter);

    GZ_DB_EXPORT virtual gzString   getExtensions();

    GZ_DB_EXPORT virtual gzULong    getVersion(const gzString &extension);
};

#endif

---