bullet3 0.1.0

data/ext/bullet3/linear_math/rb_transform.cpp

@@ -0,0 +1,157 @@
+#include "rb_transform.hpp"
+
+#include <stdexcept>
+
+#include <LinearMath/btMatrix3x3.h>
+#include <LinearMath/btQuaternion.h>
+#include <LinearMath/btVector3.h>
+#include <rice/rice.hpp>
+
+#include "../util/type_conversions.hpp"
+
+namespace bullet3 {
+Transform::Transform()
+{
+  transform_.setIdentity();
+}
+
+Transform::Transform(VALUE rotation, VALUE origin)
+{
+  transform_.setIdentity();
+  transform_.setRotation(coerce_quaternion(Rice::Object(rotation)));
+  transform_.setOrigin(coerce_vector(Rice::Object(origin)));
+}
+
+Transform::Transform(const btTransform& transform)
+  : transform_(transform)
+{
+}
+
+const btTransform& Transform::value() const
+{
+  return transform_;
+}
+
+btTransform& Transform::value()
+{
+  return transform_;
+}
+
+btVector3 Transform::origin() const
+{
+  return transform_.getOrigin();
+}
+
+btVector3 Transform::set_origin(Rice::Object origin)
+{
+  btVector3 vector = coerce_vector(origin);
+  transform_.setOrigin(vector);
+  return vector;
+}
+
+btQuaternion Transform::rotation() const
+{
+  return transform_.getRotation();
+}
+
+btQuaternion Transform::set_rotation(Rice::Object rotation)
+{
+  btQuaternion quaternion = coerce_quaternion(rotation);
+  transform_.setRotation(quaternion);
+  return quaternion;
+}
+
+btMatrix3x3 Transform::basis() const
+{
+  return transform_.getBasis();
+}
+
+Rice::Object Transform::multiply(Rice::Object other) const
+{
+  if (Rice::Data_Type<Transform>::is_bound() &&
+      rb_obj_is_kind_of(other.value(), Rice::Data_Type<Transform>::klass())) {
+    Transform* transform = Rice::detail::From_Ruby<Transform*>().convert(other);
+    return wrap_transform(transform_ * transform->value());
+  }
+
+  btVector3 vector = coerce_vector(other);
+  return Rice::Object(Rice::detail::To_Ruby<btVector3>().convert(transform_ * vector));
+}
+
+Transform Transform::inverse() const
+{
+  return Transform(transform_.inverse());
+}
+
+Transform Transform::inverse_times(Rice::Object other) const
+{
+  return Transform(transform_.inverseTimes(coerce_transform(other)));
+}
+
+Rice::Array Transform::to_array() const
+{
+  Rice::Array array;
+  array.push(vector_to_array(transform_.getOrigin()));
+  array.push(quaternion_to_array(transform_.getRotation()));
+  return array;
+}
+
+btTransform coerce_transform(Rice::Object object)
+{
+  if (object.is_nil()) {
+    throw std::invalid_argument("expected Bullet3::Transform");
+  }
+
+  if (Rice::Data_Type<Transform>::is_bound() &&
+      rb_obj_is_kind_of(object.value(), Rice::Data_Type<Transform>::klass())) {
+    return Rice::detail::From_Ruby<Transform*>().convert(object)->value();
+  }
+
+  if (object_responds_to(object, "origin") && object_responds_to(object, "rotation")) {
+    btTransform transform;
+    transform.setIdentity();
+    transform.setOrigin(coerce_vector(object.call("origin")));
+    transform.setRotation(coerce_quaternion(object.call("rotation")));
+    return transform;
+  }
+
+  if (rb_obj_is_kind_of(object.value(), rb_cArray)) {
+    Rice::Array array(object);
+    if (array.size() != 2) {
+      throw std::invalid_argument("expected [origin, rotation] transform array");
+    }
+
+    btTransform transform;
+    transform.setIdentity();
+    transform.setOrigin(coerce_vector(Rice::Object(array[0].value())));
+    transform.setRotation(coerce_quaternion(Rice::Object(array[1].value())));
+    return transform;
+  }
+
+  throw std::invalid_argument("expected Bullet3::Transform");
+}
+
+Rice::Object wrap_transform(const btTransform& transform)
+{
+  return Rice::Object(Rice::detail::To_Ruby<Transform>().convert(Transform(transform)));
+}
+} // namespace bullet3
+
+void Init_Transform(Rice::Module rb_mBullet)
+{
+  Rice::define_class_under<bullet3::Transform>(rb_mBullet, "Transform")
+    .define_constructor(Rice::Constructor<bullet3::Transform>())
+    .define_constructor(Rice::Constructor<bullet3::Transform, VALUE, VALUE>(),
+      Rice::Arg("rotation").setValue(),
+      Rice::Arg("origin").setValue())
+    .define_singleton_method("identity", [](Rice::Object) { return bullet3::Transform(); })
+    .define_method("origin", &bullet3::Transform::origin)
+    .define_method("origin=", &bullet3::Transform::set_origin)
+    .define_method("rotation", &bullet3::Transform::rotation)
+    .define_method("rotation=", &bullet3::Transform::set_rotation)
+    .define_method("basis", &bullet3::Transform::basis)
+    .define_method("*", &bullet3::Transform::multiply)
+    .define_method("inverse", &bullet3::Transform::inverse)
+    .define_method("inverse_times", &bullet3::Transform::inverse_times)
+    .define_method("to_a", &bullet3::Transform::to_array);
+}

data/ext/bullet3/linear_math/rb_transform.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <LinearMath/btTransform.h>
+#include <rice/rice.hpp>
+
+namespace bullet3 {
+class Transform {
+public:
+  Transform();
+  Transform(VALUE rotation, VALUE origin);
+  explicit Transform(const btTransform& transform);
+
+  const btTransform& value() const;
+  btTransform& value();
+
+  btVector3 origin() const;
+  btVector3 set_origin(Rice::Object origin);
+  btQuaternion rotation() const;
+  btQuaternion set_rotation(Rice::Object rotation);
+  btMatrix3x3 basis() const;
+  Rice::Object multiply(Rice::Object other) const;
+  Transform inverse() const;
+  Transform inverse_times(Rice::Object other) const;
+  Rice::Array to_array() const;
+
+private:
+  btTransform transform_;
+};
+
+btTransform coerce_transform(Rice::Object object);
+Rice::Object wrap_transform(const btTransform& transform);
+} // namespace bullet3
+
+void Init_Transform(Rice::Module rb_mBullet);

data/ext/bullet3/linear_math/rb_vector3.cpp

@@ -0,0 +1,123 @@
+#include "rb_vector3.hpp"
+
+#include <cmath>
+#include <sstream>
+#include <stdexcept>
+
+#include <LinearMath/btVector3.h>
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>
+
+namespace {
+constexpr btScalar kEpsilon = btScalar(1e-6);
+
+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(
+    Rice::detail::From_Ruby<btScalar>().convert(array[0]),
+    Rice::detail::From_Ruby<btScalar>().convert(array[1]),
+    Rice::detail::From_Ruby<btScalar>().convert(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);
+}
+
+btScalar component_at(const btVector3& vector, int index)
+{
+  if (index < 0 || index > 2) {
+    throw std::out_of_range("index outside vector");
+  }
+
+  return vector[index];
+}
+
+void set_component_at(btVector3& vector, int index, btScalar value)
+{
+  if (index < 0 || index > 2) {
+    throw std::out_of_range("index outside vector");
+  }
+
+  vector[index] = value;
+}
+
+Rice::Array to_array(const btVector3& vector)
+{
+  Rice::Array array;
+  array.push(vector.getX());
+  array.push(vector.getY());
+  array.push(vector.getZ());
+  return array;
+}
+} // namespace
+
+void Init_Vector3(Rice::Module rb_mBullet)
+{
+  Rice::define_class_under<btVector3>(rb_mBullet, "Vector3")
+    .define_constructor(Rice::Constructor<btVector3, btScalar, btScalar, btScalar>(),
+      Rice::Arg("x") = 0.0,
+      Rice::Arg("y") = 0.0,
+      Rice::Arg("z") = 0.0)
+    .define_singleton_method("zero", [](Rice::Object) { return btVector3(0, 0, 0); })
+    .define_method("x", &btVector3::getX)
+    .define_method("y", &btVector3::getY)
+    .define_method("z", &btVector3::getZ)
+    .define_method("x=", &btVector3::setX)
+    .define_method("y=", &btVector3::setY)
+    .define_method("z=", &btVector3::setZ)
+    .define_method("[]", &component_at)
+    .define_method("[]=", &set_component_at)
+    .define_method("+", [](const btVector3& self, Rice::Object other) { return self + coerce_vector(other); })
+    .define_method("-", [](const btVector3& self, Rice::Object other) { return self - coerce_vector(other); })
+    .define_method("-@", [](const btVector3& self) { return -self; })
+    .define_method("*", [](const btVector3& self, btScalar scalar) { return self * scalar; })
+    .define_method("/", [](const btVector3& self, btScalar scalar) {
+      if (scalar == btScalar(0)) {
+        throw std::domain_error("divided by 0");
+      }
+      return self / scalar;
+    })
+    .define_method("==", [](const btVector3& self, Rice::Object other) {
+      return (self - coerce_vector(other)).length2() <= kEpsilon * kEpsilon;
+    })
+    .define_method("length", &btVector3::length)
+    .define_method("length2", &btVector3::length2)
+    .define_method("normalize", [](btVector3& self) -> btVector3& {
+      self.normalize();
+      return self;
+    })
+    .define_method("normalize!", [](btVector3& self) -> btVector3& {
+      self.normalize();
+      return self;
+    })
+    .define_method("normalized", &btVector3::normalized)
+    .define_method("dot", [](const btVector3& self, Rice::Object other) { return self.dot(coerce_vector(other)); })
+    .define_method("cross", [](const btVector3& self, Rice::Object other) { return self.cross(coerce_vector(other)); })
+    .define_method("distance", [](const btVector3& self, Rice::Object other) { return self.distance(coerce_vector(other)); })
+    .define_method("distance2", [](const btVector3& self, Rice::Object other) { return self.distance2(coerce_vector(other)); })
+    .define_method("lerp", [](const btVector3& self, Rice::Object other, btScalar t) { return self.lerp(coerce_vector(other), t); })
+    .define_method("angle", [](const btVector3& self, Rice::Object other) { return self.angle(coerce_vector(other)); })
+    .define_method("absolute", &btVector3::absolute)
+    .define_method("to_a", &to_array)
+    .define_method("to_s", [](const btVector3& self) {
+      std::ostringstream stream;
+      stream << "(" << self.getX() << ", " << self.getY() << ", " << self.getZ() << ")";
+      return stream.str();
+    })
+    .define_method("inspect", [](const btVector3& self) {
+      std::ostringstream stream;
+      stream << "#<Bullet3::Vector3 (" << self.getX() << ", " << self.getY() << ", " << self.getZ() << ")>";
+      return stream.str();
+    });
+}

data/ext/bullet3/linear_math/rb_vector3.hpp

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