TXPArchive.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 __TXPARCHIVE_H_
#define __TXPARCHIVE_H_

#include "trpage_sys.h"
#include "trpage_read.h"
#include "trpage_geom.h"

#include <osg/Referenced>
#include <osg/BoundingBox>
#include <osg/Texture2D>
#include <osg/StateSet>
#include <osg/Node>
#include <osg/PagedLOD>
#include <osg/Array>
#include <osgSim/LightPointNode>
#include <osgText/Font>

#include <OpenThreads/Mutex>

namespace txp
{
    struct DeferredLightAttribute
    {
        osg::ref_ptr<osgSim::LightPointNode> lightPoint;
        osg::ref_ptr<osg::StateSet> fallback;
        osg::Vec3 attitude;
    };

    class TXPParser;
    class DT_DLL_osgdb_vrftxp TXPArchive : public trpgr_Archive, public osg::Referenced
    {
    public:
        TXPArchive();

        bool openFile(const std::string& archiveName);
        bool loadMaterials();
        bool loadMaterial(int ix);
        bool loadTexture(int i);

        bool loadModels();
        bool loadModel(int ix);

        bool loadLightAttributes();

        bool loadTextStyles();
        inline std::map<int, osg::ref_ptr<osgText::Font> >& getStyles()
        {
            return _fonts;
        }
        inline std::map<int, osg::Vec4 >& getTextColors()
        {
            return _fcolors;
        }

        void addLightAttribute(osgSim::LightPointNode* lpn, osg::StateSet* fallback , const osg::Vec3& attitude,int handle);

        int getNumLightAttributes()
        {
            return _lights.size();
        }

        inline DeferredLightAttribute& getLightAttribute(unsigned int i)
        {
            return _lights[i];
        };

        struct TileInfo
        {
            osg::Vec3           center;
            double              minRange;
            double              maxRange;
            double              lod0Range;
            float               radius;
            osg::Vec3           size;
            osg::BoundingBox    bbox;
        };
        struct TileLocationInfo
        {
            TileLocationInfo() : x( -1 ), y( -1 ), lod( -1 )
            {}
            TileLocationInfo(int gx, int gy, int glod, const trpgwAppAddress& gaddr, float gzmin = 0.0f, float gzmax = 0.0f):
                    x( gx ), y( gy ), lod( glod ), addr( gaddr ), zmin( gzmin ), zmax( gzmax )
            {}
            int x, y, lod;
            trpgwAppAddress addr;
            float zmin, zmax;
        };

        bool getTileInfo(int x, int y, int lod, TileInfo& info);
        bool getTileInfo(const TileLocationInfo& loc, TileInfo& info);

        inline void setId(int id)
        {
            _id = id;
        }
        inline const int& getId() const
        {
            return _id;
        }

        inline const int& getNumLODs() const
        {
            return _numLODs;
        }

        void getExtents(osg::BoundingBox& extents);

        inline void getOrigin(double& x, double& y)
        {
            x=_swExtents.x;
            y=_swExtents.y;
        }

        inline osg::Texture2D* getGlobalTexture(int id)
        {
            return GetTexMapEntry(id).get();
        }

        osg::Group* getTileContent(
                int x,
                int y,
                int lod,
                double realMinRange,
                double realMaxRange,
                double usedMaxRange,
                osg::Vec3& tileCenter,
                std::vector<TileLocationInfo>& childInfoList);

        osg::Group* getTileContent(
                const TileLocationInfo& loc,
                double realMinRange,
                double realMaxRange,
                double usedMaxRange,
                osg::Vec3& tileCenter,
                std::vector<TileLocationInfo>& childInfoList);

        bool getLODSize(int lod, int& x, int& y);

        void GetVersion(int& majorVer, int& minorVer) const
        {
            majorVer = _majorVersion;
            minorVer = _minorVersion;
        }

        //
        void SetUserDataToMaterialAttributes(osg::StateSet& osg_state_set, const trpgMaterial& mat)
        {
            if(!_loadMaterialsToStateSet)
                return;

            int attr_values = 0;
            osg::ref_ptr<osg::IntArray> ourValueArray = new osg::IntArray();
            for(int attrIter = 0 ; attrIter < 4; ++attrIter)
            {
                mat.GetAttr(attrIter, attr_values);
                ourValueArray->push_back(attr_values);
            }
            osg_state_set.setUserData(ourValueArray.get());
        }

        void SetMaterialAttributesToStateSetVar(bool value) {_loadMaterialsToStateSet = value;}

        static void setShouldLoadDisplayData(bool);
        static bool shouldLoadDisplayData();
        static void setExternalLoadOptions(osg::ref_ptr<osgDB::ReaderWriter::Options> opts);
        static osg::ref_ptr<osgDB::ReaderWriter::Options> externalLoadOptions();

        static void setShouldLoadLocalMaterials(bool);
        static bool shouldLoadLocalMaterials();

    protected:

        virtual ~TXPArchive();

        int _id;

        int _numLODs;

        trpg2dPoint _swExtents;
        trpg2dPoint _neExtents;

        osg::ref_ptr<TXPParser>    _parser;

        typedef std::map<int,osg::ref_ptr<osg::Texture2D> > OSGTexMapType;
        OSGTexMapType _texmap;

        void SetTexMap(int key,osg::ref_ptr<osg::Texture2D> ref);
        osg::ref_ptr<osg::Texture2D> GetTexMapEntry(int key);


        typedef std::map<int,osg::ref_ptr<osg::StateSet> > OSGStatesMapType;
        OSGStatesMapType _statesMap;

        void SetStatesMap(int key,osg::ref_ptr<osg::StateSet> ref);
        osg::ref_ptr<osg::StateSet> GetStatesMapEntry(int key);

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

        std::map<int, DeferredLightAttribute>           _lights;

        std::map<int, osg::ref_ptr<osgText::Font> >    _fonts;

        std::map<int, osg::Vec4 >            _fcolors;

        //
        OpenThreads::Mutex  _mutex;

        int _majorVersion, _minorVersion;

        bool _isMaster;

        bool _loadMaterialsToStateSet;

    };

} 

#endif