snow-math 1.1.0 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 46e87b537dadcdf09df7d18126a3fdd43bae0269
-  data.tar.gz: 48ac51001b1c24bf65e0916a2d8253745bf61680
+  metadata.gz: acf4b914538998803baaaa10019c764a2ddb6795
+  data.tar.gz: ca803853cb9d6ae15934dae390f13eb794640ca9
 SHA512:
-  metadata.gz: d69f5b6d5224531c115093013049b1273905fc66a9fd1628d1ecee557a24932fcdac3bf1851b9814415c60596d9be65e93265fce947cdeb3c820b1ff2bf0ea9c
-  data.tar.gz: be97770e8846a16d83746f28ec00334e7c472d8b19f6eaa54145ab70c181caa264ee21a96211b2c5f658813cdc443f7099d19c6078e1053a5f536bbb6798480b
+  metadata.gz: 708e55617a3bafb8e761e6fb64ac71260dc3a532687e168e829a255be508f77174d123ae94298d8f680ee043860d16a6f6f5ccea38bda038e61584477ddb83ff
+  data.tar.gz: 058f627a57fda1e6710863aa882ca1b6040d7731b51ba6d2b8ae854c3e0b12e17da7eb90815f2cfe811d7cafecc0a7826e111679807301732cb3ba323f3519d2

data/README.md

@@ -13,6 +13,7 @@ provides four 3D math types:
     - Snow::Vec3
     - Snow::Vec4
     - Snow::Quat
+    - Snow::Mat3
     - Snow::Mat4
 
 _Most_ of their functionality is implemented in the C bindings, particularly
@@ -159,40 +160,47 @@ obvious but are as follows:
 
       def inverse(output = nil) -> new vec3 or output
       def inverse! -> self
+      ~vec3 -> new vec3
         Returns a vector whose components are the multiplicative inverse of the
         vector's components.
-        Aliased as :~
 
       def negate(output = nil) -> new vec3 or output
       def negate! -> self
+      -vec3 -> new vec3
         Returns a vector whose components are the negated form of the vector's
         components. Beware of -0.0 here.
-        Aliased as :-@
 
       def normalize(output = nil) -> new vec3 or output
       def normalize!() -> self
 
-      def cross_product(rhs, output = nil) -> new vec3 or output
-      def cross_product!(rhs) -> self
-
       def multiply_vec3(rhs, output = nil) -> new vec3 or output
         Multiplies both vector's components together and returns the result.
 
       def multiply(vec3, output = nil) -> same as multiply_vec3
       def multiply(scalar, output = nil) -> same as scale
       def multiply!(rhs) -> same as multiply(rhs, self)
-        Non-mutable form aliased as :*
+      vec3 * rhs -> vec3.multiply(rhs)
 
       def add(rhs, output = nil) -> new vec3 or output
       def add!(rhs)
-        Aliased as :+
+      vec3 + vec3
 
       def subtract(rhs, output = nil) -> new vec3 or output
       def subtract!(rhs) -> self
-        Aliased as :-
+      vec3 - vec3
+
+      def project(normal, output = nil) -> new vec4 or output
+      def reflect(normal, output = nil) -> new vec4 or output
+        Returns either the projected or reflected vector, respectively. These
+        methods expect the 'normal' argument to be normalized -- that is, they
+        will not normalize their input for you.
+
+      def cross_product(rhs, output = nil) -> new vec3 or output
+      def cross_product!(rhs) -> self
+      vec3 ^ vec3 -> new vec3
 
       def dot_product(rhs) -> Float
-        Aliased as :**
+      vec3 ** vec3 -> float
 
       def magnitude_squared -> Float
       def magnitude -> Float
@@ -202,10 +210,11 @@ obvious but are as follows:
         of two things, you can skip a call to sqrt and use the squared magnitude.
 
       def scale(scalar, output = nil) -> new vec3 or output
+      vec3 * scalar
       def divide(scalar, output = nil) -> new vec3 or output
+      vec3 / scalar
         Multiplies or divides all components of the vector by a scalar. In the case
         of divide, a scalar of 0 is undefined behaviour.
-        divide is aliased as :/
 
       def size -> size in bytes
       def length -> length in floats
@@ -259,11 +268,13 @@ component. In addition, it is at times interchangeable with Quat.
 
       def inverse(output = nil) -> new vec4 or output
       def inverse! -> self
+      ~vec4 -> new vec4
         Returns a vector whose components are the multiplicative inverse of the
         vector's components.
 
       def negate(output = nil) -> new vec4 or output
       def negate! -> self
+      -vec4 -> new vec4
         Returns a vector whose components are the negated form of the vector's
         components. Beware of -0.0 here.
 
@@ -272,20 +283,30 @@ component. In addition, it is at times interchangeable with Quat.
 
       def multiply_vec4(rhs, output = nil) -> new vec4 or output
       def multiply_vec4!(rhs) -> self
+      vec4 * vec4 -> new vec4
         Multiplies both vector's components together and returns the result.
 
       def multiply(vec4, output = nil) -> same as multiply_vec4
       def multiply(numeric, output = nil) -> same as scale
       def multiply!(rhs) -> same as multiply(rhs, self)
-        Aliased as :*
+      vec4 * rhs -> vec4.multiply(rhs)
 
       def add(rhs, output = nil) -> new vec4 or output
-      def add!(rhs)
+      def add!(rhs) -> self
+      vec4 + vec4 -> new vec4
 
       def subtract(rhs, output = nil) -> new vec4 or output
       def subtract!(rhs) -> self
+      vec4 - vec4 -> new vec4
+
+      def project(normal, output = nil) -> new vec4 or output
+      def reflect(normal, output = nil) -> new vec4 or output
+        Returns either the projected or reflected vector, respectively. These
+        methods expect the 'normal' argument to be normalized -- that is, they
+        will not normalize their input for you.
 
       def dot_product(rhs) -> Float
+      vec4 ** vec4 -> Float
 
       def magnitude_squared -> Float
       def magnitude -> Float
@@ -295,7 +316,9 @@ component. In addition, it is at times interchangeable with Quat.
         of two things, you can skip a call to sqrt and use the squared magnitude.
 
       def scale(scalar, output = nil) -> new vec4 or output
+      vec4 * scalar -> new vec4
       def divide(scalar, output = nil) -> new vec4 or output
+      vec4 / scalar -> new vec4
         Multiplies or divides all components of the vector by a scalar. In the case
         of divide, a scalar of 0 is undefined behaviour.
 
@@ -365,11 +388,13 @@ and an attempt to make code more readable.
 
       def inverse(output = nil) -> new quat or output
       def inverse! -> self
+      ~quat -> new quat
         Returns the inverse of this quaternion (or writes the inverse to an output
         or itself). This is not the same as a vector's inverse -- keep that in mind.
 
       def negate(output = nil) -> new quat or output
       def negate! -> self
+      -quat -> new quat
         Returns a quaternion whose components are the negated form of the vector's
         components. Beware of -0.0 here. This is the same as negating a vector.
 
@@ -378,28 +403,34 @@ and an attempt to make code more readable.
 
       def multiply_quat(rhs: Quat, output = nil) -> new quat or output
       def multiply!(rhs: Quat) -> self
+      quat * quat -> new quat
         The first form, multiply_quat, multiplies two quaternions and returns the
         resulting quaternion. The second form, multiply!, is the same as calling
         multiply_quat(rhs, self).
 
       def mutliply_vec3(rhs: Vec3, output = nil) -> new vec3 or output
+      quat * vec3 -> new vec3
         Multiplies a vec3 by a quat and returns the resulting vec3.
 
       def multiply(vec3, output = nil) -> new vec3 or output
       def multiply(quat, output = nil) -> new quat or output
       def multiply(numeric, output = nil) -> new quat or output
+      quat * rhs -> quat.multiply(rhs)
         In its first form, it's the same as #multiply_vec3. In its second, it's the
         same as #multiply_quat. In its third, it's the same as #scale.
 
       def add(rhs, output = nil) -> new quat or output
       def add!(rhs)
+      quat + quat -> new quat
         Same as Vec4#add and Vec4#add!.
 
       def subtract(rhs, output = nil) -> new quat or output
       def subtract!(rhs) -> self
+      quat - quat -> new quat
         Same as Vec4#subtract and Vec4#subtract!.
 
       def dot_product(rhs) -> Float
+      quat ** quat -> new quat
         Same as Vec4#dot_product.
 
       def magnitude_squared -> Float
@@ -410,7 +441,9 @@ and an attempt to make code more readable.
         of two things, you can skip a call to sqrt and use the squared magnitude.
 
       def scale(scalar, output = nil) -> new quat or output
+      quat * scalar -> new quat
       def divide(scalar, output = nil) -> new quat or output
+      quat / scalar -> new quat
         Multiplies or divides all components of the quaternion by a scalar. In the
         case of divide, a scalar of 0 is undefined behaviour.
 
@@ -439,6 +472,78 @@ and an attempt to make code more readable.
 
 
 
+#### Snow::Mat3
+
+    class Snow::Mat3
+
+      def self.new() -> identity mat3
+      def self.new(m1, m2, m3, ..., m9) -> mat3 with the given components
+      def self.new([Vec3, Vec3, Vec3]) -> mat3 with rows defined by the given Vec3s
+      def self.new(Quat) -> Mat3 from Quat
+      def self.new(Mat3) -> copy of the given Mat3
+      def self.new(Mat4) -> copy of the given Mat4 as a Mat3
+        Aliased as `[]`, so you can use Mat3[...] to create a new Mat3.
+
+      def self.angle_axis(angle_degrees, axis: Vec3, output = nil) -> new mat3 or output
+        Returns a new rotation matrix for the given angle and axis. The angle is in
+        degrees.
+
+      def set(...) -> self
+        Same variations and arguments as self.new(...)
+
+      def load_identity() -> self
+        Resets self to the identity matrix.
+
+      def to_mat4(output = nil) -> new mat4 or output
+
+      def copy(output = nil) -> new mat3 or output
+        Copies self to the given output matrix.
+
+      def transpose(output = nil) -> new mat3 or output
+      def transpose!() -> self
+
+      def inverse(output = nil) -> new mat3 or output
+      def inverse!() -> self on success, nil on failure
+
+      def multiply_mat3(rhs, output = nil) -> new mat3 or output
+      def multiply_mat3!(rhs) -> self
+        Multiplies this and the rhs matrix and returns the result.
+
+      def rotate_vec3(rhs, output = nil) -> new vec3 or output
+        Rotates a vec3 by the matrix and returns the result.
+
+      def inverse_rotate_vec3(vec3, output = nil) -> new vec3 or output
+        Essentially just a convenience function.
+
+      def multiply(mat3, output = nil) -> same as mutliply_mat3
+      def multiply(vec3, output = nil) -> same as mutliply_vec3
+      def multiply(numeric, output = nil) -> same as scale(N, N, N, output)
+      def multiply!(rhs) -> same as multiply(rhs, self)
+        The fourth form, multiply!, will fail if attempting to multiply a vec3.
+
+      def adjoint(output = nil) -> new mat3 or output
+      def adjoint!() -> new mat3 or output
+
+      def cofactor(output = nil) -> new mat3 or output
+      def cofactor!() -> new mat3 or output
+
+      def determinant -> Float
+
+      def scale(x, y, z, output = nil) -> new mat3 or output
+      def scale!(x, y, z) -> new mat3 or output
+        Returns a matrix with its columns scaled by the given components.
+
+      def set_row3, set_column3(index, V) -> self
+        V is a vector with the number of components in the function name. Sets the
+        Mat3's row or column to the components of the given Vec3.
+
+      def get_row3, get_column3(index, output = nil) -> new vec3 for row/column
+        Returns a Vec3 for the given row or column in the Mat3.
+
+    end
+
+
+
 #### Snow::Mat4
 
     class Snow::Mat4
@@ -447,6 +552,7 @@ and an attempt to make code more readable.
       def self.new(m1, m2, m3, ..., m16) -> mat4 with the given components
       def self.new([Vec4, Vec4, Vec4, Vec4]) -> mat4 with rows defined by the given Vec4s
       def self.new(Quat) -> Mat4 from Quat
+      def self.new(Mat3) -> copy of the given Mat3 as a Mat4
       def self.new(Mat4) -> copy of the given Mat4
         Aliased as `[]`, so you can use Mat4[...] to create a new Mat4.
 
@@ -474,6 +580,8 @@ and an attempt to make code more readable.
       def load_identity() -> self
         Resets self to the identity matrix.
 
+      def to_mat3(output = nil) -> new mat3 or output
+
       def copy(output = nil) -> new mat4 or output
         Copies self to the given output matrix.
 
@@ -524,27 +632,28 @@ and an attempt to make code more readable.
 
       def scale(x, y, z, output = nil) -> new mat4 or output
       def scale!(x, y, z) -> new mat4 or output
-        Returns a matrix with its inner 3x3 matrix's rows scaled by the given
+        Returns a matrix with its inner 3x3 matrix's columns scaled by the given
         components.
 
       def set_row3, set_column3, set_row4, set_column4(index, V) -> self
-        V is a vector with the number of components in the function name. Sets the
-        Mat4's row or column to the components of the given vec3 or vec4.
+        Sets the Mat4's row or column to the components of the given vec3 or vec4.
+        V must be a vector with the number of components specified by the function
+        name.
 
-      def get_row3, get_column3, get_row4, get_column4(index, output = nil) -> row/column
-        Returns a vector with the number of components as specific by the name for
+      def get_row3, get_column3, get_row4, get_column4(index, output = nil) -> new vec3 or vec4 for row/column
+        Returns a vector with the number of components as specified by the name for
         the given row or column in the Mat4.
 
     end
 
 
 
-#### Snow::Vec3Array, Snow::Vec4Array, Snow::QuatArray, Snow::Mat4Array
+#### Snow::Vec3Array, Snow::Vec4Array, Snow::QuatArray, Snow::Mat3Array, Snow::Mat4Array
 
 All typed arrays have the same interface and differ only in the kind of object
 they contain. As such, this applies to all typed arrays.
 
-    class Snow::Vec3Array, Snow::Vec4Array, Snow::QuatArray, Snow::Mat4Array
+    class Snow::Vec3Array, Snow::Vec4Array, Snow::QuatArray, Snow::Mat3Array, Snow::Mat4Array
 
       def self.new(length) -> new array
       def self.new(array) -> copy of array

data/ext/snow-math/mat3.c

@@ -0,0 +1,455 @@
+/*
+  3x3 (rotation / scaling) matrix
+  Written by Noel Cower
+
+  See COPYING for license information
+*/
+
+#define __SNOW__MAT3_C__
+
+#include "maths_local.h"
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif /* __cplusplus */
+
+
+
+const mat3_t g_mat3_identity = {
+  1.0, 0.0, 0.0,
+  0.0, 1.0, 0.0,
+  0.0, 0.0, 1.0
+};
+
+
+
+// Rows
+#define S_MR 0
+#define S_MS 3
+#define S_MT 6
+
+// row components
+#define S_MR_X 0
+#define S_MR_Y 1
+#define S_MR_Z 2
+#define S_MS_X 3
+#define S_MS_Y 4
+#define S_MS_Z 5
+#define S_MT_X 6
+#define S_MT_Y 7
+#define S_MT_Z 8
+
+// columns
+#define S_MIR_X 0
+#define S_MIR_Y 3
+#define S_MIR_Z 6
+#define S_MIS_X 1
+#define S_MIS_Y 4
+#define S_MIS_Z 7
+#define S_MIT_X 2
+#define S_MIT_Y 5
+#define S_MIT_Z 8
+
+
+
+void mat3_identity(mat3_t out)
+{
+  out[0] =
+  out[4] =
+  out[8] = 1;
+
+  out[1] =
+  out[2] =
+  out[3] =
+  out[5] =
+  out[6] =
+  out[7] = 0;
+}
+
+
+
+void mat3_to_mat4(const mat3_t in, mat4_t out)
+{
+  out[0] = in[0];
+  out[1] = in[1];
+  out[2] = in[2];
+  out[3] = 0;
+  out[4] = in[3];
+  out[5] = in[4];
+  out[6] = in[5];
+  out[7] = 0;
+  out[8] = in[6];
+  out[9] = in[7];
+  out[10] = in[8];
+  out[14] =
+  out[13] =
+  out[12] =
+  out[11] = 0;
+  out[15] = 1;
+}
+
+
+
+void mat3_set(s_float_t m00, s_float_t m10, s_float_t m20,
+              s_float_t m01, s_float_t m11, s_float_t m21,
+              s_float_t m02, s_float_t m12, s_float_t m22,
+              mat3_t out)
+{
+  out[0] = m00;
+  out[1] = m10;
+  out[2] = m20;
+  out[3] = m01;
+  out[4] = m11;
+  out[5] = m21;
+  out[6] = m02;
+  out[7] = m12;
+  out[8] = m22;
+}
+
+
+
+void mat3_rotation(s_float_t angle, s_float_t x, s_float_t y, s_float_t z, mat3_t out)
+{
+  const s_float_t angle_rad = angle * S_DEG2RAD;
+  const s_float_t c  = s_cos(angle_rad);
+  const s_float_t s  = s_sin(angle_rad);
+  const s_float_t ic = 1.0 - c;
+  const s_float_t xy = x * y * ic;
+  const s_float_t yz = y * z * ic;
+  const s_float_t xz = x * z * ic;
+  const s_float_t xs = s * x;
+  const s_float_t ys = s * y;
+  const s_float_t zs = s * z;
+
+  out[0] = ((x * x) * ic) + c;
+  out[1] = xy + zs;
+  out[2] = xz - ys;
+  out[3] = xy - zs;
+  out[4] = ((y * y) * ic) + c;
+  out[5] = yz + xs;
+  out[6] = xz + ys;
+  out[7] = yz - xs;
+  out[8] = ((z * z) * ic) + c;
+}
+
+
+
+void mat3_from_quat(const quat_t in, mat3_t out)
+{
+  s_float_t tx, ty, tz, xx, xy, xz, yy, yz, zz, wx, wy, wz;
+
+  tx = 2.0 * in[0];
+  ty = 2.0 * in[1];
+  tz = 2.0 * in[2];
+
+  xx = tx * in[0];
+  xy = tx * in[1];
+  xz = tx * in[2];
+
+  yy = ty * in[1];
+  yz = tz * in[1];
+
+  zz = tz * in[3];
+
+  wx = tx * in[3];
+  wy = ty * in[3];
+  wz = tz * in[3];
+
+  out[0] = 1.0 - (yy + zz);
+  out[1] = xy - wz;
+  out[2] = xz + wy;
+  out[3] = xy + wz;
+  out[4] = 1.0 - (xx + zz);
+  out[5] = yz - wx;
+  out[6] = xz - wy;
+  out[7] = yz + wx;
+  out[8] = 1.0 - (xx + yy);
+}
+
+
+
+void mat3_transpose(const mat3_t in, mat3_t out)
+{
+  s_float_t temp;
+  #define S_SWAP_ELEM(LHS, RHS) temp = in[LHS]; out[LHS] = in[RHS]; out[RHS] = temp
+  out[0] = in[0];
+  out[4] = in[4];
+  out[8] = in[8];
+  S_SWAP_ELEM(1, 3);
+  S_SWAP_ELEM(2, 6);
+  S_SWAP_ELEM(5, 7);
+  #undef S_SWAP_ELEM
+}
+
+
+
+void mat3_copy(const mat3_t in, mat3_t out)
+{
+  out[0] = in[0];
+  out[1] = in[1];
+  out[2] = in[2];
+  out[3] = in[3];
+  out[4] = in[4];
+  out[5] = in[5];
+  out[6] = in[6];
+  out[7] = in[7];
+  out[8] = in[8];
+}
+
+
+
+int mat3_equals(const mat3_t lhs, const mat3_t rhs)
+{
+  return
+    float_equals(rhs[0], lhs[0]) &&
+    float_equals(rhs[1], lhs[1]) &&
+    float_equals(rhs[2], lhs[2]) &&
+    float_equals(rhs[3], lhs[3]) &&
+    float_equals(rhs[4], lhs[4]) &&
+    float_equals(rhs[5], lhs[5]) &&
+    float_equals(rhs[6], lhs[6]) &&
+    float_equals(rhs[7], lhs[7]) &&
+    float_equals(rhs[8], lhs[8]);
+}
+
+
+
+void mat3_scale(const mat3_t in, s_float_t x, s_float_t y, s_float_t z, mat3_t out)
+{
+  out[0] = in[0] * x;
+  out[1] = in[1] * y;
+  out[2] = in[2] * z;
+  out[3] = in[3] * x;
+  out[4] = in[4] * y;
+  out[5] = in[5] * z;
+  out[6] = in[6] * x;
+  out[7] = in[7] * y;
+  out[8] = in[8] * z;
+}
+
+
+
+void mat3_orthogonal(const mat3_t in, mat3_t out)
+{
+  vec3_normalize(&in[S_MT], &out[S_MT]);
+  vec3_cross_product(&in[S_MS], &in[S_MT], &out[S_MR]);
+  vec3_normalize(&in[S_MR], &out[S_MR]);
+  vec3_cross_product(&in[S_MT], &in[S_MR], &out[S_MS]);
+}
+
+
+
+void mat3_multiply(const mat3_t lhs, const mat3_t rhs, mat3_t out)
+{
+  mat3_t temp;
+  s_float_t cx, cy, cz;
+
+  mat3_transpose(lhs, temp);
+
+  cx      = temp[0];
+  cy      = temp[1];
+  cz      = temp[2];
+
+  temp[0] = (cx * rhs[0 ]) + (cy * rhs[1 ]) + (cz * rhs[2 ]);
+  temp[1] = (cx * rhs[3 ]) + (cy * rhs[4 ]) + (cz * rhs[5 ]);
+  temp[2] = (cx * rhs[6 ]) + (cy * rhs[7 ]) + (cz * rhs[8]);
+
+  cx      = temp[3];
+  cy      = temp[4];
+  cz      = temp[5];
+
+  temp[3] = (cx * rhs[0 ]) + (cy * rhs[1 ]) + (cz * rhs[2 ]);
+  temp[4] = (cx * rhs[3 ]) + (cy * rhs[4 ]) + (cz * rhs[5 ]);
+  temp[5] = (cx * rhs[6 ]) + (cy * rhs[7 ]) + (cz * rhs[8]);
+
+  cx      = temp[6];
+  cy      = temp[7];
+  cz      = temp[8];
+
+  temp[6] = (cx * rhs[0 ]) + (cy * rhs[1 ]) + (cz * rhs[2 ]);
+  temp[7] = (cx * rhs[3 ]) + (cy * rhs[4 ]) + (cz * rhs[5 ]);
+  temp[8] = (cx * rhs[6 ]) + (cy * rhs[7 ]) + (cz * rhs[8]);
+
+  mat3_transpose(temp, out);
+}
+
+
+
+void mat3_rotate_vec3(const mat3_t lhs, const vec3_t rhs, vec3_t out)
+{
+  mat3_t temp;
+  s_float_t x;
+  s_float_t y;
+  s_float_t z;
+
+  mat3_transpose(lhs, temp);
+
+  x = temp[0] * rhs[0] + temp[1] * rhs[1] + temp[2] * rhs[2];
+  y = temp[3] * rhs[0] + temp[4] * rhs[1] + temp[5] * rhs[2];
+  z = temp[6] * rhs[0] + temp[7] * rhs[1] + temp[8] * rhs[2];
+
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+}
+
+
+
+void mat3_inv_rotate_vec3(const mat3_t lhs, const vec3_t rhs, vec3_t out)
+{
+  s_float_t x;
+  s_float_t y;
+  s_float_t z;
+
+  x = lhs[0] * rhs[0] + lhs[1] * rhs[1] + lhs[2] * rhs[2];
+  y = lhs[3] * rhs[0] + lhs[4] * rhs[1] + lhs[5] * rhs[2];
+  z = lhs[6] * rhs[0] + lhs[7] * rhs[1] + lhs[8] * rhs[2];
+
+  out[0] = x;
+  out[1] = y;
+  out[2] = z;
+}
+
+
+
+void mat3_cofactor(const mat3_t in, mat3_t out)
+{
+  const mat3_t temp = {
+       (in[S_MS_Y] * in[S_MT_Z] - in[S_MS_Z] * in[S_MT_Y]),
+      -(in[S_MS_X] * in[S_MT_Z] - in[S_MS_Z] * in[S_MT_X]),
+       (in[S_MS_X] * in[S_MT_Y] - in[S_MS_Y] * in[S_MT_X]),
+
+      -(in[S_MR_Y] * in[S_MT_Z] - in[S_MR_Z] * in[S_MT_Y]),
+       (in[S_MR_X] * in[S_MT_Z] - in[S_MR_Z] * in[S_MT_X]),
+      -(in[S_MR_X] * in[S_MT_Y] - in[S_MR_Y] * in[S_MT_X]),
+
+       (in[S_MR_Y] * in[S_MS_Z] - in[S_MR_Z] * in[S_MS_Y]),
+      -(in[S_MR_X] * in[S_MS_Z] - in[S_MR_Z] * in[S_MS_X]),
+       (in[S_MR_X] * in[S_MS_Y] - in[S_MR_Y] * in[S_MS_X])
+  };
+  mat3_copy(temp, out);
+}
+
+
+
+s_float_t mat3_determinant(const mat3_t in)
+{
+  return in[S_MR_X] * (in[S_MS_Y] * in[S_MT_Z] - in[S_MS_Z] * in[S_MT_Y]) +
+         in[S_MR_Y] * (in[S_MS_Z] * in[S_MT_X] - in[S_MS_X] * in[S_MT_Z]) +
+         in[S_MR_Z] * (in[S_MS_X] * in[S_MT_Y] - in[S_MS_Y] * in[S_MT_X]);
+}
+
+
+
+void mat3_adjoint(const mat3_t in, mat3_t out)
+{
+  mat3_cofactor(in, out);
+  mat3_transpose(out, out);
+}
+
+
+
+int mat3_inverse(const mat3_t in, mat3_t out)
+{
+  s_float_t determinant = mat3_determinant(in);
+  if (determinant != 0.0 && determinant != -0.0) {
+    determinant = 1.0 / determinant;
+  } else {
+    return 0;
+  }
+
+  mat3_cofactor(in, out);
+  mat3_transpose(out, out);
+  out[0] *= determinant;
+  out[1] *= determinant;
+  out[2] *= determinant;
+  out[3] *= determinant;
+  out[4] *= determinant;
+  out[5] *= determinant;
+  out[6] *= determinant;
+  out[7] *= determinant;
+  out[8] *= determinant;
+
+  return 1;
+}
+
+
+
+void mat3_get_row3(const mat3_t in, int row, vec3_t out)
+{
+  const s_float_t *p = &in[0];
+  switch (row) {
+  case 2: { p += 3; }
+  case 1: { p += 3; }
+  case 0: {
+    out[0] = in[0];
+    out[1] = in[1];
+    out[2] = in[2];
+    break;
+  }
+  default: { break; }
+  }
+}
+
+
+
+void mat3_get_column3(const mat3_t in, int column, vec3_t out)
+{
+  const s_float_t *p = &in[0];
+  switch (column) {
+  case 2: { ++p; }
+  case 1: { ++p; }
+  case 0: {
+    out[0] = in[0];
+    out[1] = in[3];
+    out[2] = in[6];
+    break;
+  }
+  default: { break; }
+  }
+}
+
+
+
+void mat3_set_row3(int row, const vec3_t in, mat3_t out)
+{
+  const s_float_t *p = &out[0];
+  switch (row) {
+  case 2: { p += 3; }
+  case 1: { p += 3; }
+  case 0: {
+    out[0] = in[0];
+    out[1] = in[1];
+    out[2] = in[2];
+    break;
+  }
+  default: { break; }
+  }
+}
+
+
+
+void mat3_set_column3(int column, const vec3_t in, mat3_t out)
+{
+  const s_float_t *p = &out[0];
+  switch (column) {
+  case 2: { ++p; }
+  case 1: { ++p; }
+  case 0: {
+    out[0] = in[0];
+    out[3] = in[1];
+    out[6] = in[2];
+    break;
+  }
+  default: { break; }
+  }
+}
+
+
+
+
+
+#if defined(__cplusplus)
+}
+#endif