snow-math 0.0.1

data/ext/snow-math/vec3.c

@@ -0,0 +1,144 @@
+/*
+  3D vector maths
+  Written by Noel Cower
+
+  See COPYING for license information
+*/
+
+#define __SNOW__VEC3_C__
+
+#include "maths_local.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif /* __cplusplus */
+
+const vec3_t g_vec3_zero = {0.0, 0.0, 0.0};
+const vec3_t g_vec3_one = {1.0, 1.0, 1.0};
+
+void vec3_copy(const vec3_t in, vec3_t out)
+{
+  out[0] = in[0];
+  out[1] = in[1];
+  out[2] = in[2];
+}
+
+void vec3_set(s_float_t x, s_float_t y, s_float_t z, vec3_t v)
+{
+  v[0] = x;
+  v[1] = y;
+  v[2] = z;
+}
+
+/*!
+ * Gets the squared length of a vector.  Useful for approximations and when
+ * you don't need the actual magnitude.
+ */
+s_float_t vec3_length_squared(const vec3_t v)
+{
+  return (v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]);
+}
+
+/*!
+ * Gets the length/magnitude of a vector.
+ */
+s_float_t vec3_length(const vec3_t v)
+{
+  return sqrtf((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]));
+}
+
+void vec3_normalize(const vec3_t in, vec3_t out)
+{
+  s_float_t mag = vec3_length(in);
+  if (mag) mag = 1.0 / mag;
+  out[0] = in[0] * mag;
+  out[1] = in[1] * mag;
+  out[2] = in[2] * mag;
+}
+
+void vec3_subtract(const vec3_t left, const vec3_t right, vec3_t out)
+{
+  out[0] = left[0] - right[0];
+  out[1] = left[1] - right[1];
+  out[2] = left[2] - right[2];
+}
+
+void vec3_add(const vec3_t left, const vec3_t right, vec3_t out)
+{
+  out[0] = left[0] + right[0];
+  out[1] = left[1] + right[1];
+  out[2] = left[2] + right[2];
+}
+
+void vec3_multiply(const vec3_t left, const vec3_t right, vec3_t out)
+{
+  out[0] = left[0] * right[0];
+  out[1] = left[1] * right[1];
+  out[2] = left[2] * right[2];
+}
+
+void vec3_negate(const vec3_t v, vec3_t out)
+{
+  out[2] = -v[2];
+  out[1] = -v[1];
+  out[0] = -v[0];
+}
+
+void vec3_inverse(const vec3_t v, vec3_t out)
+{
+  out[2] = (v[2] != 0.0 && v[2] != -0.0) ? (1.0 / v[2]) : v[2];
+  out[1] = (v[1] != 0.0 && v[1] != -0.0) ? (1.0 / v[1]) : v[1];
+  out[0] = (v[0] != 0.0 && v[0] != -0.0) ? (1.0 / v[0]) : v[0];
+}
+
+void vec3_cross_product(const vec3_t left, const vec3_t right, vec3_t out)
+{
+  s_float_t x, y, z;
+  x = (left[1] * right[2]) - (left[2] * right[1]);
+  y = (left[0] * right[2]) - (left[2] * right[0]);
+  z = (left[0] * right[1]) - (left[1] * right[0]);
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+}
+
+s_float_t vec3_dot_product(const vec3_t left, const vec3_t right)
+{
+  return ((left[0] * right[0]) + (left[1] * right[1]) + (left[2] * right[2]));
+}
+
+void vec3_scale(const vec3_t v, s_float_t scalar, vec3_t out)
+{
+  out[2] = v[2] * scalar;
+  out[1] = v[1] * scalar;
+  out[0] = v[0] * scalar;
+}
+
+/*!
+ * Divides the given vector by the divisor.
+ * \returns Zero if successful, otherwise nonzero if the result is undefined.
+ */
+int vec3_divide(const vec3_t v, s_float_t divisor, vec3_t out)
+{
+  if (divisor) {
+    divisor = ((s_float_t)1.0) / divisor;
+    out[2] = v[2] * divisor;
+    out[1] = v[1] * divisor;
+    out[0] = v[0] * divisor;
+    return 0;
+  }
+  return 1;
+}
+
+int vec3_equals(const vec3_t left, const vec3_t right)
+{
+  return float_equals(left[0], right[0]) &&
+    float_equals(left[1], right[1]) &&
+    float_equals(left[2], right[2]);
+}
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+

data/ext/snow-math/vec4.c

@@ -0,0 +1,145 @@
+/*
+  4D vector maths
+  Written by Noel Cower
+
+  See COPYING for license information
+*/
+
+#define __SNOW__VEC4_C__
+
+#include "maths_local.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif /* __cplusplus */
+
+const vec4_t g_vec4_zero = {0.0, 0.0, 0.0, 0.0};
+const vec4_t g_vec4_one = {1.0, 1.0, 1.0, 1.0};
+const vec4_t g_vec4_identity = {0.0, 0.0, 0.0, 1.0};
+
+void vec4_copy(const vec4_t in, vec4_t out)
+{
+  out[0] = in[0];
+  out[1] = in[1];
+  out[2] = in[2];
+  out[3] = in[3];
+}
+
+void vec4_set(s_float_t x, s_float_t y, s_float_t z, s_float_t w, vec4_t v)
+{
+  v[0] = x;
+  v[1] = y;
+  v[2] = z;
+  v[3] = w;
+}
+
+/*!
+ * Gets the squared length of a vector.  Useful for approximations and when
+ * you don't need the actual magnitude.
+ */
+s_float_t vec4_length_squared(const vec4_t v)
+{
+  return (v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]) + (v[3] * v[3]);
+}
+
+/*!
+ * Gets the length/magnitude of a vector.
+ */
+s_float_t vec4_length(const vec4_t v)
+{
+  return sqrtf((v[0] * v[0]) + (v[1] * v[1]) + (v[2] * v[2]) + (v[3] * v[3]));
+}
+
+void vec4_normalize(const vec4_t in, vec4_t out)
+{
+  s_float_t mag = vec4_length(in);
+  if (mag) mag = 1.0 / mag;
+  out[0] = in[0] * mag;
+  out[1] = in[1] * mag;
+  out[2] = in[2] * mag;
+  out[3] = in[3] * mag;
+}
+
+void vec4_subtract(const vec4_t left, const vec4_t right, vec4_t out)
+{
+  out[0] = left[0] - right[0];
+  out[1] = left[1] - right[1];
+  out[2] = left[2] - right[2];
+  out[3] = left[3] - right[3];
+}
+
+void vec4_add(const vec4_t left, const vec4_t right, vec4_t out)
+{
+  out[0] = left[0] + right[0];
+  out[1] = left[1] + right[1];
+  out[2] = left[2] + right[2];
+  out[3] = left[3] + right[3];
+}
+
+void vec4_multiply(const vec4_t left, const vec4_t right, vec4_t out)
+{
+  out[0] = left[0] * right[0];
+  out[1] = left[1] * right[1];
+  out[2] = left[2] * right[2];
+  out[3] = left[3] * right[3];
+}
+
+void vec4_negate(const vec4_t v, vec4_t out)
+{
+  out[3] = -v[3];
+  out[2] = -v[2];
+  out[1] = -v[1];
+  out[0] = -v[0];
+}
+
+void vec4_inverse(const vec4_t v, vec4_t out)
+{
+  out[3] = (v[3] != 0.0 && v[3] != -0.0) ? (1.0 / v[3]) : v[3];
+  out[2] = (v[2] != 0.0 && v[2] != -0.0) ? (1.0 / v[2]) : v[2];
+  out[1] = (v[1] != 0.0 && v[1] != -0.0) ? (1.0 / v[1]) : v[1];
+  out[0] = (v[0] != 0.0 && v[0] != -0.0) ? (1.0 / v[0]) : v[0];
+}
+
+s_float_t vec4_dot_product(const vec4_t left, const vec4_t right)
+{
+  return ((left[0] * right[0]) + (left[1] * right[1]) + (left[2] * right[2]) + (left[3] * right[3]));
+}
+
+void vec4_scale(const vec4_t v, s_float_t scalar, vec4_t out)
+{
+   out[3] = v[3] * scalar;
+   out[2] = v[2] * scalar;
+   out[1] = v[1] * scalar;
+   out[0] = v[0] * scalar;
+}
+
+/*!
+ * Divides the given vector by the divisor.
+ * \returns Zero if successful, otherwise nonzero if the result is undefined.
+ */
+int vec4_divide(const vec4_t v, s_float_t divisor, vec4_t out)
+{
+  if (divisor) {
+    divisor = ((s_float_t)1.0) / divisor;
+    out[3] = v[3] * divisor;
+    out[2] = v[2] * divisor;
+    out[1] = v[1] * divisor;
+    out[0] = v[0] * divisor;
+    return 1;
+  }
+  return 0;
+}
+
+int vec4_equals(const vec4_t left, const vec4_t right)
+{
+  return float_equals(left[0], right[0]) &&
+    float_equals(left[1], right[1]) &&
+    float_equals(left[2], right[2]) &&
+    float_equals(left[3], right[3]);
+}
+
+#if defined(__cplusplus)
+}
+#endif /* __cplusplus */
+

data/lib/snow-math.rb

@@ -0,0 +1,14 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math/bindings'
+require 'snow-math/vec3'
+require 'snow-math/vec4'
+require 'snow-math/mat4'
+require 'snow-math/quat'
+require 'snow-math/swizzle'
+require 'snow-math/inspect'
+require 'snow-math/to_a'
+
+module Snow ; end

data/lib/snow-math/inspect.rb

@@ -0,0 +1,20 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math'
+
+module Snow ; end
+
+module Snow::MathInspect
+
+  def inspect
+    "<#{self.class.name}:0x#{self.address.to_s(16)} #{(0 ... self.length).map { |i| self[i] }.join(' ')}>"
+  end
+
+end
+
+class Snow::Vec3 ; include Snow::MathInspect ; end
+class Snow::Vec4 ; include Snow::MathInspect ; end
+class Snow::Quat ; include Snow::MathInspect ; end
+class Snow::Mat4 ; include Snow::MathInspect ; end

data/lib/snow-math/mat4.rb

@@ -0,0 +1,80 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math/bindings'
+
+module Snow ; end
+
+if Snow.const_defined?(:Mat4Array)
+  class Snow::Mat4Array
+    class << self ; alias_method :[], :new ; end
+
+    alias_method :[], :fetch
+    alias_method :[]=, :store
+  end
+end
+
+class Snow::Mat4
+
+  class << self ; alias_method :[], :new ; end
+
+  alias_method :[], :fetch
+  alias_method :[]=, :store
+
+  def transpose!
+    transpose self
+  end
+
+  def inverse_orthogonal!
+    inverse_orthogonal self
+  end
+
+  def adjoint!
+    adjoint self
+  end
+
+  def multiply_mat4!(rhs)
+    multiply_mat4 rhs, self
+  end
+
+  def multiply(rhs, out = nil)
+    raise "Invalid type for output, must be the same as RHS" if !out.nil? && !out.kind_of?(rhs.class)
+    case rhs
+    when ::Snow::Mat4 then multiply_mat4(rhs, out)
+    when ::Snow::Vec4 then multiply_vec4(rhs, out)
+    when ::Snow::Vec3 then transform_vec3(rhs, out)
+    when Numeric      then scale(rhs, rhs, rhs, out)
+    else raise TypeError, "Invalid type for RHS"
+    end
+  end
+
+  def multiply!(rhs)
+    multiply rhs, case rhs
+      when Mat4, Numeric then self
+      when Vec4, Vec3 then rhs
+      else raise TypeError, "Invalid type for RHS"
+      end
+  end
+
+  def scale!(x, y, z)
+    scale x, y, z, self
+  end
+
+  def translate!(*args)
+    translate *args, self
+  end
+
+  def inverse_affine!
+    inverse_affine self
+  end
+
+  def inverse_general!
+    inverse_general self
+  end
+
+  alias_method :*, :multiply
+  alias_method :**, :scale
+  alias_method :~, :transpose
+
+end

data/lib/snow-math/ptr.rb

@@ -0,0 +1,25 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math'
+require 'fiddle'
+
+module Snow ; end
+
+module Snow::MathPointers
+
+  def to_ptr
+    Fiddle::Pointer.new(self.address, self.size)
+  end
+
+end
+
+Snow::Vec3.include(Snow::MathPointers)
+Snow::Vec4.include(Snow::MathPointers)
+Snow::Quat.include(Snow::MathPointers)
+Snow::Mat4.include(Snow::MathPointers)
+Snow::Vec3Array.include(Snow::MathPointers) if Snow.const_defined?(:Vec3Array)
+Snow::Vec4Array.include(Snow::MathPointers) if Snow.const_defined?(:Vec4Array)
+Snow::QuatArray.include(Snow::MathPointers) if Snow.const_defined?(:QuatArray)
+Snow::Mat4Array.include(Snow::MathPointers) if Snow.const_defined?(:Mat4Array)

data/lib/snow-math/quat.rb

@@ -0,0 +1,114 @@
+# This file is part of ruby-snowmath.
+# Copyright (c) 2013 Noel Raymond Cower. All rights reserved.
+# See COPYING for license details.
+
+require 'snow-math/bindings'
+
+module Snow ; end
+
+if Snow.const_defined?(:QuatArray)
+  class Snow::QuatArray
+    class << self ; alias_method :[], :new ; end
+
+    alias_method :[], :fetch
+    alias_method :[]=, :store
+  end
+end
+
+class Snow::Quat
+
+  class << self ; alias_method :[], :new ; end
+
+  alias_method :[], :fetch
+  alias_method :[]=, :store
+
+  def x
+    self[0]
+  end
+
+  def x=(value)
+    self[0] = value
+  end
+
+  def y
+    self[1]
+  end
+
+  def y=(value)
+    self[1] = value
+  end
+
+  def z
+    self[2]
+  end
+
+  def z=(value)
+    self[2] = value
+  end
+
+  def w
+    self[3]
+  end
+
+  def w=(value)
+    self[3] = value
+  end
+
+  def dup
+    self.class.new(self)
+  end
+
+  def normalize!
+    normalize self
+  end
+
+  def inverse!
+    inverse self
+  end
+
+  def negate!
+    negate self
+  end
+
+  def multiply_quat!(rhs)
+    multiply_quat rhs, self
+  end
+
+  def multiply(rhs, output = nil)
+    case rhs
+    when Quat then multiply_quat(rhs, output)
+    when Vec3 then multiply_vec3(rhs, output)
+    when Numeric then scale(rhs, output)
+    else raise TypeError, "Invalid type for RHS"
+    end
+  end
+
+  def multiply!(rhs)
+    multiply_quat! rhs
+  end
+
+  def add!(rhs)
+    add rhs, self
+  end
+
+  def subtract!(rhs)
+    subtract rhs, self
+  end
+
+  def scale!(rhs)
+    scale rhs, self
+  end
+
+  def divide!(rhs)
+    divide rhs, self
+  end
+
+  alias_method :-, :subtract
+  alias_method :+, :add
+  alias_method :**, :dot_product
+  alias_method :*, :scale
+  alias_method :/, :divide
+  alias_method :-@, :negate
+  alias_method :~, :inverse
+
+end