bullet3 0.1.0

data/ext/bullet3/dynamics/rb_dynamics.hpp

@@ -0,0 +1,180 @@
+#pragma once
+
+#include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
+#include <btBulletDynamicsCommon.h>
+#include <rice/rice.hpp>
+
+#include "../linear_math/rb_transform.hpp"
+#include "../util/rb_debug_draw.hpp"
+
+namespace bullet3 {
+class RaycastVehicle;
+
+class CollisionConfiguration {
+public:
+  CollisionConfiguration();
+
+  btDefaultCollisionConfiguration* get();
+
+private:
+  std::unique_ptr<btDefaultCollisionConfiguration> configuration_;
+};
+
+class CollisionDispatcher {
+public:
+  explicit CollisionDispatcher(CollisionConfiguration& configuration);
+
+  btCollisionDispatcher* get();
+
+private:
+  std::unique_ptr<btCollisionDispatcher> dispatcher_;
+};
+
+class DbvtBroadphase {
+public:
+  DbvtBroadphase();
+
+  btDbvtBroadphase* get();
+
+private:
+  std::unique_ptr<btDbvtBroadphase> broadphase_;
+};
+
+class SequentialImpulseConstraintSolver {
+public:
+  SequentialImpulseConstraintSolver();
+
+  btSequentialImpulseConstraintSolver* get();
+
+private:
+  std::unique_ptr<btSequentialImpulseConstraintSolver> solver_;
+};
+
+class MotionState {
+public:
+  MotionState();
+  explicit MotionState(VALUE start_transform);
+
+  btMotionState* get();
+  Transform world_transform() const;
+  Transform set_world_transform(Rice::Object transform);
+
+private:
+  std::unique_ptr<btDefaultMotionState> motion_state_;
+};
+
+class RigidBodyConstructionInfo {
+public:
+  RigidBodyConstructionInfo(btScalar mass, MotionState& motion_state, VALUE collision_shape);
+  RigidBodyConstructionInfo(btScalar mass, MotionState& motion_state, VALUE collision_shape, VALUE local_inertia);
+
+  btRigidBody::btRigidBodyConstructionInfo& get();
+  btScalar mass() const;
+  btVector3 local_inertia() const;
+  btScalar friction() const;
+  btScalar set_friction(btScalar friction);
+  btScalar restitution() const;
+  btScalar set_restitution(btScalar restitution);
+
+private:
+  btVector3 local_inertia_;
+  std::unique_ptr<btRigidBody::btRigidBodyConstructionInfo> info_;
+};
+
+class RigidBody {
+public:
+  explicit RigidBody(RigidBodyConstructionInfo& construction_info);
+
+  btRigidBody* get();
+  const btRigidBody* get() const;
+
+  btScalar mass() const;
+  btCollisionShape* collision_shape() const;
+  Transform world_transform() const;
+  Transform set_world_transform(Rice::Object transform);
+  btVector3 linear_velocity() const;
+  btVector3 set_linear_velocity(Rice::Object velocity);
+  btVector3 angular_velocity() const;
+  btVector3 set_angular_velocity(Rice::Object velocity);
+  btVector3 total_force() const;
+  btVector3 total_torque() const;
+  btScalar friction() const;
+  btScalar set_friction(btScalar friction);
+  btScalar restitution() const;
+  btScalar set_restitution(btScalar restitution);
+  Rice::Array damping() const;
+  Rice::Array set_damping(btScalar linear_damping, btScalar angular_damping);
+  void apply_central_force(Rice::Object force);
+  void apply_force(Rice::Object force, Rice::Object relative_position);
+  void apply_torque(Rice::Object torque);
+  void apply_central_impulse(Rice::Object impulse);
+  void apply_impulse(Rice::Object impulse, Rice::Object relative_position);
+  void clear_forces();
+  void activate();
+  bool active() const;
+  bool static_object() const;
+  bool kinematic_object() const;
+
+private:
+  std::unique_ptr<btRigidBody> rigid_body_;
+};
+
+class DiscreteDynamicsWorld {
+public:
+  DiscreteDynamicsWorld();
+  DiscreteDynamicsWorld(CollisionDispatcher& dispatcher,
+                        DbvtBroadphase& broadphase,
+                        SequentialImpulseConstraintSolver& solver,
+                        CollisionConfiguration& configuration);
+  ~DiscreteDynamicsWorld();
+
+  btDiscreteDynamicsWorld* get();
+  btVector3 gravity() const;
+  btVector3 set_gravity(Rice::Object gravity);
+  void add_rigid_body(RigidBody& rigid_body);
+  void add_rigid_body_object(VALUE rigid_body);
+  void remove_rigid_body(RigidBody& rigid_body);
+  void remove_rigid_body_object(VALUE rigid_body);
+  void add_constraint_object(VALUE constraint, bool disable_collisions_between_linked_bodies);
+  void remove_constraint_object(VALUE constraint);
+  void add_vehicle_object(VALUE vehicle);
+  void remove_vehicle_object(VALUE vehicle);
+  int step_simulation(btScalar time_step, int max_sub_steps, btScalar fixed_time_step);
+  int num_collision_objects() const;
+  int num_constraints() const;
+  void clear_forces();
+  void synchronize_motion_states();
+  Rice::Object ray_test_closest(Rice::Object from, Rice::Object to) const;
+  Rice::Array ray_test_all(Rice::Object from, Rice::Object to) const;
+  Rice::Array contact_test(VALUE rigid_body) const;
+  Rice::Array contact_pair_test(VALUE rigid_body_a, VALUE rigid_body_b) const;
+  Rice::Array closest_points(VALUE rigid_body_a, VALUE rigid_body_b, btScalar distance_threshold) const;
+  Rice::Array contact_manifolds() const;
+  void set_debug_drawer(VALUE debug_drawer);
+  VALUE debug_drawer() const;
+  void debug_draw_world();
+  void mark() const;
+
+private:
+  void build_owned_world();
+  VALUE ruby_object_for(const btCollisionObject* collision_object) const;
+
+  std::unique_ptr<btDefaultCollisionConfiguration> owned_configuration_;
+  std::unique_ptr<btCollisionDispatcher> owned_dispatcher_;
+  std::unique_ptr<btDbvtBroadphase> owned_broadphase_;
+  std::unique_ptr<btSequentialImpulseConstraintSolver> owned_solver_;
+  std::unique_ptr<btDiscreteDynamicsWorld> world_;
+  std::unordered_set<btRigidBody*> rigid_bodies_;
+  std::unordered_set<btTypedConstraint*> constraints_;
+  std::unordered_set<btActionInterface*> actions_;
+  std::unordered_map<const btCollisionObject*, VALUE> collision_object_values_;
+  std::unordered_map<const btTypedConstraint*, VALUE> constraint_values_;
+  std::unordered_map<const btActionInterface*, VALUE> action_values_;
+  VALUE debug_drawer_value_ = Qnil;
+};
+} // namespace bullet3
+
+void Init_Dynamics(Rice::Module rb_mBullet);

data/ext/bullet3/extconf.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "mkmf"
+require "rbconfig"
+
+extension_name = "bullet3"
+extension_suffix = RbConfig::CONFIG.fetch("DLEXT")
+source_dir = __dir__
+build_dir = File.expand_path("build", source_dir)
+output_dir = File.expand_path("../../lib/bullet3", source_dir)
+staging_extension = File.expand_path("#{extension_name}.#{extension_suffix}", Dir.pwd)
+
+cmake_args = [
+  "-S", source_dir,
+  "-B", build_dir,
+  "-DCMAKE_BUILD_TYPE=#{ENV.fetch("BULLET3_BUILD_TYPE", "Release")}",
+  "-DRUBY_EXECUTABLE=#{RbConfig.ruby}",
+  "-DRUBY_EXTENSION_SUFFIX=.#{extension_suffix}"
+]
+
+if ENV["BULLET3_SKIP_NATIVE"] == "1"
+  File.write("Makefile", <<~MAKEFILE)
+    all:
+
+    install:
+
+    clean:
+
+  MAKEFILE
+  exit
+end
+
+abort "CMake is required to build bullet3" unless find_executable("cmake")
+
+FileUtils.mkdir_p(build_dir)
+system("cmake", *cmake_args) || abort("cmake configure failed")
+system(
+  "cmake",
+  "--build", build_dir,
+  "--target", extension_name,
+  "--config", ENV.fetch("BULLET3_BUILD_TYPE", "Release")
+) || abort("cmake build failed")
+
+FileUtils.mkdir_p(output_dir)
+built_extension = File.join(build_dir, "#{extension_name}.#{extension_suffix}")
+FileUtils.cp(built_extension, staging_extension)
+FileUtils.cp(built_extension, File.join(output_dir, "#{extension_name}.#{extension_suffix}"))
+
+File.write("Makefile", <<~MAKEFILE)
+  all:
+
+  install:
+
+  clean:
+
+MAKEFILE

data/ext/bullet3/io/rb_io.cpp

@@ -0,0 +1,108 @@
+#include "rb_io.hpp"
+
+#include <fstream>
+#include <stdexcept>
+
+#include <LinearMath/btSerializer.h>
+
+#ifdef BULLET3_WITH_WORLD_IMPORTER
+#include <btBulletWorldImporter.h>
+#endif
+
+namespace bullet3 {
+VALUE DefaultSerializer::serialize_world(DiscreteDynamicsWorld& world) const
+{
+  btDefaultSerializer serializer;
+  world.get()->serialize(&serializer);
+  return rb_str_new(
+    reinterpret_cast<const char*>(serializer.getBufferPointer()),
+    serializer.getCurrentBufferSize());
+}
+
+std::string DefaultSerializer::save_world(DiscreteDynamicsWorld& world, const std::string& filename) const
+{
+  VALUE serialized = serialize_world(world);
+  std::ofstream output(filename, std::ios::binary);
+  if (!output) {
+    throw std::runtime_error("failed to open .bullet file for writing: " + filename);
+  }
+
+  output.write(RSTRING_PTR(serialized), RSTRING_LEN(serialized));
+  if (!output) {
+    throw std::runtime_error("failed to write .bullet file: " + filename);
+  }
+
+  return filename;
+}
+
+#ifdef BULLET3_WITH_WORLD_IMPORTER
+BulletWorldImporter::BulletWorldImporter(DiscreteDynamicsWorld& world)
+  : importer_(std::make_unique<btBulletWorldImporter>(world.get()))
+{
+}
+
+BulletWorldImporter::~BulletWorldImporter() = default;
+
+bool BulletWorldImporter::load_file(const std::string& filename)
+{
+  return importer_->loadFile(filename.c_str());
+}
+
+void BulletWorldImporter::delete_all_data()
+{
+  importer_->deleteAllData();
+}
+
+int BulletWorldImporter::verbose_mode() const
+{
+  return importer_->getVerboseMode();
+}
+
+int BulletWorldImporter::set_verbose_mode(int verbose_mode)
+{
+  importer_->setVerboseMode(verbose_mode);
+  return verbose_mode;
+}
+
+int BulletWorldImporter::num_collision_shapes() const
+{
+  return importer_->getNumCollisionShapes();
+}
+
+int BulletWorldImporter::num_rigid_bodies() const
+{
+  return importer_->getNumRigidBodies();
+}
+
+int BulletWorldImporter::num_constraints() const
+{
+  return importer_->getNumConstraints();
+}
+#endif
+} // namespace bullet3
+
+void Init_IO(Rice::Module rb_mBullet)
+{
+  Rice::Module rb_mIO = Rice::define_module_under(rb_mBullet, "IO");
+
+  Rice::define_class_under<bullet3::DefaultSerializer>(rb_mIO, "DefaultSerializer")
+    .define_constructor(Rice::Constructor<bullet3::DefaultSerializer>())
+    .define_method("serialize_world", &bullet3::DefaultSerializer::serialize_world,
+      Rice::Arg("world").keepAlive())
+    .define_method("save_world", &bullet3::DefaultSerializer::save_world,
+      Rice::Arg("world").keepAlive(),
+      Rice::Arg("filename"));
+
+#ifdef BULLET3_WITH_WORLD_IMPORTER
+  Rice::define_class_under<bullet3::BulletWorldImporter>(rb_mIO, "BulletWorldImporter")
+    .define_constructor(Rice::Constructor<bullet3::BulletWorldImporter, bullet3::DiscreteDynamicsWorld&>(),
+      Rice::Arg("world").keepAlive())
+    .define_method("load_file", &bullet3::BulletWorldImporter::load_file)
+    .define_method("delete_all_data", &bullet3::BulletWorldImporter::delete_all_data)
+    .define_method("verbose_mode", &bullet3::BulletWorldImporter::verbose_mode)
+    .define_method("verbose_mode=", &bullet3::BulletWorldImporter::set_verbose_mode)
+    .define_method("num_collision_shapes", &bullet3::BulletWorldImporter::num_collision_shapes)
+    .define_method("num_rigid_bodies", &bullet3::BulletWorldImporter::num_rigid_bodies)
+    .define_method("num_constraints", &bullet3::BulletWorldImporter::num_constraints);
+#endif
+}

data/ext/bullet3/io/rb_io.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <memory>
+#include <string>
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+#include "../dynamics/rb_dynamics.hpp"
+
+class btBulletWorldImporter;
+
+namespace bullet3 {
+class DefaultSerializer {
+public:
+  VALUE serialize_world(DiscreteDynamicsWorld& world) const;
+  std::string save_world(DiscreteDynamicsWorld& world, const std::string& filename) const;
+};
+
+#ifdef BULLET3_WITH_WORLD_IMPORTER
+class BulletWorldImporter {
+public:
+  explicit BulletWorldImporter(DiscreteDynamicsWorld& world);
+  ~BulletWorldImporter();
+
+  bool load_file(const std::string& filename);
+  void delete_all_data();
+  int verbose_mode() const;
+  int set_verbose_mode(int verbose_mode);
+  int num_collision_shapes() const;
+  int num_rigid_bodies() const;
+  int num_constraints() const;
+
+private:
+  std::unique_ptr<btBulletWorldImporter> importer_;
+};
+#endif
+} // namespace bullet3
+
+void Init_IO(Rice::Module rb_mBullet);

data/ext/bullet3/linear_math/rb_matrix3x3.cpp

@@ -0,0 +1,93 @@
+#include "rb_matrix3x3.hpp"
+
+#include <stdexcept>
+
+#include <LinearMath/btMatrix3x3.h>
+#include <LinearMath/btQuaternion.h>
+#include <LinearMath/btVector3.h>
+#include <rice/rice.hpp>
+
+namespace {
+template <typename Value_T>
+btScalar scalar_from_object(Value_T object)
+{
+  return Rice::detail::From_Ruby<btScalar>().convert(object);
+}
+
+btVector3 vector_from_array(Rice::Object object)
+{
+  Rice::Array array(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])
+  );
+}
+
+btVector3 coerce_vector(Rice::Object object)
+{
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    return vector_from_array(object);
+  }
+
+  return *Rice::detail::From_Ruby<btVector3*>().convert(object);
+}
+
+btQuaternion coerce_quaternion(Rice::Object object)
+{
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    Rice::Array array(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])
+    );
+  }
+
+  return *Rice::detail::From_Ruby<btQuaternion*>().convert(object);
+}
+
+Rice::Array matrix_to_array(const btMatrix3x3& matrix)
+{
+  Rice::Array rows;
+  for (int row_index = 0; row_index < 3; ++row_index) {
+    Rice::Array row;
+    const btVector3& vector = matrix.getRow(row_index);
+    row.push(vector.getX());
+    row.push(vector.getY());
+    row.push(vector.getZ());
+    rows.push(row);
+  }
+  return rows;
+}
+} // namespace
+
+void Init_Matrix3x3(Rice::Module rb_mBullet)
+{
+  Rice::define_class_under<btMatrix3x3>(rb_mBullet, "Matrix3x3")
+    .define_constructor(Rice::Constructor<btMatrix3x3,
+      btScalar, btScalar, btScalar,
+      btScalar, btScalar, btScalar,
+      btScalar, btScalar, btScalar>(),
+      Rice::Arg("xx") = 1.0, Rice::Arg("xy") = 0.0, Rice::Arg("xz") = 0.0,
+      Rice::Arg("yx") = 0.0, Rice::Arg("yy") = 1.0, Rice::Arg("yz") = 0.0,
+      Rice::Arg("zx") = 0.0, Rice::Arg("zy") = 0.0, Rice::Arg("zz") = 1.0)
+    .define_singleton_method("identity", [](Rice::Object) { return btMatrix3x3::getIdentity(); })
+    .define_singleton_method("from_quaternion", [](Rice::Object, Rice::Object quaternion) {
+      return btMatrix3x3(coerce_quaternion(quaternion));
+    })
+    .define_method("*", [](const btMatrix3x3& self, Rice::Object vector) {
+      return self * coerce_vector(vector);
+    })
+    .define_method("transpose", &btMatrix3x3::transpose)
+    .define_method("to_a", &matrix_to_array);
+}

data/ext/bullet3/linear_math/rb_matrix3x3.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <rice/rice.hpp>
+
+void Init_Matrix3x3(Rice::Module rb_mBullet);

data/ext/bullet3/linear_math/rb_quaternion.cpp

@@ -0,0 +1,134 @@
+#include "rb_quaternion.hpp"
+
+#include <cmath>
+#include <stdexcept>
+
+#include <LinearMath/btMatrix3x3.h>
+#include <LinearMath/btQuaternion.h>
+#include <LinearMath/btVector3.h>
+#include <rice/rice.hpp>
+
+namespace {
+constexpr btScalar kEpsilon = btScalar(1e-6);
+
+template <typename Value_T>
+btScalar scalar_from_object(Value_T object)
+{
+  return Rice::detail::From_Ruby<btScalar>().convert(object);
+}
+
+btVector3 vector_from_array(Rice::Object object)
+{
+  Rice::Array array(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])
+  );
+}
+
+btVector3 coerce_vector(Rice::Object object)
+{
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    return vector_from_array(object);
+  }
+
+  return *Rice::detail::From_Ruby<btVector3*>().convert(object);
+}
+
+btQuaternion quaternion_from_array(Rice::Object object)
+{
+  Rice::Array array(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])
+  );
+}
+
+btQuaternion coerce_quaternion(Rice::Object object)
+{
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    return quaternion_from_array(object);
+  }
+
+  return *Rice::detail::From_Ruby<btQuaternion*>().convert(object);
+}
+
+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
+
+void Init_Quaternion(Rice::Module rb_mBullet)
+{
+  Rice::define_class_under<btQuaternion>(rb_mBullet, "Quaternion")
+    .define_constructor(Rice::Constructor<btQuaternion, btScalar, btScalar, btScalar, btScalar>(),
+      Rice::Arg("x") = 0.0,
+      Rice::Arg("y") = 0.0,
+      Rice::Arg("z") = 0.0,
+      Rice::Arg("w") = 1.0)
+    .define_singleton_method("identity", [](Rice::Object) { return btQuaternion(0, 0, 0, 1); })
+    .define_singleton_method("from_axis_angle", [](Rice::Object, Rice::Object axis, btScalar angle) {
+      return btQuaternion(coerce_vector(axis), angle);
+    })
+    .define_singleton_method("from_euler", [](Rice::Object, btScalar roll, btScalar pitch, btScalar yaw) {
+      btQuaternion quaternion;
+      quaternion.setEulerZYX(yaw, pitch, roll);
+      return quaternion;
+    })
+    .define_method("x", &btQuaternion::getX)
+    .define_method("y", &btQuaternion::getY)
+    .define_method("z", &btQuaternion::getZ)
+    .define_method("w", &btQuaternion::getW)
+    .define_method("x=", &btQuaternion::setX)
+    .define_method("y=", &btQuaternion::setY)
+    .define_method("z=", &btQuaternion::setZ)
+    .define_method("w=", &btQuaternion::setW)
+    .define_method("*", [](const btQuaternion& self, Rice::Object other) {
+      return self * coerce_quaternion(other);
+    })
+    .define_method("==", [](const btQuaternion& self, Rice::Object other) {
+      btQuaternion quaternion = coerce_quaternion(other);
+      return std::fabs(self.getX() - quaternion.getX()) <= kEpsilon &&
+             std::fabs(self.getY() - quaternion.getY()) <= kEpsilon &&
+             std::fabs(self.getZ() - quaternion.getZ()) <= kEpsilon &&
+             std::fabs(self.getW() - quaternion.getW()) <= kEpsilon;
+    })
+    .define_method("inverse", &btQuaternion::inverse)
+    .define_method("angle", &btQuaternion::getAngle)
+    .define_method("axis", &btQuaternion::getAxis)
+    .define_method("slerp", [](const btQuaternion& self, Rice::Object other, btScalar t) {
+      return self.slerp(coerce_quaternion(other), t);
+    })
+    .define_method("to_euler", [](const btQuaternion& self) {
+      btScalar yaw;
+      btScalar pitch;
+      btScalar roll;
+      self.getEulerZYX(yaw, pitch, roll);
+
+      Rice::Array array;
+      array.push(roll);
+      array.push(pitch);
+      array.push(yaw);
+      return array;
+    })
+    .define_method("to_matrix", [](const btQuaternion& self) { return btMatrix3x3(self); })
+    .define_method("normalized", &btQuaternion::normalized)
+    .define_method("to_a", &quaternion_to_array);
+}

data/ext/bullet3/linear_math/rb_quaternion.hpp

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <rice/rice.hpp>
+
+void Init_Quaternion(Rice::Module rb_mBullet);