jolt-ruby 1.0.0

data/lib/jolt/body.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Jolt
+  class Body
+    include BodyDynamics
+
+    attr_reader :id, :system
+
+    def initialize(system, id)
+      @system = system
+      @id = id
+      @destroyed = false
+      transform = current_transform
+      @previous_transform = transform
+      @current_transform = transform
+    end
+
+    def position
+      read_vec3(:JPH_BodyInterface_GetPosition)
+    end
+
+    def position=(value)
+      write_vec3(:JPH_BodyInterface_SetPosition, value, activation)
+    end
+
+    def rotation
+      check_alive!
+      native = Native::Quat.new
+      Native.JPH_BodyInterface_GetRotation(body_interface, @id, native.pointer)
+      Conversions.quat(native)
+    end
+
+    def rotation=(value)
+      check_alive!
+      native = Conversions.native_quat(value)
+      Native.JPH_BodyInterface_SetRotation(body_interface, @id, native.pointer, activation)
+    end
+
+    def user_data
+      check_alive!
+      @system.__user_data(@id)
+    end
+
+    def user_data=(value)
+      check_alive!
+      @system.__set_user_data(@id, value)
+    end
+
+    def interpolated(alpha)
+      check_alive!
+      alpha = Conversions.finite_float(alpha, "alpha")
+      raise InvalidArgumentError, "alpha must be between 0 and 1" unless alpha.between?(0.0, 1.0)
+
+      Transform.new(
+        position: @previous_transform.position.lerp(@current_transform.position, alpha),
+        rotation: @previous_transform.rotation.slerp(@current_transform.rotation, alpha)
+      )
+    end
+
+    def destroy
+      @system.__destroy_body(self)
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def hash
+      [@system.object_id, @id].hash
+    end
+
+    def eql?(other)
+      other.is_a?(Body) && other.system.equal?(@system) && other.id == @id
+    end
+    alias == eql?
+
+    def __capture_before_step
+      check_alive!
+      @previous_transform = @current_transform
+    end
+
+    def __capture_after_step
+      check_alive!
+      @current_transform = current_transform
+    end
+
+    def __mark_destroyed
+      @destroyed = true
+    end
+
+    private
+
+    def current_transform
+      Transform.new(position: position, rotation: rotation)
+    end
+
+    def read_vec3(function)
+      check_alive!
+      native = Native::Vec3.new
+      Native.public_send(function, body_interface, @id, native.pointer)
+      Conversions.vec3(native)
+    end
+
+    def write_vec3(function, value, *extra)
+      check_alive!
+      native = Conversions.native_vec3(value)
+      Native.public_send(function, body_interface, @id, native.pointer, *extra)
+      value
+    end
+
+    def apply_vector_at_point(center_function, point_function, value, point)
+      check_alive!
+      native_value = Conversions.native_vec3(value)
+      if point
+        native_point = Conversions.native_vec3(point, name: "point")
+        Native.public_send(point_function, body_interface, @id, native_value.pointer, native_point.pointer)
+      else
+        Native.public_send(center_function, body_interface, @id, native_value.pointer)
+      end
+      self
+    end
+
+    def scalar_property(function)
+      check_alive!
+      Native.public_send(function, body_interface, @id)
+    end
+
+    def write_scalar(function, value, name)
+      check_alive!
+      number = Conversions.non_negative_float(value, name)
+      Native.public_send(function, body_interface, @id, number)
+    end
+
+    def activation
+      0
+    end
+
+    def body_interface
+      @system.__body_interface
+    end
+
+    def check_alive!
+      raise UseAfterDestroyError, "body #{@id} has been destroyed" if @destroyed
+      @system.__check_alive!
+    end
+  end
+end

data/lib/jolt/body_collection.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Jolt
+  class BodyCollection
+    include Enumerable
+
+    MOTION_TYPES = {static: 0, kinematic: 1, dynamic: 2}.freeze
+    INVALID_BODY_ID = 0xffff_ffff
+
+    def initialize(system)
+      @system = system
+    end
+
+    def create(shape:, position: [0, 0, 0], rotation: [0, 0, 0, 1],
+               motion: :dynamic, layer: nil, activate: nil, friction: 0.2,
+               restitution: 0.0, linear_damping: 0.05, angular_damping: 0.05,
+               gravity_factor: 1.0, mass: nil, ccd: false, sensor: false,
+               user_data: nil)
+      @system.__check_alive!
+      validate_shape!(shape)
+      motion_type = MOTION_TYPES.fetch(motion.respond_to?(:to_sym) ? motion.to_sym : nil)
+      if !motion_type.zero? && shape.must_be_static?
+        raise InvalidArgumentError, "#{shape.kind} shapes can only be used by static bodies"
+      end
+      layer ||= motion_type.zero? ? :non_moving : :moving
+      layer_id = @system.layers.object_layer_id(layer)
+      settings = create_settings(shape, position, rotation, motion_type, layer_id)
+      configure_settings(
+        settings,
+        friction:, restitution:, linear_damping:, angular_damping:,
+        gravity_factor:, mass:, ccd:, sensor:, motion_type:
+      )
+      id = Native.JPH_BodyInterface_CreateAndAddBody(
+        @system.__body_interface, settings, activation(activate, motion_type)
+      )
+      raise InitializationError, "failed to create body" if id == INVALID_BODY_ID
+
+      Body.new(@system, id).tap do |body|
+        @system.__register_body(body, shape)
+        body.user_data = user_data unless user_data.nil?
+      end
+    rescue KeyError
+      raise InvalidArgumentError, "motion must be one of: #{MOTION_TYPES.keys.join(", ")}"
+    ensure
+      Native.JPH_BodyCreationSettings_Destroy(settings) if settings && !settings.null?
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block
+
+      @system.__bodies_snapshot.each(&block)
+    end
+
+    def [](id)
+      @system.__body(id)
+    end
+
+    def size
+      @system.__bodies_snapshot.size
+    end
+    alias length size
+
+    private
+
+    def create_settings(shape, position, rotation, motion_type, layer_id)
+      position = Conversions.native_vec3(position, name: "position")
+      rotation = Conversions.native_quat(rotation)
+      settings = Native.JPH_BodyCreationSettings_Create3(
+        shape.native_pointer, position.pointer, rotation.pointer, motion_type, layer_id
+      )
+      raise InitializationError, "failed to allocate body creation settings" if settings.null?
+
+      settings
+    end
+
+    def configure_settings(settings, friction:, restitution:, linear_damping:, angular_damping:,
+                           gravity_factor:, mass:, ccd:, sensor:, motion_type:)
+      {
+        Friction: [friction, "friction"],
+        Restitution: [restitution, "restitution"],
+        LinearDamping: [linear_damping, "linear_damping"],
+        AngularDamping: [angular_damping, "angular_damping"],
+        GravityFactor: [gravity_factor, "gravity_factor"]
+      }.each do |name, (value, label)|
+        number = Conversions.non_negative_float(value, label)
+        Native.public_send(:"JPH_BodyCreationSettings_Set#{name}", settings, number)
+      end
+      Native.JPH_BodyCreationSettings_SetIsSensor(settings, !!sensor)
+      Native.JPH_BodyCreationSettings_SetMotionQuality(settings, ccd ? 1 : 0)
+      configure_mass(settings, mass, motion_type) unless mass.nil?
+    end
+
+    def configure_mass(settings, mass, motion_type)
+      raise InvalidArgumentError, "mass is only valid for dynamic bodies" unless motion_type == MOTION_TYPES[:dynamic]
+
+      mass = Conversions.positive_float(mass, "mass")
+      properties = Native::MassProperties.new
+      Native.JPH_BodyCreationSettings_GetMassPropertiesOverride(settings, properties.pointer)
+      properties[:mass] = mass
+      Native.JPH_BodyCreationSettings_SetMassPropertiesOverride(settings, properties.pointer)
+      Native.JPH_BodyCreationSettings_SetOverrideMassProperties(settings, 1)
+    end
+
+    def activation(value, motion_type)
+      activate = value.nil? ? motion_type == MOTION_TYPES[:dynamic] : !!value
+      activate ? 0 : 1
+    end
+
+    def validate_shape!(shape)
+      raise InvalidArgumentError, "shape must be a Jolt::Shape" unless shape.is_a?(Shape)
+
+      shape.native_pointer
+    end
+  end
+end

data/lib/jolt/body_dynamics.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Jolt
+  module BodyDynamics
+    def linear_velocity
+      read_vec3(:JPH_BodyInterface_GetLinearVelocity)
+    end
+
+    def linear_velocity=(value)
+      write_vec3(:JPH_BodyInterface_SetLinearVelocity, value)
+    end
+
+    def angular_velocity
+      read_vec3(:JPH_BodyInterface_GetAngularVelocity)
+    end
+
+    def angular_velocity=(value)
+      write_vec3(:JPH_BodyInterface_SetAngularVelocity, value)
+    end
+
+    def apply_impulse(impulse, point: nil)
+      apply_vector_at_point(:JPH_BodyInterface_AddImpulse, :JPH_BodyInterface_AddImpulse2, impulse, point)
+    end
+
+    def apply_angular_impulse(impulse)
+      write_vec3(:JPH_BodyInterface_AddAngularImpulse, impulse)
+      self
+    end
+
+    def add_force(force, point: nil)
+      apply_vector_at_point(:JPH_BodyInterface_AddForce, :JPH_BodyInterface_AddForce2, force, point)
+    end
+
+    def add_torque(torque)
+      write_vec3(:JPH_BodyInterface_AddTorque, torque)
+      self
+    end
+
+    def active?
+      check_alive!
+      Native.JPH_BodyInterface_IsActive(body_interface, @id)
+    end
+
+    def activate
+      check_alive!
+      Native.JPH_BodyInterface_ActivateBody(body_interface, @id)
+      self
+    end
+
+    def deactivate
+      check_alive!
+      Native.JPH_BodyInterface_DeactivateBody(body_interface, @id)
+      self
+    end
+
+    def kinematic_move_to(position, rotation, delta_time)
+      check_alive!
+      position = Conversions.native_vec3(position, name: "position")
+      rotation = Conversions.native_quat(rotation)
+      delta_time = Conversions.positive_float(delta_time, "delta_time")
+      Native.JPH_BodyInterface_MoveKinematic(
+        body_interface, @id, position.pointer, rotation.pointer, delta_time
+      )
+      self
+    end
+
+    def friction
+      scalar_property(:JPH_BodyInterface_GetFriction)
+    end
+
+    def friction=(value)
+      write_scalar(:JPH_BodyInterface_SetFriction, value, "friction")
+    end
+
+    def restitution
+      scalar_property(:JPH_BodyInterface_GetRestitution)
+    end
+
+    def restitution=(value)
+      write_scalar(:JPH_BodyInterface_SetRestitution, value, "restitution")
+    end
+
+    def sensor?
+      check_alive!
+      Native.JPH_BodyInterface_IsSensor(body_interface, @id)
+    end
+
+    def sensor=(value)
+      check_alive!
+      Native.JPH_BodyInterface_SetIsSensor(body_interface, @id, !!value)
+    end
+  end
+end

data/lib/jolt/character_virtual.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Jolt
+  class CharacterVirtual
+    GROUND_STATES = {
+      0 => :on_ground,
+      1 => :sliding,
+      2 => :in_air,
+      3 => :in_air
+    }.freeze
+
+    attr_reader :system, :shape, :layer
+
+    def initialize(system, shape:, position: [0, 0, 0], rotation: [0, 0, 0, 1],
+                   max_slope: Math::PI / 4, mass: 70, layer: :moving)
+      unless system.is_a?(System) && !system.destroyed?
+        raise InvalidArgumentError, "system must be a live Jolt::System"
+      end
+      unless shape.is_a?(Shape) && !shape.released?
+        raise InvalidArgumentError, "shape must be a live Jolt::Shape"
+      end
+
+      @system = system
+      @shape = shape
+      layer_id = @system.layers.object_layer_id(layer)
+      @layer = layer.to_sym
+      native_position = Conversions.native_vec3(position, name: "position")
+      native_rotation = Conversions.native_quat(rotation)
+      slope = Conversions.positive_float(max_slope, "max_slope")
+      unless slope <= Math::PI / 2
+        raise InvalidArgumentError, "max_slope must not exceed pi / 2"
+      end
+      character_mass = Conversions.positive_float(mass, "mass")
+      @pointer = Native.JR_CharacterVirtual_Create(
+        @system.__native_pointer,
+        @shape.native_pointer,
+        native_position.pointer,
+        native_rotation.pointer,
+        slope,
+        character_mass
+      )
+      raise InitializationError, "failed to create virtual character" if @pointer.null?
+
+      @layer_id = layer_id
+      @destroyed = false
+      @system.__register_character(self, @shape)
+    rescue StandardError
+      Native.JPH_CharacterBase_Destroy(@pointer) if @pointer && !@pointer.null?
+      raise
+    end
+
+    def position
+      read_vec3(:JPH_CharacterVirtual_GetPosition)
+    end
+
+    def position=(value)
+      write_vec3(:JPH_CharacterVirtual_SetPosition, value, "position")
+    end
+
+    def rotation
+      check_alive!
+      native = Native::Quat.new
+      Native.JPH_CharacterVirtual_GetRotation(@pointer, native.pointer)
+      Conversions.quat(native)
+    end
+
+    def rotation=(value)
+      check_alive!
+      native = Conversions.native_quat(value)
+      Native.JPH_CharacterVirtual_SetRotation(@pointer, native.pointer)
+      value
+    end
+
+    def velocity
+      read_vec3(:JPH_CharacterVirtual_GetLinearVelocity)
+    end
+    alias linear_velocity velocity
+
+    def velocity=(value)
+      write_vec3(:JPH_CharacterVirtual_SetLinearVelocity, value, "velocity")
+    end
+    alias linear_velocity= velocity=
+
+    def mass
+      check_alive!
+      Native.JPH_CharacterVirtual_GetMass(@pointer)
+    end
+
+    def mass=(value)
+      check_alive!
+      Native.JPH_CharacterVirtual_SetMass(
+        @pointer,
+        Conversions.positive_float(value, "mass")
+      )
+      value
+    end
+
+    def update(delta_time)
+      check_alive!
+      delta_time = Conversions.positive_float(delta_time, "delta_time")
+      @system.__with_native_operation("recursive virtual character update is not allowed") do
+        Native.JR_CharacterVirtual_ExtendedUpdate(
+          @pointer,
+          delta_time,
+          @layer_id,
+          @system.__native_pointer
+        )
+        self
+      end
+    end
+
+    def ground_state
+      check_alive!
+      GROUND_STATES.fetch(Native.JPH_CharacterBase_GetGroundState(@pointer))
+    end
+
+    def supported?
+      check_alive!
+      Native.JPH_CharacterBase_IsSupported(@pointer)
+    end
+
+    def destroy
+      @system.__destroy_character(self)
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def __native_pointer
+      check_alive!
+      @pointer
+    end
+
+    def __destroy_native
+      Native.JPH_CharacterBase_Destroy(@pointer) if @pointer && !@pointer.null?
+      @pointer = nil
+      @destroyed = true
+    end
+
+    private
+
+    def read_vec3(function)
+      check_alive!
+      native = Native::Vec3.new
+      Native.public_send(function, @pointer, native.pointer)
+      Conversions.vec3(native)
+    end
+
+    def write_vec3(function, value, name)
+      check_alive!
+      native = Conversions.native_vec3(value, name:)
+      Native.public_send(function, @pointer, native.pointer)
+      value
+    end
+
+    def check_alive!
+      raise UseAfterDestroyError, "virtual character has been destroyed" if @destroyed
+      @system.__check_alive!
+    end
+  end
+end

data/lib/jolt/constraint.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Jolt
+  class Constraint
+    attr_reader :kind, :body_a, :body_b, :system
+
+    def initialize(system, pointer, kind, body_a, body_b)
+      @system = system
+      @pointer = pointer
+      @kind = kind
+      @body_a = body_a
+      @body_b = body_b
+      @destroyed = false
+    end
+
+    def enabled?
+      check_alive!
+      Native.JPH_Constraint_GetEnabled(@pointer)
+    end
+
+    def enabled=(value)
+      check_alive!
+      Native.JPH_Constraint_SetEnabled(@pointer, !!value)
+    end
+
+    def limits
+      check_alive!
+      functions = limit_functions
+      [
+        Native.public_send(functions.fetch(:min), @pointer),
+        Native.public_send(functions.fetch(:max), @pointer)
+      ]
+    end
+
+    def limits=(value)
+      check_alive!
+      minimum, maximum = ConstraintCollection.interval(value, "limits")
+      Native.public_send(limit_functions.fetch(:set), @pointer, minimum, maximum)
+      value
+    end
+
+    def current_position
+      check_alive!
+      function = case @kind
+                 when :hinge then :JPH_HingeConstraint_GetCurrentAngle
+                 when :slider then :JPH_SliderConstraint_GetCurrentPosition
+                 else
+                   raise InvalidArgumentError, "#{@kind} constraints do not have a scalar position"
+                 end
+      Native.public_send(function, @pointer)
+    end
+
+    def motor_speed
+      check_alive!
+      Native.public_send(motor_functions.fetch(:get), @pointer)
+    end
+
+    def motor_speed=(value)
+      check_alive!
+      speed = Conversions.finite_float(value, "motor_speed")
+      functions = motor_functions
+      Native.public_send(functions.fetch(:state), @pointer, 1)
+      Native.public_send(functions.fetch(:set), @pointer, speed)
+      value
+    end
+
+    def disable_motor
+      check_alive!
+      Native.public_send(motor_functions.fetch(:state), @pointer, 0)
+      self
+    end
+
+    def destroy
+      @system.__destroy_constraint(self)
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def __native_pointer
+      check_alive!
+      @pointer
+    end
+
+    def __involves?(body)
+      @body_a.equal?(body) || @body_b.equal?(body)
+    end
+
+    def __mark_destroyed
+      @destroyed = true
+      @pointer = nil
+    end
+
+    private
+
+    def limit_functions
+      prefix = case @kind
+               when :distance then "Distance"
+               when :hinge then "Hinge"
+               when :slider then "Slider"
+               else
+                 raise InvalidArgumentError, "#{@kind} constraints do not have limits"
+               end
+      {
+        set: :"JPH_#{prefix}Constraint_Set#{prefix == "Distance" ? "Distance" : "Limits"}",
+        min: :"JPH_#{prefix}Constraint_Get#{prefix == "Distance" ? "MinDistance" : "LimitsMin"}",
+        max: :"JPH_#{prefix}Constraint_Get#{prefix == "Distance" ? "MaxDistance" : "LimitsMax"}"
+      }
+    end
+
+    def motor_functions
+      case @kind
+      when :hinge
+        {
+          state: :JPH_HingeConstraint_SetMotorState,
+          set: :JPH_HingeConstraint_SetTargetAngularVelocity,
+          get: :JPH_HingeConstraint_GetTargetAngularVelocity
+        }
+      when :slider
+        {
+          state: :JPH_SliderConstraint_SetMotorState,
+          set: :JPH_SliderConstraint_SetTargetVelocity,
+          get: :JPH_SliderConstraint_GetTargetVelocity
+        }
+      else
+        raise InvalidArgumentError, "#{@kind} constraints do not have a motor"
+      end
+    end
+
+    def check_alive!
+      raise UseAfterDestroyError, "#{@kind} constraint has been destroyed" if @destroyed
+      @system.__check_alive!
+    end
+  end
+end