chipmunk-ffi 0.0.1 → 0.1.0

data/lib/chipmunk-ffi/core.rb

@@ -0,0 +1,49 @@
+module CP
+  INFINITY = 1.0/0.0
+  
+  attach_variable :cpVersionString, :string
+  def self.version
+    cpVersionString
+  end
+  VERSION = version.freeze
+
+  attach_variable :cp_bias_coef, CP_FLOAT
+  def bias_coef
+    cp_bias_coef
+  end
+  def bias_coef=(coef)
+    cp_bias_coef = coef
+  end
+
+  attach_variable :cp_collision_slop, CP_FLOAT
+  def collision_slop
+    cp_collision_slop
+  end
+  def collision_slop=(slop)
+    cp_collision_slop = slop
+  end
+
+  func :cpMomentForCircle, [CP_FLOAT,CP_FLOAT,CP_FLOAT,Vect.by_value], CP_FLOAT
+  def moment_for_circle(m,r1,r2,offset)
+    cpMomentForCircle(m, r1, r2, offset.struct);
+  end
+
+  func :cpMomentForSegment, [CP_FLOAT,Vect.by_value,Vect.by_value], CP_FLOAT
+  def moment_for_segment(m,v1,v2)
+    cpMomentForCircle(m, v1.struct, v2.struct)
+  end
+
+  func :cpMomentForPoly, [CP_FLOAT,:int,:pointer,Vect.by_value], CP_FLOAT
+  def moment_for_poly(m,verts,offset)
+    mem_pointer = FFI::MemoryPointer.new Vect, verts.size
+    vert_structs = verts.collect{|s|s.struct}
+
+    size = Vect.size
+    tmp = mem_pointer
+    vert_structs.each_with_index {|i, j|
+      tmp.send(:put_bytes, 0, i.to_bytes, 0, size)
+      tmp += size unless j == vert_structs.length-1 # avoid OOB
+    }
+    cpMomentForPoly(m, verts.size, mem_pointer, offset.struct)
+  end
+end

data/lib/chipmunk-ffi/shape.rb

@@ -0,0 +1,160 @@
+module CP
+
+  ShapeType = enum(
+    :circle_shape,
+    :segment_shape,
+    :poly_shape,
+    :num_shapes
+  )
+
+  callback :cacheData, [:pointer,Vect.by_value,Vect.by_value], BBStruct.by_value
+  callback :destroy, [:pointer], :void
+  callback :pointQuery, [:pointer,Vect.by_value], :int
+  callback :segmentQuery, [:pointer,Vect.by_value,Vect.by_value,:pointer], :void
+
+  class ShapeClassStruct < NiceFFI::Struct
+    layout( :type, ShapeType,
+           :cacheData, :pointer,
+           :destroy, :pointer,
+           :pointQuery, :pointer,
+           :segmentQuery, :pointer
+          )
+  end
+
+  class ShapeStruct < NiceFFI::Struct
+    layout( :klass, :pointer,
+           :body, :pointer,
+           :bb, BBStruct.by_value,
+           :sensor, :int,
+           :e, CP_FLOAT,
+           :u, CP_FLOAT,
+           :surface_v, Vect.by_value,
+           :data, :pointer,
+           :collision_type, :uint,
+           :group, :uint,
+           :layers, :int
+          )
+  end
+  class SegmentQueryInfoStruct < NiceFFI::Struct
+    layout(:shape, ShapeStruct,
+           :t, CP_FLOAT,
+           :n, Vect
+          )
+  end
+
+  func :cpCircleShapeNew, [BodyStruct,CP_FLOAT,Vect.by_value], ShapeStruct
+  func :cpSegmentShapeNew, [BodyStruct,Vect.by_value,Vect.by_value,CP_FLOAT], ShapeStruct
+  func :cpPolyShapeNew, [BodyStruct,:int,:pointer,Vect.by_value], ShapeStruct
+  func :cpShapeCacheBB, [ShapeStruct], :void
+  func :cpResetShapeIdCounter, [], :void
+
+  module Shape
+    attr_reader :struct
+
+    def body
+#      Body.new BodyStruct.new(@struct.body)
+      @body
+    end
+    def body=(new_body)
+      @struct.body = new_body.struct.pointer
+      @body = new_body
+    end
+
+    def collision_type
+      @collType
+    end
+    def collision_type=(col_type)
+      @collType = col_type
+      @struct.collision_type = col_type.object_id
+    end
+
+    def group
+      @group
+    end
+    def group=(group_obj)
+      @group = group_obj
+      @struct.group = group_obj.object_id
+    end
+
+    def layers
+      @struct.layers
+    end
+    def layers=(l)
+      @struct.layers = l
+    end
+
+    def bb
+      our_bb = @struct.bb
+      size = BBStruct.size
+      bb_ptr = FFI::MemoryPointer.new size
+      bb_ptr.send(:put_bytes, 0, our_bb.to_bytes, 0, size)
+      BB.new(BBStruct.new(bb_ptr))
+    end
+
+    def cache_bb
+      CP.cpShapeCacheBB(@struct.bb)
+      bb
+    end
+
+    def e
+      @struct.e
+    end
+    def e=(new_e)
+      @struct.e = new_e
+    end
+
+    def u
+      @struct.u
+    end
+    def u=(new_u)
+      @struct.u = new_u
+    end
+
+    def surface_v
+      Vec2.new @struct.surface_v
+    end
+    def surface_v=(new_sv)
+      @struct.surface_v = new_sv.struct
+    end
+
+    def self.reset_id_counter
+      CP.cpResetShapeIdCounter
+    end
+
+    class Circle
+      include Shape
+      def initialize(body, rad, offset_vec)
+        @body = body
+        ptr = CP.cpCircleShapeNew body.struct.pointer, rad, offset_vec.struct
+        @struct = ShapeStruct.new ptr
+      end
+    end
+    class Segment
+      include Shape
+      def initialize(body, v1, v2, r)
+        @body = body
+        ptr = CP.cpSegmentShapeNew body.struct.pointer, v1.struct, v2.struct, r
+        @struct = ShapeStruct.new ptr
+      end
+    end
+    class Poly
+      include Shape
+      def initialize(body, verts, offset_vec)
+        @body = body
+        mem_pointer = FFI::MemoryPointer.new Vect, verts.size
+        vert_structs = verts.collect{|s|s.struct}
+
+        size = Vect.size
+        tmp = mem_pointer
+        vert_structs.each_with_index {|i, j|
+          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
+      end
+    end
+  end
+
+
+end

data/lib/chipmunk-ffi/space.rb

@@ -0,0 +1,213 @@
+module CP
+  class CollisionHandlerStruct < NiceFFI::Struct
+    layout(
+      :a, :uint,
+      :b, :uint,
+      :begin, :pointer,
+      :pre_solve, :pointer,
+      :post_solve, :pointer,
+      :separate, :pointer,
+      :data, :pointer
+    )
+  end
+
+  class SpaceStruct < NiceFFI::Struct
+    layout( :iterations, :int,
+      :elastic_iterations, :int,
+      :gravity, Vect.by_value,
+      :damping, CP_FLOAT,
+      :stamp, :int,
+      :static_shapes, :pointer,
+      :active_shapes, :pointer,
+      :bodies, :pointer,
+      :arbiters, :pointer,
+      :contact_set, :pointer,
+      :constraints, :pointer,
+      :coll_func_set, :pointer,
+      :default_handler, :pointer,
+      :post_step_callbacks, :pointer
+    )
+    def self.release(ptr)
+      CP.cpSpaceFreeChildren(ptr)
+    end
+  end
+
+  callback :cpCollisionBeginFunc, [:pointer,:pointer,:pointer], :int
+  callback :cpCollisionPreSolveFunc, [:pointer,:pointer,:pointer], :int
+  callback :cpCollisionPostSolveFunc, [:pointer,:pointer,:pointer], :int
+  callback :cpCollisionSeparateFunc, [:pointer,:pointer,:pointer], :int
+
+
+  func :cpSpaceNew, [], :pointer
+  func :cpSpaceFreeChildren, [:pointer], :void
+  
+  func :cpSpaceAddShape, [:pointer, :pointer], :pointer
+  func :cpSpaceAddStaticShape, [:pointer, :pointer], :pointer
+  func :cpSpaceAddBody, [:pointer, :pointer], :pointer
+  func :cpSpaceAddConstraint, [:pointer, :pointer], :pointer
+
+  func :cpSpaceRemoveShape, [:pointer, :pointer], :void
+  func :cpSpaceRemoveStaticShape, [:pointer, :pointer], :void
+  func :cpSpaceRemoveBody, [:pointer, :pointer], :void
+  func :cpSpaceRemoveConstraint, [:pointer, :pointer], :void
+
+  func :cpSpaceRehashStatic, [:pointer], :void
+  func :cpSpaceStep, [:pointer,:double], :void
+  func :cpSpaceResizeActiveHash, [:pointer,CP_FLOAT,:int], :void
+  func :cpSpaceResizeStaticHash, [:pointer,CP_FLOAT,:int], :void
+
+
+  # TODO seems like a broken name here 
+  func :cpSpaceSetDefaultCollisionPairFunc, [:pointer, :uint, :uint,
+   :pointer, :pointer, :pointer, :pointer, :pointer], :void
+  func :cpSpaceAddCollisionHandler, [:pointer, :uint, :uint,
+   :pointer, :pointer, :pointer, :pointer, :pointer], :void
+  func :cpSpaceRemoveCollisionHandler, [:pointer, :uint, :uint], :void
+  class Space
+    attr_reader :struct
+    def initialize
+      @struct = SpaceStruct.new(CP.cpSpaceNew)
+      @static_shapes = []
+      @active_shapes = []
+      @bodies = []
+      @constraints = []
+      @blocks = {}
+    end
+    
+    def iterations
+      @struct.iterations
+    end
+    def iterations=(its)
+      @struct.iterations = its
+    end
+
+    def elastic_iterations
+      @struct.elastic_iterations
+    end
+    def elastic_iterations=(elastic_its)
+      @struct.elastic_iterations = elastic_its
+    end
+
+    def damping
+      @struct.damping
+    end
+    def damping=(damp)
+      @struct.damping = damp
+    end
+
+    def gravity
+      Vec2.new @struct.gravity
+    end
+    def gravity=(v)
+      @struct.gravity = v.struct
+    end
+
+    def add_collision_func(a,b,&block)
+      # TODO huh?
+      beg = nil
+      pre = nil
+      post = nil
+      sep = nil
+      data = block
+      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]] = block
+      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)
+      @blocks[:default] = block 
+    end
+
+    def add_shape(shape)
+      CP.cpSpaceAddShape(@struct.pointer, shape.struct.pointer)
+      @active_shapes << shape
+      shape
+    end
+
+    def add_static_shape(shape)
+      CP.cpSpaceAddStaticShape(@struct.pointer, shape.struct.pointer)
+      @static_shapes << shape
+      shape
+    end
+
+    def add_body(body)
+      CP.cpSpaceAddBody(@struct.pointer, body.struct.pointer)
+      @bodies << body
+      body
+    end
+
+    def add_constraint(con)
+      CP.cpSpaceAddConstraint(@struct.pointer, con.struct.pointer)
+      @constraints << con
+      con
+    end
+
+    def remove_shape(shape)
+      CP.cpSpaceRemoveShape(@struct.pointer, shape.struct.pointer)
+      @active_shapes.delete shape
+      shape
+    end
+
+    def remove_static_shape(shape)
+      CP.cpSpaceRemoveStaticShape(@struct.pointer, shape.struct.pointer)
+      @static_shapes.delete shape
+      shape
+    end
+
+    def remove_body(body)
+      CP.cpSpaceRemoveBody(@struct.pointer, body.struct.pointer)
+      @bodies.delete body
+      body
+    end
+
+    def remove_constraint(con)
+      CP.cpSpaceRemoveConstraint(@struct.pointer, con.struct.pointer)
+      @constraints.delete con
+      con
+    end
+
+    def resize_static_hash(dim, count)
+      CP.cpSpaceResizeStaticHash @struct.pointer, dim, count
+    end
+
+    def resize_active_hash(dim, count)
+      CP.cpSpaceResizeActiveHash @struct.pointer, dim, count
+    end
+
+    def rehash_static
+      CP.cpSpaceRehashStatic @struct.pointer
+    end
+
+    def step(dt)
+#      CP.cpSpaceStep @struct.pointer, dt
+    end
+
+    def shape_point_query(*args)
+      raise "Not Implmented yet"
+    end
+
+    def static_shape_point_query(*args)
+      raise "Not Implmented yet"
+    end
+
+    def each_body(&block)
+      @bodies.each &block
+#      typedef void (*cpSpaceBodyIterator)(cpBody *body, void *data);
+#      void cpSpaceEachBody(cpSpace *space, cpSpaceBodyIterator func, void *data);
+    end
+
+
+  end
+end
+

data/lib/chipmunk-ffi/vec2.rb

@@ -0,0 +1,187 @@
+module CP
+  class Vect < NiceFFI::Struct
+    layout( :x, CP_FLOAT,
+           :y, CP_FLOAT )
+  end
+
+  cp_static_inline :cpv, [CP_FLOAT,CP_FLOAT], Vect.by_value
+  cp_static_inline :cpvneg, [Vect.by_value], Vect.by_value
+  cp_static_inline :cpvadd, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvsub, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvmult, [Vect.by_value,CP_FLOAT], Vect.by_value
+  cp_static_inline :cpvdot, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvcross, [Vect.by_value,Vect.by_value], Vect.by_value
+
+  cp_static_inline :cpvperp, [Vect.by_value], Vect.by_value
+  cp_static_inline :cpvrperp, [Vect.by_value], Vect.by_value
+  cp_static_inline :cpvproject, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvrotate, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvunrotate, [Vect.by_value,Vect.by_value], Vect.by_value
+
+  cp_static_inline :cpvlengthsq, [Vect.by_value], CP_FLOAT
+
+  cp_static_inline :cpvlerp, [Vect.by_value,Vect.by_value], Vect.by_value
+
+  cp_static_inline :cpvnormalize, [Vect.by_value], Vect.by_value
+  cp_static_inline :cpvnormalize_safe, [Vect.by_value], Vect.by_value
+
+  cp_static_inline :cpvclamp, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvlerpconst, [Vect.by_value,Vect.by_value], Vect.by_value
+  cp_static_inline :cpvdist, [Vect.by_value,Vect.by_value], CP_FLOAT
+  cp_static_inline :cpvdistsq, [Vect.by_value,Vect.by_value], CP_FLOAT
+
+  cp_static_inline :cpvnear, [Vect.by_value,Vect.by_value, CP_FLOAT], :int
+
+  func :cpvlength, [Vect.by_value], CP_FLOAT
+  func :cpvforangle, [CP_FLOAT], Vect.by_value
+  func :cpvslerp, [Vect.by_value, Vect.by_value, CP_FLOAT], Vect.by_value
+  func :cpvslerpconst, [Vect.by_value, Vect.by_value, CP_FLOAT], Vect.by_value
+  func :cpvtoangle, [Vect.by_value], CP_FLOAT
+  func :cpvstr, [Vect.by_value], :string
+
+  class Vec2
+    attr_accessor :struct
+    def initialize(*args)
+      case args.size
+      when 1
+        @struct = args.first
+      when 2
+        @struct = CP.cpv(*args)
+      else
+        raise "wrong number of args for Vec, got #{args.size}, but expected 2"
+      end
+    end
+
+    def x
+      @struct.x
+    end
+    def x=(new_x)
+      raise TypeError "cant't modify frozen object" if frozen?
+      @struct.x = new_x
+    end
+    def y
+      @struct.y
+    end
+    def y=(new_y)
+      raise TypeError "cant't modify frozen object" if frozen?
+      @struct.y = new_y
+    end
+
+    def self.for_angle(angle)
+      Vec2.new CP.cpvforangle(angle)
+    end
+
+    def to_s
+      CP.cpvstr @struct
+    end
+
+    def to_angle
+      CP.cpvtoangle @struct
+    end
+
+    def to_a
+      [@struct.x,@struct.y]
+    end
+
+    def -@
+      Vec2.new CP.cpvneg(@struct)  
+    end
+
+    def +(other_vec)
+      Vec2.new CP.cpvadd(@struct, other_vec.struct)
+    end
+
+    def -(other_vec)
+      Vec2.new CP.cpvsub(@struct, other_vec.struct)
+    end
+
+    def *(s)
+      Vec2.new CP.cpvmult(@struct, s)
+    end
+
+    def /(s)
+      factor = 1.0/s
+      Vec2.new CP.cpvmult(@struct, factor)
+    end
+
+    def dot(other_vec)
+      CP.cpvdot(@struct, other_vec.struct)
+    end
+
+    def cross(other_vec)
+      CP.cpvcross(@struct, other_vec.struct)
+    end
+
+    def perp
+      Vec2.new CP.cpvperp(@struct)
+    end
+
+    def rperp
+      Vec2.new CP.cpvperp(@struct)
+    end
+
+    def project(other_vec)
+      Vec2.new CP.cpvproject(@struct, other_vec.struct)
+    end
+
+    def rotate(other_vec)
+      Vec2.new CP.cpvrotate(@struct, other_vec.struct)
+    end
+
+    def unrotate(other_vec)
+      Vec2.new CP.cpvunrotate(@struct, other_vec.struct)
+    end
+
+    def lengthsq
+      CP.cpvlengthsq(@struct)
+    end
+
+    def lerp(other_vec)
+      Vec2.new CP.cpvlerp(@struct, other_vec.struct)
+    end
+
+    def normalize
+      Vec2.new CP.cpvnormalize(@struct)
+    end
+
+    def normalize!
+      @struct = CP.cpvnormalize(@struct)
+      self
+    end
+
+    def normalize_safe
+      Vec2.new CP.cpvnormalize_safe(@struct)
+    end
+
+    def clamp(other_vec)
+      Vec2.new CP.cpvclamp(@struct)
+    end
+
+    def lerpconst(other_vec)
+      Vec2.new CP.cpvlerpconst(@struct)
+    end
+
+    def dist(other_vec)
+      CP.cpvdist(@struct)
+    end
+
+    def distsq(other_vec)
+      CP.cpvdistsq(@struct)
+    end
+
+    def near?(other_vec, dist)
+      delta_v = CP.cpvsub(@struct, other_vec.struct)
+      CP.cpvdot(delta_v, delta_v) < dist*dist
+    end
+
+    def length
+      CP::cpvlength @struct
+    end
+
+  end
+  ZERO_VEC_2 = Vec2.new(0,0).freeze
+
+end
+def vec2(x,y)
+  CP::Vec2.new x, y
+end