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
    {
    private:
        // Pre-blended 
        HardwareVertexBufferSharedPtr srcPositionBuffer;
        HardwareVertexBufferSharedPtr srcNormalBuffer;
        // Post-blended 
        HardwareVertexBufferSharedPtr destPositionBuffer;
        HardwareVertexBufferSharedPtr destNormalBuffer;
        bool posNormalShareBuffer;
        unsigned short posBindIndex;
        unsigned short normBindIndex;
        bool bindPositions;
        bool bindNormals;

    public:
        ~TempBlendedBufferInfo(void);
        void extractFrom(const VertexData* sourceData);
        void checkoutTempCopies(bool positions = true, bool normals = true);
        void bindTempCopies(VertexData* targetData, bool suppressHardwareUpload);
        void licenseExpired(HardwareBuffer* buffer);
        bool buffersCheckedOut(bool positions = true, bool normals = true) const;
    };


    class _OgreExport HardwareBufferManager : public Singleton<HardwareBufferManager>
    {
        friend class HardwareVertexBufferSharedPtr;
        friend class HardwareIndexBufferSharedPtr;
    protected:
        typedef std::set<HardwareVertexBuffer*> VertexBufferList;
        typedef std::set<HardwareIndexBuffer*> IndexBufferList;
        VertexBufferList mVertexBuffers;
        IndexBufferList mIndexBuffers;


        typedef std::set<VertexDeclaration*> VertexDeclarationList;
        typedef std::set<VertexBufferBinding*> VertexBufferBindingList;
        VertexDeclarationList mVertexDeclarations;
        VertexBufferBindingList mVertexBufferBindings;


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

        virtual VertexDeclaration* createVertexDeclarationImpl(void);
        virtual void destroyVertexDeclarationImpl(VertexDeclaration* decl);

        virtual VertexBufferBinding* createVertexBufferBindingImpl(void);
        virtual void destroyVertexBufferBindingImpl(VertexBufferBinding* binding);

    public:

        enum BufferLicenseType
        {
            BLT_MANUAL_RELEASE,
            BLT_AUTOMATIC_RELEASE
        };

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

        };

        typedef std::multimap<HardwareVertexBuffer*, HardwareVertexBufferSharedPtr> FreeTemporaryVertexBufferMap;
        FreeTemporaryVertexBufferMap mFreeTempVertexBufferMap;
        typedef std::map<HardwareVertexBuffer*, VertexBufferLicense> TemporaryVertexBufferLicenseMap;
        TemporaryVertexBufferLicenseMap mTempVertexBufferLicenses;
        size_t mUnderUsedFrameCount;
        static const size_t UNDER_USED_FRAME_THRESHOLD;
        static const size_t EXPIRED_DELAY_FRAME_THRESHOLD;


        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 touchVertexBufferCopy(
            const HardwareVertexBufferSharedPtr& bufferCopy);

        virtual void _freeUnusedBufferCopies(void);

        virtual void _releaseBufferCopies(bool forceFreeUnused = false);

        virtual void _forceReleaseBufferCopies(
            const HardwareVertexBufferSharedPtr& sourceBuffer);

        virtual 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 Mar 12 14:37:42 2006