chipmunk-ffi 1.0.0 → 1.1.0

data/lib/chipmunk-ffi/constraints/simple_motor.rb

@@ -10,10 +10,15 @@ module CP
   func :cpSimpleMotorNew, [:pointer, :pointer, CP_FLOAT], :pointer
 
   class SimpleMotor
-    attr_reader :struct
+    include Constraint
+    struct_accessor SimpleMotorStruct, :rate
     def initialize(a_body, b_body, rate)
+      @body_a, @body_b = a_body, b_body
       @struct = SimpleMotorStruct.new(CP.cpSimpleMotorNew(
         a_body.struct.pointer,b_body.struct.pointer,rate))
     end
   end
 end
+
+# Alias for compatibility with chipmunk C-Ruby bindings.
+CP::Constraint::SimpleMotor = CP::SimpleMotor

data/lib/chipmunk-ffi/constraints/slide_joint.rb

@@ -18,10 +18,15 @@ module CP
   func :cpSlideJointNew, [:pointer, :pointer, Vect.by_value, Vect.by_value, CP_FLOAT, CP_FLOAT], :pointer
 
   class SlideJoint
-    attr_reader :struct
+    include Constraint
+    struct_accessor SlideJointStruct, :anchr1, :anchr2, :min, :max
     def initialize(a_body, b_body, anchr_one, anchr_two, min, max)
+      @body_a, @body_b = a_body, b_body
       @struct = SlideJointStruct.new(CP.cpSlideJointNew(
         a_body.struct.pointer,b_body.struct.pointer,anchr_one.struct,anchr_two.struct,min,max))
     end
   end
 end
+
+# Alias for compatibility with chipmunk C-Ruby bindings.
+CP::Constraint::SlideJoint = CP::SlideJoint

data/lib/chipmunk-ffi/core.rb

@@ -30,7 +30,7 @@ module CP
 
   func :cpMomentForSegment, [CP_FLOAT,Vect.by_value,Vect.by_value], CP_FLOAT
   def self.moment_for_segment(m,v1,v2)
-    cpMomentForCircle(m, v1.struct, v2.struct)
+    cpMomentForSegment(m, v1.struct, v2.struct)
   end
 
   func :cpMomentForPoly, [CP_FLOAT,:int,:pointer,Vect.by_value], CP_FLOAT

data/lib/chipmunk-ffi/shape.rb

@@ -51,6 +51,7 @@ module CP
   func :cpResetShapeIdCounter, [], :void
   func :cpShapePointQuery, [:pointer, Vect.by_value], :int
 	func :cpShapeSegmentQuery, [:pointer, Vect.by_value, Vect.by_value, :pointer], :int
+  func :cpPolyValidate, [:pointer, :int], :int
 
   module Shape
     class SegmentQueryInfo
@@ -200,6 +201,15 @@ module CP
       include Shape
       def initialize(body, verts, offset_vec)
         @body = body
+        verts = CP::Shape::Poly.make_vertices_valid(verts)
+        mem_pointer = CP::Shape::Poly.pointer_for_verts(verts)
+        
+        ptr = CP.cpPolyShapeNew body.struct.pointer, verts.size, mem_pointer, offset_vec.struct
+        @struct = ShapeStruct.new ptr
+        set_data_pointer
+      end
+      
+      def self.pointer_for_verts(verts)
         mem_pointer = FFI::MemoryPointer.new Vect, verts.size
         vert_structs = verts.collect{|s|s.struct}
 
@@ -209,9 +219,28 @@ module CP
           tmp.send(:put_bytes, 0, i.to_bytes, 0, size)
           tmp += size unless j == vert_structs.length-1 # avoid OOB
         }
-        ptr = CP.cpPolyShapeNew body.struct.pointer, verts.size, mem_pointer, offset_vec.struct
-        @struct = ShapeStruct.new ptr
-        set_data_pointer
+        return mem_pointer
+      end
+      
+      def self.strictly_valid_vertices?(verts)
+        mem_pointer = CP::Shape::Poly.pointer_for_verts(verts)
+        result = CP.cpPolyValidate(mem_pointer,verts.size)
+        return (result != 0)
+      end
+      
+      def self.valid_vertices?(verts)
+        CP::Shape::Poly.strictly_valid_vertices?(verts) || 
+        CP::Shape::Poly.strictly_valid_vertices?(verts.reverse)
+      end
+      
+      def self.make_vertices_valid(verts)
+        if CP::Shape::Poly.strictly_valid_vertices?(verts)
+          return verts
+        elsif CP::Shape::Poly.strictly_valid_vertices?(verts.reverse)
+          return verts.reverse
+        else
+          raise "Chipmunk-FFI Error: Vertices do not form convex polygon."
+        end
       end
     end
   end

data/lib/chipmunk-ffi/space.rb

@@ -8,6 +8,7 @@ module CP
   callback :cpCollisionPostSolveFunc, [:pointer,:pointer,:pointer], :int
   callback :cpCollisionSeparateFunc, [:pointer,:pointer,:pointer], :int
 	callback :cpSpacePointQueryFunc, [:pointer,:pointer], :void
+	callback :cpSpaceSegmentQueryFunc, [:pointer, :float, Vect.by_value, :pointer], :void
 
   class CollisionHandlerStruct < NiceFFI::Struct
     layout(
@@ -26,6 +27,7 @@ module CP
       :elastic_iterations, :int,
       :gravity, Vect.by_value,
       :damping, CP_FLOAT,
+      :locked, :int,
       :stamp, :int,
       :static_shapes, :pointer,
       :active_shapes, :pointer,
@@ -42,7 +44,6 @@ module CP
     end
   end
 
-
   func :cpSpaceNew, [], :pointer
   func :cpSpaceFreeChildren, [:pointer], :void
   
@@ -71,7 +72,10 @@ module CP
   func :cpSpacePointQuery, [:pointer, Vect.by_value, :uint, :uint, :cpSpacePointQueryFunc, :pointer], :pointer
   func :cpSpacePointQueryFirst, [:pointer, Vect.by_value, :uint, :uint], :pointer
 
-  class Space
+  func :cpSpaceSegmentQuery, [:pointer, Vect.by_value, Vect.by_value, :uint, :uint, :cpSpaceSegmentQueryFunc, :pointer], :int
+  func :cpSpaceSegmentQueryFirst, [:pointer, Vect.by_value, Vect.by_value, :uint, :uint, :pointer], :pointer
+
+  class Space 
     attr_reader :struct
     def initialize
       @struct = SpaceStruct.new(CP.cpSpaceNew)
@@ -81,6 +85,7 @@ module CP
       @constraints = []
       @blocks = {}
       @callbacks = {}
+      @test_callbacks = Hash.new {|h,k| h[k] = {:begin => nil, :pre => nil, :post => nil, :sep => nil}}
     end
     
     def iterations
@@ -111,58 +116,58 @@ module CP
       @struct.gravity.pointer.put_bytes 0, v.struct.to_bytes, 0,Vect.size
     end
 
-    def add_collision_func(a,b,&block)
-      beg = nil
-      pre = nil
-      unless block.nil?
-        pre = Proc.new do |arb_ptr,space_ptr,data_ptr|
-          begin
-            arb = ArbiterStruct.new(arb_ptr)
-
-            swapped = arb.swapped_col == 0 ? false : true
-            arba = swapped ? arb.b : arb.a
-            arbb = swapped ? arb.a : arb.b
-
-            as = ShapeStruct.new(arba)
-            a_obj_id = as.data.get_long 0
-            rb_a = ObjectSpace._id2ref a_obj_id
-
-            bs = ShapeStruct.new(arbb)
-            b_obj_id = bs.data.get_long 0
-            rb_b = ObjectSpace._id2ref b_obj_id
-
-            block.call rb_a, rb_b
-            1
-          rescue Exception => ex
-            puts ex.message
-            puts ex.backtrace
-            0
-          end
-        end
-      else
-        # needed for old chipmunk style 
-        pre = Proc.new do |arb_ptr,space_ptr,data_ptr|
-          0
-        end
-      end
-      post = nil
-      sep = nil
-      data = nil
-      a_id = a.object_id
-      b_id = b.object_id
-      CP.cpSpaceAddCollisionHandler(@struct.pointer, a_id, b_id,
-          beg,pre,post,sep,data)
-      @blocks[[a_id,b_id]] = pre
-      nil
-    end
-
-    def remove_collision_func(a,b)
-      a_id = a.object_id
-      b_id = b.object_id
-      CP.cpSpaceRemoveCollisionHandler(@struct.pointer, a_id, b_id)
-      @blocks.delete [a_id,b_id]
-      nil
-    end
+    #def add_collision_func(a,b,&block)
+    #  beg = nil
+    #  pre = nil
+    #  unless block.nil?
+    #    pre = Proc.new do |arb_ptr,space_ptr,data_ptr|
+    #      begin
+    #        arb = ArbiterStruct.new(arb_ptr)
+    #
+    #        swapped = arb.swapped_col == 0 ? false : true
+    #        arba = swapped ? arb.b : arb.a
+    #        arbb = swapped ? arb.a : arb.b
+    #
+    #        as = ShapeStruct.new(arba)
+    #        a_obj_id = as.data.get_long 0
+    #        rb_a = ObjectSpace._id2ref a_obj_id
+    #
+    #        bs = ShapeStruct.new(arbb)
+    #        b_obj_id = bs.data.get_long 0
+    #        rb_b = ObjectSpace._id2ref b_obj_id
+    #
+    #        block.call rb_a, rb_b
+    #        1
+    #      rescue Exception => ex
+    #        puts ex.message
+    #        puts ex.backtrace
+    #        0
+    #      end
+    #    end
+    #  else
+    #    # needed for old chipmunk style 
+    #    pre = Proc.new do |arb_ptr,space_ptr,data_ptr|
+    #      0
+    #    end
+    #  end
+    #  post = nil
+    #  sep = nil
+    #  data = nil
+    #  a_id = a.object_id
+    #  b_id = b.object_id
+    #  CP.cpSpaceAddCollisionHandler(@struct.pointer, a_id, b_id,
+    #      beg,pre,post,sep,data)
+    #  @blocks[[a_id,b_id]] = pre
+    #  nil
+    #end
+
+    #def remove_collision_func(a,b)
+    #  a_id = a.object_id
+    #  b_id = b.object_id
+    #  CP.cpSpaceRemoveCollisionHandler(@struct.pointer, a_id, b_id)
+    #  @blocks.delete [a_id,b_id]
+    #  nil
+    #end
 
     def set_default_collision_func(&block)
       raise "Not Implmented yet"
@@ -183,6 +188,7 @@ module CP
         ret ? 1 : 0
       end
       @callbacks[[a,b,type]] = [handler,callback]
+      @test_callbacks[[a,b]][type] = callback
       callback
     end
 
@@ -201,6 +207,35 @@ module CP
         a_id, b_id, beg,pre,post,sep,data)
     end
 
+    def add_collision_func(a,b,type=:pre,&block)
+      arity = block.arity
+      callback = Proc.new do |arb_ptr,space_ptr,data_ptr|
+        arbiter = Arbiter.new(arb_ptr)
+        ret = case arity
+        when 1 then block.call(arbiter)
+        when 2 then block.call(*arbiter.shapes)
+        when 3 then block.call(arbiter,*arbiter.shapes)
+        else raise ArgumentError
+        end
+        ret ? 1 : 0
+      end
+      @test_callbacks[[a,b]][type] = callback
+      setup_callbacks(a,b)
+    end
+
+    def remove_collision_func(a,b,type=:pre)
+      @test_callbacks[[a,b]][type] = nil
+      setup_callbacks(a,b)
+    end
+
+    def setup_callbacks(a,b)
+      a_id = a.object_id
+      b_id = b.object_id
+      cbs = @test_callbacks[[a,b]]
+      CP.cpSpaceAddCollisionHandler(@struct.pointer,a_id,b_id,
+      cbs[:begin],cbs[:pre],cbs[:post],cbs[:sep],nil)
+    end
+
     def add_shape(shape)
       CP.cpSpaceAddShape(@struct.pointer, shape.struct.pointer)
       @active_shapes << shape
@@ -307,6 +342,53 @@ module CP
       CP.cpSpacePointQuery(@struct.pointer, point.struct, layers, group,query_proc,nil)
     end
 
+    class SegmentQueryInfo
+      attr_reader :hit,:shape, :t, :n
+      def initialize(hit,shape,t=nil,n=nil,info=nil)
+        @hit = hit
+        @shape = shape
+        @t = t
+        @n = n
+        @info = info
+      end
+    end
+
+    def shape_segment_query(a,b,layers=ALL_ONES,group=0)
+      segment_query_first(a,b,layers,group).shape
+    end
+    
+    def info_segment_query(a,b,layers=ALL_ONES,group=0)
+      segment_query_first(a,b,layers,group)
+    end
+
+    def segment_query_first(a,b,layers,group)
+      out_ptr = FFI::MemoryPointer.new(SegmentQueryInfoStruct.size)
+      info = SegmentQueryInfoStruct.new out_ptr
+
+      shape_ptr = CP.cpSpaceSegmentQueryFirst(@struct.pointer, a.struct.pointer, b.struct.pointer,layers,group,out_ptr)
+      if shape_ptr.null?
+        SegmentQueryInfo.new(false,nil,nil,nil,info)
+      else
+        shape_struct = ShapeStruct.new(shape_ptr)
+        obj_id = shape_struct.data.get_long(0)
+        shape = ObjectSpace._id2ref(obj_id)
+        n_vec = Vec2.new(info.n)
+        SegmentQueryInfo.new(true,shape,info.t,n_vec,info)
+      end
+    end
+    
+    def segment_query(a,b,layers,group,&block)
+      return nil unless block_given?
+      query_proc = Proc.new do |shape_ptr,t,n,data|
+        shape_struct = ShapeStruct.new(shape_ptr)
+        obj_id = shape_struct.data.get_long(0)
+        shape = ObjectSpace._id2ref(obj_id)
+        block.call(shape,t,n)
+      end
+      
+      CP.cpSpaceSegmentQuery(@struct.pointer, a.struct, b.struct, layers, group, query_proc, nil)
+    end
+
   end
 end
 

data/lib/chipmunk-ffi/space_hash.rb

@@ -8,8 +8,10 @@ module CP
            :cell_dim, CP_FLOAT,
            :bb_func, :cpSpaceHashBBFunc,
            :handle_set, :pointer,
+           :pooled_handles, :pointer,
            :table, :pointer,
            :bins, :pointer,
+           :allocated_buffers, :pointer,
            :stamp, :int)
   end
   func :cpSpaceHashNew,  [CP_FLOAT,:int,:cpSpaceHashBBFunc], :pointer

data/lib/chipmunk-ffi/struct_accessor.rb

@@ -0,0 +1,48 @@
+module CP
+  module StructAccessor
+    private
+    
+    def struct_reader(struct,*args)
+      raise(ArgumentError,"First argument must be an FFI::Struct subclass, got #{struct.inspect} instead.") unless struct < FFI::Struct
+      args.each {|attribute| add_struct_reader(struct,attribute) }
+    end
+    
+    def struct_writer(struct,*args)
+      raise(ArgumentError,"First argument must be an FFI::Struct subclass, got #{struct.inspect} instead.") unless struct < FFI::Struct
+      args.each {|attribute| add_struct_writer(struct,attribute) }
+    end
+      
+    def struct_accessor(struct,*args)
+      struct_reader(struct,*args)
+      struct_writer(struct,*args)
+    end
+    
+    def add_struct_reader(struct,attribute)
+      type = resolve_type(struct,attribute)
+      if type == CP::Vect
+        define_method(attribute) { Vec2.new(self.struct[attribute]) }
+      else
+        define_method(attribute) { self.struct[attribute] }
+      end
+    end
+      
+    def add_struct_writer(struct,attribute)
+      type = resolve_type(struct,attribute)
+      if type == CP::Vect
+        define_method("#{attribute}=") {|val| self.struct[attribute].pointer.put_bytes(0,val.struct.to_bytes,0,Vect.size) }
+      else
+        define_method("#{attribute}=") {|val| self.struct[attribute] = val }
+      end
+    end
+    
+    def resolve_type(struct,attribute)
+      t = struct.layout[attribute].type
+      if t.is_a?(FFI::StructByValue)
+        t.struct_class
+      else
+        t
+      end
+    end
+    
+  end
+end

data/lib/chipmunk-ffi/vec2.rb

@@ -195,9 +195,15 @@ module CP
       CP::cpvlength @struct
     end
 
+    def ==(other)
+      self.x == other.x && self.y == other.y
+    end
+
   end
   ZERO_VEC_2 = Vec2.new(0,0).freeze
-
+  def zero
+    ZERO_VEC_2
+  end
 end
 def vec2(x,y)
   CP::Vec2.new x, y

data/spec/body_spec.rb

@@ -152,5 +152,49 @@ describe 'A new Body' do
     b.v.x.should be_close(0.1,0.001)
     b.v.y.should be_close(0,0.001)
   end
+  
+  it 'can get its velocity function' do
+    b = CP::Body.new(5, 7)
+    b.apply_impulse(vec2(1,0), ZERO_VEC_2)
+    b.velocity_func.call(b,vec2(0,0), 0.5, 25)
+    b.v.x.should be_close(0.1,0.001)
+    b.v.y.should be_close(0,0.001)
+  end
+  
+  it 'can set its velocity function' do
+    b = CP::Body.new(5, 7)
+    
+    b.velocity_func = Proc.new do |body,gravity,damping,dt|
+      d = body.p - vec2(5,5)
+      g = (d * (-500.0/(d.dot(d))))
+      body.update_velocity(g,damping,dt)
+    end
+    
+    b.velocity_func.call(b,ZERO_VEC_2,0.5,25)
+    b.v.x.should be_close(1250.0,10)
+    b.v.y.should be_close(1250.0,10)
+     
+  end
+  
+  it 'can get its position function' do
+    b = CP::Body.new(5, 7)
+    b.apply_impulse(vec2(1,0), ZERO_VEC_2)
+    b.position_func.call(b,25)
+    b.p.x.should be_close(5,0.001)
+    b.p.y.should be_close(0,0.001)
+  end
+  
+  it 'can set its position function' do
+    b = CP::Body.new(5,7)
+    
+    b.position_func = Proc.new do |body,dt|
+      body.p = vec2(5,5)
+    end
+    
+    b.position_func.call(b,25)
+    b.p.should == vec2(5,5)
+  end
+  
+  
 
 end