bullet3 0.1.0

data/ext/bullet3/soft_body/rb_soft_body.hpp

@@ -0,0 +1,122 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <BulletSoftBody/btSoftBodyHelpers.h>
+#include <BulletSoftBody/btSoftBodyRigidBodyCollisionConfiguration.h>
+#include <BulletSoftBody/btSoftRigidDynamicsWorld.h>
+#include <rice/rice.hpp>
+
+#include "../dynamics/rb_dynamics.hpp"
+
+namespace bullet3 {
+class SoftBodyWorldInfo {
+public:
+  SoftBodyWorldInfo();
+  explicit SoftBodyWorldInfo(btSoftBodyWorldInfo* world_info);
+
+  btSoftBodyWorldInfo& get();
+  const btSoftBodyWorldInfo& get() const;
+  btVector3 gravity() const;
+  btVector3 set_gravity(Rice::Object gravity);
+  btScalar air_density() const;
+  btScalar set_air_density(btScalar value);
+  btScalar water_density() const;
+  btScalar set_water_density(btScalar value);
+  btScalar water_offset() const;
+  btScalar set_water_offset(btScalar value);
+  btVector3 water_normal() const;
+  btVector3 set_water_normal(Rice::Object normal);
+  btScalar max_displacement() const;
+  btScalar set_max_displacement(btScalar value);
+  void reset_sparse_sdf();
+
+private:
+  std::unique_ptr<btSoftBodyWorldInfo> owned_world_info_;
+  btSoftBodyWorldInfo* world_info_;
+};
+
+class SoftBody {
+public:
+  explicit SoftBody(btSoftBody* soft_body);
+
+  btSoftBody* get();
+  const btSoftBody* get() const;
+  int node_count() const;
+  int link_count() const;
+  int face_count() const;
+  int tetra_count() const;
+  int cluster_count() const;
+  btScalar total_mass() const;
+  void set_total_mass(btScalar mass, bool from_faces);
+  btScalar node_mass(int index) const;
+  btScalar set_node_mass(int index, btScalar mass);
+  btVector3 node_position(int index) const;
+  btVector3 node_velocity(int index) const;
+  btVector3 center_of_mass() const;
+  btVector3 linear_velocity();
+  void set_linear_velocity(Rice::Object velocity);
+  void set_velocity(Rice::Object velocity);
+  void set_angular_velocity(Rice::Object velocity);
+  void add_force(Rice::Object force);
+  void add_velocity(Rice::Object velocity);
+  void translate(Rice::Object translation);
+  void rotate(Rice::Object rotation);
+  void scale(Rice::Object scaling);
+  void transform(Rice::Object transform);
+  void set_pose(bool volume, bool frame);
+  int generate_bending_constraints(int distance);
+  int generate_clusters(int count);
+  void randomize_constraints();
+  btVector3 wind_velocity();
+  btVector3 set_wind_velocity(Rice::Object velocity);
+  void set_zero_velocity();
+  bool self_collision();
+  bool set_self_collision(bool enabled);
+  Rice::Array aabb() const;
+  Rice::Object ray_test(Rice::Object from, Rice::Object to);
+  void append_anchor(int node, RigidBody& rigid_body, bool disable_collision_between_linked_bodies, btScalar influence);
+
+private:
+  int validate_node_index(int index) const;
+
+  std::unique_ptr<btSoftBody> soft_body_;
+};
+
+class SoftRigidDynamicsWorld {
+public:
+  SoftRigidDynamicsWorld();
+  ~SoftRigidDynamicsWorld();
+
+  btSoftRigidDynamicsWorld* get();
+  btVector3 gravity() const;
+  btVector3 set_gravity(Rice::Object gravity);
+  SoftBodyWorldInfo* world_info();
+  void add_rigid_body_object(VALUE rigid_body);
+  void remove_rigid_body_object(VALUE rigid_body);
+  void add_soft_body_object(VALUE soft_body, int collision_filter_group, int collision_filter_mask);
+  void remove_soft_body_object(VALUE soft_body);
+  int step_simulation(btScalar time_step, int max_sub_steps, btScalar fixed_time_step);
+  int num_collision_objects() const;
+  int num_soft_bodies() const;
+  int draw_flags() const;
+  int set_draw_flags(int flags);
+  void clear_forces();
+  void mark() const;
+
+private:
+  std::unique_ptr<btSoftBodyRigidBodyCollisionConfiguration> configuration_;
+  std::unique_ptr<btCollisionDispatcher> dispatcher_;
+  std::unique_ptr<btDbvtBroadphase> broadphase_;
+  std::unique_ptr<btSequentialImpulseConstraintSolver> solver_;
+  std::unique_ptr<btSoftRigidDynamicsWorld> world_;
+  std::unordered_set<btRigidBody*> rigid_bodies_;
+  std::unordered_set<btSoftBody*> soft_bodies_;
+  std::unordered_map<const btCollisionObject*, VALUE> collision_object_values_;
+  std::unordered_map<const btSoftBody*, VALUE> soft_body_values_;
+};
+} // namespace bullet3
+
+void Init_SoftBody(Rice::Module rb_mBullet);

data/ext/bullet3/util/rb_debug_draw.cpp

@@ -0,0 +1,250 @@
+#include "rb_debug_draw.hpp"
+
+#include <ruby.h>
+
+#include "type_conversions.hpp"
+
+namespace {
+VALUE array_from_vector(const btVector3& vector)
+{
+  return rb_ary_new_from_args(3,
+    DBL2NUM(vector.getX()),
+    DBL2NUM(vector.getY()),
+    DBL2NUM(vector.getZ()));
+}
+
+VALUE line_hash(const btVector3& from, const btVector3& to, const btVector3& color)
+{
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, ID2SYM(rb_intern("from")), array_from_vector(from));
+  rb_hash_aset(hash, ID2SYM(rb_intern("to")), array_from_vector(to));
+  rb_hash_aset(hash, ID2SYM(rb_intern("color")), array_from_vector(color));
+  return hash;
+}
+
+VALUE contact_hash(const btVector3& point,
+                   const btVector3& normal,
+                   btScalar distance,
+                   int life_time,
+                   const btVector3& color)
+{
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, ID2SYM(rb_intern("point")), array_from_vector(point));
+  rb_hash_aset(hash, ID2SYM(rb_intern("normal")), array_from_vector(normal));
+  rb_hash_aset(hash, ID2SYM(rb_intern("distance")), DBL2NUM(distance));
+  rb_hash_aset(hash, ID2SYM(rb_intern("life_time")), INT2NUM(life_time));
+  rb_hash_aset(hash, ID2SYM(rb_intern("color")), array_from_vector(color));
+  return hash;
+}
+
+VALUE text_hash(const btVector3& location, const char* text)
+{
+  VALUE hash = rb_hash_new();
+  rb_hash_aset(hash, ID2SYM(rb_intern("location")), array_from_vector(location));
+  rb_hash_aset(hash, ID2SYM(rb_intern("text")), rb_str_new_cstr(text));
+  return hash;
+}
+} // namespace
+
+namespace bullet3 {
+DebugDraw::DebugDraw()
+  : DebugDraw(Qnil)
+{
+}
+
+DebugDraw::DebugDraw(VALUE target)
+  : target_(target),
+    lines_(rb_ary_new()),
+    contact_points_(rb_ary_new()),
+    warnings_(rb_ary_new()),
+    texts_(rb_ary_new()),
+    debug_mode_(DBG_DrawWireframe | DBG_DrawAabb | DBG_DrawConstraints | DBG_DrawConstraintLimits)
+{
+}
+
+btIDebugDraw* DebugDraw::get()
+{
+  return this;
+}
+
+Rice::Array DebugDraw::lines() const
+{
+  return Rice::Array(Rice::Object(lines_));
+}
+
+Rice::Array DebugDraw::contact_points() const
+{
+  return Rice::Array(Rice::Object(contact_points_));
+}
+
+Rice::Array DebugDraw::warnings() const
+{
+  return Rice::Array(Rice::Object(warnings_));
+}
+
+Rice::Array DebugDraw::texts() const
+{
+  return Rice::Array(Rice::Object(texts_));
+}
+
+void DebugDraw::clear()
+{
+  rb_ary_clear(lines_);
+  rb_ary_clear(contact_points_);
+  rb_ary_clear(warnings_);
+  rb_ary_clear(texts_);
+}
+
+void DebugDraw::draw_line_object(VALUE from, VALUE to, VALUE color)
+{
+  drawLine(
+    coerce_vector(Rice::Object(from)),
+    coerce_vector(Rice::Object(to)),
+    coerce_vector(Rice::Object(color)));
+}
+
+void DebugDraw::draw_contact_point_object(VALUE point, VALUE normal, btScalar distance, int life_time, VALUE color)
+{
+  drawContactPoint(
+    coerce_vector(Rice::Object(point)),
+    coerce_vector(Rice::Object(normal)),
+    distance,
+    life_time,
+    coerce_vector(Rice::Object(color)));
+}
+
+void DebugDraw::report_error_warning_object(VALUE warning)
+{
+  reportErrorWarning(StringValueCStr(warning));
+}
+
+void DebugDraw::draw_3d_text_object(VALUE location, VALUE text)
+{
+  draw3dText(coerce_vector(Rice::Object(location)), StringValueCStr(text));
+}
+
+void DebugDraw::drawLine(const btVector3& from, const btVector3& to, const btVector3& color)
+{
+  VALUE entry = line_hash(from, to, color);
+  rb_ary_push(lines_, entry);
+
+  VALUE args[] = {
+    rb_hash_aref(entry, ID2SYM(rb_intern("from"))),
+    rb_hash_aref(entry, ID2SYM(rb_intern("to"))),
+    rb_hash_aref(entry, ID2SYM(rb_intern("color")))
+  };
+  call_target("draw_line", 3, args);
+}
+
+void DebugDraw::drawContactPoint(const btVector3& point_on_b,
+                                 const btVector3& normal_on_b,
+                                 btScalar distance,
+                                 int life_time,
+                                 const btVector3& color)
+{
+  VALUE entry = contact_hash(point_on_b, normal_on_b, distance, life_time, color);
+  rb_ary_push(contact_points_, entry);
+  VALUE args[] = { entry };
+  call_target("draw_contact_point", 1, args);
+}
+
+void DebugDraw::reportErrorWarning(const char* warning_string)
+{
+  VALUE warning = rb_str_new_cstr(warning_string);
+  rb_ary_push(warnings_, warning);
+  VALUE args[] = { warning };
+  call_target("report_error_warning", 1, args);
+}
+
+void DebugDraw::draw3dText(const btVector3& location, const char* text_string)
+{
+  VALUE entry = text_hash(location, text_string);
+  rb_ary_push(texts_, entry);
+  VALUE args[] = {
+    rb_hash_aref(entry, ID2SYM(rb_intern("location"))),
+    rb_hash_aref(entry, ID2SYM(rb_intern("text")))
+  };
+  call_target("draw_3d_text", 2, args);
+}
+
+void DebugDraw::setDebugMode(int debug_mode)
+{
+  debug_mode_ = debug_mode;
+}
+
+int DebugDraw::getDebugMode() const
+{
+  return debug_mode_;
+}
+
+void DebugDraw::call_target(const char* method_name, int argc, const VALUE* argv) const
+{
+  if (NIL_P(target_)) {
+    return;
+  }
+
+  ID method_id = rb_intern(method_name);
+  if (!rb_respond_to(target_, method_id)) {
+    return;
+  }
+
+  rb_funcallv(target_, method_id, argc, argv);
+}
+
+void DebugDraw::mark() const
+{
+  rb_gc_mark(target_);
+  rb_gc_mark(lines_);
+  rb_gc_mark(contact_points_);
+  rb_gc_mark(warnings_);
+  rb_gc_mark(texts_);
+}
+} // namespace bullet3
+
+namespace Rice {
+template <>
+void ruby_mark<bullet3::DebugDraw>(bullet3::DebugDraw* debug_draw)
+{
+  if (debug_draw != nullptr) {
+    debug_draw->mark();
+  }
+}
+} // namespace Rice
+
+void Init_DebugDraw(Rice::Module rb_mBullet)
+{
+  Rice::Class rb_cDebugDraw = Rice::define_class_under<bullet3::DebugDraw>(rb_mBullet, "DebugDraw")
+    .define_constructor(Rice::Constructor<bullet3::DebugDraw>())
+    .define_constructor(Rice::Constructor<bullet3::DebugDraw, VALUE>(),
+      Rice::Arg("target").setValue().keepAlive())
+    .define_method("lines", &bullet3::DebugDraw::lines)
+    .define_method("contact_points", &bullet3::DebugDraw::contact_points)
+    .define_method("warnings", &bullet3::DebugDraw::warnings)
+    .define_method("texts", &bullet3::DebugDraw::texts)
+    .define_method("clear", &bullet3::DebugDraw::clear)
+    .define_method("draw_line", &bullet3::DebugDraw::draw_line_object,
+      Rice::Arg("from").setValue(),
+      Rice::Arg("to").setValue(),
+      Rice::Arg("color").setValue())
+    .define_method("draw_contact_point", &bullet3::DebugDraw::draw_contact_point_object,
+      Rice::Arg("point").setValue(),
+      Rice::Arg("normal").setValue(),
+      Rice::Arg("distance"),
+      Rice::Arg("life_time"),
+      Rice::Arg("color").setValue())
+    .define_method("report_error_warning", &bullet3::DebugDraw::report_error_warning_object,
+      Rice::Arg("warning").setValue())
+    .define_method("draw_3d_text", &bullet3::DebugDraw::draw_3d_text_object,
+      Rice::Arg("location").setValue(),
+      Rice::Arg("text").setValue())
+    .define_method("debug_mode", &bullet3::DebugDraw::getDebugMode)
+    .define_method("debug_mode=", &bullet3::DebugDraw::setDebugMode);
+
+  rb_cDebugDraw.define_constant("NO_DEBUG", static_cast<int>(btIDebugDraw::DBG_NoDebug));
+  rb_cDebugDraw.define_constant("DRAW_WIREFRAME", static_cast<int>(btIDebugDraw::DBG_DrawWireframe));
+  rb_cDebugDraw.define_constant("DRAW_AABB", static_cast<int>(btIDebugDraw::DBG_DrawAabb));
+  rb_cDebugDraw.define_constant("DRAW_CONTACT_POINTS", static_cast<int>(btIDebugDraw::DBG_DrawContactPoints));
+  rb_cDebugDraw.define_constant("DRAW_CONSTRAINTS", static_cast<int>(btIDebugDraw::DBG_DrawConstraints));
+  rb_cDebugDraw.define_constant("DRAW_CONSTRAINT_LIMITS", static_cast<int>(btIDebugDraw::DBG_DrawConstraintLimits));
+  rb_cDebugDraw.define_constant("DRAW_FRAMES", static_cast<int>(btIDebugDraw::DBG_DrawFrames));
+}

data/ext/bullet3/util/rb_debug_draw.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <LinearMath/btIDebugDraw.h>
+#include <rice/rice.hpp>
+
+namespace bullet3 {
+class DebugDraw : public btIDebugDraw {
+public:
+  DebugDraw();
+  explicit DebugDraw(VALUE target);
+
+  btIDebugDraw* get();
+  Rice::Array lines() const;
+  Rice::Array contact_points() const;
+  Rice::Array warnings() const;
+  Rice::Array texts() const;
+  void clear();
+  void draw_line_object(VALUE from, VALUE to, VALUE color);
+  void draw_contact_point_object(VALUE point, VALUE normal, btScalar distance, int life_time, VALUE color);
+  void report_error_warning_object(VALUE warning);
+  void draw_3d_text_object(VALUE location, VALUE text);
+  void mark() const;
+
+  void drawLine(const btVector3& from, const btVector3& to, const btVector3& color) override;
+  void drawContactPoint(const btVector3& point_on_b,
+                        const btVector3& normal_on_b,
+                        btScalar distance,
+                        int life_time,
+                        const btVector3& color) override;
+  void reportErrorWarning(const char* warning_string) override;
+  void draw3dText(const btVector3& location, const char* text_string) override;
+  void setDebugMode(int debug_mode) override;
+  int getDebugMode() const override;
+
+private:
+  void call_target(const char* method_name, int argc, const VALUE* argv) const;
+
+  VALUE target_;
+  VALUE lines_;
+  VALUE contact_points_;
+  VALUE warnings_;
+  VALUE texts_;
+  int debug_mode_;
+};
+} // namespace bullet3
+
+void Init_DebugDraw(Rice::Module rb_mBullet);

data/ext/bullet3/util/ruby_cpp_compat.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+// Ruby 3.1 can define memcpy as a macro; include C++ headers before Ruby/Rice.
+#include <algorithm>
+#include <any>
+#include <complex>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <iostream>
+#include <locale>
+#include <map>
+#include <memory>
+#include <optional>
+#include <ostream>
+#include <set>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <tuple>
+#include <type_traits>
+#include <typeindex>
+#include <typeinfo>
+#include <unordered_map>
+#include <utility>
+#include <variant>
+#include <vector>

data/ext/bullet3/util/type_conversions.hpp

@@ -0,0 +1,107 @@
+#pragma once
+
+#include <stdexcept>
+
+#include <LinearMath/btQuaternion.h>
+#include <LinearMath/btVector3.h>
+#include <rice/rice.hpp>
+
+namespace bullet3 {
+template <typename Value_T>
+inline btScalar scalar_from_object(Value_T object)
+{
+  return Rice::detail::From_Ruby<btScalar>().convert(object);
+}
+
+inline bool object_responds_to(Rice::Object object, const char* method_name)
+{
+  return rb_respond_to(object.value(), rb_intern(method_name)) != 0;
+}
+
+inline Rice::Array array_from_object(Rice::Object object)
+{
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    return Rice::Array(object);
+  }
+
+  if (object_responds_to(object, "to_a")) {
+    return Rice::Array(object.call("to_a"));
+  }
+
+  throw std::invalid_argument("expected an Array-like object");
+}
+
+inline btVector3 vector_from_array(Rice::Object object)
+{
+  Rice::Array array = array_from_object(object);
+  if (array.size() != 3) {
+    throw std::invalid_argument("expected a 3-element Array");
+  }
+
+  return btVector3(
+    scalar_from_object(array[0]),
+    scalar_from_object(array[1]),
+    scalar_from_object(array[2])
+  );
+}
+
+inline btVector3 coerce_vector(Rice::Object object)
+{
+  if (object.is_nil()) {
+    throw std::invalid_argument("expected Bullet3::Vector3 or a 3-element Array");
+  }
+
+  if (rb_obj_is_kind_of(object.value(), rb_cArray) || object_responds_to(object, "to_a")) {
+    return vector_from_array(object);
+  }
+
+  return *Rice::detail::From_Ruby<btVector3*>().convert(object);
+}
+
+inline btQuaternion quaternion_from_array(Rice::Object object)
+{
+  Rice::Array array = array_from_object(object);
+  if (array.size() != 4) {
+    throw std::invalid_argument("expected a 4-element Array");
+  }
+
+  return btQuaternion(
+    scalar_from_object(array[0]),
+    scalar_from_object(array[1]),
+    scalar_from_object(array[2]),
+    scalar_from_object(array[3])
+  );
+}
+
+inline btQuaternion coerce_quaternion(Rice::Object object)
+{
+  if (object.is_nil()) {
+    throw std::invalid_argument("expected Bullet3::Quaternion or a 4-element Array");
+  }
+
+  if (rb_obj_is_kind_of(object.value(), rb_cArray) || object_responds_to(object, "to_a")) {
+    return quaternion_from_array(object);
+  }
+
+  return *Rice::detail::From_Ruby<btQuaternion*>().convert(object);
+}
+
+inline Rice::Array vector_to_array(const btVector3& vector)
+{
+  Rice::Array array;
+  array.push(vector.getX());
+  array.push(vector.getY());
+  array.push(vector.getZ());
+  return array;
+}
+
+inline Rice::Array quaternion_to_array(const btQuaternion& quaternion)
+{
+  Rice::Array array;
+  array.push(quaternion.getX());
+  array.push(quaternion.getY());
+  array.push(quaternion.getZ());
+  array.push(quaternion.getW());
+  return array;
+}
+} // namespace bullet3