rmath3d 1.0.0

data/test/test_RQuat.rb

@@ -0,0 +1,381 @@
+require 'minitest/autorun'
+class TC_RQuat < Minitest::Test
+  def setup
+    @tolerance = RMath3D::TOLERANCE
+    @zero = RQuat.new( 0, 0, 0, 0 )
+  end
+
+  def teardown
+  end
+
+  def test_initialize
+    q0 = RQuat.new
+    assert_in_delta( 0, q0.x, @tolerance )
+    assert_in_delta( 0, q0.y, @tolerance )
+    assert_in_delta( 0, q0.z, @tolerance )
+    assert_in_delta( 0, q0.w, @tolerance )
+
+    q1 = RQuat.new( 1, 2, 3, 4 )
+    assert_in_delta( 1, q1.x, @tolerance )
+    assert_in_delta( 2, q1.y, @tolerance )
+    assert_in_delta( 3, q1.z, @tolerance )
+    assert_in_delta( 4, q1.w, @tolerance )
+
+    q2 = RQuat.new( q1 )
+    assert_in_delta( 1, q2.x, @tolerance )
+    assert_in_delta( 2, q2.y, @tolerance )
+    assert_in_delta( 3, q2.z, @tolerance )
+    assert_in_delta( 4, q2.w, @tolerance )
+  end
+
+  def test_to_s
+    assert_respond_to( @zero, :to_s )
+  end
+
+  def test_coerce
+    assert_respond_to( @zero, :coerce )
+  end
+
+  def test_setElements
+    q = RQuat.new
+    q.setElements( 1, 2, 3, 4 )
+    assert_in_delta( 1, q.x, @tolerance )
+    assert_in_delta( 2, q.y, @tolerance )
+    assert_in_delta( 3, q.z, @tolerance )
+    assert_in_delta( 4, q.w, @tolerance )
+  end
+
+  def test_setElement
+    q = RQuat.new
+
+    # x=
+    q.x = 1
+    assert_in_delta( 1, q.x, @tolerance )
+    q[0] = 2
+    assert_in_delta( 2, q.x, @tolerance )
+
+    # y=
+    q.y = 1
+    assert_in_delta( 1, q.y, @tolerance )
+    q[1] = 2
+    assert_in_delta( 2, q.y, @tolerance )
+
+    # z=
+    q.z = 1
+    assert_in_delta( 1, q.z, @tolerance )
+    q[2] = 2
+    assert_in_delta( 2, q.z, @tolerance )
+
+    # w=
+    q.w = 1
+    assert_in_delta( 1, q.w, @tolerance )
+    q[3] = 2
+    assert_in_delta( 2, q.w, @tolerance )
+
+    # xyz=
+    v3 = RVec3.new( 4, 5, 6 )
+    q.xyz = v3
+    assert_in_delta( 4, q.x, @tolerance )
+    assert_in_delta( 5, q.y, @tolerance )
+    assert_in_delta( 6, q.z, @tolerance )
+
+    v3 = RVec3.new( 7, 8, 9 )
+    q.xyz = v3
+    assert_in_delta( 7, q.x, @tolerance )
+    assert_in_delta( 8, q.y, @tolerance )
+    assert_in_delta( 9, q.z, @tolerance )
+  end
+
+  def test_getElement
+    q = RQuat.new(1,2,3,4)
+    assert_in_delta( 1, q[0], @tolerance )
+    assert_in_delta( 2, q[1], @tolerance )
+    assert_in_delta( 3, q[2], @tolerance )
+    assert_in_delta( 4, q[3], @tolerance )
+
+    assert_in_delta( 1, q.x, @tolerance )
+    assert_in_delta( 2, q.y, @tolerance )
+    assert_in_delta( 3, q.z, @tolerance )
+    assert_in_delta( 4, q.w, @tolerance )
+
+    # RQuat#getXYZ, RQuat#xyz
+    v3 = q.xyz
+    assert_kind_of( RVec3, v3 )
+    assert_in_delta( 1, v3.x, @tolerance )
+    assert_in_delta( 2, v3.y, @tolerance )
+    assert_in_delta( 3, v3.z, @tolerance )
+
+    v3 = q.xyz
+    assert_kind_of( RVec3, v3 )
+    assert_in_delta( 1, v3.x, @tolerance )
+    assert_in_delta( 2, v3.y, @tolerance )
+    assert_in_delta( 3, v3.z, @tolerance )
+  end
+
+  def test_getLength
+    len_sq = 1.0*1.0 + 2.0*2.0 + 3.0*3.0 + 4.0*4.0
+    len = Math.sqrt( len_sq )
+
+    q = RQuat.new( 1, 2, 3, 4 )
+    assert_in_delta( len_sq, q.getLengthSq, @tolerance )
+    assert_in_delta( len   , q.getLength  , @tolerance )
+  end
+
+  def test_setIdentity
+    q = RQuat.new.setIdentity
+    assert_in_delta( 0, q.x, @tolerance )
+    assert_in_delta( 0, q.y, @tolerance )
+    assert_in_delta( 0, q.z, @tolerance )
+    assert_in_delta( 1, q.w, @tolerance )
+  end
+
+  def test_conjugate
+    q0 = RQuat.new( 1, 2, 3, 4 )
+
+    q1 = q0.getConjugated
+    assert_in_delta( -1, q1.x, @tolerance )
+    assert_in_delta( -2, q1.y, @tolerance )
+    assert_in_delta( -3, q1.z, @tolerance )
+    assert_in_delta(  4, q1.w, @tolerance )
+
+    q0.conjugate!
+    assert_in_delta( -1, q0.x, @tolerance )
+    assert_in_delta( -2, q0.y, @tolerance )
+    assert_in_delta( -3, q0.z, @tolerance )
+    assert_in_delta(  4, q0.w, @tolerance )
+  end
+
+  def test_invert
+    qa = RQuat.new( 1,0,0,  3 )
+    qb = RQuat.new( 5,1,-2, 0 )
+    qc = RQuat.new.rotationAxis( RVec3.new(0,0,1), Math::PI/4.0 )
+
+    qai = qa.getInverse
+    qi = qa * qai
+
+    assert_in_delta( 0, qi.x, @tolerance )
+    assert_in_delta( 0, qi.y, @tolerance )
+    assert_in_delta( 0, qi.z, @tolerance )
+    assert_in_delta( 1, qi.w, @tolerance )
+
+    qbi = qb.getInverse
+    qi = qbi * qb
+    assert_in_delta( 0, qi.x, @tolerance )
+    assert_in_delta( 0, qi.y, @tolerance )
+    assert_in_delta( 0, qi.z, @tolerance )
+    assert_in_delta( 1, qi.w, @tolerance )
+
+    qci = RQuat.new( qc )
+    qci.invert!
+
+    qr = qci * qc
+    assert_in_delta( 0, qr.x, @tolerance )
+    assert_in_delta( 0, qr.y, @tolerance )
+    assert_in_delta( 0, qr.z, @tolerance )
+    assert_in_delta( 1, qr.w, @tolerance )
+  end
+
+  def test_normalize
+    len_sq = 1.0*1.0 + 2.0*2.0 + 3.0*3.0 + 4.0*4.0
+    len = Math.sqrt( len_sq )
+    x = 1.0 / len
+    y = 2.0 / len
+    z = 3.0 / len
+    w = 4.0 / len
+    q = RQuat.new( 1, 2, 3, 4 )
+    # getNormalized
+    q0 = q.getNormalized
+    assert_in_delta( x, q0.x, @tolerance )
+    assert_in_delta( y, q0.y, @tolerance )
+    assert_in_delta( z, q0.z, @tolerance )
+    assert_in_delta( w, q0.w, @tolerance )
+
+    # normalize!
+    q.normalize!
+    assert_in_delta( x, q.x, @tolerance )
+    assert_in_delta( y, q.y, @tolerance )
+    assert_in_delta( z, q.z, @tolerance )
+    assert_in_delta( w, q.w, @tolerance )
+  end
+
+  def test_unary_operators
+    q = RQuat.new( 1, 2, 3, 4 )
+
+    # RQuat#+@
+    qp = +q
+    assert_in_delta( 1, qp.x, @tolerance )
+    assert_in_delta( 2, qp.y, @tolerance )
+    assert_in_delta( 3, qp.z, @tolerance )
+    assert_in_delta( 4, qp.w, @tolerance )
+
+    # RQuat#-@
+    qm = -q
+    assert_in_delta( -1, qm.x, @tolerance )
+    assert_in_delta( -2, qm.y, @tolerance )
+    assert_in_delta( -3, qm.z, @tolerance )
+    assert_in_delta( -4, qm.w, @tolerance )
+  end
+
+  def test_plus_operations
+    q0 = RQuat.new( 1, 1, 1, 1 )
+    q1 = RQuat.new( 2, 2, 2, 2 )
+
+    # RQuat#+
+    qr = q0 + q1
+    assert_in_delta( 3, qr.x, @tolerance )
+    assert_in_delta( 3, qr.y, @tolerance )
+    assert_in_delta( 3, qr.z, @tolerance )
+    assert_in_delta( 3, qr.w, @tolerance )
+
+    # RQuat#add!
+    q0.add!( q1 )
+    assert_in_delta( 3, q0.x, @tolerance )
+    assert_in_delta( 3, q0.y, @tolerance )
+    assert_in_delta( 3, q0.z, @tolerance )
+    assert_in_delta( 3, q0.w, @tolerance )
+
+    assert_raises( TypeError ) { q0 + 1.0 }
+    assert_raises( TypeError ) { 1.0 + q0 }
+  end
+
+  def test_minus_operations
+    q0 = RQuat.new( 1, 1, 1, 1 )
+    q1 = RQuat.new( 2, 2, 2, 2 )
+
+    # RQuat#-
+    qr = q0 - q1
+    assert_in_delta( -1, qr.x, @tolerance )
+    assert_in_delta( -1, qr.y, @tolerance )
+    assert_in_delta( -1, qr.z, @tolerance )
+    assert_in_delta( -1, qr.w, @tolerance )
+
+    # RQuat#sub!
+    q0.sub!( q1 )
+    assert_in_delta( -1, q0.x, @tolerance )
+    assert_in_delta( -1, q0.y, @tolerance )
+    assert_in_delta( -1, q0.z, @tolerance )
+    assert_in_delta( -1, q0.w, @tolerance )
+
+    assert_raises( TypeError ) { q0 - 1.0 }
+    assert_raises( TypeError ) { 1.0 - q0 }
+  end
+
+  def test_mult_operations
+    q0 = RQuat.new( 1, 1, 1, 1 )
+
+    qr = q0 * 2.0
+    assert_in_delta( 2.0, qr.x, @tolerance )
+    assert_in_delta( 2.0, qr.y, @tolerance )
+    assert_in_delta( 2.0, qr.z, @tolerance )
+    assert_in_delta( 2.0, qr.w, @tolerance )
+
+    qr = 2.0 * q0
+    assert_in_delta( 2.0, qr.x, @tolerance )
+    assert_in_delta( 2.0, qr.y, @tolerance )
+    assert_in_delta( 2.0, qr.z, @tolerance )
+    assert_in_delta( 2.0, qr.w, @tolerance )
+
+    q0.mul!( 2.0 )
+    assert_in_delta( 2.0, q0.x, @tolerance )
+    assert_in_delta( 2.0, q0.y, @tolerance )
+    assert_in_delta( 2.0, q0.z, @tolerance )
+    assert_in_delta( 2.0, q0.w, @tolerance )
+
+    # http://en.wikipedia.org/wiki/Quaternions
+    qa = RQuat.new( 1,0,0,  3 )
+    qb = RQuat.new( 5,1,-2, 0 )
+    qab = RQuat.new( 15,5,-5, -5 )
+    qba = RQuat.new( 15,1,-7, -5 )
+
+    qr =  qa * qb
+    assert_in_delta( qab.x, qr.x, @tolerance )
+    assert_in_delta( qab.y, qr.y, @tolerance )
+    assert_in_delta( qab.z, qr.z, @tolerance )
+    assert_in_delta( qab.w, qr.w, @tolerance )
+
+    qr =  qb * qa
+    assert_in_delta( qba.x, qr.x, @tolerance )
+    assert_in_delta( qba.y, qr.y, @tolerance )
+    assert_in_delta( qba.z, qr.z, @tolerance )
+    assert_in_delta( qba.w, qr.w, @tolerance )
+
+    qa.mul!( qb )
+    assert_in_delta( qab.x, qa.x, @tolerance )
+    assert_in_delta( qab.y, qa.y, @tolerance )
+    assert_in_delta( qab.z, qa.z, @tolerance )
+    assert_in_delta( qab.w, qa.w, @tolerance )
+  end
+
+  def test_equality_operations
+    v = RQuat.new
+    assert( v == @zero )
+
+    v0 = RQuat.new(1,2,3,4)
+    assert( v != v0 )
+  end
+
+  def test_rotationMatrix
+    rad = Math::PI/3
+    m0 = RMtx4.new.rotationAxis( RVec3.new(0,0,1), rad )
+    q0 = RQuat.new( 0, 0, Math::sin(rad/2), Math::cos(rad/2) )
+    q1 = RQuat.new.rotationMatrix( m0 )
+    assert_in_delta( q0.x, q1.x, @tolerance )
+    assert_in_delta( q0.y, q1.y, @tolerance )
+    assert_in_delta( q0.z, q1.z, @tolerance )
+    assert_in_delta( q0.w, q1.w, @tolerance )
+  end
+
+  def test_rotationAxis
+    rad = Math::PI/3
+    q0 = RQuat.new( 0, 0, Math::sin(rad/2), Math::cos(rad/2) )
+    q1 = RQuat.new.rotationAxis( RVec3.new(0,0,1), rad )
+    assert_in_delta( q0.x, q1.x, @tolerance )
+    assert_in_delta( q0.y, q1.y, @tolerance )
+    assert_in_delta( q0.z, q1.z, @tolerance )
+    assert_in_delta( q0.w, q1.w, @tolerance )
+  end
+
+  def test_toAxisAngle
+    rad = Math::PI/3
+    q0 = RQuat.new( 0, 0, Math::sin(rad/2), Math::cos(rad/2) )
+    axis, angle = q0.toAxisAngle
+
+    assert_kind_of( RVec3, axis )
+    assert_in_delta( 0, axis.x, @tolerance )
+    assert_in_delta( 0, axis.y, @tolerance )
+    assert_in_delta( 1, axis.z, @tolerance )
+    assert_in_delta( rad, angle, @tolerance )
+  end
+
+  def test_dot
+    q0 = RQuat.new( 1, 1, 1, 1 )
+    q1 = RQuat.new( 2, 2, 2, 2 )
+
+    assert_in_delta( 8.0, RQuat.dot(q0, q1), @tolerance )
+  end
+
+  def test_slerp
+    qs = RQuat.new.rotationAxis( RVec3.new(0,0,1), 1.0*Math::PI/6 )
+    qe = RQuat.new.rotationAxis( RVec3.new(0,0,1), 5.0*Math::PI/6 )
+
+    q = RQuat.slerp( qs, qe, 0.0 )
+    assert_in_delta( qs.x, q.x, @tolerance )
+    assert_in_delta( qs.y, q.y, @tolerance )
+    assert_in_delta( qs.z, q.z, @tolerance )
+    assert_in_delta( qs.w, q.w, @tolerance )
+
+    q = RQuat.slerp( qs, qe, 0.5 )
+    qr = RQuat.new( 0,0,Math::sin((Math::PI/2)/2), Math::cos((Math::PI/2)/2) )
+    assert_in_delta( qr.x, q.x, @tolerance )
+    assert_in_delta( qr.y, q.y, @tolerance )
+    assert_in_delta( qr.z, q.z, @tolerance )
+    assert_in_delta( qr.w, q.w, @tolerance )
+
+    q = RQuat.slerp( qs, qe, 1.0 )
+    assert_in_delta( qe.x, q.x, @tolerance )
+    assert_in_delta( qe.y, q.y, @tolerance )
+    assert_in_delta( qe.z, q.z, @tolerance )
+    assert_in_delta( qe.w, q.w, @tolerance )
+  end
+
+end

data/test/test_RVec3.rb

@@ -0,0 +1,308 @@
+require 'minitest/autorun'
+class TC_RVec3 < Minitest::Test
+  def setup
+    @tolerance = RMath3D::TOLERANCE
+    @zero = RVec3.new( 0, 0, 0 )
+    @ax   = RVec3.new( 1, 0, 0 )
+    @ay   = RVec3.new( 0, 1, 0 )
+    @az   = RVec3.new( 0, 0, 1 )
+  end
+
+  def teardown
+  end
+
+  def test_initialize
+    v0 = RVec3.new
+    assert_in_delta( 0, v0.x, @tolerance )
+    assert_in_delta( 0, v0.y, @tolerance )
+    assert_in_delta( 0, v0.z, @tolerance )
+
+    v1 = RVec3.new( 1, 2, 3 )
+    assert_in_delta( 1, v1.x, @tolerance )
+    assert_in_delta( 2, v1.y, @tolerance )
+    assert_in_delta( 3, v1.z, @tolerance )
+
+    v2 = RVec3.new( v1 )
+    assert_in_delta( 1, v2.x, @tolerance )
+    assert_in_delta( 2, v2.y, @tolerance )
+    assert_in_delta( 3, v2.z, @tolerance )
+  end
+
+  def test_to_s
+    assert_respond_to( @zero, :to_s )
+  end
+
+  def test_coerce
+    assert_respond_to( @zero, :coerce )
+  end
+
+  def test_setElements
+    v = RVec3.new
+    v.setElements( 1, 2, 3 )
+    assert_in_delta( 1, v.x, @tolerance )
+    assert_in_delta( 2, v.y, @tolerance )
+    assert_in_delta( 3, v.z, @tolerance )
+  end
+
+  def test_setElement
+    v = RVec3.new
+
+    # x=
+    v.x = 1
+    assert_in_delta( 1, v.x, @tolerance )
+    v[0] = 2
+    assert_in_delta( 2, v.x, @tolerance )
+
+    # y=
+    v.y = 1
+    assert_in_delta( 1, v.y, @tolerance )
+    v[1] = 2
+    assert_in_delta( 2, v.y, @tolerance )
+
+    # z=
+    v.z = 1
+    assert_in_delta( 1, v.z, @tolerance )
+    v[2] = 2
+    assert_in_delta( 2, v.z, @tolerance )
+  end
+
+  def test_getElement
+    assert_in_delta( 1, @ax[0], @tolerance )
+    assert_in_delta( 1, @ay[1], @tolerance )
+    assert_in_delta( 1, @az[2], @tolerance )
+
+    assert_in_delta( 1, @ax.x, @tolerance )
+    assert_in_delta( 1, @ay.y, @tolerance )
+    assert_in_delta( 1, @az.z, @tolerance )
+  end
+
+  def test_getLength
+    len_sq = 1.0*1.0 + 2.0*2.0 + 3.0*3.0 # == 14.0
+    len = Math.sqrt( len_sq ) # == 3.3166247903554
+
+    v = RVec3.new( 1, 2, 3 )
+    assert_in_delta( len_sq, v.getLengthSq, @tolerance )
+    assert_in_delta( len   , v.getLength  , @tolerance )
+  end
+
+  def test_normalize
+    len_sq = 1.0*1.0 + 2.0*2.0 + 3.0*3.0 # == 14.0
+    len = Math.sqrt( len_sq ) # == 3.3166247903554
+    x = 1.0 / len
+    y = 2.0 / len
+    z = 3.0 / len
+    v = RVec3.new( 1, 2, 3 )
+    # getNormalized
+    v0 = v.getNormalized
+    assert_in_delta( x, v0.x, @tolerance )
+    assert_in_delta( y, v0.y, @tolerance )
+    assert_in_delta( z, v0.z, @tolerance )
+
+    # normalize!
+    v.normalize!
+    assert_in_delta( x, v.x, @tolerance )
+    assert_in_delta( y, v.y, @tolerance )
+    assert_in_delta( z, v.z, @tolerance )
+  end
+
+  def test_unary_operators
+    v = RVec3.new( 1, 2, 3 )
+
+    # RVec3#+@
+    vp = +v
+    assert_in_delta( 1, vp.x, @tolerance )
+    assert_in_delta( 2, vp.y, @tolerance )
+    assert_in_delta( 3, vp.z, @tolerance )
+
+    # RVec3#-@
+    vm = -v
+    assert_in_delta( -1, vm.x, @tolerance )
+    assert_in_delta( -2, vm.y, @tolerance )
+    assert_in_delta( -3, vm.z, @tolerance )
+  end
+
+  def test_plus_operations
+    v0 = RVec3.new( 1, 1, 1 )
+    v1 = RVec3.new( 2, 2, 2 )
+
+    # RVec3#+
+    vr = v0 + v1
+    assert_in_delta( 3, vr.x, @tolerance )
+    assert_in_delta( 3, vr.y, @tolerance )
+    assert_in_delta( 3, vr.z, @tolerance )
+
+    # RVec3#add!
+    v0.add!( v1 )
+    assert_in_delta( 3, v0.x, @tolerance )
+    assert_in_delta( 3, v0.y, @tolerance )
+    assert_in_delta( 3, v0.z, @tolerance )
+
+    assert_raises( TypeError ) { v0 + 1.0 }
+    assert_raises( TypeError ) { 1.0 + v0 }
+  end
+
+  def test_minus_operations
+    v0 = RVec3.new( 1, 1, 1 )
+    v1 = RVec3.new( 2, 2, 2 )
+
+    # RVec3#-
+    vr = v0 - v1
+    assert_in_delta( -1, vr.x, @tolerance )
+    assert_in_delta( -1, vr.y, @tolerance )
+    assert_in_delta( -1, vr.z, @tolerance )
+
+    # RVec3#sub!
+    v0.sub!( v1 )
+    assert_in_delta( -1, v0.x, @tolerance )
+    assert_in_delta( -1, v0.y, @tolerance )
+    assert_in_delta( -1, v0.z, @tolerance )
+
+    assert_raises( TypeError ) { v0 - 1.0 }
+    assert_raises( TypeError ) { 1.0 - v0 }
+  end
+
+  def test_mult_operations
+    v0 = RVec3.new( 1, 1, 1 )
+
+    vr = v0 * 2.0
+    assert_in_delta( 2.0, vr.x, @tolerance )
+    assert_in_delta( 2.0, vr.y, @tolerance )
+    assert_in_delta( 2.0, vr.z, @tolerance )
+
+    vr = 2.0 * v0
+    assert_in_delta( 2.0, vr.x, @tolerance )
+    assert_in_delta( 2.0, vr.y, @tolerance )
+    assert_in_delta( 2.0, vr.z, @tolerance )
+
+    v0.mul!( 2.0 )
+    assert_in_delta( 2.0, v0.x, @tolerance )
+    assert_in_delta( 2.0, v0.y, @tolerance )
+    assert_in_delta( 2.0, v0.z, @tolerance )
+
+    assert_raises( TypeError ) { v0 * @zero }
+  end
+
+  def test_equality_operations
+    v = RVec3.new
+    assert( v == @zero )
+    assert( v != @ax )
+  end
+
+  def test_dot
+    v0 = RVec3.new( 1, 1, 1 )
+    v1 = RVec3.new( 2, 2, 2 )
+    assert_in_delta( 6.0, RVec3.dot(v0, v1), @tolerance )
+    assert_in_delta( 0.0, RVec3.dot(@ax, @ay), @tolerance )
+#    assert_raises( TypeError ) { RVec3.dot(@ax, 1.0) }
+#    assert_raises( TypeError ) { RVec3.dot(1.0, @ax) }
+  end
+
+  def test_cross
+    vr = RVec3.cross( @ax, @ay )
+    assert_in_delta( @az.x, vr.x, @tolerance )
+    assert_in_delta( @az.y, vr.y, @tolerance )
+    assert_in_delta( @az.z, vr.z, @tolerance )
+  end
+
+  def test_transform
+    m = RMtx4.new.rotationX( Math::PI/4.0 )
+    va = RVec3.new( 0.0, -Math.sqrt(2)/2, Math.sqrt(2)/2 )
+
+    vr = @az.transform( m )
+    assert_kind_of( RVec4, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    m = RMtx4.new.translation( 1.0, 1.0, 1.0 )
+    va = RVec3.new( 1.0, 1.0, 2.0 )
+
+    vr = @az.transform( m )
+    assert_kind_of( RVec4, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+  end
+
+  def test_transformCoord
+    m = RMtx4.new.rotationX( Math::PI/4.0 )
+    va = RVec3.new( 0.0, -Math.sqrt(2)/2, Math.sqrt(2)/2 )
+
+    vr = @az.transformCoord( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    vr = RVec3.new( @az )
+    vr.transformCoord!( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    m = RMtx4.new.translation( 1.0, 1.0, 1.0 )
+    va = RVec3.new( 1.0, 1.0, 2.0 )
+
+    vr = @az.transformCoord( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+  end
+
+  def test_transformNormal
+    m = RMtx4.new.rotationX( Math::PI/4.0 )
+    va = RVec3.new( 0.0, -Math.sqrt(2)/2, Math.sqrt(2)/2 )
+
+    vr = @az.transformNormal( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    vr = RVec3.new( @az )
+    vr.transformNormal!( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    m = RMtx4.new.translation( 1.0, 1.0, 1.0 )
+    va = RVec3.new( 1.0, 1.0, 2.0 )
+
+    vr = @az.transformNormal( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( @az.x, vr.x, @tolerance )
+    assert_in_delta( @az.y, vr.y, @tolerance )
+    assert_in_delta( @az.z, vr.z, @tolerance )
+  end
+
+  def test_transformRS
+    m = RMtx3.new.rotationX( Math::PI/4.0 )
+    va = RVec3.new( 0.0, -Math.sqrt(2)/2, Math.sqrt(2)/2 )
+
+    vr = @az.transformRS( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    vr = RVec3.new( @az )
+    vr.transformRS!( m )
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+
+    m = RMtx3.new.scaling( 2.0, 2.0, 2.0 )
+
+    vr = @az.transformRS( m )
+    va = RVec3.new( 0, 0, 2.0 )
+
+    assert_kind_of( RVec3, vr )
+    assert_in_delta( va.x, vr.x, @tolerance )
+    assert_in_delta( va.y, vr.y, @tolerance )
+    assert_in_delta( va.z, vr.z, @tolerance )
+  end
+end