trpage_write.h

Go to the documentation of this file.

/* ************************
   Copyright Terrain Experts Inc.
   Terrain Experts Inc (TERREX) reserves all rights to this source code
   unless otherwise specified in writing by the President of TERREX.
   This copyright may be updated in the future, in which case that version
   supercedes this one.
   -------------------
   Terrex Experts Inc.
   4400 East Broadway #314
   Tucson, AZ  85711
   info@terrex.com
   Tel: (520) 323-7990
   ************************
   */

#ifndef _txpage_write_h_

#define _txpage_write_h_

/* trpage_write.h
    Classes that are used to write paging archives.
    */

#include <osgdb_vrftxp/trpage_sys.h>
#include <osgdb_vrftxp/trpage_io.h>
#include <osgdb_vrftxp/trpage_swap.h>
#include <osgdb_vrftxp/trpage_read.h>

/* Geometry Stats
    Used with a Geometry Helper to keep track of what go built.
    {group:Archive Writing}
    */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgwGeomStats {
public:
    trpgwGeomStats(void);
    ~trpgwGeomStats(void);

    int totalTri;  

    int totalQuad;  

    int totalStripTri;  
    int totalFanTri;    
    int totalBagTri;    

    int numStrip;       
    int numFan;            

    int stripStat[15];  
    int fanStat[15];    

    int stripGeom;        
    int fanGeom;        
    int bagGeom;        

    int stateChanges;    

    inline void AddStripStat(int val) { stripStat[MIN(14,val)]++; totalStripTri += val; totalTri += val; numStrip++;}
    inline void AddFanStat(int val) { fanStat[MIN(14,val)]++; totalFanTri += val; totalTri += val; numFan++;}
    inline void AddBagStat(int val) { totalBagTri += val; totalTri += val;}
    inline void AddQuadStat(int val) { totalQuad += val; }
};

/* Geometry Helper
    Collects up geometry and tries to form triangle strips, fans,
     and groups of triangles.
    Right now this looks for a very careful ordering.  If that ordering
     isn't there you won't get useful tristrips or fans.  You can, however
     use this class as a starting point and build something more akin
     to the geometry builder in Performer.
    {group:Archive Writing}
 */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgwGeomHelper {
public:
    trpgwGeomHelper(void);
    virtual ~trpgwGeomHelper(void);
    enum {UseDouble,UseFloat};
    trpgwGeomHelper(trpgWriteBuffer *,int dataType=UseDouble);
    void init(trpgWriteBuffer *,int dataType=UseDouble);
    virtual void SetMode(int);  
    virtual void Reset(void);
    virtual void StartPolygon(void);
    virtual void EndPolygon(void);
    virtual void ResetPolygon(void);  


    virtual void SetColor(trpgColor &);
    virtual void SetTexCoord(trpg2dPoint &);
    virtual void AddTexCoord(trpg2dPoint &); 
    virtual void SetNormal(trpg3dPoint &);
    virtual void SetMaterial(int32);
    virtual void AddMaterial(int32); 

    virtual void AddVertex(trpg3dPoint &);

    virtual void FlushGeom(void);

    virtual void GetZMinMax(double &min,double &max);

    trpgwGeomStats *GetStats(void) { return &stats; }
protected:
    int mode;
    int dataType;
    trpgWriteBuffer *buf;

    /* Builds strips and fans from the triangle array.
        We (TERREX) are assuming a certain ordering in our vertex array
         because we do this optimization elsewhere.  This won't work well
         for anyone else.  What you will need to do if you want good
         performance is to implement a more generic form of this method.
         All you should have to do is override Optimize().  You've
         got the triangle arrays and a guarantee that the triangles
         have the same material.  All you really need is a decent fan/strip
         algorithm.
         */
    virtual void Optimize(void);

    virtual void ResetTri(void);

    trpgGeometry strips,fans,bags;

    std::vector<int32> matTri;
    std::vector<trpg2dPoint> tex;
    std::vector<trpg3dPoint> norm,vert;
    std::vector<int32> matPoly;
    std::vector<trpg2dPoint> polyTex;
    std::vector<trpg3dPoint> polyNorm,polyVert;
    std::vector<trpg2dPoint> tmpTex;
    trpg3dPoint tmpNorm;
    trpgColor tmpCol;

    trpgwGeomStats stats;

    double zmin,zmax;
};

/* Image Write Helper.
    Used to manage textures being added to a TerraPage archive.
    It can write Local and Tile Local textures and also manages
    the names of External textures (but you have to write those yourself).
 */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgwImageHelper {
public:
    trpgwImageHelper() {;};
    trpgwImageHelper(trpgEndian ness,char *dir,trpgTexTable &,bool separateGeoTypical);
    virtual void Init(trpgEndian ness,char *dir,trpgTexTable &,bool separateGeoTypical);

    virtual ~trpgwImageHelper(void);

    virtual bool AddExternal(char *name,int &texID,bool lookForExisting=true);

    /* Adds an entry to the texture table for a local texture and
        writes the data for that texture out to one of our texture
        archive files.
     */
    virtual bool AddLocal(char *name,trpgTexture::ImageType type,int sizeX,int sizeY,bool isMipmap,char *data,int &texID,bool deferWrite);

    /* Replaces texture table information for a local texture and
        writes the data for that texture out to one of our texture
        archive files.
        Up to you to ensure data is appropriate for the texture.
     */
    virtual bool ReplaceLocal(char *data,int &texID);

    /* Write a Tile Local texture out to one of our texture archive files.
        Also creates a texture template, if necessary.
        Caller is responsible for creating the Tile Local material and
        placing it in the appropriate tile.
     */
    virtual bool AddTileLocal(char *name,trpgTexture::ImageType type,int sizeX,int sizeY,bool isMipmap,char *data, int &texID,trpgwAppAddress &addr);

    /* Sets the maximum advised length for a texture archive file.
        Once the length is exceeded, the image write helper will move
        on to the next tex file.
     */
    virtual void SetMaxTexFileLength(int len);

    /* Texture archive files are managed by this class and will
        be created as needed.  This method will increment to
        the next texture file.
        Note: This may create more files than we really need.
     */
    virtual trpgwAppFile * IncrementTextureFile(bool geotyp);

    /* Close the current texture file and go on to one with the
        given base name.  This is used for regenerate.
     */
    virtual bool DesignateTextureFile(int);

    virtual bool Flush(void);

    virtual trpgwAppFile* GetNewWAppFile(trpgEndian inNess,const char *fileName,bool reuse=false);
    
    bool WriteToArchive(const trpgTexture &tex,char *data,trpgwAppAddress &addr,bool geotyp=false);
    
protected:


    trpgEndian ness;
    char dir[1024];
    trpgTexTable *texTable;
    std::vector<int> texFileIDs;
    trpgwAppFile *texFile;
    std::vector<int> geotypFileIDs;
    trpgwAppFile *geotypFile;
    bool separateGeoTypical;
    int maxTexFileLen;
};

/* Paging Archive
    This is a writeable paging archive.
    It organizes where things get written and how.
    {group:Archive Writing}
    */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgwArchive : public trpgCheckable {
public:
    enum TileMode {TileLocal,TileExternal,TileExternalSaved};

    trpgwArchive(char *baseDir,char *name,trpg2dPoint &ll,trpg2dPoint &ur, int majorVer=TRPG_VERSION_MAJOR, int minorVer=TRPG_VERSION_MINOR);
    virtual void Init(char *baseDir,char *name,trpg2dPoint &ll,trpg2dPoint &ur, int majorVer=TRPG_VERSION_MAJOR, int minorVer=TRPG_VERSION_MINOR);
    trpgwArchive(trpgEndian ness=LittleEndian,TileMode tileMode=TileLocal,int majorVer=TRPG_VERSION_MAJOR, int minorVer=TRPG_VERSION_MINOR);
    virtual void Init(trpgEndian ness=LittleEndian,TileMode tileMode=TileLocal,int majorVer=TRPG_VERSION_MAJOR, int minorVer=TRPG_VERSION_MINOR);
    trpgwArchive(int ) {;};
    virtual ~trpgwArchive(void);

    virtual void SetMaxTileFileLength(int len);

    virtual bool SetHeader(const trpgHeader &);
    virtual bool SetMaterialTable(const trpgMatTable &);
    virtual bool SetTextureTable(const trpgTexTable &);
    virtual bool SetModelTable(const trpgModelTable &);
    virtual bool SetLightTable(const trpgLightTable &);
    virtual bool SetRangeTable(const trpgRangeTable &);
    virtual bool SetLabelPropertyTable(const trpgLabelPropertyTable &);
    virtual bool SetSupportStyleTable(const trpgSupportStyleTable &);
    virtual bool SetTextStyleTable(const trpgTextStyleTable &);

    virtual trpgHeader *GetHeader();
    virtual trpgMatTable *GetMatTable();
    virtual trpgTexTable *GetTextureTable();
    virtual trpgModelTable *GetModelTable();
    virtual trpgLightTable *GetLightTable();
    virtual trpgRangeTable *GetRangeTable();
    virtual trpgLabelPropertyTable *GetLabelPropertyTable();
    virtual trpgTextStyleTable *GetTextStyleTable();
    virtual trpgSupportStyleTable *GetSupportStyleTable();



    virtual bool IncrementTileFile(void);
    virtual bool DesignateTileFile(int);


    virtual bool OpenFile(const char *,const char *);
    virtual void CloseFile(void);
    virtual bool WriteHeader(void);
    virtual bool CheckpointHeader(void);
    virtual bool WriteTile(unsigned int,unsigned int,unsigned int,float zmin,float zmax,
        const trpgMemWriteBuffer *,const trpgMemWriteBuffer *, int32& fileId, int32& fileOffset);

    bool isValid(void) const;
    const char *getErrMess() const;
    char* getDir(void){return dir;};
    virtual trpgwImageHelper* GetNewWImageHelper(trpgEndian ness,char *dir,trpgTexTable &);
    virtual trpgwAppFile* GetNewWAppFile(trpgEndian inNess,const char *fileName,bool reuse=false);
    virtual trpgr_Archive* GetArchiveReader() {return new trpgr_Archive();};
    virtual int32 WriteHeaderData(const char *dataPtr,int32 length,FILE *filehandle);
    virtual int32 GetMagicNumber() {return TRPG_MAGIC;};
protected:
    bool isRegenerate;

    class TileFileEntry {
    public:
        int x,y,lod;    
        float zmin,zmax;
        int32 offset;  
    };
    class TileFile {
    public:
        int id;
        std::vector<TileFileEntry> tiles;
    };

    trpgEndian ness,cpuNess;
    int majorVersion, minorVersion;
    char dir[1024];       


    trpgHeader header;
    trpgMatTable matTable;
    trpgTexTable texTable;
    trpgModelTable modelTable;
    trpgLightTable lightTable;
    trpgRangeTable rangeTable;
    trpgTextStyleTable textStyleTable;
    trpgSupportStyleTable supportStyleTable;
    trpgLabelPropertyTable labelPropertyTable;


    trpgTileTable tileTable;

    int numLod;
    TileMode tileMode;

    trpgwAppFile *tileFile;
    int tileFileCount;

    std::vector<TileFile> tileFiles;

    std::vector<TileFileEntry> externalTiles;

    int maxTileFileLen;

    trpg2iPoint addOffset;

    FILE *fp;

    bool firstHeaderWrite;

    mutable char errMess[512];
};

#endif