diff --git a/RenderSystems/Direct3D9/include/OgreD3D9HardwareVertexBuffer.h b/RenderSystems/Direct3D9/include/OgreD3D9HardwareBuffer.h similarity index 88% rename from RenderSystems/Direct3D9/include/OgreD3D9HardwareVertexBuffer.h rename to RenderSystems/Direct3D9/include/OgreD3D9HardwareBuffer.h index 2468f39adb1..3de49a92050 100644 --- a/RenderSystems/Direct3D9/include/OgreD3D9HardwareVertexBuffer.h +++ b/RenderSystems/Direct3D9/include/OgreD3D9HardwareBuffer.h @@ -25,23 +25,23 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ----------------------------------------------------------------------------- */ -#ifndef __D3D9HARDWAREVERTEXBUFFER_H__ -#define __D3D9HARDWAREVERTEXBUFFER_H__ +#ifndef __D3D9HardwareBuffer_H__ +#define __D3D9HardwareBuffer_H__ #include "OgreD3D9Prerequisites.h" -#include "OgreHardwareVertexBuffer.h" +#include "OgreHardwareBuffer.h" #include "OgreD3D9Resource.h" namespace Ogre { /// Specialisation of HardwareVertexBuffer for D3D9 - class _OgreD3D9Export D3D9HardwareVertexBuffer : public HardwareVertexBuffer, public D3D9Resource + class _OgreD3D9Export D3D9HardwareBuffer : public HardwareBuffer, public D3D9Resource { public: - D3D9HardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize, - size_t numVertices, HardwareBuffer::Usage usage, bool useShadowBuffer); - ~D3D9HardwareVertexBuffer(); + D3D9HardwareBuffer(D3DFORMAT type, size_t sizeInBytes, Usage usage, + bool useShadowBuffer); + ~D3D9HardwareBuffer(); /** See HardwareBuffer. */ void readData(size_t offset, size_t length, void* pDest); /** See HardwareBuffer. */ @@ -63,13 +63,12 @@ namespace Ogre { // Create the actual vertex buffer. void createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool, bool updateNewBuffer); - /// Get D3D9-specific vertex buffer - IDirect3DVertexBuffer9* getD3D9VertexBuffer(void); - + /// Get D3D9-specific resource + IDirect3DResource9* getD3D9Resource(void); protected: struct BufferResources { - IDirect3DVertexBuffer9* mBuffer; + IDirect3DResource9* mBuffer; bool mOutOfDate; size_t mLockOffset; size_t mLockLength; @@ -105,7 +104,9 @@ namespace Ogre { D3DVERTEXBUFFER_DESC mBufferDesc; // Buffer description. BufferResources* mSourceBuffer; // Source buffer resources when working with multiple devices. char* mSourceLockedBytes; // Source buffer locked bytes. + D3DFORMAT mType; }; + } #endif diff --git a/RenderSystems/Direct3D9/include/OgreD3D9HardwareIndexBuffer.h b/RenderSystems/Direct3D9/include/OgreD3D9HardwareIndexBuffer.h deleted file mode 100644 index 0d3e5dcf26f..00000000000 --- a/RenderSystems/Direct3D9/include/OgreD3D9HardwareIndexBuffer.h +++ /dev/null @@ -1,110 +0,0 @@ -/* ------------------------------------------------------------------------------ -This source file is part of OGRE - (Object-oriented Graphics Rendering Engine) -For the latest info, see http://www.ogre3d.org/ - -Copyright (c) 2000-2014 Torus Knot Software Ltd - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. ------------------------------------------------------------------------------ -*/ -#ifndef __D3D9HARDWAREINDEXBUFFER_H__ -#define __D3D9HARDWAREINDEXBUFFER_H__ - -#include "OgreD3D9Prerequisites.h" -#include "OgreHardwareIndexBuffer.h" -#include "OgreD3D9Resource.h" - -namespace Ogre { - - - class _OgreD3D9Export D3D9HardwareIndexBuffer : public HardwareIndexBuffer, public D3D9Resource - { - - public: - D3D9HardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, size_t numIndexes, - HardwareBuffer::Usage usage, bool useShadowBuffer); - ~D3D9HardwareIndexBuffer(); - /** See HardwareBuffer. */ - void readData(size_t offset, size_t length, void* pDest); - /** See HardwareBuffer. */ - void writeData(size_t offset, size_t length, const void* pSource, - bool discardWholeBuffer = false); - - // Called immediately after the Direct3D device has been created. - virtual void notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device); - - // Called before the Direct3D device is going to be destroyed. - virtual void notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device); - - // Called immediately after the Direct3D device has entered a lost state. - virtual void notifyOnDeviceLost(IDirect3DDevice9* d3d9Device); - - // Called immediately after the Direct3D device has been reset - virtual void notifyOnDeviceReset(IDirect3DDevice9* d3d9Device); - - // Create the actual index buffer. - void createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool, bool updateNewBuffer); - - /// Get the D3D-specific index buffer - IDirect3DIndexBuffer9* getD3DIndexBuffer(void); - - protected: - struct BufferResources - { - IDirect3DIndexBuffer9* mBuffer; - bool mOutOfDate; - size_t mLockOffset; - size_t mLockLength; - LockOptions mLockOptions; - uint mLastUsedFrame; - }; - - protected: - /** See HardwareBuffer. */ - void* lockImpl(size_t offset, size_t length, LockOptions options); - - /** See HardwareBuffer. */ - void unlockImpl(void); - - /** Update the given buffer content.*/ - void updateBufferContent(BufferResources* bufferResources); - - // updates buffer resources from system memory buffer. - bool updateBufferResources(const char* systemMemoryBuffer, BufferResources* bufferResources); - - /** Internal buffer lock method. */ - char* _lockBuffer(BufferResources* bufferResources, size_t offset, size_t length); - - /** Internal buffer unlock method. */ - void _unlockBuffer(BufferResources* bufferResources); - - protected: - typedef std::map DeviceToBufferResourcesMap; - typedef DeviceToBufferResourcesMap::iterator DeviceToBufferResourcesIterator; - - DeviceToBufferResourcesMap mMapDeviceToBufferResources; // Map between device to buffer resources. - D3DINDEXBUFFER_DESC mBufferDesc; // Buffer description. - BufferResources* mSourceBuffer; // Source buffer resources when working with multiple devices. - char* mSourceLockedBytes; // Source buffer locked bytes. - }; -} -#endif - diff --git a/RenderSystems/Direct3D9/include/OgreD3D9Prerequisites.h b/RenderSystems/Direct3D9/include/OgreD3D9Prerequisites.h index 611ded51651..d33324e6594 100644 --- a/RenderSystems/Direct3D9/include/OgreD3D9Prerequisites.h +++ b/RenderSystems/Direct3D9/include/OgreD3D9Prerequisites.h @@ -90,7 +90,6 @@ namespace Ogre class D3D9GpuProgram; class D3D9GpuProgramManager; class D3D9HardwareBufferManager; - class D3D9HardwareIndexBuffer; class D3D9HLSLProgramFactory; class D3D9HLSLProgram; class D3D9VertexDeclaration; diff --git a/RenderSystems/Direct3D9/src/OgreD3D9HardwareVertexBuffer.cpp b/RenderSystems/Direct3D9/src/OgreD3D9HardwareBuffer.cpp similarity index 80% rename from RenderSystems/Direct3D9/src/OgreD3D9HardwareVertexBuffer.cpp rename to RenderSystems/Direct3D9/src/OgreD3D9HardwareBuffer.cpp index 7fd7567817d..e69e1d4edac 100644 --- a/RenderSystems/Direct3D9/src/OgreD3D9HardwareVertexBuffer.cpp +++ b/RenderSystems/Direct3D9/src/OgreD3D9HardwareBuffer.cpp @@ -25,7 +25,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ----------------------------------------------------------------------------- */ -#include "OgreD3D9HardwareVertexBuffer.h" +#include "OgreD3D9HardwareBuffer.h" #include "OgreD3D9Mappings.h" #include "OgreException.h" #include "OgreD3D9HardwareBufferManager.h" @@ -37,15 +37,17 @@ THE SOFTWARE. namespace Ogre { //--------------------------------------------------------------------- - D3D9HardwareVertexBuffer::D3D9HardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize, - size_t numVertices, HardwareBuffer::Usage usage, + D3D9HardwareBuffer::D3D9HardwareBuffer(D3DFORMAT type, size_t sizeInBytes, + Usage usage, bool useShadowBuffer) - : HardwareVertexBuffer(mgr, vertexSize, numVertices, usage, false, + : HardwareBuffer(usage, false, useShadowBuffer || // Allocate the system memory buffer for restoring after device lost. (((usage & HBU_DETAIL_WRITE_ONLY) != 0) && D3D9RenderSystem::getResourceManager()->getAutoHardwareBufferManagement())) { + mType = type; + mSizeInBytes = sizeInBytes; D3D9_DEVICE_ACCESS_CRITICAL_SECTION // Set the desired memory pool. @@ -64,7 +66,7 @@ namespace Ogre { } } //--------------------------------------------------------------------- - D3D9HardwareVertexBuffer::~D3D9HardwareVertexBuffer() + D3D9HardwareBuffer::~D3D9HardwareBuffer() { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -83,7 +85,7 @@ namespace Ogre { mMapDeviceToBufferResources.clear(); } //--------------------------------------------------------------------- - void* D3D9HardwareVertexBuffer::lockImpl(size_t offset, + void* D3D9HardwareBuffer::lockImpl(size_t offset, size_t length, LockOptions options) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -130,7 +132,7 @@ namespace Ogre { return mSourceLockedBytes; } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::unlockImpl(void) + void D3D9HardwareBuffer::unlockImpl(void) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -162,7 +164,7 @@ namespace Ogre { mSourceLockedBytes = NULL; } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::readData(size_t offset, size_t length, + void D3D9HardwareBuffer::readData(size_t offset, size_t length, void* pDest) { // There is no functional interface in D3D, just do via manual @@ -173,7 +175,7 @@ namespace Ogre { } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::writeData(size_t offset, size_t length, + void D3D9HardwareBuffer::writeData(size_t offset, size_t length, const void* pSource, bool discardWholeBuffer) { @@ -185,7 +187,7 @@ namespace Ogre { this->unlock(); } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device) + void D3D9HardwareBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -193,7 +195,7 @@ namespace Ogre { createBuffer(d3d9Device, mBufferDesc.Pool, true); } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device) + void D3D9HardwareBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -223,7 +225,7 @@ namespace Ogre { } } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device) + void D3D9HardwareBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -238,7 +240,7 @@ namespace Ogre { } } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device) + void D3D9HardwareBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -248,7 +250,7 @@ namespace Ogre { } } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool, bool updateNewBuffer) + void D3D9HardwareBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool, bool updateNewBuffer) { D3D9_DEVICE_ACCESS_CRITICAL_SECTION @@ -277,30 +279,39 @@ namespace Ogre { bufferResources->mLockOptions = HBL_NORMAL; bufferResources->mLastUsedFrame = Root::getSingleton().getNextFrameNumber(); - // Create the vertex buffer - hr = d3d9Device->CreateVertexBuffer( - static_cast(mSizeInBytes), - D3D9Mappings::get(mUsage), - 0, // No FVF here, thank you. - ePool, - &bufferResources->mBuffer, - NULL); + if(mType == D3DFMT_VERTEXDATA) + { + // Create the vertex buffer + hr = d3d9Device->CreateVertexBuffer( + static_cast(mSizeInBytes), + D3D9Mappings::get(mUsage), + 0, // No FVF here, thank you. + ePool, + (IDirect3DVertexBuffer9**)&bufferResources->mBuffer, + NULL); + } + else{ + // Create the Index buffer + hr = d3d9Device->CreateIndexBuffer( + static_cast(mSizeInBytes), + D3D9Mappings::get(mUsage), + mType, + ePool, + (IDirect3DIndexBuffer9**)&bufferResources->mBuffer, + NULL); + } if (FAILED(hr)) { String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot restore D3D9 vertex buffer: " + msg, - "D3D9HardwareVertexBuffer::createBuffer"); + OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Cannot restore D3D9 buffer: " + msg); } - hr = bufferResources->mBuffer->GetDesc(&mBufferDesc); + hr = static_cast(bufferResources->mBuffer)->GetDesc(&mBufferDesc); if (FAILED(hr)) { String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot get D3D9 Vertex buffer desc: " + msg, - "D3D9HardwareVertexBuffer::createBuffer"); + OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Cannot get D3D9 buffer desc: " + msg); } // Update source buffer if need to. @@ -318,7 +329,7 @@ namespace Ogre { } } //--------------------------------------------------------------------- - IDirect3DVertexBuffer9* D3D9HardwareVertexBuffer::getD3D9VertexBuffer(void) + IDirect3DResource9* D3D9HardwareBuffer::getD3D9Resource(void) { IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device(); DeviceToBufferResourcesIterator it; @@ -342,7 +353,7 @@ namespace Ogre { } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::updateBufferContent(BufferResources* bufferResources) + void D3D9HardwareBuffer::updateBufferContent(BufferResources* bufferResources) { if (bufferResources->mOutOfDate) { @@ -364,7 +375,7 @@ namespace Ogre { } //--------------------------------------------------------------------- - bool D3D9HardwareVertexBuffer::updateBufferResources(const char* systemMemoryBuffer, + bool D3D9HardwareBuffer::updateBufferResources(const char* systemMemoryBuffer, BufferResources* bufferResources) { assert(bufferResources != NULL); @@ -380,43 +391,57 @@ namespace Ogre { } //--------------------------------------------------------------------- - char* D3D9HardwareVertexBuffer::_lockBuffer(BufferResources* bufferResources, size_t offset, size_t length) + char* D3D9HardwareBuffer::_lockBuffer(BufferResources* bufferResources, size_t offset, size_t length) { HRESULT hr; char* pSourceBytes; // Lock the buffer. - hr = bufferResources->mBuffer->Lock( - static_cast(offset), - static_cast(length), - (void**)&pSourceBytes, - D3D9Mappings::get(mSourceBuffer->mLockOptions, mUsage)); + if(mType = D3DFMT_VERTEXDATA) + { + hr = static_cast(bufferResources->mBuffer)->Lock( + static_cast(offset), + static_cast(length), + (void**)&pSourceBytes, + D3D9Mappings::get(mSourceBuffer->mLockOptions, mUsage)); + } + else + { + hr = static_cast(bufferResources->mBuffer)->Lock( + static_cast(offset), + static_cast(length), + (void**)&pSourceBytes, + D3D9Mappings::get(mSourceBuffer->mLockOptions, mUsage)); + } if (FAILED(hr)) { String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot lock D3D9 vertex buffer: " + msg, - "D3D9HardwareVertexBuffer::_lockBuffer"); + OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Cannot lock D3D9 buffer: " + msg); } return pSourceBytes; } //--------------------------------------------------------------------- - void D3D9HardwareVertexBuffer::_unlockBuffer( BufferResources* bufferResources ) + void D3D9HardwareBuffer::_unlockBuffer( BufferResources* bufferResources ) { HRESULT hr; // Unlock the buffer. - hr = bufferResources->mBuffer->Unlock(); + if(mType = D3DFMT_VERTEXDATA) + { + hr = static_cast(bufferResources->mBuffer)->Unlock(); + } + else + { + hr = static_cast(bufferResources->mBuffer)->Unlock(); + } if (FAILED(hr)) { String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot unlock D3D9 vertex buffer: " + msg, - "D3D9HardwareVertexBuffer::_unlockBuffer"); + OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Cannot unlock D3D9 buffer: " + msg); } // Reset attributes. diff --git a/RenderSystems/Direct3D9/src/OgreD3D9HardwareBufferManager.cpp b/RenderSystems/Direct3D9/src/OgreD3D9HardwareBufferManager.cpp index baa1eb8d4b9..626768d33bb 100644 --- a/RenderSystems/Direct3D9/src/OgreD3D9HardwareBufferManager.cpp +++ b/RenderSystems/Direct3D9/src/OgreD3D9HardwareBufferManager.cpp @@ -27,8 +27,7 @@ THE SOFTWARE. */ #include "OgreD3D9RenderSystem.h" #include "OgreD3D9HardwareBufferManager.h" -#include "OgreD3D9HardwareVertexBuffer.h" -#include "OgreD3D9HardwareIndexBuffer.h" +#include "OgreD3D9HardwareBuffer.h" #include "OgreD3D9VertexDeclaration.h" #include "OgreLogManager.h" #include "OgreStringConverter.h" @@ -52,13 +51,13 @@ namespace Ogre { bool useShadowBuffer) { assert (numVerts > 0); - D3D9HardwareVertexBuffer* vbuf = OGRE_NEW D3D9HardwareVertexBuffer( - this, vertexSize, numVerts, usage, useShadowBuffer); + auto impl = new D3D9HardwareBuffer(D3DFMT_VERTEXDATA, vertexSize * numVerts, usage, useShadowBuffer); + auto buf = std::make_shared(this, vertexSize, numVerts, impl); { - OGRE_LOCK_MUTEX(mVertexBuffersMutex); - mVertexBuffers.insert(vbuf); + OGRE_LOCK_MUTEX(mVertexBuffersMutex); + mVertexBuffers.insert(buf.get()); } - return HardwareVertexBufferSharedPtr(vbuf); + return buf; } //----------------------------------------------------------------------- HardwareIndexBufferSharedPtr @@ -67,13 +66,15 @@ namespace Ogre { HardwareBuffer::Usage usage, bool useShadowBuffer) { assert (numIndexes > 0); - D3D9HardwareIndexBuffer* idx = OGRE_NEW D3D9HardwareIndexBuffer( - this, itype, numIndexes, usage, useShadowBuffer); + auto indexSize = HardwareIndexBuffer::indexSize(itype); + auto impl = new D3D9HardwareBuffer(D3D9Mappings::get(itype), indexSize * numIndexes, usage, useShadowBuffer); + + auto buf = std::make_shared(this, itype, numIndexes, impl); { - OGRE_LOCK_MUTEX(mIndexBuffersMutex); - mIndexBuffers.insert(idx); + OGRE_LOCK_MUTEX(mIndexBuffersMutex); + mIndexBuffers.insert(buf.get()); } - return HardwareIndexBufferSharedPtr(idx); + return buf; } //----------------------------------------------------------------------- diff --git a/RenderSystems/Direct3D9/src/OgreD3D9HardwareIndexBuffer.cpp b/RenderSystems/Direct3D9/src/OgreD3D9HardwareIndexBuffer.cpp deleted file mode 100644 index 4bb7b797783..00000000000 --- a/RenderSystems/Direct3D9/src/OgreD3D9HardwareIndexBuffer.cpp +++ /dev/null @@ -1,432 +0,0 @@ -/* ------------------------------------------------------------------------------ -This source file is part of OGRE - (Object-oriented Graphics Rendering Engine) -For the latest info, see http://www.ogre3d.org/ - -Copyright (c) 2000-2014 Torus Knot Software Ltd - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -THE SOFTWARE. ----------------------------------------------------------------------------- -*/ -#include "OgreD3D9HardwareIndexBuffer.h" -#include "OgreD3D9Mappings.h" -#include "OgreException.h" -#include "OgreD3D9HardwareBufferManager.h" -#include "OgreD3D9RenderSystem.h" -#include "OgreRoot.h" -#include "OgreD3D9Device.h" -#include "OgreD3D9ResourceManager.h" - -namespace Ogre { - - //--------------------------------------------------------------------- - D3D9HardwareIndexBuffer::D3D9HardwareIndexBuffer(HardwareBufferManagerBase* mgr, HardwareIndexBuffer::IndexType idxType, - size_t numIndexes, HardwareBuffer::Usage usage, - bool useShadowBuffer) - : HardwareIndexBuffer(mgr, idxType, numIndexes, usage, false, - useShadowBuffer || - // Allocate the system memory buffer for restoring after device lost. - (((usage & HBU_DETAIL_WRITE_ONLY) != 0) && - D3D9RenderSystem::getResourceManager()->getAutoHardwareBufferManagement())) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - // Set the desired memory pool. - mBufferDesc.Pool = usage == HBU_CPU_ONLY ? D3DPOOL_SYSTEMMEM : D3DPOOL_DEFAULT; - - // Set source buffer to NULL. - mSourceBuffer = NULL; - mSourceLockedBytes = NULL; - - // Create buffer resource(s). - for (uint i = 0; i < D3D9RenderSystem::getResourceCreationDeviceCount(); ++i) - { - IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getResourceCreationDevice(i); - - createBuffer(d3d9Device, mBufferDesc.Pool, false); - } - } - //--------------------------------------------------------------------- - D3D9HardwareIndexBuffer::~D3D9HardwareIndexBuffer() - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.begin(); - - while (it != mMapDeviceToBufferResources.end()) - { - SAFE_RELEASE(it->second->mBuffer); - if (it->second != NULL) - { - OGRE_FREE (it->second, MEMCATEGORY_RENDERSYS); - it->second = NULL; - } - ++it; - } - mMapDeviceToBufferResources.clear(); - } - //--------------------------------------------------------------------- - void* D3D9HardwareIndexBuffer::lockImpl(size_t offset, - size_t length, LockOptions options) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.begin(); - IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9DeviceIfExists(); - - while (it != mMapDeviceToBufferResources.end()) - { - BufferResources* bufferResources = it->second; - - if (options != HBL_READ_ONLY) - bufferResources->mOutOfDate = true; - - // Case it is the first buffer lock in this frame. - if (bufferResources->mLockLength == 0) - { - if (offset < bufferResources->mLockOffset) - bufferResources->mLockOffset = offset; - if (length > bufferResources->mLockLength) - bufferResources->mLockLength = length; - } - - // Case buffer already locked in this frame. - else - { - size_t highPoint = std::max( offset + length, - bufferResources->mLockOffset + bufferResources->mLockLength ); - bufferResources->mLockOffset = std::min( bufferResources->mLockOffset, offset ); - bufferResources->mLockLength = highPoint - bufferResources->mLockOffset; - } - - bufferResources->mLockOptions = options; - - //We will switch the source buffer to the active d3d9device as we may decide to only update it during unlock - if (it->first == d3d9Device) - mSourceBuffer = it->second; - - ++it; - } - - // Lock the source buffer. - mSourceLockedBytes = _lockBuffer(mSourceBuffer, mSourceBuffer->mLockOffset, mSourceBuffer->mLockLength); - - return mSourceLockedBytes; - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::unlockImpl(void) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - //check if we can delay the update of secondary buffer resources - if (!mShadowBuffer) - { - DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.begin(); - uint nextFrameNumber = Root::getSingleton().getNextFrameNumber(); - - while (it != mMapDeviceToBufferResources.end()) - { - BufferResources* bufferResources = it->second; - - if (bufferResources->mOutOfDate && - bufferResources->mBuffer != NULL && - nextFrameNumber - bufferResources->mLastUsedFrame <= 1) - { - if (mSourceBuffer != bufferResources) - { - updateBufferResources(mSourceLockedBytes, bufferResources); - } - } - - ++it; - } - } - - // Unlock the source buffer. - _unlockBuffer(mSourceBuffer); - mSourceLockedBytes = NULL; - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::readData(size_t offset, size_t length, - void* pDest) - { - // There is no functional interface in D3D, just do via manual - // lock, copy & unlock - void* pSrc = this->lock(offset, length, HardwareBuffer::HBL_READ_ONLY); - memcpy(pDest, pSrc, length); - this->unlock(); - - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::writeData(size_t offset, size_t length, - const void* pSource, - bool discardWholeBuffer) - { - // There is no functional interface in D3D, just do via manual - // lock, copy & unlock - void* pDst = this->lock(offset, length, - discardWholeBuffer ? HardwareBuffer::HBL_DISCARD : HardwareBuffer::HBL_NORMAL); - memcpy(pDst, pSource, length); - this->unlock(); - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::notifyOnDeviceCreate(IDirect3DDevice9* d3d9Device) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - if (D3D9RenderSystem::getResourceManager()->getCreationPolicy() == RCP_CREATE_ON_ALL_DEVICES) - createBuffer(d3d9Device, mBufferDesc.Pool, true); - - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::notifyOnDeviceDestroy(IDirect3DDevice9* d3d9Device) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.find(d3d9Device); - - if (it != mMapDeviceToBufferResources.end()) - { - // Case this is the source buffer. - if (it->second == mSourceBuffer) - { - mSourceBuffer = NULL; - } - - SAFE_RELEASE(it->second->mBuffer); - if (it->second != NULL) - { - OGRE_FREE (it->second, MEMCATEGORY_RENDERSYS); - it->second = NULL; - } - mMapDeviceToBufferResources.erase(it); - - // Case source buffer just destroyed -> switch to another one if exits. - if (mSourceBuffer == NULL && mMapDeviceToBufferResources.size() > 0) - { - mSourceBuffer = mMapDeviceToBufferResources.begin()->second; - } - } - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::notifyOnDeviceLost(IDirect3DDevice9* d3d9Device) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - if (mBufferDesc.Pool == D3DPOOL_DEFAULT) - { - DeviceToBufferResourcesIterator it = mMapDeviceToBufferResources.find(d3d9Device); - - if (it != mMapDeviceToBufferResources.end()) - { - SAFE_RELEASE(it->second->mBuffer); - } - } - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::notifyOnDeviceReset(IDirect3DDevice9* d3d9Device) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - if (mBufferDesc.Pool == D3DPOOL_DEFAULT) - { - createBuffer(d3d9Device, mBufferDesc.Pool, true); - } - } - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::createBuffer(IDirect3DDevice9* d3d9Device, D3DPOOL ePool, bool updateNewBuffer) - { - D3D9_DEVICE_ACCESS_CRITICAL_SECTION - - BufferResources* bufferResources; - HRESULT hr; - - DeviceToBufferResourcesIterator it; - - // Find the vertex buffer of this device. - it = mMapDeviceToBufferResources.find(d3d9Device); - if (it != mMapDeviceToBufferResources.end()) - { - bufferResources = it->second; - SAFE_RELEASE(bufferResources->mBuffer); - } - else - { - bufferResources = OGRE_ALLOC_T(BufferResources, 1, MEMCATEGORY_RENDERSYS); - mMapDeviceToBufferResources[d3d9Device] = bufferResources; - } - - bufferResources->mBuffer = NULL; - bufferResources->mOutOfDate = true; - bufferResources->mLockOffset = 0; - bufferResources->mLockLength = getSizeInBytes(); - bufferResources->mLockOptions = HBL_NORMAL; - bufferResources->mLastUsedFrame = Root::getSingleton().getNextFrameNumber(); - - // Create the Index buffer - hr = d3d9Device->CreateIndexBuffer( - static_cast(mSizeInBytes), - D3D9Mappings::get(mUsage), - D3D9Mappings::get(mIndexType), - ePool, - &bufferResources->mBuffer, - NULL - ); - - if (FAILED(hr)) - { - String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot create D3D9 Index buffer: " + msg, - "D3D9HardwareIndexBuffer::createBuffer"); - } - - hr = bufferResources->mBuffer->GetDesc(&mBufferDesc); - if (FAILED(hr)) - { - String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot get D3D9 Index buffer desc: " + msg, - "D3D9HardwareIndexBuffer::createBuffer"); - } - // Update source buffer if need to. - if (mSourceBuffer == NULL) - { - mSourceBuffer = bufferResources; - } - - // This is a new buffer and source buffer exists we must update the content now - // to prevent situation where the source buffer will be destroyed and we won't be able to restore its content. - // This is except for during the creation process of the class when there is no data yet to update. - else if (updateNewBuffer) - { - updateBufferContent(bufferResources); - } - } - //--------------------------------------------------------------------- - IDirect3DIndexBuffer9* D3D9HardwareIndexBuffer::getD3DIndexBuffer(void) - { - IDirect3DDevice9* d3d9Device = D3D9RenderSystem::getActiveD3D9Device(); - DeviceToBufferResourcesIterator it; - - // Find the index buffer of this device. - it = mMapDeviceToBufferResources.find(d3d9Device); - - // Case index buffer was not found for the current device -> create it. - if (it == mMapDeviceToBufferResources.end() || it->second->mBuffer == NULL) - { - createBuffer(d3d9Device, mBufferDesc.Pool, true); - it = mMapDeviceToBufferResources.find(d3d9Device); - } - - // Make sure that the buffer content is updated. - updateBufferContent(it->second); - - it->second->mLastUsedFrame = Root::getSingleton().getNextFrameNumber(); - - return it->second->mBuffer; - } - - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::updateBufferContent(BufferResources* bufferResources) - { - if (bufferResources->mOutOfDate) - { - if (mShadowBuffer != NULL) - { - const char* shadowData = (const char*)mShadowBuffer->lock(bufferResources->mLockOffset, bufferResources->mLockLength, HBL_NORMAL); - updateBufferResources(shadowData, bufferResources); - mShadowBuffer->unlock(); - } - else if (mSourceBuffer != bufferResources && (mUsage & HBU_DETAIL_WRITE_ONLY) == 0) - { - mSourceBuffer->mLockOptions = HBL_READ_ONLY; - mSourceLockedBytes = _lockBuffer(mSourceBuffer, bufferResources->mLockOffset, bufferResources->mLockLength); - updateBufferResources(mSourceLockedBytes, bufferResources); - _unlockBuffer(mSourceBuffer); - mSourceLockedBytes = NULL; - } - } - } - - //--------------------------------------------------------------------- - bool D3D9HardwareIndexBuffer::updateBufferResources(const char* systemMemoryBuffer, - BufferResources* bufferResources) - { - assert(bufferResources != NULL); - assert(bufferResources->mBuffer != NULL); - assert(bufferResources->mOutOfDate); - - - char* dstBytes = _lockBuffer(bufferResources, bufferResources->mLockOffset, bufferResources->mLockLength); - memcpy(dstBytes, systemMemoryBuffer, bufferResources->mLockLength); - _unlockBuffer(bufferResources); - - return true; - } - - //--------------------------------------------------------------------- - char* D3D9HardwareIndexBuffer::_lockBuffer(BufferResources* bufferResources, size_t offset, size_t length) - { - HRESULT hr; - char* pSourceBytes; - - - // Lock the buffer. - hr = bufferResources->mBuffer->Lock( - static_cast(offset), - static_cast(length), - (void**)&pSourceBytes, - D3D9Mappings::get(mSourceBuffer->mLockOptions, mUsage)); - - if (FAILED(hr)) - { - String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot lock D3D9 vertex buffer: " + msg, - "D3D9HardwareVertexBuffer::_lockBuffer"); - } - - return pSourceBytes; - } - - //--------------------------------------------------------------------- - void D3D9HardwareIndexBuffer::_unlockBuffer( BufferResources* bufferResources ) - { - HRESULT hr; - - // Unlock the buffer. - hr = bufferResources->mBuffer->Unlock(); - if (FAILED(hr)) - { - String msg = DXGetErrorDescription(hr); - OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, - "Cannot unlock D3D9 vertex buffer: " + msg, - "D3D9HardwareVertexBuffer::_unlockBuffer"); - } - - // Reset attributes. - bufferResources->mOutOfDate = false; - bufferResources->mLockOffset = mSizeInBytes; - bufferResources->mLockLength = 0; - bufferResources->mLockOptions = HBL_NORMAL; - - } -} diff --git a/RenderSystems/Direct3D9/src/OgreD3D9RenderSystem.cpp b/RenderSystems/Direct3D9/src/OgreD3D9RenderSystem.cpp index be38c63ae93..57ca90fbe51 100644 --- a/RenderSystems/Direct3D9/src/OgreD3D9RenderSystem.cpp +++ b/RenderSystems/Direct3D9/src/OgreD3D9RenderSystem.cpp @@ -39,8 +39,7 @@ THE SOFTWARE. #include "OgreMath.h" #include "OgreViewport.h" #include "OgreD3D9HardwareBufferManager.h" -#include "OgreD3D9HardwareIndexBuffer.h" -#include "OgreD3D9HardwareVertexBuffer.h" +#include "OgreD3D9HardwareBuffer.h" #include "OgreD3D9VertexDeclaration.h" #include "OgreD3D9GpuProgram.h" #include "OgreD3D9GpuProgramManager.h" @@ -3115,8 +3114,7 @@ namespace Ogre iend = binds.end(); for (i = binds.begin(); i != iend; ++i, ++source) { - D3D9HardwareVertexBuffer* d3d9buf = - static_cast(i->second.get()); + D3D9HardwareBuffer* d3d9buf = i->second->_getImpl(); // Unbind gap sources for ( ; source < i->first; ++source) @@ -3131,9 +3129,9 @@ namespace Ogre hr = getActiveD3D9Device()->SetStreamSource( static_cast(source), - d3d9buf->getD3D9VertexBuffer(), + (IDirect3DVertexBuffer9*)d3d9buf->getD3D9Resource(), 0, // no stream offset, this is handled in _render instead - static_cast(d3d9buf->getVertexSize()) // stride + static_cast(i->second->getVertexSize()) // stride ); if (FAILED(hr)) @@ -3145,9 +3143,9 @@ namespace Ogre // SetStreamSourceFreq if ( hasInstanceData ) { - if ( d3d9buf->isInstanceData() ) + if ( i->second->isInstanceData() ) { - hr = getActiveD3D9Device()->SetStreamSourceFreq( static_cast(source), D3DSTREAMSOURCE_INSTANCEDATA | d3d9buf->getInstanceDataStepRate() ); + hr = getActiveD3D9Device()->SetStreamSourceFreq( static_cast(source), D3DSTREAMSOURCE_INSTANCEDATA | i->second->getInstanceDataStepRate() ); } else { @@ -3187,14 +3185,13 @@ namespace Ogre "D3D9RenderSystem::setVertexBufferBinding"); } - D3D9HardwareVertexBuffer * d3d9buf = - static_cast(globalInstanceVertexBuffer.get()); + D3D9HardwareBuffer* d3d9buf = globalInstanceVertexBuffer->_getImpl(); hr = getActiveD3D9Device()->SetStreamSource( static_cast(source), - d3d9buf->getD3D9VertexBuffer(), + (IDirect3DVertexBuffer9*)d3d9buf->getD3D9Resource(), 0, // no stream offset, this is handled in _render instead - static_cast(d3d9buf->getVertexSize()) // stride + static_cast(i->second->getVertexSize()) // stride ); if (FAILED(hr)) @@ -3203,7 +3200,7 @@ namespace Ogre "D3D9RenderSystem::setVertexBufferBinding"); } - hr = getActiveD3D9Device()->SetStreamSourceFreq( static_cast(source), D3DSTREAMSOURCE_INSTANCEDATA | d3d9buf->getInstanceDataStepRate() ); + hr = getActiveD3D9Device()->SetStreamSourceFreq( static_cast(source), D3DSTREAMSOURCE_INSTANCEDATA | i->second->getInstanceDataStepRate() ); if (FAILED(hr)) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Unable to set D3D9 stream source Freq", @@ -3306,9 +3303,8 @@ namespace Ogre HRESULT hr; if( op.useIndexes ) { - D3D9HardwareIndexBuffer* d3dIdxBuf = - static_cast(op.indexData->indexBuffer.get()); - hr = getActiveD3D9Device()->SetIndices( d3dIdxBuf->getD3DIndexBuffer() ); + D3D9HardwareBuffer* d3dIdxBuf = op.indexData->indexBuffer->_getImpl(); + hr = getActiveD3D9Device()->SetIndices( (IDirect3DIndexBuffer9*)d3dIdxBuf->getD3D9Resource() ); if (FAILED(hr)) { OGRE_EXCEPT(Exception::ERR_RENDERINGAPI_ERROR, "Failed to set index buffer", "D3D9RenderSystem::_render" );