rmath3d 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e8d8b8a38ad55ec12170a103c39607b841855790e279ae4c003e394900f3391
-  data.tar.gz: 8d74d4f0917015c74accd26293cb4036d9befa0bbe0d562893a324881a1b005f
+  metadata.gz: 5dc23938dfb4e458f92a723ca9340b88c8cd9745b2b332c81abf8aef4981e46c
+  data.tar.gz: b23cdf387d8def83bd5310a6666ca83c57b898ee740dee861c804799935d1407
 SHA512:
-  metadata.gz: c6ea5c48fba49380581ae07cef869767a73ab1e3f2d8bda7481b352241bf3bd82197a188d529bf230ec786dedb35bb9a49145d430b54f298729598f7b3ba6702
-  data.tar.gz: b02fb89b9fbb8fe9bc1dd3456ef99507d4d1d1e659b3a2884243ea5342100bca7bee219550e6764e15e43c352cf4561bea5615db56827c2d9365596e9e098802
+  metadata.gz: 78dbf7e6ac5f2b5be92247a2ac26100b47df994cd646f25c638e8fc7486f2dbc195a452b88cc28035cc611d87de4778f93ab64a9f94205ff2405005ada383168
+  data.tar.gz: 401b5ab4bb610ea41689276cc96d05bb0c1f4a5b90d579d51781fffb08bde75d8da7140b88a2b8bac8ea223ed64a3cef2f7e1a5d6c667761a096dd6552721eab

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/ext/rmath3d/RMtx4.c

@@ -436,6 +436,104 @@ RMtx4Scale( RMtx4* out, const RMtx4* m, rmReal f )
                          GET_ELEMENT( m, row, col ) * f );
 }
 
+/* http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/lookat.html
+   http://msdn.microsoft.com/en-us/library/bb205343.aspx
+*/
+void
+RMtx4LookAtLH( RMtx4* out, const RVec3* eye, const RVec3* at, const RVec3* up )
+{
+#define AX(i) RVec3GetElement( &axis_x, i )
+#define AY(i) RVec3GetElement( &axis_y, i )
+#define AZ(i) RVec3GetElement( &axis_z, i )
+
+    RVec3 axis_x, axis_y, axis_z;
+
+    RMtx4Identity( out );
+
+    RVec3Sub( &axis_z, at, eye );
+    RVec3Normalize( &axis_z, &axis_z );
+
+    RVec3Cross( &axis_x, up, &axis_z );
+    RVec3Normalize( &axis_x, &axis_x );
+
+    RVec3Cross( &axis_y, &axis_z, &axis_x );
+
+    SET_ELEMENT( out, 0, 0,  AX(0) );
+    SET_ELEMENT( out, 0, 1,  AX(1) );
+    SET_ELEMENT( out, 0, 2,  AX(2) );
+    SET_ELEMENT( out, 0, 3,  -RVec3Dot(&axis_x, eye) );
+
+    SET_ELEMENT( out, 1, 0,  AY(0) );
+    SET_ELEMENT( out, 1, 1,  AY(1) );
+    SET_ELEMENT( out, 1, 2,  AY(2) );
+    SET_ELEMENT( out, 1, 3,  -RVec3Dot(&axis_y, eye) );
+
+    SET_ELEMENT( out, 2, 0,  AZ(0) );
+    SET_ELEMENT( out, 2, 1,  AZ(1) );
+    SET_ELEMENT( out, 2, 2,  AZ(2) );
+    SET_ELEMENT( out, 2, 3,  -RVec3Dot(&axis_z, eye) );
+
+#undef AX
+#undef AY
+#undef AZ
+}
+
+void
+RMtx4PerspectiveLH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmReal zfar, bool ndc_homogeneous )
+{
+    RMtx4PerspectiveOffCenterLH( out, -width/2.0f, width/2.0f, -height/2.0f, height/2.0f, znear, zfar, ndc_homogeneous );
+}
+
+void
+RMtx4PerspectiveFovLH( RMtx4* out, rmReal fovy_radian, rmReal aspect, rmReal znear, rmReal zfar, bool ndc_homogeneous )
+{
+    rmReal top = rmTan(fovy_radian / 2.0f) * znear;
+    rmReal bottom = -top;
+    rmReal right = top * aspect;
+    rmReal left = -right;
+    RMtx4PerspectiveOffCenterLH(out, left, right, bottom, top, znear, zfar, ndc_homogeneous);
+}
+
+void
+RMtx4PerspectiveOffCenterLH( RMtx4* out, rmReal left, rmReal right, rmReal bottom, rmReal top, rmReal znear, rmReal zfar, bool ndc_homogeneous )
+{
+    rmReal A = (right+left) / (right-left);
+    rmReal B = (top+bottom) / (top-bottom);
+    rmReal C = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : -zfar / (zfar-znear);
+    rmReal D = ndc_homogeneous ? -(2*znear*zfar) / (zfar-znear) : -(znear*zfar) / (zfar-znear);
+
+    RMtx4Zero( out );
+    SET_ELEMENT( out, 0, 0, 2*znear/(right-left) );
+    SET_ELEMENT( out, 0, 2, -A );
+    SET_ELEMENT( out, 1, 1, 2*znear/(top-bottom) );
+    SET_ELEMENT( out, 1, 2, -B );
+    SET_ELEMENT( out, 2, 2, -C );
+    SET_ELEMENT( out, 2, 3,  D );
+    SET_ELEMENT( out, 3, 2, 1.0f );
+}
+
+void
+RMtx4OrthoLH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmReal zfar, bool ndc_homogeneous )
+{
+    RMtx4OrthoOffCenterLH( out, -width/2.0f, width/2.0f, -height/2.0f, height/2.0f, znear, zfar, ndc_homogeneous );
+}
+
+void
+RMtx4OrthoOffCenterLH( RMtx4* out, rmReal left, rmReal right, rmReal bottom, rmReal top, rmReal znear, rmReal zfar, bool ndc_homogeneous )
+{
+    rmReal tx = -(right+left) / (right-left);
+    rmReal ty = -(top+bottom) / (top-bottom);
+    rmReal tz = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : -znear / (zfar-znear);
+
+    RMtx4Identity( out );
+    SET_ELEMENT( out, 0, 0, 2.0f/(right-left) );
+    SET_ELEMENT( out, 0, 3, tx );
+    SET_ELEMENT( out, 1, 1, 2.0f/(top-bottom) );
+    SET_ELEMENT( out, 1, 3, ty );
+    SET_ELEMENT( out, 2, 2, (ndc_homogeneous ? 2.0f : 1.0f)/(zfar-znear) );
+    SET_ELEMENT( out, 2, 3, tz );
+}
+
 /* http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/glu/lookat.html
    http://msdn.microsoft.com/en-us/library/bb205343.aspx
 */
@@ -484,25 +582,16 @@ RMtx4PerspectiveRH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmRea
     RMtx4PerspectiveOffCenterRH( out, -width/2.0f, width/2.0f, -height/2.0f, height/2.0f, znear, zfar, ndc_homogeneous );
 }
 
-/* https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/gluPerspective.xml
-   Game Programming in C++ (2018) https://www.oreilly.com/library/view/game-programming-in/9780134598185/
+/* https://www.scratchapixel.com/lessons/3d-basic-rendering/perspective-and-orthographic-projection-matrix/opengl-perspective-projection-matrix
  */
 void
 RMtx4PerspectiveFovRH( RMtx4* out, rmReal fovy_radian, rmReal aspect, rmReal znear, rmReal zfar, bool ndc_homogeneous )
 {
-    rmReal f = rmTan( fovy_radian / 2.0f );
-    f = 1.0f / f;
-
-    rmReal C = ndc_homogeneous ? -(zfar+znear) / (zfar-znear) : zfar / -(zfar-znear);
-    rmReal D = ndc_homogeneous ? -(2*znear*zfar) / (zfar-znear) : -(znear*zfar) / (zfar-znear);
-
-    RMtx4Identity( out );
-    SET_ELEMENT( out, 0, 0, f / aspect );
-    SET_ELEMENT( out, 1, 1, f );
-    SET_ELEMENT( out, 2, 2, C );
-    SET_ELEMENT( out, 2, 3, D );
-    SET_ELEMENT( out, 3, 2, -1.0f );
-    SET_ELEMENT( out, 3, 3, 0.0f );
+    rmReal top = rmTan(fovy_radian / 2.0f) * znear;
+    rmReal bottom = -top;
+    rmReal right = top * aspect;
+    rmReal left = -right;
+    RMtx4PerspectiveOffCenterRH(out, left, right, bottom, top, znear, zfar, ndc_homogeneous);
 }
 
 /* https://www.khronos.org/registry/OpenGL-Refpages/gl2.1/xhtml/glFrustum.xml

data/ext/rmath3d/RMtx4.h

@@ -71,6 +71,13 @@ void    RMtx4Sub( RMtx4* out, const RMtx4* m1, const RMtx4* m2 );
 void    RMtx4Mul( RMtx4* out, const RMtx4* m1, const RMtx4* m2 );
 void    RMtx4Scale( RMtx4* out, const RMtx4* m, rmReal f );
 
+void    RMtx4LookAtLH( RMtx4* out, const struct RVec3* eye, const struct RVec3* at, const struct RVec3* up );
+void    RMtx4PerspectiveLH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmReal zfar, bool ndc_homogeneous );
+void    RMtx4PerspectiveFovLH( RMtx4* out, rmReal fovy_radian, rmReal aspect, rmReal znear, rmReal zfar, bool ndc_homogeneous );
+void    RMtx4PerspectiveOffCenterLH( RMtx4* out, rmReal left, rmReal right, rmReal bottom, rmReal top, rmReal znear, rmReal zfar, bool ndc_homogeneous );
+void    RMtx4OrthoLH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmReal zfar, bool ndc_homogeneous );
+void    RMtx4OrthoOffCenterLH( RMtx4* out, rmReal left, rmReal right, rmReal bottom, rmReal top, rmReal znear, rmReal zfar, bool ndc_homogeneous );
+
 void    RMtx4LookAtRH( RMtx4* out, const struct RVec3* eye, const struct RVec3* at, const struct RVec3* up );
 void    RMtx4PerspectiveRH( RMtx4* out, rmReal width, rmReal height, rmReal znear, rmReal zfar, bool ndc_homogeneous );
 void    RMtx4PerspectiveFovRH( RMtx4* out, rmReal fovy_radian, rmReal aspect, rmReal znear, rmReal zfar, bool ndc_homogeneous );

data/ext/rmath3d/rmath3d.c

@@ -3221,6 +3221,224 @@ RMtx4_scaling( VALUE self, VALUE x, VALUE y, VALUE z )
     return self;
 }
 
+/*
+ * call-seq: lookAtLH(eye,at,up) -> self
+ *
+ * Builds a viewing matrix for a left-handed coordinate system from:
+ * * eye position (+eye+: RVec3)
+ * * a point looking at (+at+: RVec3)
+ * * up vector (+up+: RVec3)
+ */
+static VALUE
+RMtx4_lookAtLH( VALUE self, VALUE e, VALUE a, VALUE u )
+{
+    RMtx4*  m   = NULL;
+    RVec3*  eye = NULL;
+    RVec3*  at  = NULL;
+    RVec3*  up  = NULL;
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    TypedData_Get_Struct( e, RVec3, &RVec3_type, eye );
+    TypedData_Get_Struct( a, RVec3, &RVec3_type, at );
+    TypedData_Get_Struct( u, RVec3, &RVec3_type, up );
+    RMtx4LookAtLH( m, eye, at, up );
+
+    return self;
+}
+
+/*
+ * call-seq: perspectiveLH(width,height,znear,zfar,ndc_homogeneous) -> 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+)
+ */
+static VALUE
+RMtx4_perspectiveLH( int argc, VALUE* argv, VALUE self )
+{
+    VALUE w, h, zn, zf, ndch;
+    RMtx4* m = NULL;
+    rmReal width, height, znear, zfar;
+    bool ndc_homogeneous;
+
+    if (argc < 4 || argc > 5)
+    {
+        rb_raise(rb_eArgError, "RMtx4_perspectiveLH : wrong # of arguments (%d)", argc );
+    }
+
+    rb_scan_args(argc, argv, "41", &w, &h, &zn, &zf, &ndch);
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    width  = NUM2DBL(w);
+    height = NUM2DBL(h);
+    znear  = NUM2DBL(zn);
+    zfar   = NUM2DBL(zf);
+    ndc_homogeneous = NIL_P(ndch) ? true : ((ndch == Qtrue) ? true : false);
+
+    RMtx4PerspectiveLH( m, width, height, znear, zfar, ndc_homogeneous );
+
+    return 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)
+ * * 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+)
+ */
+static VALUE
+RMtx4_perspectiveFovLH( int argc, VALUE* argv, VALUE self )
+{
+    VALUE fovy, asp, zn, zf, ndch;
+    RMtx4* m = NULL;
+    rmReal fovy_radian, aspect, znear, zfar;
+    bool ndc_homogeneous;
+
+    if (argc < 4 || argc > 5)
+    {
+        rb_raise(rb_eArgError, "RMtx4_perspectiveFovLH : wrong # of arguments (%d)", argc );
+    }
+
+    rb_scan_args(argc, argv, "41", &fovy, &asp, &zn, &zf, &ndch);
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    fovy_radian = NUM2DBL(fovy);
+    aspect      = NUM2DBL(asp);
+    znear       = NUM2DBL(zn);
+    zfar        = NUM2DBL(zf);
+    ndc_homogeneous = NIL_P(ndch) ? true : ((ndch == Qtrue) ? true : false);
+
+    RMtx4PerspectiveFovLH( m, fovy_radian, aspect, znear, zfar, ndc_homogeneous );
+
+    return self;
+}
+
+/*
+ * call-seq: perspectiveOffCenterLH(left,right,bottom,top,znear,zfar,ndc_homogeneous) -> 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+)
+ */
+static VALUE
+RMtx4_perspectiveOffCenterLH( int argc, VALUE* argv, VALUE self )
+{
+    VALUE l, r, b, t, zn, zf, ndch;
+    RMtx4* m = NULL;
+    rmReal left, right, bottom, top, znear, zfar;
+    bool ndc_homogeneous;
+
+    if (argc < 6 || argc > 7)
+    {
+        rb_raise(rb_eArgError, "RMtx4_perspectiveOffCenterLH : wrong # of arguments (%d)", argc );
+    }
+
+    rb_scan_args(argc, argv, "61", &l, &r, &b, &t, &zn, &zf, &ndch);
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    left   = NUM2DBL(l);
+    right  = NUM2DBL(r);
+    bottom = NUM2DBL(b);
+    top    = NUM2DBL(t);
+    znear  = NUM2DBL(zn);
+    zfar   = NUM2DBL(zf);
+    ndc_homogeneous = NIL_P(ndch) ? true : ((ndch == Qtrue) ? true : false);
+
+    RMtx4PerspectiveOffCenterLH( m, left, right, bottom, top, znear, zfar, ndc_homogeneous );
+
+    return self;
+}
+
+/*
+ * call-seq: orthoLH(width,height,znear,zfar,ndc_homogeneous) -> 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+)
+ */
+static VALUE
+RMtx4_orthoLH( int argc, VALUE* argv, VALUE self )
+{
+    VALUE w, h, zn, zf, ndch;
+    RMtx4* m = NULL;
+    rmReal width, height, znear, zfar;
+    bool ndc_homogeneous;
+
+    if (argc < 4 || argc > 5)
+    {
+        rb_raise(rb_eArgError, "RMtx4_orthoLH : wrong # of arguments (%d)", argc );
+    }
+
+    rb_scan_args(argc, argv, "41", &w, &h, &zn, &zf, &ndch);
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    width  = NUM2DBL(w);
+    height = NUM2DBL(h);
+    znear  = NUM2DBL(zn);
+    zfar   = NUM2DBL(zf);
+    ndc_homogeneous = NIL_P(ndch) ? true : ((ndch == Qtrue) ? true : false);
+
+    RMtx4OrthoLH( m, width, height, znear, zfar, ndc_homogeneous );
+
+    return self;
+}
+
+/*
+ * call-seq: orthoOffCenterLH(left,right,bottom,top,znear,zfar,ndc_homogeneous) -> 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+)
+ */
+static VALUE
+RMtx4_orthoOffCenterLH( int argc, VALUE* argv, VALUE self )
+{
+    VALUE l, r, b, t, zn, zf, ndch;
+    RMtx4* m = NULL;
+    rmReal left, right, bottom, top, znear, zfar;
+    bool ndc_homogeneous;
+
+    if (argc < 6 || argc > 7)
+    {
+        rb_raise(rb_eArgError, "RMtx4_orthoOffCenterLH : wrong # of arguments (%d)", argc );
+    }
+
+    rb_scan_args(argc, argv, "61", &l, &r, &b, &t, &zn, &zf, &ndch);
+
+    TypedData_Get_Struct( self, RMtx4, &RMtx4_type, m );
+    left   = NUM2DBL(l);
+    right  = NUM2DBL(r);
+    bottom = NUM2DBL(b);
+    top    = NUM2DBL(t);
+    znear  = NUM2DBL(zn);
+    zfar   = NUM2DBL(zf);
+    ndc_homogeneous = NIL_P(ndch) ? true : ((ndch == Qtrue) ? true : false);
+
+    RMtx4OrthoOffCenterLH( m, left, right, bottom, top, znear, zfar, ndc_homogeneous );
+
+    return self;
+}
+
 /*
  * call-seq: lookAtRH(eye,at,up) -> self
  *
@@ -7380,6 +7598,13 @@ Init_rmath3d()
     rb_define_method( rb_cRMtx4, "rotationQuaternion", RMtx4_rotationQuaternion, 1 );
     rb_define_method( rb_cRMtx4, "scaling", RMtx4_scaling, 3 );
 
+    rb_define_method( rb_cRMtx4, "lookAtLH", RMtx4_lookAtLH, 3 );
+    rb_define_method( rb_cRMtx4, "perspectiveLH", RMtx4_perspectiveLH, -1 );
+    rb_define_method( rb_cRMtx4, "perspectiveFovLH", RMtx4_perspectiveFovLH, -1 );
+    rb_define_method( rb_cRMtx4, "perspectiveOffCenterLH", RMtx4_perspectiveOffCenterLH, -1 );
+    rb_define_method( rb_cRMtx4, "orthoLH", RMtx4_orthoLH, -1 );
+    rb_define_method( rb_cRMtx4, "orthoOffCenterLH", RMtx4_orthoOffCenterLH, -1 );
+
     rb_define_method( rb_cRMtx4, "lookAtRH", RMtx4_lookAtRH, 3 );
     rb_define_method( rb_cRMtx4, "perspectiveRH", RMtx4_perspectiveRH, -1 );
     rb_define_method( rb_cRMtx4, "perspectiveFovRH", RMtx4_perspectiveFovRH, -1 );

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
 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 C extension library form (and plain Ruby form with the same interface for debugging use).