C++ btAlignedAlloc函数代码示例

btCriticalSection* Win32ThreadSupport::createCriticalSection()
{
	unsigned char* mem = (unsigned char*) btAlignedAlloc(sizeof(btWin32CriticalSection),16);
	btWin32CriticalSection* cs = new(mem) btWin32CriticalSection();
	return cs;
}

btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(const btDefaultCollisionConstructionInfo& constructionInfo)
//btDefaultCollisionConfiguration::btDefaultCollisionConfiguration(btStackAlloc*	stackAlloc,btPoolAllocator*	persistentManifoldPool,btPoolAllocator*	collisionAlgorithmPool)
{

    void* mem = btAlignedAlloc(sizeof(btVoronoiSimplexSolver),16);
    m_simplexSolver = new (mem)btVoronoiSimplexSolver();

#define USE_EPA 1
#ifdef USE_EPA
    mem = btAlignedAlloc(sizeof(btGjkEpaPenetrationDepthSolver),16);
    m_pdSolver = new (mem)btGjkEpaPenetrationDepthSolver;
#else
    mem = btAlignedAlloc(sizeof(btMinkowskiPenetrationDepthSolver),16);
    m_pdSolver = new (mem)btMinkowskiPenetrationDepthSolver;
#endif//USE_EPA	


    //default CreationFunctions, filling the m_doubleDispatch table
    mem = btAlignedAlloc(sizeof(btConvexConvexAlgorithm::CreateFunc),16);
    m_convexConvexCreateFunc = new(mem) btConvexConvexAlgorithm::CreateFunc(m_simplexSolver,m_pdSolver);
    mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
    m_convexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::CreateFunc;
    mem = btAlignedAlloc(sizeof(btConvexConcaveCollisionAlgorithm::CreateFunc),16);
    m_swappedConvexConcaveCreateFunc = new (mem)btConvexConcaveCollisionAlgorithm::SwappedCreateFunc;
    mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::CreateFunc),16);
    m_compoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::CreateFunc;
    mem = btAlignedAlloc(sizeof(btCompoundCollisionAlgorithm::SwappedCreateFunc),16);
    m_swappedCompoundCreateFunc = new (mem)btCompoundCollisionAlgorithm::SwappedCreateFunc;
    mem = btAlignedAlloc(sizeof(btEmptyAlgorithm::CreateFunc),16);
    m_emptyCreateFunc = new(mem) btEmptyAlgorithm::CreateFunc;

    mem = btAlignedAlloc(sizeof(btSphereSphereCollisionAlgorithm::CreateFunc),16);
    m_sphereSphereCF = new(mem) btSphereSphereCollisionAlgorithm::CreateFunc;
#ifdef USE_BUGGY_SPHERE_BOX_ALGORITHM
    mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
    m_sphereBoxCF = new(mem) btSphereBoxCollisionAlgorithm::CreateFunc;
    mem = btAlignedAlloc(sizeof(btSphereBoxCollisionAlgorithm::CreateFunc),16);
    m_boxSphereCF = new (mem)btSphereBoxCollisionAlgorithm::CreateFunc;
    m_boxSphereCF->m_swapped = true;
#endif //USE_BUGGY_SPHERE_BOX_ALGORITHM

    mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
    m_sphereTriangleCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
    mem = btAlignedAlloc(sizeof(btSphereTriangleCollisionAlgorithm::CreateFunc),16);
    m_triangleSphereCF = new (mem)btSphereTriangleCollisionAlgorithm::CreateFunc;
    m_triangleSphereCF->m_swapped = true;

    mem = btAlignedAlloc(sizeof(btBoxBoxCollisionAlgorithm::CreateFunc),16);
    m_boxBoxCF = new(mem)btBoxBoxCollisionAlgorithm::CreateFunc;

    //convex versus plane
    mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
    m_convexPlaneCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
    mem = btAlignedAlloc (sizeof(btConvexPlaneCollisionAlgorithm::CreateFunc),16);
    m_planeConvexCF = new (mem) btConvexPlaneCollisionAlgorithm::CreateFunc;
    m_planeConvexCF->m_swapped = true;

    ///calculate maximum element size, big enough to fit any collision algorithm in the memory pool
    int maxSize = sizeof(btConvexConvexAlgorithm);
    int maxSize2 = sizeof(btConvexConcaveCollisionAlgorithm);
    int maxSize3 = sizeof(btCompoundCollisionAlgorithm);
    int sl = sizeof(btConvexSeparatingDistanceUtil);
    sl = sizeof(btGjkPairDetector);
    int	collisionAlgorithmMaxElementSize = btMax(maxSize,maxSize2);
    collisionAlgorithmMaxElementSize = btMax(collisionAlgorithmMaxElementSize,maxSize3);

    if (constructionInfo.m_stackAlloc)
    {
        m_ownsStackAllocator = false;
        this->m_stackAlloc = constructionInfo.m_stackAlloc;
    } else
    {
        m_ownsStackAllocator = true;
        void* mem = btAlignedAlloc(sizeof(btStackAlloc),16);
        m_stackAlloc = new(mem)btStackAlloc(constructionInfo.m_defaultStackAllocatorSize);
    }

    if (constructionInfo.m_persistentManifoldPool)
    {
        m_ownsPersistentManifoldPool = false;
        m_persistentManifoldPool = constructionInfo.m_persistentManifoldPool;
    } else
    {
        m_ownsPersistentManifoldPool = true;
        void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
        m_persistentManifoldPool = new (mem) btPoolAllocator(sizeof(btPersistentManifold),constructionInfo.m_defaultMaxPersistentManifoldPoolSize);
    }

    if (constructionInfo.m_collisionAlgorithmPool)
    {
        m_ownsCollisionAlgorithmPool = false;
        m_collisionAlgorithmPool = constructionInfo.m_collisionAlgorithmPool;
    } else
    {
        m_ownsCollisionAlgorithmPool = true;
        void* mem = btAlignedAlloc(sizeof(btPoolAllocator),16);
        m_collisionAlgorithmPool = new(mem) btPoolAllocator(collisionAlgorithmMaxElementSize,constructionInfo.m_defaultMaxCollisionAlgorithmPoolSize);
    }


//.........这里部分代码省略.........

void	ParticlesDemo::initPhysics()
{
	
	setTexturing(false);
	setShadows(false);

//	setCameraDistance(80.f);
	setCameraDistance(3.0f);
//	m_cameraTargetPosition.setValue(50, 10, 0);
	m_cameraTargetPosition.setValue(0, 0, 0);
//	m_azi = btScalar(0.f);
//	m_ele = btScalar(0.f);
	m_azi = btScalar(45.f);
	m_ele = btScalar(30.f);
	setFrustumZPlanes(0.1f, 10.f);

	///collision configuration contains default setup for memory, collision setup

	btDefaultCollisionConstructionInfo dci;
	dci.m_defaultMaxPersistentManifoldPoolSize=50000;
	dci.m_defaultMaxCollisionAlgorithmPoolSize=50000;

	m_collisionConfiguration = new btDefaultCollisionConfiguration(dci);

	///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded)
	m_dispatcher = new	btCollisionDispatcher(m_collisionConfiguration);

	m_pairCache = new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16))btHashedOverlappingPairCache(); 


//	m_broadphase = new btDbvtBroadphase(m_pairCache);
	m_broadphase = new btNullBroadphase();

	///the default constraint solver
	m_solver = new btSequentialImpulseConstraintSolver();

	m_pWorld = new btParticlesDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration, 65536);

	m_dialogDynamicsWorld = new GL_DialogDynamicsWorld();
	GL_DialogWindow* settings = m_dialogDynamicsWorld->createDialog(50,0,280,280,"CPU fallback");
	
	m_pWorld->m_useCpuControls[0] = 0;
	GL_ToggleControl* ctrl = 0;
	m_pWorld->m_useCpuControls[SIMSTAGE_INTEGRATE_MOTION] = m_dialogDynamicsWorld->createToggle(settings,"Integrate Motion");
	m_pWorld->m_useCpuControls[SIMSTAGE_COMPUTE_CELL_ID] = m_dialogDynamicsWorld->createToggle(settings,"Compute Cell ID");
	m_pWorld->m_useCpuControls[SIMSTAGE_SORT_CELL_ID] = m_dialogDynamicsWorld->createToggle(settings,"Sort Cell ID");
	m_pWorld->m_useCpuControls[SIMSTAGE_FIND_CELL_START] = m_dialogDynamicsWorld->createToggle(settings,"Find Cell Start");
	m_pWorld->m_useCpuControls[SIMSTAGE_COLLIDE_PARTICLES] = m_dialogDynamicsWorld->createToggle(settings,"Collide Particles");
	

	for(int i = 1; i < SIMSTAGE_TOTAL; i++)
	{
		m_pWorld->m_useCpuControls[i]->m_active = false;
	}
#if defined(CL_PLATFORM_MINI_CL)
	// these kernels use barrier()
	m_pWorld->m_useCpuControls[SIMSTAGE_SORT_CELL_ID]->m_active = true; 
	m_pWorld->m_useCpuControls[SIMSTAGE_FIND_CELL_START]->m_active = true; 
#endif

	// out of date
//	m_pWorld->m_useCpuControls[SIMSTAGE_SORT_CELL_ID]->m_active = true; 
//m_pWorld->m_useCpuControls[SIMSTAGE_FIND_CELL_START]->m_active = true; 


	m_dynamicsWorld = m_pWorld;

	m_pWorld->getSimulationIslandManager()->setSplitIslands(true);
	m_pWorld->setGravity(btVector3(0,-10.,0));
	m_pWorld->getSolverInfo().m_numIterations = 4;

	{
//		btCollisionShape* colShape = new btSphereShape(btScalar(1.0f));
/*	
		btCollisionShape* colShape = new btSphereShape(DEF_PARTICLE_RADIUS);
		m_collisionShapes.push_back(colShape);
		btTransform startTransform;
		startTransform.setIdentity();
		btScalar	mass(1.f);
		btVector3 localInertia(0,0,0);
		colShape->calculateLocalInertia(mass,localInertia);
		float start_x = START_POS_X - ARRAY_SIZE_X * DIST * btScalar(0.5f);
		float start_y = START_POS_Y - ARRAY_SIZE_Y * DIST * btScalar(0.5f);
		float start_z = START_POS_Z - ARRAY_SIZE_Z * DIST * btScalar(0.5f);
		startTransform.setOrigin(btVector3(start_x, start_y, start_z));
		btRigidBody::btRigidBodyConstructionInfo rbInfo(mass,0,colShape,localInertia);
		rbInfo.m_startWorldTransform = startTransform;
		btRigidBody* body = new btRigidBody(rbInfo);
		m_pWorld->addRigidBody(body);
		*/

		init_scene_directly();
	}
	clientResetScene();
	m_pWorld->initDeviceData();
}

plCollisionShapeHandle plNewCylinderShape(plReal radius, plReal height)
{
	void* mem = btAlignedAlloc(sizeof(btCylinderShape),16);
	return (plCollisionShapeHandle) new (mem)btCylinderShape(btVector3(radius,height,radius));
}

plPhysicsSdkHandle	plNewBulletSdk()
{
	void* mem = btAlignedAlloc(sizeof(btPhysicsSdk),16);
	return (plPhysicsSdkHandle)new (mem)btPhysicsSdk;
}

btPairCachingGhostObject::btPairCachingGhostObject()
{
	m_hashPairCache = new (btAlignedAlloc(sizeof(btHashedOverlappingPairCache),16)) btHashedOverlappingPairCache();
}

plCollisionShapeHandle plNewBoxShape(plReal x, plReal y, plReal z)
{
	void* mem = btAlignedAlloc(sizeof(btBoxShape),16);
	return (plCollisionShapeHandle) new (mem)btBoxShape(btVector3(x,y,z));
}

PlCylinderShape* pl_cylindershape_new(PlReal radius, PlReal height)
{
	void* mem = btAlignedAlloc(sizeof(btCylinderShape),16);
	return (PlCylinderShape*) new (mem)btCylinderShape(btVector3(radius,height,radius));
}

/* Convex Meshes */
PlConvexHullShape* pl_convexhullshape_new()
{
	void* mem = btAlignedAlloc(sizeof(btConvexHullShape),16);
	return (PlConvexHullShape*) new (mem)btConvexHullShape();
}

PlBoxShape* pl_boxshape_new(PlReal x, PlReal y, PlReal z)
{
	void* mem = btAlignedAlloc(sizeof(btBoxShape),16);
	return (PlBoxShape*) new (mem)btBoxShape(btVector3(x,y,z));
}

PlConeShape* pl_coneshape_new(PlReal radius, PlReal height)
{
	void* mem = btAlignedAlloc(sizeof(btConeShape),16);
	return (PlConeShape*) new (mem)btConeShape(radius,height);
}

PlSphereShape* pl_sphereshape_new(PlReal radius)
{
	void* mem = btAlignedAlloc(sizeof(btSphereShape),16);
	return (PlSphereShape*) new (mem)btSphereShape(radius);
	
}

PlPhysicsSdk*	pl_physicssdk_new()
{
	void* mem = btAlignedAlloc(sizeof(btPhysicsSdk),16);
	return (PlPhysicsSdk*)new (mem)btPhysicsSdk;
}

PlQuaternion* pl_quaternion_new()
{
	PlQuaternion* mem = (PlQuaternion*)(btAlignedAlloc(4 * sizeof(PlReal),16));
	return (PlQuaternion*)mem;
}

//.........这里部分代码省略.........
			gIndices[index++] = (j+1)*NUM_VERTS_X+i+1;

			gIndices[index++] = j*NUM_VERTS_X+i;
			gIndices[index++] = (j+1)*NUM_VERTS_X+i+1;
			gIndices[index++] = (j+1)*NUM_VERTS_X+i;
#endif //SHIFT_INDICES

#endif //SWAP_WINDING

			
		}
	}

	m_indexVertexArrays = new btTriangleIndexVertexArray(totalTriangles,
		gIndices,
		indexStride,
		totalVerts,(btScalar*) &gVertices[0].x(),vertStride);

	
	bool useQuantizedAabbCompression = true;

//comment out the next line to read the BVH from disk (first run the demo once to create the BVH)
#define SERIALIZE_TO_DISK 1
#ifdef SERIALIZE_TO_DISK
	btVector3 aabbMin(-1000,-1000,-1000),aabbMax(1000,1000,1000);
	
	trimeshShape  = new btBvhTriangleMeshShape(m_indexVertexArrays,useQuantizedAabbCompression,aabbMin,aabbMax);
	m_collisionShapes.push_back(trimeshShape);
	
	
	///we can serialize the BVH data 
	void* buffer = 0;
	int numBytes = trimeshShape->getOptimizedBvh()->calculateSerializeBufferSize();
	buffer = btAlignedAlloc(numBytes,16);
	bool swapEndian = false;
	trimeshShape->getOptimizedBvh()->serialize(buffer,numBytes,swapEndian);
#ifdef __QNX__
	FILE* file = fopen("app/native/bvh.bin","wb");
#else
	FILE* file = fopen("bvh.bin","wb");
#endif
	fwrite(buffer,1,numBytes,file);
	fclose(file);
	btAlignedFree(buffer);
	


#else

	trimeshShape  = new btBvhTriangleMeshShape(m_indexVertexArrays,useQuantizedAabbCompression,false);

	char* fileName = "bvh.bin";

#ifdef __QNX__
	char* fileName = "app/native/bvh.bin";
#else
	char* fileName = "bvh.bin";
#endif
	int size=0;
	btOptimizedBvh* bvh = 0;

	if (fseek(file, 0, SEEK_END) || (size = ftell(file)) == EOF || fseek(file, 0, SEEK_SET)) {        /* File operations denied? ok, just close and return failure */
		printf("Error: cannot get filesize from %s\n", fileName);
		exit(0);
	} else
	{