jolt-ruby 1.0.0

data/lib/jolt/system_characters.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Jolt
+  module SystemCharacters
+    def __register_character(character, shape)
+      @character_registry << character
+      @shapes[shape.object_id] = shape
+    end
+
+    def __destroy_character(character)
+      return if character.destroyed?
+
+      __check_alive!
+      removed = @character_registry.delete(character)
+      raise InvalidArgumentError, "virtual character does not belong to this system" unless removed
+
+      character.__destroy_native
+      nil
+    end
+
+    def __destroy_all_characters
+      @character_registry.dup.each(&:destroy)
+    end
+  end
+end

data/lib/jolt/system_constraints.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Jolt
+  module SystemConstraints
+    def __register_constraint(constraint)
+      @constraint_registry << constraint
+    end
+
+    def __destroy_constraint(constraint)
+      return if constraint.destroyed?
+
+      __check_alive!
+      removed = @constraint_registry.delete(constraint)
+      raise InvalidArgumentError, "constraint does not belong to this system" unless removed
+
+      pointer = constraint.__native_pointer
+      Native.JPH_PhysicsSystem_RemoveConstraint(@pointer, pointer)
+      Native.JPH_Constraint_Destroy(pointer)
+      constraint.__mark_destroyed
+      nil
+    end
+
+    def __constraints_snapshot
+      __check_alive!
+      @constraint_registry.dup
+    end
+
+    def __destroy_constraints_for(body)
+      @constraint_registry.select { |constraint| constraint.__involves?(body) }.each(&:destroy)
+    end
+
+    def __destroy_all_constraints
+      @constraint_registry.dup.each(&:destroy)
+    end
+  end
+end

data/lib/jolt/system_contacts.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Jolt
+  module SystemContacts
+    CONTACT_EVENT_TYPES = %i[added persisted removed].freeze
+    MAX_CONTACT_QUEUE_CAPACITY = 1 << 30
+
+    def __create_contact_queue(capacity)
+      unless capacity.is_a?(Integer) && capacity.between?(2, MAX_CONTACT_QUEUE_CAPACITY)
+        raise InvalidArgumentError,
+              "contact_queue_capacity must be an integer between 2 and #{MAX_CONTACT_QUEUE_CAPACITY}"
+      end
+
+      @contact_queue = Native.JR_ContactQueue_Create(capacity)
+      raise InitializationError, "failed to create contact event queue" if @contact_queue.null?
+
+      listener = Native.JR_ContactQueue_GetListener(@contact_queue)
+      raise InitializationError, "failed to create contact listener" if listener.null?
+
+      Native.JPH_PhysicsSystem_SetContactListener(@pointer, listener)
+      @contact_events = ContactEvents.empty
+    end
+
+    def __drain_contact_events
+      grouped = {added: [], persisted: [], removed: []}
+      native = Native::ContactEvent.new
+      while Native.JR_ContactQueue_Pop(@contact_queue, native.pointer)
+        type = CONTACT_EVENT_TYPES.fetch(native[:type])
+        removed = type == :removed
+        grouped.fetch(type) << Contact.new(
+          body_a: @body_registry[native[:body_a]],
+          body_b: @body_registry[native[:body_b]],
+          sub_shape_a: native[:sub_shape_a],
+          sub_shape_b: native[:sub_shape_b],
+          point: removed ? nil : Larb::Vec3.new(*native[:point].to_a),
+          normal: removed ? nil : Larb::Vec3.new(*native[:normal].to_a),
+          penetration: removed ? nil : native[:penetration]
+        )
+      end
+      dropped = Native.JR_ContactQueue_GetDroppedCount(@contact_queue)
+      @contact_events = ContactEvents.new(
+        added: grouped[:added].freeze,
+        persisted: grouped[:persisted].freeze,
+        removed: grouped[:removed].freeze,
+        dropped_count: dropped
+      )
+    end
+
+    def __destroy_contact_queue
+      return unless @contact_queue && !@contact_queue.null?
+
+      Native.JPH_PhysicsSystem_SetContactListener(@pointer, nil) if @pointer && !@pointer.null?
+      Native.JR_ContactQueue_Destroy(@contact_queue)
+      @contact_queue = nil
+    end
+  end
+end

data/lib/jolt/system_queries.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Jolt
+  module SystemQueries
+    def raycast(origin:, direction:, layer_mask: nil)
+      __check_alive!
+      origin_native = Conversions.native_vec3(origin, name: "origin")
+      direction_native = Conversions.native_vec3(direction, name: "direction")
+      direction_vector = Conversions.vec3(direction_native)
+      if direction_vector.length <= Float::EPSILON
+        raise InvalidArgumentError, "direction must not be zero"
+      end
+
+      filter, filter_context = object_layer_filter(layer_mask)
+      result = Native::RayCastResult.new
+      hit = Native.JPH_NarrowPhaseQuery_CastRay(
+        @narrow_phase_query,
+        origin_native.pointer,
+        direction_native.pointer,
+        result.pointer,
+        nil,
+        filter,
+        nil
+      )
+      return nil unless hit
+
+      build_hit(origin_native, direction_native, result)
+    ensure
+      Native.JPH_ObjectLayerFilter_Destroy(filter) if filter && !filter.null?
+      filter_context = nil
+    end
+
+    def overlap_sphere(center, radius, layer_mask: nil, &block)
+      center_native = Conversions.native_vec3(center, name: "center")
+      radius = Conversions.positive_float(radius, "radius")
+      collect_overlapping_bodies(
+        :JPH_BroadPhaseQuery_CollideSphere,
+        center_native.pointer,
+        radius,
+        layer_mask:,
+        &block
+      )
+    end
+
+    def overlap_point(point, layer_mask: nil, &block)
+      point_native = Conversions.native_vec3(point, name: "point")
+      collect_overlapping_bodies(
+        :JPH_BroadPhaseQuery_CollidePoint,
+        point_native.pointer,
+        layer_mask:,
+        &block
+      )
+    end
+
+    private
+
+    def collect_overlapping_bodies(function, *query_arguments, layer_mask:)
+      __check_alive!
+      filter, filter_context = object_layer_filter(layer_mask)
+      callback, body_ids = Native::QueryFunctions.body_collector
+      Native.public_send(
+        function,
+        @broad_phase_query,
+        *query_arguments,
+        callback,
+        nil,
+        nil,
+        filter
+      )
+      bodies = body_ids.uniq.filter_map { |id| @body_registry[id] }
+      bodies.each { |body| yield body } if block_given?
+      bodies
+    ensure
+      Native.JPH_ObjectLayerFilter_Destroy(filter) if filter && !filter.null?
+      filter_context = callback = nil
+    end
+
+    def object_layer_filter(layer_mask)
+      return [nil, nil] if layer_mask.nil?
+
+      layer_ids = Array(layer_mask).map { |name| @layers.object_layer_id(name) }.uniq
+      Native::QueryFunctions.object_layer_filter(
+        Native, layer_ids, @layers.object_layers.length
+      )
+    end
+
+    def build_hit(origin, direction, result)
+      fraction = result[:fraction]
+      point = Native::Vec3.new
+      %i[x y z].each do |component|
+        point[component] = origin[component] + direction[component] * fraction
+      end
+
+      normal = Native::Vec3.new
+      body_pointer = Native.JPH_PhysicsSystem_GetBodyPtr(@pointer, result[:body_id])
+      unless body_pointer.null?
+        Native.JPH_Body_GetWorldSpaceSurfaceNormal(
+          body_pointer, result[:sub_shape_id2], point.pointer, normal.pointer
+        )
+      end
+
+      Hit.new(
+        body: @body_registry[result[:body_id]],
+        fraction:,
+        point: Conversions.vec3(point),
+        normal: Conversions.vec3(normal),
+        sub_shape_id: result[:sub_shape_id2]
+      )
+    end
+  end
+end

data/lib/jolt/transform.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jolt
+  Transform = Data.define(:position, :rotation)
+end

data/lib/jolt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jolt
+  VERSION = "1.0.0"
+end

data/lib/jolt.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative "jolt/version"
+require_relative "jolt/errors"
+require_relative "jolt/native"
+require_relative "jolt/conversions"
+require_relative "jolt/layers"
+require_relative "jolt/shape_builders"
+require_relative "jolt/shape"
+require_relative "jolt/fixed_stepper"
+require_relative "jolt/transform"
+require_relative "jolt/body_dynamics"
+require_relative "jolt/body"
+require_relative "jolt/body_collection"
+require_relative "jolt/contact_events"
+require_relative "jolt/hit"
+require_relative "jolt/system_contacts"
+require_relative "jolt/system_queries"
+require_relative "jolt/constraint"
+require_relative "jolt/constraint_collection"
+require_relative "jolt/system_constraints"
+require_relative "jolt/system_characters"
+require_relative "jolt/system"
+require_relative "jolt/character_virtual"
+
+module Jolt
+  @lifecycle_mutex = Mutex.new
+  @initialized = false
+  @systems = []
+  @at_exit_registered = false
+
+  class << self
+    def init
+      @lifecycle_mutex.synchronize do
+        return self if @initialized
+
+        Native.load!
+        raise InitializationError, "Jolt Physics initialization failed" unless Native.JPH_Init
+
+        @initialized = true
+        unless @at_exit_registered
+          at_exit { shutdown }
+          @at_exit_registered = true
+        end
+      end
+
+      self
+    end
+
+    def initialized?
+      @lifecycle_mutex.synchronize { @initialized }
+    end
+
+    def shutdown
+      systems = @lifecycle_mutex.synchronize do
+        return unless @initialized
+
+        @systems.dup
+      end
+      systems.each(&:destroy)
+
+      @lifecycle_mutex.synchronize do
+        return unless @initialized
+
+        @systems.clear
+        Native.JPH_Shutdown
+        @initialized = false
+      end
+    end
+
+    def __register_system(system)
+      @lifecycle_mutex.synchronize do
+        raise InitializationError, "Jolt Physics is not initialized" unless @initialized
+
+        @systems << system
+      end
+    end
+
+    def __unregister_system(system)
+      @lifecycle_mutex.synchronize { @systems.delete(system) }
+    end
+  end
+end

data/script/smoke_gem.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rubygems"
+
+gem "jolt-ruby"
+require "jolt"
+
+smoke_home = File.realpath(ENV.fetch("JOLT_RUBY_SMOKE_HOME"))
+loaded_gem = File.realpath(Gem.loaded_specs.fetch("jolt-ruby").full_gem_path)
+unless loaded_gem.start_with?("#{smoke_home}#{File::SEPARATOR}")
+  raise "loaded jolt-ruby from #{loaded_gem}, expected an installation under #{smoke_home}"
+end
+
+begin
+  system = Jolt::System.new
+  missing_functions = Jolt::Native::Generated.missing_functions
+  unless missing_functions.empty?
+    raise "packaged native libraries are missing: #{missing_functions.join(", ")}"
+  end
+
+  body = system.bodies.create(shape: Jolt::Shape.sphere(0.5), position: [0, 2, 0])
+  system.update(1.0 / 60.0)
+  raise "packaged simulation did not advance" unless body.position.y < 2
+
+  puts "loaded and simulated with #{File.basename(loaded_gem)}"
+ensure
+  system&.destroy
+  Jolt.shutdown
+end

data/script/verify_release.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "rubygems/package"
+
+directory, tag = ARGV
+abort "usage: #{$PROGRAM_NAME} GEM_DIRECTORY vVERSION" unless directory && tag
+abort "release tag must have the form v1.2.3" unless tag.match?(/\Av\d+\.\d+\.\d+\z/)
+
+version = tag.delete_prefix("v")
+expected_platforms = %w[
+  ruby
+  x86_64-linux
+  aarch64-linux
+  arm64-darwin
+  x86_64-darwin
+  x64-mingw-ucrt
+].sort
+gem_paths = Dir[File.join(directory, "*.gem")].sort
+specifications = gem_paths.map { |path| Gem::Package.new(path).spec }
+
+unless specifications.length == expected_platforms.length
+  abort "expected #{expected_platforms.length} gems, found #{specifications.length}"
+end
+unless specifications.all? { |specification| specification.name == "jolt-ruby" }
+  abort "release directory contains a gem other than jolt-ruby"
+end
+unless specifications.all? { |specification| specification.version.to_s == version }
+  abort "release gem version does not match tag #{tag}"
+end
+
+actual_platforms = specifications.map { |specification| specification.platform.to_s }.sort
+unless actual_platforms == expected_platforms
+  abort "expected platforms #{expected_platforms.join(", ")}, found #{actual_platforms.join(", ")}"
+end
+
+puts "verified jolt-ruby #{version} for #{actual_platforms.join(", ")}"

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: jolt-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yudai Takada
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: larb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: A Ruby-friendly 3D physics API backed by Jolt Physics through joltc and
+  FFI.
+email:
+- t.yudai92@gmail.com
+executables: []
+extensions:
+- ext/jolt_ruby/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitmodules"
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/character_virtual.rb
+- examples/falling_sphere.rb
+- examples/stagecraft_binding.rb
+- ext/jolt_ruby/CMakeLists.txt
+- ext/jolt_ruby/character_helper.cpp
+- ext/jolt_ruby/constraint_helper.cpp
+- ext/jolt_ruby/extconf.rb
+- ext/jolt_ruby/helper.cpp
+- ext/jolt_ruby/helper.h
+- ext/joltc/.github/FUNDING.yml
+- ext/joltc/.github/workflows/build.yml
+- ext/joltc/.gitignore
+- ext/joltc/CMakeLists.txt
+- ext/joltc/LICENSE
+- ext/joltc/README.md
+- ext/joltc/build/cmake_vs2026_arm64.bat
+- ext/joltc/build/cmake_vs2026_clang.bat
+- ext/joltc/build/cmake_vs2026_x64.bat
+- ext/joltc/build/cmake_vs2026_x64_double.bat
+- ext/joltc/include/joltc.h
+- ext/joltc/samples/01_HelloWorld/main.cpp
+- ext/joltc/samples/CMakeLists.txt
+- ext/joltc/src/joltc.c
+- ext/joltc/src/joltc.cpp
+- ext/joltc/src/joltc_assert.cpp
+- ext/joltc/tests/CMakeLists.txt
+- ext/joltc/tests/test_character.cpp
+- ext/joltc/tests/test_collision.cpp
+- ext/joltc/tests/test_constraints.cpp
+- ext/joltc/tests/test_core.cpp
+- ext/joltc/tests/test_math.cpp
+- ext/joltc/tests/test_physics_system.cpp
+- ext/joltc/tests/test_shapes.cpp
+- ext/joltc/tests/test_skeleton.cpp
+- ext/joltc/tests/test_vehicle.cpp
+- generator/generate.rb
+- generator/layout_probe.cpp
+- generator/verify_layout.rb
+- lib/jolt.rb
+- lib/jolt/body.rb
+- lib/jolt/body_collection.rb
+- lib/jolt/body_dynamics.rb
+- lib/jolt/character_virtual.rb
+- lib/jolt/constraint.rb
+- lib/jolt/constraint_collection.rb
+- lib/jolt/contact_events.rb
+- lib/jolt/conversions.rb
+- lib/jolt/errors.rb
+- lib/jolt/fixed_stepper.rb
+- lib/jolt/hit.rb
+- lib/jolt/layers.rb
+- lib/jolt/native.rb
+- lib/jolt/native/character_functions.rb
+- lib/jolt/native/constraint_functions.rb
+- lib/jolt/native/core_functions.rb
+- lib/jolt/native/generated.rb
+- lib/jolt/native/platform.rb
+- lib/jolt/native/query_functions.rb
+- lib/jolt/native/types.rb
+- lib/jolt/shape.rb
+- lib/jolt/shape_builders.rb
+- lib/jolt/system.rb
+- lib/jolt/system_characters.rb
+- lib/jolt/system_constraints.rb
+- lib/jolt/system_contacts.rb
+- lib/jolt/system_queries.rb
+- lib/jolt/transform.rb
+- lib/jolt/version.rb
+- script/smoke_gem.rb
+- script/verify_release.rb
+homepage: https://github.com/ydah/jolt-ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ydah/jolt-ruby
+  source_code_uri: https://github.com/ydah/jolt-ruby/tree/main
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Ruby bindings for the Jolt Physics engine
+test_files: []