void Object::Load(){ if (!isStatic){ btTransform trans; trans.setFromOpenGLMatrix(glm::value_ptr(position)); btDefaultMotionState* motState = new btDefaultMotionState(trans); btScalar mass = 1; btVector3 fallInertia(0, 0, 0); shape->calculateLocalInertia(mass, fallInertia); btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, motState, shape, fallInertia); rigidBody = new btRigidBody(fallRigidBodyCI); rigidBody->setFriction(1.35f); if (isGhost){ rigidBody->setCollisionFlags(rigidBody->getCollisionFlags() | rigidBody->CF_NO_CONTACT_RESPONSE); } world->addRigidBody(rigidBody); } else{ btTransform trans; trans.setFromOpenGLMatrix(glm::value_ptr(position)); btDefaultMotionState* motState = new btDefaultMotionState(trans); btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, motState, shape, btVector3(0, 0, 0)); rigidBody = new btRigidBody(groundRigidBodyCI); rigidBody->setFriction(1.35f); if (isGhost){ rigidBody->setCollisionFlags(rigidBody->getCollisionFlags() | rigidBody->CF_NO_CONTACT_RESPONSE); } world->addRigidBody(rigidBody); } shader = LoadShaders(vertexName, "geometry-shader[basic].txt", fragmentName); cameraUniform = shader->uniform("camera"); posNormUniform = shader->uniform("normalPos"); texUniform = shader->uniform("tex"); disUniform = shader->uniform("dis"); normUniform = shader->uniform("norm"); posUniform = shader->uniform("position"); normal = LoadTexture(LoadBmp(normalName)); texture = LoadTexture(LoadBmp(textureName)); displacement = LoadTexture(LoadBmp(displacementName)); glGenVertexArrays(1, &vao); glBindVertexArray(vao); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex)*vertices.size(), &vertices.front(), GL_STATIC_DRAW); glEnableVertexAttribArray(shader->attrib("vert_VS_in")); glVertexAttribPointer(shader->attrib("vert_VS_in"), 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), NULL); glEnableVertexAttribArray(shader->attrib("frag_VS_in")); glVertexAttribPointer(shader->attrib("frag_VS_in"), 2, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (const GLvoid*)(3 * sizeof(GLfloat))); glEnableVertexAttribArray(shader->attrib("normal_VS_in")); glVertexAttribPointer(shader->attrib("normal_VS_in"), 3, GL_FLOAT, GL_FALSE, 8 * sizeof(GLfloat), (const GLvoid*)(5 * sizeof(GLfloat))); glGenBuffers(1, &ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(Index)*indices.size(), &indices.front(), GL_STATIC_DRAW); glBindVertexArray(0); }
int main( int argc, char* args[] ) { //SDL //Initialize all SDL subsystems if( SDL_Init( SDL_INIT_EVERYTHING ) == -1 ) { return 1; } //Set up the screen screen = SDL_SetVideoMode( SCREEN_WIDTH, SCREEN_HEIGHT, SCREEN_BPP, SDL_SWSURFACE ); //If there was an error in setting up the screen if( screen == NULL ) { return 1; } //Set the window caption SDL_WM_SetCaption( "Hello World", NULL ); //Load the images message = load_image( "data/hello.bmp" ); background = load_image( "data/background.bmp" ); sphere = load_image("data/Circle.bmp"); //SDL //Physics //=> World Creation // Specify the dynamic AABB tree broadphase algorithm to be used to work out what objects // to test collision for. btBroadphaseInterface* broadphase = new btDbvtBroadphase(); // The collision configuration allows you to fine tune the algorithms used // for the full (not broadphase) collision detection. Here be dragons! btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration); // We also need a "solver". This is what causes the objects to interact // properly, taking into account gravity, game logic supplied forces, // collisions, and hinge constraints. It does a good job as long as you // don't push it to extremes, and is one of the bottlenecks in any high // performance simulation. There are parallel versions available for some // threading models. btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver; // Now, we can finally instantiate the dynamics world. btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration); // Set the gravity. We have chosen the Y axis to be "up". dynamicsWorld->setGravity(btVector3(0, -10, 0)); //=> World Creation //=> Ground Creation // In this demonstration, we will place a ground plane running through // the origin. btCollisionShape* groundShape = new btStaticPlaneShape( btVector3(0, 1, 0), 1); // Instantiate the ground. Its orientation is the identity, Bullet quaternions // are specified in x,y,z,w form. The position is 1 metre below the ground, // which compensates the 1m offset we had to put into the shape itself. btDefaultMotionState* groundMotionState = new btDefaultMotionState( btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, -1, 0))); // The first and last parameters of the following constructor are the mass and // inertia of the ground. Since the ground is static, we represent this by // filling these values with zeros. Bullet considers passing a mass of zero // equivalent to making a body with infinite mass - it is immovable. btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0, groundMotionState, groundShape, btVector3(0, 0, 0)); btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI); //=> Ground Creation //=> Sphere Creation // The shape that we will let fall from the sky is a sphere with a radius // of 1 metre. btCollisionShape* fallShape = new btSphereShape(1); // Adding the falling sphere is very similar. We will place it 50m above the // ground. btDefaultMotionState* fallMotionState = new btDefaultMotionState(btTransform(btQuaternion(0, 0, 0, 1), btVector3(0, 50, 0))); // Since it's dynamic we will give it a mass of 1kg. I can't remember how to // calculate the inertia of a sphere, but that doesn't matter because Bullet // provides a utility function. btScalar mass = 1; btVector3 fallInertia(0, 0, 0); fallShape->calculateLocalInertia(mass, fallInertia); // Construct the rigid body just like before, and add it to the world. btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, fallMotionState, fallShape, fallInertia); btRigidBody* fallRigidBody = new btRigidBody(fallRigidBodyCI); //=> Sphere Creation // Add the ground and sphere to the world. dynamicsWorld->addRigidBody(fallRigidBody); dynamicsWorld->addRigidBody(groundRigidBody); //Physics bool go = true; while (go){ SDL_Event incomingEvent; while (SDL_PollEvent(&incomingEvent)) { switch (incomingEvent.type) { case SDL_QUIT: go = false; break; } } //Logic //Physics dynamicsWorld->stepSimulation(1 / 60.f, 10); btTransform trans; fallRigidBody->getMotionState()->getWorldTransform(trans); //std::cout << "sphere height: " << trans.getOrigin().getY() << std::endl; //Physics //SDL //Clear screen SDL_FillRect(screen, NULL, 0x000000); //Apply the background to the screen apply_surface(0, 0, background, screen); apply_surface(320, 0, background, screen); apply_surface(0, 240, background, screen); apply_surface(320, 240, background, screen); //Apply the message to the screen //apply_surface(180, 140, message, screen); apply_surface(50, -(trans.getOrigin().getY()), sphere, screen); //apply_surface(50, 50, sphere, screen); std::cout << "X: " << trans.getOrigin().getX() << " Y: " << trans.getOrigin().getY() << std::endl; //SDL //Update SDL_Flip(screen); //Wait 2 seconds SDL_Delay( 50 ); } //Free the surfaces SDL_FreeSurface( message ); SDL_FreeSurface( background ); //Quit SDL SDL_Quit(); return 0; }
int main(int argc, char *argv[]) { // Build the broadphase btBroadphaseInterface* broadphase = new btDbvtBroadphase(); btDefaultCollisionConfiguration* collisionConfiguration = new btDefaultCollisionConfiguration(); btCollisionDispatcher* dispatcher = new btCollisionDispatcher(collisionConfiguration); // The actual physics solver btSequentialImpulseConstraintSolver* solver = new btSequentialImpulseConstraintSolver; btDiscreteDynamicsWorld* dynamicsWorld = new btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration); dynamicsWorld->setGravity(btVector3(0, -10, 0)); btCollisionShape* groundShape = new btStaticPlaneShape(btVector3(0,1,0),1); btCollisionShape* fallShape = new btSphereShape(1); btDefaultMotionState* groundMotionState = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1), btVector3(0,-1,0))); btRigidBody::btRigidBodyConstructionInfo groundRigidBodyCI(0,groundMotionState,groundShape,btVector3(0,0,0)); btRigidBody* groundRigidBody = new btRigidBody(groundRigidBodyCI); dynamicsWorld->addRigidBody(groundRigidBody); btDefaultMotionState* fallMotionState = new btDefaultMotionState(btTransform(btQuaternion(0,0,0,1), btVector3(0,50,0))); btScalar mass = 1; btVector3 fallInertia(0,0,0); fallShape->calculateLocalInertia(mass, fallInertia); btRigidBody::btRigidBodyConstructionInfo fallRigidBodyCI(mass, fallMotionState, fallShape, fallInertia); btRigidBody* fallRigidBody = new btRigidBody(fallRigidBodyCI); dynamicsWorld->addRigidBody(fallRigidBody); for (int i=0; i<300; i++) { dynamicsWorld->stepSimulation( 1.f/60.f, 10); btTransform trans; fallRigidBody->getMotionState()->getWorldTransform(trans); std::cout << "sphere height: " << trans.getOrigin().getY() << std::endl; } dynamicsWorld->removeRigidBody(fallRigidBody); delete fallRigidBody->getMotionState(); delete fallRigidBody; dynamicsWorld->removeRigidBody(groundRigidBody); delete groundRigidBody->getMotionState(); delete groundRigidBody; delete fallShape; delete groundShape; // Clean up delete dynamicsWorld; delete solver; delete dispatcher; delete collisionConfiguration; delete broadphase; return 0; }