OgreHardwareBufferManager.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 __HardwareBufferManager__
#define __HardwareBufferManager__

// Precompiler options
#include "OgrePrerequisites.h"

#include "OgreSingleton.h"
#include "OgreHardwareVertexBuffer.h"
#include "OgreHardwareIndexBuffer.h"


namespace Ogre {

    class _OgreExport HardwareBufferLicensee
    {
    public:
        virtual ~HardwareBufferLicensee() { }
        virtual void licenseExpired(HardwareBuffer* buffer) = 0;
    };

    class _OgreExport TempBlendedBufferInfo : public HardwareBufferLicensee
    {
    public:
        // Pre-blended 
        HardwareVertexBufferSharedPtr srcPositionBuffer;
        HardwareVertexBufferSharedPtr srcNormalBuffer;
        // Post-blended 
        HardwareVertexBufferSharedPtr destPositionBuffer;
        HardwareVertexBufferSharedPtr destNormalBuffer;
        bool posNormalShareBuffer;
        unsigned short posBindIndex;
        unsigned short normBindIndex;
        bool bindPositions;
        bool bindNormals;

        ~TempBlendedBufferInfo(void);
        void checkoutTempCopies(bool positions = true, bool normals = true);
        void bindTempCopies(VertexData* targetData, bool suppressHardwareUpload);
        void licenseExpired(HardwareBuffer* buffer);
    };


    class _OgreExport HardwareBufferManager : public Singleton<HardwareBufferManager>
    {
        friend class HardwareVertexBufferSharedPtr;
        friend class HardwareIndexBufferSharedPtr;
    protected:
        typedef std::list<VertexDeclaration*> VertexDeclarationList;
        typedef std::list<VertexBufferBinding*> VertexBufferBindingList;

        VertexDeclarationList mVertexDeclarations;
        VertexBufferBindingList mVertexBufferBindings;


        virtual void destroyAllDeclarations(void);
        virtual void destroyAllBindings(void);

    public:

        enum BufferLicenseType
        {
            BLT_MANUAL_RELEASE,
            BLT_AUTOMATIC_RELEASE
        };

    protected:
        class _OgrePrivate VertexBufferLicense
        {
        public:
            HardwareVertexBuffer* originalBufferPtr;
            BufferLicenseType licenseType;
            HardwareVertexBufferSharedPtr buffer;
            HardwareBufferLicensee* licensee;
            VertexBufferLicense(
                HardwareVertexBuffer* orig,
                BufferLicenseType ltype, 
                HardwareVertexBufferSharedPtr buf, 
                HardwareBufferLicensee* lic) 
                : originalBufferPtr(orig), licenseType(ltype), buffer(buf), licensee(lic) {}

        };

        typedef std::vector<HardwareVertexBufferSharedPtr> FreeTemporaryVertexBufferList;
        typedef std::map<HardwareVertexBuffer*, FreeTemporaryVertexBufferList*> FreeTemporaryVertexBufferMap;
        FreeTemporaryVertexBufferMap mFreeTempVertexBufferMap;
        typedef std::vector<VertexBufferLicense> TemporaryVertexBufferLicenseList;
        TemporaryVertexBufferLicenseList mTempVertexBufferLicenses;

        typedef std::set<HardwareVertexBuffer*> VertexBufferList;
        typedef std::set<HardwareIndexBuffer*> IndexBufferList;
        VertexBufferList mVertexBuffers;
        IndexBufferList mIndexBuffers;


        HardwareVertexBufferSharedPtr makeBufferCopy(
            const HardwareVertexBufferSharedPtr& source, 
            HardwareBuffer::Usage usage, bool useShadowBuffer);

    public:
        HardwareBufferManager();
        virtual ~HardwareBufferManager();
        virtual HardwareVertexBufferSharedPtr 
            createVertexBuffer(size_t vertexSize, size_t numVerts, HardwareBuffer::Usage usage, 
            bool useShadowBuffer = false) = 0;
        virtual HardwareIndexBufferSharedPtr 
            createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, 
            HardwareBuffer::Usage usage, bool useShadowBuffer = false) = 0;
        virtual VertexDeclaration* createVertexDeclaration(void);
        virtual void destroyVertexDeclaration(VertexDeclaration* decl);

        virtual VertexBufferBinding* createVertexBufferBinding(void);
        virtual void destroyVertexBufferBinding(VertexBufferBinding* binding);

        virtual void registerVertexBufferSourceAndCopy(
            const HardwareVertexBufferSharedPtr& sourceBuffer,
            const HardwareVertexBufferSharedPtr& copy);

        virtual HardwareVertexBufferSharedPtr allocateVertexBufferCopy(
            const HardwareVertexBufferSharedPtr& sourceBuffer, 
            BufferLicenseType licenseType,
            HardwareBufferLicensee* licensee,
            bool copyData = false);
        virtual void releaseVertexBufferCopy(
            const HardwareVertexBufferSharedPtr& bufferCopy); 

        virtual void _releaseBufferCopies(void);

        virtual void _forceReleaseBufferCopies(
            const HardwareVertexBufferSharedPtr& sourceBuffer)
        { _forceReleaseBufferCopies(sourceBuffer.get()); }

        void _forceReleaseBufferCopies(HardwareVertexBuffer* sourceBuffer);

        void _notifyVertexBufferDestroyed(HardwareVertexBuffer* buf);
        void _notifyIndexBufferDestroyed(HardwareIndexBuffer* buf);

        static HardwareBufferManager& getSingleton(void);
        static HardwareBufferManager* getSingletonPtr(void);
            
    };

}

#endif

---

Copyright © 2000-2005 by The OGRE Team

This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Feb 12 12:59:46 2006