2017-08-01 14:30:58 +02:00
/*
Bullet Continuous Collision Detection and Physics Library
Copyright ( c ) 2003 - 2006 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 .
*/
# ifndef BT_ALIGNED_ALLOCATOR
# define BT_ALIGNED_ALLOCATOR
///we probably replace this with our own aligned memory allocator
///so we replace _aligned_malloc and _aligned_free with our own
///that is better portable and more predictable
# include "btScalar.h"
///BT_DEBUG_MEMORY_ALLOCATIONS preprocessor can be set in build system
///for regression tests to detect memory leaks
///#define BT_DEBUG_MEMORY_ALLOCATIONS 1
# ifdef BT_DEBUG_MEMORY_ALLOCATIONS
int btDumpMemoryLeaks ( ) ;
2019-01-03 14:26:51 +01:00
# define btAlignedAlloc(a, b) \
btAlignedAllocInternal ( a , b , __LINE__ , __FILE__ )
2017-08-01 14:30:58 +02:00
# define btAlignedFree(ptr) \
2019-01-03 14:26:51 +01:00
btAlignedFreeInternal ( ptr , __LINE__ , __FILE__ )
2017-08-01 14:30:58 +02:00
2021-09-29 15:47:08 +02:00
void * btAlignedAllocInternal ( size_t size , int alignment , int line , const char * filename ) ;
2017-08-01 14:30:58 +02:00
2021-09-29 15:47:08 +02:00
void btAlignedFreeInternal ( void * ptr , int line , const char * filename ) ;
2017-08-01 14:30:58 +02:00
# else
2019-01-03 14:26:51 +01:00
void * btAlignedAllocInternal ( size_t size , int alignment ) ;
void btAlignedFreeInternal ( void * ptr ) ;
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
# define btAlignedAlloc(size, alignment) btAlignedAllocInternal(size, alignment)
# define btAlignedFree(ptr) btAlignedFreeInternal(ptr)
2017-08-01 14:30:58 +02:00
# endif
2019-01-03 14:26:51 +01:00
typedef int size_type ;
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
typedef void * ( btAlignedAllocFunc ) ( size_t size , int alignment ) ;
typedef void ( btAlignedFreeFunc ) ( void * memblock ) ;
typedef void * ( btAllocFunc ) ( size_t size ) ;
typedef void ( btFreeFunc ) ( void * memblock ) ;
2017-08-01 14:30:58 +02:00
///The developer can let all Bullet memory allocations go through a custom memory allocator, using btAlignedAllocSetCustom
2019-01-03 14:26:51 +01:00
void btAlignedAllocSetCustom ( btAllocFunc * allocFunc , btFreeFunc * freeFunc ) ;
2017-08-01 14:30:58 +02:00
///If the developer has already an custom aligned allocator, then btAlignedAllocSetCustomAligned can be used. The default aligned allocator pre-allocates extra memory using the non-aligned allocator, and instruments it.
2019-01-03 14:26:51 +01:00
void btAlignedAllocSetCustomAligned ( btAlignedAllocFunc * allocFunc , btAlignedFreeFunc * freeFunc ) ;
2017-08-01 14:30:58 +02:00
///The btAlignedAllocator is a portable class for aligned memory allocations.
///Default implementations for unaligned and aligned allocations can be overridden by a custom allocator using btAlignedAllocSetCustom and btAlignedAllocSetCustomAligned.
2019-01-03 14:26:51 +01:00
template < typename T , unsigned Alignment >
class btAlignedAllocator
{
typedef btAlignedAllocator < T , Alignment > self_type ;
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
public :
2017-08-01 14:30:58 +02:00
//just going down a list:
btAlignedAllocator ( ) { }
/*
btAlignedAllocator ( const self_type & ) { }
*/
2019-01-03 14:26:51 +01:00
template < typename Other >
btAlignedAllocator ( const btAlignedAllocator < Other , Alignment > & )
{
}
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
typedef const T * const_pointer ;
typedef const T & const_reference ;
typedef T * pointer ;
typedef T & reference ;
typedef T value_type ;
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
pointer address ( reference ref ) const { return & ref ; }
const_pointer address ( const_reference ref ) const { return & ref ; }
pointer allocate ( size_type n , const_pointer * hint = 0 )
{
2017-08-01 14:30:58 +02:00
( void ) hint ;
2019-01-03 14:26:51 +01:00
return reinterpret_cast < pointer > ( btAlignedAlloc ( sizeof ( value_type ) * n , Alignment ) ) ;
2017-08-01 14:30:58 +02:00
}
2019-01-03 14:26:51 +01:00
void construct ( pointer ptr , const value_type & value ) { new ( ptr ) value_type ( value ) ; }
void deallocate ( pointer ptr )
{
btAlignedFree ( reinterpret_cast < void * > ( ptr ) ) ;
2017-08-01 14:30:58 +02:00
}
2019-01-03 14:26:51 +01:00
void destroy ( pointer ptr ) { ptr - > ~ value_type ( ) ; }
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
template < typename O >
struct rebind
{
typedef btAlignedAllocator < O , Alignment > other ;
2017-08-01 14:30:58 +02:00
} ;
2019-01-03 14:26:51 +01:00
template < typename O >
self_type & operator = ( const btAlignedAllocator < O , Alignment > & )
{
return * this ;
}
2017-08-01 14:30:58 +02:00
2019-01-03 14:26:51 +01:00
friend bool operator = = ( const self_type & , const self_type & ) { return true ; }
2017-08-01 14:30:58 +02:00
} ;
2019-01-03 14:26:51 +01:00
# endif //BT_ALIGNED_ALLOCATOR