diff --git a/game-lib.js b/game-lib.js
index 286f076..8dfbb75 100644
--- a/game-lib.js
+++ b/game-lib.js
@@ -1180,36 +1180,40 @@ GameLib.D3.Physics.World = function(
  * Physics Rigid Body Superset
  * @param id
  * @param name
- * @param position
- * @param rotation
- * @param scale
- * @param shapes GameLib.D3.Physics.Shape[]
  * @constructor
  */
 GameLib.D3.Physics.RigidBody = function(
     id,
-    name,
-    position,
-    rotation,
-    scale,
-    shapes
+    name
 ) {
-    this.position = new this.Vector3(0,0,0);
+    this.bodyObject = null;
 };
 
 /**
  * Physics Rigid Body Vehicle Superset
  * @constructor
  */
-GameLib.D3.Physics.RigidBody.Vehicle = function() {
-
+GameLib.D3.Physics.Vehicle = function(
+) {
+    this.vehicleObject = null;
 };
 
 /**
  * Physics Shape Superset
  * @constructor
  */
-GameLib.D3.Physics.Shape = function() {};
+GameLib.D3.Physics.Shape = function(
+    shapeObject,     // Physics engine specific
+    shapeType
+) {
+    this.shapeObject = shapeObject;
+    this.shapeType = shapeType;
+    this.scale = new GameLib.D3.Vector3(1, 1, 1);
+};
+
+GameLib.D3.Physics.Shape.TYPE_SPHERE    = 1;
+GameLib.D3.Physics.Shape.TYPE_BOX       = 2;
+GameLib.D3.Physics.Shape.TYPE_TRIMESH   = 3;
 
 /**
  * Physics Convex Hull Shape Superset
@@ -1708,11 +1712,11 @@ GameLib.D3.prototype.fixWindingOrder = function(faces, orientationEdge) {
          */
         if (
             (triangleEdge.triangle.v0 == triangleEdge.edge.x &&
-             triangleEdge.triangle.v1 == triangleEdge.edge.y) ||
+            triangleEdge.triangle.v1 == triangleEdge.edge.y) ||
             (triangleEdge.triangle.v1 == triangleEdge.edge.x &&
-             triangleEdge.triangle.v2 == triangleEdge.edge.y) ||
+            triangleEdge.triangle.v2 == triangleEdge.edge.y) ||
             (triangleEdge.triangle.v2 == triangleEdge.edge.x &&
-             triangleEdge.triangle.v0 == triangleEdge.edge.y)
+            triangleEdge.triangle.v0 == triangleEdge.edge.y)
         ) {
             var backupV = triangleEdge.triangle.v1;
             triangleEdge.triangle.v1 = triangleEdge.triangle.v2;
@@ -2400,7 +2404,7 @@ GameLib.D3.prototype.loadScene = function(gameLibScene, onLoaded, computeNormals
     for (var m = 0; m < gameLibScene.meshes.length; m++) {
 
         var mesh = gameLibScene.meshes[m];
-        
+
         console.log("loading mesh " + mesh.name);
 
         var geometry = new this.THREE.Geometry();
@@ -2544,7 +2548,7 @@ GameLib.D3.prototype.loadScene = function(gameLibScene, onLoaded, computeNormals
         var result = this.Q.all(threeMaterialLoaders).then(
             function(gl3d, mesh, geometry) {
                 return function(materials) {
-                    
+
                     console.log("loaded all materials maps (" + materials.length + ")");
 
                     /**
@@ -2647,19 +2651,173 @@ GameLib.D3.prototype.loadScene = function(gameLibScene, onLoaded, computeNormals
 // Physics
 // ---------------
 
-GameLib.D3.Physics.World.prototype.AddRigidBody = function(
-    body
+GameLib.D3.Physics.Shape.prototype.Update = function(
+    physicsWorld
+) {
+    if(physicsWorld.engineType === GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        if(this.shapeType === GameLib.D3.Physics.Shape.TYPE_TRIMESH) {
+            this.shapeObject.setScale(new CANNON.Vec3(this.scale.x, this.scale.y, this.scale.z));
+            this.shapeObject.scale.x = this.scale.x;
+            this.shapeObject.scale.y = this.scale.y;
+            this.shapeObject.scale.z = this.scale.z;
+            this.shapeObject.updateAABB();
+            this.shapeObject.updateNormals();
+            this.shapeObject.updateEdges();
+            this.shapeObject.updateBoundingSphereRadius();
+            this.shapeObject.updateTree();
+        }
+    }
+};
+
+GameLib.D3.Physics.World.prototype.AddShape = function(
+    shape, // d3.physics.shape
+    rigidBody
+) {
+    shape.shape = shape;
+
+    if(this.engineType === GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        rigidBody.bodyObject.addShape(shape.shapeObject);
+    }
+};
+
+GameLib.D3.Physics.World.prototype.CreateRigidVehicle = function(
+    chassisBody // Physics.RigidBody
+) {
+    var rigidVehicle = new GameLib.D3.Physics.Vehicle();
+
+    if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        var vehicle = new CANNON.RigidVehicle({
+            chassisBody: chassisBody.bodyObject
+        });
+        rigidVehicle.vehicleObject = vehicle;
+        return rigidVehicle;
+    }
+};
+
+GameLib.D3.Physics.World.prototype.AddWheel = function(
+    vehicle,
+    rigidBody,
+    position,
+    axis,
+    direction
 ) {
     if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
-        this.worldObject.addBody(body);
+        vehicle.vehicleObject.addWheel({
+            body: rigidBody.bodyObject,
+            position: new CANNON.Vec3(position.x, position.y, position.z),
+            axis: new CANNON.Vec3(axis.x, axis.y, axis.z),
+            direction: new CANNON.Vec3(direction.x, direction.y, direction.z)
+        });
+    }
+};
+
+GameLib.D3.Physics.Vehicle.prototype.GetWheelInfo = function(
+
+) {
+    return this.vehicleObject.wheelBodies;
+};
+
+GameLib.D3.Physics.World.prototype.CreateRigidBody = function(
+    mass,
+    friction,
+    position,
+    quaternion,
+    velocity,
+    angularVelocity,
+    linearDamping,
+    angularDamping,
+    allowSleep,
+    sleepSpeedLimit,
+    sleepTimeLimit,
+    collisionFilterGroup,
+    collisionFilterMask,
+    fixedRotation,
+    shape
+) {
+
+    var rigidBody = new GameLib.D3.Physics.RigidBody(0, "null");
+
+    position = position || new GameLib.D3.Vector3();
+    velocity = velocity || new GameLib.D3.Vector3();
+    angularVelocity = angularVelocity || new GameLib.D3.Vector3();
+    quaternion = quaternion || new GameLib.D3.Vector4(0, 0, 0, 1);
+    mass = typeof mass == "undefined" ? 0 : mass;
+    friction = typeof friction == "undefined" ? 5 : friction;
+    linearDamping = typeof linearDamping == "undefined" ? 0.01 : linearDamping;
+    angularDamping = typeof angularDamping == "undefined" ? 0.01 : angularDamping;
+    allowSleep = typeof allowSleep == "undefined" ? true : allowSleep;
+    sleepSpeedLimit = typeof sleepSpeedLimit == "undefined" ? 0.1 : sleepSpeedLimit;
+    sleepTimeLimit = typeof sleepTimeLimit == "undefined" ? 1.0 : sleepTimeLimit;
+    collisionFilterGroup = typeof collisionFilterGroup == "undefined" ? 1 : collisionFilterGroup;
+    collisionFilterMask = typeof collisionFilterMask == "undefined" ? 1 : collisionFilterMask;
+    fixedRotation = typeof fixedRotation == "undefined" ? false : fixedRotation;
+    shape = typeof shape == "undefined" ? null : shape;
+
+
+    // Create the bodyObject
+    if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        rigidBody.bodyObject = new CANNON.Body(
+            {
+                mass: mass,
+                friction: friction,
+                position: new CANNON.Vec3(position.x, position.y, position.z),
+                velocity: new CANNON.Vec3(velocity.x, velocity.y, velocity.z),
+                quaternion: new CANNON.Quaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w),
+                angularVelocity: new CANNON.Vec3(angularVelocity.x, angularVelocity.y, angularVelocity.z),
+                linearDamping: linearDamping,
+                angularDamping: angularDamping,
+                allowSleep: allowSleep,
+                sleepSpeedLimit: sleepSpeedLimit,
+                sleepTimeLimit: sleepTimeLimit,
+                collisionFilterGroup: collisionFilterGroup,
+                collisionFilterMask: collisionFilterMask,
+                fixedRotation: fixedRotation,
+                shape: shape
+            }
+        );
+
+        return rigidBody;
+    }
+};
+
+GameLib.D3.Physics.World.prototype.CreateTriMeshShape = function(
+    vertices,   // flat list of floats
+    indices     // float list of floats
+) {
+    if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        return new GameLib.D3.Physics.Shape(new CANNON.Trimesh(vertices, indices), GameLib.D3.Physics.Shape.TYPE_TRIMESH);
+    }
+};
+
+GameLib.D3.Physics.World.prototype.CreateSphereShape = function (
+    radius
+) {
+    if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        return new GameLib.D3.Physics.Shape(new CANNON.Sphere(radius), GameLib.D3.Physics.Shape.TYPE_SPHERE);
+    }
+};
+
+GameLib.D3.Physics.World.prototype.CreateBoxShape = function(
+    halfExtensions // vec3
+) {
+    if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        return new GameLib.D3.Physics.Shape(new CANNON.Box(new CANNON.Vec3(halfExtensions.x, halfExtensions.y, halfExtensions.z)), GameLib.D3.Physics.Shape.TYPE_BOX);
+    }
+};
+
+GameLib.D3.Physics.World.prototype.AddRigidBody = function(
+    rigidBody   // Physics.RigidBody
+) {
+    if(this.engineType === GameLib.D3.Physics.Engine.TYPE_CANNON) {
+        this.worldObject.addBody(rigidBody.bodyObject);
     }
 };
 
 GameLib.D3.Physics.World.prototype.AddVehicle = function(
-    vehicle
+    vehicle // note: this is the cannon vehicle...
 ) {
     if(this.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
-        vehicle.addToWorld(this.worldObject);
+        vehicle.vehicleObject.addToWorld(this.worldObject);
     }
 };
 
@@ -2672,7 +2830,7 @@ GameLib.D3.Physics.World.prototype.Step = function(
 };
 
 GameLib.D3.Physics.World.prototype.GetIndexedVertices = function(
-   triangleMeshShape
+    triangleMeshShape
 ) {
 
     if(this.engine.engineType == GameLib.D3.Physics.Engine.TYPE_CANNON) {
@@ -2951,8 +3109,10 @@ GameLib.D3.Game.prototype.ProcessPhysics = function (
                     var body = pair.physicsBody;
 
                     if(mesh) {
-                        mesh.position.copy(body.position);
-                        mesh.quaternion.copy(body.quaternion);
+                        if(physicsWorld.engineType === GameLib.D3.Physics.Engine.TYPE_CANNON) {
+                            mesh.position.copy(body.bodyObject.position);
+                            mesh.quaternion.copy(body.bodyObject.quaternion);
+                        }
                     }
                 }
             }