chipmunk 5.3.4.0-x86-mingw32

data/ext/chipmunk/rb_cpVect.c

@@ -0,0 +1,346 @@
+/* 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 c_cpVect;
+
+static VALUE
+rb_cpVectForAngle(VALUE self, VALUE angle)
+{
+	return VNEW(cpvforangle(NUM2DBL(angle)));
+}
+
+static VALUE
+rb_cpVectAlloc(VALUE klass)
+{
+	cpVect *v = malloc(sizeof(cpVect));
+	return Data_Wrap_Struct(klass, NULL, free, v);
+}
+
+static VALUE
+rb_cpVectInitialize(VALUE self, VALUE x, VALUE y)
+{
+	cpVect *v = VGET(self);
+	v->x = NUM2DBL(x);
+	v->y = NUM2DBL(y);
+	
+	return self;
+}
+
+static VALUE
+rb_cpVectGetX(VALUE self)
+{
+	return rb_float_new(VGET(self)->x);
+}
+
+static VALUE
+rb_cpVectGetY(VALUE self)
+{
+	return rb_float_new(VGET(self)->y);
+}
+
+static VALUE
+rb_cpVectSetX(VALUE self, VALUE x)
+{
+	VGET(self)->x = NUM2DBL(x);
+	return self;
+}
+
+static VALUE
+rb_cpVectSetY(VALUE self, VALUE y)
+{
+	VGET(self)->y = NUM2DBL(y);
+	return self;
+}
+
+static VALUE
+rb_cpVectToString(VALUE self)
+{
+	char str[256];
+	cpVect *v = VGET(self);
+	
+	sprintf(str, "(% .3f, % .3f)", v->x, v->y);
+	
+	return rb_str_new2(str);
+}
+
+static VALUE
+rb_cpVectToArray(VALUE self)
+{
+	cpVect *v = VGET(self);
+	return rb_ary_new3(2, rb_float_new(v->x), rb_float_new(v->y));
+}
+
+static VALUE
+rb_cpVectToAngle(VALUE self)
+{
+	return rb_float_new(cpvtoangle(*VGET(self)));
+}
+	
+
+static VALUE
+rb_cpVectNegate(VALUE self)
+{
+	return VNEW(cpvneg(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectAdd(VALUE self, VALUE v)
+{
+	return VNEW(cpvadd(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectSub(VALUE self, VALUE v)
+{
+	return VNEW(cpvsub(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectSMult(VALUE self, VALUE s)
+{
+	return VNEW(cpvmult(*VGET(self), NUM2DBL(s)));
+}
+
+static VALUE
+rb_cpVectSDiv(VALUE self, VALUE s)
+{
+	cpFloat factor = 1.0f/(float)NUM2DBL(s);
+	return VNEW(cpvmult(*VGET(self), factor));
+}
+
+static VALUE
+rb_cpVectDot(VALUE self, VALUE v)
+{
+	return rb_float_new(cpvdot(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectCross(VALUE self, VALUE v)
+{
+	return rb_float_new(cpvcross(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectLength(VALUE self)
+{
+	cpVect *v;
+	Data_Get_Struct(self, cpVect, v);
+	return rb_float_new(cpvlength(*v));
+}
+
+static VALUE
+rb_cpVectLengthsq(VALUE self)
+{
+	cpVect *v;
+	Data_Get_Struct(self, cpVect, v);
+	return rb_float_new(cpvlengthsq(*v));
+}
+
+static VALUE
+rb_cpVectNorm(VALUE self)
+{
+	return VNEW(cpvnormalize(*VGET(self)));
+}
+
+static VALUE
+rb_cpVectNormBang(VALUE self)
+{
+	cpVect *v = VGET(self);
+	*v = cpvnormalize(*v);
+	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 = (cpFloat) NUM2DBL(d);
+  return VNEW(cpvlerpconst(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectSlerp(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = (cpFloat) NUM2DBL(d);
+  return VNEW(cpvslerp(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectSlerpconst(VALUE self, VALUE v, VALUE d)
+{
+  cpFloat df = (cpFloat) NUM2DBL(d);
+  return VNEW(cpvslerpconst(*VGET(self), *VGET(v), df));
+}
+
+static VALUE
+rb_cpVectProject(VALUE self, VALUE v)
+{
+	return VNEW(cpvproject(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+rb_cpVectRotate(VALUE self, VALUE v)
+{
+	return VNEW(cpvrotate(*VGET(self), *VGET(v)));
+}
+
+static VALUE
+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)
+{
+	cpFloat dist = NUM2DBL(d);
+	cpVect delta = cpvsub(*VGET(self), *VGET(v));
+	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)
+{
+	return VNEW(cpv(NUM2DBL(x), NUM2DBL(y)));
+}
+
+void
+Init_cpVect(void)
+{
+	c_cpVect = rb_define_class_under(m_Chipmunk, "Vec2", rb_cObject);
+	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);
+	
+	rb_define_method(c_cpVect, "x", rb_cpVectGetX, 0);
+	rb_define_method(c_cpVect, "y", rb_cpVectGetY, 0);
+	rb_define_method(c_cpVect, "x=", rb_cpVectSetX, 1);
+	rb_define_method(c_cpVect, "y=", rb_cpVectSetY, 1);
+	
+	rb_define_method(c_cpVect, "to_s", rb_cpVectToString, 0);
+	rb_define_method(c_cpVect, "to_a", rb_cpVectToArray, 0);
+	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);
+	rb_define_method(c_cpVect, "/", rb_cpVectSDiv, 1);
+	rb_define_method(c_cpVect, "dot", rb_cpVectDot, 1);
+	rb_define_method(c_cpVect, "cross", rb_cpVectCross, 1);
+	rb_define_method(c_cpVect, "length", rb_cpVectLength, 0);
+	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, "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

@@ -0,0 +1,183 @@
+# this redirection script by John Mair (banisterfiend)
+
+require 'rbconfig'
+
+direc = File.dirname(__FILE__)
+dlext = Config::CONFIG['DLEXT']
+begin
+    if RUBY_VERSION && RUBY_VERSION =~ /1.9/
+        require "#{direc}/1.9/chipmunk.#{dlext}"
+    else
+        require "#{direc}/1.8/chipmunk.#{dlext}"
+    end
+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
+ 
+
+
+