chipmunk 5.3.4.0-x86-mingw32

data/LICENSE

@@ -0,0 +1,22 @@
+/* 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
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ */

data/README

@@ -0,0 +1,70 @@
+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.
+  
+DOCUMENTATION:
+  http://beoran.github.com/chipmunk/
+  
+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

@@ -0,0 +1,86 @@
+# Rakefile added by John Mair (banisterfiend)
+ 
+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/**")
+
+ 
+def apply_spec_defaults(s)
+    s.name = "chipmunk"
+    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 = 'beoran@rubyforge.org'
+    s.date = Time.now.strftime '%Y-%m-%d'
+    s.require_path = 'lib'
+    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 = 'i586-mingw32'
+        # 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

@@ -0,0 +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

@@ -0,0 +1,250 @@
+/* Copyright (c) 2007 Scott Lembcke
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * 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.
+ */
+
+#include <stdlib.h>
+
+#include "chipmunk.h"
+
+#include "ruby.h"
+#include "rb_chipmunk.h"
+
+VALUE m_Chipmunk;
+
+ID id_parent;
+
+static VALUE
+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) {
+	cp_bias_coef = NUM2DBL(num);
+	return num;
+}
+
+static VALUE
+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) {
+	cp_collision_slop = NUM2DBL(num);
+	return num;
+}
+
+static VALUE
+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_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(ary_ptr[i]);
+	
+	cpFloat inertia = cpMomentForPoly(NUM2DBL(m), numVerts, verts, *VGET(offset));
+	return rb_float_new(inertia);
+}
+
+static VALUE
+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)
+{
+  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)
+{
+	id_parent = rb_intern("parent");
+	
+	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_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_cpConstraint();
+	Init_cpSpace();
+  Init_cpArbiter();  
+}