OgreMeshManager.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 __MeshManager_H__
#define __MeshManager_H__

#include "OgrePrerequisites.h"

#include "OgreResourceManager.h"
#include "OgreSingleton.h"
#include "OgreVector3.h"
#include "OgreHardwareBuffer.h"
#include "OgreMesh.h"
#include "OgrePatchMesh.h"

namespace Ogre {

    class _OgreExport MeshManager: public ResourceManager, public Singleton<MeshManager>, 
        public ManualResourceLoader
    {
    public:
        MeshManager();
        ~MeshManager();

        void _initialise(void);

        MeshPtr load( const String& filename, const String& groupName,
            HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            bool vertexBufferShadowed = true, bool indexBufferShadowed = true);


        MeshPtr createManual( const String& name, const String& groupName, 
            ManualResourceLoader* loader = 0);

        MeshPtr createPlane(
            const String& name, const String& groupName, const Plane& plane,
            Real width, Real height,
            int xsegments = 1, int ysegments = 1,
            bool normals = true, int numTexCoordSets = 1,
            Real uTile = 1.0f, Real vTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
            HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
            bool vertexShadowBuffer = true, bool indexShadowBuffer = true);

        
        MeshPtr createCurvedIllusionPlane(
            const String& name, const String& groupName, const Plane& plane,
            Real width, Real height, Real curvature,
            int xsegments = 1, int ysegments = 1,
            bool normals = true, int numTexCoordSets = 1,
            Real uTile = 1.0f, Real vTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
            const Quaternion& orientation = Quaternion::IDENTITY,
            HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
            bool vertexShadowBuffer = true, bool indexShadowBuffer = true, 
            int ySegmentsToKeep = -1);

        MeshPtr createCurvedPlane( 
            const String& name, const String& groupName, const Plane& plane, 
            Real width, Real height, Real bow = 0.5f, 
            int xsegments = 1, int ysegments = 1,
            bool normals = false, int numTexCoordSets = 1, 
            Real xTile = 1.0f, Real yTile = 1.0f, const Vector3& upVector = Vector3::UNIT_Y,
            HardwareBuffer::Usage vertexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
            bool vertexShadowBuffer = true, bool indexShadowBuffer = true);

        PatchMeshPtr createBezierPatch(
            const String& name, const String& groupName, void* controlPointBuffer, 
            VertexDeclaration *declaration, size_t width, size_t height,
            size_t uMaxSubdivisionLevel = PatchSurface::AUTO_LEVEL, 
            size_t vMaxSubdivisionLevel = PatchSurface::AUTO_LEVEL,
            PatchSurface::VisibleSide visibleSide = PatchSurface::VS_FRONT,
            HardwareBuffer::Usage vbUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY, 
            HardwareBuffer::Usage ibUsage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY,
            bool vbUseShadow = true, bool ibUseShadow = true);
        
        void setPrepareAllMeshesForShadowVolumes(bool enable);
        bool getPrepareAllMeshesForShadowVolumes(void);

        static MeshManager& getSingleton(void);
        static MeshManager* getSingletonPtr(void);

        Real getBoundsPaddingFactor(void);
    
        void setBoundsPaddingFactor(Real paddingFactor);

        void loadResource(Resource* res);

    protected:
        Resource* createImpl(const String& name, ResourceHandle handle, 
            const String& group, bool isManual, ManualResourceLoader* loader, 
            const NameValuePairList* createParams);
        
        void tesselate2DMesh(SubMesh* pSub, int meshWidth, int meshHeight, 
            bool doubleSided = false, 
            HardwareBuffer::Usage indexBufferUsage = HardwareBuffer::HBU_STATIC_WRITE_ONLY,
            bool indexSysMem = false);

        void createPrefabPlane(void);
    
        enum MeshBuildType
        {
            MBT_PLANE,
            MBT_CURVED_ILLUSION_PLANE,
            MBT_CURVED_PLANE
        };
        struct MeshBuildParams
        {
            MeshBuildType type;
            Plane plane;
            Real width;
            Real height;
            Real curvature;
            int xsegments;
            int ysegments;
            bool normals;
            int numTexCoordSets;
            Real xTile;
            Real yTile;
            Vector3 upVector;
            Quaternion orientation;
            HardwareBuffer::Usage vertexBufferUsage;
            HardwareBuffer::Usage indexBufferUsage;
            bool vertexShadowBuffer;
            bool indexShadowBuffer;
            int ySegmentsToKeep;
        };
        typedef std::map<Resource*, MeshBuildParams> MeshBuildParamsMap;
        MeshBuildParamsMap mMeshBuildParams;

        void loadManualPlane(Mesh* pMesh, MeshBuildParams& params);
        void loadManualCurvedPlane(Mesh* pMesh, MeshBuildParams& params);
        void loadManualCurvedIllusionPlane(Mesh* pMesh, MeshBuildParams& params);

        bool mPrepAllMeshesForShadowVolumes;
    
    //the factor by which the bounding box of an entity is padded   
    Real mBoundsPaddingFactor;
    };


} //namespace

#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:44 2006