void Physics::Init() { broadphase = new btDbvtBroadphase(); btVector3 worldAabbMin(-1000, -1000, -1000); btVector3 worldAabbMax(1000, 1000, 1000); broadphase = new btAxisSweep3(worldAabbMin, worldAabbMax, MAX_PROXIES); collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); dispatcher = new btCollisionDispatcher(collisionConfiguration); solver = new btSequentialImpulseConstraintSolver(); //new btConstraintSolver() softBodySolver = new btDefaultSoftBodySolver(); dynamicsWorld = new btSoftRigidDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration, softBodySolver); dynamicsWorld->setGravity(btVector3(0, -10, 0)); softBodyWorldInfo.m_broadphase = broadphase; softBodyWorldInfo.m_dispatcher = dispatcher; softBodyWorldInfo.m_gravity.setValue(0, -10, 0); softBodyWorldInfo.air_density = (btScalar)0.2; softBodyWorldInfo.water_density = 0; softBodyWorldInfo.water_offset = 0; softBodyWorldInfo.water_normal = btVector3(0, 0, 0); softBodyWorldInfo.m_sparsesdf.Initialize(); blob = nullptr; }
void startup(gemini::Allocator& allocator) { physics_allocator = &allocator; // TODO@apetrone: set up custom allocation with btAlignedAllocSetCustom. collision_config = new btDefaultCollisionConfiguration(); dispatcher = new btCollisionDispatcher( collision_config ); btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); constraint_solver = new btSequentialImpulseConstraintSolver(); broadphase = new btDbvtBroadphase(); // broadphase = new btAxisSweep3(worldAabbMin, worldAabbMax); pair_cache = broadphase->getOverlappingPairCache(); // setup ghost pair callback instance pair_cache->setInternalGhostPairCallback( new CustomGhostPairCallback() ); dynamics_world = new btDiscreteDynamicsWorld(dispatcher, (btBroadphaseInterface*)broadphase, constraint_solver, collision_config); dynamics_world->setGravity( btVector3( 0, -9.8f, 0 ) ); // dynamics_world->getDispatchInfo().m_useConvexConservativeDistanceUtil = true; // dynamics_world->getDispatchInfo().m_convexConservativeDistanceThreshold = 0.01; dynamics_world->getDispatchInfo().m_allowedCcdPenetration = 0.0001f; // instance and set the debug renderer debug_renderer = MEMORY2_NEW(*physics_allocator, bullet::DebugPhysicsRenderer); dynamics_world->setDebugDrawer(debug_renderer); }
void PhysicalSystem::initPhysicalSystem() { ///collision configuration contains default setup for memory, collision setup. Advanced users can create their own configuration. collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); //dispatcher =0; ///use the default collision dispatcher. For parallel processing you can use a diffent dispatcher (see Extras/BulletMultiThreaded) dispatcher = new btCollisionDispatcher(collisionConfiguration); btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); broadPhase = new btAxisSweep3(worldAabbMin,worldAabbMax,32766); softBodyWorldInfo.m_dispatcher = dispatcher; softBodyWorldInfo.m_broadphase = broadPhase; softBodyWorldInfo.air_density = (btScalar)1.2; softBodyWorldInfo.water_density = 0; softBodyWorldInfo.water_offset = 0; softBodyWorldInfo.water_normal = btVector3(0,0,0); softBodyWorldInfo.m_gravity.setValue(0,-10,0); softBodyWorldInfo.m_sparsesdf.Initialize(); ///the default constraint solver. For parallel processing you can use a different solver (see Extras/BulletMultiThreaded) solver = new btSequentialImpulseConstraintSolver; dynamicsWorld = new btSoftRigidDynamicsWorld(dispatcher,broadPhase,solver,collisionConfiguration); //softBodyWorldInfo.m_gravity.setValue(0,-10,0); }
void DoublePrecisionDemo::initPhysics() { m_debugMode |= btIDebugDraw::DBG_DrawWireframe; btMatrix3x3 basisA; basisA.setIdentity(); btMatrix3x3 basisB; basisB.setIdentity(); objects[0].getWorldTransform().setBasis(basisA); objects[1].getWorldTransform().setBasis(basisB); btBoxShape* boxA = new btBoxShape(btVector3(0.5,0.5,0.5)); btBoxShape* boxB = new btBoxShape(btVector3(0.5,0.5,0.5)); objects[0].setCollisionShape(boxA);//&hullA; objects[1].setCollisionShape(boxB);//&hullB; btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration); btVector3 worldAabbMin(80000,80000,80000); btVector3 worldAabbMax(120000,120000,120000); btAxisSweep3* broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax); collisionWorld = new btCollisionWorld(dispatcher,broadphase,collisionConfiguration); collisionWorld->addCollisionObject(&objects[0]); collisionWorld->addCollisionObject(&objects[1]); }
void ColladaDemo::initPhysics(const char* filename) { m_cameraUp = SimdVector3(0,0,1); m_forwardAxis = 1; ///Setup a Physics Simulation Environment CollisionDispatcher* dispatcher = new CollisionDispatcher(); SimdVector3 worldAabbMin(-10000,-10000,-10000); SimdVector3 worldAabbMax(10000,10000,10000); OverlappingPairCache* broadphase = new AxisSweep3(worldAabbMin,worldAabbMax); //BroadphaseInterface* broadphase = new SimpleBroadphase(); m_physicsEnvironmentPtr = new CcdPhysicsEnvironment(dispatcher,broadphase); m_physicsEnvironmentPtr->setDeactivationTime(2.f); m_physicsEnvironmentPtr->setGravity(0,0,-10); m_physicsEnvironmentPtr->setDebugDrawer(&debugDrawer); MyColladaConverter* converter = new MyColladaConverter(this); bool result = converter->load(filename); if (result) { result = converter->convert(); } if (result) { gColladaConverter = converter; } else { gColladaConverter = 0; } }
void PendulumApplication::initPhysics() { setCameraDistance(8.); m_debugMode |= btIDebugDraw::DBG_NoHelpText; ///register some softbody collision algorithms on top of the default btDefaultCollisionConfiguration m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); m_softBodyWorldInfo.m_dispatcher = m_dispatcher; btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); m_broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,maxProxies); m_softBodyWorldInfo.m_broadphase = m_broadphase; btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver(); m_solver = solver; btSoftBodySolver* softBodySolver = 0; btDiscreteDynamicsWorld* world = new btSoftRigidDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration,softBodySolver); m_dynamicsWorld = world; m_dynamicsWorld->setDebugDrawer(&gDebugDrawer); m_dynamicsWorld->getDispatchInfo().m_enableSPU = true; m_dynamicsWorld->setGravity(btVector3(0,-10,0)); m_softBodyWorldInfo.m_gravity.setValue(0,-10,0); m_softBodyWorldInfo.m_sparsesdf.Initialize(); //create a few basic rigid bodies btBoxShape* groundShape = new btBoxShape(btVector3(btScalar(50.),btScalar(50.),btScalar(50.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-50,0)); localCreateRigidBody(0,groundTransform,groundShape); //buildDoublePendulumRigid(); //buildDoublePendulumSoft(); buildFlyingTrapeze(); m_softBodyWorldInfo.m_sparsesdf.Reset(); m_softBodyWorldInfo.air_density = (btScalar)1.2; m_softBodyWorldInfo.water_density = 0; m_softBodyWorldInfo.water_offset = 0; m_softBodyWorldInfo.water_normal = btVector3(0,0,0); m_softBodyWorldInfo.m_gravity.setValue(0,-10,0); }
World::World() : m_root(new osg::Group) { btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher *dispatcher = new btCollisionDispatcher(collisionConfiguration); btConstraintSolver *solver = new btSequentialImpulseConstraintSolver(); btVector3 worldAabbMin(-10000, -10000, -10000); btVector3 worldAabbMax(10000, 10000, 10000); btBroadphaseInterface *inter = new btDbvtBroadphase(); m_dynamics = new btDiscreteDynamicsWorld(dispatcher, inter, solver, collisionConfiguration); m_dynamics->setGravity(btVector3(0, 0, -10)); }
void RagdollDemo::initPhysics() { // Setup the basic world setTexturing(true); setShadows(true); setCameraDistance(btScalar(5.)); m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); //m_dynamicsWorld->getDispatchInfo().m_useConvexConservativeDistanceUtil = true; //m_dynamicsWorld->getDispatchInfo().m_convexConservativeDistanceThreshold = 0.01f; // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(10.),btScalar(200.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-10,0)); #define CREATE_GROUND_COLLISION_OBJECT 1 #ifdef CREATE_GROUND_COLLISION_OBJECT btCollisionObject* fixedGround = new btCollisionObject(); fixedGround->setCollisionShape(groundShape); fixedGround->setWorldTransform(groundTransform); m_dynamicsWorld->addCollisionObject(fixedGround); #else localCreateRigidBody(btScalar(0.),groundTransform,groundShape); #endif //CREATE_GROUND_COLLISION_OBJECT } // Spawn one ragdoll btVector3 startOffset(1,0.5,0); spawnRagdoll(startOffset); startOffset.setValue(-1,0.5,0); spawnRagdoll(startOffset); clientResetScene(); }
btCollisionWorld* initCollision() { btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher( collisionConfiguration ); btVector3 worldAabbMin( -10000, -10000, -10000 ); btVector3 worldAabbMax( 10000, 10000, 10000 ); btBroadphaseInterface* inter = new btAxisSweep3( worldAabbMin, worldAabbMax, 1000 ); btCollisionWorld* collisionWorld = new btCollisionWorld( dispatcher, inter, collisionConfiguration ); return( collisionWorld ); }
void ArtificialBirdsDemoApp::initPhysics() { // Setup the basic world setTexturing(true); setShadows(true); setCameraDistance(btScalar(5.)); m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); //m_dynamicsWorld->getDispatchInfo().m_useConvexConservativeDistanceUtil = true; //m_dynamicsWorld->getDispatchInfo().m_convexConservativeDistanceThreshold = 0.01f; m_dynamicsWorld->setInternalTickCallback(pickingPreTickCallback, this, true); m_dynamicsWorld->getSolverInfo().m_numIterations = kSolverNumIterations; m_dynamicsWorld->setGravity(btVector3(0,kGravity,0)); // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(10.),btScalar(200.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-10,0)); #define CREATE_GROUND_COLLISION_OBJECT 1 #ifdef CREATE_GROUND_COLLISION_OBJECT btCollisionObject* fixedGround = new btCollisionObject(); fixedGround->setCollisionShape(groundShape); fixedGround->setWorldTransform(groundTransform); m_dynamicsWorld->addCollisionObject(fixedGround); #else localCreateRigidBody(btScalar(0.),groundTransform,groundShape); #endif //CREATE_GROUND_COLLISION_OBJECT } m_birdOpt = 0; m_birdDemo = 0; //m_birdOpt = new BirdOptimizer(m_dynamicsWorld); m_birdDemo = new BirdDemo(m_dynamicsWorld); clientResetScene(); }
void RagdollApp::initPhysics() { // Setup the basic world m_time = 0; m_CycPerKnee = 2000.f; // in milliseconds m_CycPerHip = 3000.f; // in milliseconds m_fMuscleStrength = 0.5f; setTexturing(true); setShadows(true); setCameraDistance(btScalar(5.)); m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); //m_dynamicsWorld->getDispatchInfo().m_useConvexConservativeDistanceUtil = true; //m_dynamicsWorld->getDispatchInfo().m_convexConservativeDistanceThreshold = 0.01f; m_dynamicsWorld->setInternalTickCallback( forcePreTickCB, this, true ); m_dynamicsWorld->setGravity( btVector3(0,-0,0) ); // create surface //createSurface(); //// Setup a big ground box btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(10.),btScalar(200.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-10,0)); btCollisionObject* fixedGround = new btCollisionObject(); fixedGround->setCollisionShape(groundShape); fixedGround->setWorldTransform(groundTransform); m_dynamicsWorld->addCollisionObject(fixedGround); // Spawn one ragdoll btVector3 startOffset(1,0.5,0); spawnRagdoll(startOffset); startOffset.setValue(-1,0.1,0); spawnRagdoll(startOffset); clientResetScene(); }
void MotorDemo::initPhysics() { setTexturing(true); setShadows(true); // Setup the basic world m_Time = 0; m_fCyclePeriod = 2000.f; // in milliseconds // m_fMuscleStrength = 0.05f; // new SIMD solver for joints clips accumulated impulse, so the new limits for the motor // should be (numberOfsolverIterations * oldLimits) // currently solver uses 10 iterations, so: m_fMuscleStrength = 0.5f; setCameraDistance(btScalar(5.)); m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); m_dynamicsWorld->setInternalTickCallback(motorPreTickCallback,this,true); // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(10.),btScalar(200.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-10,0)); localCreateRigidBody(btScalar(0.),groundTransform,groundShape); } // Spawn one ragdoll btVector3 startOffset(1,0.5,0); spawnTestRig(startOffset, false); startOffset.setValue(-2,0.5,0); spawnTestRig(startOffset, true); clientResetScene(); }
void PhysicsEngine::Init() { srand(GetTickCount()); btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); const int maxProxies = 32766; m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_solver = new btSequentialImpulseConstraintSolver(); m_broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,maxProxies); btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); Reset(); }
PhysicsEngine::PhysicsEngine() { m_CollisionConfig = new btDefaultCollisionConfiguration(); m_Dispatcher = new btCollisionDispatcher(m_CollisionConfig); double scene_size = 1000.0; btScalar sscene_size = (btScalar)scene_size; btVector3 worldAabbMin(-sscene_size, -sscene_size, -sscene_size); btVector3 worldAabbMax(sscene_size, sscene_size, sscene_size); //This is one type of broadphase, bullet has others that might be faster depending on the application m_Broadphase = new bt32BitAxisSweep3(worldAabbMin, worldAabbMax, 16000, 0, true); // true for disabling raycast accelerator m_Solver = new btSequentialImpulseConstraintSolver(); m_World = new btDiscreteDynamicsWorld(m_Dispatcher, m_Broadphase, m_Solver, m_CollisionConfig); m_World->setGravity(btVector3(0.0f, -9.18f, 0.0f)); }
//-------------------------------------------------------------- void ofxBulletWorldSoft::setup() { if(broadphase == NULL) { btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); } if(collisionConfig == NULL) collisionConfig = new btSoftBodyRigidBodyCollisionConfiguration(); if(dispatcher == NULL) dispatcher = new btCollisionDispatcher( collisionConfig ); if(solver == NULL) solver = new btSequentialImpulseConstraintSolver; if(world == NULL) world = new btSoftRigidDynamicsWorld(dispatcher, broadphase, solver, collisionConfig); // default gravity // setGravity(ofVec3f(0.f, 9.8f, 0.f)); world->getDispatchInfo().m_enableSPU = true; world->getWorldInfo().m_sparsesdf.Initialize(); world->getWorldInfo().air_density = (btScalar)1.2; world->getWorldInfo().m_sparsesdf.Reset(); /* Nodes = 0x0001, Links = 0x0002, Faces = 0x0004, Tetras = 0x0008, Normals = 0x0010, Contacts = 0x0020, Anchors = 0x0040, Notes = 0x0080, Clusters = 0x0100, NodeTree = 0x0200, FaceTree = 0x0400, ClusterTree = 0x0800, Joints = 0x1000, Std = Links+Faces+Tetras+Anchors+Notes+Joints, StdTetra = Std-Faces+Tetras*/ world->setDrawFlags(fDrawFlags::Links | fDrawFlags::Normals | fDrawFlags::Joints | fDrawFlags::Anchors | fDrawFlags::Contacts | fDrawFlags::Faces ); }
//----------------------------------- void CollisionManager::init() { m_pCollisionConfig = new btDefaultCollisionConfiguration(); ///the maximum size of the collision world. Make sure objects stay within these boundaries ///Don't make the world AABB size too large, it will harm simulation quality and performance btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_pBroadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,MAX_PROXIES); m_pCollisionDispatcher = new btCollisionDispatcher(m_pCollisionConfig); m_pConstraintSolver = new btSequentialImpulseConstraintSolver; m_pDynamicsWorld = new btDiscreteDynamicsWorld(m_pCollisionDispatcher,m_pBroadphase,m_pConstraintSolver,m_pCollisionConfig); m_pDynamicsWorld->setGravity(btVector3(0,0,0)); }
btDynamicsWorld * initPhysics() { btDefaultCollisionConfiguration * collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher * dispatcher = new btCollisionDispatcher( collisionConfiguration ); btConstraintSolver * solver = new btSequentialImpulseConstraintSolver; btVector3 worldAabbMin( -10000, -10000, -10000 );// 进行aabb算法的范围? btVector3 worldAabbMax( 10000, 10000, 10000 ); btBroadphaseInterface * inter = new btAxisSweep3( worldAabbMin, worldAabbMax, 1000 );//采用的碰撞检测算法 btDynamicsWorld * dynamicsWorld = new btDiscreteDynamicsWorld( dispatcher, inter, solver, collisionConfiguration ); dynamicsWorld->setGravity( btVector3( 0, 0, -10 ) ); return( dynamicsWorld ); }
void ChainBtDynamics::initPhysics() { // Setup the basic world m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); //m_dynamicsWorld->setGravity(btVector3(0.0f, -9.8f*GRAVITY_SCALE, 0.0f)); //m_dynamicsWorld->setGravity(btVector3(0.0f, 0.1f*GRAVITY_SCALE, 0.0f)); //m_dynamicsWorld->setGravity(btVector3(0.0f, -3.0f*GRAVITY_SCALE, 0.0f)); m_dynamicsWorld->setGravity(btVector3(0.0f, 0.00f*GRAVITY_SCALE, 0.0f)); //m_dynamicsWorld->getDispatchInfo().m_useConvexConservativeDistanceUtil = true; //m_dynamicsWorld->getDispatchInfo().m_convexConservativeDistanceThreshold = 0.01f; // Setup a big ground box //{ // //btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(1.5),btScalar(0.1),btScalar(1.5))); // // btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(3000.0f), // btScalar(600.0f), // btScalar(3000.0f))); // m_collisionShapes.push_back(groundShape); // btTransform groundTransform; // groundTransform.setIdentity(); // //groundTransform.setOrigin(btVector3(0,-10,0)); // groundTransform.setOrigin(btVector3(0,-600.0f,0)); // // btCollisionObject* fixedGround = new btCollisionObject(); // fixedGround->setCollisionShape(groundShape); // fixedGround->setWorldTransform(groundTransform); // m_groundInfo.isGround = true; // fixedGround->setUserPointer(&m_groundInfo); // // m_dynamicsWorld->addCollisionObject(fixedGround); //} btVector3 startOffset(0,100,0); clientResetScene(); }
BulletPhysics::BulletPhysics(double configGravity[3],osgOcean::OceanTechnique* oceanSurf,PhysicsWater physicsWater) { collisionConfiguration = new btHfFluidRigidCollisionConfiguration(); dispatcher = new btCollisionDispatcher( collisionConfiguration ); solver = new btSequentialImpulseConstraintSolver(); btVector3 worldAabbMin( -10000, -10000, -10000 ); btVector3 worldAabbMax( 10000, 10000, 10000 ); inter = new btAxisSweep3( worldAabbMin, worldAabbMax, 1000 ); dynamicsWorld = new btHfFluidRigidDynamicsWorld( dispatcher, inter, solver, collisionConfiguration ); dynamicsWorld->getDispatchInfo().m_enableSPU = true; btVector3 gravity(configGravity[0],configGravity[1],configGravity[2]); if(configGravity[0]==0 && configGravity[1]==0 && configGravity[2]==0){ gravity=UWSIM_DEFAULT_GRAVITY; } dynamicsWorld->setGravity( gravity); oceanSurface=oceanSurf; if(physicsWater.enable){ fluid = new btHfFluid (physicsWater.resolution, physicsWater.size[0], physicsWater.size[1],physicsWater.size[2], physicsWater.size[3],physicsWater.size[4] , physicsWater.size[5]); //fluid = new btHfFluid (btScalar(0.25), 100,100); btTransform xform; xform.setIdentity (); xform.getOrigin() = btVector3(physicsWater.position[0], physicsWater.position[1], physicsWater.position[2]); //xform.setRotation(btQuaternion(0,1.57,0)); fluid->setWorldTransform (xform); fluid->setHorizontalVelocityScale (btScalar(0.0f)); fluid->setVolumeDisplacementScale (btScalar(0.0f)); dynamicsWorld->addHfFluid (fluid); for (int i = 0; i < fluid->getNumNodesLength()*fluid->getNumNodesWidth(); i++){ fluid->setFluidHeight(i, btScalar(0.0f)); } fluid->prep (); } else fluid=NULL; /*debugDrawer.setDebugMode(btIDebugDraw::DBG_DrawContactPoints|| btIDebugDraw::DBG_DrawWireframe || btIDebugDraw::DBG_DrawText); dynamicsWorld->setDebugDrawer(&debugDrawer); debugDrawer.BeginDraw(); debugDrawer.setEnabled(true);*/ }
// init void MBulletContext::init(const MVector3 & worldMin, const MVector3 & worldMax) { clear(); m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); int maxProxies = 1024; btVector3 worldAabbMin(worldMin.x, worldMin.y, worldMin.z); btVector3 worldAabbMax(worldMax.x, worldMax.y, worldMax.z); //m_overlappingPairCache = new btAxisSweep3(worldAabbMin, worldAabbMax, maxProxies); m_overlappingPairCache = new btDbvtBroadphase(); m_solver = new btSequentialImpulseConstraintSolver(); m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher, m_overlappingPairCache, m_solver, m_collisionConfiguration); m_dynamicsWorld->setGravity(btVector3(0,0,-10)); }
void CollisionInterfaceDemo::initPhysics() { m_debugMode |= btIDebugDraw::DBG_DrawWireframe; btMatrix3x3 basisA; basisA.setIdentity(); btMatrix3x3 basisB; basisB.setIdentity(); objects[0].getWorldTransform().setBasis(basisA); objects[1].getWorldTransform().setBasis(basisB); btBoxShape* boxA = new btBoxShape(btVector3(1,1,1)); boxA->setMargin(0.f); btBoxShape* boxB = new btBoxShape(btVector3(0.5,0.5,0.5)); boxB->setMargin(0.f); //ConvexHullShape hullA(points0,3); //hullA.setLocalScaling(btVector3(3,3,3)); //ConvexHullShape hullB(points1,4); //hullB.setLocalScaling(btVector3(4,4,4)); objects[0].setCollisionShape(boxA);//&hullA; objects[1].setCollisionShape(boxB);//&hullB; btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration); btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); btAxisSweep3* broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax); //SimpleBroadphase is a brute force alternative, performing N^2 aabb overlap tests //SimpleBroadphase* broadphase = new btSimpleBroadphase; collisionWorld = new btCollisionWorld(dispatcher,broadphase,collisionConfiguration); collisionWorld->setDebugDrawer(&debugDrawer); #ifdef TEST_NOT_ADDING_OBJECTS_TO_WORLD // collisionWorld->addCollisionObject(&objects[0]); collisionWorld->addCollisionObject(&objects[1]); #endif //TEST_NOT_ADDING_OBJECTS_TO_WORLD }
void ConvexDecompositionDemo::setupEmptyDynamicsWorld() { m_collisionConfiguration = new btDefaultCollisionConfiguration(); #ifdef USE_PARALLEL_DISPATCHER #ifdef USE_WIN32_THREADING int maxNumOutstandingTasks = 4;//number of maximum outstanding tasks Win32ThreadSupport* threadSupport = new Win32ThreadSupport(Win32ThreadSupport::Win32ThreadConstructionInfo( "collision", processCollisionTask, createCollisionLocalStoreMemory, maxNumOutstandingTasks)); #else ///@todo other platform threading ///Playstation 3 SPU (SPURS) version is available through PS3 Devnet ///Libspe2 SPU support will be available soon ///pthreads version ///you can hook it up to your custom task scheduler by deriving from btThreadSupportInterface #endif m_dispatcher = new SpuGatheringCollisionDispatcher(threadSupport,maxNumOutstandingTasks,m_collisionConfiguration); #else m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); #endif//USE_PARALLEL_DISPATCHER gCompoundChildShapePairCallback = MyCompoundChildShapeCallback; convexDecompositionObjectOffset.setValue(10,0,0); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax); //m_broadphase = new btSimpleBroadphase(); m_solver = new btSequentialImpulseConstraintSolver(); m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration); #ifdef USE_PARALLEL_DISPATCHER m_dynamicsWorld->getDispatchInfo().m_enableSPU = true; #endif //USE_PARALLEL_DISPATCHER }
Physics::Physics() { body_max_ = 16384; /* Maximum number of rigid bodies */ btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); broadphase_ = new btAxisSweep3(worldAabbMin,worldAabbMax,body_max_); collisionConfiguration_ = new btDefaultCollisionConfiguration(); dispatcher_ = new btCollisionDispatcher(collisionConfiguration_); solver_ = new btSequentialImpulseConstraintSolver; dynamicsWorld_ = new btDiscreteDynamicsWorld(dispatcher_, broadphase_, solver_, collisionConfiguration_); setGravity(GRAVITY_EARTH); //gDebugDrawer_.setDebugMode(1); //dynamicsWorld_->setDebugDrawer(&gDebugDrawer_); body_count_ = 0; }
void BulletSoftObject::init() { btDefaultCollisionConfiguration* m_collisionConfiguration = new btSoftBodyRigidBodyCollisionConfiguration(); btCollisionDispatcher* m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); getEnvironment()->bullet->dispatcher = m_dispatcher; btVector3 worldAabbMin(-1000,-1000,-1000); btVector3 worldAabbMax(1000,1000,1000); btBroadphaseInterface* m_broadphase = new btAxisSweep3(worldAabbMin,worldAabbMax,32766); getEnvironment()->bullet->broadphase = m_broadphase; btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver(); getEnvironment()->bullet->solver = solver; //btSoftRigidDynamicsWorld* world = new btSoftRigidDynamicsWorld(m_dispatcher,m_broadphase,solver,m_collisionConfiguration); //getEnvironment()->bullet->dynamicsWorld = world; //m_dynamicsWorld->setInternalTickCallback(pickingPreTickCallback,this,true); //getEnvironment()->bullet->dynamicsWorld->getDispatchInfo().m_enableSPU = true; //getEnvironment()->bullet->dynamicsWorld->setGravity(btVector3(0,0,-10)); //m_softBodyWorldInfo.m_gravity.setValue(0,-10,0); getEnvironment()->bullet->dynamicsWorld->addSoftBody(softBody.get()); vertices = new osg::Vec3Array; normals = new osg::Vec3Array; geom = new osg::Geometry; geom->setDataVariance(osg::Object::DYNAMIC); geom->setUseDisplayList(false); geom->setUseVertexBufferObjects(true); geom->setVertexArray(vertices.get()); geom->setNormalArray(normals.get()); geom->setNormalBinding(osg::Geometry::BIND_PER_VERTEX); osg::ref_ptr<osg::Geode> geode = new osg::Geode; geode->addDrawable(geom); transform = new osg::MatrixTransform; transform->addChild(geode); getEnvironment()->osg->root->addChild(transform); }
void Simulation::initPhysics() { // setup the ANN ANN* neuralNet = new ANN(); neuralNet->loadXML(); // Setup the basic world m_collisionConfiguration = new btDefaultCollisionConfiguration(); m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); m_broadphase = new btAxisSweep3 (worldAabbMin, worldAabbMax); m_solver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher, m_broadphase, m_solver,m_collisionConfiguration); //tick = 0; m_dynamicsWorld->setInternalTickCallback(robotPreTickCallback, this, true); // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.), btScalar(10.),btScalar(200.))); m_collisionShapes.push_back(groundShape); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-10,0)); btCollisionObject* fixedGround = new btCollisionObject(); fixedGround->setCollisionShape(groundShape); fixedGround->setWorldTransform(groundTransform); m_dynamicsWorld->addCollisionObject(fixedGround); } // Spawn one ragdoll btVector3 startOffset(1,0.5,0); spawnRagdoll(startOffset); }
// Bullet engine initialisation btDynamicsWorld* Scene::initBulletEngine() { btDefaultCollisionConfiguration * collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher * dispatcher = new btCollisionDispatcher( collisionConfiguration ); btConstraintSolver * solver = new btSequentialImpulseConstraintSolver; solver->reset(); // Anything outside this area won't be taken into account by bullet btVector3 worldAabbMin( -10000, -10000, -10000 ); btVector3 worldAabbMax( 10000, 10000, 10000 ); btBroadphaseInterface * inter = new btAxisSweep3( worldAabbMin, worldAabbMax, 1000 ); // You can now use: dynamicsWorld->addRigidBody( btRigidBody ); to add an object the simulation btDynamicsWorld * dynamicsWorld = new btDiscreteDynamicsWorld( dispatcher, inter, solver, collisionConfiguration ); dynamicsWorld->getPairCache()->setInternalGhostPairCallback(new btGhostPairCallback()); dynamicsWorld->setGravity( btVector3( 0, 0, -250 ) ); return( dynamicsWorld ); }
int main(int argc,char** argv) { clientResetScene(); SimdMatrix3x3 basisA; basisA.setIdentity(); SimdMatrix3x3 basisB; basisB.setIdentity(); objects[0].m_worldTransform.setBasis(basisA); objects[1].m_worldTransform.setBasis(basisB); SimdPoint3 points0[3]={SimdPoint3(1,0,0),SimdPoint3(0,1,0),SimdPoint3(0,0,1)}; SimdPoint3 points1[5]={SimdPoint3(1,0,0),SimdPoint3(0,1,0),SimdPoint3(0,0,1),SimdPoint3(0,0,-1),SimdPoint3(-1,-1,0)}; BoxShape boxA(SimdVector3(1,1,1)); BoxShape boxB(SimdVector3(0.5,0.5,0.5)); //ConvexHullShape hullA(points0,3); //hullA.setLocalScaling(SimdVector3(3,3,3)); //ConvexHullShape hullB(points1,4); //hullB.setLocalScaling(SimdVector3(4,4,4)); objects[0].m_collisionShape = &boxA;//&hullA; objects[1].m_collisionShape = &boxB;//&hullB; CollisionDispatcher dispatcher; //SimpleBroadphase broadphase; SimdVector3 worldAabbMin(-1000,-1000,-1000); SimdVector3 worldAabbMax(1000,1000,1000); AxisSweep3 broadphase(worldAabbMin,worldAabbMax); collisionWorld = new CollisionWorld(&dispatcher,&broadphase); collisionWorld->AddCollisionObject(&objects[0]); collisionWorld->AddCollisionObject(&objects[1]); return glutmain(argc, argv,screenWidth,screenHeight,"Collision Interface Demo"); }
BB_World* BB_NewWorld() { BB_World* ret = new BB_World(); ret->collisionConfiguration = new btDefaultCollisionConfiguration(); ret->dispatcher = new btCollisionDispatcher(ret->collisionConfiguration); btVector3 worldAabbMin(-100, -100, -100); btVector3 worldAabbMax(100, 100, 100); ret->broadphase = new btAxisSweep3(worldAabbMin, worldAabbMax); ret->solver = new btSequentialImpulseConstraintSolver(); ret->dynamicsWorld = new btDiscreteDynamicsWorld( ret->dispatcher, ret->broadphase, ret->solver, ret->collisionConfiguration); ret->broadphase->getOverlappingPairCache()->setInternalGhostPairCallback(new btGhostPairCallback()); return ret; }
void GenericJointDemo::initPhysics() { setTexturing(true); setShadows(true); // Setup the basic world btDefaultCollisionConfiguration * collision_config = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collision_config); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); btBroadphaseInterface* overlappingPairCache = new btAxisSweep3 (worldAabbMin, worldAabbMax); btConstraintSolver* constraintSolver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,overlappingPairCache,constraintSolver,collision_config); m_dynamicsWorld->setGravity(btVector3(0,-10,0)); m_dynamicsWorld->setDebugDrawer(&debugDrawer); //m_dynamicsWorld->getSolverInfo().m_restingContactRestitutionThreshold = 0.f; // m_singleAxisRollingFrictionThreshold = 0.f;//faster but lower quality // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(0.),btScalar(200.))); //! 0 thickness btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-8,0)); m_ground = localCreateRigidBody(btScalar(0.),groundTransform,groundShape); } Swing* swing1 = new Swing( m_dynamicsWorld, btVector3(0,9,0), 4.0f, m_ground ); Swing* swing2 = new Swing( m_dynamicsWorld, btVector3(4,9,0), 4.0f, m_ground ); clientResetScene(); }
void GenericJointDemo::initPhysics() { setTexturing(true); setShadows(true); // Setup the basic world btDefaultCollisionConfiguration * collision_config = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collision_config); btVector3 worldAabbMin(-10000,-10000,-10000); btVector3 worldAabbMax(10000,10000,10000); btBroadphaseInterface* overlappingPairCache = new btAxisSweep3 (worldAabbMin, worldAabbMax); btConstraintSolver* constraintSolver = new btSequentialImpulseConstraintSolver; m_dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher,overlappingPairCache,constraintSolver,collision_config); m_dynamicsWorld->setGravity(btVector3(0,-30,0)); m_dynamicsWorld->setDebugDrawer(&debugDrawer); // Setup a big ground box { btCollisionShape* groundShape = new btBoxShape(btVector3(btScalar(200.),btScalar(10.),btScalar(200.))); btTransform groundTransform; groundTransform.setIdentity(); groundTransform.setOrigin(btVector3(0,-15,0)); localCreateRigidBody(btScalar(0.),groundTransform,groundShape); } // Spawn one ragdoll spawnRagdoll(); clientResetScene(); }