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

data/{ext/chipmunk/cpCollision.h → LICENSE}

@@ -1,4 +1,6 @@
-/* Copyright (c) 2007 Scott Lembcke
+/* Copyright (c) 2007 Scott Lembcke  
+ * Copyright (c) 2010-2011 John Mair
+ * Copyright (c) 2010-2011 Beoran (beoran@rubyforge.org)
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -17,7 +19,4 @@
  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
- */
-
-// Collides two cpShape structures. (this function is lonely :( )
-int cpCollideShapes(cpShape *a, cpShape *b, cpContact **arr);
+ */

data/README

@@ -0,0 +1,67 @@
+Ruby Bindings to Chipmunk Physics Version 5.3.4
+
+(C) Scott Lembcke, Beoran and John Mair (banisterfiend)
+
+IMPORTANT NOTICE:
+These are bindings for MRI Ruby 1.8.x and 1.9.x to Chipmunk version 5.3.4
+
+(1) 1/10/09 Cross-Platform Gem built by John Mair (banisterfiend)
+    * Just go: gem install chipmunk  
+
+FORUM:
+  http://www.slembcke.net/forums
+
+CONTACT:
+  slembcke@gmail.com (also on Google Talk) for Chipmunk.
+  beoran@rubyforge.org for these bindings to Ruby.
+
+ABOUT CHIPMUNK:
+  Chipmunk is a simple, lightweight and fast 2D rigid body physics library 
+  written in C by Slembcke. It's licensed under the unrestrictive, OSI approved 
+  MIT license. 
+  
+ABOUT THESE RUBY BINDINGS:  
+  Although chipmunk comes with ruby bindings, they are not always up to date 
+  with regards to the functionality of the C library, and historically, they
+  have been incompatible with recent versions of Ruby. 
+    
+  Therefore, these bindings are intended to as an enhanced version with more 
+  features and better compatibility with recent versions of Ruby. They are also 
+  intended to be an alternative to the chipmunk-ffi bindings when performance 
+  is of the utmost importance, as it may be for games. 
+  
+  The intent is for these bindings to be mostly source code compatible with both 
+  Slembcke's and ffi's bindings. Main exceptions are where I dislike either API. 
+  In that case, I made an API that is pleasing to myself, and similar in naming 
+  to the C API adjusted to ruby conventions. If you have any problems with these bindings, please contact the maintainer at beoran@rubyforge.org.
+  
+INCOMPATIBILITIES:
+  There are no bindings to SpaceHash since I fail to see the use of it, but
+  if someone is using them, I'll probably implement them.
+  
+CONTRACTING:
+  Howling Moon Software (Slembke's company) is available for contracting if you 
+  want to make the physics in your game really stand out. Feel free to contact 
+  them through their webpage: http://howlingmoonsoftware.com/contracting.php
+
+TODO:
+  * More functionality. 
+  * Specs for the new functionality I've wrapped and will wrap.
+  * Better documentation, perhaps based on C API documentation.
+  
+
+INFO FOR MAINTAINERS:
+
+(1) 1/10/09 Cross-Platform Gem built by John Mair (banisterfiend)
+    * Just go: gem install chipmunk  
+
+(2) Patched for 1.9.1 by Beoran (beoran@rubyforge.org)
+
+(3) How to build the gems? (maintainers only)
+    * Install rake-compiler (http://github.com/luislavena/rake-compiler)
+    * Install 1.9.1 and 1.8.6 mingw ruby versions (instructions above)
+    * Type: rake cross native gem RUBY_CC_VERSION=1.8.6:1.9.1
+    * Upload new gems to rubyforge and gemcutter.
+
+
+

data/Rakefile

@@ -1,38 +1,85 @@
 # Rakefile added by John Mair (banisterfiend)
-
-require 'rake/clean'
-require 'rake/extensiontask'
+ 
 require 'rake/gempackagetask'
+require 'rake/clean'
+ 
+begin
+    require 'rake/extensiontask'
+rescue LoadError
+    puts "rake-compiler not found! Please install the rake-compiler gem!"
+#    `/bin/bash -l -c "gem1.9 install rake-compiler"`
+#    require 'rake/extensiontask'
+#    puts "...done!"
+end
+ 
+CHIPMUNK_VERSION = "5.3.4.0"
+ 
+dlext = Config::CONFIG['DLEXT']
+ 
+CLEAN.include("ext/**/*.#{dlext}", "ext/**/.log", "ext/**/.o", "ext/**/*~", "ext/**/*#*", "ext/**/.obj", "ext/**/.def", "ext/**/.pdb")
+CLOBBER.include("**/*.#{dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
 
-CHIPMUNK_VERSION = "4.1.0"
-
-CLEAN.include("ext/**/*.#{$dlext}", "ext/**/.log", "ext/**/.o", "ext/**/*~", "ext/**/*#*", "ext/**/.obj", "ext/**/.def", "ext/**/.pdb")
-CLOBBER.include("**/*.#{$dlext}", "**/*~", "**/*#*", "**/*.log", "**/*.o", "doc/**")
-
-Rake::ExtensionTask.new('chipmunk')
-
-spec = Gem::Specification.new do |s|
+ 
+def apply_spec_defaults(s)
     s.name = "chipmunk"
-    s.summary = "ruby bindings for the chipmunk physics engine"
-    s.description = s.summary
+    s.summary = "Enhanced ruby bindings for the chipmunk 5.3.4 game physics engine."
+    s.description = s.summary + " "
     s.version = CHIPMUNK_VERSION
     s.author = "Scott Lembcke, Beoran, John Mair (banisterfiend)"
-    s.email = 'jrmair@gmail.com'
+    s.email = 'beoran@rubyforge.com'
     s.date = Time.now.strftime '%Y-%m-%d'
     s.require_path = 'lib'
-    s.homepage = "http://code.google.com/p/chipmunk-physics/"
-    s.platform = Gem::Platform::RUBY
-    s.extensions = FileList["ext/**/extconf.rb"]
-    s.files = ["Rakefile", "lib/chipmunk.rb"] + FileList["ext/**/extconf.rb", "ext/**/*.h",
-               "ext/**/*.c"].to_a
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-    pkg.need_zip = false
-    pkg.need_tar = false
-end
-
-Rake::ExtensionTask.new('chipmunk', spec) do |ext|
-    ext.cross_compile = true                
-    ext.cross_platform = 'i386-mswin32'     
+    s.homepage = "https://github.com/beoran/chipmunk"
 end
+ 
+ 
+# common tasks
+task :compile => :clean
+ 
+# platform dependent tasks
+if RUBY_PLATFORM =~ /darwin/
+ 
+    spec = Gem::Specification.new do |s|
+        apply_spec_defaults(s)        
+        s.platform = Gem::Platform::CURRENT
+        s.files = ["Rakefile", "README", "LICENSE", "lib/chipmunk.rb", "lib/1.8/chipmunk.#{dlext}", "lib/1.9/chipmunk.#{dlext}"] 
+    end
+ 
+    Rake::ExtensionTask.new('chipmunk') do |ext|
+        ext.ext_dir   = "ext"
+        ext.lib_dir   = "lib/#{RUBY_VERSION[0..2]}"
+        ext.config_script = 'extconf.rb'
+        ext.config_options << 'macosx'
+    end
+ 
+    task :compile_multi => :clean do
+        `/bin/bash -l -c "rvm 1.8.6,1.9.1 rake compile"`
+    end
+ 
+    task :gem => :compile_multi
+    Rake::GemPackageTask.new(spec) do |pkg|
+        pkg.need_zip = false
+        pkg.need_tar = false
+    end
+ 
+else
+ 
+    spec = Gem::Specification.new do |s|
+        apply_spec_defaults(s)
+        s.platform = Gem::Platform::RUBY
+        s.extensions = FileList["ext/**/extconf.rb"]
+        s.files = ["Rakefile", "README", "LICENSE", "lib/chipmunk.rb"] +
+            FileList["ext/**/extconf.rb", "ext/**/*.h", "ext/**/*.c"].to_a
+    end
+ 
+    Rake::ExtensionTask.new('chipmunk', spec) do |ext|
+        ext.config_script = 'extconf.rb'
+        ext.cross_compile = true
+        ext.cross_platform = 'i386-mswin32'
+    end
+ 
+    Rake::GemPackageTask.new(spec) do |pkg|
+        pkg.need_zip = false
+        pkg.need_tar = false
+    end
+end

data/ext/chipmunk/extconf.rb

@@ -1,4 +1,42 @@
 require 'mkmf'
 
+RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC'] if ENV['CC']
+
+dir_config('chipmunk')
+
+MINGW = '/usr/i586-mingw32msvc'
+CHIPMUNK_HEADER   = 'chipmunk.h'
+CHIPMUNK_NAME     = 'chipmunk'
+CHIPMUNK_FUNCTION = 'cpMomentForPoly'
+CHIPMUNK_INCLUDE  = ['/usr/include', 
+                      File.join(MINGW, 'include'),
+                      File.join(MINGW, 'include', 'chipmunk'),
+                     '/usr/local/include', 
+                     '/usr/include/chipmunk',
+                     '/usr/local/include/chipmunk'
+                    ]
+CHIPMUNK_LIBDIR   = ['/usr/lib', 
+File.join(MINGW, 'lib'),
+'/usr/local/lib']
+
+unless find_header(CHIPMUNK_HEADER, *CHIPMUNK_INCLUDE)
+  raise "Could not find Chipmunk headers!" 
+end
+
+
+unless find_library(CHIPMUNK_NAME, CHIPMUNK_FUNCTION, *CHIPMUNK_LIBDIR)
+  raise "Could not link to Chipmunk library!" 
+end
+
+=begin
+have_header('chipmunk.h', include_dirs)
+=end
+ 
+if ARGV[0] == "macosx"
+    $CFLAGS += ' -arch ppc -arch i386 -arch x86_64'
+    $LDFLAGS += ' -arch x86_64 -arch i386 -arch ppc'
+end
+ 
 $CFLAGS += ' -std=gnu99 -ffast-math'
 create_makefile('chipmunk')
+

data/ext/chipmunk/rb_chipmunk.c

@@ -18,7 +18,9 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
- 
+
+#include <stdlib.h>
+
 #include "chipmunk.h"
 
 #include "ruby.h"
@@ -29,59 +31,160 @@ VALUE m_Chipmunk;
 ID id_parent;
 
 static VALUE
-rb_get_cp_bias_coef(VALUE self)
-{
+rb_get_cp_bias_coef(VALUE self) {
 	return rb_float_new(cp_bias_coef);
 }
 
 static VALUE
-rb_set_cp_bias_coef(VALUE self, VALUE num)
-{
+rb_set_cp_bias_coef(VALUE self, VALUE num) {
 	cp_bias_coef = NUM2DBL(num);
 	return num;
 }
 
 static VALUE
-rb_get_cp_collision_slop(VALUE self)
-{
+rb_get_cp_collision_slop(VALUE self) {
 	return rb_float_new(cp_collision_slop);
 }
 
 static VALUE
-rb_set_cp_collision_slop(VALUE self, VALUE num)
-{
+rb_set_cp_collision_slop(VALUE self, VALUE num) {
 	cp_collision_slop = NUM2DBL(num);
 	return num;
 }
 
 static VALUE
-rb_momentForCircle(VALUE self, VALUE m, VALUE r1, VALUE r2, VALUE offset)
+rb_set_cp_contact_persistence(VALUE self, VALUE num) {
+  cp_contact_persistence = NUM2DBL(num);
+  return num;
+}
+
+static VALUE
+rb_get_cp_contact_persistence(VALUE self) {   
+  return rb_float_new(cp_contact_persistence);
+}
+
+
+static VALUE
+rb_cpMomentForCircle(VALUE self, VALUE m, VALUE r1, VALUE r2, VALUE offset)
 {
 	cpFloat i = cpMomentForCircle(NUM2DBL(m), NUM2DBL(r1), NUM2DBL(r2), *VGET(offset));
 	return rb_float_new(i);
 }
 
 static VALUE
-rb_momentForPoly(VALUE self, VALUE m, VALUE arr, VALUE offset)
+rb_cpMomentForSegment(VALUE self, VALUE m, VALUE v1, VALUE v2)
+{
+  cpFloat i = cpMomentForSegment(NUM2DBL(m), *VGET(v1), *VGET(v2));
+  return rb_float_new(i);
+}
+
+static VALUE
+rb_cpMomentForPoly(VALUE self, VALUE m, VALUE arr, VALUE offset)
 {
 	Check_Type(arr, T_ARRAY);
 	int numVerts = RARRAY_LEN(arr);
+	VALUE *ary_ptr = RARRAY_PTR(arr);
 	cpVect verts[numVerts];
 	
 	for(int i=0; i<numVerts; i++)
-		verts[i] = *VGET(RARRAY_PTR(arr)[i]);
+		verts[i] = *VGET(ary_ptr[i]);
 	
 	cpFloat inertia = cpMomentForPoly(NUM2DBL(m), numVerts, verts, *VGET(offset));
 	return rb_float_new(inertia);
 }
 
 static VALUE
-rb_dampedSpring(VALUE self, VALUE a, VALUE b, VALUE r1, VALUE r2, VALUE len, VALUE k, VALUE dmp, VALUE dt)
+rb_cpMomentForBox(VALUE self, VALUE m, VALUE w, VALUE h) {
+  cpFloat i = cpMomentForBox(NUM2DBL(m), NUM2DBL(w), NUM2DBL(h));
+  return rb_float_new(i);
+}
+
+static VALUE
+rb_cpAreaForCircle(VALUE self, VALUE r1, VALUE r2)
+{
+  cpFloat i = cpAreaForCircle(NUM2DBL(r1), NUM2DBL(r2));
+  return rb_float_new(i);
+}
+
+static VALUE
+rb_cpAreaForSegment(VALUE self, VALUE v1, VALUE v2, VALUE r)
+{
+  cpFloat i = cpAreaForSegment(*VGET(v1), *VGET(v2), NUM2DBL(r));
+  return rb_float_new(i);
+}
+
+static VALUE
+rb_cpAreaForPoly(VALUE self, VALUE arr)
+{
+  Check_Type(arr, T_ARRAY);
+  int numVerts = RARRAY_LEN(arr);
+  VALUE *ary_ptr = RARRAY_PTR(arr);
+  cpVect verts[numVerts];
+  
+  for(int i=0; i<numVerts; i++)
+    verts[i] = *VGET(ary_ptr[i]);
+  
+  cpFloat area = cpAreaForPoly(numVerts, verts);
+  return rb_float_new(area);
+}
+
+static VALUE
+rb_cpAreaForBox(VALUE self, VALUE w, VALUE h) {
+  cpFloat i = NUM2DBL(w) * NUM2DBL(h);
+  return rb_float_new(i);
+}
+
+
+static VALUE rb_cpfclamp(VALUE self, VALUE f, VALUE min, VALUE max) {
+  cpFloat result = cpfclamp(NUM2DBL(f), NUM2DBL(min), NUM2DBL(max));
+  return rb_float_new(result);
+} 
+
+static VALUE rb_cpflerp(VALUE self, VALUE f1, VALUE f2, VALUE t) {
+  cpFloat result = cpflerp(NUM2DBL(f1), NUM2DBL(f2), NUM2DBL(t));
+  return rb_float_new(result);
+} 
+
+static VALUE rb_cpflerpconst(VALUE self, VALUE f1, VALUE f2, VALUE d) {
+  cpFloat result = cpflerpconst(NUM2DBL(f1), NUM2DBL(f2), NUM2DBL(d));
+  return rb_float_new(result);
+} 
+
+static VALUE
+rb_cpCentroidForPoly(VALUE self,  VALUE arr)
 {
-	cpDampedSpring(BODY(a), BODY(b), *VGET(r1), *VGET(r2), NUM2DBL(len), NUM2DBL(k), NUM2DBL(dmp), NUM2DBL(dt));
-	return Qnil;
+  Check_Type(arr, T_ARRAY);
+  int numVerts = RARRAY_LEN(arr);
+  VALUE *ary_ptr = RARRAY_PTR(arr);
+  cpVect verts[numVerts];
+  
+  for(int i=0; i<numVerts; i++)
+    verts[i] = *VGET(ary_ptr[i]);
+  
+  return VNEW(cpCentroidForPoly(numVerts, verts));
 }
 
+static VALUE
+rb_cpRecenterPoly(VALUE self,  VALUE arr)
+{
+  Check_Type(arr, T_ARRAY);
+  int numVerts = RARRAY_LEN(arr);
+  VALUE *ary_ptr = RARRAY_PTR(arr);
+  cpVect verts[numVerts];
+  
+  for(int i=0; i<numVerts; i++)
+    verts[i] = *VGET(ary_ptr[i]);
+    
+  cpRecenterPoly(numVerts, verts);
+  
+  for(int i=0; i<numVerts; i++)
+    ary_ptr[i] = VNEW(verts[i]);
+  return arr;
+}
+
+
+
+
 void
 Init_chipmunk(void)
 {
@@ -89,21 +192,59 @@ Init_chipmunk(void)
 	
 	cpInitChipmunk();
 	
+
+	
 	m_Chipmunk = rb_define_module("CP");
 	rb_define_module_function(m_Chipmunk, "bias_coef", rb_get_cp_bias_coef, 0);
 	rb_define_module_function(m_Chipmunk, "bias_coef=", rb_set_cp_bias_coef, 1);
 	rb_define_module_function(m_Chipmunk, "collision_slop", rb_get_cp_collision_slop, 0);
 	rb_define_module_function(m_Chipmunk, "collision_slop=", rb_set_cp_collision_slop, 1);
+  rb_define_module_function(m_Chipmunk, "contact_persistence", rb_get_cp_contact_persistence, 0);
+  rb_define_module_function(m_Chipmunk, "contact_persistence=", rb_set_cp_contact_persistence, 1);
+  
+  
+  
+  rb_define_module_function(m_Chipmunk, "clamp", rb_cpfclamp, 3);
+  rb_define_module_function(m_Chipmunk, "flerp", rb_cpflerp, 3);
+  rb_define_module_function(m_Chipmunk, "flerpconst", rb_cpflerpconst, 3);
 	
-	rb_define_module_function(m_Chipmunk, "moment_for_circle", rb_momentForCircle, 4);
-	rb_define_module_function(m_Chipmunk, "moment_for_poly", rb_momentForPoly, 3);
-	
-	rb_define_module_function(m_Chipmunk, "damped_spring", rb_dampedSpring, 8);
-	
+	rb_define_module_function(m_Chipmunk, "moment_for_circle", rb_cpMomentForCircle, 4);
+	rb_define_module_function(m_Chipmunk, "moment_for_poly", rb_cpMomentForPoly, 3);
+  rb_define_module_function(m_Chipmunk, "moment_for_segment", rb_cpMomentForSegment, 3);
+  rb_define_module_function(m_Chipmunk, "moment_for_box", rb_cpMomentForBox, 3);
+  
+  rb_define_module_function(m_Chipmunk, "circle_moment", rb_cpMomentForCircle, 4);
+  rb_define_module_function(m_Chipmunk, "poly_moment", rb_cpMomentForPoly, 3);
+  rb_define_module_function(m_Chipmunk, "segment_moment", rb_cpMomentForSegment, 3);
+  rb_define_module_function(m_Chipmunk, "box_moment", rb_cpMomentForBox, 3);
+ 
+ 
+  rb_define_module_function(m_Chipmunk, "area_for_circle", rb_cpAreaForCircle, 2);
+  rb_define_module_function(m_Chipmunk, "area_for_poly", rb_cpAreaForPoly, 1);
+  rb_define_module_function(m_Chipmunk, "centroid_for_poly",
+    rb_cpCentroidForPoly, 1);
+  rb_define_module_function(m_Chipmunk, "recenter_poly",
+    rb_cpRecenterPoly, 1);
+    
+  rb_define_module_function(m_Chipmunk, "area_for_segment", rb_cpAreaForSegment, 3);
+  rb_define_module_function(m_Chipmunk, "area_for_box", rb_cpAreaForBox, 2);
+  
+  rb_define_module_function(m_Chipmunk, "circle_area", rb_cpAreaForCircle, 2);
+  rb_define_module_function(m_Chipmunk, "poly_area", rb_cpAreaForPoly, 1);
+  rb_define_module_function(m_Chipmunk, "segment_area", rb_cpAreaForSegment, 3);
+  rb_define_module_function(m_Chipmunk, "box_area", rb_cpAreaForBox, 2);
+  
+  rb_define_const(m_Chipmunk, "ALL_LAYERS", UINT2NUM((unsigned int)CP_ALL_LAYERS));
+  rb_define_const(m_Chipmunk, "NO_GROUP"  , UINT2NUM(CP_NO_GROUP));
+
+  rb_eval_string("Float::INFINITY = 1.0/0.0 unless Float.const_defined? :INFINITY");
+  rb_eval_string("CP::INFINITY = 1.0/0.0 unless CP.const_defined? :INFINITY"); 
+  
 	Init_cpVect();
 	Init_cpBB();
 	Init_cpBody();
 	Init_cpShape();
-	Init_cpJoint();
+	Init_cpConstraint();
 	Init_cpSpace();
+  Init_cpArbiter();  
 }