box2d-ruby 1.0.0

data/lib/box2d/body.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Box2D
+  class Body < Handle
+    include BodyShapes
+
+    ID_CLASS = Native::BodyId
+    TYPES = {
+      Native::BodyType::STATIC_BODY => :static,
+      Native::BodyType::KINEMATIC_BODY => :kinematic,
+      Native::BodyType::DYNAMIC_BODY => :dynamic
+    }.freeze
+    TYPE_VALUES = TYPES.invert.freeze
+
+    attr_reader :shapes, :chains, :joints
+
+    def initialize(world, id)
+      super
+      @shapes = []
+      @chains = []
+      @joints = []
+    end
+
+    def destroy
+      ensure_valid!
+      Native.b2DestroyBody(@id)
+      @joints.dup.each(&:invalidate_from_body!)
+      @shapes.each { |shape| shape.send(:invalidate!) }
+      @chains.each { |chain| chain.send(:invalidate!) }
+      invalidate!
+      @world.unregister_body(self)
+      true
+    end
+
+    def type
+      ensure_valid!
+      TYPES.fetch(Native.b2Body_GetType(@id))
+    end
+
+    def type=(value)
+      ensure_valid!
+      Native.b2Body_SetType(@id, TYPE_VALUES.fetch(value) { raise ArgumentError, "invalid body type: #{value.inspect}" })
+    end
+
+    def position
+      ensure_valid!
+      ValueConversion.vec2(Native.b2Body_GetPosition(@id))
+    end
+
+    def position=(value)
+      ensure_valid!
+      Native.b2Body_SetTransform(@id, ValueConversion.native_vec2(value, label: "position"), Native.b2Body_GetRotation(@id))
+    end
+
+    def angle
+      ensure_valid!
+      rotation = Native.b2Body_GetRotation(@id)
+      Math.atan2(rotation[:s], rotation[:c])
+    end
+
+    def angle=(value)
+      ensure_valid!
+      Native.b2Body_SetTransform(@id, Native.b2Body_GetPosition(@id), ValueConversion.native_rot(value))
+    end
+
+    def linear_velocity
+      ensure_valid!
+      ValueConversion.vec2(Native.b2Body_GetLinearVelocity(@id))
+    end
+
+    def linear_velocity=(value)
+      ensure_valid!
+      Native.b2Body_SetLinearVelocity(@id, ValueConversion.native_vec2(value, label: "linear_velocity"))
+    end
+
+    def angular_velocity
+      ensure_valid!
+      Native.b2Body_GetAngularVelocity(@id)
+    end
+
+    def angular_velocity=(value)
+      ensure_valid!
+      Native.b2Body_SetAngularVelocity(@id, ValueConversion.finite_float(value, label: "angular_velocity"))
+    end
+
+    def apply_impulse(impulse, point: nil, wake: true)
+      ensure_valid!
+      native_impulse = ValueConversion.native_vec2(impulse, label: "impulse")
+      if point
+        Native.b2Body_ApplyLinearImpulse(@id, native_impulse, ValueConversion.native_vec2(point, label: "point"), !!wake)
+      else
+        Native.b2Body_ApplyLinearImpulseToCenter(@id, native_impulse, !!wake)
+      end
+      self
+    end
+
+    def apply_force(force, point: nil, wake: true)
+      ensure_valid!
+      native_force = ValueConversion.native_vec2(force, label: "force")
+      if point
+        Native.b2Body_ApplyForce(@id, native_force, ValueConversion.native_vec2(point, label: "point"), !!wake)
+      else
+        Native.b2Body_ApplyForceToCenter(@id, native_force, !!wake)
+      end
+      self
+    end
+
+    def apply_torque(torque, wake: true)
+      ensure_valid!
+      Native.b2Body_ApplyTorque(@id, ValueConversion.finite_float(torque, label: "torque"), !!wake)
+      self
+    end
+
+    def mass
+      ensure_valid!
+      Native.b2Body_GetMass(@id)
+    end
+
+    def awake?
+      ensure_valid!
+      Native.b2Body_IsAwake(@id)
+    end
+
+    def awake=(value)
+      ensure_valid!
+      Native.b2Body_SetAwake(@id, !!value)
+    end
+
+    def bullet?
+      ensure_valid!
+      Native.b2Body_IsBullet(@id)
+    end
+
+    def bullet=(value)
+      ensure_valid!
+      Native.b2Body_SetBullet(@id, !!value)
+    end
+
+    def user_data
+      ensure_valid!
+      @world.body_user_data(self)
+    end
+
+    def user_data=(value)
+      ensure_valid!
+      @world.set_body_user_data(self, value)
+    end
+
+    def unregister_shape(shape)
+      @shapes.delete(shape)
+    end
+
+    def unregister_chain(chain)
+      @chains.delete(chain)
+    end
+
+    def register_joint(joint)
+      @joints << joint
+      joint
+    end
+
+    def unregister_joint(joint)
+      @joints.delete(joint)
+    end
+
+    protected
+
+    def native_valid?
+      Native.b2Body_IsValid(@id)
+    end
+  end
+end

data/lib/box2d/body_definition.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Box2D
+  module BodyDefinition
+    private
+
+    def build_body_definition(type:, position:, angle:, options:)
+      definition = Native.b2DefaultBodyDef
+      definition[:type] = self.class::BODY_TYPES.fetch(type) do
+        raise ArgumentError, "invalid body type: #{type.inspect}"
+      end
+      definition[:position] = ValueConversion.native_vec2(position, label: "position")
+      definition[:rotation] = ValueConversion.native_rot(angle)
+      definition[:linearVelocity] = ValueConversion.native_vec2(
+        options.fetch(:linear_velocity, [0, 0]),
+        label: "linear_velocity"
+      )
+      definition[:angularVelocity] = ValueConversion.finite_float(
+        options.fetch(:angular_velocity, 0),
+        label: "angular_velocity"
+      )
+      definition[:linearDamping] = ValueConversion.non_negative_float(
+        options.fetch(:linear_damping, 0),
+        label: "linear_damping"
+      )
+      definition[:angularDamping] = ValueConversion.non_negative_float(
+        options.fetch(:angular_damping, 0),
+        label: "angular_damping"
+      )
+      definition[:gravityScale] = ValueConversion.finite_float(options.fetch(:gravity_scale, 1), label: "gravity_scale")
+      definition[:isBullet] = !!options.fetch(:bullet, false)
+      definition[:fixedRotation] = !!options.fetch(:fixed_rotation, false)
+      definition[:isAwake] = !!options.fetch(:awake, true)
+      definition[:enableSleep] = !!options.fetch(:sleep, true)
+      definition
+    end
+  end
+end

data/lib/box2d/body_shapes.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Box2D
+  module BodyShapes
+    def box(half_width, half_height, center: [0, 0], angle: 0, **options)
+      ensure_valid!
+      width = ValueConversion.positive_float(half_width, label: "half_width")
+      height = ValueConversion.positive_float(half_height, label: "half_height")
+      polygon = Native.b2MakeOffsetBox(
+        width,
+        height,
+        ValueConversion.native_vec2(center, label: "center"),
+        ValueConversion.native_rot(angle)
+      )
+      create_shape(:b2CreatePolygonShape, polygon, options)
+    end
+
+    def circle(radius:, center: [0, 0], **options)
+      ensure_valid!
+      geometry = Native::Circle.new
+      geometry[:center] = ValueConversion.native_vec2(center, label: "center")
+      geometry[:radius] = ValueConversion.positive_float(radius, label: "radius")
+      create_shape(:b2CreateCircleShape, geometry, options)
+    end
+
+    def capsule(point1, point2, radius:, **options)
+      ensure_valid!
+      geometry = Native::Capsule.new
+      geometry[:center1] = ValueConversion.native_vec2(point1, label: "point1")
+      geometry[:center2] = ValueConversion.native_vec2(point2, label: "point2")
+      geometry[:radius] = ValueConversion.positive_float(radius, label: "radius")
+      create_shape(:b2CreateCapsuleShape, geometry, options)
+    end
+
+    def polygon(points, radius: 0.0, **options)
+      ensure_valid!
+      point_buffer, count = native_points(points, minimum: 3, maximum: 8)
+      hull = Native.b2ComputeHull(point_buffer, count)
+      raise ArgumentError, "points do not form a valid convex hull" if hull[:count] < 3
+
+      polygon = Native.b2MakePolygon(
+        hull.pointer,
+        ValueConversion.non_negative_float(radius, label: "radius")
+      )
+      create_shape(:b2CreatePolygonShape, polygon, options)
+    end
+
+    def segment(point1, point2, **options)
+      ensure_valid!
+      geometry = Native::Segment.new
+      geometry[:point1] = ValueConversion.native_vec2(point1, label: "point1")
+      geometry[:point2] = ValueConversion.native_vec2(point2, label: "point2")
+      validate_separation!(geometry[:point1], geometry[:point2], label: "segment endpoints")
+      create_shape(:b2CreateSegmentShape, geometry, options)
+    end
+
+    def chain(points, loop: false, **options)
+      ensure_valid!
+      point_buffer, count = native_points(points, minimum: 4)
+      if loop
+        first = Native::Vec2.new(point_buffer)
+        last = Native::Vec2.new(point_buffer + (count - 1) * Native::Vec2.size)
+        validate_separation!(last, first, label: "loop endpoints")
+      end
+      definition = Native.b2DefaultChainDef
+      definition[:points] = point_buffer
+      definition[:count] = count
+      definition[:isLoop] = !!loop
+      definition[:enableSensorEvents] = !!options.fetch(:sensor_events, true)
+      ShapeDefinition.apply_filter(definition[:filter], options.fetch(:filter, {}))
+
+      material_buffer = FFI::MemoryPointer.new(Native::SurfaceMaterial)
+      material = Native.b2DefaultSurfaceMaterial
+      configure_material(material, options)
+      material_buffer.put_bytes(0, material.pointer.read_bytes(Native::SurfaceMaterial.size))
+      definition[:materials] = material_buffer
+      definition[:materialCount] = 1
+
+      native_id = Native.b2CreateChain(@id, definition.pointer)
+      chain = Chain.new(@world, native_id, body: self)
+      @chains << chain
+      @world.register_chain(chain)
+    end
+
+    private
+
+    def create_shape(function, geometry, options)
+      definition = ShapeDefinition.build(options)
+      native_id = Native.public_send(function, @id, definition.pointer, geometry.pointer)
+      shape = Shape.new(@world, native_id, body: self)
+      shape.user_data = options[:user_data] if options.key?(:user_data)
+      @shapes << shape
+      @world.register_shape(shape)
+    end
+
+    def native_points(points, minimum:, maximum: nil)
+      values = points.to_a
+      valid = values.length >= minimum && (!maximum || values.length <= maximum)
+      range = maximum ? "#{minimum}..#{maximum}" : "at least #{minimum}"
+      raise ArgumentError, "points must contain #{range} vertices" unless valid
+
+      pointer = FFI::MemoryPointer.new(Native::Vec2, values.length)
+      values.each_with_index do |point, index|
+        vector = ValueConversion.native_vec2(point, label: "points[#{index}]")
+        pointer.put_bytes(index * Native::Vec2.size, vector.pointer.read_bytes(Native::Vec2.size))
+      end
+      validate_chain_points!(pointer, values.length) if minimum >= 4
+      [pointer, values.length]
+    end
+
+    def validate_chain_points!(pointer, count)
+      points = Array.new(count) { |index| Native::Vec2.new(pointer + index * Native::Vec2.size) }
+      points.each_cons(2) { |point1, point2| validate_separation!(point1, point2, label: "adjacent chain points") }
+    end
+
+    def validate_separation!(point1, point2, label:)
+      minimum = 0.005 * Native.b2GetLengthUnitsPerMeter
+      distance_squared = (point2[:x] - point1[:x])**2 + (point2[:y] - point1[:y])**2
+      return if distance_squared > minimum**2
+
+      raise ArgumentError, "#{label} must be more than #{minimum} units apart"
+    end
+
+    def configure_material(material, options)
+      material[:friction] = ValueConversion.non_negative_float(options.fetch(:friction, 0.6), label: "friction")
+      material[:restitution] = ShapeDefinition.coefficient(options.fetch(:restitution, 0.0), "restitution")
+      material[:rollingResistance] = ShapeDefinition.coefficient(
+        options.fetch(:rolling_resistance, 0.0),
+        "rolling_resistance"
+      )
+      material[:tangentSpeed] = ValueConversion.finite_float(options.fetch(:tangent_speed, 0.0), label: "tangent_speed")
+      material[:userMaterialId] = Integer(options.fetch(:material, 0))
+    end
+  end
+end

data/lib/box2d/chain.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Box2D
+  class Chain < Handle
+    ID_CLASS = Native::ChainId
+
+    attr_reader :body
+
+    def initialize(world, id, body: nil)
+      super(world, id)
+      @body = body
+    end
+
+    def destroy
+      ensure_valid!
+      Native.b2DestroyChain(@id)
+      invalidate!
+      @world.unregister_chain(self)
+      @body&.unregister_chain(self)
+      true
+    end
+
+    def segments
+      ensure_valid!
+      count = Native.b2Chain_GetSegmentCount(@id)
+      pointer = FFI::MemoryPointer.new(Native::ShapeId, count)
+      actual = Native.b2Chain_GetSegments(@id, pointer, count)
+
+      Array.new(actual) do |index|
+        id = Native::ShapeId.new(pointer + index * Native::ShapeId.size)
+        @world.shape_for_id(id)
+      end
+    end
+
+    def friction
+      ensure_valid!
+      Native.b2Chain_GetFriction(@id)
+    end
+
+    def friction=(value)
+      ensure_valid!
+      Native.b2Chain_SetFriction(@id, ValueConversion.non_negative_float(value, label: "friction"))
+    end
+
+    def restitution
+      ensure_valid!
+      Native.b2Chain_GetRestitution(@id)
+    end
+
+    def restitution=(value)
+      ensure_valid!
+      Native.b2Chain_SetRestitution(@id, ShapeDefinition.coefficient(value, "restitution"))
+    end
+
+    protected
+
+    def native_valid?
+      Native.b2Chain_IsValid(@id)
+    end
+  end
+end

data/lib/box2d/debug_draw.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Box2D
+  class DebugDraw
+    FLAG_FIELDS = {
+      shapes: :drawShapes,
+      joints: :drawJoints,
+      joint_extras: :drawJointExtras,
+      aabbs: :drawBounds,
+      bounds: :drawBounds,
+      mass: :drawMass,
+      body_names: :drawBodyNames,
+      contacts: :drawContacts,
+      graph_colors: :drawGraphColors,
+      contact_normals: :drawContactNormals,
+      contact_impulses: :drawContactImpulses,
+      contact_features: :drawContactFeatures,
+      friction_impulses: :drawFrictionImpulses,
+      islands: :drawIslands
+    }.freeze
+
+    attr_reader :definition, :callbacks
+
+    def initialize(flags, &block)
+      @block = block
+      @error = nil
+      @definition = Native.b2DefaultDebugDraw
+      @callbacks = []
+      configure_flags(flags)
+      configure_callbacks
+    end
+
+    def raise_callback_error
+      raise @error if @error
+    end
+
+    private
+
+    def configure_flags(flags)
+      flags.each do |flag|
+        field = FLAG_FIELDS.fetch(flag) { raise ArgumentError, "unknown debug draw flag: #{flag.inspect}" }
+        @definition[field] = true
+      end
+    end
+
+    def configure_callbacks
+      callback(:DrawPolygonFcn, :void, [:pointer, :int, :int, :pointer]) do |vertices, count, color, _context|
+        emit([:polygon, points(vertices, count), color])
+      end
+      callback(
+        :DrawSolidPolygonFcn,
+        :void,
+        [Native::Transform.by_value, :pointer, :int, :float, :int, :pointer]
+      ) do |transform, vertices, count, radius, color, _context|
+        emit([:solid_polygon, transform_value(transform), points(vertices, count), radius, color])
+      end
+      callback(:DrawCircleFcn, :void, [Native::Vec2.by_value, :float, :int, :pointer]) do |center, radius, color, _context|
+        emit([:circle, ValueConversion.vec2(center), radius, color])
+      end
+      callback(
+        :DrawSolidCircleFcn,
+        :void,
+        [Native::Transform.by_value, :float, :int, :pointer]
+      ) do |transform, radius, color, _context|
+        emit([:solid_circle, transform_value(transform), radius, color])
+      end
+      callback(
+        :DrawSolidCapsuleFcn,
+        :void,
+        [Native::Vec2.by_value, Native::Vec2.by_value, :float, :int, :pointer]
+      ) do |point1, point2, radius, color, _context|
+        emit([:solid_capsule, ValueConversion.vec2(point1), ValueConversion.vec2(point2), radius, color])
+      end
+      callback(
+        :DrawSegmentFcn,
+        :void,
+        [Native::Vec2.by_value, Native::Vec2.by_value, :int, :pointer]
+      ) do |point1, point2, color, _context|
+        emit([:segment, ValueConversion.vec2(point1), ValueConversion.vec2(point2), color])
+      end
+      callback(:DrawTransformFcn, :void, [Native::Transform.by_value, :pointer]) do |transform, _context|
+        emit([:transform, transform_value(transform)])
+      end
+      callback(:DrawPointFcn, :void, [Native::Vec2.by_value, :float, :int, :pointer]) do |point, size, color, _context|
+        emit([:point, ValueConversion.vec2(point), size, color])
+      end
+      callback(:DrawStringFcn, :void, [Native::Vec2.by_value, :pointer, :int, :pointer]) do |point, string, color, _context|
+        emit([:string, ValueConversion.vec2(point), string.read_string, color])
+      end
+    end
+
+    def callback(field, result, arguments, &block)
+      function = FFI::Function.new(result, arguments, &block)
+      @callbacks << function
+      @definition[field] = function
+    end
+
+    def points(pointer, count)
+      Array.new(count) do |index|
+        ValueConversion.vec2(Native::Vec2.new(pointer + index * Native::Vec2.size))
+      end
+    end
+
+    def transform_value(transform)
+      rotation = transform[:q]
+      {
+        position: ValueConversion.vec2(transform[:p]),
+        angle: Math.atan2(rotation[:s], rotation[:c])
+      }
+    end
+
+    def emit(command)
+      @block.call(command)
+    rescue Exception => error
+      @error ||= error
+    end
+  end
+end

data/lib/box2d/events.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Box2D
+  ContactBegin = Data.define(:shape_a, :shape_b, :manifold)
+  ContactEnd = Data.define(:shape_a, :shape_b)
+  ContactHit = Data.define(:shape_a, :shape_b, :point, :normal, :approach_speed)
+  SensorBegin = Data.define(:sensor, :visitor)
+  SensorEnd = Data.define(:sensor, :visitor)
+  Manifold = Data.define(:normal, :points)
+  ManifoldPoint = Data.define(:point, :separation, :normal_impulse, :tangent_impulse, :persisted)
+
+  class Events
+    EMPTY = [].freeze
+
+    attr_reader :begin_contacts, :end_contacts, :hits, :sensor_begins, :sensor_ends
+
+    def self.empty
+      new(
+        begin_contacts: EMPTY,
+        end_contacts: EMPTY,
+        hits: EMPTY,
+        sensor_begins: EMPTY,
+        sensor_ends: EMPTY
+      )
+    end
+
+    def self.capture(world)
+      contact_events = Native.b2World_GetContactEvents(world.id)
+      sensor_events = Native.b2World_GetSensorEvents(world.id)
+      new(
+        begin_contacts: read_array(contact_events[:beginEvents], contact_events[:beginCount], Native::ContactBeginTouchEvent) do |event|
+          ContactBegin.new(
+            shape_a: world.shape_for_id(event[:shapeIdA]),
+            shape_b: world.shape_for_id(event[:shapeIdB]),
+            manifold: capture_manifold(event[:manifold])
+          )
+        end,
+        end_contacts: read_array(contact_events[:endEvents], contact_events[:endCount], Native::ContactEndTouchEvent) do |event|
+          ContactEnd.new(
+            shape_a: world.shape_for_id(event[:shapeIdA]),
+            shape_b: world.shape_for_id(event[:shapeIdB])
+          )
+        end,
+        hits: read_array(contact_events[:hitEvents], contact_events[:hitCount], Native::ContactHitEvent) do |event|
+          ContactHit.new(
+            shape_a: world.shape_for_id(event[:shapeIdA]),
+            shape_b: world.shape_for_id(event[:shapeIdB]),
+            point: ValueConversion.vec2(event[:point]),
+            normal: ValueConversion.vec2(event[:normal]),
+            approach_speed: event[:approachSpeed]
+          )
+        end,
+        sensor_begins: read_array(sensor_events[:beginEvents], sensor_events[:beginCount], Native::SensorBeginTouchEvent) do |event|
+          SensorBegin.new(
+            sensor: world.shape_for_id(event[:sensorShapeId]),
+            visitor: world.shape_for_id(event[:visitorShapeId])
+          )
+        end,
+        sensor_ends: read_array(sensor_events[:endEvents], sensor_events[:endCount], Native::SensorEndTouchEvent) do |event|
+          SensorEnd.new(
+            sensor: world.shape_for_id(event[:sensorShapeId]),
+            visitor: world.shape_for_id(event[:visitorShapeId])
+          )
+        end
+      )
+    end
+
+    def initialize(begin_contacts:, end_contacts:, hits:, sensor_begins:, sensor_ends:)
+      @begin_contacts = begin_contacts.freeze
+      @end_contacts = end_contacts.freeze
+      @hits = hits.freeze
+      @sensor_begins = sensor_begins.freeze
+      @sensor_ends = sensor_ends.freeze
+      freeze
+    end
+
+    class << self
+      private
+
+      def read_array(pointer, count, struct_class)
+        return [] if count.zero?
+
+        Array.new(count) do |index|
+          yield struct_class.new(pointer + index * struct_class.size)
+        end
+      end
+
+      def capture_manifold(manifold)
+        points = Array.new(manifold[:pointCount]) do |index|
+          point = Native::ManifoldPoint.new(manifold[:points].to_ptr + index * Native::ManifoldPoint.size)
+          ManifoldPoint.new(
+            point: ValueConversion.vec2(point[:point]),
+            separation: point[:separation],
+            normal_impulse: point[:normalImpulse],
+            tangent_impulse: point[:tangentImpulse],
+            persisted: point[:persisted]
+          )
+        end
+        Manifold.new(normal: ValueConversion.vec2(manifold[:normal]), points: points.freeze)
+      end
+    end
+  end
+end

data/lib/box2d/fixed_stepper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Box2D
+  class FixedStepper
+    attr_reader :step, :max_substeps
+
+    def initialize(hz: 60, max_substeps: 5)
+      frequency = ValueConversion.positive_float(hz, label: "hz")
+      @step = 1.0 / frequency
+      @max_substeps = Integer(max_substeps)
+      raise ArgumentError, "max_substeps must be greater than zero" unless @max_substeps.positive?
+
+      @accumulator = 0.0
+    end
+
+    def advance(delta_time)
+      raise ArgumentError, "a step block is required" unless block_given?
+
+      delta = ValueConversion.non_negative_float(delta_time, label: "delta_time")
+      @accumulator = [@accumulator + delta, @step * @max_substeps].min
+
+      steps = 0
+      epsilon = @step * 1e-12
+      while @accumulator + epsilon >= @step && steps < @max_substeps
+        yield @step
+        @accumulator -= @step
+        @accumulator = 0.0 if @accumulator.abs < epsilon
+        steps += 1
+      end
+
+      [@accumulator / @step, 1.0 - Float::EPSILON].min
+    end
+
+    def reset
+      @accumulator = 0.0
+      self
+    end
+  end
+end