TXPParser.h

Go to the documentation of this file.

/***************************************************************************
 * December 2003
 *
 * This TerraPage loader was re-written in a fashion to use PagedLOD
 * to manage paging entirely, also includes a version of Terrex's smart mesh
 * adapted to work with PagedLOD. The essential code by Boris Bralo is still present,
 * slight modified.
 * nick at terrex dot com
 *
 * Ported to PagedLOD technology by Trajce Nikolov (Nick) & Robert Osfield
 *****************************************************************************/

/***************************************************************************
 * OpenSceneGraph loader for Terrapage format database
 * by Boris Bralo 2002
 *
 * based on/modifed  sgl (Scene Graph Library) loader by Bryan Walsh
 *
 * This loader is based on/modified from Terrain Experts Performer Loader,
 * and was ported to SGL by Bryan Walsh / bryanw at earthlink dot net
 *
 * That loader is redistributed under the terms listed on Terrain Experts
 * website (www.terrex.com/www/pages/technology/technologypage.htm)
 *
 * "TerraPage is provided as an Open Source format for use by anyone...
 * We supply the TerraPage C++ source code free of charge.  Anyone
 * can use it and redistribute it as needed (including our competitors).
 * We do, however, ask that you keep the TERREX copyrights intact."
 *
 * Copyright Terrain Experts Inc. 1999.
 * All Rights Reserved.
 *
 *****************************************************************************/

#ifndef __TXPPARSER_H_
#define __TXPPARSER_H_

#include <osg/Referenced>
#include <osg/Texture2D>
#include <osg/StateSet>
#include <osg/Node>

#include <stack>

#include "trpage_read.h"

#include "TXPArchive.h"

namespace txp
{

osg::Texture2D* getLocalTexture(trpgrImageHelper& image_helper, const trpgTexture* tex);
osg::Texture2D* getTemplateTexture(trpgrImageHelper& image_helper, trpgLocalMaterial* locmat, const trpgTexture* tex, int index=0);




class GeodeGroup : public osg::Group
{
public:

    GeodeGroup() : osg::Group(), _geode(NULL)
    {}

    GeodeGroup(const GeodeGroup& gg,const osg::CopyOp& copyop=osg::CopyOp::SHALLOW_COPY):
    osg::Group(gg, copyop), _geode(gg._geode)
    {}

    META_Node(txp, GeodeGroup);

    osg::Geode* getGeode()
    {
        if (_geode == 0)
        {
            _geode = new osg::Geode();
            addChild(_geode);
        }

        return _geode;
    }
protected:
    osg::Geode*    _geode;
};


class TXPArchive;
class childRefRead;
struct DeferredLightAttribute;

class TXPParser : public trpgSceneParser, public osg::Referenced
{
public:
    TXPParser();

    inline void setArchive(TXPArchive* archive)
    {
        _archive = archive;
    }

    inline TXPArchive* getArchive()
    {
        return _archive;
    }

    osg::Group *parseScene(
        trpgReadBuffer &buf,
        std::map<int,osg::ref_ptr<osg::StateSet> > &materials,
        std::map<int,osg::ref_ptr<osg::Node> > &models,
        double realMinRange, double realMaxRange, double usedMaxRange);

    inline osg::Group* getCurrTop()
    {
        return _currentTop ? _currentTop : _root.get();
    }

    inline void setPotentionalTileGroup(osg::Group* grp)
    {
        _tileGroups[grp] = 1;
    }

    inline std::map<int,osg::ref_ptr<osg::StateSet> >* getMaterials()
    {
        return _materialMap;
    }

    inline void loadMaterial( int ix )
    {
        _archive->loadMaterial( ix );
    }

    std::vector<osg::ref_ptr<osg::StateSet> >* getLocalMaterials()
    {
        return &_localMaterials;
    }

    void loadLocalMaterials();

    std::map<int,osg::ref_ptr<osg::Node> >* getModels()
    {
        return _models;
    }

    bool requestModel(int ix);

    inline trpgTileHeader *getTileHeaderRef()
    {
        return &_tileHeader;
    }


    inline const bool underBillboardSubgraph() const
    {
        return _underBillboardSubgraph;
    }

    inline void setUnderBillboardSubgraph(bool b)
    {
        _underBillboardSubgraph = b;
    }

    struct TXPBillboardInfo
    {
        int type;
        int mode;
        trpg3dPoint center;
        trpg3dPoint axis;
    };

    inline void setLastBillboardInfo(TXPBillboardInfo& info)
    {
        _lastBillboardInfo = info;
    }

    inline void getLastBillboardInfo(TXPBillboardInfo& info)
    {
        info = _lastBillboardInfo;
    }

    DeferredLightAttribute& getLightAttribute(int ix);

    inline const bool underLayerSubgraph() const
    {
        return _underLayerSubgraph;
    }

    inline void setUnderLayerSubgraph(bool b)
    {
        _underLayerSubgraph = b;
    }

    inline void setLayerGeode(osg::Geode* layer)
    {
        _layerGeode = layer;
    }

    inline osg::Geode* getLayerGeode() const
    {
        return _layerGeode;
    }

    inline unsigned int getNumLayerLavels() const { return _numLayerLevels; }

    void setMaxAnisotropy(float anisotropy)
    {
        _defaultMaxAnisotropy = anisotropy;
    }
    float getMaxAnisotropy() const
    {
        return _defaultMaxAnisotropy;
    }

    inline double checkAndGetMinRange(double range)
    {
        if ((range-_realMinRange) < 0.0001)
            return 0.0;
        else
            return range;
    }
    inline double checkAndGetMaxRange(double range)
    {
        if ((range-_realMaxRange) < 0.0001)
            return _usedMaxRange;
        else
            return range;
    }

    inline const osg::Vec3 getTileCenter() const
    {
        return _tileCenter;
    }

    inline void setCurrentNode( osg::Node* node )
    {
        _currentNode = node;
    }

   unsigned int GetNbChildrenRef() const;

   const trpgChildRef* GetChildRef(unsigned int idx) const;



protected:

    virtual ~TXPParser() override;

    void removeEmptyGroups();

   virtual bool StartChildren(void*) override;

   virtual bool EndChildren(void*) override;

    TXPArchive * _archive;

    osg::Group* _currentTop;

    osg::Node* _currentNode;

    osg::ref_ptr<osg::Group> _root;

    std::stack<osg::Group*>    _parents;

    std::map<osg::Group*,int>    _tileGroups;

    void replaceTileLod(osg::Group*);

    typedef std::map<int,osg::ref_ptr<osg::StateSet> >* MaterialMapType;
    MaterialMapType _materialMap;

    std::vector<osg::ref_ptr<osg::StateSet> >    _localMaterials;

    typedef std::map<int,osg::ref_ptr<osg::Node> > OSGModelsMapType;
    OSGModelsMapType*      _models;

    trpgTileHeader    _tileHeader;

    bool _underBillboardSubgraph;

    int _numBillboardLevels;

    TXPBillboardInfo _lastBillboardInfo;

    bool _underLayerSubgraph;

    int _numLayerLevels;

    osg::Geode*    _layerGeode;

    float _defaultMaxAnisotropy;

    double _realMinRange;
    double _realMaxRange;
    double _usedMaxRange;

    osg::Vec3 _tileCenter;

    osg::Geode* createBoundingBox(int x,int y, int lod);

    private:

       childRefRead *_childRefCB;


};


//----------------------------------------------------------------------------
class geomRead : public trpgr_Callback
{
public:

    geomRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};


//----------------------------------------------------------------------------
class groupRead : public trpgr_Callback
{
public:
    groupRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class attachRead : public trpgr_Callback
{
public:
    attachRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;

};
//----------------------------------------------------------------------------
class childRefRead : public trpgr_Callback
{
public:
   typedef std::vector<trpgChildRef> ChildRefList;

    childRefRead(TXPParser *in_parse) : _parse(in_parse)
    {}
    void Reset();
    virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;

   unsigned int GetNbChildrenRef() const
   {
      return childRefList.size();
   }
   const trpgChildRef* GetChildRef(unsigned int idx) const
   {
      if(idx >= childRefList.size())
         return 0;
      else
         return &childRefList[idx];
   }

protected:
    TXPParser *_parse;



private:

   ChildRefList childRefList;


};

//----------------------------------------------------------------------------
class lodRead : public trpgr_Callback
{
public:
    lodRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class tileHeaderRead : public trpgr_Callback
{
public:
    tileHeaderRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------

class modelRefRead : public trpgr_Callback
{
public:
    modelRefRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class billboardRead : public trpgr_Callback
{
public:
    billboardRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class lightRead: public trpgr_Callback
{
public:
    lightRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class layerRead: public trpgr_Callback
{
public:
    layerRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

//----------------------------------------------------------------------------
class labelRead: public trpgr_Callback
{
public:
    labelRead(TXPParser* in_parse)
      : _parse(in_parse)
   {
   }
   virtual void * Parse(trpgToken tok, trpgReadBuffer& buf) override;
protected:
    TXPParser *_parse;
};

} 

#endif