bouncing sphere

Author: fedor

examples/sphere.rs

@@ -5,7 +5,6 @@ use cgmath::{Vector3, Vector4};
 
 use bulletrs::*;
 
-
 fn main() {
     let configuration = CollisionConfiguration::new_default();
 
@@ -18,20 +17,32 @@ fn main() {
 
     dynamics_world.set_gravity(Vector3::new(0.0, -10.0, 0.0));
 
+    let ground_shape = Shape::new_plane(Vector3::new(0.0, 1.0, 0.0), -2.0);
+    let ground_rigid_body = RigidBody::new(
+        0.0,
+        Vector3::new(0.0, 0.0, 0.0),
+        ground_shape,
+        Vector3::new(0.0, 0.0, 0.0),
+        Vector4::new(0.0, 0.0, 0.0, 1.0),
+    );
+    ground_rigid_body.set_restitution(0.95);
+
+    dynamics_world.add_rigid_body(&ground_rigid_body);
+
     let fall_shape = Shape::new_sphere(2.0);
-    let mass = 1.0;
-    let fall_inertia = fall_shape.calculate_local_inertia(mass);
+    let mass = 0.1;
     let fall_rigid_body = RigidBody::new(
         mass,
+        fall_shape.calculate_local_inertia(mass),
         fall_shape,
-        fall_inertia,
         Vector3::new(0.0, 5.0, 0.0),
         Vector4::new(0.0, 0.0, 0.0, 1.0),
     );
     dynamics_world.add_rigid_body(&fall_rigid_body);
+    fall_rigid_body.set_restitution(0.9);
 
     for _ in 0 .. 100 {
-        dynamics_world.step(0.01, 0, 0.01);
+        dynamics_world.step(0.1, 0, 0.0);
         println!("{:?}", fall_rigid_body.get_world_transform());
     }
 }

src/collision/collision_shapes/mod.rs

@@ -1,17 +1,30 @@
 use sys;
 use std::mem;
-
+use bullet_vector3::BulletVector3;
 use mint::Vector3;
 
 pub enum Shape {
     Sphere(sys::btSphereShape),
+    Plane(sys::btStaticPlaneShape),
 }
 
 impl Shape {
     pub fn new_sphere(radius: f64) -> Shape {
         Shape::Sphere(unsafe { sys::btSphereShape::new(radius) })
     }
 
+    pub fn new_plane<T : Into<Vector3<f64>>>(normal : T, plane_const: f64) -> Shape {
+        let up: BulletVector3 = normal.into().into();
+        Shape::Plane(unsafe { sys::btStaticPlaneShape::new(up.0.as_ptr() as *const _, plane_const) })
+    }
+
+    pub fn as_ptr(&self) -> *mut sys::btCollisionShape {
+        match self {
+            &Shape::Sphere(ref sphere) => sphere as *const _ as *mut _,
+            &Shape::Plane(ref plane) => plane as *const _ as *mut _,
+        }
+    }
+
     pub fn calculate_local_inertia(&self, mass: f64) -> Vector3<f64> {
         let mut inertia: [f64; 4] = unsafe { mem::uninitialized() };
         match self {
@@ -24,6 +37,16 @@ impl Shape {
                     );
                 }
                 Vector3::from_slice(&inertia[0..3])
+            },
+            &Shape::Plane(ref sphere) => {
+                unsafe {
+                    sys::btStaticPlaneShape_calculateLocalInertia(
+                        sphere as *const _ as *mut _,
+                        mass,
+                        inertia.as_mut_ptr() as *mut _,
+                    );
+                }
+                Vector3::from_slice(&inertia[0..3])
             }
         }
     }

src/dynamics/rigid_body.rs

@@ -14,13 +14,13 @@ pub struct RigidBody {
 impl RigidBody {
     pub fn new<T1: Into<Vector3<f64>>, T2: Into<Vector3<f64>>, T3: Into<Vector4<f64>>>(
         mass: f64,
-        shape: Shape,
         inertia: T1,
+        shape: Shape,
         translation: T2,
         orientation: T3,
     ) -> RigidBody {
         let mut inertia: BulletVector3 = inertia.into().into();
-        let mut shape_box = Box::new(shape);
+        let shape_box = Box::new(shape);
         let translation: BulletVector3 = translation.into().into();
         let orientation: [f64; 4] = orientation.into().into();
         let transform = unsafe {
@@ -37,7 +37,7 @@ impl RigidBody {
             sys::btRigidBody_btRigidBodyConstructionInfo::new(
                 mass,
                 &mut *motion_state_box as *mut _ as *mut _,
-                &mut *shape_box as *mut _ as *mut _,
+                shape_box.as_ptr(),
                 inertia.0.as_mut_ptr() as *mut _,
             )
         });
@@ -52,10 +52,13 @@ impl RigidBody {
         }
     }
 
-    pub fn as_ptr(&self) -> *mut sys::btRigidBody {
+    pub(crate) unsafe fn as_ptr(&self) -> *mut sys::btRigidBody {
         &*self.rigid_body as *const _ as *mut _
     }
 
+    pub fn set_restitution(&self, restitution : f64) {
+        unsafe { sys::btCollisionObject_setRestitution(self.as_ptr() as *mut _, restitution); }
+    }
 
     pub fn get_world_transform(&self) -> Vector3<f64> {
         unsafe {