rmath3d 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ba56d50a0d57ad2687e2d3fb34278961e0524e5
+  data.tar.gz: d12e16143db7abb2ceb3018ebba52081b72631dd
+SHA512:
+  metadata.gz: 442b329ea744cafb2ed79b33e1443d604dce6770dbe2f2fb39cda1921a738a84f20ae4575ef837ff8a93d030d53285fb387e80b7d9a06323a9674ed8862703a0
+  data.tar.gz: 801f92748ee33a253fbb0bf232ed1879d99ff6ee2fd76b34673fa7dadcd4a7d69e1166f094d917c04786b3ee06f7ed790d716ffe3a777642a6bc658369b48773

data/ChangeLog

@@ -0,0 +1,73 @@
+2013-09-16  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* sample/opengl-bingings: Added sample using my opengl-bindings gem ( https://rubygems.org/gems/opengl-bindings ).
+
+2013-07-15  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* Fixed directory organization / source file names to comply with RubyGems' packaging system.
+
+2010-09-14  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RVec3.c|h, RVec4.c|h, WrapRMath.c, RMath.rb (RVec3#transformTransposed, etc): Added.
+
+2010-08-15  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RVec3.c, WrapRMath.c, RMath.rb (RVec3#transformByQuaternion): Added.
+
+2010-06-23  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* WrapRMath.c (RQuat_getElement/RVec3_getElement/RVec4_getElement):
+	Return values from R*GetElement() are now received by correct type (int -> rmReal).
+
+2010-01-03  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RMtx4.c, WrapRMath.c, RMath.rb (RMtx4#getUpper3x3/RMtx4#setUpper3x3): Added.
+	* WrapRMath.c (RMtx4#e00=~RMtx4#e33=): The number of arguments to C function (4th argument of rb_define_method()) is corrected.
+
+2010-01-02  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RMtx3.c, RMtx4.c, WrapRMath.c, RMath.rb (getRow/getColumn, SetRow/SetColumn): Added.
+
+2009-12-21  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* Update: Old contact information is updated to the current one.
+
+2008-08-30  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RMtx3.c, RMtx4.c (RMtx3Inverse,RMtx4Inverse): Modified to reduce
+	the number of scalar multiplication.
+
+2008-08-02  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* WrapRMath.c (RMtx3_to_s, RMtx4_to_s, etc.): Functions for "to_s"
+	implementation now buid strings by +sprintf+, not +rb_str_plus+, etc.
+
+2008-07-27  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RType.h (RMATH_SINGLE_PRECISION): Added. Enable this to force
+	RMath using +float+ for its internal calculation.
+
+	* WrapRMath.c (RMATH_ENABLE_ARGUMENT_CHECK): Added. Enable this
+	macro for strict type checking.
+
+	* WrapRMath.c: The codes for overriding "!=" operators are
+	removed. Note that the operation "a != b" is just a syntactic
+	shortcut of "!(a == b)", and the former expression is
+	automatically convertd into the latter one.
+	See: Programming Ruby: The Pragmatic Programmer's Guide
+	http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_expressions.html#UG
+	  Both == and =~ have negated forms, != and !~. However, these are
+	  converted by Ruby when your program is read. a!=b is equivalent
+	  to !(a==b), and a!~b is the same as !(a=~b). This means that if
+	  you write a class that overrides == or =~ you get a working !=
+	  and !~ for free. But on the flip side, this also means that you
+	  cannot define != and !~ independent of == and =~, respectively.
+
+2008-07-21  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* WrapRMath.c (RMtx3,RMtx4): Added new element-wise
+	getters/setters (mtx.e00, mtx.e00=, etc.)
+
+2008-07-20  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* Announce: First release.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+rmath3d : Ruby math module for 3D Applications
+Copyright (c) 2008- vaiorabbit  <http://twitter.com/vaiorabbit>
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.

data/README.txt

@@ -0,0 +1,154 @@
+=            rmath3d : Ruby Math Module for 3D Applications
+
+rmath3d is a math module for 3D game programming and computer graphics.
+
+                                             Last Update: Sep 16, 2013
+                                                   Since: Jul 20, 2008
+                                                   by vaiorabbit
+== Features
+
+=== Supports frequently-used vector and matrix classes
+
+* RMtx3 (3x3 matrix)
+* RMtx4 (4x4 matrix)
+* RQuat (Quaternion)
+* RVec3 (3 element vector)
+* RVec4 (4 element vector)
+
+=== Two implementations that are interchangeable with each other
+
+1. rmath3d.{so|bundle} : Ruby extension library for faster execution.
+2. rmath3d_plain.rb    : Ruby implemantation for debugging use.
+
+
+== Building rmath3d.{so|bundle}
+
+=== From source package
+
+  $ rake install
+
+=== For mkmf users
+
+  $ ruby extconf.rb
+  $ make
+
+For Windows users, type commands below via the "Visual Studio 200{5|8}
+Command Prompt". This process requires "cl.exe", "link.exe and
+"mt.exe" to be exist in the program PATH:
+
+  X:\> ruby extconf.rb
+  X:\> nmake
+
+You might encounter the "MSC version unmatch: _MSC_VER: XXXX is
+expected." error at the time compiling "rmath3d.c". See the
+instruction in the extconf.rb to avoid this error.
+
+
+=== Embedding manifest file (For Windows users)
+
+Make sure that your rmath3d.so has "rmath3d.so.manifest" embedded into itself.
+Otherwise, while using rmath3d.so in your application, you might come
+across an error dialog saying:
+
+  ---------------------------
+  Microsoft Visual C++ Runtime Library
+  ---------------------------
+  Runtime Error!
+  
+  Program: d:\ruby\bin\ruby.exe
+  
+  R6034
+  An application has made an attempt to load the C runtime library incorrectly.
+  Please contact the application's support team for more information.
+  
+  ---------------------------
+  OK   
+  ---------------------------
+
+To ensure the file status, try checking if the string "manifest" can
+be found in the file:
+
+  X:\> strings rmath3d.so | grep manifest
+
+If you don't see any outputs, it's time to embed "rmath3d.so.manifest". 
+
+  X:\> mt -manifest rmath3d.so.manifest -outputresource:rmath3d.so;2
+
+or run the "embed_manifest.bat" instead. Then check again the status.
+
+  X:\> strings rmath3d.so | grep manifest
+  <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
+
+  X:\> 
+
+If you see some similar output like that, the manifest file
+"rmath3d.so.manifest" is successfully embedded.
+
+
+== About rmath3d_plain.rb
+
+rmath3d_plain.rb is a pure Ruby version of rmath3d.so: all the functionality of
+rmath3d.so is implemented with plain Ruby code.
+It is possible to trace the bugs caused by rmath3d.so by replacing the code
+
+  gem 'rmath3d'
+  require 'rmath3d/rmath3d'
+
+with
+
+  gem 'rmath3d'
+  require 'rmath3d/rmath3d_plain'
+
+rmath3d_plain.rb performs more strict type checking, that might be some burden
+for its execution speed. So don't expect the performance efficiency
+when you use rmath3d_plain.rb instead of rmath3d.so.
+
+
+== Notes
+
+=== Collaboration with ruby-opengl
+
+The instances of RMtx4 can be used directly as the arguments of the
+ruby-opengl functions that accept matrices.
+
+For example, this code snippet using RMath:
+
+  eye = RVec3.new(0.0, 15.0, 15.0)
+  at  = RVec3.new(0.0,  0.0,  0.0)
+  up  = RVec3.new(0.0,  1.0,  0.0)
+  mtxLookAt = RMtx4.new.lookAtRH( eye, at, up )
+  glMatrixMode( GL_PROJECTION )
+  glLoadMatrix( @mtxProj )
+  
+  mtxProj = RMtx4.new.perspectiveFovRH( 30.0*Math::PI/180.0, WINDOW_WIDTH/WINDOW_HEIGHT, 0.1, 1000.0 )
+  glMatrixMode( GL_MODELVIEW )
+  glLoadMatrix( @mtxLookAt )
+
+has the same transformation effect with the OpenGL fixed pipeline:
+
+  glMatrixMode( GL_PROJECTION )
+  gluPerspective( 30.0*Math::PI/180.0, WINDOW_WIDTH/WINDOW_HEIGHT, 0.1, 1000.0 )
+
+  glMatrixMode( GL_MODELVIEW )
+  gluLookAt( 0.0,15.0,15.0, 0.0,0.0,0.0, 0.0,1.0,0.0 )
+
+
+=== Compatibility with matrix.rb
+
+Currently, there is no combenient way to convert between matrix.rb's
++Matrix+ and +RMtx{3|4}".
+
+(The matrix.rb is a standard Ruby library that provides N-dimensional
++Vector+ class and "N x M" +Matrix+ class.)
+
+
+
+== Credits
+
+* vaiorabbit  <http://twitter.com/vaiorabbit>
+
+ 
+== License
+
+All source codes are available under the terms of the zlib/libpng license
+(see LICENSE.txt).

data/Rakefile

@@ -0,0 +1,42 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'rake/clean'
+require 'rbconfig'
+
+NAME = 'rmath3d'
+
+# "bundle", "so", etc.
+DLEXT = RbConfig::CONFIG['DLEXT']
+
+# rule to build the extension: this says
+# that the extension should be rebuilt
+# after any change to the files in ext
+file "lib/#{NAME}/#{NAME}.#{DLEXT}" =>
+    Dir.glob("ext/#{NAME}/*{.rb,.c}") do
+  Dir.chdir("ext/#{NAME}") do
+    # this does essentially the same thing
+    # as what RubyGems does
+    ruby "extconf.rb", *ARGV.grep(/\A--/)
+    sh "make", *ARGV.grep(/\A(?!--)/)
+  end
+  cp "ext/#{NAME}/#{NAME}.#{DLEXT}", "lib/#{NAME}"
+end
+
+# make the :test task depend on the shared
+# object, so it will be built automatically
+# before running the tests
+task :test => "lib/#{NAME}/#{NAME}.#{DLEXT}"
+
+# use 'rake clean' and 'rake clobber' to
+# easily delete generated files
+CLEAN.include('ext/**/*{.o,.log,.#{DLEXT}}')
+CLEAN.include('ext/**/Makefile')
+CLOBBER.include('lib/**/*.#{DLEXT}')
+
+# the same as before
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/ext/rmath3d/RMath3D.h

@@ -0,0 +1,35 @@
+#ifndef RMATH_H_INCLUDED
+#define RMATH_H_INCLUDED
+
+#include "RType.h"
+#include "RVec3.h"
+#include "RVec4.h"
+#include "RQuat.h"
+#include "RMtx3.h"
+#include "RMtx4.h"
+
+#endif
+
+/*
+RMath : Ruby math module for 3D Applications
+Copyright (c) 2008- vaiorabbit  <http://twitter.com/vaiorabbit>
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+*/

data/ext/rmath3d/RMtx3.c

@@ -0,0 +1,370 @@
+#include <math.h>
+#include <string.h>
+
+#include "RVec3.h"
+#include "RQuat.h"
+#include "RMtx3.h"
+
+/* NOTE : column-major */
+#define SET_ELEMENT(out, row, col, val) (out)->e[(col)*3+(row)] = (val)
+#define GET_ELEMENT(in, row, col) ((in)->e[(col)*3+(row)])
+
+void
+RMtx3SetElement( RMtx3* out, int row, int col, rmReal e )
+{
+    SET_ELEMENT( out, row, col, e );
+}
+
+rmReal
+RMtx3GetElement( const RMtx3* in, int row, int col )
+{
+    return GET_ELEMENT( in, row, col );
+}
+
+void
+RMtx3GetRow( RVec3* out, const RMtx3* in, int row )
+{
+    RVec3SetX( out, GET_ELEMENT( in, row, 0 ) );
+    RVec3SetY( out, GET_ELEMENT( in, row, 1 ) );
+    RVec3SetZ( out, GET_ELEMENT( in, row, 2 ) );
+}
+
+void
+RMtx3GetColumn( RVec3* out, const RMtx3* in, int col )
+{
+    RVec3SetX( out, GET_ELEMENT( in, 0, col ) );
+    RVec3SetY( out, GET_ELEMENT( in, 1, col ) );
+    RVec3SetZ( out, GET_ELEMENT( in, 2, col ) );
+}
+
+void
+RMtx3SetRow( RMtx3* out, const RVec3* in, int row )
+{
+    SET_ELEMENT( out, row, 0, RVec3GetElement( in, 0 ) );
+    SET_ELEMENT( out, row, 1, RVec3GetElement( in, 1 ) );
+    SET_ELEMENT( out, row, 2, RVec3GetElement( in, 2 ) );
+}
+
+void
+RMtx3SetColumn( RMtx3* out, const RVec3* in, int col )
+{
+    SET_ELEMENT( out, 0, col, RVec3GetElement( in, 0 ) );
+    SET_ELEMENT( out, 1, col, RVec3GetElement( in, 1 ) );
+    SET_ELEMENT( out, 2, col, RVec3GetElement( in, 2 ) );
+}
+
+void
+RMtx3Copy( RMtx3* out, const RMtx3* in )
+{
+    memmove( out, in, sizeof(RMtx3) );
+}
+
+void
+RMtx3SetElements( RMtx3* out,
+                  rmReal e00, rmReal e01, rmReal e02,
+                  rmReal e10, rmReal e11, rmReal e12,
+                  rmReal e20, rmReal e21, rmReal e22
+    )
+{
+    SET_ELEMENT( out, 0, 0, e00 );
+    SET_ELEMENT( out, 0, 1, e01 );
+    SET_ELEMENT( out, 0, 2, e02 );
+
+    SET_ELEMENT( out, 1, 0, e10 );
+    SET_ELEMENT( out, 1, 1, e11 );
+    SET_ELEMENT( out, 1, 2, e12 );
+
+    SET_ELEMENT( out, 2, 0, e20 );
+    SET_ELEMENT( out, 2, 1, e21 );
+    SET_ELEMENT( out, 2, 2, e22 );
+}
+
+void
+RMtx3Zero( RMtx3* out )
+{
+    int row, col;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( out, row, col, 0.0f );
+}
+
+void
+RMtx3Identity( RMtx3* out )
+{
+    int row, col;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( out, row, col, (row==col) ? 1.0f : 0.0f );
+}
+
+rmReal
+RMtx3Determinant( const RMtx3* in )
+{
+#define I( r, c ) GET_ELEMENT( in, (r), (c) )
+#define D( e00, e01, e10, e11 ) ((e00)*(e11)-(e01)*(e10))
+
+    return
+        I(0,0) * D( I(1,1), I(1,2), I(2,1), I(2,2) ) -
+        I(0,1) * D( I(1,0), I(1,2), I(2,0), I(2,2) ) +
+        I(0,2) * D( I(1,0), I(1,1), I(2,0), I(2,1) ) ;
+
+#undef I
+#undef D
+}
+
+void
+RMtx3Transpose( RMtx3* out, const RMtx3* in )
+{
+    int row, col;
+    RMtx3 tmp;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( &tmp, row, col, GET_ELEMENT( in, col, row ) );
+
+    RMtx3Copy( out, &tmp );
+}
+
+rmReal
+RMtx3Inverse( RMtx3* out, const RMtx3* in )
+{
+#define I( r, c ) GET_ELEMENT( in, (r), (c) )
+#define R( r, c ) GET_ELEMENT( &result, (r), (c) )
+#define D( e00, e01, e10, e11 ) ((e00)*(e11)-(e01)*(e10))
+
+    RMtx3 result;
+    rmReal det;
+
+    SET_ELEMENT( &result, 0, 0,  D( I(1,1),I(1,2), I(2,1),I(2,2) ) );
+    SET_ELEMENT( &result, 0, 1, -D( I(0,1),I(0,2), I(2,1),I(2,2) ) );
+    SET_ELEMENT( &result, 0, 2,  D( I(0,1),I(0,2), I(1,1),I(1,2) ) );
+
+    SET_ELEMENT( &result, 1, 0, -D( I(1,0),I(1,2), I(2,0),I(2,2) ) );
+    SET_ELEMENT( &result, 1, 1,  D( I(0,0),I(0,2), I(2,0),I(2,2) ) );
+    SET_ELEMENT( &result, 1, 2, -D( I(0,0),I(0,2), I(1,0),I(1,2) ) );
+
+    SET_ELEMENT( &result, 2, 0,  D( I(1,0),I(1,1), I(2,0),I(2,1) ) );
+    SET_ELEMENT( &result, 2, 1, -D( I(0,0),I(0,1), I(2,0),I(2,1) ) );
+    SET_ELEMENT( &result, 2, 2,  D( I(0,0),I(0,1), I(1,0),I(1,1) ) );
+
+    det = I(0,0) * R(0,0) + I(0,1) * R(1,0) + I(0,2) * R(2,0);
+
+    if ( rmFabs(det) < RMATH_TOLERANCE )
+        return det;
+
+    RMtx3Scale( out, &result, 1.0f / det );
+
+    return det;
+
+#undef I
+#undef R
+#undef D
+}
+
+
+/* http://en.wikipedia.org/wiki/Rotation_representation_%28mathematics%29
+   http://en.wikipedia.org/wiki/Rotation_matrix
+*/
+void
+RMtx3RotationX( RMtx3* out, rmReal radian )
+{
+    rmReal s = rmSin( radian );
+    rmReal c = rmCos( radian );
+
+    RMtx3Identity( out );
+    SET_ELEMENT( out, 1, 1,  c );
+    SET_ELEMENT( out, 1, 2, -s );
+    SET_ELEMENT( out, 2, 1,  s );
+    SET_ELEMENT( out, 2, 2,  c );
+}
+
+/* http://en.wikipedia.org/wiki/Rotation_representation_%28mathematics%29
+   http://en.wikipedia.org/wiki/Rotation_matrix
+*/
+void
+RMtx3RotationY( RMtx3* out, rmReal radian )
+{
+    rmReal s = rmSin( radian );
+    rmReal c = rmCos( radian );
+
+    RMtx3Identity( out );
+    SET_ELEMENT( out, 0, 0,  c );
+    SET_ELEMENT( out, 0, 2,  s );
+    SET_ELEMENT( out, 2, 0, -s );
+    SET_ELEMENT( out, 2, 2,  c );
+}
+
+/* http://en.wikipedia.org/wiki/Rotation_representation_%28mathematics%29
+   http://en.wikipedia.org/wiki/Rotation_matrix
+*/
+void
+RMtx3RotationZ( RMtx3* out, rmReal radian )
+{
+    rmReal s = rmSin( radian );
+    rmReal c = rmCos( radian );
+
+    RMtx3Identity( out );
+    SET_ELEMENT( out, 0, 0,  c );
+    SET_ELEMENT( out, 0, 1, -s );
+    SET_ELEMENT( out, 1, 0,  s );
+    SET_ELEMENT( out, 1, 1,  c );
+}
+
+/* http://en.wikipedia.org/wiki/Rotation_matrix
+ */
+void
+RMtx3RotationAxis( RMtx3* out, const RVec3* axis, rmReal radian )
+{
+    rmReal s = rmSin( radian );
+    rmReal c = rmCos( radian );
+    rmReal C = 1.0f - c;
+    rmReal x = RVec3GetX( axis );
+    rmReal y = RVec3GetY( axis );
+    rmReal z = RVec3GetZ( axis );
+
+    SET_ELEMENT( out, 0, 0, x*x*C + c );
+    SET_ELEMENT( out, 0, 1, x*y*C - z*s );
+    SET_ELEMENT( out, 0, 2, z*x*C + y*s );
+    SET_ELEMENT( out, 1, 0, x*y*C + z*s );
+    SET_ELEMENT( out, 1, 1, y*y*C + c );
+    SET_ELEMENT( out, 1, 2, y*z*C - x*s );
+    SET_ELEMENT( out, 2, 0, z*x*C - y*s );
+    SET_ELEMENT( out, 2, 1, y*z*C + x*s );
+    SET_ELEMENT( out, 2, 2, z*z*C + c );
+}
+
+/* From Quaternion to Matrix and Back
+   http://www.intel.com/cd/ids/developer/asmo-na/eng/293748.htm
+*/
+void
+RMtx3RotationQuaternion( RMtx3* out, const struct RQuat* q )
+{
+    rmReal x  = RQuatGetX( q );
+    rmReal y  = RQuatGetY( q );
+    rmReal z  = RQuatGetZ( q );
+    rmReal w  = RQuatGetW( q );
+
+    rmReal x2 = 2.0f * x;
+    rmReal y2 = 2.0f * y;
+    rmReal z2 = 2.0f * z;
+
+    rmReal xx2 = x * x2;
+    rmReal yy2 = y * y2;
+    rmReal zz2 = z * z2;
+
+    rmReal yz2 = y * z2;
+    rmReal wx2 = w * x2;
+    rmReal xy2 = x * y2;
+    rmReal wz2 = w * z2;
+    rmReal xz2 = x * z2;
+    rmReal wy2 = w * y2;
+
+    RMtx3Identity( out );
+    SET_ELEMENT( out, 0, 0, 1.0f - yy2 - zz2 );
+    SET_ELEMENT( out, 1, 0, xy2 + wz2 );
+    SET_ELEMENT( out, 2, 0, xz2 - wy2 );
+    SET_ELEMENT( out, 0, 1, xy2 - wz2 );
+    SET_ELEMENT( out, 1, 1, 1.0f - xx2 - zz2 );
+    SET_ELEMENT( out, 2, 1, yz2 + wx2 );
+    SET_ELEMENT( out, 0, 2, xz2 + wy2 );
+    SET_ELEMENT( out, 1, 2, yz2 - wx2 );
+    SET_ELEMENT( out, 2, 2, 1.0f - xx2 - yy2 );
+}
+
+void
+RMtx3Scaling( RMtx3* out, rmReal sx, rmReal sy, rmReal sz )
+{
+    RMtx3Identity( out );
+    SET_ELEMENT( out, 0, 0, sx );
+    SET_ELEMENT( out, 1, 1, sy );
+    SET_ELEMENT( out, 2, 2, sz );
+}
+
+
+int
+RMtx3Equal( const RMtx3* m1, const RMtx3* m2 )
+{
+    if ( 0 == memcmp( m1, m2, sizeof(RMtx3) ) )
+        return !0;
+    else
+        return 0;
+}
+
+
+void
+RMtx3Add( RMtx3* out, const RMtx3* m1, const RMtx3* m2 )
+{
+    int row, col;
+    RMtx3 tmp;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( &tmp, row, col,
+                         GET_ELEMENT( m1, row, col ) + GET_ELEMENT( m2, row, col ) );
+
+    RMtx3Copy( out, &tmp );
+}
+
+void
+RMtx3Sub( RMtx3* out, const RMtx3* m1, const RMtx3* m2 )
+{
+    int row, col;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( out, row, col,
+                         GET_ELEMENT( m1, row, col ) - GET_ELEMENT( m2, row, col ) );
+}
+
+void
+RMtx3Mul( RMtx3* out, const RMtx3* m1, const RMtx3* m2 )
+{
+    int row, col;
+    RMtx3 tmp;
+    for ( row = 0; row < 3; ++row )
+    {
+        for ( col = 0; col < 3; ++col )
+        {
+            int i;
+            rmReal sum = 0.0f;
+            for ( i = 0; i < 3; ++i )
+            {
+                sum += GET_ELEMENT( m1, row, i ) * GET_ELEMENT( m2, i, col );
+            }
+            SET_ELEMENT( &tmp, row, col, sum );
+        }
+    }
+
+    RMtx3Copy( out, &tmp );
+}
+
+void
+RMtx3Scale( RMtx3* out, const RMtx3* m, rmReal f )
+{
+    int row, col;
+    for ( row = 0; row < 3; ++row )
+        for ( col = 0; col < 3; ++col )
+            SET_ELEMENT( out, row, col,
+                         GET_ELEMENT( m, row, col ) * f );
+}
+
+/*
+RMath : Ruby math module for 3D Applications
+Copyright (c) 2008- vaiorabbit  <http://twitter.com/vaiorabbit>
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any damages
+arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose,
+including commercial applications, and to alter it and redistribute it
+freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not
+    claim that you wrote the original software. If you use this software
+    in a product, an acknowledgment in the product documentation would be
+    appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be
+    misrepresented as being the original software.
+
+    3. This notice may not be removed or altered from any source
+    distribution.
+ */