OgreHardwareBuffer.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 __HardwareBuffer__
#define __HardwareBuffer__

// Precompiler options
#include "OgrePrerequisites.h"

namespace Ogre {

    class _OgreExport HardwareBuffer 
    {

        public:
            enum Usage 
            {
                HBU_STATIC = 1,
                HBU_DYNAMIC = 2,
                HBU_WRITE_ONLY = 4,
                HBU_DISCARDABLE = 8,
                HBU_STATIC_WRITE_ONLY = 5, 
                HBU_DYNAMIC_WRITE_ONLY = 6,
                HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE = 14


            };
            enum LockOptions
            {
                HBL_NORMAL,
                HBL_DISCARD,
                HBL_READ_ONLY,
                HBL_NO_OVERWRITE
                
            };
        protected:
            size_t mSizeInBytes;
            Usage mUsage;
            bool mIsLocked;
            size_t mLockStart;
            size_t mLockSize;
            bool mSystemMemory;
            bool mUseShadowBuffer;
            HardwareBuffer* mpShadowBuffer;
            bool mShadowUpdated;
            bool mSuppressHardwareUpdate;
            
            virtual void* lockImpl(size_t offset, size_t length, LockOptions options) = 0;
            virtual void unlockImpl(void) = 0;

    public:
            HardwareBuffer(Usage usage, bool systemMemory, bool useShadowBuffer) 
                : mUsage(usage), mIsLocked(false), mSystemMemory(systemMemory), 
                mUseShadowBuffer(useShadowBuffer), mpShadowBuffer(NULL), mShadowUpdated(false), 
                mSuppressHardwareUpdate(false) 
            {
                // If use shadow buffer, upgrade to WRITE_ONLY on hardware side
                if (useShadowBuffer && usage == HBU_DYNAMIC)
                {
                    mUsage = HBU_DYNAMIC_WRITE_ONLY;
                }
                else if (useShadowBuffer && usage == HBU_STATIC)
                {
                    mUsage = HBU_STATIC_WRITE_ONLY;
                }
            }
            virtual ~HardwareBuffer() {}
            virtual void* lock(size_t offset, size_t length, LockOptions options)
            {
                assert(!isLocked() && "Cannot lock this buffer, it is already locked!");
                void* ret;
                if (mUseShadowBuffer)
                {
                    if (options != HBL_READ_ONLY)
                    {
                        // we have to assume a read / write lock so we use the shadow buffer
                        // and tag for sync on unlock()
                        mShadowUpdated = true;
                    }

                    ret = mpShadowBuffer->lock(offset, length, options);
                }
                else
                {
                    // Lock the real buffer if there is no shadow buffer 
                    ret = lockImpl(offset, length, options);
                    mIsLocked = true;
                }
                mLockStart = offset;
                mLockSize = length;
                return ret;
            }

            void* lock(LockOptions options)
            {
                return this->lock(0, mSizeInBytes, options);
            }
            virtual void unlock(void)
            {
                assert(isLocked() && "Cannot unlock this buffer, it is not locked!");

                // If we used the shadow buffer this time...
                if (mUseShadowBuffer && mpShadowBuffer->isLocked())
                {
                    mpShadowBuffer->unlock();
                    // Potentially update the 'real' buffer from the shadow buffer
                    _updateFromShadow();
                }
                else
                {
                    // Otherwise, unlock the real one
                    unlockImpl();
                    mIsLocked = false;
                }

            }

            virtual void readData(size_t offset, size_t length, void* pDest) = 0;
            virtual void writeData(size_t offset, size_t length, const void* pSource,
                    bool discardWholeBuffer = false) = 0;

            virtual void copyData(HardwareBuffer& srcBuffer, size_t srcOffset, 
                size_t dstOffset, size_t length, bool discardWholeBuffer = false)
            {
                const void *srcData = srcBuffer.lock(
                    srcOffset, length, HBL_READ_ONLY);
                this->writeData(dstOffset, length, srcData, discardWholeBuffer);
                srcBuffer.unlock();
            }

            virtual void _updateFromShadow(void)
            {
                if (mUseShadowBuffer && mShadowUpdated && !mSuppressHardwareUpdate)
                {
                    // Do this manually to avoid locking problems
                    const void *srcData = mpShadowBuffer->lockImpl(
                        mLockStart, mLockSize, HBL_READ_ONLY);
                    // Lock with discard if the whole buffer was locked, otherwise normal
                    LockOptions lockOpt;
                    if (mLockStart == 0 && mLockSize == mSizeInBytes)
                        lockOpt = HBL_DISCARD;
                    else
                        lockOpt = HBL_NORMAL;
                    
                    void *destData = this->lockImpl(
                        mLockStart, mLockSize, lockOpt);
                    // Copy shadow to real
                    memcpy(destData, srcData, mLockSize);
                    this->unlockImpl();
                    mpShadowBuffer->unlockImpl();
                    mShadowUpdated = false;
                }
            }

            size_t getSizeInBytes(void) const { return mSizeInBytes; }
            Usage getUsage(void) const { return mUsage; }
            bool isSystemMemory(void) const { return mSystemMemory; }
            bool hasShadowBuffer(void) const { return mUseShadowBuffer; }
            bool isLocked(void) const { 
                return mIsLocked || (mUseShadowBuffer && mpShadowBuffer->isLocked()); 
            }
            void suppressHardwareUpdate(bool suppress) {
                mSuppressHardwareUpdate = suppress;
                if (!suppress)
                    _updateFromShadow();
            }




            
    };
}
#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