box2d-bindings 0.1.0-arm64-darwin → 0.1.2-arm64-darwin

data/lib/box2d_math_inline_functions.rb

@@ -53,13 +53,14 @@ module Box2D
       [:Length, :b2Length, [Vec2.by_value], :float],
       [:Distance, :b2Distance, [Vec2.by_value, Vec2.by_value], :float],
       [:Normalize, :b2Normalize, [Vec2.by_value], Vec2.by_value],
+      [:IsNormalized, :b2IsNormalized, [Vec2.by_value], :bool],
       [:GetLengthAndNormalize, :b2GetLengthAndNormalize, [:pointer, Vec2.by_value], Vec2.by_value],
       [:NormalizeRot, :b2NormalizeRot, [Rot.by_value], Rot.by_value],
       [:IntegrateRotation, :b2IntegrateRotation, [Rot.by_value, :float], Rot.by_value],
       [:LengthSquared, :b2LengthSquared, [Vec2.by_value], :float],
       [:DistanceSquared, :b2DistanceSquared, [Vec2.by_value, Vec2.by_value], :float],
       [:MakeRot, :b2MakeRot, [:float], Rot.by_value],
-      [:IsNormalized, :b2IsNormalized, [Rot.by_value], :bool],
+      [:IsNormalizedRot, :b2IsNormalizedRot, [Rot.by_value], :bool],
       [:NLerp, :b2NLerp, [Rot.by_value, Rot.by_value, :float], Rot.by_value],
       [:ComputeAngularVelocity, :b2ComputeAngularVelocity, [Rot.by_value, Rot.by_value, :float], :float],
       [:Rot_GetAngle, :b2Rot_GetAngle, [Rot.by_value], :float],
@@ -83,6 +84,9 @@ module Box2D
       [:AABB_Center, :b2AABB_Center, [AABB.by_value], Vec2.by_value],
       [:AABB_Extents, :b2AABB_Extents, [AABB.by_value], Vec2.by_value],
       [:AABB_Union, :b2AABB_Union, [AABB.by_value, AABB.by_value], AABB.by_value],
+      [:AABB_Overlaps, :b2AABB_Overlaps, [AABB.by_value, AABB.by_value], :bool],
+      [:MakeAABB, :b2MakeAABB, [:pointer, :int, :float], AABB.by_value],
+      [:PlaneSeparation, :b2PlaneSeparation, [Plane.by_value, Vec2.by_value], :float],
     ]
     entries.each do |entry|
       api_name = if method_naming == :snake_case

data/lib/box2d_types.rb

@@ -14,11 +14,6 @@ module Box2D
 
   # Enum
 
-  MixingRule_mixAverage = 0
-  MixingRule_mixGeometricMean = 1
-  MixingRule_mixMultiply = 2
-  MixingRule_mixMinimum = 3
-  MixingRule_mixMaximum = 4
   BodyType_staticBody = 0
   BodyType_kinematicBody = 1
   BodyType_dynamicBody = 2
@@ -30,9 +25,9 @@ module Box2D
   ShapeType_chainSegmentShape = 4
   ShapeType_shapeTypeCount = 5
   JointType_distanceJoint = 0
-  JointType_motorJoint = 1
-  JointType_mouseJoint = 2
-  JointType_nullJoint = 3
+  JointType_filterJoint = 1
+  JointType_motorJoint = 2
+  JointType_mouseJoint = 3
   JointType_prismaticJoint = 4
   JointType_revoluteJoint = 5
   JointType_weldJoint = 6
@@ -188,7 +183,8 @@ module Box2D
   typedef :pointer, :b2TaskCallback
   typedef :pointer, :b2EnqueueTaskCallback
   typedef :pointer, :b2FinishTaskCallback
-  typedef :int, :b2MixingRule
+  typedef :pointer, :b2FrictionCallback
+  typedef :pointer, :b2RestitutionCallback
   typedef :int, :b2BodyType
   typedef :int, :b2ShapeType
   typedef :int, :b2JointType
@@ -196,6 +192,7 @@ module Box2D
   typedef :pointer, :b2PreSolveFcn
   typedef :pointer, :b2OverlapResultFcn
   typedef :pointer, :b2CastResultFcn
+  typedef :pointer, :b2PlaneResultFcn
   typedef :int, :b2HexColor
 
   # Struct
@@ -241,15 +238,15 @@ module Box2D
     layout(
       :gravity, Vec2,
       :restitutionThreshold, :float,
-      :contactPushSpeed, :float,
       :hitEventThreshold, :float,
       :contactHertz, :float,
       :contactDampingRatio, :float,
+      :maxContactPushSpeed, :float,
       :jointHertz, :float,
       :jointDampingRatio, :float,
       :maximumLinearSpeed, :float,
-      :frictionMixingRule, :int,
-      :restitutionMixingRule, :int,
+      :frictionCallback, :pointer,
+      :restitutionCallback, :pointer,
       :enableSleep, :bool,
       :enableContinuous, :bool,
       :workerCount, :int,
@@ -263,24 +260,24 @@ module Box2D
     def gravity=(v) self[:gravity] = v end
     def restitutionThreshold = self[:restitutionThreshold]
     def restitutionThreshold=(v) self[:restitutionThreshold] = v end
-    def contactPushSpeed = self[:contactPushSpeed]
-    def contactPushSpeed=(v) self[:contactPushSpeed] = v end
     def hitEventThreshold = self[:hitEventThreshold]
     def hitEventThreshold=(v) self[:hitEventThreshold] = v end
     def contactHertz = self[:contactHertz]
     def contactHertz=(v) self[:contactHertz] = v end
     def contactDampingRatio = self[:contactDampingRatio]
     def contactDampingRatio=(v) self[:contactDampingRatio] = v end
+    def maxContactPushSpeed = self[:maxContactPushSpeed]
+    def maxContactPushSpeed=(v) self[:maxContactPushSpeed] = v end
     def jointHertz = self[:jointHertz]
     def jointHertz=(v) self[:jointHertz] = v end
     def jointDampingRatio = self[:jointDampingRatio]
     def jointDampingRatio=(v) self[:jointDampingRatio] = v end
     def maximumLinearSpeed = self[:maximumLinearSpeed]
     def maximumLinearSpeed=(v) self[:maximumLinearSpeed] = v end
-    def frictionMixingRule = self[:frictionMixingRule]
-    def frictionMixingRule=(v) self[:frictionMixingRule] = v end
-    def restitutionMixingRule = self[:restitutionMixingRule]
-    def restitutionMixingRule=(v) self[:restitutionMixingRule] = v end
+    def frictionCallback = self[:frictionCallback]
+    def frictionCallback=(v) self[:frictionCallback] = v end
+    def restitutionCallback = self[:restitutionCallback]
+    def restitutionCallback=(v) self[:restitutionCallback] = v end
     def enableSleep = self[:enableSleep]
     def enableSleep=(v) self[:enableSleep] = v end
     def enableContinuous = self[:enableContinuous]
@@ -297,19 +294,19 @@ module Box2D
     def userData=(v) self[:userData] = v end
     def internalValue = self[:internalValue]
     def internalValue=(v) self[:internalValue] = v end
-    def self.create_as(_gravity_, _restitutionThreshold_, _contactPushSpeed_, _hitEventThreshold_, _contactHertz_, _contactDampingRatio_, _jointHertz_, _jointDampingRatio_, _maximumLinearSpeed_, _frictionMixingRule_, _restitutionMixingRule_, _enableSleep_, _enableContinuous_, _workerCount_, _enqueueTask_, _finishTask_, _userTaskContext_, _userData_, _internalValue_)
+    def self.create_as(_gravity_, _restitutionThreshold_, _hitEventThreshold_, _contactHertz_, _contactDampingRatio_, _maxContactPushSpeed_, _jointHertz_, _jointDampingRatio_, _maximumLinearSpeed_, _frictionCallback_, _restitutionCallback_, _enableSleep_, _enableContinuous_, _workerCount_, _enqueueTask_, _finishTask_, _userTaskContext_, _userData_, _internalValue_)
       instance = WorldDef.new
       instance[:gravity] = _gravity_
       instance[:restitutionThreshold] = _restitutionThreshold_
-      instance[:contactPushSpeed] = _contactPushSpeed_
       instance[:hitEventThreshold] = _hitEventThreshold_
       instance[:contactHertz] = _contactHertz_
       instance[:contactDampingRatio] = _contactDampingRatio_
+      instance[:maxContactPushSpeed] = _maxContactPushSpeed_
       instance[:jointHertz] = _jointHertz_
       instance[:jointDampingRatio] = _jointDampingRatio_
       instance[:maximumLinearSpeed] = _maximumLinearSpeed_
-      instance[:frictionMixingRule] = _frictionMixingRule_
-      instance[:restitutionMixingRule] = _restitutionMixingRule_
+      instance[:frictionCallback] = _frictionCallback_
+      instance[:restitutionCallback] = _restitutionCallback_
       instance[:enableSleep] = _enableSleep_
       instance[:enableContinuous] = _enableContinuous_
       instance[:workerCount] = _workerCount_
@@ -333,6 +330,7 @@ module Box2D
       :angularDamping, :float,
       :gravityScale, :float,
       :sleepThreshold, :float,
+      :name, :pointer,
       :userData, :pointer,
       :enableSleep, :bool,
       :isAwake, :bool,
@@ -360,6 +358,8 @@ module Box2D
     def gravityScale=(v) self[:gravityScale] = v end
     def sleepThreshold = self[:sleepThreshold]
     def sleepThreshold=(v) self[:sleepThreshold] = v end
+    def name = self[:name]
+    def name=(v) self[:name] = v end
     def userData = self[:userData]
     def userData=(v) self[:userData] = v end
     def enableSleep = self[:enableSleep]
@@ -376,7 +376,7 @@ module Box2D
     def allowFastRotation=(v) self[:allowFastRotation] = v end
     def internalValue = self[:internalValue]
     def internalValue=(v) self[:internalValue] = v end
-    def self.create_as(_type_, _position_, _rotation_, _linearVelocity_, _angularVelocity_, _linearDamping_, _angularDamping_, _gravityScale_, _sleepThreshold_, _userData_, _enableSleep_, _isAwake_, _fixedRotation_, _isBullet_, _isEnabled_, _allowFastRotation_, _internalValue_)
+    def self.create_as(_type_, _position_, _rotation_, _linearVelocity_, _angularVelocity_, _linearDamping_, _angularDamping_, _gravityScale_, _sleepThreshold_, _name_, _userData_, _enableSleep_, _isAwake_, _fixedRotation_, _isBullet_, _isEnabled_, _allowFastRotation_, _internalValue_)
       instance = BodyDef.new
       instance[:type] = _type_
       instance[:position] = _position_
@@ -387,6 +387,7 @@ module Box2D
       instance[:angularDamping] = _angularDamping_
       instance[:gravityScale] = _gravityScale_
       instance[:sleepThreshold] = _sleepThreshold_
+      instance[:name] = _name_
       instance[:userData] = _userData_
       instance[:enableSleep] = _enableSleep_
       instance[:isAwake] = _isAwake_
@@ -437,15 +438,45 @@ module Box2D
     end
   end
 
-  class ShapeDef < FFI::Struct
+  class SurfaceMaterial < FFI::Struct
     layout(
-      :userData, :pointer,
       :friction, :float,
       :restitution, :float,
       :rollingResistance, :float,
+      :tangentSpeed, :float,
+      :userMaterialId, :int,
+      :customColor, :uint,
+    )
+    def friction = self[:friction]
+    def friction=(v) self[:friction] = v end
+    def restitution = self[:restitution]
+    def restitution=(v) self[:restitution] = v end
+    def rollingResistance = self[:rollingResistance]
+    def rollingResistance=(v) self[:rollingResistance] = v end
+    def tangentSpeed = self[:tangentSpeed]
+    def tangentSpeed=(v) self[:tangentSpeed] = v end
+    def userMaterialId = self[:userMaterialId]
+    def userMaterialId=(v) self[:userMaterialId] = v end
+    def customColor = self[:customColor]
+    def customColor=(v) self[:customColor] = v end
+    def self.create_as(_friction_, _restitution_, _rollingResistance_, _tangentSpeed_, _userMaterialId_, _customColor_)
+      instance = SurfaceMaterial.new
+      instance[:friction] = _friction_
+      instance[:restitution] = _restitution_
+      instance[:rollingResistance] = _rollingResistance_
+      instance[:tangentSpeed] = _tangentSpeed_
+      instance[:userMaterialId] = _userMaterialId_
+      instance[:customColor] = _customColor_
+      instance
+    end
+  end
+
+  class ShapeDef < FFI::Struct
+    layout(
+      :userData, :pointer,
+      :material, SurfaceMaterial,
       :density, :float,
       :filter, Filter,
-      :customColor, :uint,
       :isSensor, :bool,
       :enableSensorEvents, :bool,
       :enableContactEvents, :bool,
@@ -457,18 +488,12 @@ module Box2D
     )
     def userData = self[:userData]
     def userData=(v) self[:userData] = v end
-    def friction = self[:friction]
-    def friction=(v) self[:friction] = v end
-    def restitution = self[:restitution]
-    def restitution=(v) self[:restitution] = v end
-    def rollingResistance = self[:rollingResistance]
-    def rollingResistance=(v) self[:rollingResistance] = v end
+    def material = self[:material]
+    def material=(v) self[:material] = v end
     def density = self[:density]
     def density=(v) self[:density] = v end
     def filter = self[:filter]
     def filter=(v) self[:filter] = v end
-    def customColor = self[:customColor]
-    def customColor=(v) self[:customColor] = v end
     def isSensor = self[:isSensor]
     def isSensor=(v) self[:isSensor] = v end
     def enableSensorEvents = self[:enableSensorEvents]
@@ -485,15 +510,12 @@ module Box2D
     def updateBodyMass=(v) self[:updateBodyMass] = v end
     def internalValue = self[:internalValue]
     def internalValue=(v) self[:internalValue] = v end
-    def self.create_as(_userData_, _friction_, _restitution_, _rollingResistance_, _density_, _filter_, _customColor_, _isSensor_, _enableSensorEvents_, _enableContactEvents_, _enableHitEvents_, _enablePreSolveEvents_, _invokeContactCreation_, _updateBodyMass_, _internalValue_)
+    def self.create_as(_userData_, _material_, _density_, _filter_, _isSensor_, _enableSensorEvents_, _enableContactEvents_, _enableHitEvents_, _enablePreSolveEvents_, _invokeContactCreation_, _updateBodyMass_, _internalValue_)
       instance = ShapeDef.new
       instance[:userData] = _userData_
-      instance[:friction] = _friction_
-      instance[:restitution] = _restitution_
-      instance[:rollingResistance] = _rollingResistance_
+      instance[:material] = _material_
       instance[:density] = _density_
       instance[:filter] = _filter_
-      instance[:customColor] = _customColor_
       instance[:isSensor] = _isSensor_
       instance[:enableSensorEvents] = _enableSensorEvents_
       instance[:enableContactEvents] = _enableContactEvents_
@@ -511,11 +533,11 @@ module Box2D
       :userData, :pointer,
       :points, :pointer,
       :count, :int,
-      :friction, :float,
-      :restitution, :float,
+      :materials, :pointer,
+      :materialCount, :int,
       :filter, Filter,
-      :customColor, :uint,
       :isLoop, :bool,
+      :enableSensorEvents, :bool,
       :internalValue, :int,
     )
     def userData = self[:userData]
@@ -524,28 +546,28 @@ module Box2D
     def points=(v) self[:points] = v end
     def count = self[:count]
     def count=(v) self[:count] = v end
-    def friction = self[:friction]
-    def friction=(v) self[:friction] = v end
-    def restitution = self[:restitution]
-    def restitution=(v) self[:restitution] = v end
+    def materials = self[:materials]
+    def materials=(v) self[:materials] = v end
+    def materialCount = self[:materialCount]
+    def materialCount=(v) self[:materialCount] = v end
     def filter = self[:filter]
     def filter=(v) self[:filter] = v end
-    def customColor = self[:customColor]
-    def customColor=(v) self[:customColor] = v end
     def isLoop = self[:isLoop]
     def isLoop=(v) self[:isLoop] = v end
+    def enableSensorEvents = self[:enableSensorEvents]
+    def enableSensorEvents=(v) self[:enableSensorEvents] = v end
     def internalValue = self[:internalValue]
     def internalValue=(v) self[:internalValue] = v end
-    def self.create_as(_userData_, _points_, _count_, _friction_, _restitution_, _filter_, _customColor_, _isLoop_, _internalValue_)
+    def self.create_as(_userData_, _points_, _count_, _materials_, _materialCount_, _filter_, _isLoop_, _enableSensorEvents_, _internalValue_)
       instance = ChainDef.new
       instance[:userData] = _userData_
       instance[:points] = _points_
       instance[:count] = _count_
-      instance[:friction] = _friction_
-      instance[:restitution] = _restitution_
+      instance[:materials] = _materials_
+      instance[:materialCount] = _materialCount_
       instance[:filter] = _filter_
-      instance[:customColor] = _customColor_
       instance[:isLoop] = _isLoop_
+      instance[:enableSensorEvents] = _enableSensorEvents_
       instance[:internalValue] = _internalValue_
       instance
     end
@@ -557,24 +579,24 @@ module Box2D
       :pairs, :float,
       :collide, :float,
       :solve, :float,
-      :buildIslands, :float,
+      :mergeIslands, :float,
+      :prepareStages, :float,
       :solveConstraints, :float,
-      :prepareTasks, :float,
-      :solverTasks, :float,
       :prepareConstraints, :float,
       :integrateVelocities, :float,
       :warmStart, :float,
-      :solveVelocities, :float,
+      :solveImpulses, :float,
       :integratePositions, :float,
-      :relaxVelocities, :float,
+      :relaxImpulses, :float,
       :applyRestitution, :float,
       :storeImpulses, :float,
-      :finalizeBodies, :float,
       :splitIslands, :float,
-      :sleepIslands, :float,
+      :transforms, :float,
       :hitEvents, :float,
-      :broadphase, :float,
-      :continuous, :float,
+      :refit, :float,
+      :bullets, :float,
+      :sleepIslands, :float,
+      :sensors, :float,
     )
     def step = self[:step]
     def step=(v) self[:step] = v end
@@ -584,66 +606,66 @@ module Box2D
     def collide=(v) self[:collide] = v end
     def solve = self[:solve]
     def solve=(v) self[:solve] = v end
-    def buildIslands = self[:buildIslands]
-    def buildIslands=(v) self[:buildIslands] = v end
+    def mergeIslands = self[:mergeIslands]
+    def mergeIslands=(v) self[:mergeIslands] = v end
+    def prepareStages = self[:prepareStages]
+    def prepareStages=(v) self[:prepareStages] = v end
     def solveConstraints = self[:solveConstraints]
     def solveConstraints=(v) self[:solveConstraints] = v end
-    def prepareTasks = self[:prepareTasks]
-    def prepareTasks=(v) self[:prepareTasks] = v end
-    def solverTasks = self[:solverTasks]
-    def solverTasks=(v) self[:solverTasks] = v end
     def prepareConstraints = self[:prepareConstraints]
     def prepareConstraints=(v) self[:prepareConstraints] = v end
     def integrateVelocities = self[:integrateVelocities]
     def integrateVelocities=(v) self[:integrateVelocities] = v end
     def warmStart = self[:warmStart]
     def warmStart=(v) self[:warmStart] = v end
-    def solveVelocities = self[:solveVelocities]
-    def solveVelocities=(v) self[:solveVelocities] = v end
+    def solveImpulses = self[:solveImpulses]
+    def solveImpulses=(v) self[:solveImpulses] = v end
     def integratePositions = self[:integratePositions]
     def integratePositions=(v) self[:integratePositions] = v end
-    def relaxVelocities = self[:relaxVelocities]
-    def relaxVelocities=(v) self[:relaxVelocities] = v end
+    def relaxImpulses = self[:relaxImpulses]
+    def relaxImpulses=(v) self[:relaxImpulses] = v end
     def applyRestitution = self[:applyRestitution]
     def applyRestitution=(v) self[:applyRestitution] = v end
     def storeImpulses = self[:storeImpulses]
     def storeImpulses=(v) self[:storeImpulses] = v end
-    def finalizeBodies = self[:finalizeBodies]
-    def finalizeBodies=(v) self[:finalizeBodies] = v end
     def splitIslands = self[:splitIslands]
     def splitIslands=(v) self[:splitIslands] = v end
-    def sleepIslands = self[:sleepIslands]
-    def sleepIslands=(v) self[:sleepIslands] = v end
+    def transforms = self[:transforms]
+    def transforms=(v) self[:transforms] = v end
     def hitEvents = self[:hitEvents]
     def hitEvents=(v) self[:hitEvents] = v end
-    def broadphase = self[:broadphase]
-    def broadphase=(v) self[:broadphase] = v end
-    def continuous = self[:continuous]
-    def continuous=(v) self[:continuous] = v end
-    def self.create_as(_step_, _pairs_, _collide_, _solve_, _buildIslands_, _solveConstraints_, _prepareTasks_, _solverTasks_, _prepareConstraints_, _integrateVelocities_, _warmStart_, _solveVelocities_, _integratePositions_, _relaxVelocities_, _applyRestitution_, _storeImpulses_, _finalizeBodies_, _splitIslands_, _sleepIslands_, _hitEvents_, _broadphase_, _continuous_)
+    def refit = self[:refit]
+    def refit=(v) self[:refit] = v end
+    def bullets = self[:bullets]
+    def bullets=(v) self[:bullets] = v end
+    def sleepIslands = self[:sleepIslands]
+    def sleepIslands=(v) self[:sleepIslands] = v end
+    def sensors = self[:sensors]
+    def sensors=(v) self[:sensors] = v end
+    def self.create_as(_step_, _pairs_, _collide_, _solve_, _mergeIslands_, _prepareStages_, _solveConstraints_, _prepareConstraints_, _integrateVelocities_, _warmStart_, _solveImpulses_, _integratePositions_, _relaxImpulses_, _applyRestitution_, _storeImpulses_, _splitIslands_, _transforms_, _hitEvents_, _refit_, _bullets_, _sleepIslands_, _sensors_)
       instance = Profile.new
       instance[:step] = _step_
       instance[:pairs] = _pairs_
       instance[:collide] = _collide_
       instance[:solve] = _solve_
-      instance[:buildIslands] = _buildIslands_
+      instance[:mergeIslands] = _mergeIslands_
+      instance[:prepareStages] = _prepareStages_
       instance[:solveConstraints] = _solveConstraints_
-      instance[:prepareTasks] = _prepareTasks_
-      instance[:solverTasks] = _solverTasks_
       instance[:prepareConstraints] = _prepareConstraints_
       instance[:integrateVelocities] = _integrateVelocities_
       instance[:warmStart] = _warmStart_
-      instance[:solveVelocities] = _solveVelocities_
+      instance[:solveImpulses] = _solveImpulses_
       instance[:integratePositions] = _integratePositions_
-      instance[:relaxVelocities] = _relaxVelocities_
+      instance[:relaxImpulses] = _relaxImpulses_
       instance[:applyRestitution] = _applyRestitution_
       instance[:storeImpulses] = _storeImpulses_
-      instance[:finalizeBodies] = _finalizeBodies_
       instance[:splitIslands] = _splitIslands_
-      instance[:sleepIslands] = _sleepIslands_
+      instance[:transforms] = _transforms_
       instance[:hitEvents] = _hitEvents_
-      instance[:broadphase] = _broadphase_
-      instance[:continuous] = _continuous_
+      instance[:refit] = _refit_
+      instance[:bullets] = _bullets_
+      instance[:sleepIslands] = _sleepIslands_
+      instance[:sensors] = _sensors_
       instance
     end
   end
@@ -872,7 +894,7 @@ module Box2D
     end
   end
 
-  class NullJointDef < FFI::Struct
+  class FilterJointDef < FFI::Struct
     layout(
       :bodyIdA, BodyId,
       :bodyIdB, BodyId,
@@ -888,7 +910,7 @@ module Box2D
     def internalValue = self[:internalValue]
     def internalValue=(v) self[:internalValue] = v end
     def self.create_as(_bodyIdA_, _bodyIdB_, _userData_, _internalValue_)
-      instance = NullJointDef.new
+      instance = FilterJointDef.new
       instance[:bodyIdA] = _bodyIdA_
       instance[:bodyIdB] = _bodyIdB_
       instance[:userData] = _userData_
@@ -1446,47 +1468,50 @@ module Box2D
 
   class DebugDraw < FFI::Struct
     layout(
-      :DrawPolygon, :pointer,
-      :DrawSolidPolygon, :pointer,
-      :DrawCircle, :pointer,
-      :DrawSolidCircle, :pointer,
-      :DrawSolidCapsule, :pointer,
-      :DrawSegment, :pointer,
-      :DrawTransform, :pointer,
-      :DrawPoint, :pointer,
-      :DrawString, :pointer,
+      :DrawPolygonFcn, :pointer,
+      :DrawSolidPolygonFcn, :pointer,
+      :DrawCircleFcn, :pointer,
+      :DrawSolidCircleFcn, :pointer,
+      :DrawSolidCapsuleFcn, :pointer,
+      :DrawSegmentFcn, :pointer,
+      :DrawTransformFcn, :pointer,
+      :DrawPointFcn, :pointer,
+      :DrawStringFcn, :pointer,
       :drawingBounds, AABB,
       :useDrawingBounds, :bool,
       :drawShapes, :bool,
       :drawJoints, :bool,
       :drawJointExtras, :bool,
-      :drawAABBs, :bool,
+      :drawBounds, :bool,
       :drawMass, :bool,
+      :drawBodyNames, :bool,
       :drawContacts, :bool,
       :drawGraphColors, :bool,
       :drawContactNormals, :bool,
       :drawContactImpulses, :bool,
+      :drawContactFeatures, :bool,
       :drawFrictionImpulses, :bool,
+      :drawIslands, :bool,
       :context, :pointer,
     )
-    def DrawPolygon = self[:DrawPolygon]
-    def DrawPolygon=(v) self[:DrawPolygon] = v end
-    def DrawSolidPolygon = self[:DrawSolidPolygon]
-    def DrawSolidPolygon=(v) self[:DrawSolidPolygon] = v end
-    def DrawCircle = self[:DrawCircle]
-    def DrawCircle=(v) self[:DrawCircle] = v end
-    def DrawSolidCircle = self[:DrawSolidCircle]
-    def DrawSolidCircle=(v) self[:DrawSolidCircle] = v end
-    def DrawSolidCapsule = self[:DrawSolidCapsule]
-    def DrawSolidCapsule=(v) self[:DrawSolidCapsule] = v end
-    def DrawSegment = self[:DrawSegment]
-    def DrawSegment=(v) self[:DrawSegment] = v end
-    def DrawTransform = self[:DrawTransform]
-    def DrawTransform=(v) self[:DrawTransform] = v end
-    def DrawPoint = self[:DrawPoint]
-    def DrawPoint=(v) self[:DrawPoint] = v end
-    def DrawString = self[:DrawString]
-    def DrawString=(v) self[:DrawString] = v end
+    def DrawPolygonFcn = self[:DrawPolygonFcn]
+    def DrawPolygonFcn=(v) self[:DrawPolygonFcn] = v end
+    def DrawSolidPolygonFcn = self[:DrawSolidPolygonFcn]
+    def DrawSolidPolygonFcn=(v) self[:DrawSolidPolygonFcn] = v end
+    def DrawCircleFcn = self[:DrawCircleFcn]
+    def DrawCircleFcn=(v) self[:DrawCircleFcn] = v end
+    def DrawSolidCircleFcn = self[:DrawSolidCircleFcn]
+    def DrawSolidCircleFcn=(v) self[:DrawSolidCircleFcn] = v end
+    def DrawSolidCapsuleFcn = self[:DrawSolidCapsuleFcn]
+    def DrawSolidCapsuleFcn=(v) self[:DrawSolidCapsuleFcn] = v end
+    def DrawSegmentFcn = self[:DrawSegmentFcn]
+    def DrawSegmentFcn=(v) self[:DrawSegmentFcn] = v end
+    def DrawTransformFcn = self[:DrawTransformFcn]
+    def DrawTransformFcn=(v) self[:DrawTransformFcn] = v end
+    def DrawPointFcn = self[:DrawPointFcn]
+    def DrawPointFcn=(v) self[:DrawPointFcn] = v end
+    def DrawStringFcn = self[:DrawStringFcn]
+    def DrawStringFcn=(v) self[:DrawStringFcn] = v end
     def drawingBounds = self[:drawingBounds]
     def drawingBounds=(v) self[:drawingBounds] = v end
     def useDrawingBounds = self[:useDrawingBounds]
@@ -1497,10 +1522,12 @@ module Box2D
     def drawJoints=(v) self[:drawJoints] = v end
     def drawJointExtras = self[:drawJointExtras]
     def drawJointExtras=(v) self[:drawJointExtras] = v end
-    def drawAABBs = self[:drawAABBs]
-    def drawAABBs=(v) self[:drawAABBs] = v end
+    def drawBounds = self[:drawBounds]
+    def drawBounds=(v) self[:drawBounds] = v end
     def drawMass = self[:drawMass]
     def drawMass=(v) self[:drawMass] = v end
+    def drawBodyNames = self[:drawBodyNames]
+    def drawBodyNames=(v) self[:drawBodyNames] = v end
     def drawContacts = self[:drawContacts]
     def drawContacts=(v) self[:drawContacts] = v end
     def drawGraphColors = self[:drawGraphColors]
@@ -1509,33 +1536,40 @@ module Box2D
     def drawContactNormals=(v) self[:drawContactNormals] = v end
     def drawContactImpulses = self[:drawContactImpulses]
     def drawContactImpulses=(v) self[:drawContactImpulses] = v end
+    def drawContactFeatures = self[:drawContactFeatures]
+    def drawContactFeatures=(v) self[:drawContactFeatures] = v end
     def drawFrictionImpulses = self[:drawFrictionImpulses]
     def drawFrictionImpulses=(v) self[:drawFrictionImpulses] = v end
+    def drawIslands = self[:drawIslands]
+    def drawIslands=(v) self[:drawIslands] = v end
     def context = self[:context]
     def context=(v) self[:context] = v end
-    def self.create_as(_DrawPolygon_, _DrawSolidPolygon_, _DrawCircle_, _DrawSolidCircle_, _DrawSolidCapsule_, _DrawSegment_, _DrawTransform_, _DrawPoint_, _DrawString_, _drawingBounds_, _useDrawingBounds_, _drawShapes_, _drawJoints_, _drawJointExtras_, _drawAABBs_, _drawMass_, _drawContacts_, _drawGraphColors_, _drawContactNormals_, _drawContactImpulses_, _drawFrictionImpulses_, _context_)
+    def self.create_as(_DrawPolygonFcn_, _DrawSolidPolygonFcn_, _DrawCircleFcn_, _DrawSolidCircleFcn_, _DrawSolidCapsuleFcn_, _DrawSegmentFcn_, _DrawTransformFcn_, _DrawPointFcn_, _DrawStringFcn_, _drawingBounds_, _useDrawingBounds_, _drawShapes_, _drawJoints_, _drawJointExtras_, _drawBounds_, _drawMass_, _drawBodyNames_, _drawContacts_, _drawGraphColors_, _drawContactNormals_, _drawContactImpulses_, _drawContactFeatures_, _drawFrictionImpulses_, _drawIslands_, _context_)
       instance = DebugDraw.new
-      instance[:DrawPolygon] = _DrawPolygon_
-      instance[:DrawSolidPolygon] = _DrawSolidPolygon_
-      instance[:DrawCircle] = _DrawCircle_
-      instance[:DrawSolidCircle] = _DrawSolidCircle_
-      instance[:DrawSolidCapsule] = _DrawSolidCapsule_
-      instance[:DrawSegment] = _DrawSegment_
-      instance[:DrawTransform] = _DrawTransform_
-      instance[:DrawPoint] = _DrawPoint_
-      instance[:DrawString] = _DrawString_
+      instance[:DrawPolygonFcn] = _DrawPolygonFcn_
+      instance[:DrawSolidPolygonFcn] = _DrawSolidPolygonFcn_
+      instance[:DrawCircleFcn] = _DrawCircleFcn_
+      instance[:DrawSolidCircleFcn] = _DrawSolidCircleFcn_
+      instance[:DrawSolidCapsuleFcn] = _DrawSolidCapsuleFcn_
+      instance[:DrawSegmentFcn] = _DrawSegmentFcn_
+      instance[:DrawTransformFcn] = _DrawTransformFcn_
+      instance[:DrawPointFcn] = _DrawPointFcn_
+      instance[:DrawStringFcn] = _DrawStringFcn_
       instance[:drawingBounds] = _drawingBounds_
       instance[:useDrawingBounds] = _useDrawingBounds_
       instance[:drawShapes] = _drawShapes_
       instance[:drawJoints] = _drawJoints_
       instance[:drawJointExtras] = _drawJointExtras_
-      instance[:drawAABBs] = _drawAABBs_
+      instance[:drawBounds] = _drawBounds_
       instance[:drawMass] = _drawMass_
+      instance[:drawBodyNames] = _drawBodyNames_
       instance[:drawContacts] = _drawContacts_
       instance[:drawGraphColors] = _drawGraphColors_
       instance[:drawContactNormals] = _drawContactNormals_
       instance[:drawContactImpulses] = _drawContactImpulses_
+      instance[:drawContactFeatures] = _drawContactFeatures_
       instance[:drawFrictionImpulses] = _drawFrictionImpulses_
+      instance[:drawIslands] = _drawIslands_
       instance[:context] = _context_
       instance
     end
@@ -1550,12 +1584,13 @@ module Box2D
       [:DefaultBodyDef, :b2DefaultBodyDef, [], BodyDef.by_value],
       [:DefaultFilter, :b2DefaultFilter, [], Filter.by_value],
       [:DefaultQueryFilter, :b2DefaultQueryFilter, [], QueryFilter.by_value],
+      [:DefaultSurfaceMaterial, :b2DefaultSurfaceMaterial, [], SurfaceMaterial.by_value],
       [:DefaultShapeDef, :b2DefaultShapeDef, [], ShapeDef.by_value],
       [:DefaultChainDef, :b2DefaultChainDef, [], ChainDef.by_value],
       [:DefaultDistanceJointDef, :b2DefaultDistanceJointDef, [], DistanceJointDef.by_value],
       [:DefaultMotorJointDef, :b2DefaultMotorJointDef, [], MotorJointDef.by_value],
       [:DefaultMouseJointDef, :b2DefaultMouseJointDef, [], MouseJointDef.by_value],
-      [:DefaultNullJointDef, :b2DefaultNullJointDef, [], NullJointDef.by_value],
+      [:DefaultFilterJointDef, :b2DefaultFilterJointDef, [], FilterJointDef.by_value],
       [:DefaultPrismaticJointDef, :b2DefaultPrismaticJointDef, [], PrismaticJointDef.by_value],
       [:DefaultRevoluteJointDef, :b2DefaultRevoluteJointDef, [], RevoluteJointDef.by_value],
       [:DefaultWeldJointDef, :b2DefaultWeldJointDef, [], WeldJointDef.by_value],

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: box2d-bindings
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: arm64-darwin
 authors:
 - vaiorabbit
 bindir: bin
 cert_chain: []
-date: 2025-01-01 00:00:00.000000000 Z
+date: 2025-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -38,7 +38,6 @@ files:
 - lib/box2d.rb
 - lib/box2d_base.rb
 - lib/box2d_collision.rb
-- lib/box2d_collision_inline.rb
 - lib/box2d_helper.rb
 - lib/box2d_id.rb
 - lib/box2d_id_inline.rb
@@ -65,7 +64,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.5
 specification_version: 4
 summary: Ruby bindings for Box2D
 test_files: []