OgreBspLevel.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
    (Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2005 The OGRE Team
Also see acknowledgements in Readme.html

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt.
-----------------------------------------------------------------------------
*/
#ifndef _BspLevel_H__
#define _BspLevel_H__

#include "OgreBspPrerequisites.h"
#include "OgreResource.h"
#include "OgreStaticFaceGroup.h"
#include "OgreSceneManager.h"
#include "OgreBspNode.h"
#include "OgreHardwareBufferManager.h"
#include "OgreDefaultHardwareBufferManager.h"
#include "OgreQuake3Level.h"


namespace Ogre {

    class BspLevel : public Resource
    {
        friend class BspSceneManager;
    public:
        BspLevel(ResourceManager* creator, const String& name, ResourceHandle handle,
            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
        ~BspLevel();

        bool isLeafVisible(const BspNode* from, const BspNode* to) const;

        const BspNode* getRootNode(void);

        BspNode* findLeaf(const Vector3& point) const;

        void _notifyObjectMoved(const MovableObject* mov, 
            const Vector3& pos);
        void _notifyObjectDetached(const MovableObject* mov);
        BspNode* getLeafStart(void) {return &mRootNode[mLeafStart]; }
        int getNumLeaves(void) const { return mNumLeaves; }

        static size_t calculateLoadingStages(const String& levelName);
        static size_t calculateLoadingStages(DataStreamPtr& stream);

        void load(DataStreamPtr& stream);

        bool isSkyEnabled(void) const;
        const String& getSkyMaterialName(void) const;
        Real getSkyCurvature(void) const;

    protected:
        void loadImpl(void);
        void unloadImpl(void);
        size_t calculateSize(void) const;
        BspNode* mRootNode;
        int mNumNodes;
        int mNumLeaves;
        int mLeafStart; // the index at which leaf nodes begin

        struct BspVertex
        {
            float position[3];
            float normal[3];
            int colour;
            float texcoords[2];
            float lightmap[2];
        };
        /*
        BspVertex* mVertices;
        int mNumVertices;
        */
        VertexData* mVertexData;

        int* mLeafFaceGroups;
        int mNumLeafFaceGroups;

        StaticFaceGroup* mFaceGroups;
        int mNumFaceGroups;


        /*
        int* mElements;
        int mNumElements;
        */

        size_t mNumIndexes;
        // system-memory buffer
        HardwareIndexBufferSharedPtr mIndexes;

        BspNode::Brush *mBrushes;

        std::vector<ViewPoint> mPlayerStarts;

        void loadQuake3Level(const Quake3Level& q3lvl);
        struct VisData
        {
            unsigned char *tableData;
            int numClusters;            // Number of clusters, therefore number of rows
            int rowLength;                // Length in bytes of each row (num clusters / 8 rounded up)
        };

        VisData mVisData;


        void loadEntities(const Quake3Level& q3lvl);

        typedef std::map<const MovableObject*, std::list<BspNode*> > MovableToNodeMap;
        MovableToNodeMap mMovableToNodeMap;

        void tagNodesWithMovable(BspNode* node, const MovableObject* mov, const Vector3& pos);

        // Storage of patches 
        typedef std::map<int, PatchSurface*> PatchMap;
        PatchMap mPatches;
        // Total number of vertices required for all patches
        size_t mPatchVertexCount;
        // Total number of indexes required for all patches
        size_t mPatchIndexCount;
        // Sky enabled?
        bool mSkyEnabled;
        // Sky material
        String mSkyMaterial;
        // Sky details
        Real mSkyCurvature;


        void initQuake3Patches(const Quake3Level & q3lvl, VertexDeclaration* decl);
        void buildQuake3Patches(size_t vertOffset, size_t indexOffset);

        void quakeVertexToBspVertex(const bsp_vertex_t* src, BspVertex* dest);


    };
    class BspLevelPtr : public SharedPtr<BspLevel> 
    {
    public:
        BspLevelPtr() : SharedPtr<BspLevel>() {}
        explicit BspLevelPtr(BspLevel* rep) : SharedPtr<BspLevel>(rep) {}
        BspLevelPtr(const BspLevelPtr& r) : SharedPtr<BspLevel>(r) {} 
        BspLevelPtr(const ResourcePtr& r) : SharedPtr<BspLevel>()
        {
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<BspLevel*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
        }

        BspLevelPtr& operator=(const ResourcePtr& r)
        {
            if (pRep == static_cast<BspLevel*>(r.getPointer()))
                return *this;
            release();
            // lock & copy other mutex pointer
            OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
            OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
            pRep = static_cast<BspLevel*>(r.getPointer());
            pUseCount = r.useCountPointer();
            if (pUseCount)
            {
                ++(*pUseCount);
            }
            return *this;
        }
    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Mar 12 14:37:37 2006