OGRE  1.9.0
OgreHardwareBufferManager.h
Go to the documentation of this file.
1/*
2-----------------------------------------------------------------------------
3This source file is part of OGRE
4 (Object-oriented Graphics Rendering Engine)
5For the latest info, see http://www.ogre3d.org/
6
7Copyright (c) 2000-2014 Torus Knot Software Ltd
8
9Permission is hereby granted, free of charge, to any person obtaining a copy
10of this software and associated documentation files (the "Software"), to deal
11in the Software without restriction, including without limitation the rights
12to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13copies of the Software, and to permit persons to whom the Software is
14furnished to do so, subject to the following conditions:
15
16The above copyright notice and this permission notice shall be included in
17all copies or substantial portions of the Software.
18
19THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25THE SOFTWARE.
26-----------------------------------------------------------------------------
27*/
28#ifndef __HardwareBufferManager__
29#define __HardwareBufferManager__
30
31// Precompiler options
32#include "OgrePrerequisites.h"
33
34#include "OgreSingleton.h"
40#include "OgreHeaderPrefix.h"
41
42namespace Ogre {
61 {
62 public:
67 virtual void licenseExpired(HardwareBuffer* buffer) = 0;
68 };
69
72 {
73 private:
74 // Pre-blended
77 // Post-blended
82 unsigned short posBindIndex;
83 unsigned short normBindIndex;
86
87 public:
90 void extractFrom(const VertexData* sourceData);
92 void checkoutTempCopies(bool positions = true, bool normals = true);
94 void bindTempCopies(VertexData* targetData, bool suppressHardwareUpload);
98 bool buffersCheckedOut(bool positions = true, bool normals = true) const;
99 };
100
101
114 {
117 protected:
131
132
137
138 // Mutexes
139 OGRE_MUTEX(mVertexBuffersMutex);
140 OGRE_MUTEX(mIndexBuffersMutex);
141 OGRE_MUTEX(mUniformBuffersMutex);
142 OGRE_MUTEX(mCounterBuffersMutex);
143 OGRE_MUTEX(mVertexDeclarationsMutex);
144 OGRE_MUTEX(mVertexBufferBindingsMutex);
145
147 virtual void destroyAllDeclarations(void);
149 virtual void destroyAllBindings(void);
150
155
160
161 public:
162
164 {
168 BLT_AUTOMATIC_RELEASE
169 };
170
171 protected:
174 {
175 public:
183 BufferLicenseType ltype,
184 size_t delay,
187 : originalBufferPtr(orig)
188 , licenseType(ltype)
189 , expiredDelay(delay)
190 , buffer(buf)
191 , licensee(lic)
192 {}
193
194 };
195
207 static const size_t UNDER_USED_FRAME_THRESHOLD;
209 static const size_t EXPIRED_DELAY_FRAME_THRESHOLD;
210 // Mutexes
211 OGRE_MUTEX(mTempBuffersMutex);
212
213
216 const HardwareVertexBufferSharedPtr& source,
217 HardwareBuffer::Usage usage, bool useShadowBuffer);
218
219 public:
255 createVertexBuffer(size_t vertexSize, size_t numVerts, HardwareBuffer::Usage usage,
256 bool useShadowBuffer = false) = 0;
279 HardwareBuffer::Usage usage, bool useShadowBuffer = false) = 0;
280
286
293 HardwareBuffer::Usage usage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
294 bool useShadowBuffer = false, const String& name = "") = 0;
295
301 HardwareBuffer::Usage usage = HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE,
302 bool useShadowBuffer = false, const String& name = "") = 0;
303
308
313
320 const HardwareVertexBufferSharedPtr& sourceBuffer,
322
344 const HardwareVertexBufferSharedPtr& sourceBuffer,
345 BufferLicenseType licenseType,
346 HardwareBufferLicensee* licensee,
347 bool copyData = false);
348
359 const HardwareVertexBufferSharedPtr& bufferCopy);
360
373
383 virtual void _freeUnusedBufferCopies(void);
384
392 virtual void _releaseBufferCopies(bool forceFreeUnused = false);
393
405
417
426 };
427
429 class _OgreExport HardwareBufferManager : public HardwareBufferManagerBase, public Singleton<HardwareBufferManager>
430 {
433 protected:
435 public:
438
441 createVertexBuffer(size_t vertexSize, size_t numVerts, HardwareBuffer::Usage usage,
442 bool useShadowBuffer = false)
443 {
444 return mImpl->createVertexBuffer(vertexSize, numVerts, usage, useShadowBuffer);
445 }
449 HardwareBuffer::Usage usage, bool useShadowBuffer = false)
450 {
451 return mImpl->createIndexBuffer(itype, numIndexes, usage, useShadowBuffer);
452 }
453
459
462 createUniformBuffer(size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String& name = "")
463 {
464 return mImpl->createUniformBuffer(sizeBytes, usage, useShadowBuffer, name);
465 }
466
469 createCounterBuffer(size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String& name = "")
470 {
471 return mImpl->createCounterBuffer(sizeBytes, usage, useShadowBuffer, name);
472 }
473
476 {
477 return mImpl->createVertexDeclaration();
478 }
481 {
482 mImpl->destroyVertexDeclaration(decl);
483 }
484
487 {
488 return mImpl->createVertexBufferBinding();
489 }
492 {
493 mImpl->destroyVertexBufferBinding(binding);
494 }
497 const HardwareVertexBufferSharedPtr& sourceBuffer,
499 {
500 mImpl->registerVertexBufferSourceAndCopy(sourceBuffer, copy);
501 }
504 const HardwareVertexBufferSharedPtr& sourceBuffer,
505 BufferLicenseType licenseType,
506 HardwareBufferLicensee* licensee,
507 bool copyData = false)
508 {
509 return mImpl->allocateVertexBufferCopy(sourceBuffer, licenseType, licensee, copyData);
510 }
513 const HardwareVertexBufferSharedPtr& bufferCopy)
514 {
515 mImpl->releaseVertexBufferCopy(bufferCopy);
516 }
517
520 const HardwareVertexBufferSharedPtr& bufferCopy)
521 {
522 mImpl->touchVertexBufferCopy(bufferCopy);
523 }
524
526 virtual void _freeUnusedBufferCopies(void)
527 {
529 }
531 virtual void _releaseBufferCopies(bool forceFreeUnused = false)
532 {
533 mImpl->_releaseBufferCopies(forceFreeUnused);
534 }
537 const HardwareVertexBufferSharedPtr& sourceBuffer)
538 {
539 mImpl->_forceReleaseBufferCopies(sourceBuffer);
540 }
543 {
544 mImpl->_forceReleaseBufferCopies(sourceBuffer);
545 }
566
599
600 };
601
604} // namespace Ogre
605
606#include "OgreHeaderSuffix.h"
607
608#endif // __HardwareBufferManager__
609
#define _OgreExport
#define _OgrePrivate
Superclass for all objects that wish to use custom memory allocators when their new / delete operator...
Abstract interface representing a 'licensee' of a hardware buffer copy.
virtual void licenseExpired(HardwareBuffer *buffer)=0
This method is called when the buffer license is expired and is about to be returned to the shared po...
Struct holding details of a license to use a temporary shared buffer.
VertexBufferLicense(HardwareVertexBuffer *orig, BufferLicenseType ltype, size_t delay, HardwareVertexBufferSharedPtr buf, HardwareBufferLicensee *lic)
Base definition of a hardware buffer manager.
set< HardwareIndexBuffer * >::type IndexBufferList
map< HardwareVertexBuffer *, VertexBufferLicense >::type TemporaryVertexBufferLicenseMap
Map from temporary buffer to details of a license.
virtual VertexBufferBinding * createVertexBufferBindingImpl(void)
Internal method for creates a new VertexBufferBinding, may be overridden by certain rendering APIs.
virtual void _forceReleaseBufferCopies(const HardwareVertexBufferSharedPtr &sourceBuffer)
Internal method that forces the release of copies of a given buffer.
set< VertexBufferBinding * >::type VertexBufferBindingList
virtual void registerVertexBufferSourceAndCopy(const HardwareVertexBufferSharedPtr &sourceBuffer, const HardwareVertexBufferSharedPtr &copy)
Registers a vertex buffer as a copy of another.
void _notifyVertexBufferDestroyed(HardwareVertexBuffer *buf)
Notification that a hardware vertex buffer has been destroyed.
OGRE_MUTEX(mIndexBuffersMutex)
virtual void _freeUnusedBufferCopies(void)
Free all unused vertex buffer copies.
OGRE_MUTEX(mUniformBuffersMutex)
virtual void destroyVertexBufferBindingImpl(VertexBufferBinding *binding)
Internal method for destroys a VertexBufferBinding, may be overridden by certain rendering APIs.
OGRE_MUTEX(mVertexBuffersMutex)
void _notifyCounterBufferDestroyed(HardwareCounterBuffer *buf)
Notification that at hardware counter buffer has been destroyed.
virtual void destroyAllDeclarations(void)
Internal method for destroys all vertex declarations.
set< HardwareCounterBuffer * >::type CounterBufferList
virtual void _releaseBufferCopies(bool forceFreeUnused=false)
Internal method for releasing all temporary buffers which have been allocated using BLT_AUTOMATIC_REL...
virtual VertexDeclaration * createVertexDeclarationImpl(void)
Internal method for creates a new vertex declaration, may be overridden by certain rendering APIs.
virtual HardwareVertexBufferSharedPtr createVertexBuffer(size_t vertexSize, size_t numVerts, HardwareBuffer::Usage usage, bool useShadowBuffer=false)=0
Create a hardware vertex buffer.
virtual void touchVertexBufferCopy(const HardwareVertexBufferSharedPtr &bufferCopy)
Tell engine that the vertex buffer copy intent to reuse.
static const size_t EXPIRED_DELAY_FRAME_THRESHOLD
Frame delay for BLT_AUTOMATIC_RELEASE temporary buffers.
TemporaryVertexBufferLicenseMap mTempVertexBufferLicenses
Map of currently licensed temporary buffers.
virtual RenderToVertexBufferSharedPtr createRenderToVertexBuffer()=0
Create a render to vertex buffer.
@ BLT_MANUAL_RELEASE
Licensee will only release buffer when it says so.
virtual void destroyVertexBufferBinding(VertexBufferBinding *binding)
Destroys a VertexBufferBinding.
virtual void destroyVertexDeclaration(VertexDeclaration *decl)
Destroys a vertex declaration.
size_t mUnderUsedFrameCount
Number of frames elapsed since temporary buffers utilization was above half the available.
virtual void destroyAllBindings(void)
Internal method for destroys all vertex buffer bindings.
virtual void _forceReleaseBufferCopies(HardwareVertexBuffer *sourceBuffer)
Internal method that forces the release of copies of a given buffer.
void _notifyIndexBufferDestroyed(HardwareIndexBuffer *buf)
Notification that a hardware index buffer has been destroyed.
set< HardwareVertexBuffer * >::type VertexBufferList
WARNING: The following two members should place before all other members.
virtual HardwareVertexBufferSharedPtr allocateVertexBufferCopy(const HardwareVertexBufferSharedPtr &sourceBuffer, BufferLicenseType licenseType, HardwareBufferLicensee *licensee, bool copyData=false)
Allocates a copy of a given vertex buffer.
set< HardwareUniformBuffer * >::type UniformBufferList
virtual VertexBufferBinding * createVertexBufferBinding(void)
Creates a new VertexBufferBinding.
virtual HardwareVertexBufferSharedPtr makeBufferCopy(const HardwareVertexBufferSharedPtr &source, HardwareBuffer::Usage usage, bool useShadowBuffer)
Creates a new buffer as a copy of the source, does not copy data.
OGRE_MUTEX(mVertexDeclarationsMutex)
FreeTemporaryVertexBufferMap mFreeTempVertexBufferMap
Map of current available temp buffers.
OGRE_MUTEX(mCounterBuffersMutex)
set< VertexDeclaration * >::type VertexDeclarationList
OGRE_MUTEX(mTempBuffersMutex)
virtual void releaseVertexBufferCopy(const HardwareVertexBufferSharedPtr &bufferCopy)
Manually release a vertex buffer copy for others to subsequently use.
void _notifyUniformBufferDestroyed(HardwareUniformBuffer *buf)
Notification that at hardware uniform buffer has been destroyed.
virtual HardwareUniformBufferSharedPtr createUniformBuffer(size_t sizeBytes, HardwareBuffer::Usage usage=HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, bool useShadowBuffer=false, const String &name="")=0
Create uniform buffer.
virtual VertexDeclaration * createVertexDeclaration(void)
Creates a new vertex declaration.
virtual HardwareIndexBufferSharedPtr createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, HardwareBuffer::Usage usage, bool useShadowBuffer=false)=0
Create a hardware index buffer.
multimap< HardwareVertexBuffer *, HardwareVertexBufferSharedPtr >::type FreeTemporaryVertexBufferMap
Map from original buffer to temporary buffers.
virtual HardwareCounterBufferSharedPtr createCounterBuffer(size_t sizeBytes, HardwareBuffer::Usage usage=HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE, bool useShadowBuffer=false, const String &name="")=0
Create counter buffer.
virtual void destroyVertexDeclarationImpl(VertexDeclaration *decl)
Internal method for destroys a vertex declaration, may be overridden by certain rendering APIs.
OGRE_MUTEX(mVertexBufferBindingsMutex)
static const size_t UNDER_USED_FRAME_THRESHOLD
Number of frames to wait before free unused temporary buffers.
Singleton wrapper for hardware buffer manager.
HardwareBufferManager(HardwareBufferManagerBase *imp)
virtual void _forceReleaseBufferCopies(HardwareVertexBuffer *sourceBuffer)
Internal method that forces the release of copies of a given buffer.
HardwareBufferManagerBase * mImpl
void _notifyVertexBufferDestroyed(HardwareVertexBuffer *buf)
Notification that a hardware vertex buffer has been destroyed.
virtual void releaseVertexBufferCopy(const HardwareVertexBufferSharedPtr &bufferCopy)
Manually release a vertex buffer copy for others to subsequently use.
void _notifyUniformBufferDestroyed(HardwareUniformBuffer *buf)
void _notifyConterBufferDestroyed(HardwareCounterBuffer *buf)
virtual void registerVertexBufferSourceAndCopy(const HardwareVertexBufferSharedPtr &sourceBuffer, const HardwareVertexBufferSharedPtr &copy)
Registers a vertex buffer as a copy of another.
virtual void _releaseBufferCopies(bool forceFreeUnused=false)
Internal method for releasing all temporary buffers which have been allocated using BLT_AUTOMATIC_REL...
RenderToVertexBufferSharedPtr createRenderToVertexBuffer()
Create a render to vertex buffer.
virtual void destroyVertexDeclaration(VertexDeclaration *decl)
Destroys a vertex declaration.
virtual HardwareVertexBufferSharedPtr allocateVertexBufferCopy(const HardwareVertexBufferSharedPtr &sourceBuffer, BufferLicenseType licenseType, HardwareBufferLicensee *licensee, bool copyData=false)
Allocates a copy of a given vertex buffer.
HardwareIndexBufferSharedPtr createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, HardwareBuffer::Usage usage, bool useShadowBuffer=false)
Create a hardware index buffer.
static HardwareBufferManager & getSingleton(void)
Override standard Singleton retrieval.
virtual void _freeUnusedBufferCopies(void)
Free all unused vertex buffer copies.
HardwareUniformBufferSharedPtr createUniformBuffer(size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String &name="")
Create uniform buffer.
HardwareCounterBufferSharedPtr createCounterBuffer(size_t sizeBytes, HardwareBuffer::Usage usage, bool useShadowBuffer, const String &name="")
Create counter buffer.
virtual VertexBufferBinding * createVertexBufferBinding(void)
Creates a new VertexBufferBinding.
virtual void _forceReleaseBufferCopies(const HardwareVertexBufferSharedPtr &sourceBuffer)
Internal method that forces the release of copies of a given buffer.
virtual VertexDeclaration * createVertexDeclaration(void)
static HardwareBufferManager * getSingletonPtr(void)
Override standard Singleton retrieval.
HardwareVertexBufferSharedPtr createVertexBuffer(size_t vertexSize, size_t numVerts, HardwareBuffer::Usage usage, bool useShadowBuffer=false)
Create a hardware vertex buffer.
void _notifyIndexBufferDestroyed(HardwareIndexBuffer *buf)
Notification that a hardware index buffer has been destroyed.
virtual void destroyVertexBufferBinding(VertexBufferBinding *binding)
Destroys a VertexBufferBinding.
virtual void touchVertexBufferCopy(const HardwareVertexBufferSharedPtr &bufferCopy)
Tell engine that the vertex buffer copy intent to reuse.
Abstract class defining common features of hardware buffers.
Usage
Enums describing buffer usage; not mutually exclusive.
Shared pointer implementation used to share counter buffers.
Specialisation of HardwareBuffer for a counter buffer.
Shared pointer implementation used to share index buffers.
Specialisation of HardwareBuffer for vertex index buffers, still abstract.
Shared pointer implementation used to share uniform buffers.
Specialisation of HardwareBuffer for a uniform buffer.
Shared pointer implementation used to share vertex buffers.
Specialisation of HardwareBuffer for a vertex buffer.
Reference-counted shared pointer, used for objects where implicit destruction is required.
Template class for creating single-instance global classes.
Structure for recording the use of temporary blend buffers.
HardwareVertexBufferSharedPtr srcNormalBuffer
HardwareVertexBufferSharedPtr destNormalBuffer
void licenseExpired(HardwareBuffer *buffer)
Overridden member from HardwareBufferLicensee.
void checkoutTempCopies(bool positions=true, bool normals=true)
Utility method, checks out temporary copies of src into dest.
bool posNormalShareBuffer
Both positions and normals are contained in the same buffer.
HardwareVertexBufferSharedPtr destPositionBuffer
bool buffersCheckedOut(bool positions=true, bool normals=true) const
Detect currently have buffer copies checked out and touch it.
void bindTempCopies(VertexData *targetData, bool suppressHardwareUpload)
Utility method, binds dest copies into a given VertexData struct.
void extractFrom(const VertexData *sourceData)
Utility method, extract info from the given VertexData.
HardwareVertexBufferSharedPtr srcPositionBuffer
Records the state of all the vertex buffer bindings required to provide a vertex declaration with the...
Summary class collecting together vertex source information.
This class declares the format of a set of vertex inputs, which can be issued to the rendering API th...
_StringBase String
std::map< K, V, P, A > type
std::multimap< K, V, P, A > type
std::set< T, P, A > type