chipmunk 4.1.0-x86-mswin32 → 5.3.4.0-x86-mswin32

data/ext/chipmunk/rb_cpVect.c

@@ -19,6 +19,7 @@
  * SOFTWARE.
  */
  
+#include <stdlib.h>
 #include "chipmunk.h"
 
 #include "ruby.h"
@@ -173,12 +174,60 @@ rb_cpVectNormBang(VALUE self)
 	return self;
 }
 
+static VALUE
+rb_cpVectNormSafe(VALUE self)
+{
+  return VNEW(cpvnormalize_safe(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectNormSafeBang(VALUE self)
+{
+  cpVect *v = VGET(self);
+  *v = cpvnormalize_safe(*v);
+  return self;
+}
+
 static VALUE
 rb_cpVectPerp(VALUE self)
 {
 	return VNEW(cpvperp(*VGET(self)));
 }
 
+static VALUE
+rb_cpVectRperp(VALUE self)
+{
+  return VNEW(cpvrperp(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectLerp(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = NUM2DBL(d);
+  return VNEW(cpvlerp(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectLerpconst(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = NUM2DBL(d);
+  return VNEW(cpvlerpconst(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectSlerp(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = NUM2DBL(d);
+  return VNEW(cpvslerp(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectSlerpconst(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = NUM2DBL(d);
+  return VNEW(cpvslerpconst(*VGET(self), *VGET(v), df));
+}
+
 static VALUE
 rb_cpVectProject(VALUE self, VALUE v)
 {
@@ -197,6 +246,25 @@ rb_cpVectUnRotate(VALUE self, VALUE v)
 	return VNEW(cpvunrotate(*VGET(self), *VGET(v)));
 }
 
+static VALUE
+rb_cpVectDist(VALUE self, VALUE v)
+{
+  return rb_float_new(cpvdist(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectDistsq(VALUE self, VALUE v)
+{
+  return rb_float_new(cpvdistsq(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectClamp(VALUE self, VALUE len)
+{
+  return VNEW(cpvclamp(*VGET(self), NUM2DBL(len)));
+}
+
+
 static VALUE
 rb_cpVectNear(VALUE self, VALUE v, VALUE d)
 {
@@ -205,6 +273,18 @@ rb_cpVectNear(VALUE self, VALUE v, VALUE d)
 	return (cpvdot(delta, delta) <= dist*dist) ? Qtrue : Qfalse;
 }
 
+static VALUE
+rb_cpVectEql(VALUE self, VALUE other)
+{
+  return cpveql(*VGET(self), *VGET(other)) ? Qtrue : Qfalse;
+}
+
+// the usefulness of unary plus is debatable, but I'll include it for consistency.
+static VALUE rb_cpVectUnaryplus(VALUE  self) {
+  return self;
+}
+
+
 static VALUE
 rb_vec2(VALUE self, VALUE x, VALUE y)
 {
@@ -215,7 +295,7 @@ void
 Init_cpVect(void)
 {
 	c_cpVect = rb_define_class_under(m_Chipmunk, "Vec2", rb_cObject);
-	rb_define_singleton_method(c_cpBB, "for_angle", rb_cpVectForAngle, 1);
+	rb_define_singleton_method(c_cpVect, "for_angle", rb_cpVectForAngle, 1);
 	
 	rb_define_alloc_func(c_cpVect, rb_cpVectAlloc);
 	rb_define_method(c_cpVect, "initialize", rb_cpVectInitialize, 2);
@@ -230,6 +310,7 @@ Init_cpVect(void)
 	rb_define_method(c_cpVect, "to_angle", rb_cpVectToAngle, 0);
 	
 	rb_define_method(c_cpVect, "-@", rb_cpVectNegate, 0);
+  rb_define_method(c_cpVect, "+@", rb_cpVectUnaryplus, 0);
 	rb_define_method(c_cpVect, "+", rb_cpVectAdd, 1);
 	rb_define_method(c_cpVect, "-", rb_cpVectSub, 1);
 	rb_define_method(c_cpVect, "*", rb_cpVectSMult, 1);
@@ -240,11 +321,26 @@ Init_cpVect(void)
 	rb_define_method(c_cpVect, "lengthsq", rb_cpVectLengthsq, 0);
 	rb_define_method(c_cpVect, "normalize", rb_cpVectNorm, 0);
 	rb_define_method(c_cpVect, "normalize!", rb_cpVectNormBang, 0);
+  rb_define_method(c_cpVect, "normalize_safe", rb_cpVectNormSafe, 0);
+  rb_define_method(c_cpVect, "normalize_safe!", rb_cpVectNormSafeBang, 0); 
 	rb_define_method(c_cpVect, "perp", rb_cpVectPerp, 0);
+  rb_define_method(c_cpVect, "rperp", rb_cpVectRperp, 0);
+  rb_define_method(c_cpVect, "lerp", rb_cpVectLerp, 2);
+  rb_define_method(c_cpVect, "lerpconst", rb_cpVectLerpconst, 2);
+  rb_define_method(c_cpVect, "slerp", rb_cpVectSlerp, 2);
+  rb_define_method(c_cpVect, "slerpconst", rb_cpVectSlerpconst, 2);
+
 	rb_define_method(c_cpVect, "project", rb_cpVectProject, 1);
 	rb_define_method(c_cpVect, "rotate", rb_cpVectRotate, 1);
 	rb_define_method(c_cpVect, "unrotate", rb_cpVectUnRotate, 1);
-	rb_define_method(c_cpVect, "near?", rb_cpVectNear, 2);
+	rb_define_method(c_cpVect, "near?", rb_cpVectNear, 2);  
+  
+  rb_define_method(c_cpVect, "dist", rb_cpVectDist, 1);
+  rb_define_method(c_cpVect, "distsq", rb_cpVectDistsq, 1);
+  
+  rb_define_method(c_cpVect, "==", rb_cpVectEql, 1);
+  rb_define_method(c_cpVect, "clamp", rb_cpVectClamp, 1);
+  
 		
 	rb_define_global_function("vec2", rb_vec2, 2);
 }

data/lib/chipmunk.rb

@@ -13,3 +13,171 @@ begin
 rescue LoadError => e
     require "#{direc}/chipmunk.#{dlext}"
 end
+
+# Add some constants to CP here, so we don't need 
+# to do it in the C code.
+# Let's cheat a bit here.. :p
+
+module CP
+  VERSION    = '5.4.3' 
+  ZERO_VEC_2 = Vec2.new(0,0).freeze
+  ALL_ONES   = Vec2.new(1,1).freeze
+end  
+ 
+# Extra functionality added by Slembkce and Beoran.
+
+module CP
+  # Chipmunk Object
+  # Makes it easier to manage complex objects that reference many primitive Chipmunk objects such as bodies shapes and constraints.
+  # New composite objects simply need to include CP::Object and call #init_chipmunk_object(*objects) with the
+  # composite and primitive Chipmunk objects that make up itself.
+  module Object
+    # Returns the list of primitive Chipmunk objects (bodies, shapes and constraints)
+    # that this composite object references directly and indirectly.
+    def chipmunk_objects
+      if @chipmunk_objects
+        return @chipmunk_objects
+      else
+        raise "This CP::Object (#{self.class}) did not call #init_chipmunk_object."
+      end
+    end
+    
+    private
+    # Should be called during initialization of a CP::Object to set what primitive
+    # and composite Chipmunk objects this object references.
+    def init_chipmunk_object(*objs)
+      bad_objs = objs.reject{|obj| obj.is_a?(CP::Object)}
+      raise(ArgumentError, "The following objects: #{bad_objs.inspect} are not CP::Objects") unless bad_objs.empty?
+
+      @chipmunk_objects = objs.inject([]){|sum, obj| sum + obj.chipmunk_objects}.uniq
+    end
+  end
+  
+  class Body
+    include CP::Object
+
+    def chipmunk_objects
+      [self]
+    end
+    
+    def add_to_space(space)
+      space.add_body(self)
+    end
+    
+    def remove_from_space(space)
+      space.remove_body(self)
+    end
+    
+  end
+  
+  module Shape
+    include CP::Object
+    
+    def chipmunk_objects
+      [self]
+    end
+    
+    def add_to_space(space)
+      space.add_shape(self)
+    end
+    
+    def remove_from_space(space)
+      space.remove_shape(self)
+    end
+  end
+    
+  module Constraint
+    include CP::Object
+    
+    def chipmunk_objects
+      [self]
+    end
+    
+    def add_to_space(space)
+      space.add_constraint(self)
+    end
+    
+    def remove_from_space(space)
+      space.remove_constraint(self)
+    end
+  end
+  
+  class Space
+    def add_object(obj)
+      obj.chipmunk_objects.each{|elt| elt.add_to_space(self)}
+    end
+    
+    def add_objects(*objs)
+      objs.each{|obj| add_object(obj)}
+    end
+    
+    def remove_object(obj)
+      obj.chipmunk_objects.each{|elt| elt.remove_from_space(self)}
+    end
+    
+    def remove_objects(*objs)
+      objs.each{|obj| remove_object(obj)}
+    end
+    
+  end
+  
+  class Vec2
+    ZERO = Vec2.new(0,0).freeze
+  end
+  
+  # define the helpers here( easier than in the extension.
+  class SegmentQueryInfo
+    def hit_point(start, stop)
+      return start.lerp(stop, self.t)
+    end
+    
+    def hit_dist(start, stop)
+      return start.dist(stop) * self.t
+    end
+  end  
+  
+  
+end
+
+
+# Create derived static objects that know to add themselves as static.
+module CP
+  class StaticBody < Body
+    def initialize
+      super(Float::INFINITY, Float::INFINITY)
+    end
+    
+    def chipmunk_objects
+      # return [] instead of [self] so the static body will not be added.
+      []
+    end
+  end
+  
+  module StaticShape
+    include Shape
+    
+    class Circle < Shape::Circle
+      include StaticShape
+    end
+    
+    class Segment < Shape::Segment
+      include StaticShape
+    end
+    
+    class Poly < Shape::Poly
+      include StaticShape
+    end
+
+    def add_to_space(space)
+      space.add_static_shape(self)
+    end
+    
+    def remove_from_space(space)
+      space.remove_static_shape(self)
+    end
+  end
+end
+ 
+
+
+

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: chipmunk
 version: !ruby/object:Gem::Version 
-  version: 4.1.0
+  prerelease: false
+  segments: 
+  - 5
+  - 3
+  - 4
+  - 0
+  version: 5.3.4.0
 platform: x86-mswin32
 authors: 
 - Scott Lembcke, Beoran, John Mair (banisterfiend)
@@ -9,12 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-01 00:00:00 +13:00
+date: 2011-05-01 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
-description: ruby bindings for the chipmunk physics engine
-email: jrmair@gmail.com
+description: "Enhanced ruby bindings for the chipmunk 5.3.4 game physics engine. "
+email: beoran@rubyforge.com
 executables: []
 
 extensions: []
@@ -23,70 +29,52 @@ extra_rdoc_files: []
 
 files: 
 - Rakefile
+- README
+- LICENSE
 - lib/chipmunk.rb
 - ext/chipmunk/extconf.rb
-- ext/chipmunk/prime.h
-- ext/chipmunk/cpVect.h
-- ext/chipmunk/cpJoint.h
-- ext/chipmunk/cpBB.h
 - ext/chipmunk/rb_chipmunk.h
-- ext/chipmunk/cpBody.h
-- ext/chipmunk/chipmunk.h
-- ext/chipmunk/cpHashSet.h
-- ext/chipmunk/cpShape.h
-- ext/chipmunk/cpSpace.h
-- ext/chipmunk/cpPolyShape.h
-- ext/chipmunk/cpCollision.h
-- ext/chipmunk/cpArray.h
-- ext/chipmunk/cpSpaceHash.h
-- ext/chipmunk/cpArbiter.h
-- ext/chipmunk/cpBB.c
-- ext/chipmunk/cpCollision.c
+- ext/chipmunk/rb_chipmunk.c
 - ext/chipmunk/rb_cpBody.c
-- ext/chipmunk/cpArbiter.c
-- ext/chipmunk/cpJoint.c
-- ext/chipmunk/chipmunk.c
-- ext/chipmunk/cpHashSet.c
-- ext/chipmunk/cpSpace.c
-- ext/chipmunk/cpShape.c
-- ext/chipmunk/cpBody.c
 - ext/chipmunk/rb_cpBB.c
-- ext/chipmunk/cpArray.c
-- ext/chipmunk/rb_cpJoint.c
+- ext/chipmunk/rb_cpShape.c
+- ext/chipmunk/rb_cpConstraint.c
 - ext/chipmunk/rb_cpVect.c
+- ext/chipmunk/rb_cpArbiter.c
 - ext/chipmunk/rb_cpSpace.c
-- ext/chipmunk/cpSpaceHash.c
-- ext/chipmunk/cpVect.c
-- ext/chipmunk/rb_cpShape.c
-- ext/chipmunk/rb_chipmunk.c
-- ext/chipmunk/cpPolyShape.c
 - lib/1.8/chipmunk.so
 - lib/1.9/chipmunk.so
-has_rdoc: false
-homepage: http://code.google.com/p/chipmunk-physics/
+has_rdoc: true
+homepage: https://github.com/beoran/chipmunk
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.7
 signing_key: 
-specification_version: 2
-summary: ruby bindings for the chipmunk physics engine
+specification_version: 3
+summary: Enhanced ruby bindings for the chipmunk 5.3.4 game physics engine.
 test_files: []