Added some methods

liquidfun-c/Box2D/Collision/Shapes/c_b2PolygonShape.cpp

@@ -30,4 +30,8 @@ extern "C" {
         return static_cast<b2Shape*>(reinterpret_cast<b2PolygonShape*>(self));
     }
 
+    void b2PolygonShape_Set(b2PolygonShape* self, const b2Vec2* vertices, int32 count) {
+        self->Set(vertices, count);
+    }
+
 } // extern C

liquidfun-c/Box2D/Collision/Shapes/c_b2PolygonShape.h

@@ -12,7 +12,7 @@ extern "C" {
 	void b2PolygonShape_SetAsBox(b2PolygonShape* self, float32 hx, float32 hy);
 	void b2PolygonShape_SetAsBox_Oriented(b2PolygonShape* self, float32 hx, float32 hy, const b2Vec2& center, float32 angle);
 	b2Shape* b2PolygonShape_Upcast(b2PolygonShape* self);
-
+	void b2PolygonShape_Set(b2PolygonShape* self, const b2Vec2* vertices, int32 count);
 
 #ifdef __cplusplus
 } // extern C

liquidfun-c/Box2D/Dynamics/c_b2Body.cpp

@@ -39,5 +39,17 @@ extern "C" {
 		return self->GetLocalPoint(worldPoint);
 	}
 
+	void b2Body_SetTransform(b2Body* self, const b2Vec2& position, float32 angle) {
+		self->SetTransform(position, angle);
+	}
+
+	void b2Body_SetLinearVelocity(b2Body* self, const b2Vec2& v) {
+		self->SetLinearVelocity(v);
+	}
+
+	const b2Vec2& b2Body_GetLinearVelocity(const b2Body* self) {
+		return self->GetLinearVelocity();
+	}
+
 } // extern C
 

liquidfun-c/Box2D/Dynamics/c_b2Body.h

@@ -14,6 +14,9 @@ extern "C" {
 	void* b2Body_GetUserData(const b2Body* self);
 	b2World* b2Body_GetWorld(b2Body* self);
 	b2Vec2 b2Body_GetLocalPoint(const b2Body* self, const b2Vec2& worldPoint);
+    void b2Body_SetTransform(b2Body* self, const b2Vec2& position, float32 angle);
+    void b2Body_SetLinearVelocity(b2Body* self, const b2Vec2& v);
+    const b2Vec2& b2Body_GetLinearVelocity(const b2Body* self);
 
 #ifdef __cplusplus
 } // extern C

src/box2d/collision/shapes/polygon_shape.rs

@@ -12,6 +12,7 @@ extern {
     fn b2PolygonShape_SetAsBox(ptr: *mut B2PolygonShape, hx: Float32, hy: Float32);
     fn b2PolygonShape_SetAsBox_Oriented(ptr: *mut B2PolygonShape, hx: Float32, hy: Float32, center: &Vec2, angle: Float32);
     fn b2PolygonShape_Upcast(ptr: *mut B2PolygonShape) -> *mut B2Shape;
+    fn b2PolygonShape_Set(ptr: *mut B2PolygonShape, vertices: *const Vec2, count: Int32);
 }
 
 /// A convex polygon. It is assumed that the interior of the polygon is to
@@ -79,6 +80,15 @@ impl PolygonShape {
             b2PolygonShape_SetAsBox_Oriented(self.ptr, hx, hy, center, angle);
         }
     }
+
+    /// Build a convex polygon.
+    /// @param hx the half-width.
+    /// @param hy the half-height.
+    pub fn set(&mut self, vertices: &[Vec2]) {
+        unsafe {
+            b2PolygonShape_Set(self.ptr, vertices.as_ptr(), vertices.len() as Int32);
+        }
+    }
 }
 
 impl Drop for PolygonShape {

src/box2d/dynamics/body.rs

@@ -104,13 +104,16 @@ pub enum B2Body {}
 extern {
     fn b2Body_CreateFixture_FromShape(this: *mut B2Body, shape: *const B2Shape, density: Float32) -> *mut B2Fixture;
     fn b2Body_CreateFixture(this: *mut B2Body, def: *mut FixtureDef) -> *mut B2Fixture;
-    fn b2Body_GetAngle(this: *mut B2Body) -> Float32;
+    fn b2Body_GetAngle(this: *const B2Body) -> Float32;
     fn b2Body_GetFixtureList(this: *mut B2Body) -> *mut B2Fixture;
     fn b2Body_GetNext(this: *mut B2Body) -> *mut B2Body;
-    fn b2Body_GetPosition(this: *mut B2Body) -> &Vec2;
+    fn b2Body_GetPosition(this: *const B2Body) -> &Vec2;
     fn b2Body_GetUserData(this: *const B2Body) -> usize;
     fn b2Body_GetWorld(this: *const B2Body) -> *mut B2World;
     fn b2Body_GetLocalPoint(this: *const B2Body, worldPoint: &Vec2) -> Vec2;
+    fn b2Body_SetTransform(this: *mut B2Body, position: &Vec2, angle: Float32);
+    fn b2Body_SetLinearVelocity(this: *mut B2Body, v: &Vec2);
+    fn b2Body_GetLinearVelocity(this: *const B2Body) -> &Vec2;
 }
 
 /// A rigid body. These are created via b2World::CreateBody.
@@ -213,4 +216,21 @@ impl Body {
         }
     }
 
+    pub fn set_transform(&mut self, position: &Vec2, angle: f32) {
+        unsafe {
+            b2Body_SetTransform(self.ptr, position, angle)
+        }
+    }
+
+    pub fn set_linear_velocity(&mut self, v: &Vec2) {
+        unsafe {
+            b2Body_SetLinearVelocity(self.ptr, v)
+        }
+    }
+
+    pub fn get_linear_velocity(&self) -> &Vec2 {
+        unsafe {
+            b2Body_GetLinearVelocity(self.ptr)
+        }
+    }
 }

src/lib.rs

@@ -50,6 +50,8 @@
 //! }
 //! ```
 
+#![allow(renamed_and_removed_lints)]
+
 extern crate libc;
 #[macro_use]
 extern crate bitflags;

tests/hello-world.rs

@@ -73,8 +73,9 @@ fn hello_world() {
 		// Now print the position and angle of the body.
 		let position = body.get_position();
 		let angle = body.get_angle();
+		let vel = body.get_linear_velocity();
 
-		println!("{:?} angle: {:?}", position, angle);
+		println!("{:?} angle: {:?}, vel: {:?}", position, angle, vel);
 	}
 
 	// When the world destructor is called, all bodies and joints are freed. This can