jolt-ruby 1.0.0

data/ext/jolt_ruby/constraint_helper.cpp

@@ -0,0 +1,154 @@
+#include "helper.h"
+
+#include <joltc.h>
+
+namespace {
+
+JPH_Vec3 to_vec3(const float* value) {
+  return JPH_Vec3{value[0], value[1], value[2]};
+}
+
+JPH_Body* find_body(JPH_PhysicsSystem* system, uint32_t body_id) {
+  return const_cast<JPH_Body*>(JPH_PhysicsSystem_GetBodyPtr(system, body_id));
+}
+
+JPH_Constraint* add_constraint(JPH_PhysicsSystem* system, JPH_Constraint* constraint) {
+  if (!constraint) return nullptr;
+
+  JPH_PhysicsSystem_AddConstraint(system, constraint);
+  return constraint;
+}
+
+}  // namespace
+
+JPH_Constraint* JR_Constraint_CreateFixed(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor) {
+  auto* first = find_body(system, body_a);
+  auto* second = find_body(system, body_b);
+  if (!first || !second) return nullptr;
+
+  JPH_FixedConstraintSettings settings{};
+  JPH_FixedConstraintSettings_Init(&settings);
+  settings.space = JPH_ConstraintSpace_WorldSpace;
+  if (anchor) {
+    settings.autoDetectPoint = false;
+    settings.point1 = to_vec3(anchor);
+    settings.point2 = settings.point1;
+  }
+  return add_constraint(
+      system,
+      reinterpret_cast<JPH_Constraint*>(
+          JPH_FixedConstraint_Create(&settings, first, second)));
+}
+
+JPH_Constraint* JR_Constraint_CreatePoint(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor) {
+  auto* first = find_body(system, body_a);
+  auto* second = find_body(system, body_b);
+  if (!first || !second || !anchor) return nullptr;
+
+  JPH_PointConstraintSettings settings{};
+  JPH_PointConstraintSettings_Init(&settings);
+  settings.space = JPH_ConstraintSpace_WorldSpace;
+  settings.point1 = to_vec3(anchor);
+  settings.point2 = settings.point1;
+  return add_constraint(
+      system,
+      reinterpret_cast<JPH_Constraint*>(
+          JPH_PointConstraint_Create(&settings, first, second)));
+}
+
+JPH_Constraint* JR_Constraint_CreateDistance(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* point_a,
+    const float* point_b,
+    float min_distance,
+    float max_distance) {
+  auto* first = find_body(system, body_a);
+  auto* second = find_body(system, body_b);
+  if (!first || !second || !point_a || !point_b) return nullptr;
+
+  JPH_DistanceConstraintSettings settings{};
+  JPH_DistanceConstraintSettings_Init(&settings);
+  settings.space = JPH_ConstraintSpace_WorldSpace;
+  settings.point1 = to_vec3(point_a);
+  settings.point2 = to_vec3(point_b);
+  settings.minDistance = min_distance;
+  settings.maxDistance = max_distance;
+  return add_constraint(
+      system,
+      reinterpret_cast<JPH_Constraint*>(
+          JPH_DistanceConstraint_Create(&settings, first, second)));
+}
+
+JPH_Constraint* JR_Constraint_CreateHinge(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor,
+    const float* axis,
+    const float* normal,
+    bool has_limits,
+    float min_angle,
+    float max_angle) {
+  auto* first = find_body(system, body_a);
+  auto* second = find_body(system, body_b);
+  if (!first || !second || !anchor || !axis || !normal) return nullptr;
+
+  JPH_HingeConstraintSettings settings{};
+  JPH_HingeConstraintSettings_Init(&settings);
+  settings.space = JPH_ConstraintSpace_WorldSpace;
+  settings.point1 = to_vec3(anchor);
+  settings.point2 = settings.point1;
+  settings.hingeAxis1 = to_vec3(axis);
+  settings.hingeAxis2 = settings.hingeAxis1;
+  settings.normalAxis1 = to_vec3(normal);
+  settings.normalAxis2 = settings.normalAxis1;
+  if (has_limits) {
+    settings.limitsMin = min_angle;
+    settings.limitsMax = max_angle;
+  }
+  return add_constraint(
+      system,
+      reinterpret_cast<JPH_Constraint*>(
+          JPH_HingeConstraint_Create(&settings, first, second)));
+}
+
+JPH_Constraint* JR_Constraint_CreateSlider(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor,
+    const float* axis,
+    bool has_limits,
+    float min_distance,
+    float max_distance) {
+  auto* first = find_body(system, body_a);
+  auto* second = find_body(system, body_b);
+  if (!first || !second || !anchor || !axis) return nullptr;
+
+  JPH_SliderConstraintSettings settings{};
+  JPH_SliderConstraintSettings_Init(&settings);
+  settings.space = JPH_ConstraintSpace_WorldSpace;
+  settings.autoDetectPoint = false;
+  settings.point1 = to_vec3(anchor);
+  settings.point2 = settings.point1;
+  const JPH_Vec3 slider_axis = to_vec3(axis);
+  JPH_SliderConstraintSettings_SetSliderAxis(&settings, &slider_axis);
+  if (has_limits) {
+    settings.limitsMin = min_distance;
+    settings.limitsMax = max_distance;
+  }
+  return add_constraint(
+      system,
+      reinterpret_cast<JPH_Constraint*>(
+          JPH_SliderConstraint_Create(&settings, first, second)));
+}

data/ext/jolt_ruby/extconf.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "mkmf"
+require "rbconfig"
+require File.expand_path("../../lib/jolt/native/platform", __dir__)
+
+source_dir = __dir__
+platform = Jolt::Native::Platform.tag
+build_dir = File.join(source_dir, "build", platform)
+artifact_dir = File.join(source_dir, "native-artifacts")
+host_os = RbConfig::CONFIG.fetch("host_os")
+library_names =
+  case host_os
+  when /darwin/
+    %w[libjoltc.dylib libjolt_ruby_helper.dylib]
+  when /mswin|mingw/
+    %w[joltc.dll jolt_ruby_helper.dll]
+  else
+    %w[libjoltc.so libjolt_ruby_helper.so]
+  end
+
+configure = [
+  "cmake",
+  "-S", source_dir,
+  "-B", build_dir,
+  "-DCMAKE_BUILD_TYPE=Release"
+]
+configure << "-DCMAKE_OSX_ARCHITECTURES=#{RbConfig::CONFIG.fetch("host_cpu")}" if host_os.include?("darwin")
+
+abort "CMake configuration failed" unless system(*configure)
+abort "native build failed" unless system(
+  "cmake", "--build", build_dir, "--config", "Release", "--parallel"
+)
+
+search_directories = [
+  File.join(build_dir, "lib"),
+  File.join(build_dir, "lib", "Release"),
+  File.join(build_dir, "Release")
+]
+FileUtils.rm_rf(artifact_dir)
+FileUtils.mkdir_p(artifact_dir)
+library_names.each do |name|
+  source = search_directories.lazy
+    .map { |directory| File.join(directory, name) }
+    .find { |path| File.file?(path) }
+  abort "native build did not produce #{name}" unless source
+
+  FileUtils.cp(source, artifact_dir)
+end
+
+$srcs = []
+$INSTALLFILES = library_names.map do |name|
+  ["./native-artifacts/#{name}", "$(RUBYARCHDIR)/jolt/native/#{platform}", "native-artifacts"]
+end
+create_makefile("jolt_ruby_native")

data/ext/jolt_ruby/helper.cpp

@@ -0,0 +1,225 @@
+#include "helper.h"
+
+#include <joltc.h>
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <new>
+
+namespace {
+
+struct Slot {
+  std::atomic<size_t> sequence;
+  JR_ContactEvent event;
+};
+
+uint32_t next_power_of_two(uint32_t value) {
+  if (value < 2) return 2;
+
+  --value;
+  value |= value >> 1;
+  value |= value >> 2;
+  value |= value >> 4;
+  value |= value >> 8;
+  value |= value >> 16;
+  return value + 1;
+}
+
+void copy_vec3(float target[3], const JPH_Vec3& source) {
+  target[0] = source.x;
+  target[1] = source.y;
+  target[2] = source.z;
+}
+
+void copy_rvec3(float target[3], const JPH_RVec3& source) {
+  target[0] = static_cast<float>(source.x);
+  target[1] = static_cast<float>(source.y);
+  target[2] = static_cast<float>(source.z);
+}
+
+}  // namespace
+
+struct JR_ContactQueue {
+  explicit JR_ContactQueue(uint32_t requested_capacity)
+      : capacity(next_power_of_two(requested_capacity)),
+        mask(capacity - 1),
+        slots(new Slot[capacity]) {
+    for (size_t index = 0; index < capacity; ++index) {
+      slots[index].sequence.store(index, std::memory_order_relaxed);
+    }
+  }
+
+  bool push(const JR_ContactEvent& event) {
+    size_t position = enqueue_position.load(std::memory_order_relaxed);
+    Slot* slot = nullptr;
+
+    for (;;) {
+      slot = &slots[position & mask];
+      const size_t sequence = slot->sequence.load(std::memory_order_acquire);
+      const intptr_t difference = static_cast<intptr_t>(sequence) - static_cast<intptr_t>(position);
+      if (difference == 0) {
+        if (enqueue_position.compare_exchange_weak(position, position + 1, std::memory_order_relaxed)) break;
+      } else if (difference < 0) {
+        dropped.fetch_add(1, std::memory_order_relaxed);
+        return false;
+      } else {
+        position = enqueue_position.load(std::memory_order_relaxed);
+      }
+    }
+
+    slot->event = event;
+    slot->sequence.store(position + 1, std::memory_order_release);
+    return true;
+  }
+
+  bool pop(JR_ContactEvent& event) {
+    size_t position = dequeue_position.load(std::memory_order_relaxed);
+    Slot* slot = nullptr;
+
+    for (;;) {
+      slot = &slots[position & mask];
+      const size_t sequence = slot->sequence.load(std::memory_order_acquire);
+      const intptr_t difference =
+          static_cast<intptr_t>(sequence) - static_cast<intptr_t>(position + 1);
+      if (difference == 0) {
+        if (dequeue_position.compare_exchange_weak(position, position + 1, std::memory_order_relaxed)) break;
+      } else if (difference < 0) {
+        return false;
+      } else {
+        position = dequeue_position.load(std::memory_order_relaxed);
+      }
+    }
+
+    event = slot->event;
+    slot->sequence.store(position + capacity, std::memory_order_release);
+    return true;
+  }
+
+  const size_t capacity;
+  const size_t mask;
+  std::unique_ptr<Slot[]> slots;
+  alignas(64) std::atomic<size_t> enqueue_position{0};
+  alignas(64) std::atomic<size_t> dequeue_position{0};
+  std::atomic<uint64_t> dropped{0};
+  JPH_ContactListener* listener{nullptr};
+};
+
+namespace {
+
+JPH_ValidateResult on_contact_validate(
+    void*,
+    const JPH_Body*,
+    const JPH_Body*,
+    const JPH_RVec3*,
+    const JPH_CollideShapeResult*) {
+  return JPH_ValidateResult_AcceptAllContactsForThisBodyPair;
+}
+
+void push_manifold_event(
+    JR_ContactQueue* queue,
+    JR_ContactEventType type,
+    const JPH_Body* body1,
+    const JPH_Body* body2,
+    const JPH_ContactManifold* manifold) {
+  JR_ContactEvent event{};
+  event.type = type;
+  event.body_a = JPH_Body_GetID(body1);
+  event.body_b = JPH_Body_GetID(body2);
+  event.sub_shape_a = JPH_ContactManifold_GetSubShapeID1(manifold);
+  event.sub_shape_b = JPH_ContactManifold_GetSubShapeID2(manifold);
+  event.penetration = JPH_ContactManifold_GetPenetrationDepth(manifold);
+
+  JPH_Vec3 normal{};
+  JPH_ContactManifold_GetWorldSpaceNormal(manifold, &normal);
+  copy_vec3(event.normal, normal);
+
+  if (JPH_ContactManifold_GetPointCount(manifold) > 0) {
+    JPH_RVec3 point{};
+    JPH_ContactManifold_GetWorldSpaceContactPointOn1(manifold, 0, &point);
+    copy_rvec3(event.point, point);
+  }
+
+  queue->push(event);
+}
+
+void on_contact_added(
+    void* user_data,
+    const JPH_Body* body1,
+    const JPH_Body* body2,
+    const JPH_ContactManifold* manifold,
+    JPH_ContactSettings*) {
+  push_manifold_event(
+      static_cast<JR_ContactQueue*>(user_data), JR_CONTACT_ADDED, body1, body2, manifold);
+}
+
+void on_contact_persisted(
+    void* user_data,
+    const JPH_Body* body1,
+    const JPH_Body* body2,
+    const JPH_ContactManifold* manifold,
+    JPH_ContactSettings*) {
+  push_manifold_event(
+      static_cast<JR_ContactQueue*>(user_data), JR_CONTACT_PERSISTED, body1, body2, manifold);
+}
+
+void on_contact_removed(void* user_data, const JPH_SubShapeIDPair* pair) {
+  JR_ContactEvent event{};
+  event.type = JR_CONTACT_REMOVED;
+  event.body_a = pair->Body1ID;
+  event.body_b = pair->Body2ID;
+  event.sub_shape_a = pair->subShapeID1;
+  event.sub_shape_b = pair->subShapeID2;
+  static_cast<JR_ContactQueue*>(user_data)->push(event);
+}
+
+void install_contact_procs() {
+  static JPH_ContactListener_Procs procs{};
+  procs.OnContactValidate = on_contact_validate;
+  procs.OnContactAdded = on_contact_added;
+  procs.OnContactPersisted = on_contact_persisted;
+  procs.OnContactRemoved = on_contact_removed;
+  JPH_ContactListener_SetProcs(&procs);
+}
+
+}  // namespace
+
+JR_ContactQueue* JR_ContactQueue_Create(uint32_t capacity) {
+  if (capacity < 2 || capacity > (1U << 30)) return nullptr;
+
+  static std::once_flag contact_procs_once;
+  std::call_once(contact_procs_once, install_contact_procs);
+
+  JR_ContactQueue* queue = nullptr;
+  try {
+    queue = new JR_ContactQueue(capacity);
+  } catch (const std::bad_alloc&) {
+    return nullptr;
+  }
+  queue->listener = JPH_ContactListener_Create(queue);
+  if (queue->listener) return queue;
+
+  delete queue;
+  return nullptr;
+}
+
+void JR_ContactQueue_Destroy(JR_ContactQueue* queue) {
+  if (!queue) return;
+
+  if (queue->listener) JPH_ContactListener_Destroy(queue->listener);
+  delete queue;
+}
+
+JPH_ContactListener* JR_ContactQueue_GetListener(JR_ContactQueue* queue) {
+  return queue ? queue->listener : nullptr;
+}
+
+bool JR_ContactQueue_Pop(JR_ContactQueue* queue, JR_ContactEvent* event) {
+  return queue && event && queue->pop(*event);
+}
+
+uint64_t JR_ContactQueue_GetDroppedCount(const JR_ContactQueue* queue) {
+  return queue ? queue->dropped.load(std::memory_order_relaxed) : 0;
+}

data/ext/jolt_ruby/helper.h

@@ -0,0 +1,103 @@
+#ifndef JOLT_RUBY_HELPER_H
+#define JOLT_RUBY_HELPER_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#if defined(_WIN32)
+#  define JR_EXPORT __declspec(dllexport)
+#else
+#  define JR_EXPORT __attribute__((visibility("default")))
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct JPH_ContactListener JPH_ContactListener;
+typedef struct JPH_Constraint JPH_Constraint;
+typedef struct JPH_CharacterVirtual JPH_CharacterVirtual;
+typedef struct JPH_PhysicsSystem JPH_PhysicsSystem;
+typedef struct JPH_Shape JPH_Shape;
+
+typedef enum JR_ContactEventType {
+  JR_CONTACT_ADDED = 0,
+  JR_CONTACT_PERSISTED = 1,
+  JR_CONTACT_REMOVED = 2
+} JR_ContactEventType;
+
+typedef struct JR_ContactEvent {
+  uint32_t type;
+  uint32_t body_a;
+  uint32_t body_b;
+  uint32_t sub_shape_a;
+  uint32_t sub_shape_b;
+  float point[3];
+  float normal[3];
+  float penetration;
+} JR_ContactEvent;
+
+typedef struct JR_ContactQueue JR_ContactQueue;
+
+JR_EXPORT JR_ContactQueue* JR_ContactQueue_Create(uint32_t capacity);
+JR_EXPORT void JR_ContactQueue_Destroy(JR_ContactQueue* queue);
+JR_EXPORT JPH_ContactListener* JR_ContactQueue_GetListener(JR_ContactQueue* queue);
+JR_EXPORT bool JR_ContactQueue_Pop(JR_ContactQueue* queue, JR_ContactEvent* event);
+JR_EXPORT uint64_t JR_ContactQueue_GetDroppedCount(const JR_ContactQueue* queue);
+
+JR_EXPORT JPH_Constraint* JR_Constraint_CreateFixed(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor);
+JR_EXPORT JPH_Constraint* JR_Constraint_CreatePoint(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor);
+JR_EXPORT JPH_Constraint* JR_Constraint_CreateDistance(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* point_a,
+    const float* point_b,
+    float min_distance,
+    float max_distance);
+JR_EXPORT JPH_Constraint* JR_Constraint_CreateHinge(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor,
+    const float* axis,
+    const float* normal,
+    bool has_limits,
+    float min_angle,
+    float max_angle);
+JR_EXPORT JPH_Constraint* JR_Constraint_CreateSlider(
+    JPH_PhysicsSystem* system,
+    uint32_t body_a,
+    uint32_t body_b,
+    const float* anchor,
+    const float* axis,
+    bool has_limits,
+    float min_distance,
+    float max_distance);
+
+JR_EXPORT JPH_CharacterVirtual* JR_CharacterVirtual_Create(
+    JPH_PhysicsSystem* system,
+    const JPH_Shape* shape,
+    const float* position,
+    const float* rotation,
+    float max_slope_angle,
+    float mass);
+JR_EXPORT void JR_CharacterVirtual_ExtendedUpdate(
+    JPH_CharacterVirtual* character,
+    float delta_time,
+    uint32_t layer,
+    JPH_PhysicsSystem* system);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/joltc/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: [amerkoleci]