Added rigid bodys

core/Rigidbody.cpp

@@ -0,0 +1,56 @@
+#include "Rigidbody.h"
+#include "World.h"
+
+Rigidbody::Rigidbody() {}
+
+Rigidbody *Rigidbody::Create() {
+  return new Rigidbody;
+}
+
+Rigidbody *Rigidbody::Duplicate() {
+  Rigidbody *rigidbody = static_cast<Rigidbody*>(Spatial::Duplicate());
+
+  rigidbody->collisionShape = collisionShape;
+  rigidbody->btBody = btBody;
+  rigidbody->mass = mass;
+  return rigidbody;
+}
+
+Rigidbody *Rigidbody::Instance() {
+  Rigidbody *rigidbody = static_cast<Rigidbody*>(Node::Instance());
+
+  rigidbody->collisionShape = new btSphereShape(1.0f);
+  rigidbody->btBody = new btRigidBody(rigidbody->mass, new RigidbodyMotionState(rigidbody), rigidbody->collisionShape);
+  assert(rigidbody);
+
+  World *world = World::GetWorld();
+  world->AddRigidbody(rigidbody);
+
+  return rigidbody;
+}
+
+RigidbodyMotionState::RigidbodyMotionState(Rigidbody *rigidbody) {
+  this->rigidbody = rigidbody;
+}
+
+void RigidbodyMotionState::getWorldTransform(btTransform &worldTrans) const {
+  worldTrans.setOrigin(btVector3(
+			 rigidbody->transform.position.x,
+			 rigidbody->transform.position.y,
+			 rigidbody->transform.position.z));
+  btQuaternion quat;
+  quat.setEuler(rigidbody->transform.rotation.z,
+		rigidbody->transform.rotation.y,
+		rigidbody->transform.rotation.x);
+  worldTrans.setRotation(quat);
+}
+
+void RigidbodyMotionState::setWorldTransform(const btTransform &worldTrans) {
+  rigidbody->transform.position = Vector3(worldTrans.getOrigin().getX(),
+					  worldTrans.getOrigin().getY(),
+					  worldTrans.getOrigin().getZ());
+  
+  worldTrans.getRotation().getEulerZYX(rigidbody->transform.rotation.z,
+				       rigidbody->transform.rotation.y,
+				       rigidbody->transform.rotation.x);
+}

core/Rigidbody.h

@@ -0,0 +1,31 @@
+#ifndef RIGIDBODY_H
+#define RIGIDBODY_H
+
+#include <btBulletDynamicsCommon.h>
+
+#include "types.h"
+#include "Spatial.h"
+
+class Rigidbody : public Spatial {
+public:
+  Rigidbody();
+  virtual Rigidbody *Create();
+  virtual Rigidbody *Duplicate();
+  virtual Rigidbody *Instance();
+  cfloat mass = 1.0f;
+private:
+  btRigidBody *btBody;
+  btCollisionShape *collisionShape;
+  friend class World;
+};
+
+class RigidbodyMotionState : public btMotionState {
+public:
+  RigidbodyMotionState(Rigidbody *rigidbody);
+  virtual void getWorldTransform(btTransform &worldTrans) const;
+  virtual void setWorldTransform(const btTransform &worldTrans);
+private:
+  Rigidbody *rigidbody;
+};
+
+#endif /* RIGIDBODY_H */

core/World.cpp

@@ -0,0 +1,37 @@
+#include "World.h"
+
+World* World::GetWorld() {
+  if (!world) {
+    world = new World();
+  }
+
+  return world;
+}
+
+void World::AddRigidbody(Rigidbody *rigidbody) {
+  btWorld->addRigidBody(rigidbody->btBody);
+}
+
+void World::Step(cfloat delta) {
+  btWorld->stepSimulation(delta);
+}
+
+World* World::world { new World() };
+
+World::World() {
+  // Some Java-ass code to follow
+  collisionConfiguration = new btDefaultCollisionConfiguration();
+  dispatcher = new btCollisionDispatcher(collisionConfiguration);
+  overlappingPairCache = new btDbvtBroadphase();
+  solver = new btSequentialImpulseConstraintSolver();
+  btWorld = new btDiscreteDynamicsWorld(dispatcher, overlappingPairCache, solver, collisionConfiguration);
+  btWorld->setGravity(btVector3(0, -10, 0));
+}
+
+World::~World() {
+  delete btWorld;
+  delete solver;
+  delete overlappingPairCache;
+  delete dispatcher;
+  delete collisionConfiguration;
+}

core/World.h

@@ -0,0 +1,24 @@
+#ifndef WORLD_H
+#define WORLD_H
+
+#include <btBulletDynamicsCommon.h>
+
+#include "Rigidbody.h"
+
+class World {
+public:
+  static World* GetWorld();
+  void AddRigidbody(Rigidbody *rigidbody);
+  void Step(cfloat delta);
+private:
+  static World* world;
+  btDiscreteDynamicsWorld *btWorld;
+  btDefaultCollisionConfiguration *collisionConfiguration;
+  btCollisionDispatcher *dispatcher;
+  btBroadphaseInterface *overlappingPairCache;
+  btSequentialImpulseConstraintSolver *solver;
+  World();
+  ~World();
+};
+
+#endif /* WORLD_H */

core/couch.cpp

@@ -23,6 +23,10 @@
 #include "Light.h"
 #include "Skybox.h"
 
+#include "Rigidbody.h"
+#include "World.h"
+
+
 #include "Scripting/Lua.h"
 
 // Thirdparty Includes
@@ -37,22 +41,22 @@ const int height = 600;
 Node *root;
 
 void render(Node *curr, Shader *shader, Matrix model) {
+  if (curr->IsTransformable()) {
+    Spatial *spatial = dynamic_cast<Spatial*>(curr);
+    model = glm::rotate(model, spatial->transform.rotation.x, Vector3(1.0f, 0.0f, 0.0f));
+    model = glm::rotate(model, spatial->transform.rotation.y, Vector3(0.0f, 1.0f, 0.0f));
+    model = glm::rotate(model, spatial->transform.rotation.z, Vector3(0.0f, 0.0f, 1.0f));
+    model = glm::translate(model, spatial->transform.position);
+    model = glm::scale(model, spatial->transform.scale);
+    shader->UpdateModel(model);
+    shader->UpdateNormal(glm::mat3(glm::transpose(glm::inverse(model))));
+  }
   if (curr->IsDrawable()) {
-    if (curr->IsTransformable()) {
-      Spatial *spatial = dynamic_cast<Spatial*>(curr);
-      model = glm::rotate(model, spatial->transform.rotation.x, Vector3(1.0f, 0.0f, 0.0f));
-      model = glm::rotate(model, spatial->transform.rotation.y, Vector3(0.0f, 1.0f, 0.0f));
-      model = glm::rotate(model, spatial->transform.rotation.z, Vector3(0.0f, 0.0f, 1.0f));
-      model = glm::translate(model, spatial->transform.position);
-      model = glm::scale(model, spatial->transform.scale);
-      shader->UpdateModel(model);
-      shader->UpdateNormal(glm::mat3(glm::transpose(glm::inverse(model))));
-    }
     Mesh *mesh = dynamic_cast<Mesh*>(curr);
     mesh->Draw(shader);
   }
   for (Node *child : curr->children) {
-    render(child, shader, model);   
+    render(child, shader, model);
   }
 }
 
@@ -89,6 +93,8 @@ int main() {
 
   Camera defaultCamera;
 
+  World *world = World::GetWorld();
+
   Screen screen;
   ScreenShader *screenShader = new ScreenShader();
 
@@ -106,6 +112,10 @@ int main() {
   double delta = 0.0;
 
   while(!glfwWindowShouldClose(window)) {
+
+    // Physics update()
+    world->Step(delta);
+    
     // Start rendering to texture;
     screen.Enable();