diff --git a/Demos/BulletDinoDemo/BulletDino.c b/Demos/BulletDinoDemo/BulletDino.c index a9619f2a4..ffba22ab4 100644 --- a/Demos/BulletDinoDemo/BulletDino.c +++ b/Demos/BulletDinoDemo/BulletDino.c @@ -1,5 +1,8 @@ -/// this demo will be modified to use the upcoming Bullet C-API, stay tuned. +/* This demo has been modified to use the Bullet C-API. + The C-API is minimal, and will develop based on developer feedback. + The C++ API is recommended, and compatible with the C-API. +*/ /* Copyright (c) Mark J. Kilgard, 1994, 1997. */ @@ -68,6 +71,16 @@ #endif +//#include "../../include/Bullet-C-Api.h" +#include "../include/Bullet-C-Api.h" + + + +plPhysicsSdkHandle physicsSdk=0; +plDynamicsWorldHandle dynamicsWorld=0; +plRigidBodyHandle floorRigidBody; +plRigidBodyHandle dinoRigidBody; + /* Variable controlling various rendering modes. */ static int stencilReflection = 1, stencilShadow = 1, offsetShadow = 1; static int renderShadow = 1, renderDinosaur = 1, renderReflection = 1; @@ -136,6 +149,7 @@ makeFloorTexture(void) GLubyte floorTexture[16][16][3]; GLubyte *loc; int s, t; + loc=0; /* Setup RGB image for the texture. */ loc = (GLubyte*) floorTexture; @@ -325,10 +339,22 @@ static void drawDinosaur(void) { - glPushMatrix(); + plReal matrix[16]; + plVector3 dinoWorldPos; + + glPushMatrix(); /* Translate the dinosaur to be at (0,8,0). */ - glTranslatef(-8, 0, -bodyWidth / 2); - glTranslatef(0.0, jump, 0.0); + + plGetOpenGLMatrix(dinoRigidBody,matrix); +// plGetPosition(dinoRigidBody,dinoWorldPos); + // glTranslatef(-8, 0, -bodyWidth / 2); + //glTranslatef(0.0, jump, 0.0); +// glTranslatef(dinoWorldPos[0],dinoWorldPos[1],dinoWorldPos[2]); + + glMultMatrixf(matrix); +// glutSolidCube(15); + glTranslatef(-8.5, -8.5, 0); + glMaterialfv(GL_FRONT, GL_DIFFUSE, skinColor); glCallList(BODY_WHOLE); glTranslatef(0.0, 0.0, bodyWidth); @@ -341,6 +367,8 @@ drawDinosaur(void) glTranslatef(0.0, 0.0, bodyWidth / 2 - 0.1); glMaterialfv(GL_FRONT, GL_DIFFUSE, eyeColor); glCallList(EYE_WHOLE); + + glPopMatrix(); } @@ -660,7 +688,7 @@ motion(int x, int y) starty = y; glutPostRedisplay(); } - if (lightMoving) { + if (0){//lightMoving) { lightAngle += (x - lightStartX)/40.0; lightHeight += (lightStartY - y)/20.0; lightStartX = x; @@ -674,13 +702,21 @@ static void idle(void) { static float time = 0.0; + static float prevtime = 0.0; + float dtime; + prevtime = time; time = glutGet(GLUT_ELAPSED_TIME) / 500.0; + dtime = time - prevtime; jump = 4.0 * fabs(sin(time)*0.5); if (!lightMoving) { - lightAngle += 0.03; + lightAngle = time; } + + if (dynamicsWorld) + plStepSimulation(dynamicsWorld,dtime); + glutPostRedisplay(); } @@ -792,12 +828,65 @@ supportsOneDotOne(void) return 0; /* OpenGL version string malformed! */ } + int main(int argc, char **argv) { int i; + plCollisionShapeHandle floorShape; + plCollisionShapeHandle dinoShape,dinoChildShape; + plVector3 floorPos,childPos; + plVector3 dinoPos; + plQuaternion childOrn,dinoOrient; + + void* user_data; + + physicsSdk = plNewBulletSdk(); + dynamicsWorld = plCreateDynamicsWorld(physicsSdk); -printf("BulletDino\n"); + //create ground plane + + floorShape = plNewConvexHullShape(); + + for (i=0;i<4;i++) + { +// floorVertices + plAddVertex(floorShape,floorVertices[i][0],floorVertices[i][1],floorVertices[i][2]); + } + + + floorShape = plNewBoxShape(120,0,120); + + floorRigidBody = plCreateRigidBody(user_data,0.f,floorShape); + floorPos[0] = 0; + floorPos[1] = 0; + floorPos[2] = 0; + + plSetPosition(floorRigidBody,floorPos); + plAddRigidBody(dynamicsWorld,floorRigidBody); + + //create dino rigidbody + dinoChildShape = plNewBoxShape(8.5,8.5,8.5); + dinoShape = plNewCompoundShape(); + childPos[0] = 0; + childPos[1] = 0; + childPos[2] = 0; + childOrn[0] = 0; + childOrn[1] = 0; + childOrn[2] = 0; + childOrn[3] = 1; + + plAddChildShape(dinoShape,dinoChildShape,childPos,childOrn); + + dinoPos[0] = -10; dinoPos[1] = 28; dinoPos[2] = 0; + dinoRigidBody = plCreateRigidBody(0,1.0,dinoShape); + plSetPosition(dinoRigidBody,dinoPos); + plSetEuler(0,0,3.15*0.20,dinoOrient); + plSetOrientation(dinoRigidBody,dinoOrient); + + plAddRigidBody(dynamicsWorld,dinoRigidBody); + + printf("BulletDino\n"); glutInit(&argc, argv); for (i=1; i +*/ + +#include "Bullet-C-Api.h" +#include "btBulletDynamicsCommon.h" + +/* + Create and Delete a Physics SDK +*/ + +struct btPhysicsSdk +{ + +// btDispatcher* m_dispatcher; +// btOverlappingPairCache* m_pairCache; +// btConstraintSolver* m_constraintSolver + + btVector3 m_worldAabbMin; + btVector3 m_worldAabbMax; + + + //todo: version, hardware/optimization settings etc? + btPhysicsSdk() + :m_worldAabbMin(-1000,-1000,-1000), + m_worldAabbMax(1000,1000,1000) + { + + } + + +}; + +plPhysicsSdkHandle plNewBulletSdk() +{ + return (plPhysicsSdkHandle)new btPhysicsSdk; +} + +void plDeletePhysicsSdk(plPhysicsSdkHandle physicsSdk) +{ + btPhysicsSdk* phys = reinterpret_cast(physicsSdk); + delete phys; +} + + +/* Dynamics World */ +plDynamicsWorldHandle plCreateDynamicsWorld(plPhysicsSdkHandle physicsSdkHandle) +{ + btPhysicsSdk* physicsSdk = reinterpret_cast(physicsSdkHandle); + btDispatcher* dispatcher = new btCollisionDispatcher(); + btOverlappingPairCache* pairCache = new btAxisSweep3(physicsSdk->m_worldAabbMin,physicsSdk->m_worldAabbMax); + btConstraintSolver* constraintSolver = new btSequentialImpulseConstraintSolver(); + + return (plDynamicsWorldHandle) new btDiscreteDynamicsWorld(dispatcher,pairCache,constraintSolver); +} +void plDeleteDynamicsWorld(plDynamicsWorldHandle world) +{ + btDynamicsWorld* dynamicsWorld = reinterpret_cast< btDynamicsWorld* >(world); + delete dynamicsWorld; +} + +void plStepSimulation(plDynamicsWorldHandle world, plReal timeStep) +{ + btDynamicsWorld* dynamicsWorld = reinterpret_cast< btDynamicsWorld* >(world); + assert(dynamicsWorld); + dynamicsWorld->stepSimulation(timeStep); +} + +void plAddRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object) +{ + btDynamicsWorld* dynamicsWorld = reinterpret_cast< btDynamicsWorld* >(world); + assert(dynamicsWorld); + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + assert(body); + + dynamicsWorld->addRigidBody(body); +} + +void plRemoveRigidBody(plDynamicsWorldHandle world, plRigidBodyHandle object) +{ + btDynamicsWorld* dynamicsWorld = reinterpret_cast< btDynamicsWorld* >(world); + assert(dynamicsWorld); + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + assert(body); + + dynamicsWorld->removeRigidBody(body); +} + +/* Rigid Body */ + +plRigidBodyHandle plCreateRigidBody( void* user_data, float mass, plCollisionShapeHandle cshape ) +{ + btTransform trans; + trans.setIdentity(); + btVector3 localInertia(0,0,0); + btCollisionShape* shape = reinterpret_cast( cshape); + assert(shape); + if (mass) + { + shape->calculateLocalInertia(mass,localInertia); + } + btRigidBody* body = new btRigidBody(mass, 0,shape,localInertia); + body->setWorldTransform(trans); + body->setUserPointer(user_data); + return (plRigidBodyHandle) body; +} + +void plDeleteRigidBody(plRigidBodyHandle cbody) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(cbody); + assert(body); + delete body; +} + + +/* Collision Shape definition */ + +plCollisionShapeHandle plNewSphereShape(plReal radius) +{ + return (plCollisionShapeHandle) new btSphereShape(radius); + +} + +plCollisionShapeHandle plNewBoxShape(plReal x, plReal y, plReal z) +{ + return (plCollisionShapeHandle) new btBoxShape(btVector3(x,y,z)); +} + +plCollisionShapeHandle plNewCapsuleShape(plReal radius, plReal height) +{ + //capsule is convex hull of 2 spheres, so use btMultiSphereShape + btVector3 inertiaHalfExtents(radius,height,radius); + const int numSpheres = 2; + btVector3 positions[numSpheres] = {btVector3(0,height,0),btVector3(0,-height,0)}; + btScalar radi[numSpheres] = {radius,radius}; + return (plCollisionShapeHandle) new btMultiSphereShape(inertiaHalfExtents,positions,radi,numSpheres); +} +plCollisionShapeHandle plNewConeShape(plReal radius, plReal height) +{ + return (plCollisionShapeHandle) new btConeShape(radius,height); +} + +plCollisionShapeHandle plNewCylinderShape(plReal radius, plReal height) +{ + return (plCollisionShapeHandle) new btCylinderShape(btVector3(radius,height,radius)); +} + +/* Convex Meshes */ +plCollisionShapeHandle plNewConvexHullShape() +{ + return (plCollisionShapeHandle) new btConvexHullShape(); +} + + +/* Concave static triangle meshes */ +plMeshInterfaceHandle plNewMeshInterface() +{ + return 0; +} + +plCollisionShapeHandle plNewCompoundShape() +{ + return (plCollisionShapeHandle) new btCompoundShape(); +} + +void plAddChildShape(plCollisionShapeHandle compoundShapeHandle,plCollisionShapeHandle childShapeHandle, plVector3 childPos,plQuaternion childOrn) +{ + btCollisionShape* colShape = reinterpret_cast(compoundShapeHandle); + btAssert(colShape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE); + btCompoundShape* compoundShape = reinterpret_cast(colShape); + btCollisionShape* childShape = reinterpret_cast(childShapeHandle); + btTransform localTrans; + localTrans.setIdentity(); + localTrans.setOrigin(btVector3(childPos[0],childPos[1],childPos[2])); + localTrans.setRotation(btQuaternion(childOrn[0],childOrn[1],childOrn[2],childOrn[3])); + compoundShape->addChildShape(localTrans,childShape); +} + +void plSetEuler(plReal yaw,plReal pitch,plReal roll, plQuaternion orient) +{ + btQuaternion orn; + orn.setEuler(yaw,pitch,roll); + orient[0] = orn.getX(); + orient[1] = orn.getY(); + orient[2] = orn.getZ(); + orient[3] = orn.getW(); + +} + + +// extern void plAddTriangle(plMeshInterfaceHandle meshHandle, plVector3 v0,plVector3 v1,plVector3 v2); +// extern plCollisionShapeHandle plNewStaticTriangleMeshShape(plMeshInterfaceHandle); + + +void plAddVertex(plCollisionShapeHandle cshape, plReal x,plReal y,plReal z) +{ + btCollisionShape* colShape = reinterpret_cast( cshape); + btAssert(colShape->getShapeType()==CONVEX_HULL_SHAPE_PROXYTYPE); + btConvexHullShape* convexHullShape = reinterpret_cast( cshape); + convexHullShape->addPoint(btPoint3(x,y,z)); + +} + +void plDeleteShape(plCollisionShapeHandle cshape) +{ + btCollisionShape* shape = reinterpret_cast( cshape); + assert(shape); + delete shape; +} +void plSetScaling(plCollisionShapeHandle cshape, plVector3 cscaling) +{ + btCollisionShape* shape = reinterpret_cast( cshape); + assert(shape); + btVector3 scaling(cscaling[0],cscaling[1],cscaling[2]); + shape->setLocalScaling(scaling); +} + + + +void plSetPosition(plRigidBodyHandle object, const plVector3 position) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + btAssert(body); + btVector3 pos(position[0],position[1],position[2]); + btTransform worldTrans = body->getWorldTransform(); + worldTrans.setOrigin(pos); + body->setWorldTransform(worldTrans); +} + +void plSetOrientation(plRigidBodyHandle object, const plQuaternion orientation) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + btAssert(body); + btQuaternion orn(orientation[0],orientation[1],orientation[2],orientation[3]); + btTransform worldTrans = body->getWorldTransform(); + worldTrans.setRotation(orn); + body->setWorldTransform(worldTrans); +} + +void plGetOpenGLMatrix(plRigidBodyHandle object, plReal* matrix) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + btAssert(body); + body->getWorldTransform().getOpenGLMatrix(matrix); + +} + +void plGetPosition(plRigidBodyHandle object,plVector3 position) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + btAssert(body); + const btVector3& pos = body->getWorldTransform().getOrigin(); + position[0] = pos.getX(); + position[1] = pos.getY(); + position[2] = pos.getZ(); +} + +void plGetOrientation(plRigidBodyHandle object,plQuaternion orientation) +{ + btRigidBody* body = reinterpret_cast< btRigidBody* >(object); + btAssert(body); + const btQuaternion& orn = body->getWorldTransform().getRotation(); + orientation[0] = orn.getX(); + orientation[1] = orn.getY(); + orientation[2] = orn.getZ(); + orientation[3] = orn.getW(); +} + + + +//plRigidBodyHandle plRayCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plVector3 hitpoint, plVector3 normal); + +// extern plRigidBodyHandle plObjectCast(plDynamicsWorldHandle world, const plVector3 rayStart, const plVector3 rayEnd, plVector3 hitpoint, plVector3 normal);