rmath3d_plain 1.0.2 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3625f1baf42745a3e10bcba93e504b9c83764180
-  data.tar.gz: e1f7590e0aa500ab797a31434cd1b3a397e2840f
+  metadata.gz: 5b2a5f2fa521f8b303ef746634b8574967b7b703
+  data.tar.gz: ecfe68cac549e516052ea77ddd885051fd36fc81
 SHA512:
-  metadata.gz: aba8c4dae29be93bf0beb77cc11c4a401db89fdf8e7b608d41dff379bbec96c6702c14669c23933e24df05c5d79d0500e322659f6c12a8a5818c72a09646a0c9
-  data.tar.gz: 2b9c55755c9aa514735e63129df3d37b6486b3b83746b549ddae0a3c87e9bb0cc77ce140632b115dbf750c8aeb68535ae500106b27d9fb4fa581f9aeadcfcc69
+  metadata.gz: 1bda4cabbc91bc183b5881f5c51c0716c3fb8b0f1b3562eb8843e47c3bd3f774c69de6111c4f7412103e81b2258b3476cd7f1b974c6aaa9abbc8b05c3d447750
+  data.tar.gz: a58f95113e0d9e3bef1488fdf26d79c2069f3fb0654eeeaec0bd6741ceb43941ec2af3e8cd7c016d3524d5adcda99933da38e1c4496cfb7f1c1335aea23ef245

data/ChangeLog

@@ -1,3 +1,7 @@
+2015-04-12  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* RVec2.c|h, RMtx2.c|h: Added.
+
 2014-05-17  vaiorabbit  <http://twitter.com/vaiorabbit>
 
 	* ext/rmath3d/rmath3d.c: Fixed memory management

data/LICENSE.txt

@@ -1,5 +1,5 @@
 rmath3d : Ruby math module for 3D Applications
-Copyright (c) 2008-2014 vaiorabbit  <http://twitter.com/vaiorabbit>
+Copyright (c) 2008-2015 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

data/README.md

@@ -4,18 +4,20 @@
 
 rmath3d is a math module for 3D game programming and computer graphics.
 
-*   Last Update: May 17, 2014
+*   Last Update: Apr 12, 2015
 *   Since: Jul 20, 2008
 
 ## Features ##
 
 ### Supports frequently-used vector and matrix classes ###
 
+*   RMtx2 (2x2 matrix)
 *   RMtx3 (3x3 matrix)
 *   RMtx4 (4x4 matrix)
 *   RQuat (Quaternion)
-*   RVec3 (3 element vector)
-*   RVec4 (4 element vector)
+*   RVec2 (2-element vector)
+*   RVec3 (3-element vector)
+*   RVec4 (4-element vector)
 
 ### Two implementations that are interchangeable with each other ###
 

data/lib/rmath3d/rmath3d_plain.rb

@@ -3,62 +3,59 @@ module RMath3D
   TOLERANCE = 1.0e-15
 
   #
-  # Document-class: RMath3D::RMtx3
-  # provies 3x3 matrix arithmetic.
+  # Document-class: RMath3D::RMtx2
+  # provies 2x2 matrix arithmetic.
   #
   # <b>Notice</b>
   # * elements are stored in column-major order.
   #
-  class RMtx3
+  class RMtx2
 
     #
     # call-seq:
-    #   RMtx3.new -> ((1,0,0),(0,1,0),(0,0,1))
-    #   RMtx3.new(e) -> ((e,e,e), (e,e,e), (e,e,e))
-    #   RMtx3.new( other ) : Copy Constructor
-    #   RMtx3.new( e0, e1, ..., e8 ) -> ((e0,e1,e2), (e3,e4,e5), (e6,e7,e8))
+    #   RMtx2.new -> ((1,0),(0,1))
+    #   RMtx2.new(e) -> ((e,e), (e,e))
+    #   RMtx2.new( other ) : Copy Constructor
+    #   RMtx2.new( e0, e1, e2, e3 ) -> ((e0,e1), (e2,e3))
     #
-    # Creates a new 3x3 matrix.
+    # Creates a new 2x2 matrix.
     #
     def initialize( *a )
       # [NOTE] elemetns are stored in column-major order.
       @e = []
       case a.length
       when 0
-        @e = [ 0.0, 0.0, 0.0,
-               0.0, 0.0, 0.0,
-               0.0, 0.0, 0.0 ]
+        @e = [ 0.0, 0.0,
+               0.0, 0.0 ]
       when 1
         case a[0]
         when Fixnum, Float
-          @e = [ a[0], a[0], a[0],
-                 a[0], a[0], a[0],
-                 a[0], a[0], a[0] ]
-        when RMtx3
+          @e = [ a[0], a[0],
+                 a[0], a[0] ]
+        when RMtx2
           # Copy Constructor
-          @e = [ a[0].e00, a[0].e10, a[0].e20,
-                 a[0].e01, a[0].e11, a[0].e21,
-                 a[0].e02, a[0].e12, a[0].e22 ]
+          @e = [ a[0].e00, a[0].e10,
+                 a[0].e01, a[0].e11 ]
         else
-          raise TypeError, "RMtx3#initialize : Unknown type #{a[0].class}."
+          raise TypeError, "RMtx2#initialize : Unknown type #{a[0].class}."
           return nil
         end
-      when 9
+      when 4
         # Element-wise setter
-        for row in 0...3 do
-          for col in 0...3 do
-            index = 3*row + col
+        for row in 0...2 do
+          for col in 0...2 do
+            index = 2*row + col
             case a[index]
             when Fixnum, Float
               setElement( row, col, a[index] )
             else
-              raise TypeError, "RMtx3#initialize : Unknown type #{a[0].class}."
+              raise TypeError, "RMtx2#initialize : Unknown type #{a[0].class}."
               return nil
             end
           end
         end
       else
-        raise RuntimeError, "RMtx3#initialize : wrong # of arguments (#{a.length})"
+        raise RuntimeError, "RMtx2#initialize : wrong # of arguments (#{a.length})"
         return nil
       end
 
@@ -71,9 +68,8 @@ module RMath3D
     # Returns human-readable string.
     #
     def to_s
-      "( #{@e[0]}, #{@e[3]}, #{@e[6]} )\n" +
-      "( #{@e[1]}, #{@e[4]}, #{@e[7]} )\n" +
-      "( #{@e[2]}, #{@e[5]}, #{@e[8]} )\n"
+      "( #{@e[0]}, #{@e[2]} )\n" +
+      "( #{@e[1]}, #{@e[3]} )\n"
     end
 
     #
@@ -95,25 +91,25 @@ module RMath3D
       when Fixnum, Float, Bignum
         return [ self, arg ]
       else
-        raise TypeError, "RMtx3#coerce : #{arg.self} can't be coerced into  #{self.class}."
+        raise TypeError, "RMtx2#coerce : #{arg.self} can't be coerced into  #{self.class}."
         return nil
       end
     end
 
     #
-    # call-seq: setElements( e0, e1, ..., e8 )
+    # call-seq: setElements( e0, e1, e2, e3 )
     #
-    # Stores given 9 new values.
+    # Stores given 4 new values.
     #
     def setElements( *a )
-      if a.length != 9
-        raise RuntimeError, "RMtx3#setElements : wrong # of arguments (#{a.length})"
+      if a.length != 4
+        raise RuntimeError, "RMtx2#setElements : wrong # of arguments (#{a.length})"
         return nil
       end
 
-      for row in 0...3 do
-        for col in 0...3 do
-          index = 3*row + col
+      for row in 0...2 do
+        for col in 0...2 do
+          index = 2*row + col
           setElement( row, col, a[index] )
         end
       end
@@ -126,7 +122,7 @@ module RMath3D
     #
     def []=(row,col,value)
       # [NOTE] elemetns are stored in column-major order.
-      @e[col*3+row] = value
+      @e[col*2+row] = value
     end
     alias_method :setElement, :'[]='
 
@@ -137,7 +133,7 @@ module RMath3D
     #
     def [](row,col)
       # [NOTE] elemetns are stored in column-major order.
-      return @e[col*3+row]
+      return @e[col*2+row]
     end
     alias_method :getElement, :'[]'
 
@@ -145,79 +141,57 @@ module RMath3D
     def e00() getElement(0,0) end
     # Returns the element at row 0 and column 1.
     def e01() getElement(0,1) end
-    # Returns the element at row 0 and column 2.
-    def e02() getElement(0,2) end
     # Returns the element at row 1 and column 0.
     def e10() getElement(1,0) end
     # Returns the element at row 1 and column 1.
     def e11() getElement(1,1) end
-    # Returns the element at row 1 and column 2.
-    def e12() getElement(1,2) end
-    # Returns the element at row 2 and column 0.
-    def e20() getElement(2,0) end
-    # Returns the element at row 2 and column 1.
-    def e21() getElement(2,1) end
-    # Returns the element at row 2 and column 2.
-    def e22() getElement(2,2) end
 
     # Replaces the element at row 0 and column 0 by +value+.
     def e00=(value) setElement(0,0,value) end
     # Replaces the element at row 0 and column 1 by +value+.
     def e01=(value) setElement(0,1,value) end
-    # Replaces the element at row 0 and column 2 by +value+.
-    def e02=(value) setElement(0,2,value) end
     # Replaces the element at row 1 and column 0 by +value+.
     def e10=(value) setElement(1,0,value) end
     # Replaces the element at row 1 and column 1 by +value+.
     def e11=(value) setElement(1,1,value) end
-    # Replaces the element at row 1 and column 2 by +value+.
-    def e12=(value) setElement(1,2,value) end
-    # Replaces the element at row 2 and column 0 by +value+.
-    def e20=(value) setElement(2,0,value) end
-    # Replaces the element at row 2 and column 1 by +value+.
-    def e21=(value) setElement(2,1,value) end
-    # Replaces the element at row 2 and column 2 by +value+.
-    def e22=(value) setElement(2,2,value) end
 
 
     #
-    # call-seq: mtx3.getRow(r) -> RVec3
+    # call-seq: mtx2.getRow(r) -> RVec2
     #
     # Returns +r+-th row vector.
     #
     def getRow( row )
-      return RVec3.new( self[row,0], self[row,1], self[row,2] )
+      return RVec2.new( self[row,0], self[row,1] )
     end
 
     #
-    # call-seq: mtx3.getColumn(c) -> RVec3
+    # call-seq: mtx2.getColumn(c) -> RVec2
     #
     # Returns +c+-th column vector.
     #
     def getColumn( column )
-      return RVec3.new( self[0,column], self[1,column], self[2,column] )
+      return RVec2.new( self[0,column], self[1,column] )
     end
 
     #
-    # call-seq: mtx3.setRow(v,r)
+    # call-seq: mtx2.setRow(v,r)
     #
     # Returns sets +r+-th row by vector +v+.
     #
     def setRow( v, row )
       self[row,0] = v.x
       self[row,1] = v.y
-      self[row,2] = v.z
     end
 
     #
-    # call-seq: mtx3.setColumn(v,c)
+    # call-seq: mtx2.setColumn(v,c)
     #
     # Returns sets +c+-th column by vector +v+.
     #
     def setColumn( v, column )
       self[0,column] = v.x
       self[1,column] = v.y
-      self[2,column] = v.z
     end
 
     #
@@ -226,7 +200,7 @@ module RMath3D
     # Clears all elements by 0.0
     #
     def setZero
-      9.times do |i|
+      4.times do |i|
         @e[i] = 0.0
       end
       return self
@@ -238,9 +212,9 @@ module RMath3D
     # Sets as identity matrix.
     #
     def setIdentity
-      for row in 0...3 do
-        for col in 0...3 do
-          index = 3*row + col
+      for row in 0...2 do
+        for col in 0...2 do
+          index = 2*row + col
           if ( row == col )
             setElement( row, col, 1.0 )
           else
@@ -257,9 +231,7 @@ module RMath3D
     # Calculates determinant.
     #
     def getDeterminant
-      e00 * (e11*e22 - e12*e21) -
-      e01 * (e10*e22 - e12*e20) +
-      e02 * (e10*e21 - e11*e20)
+      e00 * e11 - e01 * e10
     end
 
     #
@@ -268,9 +240,8 @@ module RMath3D
     # Returns transposed matrix.
     #
     def getTransposed
-      return RMtx3.new( @e[0], @e[1], @e[2],
-                        @e[3], @e[4], @e[5],
-                        @e[6], @e[7], @e[8] )
+      return RMtx2.new( @e[0], @e[1],
+                        @e[2], @e[3] )
     end
 
     #
@@ -279,9 +250,7 @@ module RMath3D
     # Transposeas its elements.
     #
     def transpose!
-      @e[1], @e[3] = @e[3], @e[1]
-      @e[2], @e[6] = @e[6], @e[2]
-      @e[5], @e[7] = @e[7], @e[5]
+      @e[1], @e[2] = @e[2], @e[1]
     end
 
     #
@@ -290,27 +259,21 @@ module RMath3D
     # Returns the inverse.
     #
     def getInverse
-      result = RMtx3.new
-
-      result.e00 =  (self.e11*self.e22 - self.e12*self.e21)
-      result.e01 = -(self.e01*self.e22 - self.e02*self.e21)
-      result.e02 =  (self.e01*self.e12 - self.e02*self.e11)
-
-      result.e10 = -(self.e10*self.e22 - self.e12*self.e20)
-      result.e11 =  (self.e00*self.e22 - self.e02*self.e20)
-      result.e12 = -(self.e00*self.e12 - self.e02*self.e10)
-
-      result.e20 =  (self.e10*self.e21 - self.e11*self.e20)
-      result.e21 = -(self.e00*self.e21 - self.e01*self.e20)
-      result.e22 =  (self.e00*self.e11 - self.e01*self.e10)
-
-      det = e00 * result.e00 + e01 * result.e10 + e02 * result.e20
+      det = getDeterminant()
 
       if ( det.abs < TOLERANCE )
-        raise RuntimeError, "RMtx3#getInverse : det.abs < TOLERANCE"
+        raise RuntimeError, "RMtx2#getInverse : det.abs < TOLERANCE"
         return nil
       end
 
+      result = RMtx2.new
+
+      result.e00 =  self.e11
+      result.e01 = -self.e01
+
+      result.e10 = -self.e10
+      result.e11 =  self.e00
+
       d = 1.0 / det
 
       result.mul!( d )
@@ -324,84 +287,38 @@ module RMath3D
     # Makes itself as the inverse of the original matrix.
     #
     def invert!
-      elements = Array.new( 9 )
-
-      elements[3*0+0] =  (self.e11*self.e22 - self.e12*self.e21)
-      elements[3*0+1] = -(self.e01*self.e22 - self.e02*self.e21)
-      elements[3*0+2] =  (self.e01*self.e12 - self.e02*self.e11)
-
-      elements[3*1+0] = -(self.e10*self.e22 - self.e12*self.e20)
-      elements[3*1+1] =  (self.e00*self.e22 - self.e02*self.e20)
-      elements[3*1+2] = -(self.e00*self.e12 - self.e02*self.e10)
-
-      elements[3*2+0] =  (self.e10*self.e21 - self.e11*self.e20)
-      elements[3*2+1] = -(self.e00*self.e21 - self.e01*self.e20)
-      elements[3*2+2] =  (self.e00*self.e11 - self.e01*self.e10)
-
-      det = e00 * elements[3*0+0] + e01 * elements[3*1+0] + e02 * elements[3*2+0]
+      det = getDeterminant()
 
       if ( det.abs < TOLERANCE )
-        raise RuntimeError, "RMtx3#invert! : det.abs < TOLERANCE"
+        raise RuntimeError, "RMtx2#invert! : det.abs < TOLERANCE"
         return nil
       end
 
-      d = 1.0 / det
-
-      setElement( 0, 0, d * elements[3*0+0] )
-      setElement( 0, 1, d * elements[3*0+1] )
-      setElement( 0, 2, d * elements[3*0+2] )
-      setElement( 1, 0, d * elements[3*1+0] )
-      setElement( 1, 1, d * elements[3*1+1] )
-      setElement( 1, 2, d * elements[3*1+2] )
-      setElement( 2, 0, d * elements[3*2+0] )
-      setElement( 2, 1, d * elements[3*2+1] )
-      setElement( 2, 2, d * elements[3*2+2] )
-
-      return self
-    end
+      elements = Array.new( 4 )
 
-    #
-    # call-seq: rotationX(radian) -> self
-    #
-    # Makes a matrix that rotates around the x-axis.
-    #
-    def rotationX( radian )
-      s = Math.sin( radian )
-      c = Math.cos( radian )
+      elements[2*0+0] =  self.e11
+      elements[2*0+1] = -self.e01
 
-      setIdentity()
-      self.e11 =  c
-      self.e12 = -s
-      self.e21 =  s
-      self.e22 =  c
+      elements[2*1+0] = -self.e10
+      elements[2*1+1] =  self.e00
 
-      return self
-    end
+      d = 1.0 / det
 
-    #
-    # call-seq: rotationY(radian) -> self
-    #
-    # Makes a matrix that rotates around the y-axis.
-    #
-    def rotationY( radian )
-      s = Math.sin( radian )
-      c = Math.cos( radian )
+      setElement( 0, 0, d * elements[2*0+0] )
+      setElement( 0, 1, d * elements[2*0+1] )
 
-      setIdentity()
-      self.e00 =  c
-      self.e02 =  s
-      self.e20 = -s
-      self.e22 =  c
+      setElement( 1, 0, d * elements[2*1+0] )
+      setElement( 1, 1, d * elements[2*1+1] )
 
       return self
     end
 
     #
-    # call-seq: rotationZ(radian) -> self
+    # call-seq: rotation(radian) -> self
     #
     # Makes a matrix that rotates around the z-axis.
     #
-    def rotationZ( radian )
+    def rotation( radian )
       s = Math.sin( radian )
       c = Math.cos( radian )
 
@@ -415,88 +332,14 @@ module RMath3D
     end
 
     #
-    # call-seq: rotationAxis(axis,radian) -> self
-    #
-    # Makes a matrix that rotates around the +axis+.
-    #
-    def rotationAxis( axis, radian )
-      if ( axis.class != RVec3 )
-        raise TypeError, "RMtx3#rotationAxis : Unknown type #{axis.class} given as axis."
-        return nil
-      end
-      s   = Math.sin( radian )
-      c   = Math.cos( radian )
-      omc = 1.0 - c
-      x   = axis.x.to_f
-      y   = axis.y.to_f
-      z   = axis.z.to_f
-
-      self.e00 = x*x*omc + c
-      self.e01 = x*y*omc - z*s
-      self.e02 = z*x*omc + y*s
-      self.e10 = x*y*omc + z*s
-      self.e11 = y*y*omc + c
-      self.e12 = y*z*omc - x*s
-      self.e20 = z*x*omc - y*s
-      self.e21 = y*z*omc + x*s
-      self.e22 = z*z*omc + c
-
-      return self
-    end
-
-    #
-    # call-seq: rotationQuaternion(q) -> self
-    #
-    # Makes a rotation matrix from a normalized quaternion +q+.
-    #
-    def rotationQuaternion( q )
-      if ( q.class != RQuat )
-        raise TypeError, "RMtx3#rotationQuaternion : Unknown type #{q.class} given as RQuat."
-        return nil
-      end
-      x  = q.x
-      y  = q.y
-      z  = q.z
-      w  = q.w
-
-      x2 = 2.0 * x
-      y2 = 2.0 * y
-      z2 = 2.0 * z
-
-      xx2 = x * x2
-      yy2 = y * y2
-      zz2 = z * z2
-
-      yz2 = y * z2
-      wx2 = w * x2
-      xy2 = x * y2
-      wz2 = w * z2
-      xz2 = x * z2
-      wy2 = w * y2
-
-      self.e00 = 1.0 - yy2 - zz2
-      self.e10 = xy2 + wz2
-      self.e20 = xz2 - wy2
-      self.e01 = xy2 - wz2
-      self.e11 = 1.0 - xx2 - zz2
-      self.e21 = yz2 + wx2
-      self.e02 = xz2 + wy2
-      self.e12 = yz2 - wx2
-      self.e22 = 1.0 - xx2 - yy2
-
-      return self
-    end
-
-    #
-    # call-seq: scaling(sx,sy,sz) -> self
+    # call-seq: scaling(sx,sy) -> self
     #
     # Makes itself as a scaling matrix.
     #
-    def scaling( sx, sy, sz )
+    def scaling( sx, sy )
       setIdentity()
       setElement( 0, 0, sx )
       setElement( 1, 1, sy )
-      setElement( 2, 2, sz )
 
       return self
     end
@@ -516,7 +359,7 @@ module RMath3D
     # -mtx : Unary minus operator.
     #
     def -@
-      return RMtx3.new( self * -1.0 )
+      return RMtx2.new( self * -1.0 )
     end
 
     #
@@ -525,14 +368,14 @@ module RMath3D
     # mtx1 + mtx2 : Binary plus operator.
     #
     def +( arg )
-      if ( arg.class != RMtx3 )
-        raise TypeError, "RMtx3#+(arg) : Unknown type #{arg.class} given as RMtx3."
+      if ( arg.class != RMtx2 )
+        raise TypeError, "RMtx2#+(arg) : Unknown type #{arg.class} given as RMtx2."
         return nil
       end
 
-      result = RMtx3.new
-      for row in 0...3 do
-        for col in 0...3 do
+      result = RMtx2.new
+      for row in 0...2 do
+        for col in 0...2 do
           result.setElement( row, col, getElement(row,col) + arg.getElement(row,col) )
         end
       end
@@ -546,14 +389,14 @@ module RMath3D
     # mtx1 - mtx2 : Binary minus operator.
     #
     def -( arg )
-      if ( arg.class != RMtx3 )
-        raise TypeError, "RMtx3#-(arg) : Unknown type #{arg.class} given as RMtx3."
+      if ( arg.class != RMtx2 )
+        raise TypeError, "RMtx2#-(arg) : Unknown type #{arg.class} given as RMtx2."
         return nil
       end
 
-      result = RMtx3.new
-      for row in 0...3 do
-        for col in 0...3 do
+      result = RMtx2.new
+      for row in 0...2 do
+        for col in 0...2 do
           result.setElement( row, col, getElement(row,col) - arg.getElement(row,col) )
         end
       end
@@ -569,16 +412,15 @@ module RMath3D
     def *( arg )
       case arg
       when Fixnum, Float, Bignum
-        return RMtx3.new( arg*self.e00, arg*self.e01, arg*self.e02,
-                          arg*self.e10, arg*self.e11, arg*self.e12,
-                          arg*self.e20, arg*self.e21, arg*self.e22 )
+        return RMtx2.new( arg*self.e00, arg*self.e01,
+                          arg*self.e10, arg*self.e11 )
 
-      when RMtx3
-        result = RMtx3.new
-        for row in 0...3 do
-          for col in 0...3 do
+      when RMtx2
+        result = RMtx2.new
+        for row in 0...2 do
+          for col in 0...2 do
             sum = 0.0
-            for i in 0...3 do
+            for i in 0...2 do
               sum += getElement( row, i ) * arg.getElement( i, col )
             end
             result.setElement( row, col, sum )
@@ -587,7 +429,7 @@ module RMath3D
         return result
 
       else
-        raise TypeError, "RMtx3#*(arg) : Unknown type #{arg.class} given."
+        raise TypeError, "RMtx2#*(arg) : Unknown type #{arg.class} given."
         return nil
       end
     end
@@ -598,13 +440,13 @@ module RMath3D
     # mtx1 == mtx2 : evaluates equality.
     #
     def ==( other )
-      if ( other.class != RMtx3 )
-        raise TypeError, "RMtx3#==(other) : Unknown type #{other.class} given as RMtx3."
+      if ( other.class != RMtx2 )
+        raise TypeError, "RMtx2#==(other) : Unknown type #{other.class} given as RMtx2."
         return nil
       end
 
-      for row in 0...3 do
-        for col in 0...3 do
+      for row in 0...2 do
+        for col in 0...2 do
           if ( (getElement(row,col) - other.getElement(row,col)).abs > TOLERANCE )
             return false
           end
@@ -619,14 +461,14 @@ module RMath3D
     # mtx1 += mtx2 : appends the elements of +mtx2+ into corresponding +mtx1+ elements.
     #
     def add!( other )
-      if ( other.class != RMtx3 )
-        raise TypeError, "RMtx3#add! : Unknown type #{other.class} given as RMtx3."
+      if ( other.class != RMtx2 )
+        raise TypeError, "RMtx2#add! : Unknown type #{other.class} given as RMtx2."
         return nil
       end
 
-      result = RMtx3.new
-      for row in 0...3 do
-        for col in 0...3 do
+      result = RMtx2.new
+      for row in 0...2 do
+        for col in 0...2 do
           self.setElement( row, col, getElement(row,col) + other.getElement(row,col) )
         end
       end
@@ -640,14 +482,14 @@ module RMath3D
     # mtx1 -= mtx2 : subtracts the elements of +mtx2+ from corresponding +mtx1+ elements.
     #
     def sub!( other )
-      if ( other.class != RMtx3 )
-        raise TypeError, "RMtx3#sub! : Unknown type #{other.class} given as RMtx3."
+      if ( other.class != RMtx2 )
+        raise TypeError, "RMtx2#sub! : Unknown type #{other.class} given as RMtx2."
         return nil
       end
 
-      result = RMtx3.new
-      for row in 0...3 do
-        for col in 0...3 do
+      result = RMtx2.new
+      for row in 0...2 do
+        for col in 0...2 do
           self.setElement( row, col, getElement(row,col) - other.getElement(row,col) )
         end
       end
@@ -665,21 +507,16 @@ module RMath3D
       when Fixnum, Float, Bignum
         self.e00 = other*self.e00
         self.e01 = other*self.e01
-        self.e02 = other*self.e02
         self.e10 = other*self.e10
         self.e11 = other*self.e11
-        self.e12 = other*self.e12
-        self.e20 = other*self.e20
-        self.e21 = other*self.e21
-        self.e22 = other*self.e22
 
         return self
-      when RMtx3
-        result = RMtx3.new
-        for row in 0...3 do
-          for col in 0...3 do
+      when RMtx2
+        result = RMtx2.new
+        for row in 0...2 do
+          for col in 0...2 do
             sum = 0.0
-            for i in 0...3 do
+            for i in 0...2 do
               sum += getElement( row, i ) * other.getElement( i, col )
             end
             result.setElement( row, col, sum )
@@ -688,13 +525,8 @@ module RMath3D
 
         self.e00 = result.e00
         self.e01 = result.e01
-        self.e02 = result.e02
         self.e10 = result.e10
         self.e11 = result.e11
-        self.e12 = result.e12
-        self.e20 = result.e20
-        self.e21 = result.e21
-        self.e22 = result.e22
 
         return self
       end
@@ -702,65 +534,62 @@ module RMath3D
   end
 
   #
-  # Document-class: RMath3D::RMtx4
-  # provies 4x4 matrix arithmetic.
+  # Document-class: RMath3D::RMtx3
+  # provies 3x3 matrix arithmetic.
   #
   # <b>Notice</b>
   # * elements are stored in column-major order.
   #
-  class RMtx4
+  class RMtx3
 
     #
     # call-seq:
-    #   RMtx4.new -> ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1))
-    #   RMtx4.new(e) -> ((e,e,e,e),(e,e,e,e),(e,e,e,e),(e,e,e,e))
-    #   RMtx4.new( other ) : Copy Constructor
-    #   RMtx4.new( e0, e1, ..., e15 ) -> ((e0,e1,e2,e3),(e4,e5,e6,e7),(e8,e9,e10,e11),(e12,e13,e14,e15))
+    #   RMtx3.new -> ((1,0,0),(0,1,0),(0,0,1))
+    #   RMtx3.new(e) -> ((e,e,e), (e,e,e), (e,e,e))
+    #   RMtx3.new( other ) : Copy Constructor
+    #   RMtx3.new( e0, e1, ..., e8 ) -> ((e0,e1,e2), (e3,e4,e5), (e6,e7,e8))
     #
-    # Creates a new 4x4 matrix.
+    # Creates a new 3x3 matrix.
     #
     def initialize( *a )
       # [NOTE] elemetns are stored in column-major order.
       @e = []
       case a.length
       when 0
-        @e = [ 0.0, 0.0, 0.0, 0.0,
-               0.0, 0.0, 0.0, 0.0,
-               0.0, 0.0, 0.0, 0.0,
-               0.0, 0.0, 0.0, 0.0 ]
+        @e = [ 0.0, 0.0, 0.0,
+               0.0, 0.0, 0.0,
+               0.0, 0.0, 0.0 ]
       when 1
         case a[0]
         when Fixnum, Float
-          @e = [ a[0], a[0], a[0], a[0],
-                 a[0], a[0], a[0], a[0],
-                 a[0], a[0], a[0], a[0],
-                 a[0], a[0], a[0], a[0] ]
-        when RMtx4
+          @e = [ a[0], a[0], a[0],
+                 a[0], a[0], a[0],
+                 a[0], a[0], a[0] ]
+        when RMtx3
           # Copy Constructor
-          @e = [ a[0].e00, a[0].e10, a[0].e20, a[0].e30,
-                 a[0].e01, a[0].e11, a[0].e21, a[0].e31,
-                 a[0].e02, a[0].e12, a[0].e22, a[0].e32,
-                 a[0].e03, a[0].e13, a[0].e23, a[0].e33 ]
+          @e = [ a[0].e00, a[0].e10, a[0].e20,
+                 a[0].e01, a[0].e11, a[0].e21,
+                 a[0].e02, a[0].e12, a[0].e22 ]
         else
-          raise TypeError, "RMtx4#initialize : Unknown type #{a[0].class}."
+          raise TypeError, "RMtx3#initialize : Unknown type #{a[0].class}."
           return nil
         end
-      when 16
+      when 9
         # Element-wise setter
-        for row in 0...4 do
-          for col in 0...4 do
-            index = 4*row + col
+        for row in 0...3 do
+          for col in 0...3 do
+            index = 3*row + col
             case a[index]
             when Fixnum, Float
               setElement( row, col, a[index] )
             else
-              raise TypeError, "RMtx4#initialize : Unknown type #{a[0].class}."
+              raise TypeError, "RMtx3#initialize : Unknown type #{a[0].class}."
               return nil
             end
           end
         end
       else
-        raise RuntimeError, "RMtx4#initialize : wrong # of arguments (#{a.length})"
+        raise RuntimeError, "RMtx3#initialize : wrong # of arguments (#{a.length})"
         return nil
       end
 
@@ -773,10 +602,9 @@ module RMath3D
     # Returns human-readable string.
     #
     def to_s
-      "( #{@e[0]}, #{@e[4]}, #{@e[8]}, #{@e[12]} )\n"  +
-      "( #{@e[1]}, #{@e[5]}, #{@e[9]}, #{@e[13]} )\n"  +
-      "( #{@e[2]}, #{@e[6]}, #{@e[10]}, #{@e[14]} )\n" +
-      "( #{@e[3]}, #{@e[7]}, #{@e[11]}, #{@e[15]} )\n"
+      "( #{@e[0]}, #{@e[3]}, #{@e[6]} )\n" +
+      "( #{@e[1]}, #{@e[4]}, #{@e[7]} )\n" +
+      "( #{@e[2]}, #{@e[5]}, #{@e[8]} )\n"
     end
 
     #
@@ -798,25 +626,25 @@ module RMath3D
       when Fixnum, Float, Bignum
         return [ self, arg ]
       else
-        raise TypeError, "RMtx4#coerce : #{arg.self} can't be coerced into  #{self.class}."
+        raise TypeError, "RMtx3#coerce : #{arg.self} can't be coerced into  #{self.class}."
         return nil
       end
     end
 
     #
-    # call-seq: setElements( e0, e1, ..., e15 )
+    # call-seq: setElements( e0, e1, ..., e8 )
     #
-    # Stores given 16 new values.
+    # Stores given 9 new values.
     #
     def setElements( *a )
-      if a.length != 16
-        raise RuntimeError, "RMtx4#setElements : wrong # of arguments (#{a.length})"
+      if a.length != 9
+        raise RuntimeError, "RMtx3#setElements : wrong # of arguments (#{a.length})"
         return nil
       end
 
-      for row in 0...4 do
-        for col in 0...4 do
-          index = 4*row + col
+      for row in 0...3 do
+        for col in 0...3 do
+          index = 3*row + col
           setElement( row, col, a[index] )
         end
       end
@@ -829,7 +657,7 @@ module RMath3D
     #
     def []=(row,col,value)
       # [NOTE] elemetns are stored in column-major order.
-      @e[col*4+row] = value
+      @e[col*3+row] = value
     end
     alias_method :setElement, :'[]='
 
@@ -840,7 +668,7 @@ module RMath3D
     #
     def [](row,col)
       # [NOTE] elemetns are stored in column-major order.
-      return @e[col*4+row]
+      return @e[col*3+row]
     end
     alias_method :getElement, :'[]'
 
@@ -850,32 +678,18 @@ module RMath3D
     def e01() getElement(0,1) end
     # Returns the element at row 0 and column 2.
     def e02() getElement(0,2) end
-    # Returns the element at row 0 and column 3.
-    def e03() getElement(0,3) end
     # Returns the element at row 1 and column 0.
     def e10() getElement(1,0) end
     # Returns the element at row 1 and column 1.
     def e11() getElement(1,1) end
     # Returns the element at row 1 and column 2.
     def e12() getElement(1,2) end
-    # Returns the element at row 1 and column 3.
-    def e13() getElement(1,3) end
     # Returns the element at row 2 and column 0.
     def e20() getElement(2,0) end
     # Returns the element at row 2 and column 1.
     def e21() getElement(2,1) end
     # Returns the element at row 2 and column 2.
     def e22() getElement(2,2) end
-    # Returns the element at row 2 and column 3.
-    def e23() getElement(2,3) end
-    # Returns the element at row 3 and column 0.
-    def e30() getElement(3,0) end
-    # Returns the element at row 3 and column 1.
-    def e31() getElement(3,1) end
-    # Returns the element at row 3 and column 2.
-    def e32() getElement(3,2) end
-    # Returns the element at row 3 and column 3.
-    def e33() getElement(3,3) end
 
     # Replaces the element at row 0 and column 0 by +value+.
     def e00=(value) setElement(0,0,value) end
@@ -883,53 +697,40 @@ module RMath3D
     def e01=(value) setElement(0,1,value) end
     # Replaces the element at row 0 and column 2 by +value+.
     def e02=(value) setElement(0,2,value) end
-    # Replaces the element at row 0 and column 3 by +value+.
-    def e03=(value) setElement(0,3,value) end
     # Replaces the element at row 1 and column 0 by +value+.
     def e10=(value) setElement(1,0,value) end
     # Replaces the element at row 1 and column 1 by +value+.
     def e11=(value) setElement(1,1,value) end
     # Replaces the element at row 1 and column 2 by +value+.
     def e12=(value) setElement(1,2,value) end
-    # Replaces the element at row 1 and column 3 by +value+.
-    def e13=(value) setElement(1,3,value) end
     # Replaces the element at row 2 and column 0 by +value+.
     def e20=(value) setElement(2,0,value) end
     # Replaces the element at row 2 and column 1 by +value+.
     def e21=(value) setElement(2,1,value) end
     # Replaces the element at row 2 and column 2 by +value+.
     def e22=(value) setElement(2,2,value) end
-    # Replaces the element at row 2 and column 3 by +value+.
-    def e23=(value) setElement(2,3,value) end
-    # Replaces the element at row 3 and column 0 by +value+.
-    def e30=(value) setElement(3,0,value) end
-    # Replaces the element at row 3 and column 1 by +value+.
-    def e31=(value) setElement(3,1,value) end
-    # Replaces the element at row 3 and column 2 by +value+.
-    def e32=(value) setElement(3,2,value) end
-    # Replaces the element at row 3 and column 3 by +value+.
-    def e33=(value) setElement(3,3,value) end
+
 
     #
-    # call-seq: mtx4.getRow(r) -> RVec4
+    # call-seq: mtx3.getRow(r) -> RVec3
     #
     # Returns +r+-th row vector.
     #
     def getRow( row )
-      return RVec4.new( self[row,0], self[row,1], self[row,2], self[row,3] )
+      return RVec3.new( self[row,0], self[row,1], self[row,2] )
     end
 
     #
-    # call-seq: mtx4.getColumn(c) -> RVec4
+    # call-seq: mtx3.getColumn(c) -> RVec3
     #
     # Returns +c+-th column vector.
     #
     def getColumn( column )
-      return RVec4.new( self[0,column], self[1,column], self[2,column], self[3,column] )
+      return RVec3.new( self[0,column], self[1,column], self[2,column] )
     end
 
     #
-    # call-seq: mtx4.setRow(v,r)
+    # call-seq: mtx3.setRow(v,r)
     #
     # Returns sets +r+-th row by vector +v+.
     #
@@ -937,11 +738,10 @@ module RMath3D
       self[row,0] = v.x
       self[row,1] = v.y
       self[row,2] = v.z
-      self[row,3] = v.w
     end
 
     #
-    # call-seq: mtx4.setColumn(v,c)
+    # call-seq: mtx3.setColumn(v,c)
     #
     # Returns sets +c+-th column by vector +v+.
     #
@@ -949,35 +749,15 @@ module RMath3D
       self[0,column] = v.x
       self[1,column] = v.y
       self[2,column] = v.z
-      self[3,column] = v.w
-    end
-
-    def getUpper3x3
-      return RMtx3.new( self.e00, self.e01, self.e02,
-                        self.e10, self.e11, self.e12,
-                        self.e20, self.e21, self.e22 )
-    end
-
-    def setUpper3x3( mtx3x3 )
-      self.e00 = mtx3x3.e00
-      self.e01 = mtx3x3.e01
-      self.e02 = mtx3x3.e02
-      self.e10 = mtx3x3.e10
-      self.e11 = mtx3x3.e11
-      self.e12 = mtx3x3.e12
-      self.e20 = mtx3x3.e20
-      self.e21 = mtx3x3.e21
-      self.e22 = mtx3x3.e22
-
-      return self
     end
 
+    #
     # call-seq: setZero
     #
     # Clears all elements by 0.0
     #
     def setZero
-      16.times do |i|
+      9.times do |i|
         @e[i] = 0.0
       end
       return self
@@ -989,9 +769,9 @@ module RMath3D
     # Sets as identity matrix.
     #
     def setIdentity
-      for row in 0...4 do
-        for col in 0...4 do
-          index = 4*row + col
+      for row in 0...3 do
+        for col in 0...3 do
+          index = 3*row + col
           if ( row == col )
             setElement( row, col, 1.0 )
           else
@@ -1002,23 +782,15 @@ module RMath3D
       return self
     end
 
-    def det3( _e00,_e01,_e02, _e10,_e11,_e12, _e20,_e21,_e22 )
-      _e00 * (_e11*_e22 - _e12*_e21) -
-      _e01 * (_e10*_e22 - _e12*_e20) +
-      _e02 * (_e10*_e21 - _e11*_e20)
-    end
-    private :det3
-
     #
     # call-seq: getDeterminant -> determinant
     #
     # Calculates determinant.
     #
     def getDeterminant
-      e00 * det3( e11,e12,e13, e21,e22,e23, e31,e32,e33 ) -
-      e01 * det3( e10,e12,e13, e20,e22,e23, e30,e32,e33 ) +
-      e02 * det3( e10,e11,e13, e20,e21,e23, e30,e31,e33 ) -
-      e03 * det3( e10,e11,e12, e20,e21,e22, e30,e31,e32 )
+      e00 * (e11*e22 - e12*e21) -
+      e01 * (e10*e22 - e12*e20) +
+      e02 * (e10*e21 - e11*e20)
     end
 
     #
@@ -1027,10 +799,9 @@ module RMath3D
     # Returns transposed matrix.
     #
     def getTransposed
-      return RMtx4.new( @e[ 0], @e[ 1], @e[ 2], @e[ 3],
-                        @e[ 4], @e[ 5], @e[ 6], @e[ 7],
-                        @e[ 8], @e[ 9], @e[10], @e[11],
-                        @e[12], @e[13], @e[14], @e[15] )
+      return RMtx3.new( @e[0], @e[1], @e[2],
+                        @e[3], @e[4], @e[5],
+                        @e[6], @e[7], @e[8] )
     end
 
     #
@@ -1039,12 +810,9 @@ module RMath3D
     # Transposeas its elements.
     #
     def transpose!
-      @e[ 1], @e[ 4] = @e[ 4], @e[ 1]
-      @e[ 2], @e[ 8] = @e[ 8], @e[ 2]
-      @e[ 3], @e[12] = @e[12], @e[ 3]
-      @e[ 6], @e[ 9] = @e[ 9], @e[ 6]
-      @e[ 7], @e[13] = @e[13], @e[ 7]
-      @e[11], @e[14] = @e[14], @e[11]
+      @e[1], @e[3] = @e[3], @e[1]
+      @e[2], @e[6] = @e[6], @e[2]
+      @e[5], @e[7] = @e[7], @e[5]
     end
 
     #
@@ -1053,32 +821,24 @@ module RMath3D
     # Returns the inverse.
     #
     def getInverse
-      result = RMtx4.new
-
-      result.e00 =  det3( e11,e12,e13, e21,e22,e23, e31,e32,e33 )
-      result.e01 = -det3( e01,e02,e03, e21,e22,e23, e31,e32,e33 )
-      result.e02 =  det3( e01,e02,e03, e11,e12,e13, e31,e32,e33 )
-      result.e03 = -det3( e01,e02,e03, e11,e12,e13, e21,e22,e23 )
+      result = RMtx3.new
 
-      result.e10 = -det3( e10,e12,e13, e20,e22,e23, e30,e32,e33 )
-      result.e11 =  det3( e00,e02,e03, e20,e22,e23, e30,e32,e33 )
-      result.e12 = -det3( e00,e02,e03, e10,e12,e13, e30,e32,e33 )
-      result.e13 =  det3( e00,e02,e03, e10,e12,e13, e20,e22,e23 )
+      result.e00 =  (self.e11*self.e22 - self.e12*self.e21)
+      result.e01 = -(self.e01*self.e22 - self.e02*self.e21)
+      result.e02 =  (self.e01*self.e12 - self.e02*self.e11)
 
-      result.e20 =  det3( e10,e11,e13, e20,e21,e23, e30,e31,e33 )
-      result.e21 = -det3( e00,e01,e03, e20,e21,e23, e30,e31,e33 )
-      result.e22 =  det3( e00,e01,e03, e10,e11,e13, e30,e31,e33 )
-      result.e23 = -det3( e00,e01,e03, e10,e11,e13, e20,e21,e23 )
+      result.e10 = -(self.e10*self.e22 - self.e12*self.e20)
+      result.e11 =  (self.e00*self.e22 - self.e02*self.e20)
+      result.e12 = -(self.e00*self.e12 - self.e02*self.e10)
 
-      result.e30 = -det3( e10,e11,e12, e20,e21,e22, e30,e31,e32 )
-      result.e31 =  det3( e00,e01,e02, e20,e21,e22, e30,e31,e32 )
-      result.e32 = -det3( e00,e01,e02, e10,e11,e12, e30,e31,e32 )
-      result.e33 =  det3( e00,e01,e02, e10,e11,e12, e20,e21,e22 )
+      result.e20 =  (self.e10*self.e21 - self.e11*self.e20)
+      result.e21 = -(self.e00*self.e21 - self.e01*self.e20)
+      result.e22 =  (self.e00*self.e11 - self.e01*self.e10)
 
-      det = e00 * result.e00 + e01 * result.e10 + e02 * result.e20 + e03 * result.e30
+      det = e00 * result.e00 + e01 * result.e10 + e02 * result.e20
 
       if ( det.abs < TOLERANCE )
-        raise RuntimeError, "RMtx4#getInverse : det.abs < TOLERANCE"
+        raise RuntimeError, "RMtx3#getInverse : det.abs < TOLERANCE"
         return nil
       end
 
@@ -1095,70 +855,38 @@ module RMath3D
     # Makes itself as the inverse of the original matrix.
     #
     def invert!
-      elements = Array.new( 16 )
+      elements = Array.new( 9 )
 
-      elements[4*0+0] =  det3( self.e11,self.e12,self.e13, self.e21,self.e22,self.e23, self.e31,self.e32,self.e33 )
-      elements[4*0+1] = -det3( self.e01,self.e02,self.e03, self.e21,self.e22,self.e23, self.e31,self.e32,self.e33 )
-      elements[4*0+2] =  det3( self.e01,self.e02,self.e03, self.e11,self.e12,self.e13, self.e31,self.e32,self.e33 )
-      elements[4*0+3] = -det3( self.e01,self.e02,self.e03, self.e11,self.e12,self.e13, self.e21,self.e22,self.e23 )
+      elements[3*0+0] =  (self.e11*self.e22 - self.e12*self.e21)
+      elements[3*0+1] = -(self.e01*self.e22 - self.e02*self.e21)
+      elements[3*0+2] =  (self.e01*self.e12 - self.e02*self.e11)
 
-      elements[4*1+0] = -det3( self.e10,self.e12,self.e13, self.e20,self.e22,self.e23, self.e30,self.e32,self.e33 )
-      elements[4*1+1] =  det3( self.e00,self.e02,self.e03, self.e20,self.e22,self.e23, self.e30,self.e32,self.e33 )
-      elements[4*1+2] = -det3( self.e00,self.e02,self.e03, self.e10,self.e12,self.e13, self.e30,self.e32,self.e33 )
-      elements[4*1+3] =  det3( self.e00,self.e02,self.e03, self.e10,self.e12,self.e13, self.e20,self.e22,self.e23 )
-
-      elements[4*2+0] =  det3( self.e10,self.e11,self.e13, self.e20,self.e21,self.e23, self.e30,self.e31,self.e33 )
-      elements[4*2+1] = -det3( self.e00,self.e01,self.e03, self.e20,self.e21,self.e23, self.e30,self.e31,self.e33 )
-      elements[4*2+2] =  det3( self.e00,self.e01,self.e03, self.e10,self.e11,self.e13, self.e30,self.e31,self.e33 )
-      elements[4*2+3] = -det3( self.e00,self.e01,self.e03, self.e10,self.e11,self.e13, self.e20,self.e21,self.e23 )
+      elements[3*1+0] = -(self.e10*self.e22 - self.e12*self.e20)
+      elements[3*1+1] =  (self.e00*self.e22 - self.e02*self.e20)
+      elements[3*1+2] = -(self.e00*self.e12 - self.e02*self.e10)
 
-      elements[4*3+0] = -det3( self.e10,self.e11,self.e12, self.e20,self.e21,self.e22, self.e30,self.e31,self.e32 )
-      elements[4*3+1] =  det3( self.e00,self.e01,self.e02, self.e20,self.e21,self.e22, self.e30,self.e31,self.e32 )
-      elements[4*3+2] = -det3( self.e00,self.e01,self.e02, self.e10,self.e11,self.e12, self.e30,self.e31,self.e32 )
-      elements[4*3+3] =  det3( self.e00,self.e01,self.e02, self.e10,self.e11,self.e12, self.e20,self.e21,self.e22 )
+      elements[3*2+0] =  (self.e10*self.e21 - self.e11*self.e20)
+      elements[3*2+1] = -(self.e00*self.e21 - self.e01*self.e20)
+      elements[3*2+2] =  (self.e00*self.e11 - self.e01*self.e10)
 
-      det = e00 * elements[4*0+0] + e01 * elements[4*1+0] + e02 * elements[4*2+0] + e03 * elements[4*3+0]
+      det = e00 * elements[3*0+0] + e01 * elements[3*1+0] + e02 * elements[3*2+0]
 
-      if ( det.abs< TOLERANCE )
-        raise RuntimeError, "RMtx4invert! : det.abs < TOLERANCE"
+      if ( det.abs < TOLERANCE )
+        raise RuntimeError, "RMtx3#invert! : det.abs < TOLERANCE"
         return nil
       end
 
       d = 1.0 / det
 
-      setElement( 0, 0, d * elements[4*0+0] )
-      setElement( 0, 1, d * elements[4*0+1] )
-      setElement( 0, 2, d * elements[4*0+2] )
-      setElement( 0, 3, d * elements[4*0+3] )
-
-      setElement( 1, 0, d * elements[4*1+0] )
-      setElement( 1, 1, d * elements[4*1+1] )
-      setElement( 1, 2, d * elements[4*1+2] )
-      setElement( 1, 3, d * elements[4*1+3] )
-
-      setElement( 2, 0, d * elements[4*2+0] )
-      setElement( 2, 1, d * elements[4*2+1] )
-      setElement( 2, 2, d * elements[4*2+2] )
-      setElement( 2, 3, d * elements[4*2+3] )
-
-      setElement( 3, 0, d * elements[4*3+0] )
-      setElement( 3, 1, d * elements[4*3+1] )
-      setElement( 3, 2, d * elements[4*3+2] )
-      setElement( 3, 3, d * elements[4*3+3] )
-
-      return self
-    end
-
-    #
-    # call-seq: translation(tx,ty,tz) -> self
-    #
-    # Makes itself as a translation matrix.
-    #
-    def translation( tx, ty, tz )
-      setIdentity()
-      self.e03 =  tx
-      self.e13 =  ty
-      self.e23 =  tz
+      setElement( 0, 0, d * elements[3*0+0] )
+      setElement( 0, 1, d * elements[3*0+1] )
+      setElement( 0, 2, d * elements[3*0+2] )
+      setElement( 1, 0, d * elements[3*1+0] )
+      setElement( 1, 1, d * elements[3*1+1] )
+      setElement( 1, 2, d * elements[3*1+2] )
+      setElement( 2, 0, d * elements[3*2+0] )
+      setElement( 2, 1, d * elements[3*2+1] )
+      setElement( 2, 2, d * elements[3*2+2] )
 
       return self
     end
@@ -1224,7 +952,7 @@ module RMath3D
     #
     def rotationAxis( axis, radian )
       if ( axis.class != RVec3 )
-        raise TypeError, "RMtx4#rotationAxis : Unknown type #{axis.class} given as axis."
+        raise TypeError, "RMtx3#rotationAxis : Unknown type #{axis.class} given as axis."
         return nil
       end
       s   = Math.sin( radian )
@@ -1234,8 +962,6 @@ module RMath3D
       y   = axis.y.to_f
       z   = axis.z.to_f
 
-      setIdentity()
-
       self.e00 = x*x*omc + c
       self.e01 = x*y*omc - z*s
       self.e02 = z*x*omc + y*s
@@ -1256,7 +982,7 @@ module RMath3D
     #
     def rotationQuaternion( q )
       if ( q.class != RQuat )
-        raise TypeError, "RMtx4#rotationQuaternion : Unknown type #{q.class} given as RQuat."
+        raise TypeError, "RMtx3#rotationQuaternion : Unknown type #{q.class} given as RQuat."
         return nil
       end
       x  = q.x
@@ -1279,8 +1005,6 @@ module RMath3D
       xz2 = x * z2
       wy2 = w * y2
 
-      setIdentity()
-
       self.e00 = 1.0 - yy2 - zz2
       self.e10 = xy2 + wz2
       self.e20 = xz2 - wy2
@@ -1308,150 +1032,6 @@ module RMath3D
       return self
     end
 
-    #
-    # call-seq: lookAtRH(eye,at,up) -> self
-    #
-    # Builds a viewing matrix for a right-handed coordinate system from:
-    # * eye position (+eye+: RVec3)
-    # * a point looking at (+at+: RVec3)
-    # * up vector (+up+: RVec3)
-    #
-    def lookAtRH( eye, at, up )
-      setIdentity()
-
-      axis_z = (eye - at).normalize!
-      axis_x = RVec3.cross( up, axis_z ).normalize!
-      axis_y = RVec3.cross( axis_z, axis_x )
-
-      self.e00 = axis_x[0]
-      self.e01 = axis_x[1]
-      self.e02 = axis_x[2]
-      self.e03 = -RVec3.dot( axis_x, eye )
-
-      self.e10 = axis_y[0]
-      self.e11 = axis_y[1]
-      self.e12 = axis_y[2]
-      self.e13 = -RVec3.dot( axis_y, eye )
-
-      self.e20 = axis_z[0]
-      self.e21 = axis_z[1]
-      self.e22 = axis_z[2]
-      self.e23 = -RVec3.dot( axis_z, eye )
-
-      return self
-    end
-
-    #
-    # call-seq: perspectiveRH(width,height,znear,zfar) -> self
-    #
-    # Builds a perspective projection matrix for a right-handed coordinate system from:
-    # * View volume width (+width+)
-    # * View volume height (+height+)
-    # * Near clip plane distance (+znear+)
-    # * Far clip plane distance (+zfar+)
-    #
-    def perspectiveRH( width, height, znear, zfar )
-      perspectiveOffCenterRH(-width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar )
-      return self
-    end
-
-    #
-    # call-seq: perspectiveFovRH(fovy,aspect,znear,zfar) -> self
-    #
-    # Builds a perspective projection matrix for a right-handed coordinate system from:
-    # * Field of view in y direction (+fovy+ radian)
-    # * Aspect ratio (+aspect+)
-    # * Near clip plane distance (+znear+)
-    # * Far clip plane distance (+zfar+)
-    #
-    def perspectiveFovRH( fovy_radian, aspect, znear, zfar )
-      f = Math::tan( fovy_radian / 2.0 )
-      f = 1.0 / f
-
-      setIdentity()
-      setElement( 0, 0, f / aspect )
-      setElement( 1, 1, f )
-      setElement( 2, 2, (zfar+znear)/(znear-zfar) )
-      setElement( 2, 3, 2*zfar*znear/(znear-zfar) )
-      setElement( 3, 2, -1.0 )
-      setElement( 3, 3, 0.0 )
-
-      return self
-    end
-
-    #
-    # call-seq: perspectiveOffCenterRH(left,right,bottom,top,znear,zfar) -> self
-    #
-    # Builds a perspective projection matrix for a right-handed coordinate system from:
-    # * Minimum value of the view volume width (+left+)
-    # * Maximum value of the view volume width (+right+)
-    # * Minimum value of the view volume height (+bottom+)
-    # * Maximum value of the view volume height (+top+)
-    # * Near clip plane distance (+znear+)
-    # * Far clip plane distance (+zfar+)
-    #
-    def perspectiveOffCenterRH( left, right, bottom, top, znear, zfar )
-      a = (right+left) / (right-left)
-      b = (top+bottom) / (top-bottom)
-      c = -(zfar+znear) / (zfar-znear)
-      d = -(2*znear*zfar) / (zfar-znear)
-
-      setIdentity()
-
-      setElement( 0, 0, 2*znear/(right-left) )
-      setElement( 0, 2, a )
-      setElement( 1, 1, 2*znear/(top-bottom) )
-      setElement( 1, 2, b )
-      setElement( 2, 2, c )
-      setElement( 2, 3, d )
-      setElement( 3, 2, -1.0 )
-      setElement( 3, 3,  0.0 )
-
-      return self
-    end
-
-    #
-    # call-seq: orthoRH(width,height,znear,zfar) -> self
-    #
-    # Builds a orthogonal projection matrix for a right-handed coordinate system from:
-    # * View volume width (+width+)
-    # * View volume height (+height+)
-    # * Near clip plane distance (+znear+)
-    # * Far clip plane distance (+zfar+)
-    #
-    def orthoRH( width, height, znear, zfar )
-      orthoOffCenterRH( -width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar )
-      return self
-    end
-
-    #
-    # call-seq: orthoOffCenterRH(left,right,bottom,top,znear,zfar) -> self
-    #
-    # Builds a orthogonal projection matrix for a right-handed coordinate system from:
-    # * Minimum value of the view volume width (+left+)
-    # * Maximum value of the view volume width (+right+)
-    # * Minimum value of the view volume height (+bottom+)
-    # * Maximum value of the view volume height (+top+)
-    # * Near clip plane distance (+znear+)
-    # * Far clip plane distance (+zfar+)
-    #
-    def orthoOffCenterRH( left, right, bottom, top, znear, zfar )
-      tx = (right+left) / (right-left)
-      ty = (top+bottom) / (top-bottom)
-      tz = (zfar+znear) / (zfar-znear)
-
-      setIdentity()
-
-      setElement( 0, 0, 2.0/(right-left) )
-      setElement( 0, 3, tx )
-      setElement( 1, 1, 2.0/(top-bottom) )
-      setElement( 1, 3, ty )
-      setElement( 2, 2, -2.0/(zfar-znear) )
-      setElement( 2, 3, tz )
-
-      return self
-    end
-
     #
     # call-seq: +
     #
@@ -1467,7 +1047,7 @@ module RMath3D
     # -mtx : Unary minus operator.
     #
     def -@
-      return RMtx4.new( self * -1.0 )
+      return RMtx3.new( self * -1.0 )
     end
 
     #
@@ -1476,14 +1056,14 @@ module RMath3D
     # mtx1 + mtx2 : Binary plus operator.
     #
     def +( arg )
-      if ( arg.class != RMtx4 )
-        raise TypeError, "RMtx4#+(arg) : Unknown type #{arg.class} given as RMtx4."
+      if ( arg.class != RMtx3 )
+        raise TypeError, "RMtx3#+(arg) : Unknown type #{arg.class} given as RMtx3."
         return nil
       end
 
-      result = RMtx4.new
-      for row in 0...4 do
-        for col in 0...4 do
+      result = RMtx3.new
+      for row in 0...3 do
+        for col in 0...3 do
           result.setElement( row, col, getElement(row,col) + arg.getElement(row,col) )
         end
       end
@@ -1497,14 +1077,14 @@ module RMath3D
     # mtx1 - mtx2 : Binary minus operator.
     #
     def -( arg )
-      if ( arg.class != RMtx4 )
-        raise TypeError, "RMtx4#-(arg) : Unknown type #{arg.class} given as RMtx4."
+      if ( arg.class != RMtx3 )
+        raise TypeError, "RMtx3#-(arg) : Unknown type #{arg.class} given as RMtx3."
         return nil
       end
 
-      result = RMtx4.new
-      for row in 0...4 do
-        for col in 0...4 do
+      result = RMtx3.new
+      for row in 0...3 do
+        for col in 0...3 do
           result.setElement( row, col, getElement(row,col) - arg.getElement(row,col) )
         end
       end
@@ -1520,17 +1100,16 @@ module RMath3D
     def *( arg )
       case arg
       when Fixnum, Float, Bignum
-        return RMtx4.new( arg*self.e00, arg*self.e01, arg*self.e02, arg*self.e03,
-                          arg*self.e10, arg*self.e11, arg*self.e12, arg*self.e13,
-                          arg*self.e20, arg*self.e21, arg*self.e22, arg*self.e23,
-                          arg*self.e30, arg*self.e31, arg*self.e32, arg*self.e33 )
+        return RMtx3.new( arg*self.e00, arg*self.e01, arg*self.e02,
+                          arg*self.e10, arg*self.e11, arg*self.e12,
+                          arg*self.e20, arg*self.e21, arg*self.e22 )
 
-      when RMtx4
-        result = RMtx4.new
-        for row in 0...4 do
-          for col in 0...4 do
+      when RMtx3
+        result = RMtx3.new
+        for row in 0...3 do
+          for col in 0...3 do
             sum = 0.0
-            for i in 0...4 do
+            for i in 0...3 do
               sum += getElement( row, i ) * arg.getElement( i, col )
             end
             result.setElement( row, col, sum )
@@ -1539,7 +1118,7 @@ module RMath3D
         return result
 
       else
-        raise TypeError, "RMtx4#*(arg) : Unknown type #{arg.class} given."
+        raise TypeError, "RMtx3#*(arg) : Unknown type #{arg.class} given."
         return nil
       end
     end
@@ -1550,13 +1129,13 @@ module RMath3D
     # mtx1 == mtx2 : evaluates equality.
     #
     def ==( other )
-      if ( other.class != RMtx4 )
-        raise TypeError, "RMtx4#==(other) : Unknown type #{other.class} given as RMtx4."
+      if ( other.class != RMtx3 )
+        raise TypeError, "RMtx3#==(other) : Unknown type #{other.class} given as RMtx3."
         return nil
       end
 
-      for row in 0...4 do
-        for col in 0...4 do
+      for row in 0...3 do
+        for col in 0...3 do
           if ( (getElement(row,col) - other.getElement(row,col)).abs > TOLERANCE )
             return false
           end
@@ -1571,14 +1150,14 @@ module RMath3D
     # mtx1 += mtx2 : appends the elements of +mtx2+ into corresponding +mtx1+ elements.
     #
     def add!( other )
-      if ( other.class != RMtx4 )
-        raise TypeError, "RMtx4#add! : Unknown type #{other.class} given as RMtx4."
+      if ( other.class != RMtx3 )
+        raise TypeError, "RMtx3#add! : Unknown type #{other.class} given as RMtx3."
         return nil
       end
 
-      result = RMtx4.new
-      for row in 0...4 do
-        for col in 0...4 do
+      result = RMtx3.new
+      for row in 0...3 do
+        for col in 0...3 do
           self.setElement( row, col, getElement(row,col) + other.getElement(row,col) )
         end
       end
@@ -1592,14 +1171,14 @@ module RMath3D
     # mtx1 -= mtx2 : subtracts the elements of +mtx2+ from corresponding +mtx1+ elements.
     #
     def sub!( other )
-      if ( other.class != RMtx4 )
-        raise TypeError, "RMtx4#sub! : Unknown type #{other.class} given as RMtx4."
+      if ( other.class != RMtx3 )
+        raise TypeError, "RMtx3#sub! : Unknown type #{other.class} given as RMtx3."
         return nil
       end
 
-      result = RMtx4.new
-      for row in 0...4 do
-        for col in 0...4 do
+      result = RMtx3.new
+      for row in 0...3 do
+        for col in 0...3 do
           self.setElement( row, col, getElement(row,col) - other.getElement(row,col) )
         end
       end
@@ -1618,31 +1197,20 @@ module RMath3D
         self.e00 = other*self.e00
         self.e01 = other*self.e01
         self.e02 = other*self.e02
-        self.e03 = other*self.e03
-
         self.e10 = other*self.e10
         self.e11 = other*self.e11
         self.e12 = other*self.e12
-        self.e13 = other*self.e13
-
         self.e20 = other*self.e20
         self.e21 = other*self.e21
         self.e22 = other*self.e22
-        self.e23 = other*self.e23
-
-        self.e30 = other*self.e30
-        self.e31 = other*self.e31
-        self.e32 = other*self.e32
-        self.e33 = other*self.e33
 
         return self
-
-      when RMtx4
-        result = RMtx4.new
-        for row in 0...4 do
-          for col in 0...4 do
+      when RMtx3
+        result = RMtx3.new
+        for row in 0...3 do
+          for col in 0...3 do
             sum = 0.0
-            for i in 0...4 do
+            for i in 0...3 do
               sum += getElement( row, i ) * other.getElement( i, col )
             end
             result.setElement( row, col, sum )
@@ -1652,22 +1220,12 @@ module RMath3D
         self.e00 = result.e00
         self.e01 = result.e01
         self.e02 = result.e02
-        self.e03 = result.e03
-
         self.e10 = result.e10
         self.e11 = result.e11
         self.e12 = result.e12
-        self.e13 = result.e13
-
         self.e20 = result.e20
         self.e21 = result.e21
         self.e22 = result.e22
-        self.e23 = result.e23
-
-        self.e30 = result.e30
-        self.e31 = result.e31
-        self.e32 = result.e32
-        self.e33 = result.e33
 
         return self
       end
@@ -1675,49 +1233,68 @@ module RMath3D
   end
 
   #
-  # Document-class: RMath3D::RQuat
-  # provies quaternion arithmetic.
+  # Document-class: RMath3D::RMtx4
+  # provies 4x4 matrix arithmetic.
   #
-  class RQuat
+  # <b>Notice</b>
+  # * elements are stored in column-major order.
+  #
+  class RMtx4
 
     #
     # call-seq:
-    #   RQuat.new -> (0,0,0,0)
-    #   RQuat.new(e) -> (e,e,e,e)
-    #   RQuat.new( other ) : Copy Constructor
-    #   RQuat.new( e0, e1, e2, e3 ) -> (e0,e1,e2,e3)
+    #   RMtx4.new -> ((1,0,0,0),(0,1,0,0),(0,0,1,0),(0,0,0,1))
+    #   RMtx4.new(e) -> ((e,e,e,e),(e,e,e,e),(e,e,e,e),(e,e,e,e))
+    #   RMtx4.new( other ) : Copy Constructor
+    #   RMtx4.new( e0, e1, ..., e15 ) -> ((e0,e1,e2,e3),(e4,e5,e6,e7),(e8,e9,e10,e11),(e12,e13,e14,e15))
     #
-    # Creates a new quaternion.
+    # Creates a new 4x4 matrix.
     #
     def initialize( *a )
+      # [NOTE] elemetns are stored in column-major order.
       @e = []
       case a.length
       when 0
-        @e = [0.0, 0.0, 0.0, 0.0]
+        @e = [ 0.0, 0.0, 0.0, 0.0,
+               0.0, 0.0, 0.0, 0.0,
+               0.0, 0.0, 0.0, 0.0,
+               0.0, 0.0, 0.0, 0.0 ]
       when 1
         case a[0]
         when Fixnum, Float
-          @e = [ a[0], a[0], a[0], a[0] ]
-        when RQuat
-          @e = [ a[0].x, a[0].y, a[0].z, a[0].w ]
+          @e = [ a[0], a[0], a[0], a[0],
+                 a[0], a[0], a[0], a[0],
+                 a[0], a[0], a[0], a[0],
+                 a[0], a[0], a[0], a[0] ]
+        when RMtx4
+          # Copy Constructor
+          @e = [ a[0].e00, a[0].e10, a[0].e20, a[0].e30,
+                 a[0].e01, a[0].e11, a[0].e21, a[0].e31,
+                 a[0].e02, a[0].e12, a[0].e22, a[0].e32,
+                 a[0].e03, a[0].e13, a[0].e23, a[0].e33 ]
         else
-          raise TypeError, "RQuat#initialize : Unknown type #{a[0].class}."
+          raise TypeError, "RMtx4#initialize : Unknown type #{a[0].class}."
           return nil
         end
-      when 4
-        a.each_with_index do |elem, index|
-          case elem
-          when Fixnum, Float
-            @e[index] = elem
-          else
-            raise TypeError, "RQuat#initialize : Unknown type #{elem.class}."
-            return nil
+      when 16
+        # Element-wise setter
+        for row in 0...4 do
+          for col in 0...4 do
+            index = 4*row + col
+            case a[index]
+            when Fixnum, Float
+              setElement( row, col, a[index] )
+            else
+              raise TypeError, "RMtx4#initialize : Unknown type #{a[0].class}."
+              return nil
+            end
           end
         end
       else
-        raise RuntimeError, "RQuat#initialize : wrong # of arguments (#{a.length})"
+        raise RuntimeError, "RMtx4#initialize : wrong # of arguments (#{a.length})"
         return nil
       end
+
       return self
     end
 
@@ -1727,7 +1304,10 @@ module RMath3D
     # Returns human-readable string.
     #
     def to_s
-      return "( #{@e[0]}, #{@e[1]}, #{@e[2]}, #{@e[3]} )\n"
+      "( #{@e[0]}, #{@e[4]}, #{@e[8]}, #{@e[12]} )\n"  +
+      "( #{@e[1]}, #{@e[5]}, #{@e[9]}, #{@e[13]} )\n"  +
+      "( #{@e[2]}, #{@e[6]}, #{@e[10]}, #{@e[14]} )\n" +
+      "( #{@e[3]}, #{@e[7]}, #{@e[11]}, #{@e[15]} )\n"
     end
 
     #
@@ -1744,266 +1324,1683 @@ module RMath3D
     #
     # Resolves type mismatch.
     #
-    def coerce( arg )
+    def coerce
       case arg
       when Fixnum, Float, Bignum
         return [ self, arg ]
       else
-        raise TypeError, "RQuat#coerce : #{arg.self} can't be coerced into  #{self.class}."
+        raise TypeError, "RMtx4#coerce : #{arg.self} can't be coerced into  #{self.class}."
         return nil
       end
     end
 
     #
-    # call-seq: setElements( e0, e1, e2, e3 )
+    # call-seq: setElements( e0, e1, ..., e15 )
     #
-    # Stores given 4 new values.
+    # Stores given 16 new values.
     #
-    def setElements( x, y, z, w )
-      self.x = x
-      self.y = y
-      self.z = z
-      self.w = w
+    def setElements( *a )
+      if a.length != 16
+        raise RuntimeError, "RMtx4#setElements : wrong # of arguments (#{a.length})"
+        return nil
+      end
+
+      for row in 0...4 do
+        for col in 0...4 do
+          index = 4*row + col
+          setElement( row, col, a[index] )
+        end
+      end
     end
 
     #
-    # call-seq: quat[i]= value
+    # call-seq: [row,col]= value
     #
-    # Stores +value+ at +i+.
+    # Stores +value+ at (+row+,+col+).
     #
-    def []=(i,value)
-      @e[i] = value
+    def []=(row,col,value)
+      # [NOTE] elemetns are stored in column-major order.
+      @e[col*4+row] = value
     end
+    alias_method :setElement, :'[]='
 
     #
-    # call-seq: x= value
+    # call-seq: [row,col] -> value
     #
-    # Stores +value+ as +x+.
+    # Returns the element at (+row+,+col+).
     #
-    def x=(value) @e[0] = value end
+    def [](row,col)
+      # [NOTE] elemetns are stored in column-major order.
+      return @e[col*4+row]
+    end
+    alias_method :getElement, :'[]'
+
+    # Returns the element at row 0 and column 0.
+    def e00() getElement(0,0) end
+    # Returns the element at row 0 and column 1.
+    def e01() getElement(0,1) end
+    # Returns the element at row 0 and column 2.
+    def e02() getElement(0,2) end
+    # Returns the element at row 0 and column 3.
+    def e03() getElement(0,3) end
+    # Returns the element at row 1 and column 0.
+    def e10() getElement(1,0) end
+    # Returns the element at row 1 and column 1.
+    def e11() getElement(1,1) end
+    # Returns the element at row 1 and column 2.
+    def e12() getElement(1,2) end
+    # Returns the element at row 1 and column 3.
+    def e13() getElement(1,3) end
+    # Returns the element at row 2 and column 0.
+    def e20() getElement(2,0) end
+    # Returns the element at row 2 and column 1.
+    def e21() getElement(2,1) end
+    # Returns the element at row 2 and column 2.
+    def e22() getElement(2,2) end
+    # Returns the element at row 2 and column 3.
+    def e23() getElement(2,3) end
+    # Returns the element at row 3 and column 0.
+    def e30() getElement(3,0) end
+    # Returns the element at row 3 and column 1.
+    def e31() getElement(3,1) end
+    # Returns the element at row 3 and column 2.
+    def e32() getElement(3,2) end
+    # Returns the element at row 3 and column 3.
+    def e33() getElement(3,3) end
+
+    # Replaces the element at row 0 and column 0 by +value+.
+    def e00=(value) setElement(0,0,value) end
+    # Replaces the element at row 0 and column 1 by +value+.
+    def e01=(value) setElement(0,1,value) end
+    # Replaces the element at row 0 and column 2 by +value+.
+    def e02=(value) setElement(0,2,value) end
+    # Replaces the element at row 0 and column 3 by +value+.
+    def e03=(value) setElement(0,3,value) end
+    # Replaces the element at row 1 and column 0 by +value+.
+    def e10=(value) setElement(1,0,value) end
+    # Replaces the element at row 1 and column 1 by +value+.
+    def e11=(value) setElement(1,1,value) end
+    # Replaces the element at row 1 and column 2 by +value+.
+    def e12=(value) setElement(1,2,value) end
+    # Replaces the element at row 1 and column 3 by +value+.
+    def e13=(value) setElement(1,3,value) end
+    # Replaces the element at row 2 and column 0 by +value+.
+    def e20=(value) setElement(2,0,value) end
+    # Replaces the element at row 2 and column 1 by +value+.
+    def e21=(value) setElement(2,1,value) end
+    # Replaces the element at row 2 and column 2 by +value+.
+    def e22=(value) setElement(2,2,value) end
+    # Replaces the element at row 2 and column 3 by +value+.
+    def e23=(value) setElement(2,3,value) end
+    # Replaces the element at row 3 and column 0 by +value+.
+    def e30=(value) setElement(3,0,value) end
+    # Replaces the element at row 3 and column 1 by +value+.
+    def e31=(value) setElement(3,1,value) end
+    # Replaces the element at row 3 and column 2 by +value+.
+    def e32=(value) setElement(3,2,value) end
+    # Replaces the element at row 3 and column 3 by +value+.
+    def e33=(value) setElement(3,3,value) end
 
     #
-    # call-seq: y= value
+    # call-seq: mtx4.getRow(r) -> RVec4
     #
-    # Stores +value+ as +y+.
+    # Returns +r+-th row vector.
     #
-    def y=(value) @e[1] = value end
+    def getRow( row )
+      return RVec4.new( self[row,0], self[row,1], self[row,2], self[row,3] )
+    end
 
     #
-    # call-seq: z= value
+    # call-seq: mtx4.getColumn(c) -> RVec4
     #
-    # Stores +value+ as +z+.
+    # Returns +c+-th column vector.
     #
-    def z=(value) @e[2] = value end
+    def getColumn( column )
+      return RVec4.new( self[0,column], self[1,column], self[2,column], self[3,column] )
+    end
+
+    #
+    # call-seq: mtx4.setRow(v,r)
+    #
+    # Returns sets +r+-th row by vector +v+.
+    #
+    def setRow( v, row )
+      self[row,0] = v.x
+      self[row,1] = v.y
+      self[row,2] = v.z
+      self[row,3] = v.w
+    end
+
+    #
+    # call-seq: mtx4.setColumn(v,c)
+    #
+    # Returns sets +c+-th column by vector +v+.
+    #
+    def setColumn( v, column )
+      self[0,column] = v.x
+      self[1,column] = v.y
+      self[2,column] = v.z
+      self[3,column] = v.w
+    end
+
+    def getUpper3x3
+      return RMtx3.new( self.e00, self.e01, self.e02,
+                        self.e10, self.e11, self.e12,
+                        self.e20, self.e21, self.e22 )
+    end
+
+    def setUpper3x3( mtx3x3 )
+      self.e00 = mtx3x3.e00
+      self.e01 = mtx3x3.e01
+      self.e02 = mtx3x3.e02
+      self.e10 = mtx3x3.e10
+      self.e11 = mtx3x3.e11
+      self.e12 = mtx3x3.e12
+      self.e20 = mtx3x3.e20
+      self.e21 = mtx3x3.e21
+      self.e22 = mtx3x3.e22
+
+      return self
+    end
+
+    # call-seq: setZero
+    #
+    # Clears all elements by 0.0
+    #
+    def setZero
+      16.times do |i|
+        @e[i] = 0.0
+      end
+      return self
+    end
+
+    #
+    # call-seq: setIdentity
+    #
+    # Sets as identity matrix.
+    #
+    def setIdentity
+      for row in 0...4 do
+        for col in 0...4 do
+          index = 4*row + col
+          if ( row == col )
+            setElement( row, col, 1.0 )
+          else
+            setElement( row, col, 0.0 )
+          end
+        end
+      end
+      return self
+    end
+
+    def det3( _e00,_e01,_e02, _e10,_e11,_e12, _e20,_e21,_e22 )
+      _e00 * (_e11*_e22 - _e12*_e21) -
+      _e01 * (_e10*_e22 - _e12*_e20) +
+      _e02 * (_e10*_e21 - _e11*_e20)
+    end
+    private :det3
+
+    #
+    # call-seq: getDeterminant -> determinant
+    #
+    # Calculates determinant.
+    #
+    def getDeterminant
+      e00 * det3( e11,e12,e13, e21,e22,e23, e31,e32,e33 ) -
+      e01 * det3( e10,e12,e13, e20,e22,e23, e30,e32,e33 ) +
+      e02 * det3( e10,e11,e13, e20,e21,e23, e30,e31,e33 ) -
+      e03 * det3( e10,e11,e12, e20,e21,e22, e30,e31,e32 )
+    end
+
+    #
+    # call-seq: getTransposed
+    #
+    # Returns transposed matrix.
+    #
+    def getTransposed
+      return RMtx4.new( @e[ 0], @e[ 1], @e[ 2], @e[ 3],
+                        @e[ 4], @e[ 5], @e[ 6], @e[ 7],
+                        @e[ 8], @e[ 9], @e[10], @e[11],
+                        @e[12], @e[13], @e[14], @e[15] )
+    end
+
+    #
+    # call-seq: transpose!
+    #
+    # Transposeas its elements.
+    #
+    def transpose!
+      @e[ 1], @e[ 4] = @e[ 4], @e[ 1]
+      @e[ 2], @e[ 8] = @e[ 8], @e[ 2]
+      @e[ 3], @e[12] = @e[12], @e[ 3]
+      @e[ 6], @e[ 9] = @e[ 9], @e[ 6]
+      @e[ 7], @e[13] = @e[13], @e[ 7]
+      @e[11], @e[14] = @e[14], @e[11]
+    end
+
+    #
+    # call-seq: getInverse -> inverse
+    #
+    # Returns the inverse.
+    #
+    def getInverse
+      result = RMtx4.new
+
+      result.e00 =  det3( e11,e12,e13, e21,e22,e23, e31,e32,e33 )
+      result.e01 = -det3( e01,e02,e03, e21,e22,e23, e31,e32,e33 )
+      result.e02 =  det3( e01,e02,e03, e11,e12,e13, e31,e32,e33 )
+      result.e03 = -det3( e01,e02,e03, e11,e12,e13, e21,e22,e23 )
+
+      result.e10 = -det3( e10,e12,e13, e20,e22,e23, e30,e32,e33 )
+      result.e11 =  det3( e00,e02,e03, e20,e22,e23, e30,e32,e33 )
+      result.e12 = -det3( e00,e02,e03, e10,e12,e13, e30,e32,e33 )
+      result.e13 =  det3( e00,e02,e03, e10,e12,e13, e20,e22,e23 )
+
+      result.e20 =  det3( e10,e11,e13, e20,e21,e23, e30,e31,e33 )
+      result.e21 = -det3( e00,e01,e03, e20,e21,e23, e30,e31,e33 )
+      result.e22 =  det3( e00,e01,e03, e10,e11,e13, e30,e31,e33 )
+      result.e23 = -det3( e00,e01,e03, e10,e11,e13, e20,e21,e23 )
+
+      result.e30 = -det3( e10,e11,e12, e20,e21,e22, e30,e31,e32 )
+      result.e31 =  det3( e00,e01,e02, e20,e21,e22, e30,e31,e32 )
+      result.e32 = -det3( e00,e01,e02, e10,e11,e12, e30,e31,e32 )
+      result.e33 =  det3( e00,e01,e02, e10,e11,e12, e20,e21,e22 )
+
+      det = e00 * result.e00 + e01 * result.e10 + e02 * result.e20 + e03 * result.e30
+
+      if ( det.abs < TOLERANCE )
+        raise RuntimeError, "RMtx4#getInverse : det.abs < TOLERANCE"
+        return nil
+      end
+
+      d = 1.0 / det
+
+      result.mul!( d )
+
+      return result
+    end
+
+    #
+    # call-seq: invert! -> self
+    #
+    # Makes itself as the inverse of the original matrix.
+    #
+    def invert!
+      elements = Array.new( 16 )
+
+      elements[4*0+0] =  det3( self.e11,self.e12,self.e13, self.e21,self.e22,self.e23, self.e31,self.e32,self.e33 )
+      elements[4*0+1] = -det3( self.e01,self.e02,self.e03, self.e21,self.e22,self.e23, self.e31,self.e32,self.e33 )
+      elements[4*0+2] =  det3( self.e01,self.e02,self.e03, self.e11,self.e12,self.e13, self.e31,self.e32,self.e33 )
+      elements[4*0+3] = -det3( self.e01,self.e02,self.e03, self.e11,self.e12,self.e13, self.e21,self.e22,self.e23 )
+
+      elements[4*1+0] = -det3( self.e10,self.e12,self.e13, self.e20,self.e22,self.e23, self.e30,self.e32,self.e33 )
+      elements[4*1+1] =  det3( self.e00,self.e02,self.e03, self.e20,self.e22,self.e23, self.e30,self.e32,self.e33 )
+      elements[4*1+2] = -det3( self.e00,self.e02,self.e03, self.e10,self.e12,self.e13, self.e30,self.e32,self.e33 )
+      elements[4*1+3] =  det3( self.e00,self.e02,self.e03, self.e10,self.e12,self.e13, self.e20,self.e22,self.e23 )
+
+      elements[4*2+0] =  det3( self.e10,self.e11,self.e13, self.e20,self.e21,self.e23, self.e30,self.e31,self.e33 )
+      elements[4*2+1] = -det3( self.e00,self.e01,self.e03, self.e20,self.e21,self.e23, self.e30,self.e31,self.e33 )
+      elements[4*2+2] =  det3( self.e00,self.e01,self.e03, self.e10,self.e11,self.e13, self.e30,self.e31,self.e33 )
+      elements[4*2+3] = -det3( self.e00,self.e01,self.e03, self.e10,self.e11,self.e13, self.e20,self.e21,self.e23 )
+
+      elements[4*3+0] = -det3( self.e10,self.e11,self.e12, self.e20,self.e21,self.e22, self.e30,self.e31,self.e32 )
+      elements[4*3+1] =  det3( self.e00,self.e01,self.e02, self.e20,self.e21,self.e22, self.e30,self.e31,self.e32 )
+      elements[4*3+2] = -det3( self.e00,self.e01,self.e02, self.e10,self.e11,self.e12, self.e30,self.e31,self.e32 )
+      elements[4*3+3] =  det3( self.e00,self.e01,self.e02, self.e10,self.e11,self.e12, self.e20,self.e21,self.e22 )
+
+      det = e00 * elements[4*0+0] + e01 * elements[4*1+0] + e02 * elements[4*2+0] + e03 * elements[4*3+0]
+
+      if ( det.abs< TOLERANCE )
+        raise RuntimeError, "RMtx4invert! : det.abs < TOLERANCE"
+        return nil
+      end
+
+      d = 1.0 / det
+
+      setElement( 0, 0, d * elements[4*0+0] )
+      setElement( 0, 1, d * elements[4*0+1] )
+      setElement( 0, 2, d * elements[4*0+2] )
+      setElement( 0, 3, d * elements[4*0+3] )
+
+      setElement( 1, 0, d * elements[4*1+0] )
+      setElement( 1, 1, d * elements[4*1+1] )
+      setElement( 1, 2, d * elements[4*1+2] )
+      setElement( 1, 3, d * elements[4*1+3] )
+
+      setElement( 2, 0, d * elements[4*2+0] )
+      setElement( 2, 1, d * elements[4*2+1] )
+      setElement( 2, 2, d * elements[4*2+2] )
+      setElement( 2, 3, d * elements[4*2+3] )
+
+      setElement( 3, 0, d * elements[4*3+0] )
+      setElement( 3, 1, d * elements[4*3+1] )
+      setElement( 3, 2, d * elements[4*3+2] )
+      setElement( 3, 3, d * elements[4*3+3] )
+
+      return self
+    end
+
+    #
+    # call-seq: translation(tx,ty,tz) -> self
+    #
+    # Makes itself as a translation matrix.
+    #
+    def translation( tx, ty, tz )
+      setIdentity()
+      self.e03 =  tx
+      self.e13 =  ty
+      self.e23 =  tz
+
+      return self
+    end
+
+    #
+    # call-seq: rotationX(radian) -> self
+    #
+    # Makes a matrix that rotates around the x-axis.
+    #
+    def rotationX( radian )
+      s = Math.sin( radian )
+      c = Math.cos( radian )
+
+      setIdentity()
+      self.e11 =  c
+      self.e12 = -s
+      self.e21 =  s
+      self.e22 =  c
+
+      return self
+    end
+
+    #
+    # call-seq: rotationY(radian) -> self
+    #
+    # Makes a matrix that rotates around the y-axis.
+    #
+    def rotationY( radian )
+      s = Math.sin( radian )
+      c = Math.cos( radian )
+
+      setIdentity()
+      self.e00 =  c
+      self.e02 =  s
+      self.e20 = -s
+      self.e22 =  c
+
+      return self
+    end
+
+    #
+    # call-seq: rotationZ(radian) -> self
+    #
+    # Makes a matrix that rotates around the z-axis.
+    #
+    def rotationZ( radian )
+      s = Math.sin( radian )
+      c = Math.cos( radian )
+
+      setIdentity()
+      self.e00 =  c
+      self.e01 = -s
+      self.e10 =  s
+      self.e11 =  c
+
+      return self
+    end
+
+    #
+    # call-seq: rotationAxis(axis,radian) -> self
+    #
+    # Makes a matrix that rotates around the +axis+.
+    #
+    def rotationAxis( axis, radian )
+      if ( axis.class != RVec3 )
+        raise TypeError, "RMtx4#rotationAxis : Unknown type #{axis.class} given as axis."
+        return nil
+      end
+      s   = Math.sin( radian )
+      c   = Math.cos( radian )
+      omc = 1.0 - c
+      x   = axis.x.to_f
+      y   = axis.y.to_f
+      z   = axis.z.to_f
+
+      setIdentity()
+
+      self.e00 = x*x*omc + c
+      self.e01 = x*y*omc - z*s
+      self.e02 = z*x*omc + y*s
+      self.e10 = x*y*omc + z*s
+      self.e11 = y*y*omc + c
+      self.e12 = y*z*omc - x*s
+      self.e20 = z*x*omc - y*s
+      self.e21 = y*z*omc + x*s
+      self.e22 = z*z*omc + c
+
+      return self
+    end
+
+    #
+    # call-seq: rotationQuaternion(q) -> self
+    #
+    # Makes a rotation matrix from a normalized quaternion +q+.
+    #
+    def rotationQuaternion( q )
+      if ( q.class != RQuat )
+        raise TypeError, "RMtx4#rotationQuaternion : Unknown type #{q.class} given as RQuat."
+        return nil
+      end
+      x  = q.x
+      y  = q.y
+      z  = q.z
+      w  = q.w
+
+      x2 = 2.0 * x
+      y2 = 2.0 * y
+      z2 = 2.0 * z
+
+      xx2 = x * x2
+      yy2 = y * y2
+      zz2 = z * z2
+
+      yz2 = y * z2
+      wx2 = w * x2
+      xy2 = x * y2
+      wz2 = w * z2
+      xz2 = x * z2
+      wy2 = w * y2
+
+      setIdentity()
+
+      self.e00 = 1.0 - yy2 - zz2
+      self.e10 = xy2 + wz2
+      self.e20 = xz2 - wy2
+      self.e01 = xy2 - wz2
+      self.e11 = 1.0 - xx2 - zz2
+      self.e21 = yz2 + wx2
+      self.e02 = xz2 + wy2
+      self.e12 = yz2 - wx2
+      self.e22 = 1.0 - xx2 - yy2
+
+      return self
+    end
+
+    #
+    # call-seq: scaling(sx,sy,sz) -> self
+    #
+    # Makes itself as a scaling matrix.
+    #
+    def scaling( sx, sy, sz )
+      setIdentity()
+      setElement( 0, 0, sx )
+      setElement( 1, 1, sy )
+      setElement( 2, 2, sz )
+
+      return self
+    end
+
+    #
+    # call-seq: lookAtRH(eye,at,up) -> self
+    #
+    # Builds a viewing matrix for a right-handed coordinate system from:
+    # * eye position (+eye+: RVec3)
+    # * a point looking at (+at+: RVec3)
+    # * up vector (+up+: RVec3)
+    #
+    def lookAtRH( eye, at, up )
+      setIdentity()
+
+      axis_z = (eye - at).normalize!
+      axis_x = RVec3.cross( up, axis_z ).normalize!
+      axis_y = RVec3.cross( axis_z, axis_x )
+
+      self.e00 = axis_x[0]
+      self.e01 = axis_x[1]
+      self.e02 = axis_x[2]
+      self.e03 = -RVec3.dot( axis_x, eye )
+
+      self.e10 = axis_y[0]
+      self.e11 = axis_y[1]
+      self.e12 = axis_y[2]
+      self.e13 = -RVec3.dot( axis_y, eye )
+
+      self.e20 = axis_z[0]
+      self.e21 = axis_z[1]
+      self.e22 = axis_z[2]
+      self.e23 = -RVec3.dot( axis_z, eye )
+
+      return self
+    end
+
+    #
+    # call-seq: perspectiveRH(width,height,znear,zfar) -> self
+    #
+    # Builds a perspective projection matrix for a right-handed coordinate system from:
+    # * View volume width (+width+)
+    # * View volume height (+height+)
+    # * Near clip plane distance (+znear+)
+    # * Far clip plane distance (+zfar+)
+    #
+    def perspectiveRH( width, height, znear, zfar )
+      perspectiveOffCenterRH(-width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar )
+      return self
+    end
+
+    #
+    # call-seq: perspectiveFovRH(fovy,aspect,znear,zfar) -> self
+    #
+    # Builds a perspective projection matrix for a right-handed coordinate system from:
+    # * Field of view in y direction (+fovy+ radian)
+    # * Aspect ratio (+aspect+)
+    # * Near clip plane distance (+znear+)
+    # * Far clip plane distance (+zfar+)
+    #
+    def perspectiveFovRH( fovy_radian, aspect, znear, zfar )
+      f = Math::tan( fovy_radian / 2.0 )
+      f = 1.0 / f
+
+      setIdentity()
+      setElement( 0, 0, f / aspect )
+      setElement( 1, 1, f )
+      setElement( 2, 2, (zfar+znear)/(znear-zfar) )
+      setElement( 2, 3, 2*zfar*znear/(znear-zfar) )
+      setElement( 3, 2, -1.0 )
+      setElement( 3, 3, 0.0 )
+
+      return self
+    end
+
+    #
+    # call-seq: perspectiveOffCenterRH(left,right,bottom,top,znear,zfar) -> self
+    #
+    # Builds a perspective projection matrix for a right-handed coordinate system from:
+    # * Minimum value of the view volume width (+left+)
+    # * Maximum value of the view volume width (+right+)
+    # * Minimum value of the view volume height (+bottom+)
+    # * Maximum value of the view volume height (+top+)
+    # * Near clip plane distance (+znear+)
+    # * Far clip plane distance (+zfar+)
+    #
+    def perspectiveOffCenterRH( left, right, bottom, top, znear, zfar )
+      a = (right+left) / (right-left)
+      b = (top+bottom) / (top-bottom)
+      c = -(zfar+znear) / (zfar-znear)
+      d = -(2*znear*zfar) / (zfar-znear)
+
+      setIdentity()
+
+      setElement( 0, 0, 2*znear/(right-left) )
+      setElement( 0, 2, a )
+      setElement( 1, 1, 2*znear/(top-bottom) )
+      setElement( 1, 2, b )
+      setElement( 2, 2, c )
+      setElement( 2, 3, d )
+      setElement( 3, 2, -1.0 )
+      setElement( 3, 3,  0.0 )
+
+      return self
+    end
+
+    #
+    # call-seq: orthoRH(width,height,znear,zfar) -> self
+    #
+    # Builds a orthogonal projection matrix for a right-handed coordinate system from:
+    # * View volume width (+width+)
+    # * View volume height (+height+)
+    # * Near clip plane distance (+znear+)
+    # * Far clip plane distance (+zfar+)
+    #
+    def orthoRH( width, height, znear, zfar )
+      orthoOffCenterRH( -width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar )
+      return self
+    end
+
+    #
+    # call-seq: orthoOffCenterRH(left,right,bottom,top,znear,zfar) -> self
+    #
+    # Builds a orthogonal projection matrix for a right-handed coordinate system from:
+    # * Minimum value of the view volume width (+left+)
+    # * Maximum value of the view volume width (+right+)
+    # * Minimum value of the view volume height (+bottom+)
+    # * Maximum value of the view volume height (+top+)
+    # * Near clip plane distance (+znear+)
+    # * Far clip plane distance (+zfar+)
+    #
+    def orthoOffCenterRH( left, right, bottom, top, znear, zfar )
+      tx = (right+left) / (right-left)
+      ty = (top+bottom) / (top-bottom)
+      tz = (zfar+znear) / (zfar-znear)
+
+      setIdentity()
+
+      setElement( 0, 0, 2.0/(right-left) )
+      setElement( 0, 3, tx )
+      setElement( 1, 1, 2.0/(top-bottom) )
+      setElement( 1, 3, ty )
+      setElement( 2, 2, -2.0/(zfar-znear) )
+      setElement( 2, 3, tz )
+
+      return self
+    end
+
+    #
+    # call-seq: +
+    #
+    # +mtx : Unary plus operator.
+    #
+    def +@
+      return self
+    end
+
+    #
+    # call-seq: -
+    #
+    # -mtx : Unary minus operator.
+    #
+    def -@
+      return RMtx4.new( self * -1.0 )
+    end
+
+    #
+    # call-seq: +
+    #
+    # mtx1 + mtx2 : Binary plus operator.
+    #
+    def +( arg )
+      if ( arg.class != RMtx4 )
+        raise TypeError, "RMtx4#+(arg) : Unknown type #{arg.class} given as RMtx4."
+        return nil
+      end
+
+      result = RMtx4.new
+      for row in 0...4 do
+        for col in 0...4 do
+          result.setElement( row, col, getElement(row,col) + arg.getElement(row,col) )
+        end
+      end
+
+      return result
+    end
+
+    #
+    # call-seq: -
+    #
+    # mtx1 - mtx2 : Binary minus operator.
+    #
+    def -( arg )
+      if ( arg.class != RMtx4 )
+        raise TypeError, "RMtx4#-(arg) : Unknown type #{arg.class} given as RMtx4."
+        return nil
+      end
+
+      result = RMtx4.new
+      for row in 0...4 do
+        for col in 0...4 do
+          result.setElement( row, col, getElement(row,col) - arg.getElement(row,col) )
+        end
+      end
+
+      return result
+    end
+
+    #
+    # call-seq: *
+    #
+    # mtx1 * mtx2 : Binary multiply operator.
+    #
+    def *( arg )
+      case arg
+      when Fixnum, Float, Bignum
+        return RMtx4.new( arg*self.e00, arg*self.e01, arg*self.e02, arg*self.e03,
+                          arg*self.e10, arg*self.e11, arg*self.e12, arg*self.e13,
+                          arg*self.e20, arg*self.e21, arg*self.e22, arg*self.e23,
+                          arg*self.e30, arg*self.e31, arg*self.e32, arg*self.e33 )
+
+      when RMtx4
+        result = RMtx4.new
+        for row in 0...4 do
+          for col in 0...4 do
+            sum = 0.0
+            for i in 0...4 do
+              sum += getElement( row, i ) * arg.getElement( i, col )
+            end
+            result.setElement( row, col, sum )
+          end
+        end
+        return result
+
+      else
+        raise TypeError, "RMtx4#*(arg) : Unknown type #{arg.class} given."
+        return nil
+      end
+    end
+
+    #
+    # call-seq: ==
+    #
+    # mtx1 == mtx2 : evaluates equality.
+    #
+    def ==( other )
+      if ( other.class != RMtx4 )
+        raise TypeError, "RMtx4#==(other) : Unknown type #{other.class} given as RMtx4."
+        return nil
+      end
+
+      for row in 0...4 do
+        for col in 0...4 do
+          if ( (getElement(row,col) - other.getElement(row,col)).abs > TOLERANCE )
+            return false
+          end
+        end
+      end
+      return true
+    end
+
+    #
+    # call-seq: mtx1.add!( mtx2 )
+    #
+    # mtx1 += mtx2 : appends the elements of +mtx2+ into corresponding +mtx1+ elements.
+    #
+    def add!( other )
+      if ( other.class != RMtx4 )
+        raise TypeError, "RMtx4#add! : Unknown type #{other.class} given as RMtx4."
+        return nil
+      end
+
+      result = RMtx4.new
+      for row in 0...4 do
+        for col in 0...4 do
+          self.setElement( row, col, getElement(row,col) + other.getElement(row,col) )
+        end
+      end
+
+      return self
+    end
+
+    #
+    # call-seq: mtx1.sub!( mtx2 )
+    #
+    # mtx1 -= mtx2 : subtracts the elements of +mtx2+ from corresponding +mtx1+ elements.
+    #
+    def sub!( other )
+      if ( other.class != RMtx4 )
+        raise TypeError, "RMtx4#sub! : Unknown type #{other.class} given as RMtx4."
+        return nil
+      end
+
+      result = RMtx4.new
+      for row in 0...4 do
+        for col in 0...4 do
+          self.setElement( row, col, getElement(row,col) - other.getElement(row,col) )
+        end
+      end
+
+      return self
+    end
+
+    #
+    # call-seq: mtx1.mul!( mtx2 )
+    #
+    # mtx1 *= mtx2
+    #
+    def mul!( other )
+      case other
+      when Fixnum, Float, Bignum
+        self.e00 = other*self.e00
+        self.e01 = other*self.e01
+        self.e02 = other*self.e02
+        self.e03 = other*self.e03
+
+        self.e10 = other*self.e10
+        self.e11 = other*self.e11
+        self.e12 = other*self.e12
+        self.e13 = other*self.e13
+
+        self.e20 = other*self.e20
+        self.e21 = other*self.e21
+        self.e22 = other*self.e22
+        self.e23 = other*self.e23
+
+        self.e30 = other*self.e30
+        self.e31 = other*self.e31
+        self.e32 = other*self.e32
+        self.e33 = other*self.e33
+
+        return self
+
+      when RMtx4
+        result = RMtx4.new
+        for row in 0...4 do
+          for col in 0...4 do
+            sum = 0.0
+            for i in 0...4 do
+              sum += getElement( row, i ) * other.getElement( i, col )
+            end
+            result.setElement( row, col, sum )
+          end
+        end
+
+        self.e00 = result.e00
+        self.e01 = result.e01
+        self.e02 = result.e02
+        self.e03 = result.e03
+
+        self.e10 = result.e10
+        self.e11 = result.e11
+        self.e12 = result.e12
+        self.e13 = result.e13
+
+        self.e20 = result.e20
+        self.e21 = result.e21
+        self.e22 = result.e22
+        self.e23 = result.e23
+
+        self.e30 = result.e30
+        self.e31 = result.e31
+        self.e32 = result.e32
+        self.e33 = result.e33
+
+        return self
+      end
+    end
+  end
+
+  #
+  # Document-class: RMath3D::RQuat
+  # provies quaternion arithmetic.
+  #
+  class RQuat
+
+    #
+    # call-seq:
+    #   RQuat.new -> (0,0,0,0)
+    #   RQuat.new(e) -> (e,e,e,e)
+    #   RQuat.new( other ) : Copy Constructor
+    #   RQuat.new( e0, e1, e2, e3 ) -> (e0,e1,e2,e3)
+    #
+    # Creates a new quaternion.
+    #
+    def initialize( *a )
+      @e = []
+      case a.length
+      when 0
+        @e = [0.0, 0.0, 0.0, 0.0]
+      when 1
+        case a[0]
+        when Fixnum, Float
+          @e = [ a[0], a[0], a[0], a[0] ]
+        when RQuat
+          @e = [ a[0].x, a[0].y, a[0].z, a[0].w ]
+        else
+          raise TypeError, "RQuat#initialize : Unknown type #{a[0].class}."
+          return nil
+        end
+      when 4
+        a.each_with_index do |elem, index|
+          case elem
+          when Fixnum, Float
+            @e[index] = elem
+          else
+            raise TypeError, "RQuat#initialize : Unknown type #{elem.class}."
+            return nil
+          end
+        end
+      else
+        raise RuntimeError, "RQuat#initialize : wrong # of arguments (#{a.length})"
+        return nil
+      end
+      return self
+    end
+
+    #
+    # call-seq: to_s
+    #
+    # Returns human-readable string.
+    #
+    def to_s
+      return "( #{@e[0]}, #{@e[1]}, #{@e[2]}, #{@e[3]} )\n"
+    end
+
+    #
+    # call-seq: to_a
+    #
+    # Returns its elements as a new Array.
+    #
+    def to_a
+      return @e
+    end
+
+    #
+    # call-seq: coerse(other)
+    #
+    # Resolves type mismatch.
+    #
+    def coerce( arg )
+      case arg
+      when Fixnum, Float, Bignum
+        return [ self, arg ]
+      else
+        raise TypeError, "RQuat#coerce : #{arg.self} can't be coerced into  #{self.class}."
+        return nil
+      end
+    end
+
+    #
+    # call-seq: setElements( e0, e1, e2, e3 )
+    #
+    # Stores given 4 new values.
+    #
+    def setElements( x, y, z, w )
+      self.x = x
+      self.y = y
+      self.z = z
+      self.w = w
+    end
+
+    #
+    # call-seq: quat[i]= value
+    #
+    # Stores +value+ at +i+.
+    #
+    def []=(i,value)
+      @e[i] = value
+    end
+
+    #
+    # call-seq: x= value
+    #
+    # Stores +value+ as +x+.
+    #
+    def x=(value) @e[0] = value end
+
+    #
+    # call-seq: y= value
+    #
+    # Stores +value+ as +y+.
+    #
+    def y=(value) @e[1] = value end
+
+    #
+    # call-seq: z= value
+    #
+    # Stores +value+ as +z+.
+    #
+    def z=(value) @e[2] = value end
 
     #
     # call-seq: w= value
     #
-    # Stores +value+ as +w+.
+    # Stores +value+ as +w+.
+    #
+    def w=(value) @e[3] = value end
+
+    #
+    # call-seq: xyz= vXYZ
+    #
+    # Copies the values of +vXYZ+(RVec3) into +x+, +y+ and +z+.
+    #
+    def xyz=( arg )
+      if arg.class != RVec3
+        raise TypeError, "RQuat#xyz= : Unknown type #{arg.class}."
+        return nil
+      end
+      @e[0] = arg.x
+      @e[1] = arg.y
+      @e[2] = arg.z
+    end
+
+    #
+    # call-seq: quat[i] -> value
+    #
+    # Returns the element at +i+.
+    #
+    def [](i)
+      @e[i]
+    end
+
+
+    #
+    # call-seq: x -> value
+    #
+    # Returns the value of +x+.
+    #
+    def x() return @e[0] end
+
+    #
+    # call-seq: y -> value
+    #
+    # Returns the value of +y+.
+    #
+    def y() return @e[1] end
+
+    #
+    # call-seq: z -> value
+    #
+    # Returns the value of +z+.
+    #
+    def z() return @e[2] end
+
+    #
+    # call-seq: w -> value
+    #
+    # Returns the value of +w+.
+    #
+    def w() return @e[3] end
+
+    #
+    # call-seq: xyz -> RVec3
+    #
+    # Returns the values of +x+, +y+ and +z+ with new RVec3(+x+,+y+,+z+).
+    #
+    def xyz()
+      return RVec3.new( @e[0], @e[1], @e[2] )
+    end
+
+    #
+    # call-seq: getLength
+    #
+    # Returns the Euclidean length.
+    #
+    def getLength
+      return Math.sqrt( @e[0]*@e[0] + @e[1]*@e[1] + @e[2]*@e[2] + @e[3]*@e[3] )
+    end
+
+    #
+    # call-seq: getLengthSq
+    #
+    # Returns the squared Euclidean length.
+    #
+    def getLengthSq
+      return (@e[0]*@e[0] + @e[1]*@e[1] + @e[2]*@e[2] + @e[3]*@e[3]).to_f
+    end
+
+    #
+    # call-seq: RQuat.dot(q_a,q_b) -> value
+    #
+    # Calculates the dot product of +q_a+ and +q_b+.
+    #
+    def RQuat.dot( q1, q2 )
+      if q1.class != RQuat || q2.class != RQuat
+        raise TypeError, "RQuat#dot : Unknown type q1:#{q2.class}, q2:#{q2.class}."
+        return nil
+      end
+      return q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w
+    end
+
+    #
+    # call-seq: RQuat.slerp( q_a, q_b, t ) -> interpolated quaternion
+    #
+    # Calculates the spherical linear interpolation between +q_a+ and
+    # +q_b+ at time +t+ (0.0~1.0).
+    #
+    def RQuat.slerp( q1, q2, t )
+      if q1.class != RQuat || q2.class != RQuat
+        raise TypeError, "RQuat#slerp : Unknown type q1:#{q2.class}, q2:#{q2.class}."
+        return nil
+      end
+      s1 = 0.0
+      s2 = 0.0
+      it = 1.0 - t
+      cosine = RQuat.dot( q1, q2 )
+
+      qn1 = q1
+      qn2 = q2
+
+      if ( cosine < 0.0 )
+        cosine *= -1.0
+        qn1 *= -1.0
+      end
+
+      if ( (1.0 - cosine) > TOLERANCE )
+        theta = Math.acos( cosine )
+        sin_theta = Math.sin( theta )
+
+        s1 = Math.sin( it * theta ) / sin_theta
+        s2 = Math.sin(  t * theta ) / sin_theta
+      else
+        s1 = it
+        s2 = t
+      end
+
+      qn1 *= s1
+      qn2 *= s2
+      qResult = qn1 + qn2
+
+      return qResult
+    end
+
+    #
+    # call-seq: setIdentity
+    #
+    # Sets as identity quaternion.
+    #
+    def setIdentity
+      self.x = 0.0
+      self.y = 0.0
+      self.z = 0.0
+      self.w = 1.0
+      return self
+    end
+
+    #
+    # call-seq: getConjugated
+    #
+    # Returns its conjugate quaternion.
+    #
+    def getConjugated
+      return RQuat.new( -@e[0], -@e[1], -@e[2], @e[3] )
+    end
+
+    #
+    # call-seq: conjugate!
+    #
+    # Conjugates itself.
+    #
+    def conjugate!
+      @e[0] *= -1.0
+      @e[1] *= -1.0
+      @e[2] *= -1.0
+      return self
+    end
+
+    #
+    # call-seq: getInverse -> inverse quaternion
+    #
+    # Returns the inverse.
+    #
+    def getInverse
+      length_sq = getLengthSq()
+      return RQuat.new( -@e[0]/length_sq, -@e[1]/length_sq, -@e[2]/length_sq, @e[3]/length_sq )
+    end
+
+    #
+    # call-seq: invert! -> self
+    #
+    # Inverts itself.
+    #
+    def invert!
+      length_sq = getLengthSq()
+      @e[0] /= -length_sq
+      @e[1] /= -length_sq
+      @e[2] /= -length_sq
+      @e[3] /= length_sq
+      return self
+    end
+
+    #
+    # call-seq: getNormalized -> RQuat
+    #
+    # Returns normalized quaternion.
+    #
+    def getNormalized
+      length = getLength()
+      return RQuat.new( @e[0]/length, @e[1]/length, @e[2]/length, @e[3]/length )
+    end
+
+    #
+    # call-seq: normalize! -> self
+    #
+    # Normalizes itself.
+    #
+    def normalize!
+      length = getLength()
+      @e[0] /= length
+      @e[1] /= length
+      @e[2] /= length
+      @e[3] /= length
+      return self
+    end
+
+    #
+    # call-seq: +
+    #
+    # +quat : Unary plus operator.
+    #
+    def +@
+      return self
+    end
+
+    #
+    # call-seq: -
+    #
+    # -quat : Unary minus operator.
+    #
+    def -@
+      return RQuat.new( -@e[0], -@e[1], -@e[2], -@e[3] )
+    end
+
+    #
+    # call-seq: +
+    #
+    # quat1 + quat2 : Binary plus operator.
+    #
+    def +( arg )
+      if arg.class != RQuat
+        raise TypeError, "RQuat#+ : Unknown type #{arg.class}."
+        return nil
+      end
+      RQuat.new( x+arg.x, y+arg.y, z+arg.z, w+arg.w )
+    end
+
+    #
+    # call-seq: -
+    #
+    # quat1 - quat2 : Binary minus operator.
+    #
+    def -( arg )
+      if arg.class != RQuat
+        raise TypeError, "RQuat#- : Unknown type #{arg.class}."
+        return nil
+      end
+      RQuat.new( x-arg.x, y-arg.y, z-arg.z, w-arg.w )
+    end
+
+    #
+    # call-seq: *
+    #
+    # quat1 * quat2 : Binary multiply operator.
+    #
+    def *( arg )
+      case arg
+      when RQuat
+        q1x = self.x
+        q1y = self.y
+        q1z = self.z
+        q1w = self.w
+        q2x = arg.x
+        q2y = arg.y
+        q2z = arg.z
+        q2w = arg.w
+        x = q1w*q2x + q1x*q2w + q1y*q2z - q1z*q2y
+        y = q1w*q2y - q1x*q2z + q1y*q2w + q1z*q2x
+        z = q1w*q2z + q1x*q2y - q1y*q2x + q1z*q2w
+        w = q1w*q2w - q1x*q2x - q1y*q2y - q1z*q2z
+        return RQuat.new( x, y, z, w )
+      when Fixnum, Float
+        return RQuat.new( @e[0]*arg, @e[1]*arg, @e[2]*arg, @e[3]*arg )
+      else
+        raise TypeError, "RQuat#* : Unknown type #{arg}."
+        return nil
+      end
+    end
+
+    #
+    # call-seq: ==
+    #
+    # quat1 == quat2 : evaluates equality.
+    #
+    def ==( other )
+      if other.class != RQuat
+        raise TypeError, "RQuat#== : Unknown type #{other.class}."
+        return nil
+      end
+
+      if  (x-other.x).abs<=Float::EPSILON &&
+          (y-other.y).abs<=Float::EPSILON &&
+          (z-other.z).abs<=Float::EPSILON &&
+          (w-other.w).abs<=Float::EPSILON
+        return true
+      else
+        return false
+      end
+    end
+
+    #
+    # call-seq: quat1.add!( quat2 )
+    #
+    # quat1 += quat2 : appends the elements of +quat2+ into corresponding +quat1+ elements.
+    #
+    def add!( other )
+      if other.class != RQuat
+        raise TypeError, "RQ#add! : Unknown type #{other.class}."
+        return nil
+      end
+
+      self.x += other.x
+      self.y += other.y
+      self.z += other.z
+      self.w += other.w
+
+      return self
+    end
+
+    #
+    # call-seq: quat1.sub!( quat2 )
+    #
+    # quat1 -= quat2 : subtracts the elements of +quat2+ from corresponding +quat1+ elements.
     #
-    def w=(value) @e[3] = value end
+    def sub!( other )
+      if other.class != RQuat
+        raise TypeError, "RQuat#sub! : Unknown type #{other.class}."
+        return nil
+      end
+
+      self.x -= other.x
+      self.y -= other.y
+      self.z -= other.z
+      self.w -= other.w
+
+      return self
+    end
 
     #
-    # call-seq: xyz= vXYZ
+    # call-seq: quat1.mul!( quat2 )
     #
-    # Copies the values of +vXYZ+(RVec3) into +x+, +y+ and +z+.
+    # quat1 *= quat2
     #
-    def xyz=( arg )
-      if arg.class != RVec3
-        raise TypeError, "RQuat#xyz= : Unknown type #{arg.class}."
+    def mul!( other )
+      case other
+      when RQuat
+        q1x = self.x
+        q1y = self.y
+        q1z = self.z
+        q1w = self.w
+        q2x = other.x
+        q2y = other.y
+        q2z = other.z
+        q2w = other.w
+
+        x = q1w*q2x + q1x*q2w + q1y*q2z - q1z*q2y
+        y = q1w*q2y - q1x*q2z + q1y*q2w + q1z*q2x
+        z = q1w*q2z + q1x*q2y - q1y*q2x + q1z*q2w
+        w = q1w*q2w - q1x*q2x - q1y*q2y - q1z*q2z
+
+        self.x = x
+        self.y = y
+        self.z = z
+        self.w = w
+
+        return self
+
+      when Fixnum, Float
+        self.x *= other
+        self.y *= other
+        self.z *= other
+        self.w *= other
+        return self
+
+      else
+        raise TypeError, "RQuat#mul! : Unknown type #{other.class}."
         return nil
       end
-      @e[0] = arg.x
-      @e[1] = arg.y
-      @e[2] = arg.z
     end
 
     #
-    # call-seq: quat[i] -> value
+    # call-seq: rotationMarix(mtx4) -> self
     #
-    # Returns the element at +i+.
+    # Makes a rotation quaternion from a rotation matrix +mtx4+ (RMtx4).
     #
-    def [](i)
-      @e[i]
-    end
+    def rotationMatrix( mtx )
+      if mtx.class != RMtx3 && mtx.class != RMtx4
+        raise TypeError, "RQuat#rotationMatrix : Unknown type #{mtx.class}."
+        return nil
+      end
+
+      diag00 = mtx.getElement(0,0)
+      diag11 = mtx.getElement(1,1)
+      diag22 = mtx.getElement(2,2)
+
+      if ( diag00 + diag11 + diag22 > 0.0 )
+        t = diag00 + diag11 + diag22 + 1.0
+        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
+        self.w = s * t
+        self.z = (mtx.getElement(1,0) - mtx.getElement(0,1)) * s
+        self.y = (mtx.getElement(0,2) - mtx.getElement(2,0)) * s
+        self.x = (mtx.getElement(2,1) - mtx.getElement(1,2)) * s
+      elsif ( diag00 > diag11 && diag00 > diag22 )
+        t = diag00 - diag11 - diag22 + 1.0
+        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
+        self.x = s * t
+        self.y = (mtx.getElement(1,0) + mtx.getElement(0,1)) * s
+        self.z = (mtx.getElement(0,2) + mtx.getElement(2,0)) * s
+        self.w = (mtx.getElement(2,1) - mtx.getElement(1,2)) * s
+      elsif ( diag11 > diag22 )
+        t = -diag00 + diag11 - diag22 + 1.0
+        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
+        self.y = s * t
+        self.x = (mtx.getElement(1,0) + mtx.getElement(0,1)) * s
+        self.w = (mtx.getElement(0,2) - mtx.getElement(2,0)) * s
+        self.z = (mtx.getElement(2,1) + mtx.getElement(1,2)) * s
+      else
+        t = -diag00 - diag11 + diag22 + 1.0
+        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
+        self.z = s * t
+        self.w = (mtx.getElement(1,0) - mtx.getElement(0,1)) * s
+        self.x = (mtx.getElement(0,2) + mtx.getElement(2,0)) * s
+        self.y = (mtx.getElement(2,1) + mtx.getElement(1,2)) * s
+      end
 
+      return self
+    end
 
     #
-    # call-seq: x -> value
+    # call-seq: rotationAxis(axis,radian) -> self
     #
-    # Returns the value of +x+.
+    # Makes a quaternion that rotates around the +axis+.
     #
-    def x() return @e[0] end
+    def rotationAxis( axis, radian )
+      if axis.class != RVec3
+        raise TypeError, "RQuat#rotationAxis : Unknown type #{axis.class}."
+        return nil
+      end
+
+      s = Math.sin( radian / 2.0 )
+      self.x = s * axis.x
+      self.y = s * axis.y
+      self.z = s * axis.z
+      self.w = Math.cos( radian / 2.0 )
+
+      return self
+    end
 
     #
-    # call-seq: y -> value
+    # call-seq: toAxisAngle -> [axis,radian]
     #
-    # Returns the value of +y+.
+    # Returns its rotation axis (RVec3) and rotation angle (in radian).
     #
-    def y() return @e[1] end
+    def toAxisAngle
+      axis = RVec3.new( self.x, self.y, self.z ).normalize!
+      radian = 2.0 * Math.acos( self.w )
+
+      return [ axis, radian ]
+    end
+  end
+
+  #
+  # Document-class: RMath3D::RVec2
+  # provies 2 element vector arithmetic.
+  #
+  class RVec2
 
     #
-    # call-seq: z -> value
+    # call-seq:
+    #   RVec2.new -> (0,0)
+    #   RVec2.new(e) -> (e,e)
+    #   RVec2.new( other ) : Copy Constructor
+    #   RVec2.new( e0, e1 ) -> (e0,e1)
     #
-    # Returns the value of +z+.
+    # Creates a new 3 element vector.
     #
-    def z() return @e[2] end
+    def initialize( *a )
+      @e = []
+      case a.length
+      when 0
+        @e = [0.0, 0.0]
+      when 1
+        case a[0]
+        when Fixnum, Float
+          @e = [ a[0], a[0] ]
+        when RVec2
+          @e = [ a[0].x, a[0].y ]
+        else
+          raise TypeError, "RVec2#initialize : Unknown type #{a[0].class}."
+          return nil
+        end
+      when 2
+        a.each_with_index do |elem, index|
+          case elem
+          when Fixnum, Float
+            @e[index] = elem
+          else
+            raise TypeError, "RVec2#initialize : Unknown type #{elem.class}."
+            return nil
+          end
+        end
+      else
+        raise RuntimeError, "RVec2#initialize : wrong # of arguments (#{a.length})"
+        return nil
+      end
+      return self
+    end
 
     #
-    # call-seq: w -> value
+    # call-seq: to_s
     #
-    # Returns the value of +w+.
+    # Returns human-readable string.
     #
-    def w() return @e[3] end
+    def to_s
+      return "( #{@e[0]}, #{@e[1]} )\n"
+    end
 
     #
-    # call-seq: xyz -> RVec3
+    # call-seq: to_a
     #
-    # Returns the values of +x+, +y+ and +z+ with new RVec3(+x+,+y+,+z+).
+    # Returns its elements as a new Array.
     #
-    def xyz()
-      return RVec3.new( @e[0], @e[1], @e[2] )
+    def to_a
+      return @e
     end
 
     #
-    # call-seq: getLength
+    # call-seq: coerse(other)
     #
-    # Returns the Euclidean length.
+    # Resolves type mismatch.
     #
-    def getLength
-      return Math.sqrt( @e[0]*@e[0] + @e[1]*@e[1] + @e[2]*@e[2] + @e[3]*@e[3] )
+    def coerce( arg )
+      case arg
+      when Fixnum, Float, Bignum
+        return [ self, arg ]
+      else
+        raise TypeError, "RVec2#coerce : #{arg.self} can't be coerced into  #{self.class}."
+        return nil
+      end
     end
 
     #
-    # call-seq: getLengthSq
+    # call-seq: setElements( e0, e1 )
     #
-    # Returns the squared Euclidean length.
+    # Stores given 2 new values.
     #
-    def getLengthSq
-      return (@e[0]*@e[0] + @e[1]*@e[1] + @e[2]*@e[2] + @e[3]*@e[3]).to_f
+    def setElements( x, y )
+      self.x = x
+      self.y = y
     end
 
     #
-    # call-seq: RQuat.dot(q_a,q_b) -> value
+    # call-seq: vec2[i]= value
     #
-    # Calculates the dot product of +q_a+ and +q_b+.
+    # Stores +value+ at +i+.
     #
-    def RQuat.dot( q1, q2 )
-      if q1.class != RQuat || q2.class != RQuat
-        raise TypeError, "RQuat#dot : Unknown type q1:#{q2.class}, q2:#{q2.class}."
-        return nil
-      end
-      return q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w
+    def []=(i,value)
+      @e[i] = value
     end
 
     #
-    # call-seq: RQuat.slerp( q_a, q_b, t ) -> interpolated quaternion
+    # call-seq: x= value
     #
-    # Calculates the spherical linear interpolation between +q_a+ and
-    # +q_b+ at time +t+ (0.0~1.0).
+    # Stores +value+ as +x+.
     #
-    def RQuat.slerp( q1, q2, t )
-      if q1.class != RQuat || q2.class != RQuat
-        raise TypeError, "RQuat#slerp : Unknown type q1:#{q2.class}, q2:#{q2.class}."
-        return nil
-      end
-      s1 = 0.0
-      s2 = 0.0
-      it = 1.0 - t
-      cosine = RQuat.dot( q1, q2 )
-
-      qn1 = q1
-      qn2 = q2
-
-      if ( cosine < 0.0 )
-        cosine *= -1.0
-        qn1 *= -1.0
-      end
-
-      if ( (1.0 - cosine) > TOLERANCE )
-        theta = Math.acos( cosine )
-        sin_theta = Math.sin( theta )
-
-        s1 = Math.sin( it * theta ) / sin_theta
-        s2 = Math.sin(  t * theta ) / sin_theta
-      else
-        s1 = it
-        s2 = t
-      end
+    def x=(value) @e[0] = value end
 
-      qn1 *= s1
-      qn2 *= s2
-      qResult = qn1 + qn2
+    #
+    # call-seq: y= value
+    #
+    # Stores +value+ as +y+.
+    #
+    def y=(value) @e[1] = value end
 
-      return qResult
+    #
+    # call-seq: vec3[i] -> value
+    #
+    # Returns the element at +i+.
+    #
+    def [](i)
+      @e[i]
     end
 
     #
-    # call-seq: setIdentity
+    # call-seq: x -> value
     #
-    # Sets as identity quaternion.
+    # Returns the value of +x+.
     #
-    def setIdentity
-      self.x = 0.0
-      self.y = 0.0
-      self.z = 0.0
-      self.w = 1.0
-      return self
+    def x() return @e[0] end
+
+    #
+    # call-seq: y -> value
+    #
+    # Returns the value of +y+.
+    #
+    def y() return @e[1] end
+
+    #
+    # call-seq: getLength
+    #
+    # Returns the Euclidean length.
+    #
+    def getLength
+      return Math.sqrt( @e[0]*@e[0] + @e[1]*@e[1] )
     end
 
     #
-    # call-seq: getConjugated
+    # call-seq: getLengthSq
     #
-    # Returns its conjugate quaternion.
+    # Returns the squared Euclidean length.
     #
-    def getConjugated
-      return RQuat.new( -@e[0], -@e[1], -@e[2], @e[3] )
+    def getLengthSq
+      return (@e[0]*@e[0] + @e[1]*@e[1]).to_f
     end
 
     #
-    # call-seq: conjugate!
+    # call-seq: RVec2.dot(v_a,v_b) -> value
     #
-    # Conjugates itself.
+    # Calculates the dot product of +v_a+ and +v_b+.
     #
-    def conjugate!
-      @e[0] *= -1.0
-      @e[1] *= -1.0
-      @e[2] *= -1.0
-      return self
+    def RVec2.dot( v1, v2 )
+      return v1.x*v2.x + v1.y*v2.y
     end
 
     #
-    # call-seq: getInverse -> inverse quaternion
+    # call-seq: RVec2.cross(v_a,v_b) -> value
     #
-    # Returns the inverse.
+    # Calculates the cross product of +v_a+ and +v_b+.
     #
-    def getInverse
-      length_sq = getLengthSq()
-      return RQuat.new( -@e[0]/length_sq, -@e[1]/length_sq, -@e[2]/length_sq, @e[3]/length_sq )
+    def RVec2.cross( v1, v2 )
+      return v1.x*v2.y - v1.y*v2.x
     end
 
     #
-    # call-seq: invert! -> self
+    # call-seq: transform(mtx2) -> transformed RVec2
     #
-    # Inverts itself.
+    # Returns new RVec2 containing the result of the transformation of
+    #  RVec2(self.x,self.y) by +mtx2+ (RMtx2).
     #
-    def invert!
-      length_sq = getLengthSq()
-      @e[0] /= -length_sq
-      @e[1] /= -length_sq
-      @e[2] /= -length_sq
-      @e[3] /= length_sq
-      return self
+    def transform( mtx2 )
+      result = RVec2.new
+      result.x = mtx2.e00 * self[0] + mtx2.e01 * self[1]
+      result.y = mtx2.e10 * self[0] + mtx2.e11 * self[1]
+
+      return result
     end
 
     #
-    # call-seq: getNormalized -> RQuat
+    # call-seq: getNormalized -> RVec2
     #
-    # Returns normalized quaternion.
+    # Returns normalized vector.
     #
     def getNormalized
-      length = getLength()
-      return RQuat.new( @e[0]/length, @e[1]/length, @e[2]/length, @e[3]/length )
+      l = getLength()
+      l = 1.0/l
+      return RVec2.new( @e[0]*l, @e[1]*l )
     end
 
     #
@@ -2012,18 +3009,17 @@ module RMath3D
     # Normalizes itself.
     #
     def normalize!
-      length = getLength()
-      @e[0] /= length
-      @e[1] /= length
-      @e[2] /= length
-      @e[3] /= length
+      l = getLength()
+      l = 1.0/l
+      @e[0] *= l
+      @e[1] *= l
       return self
     end
 
     #
     # call-seq: +
     #
-    # +quat : Unary plus operator.
+    # +vec : Unary plus operator.
     #
     def +@
       return self
@@ -2032,63 +3028,49 @@ module RMath3D
     #
     # call-seq: -
     #
-    # -quat : Unary minus operator.
+    # -vec : Unary minus operator.
     #
     def -@
-      return RQuat.new( -@e[0], -@e[1], -@e[2], -@e[3] )
+      return RVec2.new( -@e[0], -@e[1] )
     end
 
     #
     # call-seq: +
     #
-    # quat1 + quat2 : Binary plus operator.
+    # vec1 + vec2 : Binary plus operator.
     #
     def +( arg )
-      if arg.class != RQuat
-        raise TypeError, "RQuat#+ : Unknown type #{arg.class}."
+      if arg.class != RVec2
+        raise TypeError, "RVec2#+ : Unknown type #{arg.class}."
         return nil
       end
-      RQuat.new( x+arg.x, y+arg.y, z+arg.z, w+arg.w )
+      RVec2.new( x+arg.x, y+arg.y )
     end
 
     #
     # call-seq: -
     #
-    # quat1 - quat2 : Binary minus operator.
+    # vec1 - vec2 : Binary minus operator.
     #
     def -( arg )
-      if arg.class != RQuat
-        raise TypeError, "RQuat#- : Unknown type #{arg.class}."
+      if arg.class != RVec2
+        raise TypeError, "RVec2#- : Unknown type #{arg.class}."
         return nil
       end
-      RQuat.new( x-arg.x, y-arg.y, z-arg.z, w-arg.w )
+      RVec2.new( x-arg.x, y-arg.y )
     end
 
     #
     # call-seq: *
     #
-    # quat1 * quat2 : Binary multiply operator.
+    # vec1 * vec2 : Binary multiply operator.
     #
     def *( arg )
       case arg
-      when RQuat
-        q1x = self.x
-        q1y = self.y
-        q1z = self.z
-        q1w = self.w
-        q2x = arg.x
-        q2y = arg.y
-        q2z = arg.z
-        q2w = arg.w
-        x = q1w*q2x + q1x*q2w + q1y*q2z - q1z*q2y
-        y = q1w*q2y - q1x*q2z + q1y*q2w + q1z*q2x
-        z = q1w*q2z + q1x*q2y - q1y*q2x + q1z*q2w
-        w = q1w*q2w - q1x*q2x - q1y*q2y - q1z*q2z
-        return RQuat.new( x, y, z, w )
       when Fixnum, Float
-        return RQuat.new( @e[0]*arg, @e[1]*arg, @e[2]*arg, @e[3]*arg )
+        return RVec2.new( @e[0]*arg, @e[1]*arg )
       else
-        raise TypeError, "RQuat#* : Unknown type #{arg}."
+        raise TypeError, "RVec2#* : Unknown type #{arg}."
         return nil
       end
     end
@@ -2096,18 +3078,16 @@ module RMath3D
     #
     # call-seq: ==
     #
-    # quat1 == quat2 : evaluates equality.
+    # vec1 == vec2 : evaluates equality.
     #
     def ==( other )
-      if other.class != RQuat
-        raise TypeError, "RQuat#== : Unknown type #{other.class}."
+      if other.class != RVec2
+        raise TypeError, "RVec2#== : Unknown type #{other.class}."
         return nil
       end
 
       if  (x-other.x).abs<=Float::EPSILON &&
-          (y-other.y).abs<=Float::EPSILON &&
-          (z-other.z).abs<=Float::EPSILON &&
-          (w-other.w).abs<=Float::EPSILON
+          (y-other.y).abs<=Float::EPSILON
         return true
       else
         return false
@@ -2115,164 +3095,55 @@ module RMath3D
     end
 
     #
-    # call-seq: quat1.add!( quat2 )
+    # call-seq: vec1.add!( vec2 )
     #
-    # quat1 += quat2 : appends the elements of +quat2+ into corresponding +quat1+ elements.
+    # vec1 += vec2 : appends the elements of +vec2+ into corresponding +vec1+ elements.
     #
     def add!( other )
-      if other.class != RQuat
-        raise TypeError, "RQ#add! : Unknown type #{other.class}."
+      if other.class != RVec2
+        raise TypeError, "RVec2#add! : Unknown type #{other.class}."
         return nil
       end
 
       self.x += other.x
       self.y += other.y
-      self.z += other.z
-      self.w += other.w
 
       return self
     end
 
     #
-    # call-seq: quat1.sub!( quat2 )
+    # call-seq: vec1.sub!( vec2 )
     #
-    # quat1 -= quat2 : subtracts the elements of +quat2+ from corresponding +quat1+ elements.
+    # vec1 -= vec2 : subtracts the elements of +vec2+ from corresponding +vec1+ elements.
     #
     def sub!( other )
-      if other.class != RQuat
-        raise TypeError, "RQuat#sub! : Unknown type #{other.class}."
+      if other.class != RVec2
+        raise TypeError, "RVec2#sub! : Unknown type #{other.class}."
         return nil
       end
 
       self.x -= other.x
       self.y -= other.y
-      self.z -= other.z
-      self.w -= other.w
-
-      return self
-    end
-
-    #
-    # call-seq: quat1.mul!( quat2 )
-    #
-    # quat1 *= quat2
-    #
-    def mul!( other )
-      case other
-      when RQuat
-        q1x = self.x
-        q1y = self.y
-        q1z = self.z
-        q1w = self.w
-        q2x = other.x
-        q2y = other.y
-        q2z = other.z
-        q2w = other.w
-
-        x = q1w*q2x + q1x*q2w + q1y*q2z - q1z*q2y
-        y = q1w*q2y - q1x*q2z + q1y*q2w + q1z*q2x
-        z = q1w*q2z + q1x*q2y - q1y*q2x + q1z*q2w
-        w = q1w*q2w - q1x*q2x - q1y*q2y - q1z*q2z
-
-        self.x = x
-        self.y = y
-        self.z = z
-        self.w = w
-
-        return self
-
-      when Fixnum, Float
-        self.x *= other
-        self.y *= other
-        self.z *= other
-        self.w *= other
-        return self
-
-      else
-        raise TypeError, "RQuat#mul! : Unknown type #{other.class}."
-        return nil
-      end
-    end
-
-    #
-    # call-seq: rotationMarix(mtx4) -> self
-    #
-    # Makes a rotation quaternion from a rotation matrix +mtx4+ (RMtx4).
-    #
-    def rotationMatrix( mtx )
-      if mtx.class != RMtx3 && mtx.class != RMtx4
-        raise TypeError, "RQuat#rotationMatrix : Unknown type #{mtx.class}."
-        return nil
-      end
-
-      diag00 = mtx.getElement(0,0)
-      diag11 = mtx.getElement(1,1)
-      diag22 = mtx.getElement(2,2)
-
-      if ( diag00 + diag11 + diag22 > 0.0 )
-        t = diag00 + diag11 + diag22 + 1.0
-        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
-        self.w = s * t
-        self.z = (mtx.getElement(1,0) - mtx.getElement(0,1)) * s
-        self.y = (mtx.getElement(0,2) - mtx.getElement(2,0)) * s
-        self.x = (mtx.getElement(2,1) - mtx.getElement(1,2)) * s
-      elsif ( diag00 > diag11 && diag00 > diag22 )
-        t = diag00 - diag11 - diag22 + 1.0
-        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
-        self.x = s * t
-        self.y = (mtx.getElement(1,0) + mtx.getElement(0,1)) * s
-        self.z = (mtx.getElement(0,2) + mtx.getElement(2,0)) * s
-        self.w = (mtx.getElement(2,1) - mtx.getElement(1,2)) * s
-      elsif ( diag11 > diag22 )
-        t = -diag00 + diag11 - diag22 + 1.0
-        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
-        self.y = s * t
-        self.x = (mtx.getElement(1,0) + mtx.getElement(0,1)) * s
-        self.w = (mtx.getElement(0,2) - mtx.getElement(2,0)) * s
-        self.z = (mtx.getElement(2,1) + mtx.getElement(1,2)) * s
-      else
-        t = -diag00 - diag11 + diag22 + 1.0
-        s = 1.0 / ( Math.sqrt( t ) * 2.0 )
-        self.z = s * t
-        self.w = (mtx.getElement(1,0) - mtx.getElement(0,1)) * s
-        self.x = (mtx.getElement(0,2) + mtx.getElement(2,0)) * s
-        self.y = (mtx.getElement(2,1) + mtx.getElement(1,2)) * s
-      end
 
       return self
     end
 
     #
-    # call-seq: rotationAxis(axis,radian) -> self
+    # call-seq: vec1.mul!( vec2 )
     #
-    # Makes a quaternion that rotates around the +axis+.
+    # vec1 *= vec2
     #
-    def rotationAxis( axis, radian )
-      if axis.class != RVec3
-        raise TypeError, "RQuat#rotationAxis : Unknown type #{axis.class}."
+    def mul!( arg )
+      if arg.class != Fixnum && arg.class != Float
+        raise TypeError, "RVec2#mul! : Unknown type #{arg.class}."
         return nil
       end
 
-      s = Math.sin( radian / 2.0 )
-      self.x = s * axis.x
-      self.y = s * axis.y
-      self.z = s * axis.z
-      self.w = Math.cos( radian / 2.0 )
+      self.x *= arg
+      self.y *= arg
 
       return self
     end
-
-    #
-    # call-seq: toAxisAngle -> [axis,radian]
-    #
-    # Returns its rotation axis (RVec3) and rotation angle (in radian).
-    #
-    def toAxisAngle
-      axis = RVec3.new( self.x, self.y, self.z ).normalize!
-      radian = 2.0 * Math.acos( self.w )
-
-      return [ axis, radian ]
-    end
   end
 
   #