box2d-bindings 0.1.0-x64-mingw → 0.1.1-x64-mingw

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ee8b757648eafbe65a258a04e611597d61bf16f9195321edf2027767f0c9355
-  data.tar.gz: ca62b982d7f4e3612b840b01b06df2549d3a5d141d995bba3919a8511c3bf4d4
+  metadata.gz: 1f20e70889c5e4d28e9ba14dc0a2173fe65c3b983d4ee55fa44d6ab161d52576
+  data.tar.gz: b41b9bf3e4ccc751172d84542c3fc37349a5d2d56e2e50c724d6054cade03312
 SHA512:
-  metadata.gz: 8780f8d8cb56ed33e2c72e0b16d9d1284b9f810dbeb2f4097bbe44abd139f1cb16f2ed55fb20cf3f51ce38bedbc2df555872f1f9aeff61c3083841d4106cbd5a
-  data.tar.gz: e9e415647390acf98025b8a489b6bb828ac24a7c4e27035eeb3834f18ceba4f84d1b0440b2872e820790500de5acc3ce5368d317ac563471d9ee5c70f593ac13
+  metadata.gz: c67c2c3ecb7f0d9328f38a566ca860b59ae8bd24e76444102cf49993920c900989c30d2e88873f2e54d1f11712c2f379f0fa9d86c8e30dfa4b2a3a590a9a54ee
+  data.tar.gz: 9765c2058a165717f2a3deaa12d27cf9d11786c0946f745ced2fa655c95fbdffe86fa61a48c2e3951c2b219ec1e55edc79959e632a3c39ff925f9979a679a500

data/ChangeLog

@@ -1,3 +1,9 @@
+2025-02-01  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* https://github.com/erincatto/box2d/commit/28adacf82377d4113f2ed00586141463244b9d10
+	* Updated the helper function to use the latest version of Box2D.
+	* Added sample_compound.rb
+
 2024-12-29  vaiorabbit  <http://twitter.com/vaiorabbit>
 
 	* Added sample_softbody.rb

data/README.md

@@ -3,7 +3,7 @@
 # Box2D bindings for Ruby #
 
 *   Created : 2024-08-18
-*   Last modified : 2025-01-01
+*   Last modified : 2025-02-01
 
 Provides Ruby bindings for Box2D
 *   https://box2d.org

data/lib/box2d.rb

@@ -9,7 +9,6 @@ require_relative 'box2d_math_inline_functions.rb'
 require_relative 'box2d_id.rb'
 require_relative 'box2d_id_inline.rb'
 require_relative 'box2d_collision.rb'
-require_relative 'box2d_collision_inline.rb'
 require_relative 'box2d_types.rb'
 require_relative 'box2d_main.rb'
 require_relative 'box2d_helper.rb'
@@ -42,7 +41,6 @@ module Box2D
     setup_id_symbols(method_naming: method_naming)
     setup_id_inline_symbols(method_naming: method_naming)
     setup_collision_symbols(method_naming: method_naming)
-    setup_collision_inline_symbols(method_naming: method_naming)
     setup_types_symbols(method_naming: method_naming)
     setup_main_symbols(method_naming: method_naming)
   end

data/lib/box2d_base.rb

@@ -44,19 +44,6 @@ module Box2D
     end
   end
 
-  class Timer < FFI::Struct
-    layout(
-      :start, :long_long,
-    )
-    def start = self[:start]
-    def start=(v) self[:start] = v end
-    def self.create_as(_start_)
-      instance = Timer.new
-      instance[:start] = _start_
-      instance
-    end
-  end
-
 
   # Function
 
@@ -67,11 +54,9 @@ module Box2D
       [:SetAssertFcn, :b2SetAssertFcn, [:pointer], :void],
       [:InternalAssertFcn, :b2InternalAssertFcn, [:pointer, :pointer, :int], :int],
       [:GetVersion, :b2GetVersion, [], Version.by_value],
-      [:CreateTimer, :b2CreateTimer, [], Timer.by_value],
-      [:GetTicks, :b2GetTicks, [:pointer], :long_long],
-      [:GetMilliseconds, :b2GetMilliseconds, [:pointer], :float],
+      [:GetTicks, :b2GetTicks, [], :ulong_long],
+      [:GetMilliseconds, :b2GetMilliseconds, [:ulong_long], :float],
       [:GetMillisecondsAndReset, :b2GetMillisecondsAndReset, [:pointer], :float],
-      [:SleepMilliseconds, :b2SleepMilliseconds, [:int], :void],
       [:Yield, :b2Yield, [], :void],
       [:Hash, :b2Hash, [:uint, :pointer, :int], :uint],
     ]

data/lib/box2d_collision.rb

@@ -654,20 +654,24 @@ module Box2D
 
   class Manifold < FFI::Struct
     layout(
-      :points, [ManifoldPoint, 2],
       :normal, Vec2,
+      :rollingImpulse, :float,
+      :points, [ManifoldPoint, 2],
       :pointCount, :int,
     )
-    def points = self[:points]
-    def points=(v) self[:points] = v end
     def normal = self[:normal]
     def normal=(v) self[:normal] = v end
+    def rollingImpulse = self[:rollingImpulse]
+    def rollingImpulse=(v) self[:rollingImpulse] = v end
+    def points = self[:points]
+    def points=(v) self[:points] = v end
     def pointCount = self[:pointCount]
     def pointCount=(v) self[:pointCount] = v end
-    def self.create_as(_points_, _normal_, _pointCount_)
+    def self.create_as(_normal_, _rollingImpulse_, _points_, _pointCount_)
       instance = Manifold.new
-      instance[:points] = _points_
       instance[:normal] = _normal_
+      instance[:rollingImpulse] = _rollingImpulse_
+      instance[:points] = _points_
       instance[:pointCount] = _pointCount_
       instance
     end
@@ -805,12 +809,15 @@ module Box2D
       [:DynamicTree_Query, :b2DynamicTree_Query, [:pointer, AABB.by_value, :ulong_long, :pointer, :pointer], TreeStats.by_value],
       [:DynamicTree_RayCast, :b2DynamicTree_RayCast, [:pointer, :pointer, :ulong_long, :pointer, :pointer], TreeStats.by_value],
       [:DynamicTree_ShapeCast, :b2DynamicTree_ShapeCast, [:pointer, :pointer, :ulong_long, :pointer, :pointer], TreeStats.by_value],
-      [:DynamicTree_Validate, :b2DynamicTree_Validate, [:pointer], :void],
       [:DynamicTree_GetHeight, :b2DynamicTree_GetHeight, [:pointer], :int],
       [:DynamicTree_GetAreaRatio, :b2DynamicTree_GetAreaRatio, [:pointer], :float],
       [:DynamicTree_GetProxyCount, :b2DynamicTree_GetProxyCount, [:pointer], :int],
       [:DynamicTree_Rebuild, :b2DynamicTree_Rebuild, [:pointer, :bool], :int],
       [:DynamicTree_GetByteCount, :b2DynamicTree_GetByteCount, [:pointer], :int],
+      [:DynamicTree_GetUserData, :b2DynamicTree_GetUserData, [:pointer, :int], :int],
+      [:DynamicTree_GetAABB, :b2DynamicTree_GetAABB, [:pointer, :int], AABB.by_value],
+      [:DynamicTree_Validate, :b2DynamicTree_Validate, [:pointer], :void],
+      [:DynamicTree_ValidateNoEnlarged, :b2DynamicTree_ValidateNoEnlarged, [:pointer], :void],
     ]
     entries.each do |entry|
       api_name = if method_naming == :snake_case

data/lib/box2d_helper.rb

@@ -24,7 +24,7 @@ module Box2D
   end
 
   def self.id_equals(id1, id2)
-    id1.index1 == id2.index1 && id1.world0 == id2.world0 && id1.revision == id2.revision
+    id1.index1 == id2.index1 && id1.world0 == id2.world0 && id1.generation == id2.generation
   end
 
   #

data/lib/box2d_id.rb

@@ -22,16 +22,16 @@ module Box2D
   class WorldId < FFI::Struct
     layout(
       :index1, :ushort,
-      :revision, :ushort,
+      :generation, :ushort,
     )
     def index1 = self[:index1]
     def index1=(v) self[:index1] = v end
-    def revision = self[:revision]
-    def revision=(v) self[:revision] = v end
-    def self.create_as(_index1_, _revision_)
+    def generation = self[:generation]
+    def generation=(v) self[:generation] = v end
+    def self.create_as(_index1_, _generation_)
       instance = WorldId.new
       instance[:index1] = _index1_
-      instance[:revision] = _revision_
+      instance[:generation] = _generation_
       instance
     end
   end
@@ -40,19 +40,19 @@ module Box2D
     layout(
       :index1, :int,
       :world0, :ushort,
-      :revision, :ushort,
+      :generation, :ushort,
     )
     def index1 = self[:index1]
     def index1=(v) self[:index1] = v end
     def world0 = self[:world0]
     def world0=(v) self[:world0] = v end
-    def revision = self[:revision]
-    def revision=(v) self[:revision] = v end
-    def self.create_as(_index1_, _world0_, _revision_)
+    def generation = self[:generation]
+    def generation=(v) self[:generation] = v end
+    def self.create_as(_index1_, _world0_, _generation_)
       instance = BodyId.new
       instance[:index1] = _index1_
       instance[:world0] = _world0_
-      instance[:revision] = _revision_
+      instance[:generation] = _generation_
       instance
     end
   end
@@ -61,19 +61,19 @@ module Box2D
     layout(
       :index1, :int,
       :world0, :ushort,
-      :revision, :ushort,
+      :generation, :ushort,
     )
     def index1 = self[:index1]
     def index1=(v) self[:index1] = v end
     def world0 = self[:world0]
     def world0=(v) self[:world0] = v end
-    def revision = self[:revision]
-    def revision=(v) self[:revision] = v end
-    def self.create_as(_index1_, _world0_, _revision_)
+    def generation = self[:generation]
+    def generation=(v) self[:generation] = v end
+    def self.create_as(_index1_, _world0_, _generation_)
       instance = ShapeId.new
       instance[:index1] = _index1_
       instance[:world0] = _world0_
-      instance[:revision] = _revision_
+      instance[:generation] = _generation_
       instance
     end
   end
@@ -82,19 +82,19 @@ module Box2D
     layout(
       :index1, :int,
       :world0, :ushort,
-      :revision, :ushort,
+      :generation, :ushort,
     )
     def index1 = self[:index1]
     def index1=(v) self[:index1] = v end
     def world0 = self[:world0]
     def world0=(v) self[:world0] = v end
-    def revision = self[:revision]
-    def revision=(v) self[:revision] = v end
-    def self.create_as(_index1_, _world0_, _revision_)
+    def generation = self[:generation]
+    def generation=(v) self[:generation] = v end
+    def self.create_as(_index1_, _world0_, _generation_)
       instance = ChainId.new
       instance[:index1] = _index1_
       instance[:world0] = _world0_
-      instance[:revision] = _revision_
+      instance[:generation] = _generation_
       instance
     end
   end
@@ -103,19 +103,19 @@ module Box2D
     layout(
       :index1, :int,
       :world0, :ushort,
-      :revision, :ushort,
+      :generation, :ushort,
     )
     def index1 = self[:index1]
     def index1=(v) self[:index1] = v end
     def world0 = self[:world0]
     def world0=(v) self[:world0] = v end
-    def revision = self[:revision]
-    def revision=(v) self[:revision] = v end
-    def self.create_as(_index1_, _world0_, _revision_)
+    def generation = self[:generation]
+    def generation=(v) self[:generation] = v end
+    def self.create_as(_index1_, _world0_, _generation_)
       instance = JointId.new
       instance[:index1] = _index1_
       instance[:world0] = _world0_
-      instance[:revision] = _revision_
+      instance[:generation] = _generation_
       instance
     end
   end

data/lib/box2d_main.rb

@@ -66,6 +66,8 @@ module Box2D
       [:World_GetCounters, :b2World_GetCounters, [WorldId.by_value], Counters.by_value],
       [:World_SetUserData, :b2World_SetUserData, [WorldId.by_value, :pointer], :void],
       [:World_GetUserData, :b2World_GetUserData, [WorldId.by_value], :pointer],
+      [:World_SetFrictionCallback, :b2World_SetFrictionCallback, [WorldId.by_value, :pointer], :void],
+      [:World_SetRestitutionCallback, :b2World_SetRestitutionCallback, [WorldId.by_value, :pointer], :void],
       [:World_DumpMemoryStats, :b2World_DumpMemoryStats, [WorldId.by_value], :void],
       [:World_RebuildStaticTree, :b2World_RebuildStaticTree, [WorldId.by_value], :void],
       [:World_EnableSpeculative, :b2World_EnableSpeculative, [WorldId.by_value, :bool], :void],
@@ -74,6 +76,8 @@ module Box2D
       [:Body_IsValid, :b2Body_IsValid, [BodyId.by_value], :bool],
       [:Body_GetType, :b2Body_GetType, [BodyId.by_value], :int],
       [:Body_SetType, :b2Body_SetType, [BodyId.by_value, :int], :void],
+      [:Body_SetName, :b2Body_SetName, [BodyId.by_value, :pointer], :void],
+      [:Body_GetName, :b2Body_GetName, [BodyId.by_value], :pointer],
       [:Body_SetUserData, :b2Body_SetUserData, [BodyId.by_value, :pointer], :void],
       [:Body_GetUserData, :b2Body_GetUserData, [BodyId.by_value], :pointer],
       [:Body_GetPosition, :b2Body_GetPosition, [BodyId.by_value], Vec2.by_value],
@@ -88,6 +92,8 @@ module Box2D
       [:Body_GetAngularVelocity, :b2Body_GetAngularVelocity, [BodyId.by_value], :float],
       [:Body_SetLinearVelocity, :b2Body_SetLinearVelocity, [BodyId.by_value, Vec2.by_value], :void],
       [:Body_SetAngularVelocity, :b2Body_SetAngularVelocity, [BodyId.by_value, :float], :void],
+      [:Body_GetLocalPointVelocity, :b2Body_GetLocalPointVelocity, [BodyId.by_value, Vec2.by_value], Vec2.by_value],
+      [:Body_GetWorldPointVelocity, :b2Body_GetWorldPointVelocity, [BodyId.by_value, Vec2.by_value], Vec2.by_value],
       [:Body_ApplyForce, :b2Body_ApplyForce, [BodyId.by_value, Vec2.by_value, Vec2.by_value, :bool], :void],
       [:Body_ApplyForceToCenter, :b2Body_ApplyForceToCenter, [BodyId.by_value, Vec2.by_value, :bool], :void],
       [:Body_ApplyTorque, :b2Body_ApplyTorque, [BodyId.by_value, :float, :bool], :void],
@@ -120,7 +126,6 @@ module Box2D
       [:Body_IsFixedRotation, :b2Body_IsFixedRotation, [BodyId.by_value], :bool],
       [:Body_SetBullet, :b2Body_SetBullet, [BodyId.by_value, :bool], :void],
       [:Body_IsBullet, :b2Body_IsBullet, [BodyId.by_value], :bool],
-      [:Body_EnableSensorEvents, :b2Body_EnableSensorEvents, [BodyId.by_value, :bool], :void],
       [:Body_EnableContactEvents, :b2Body_EnableContactEvents, [BodyId.by_value, :bool], :void],
       [:Body_EnableHitEvents, :b2Body_EnableHitEvents, [BodyId.by_value, :bool], :void],
       [:Body_GetWorld, :b2Body_GetWorld, [BodyId.by_value], WorldId.by_value],
@@ -149,10 +154,10 @@ module Box2D
       [:Shape_GetFriction, :b2Shape_GetFriction, [ShapeId.by_value], :float],
       [:Shape_SetRestitution, :b2Shape_SetRestitution, [ShapeId.by_value, :float], :void],
       [:Shape_GetRestitution, :b2Shape_GetRestitution, [ShapeId.by_value], :float],
+      [:Shape_SetMaterial, :b2Shape_SetMaterial, [ShapeId.by_value, :int], :void],
+      [:Shape_GetMaterial, :b2Shape_GetMaterial, [ShapeId.by_value], :int],
       [:Shape_GetFilter, :b2Shape_GetFilter, [ShapeId.by_value], Filter.by_value],
       [:Shape_SetFilter, :b2Shape_SetFilter, [ShapeId.by_value, Filter.by_value], :void],
-      [:Shape_EnableSensorEvents, :b2Shape_EnableSensorEvents, [ShapeId.by_value, :bool], :void],
-      [:Shape_AreSensorEventsEnabled, :b2Shape_AreSensorEventsEnabled, [ShapeId.by_value], :bool],
       [:Shape_EnableContactEvents, :b2Shape_EnableContactEvents, [ShapeId.by_value, :bool], :void],
       [:Shape_AreContactEventsEnabled, :b2Shape_AreContactEventsEnabled, [ShapeId.by_value], :bool],
       [:Shape_EnablePreSolveEvents, :b2Shape_EnablePreSolveEvents, [ShapeId.by_value, :bool], :void],
@@ -176,6 +181,7 @@ module Box2D
       [:Shape_GetSensorCapacity, :b2Shape_GetSensorCapacity, [ShapeId.by_value], :int],
       [:Shape_GetSensorOverlaps, :b2Shape_GetSensorOverlaps, [ShapeId.by_value, :pointer, :int], :int],
       [:Shape_GetAABB, :b2Shape_GetAABB, [ShapeId.by_value], AABB.by_value],
+      [:Shape_GetMassData, :b2Shape_GetMassData, [ShapeId.by_value], MassData.by_value],
       [:Shape_GetClosestPoint, :b2Shape_GetClosestPoint, [ShapeId.by_value, Vec2.by_value], Vec2.by_value],
       [:CreateChain, :b2CreateChain, [BodyId.by_value, :pointer], ChainId.by_value],
       [:DestroyChain, :b2DestroyChain, [ChainId.by_value], :void],
@@ -186,6 +192,8 @@ module Box2D
       [:Chain_GetFriction, :b2Chain_GetFriction, [ChainId.by_value], :float],
       [:Chain_SetRestitution, :b2Chain_SetRestitution, [ChainId.by_value, :float], :void],
       [:Chain_GetRestitution, :b2Chain_GetRestitution, [ChainId.by_value], :float],
+      [:Chain_SetMaterial, :b2Chain_SetMaterial, [ChainId.by_value, :int], :void],
+      [:Chain_GetMaterial, :b2Chain_GetMaterial, [ChainId.by_value], :int],
       [:Chain_IsValid, :b2Chain_IsValid, [ChainId.by_value], :bool],
       [:DestroyJoint, :b2DestroyJoint, [JointId.by_value], :void],
       [:Joint_IsValid, :b2Joint_IsValid, [JointId.by_value], :bool],

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
@@ -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
@@ -241,15 +237,15 @@ module Box2D
     layout(
       :gravity, Vec2,
       :restitutionThreshold, :float,
-      :contactPushSpeed, :float,
       :hitEventThreshold, :float,
       :contactHertz, :float,
       :contactDampingRatio, :float,
+      :contactPushMaxSpeed, :float,
       :jointHertz, :float,
       :jointDampingRatio, :float,
       :maximumLinearSpeed, :float,
-      :frictionMixingRule, :int,
-      :restitutionMixingRule, :int,
+      :frictionCallback, :pointer,
+      :restitutionCallback, :pointer,
       :enableSleep, :bool,
       :enableContinuous, :bool,
       :workerCount, :int,
@@ -263,24 +259,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 contactPushMaxSpeed = self[:contactPushMaxSpeed]
+    def contactPushMaxSpeed=(v) self[:contactPushMaxSpeed] = 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 +293,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_, _contactPushMaxSpeed_, _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[:contactPushMaxSpeed] = _contactPushMaxSpeed_
       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 +329,7 @@ module Box2D
       :angularDamping, :float,
       :gravityScale, :float,
       :sleepThreshold, :float,
+      :name, :pointer,
       :userData, :pointer,
       :enableSleep, :bool,
       :isAwake, :bool,
@@ -360,6 +357,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 +375,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 +386,7 @@ module Box2D
       instance[:angularDamping] = _angularDamping_
       instance[:gravityScale] = _gravityScale_
       instance[:sleepThreshold] = _sleepThreshold_
+      instance[:name] = _name_
       instance[:userData] = _userData_
       instance[:enableSleep] = _enableSleep_
       instance[:isAwake] = _isAwake_
@@ -443,11 +443,12 @@ module Box2D
       :friction, :float,
       :restitution, :float,
       :rollingResistance, :float,
+      :tangentSpeed, :float,
+      :material, :int,
       :density, :float,
       :filter, Filter,
       :customColor, :uint,
       :isSensor, :bool,
-      :enableSensorEvents, :bool,
       :enableContactEvents, :bool,
       :enableHitEvents, :bool,
       :enablePreSolveEvents, :bool,
@@ -463,6 +464,10 @@ module Box2D
     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 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]
@@ -471,8 +476,6 @@ module Box2D
     def customColor=(v) self[:customColor] = v end
     def isSensor = self[:isSensor]
     def isSensor=(v) self[:isSensor] = v end
-    def enableSensorEvents = self[:enableSensorEvents]
-    def enableSensorEvents=(v) self[:enableSensorEvents] = v end
     def enableContactEvents = self[:enableContactEvents]
     def enableContactEvents=(v) self[:enableContactEvents] = v end
     def enableHitEvents = self[:enableHitEvents]
@@ -485,17 +488,18 @@ 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_, _friction_, _restitution_, _rollingResistance_, _tangentSpeed_, _material_, _density_, _filter_, _customColor_, _isSensor_, _enableContactEvents_, _enableHitEvents_, _enablePreSolveEvents_, _invokeContactCreation_, _updateBodyMass_, _internalValue_)
       instance = ShapeDef.new
       instance[:userData] = _userData_
       instance[:friction] = _friction_
       instance[:restitution] = _restitution_
       instance[:rollingResistance] = _rollingResistance_
+      instance[:tangentSpeed] = _tangentSpeed_
+      instance[:material] = _material_
       instance[:density] = _density_
       instance[:filter] = _filter_
       instance[:customColor] = _customColor_
       instance[:isSensor] = _isSensor_
-      instance[:enableSensorEvents] = _enableSensorEvents_
       instance[:enableContactEvents] = _enableContactEvents_
       instance[:enableHitEvents] = _enableHitEvents_
       instance[:enablePreSolveEvents] = _enablePreSolveEvents_
@@ -506,15 +510,47 @@ module Box2D
     end
   end
 
+  class SurfaceMaterial < FFI::Struct
+    layout(
+      :friction, :float,
+      :restitution, :float,
+      :rollingResistance, :float,
+      :tangentSpeed, :float,
+      :material, :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 material = self[:material]
+    def material=(v) self[:material] = v end
+    def customColor = self[:customColor]
+    def customColor=(v) self[:customColor] = v end
+    def self.create_as(_friction_, _restitution_, _rollingResistance_, _tangentSpeed_, _material_, _customColor_)
+      instance = SurfaceMaterial.new
+      instance[:friction] = _friction_
+      instance[:restitution] = _restitution_
+      instance[:rollingResistance] = _rollingResistance_
+      instance[:tangentSpeed] = _tangentSpeed_
+      instance[:material] = _material_
+      instance[:customColor] = _customColor_
+      instance
+    end
+  end
+
   class ChainDef < FFI::Struct
     layout(
       :userData, :pointer,
       :points, :pointer,
       :count, :int,
-      :friction, :float,
-      :restitution, :float,
+      :materials, :pointer,
+      :materialCount, :int,
       :filter, Filter,
-      :customColor, :uint,
       :isLoop, :bool,
       :internalValue, :int,
     )
@@ -524,27 +560,24 @@ 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 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_, _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[:internalValue] = _internalValue_
       instance
@@ -557,24 +590,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 +617,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
@@ -1462,6 +1495,7 @@ module Box2D
       :drawJointExtras, :bool,
       :drawAABBs, :bool,
       :drawMass, :bool,
+      :drawBodyNames, :bool,
       :drawContacts, :bool,
       :drawGraphColors, :bool,
       :drawContactNormals, :bool,
@@ -1501,6 +1535,8 @@ module Box2D
     def drawAABBs=(v) self[:drawAABBs] = 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]
@@ -1513,7 +1549,7 @@ module Box2D
     def drawFrictionImpulses=(v) self[:drawFrictionImpulses] = 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(_DrawPolygon_, _DrawSolidPolygon_, _DrawCircle_, _DrawSolidCircle_, _DrawSolidCapsule_, _DrawSegment_, _DrawTransform_, _DrawPoint_, _DrawString_, _drawingBounds_, _useDrawingBounds_, _drawShapes_, _drawJoints_, _drawJointExtras_, _drawAABBs_, _drawMass_, _drawBodyNames_, _drawContacts_, _drawGraphColors_, _drawContactNormals_, _drawContactImpulses_, _drawFrictionImpulses_, _context_)
       instance = DebugDraw.new
       instance[:DrawPolygon] = _DrawPolygon_
       instance[:DrawSolidPolygon] = _DrawSolidPolygon_
@@ -1531,6 +1567,7 @@ module Box2D
       instance[:drawJointExtras] = _drawJointExtras_
       instance[:drawAABBs] = _drawAABBs_
       instance[:drawMass] = _drawMass_
+      instance[:drawBodyNames] = _drawBodyNames_
       instance[:drawContacts] = _drawContacts_
       instance[:drawGraphColors] = _drawGraphColors_
       instance[:drawContactNormals] = _drawContactNormals_
@@ -1551,6 +1588,7 @@ module Box2D
       [:DefaultFilter, :b2DefaultFilter, [], Filter.by_value],
       [:DefaultQueryFilter, :b2DefaultQueryFilter, [], QueryFilter.by_value],
       [:DefaultShapeDef, :b2DefaultShapeDef, [], ShapeDef.by_value],
+      [:DefaultSurfaceMaterial, :b2DefaultSurfaceMaterial, [], SurfaceMaterial.by_value],
       [:DefaultChainDef, :b2DefaultChainDef, [], ChainDef.by_value],
       [:DefaultDistanceJointDef, :b2DefaultDistanceJointDef, [], DistanceJointDef.by_value],
       [:DefaultMotorJointDef, :b2DefaultMotorJointDef, [], MotorJointDef.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.1
 platform: x64-mingw
 authors:
 - vaiorabbit
 bindir: bin
 cert_chain: []
-date: 2025-01-01 00:00:00.000000000 Z
+date: 2025-02-01 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

data/lib/box2d_collision_inline.rb

@@ -1,47 +0,0 @@
-# Ruby-Box2D : Yet another Box2D wrapper for Ruby
-#
-# * https://github.com/vaiorabbit/box2d-bindings
-#
-# [NOTICE] Autogenerated. Do not edit.
-
-require 'ffi'
-
-module Box2D
-  extend FFI::Library
-  # Define/Macro
-
-
-  # Enum
-
-
-  # Typedef
-
-
-  # Struct
-
-
-  # Function
-
-  def self.setup_collision_inline_symbols(method_naming: :original)
-    entries = [
-      [:DynamicTree_GetUserData, :b2DynamicTree_GetUserData, [:pointer, :int], :int],
-      [:DynamicTree_GetAABB, :b2DynamicTree_GetAABB, [:pointer, :int], AABB.by_value],
-    ]
-    entries.each do |entry|
-      api_name = if method_naming == :snake_case
-                   snake_case_name = entry[0].to_s.gsub(/([A-Z]+)([A-Z0-9][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z0-9])/, '\1_\2').downcase
-                   snake_case_name.gsub!('vector_3', 'vector3_') if snake_case_name.include?('vector_3')
-                   snake_case_name.gsub!('vector_2', 'vector2_') if snake_case_name.include?('vector_2')
-                   snake_case_name.chop! if snake_case_name.end_with?('_')
-                   snake_case_name.to_sym
-                 else
-                   entry[0]
-                 end
-      attach_function api_name, entry[1], entry[2], entry[3]
-    rescue FFI::NotFoundError => e
-      warn "[Warning] Failed to import #{entry[0]} (#{e})."
-    end
-  end
-
-end
-