| /* | |
| Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/ | |
| This software is provided 'as-is', without any express or implied warranty. | |
| In no event will the authors be held liable for any damages arising from the use of this software. | |
| Permission is granted to anyone to use this software for any purpose, | |
| including commercial applications, and to alter it and redistribute it freely, | |
| subject to the following restrictions: | |
| 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. | |
| 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. | |
| 3. This notice may not be removed or altered from any source distribution. | |
| */ | |
| /* | |
| StackAlloc extracted from GJK-EPA collision solver by Nathanael Presson | |
| Nov.2006 | |
| */ | |
| #ifndef BT_STACK_ALLOC | |
| #define BT_STACK_ALLOC | |
| #include "btScalar.h" //for btAssert | |
| #include "btAlignedAllocator.h" | |
| ///The btBlock class is an internal structure for the btStackAlloc memory allocator. | |
| struct btBlock | |
| { | |
| btBlock* previous; | |
| unsigned char* address; | |
| }; | |
| ///The StackAlloc class provides some fast stack-based memory allocator (LIFO last-in first-out) | |
| class btStackAlloc | |
| { | |
| public: | |
| btStackAlloc(unsigned int size) { ctor();create(size); } | |
| ~btStackAlloc() { destroy(); } | |
| inline void create(unsigned int size) | |
| { | |
| destroy(); | |
| data = (unsigned char*) btAlignedAlloc(size,16); | |
| totalsize = size; | |
| } | |
| inline void destroy() | |
| { | |
| btAssert(usedsize==0); | |
| //Raise(L"StackAlloc is still in use"); | |
| if(usedsize==0) | |
| { | |
| if(!ischild && data) | |
| btAlignedFree(data); | |
| data = 0; | |
| usedsize = 0; | |
| } | |
| } | |
| int getAvailableMemory() const | |
| { | |
| return static_cast<int>(totalsize - usedsize); | |
| } | |
| unsigned char* allocate(unsigned int size) | |
| { | |
| const unsigned int nus(usedsize+size); | |
| if(nus<totalsize) | |
| { | |
| usedsize=nus; | |
| return(data+(usedsize-size)); | |
| } | |
| btAssert(0); | |
| //&& (L"Not enough memory")); | |
| return(0); | |
| } | |
| SIMD_FORCE_INLINE btBlock* beginBlock() | |
| { | |
| btBlock* pb = (btBlock*)allocate(sizeof(btBlock)); | |
| pb->previous = current; | |
| pb->address = data+usedsize; | |
| current = pb; | |
| return(pb); | |
| } | |
| SIMD_FORCE_INLINE void endBlock(btBlock* block) | |
| { | |
| btAssert(block==current); | |
| //Raise(L"Unmatched blocks"); | |
| if(block==current) | |
| { | |
| current = block->previous; | |
| usedsize = (unsigned int)((block->address-data)-sizeof(btBlock)); | |
| } | |
| } | |
| private: | |
| void ctor() | |
| { | |
| data = 0; | |
| totalsize = 0; | |
| usedsize = 0; | |
| current = 0; | |
| ischild = false; | |
| } | |
| unsigned char* data; | |
| unsigned int totalsize; | |
| unsigned int usedsize; | |
| btBlock* current; | |
| bool ischild; | |
| }; | |
| #endif //BT_STACK_ALLOC |