rmath3d_plain 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4afeec14769aedc4dc064924600f42123b7db3001dd1d9b04887ea72226a6e62
-  data.tar.gz: 65f26f341e1c5c13e2e1971131132c7d641e1ac2cc1ee1abc1cc9a92c47f2731
+  metadata.gz: 569f5334bd7df6cf7e0f7a857ae589bc8258b0940913807ebaa2dcae60bf711e
+  data.tar.gz: 5f5cf50b25ad23c0a51574f6a4d83ac45cfc820e9c5a337591d66a7574c47145
 SHA512:
-  metadata.gz: dc52e86e9d990b0bfe033c399dbcf5da0b2eefd2309b37ce539bfaf420c58fbd8a526e4723c511d92ab5f473ea7257a696126f39b79606342dcfb91840273759
-  data.tar.gz: a197442846a593aa7d54a63609aa9ba3eebebdd6a2fa7b984def5741f077ec3e6322770164d2e200718769635f24a1cd58b3cc1ceb5a9bf1770336e81d7a822a
+  metadata.gz: 13a0b47c640f875de55331962edc75ee9f48f43554e196b98073c297b7ebf6f02e47449c0280f4f9a377a281d0c2607a154a37838cdbaf2d90aa6536a7429c72
+  data.tar.gz: da55b4c5ed4322637162396c67ff45d2f2c870ec7242592309d9bc31dce68e9b3014449bc4f781cde6754cc02e1ce5f5aacbcb98f57cbe867d031dc37a07338d

data/ChangeLog

@@ -1,3 +1,7 @@
+2020-07-23  vaiorabbit  <http://twitter.com/vaiorabbit>
+
+	* rmath3d.c, rmath3d_plain.rb (RMtx4): Added lookAtLH, perspectiveLH, etc.
+
 2020-06-21  vaiorabbit  <http://twitter.com/vaiorabbit>
 
 	* rmath3d.c, rmath3d_plain.rb (RMtx4): Added argument 'ndc_homogeneous' for projection matrix APIs.

data/README.md

@@ -4,7 +4,7 @@
 
 rmath3d is a math module for 3D game programming and computer graphics.
 
-*   Last Update: Jun 21, 2020
+*   Last Update: Jul 23, 2020
 *   Since: Jul 20, 2008
 
 * rmath3d (C Extension Library Implementation) [![Gem Version](https://badge.fury.io/rb/rmath3d.svg)](https://badge.fury.io/rb/rmath3d) [![Gem](https://img.shields.io/gem/dt/rmath3d.svg)](https://rubygems.org/gems/rmath3d)
@@ -33,14 +33,8 @@ rmath3d is a math module for 3D game programming and computer graphics.
 Notice: This library provides native extension. You must setup develop environment (or DevKit) before installation.
 
 *   Ruby
-    *   ruby 2.0.0p247 (2013-06-27 revision 41674) [x86_64-darwin12.4.0]
-    *   ruby 2.0.0p247 (2013-06-27) [i386-mingw32] With Development Kit installed.
-        *   I used: DevKit-mingw64-32-4.7.2-20130224-1151-sfx.exe
-        *   Unpack the archive -> "> ruby dk.rb init" -> edit config.yml (just add your ruby foldier) -> "> ruby dk.rb install" 
-        *   Ref.: http://blog.mattwynne.net/2010/10/12/installing-ruby-gems-with-native-extensions-on-windows/
-    *   ruby 2.2.2p95 (2015-04-13 revision 50295) [x86_64-darwin14]
-    *   Ruby 1.9.3 and prior versions are no longer supported.
-        *   Ref.: https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/
+    *   ruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x64-mingw32]
+    *   Ruby 2.3 and prior versions are no longer supported.
 
 ## Building rmath3d.{so|bundle} ##
 

data/lib/rmath3d/rmath3d_plain.rb

@@ -1904,7 +1904,7 @@ module RMath3D
     end
 
     #
-    # call-seq: perspectiveRH(width,height,znear,zfar,ndc_convention) -> self
+    # call-seq: perspectiveLH(width,height,znear,zfar,ndc_convention) -> self
     #
     # Builds a perspective projection matrix for a right-handed coordinate system from:
     # * View volume width (+width+)
@@ -1913,13 +1913,12 @@ module RMath3D
     # * Far clip plane distance (+zfar+)
     # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
     #
-    def perspectiveRH( width, height, znear, zfar, ndc_homogeneous = true)
-      perspectiveOffCenterRH(-width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar, ndc_homogeneous )
-      return self
+    def perspectiveLH( width, height, znear, zfar, ndc_homogeneous = true)
+      return perspectiveOffCenterLH(-width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar, ndc_homogeneous )
     end
 
     #
-    # call-seq: perspectiveFovRH(fovy,aspect,znear,zfar,ndc_homogeneous) -> self
+    # call-seq: perspectiveFovLH(fovy,aspect,znear,zfar,ndc_homogeneous) -> self
     #
     # Builds a perspective projection matrix for a right-handed coordinate system from:
     # * Field of view in y direction (+fovy+ radian)
@@ -1928,24 +1927,123 @@ module RMath3D
     # * Far clip plane distance (+zfar+)
     # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
     #
-    def perspectiveFovRH( fovy_radian, aspect, znear, zfar, ndc_homogeneous = true)
-      f = Math::tan( fovy_radian / 2.0 )
-      f = 1.0 / f
+    def perspectiveFovLH( fovy_radian, aspect, znear, zfar, ndc_homogeneous = true)
+      # Ref.: https://www.scratchapixel.com/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix/opengl-perspective-projection-matrix
+      top = Math::tan(fovy_radian / 2.0) * znear
+      bottom = -top
+      right = top * aspect
+      left = -right
+      return perspectiveOffCenterLH(left, right, bottom, top, znear, zfar, ndc_homogeneous)
+    end
 
+    #
+    # call-seq: perspectiveOffCenterLH(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+)
+    # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
+    #
+    def perspectiveOffCenterLH( left, right, bottom, top, znear, zfar, ndc_homogeneous = true)
+      a = (right+left) / (right-left)
+      b = (top+bottom) / (top-bottom)
       c = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : -zfar / (zfar-znear)
       d = ndc_homogeneous ? -(2*znear*zfar) / (zfar-znear) : -(znear*zfar) / (zfar-znear)
 
-      setIdentity()
-      setElement( 0, 0, f / aspect )
-      setElement( 1, 1, f )
-      setElement( 2, 2, c )
+      setZero()
+
+      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 )
+      setElement( 3, 2, 1.0 )
+
+      return self
+    end
+
+    #
+    # call-seq: orthoLH(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+)
+    # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
+    #
+    def orthoLH( width, height, znear, zfar, ndc_homogeneous = true)
+      orthoOffCenterLH( -width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar, ndc_homogeneous )
+      return self
+    end
+
+    #
+    # call-seq: orthoOffCenterLH(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+)
+    # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
+    #
+    def orthoOffCenterLH( left, right, bottom, top, znear, zfar, ndc_homogeneous = true)
+      tx = -(right+left) / (right-left)
+      ty = -(top+bottom) / (top-bottom)
+      tz = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : -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, (ndc_homogeneous ? 2.0 : 1.0)/(zfar-znear) )
+      setElement( 2, 3, tz )
 
       return self
     end
 
+    #
+    # call-seq: perspectiveRH(width,height,znear,zfar,ndc_convention) -> 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+)
+    # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
+    #
+    def perspectiveRH( width, height, znear, zfar, ndc_homogeneous = true)
+      return perspectiveOffCenterRH(-width/2.0, width/2.0, -height/2.0, height/2.0, znear, zfar, ndc_homogeneous )
+    end
+
+    #
+    # call-seq: perspectiveFovRH(fovy,aspect,znear,zfar,ndc_homogeneous) -> 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+)
+    # * Set true for the environment with Z coordinate ranges from -1 to +1 (OpenGL), and false otherwise (Direct3D, Metal) (+ndc_homogeneous+)
+    #
+    def perspectiveFovRH( fovy_radian, aspect, znear, zfar, ndc_homogeneous = true)
+      # Ref.: https://www.scratchapixel.com/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix/opengl-perspective-projection-matrix
+      top = Math::tan(fovy_radian / 2.0) * znear
+      bottom = -top
+      right = top * aspect
+      left = -right
+      return perspectiveOffCenterRH(left, right, bottom, top, znear, zfar, ndc_homogeneous)
+    end
+
     #
     # call-seq: perspectiveOffCenterRH(left,right,bottom,top,znear,zfar) -> self
     #
@@ -1964,7 +2062,7 @@ module RMath3D
       c = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : -zfar / (zfar-znear)
       d = ndc_homogeneous ? -(2*znear*zfar) / (zfar-znear) : -(znear*zfar) / (zfar-znear)
 
-      setIdentity()
+      setZero()
 
       setElement( 0, 0, 2*znear/(right-left) )
       setElement( 0, 2, a )
@@ -1973,7 +2071,6 @@ module RMath3D
       setElement( 2, 2, c )
       setElement( 2, 3, d )
       setElement( 3, 2, -1.0 )
-      setElement( 3, 3,  0.0 )
 
       return self
     end

data/test/test_RMtx4.rb

@@ -485,6 +485,29 @@ class TC_RMtx4 < Minitest::Test
     end
   end
 
+  def test_lookAtLH
+    pEye = RVec3.new( 10, 10, 10 )
+    vDir = ( RVec3.new(0,0,0) - pEye ).normalize! # staring at (0,0,0)
+    vUp = RVec3.new( 0, 1, 0 )
+    vRight = RVec3.cross( vUp, vDir ).normalize!
+    vUp = RVec3.cross( vDir, vRight ).normalize!
+
+    m0 = RMtx4.new( vRight.x, vRight.y, vRight.z, -RVec3.dot(pEye,vRight),
+                    vUp.x,    vUp.y,    vUp.z,    -RVec3.dot(pEye,vUp),
+                    vDir.x,   vDir.y,   vDir.z,   -RVec3.dot(pEye,vDir),
+                    0.0,      0.0,      0.0,       1.0    )
+
+    m1 = RMtx4.new.lookAtLH( RVec3.new(10,10,10), # posistion
+                             RVec3.new(0,0,0),    # at
+                             RVec3.new(0,1,0) )   # up
+
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
   def test_lookAtRH
     pEye = RVec3.new( 10, 10, 10 )
     vDir = ( pEye - RVec3.new(0,0,0) ).normalize! # staring at (0,0,0)
@@ -540,15 +563,15 @@ class TC_RMtx4 < Minitest::Test
     fovy = 2.0 * Math::atan( (height/2.0) / z_n )
     f = 1.0/Math::tan( fovy/2.0 )
 
-    m2 = RMtx4.new( f/aspect, 0.0,  0.0,                 0.0,
-                    0.0,      f,    0.0,                 0.0,
-                    0.0,      0.0,  (z_f+z_n)/(z_n-z_f), 2*z_f*z_n/(z_n-z_f),
-                    0.0,      0.0, -1.0,                 0.0 )
+    m2 = RMtx4.new( f/aspect, 0.0,  0.0,                   0.0,
+                    0.0,      f,    0.0,                   0.0,
+                    0.0,      0.0,  -(z_f+z_n)/(z_f-z_n), -2*z_f*z_n/(z_f-z_n),
+                    0.0,      0.0,  -1.0,                  0.0 )
     m3 = RMtx4.new.perspectiveFovRH( fovy, aspect, z_n, z_f, true );
 
     for r in 0...4 do
       for c in 0...4 do
-        assert_in_delta( m2.getElement(r,c), m2.getElement(r,c), @tolerance )
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
       end
     end
 
@@ -572,6 +595,67 @@ class TC_RMtx4 < Minitest::Test
     end
   end
 
+  def test_perspectiveLH
+    left  = -640.0
+    right =  640.0
+    bottom = -360.0
+    top    =  360.0
+    z_n = 1.0
+    z_f = 1000.0
+    width = right - left
+    height = top - bottom
+    aspect = width/height
+
+    # RMtx4#perspectiveLH
+    m0 = RMtx4.new( 2*z_n/width, 0.0,          0.0,                  0.0,
+                    0.0,         2*z_n/height, 0.0,                  0.0,
+                    0.0,         0.0,          (z_f+z_n)/(z_f-z_n), -2.0*z_f*z_n / (z_f-z_n),
+                    0.0,         0.0,          1.0,                  0.0 )
+    m1 = RMtx4.new.perspectiveLH( width, height, z_n, z_f, true )
+
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx4#perspectiveFovLH
+
+    # [NOTE] tan(fovy/2) == (height/2)/z_n
+    fovy = 2.0 * Math::atan( (height/2.0) / z_n )
+    f = 1.0/Math::tan( fovy/2.0 )
+
+    m2 = RMtx4.new( f/aspect, 0.0,  0.0,                 0.0,
+                    0.0,      f,    0.0,                 0.0,
+                    0.0,      0.0,  (z_f+z_n)/(z_f-z_n), -2.0*z_f*z_n/(z_f-z_n),
+                    0.0,      0.0,  1.0,                 0.0 )
+    m3 = RMtx4.new.perspectiveFovLH( fovy, aspect, z_n, z_f, true );
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx4#perspectiveOffCenterLH
+
+    a = (right+left)/(right-left)
+    b = (top+bottom)/(top-bottom)
+    c = -(z_f+z_n)/(z_f-z_n)
+    d = -2.0*z_f*z_n/(z_f-z_n)
+    m4 = RMtx4.new( 2*z_n/(right-left), 0.0,                -a,   0.0,
+                    0.0,                2*z_n/(top-bottom), -b,   0.0,
+                    0.0,                0.0,                -c,   d,
+                    0.0,                0.0,                 1.0, 0.0 )
+
+    m5 = RMtx4.new.perspectiveOffCenterLH( left, right, bottom, top, z_n, z_f, true )
+
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m4.getElement(r,c), m5.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
   # http://pyopengl.sourceforge.net/documentation/manual/glOrtho.3G.xml
   def test_orthoRH
     left  = -640.0
@@ -616,6 +700,49 @@ class TC_RMtx4 < Minitest::Test
     end
   end
 
+  def test_orthoLH
+    left  = -640.0
+    right =  640.0
+    bottom = -360.0
+    top    =  360.0
+    z_n = 1.0
+    z_f = 1000.0
+    width = right - left
+    height = top - bottom
+
+    # RMtx4#orthoLH
+    tx = -(right+left)/width
+    ty = -(top+bottom)/height
+    tz = -(z_f+z_n)/(z_f-z_n)
+    m0 = RMtx4.new( 2.0/width, 0.0,         0.0,           tx,
+                    0.0,       2.0/height,  0.0,           ty,
+                    0.0,       0.0,         2.0/(z_f-z_n), tz,
+                    0.0,       0.0,         0.0,           1.0 )
+    m1 = RMtx4.new.orthoLH( width, height, z_n, z_f, true )
+
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m0.getElement(r,c), m1.getElement(r,c), @tolerance )
+      end
+    end
+
+    # RMtx4#orthoOffCenterLH
+    tx = -(right+left)/(right-left)
+    ty = -(top+bottom)/(top-bottom)
+    tz = -(z_f+z_n)/(z_f-z_n)
+    m2 = RMtx4.new( 2.0/(right-left), 0.0,               0.0,           tx,
+                    0.0,              2.0/(top-bottom),  0.0,           ty,
+                    0.0,              0.0,               2.0/(z_f-z_n), tz,
+                    0.0,              0.0,               0.0,           1.0 )
+    m3 = RMtx4.new.orthoOffCenterLH( left, right, bottom, top, z_n, z_f, true )
+
+    for r in 0...4 do
+      for c in 0...4 do
+        assert_in_delta( m2.getElement(r,c), m3.getElement(r,c), @tolerance )
+      end
+    end
+  end
+
   def test_unary_operators
     # RMtx4#+@
     m0 = RMtx4.new( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 )

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rmath3d_plain
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - vaiorabbit
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-21 00:00:00.000000000 Z
+date: 2020-07-23 00:00:00.000000000 Z
 dependencies: []
 description: 'Provides vector2/3/4, matrix2x2/3x3/4x4 and quaternion in plain Ruby
   form.