00001 /* 00002 ----------------------------------------------------------------------------- 00003 This source file is part of OGRE 00004 (Object-oriented Graphics Rendering Engine) 00005 For the latest info, see http://www.ogre3d.org/ 00006 00007 Copyright (c) 2000-2006 Torus Knot Software Ltd 00008 Also see acknowledgements in Readme.html 00009 00010 This program is free software; you can redistribute it and/or modify it under 00011 the terms of the GNU Lesser General Public License as published by the Free Software 00012 Foundation; either version 2 of the License, or (at your option) any later 00013 version. 00014 00015 This program is distributed in the hope that it will be useful, but WITHOUT 00016 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 00017 FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. 00018 00019 You should have received a copy of the GNU Lesser General Public License along with 00020 this program; if not, write to the Free Software Foundation, Inc., 59 Temple 00021 Place - Suite 330, Boston, MA 02111-1307, USA, or go to 00022 http://www.gnu.org/copyleft/lesser.txt. 00023 00024 You may alternatively use this source under the terms of a specific version of 00025 the OGRE Unrestricted License provided you have obtained such a license from 00026 Torus Knot Software Ltd. 00027 ----------------------------------------------------------------------------- 00028 */ 00029 #ifndef __HardwareBuffer__ 00030 #define __HardwareBuffer__ 00031 00032 // Precompiler options 00033 #include "OgrePrerequisites.h" 00034 00035 namespace Ogre { 00036 00068 class _OgreExport HardwareBuffer : public BufferAlloc 00069 { 00070 00071 public: 00073 enum Usage 00074 { 00078 HBU_STATIC = 1, 00084 HBU_DYNAMIC = 2, 00091 HBU_WRITE_ONLY = 4, 00100 HBU_DISCARDABLE = 8, 00102 HBU_STATIC_WRITE_ONLY = 5, 00108 HBU_DYNAMIC_WRITE_ONLY = 6, 00110 HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE = 14 00111 00112 00113 }; 00115 enum LockOptions 00116 { 00118 HBL_NORMAL, 00123 HBL_DISCARD, 00127 HBL_READ_ONLY, 00131 HBL_NO_OVERWRITE 00132 00133 }; 00134 protected: 00135 size_t mSizeInBytes; 00136 Usage mUsage; 00137 bool mIsLocked; 00138 size_t mLockStart; 00139 size_t mLockSize; 00140 bool mSystemMemory; 00141 bool mUseShadowBuffer; 00142 HardwareBuffer* mpShadowBuffer; 00143 bool mShadowUpdated; 00144 bool mSuppressHardwareUpdate; 00145 00147 virtual void* lockImpl(size_t offset, size_t length, LockOptions options) = 0; 00149 virtual void unlockImpl(void) = 0; 00150 00151 public: 00153 HardwareBuffer(Usage usage, bool systemMemory, bool useShadowBuffer) 00154 : mUsage(usage), mIsLocked(false), mSystemMemory(systemMemory), 00155 mUseShadowBuffer(useShadowBuffer), mpShadowBuffer(NULL), mShadowUpdated(false), 00156 mSuppressHardwareUpdate(false) 00157 { 00158 // If use shadow buffer, upgrade to WRITE_ONLY on hardware side 00159 if (useShadowBuffer && usage == HBU_DYNAMIC) 00160 { 00161 mUsage = HBU_DYNAMIC_WRITE_ONLY; 00162 } 00163 else if (useShadowBuffer && usage == HBU_STATIC) 00164 { 00165 mUsage = HBU_STATIC_WRITE_ONLY; 00166 } 00167 } 00168 virtual ~HardwareBuffer() {} 00175 virtual void* lock(size_t offset, size_t length, LockOptions options) 00176 { 00177 assert(!isLocked() && "Cannot lock this buffer, it is already locked!"); 00178 void* ret; 00179 if (mUseShadowBuffer) 00180 { 00181 if (options != HBL_READ_ONLY) 00182 { 00183 // we have to assume a read / write lock so we use the shadow buffer 00184 // and tag for sync on unlock() 00185 mShadowUpdated = true; 00186 } 00187 00188 ret = mpShadowBuffer->lock(offset, length, options); 00189 } 00190 else 00191 { 00192 // Lock the real buffer if there is no shadow buffer 00193 ret = lockImpl(offset, length, options); 00194 mIsLocked = true; 00195 } 00196 mLockStart = offset; 00197 mLockSize = length; 00198 return ret; 00199 } 00200 00205 void* lock(LockOptions options) 00206 { 00207 return this->lock(0, mSizeInBytes, options); 00208 } 00221 virtual void unlock(void) 00222 { 00223 assert(isLocked() && "Cannot unlock this buffer, it is not locked!"); 00224 00225 // If we used the shadow buffer this time... 00226 if (mUseShadowBuffer && mpShadowBuffer->isLocked()) 00227 { 00228 mpShadowBuffer->unlock(); 00229 // Potentially update the 'real' buffer from the shadow buffer 00230 _updateFromShadow(); 00231 } 00232 else 00233 { 00234 // Otherwise, unlock the real one 00235 unlockImpl(); 00236 mIsLocked = false; 00237 } 00238 00239 } 00240 00247 virtual void readData(size_t offset, size_t length, void* pDest) = 0; 00256 virtual void writeData(size_t offset, size_t length, const void* pSource, 00257 bool discardWholeBuffer = false) = 0; 00258 00269 virtual void copyData(HardwareBuffer& srcBuffer, size_t srcOffset, 00270 size_t dstOffset, size_t length, bool discardWholeBuffer = false) 00271 { 00272 const void *srcData = srcBuffer.lock( 00273 srcOffset, length, HBL_READ_ONLY); 00274 this->writeData(dstOffset, length, srcData, discardWholeBuffer); 00275 srcBuffer.unlock(); 00276 } 00277 00279 virtual void _updateFromShadow(void) 00280 { 00281 if (mUseShadowBuffer && mShadowUpdated && !mSuppressHardwareUpdate) 00282 { 00283 // Do this manually to avoid locking problems 00284 const void *srcData = mpShadowBuffer->lockImpl( 00285 mLockStart, mLockSize, HBL_READ_ONLY); 00286 // Lock with discard if the whole buffer was locked, otherwise normal 00287 LockOptions lockOpt; 00288 if (mLockStart == 0 && mLockSize == mSizeInBytes) 00289 lockOpt = HBL_DISCARD; 00290 else 00291 lockOpt = HBL_NORMAL; 00292 00293 void *destData = this->lockImpl( 00294 mLockStart, mLockSize, lockOpt); 00295 // Copy shadow to real 00296 memcpy(destData, srcData, mLockSize); 00297 this->unlockImpl(); 00298 mpShadowBuffer->unlockImpl(); 00299 mShadowUpdated = false; 00300 } 00301 } 00302 00304 size_t getSizeInBytes(void) const { return mSizeInBytes; } 00306 Usage getUsage(void) const { return mUsage; } 00308 bool isSystemMemory(void) const { return mSystemMemory; } 00310 bool hasShadowBuffer(void) const { return mUseShadowBuffer; } 00312 bool isLocked(void) const { 00313 return mIsLocked || (mUseShadowBuffer && mpShadowBuffer->isLocked()); 00314 } 00316 void suppressHardwareUpdate(bool suppress) { 00317 mSuppressHardwareUpdate = suppress; 00318 if (!suppress) 00319 _updateFromShadow(); 00320 } 00321 00322 00323 00324 00325 00326 }; 00327 } 00328 #endif 00329 00330
Copyright © 2008 Torus Knot Software Ltd
This work is licensed under a Creative Commons Attribution-ShareAlike 2.5 License.
Last modified Sun Sep 27 22:02:23 2009