trpage_scene.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_scene_h_
#define _txpage_scene_h_

/* trpage_scene.h
    Scene Graph definition.
    This is a small scene graph we use for testing.
    It's not intended to replace the scene graph you may already be using.
    You do not need to translate from this scene graph structure to your own,
     at run-time.  Instead, use this file and trpage_scene.cpp as a guideline
     for how to read TerraPage format into your own scene graph.
   */

#include <osgdb_vrftxp/trpage_geom.h>

/*
    {group:Demonstration Scene Graph}
    */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgMBR {
public:
    trpgMBR(void);
    ~trpgMBR(void) { };
    bool isValid(void) const;
    void Reset(void);
    void AddPoint(const trpg3dPoint &);
    void AddPoint(double,double,double);
    void GetMBR(trpg3dPoint &ll,trpg3dPoint &ur) const;
    trpg3dPoint GetLL(void) const;
    trpg3dPoint GetUR(void) const;
    void Union(const trpgMBR &);
    bool Overlap(const trpg2dPoint &ll, const trpg2dPoint &ur) const;
    bool Within(const trpg2dPoint &) const;
protected:
    inline bool inRange(double minv,double maxv,double val) const { return (val >= minv && val <= maxv); }
    bool valid;
    trpg3dPoint ll,ur;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadNode {
public:
    virtual ~trpgReadNode(void) { };
    virtual bool isGroupType(void) = 0;
    virtual int GetType(void) { return type; }
    virtual trpgMBR GetMBR(void) const { return trpgMBR(); }
protected:
    int type;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadGroupBase : public trpgReadNode {
public:
    virtual ~trpgReadGroupBase(void) override;
    void AddChild(trpgReadNode*);
   virtual bool isGroupType(void) override { return true; }
    int GetNumChildren(void) { return int(children.size()); }
    trpgReadNode* GetChild(int i) { return children[i]; }
   virtual trpgMBR GetMBR(void) const override;
    void unRefChild(int i);
    void unRefChildren(void);
protected:
    trpgMBR mbr;
    void DeleteChildren(void);
    std::vector<trpgReadNode *> children;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadGeometry : public trpgReadNode {
public:
    trpgReadGeometry(void) { type = TRPG_GEOMETRY; }
   virtual ~trpgReadGeometry(void) override { };
   virtual bool isGroupType(void) override { return false; }
    trpgGeometry* GetData(void) { return &data; }
   virtual trpgMBR GetMBR(void) const override;
protected:
    trpgMBR mbr;
    trpgGeometry data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadTileHeader : public trpgReadNode {
public:
    trpgReadTileHeader(void) { type = TRPGTILEHEADER; }
   virtual ~trpgReadTileHeader(void) override { };
   virtual bool isGroupType(void) override { return false; }
    trpgTileHeader* GetData(void) { return &data; }
   virtual trpgMBR GetMBR(void) const override
   { trpgMBR mbr;  return mbr; };
protected:
    trpgTileHeader data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadGroup : public trpgReadGroupBase {
public:
    trpgReadGroup(void) { type = TRPG_GROUP; }
   virtual ~trpgReadGroup(void) override { };
    trpgGroup *GetData(void) { return &data; }
protected:
    trpgGroup data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadAttach : public trpgReadGroupBase {
public:
    trpgReadAttach(void) { type = TRPG_ATTACH; }
   virtual ~trpgReadAttach(void) override { };
    trpgAttach *GetData(void) { return &data; }
protected:
    trpgAttach data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadChildRef : public trpgReadGroupBase {
public:
    trpgReadChildRef(void) { type = TRPG_CHILDREF; }
   virtual ~trpgReadChildRef(void) override { };
   virtual bool isGroupType(void) override { return false;}
    trpgChildRef *GetData(void) { return &data; }
protected:
    trpgChildRef data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadBillboard : public trpgReadGroupBase {
public:
    trpgReadBillboard(void) { type = TRPG_BILLBOARD; }
   virtual ~trpgReadBillboard(void) override { };
    trpgBillboard *GetData(void) { return &data; }
protected:
    trpgBillboard data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadLod : public trpgReadGroupBase {
public:
    trpgReadLod(void) { type = TRPG_LOD; }
   virtual ~trpgReadLod(void) override { };
    trpgLod *GetData(void) { return &data; }
protected:
    trpgLod data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadLayer : public trpgReadGroupBase {
public:
    trpgReadLayer(void) { type = TRPG_LAYER; }
   virtual ~trpgReadLayer(void) override { };
    trpgLayer *GetData(void) { return &data; }
protected:
    trpgLayer data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadTransform : public trpgReadGroupBase {
public:
    trpgReadTransform(void) { type = TRPG_TRANSFORM; }
   virtual ~trpgReadTransform(void) override { };
    trpgTransform *GetData(void) { return &data; }
protected:
    trpgTransform data;
};

TX_EXDECL class DT_DLL_osgdb_vrftxp trpgReadModelRef : public trpgReadGroupBase {
public:
    trpgReadModelRef(void) { type = TRPG_MODELREF; }
   virtual ~trpgReadModelRef(void) override { };
    trpgModelRef *GetData(void) { return &data; }
protected:
    trpgModelRef data;
};

/* Scene Graph Parser
    Parses a read buffer and returns a full scenegraph.
    You don't want to use this if you're reading into your own scenegraph.
    Instead, you'll want to sublcass trpgSceneParser, which is a helper
     class to keep track of pushes and pops and implement the same functionality
     that trpgSceneGraphParser has for your own scene graph.
    */
TX_EXDECL class DT_DLL_osgdb_vrftxp trpgSceneGraphParser : public trpgSceneParser {
public:
#if defined(_WIN32)
    typedef std::map<int,trpgReadGroupBase *> GroupMap;
#else
    typedef std::map< int,trpgReadGroupBase *,std::less<int> > GroupMap;
#endif
    trpgSceneGraphParser(void);
    virtual ~trpgSceneGraphParser(void) override { };
    trpgReadNode *ParseScene(trpgReadBuffer &,GroupMap &);
    trpgReadGroupBase *GetCurrTop(void);  
    trpgReadTileHeader *GetTileHeaderRef(void);

    GroupMap *GetGroupMap(void);
protected:
    virtual bool StartChildren(void*) override;
    virtual bool EndChildren(void*) override;
    trpgReadNode *currTop;            
    trpgReadNode *top;                
    GroupMap *gmap;
    trpgReadTileHeader tileHead;    
};

/*  Test Archive
    Utility function that loads and tests all tiles.
    The only reason you'd want to call this is to test a TerraPage archive
     you'd written.
    */
TX_CPPDECL bool trpgTestArchive(trpgr_Archive &);

#endif