btHfFluidRigidCollisionConfiguration::~btHfFluidRigidCollisionConfiguration() { m_hfFluidRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc(); m_swappedHfFluidRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree(m_hfFluidRigidConvexCreateFunc); btAlignedFree(m_swappedHfFluidRigidConvexCreateFunc); }
void btGenericMemoryPool::end_pool() { btAlignedFree(m_pool); btAlignedFree(m_free_nodes); btAlignedFree(m_allocated_sizes); m_allocated_count = 0; m_free_nodes_count = 0; }
btSimpleBroadphase::~btSimpleBroadphase() { btAlignedFree(m_pHandlesRawPtr); if (m_ownsPairCache) { m_pairCache->~btOverlappingPairCache(); btAlignedFree(m_pairCache); } }
btBvhTriangleMeshShape::~btBvhTriangleMeshShape() { if (m_ownsBvh) { m_bvh->~btOptimizedBvh(); btAlignedFree(m_bvh); } if (m_ownShape) { m_meshInterface->~btStridingMeshInterface(); btAlignedFree(m_meshInterface); } }
btDiscreteDynamicsWorldMt::~btDiscreteDynamicsWorldMt() { if (m_solverIslandCallbackMt) { m_solverIslandCallbackMt->~InplaceSolverIslandCallbackMt(); btAlignedFree(m_solverIslandCallbackMt); } if (m_ownsConstraintSolver) { m_constraintSolver->~btConstraintSolver(); btAlignedFree(m_constraintSolver); } }
btDiscreteDynamicsWorld::~btDiscreteDynamicsWorld() { //only delete it when we created it if (m_ownsIslandManager) { m_islandManager->~btSimulationIslandManager(); btAlignedFree( m_islandManager); } if (m_ownsConstraintSolver) { m_constraintSolver->~btConstraintSolver(); btAlignedFree(m_constraintSolver); } }
btPolyhedralConvexShape::~btPolyhedralConvexShape() { if (m_polyhedron) { btAlignedFree(m_polyhedron); } }
void HullLibrary::deAllocateTriangle(btHullTriangle* tri) { btAssert(m_tris[tri->id]==tri); m_tris[tri->id]=NULL; tri->~btHullTriangle(); btAlignedFree(tri); }
void pl_DeleteDynamicsWorld(pl_DynamicsWorldHandle world) { btDynamicsWorld* dynamicsWorld = reinterpret_cast< btDynamicsWorld* >(world); btAssert(dynamicsWorld); btAlignedFree(dynamicsWorld->getConstraintSolver()); btAlignedFree(dynamicsWorld->getBroadphase()); btAlignedFree(dynamicsWorld->getDispatcher()); // DynamicsWorld does not safe collisionConfiguration object, only // stackAllocator. Not clear how to delete collisionConfiguration from // inside of this destructor. btAlignedFree(dynamicsWorld); }
akPose::~akPose() { btAlignedFree(m_transform); if(m_skelpose) delete m_skelpose; m_floats.clear(); }
void btCollisionDispatcher::freeCollisionAlgorithm(void* ptr) { if (m_collisionAlgorithmPoolAllocator->validPtr(ptr)) m_collisionAlgorithmPoolAllocator->freeMemory(ptr); else btAlignedFree(ptr); }
btMultiSapBroadphase::~btMultiSapBroadphase() { if (m_ownsPairCache) { m_overlappingPairs->~btOverlappingPairCache(); btAlignedFree(m_overlappingPairs); } }
btSoftRigidDynamicsWorld::~btSoftRigidDynamicsWorld() { if (m_ownsSolver) { m_softBodySolver->~btSoftBodySolver(); btAlignedFree(m_softBodySolver); } }
btDbvtBroadphase::~btDbvtBroadphase() { if (m_releasepaircache) { m_paircache->~btOverlappingPairCache(); btAlignedFree(m_paircache); } }
btCompoundShape::~btCompoundShape() { if (m_dynamicAabbTree) { m_dynamicAabbTree->~btDbvt(); btAlignedFree(m_dynamicAabbTree); } }
btBvhTriangleMeshShape::~btBvhTriangleMeshShape() { if (m_ownsBvh) { m_bvh->~btOptimizedBvh(); btAlignedFree(m_bvh); } }
btPolyhedralConvexShape::~btPolyhedralConvexShape() { if (m_polyhedron) { m_polyhedron->~btConvexPolyhedron(); btAlignedFree(m_polyhedron); } }
void btSimpleDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) { if (m_ownsConstraintSolver) { btAlignedFree(m_constraintSolver); } m_ownsConstraintSolver = false; m_constraintSolver = solver; }
btCompoundShape::~btCompoundShape() { freeChildrenShapes(); if (m_dynamicAabbTree) { m_dynamicAabbTree->~btDbvt(); btAlignedFree(m_dynamicAabbTree); } }
btGenericPoolAllocator::~btGenericPoolAllocator() { // destroy pools size_t i; for (i=0;i<m_pool_count;i++) { m_pools[i]->end_pool(); btAlignedFree(m_pools[i]); } }
void btDiscreteDynamicsWorld::setConstraintSolver(btConstraintSolver* solver) { if (m_ownsConstraintSolver) { btAlignedFree( m_constraintSolver); } m_ownsConstraintSolver = false; m_constraintSolver = solver; m_solverIslandCallback->m_solver = solver; }
btSoftBodyRigidBodyCollisionConfiguration::~btSoftBodyRigidBodyCollisionConfiguration() { m_softSoftCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree( m_softSoftCreateFunc); m_softRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree( m_softRigidConvexCreateFunc); m_swappedSoftRigidConvexCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree( m_swappedSoftRigidConvexCreateFunc); #ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS m_softRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree( m_softRigidConcaveCreateFunc); m_swappedSoftRigidConcaveCreateFunc->~btCollisionAlgorithmCreateFunc(); btAlignedFree( m_swappedSoftRigidConcaveCreateFunc); #endif }
void btDbvt::clear() { if(m_root) recursedeletenode(this,m_root); btAlignedFree(m_free); m_free=0; m_lkhd = -1; m_stkStack.clear(); m_opath = 0; }
void btDbvtBroadphase::destroyProxy( btBroadphaseProxy* absproxy,btDispatcher* dispatcher) { btDbvtProxy* proxy=(btDbvtProxy*)absproxy; if(proxy->stage==STAGECOUNT) m_sets[1].remove(proxy->leaf); else m_sets[0].remove(proxy->leaf); listremove(proxy,m_stageRoots[proxy->stage]); m_paircache->removeOverlappingPairsContainingProxy(proxy,dispatcher); btAlignedFree(proxy); m_needcleanup=true; }
void btHfFluidBuoyantConvexShape::generateShape (btScalar radius, btScalar gap) { btTransform T; T.setIdentity (); btVector3 aabbMin, aabbMax; getAabb (T, aabbMin, aabbMax); m_radius = radius; m_numVoxels = 0; btVoronoiSimplexSolver simplexSolver; btSphereShape sphereShape(radius); btVector3* voxelPositions = (btVector3*)btAlignedAlloc (sizeof(btVector3)*MAX_VOXEL_DIMENSION*MAX_VOXEL_DIMENSION*MAX_VOXEL_DIMENSION,16); for (int i = 0; i < MAX_VOXEL_DIMENSION; i++) { for (int j = 0; j < MAX_VOXEL_DIMENSION; j++) { for (int k = 0; k < MAX_VOXEL_DIMENSION; k++) { btVector3 point; btTransform sT; sT.setIdentity (); point.setX(aabbMin.getX() + (i * btScalar(2.0f) * radius) + (i * gap)); point.setY(aabbMin.getY() + (j * btScalar(2.0f) * radius) + (j * gap)); point.setZ(aabbMin.getZ() + (k * btScalar(2.0f) * radius) + (k * gap)); if (TestPointAgainstAabb2(aabbMin, aabbMax, point)) { btTransform sT; sT.setIdentity (); sT.setOrigin (point); if (intersect (&simplexSolver, T, sT, m_convexShape, &sphereShape)) { voxelPositions[m_numVoxels] = point; m_numVoxels++; } } } } } m_voxelPositions = (btVector3*)btAlignedAlloc (sizeof(btVector3)*m_numVoxels, 16); for (int i = 0; i < m_numVoxels;i++) { m_voxelPositions[i] = voxelPositions[i]; } btAlignedFree (voxelPositions); m_volumePerVoxel = btScalar(4.0f)/btScalar(3.0f)*SIMD_PI*radius*radius*radius; m_totalVolume = m_numVoxels * m_volumePerVoxel; m_radius = radius; }
void btGpu3DGridBroadphase::_finalize() { assert(m_bInitialized); delete [] m_hBodiesHash; delete [] m_hCellStart; delete [] m_hPairBuffStartCurr; delete [] m_hAABB; delete [] m_hPairBuff; delete [] m_hPairScan; delete [] m_hPairOut; btAlignedFree(m_pLargeHandlesRawPtr); m_bInitialized = false; }
void btBvhTriangleMeshShape::buildOptimizedBvh() { if (m_ownsBvh) { m_bvh->~btOptimizedBvh(); btAlignedFree(m_bvh); } ///m_localAabbMin/m_localAabbMax is already re-calculated in btTriangleMeshShape. We could just scale aabb, but this needs some more work void* mem = btAlignedAlloc(sizeof(btOptimizedBvh),16); m_bvh = new(mem) btOptimizedBvh(); //rebuild the bvh... m_bvh->build(m_meshInterface,m_useQuantizedAabbCompression,m_localAabbMin,m_localAabbMax); m_ownsBvh = true; }
SpuCollisionTaskProcess::~SpuCollisionTaskProcess() { if (m_workUnitTaskBuffers != 0) { btAlignedFree(m_workUnitTaskBuffers); m_workUnitTaskBuffers = 0; } m_threadInterface->stopSPU(); }
btSoftBodyRigidBodyCollisionConfiguration::btSoftBodyRigidBodyCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo) :btDefaultCollisionConfiguration(constructionInfo) { void* mem; mem = btAlignedAlloc(sizeof(btSoftSoftCollisionAlgorithm::CreateFunc),16); m_softSoftCreateFunc = new(mem) btSoftSoftCollisionAlgorithm::CreateFunc; mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc),16); m_softRigidConvexCreateFunc = new(mem) btSoftRigidCollisionAlgorithm::CreateFunc; mem = btAlignedAlloc(sizeof(btSoftRigidCollisionAlgorithm::CreateFunc),16); m_swappedSoftRigidConvexCreateFunc = new(mem) btSoftRigidCollisionAlgorithm::CreateFunc; m_swappedSoftRigidConvexCreateFunc->m_swapped=true; #ifdef ENABLE_SOFTBODY_CONCAVE_COLLISIONS mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc),16); m_softRigidConcaveCreateFunc = new(mem) btSoftBodyConcaveCollisionAlgorithm::CreateFunc; mem = btAlignedAlloc(sizeof(btSoftBodyConcaveCollisionAlgorithm::CreateFunc),16); m_swappedSoftRigidConcaveCreateFunc = new(mem) btSoftBodyConcaveCollisionAlgorithm::SwappedCreateFunc; m_swappedSoftRigidConcaveCreateFunc->m_swapped=true; #endif //replace pool by a new one, with potential larger size if (m_ownsCollisionAlgorithmPool && m_collisionAlgorithmPool) { int curElemSize = m_collisionAlgorithmPool->getElementSize(); ///calculate maximum element size, big enough to fit any collision algorithm in the memory pool int maxSize0 = sizeof(btSoftSoftCollisionAlgorithm); int maxSize1 = sizeof(btSoftRigidCollisionAlgorithm); int maxSize2 = sizeof(btSoftBodyConcaveCollisionAlgorithm); int collisionAlgorithmMaxElementSize = btMax(maxSize0,maxSize1); collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize2); if (collisionAlgorithmMaxElementSize > curElemSize) { m_collisionAlgorithmPool->~btPoolAllocator(); btAlignedFree(m_collisionAlgorithmPool); void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16); m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize); } } }
void gim_free(void *ptr) { if (!ptr) return; if (g_freefn) { g_freefn(ptr); } else { #ifdef GIM_SIMD_MEMORY btAlignedFree(ptr); #else free(ptr); #endif } }