Update README.md

since struct param is copy-by-value, result was noop

.gitignore

@@ -76,3 +76,5 @@ build/
 conftest.dir/*
 confdefs.h
 *.xcuserdatad
+.idea
+cmake-build-debug

CMakeLists.txt

@@ -1,5 +1,5 @@
 cmake_minimum_required(VERSION 3.8.2)
-project(cglm VERSION 0.8.2 LANGUAGES C)
+project(cglm VERSION 0.8.3 LANGUAGES C)
 
 set(CMAKE_C_STANDARD 11)
 set(CMAKE_C_STANDARD_REQUIRED YES)
@@ -73,6 +73,18 @@ add_library(${PROJECT_NAME}
   src/bezier.c
   src/ray.c
   src/affine2d.c
+  src/clipspace/persp_lh_zo.c
+  src/clipspace/persp_rh_zo.c
+  src/clipspace/persp_lh_no.c
+  src/clipspace/persp_rh_no.c
+  src/clipspace/ortho_lh_zo.c
+  src/clipspace/ortho_rh_zo.c
+  src/clipspace/ortho_lh_no.c
+  src/clipspace/ortho_rh_no.c
+  src/clipspace/view_lh_zo.c
+  src/clipspace/view_rh_zo.c
+  src/clipspace/view_lh_no.c
+  src/clipspace/view_rh_no.c
   )
 
 if(CGLM_SHARED)

Makefile.am

@@ -69,6 +69,23 @@ cglm_HEADERS = include/cglm/version.h \
                include/cglm/ray.h \
                include/cglm/affine2d.h
 
+cglm_clipspacedir=$(includedir)/cglm/clipspace
+cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
+                         include/cglm/clipspace/persp_lh_zo.h \
+                         include/cglm/clipspace/persp_rh_zo.h \
+                         include/cglm/clipspace/persp_lh_no.h \
+                         include/cglm/clipspace/persp_rh_no.h \
+                         include/cglm/clipspace/ortho_lh_zo.h \
+                         include/cglm/clipspace/ortho_rh_zo.h \
+                         include/cglm/clipspace/ortho_lh_no.h \
+                         include/cglm/clipspace/ortho_rh_no.h \
+                         include/cglm/clipspace/view_lh.h \
+                         include/cglm/clipspace/view_rh.h \
+                         include/cglm/clipspace/view_lh_zo.h \
+                         include/cglm/clipspace/view_rh_zo.h \
+                         include/cglm/clipspace/view_lh_no.h \
+                         include/cglm/clipspace/view_rh_no.h
+
 cglm_calldir=$(includedir)/cglm/call
 cglm_call_HEADERS = include/cglm/call/mat4.h \
                     include/cglm/call/mat3.h \
@@ -138,6 +155,20 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
                       include/cglm/struct/curve.h \
                       include/cglm/struct/affine2d.h
 
+cglm_struct_clipspacedir=$(includedir)/cglm/struct/clipspace
+cglm_struct_clipspace_HEADERS = include/cglm/struct/clipspace/persp_lh_zo.h \
+                                include/cglm/struct/clipspace/persp_rh_zo.h \
+                                include/cglm/struct/clipspace/persp_lh_no.h \
+                                include/cglm/struct/clipspace/persp_rh_no.h \
+                                include/cglm/struct/clipspace/ortho_lh_zo.h \
+                                include/cglm/struct/clipspace/ortho_rh_zo.h \
+                                include/cglm/struct/clipspace/ortho_lh_no.h \
+                                include/cglm/struct/clipspace/ortho_rh_no.h \
+                                include/cglm/struct/clipspace/view_lh_zo.h \
+                                include/cglm/struct/clipspace/view_rh_zo.h \
+                                include/cglm/struct/clipspace/view_lh_no.h \
+                                include/cglm/struct/clipspace/view_rh_no.h
+
 libcglm_la_SOURCES=\
     src/euler.c \
     src/affine.c \
@@ -159,13 +190,29 @@ libcglm_la_SOURCES=\
     src/curve.c \
     src/bezier.c \
     src/ray.c \
-    src/affine2d.c
+    src/affine2d.c \
+    src/clipspace/ortho_lh_no.c \
+    src/clipspace/ortho_lh_zo.c \
+    src/clipspace/ortho_rh_no.c \
+    src/clipspace/ortho_rh_zo.c \
+    src/clipspace/persp_lh_no.c \
+    src/clipspace/persp_lh_zo.c \
+    src/clipspace/persp_rh_no.c \
+    src/clipspace/persp_rh_zo.c \
+    src/clipspace/view_lh_no.c \
+    src/clipspace/view_lh_zo.c \
+    src/clipspace/view_rh_no.c \
+    src/clipspace/view_rh_zo.c
 
 test_tests_SOURCES=\
     test/runner.c \
     test/src/test_common.c \
     test/src/tests.c \
     test/src/test_cam.c \
+    test/src/test_cam_lh_zo.c \
+    test/src/test_cam_rh_zo.c \
+    test/src/test_cam_lh_no.c \
+    test/src/test_cam_rh_no.c \
     test/src/test_clamp.c \
     test/src/test_euler.c \
     test/src/test_bezier.c \

README.md

@@ -1,5 +1,5 @@
 # 🎥 OpenGL Mathematics (glm) for `C`
-[![Build Status](https://travis-ci.org/recp/cglm.svg?branch=master)](https://travis-ci.org/recp/cglm)
+[![Build Status](https://travis-ci.com/recp/cglm.svg?branch=master)](https://travis-ci.com/recp/cglm)
 [![Build status](https://ci.appveyor.com/api/projects/status/av7l3gc0yhfex8y4/branch/master?svg=true)](https://ci.appveyor.com/project/recp/cglm/branch/master)
 [![Documentation Status](https://readthedocs.org/projects/cglm/badge/?version=latest)](http://cglm.readthedocs.io/en/latest/?badge=latest)
 [![Coverage Status](https://coveralls.io/repos/github/recp/cglm/badge.svg?branch=master)](https://coveralls.io/github/recp/cglm?branch=master)
@@ -26,6 +26,7 @@ you have the latest version
 - **[major change]** by starting v0.5.0, vec3 functions use **glm_vec3_** namespace, it was **glm_vec_** until v0.5.0
 - **[major change]** by starting v0.5.1, built-in alignment is removed from **vec3** and **mat3** types
 - **[major change]** by starting v0.7.3, inline print functions are disabled in release/production mode to eliminate print costs (see options in documentation). Print output also improved. You can disable colors if you need  (see documentation)
+- **[major change]** by starting v0.8.3, **cglm** supports alternative clipspace configuations e.g. Left Handed, Zero-to-One (_zo)... `CGLM_FORCE_DEPTH_ZERO_TO_ONE` and `CGLM_FORCE_LEFT_HANDED` is provided to control clipspace. You should be able to use **cglm** with Vulkan, DirectX and Metal now... see https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s
 
 #### Note for C++ developers:
 If you are not aware of the original GLM library yet, you may also want to look at:
@@ -69,6 +70,8 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 </table>
 
 ## Features
+- **scalar** and **simd** (sse, avx, neon...) optimizations
+- option to use different clipspaces e.g. Left Handed, Zero-to-One... (currrently right handed negative-one is default)
 - array api and struct api, you can use arrays or structs.
 - general purpose matrix operations (mat4, mat3)
 - chain matrix multiplication (square only)
@@ -95,9 +98,9 @@ Currently *cglm* uses default clip space configuration (-1, 1) for camera functi
 
 <hr />
 
-You have two option to call a function/operation: inline or library call (link)
+You have two options to call a function/operation: inline or library call (link)
 Almost all functions are marked inline (always_inline) so compiler will probably inline.
-To call pre-compiled version, just use `glmc_` (c stands for 'call') instead of `glm_`.
+To call pre-compiled versions, just use `glmc_` (c stands for 'call') instead of `glm_`.
 
 ```C
   #include <cglm/cglm.h>   /* for inline */

cglm.podspec

@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
 
   # Description
   s.name         = "cglm"
-  s.version      = "0.8.1"
+  s.version      = "0.8.2"
   s.summary      = "📽 Highly Optimized Graphics Math (glm) for C"
   s.description  = <<-DESC
 cglm is math library for graphics programming for C. See the documentation or README for all features.

configure.ac

@@ -7,7 +7,7 @@
 #*****************************************************************************
 
 AC_PREREQ([2.69])
-AC_INIT([cglm], [0.8.2], [info@recp.me])
+AC_INIT([cglm], [0.8.3], [info@recp.me])
 AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects serial-tests])
 
 # Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.

docs/source/conf.py

@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
 # built documents.
 #
 # The short X.Y version.
-version = u'0.8.2'
+version = u'0.8.3'
 # The full version, including alpha/beta/rc tags.
-release = u'0.8.2'
+release = u'0.8.3'
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/source/features.rst

@@ -1,6 +1,8 @@
 Features
 ================================================================================
 
+* **scalar** and **simd** (sse, avx, neon...) optimizations
+* option to use different clipspaces e.g. Left Handed, Zero-to-One... (currrently right handed negative-one is default)
 * array api and struct api, you can use arrays or structs.
 * general purpose matrix operations (mat4, mat3)
 * chain matrix multiplication (square only)

docs/source/opt.rst

@@ -35,6 +35,45 @@ have to compile cglm with **CGLM_ALL_UNALIGNED** macro.
 
  For instance if you set CGLM_ALL_UNALIGNED in a project then set it in other projects too
 
+Clipspace Option[s]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By starting **v0.8.3** cglm provides options to switch between clipspace configurations.
+
+Clipspace related files are located at `include/cglm/[struct]/clipspace.h` but 
+these are included in related files like `cam.h`. If you don't want to change your existing 
+clipspace configuration and want to use different clipspace function like `glm_lookat_zo` or `glm_lookat_lh_zo`...
+then you can include individual headers or just define `CGLM_CLIPSPACE_INCLUDE_ALL` which will iclude all headers for you.
+
+1. **CGLM_CLIPSPACE_INCLUDE_ALL**
+2. **CGLM_FORCE_DEPTH_ZERO_TO_ONE**
+3. **CGLM_FORCE_LEFT_HANDED**
+
+
+1. **CGLM_CLIPSPACE_INCLUDE_ALL**:
+
+By defining this macro, **cglm** will include all clipspace functions for you by just using
+`#include cglm/cglm.h` or `#include cglm/struct.h` or `#include cglm/call.h`
+
+Otherwise you need to include header you want manually e.g. `#include cglm/clipspace/view_rh_zo.h`
+
+2. **CGLM_FORCE_DEPTH_ZERO_TO_ONE**
+
+This is similar to **GLM**'s **GLM_FORCE_DEPTH_ZERO_TO_ONE** option. 
+This will set clip space between 0 to 1 which makes **cglm** Vulkan, Metal friendly. 
+
+You can use functions like `glm_lookat_lh_zo()` individually. By setting **CGLM_FORCE_DEPTH_ZERO_TO_ONE**
+functions in cam.h for instance will use `_zo` versions.
+
+3. **CGLM_FORCE_LEFT_HANDED**
+
+Force **cglm** to use the left handed coordinate system by default, currently **cglm** uses right handed coordinate system as default,
+you can change this behavior with this option.
+
+**VERY VERY IMPORTANT:**
+
+Be careful if you include **cglm** in multiple projects.
+
 SSE and SSE2 Shuffle Option
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 **_mm_shuffle_ps** generates **shufps** instruction even if registers are same.

docs/source/quat.rst

@@ -52,6 +52,7 @@ Functions:
 #. :c:func:`glm_quat_mat3`
 #. :c:func:`glm_quat_mat3t`
 #. :c:func:`glm_quat_lerp`
+#. :c:func:`glm_quat_nlerp`
 #. :c:func:`glm_quat_slerp`
 #. :c:func:`glm_quat_look`
 #. :c:func:`glm_quat_for`
@@ -304,6 +305,25 @@ Functions documentation
       | *[in]*  **t**     interpolant (amount) clamped between 0 and 1
       | *[out]* **dest**  result quaternion
 
+.. c:function:: void glm_quat_nlerp(versor q, versor r, float  t, versor dest)
+
+    | interpolates between two quaternions
+    | taking the shortest rotation path using
+    | normalized linear interpolation (NLERP)
+
+    | This is a cheaper alternative to slerp; most games use nlerp
+    | for animations as it visually makes little difference.
+
+    References:
+      * `Understanding Slerp, Then Not Using it <http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It>`_
+      * `Lerp, Slerp and Nlerp <https://keithmaggio.wordpress.com/2011/02/15/math-magician-lerp-slerp-and-nlerp/>`_
+
+    Parameters:
+      | *[in]*  **from**  from
+      | *[in]*  **to**    to
+      | *[in]*  **t**     interpolant (amount) clamped between 0 and 1
+      | *[out]* **dest**  result quaternion
+
 .. c:function:: void glm_quat_slerp(versor q, versor r, float  t, versor dest)
 
     | interpolates between two quaternions

include/cglm/call/cam.h

@@ -15,22 +15,16 @@ extern "C" {
 
 CGLM_EXPORT
 void
-glmc_frustum(float left,
+glmc_frustum(float left,   float right,
-             float right,
+             float bottom, float top,
-             float bottom,
+             float nearZ,  float farZ,
-             float top,
-             float nearVal,
-             float farVal,
              mat4  dest);
 
 CGLM_EXPORT
 void
-glmc_ortho(float left,
+glmc_ortho(float left,   float right,
-           float right,
+           float bottom, float top,
-           float bottom,
+           float nearZ,  float farZ,
-           float top,
-           float nearVal,
-           float farVal,
            mat4  dest);
 
 CGLM_EXPORT
@@ -55,11 +49,7 @@ glmc_ortho_default_s(float aspect, float size, mat4 dest);
 
 CGLM_EXPORT
 void
-glmc_perspective(float fovy,
+glmc_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest);
-                 float aspect,
-                 float nearVal,
-                 float farVal,
-                 mat4 dest);
 
 CGLM_EXPORT
 void
@@ -88,8 +78,8 @@ glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
 CGLM_EXPORT
 void
 glmc_persp_decomp(mat4 proj,
-                  float * __restrict nearVal,
+                  float * __restrict nearZ,
-                  float * __restrict farVal,
+                  float * __restrict farZ,
                   float * __restrict top,
                   float * __restrict bottom,
                   float * __restrict left,
@@ -114,16 +104,16 @@ glmc_persp_decomp_y(mat4 proj,
 CGLM_EXPORT
 void
 glmc_persp_decomp_z(mat4 proj,
-                    float * __restrict nearVal,
+                    float * __restrict nearZ,
-                    float * __restrict farVal);
+                    float * __restrict farZ);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_far(mat4 proj, float * __restrict farVal);
+glmc_persp_decomp_far(mat4 proj, float * __restrict farZ);
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal);
+glmc_persp_decomp_near(mat4 proj, float * __restrict nearZ);
 
 CGLM_EXPORT
 float

include/cglm/call/clipspace/ortho_lh_no.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ortho_lh_no_h
+#define cglmc_ortho_lh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_lh_no(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ,   float farZ,
+                 mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_lh_no(vec3 box[2], mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_lh_no(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_lh_no(float aspect, float size, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ortho_lh_no_h */

include/cglm/call/clipspace/ortho_lh_zo.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ortho_lh_zo_h
+#define cglmc_ortho_lh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_lh_zo(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ,   float farZ,
+                 mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_lh_zo(vec3 box[2], mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_lh_zo(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_lh_zo(float aspect, float size, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ortho_lh_zo_h */

include/cglm/call/clipspace/ortho_rh_no.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ortho_rh_no_h
+#define cglmc_ortho_rh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_rh_no(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ,   float farZ,
+                 mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_rh_no(vec3 box[2], mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_rh_no(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_rh_no(float aspect, float size, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ortho_rh_no_h */

include/cglm/call/clipspace/ortho_rh_zo.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_ortho_rh_zo_h
+#define cglmc_ortho_rh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_rh_zo(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ,   float farZ,
+                 mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_rh_zo(vec3 box[2], mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_rh_zo(float aspect, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_rh_zo(float aspect, float size, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_ortho_rh_zo_h */

include/cglm/call/clipspace/persp_lh_no.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_persp_lh_no_h
+#define cglmc_persp_lh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_lh_no(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ,   float farZ,
+                   mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_perspective_lh_no(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_lh_no(mat4 proj, float deltaFar);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_lh_no(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_lh_no(mat4 proj, float dest[6]);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_lh_no(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_lh_no(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_lh_no(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ);
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_lh_no(mat4 proj);
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_lh_no(mat4 proj);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_persp_lh_no_h */

include/cglm/call/clipspace/persp_lh_zo.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_persp_lh_zo_h
+#define cglmc_persp_lh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_lh_zo(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ,   float farZ,
+                   mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_perspective_lh_zo(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_lh_zo(mat4 proj, float deltaFar);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_lh_zo(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_lh_zo(mat4 proj, float dest[6]);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_lh_zo(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_lh_zo(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_lh_zo(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ);
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_lh_zo(mat4 proj);
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_lh_zo(mat4 proj);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_persp_lh_zo_h */

include/cglm/call/clipspace/persp_rh_no.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_persp_rh_no_h
+#define cglmc_persp_rh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_rh_no(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ,   float farZ,
+                   mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_perspective_rh_no(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_rh_no(mat4 proj, float deltaFar);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_rh_no(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_rh_no(mat4 proj, float dest[6]);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_rh_no(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_rh_no(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_rh_no(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ);
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_rh_no(mat4 proj);
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_rh_no(mat4 proj);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_persp_rh_no_h */

include/cglm/call/clipspace/persp_rh_zo.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_persp_rh_zo_h
+#define cglmc_persp_rh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_rh_zo(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ,   float farZ,
+                   mat4  dest);
+
+CGLM_EXPORT
+void
+glmc_perspective_rh_zo(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_rh_zo(mat4 proj, float deltaFar);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_rh_zo(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_rh_zo(mat4 proj, float dest[6]);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_rh_zo(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_rh_zo(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_rh_zo(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ);
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ);
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest);
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_rh_zo(mat4 proj);
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_rh_zo(mat4 proj);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_persp_rh_zo_h */

include/cglm/call/clipspace/view_lh_no.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_view_lh_no_h
+#define cglmc_view_lh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_view_lh_no_h */

include/cglm/call/clipspace/view_lh_zo.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_view_lh_zo_h
+#define cglmc_view_lh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_view_lh_zo_h */

include/cglm/call/clipspace/view_rh_no.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_view_rh_no_h
+#define cglmc_view_rh_no_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_view_rh_no_h */

include/cglm/call/clipspace/view_rh_zo.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglmc_view_rh_zo_h
+#define cglmc_view_rh_zo_h
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "../cglm.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
+
+CGLM_EXPORT
+void
+glmc_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* cglmc_view_rh_zo_h */

include/cglm/call/quat.h

@@ -121,6 +121,10 @@ CGLM_EXPORT
 void
 glmc_quat_lerpc(versor from, versor to, float t, versor dest);
 
+CGLM_EXPORT
+void
+glmc_quat_nlerp(versor q, versor r, float t, versor dest);
+
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor q, versor r, float t, versor dest);

include/cglm/call/vec4.h

@@ -99,7 +99,7 @@ glmc_vec4_scale(vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void
-glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
+glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
 
 CGLM_EXPORT
 void

include/cglm/cam.h

@@ -9,11 +9,11 @@
  Functions:
    CGLM_INLINE void  glm_frustum(float left,   float right,
                                  float bottom, float top,
-                                 float nearVal, float farVal,
+                                 float nearZ,  float farZ,
                                  mat4  dest)
    CGLM_INLINE void  glm_ortho(float left,   float right,
                                float bottom, float top,
-                               float nearVal, float farVal,
+                               float nearZ,  float farZ,
                                mat4  dest)
    CGLM_INLINE void  glm_ortho_aabb(vec3 box[2], mat4 dest)
    CGLM_INLINE void  glm_ortho_aabb_p(vec3 box[2],  float padding, mat4 dest)
@@ -22,8 +22,8 @@
    CGLM_INLINE void  glm_ortho_default_s(float aspect, float size, mat4 dest)
    CGLM_INLINE void  glm_perspective(float fovy,
                                      float aspect,
-                                     float nearVal,
+                                     float nearZ,
-                                     float farVal,
+                                     float farZ,
                                      mat4  dest)
    CGLM_INLINE void  glm_perspective_default(float aspect, mat4 dest)
    CGLM_INLINE void  glm_perspective_resize(float aspect, mat4 proj)
@@ -31,26 +31,61 @@
    CGLM_INLINE void  glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
    CGLM_INLINE void  glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
    CGLM_INLINE void  glm_persp_decomp(mat4   proj,
-                                      float *nearVal, float *farVal,
+                                      float *nearZ, float *farZ,
                                       float *top,   float *bottom,
                                       float *left,  float *right)
    CGLM_INLINE void  glm_persp_decompv(mat4 proj, float dest[6])
    CGLM_INLINE void  glm_persp_decomp_x(mat4 proj, float *left, float *right)
    CGLM_INLINE void  glm_persp_decomp_y(mat4 proj, float *top,  float *bottom)
    CGLM_INLINE void  glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
-   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farVal)
+   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
-   CGLM_INLINE void  glm_persp_decomp_near(mat4 proj, float *nearVal)
+   CGLM_INLINE void  glm_persp_decomp_near(mat4 proj, float *nearZ)
    CGLM_INLINE float glm_persp_fovy(mat4 proj)
    CGLM_INLINE float glm_persp_aspect(mat4 proj)
    CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
  */
 
-#ifndef cglm_vcam_h
+#ifndef cglm_cam_h
-#define cglm_vcam_h
+#define cglm_cam_h
 
 #include "common.h"
 #include "plane.h"
 
+#include "clipspace/persp.h"
+
+#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
+#  if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+#    include "clipspace/ortho_lh_zo.h"
+#    include "clipspace/persp_lh_zo.h"
+#    include "clipspace/view_lh_zo.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+#    include "clipspace/ortho_lh_no.h"
+#    include "clipspace/persp_lh_no.h"
+#    include "clipspace/view_lh_no.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+#    include "clipspace/ortho_rh_zo.h"
+#    include "clipspace/persp_rh_zo.h"
+#    include "clipspace/view_rh_zo.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+#    include "clipspace/ortho_rh_no.h"
+#    include "clipspace/persp_rh_no.h"
+#    include "clipspace/view_rh_no.h"
+#  endif
+#else
+#  include "clipspace/ortho_lh_zo.h"
+#  include "clipspace/persp_lh_zo.h"
+#  include "clipspace/ortho_lh_no.h"
+#  include "clipspace/persp_lh_no.h"
+#  include "clipspace/ortho_rh_zo.h"
+#  include "clipspace/persp_rh_zo.h"
+#  include "clipspace/ortho_rh_no.h"
+#  include "clipspace/persp_rh_no.h"
+#  include "clipspace/view_lh_zo.h"
+#  include "clipspace/view_lh_no.h"
+#  include "clipspace/view_rh_zo.h"
+#  include "clipspace/view_rh_no.h"
+#endif
+
 /*!
  * @brief set up perspective peprojection matrix
  *
@@ -58,32 +93,25 @@
  * @param[in]  right   viewport.right
  * @param[in]  bottom  viewport.bottom
  * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping plane
+ * @param[in]  farZ    far clipping plane
  * @param[out] dest    result matrix
  */
 CGLM_INLINE
 void
 glm_frustum(float left,    float right,
             float bottom,  float top,
-            float nearVal, float farVal,
+            float nearZ,   float farZ,
             mat4  dest) {
-  float rl, tb, fn, nv;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_frustum_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
-  glm_mat4_zero(dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-
+  glm_frustum_lh_no(left, right, bottom, top, nearZ, farZ, dest);
-  rl = 1.0f / (right  - left);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  tb = 1.0f / (top    - bottom);
+  glm_frustum_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
-  fn =-1.0f / (farVal - nearVal);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  nv = 2.0f * nearVal;
+  glm_frustum_rh_no(left, right, bottom, top, nearZ, farZ, dest);
-
+#endif
-  dest[0][0] = nv * rl;
-  dest[1][1] = nv * tb;
-  dest[2][0] = (right  + left)    * rl;
-  dest[2][1] = (top    + bottom)  * tb;
-  dest[2][2] = (farVal + nearVal) * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = farVal * nv * fn;
 }
 
 /*!
@@ -93,31 +121,25 @@ glm_frustum(float left,    float right,
  * @param[in]  right   viewport.right
  * @param[in]  bottom  viewport.bottom
  * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping plane
+ * @param[in]  farZ    far clipping plane
  * @param[out] dest    result matrix
  */
 CGLM_INLINE
 void
 glm_ortho(float left,    float right,
           float bottom,  float top,
-          float nearVal, float farVal,
+          float nearZ,   float farZ,
           mat4  dest) {
-  float rl, tb, fn;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_ortho_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
-  glm_mat4_zero(dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-
+  glm_ortho_lh_no(left, right, bottom, top, nearZ, farZ, dest);
-  rl = 1.0f / (right  - left);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  tb = 1.0f / (top    - bottom);
+  glm_ortho_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
-  fn =-1.0f / (farVal - nearVal);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-
+  glm_ortho_rh_no(left, right, bottom, top, nearZ, farZ, dest);
-  dest[0][0] = 2.0f * rl;
+#endif
-  dest[1][1] = 2.0f * tb;
-  dest[2][2] = 2.0f * fn;
-  dest[3][0] =-(right  + left)    * rl;
-  dest[3][1] =-(top    + bottom)  * tb;
-  dest[3][2] = (farVal + nearVal) * fn;
-  dest[3][3] = 1.0f;
 }
 
 /*!
@@ -131,10 +153,15 @@ glm_ortho(float left,    float right,
 CGLM_INLINE
 void
 glm_ortho_aabb(vec3 box[2], mat4 dest) {
-  glm_ortho(box[0][0],  box[1][0],
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-            box[0][1],  box[1][1],
+  glm_ortho_aabb_lh_zo(box, dest);
-           -box[1][2], -box[0][2],
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-            dest);
+  glm_ortho_aabb_lh_no(box, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_ortho_aabb_rh_zo(box, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_ortho_aabb_rh_no(box, dest);
+#endif
 }
 
 /*!
@@ -149,10 +176,15 @@ glm_ortho_aabb(vec3 box[2], mat4 dest) {
 CGLM_INLINE
 void
 glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho(box[0][0] - padding,    box[1][0] + padding,
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-            box[0][1] - padding,    box[1][1] + padding,
+  glm_ortho_aabb_p_lh_zo(box, padding, dest);
-          -(box[1][2] + padding), -(box[0][2] - padding),
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-            dest);
+  glm_ortho_aabb_p_lh_no(box, padding, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_ortho_aabb_p_rh_zo(box, padding, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_ortho_aabb_p_rh_no(box, padding, dest);
+#endif
 }
 
 /*!
@@ -167,10 +199,15 @@ glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
 CGLM_INLINE
 void
 glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
-  glm_ortho(box[0][0],              box[1][0],
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-            box[0][1],              box[1][1],
+  glm_ortho_aabb_pz_lh_zo(box, padding, dest);
-          -(box[1][2] + padding), -(box[0][2] - padding),
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-            dest);
+  glm_ortho_aabb_pz_lh_no(box, padding, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_ortho_aabb_pz_rh_zo(box, padding, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_ortho_aabb_pz_rh_no(box, padding, dest);
+#endif
 }
 
 /*!
@@ -182,14 +219,15 @@ glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
 CGLM_INLINE
 void
 glm_ortho_default(float aspect, mat4 dest) {
-  if (aspect >= 1.0f) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-    glm_ortho(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
+  glm_ortho_default_lh_zo(aspect, dest);
-    return;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  }
+  glm_ortho_default_lh_no(aspect, dest);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  aspect = 1.0f / aspect;
+  glm_ortho_default_rh_zo(aspect, dest);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  glm_ortho(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
+  glm_ortho_default_rh_no(aspect, dest);
+#endif
 }
 
 /*!
@@ -202,24 +240,15 @@ glm_ortho_default(float aspect, mat4 dest) {
 CGLM_INLINE
 void
 glm_ortho_default_s(float aspect, float size, mat4 dest) {
-  if (aspect >= 1.0f) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-    glm_ortho(-size * aspect,
+  glm_ortho_default_s_lh_zo(aspect, size, dest);
-               size * aspect,
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-              -size,
+  glm_ortho_default_s_lh_no(aspect, size, dest);
-               size,
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-              -size - 100.0f,
+  glm_ortho_default_s_rh_zo(aspect, size, dest);
-               size + 100.0f,
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-               dest);
+  glm_ortho_default_s_rh_no(aspect, size, dest);
-    return;
+#endif
-  }
-
-  glm_ortho(-size,
-             size,
-            -size / aspect,
-             size / aspect,
-            -size - 100.0f,
-             size + 100.0f,
-             dest);
 }
 
 /*!
@@ -227,29 +256,22 @@ glm_ortho_default_s(float aspect, float size, mat4 dest) {
  *
  * @param[in]  fovy    field of view angle
  * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping planes
+ * @param[in]  farZ    far clipping planes
  * @param[out] dest    result matrix
  */
 CGLM_INLINE
 void
-glm_perspective(float fovy,
+glm_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest) {
-                float aspect,
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-                float nearVal,
+  glm_perspective_lh_zo(fovy, aspect, nearZ, farZ, dest);
-                float farVal,
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-                mat4  dest) {
+  glm_perspective_lh_no(fovy, aspect, nearZ, farZ, dest);
-  float f, fn;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-
+  glm_perspective_rh_zo(fovy, aspect, nearZ, farZ, dest);
-  glm_mat4_zero(dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-
+  glm_perspective_rh_no(fovy, aspect, nearZ, farZ, dest);
-  f  = 1.0f / tanf(fovy * 0.5f);
+#endif
-  fn = 1.0f / (nearVal - farVal);
-
-  dest[0][0] = f / aspect;
-  dest[1][1] = f;
-  dest[2][2] = (nearVal + farVal) * fn;
-  dest[2][3] =-1.0f;
-  dest[3][2] = 2.0f * nearVal * farVal * fn;
 }
 
 /*!
@@ -263,17 +285,15 @@ glm_perspective(float fovy,
 CGLM_INLINE
 void
 glm_persp_move_far(mat4 proj, float deltaFar) {
-  float fn, farVal, nearVal, p22, p32;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_persp_move_far_lh_zo(proj, deltaFar);
-  p22        = proj[2][2];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  p32        = proj[3][2];
+  glm_persp_move_far_lh_no(proj, deltaFar);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  nearVal    = p32 / (p22 - 1.0f);
+  glm_persp_move_far_rh_zo(proj, deltaFar);
-  farVal     = p32 / (p22 + 1.0f) + deltaFar;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  fn         = 1.0f / (nearVal - farVal);
+  glm_persp_move_far_rh_no(proj, deltaFar);
-
+#endif
-  proj[2][2] = (nearVal + farVal) * fn;
-  proj[3][2] = 2.0f * nearVal * farVal * fn;
 }
 
 /*!
@@ -286,7 +306,15 @@ glm_persp_move_far(mat4 proj, float deltaFar) {
 CGLM_INLINE
 void
 glm_perspective_default(float aspect, mat4 dest) {
-  glm_perspective(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glm_perspective_default_lh_zo(aspect, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glm_perspective_default_lh_no(aspect, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_perspective_default_rh_zo(aspect, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_perspective_default_rh_no(aspect, dest);
+#endif
 }
 
 /*!
@@ -320,28 +348,11 @@ glm_perspective_resize(float aspect, mat4 proj) {
 CGLM_INLINE
 void
 glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 f, u, s;
+#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-
+  glm_lookat_lh(eye, center, up, dest);
-  glm_vec3_sub(center, eye, f);
+#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
-  glm_vec3_normalize(f);
+  glm_lookat_rh(eye, center, up, dest);
-
+#endif
-  glm_vec3_crossn(f, up, s);
-  glm_vec3_cross(s, f, u);
-
-  dest[0][0] = s[0];
-  dest[0][1] = u[0];
-  dest[0][2] =-f[0];
-  dest[1][0] = s[1];
-  dest[1][1] = u[1];
-  dest[1][2] =-f[1];
-  dest[2][0] = s[2];
-  dest[2][1] = u[2];
-  dest[2][2] =-f[2];
-  dest[3][0] =-glm_vec3_dot(s, eye);
-  dest[3][1] =-glm_vec3_dot(u, eye);
-  dest[3][2] = glm_vec3_dot(f, eye);
-  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
-  dest[3][3] = 1.0f;
 }
 
 /*!
@@ -361,9 +372,11 @@ glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
 CGLM_INLINE
 void
 glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
-  CGLM_ALIGN(8) vec3 target;
+#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-  glm_vec3_add(eye, dir, target);
+  glm_look_lh(eye, dir, up, dest);
-  glm_lookat(eye, target, up, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
+  glm_look_rh(eye, dir, up, dest);
+#endif
 }
 
 /*!
@@ -379,17 +392,19 @@ glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
 CGLM_INLINE
 void
 glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
-  CGLM_ALIGN(8) vec3 up;
+#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
-  glm_vec3_ortho(dir, up);
+  glm_look_anyup_lh(eye, dir, dest);
-  glm_look(eye, dir, up, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
+  glm_look_anyup_rh(eye, dir, dest);
+#endif
 }
 
 /*!
  * @brief decomposes frustum values of perspective projection.
  *
  * @param[in]  proj    perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ   near
- * @param[out] farVal  far
+ * @param[out] farZ    far
  * @param[out] top     top
  * @param[out] bottom  bottom
  * @param[out] left    left
@@ -398,31 +413,18 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
 CGLM_INLINE
 void
 glm_persp_decomp(mat4 proj,
-                 float * __restrict nearVal, float * __restrict farVal,
+                 float * __restrict nearZ, float * __restrict farZ,
                  float * __restrict top,   float * __restrict bottom,
                  float * __restrict left,  float * __restrict right) {
-  float m00, m11, m20, m21, m22, m32, n, f;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  float n_m11, n_m00;
+  glm_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  m00 = proj[0][0];
+  glm_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
-  m11 = proj[1][1];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  m20 = proj[2][0];
+  glm_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
-  m21 = proj[2][1];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  m22 = proj[2][2];
+  glm_persp_decomp_rh_no(proj, nearZ, farZ, top, bottom, left, right);
-  m32 = proj[3][2];
+#endif
-
-  n = m32 / (m22 - 1.0f);
-  f = m32 / (m22 + 1.0f);
-
-  n_m11 = n / m11;
-  n_m00 = n / m00;
-
-  *nearVal = n;
-  *farVal  = f;
-  *bottom  = n_m11 * (m21 - 1.0f);
-  *top     = n_m11 * (m21 + 1.0f);
-  *left    = n_m00 * (m20 - 1.0f);
-  *right   = n_m00 * (m20 + 1.0f);
 }
 
 /*!
@@ -435,8 +437,15 @@ glm_persp_decomp(mat4 proj,
 CGLM_INLINE
 void
 glm_persp_decompv(mat4 proj, float dest[6]) {
-  glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-                         &dest[3], &dest[4], &dest[5]);
+  glm_persp_decompv_lh_zo(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glm_persp_decompv_lh_no(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_persp_decompv_rh_zo(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_persp_decompv_rh_no(proj, dest);
+#endif
 }
 
 /*!
@@ -452,14 +461,15 @@ void
 glm_persp_decomp_x(mat4 proj,
                    float * __restrict left,
                    float * __restrict right) {
-  float nearVal, m20, m00;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_persp_decomp_x_lh_zo(proj, left, right);
-  m00 = proj[0][0];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  m20 = proj[2][0];
+  glm_persp_decomp_x_lh_no(proj, left, right);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  nearVal = proj[3][2] / (proj[3][3] - 1.0f);
+  glm_persp_decomp_x_rh_zo(proj, left, right);
-  *left   = nearVal * (m20 - 1.0f) / m00;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  *right  = nearVal * (m20 + 1.0f) / m00;
+  glm_persp_decomp_x_rh_no(proj, left, right);
+#endif
 }
 
 /*!
@@ -475,14 +485,15 @@ void
 glm_persp_decomp_y(mat4 proj,
                    float * __restrict top,
                    float * __restrict bottom) {
-  float nearVal, m21, m11;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_persp_decomp_y_lh_zo(proj, top, bottom);
-  m21 = proj[2][1];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  m11 = proj[1][1];
+  glm_persp_decomp_y_lh_no(proj, top, bottom);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  nearVal = proj[3][2] / (proj[3][3] - 1.0f);
+  glm_persp_decomp_y_rh_zo(proj, top, bottom);
-  *bottom = nearVal * (m21 - 1) / m11;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  *top    = nearVal * (m21 + 1) / m11;
+  glm_persp_decomp_y_rh_no(proj, top, bottom);
+#endif
 }
 
 /*!
@@ -490,70 +501,61 @@ glm_persp_decomp_y(mat4 proj,
  *        z stands for z axis (near / far axis)
  *
  * @param[in]  proj    perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ   near
- * @param[out] farVal  far
+ * @param[out] farZ    far
  */
 CGLM_INLINE
 void
-glm_persp_decomp_z(mat4 proj,
+glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
-                   float * __restrict nearVal,
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-                   float * __restrict farVal) {
+  glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
-  float m32, m22;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-
+  glm_persp_decomp_z_lh_no(proj, nearZ, farZ);
-  m32 = proj[3][2];
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  m22 = proj[2][2];
+  glm_persp_decomp_z_rh_zo(proj, nearZ, farZ);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  *nearVal = m32 / (m22 - 1.0f);
+  glm_persp_decomp_z_rh_no(proj, nearZ, farZ);
-  *farVal  = m32 / (m22 + 1.0f);
+#endif
 }
 
 /*!
  * @brief decomposes far value of perspective projection.
  *
  * @param[in]  proj   perspective projection matrix
- * @param[out] farVal far
+ * @param[out] farZ   far
  */
 CGLM_INLINE
 void
-glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
-  *farVal = proj[3][2] / (proj[2][2] + 1.0f);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glm_persp_decomp_far_lh_zo(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glm_persp_decomp_far_lh_no(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glm_persp_decomp_far_rh_zo(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glm_persp_decomp_far_rh_no(proj, farZ);
+#endif
 }
 
 /*!
  * @brief decomposes near value of perspective projection.
  *
  * @param[in]  proj   perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ  near
  */
 CGLM_INLINE
 void
-glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
-  *nearVal = proj[3][2] / (proj[2][2] - 1.0f);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-}
+  glm_persp_decomp_near_lh_zo(proj, nearZ);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-/*!
+  glm_persp_decomp_near_lh_no(proj, nearZ);
- * @brief returns field of view angle along the Y-axis (in radians)
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
- *
+  glm_persp_decomp_near_rh_zo(proj, nearZ);
- * if you need to degrees, use glm_deg to convert it or use this:
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
- * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+  glm_persp_decomp_near_rh_no(proj, nearZ);
- *
+#endif
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_fovy(mat4 proj) {
-  return 2.0f * atanf(1.0f / proj[1][1]);
-}
-
-/*!
- * @brief returns aspect ratio of perspective projection
- *
- * @param[in] proj perspective projection matrix
- */
-CGLM_INLINE
-float
-glm_persp_aspect(mat4 proj) {
-  return proj[1][1] / proj[0][0];
 }
 
 /*!
@@ -566,17 +568,15 @@ glm_persp_aspect(mat4 proj) {
 CGLM_INLINE
 void
 glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
-  float t, a, nearVal, farVal;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-
+  glm_persp_sizes_lh_zo(proj, fovy, dest);
-  t = 2.0f * tanf(fovy * 0.5f);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  a = glm_persp_aspect(proj);
+  glm_persp_sizes_lh_no(proj, fovy, dest);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-  glm_persp_decomp_z(proj, &nearVal, &farVal);
+  glm_persp_sizes_rh_zo(proj, fovy, dest);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
-  dest[1]  = t * nearVal;
+  glm_persp_sizes_rh_no(proj, fovy, dest);
-  dest[3]  = t * farVal;
+#endif
-  dest[0]  = a * dest[1];
-  dest[2]  = a * dest[3];
 }
 
-#endif /* cglm_vcam_h */
+#endif /* cglm_cam_h */

include/cglm/clipspace/ortho_lh_no.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_ortho_lh_no(float left,    float right,
+                                    float bottom,  float top,
+                                    float nearZ, float farZ,
+                                    mat4  dest)
+   CGLM_INLINE void glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_lh_no(vec3 box[2],
+                                           float padding,
+                                           mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_pz_lh_no(vec3 box[2],
+                                            float padding,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_lh_no(float aspect,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_s_lh_no(float aspect,
+                                              float size,
+                                              mat4 dest)
+ */
+
+#ifndef cglm_ortho_lh_no_h
+#define cglm_ortho_lh_no_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_lh_no(float left,    float right,
+                float bottom,  float top,
+                float nearZ, float farZ,
+                mat4  dest) {
+  float rl, tb, fn;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+
+  dest[0][0] = 2.0f * rl;
+  dest[1][1] = 2.0f * tb;
+  dest[2][2] =-2.0f * fn;
+  dest[3][0] =-(right  + left)    * rl;
+  dest[3][1] =-(top    + bottom)  * tb;
+  dest[3][2] = (farZ + nearZ) * fn;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @param[out] dest  result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
+  glm_ortho_lh_no(box[0][0],  box[1][0],
+                  box[0][1],  box[1][1],
+                 -box[1][2], -box[0][2],
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_lh_no(box[0][0] - padding,    box[1][0] + padding,
+                  box[0][1] - padding,    box[1][1] + padding,
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_lh_no(box[0][0],              box[1][0],
+                  box[0][1],              box[1][1],
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_lh_no(float aspect, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_lh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
+    return;
+  }
+
+  aspect = 1.0f / aspect;
+
+  glm_ortho_lh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_s_lh_no(float aspect, float size, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_lh_no(-size * aspect,
+                     size * aspect,
+                    -size,
+                     size,
+                    -size - 100.0f,
+                     size + 100.0f,
+                     dest);
+    return;
+  }
+
+  glm_ortho_lh_no(-size,
+                   size,
+                  -size / aspect,
+                   size / aspect,
+                  -size - 100.0f,
+                   size + 100.0f,
+                   dest);
+}
+
+#endif /*cglm_ortho_lh_no_h*/

include/cglm/clipspace/ortho_lh_zo.h

@@ -0,0 +1,176 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_ortho_lh_zo(float left,    float right,
+                                    float bottom,  float top,
+                                    float nearZ, float farZ,
+                                    mat4  dest)
+   CGLM_INLINE void glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_lh_zo(vec3 box[2],
+                                           float padding,
+                                           mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(vec3 box[2],
+                                            float padding,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_lh_zo(float aspect,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_s_lh_zo(float aspect,
+                                              float size,
+                                              mat4 dest)
+ */
+
+#ifndef cglm_ortho_lh_zo_h
+#define cglm_ortho_lh_zo_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up orthographic projection matrix with a left-hand coordinate
+ *        system and a clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_lh_zo(float left,    float right,
+                float bottom,  float top,
+                float nearZ, float farZ,
+                mat4  dest) {
+  float rl, tb, fn;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+
+  dest[0][0] = 2.0f * rl;
+  dest[1][1] = 2.0f * tb;
+  dest[2][2] =-fn;
+  dest[3][0] =-(right  + left)    * rl;
+  dest[3][1] =-(top    + bottom)  * tb;
+  dest[3][2] = nearZ * fn;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @param[out] dest  result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
+  glm_ortho_lh_zo(box[0][0],  box[1][0],
+                  box[0][1],  box[1][1],
+                 -box[1][2], -box[0][2],
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_lh_zo(box[0][0] - padding,    box[1][0] + padding,
+                  box[0][1] - padding,    box[1][1] + padding,
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_lh_zo(box[0][0],              box[1][0],
+                  box[0][1],              box[1][1],
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_lh_zo(float aspect, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_lh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
+    return;
+  }
+
+  aspect = 1.0f / aspect;
+
+  glm_ortho_lh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_s_lh_zo(float aspect, float size, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_lh_zo(-size * aspect,
+                     size * aspect,
+                    -size,
+                     size,
+                    -size - 100.0f,
+                     size + 100.0f,
+                     dest);
+    return;
+  }
+
+  glm_ortho_lh_zo(-size,
+                   size,
+                  -size / aspect,
+                   size / aspect,
+                  -size - 100.0f,
+                   size + 100.0f,
+                   dest);
+}
+
+#endif /*cglm_ortho_lh_zo_h*/

include/cglm/clipspace/ortho_rh_no.h

@@ -0,0 +1,182 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_ortho_rh_no(float left,    float right,
+                                    float bottom,  float top,
+                                    float nearZ, float farZ,
+                                    mat4  dest)
+   CGLM_INLINE void glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_rh_no(vec3 box[2],
+                                           float padding,
+                                           mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_pz_rh_no(vec3 box[2],
+                                            float padding,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_rh_no(float aspect,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_s_rh_no(float aspect,
+                                              float size,
+                                              mat4 dest)
+ */
+
+#ifndef cglm_ortho_rh_no_h
+#define cglm_ortho_rh_no_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_rh_no(float left,    float right,
+                float bottom,  float top,
+                float nearZ, float farZ,
+                mat4  dest) {
+  float rl, tb, fn;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+
+  dest[0][0] = 2.0f * rl;
+  dest[1][1] = 2.0f * tb;
+  dest[2][2] = 2.0f * fn;
+  dest[3][0] =-(right  + left)    * rl;
+  dest[3][1] =-(top    + bottom)  * tb;
+  dest[3][2] = (farZ + nearZ) * fn;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @param[out] dest  result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
+  glm_ortho_rh_no(box[0][0],  box[1][0],
+                  box[0][1],  box[1][1],
+                 -box[1][2], -box[0][2],
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_rh_no(box[0][0] - padding,    box[1][0] + padding,
+                  box[0][1] - padding,    box[1][1] + padding,
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_rh_no(box[0][0],              box[1][0],
+                  box[0][1],              box[1][1],
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_rh_no(float aspect, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_rh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
+    return;
+  }
+
+  aspect = 1.0f / aspect;
+
+  glm_ortho_rh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_s_rh_no(float aspect, float size, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_rh_no(-size * aspect,
+                     size * aspect,
+                    -size,
+                     size,
+                    -size - 100.0f,
+                     size + 100.0f,
+                     dest);
+    return;
+  }
+
+  glm_ortho_rh_no(-size,
+                   size,
+                  -size / aspect,
+                   size / aspect,
+                  -size - 100.0f,
+                   size + 100.0f,
+                   dest);
+}
+
+#endif /*cglm_ortho_rh_no_h*/

include/cglm/clipspace/ortho_rh_zo.h

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_ortho_rh_zo(float left,    float right,
+                                    float bottom,  float top,
+                                    float nearZ, float farZ,
+                                    mat4  dest)
+   CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
+                                           float padding,
+                                           mat4 dest)
+   CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
+                                            float padding,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
+                                            mat4 dest)
+   CGLM_INLINE void glm_ortho_default_s_rh_zo(float aspect,
+                                              float size,
+                                              mat4 dest)
+ */
+
+#ifndef cglm_ortho_rh_zo_h
+#define cglm_ortho_rh_zo_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up orthographic projection matrix with a right-hand coordinate
+ *        system and a clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_rh_zo(float left,    float right,
+                float bottom,  float top,
+                float nearZ, float farZ,
+                mat4  dest) {
+  float rl, tb, fn;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+
+  dest[0][0] = 2.0f * rl;
+  dest[1][1] = 2.0f * tb;
+  dest[2][2] = fn;
+  dest[3][0] =-(right  + left)    * rl;
+  dest[3][1] =-(top    + bottom)  * tb;
+  dest[3][2] = nearZ * fn;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a clip-space with depth
+ *        values from zero to one.
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @param[out] dest  result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
+  glm_ortho_rh_zo(box[0][0],  box[1][0],
+                  box[0][1],  box[1][1],
+                 -box[1][2], -box[0][2],
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a clip-space with depth
+ *        values from zero to one.
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_rh_zo(box[0][0] - padding,    box[1][0] + padding,
+                  box[0][1] - padding,    box[1][1] + padding,
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a clip-space with depth
+ *        values from zero to one.
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_rh_zo(box[0][0],              box[1][0],
+                  box[0][1],              box[1][1],
+                -(box[1][2] + padding), -(box[0][2] - padding),
+                  dest);
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix with a right-hand
+ *        coordinate system and a clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_rh_zo(float aspect, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_rh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
+    return;
+  }
+
+  aspect = 1.0f / aspect;
+
+  glm_ortho_rh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a right-hand coordinate system and a clip-space with depth
+ *        values from zero to one.
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_ortho_default_s_rh_zo(float aspect, float size, mat4 dest) {
+  if (aspect >= 1.0f) {
+    glm_ortho_rh_zo(-size * aspect,
+                     size * aspect,
+                    -size,
+                     size,
+                    -size - 100.0f,
+                     size + 100.0f,
+                     dest);
+    return;
+  }
+
+  glm_ortho_rh_zo(-size,
+                   size,
+                  -size / aspect,
+                   size / aspect,
+                  -size - 100.0f,
+                   size + 100.0f,
+                   dest);
+}
+
+#endif /*cglm_ortho_rh_zo_h*/

include/cglm/clipspace/persp.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void  glm_persp_decomp_far(mat4 proj, float *farZ)
+   CGLM_INLINE float glm_persp_fovy(mat4 proj)
+   CGLM_INLINE float glm_persp_aspect(mat4 proj)
+   CGLM_INLINE void  glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
+ */
+
+#ifndef cglm_persp_h
+#define cglm_persp_h
+
+#include "../common.h"
+#include "../plane.h"
+#include "../mat4.h"
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_fovy(mat4 proj) {
+  return 2.0f * atanf(1.0f / proj[1][1]);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_aspect(mat4 proj) {
+  return proj[1][1] / proj[0][0];
+}
+
+#endif /* cglm_persp_h */

include/cglm/clipspace/persp_lh_no.h

@@ -0,0 +1,396 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_frustum_lh_no(float left,    float right,
+                                       float bottom,  float top,
+                                       float nearZ, float farZ,
+                                       mat4  dest)
+   CGLM_INLINE void glm_perspective_lh_no(float fovy,
+                                          float aspect,
+                                          float nearZ,
+                                          float farZ,
+                                          mat4  dest)
+   CGLM_INLINE void glm_perspective_default_lh_no(float aspect, mat4 dest)
+   CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
+   CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
+                                             float deltaFar)
+   CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
+                                           float * __restrict nearZ,
+                                           float * __restrict farZ,
+                                           float * __restrict top,
+                                           float * __restrict bottom,
+                                           float * __restrict left,
+                                           float * __restrict right)
+  CGLM_INLINE void glm_persp_decompv_lh_no(mat4 proj,
+                                           float dest[6])
+  CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
+                                            float * __restrict left,
+                                            float * __restrict right)
+  CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
+                                            float * __restrict top,
+                                            float * __restrict bottom)
+  CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
+                                            float * __restrict nearZ,
+                                            float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
+ */
+
+#ifndef cglm_persp_lh_no_h
+#define cglm_persp_lh_no_h
+
+#include "../common.h"
+#include "../plane.h"
+#include "persp.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_frustum_lh_no(float left,    float right,
+                  float bottom,  float top,
+                  float nearZ, float farZ,
+                  mat4  dest) {
+  float rl, tb, fn, nv;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+  nv = 2.0f * nearZ;
+
+  dest[0][0] = nv * rl;
+  dest[1][1] = nv * tb;
+  dest[2][0] = (right  + left)    * rl;
+  dest[2][1] = (top    + bottom)  * tb;
+  dest[2][2] =-(farZ + nearZ) * fn;
+  dest[2][3] = 1.0f;
+  dest[3][2] = farZ * nv * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_lh_no(float fovy,
+                      float aspect,
+                      float nearZ,
+                      float farZ,
+                      mat4  dest) {
+  float f, fn;
+
+  glm_mat4_zero(dest);
+
+  f  = 1.0f / tanf(fovy * 0.5f);
+  fn = 1.0f / (nearZ - farZ);
+
+  dest[0][0] = f / aspect;
+  dest[1][1] = f;
+  dest[2][2] =-(nearZ + farZ) * fn;
+  dest[2][3] = 1.0f;
+  dest[3][2] = 2.0f * nearZ * farZ * fn;
+
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_default_lh_no(float aspect, mat4 dest) {
+  glm_perspective_lh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        resized with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]      aspect aspect ratio ( width / height )
+ * @param[in, out] proj   perspective projection matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_resize_lh_no(float aspect, mat4 proj) {
+  if (proj[0][0] == 0.0f)
+    return;
+
+  proj[0][0] = proj[1][1] / aspect;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
+  float fn, farZ, nearZ, p22, p32;
+
+  p22        = -proj[2][2];
+  p32        = proj[3][2];
+
+  nearZ    = p32 / (p22 - 1.0f);
+  farZ     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearZ - farZ);
+
+  proj[2][2] = -(farZ + nearZ) * fn;
+  proj[3][2] = 2.0f * nearZ * farZ * fn;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_lh_no(mat4 proj,
+                       float * __restrict nearZ, float * __restrict farZ,
+                       float * __restrict top,   float * __restrict bottom,
+                       float * __restrict left,  float * __restrict right) {
+  float m00, m11, m20, m21, m22, m32, n, f;
+  float n_m11, n_m00;
+
+  m00 = proj[0][0];
+  m11 = proj[1][1];
+  m20 = proj[2][0];
+  m21 = proj[2][1];
+  m22 =-proj[2][2];
+  m32 = proj[3][2];
+
+  n = m32 / (m22 - 1.0f);
+  f = m32 / (m22 + 1.0f);
+
+  n_m11 = n / m11;
+  n_m00 = n / m00;
+
+  *nearZ = n;
+  *farZ  = f;
+  *bottom  = n_m11 * (m21 - 1.0f);
+  *top     = n_m11 * (m21 + 1.0f);
+  *left    = n_m00 * (m20 - 1.0f);
+  *right   = n_m00 * (m20 + 1.0f);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
+  glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
+                               &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x_lh_no(mat4 proj,
+                         float * __restrict left,
+                         float * __restrict right) {
+  float nearZ, m20, m00, m22;
+
+  m00 = proj[0][0];
+  m20 = proj[2][0];
+  m22 =-proj[2][2];
+
+  nearZ = proj[3][2] / (m22 - 1.0f);
+  *left   = nearZ * (m20 - 1.0f) / m00;
+  *right  = nearZ * (m20 + 1.0f) / m00;
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y_lh_no(mat4 proj,
+                         float * __restrict top,
+                         float * __restrict bottom) {
+  float nearZ, m21, m11, m22;
+
+  m21 = proj[2][1];
+  m11 = proj[1][1];
+  m22 =-proj[2][2];
+
+  nearZ = proj[3][2] / (m22 - 1.0f);
+  *bottom = nearZ * (m21 - 1.0f) / m11;
+  *top    = nearZ * (m21 + 1.0f) / m11;
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z_lh_no(mat4 proj,
+                         float * __restrict nearZ,
+                         float * __restrict farZ) {
+  float m32, m22;
+
+  m32 = proj[3][2];
+  m22 =-proj[2][2];
+
+  *nearZ = m32 / (m22 - 1.0f);
+  *farZ  = m32 / (m22 + 1.0f);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
+  *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
+  *nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+void
+glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
+  float t, a, nearZ, farZ;
+
+  t = 2.0f * tanf(fovy * 0.5f);
+  a = glm_persp_aspect(proj);
+
+  glm_persp_decomp_z_lh_no(proj, &nearZ, &farZ);
+
+  dest[1]  = t * nearZ;
+  dest[3]  = t * farZ;
+  dest[0]  = a * dest[1];
+  dest[2]  = a * dest[3];
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a left-hand coordinate system and a clip-space of [-1, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_fovy_lh_no(mat4 proj) {
+  return glm_persp_fovy(proj);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a left-hand coordinate system and a clip-space of [-1, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_aspect_lh_no(mat4 proj) {
+  return glm_persp_aspect(proj);
+}
+
+#endif /*cglm_cam_lh_no_h*/

include/cglm/clipspace/persp_lh_zo.h

@@ -0,0 +1,388 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_frustum_lh_zo(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ, float farZ,
+                                      mat4  dest)
+   CGLM_INLINE void glm_perspective_lh_zo(float fovy,
+                                          float aspect,
+                                          float nearZ,
+                                          float farZ,
+                                          mat4  dest)
+   CGLM_INLINE void glm_perspective_default_lh_zo(float aspect, mat4 dest)
+   CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
+   CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
+                                             float deltaFar)
+   CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
+                                           float * __restrict nearZ,
+                                           float * __restrict farZ,
+                                           float * __restrict top,
+                                           float * __restrict bottom,
+                                           float * __restrict left,
+                                           float * __restrict right)
+  CGLM_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
+                                           float dest[6])
+  CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
+                                            float * __restrict left,
+                                            float * __restrict right)
+  CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
+                                            float * __restrict top,
+                                            float * __restrict bottom)
+  CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
+                                            float * __restrict nearZ,
+                                            float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
+ */
+
+#ifndef cglm_persp_lh_zo_h
+#define cglm_persp_lh_zo_h
+
+#include "../common.h"
+#include "../plane.h"
+#include "persp.h"
+
+/*!
+ * @brief set up perspective peprojection matrix with a left-hand coordinate
+ *        system and a clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_frustum_lh_zo(float left,    float right,
+                  float bottom,  float top,
+                  float nearZ, float farZ,
+                  mat4  dest) {
+  float rl, tb, fn, nv;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+  nv = 2.0f * nearZ;
+
+  dest[0][0] = nv * rl;
+  dest[1][1] = nv * tb;
+  dest[2][0] = (right  + left)    * rl;
+  dest[2][1] = (top    + bottom)  * tb;
+  dest[2][2] =-farZ * fn;
+  dest[2][3] = 1.0f;
+  dest[3][2] = farZ * nearZ * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix with a left-hand coordinate
+ * system and a clip-space of [0, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_lh_zo(float fovy,
+                      float aspect,
+                      float nearZ,
+                      float farZ,
+                      mat4  dest) {
+  float f, fn;
+
+  glm_mat4_zero(dest);
+
+  f  = 1.0f / tanf(fovy * 0.5f);
+  fn = 1.0f / (nearZ - farZ);
+
+  dest[0][0] = f / aspect;
+  dest[1][1] = f;
+  dest[2][2] =-farZ * fn;
+  dest[2][3] = 1.0f;
+  dest[3][2] = nearZ * farZ * fn;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance with a
+ *        left-hand coordinate system and a clip-space with depth values
+ *        from zero to one.
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glm_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
+  float fn, farZ, nearZ, p22, p32;
+
+  p22        = -proj[2][2];
+  p32        = proj[3][2];
+
+  nearZ    = p32 / p22;
+  farZ     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearZ - farZ);
+
+  proj[2][2] = -farZ * fn;
+  proj[3][2] = nearZ * farZ * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_default_lh_zo(float aspect, mat4 dest) {
+  glm_perspective_lh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized
+ *
+ * @param[in]      aspect aspect ratio ( width / height )
+ * @param[in, out] proj   perspective projection matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
+  if (proj[0][0] == 0.0f)
+    return;
+
+  proj[0][0] = proj[1][1] / aspect;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_lh_zo(mat4 proj,
+                    float * __restrict nearZ, float * __restrict farZ,
+                    float * __restrict top,     float * __restrict bottom,
+                    float * __restrict left,    float * __restrict right) {
+  float m00, m11, m20, m21, m22, m32, n, f;
+  float n_m11, n_m00;
+
+  m00 = proj[0][0];
+  m11 = proj[1][1];
+  m20 = proj[2][0];
+  m21 = proj[2][1];
+  m22 =-proj[2][2];
+  m32 = proj[3][2];
+
+  n = m32 / m22;
+  f = m32 / (m22 + 1.0f);
+
+  n_m11 = n / m11;
+  n_m00 = n / m00;
+
+  *nearZ = n;
+  *farZ  = f;
+  *bottom  = n_m11 * (m21 - 1.0f);
+  *top     = n_m11 * (m21 + 1.0f);
+  *left    = n_m00 * (m20 - 1.0f);
+  *right   = n_m00 * (m20 + 1.0f);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
+  glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
+                               &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection (ZO).
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x_lh_zo(mat4 proj,
+                         float * __restrict left,
+                         float * __restrict right) {
+  float nearZ, m20, m00;
+
+  m00 = proj[0][0];
+  m20 = proj[2][0];
+
+  nearZ = proj[3][2] / (proj[3][3]);
+  *left   = nearZ * (m20 - 1.0f) / m00;
+  *right  = nearZ * (m20 + 1.0f) / m00;
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        y stands for y axis (top / bottom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y_lh_zo(mat4 proj,
+                         float * __restrict top,
+                         float * __restrict bottom) {
+  float nearZ, m21, m11;
+
+  m21 = proj[2][1];
+  m11 = proj[1][1];
+
+  nearZ = proj[3][2] / (proj[3][3]);
+  *bottom = nearZ * (m21 - 1) / m11;
+  *top    = nearZ * (m21 + 1) / m11;
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z_lh_zo(mat4 proj,
+                         float * __restrict nearZ,
+                         float * __restrict farZ) {
+  float m32, m22;
+
+  m32 = proj[3][2];
+  m22 = -proj[2][2];
+
+  *nearZ = m32 / m22;
+  *farZ  = m32 / (m22 + 1.0f);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
+  *farZ = proj[3][2] / (-proj[2][2] + 1.0f);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with angle values with a left-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
+  *nearZ = proj[3][2] / -proj[2][2];
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+void
+glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
+  float t, a, nearZ, farZ;
+
+  t = 2.0f * tanf(fovy * 0.5f);
+  a = glm_persp_aspect(proj);
+
+  glm_persp_decomp_z_lh_zo(proj, &nearZ, &farZ);
+
+  dest[1]  = t * nearZ;
+  dest[3]  = t * farZ;
+  dest[0]  = a * dest[1];
+  dest[2]  = a * dest[3];
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_fovy_lh_zo(mat4 proj) {
+  return glm_persp_fovy(proj);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a left-hand coordinate system and a clip-space of [0, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_aspect_lh_zo(mat4 proj) {
+  return glm_persp_aspect(proj);
+}
+
+#endif /*cglm_persp_lh_zo_h*/

include/cglm/clipspace/persp_rh_no.h

@@ -0,0 +1,396 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_frustum_rh_no(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ, float farZ,
+                                      mat4  dest)
+   CGLM_INLINE void glm_perspective_rh_no(float fovy,
+                                          float aspect,
+                                          float nearZ,
+                                          float farZ,
+                                          mat4  dest)
+   CGLM_INLINE void glm_perspective_default_rh_no(float aspect, mat4 dest)
+   CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
+   CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
+                                             float deltaFar)
+   CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
+                                           float * __restrict nearZ,
+                                           float * __restrict farZ,
+                                           float * __restrict top,
+                                           float * __restrict bottom,
+                                           float * __restrict left,
+                                           float * __restrict right)
+  CGLM_INLINE void glm_persp_decompv_rh_no(mat4 proj,
+                                           float dest[6])
+  CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
+                                            float * __restrict left,
+                                            float * __restrict right)
+  CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
+                                            float * __restrict top,
+                                            float * __restrict bottom)
+  CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
+                                            float * __restrict nearZ,
+                                            float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
+ */
+
+#ifndef cglm_persp_rh_no_h
+#define cglm_persp_rh_no_h
+
+#include "../common.h"
+#include "../plane.h"
+#include "persp.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_frustum_rh_no(float left,    float right,
+                  float bottom,  float top,
+                  float nearZ, float farZ,
+                  mat4  dest) {
+  float rl, tb, fn, nv;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+  nv = 2.0f * nearZ;
+
+  dest[0][0] = nv * rl;
+  dest[1][1] = nv * tb;
+  dest[2][0] = (right  + left)    * rl;
+  dest[2][1] = (top    + bottom)  * tb;
+  dest[2][2] = (farZ + nearZ) * fn;
+  dest[2][3] =-1.0f;
+  dest[3][2] = farZ * nv * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_rh_no(float fovy,
+                      float aspect,
+                      float nearZ,
+                      float farZ,
+                      mat4  dest) {
+  float f, fn;
+
+  glm_mat4_zero(dest);
+
+  f  = 1.0f / tanf(fovy * 0.5f);
+  fn = 1.0f / (nearZ - farZ);
+
+  dest[0][0] = f / aspect;
+  dest[1][1] = f;
+  dest[2][2] = (nearZ + farZ) * fn;
+  dest[2][3] =-1.0f;
+  dest[3][2] = 2.0f * nearZ * farZ * fn;
+
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_default_rh_no(float aspect, mat4 dest) {
+  glm_perspective_rh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        resized with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]      aspect aspect ratio ( width / height )
+ * @param[in, out] proj   perspective projection matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_resize_rh_no(float aspect, mat4 proj) {
+  if (proj[0][0] == 0.0f)
+    return;
+
+  proj[0][0] = proj[1][1] / aspect;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
+  float fn, farZ, nearZ, p22, p32;
+
+  p22        = proj[2][2];
+  p32        = proj[3][2];
+
+  nearZ    = p32 / (p22 - 1.0f);
+  farZ     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearZ - farZ);
+
+  proj[2][2] = (farZ + nearZ) * fn;
+  proj[3][2] = 2.0f * nearZ * farZ * fn;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_rh_no(mat4 proj,
+                       float * __restrict nearZ, float * __restrict farZ,
+                       float * __restrict top,     float * __restrict bottom,
+                       float * __restrict left,    float * __restrict right) {
+  float m00, m11, m20, m21, m22, m32, n, f;
+  float n_m11, n_m00;
+
+  m00 = proj[0][0];
+  m11 = proj[1][1];
+  m20 = proj[2][0];
+  m21 = proj[2][1];
+  m22 = proj[2][2];
+  m32 = proj[3][2];
+
+  n = m32 / (m22 - 1.0f);
+  f = m32 / (m22 + 1.0f);
+
+  n_m11 = n / m11;
+  n_m00 = n / m00;
+
+  *nearZ = n;
+  *farZ  = f;
+  *bottom  = n_m11 * (m21 - 1.0f);
+  *top     = n_m11 * (m21 + 1.0f);
+  *left    = n_m00 * (m20 - 1.0f);
+  *right   = n_m00 * (m20 + 1.0f);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
+  glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
+                               &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x_rh_no(mat4 proj,
+                         float * __restrict left,
+                         float * __restrict right) {
+  float nearZ, m20, m00, m22;
+
+  m00 = proj[0][0];
+  m20 = proj[2][0];
+  m22 = proj[2][2];
+
+  nearZ = proj[3][2] / (m22 - 1.0f);
+  *left   = nearZ * (m20 - 1.0f) / m00;
+  *right  = nearZ * (m20 + 1.0f) / m00;
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y_rh_no(mat4 proj,
+                         float * __restrict top,
+                         float * __restrict bottom) {
+  float nearZ, m21, m11, m22;
+
+  m21 = proj[2][1];
+  m11 = proj[1][1];
+  m22 = proj[2][2];
+
+  nearZ = proj[3][2] / (m22 - 1.0f);
+  *bottom = nearZ * (m21 - 1.0f) / m11;
+  *top    = nearZ * (m21 + 1.0f) / m11;
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z_rh_no(mat4 proj,
+                      float * __restrict nearZ,
+                      float * __restrict farZ) {
+  float m32, m22;
+
+  m32 = proj[3][2];
+  m22 = proj[2][2];
+
+  *nearZ = m32 / (m22 - 1.0f);
+  *farZ  = m32 / (m22 + 1.0f);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
+  *farZ = proj[3][2] / (proj[2][2] + 1.0f);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
+  *nearZ = proj[3][2] / (proj[2][2] - 1.0f);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+void
+glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
+  float t, a, nearZ, farZ;
+
+  t = 2.0f * tanf(fovy * 0.5f);
+  a = glm_persp_aspect(proj);
+
+  glm_persp_decomp_z_rh_no(proj, &nearZ, &farZ);
+
+  dest[1]  = t * nearZ;
+  dest[3]  = t * farZ;
+  dest[0]  = a * dest[1];
+  dest[2]  = a * dest[3];
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a right-hand coordinate system and a clip-space of [-1, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_fovy_rh_no(mat4 proj) {
+  return glm_persp_fovy(proj);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a right-hand coordinate system and a clip-space of [-1, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_aspect_rh_no(mat4 proj) {
+  return glm_persp_aspect(proj);
+}
+
+#endif /*cglm_cam_rh_no_h*/

include/cglm/clipspace/persp_rh_zo.h

@@ -0,0 +1,390 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_frustum_rh_zo(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ, float farZ,
+                                      mat4  dest)
+   CGLM_INLINE void glm_perspective_rh_zo(float fovy,
+                                          float aspect,
+                                          float nearZ,
+                                          float farZ,
+                                          mat4  dest)
+   CGLM_INLINE void glm_perspective_default_rh_zo(float aspect, mat4 dest)
+   CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
+   CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
+                                             float deltaFar)
+   CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
+                                           float * __restrict nearZ,
+                                           float * __restrict farZ,
+                                           float * __restrict top,
+                                           float * __restrict bottom,
+                                           float * __restrict left,
+                                           float * __restrict right)
+  CGLM_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
+                                           float dest[6])
+  CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
+                                            float * __restrict left,
+                                            float * __restrict right)
+  CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
+                                            float * __restrict top,
+                                            float * __restrict bottom)
+  CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
+                                            float * __restrict nearZ,
+                                            float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
+  CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
+  CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
+ */
+
+#ifndef cglm_persp_rh_zo_h
+#define cglm_persp_rh_zo_h
+
+#include "../common.h"
+#include "../plane.h"
+#include "persp.h"
+
+/*!
+ * @brief set up perspective peprojection matrix with a right-hand coordinate
+ *        system and a clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_frustum_rh_zo(float left,    float right,
+                  float bottom,  float top,
+                  float nearZ, float farZ,
+                  mat4  dest) {
+  float rl, tb, fn, nv;
+
+  glm_mat4_zero(dest);
+
+  rl = 1.0f / (right  - left);
+  tb = 1.0f / (top    - bottom);
+  fn =-1.0f / (farZ - nearZ);
+  nv = 2.0f * nearZ;
+
+  dest[0][0] = nv * rl;
+  dest[1][1] = nv * tb;
+  dest[2][0] = (right  + left)    * rl;
+  dest[2][1] = (top    + bottom)  * tb;
+  dest[2][2] = farZ * fn;
+  dest[2][3] =-1.0f;
+  dest[3][2] = farZ * nearZ * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix with a right-hand coordinate
+ *        system and a clip-space of [0, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ near clipping plane
+ * @param[in]  farZ  far clipping planes
+ * @param[out] dest    result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_rh_zo(float fovy,
+                      float aspect,
+                      float nearZ,
+                      float farZ,
+                      mat4  dest) {
+  float f, fn;
+
+  glm_mat4_zero(dest);
+
+  f  = 1.0f / tanf(fovy * 0.5f);
+  fn = 1.0f / (nearZ - farZ);
+
+  dest[0][0] = f / aspect;
+  dest[1][1] = f;
+  dest[2][2] = farZ * fn;
+  dest[2][3] =-1.0f;
+  dest[3][2] = nearZ * farZ * fn;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_default_rh_zo(float aspect, mat4 dest) {
+  glm_perspective_rh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        resized with a right-hand coordinate system and a clip-space of
+ *        [0, 1].
+ *
+ * @param[in]      aspect aspect ratio ( width / height )
+ * @param[in, out] proj   perspective projection matrix
+ */
+CGLM_INLINE
+void
+glm_perspective_resize_rh_zo(float aspect, mat4 proj) {
+  if (proj[0][0] == 0.0f)
+    return;
+
+  proj[0][0] = proj[1][1] / aspect;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance with a
+ *        right-hand coordinate system and a clip-space of [0, 1].
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+void
+glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
+  float fn, farZ, nearZ, p22, p32;
+
+  p22        = proj[2][2];
+  p32        = proj[3][2];
+
+  nearZ    = p32 / p22;
+  farZ     = p32 / (p22 + 1.0f) + deltaFar;
+  fn         = 1.0f / (nearZ - farZ);
+
+  proj[2][2] = farZ * fn;
+  proj[3][2] = nearZ * farZ * fn;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_rh_zo(mat4 proj,
+                    float * __restrict nearZ, float * __restrict farZ,
+                    float * __restrict top,     float * __restrict bottom,
+                    float * __restrict left,    float * __restrict right) {
+  float m00, m11, m20, m21, m22, m32, n, f;
+  float n_m11, n_m00;
+
+  m00 = proj[0][0];
+  m11 = proj[1][1];
+  m20 = proj[2][0];
+  m21 = proj[2][1];
+  m22 = proj[2][2];
+  m32 = proj[3][2];
+
+  n = m32 / m22;
+  f = m32 / (m22 + 1.0f);
+
+  n_m11 = n / m11;
+  n_m00 = n / m00;
+
+  *nearZ = n;
+  *farZ  = f;
+  *bottom  = n_m11 * (m21 - 1.0f);
+  *top     = n_m11 * (m21 + 1.0f);
+  *left    = n_m00 * (m20 - 1.0f);
+  *right   = n_m00 * (m20 + 1.0f);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
+  glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
+                               &dest[3], &dest[4], &dest[5]);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection (ZO).
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_x_rh_zo(mat4 proj,
+                         float * __restrict left,
+                         float * __restrict right) {
+  float nearZ, m20, m00, m22;
+
+  m00 = proj[0][0];
+  m20 = proj[2][0];
+  m22 = proj[2][2];
+
+  nearZ = proj[3][2] / m22;
+  *left   = nearZ * (m20 - 1.0f) / m00;
+  *right  = nearZ * (m20 + 1.0f) / m00;
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        y stands for y axis (top / bottom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_y_rh_zo(mat4 proj,
+                         float * __restrict top,
+                         float * __restrict bottom) {
+  float nearZ, m21, m11, m22;
+
+  m21 = proj[2][1];
+  m11 = proj[1][1];
+  m22 = proj[2][2];
+
+  nearZ = proj[3][2] / m22;
+  *bottom = nearZ * (m21 - 1) / m11;
+  *top    = nearZ * (m21 + 1) / m11;
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_z_rh_zo(mat4 proj,
+                         float * __restrict nearZ,
+                         float * __restrict farZ) {
+  float m32, m22;
+
+  m32 = proj[3][2];
+  m22 = proj[2][2];
+
+  *nearZ = m32 / m22;
+  *farZ  = m32 / (m22 + 1.0f);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
+  *farZ = proj[3][2] / (proj[2][2] + 1.0f);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with angle values with a right-hand coordinate system and a 
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ */
+CGLM_INLINE
+void
+glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
+  *nearZ = proj[3][2] / proj[2][2];
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+void
+glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
+  float t, a, nearZ, farZ;
+
+  t = 2.0f * tanf(fovy * 0.5f);
+  a = glm_persp_aspect(proj);
+
+  glm_persp_decomp_z_rh_zo(proj, &nearZ, &farZ);
+
+  dest[1]  = t * nearZ;
+  dest[3]  = t * farZ;
+  dest[0]  = a * dest[1];
+  dest[2]  = a * dest[3];
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a right-hand coordinate system and a clip-space of [0, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_fovy_rh_zo(mat4 proj) {
+  return glm_persp_fovy(proj);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a right-hand coordinate system and a clip-space of [0, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glm_persp_aspect_rh_zo(mat4 proj) {
+  return glm_persp_aspect(proj);
+}
+
+#endif /*cglm_persp_rh_zo_h*/

include/cglm/clipspace/view_lh.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_lh_h
+#define cglm_view_lh_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up view matrix (LH)
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  CGLM_ALIGN(8) vec3 f, u, s;
+
+  glm_vec3_sub(center, eye, f);
+  glm_vec3_normalize(f);
+
+  glm_vec3_crossn(f, up, s);
+  glm_vec3_cross(s, f, u);
+
+  dest[0][0] = s[0];
+  dest[0][1] = u[0];
+  dest[0][2] = f[0];
+  dest[1][0] = s[1];
+  dest[1][1] = u[1];
+  dest[1][2] = f[1];
+  dest[2][0] = s[2];
+  dest[2][1] = u[2];
+  dest[2][2] = f[2];
+  dest[3][0] =-glm_vec3_dot(s, eye);
+  dest[3][1] =-glm_vec3_dot(u, eye);
+  dest[3][2] =-glm_vec3_dot(f, eye);
+  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  CGLM_ALIGN(8) vec3 target;
+  glm_vec3_add(eye, dir, target);
+  glm_lookat_lh(eye, target, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest) {
+  CGLM_ALIGN(8) vec3 up;
+  glm_vec3_ortho(dir, up);
+  glm_look_lh(eye, dir, up, dest);
+}
+
+#endif /*cglm_view_lh_h*/

include/cglm/clipspace/view_lh_no.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_lh_no_h
+#define cglm_view_lh_no_h
+
+#include "view_lh.h"
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_lh(eye, center, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_lh(eye, dir, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_lh(eye, dir, dest);
+}
+
+#endif /*cglm_view_lh_no_h*/

include/cglm/clipspace/view_lh_zo.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_lh_zo_h
+#define cglm_view_lh_zo_h
+
+#include "view_lh.h"
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_lh(eye, center, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_lh(eye, dir, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with left handed coordinate system.
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_lh(eye, dir, dest);
+}
+
+#endif /*cglm_view_lh_zo_h*/

include/cglm/clipspace/view_rh.h

@@ -0,0 +1,99 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_rh_h
+#define cglm_view_rh_h
+
+#include "../common.h"
+#include "../plane.h"
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  CGLM_ALIGN(8) vec3 f, u, s;
+
+  glm_vec3_sub(center, eye, f);
+  glm_vec3_normalize(f);
+
+  glm_vec3_crossn(f, up, s);
+  glm_vec3_cross(s, f, u);
+
+  dest[0][0] = s[0];
+  dest[0][1] = u[0];
+  dest[0][2] =-f[0];
+  dest[1][0] = s[1];
+  dest[1][1] = u[1];
+  dest[1][2] =-f[1];
+  dest[2][0] = s[2];
+  dest[2][1] = u[2];
+  dest[2][2] =-f[2];
+  dest[3][0] =-glm_vec3_dot(s, eye);
+  dest[3][1] =-glm_vec3_dot(u, eye);
+  dest[3][2] = glm_vec3_dot(f, eye);
+  dest[0][3] = dest[1][3] = dest[2][3] = 0.0f;
+  dest[3][3] = 1.0f;
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  CGLM_ALIGN(8) vec3 target;
+  glm_vec3_add(eye, dir, target);
+  glm_lookat_rh(eye, target, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest) {
+  CGLM_ALIGN(8) vec3 up;
+  glm_vec3_ortho(dir, up);
+  glm_look_rh(eye, dir, up, dest);
+}
+
+#endif /*cglm_view_rh_h*/

include/cglm/clipspace/view_rh_no.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_rh_no_h
+#define cglm_view_rh_no_h
+
+#include "view_rh.h"
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_rh(eye, center, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_rh(eye, dir, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_rh(eye, dir, dest);
+}
+
+#endif /*cglm_view_rh_no_h*/

include/cglm/clipspace/view_rh_zo.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE void glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
+   CGLM_INLINE void glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest)
+ */
+
+#ifndef cglm_view_rh_zo_h
+#define cglm_view_rh_zo_h
+
+#include "view_rh.h"
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_rh(eye, center, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_rh(eye, dir, up, dest);
+}
+
+/*!
+ * @brief set up view matrix with right handed coordinate system.
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[out] dest   result matrix
+ */
+CGLM_INLINE
+void
+glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_rh(eye, dir, dest);
+}
+
+#endif /*cglm_view_rh_zo_h*/

include/cglm/common.h

@@ -50,4 +50,35 @@
 #  define GLM_FLT_EPSILON FLT_EPSILON
 #endif
 
+/*
+ * Clip control: define GLM_FORCE_DEPTH_ZERO_TO_ONE before including
+ * CGLM to use a clip space between 0 to 1.
+ * Coordinate system: define GLM_FORCE_LEFT_HANDED before including
+ * CGLM to use the left handed coordinate system by default.
+ */
+
+#define CGLM_CLIP_CONTROL_ZO_BIT (1 << 0) /* ZERO_TO_ONE */
+#define CGLM_CLIP_CONTROL_NO_BIT (1 << 1) /* NEGATIVE_ONE_TO_ONE */
+#define CGLM_CLIP_CONTROL_LH_BIT (1 << 2) /* LEFT_HANDED, For DirectX, Metal, Vulkan */
+#define CGLM_CLIP_CONTROL_RH_BIT (1 << 3) /* RIGHT_HANDED, For OpenGL, default in GLM */
+
+#define CGLM_CLIP_CONTROL_LH_ZO (CGLM_CLIP_CONTROL_LH_BIT | CGLM_CLIP_CONTROL_ZO_BIT)
+#define CGLM_CLIP_CONTROL_LH_NO (CGLM_CLIP_CONTROL_LH_BIT | CGLM_CLIP_CONTROL_NO_BIT)
+#define CGLM_CLIP_CONTROL_RH_ZO (CGLM_CLIP_CONTROL_RH_BIT | CGLM_CLIP_CONTROL_ZO_BIT)
+#define CGLM_CLIP_CONTROL_RH_NO (CGLM_CLIP_CONTROL_RH_BIT | CGLM_CLIP_CONTROL_NO_BIT)
+
+#ifdef CGLM_FORCE_DEPTH_ZERO_TO_ONE
+#  ifdef CGLM_FORCE_LEFT_HANDED
+#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_LH_ZO
+#  else
+#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_RH_ZO
+#  endif
+#else
+#  ifdef CGLM_FORCE_LEFT_HANDED
+#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_LH_NO
+#  else
+#    define CGLM_CONFIG_CLIP_CONTROL CGLM_CLIP_CONTROL_RH_NO
+#  endif
+#endif
+
 #endif /* cglm_common_h */

include/cglm/mat4.h

@@ -187,8 +187,29 @@ glm_mat4_identity_array(mat4 * __restrict mat, size_t count) {
 CGLM_INLINE
 void
 glm_mat4_zero(mat4 mat) {
+#ifdef __AVX__
+  __m256 y0;
+  y0 = _mm256_setzero_ps();
+  glmm_store256(mat[0], y0);
+  glmm_store256(mat[2], y0);
+#elif defined( __SSE__ ) || defined( __SSE2__ )
+  glmm_128 x0;
+  x0 = _mm_setzero_ps();
+  glmm_store(mat[0], x0);
+  glmm_store(mat[1], x0);
+  glmm_store(mat[2], x0);
+  glmm_store(mat[3], x0);
+#elif defined(CGLM_NEON_FP)
+  glmm_128 x0;
+  x0 = vdupq_n_f32(0.0f);
+  vst1q_f32(mat[0], x0);
+  vst1q_f32(mat[1], x0);
+  vst1q_f32(mat[2], x0);
+  vst1q_f32(mat[3], x0);
+#else
   CGLM_ALIGN_MAT mat4 t = GLM_MAT4_ZERO_INIT;
   glm_mat4_copy(t, mat);
+#endif
 }
 
 /*!

include/cglm/plane.h

@@ -9,6 +9,7 @@
 #define cglm_plane_h
 
 #include "common.h"
+#include "vec3.h"
 #include "vec4.h"
 
 /*

include/cglm/quat.h

@@ -38,6 +38,7 @@
    CGLM_INLINE void glm_quat_lerp(versor from, versor to, float t, versor dest);
    CGLM_INLINE void glm_quat_lerpc(versor from, versor to, float t, versor dest);
    CGLM_INLINE void glm_quat_slerp(versor q, versor r, float t, versor dest);
+   CGLM_INLINE void glm_quat_nlerp(versor q, versor r, float t, versor dest);
    CGLM_INLINE void glm_quat_look(vec3 eye, versor ori, mat4 dest);
    CGLM_INLINE void glm_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
    CGLM_INLINE void glm_quat_forp(vec3 from,
@@ -628,6 +629,29 @@ glm_quat_lerpc(versor from, versor to, float t, versor dest) {
   glm_vec4_lerpc(from, to, t, dest);
 }
 
+/*!
+ * @brief interpolates between two quaternions
+ *        taking the shortest rotation path using
+ *        normalized linear interpolation (NLERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount)
+ * @param[out]  dest  result quaternion
+ */
+CGLM_INLINE
+void
+glm_quat_nlerp(versor from, versor to, float t, versor dest) {
+  versor target;
+  float  dot;
+  
+  dot = glm_vec4_dot(from, to);
+  
+  glm_vec4_scale(to, (dot >= 0) ? 1.0f : -1.0f, target);
+  glm_quat_lerp(from, target, t, dest);
+  glm_quat_normalize(dest);
+}
+
 /*!
  * @brief interpolates between two quaternions
  *        using spherical linear interpolation (SLERP)

include/cglm/simd/arm.h

@@ -29,6 +29,15 @@
   vreinterpretq_f32_s32(veorq_s32(vreinterpretq_s32_f32(a),                   \
                                   vreinterpretq_s32_f32(b)))
 
+#define glmm_swplane(v) vextq_f32(v, v, 2)
+#define glmm_low(x)     vget_low_f32(x)
+#define glmm_high(x)    vget_high_f32(x)
+
+#define glmm_combine_ll(x, y) vcombine_f32(vget_low_f32(x),  vget_low_f32(y))
+#define glmm_combine_hl(x, y) vcombine_f32(vget_high_f32(x), vget_low_f32(y))
+#define glmm_combine_lh(x, y) vcombine_f32(vget_low_f32(x),  vget_high_f32(y))
+#define glmm_combine_hh(x, y) vcombine_f32(vget_high_f32(x), vget_high_f32(y))
+
 static inline
 float32x4_t
 glmm_abs(float32x4_t v) {
@@ -38,8 +47,13 @@ glmm_abs(float32x4_t v) {
 static inline
 float32x4_t
 glmm_vhadd(float32x4_t v) {
+  return vaddq_f32(vaddq_f32(glmm_splat_x(v), glmm_splat_y(v)),
+                   vaddq_f32(glmm_splat_z(v), glmm_splat_w(v)));
+  /*
+   this seems slower:
    v = vaddq_f32(v, vrev64q_f32(v));
    return vaddq_f32(v, vcombine_f32(vget_high_f32(v), vget_low_f32(v)));
+   */
 }
 
 static inline

include/cglm/simd/neon/affine.h

@@ -17,29 +17,32 @@ void
 glm_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
-  glmm_128 l0, l1, l2, l3, r0, r1, r2, r3, v0, v1, v2, v3;
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
-  l0 = glmm_load(m1[0]);    r0 = glmm_load(m2[0]);
+  l  = glmm_load(m1[0]);
-  l1 = glmm_load(m1[1]);    r1 = glmm_load(m2[1]);
+  r0 = glmm_load(m2[0]);
-  l2 = glmm_load(m1[2]);    r2 = glmm_load(m2[2]);
+  r1 = glmm_load(m2[1]);
-  l3 = glmm_load(m1[3]);    r3 = glmm_load(m2[3]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
 
-  v0 = vmulq_f32(glmm_splat_x(r0), l0);
+  v0 = vmulq_f32(glmm_splat_x(r0), l);
-  v1 = vmulq_f32(glmm_splat_x(r1), l0);
+  v1 = vmulq_f32(glmm_splat_x(r1), l);
-  v2 = vmulq_f32(glmm_splat_x(r2), l0);
+  v2 = vmulq_f32(glmm_splat_x(r2), l);
-  v3 = vmulq_f32(glmm_splat_x(r3), l0);
+  v3 = vmulq_f32(glmm_splat_x(r3), l);
 
-  v0 = glmm_fmadd(glmm_splat_y(r0), l1, v0);
+  l  = glmm_load(m1[1]);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l1, v1);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l1, v2);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-  v3 = glmm_fmadd(glmm_splat_y(r3), l1, v3);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
 
-  v0 = glmm_fmadd(glmm_splat_z(r0), l2, v0);
+  l  = glmm_load(m1[2]);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l2, v1);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l2, v2);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v3 = glmm_fmadd(glmm_splat_z(r3), l2, v3);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
 
-  v3 = glmm_fmadd(glmm_splat_w(r3), l3, v3);
+  v3 = glmm_fmadd(glmm_splat_w(r3), glmm_load(m1[3]), v3);
 
   glmm_store(dest[0], v0);
   glmm_store(dest[1], v1);
@@ -52,23 +55,26 @@ void
 glm_mul_rot_neon(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
-  glmm_128 l0, l1, l2, r0, r1, r2, v0, v1, v2;
+  glmm_128 l, r0, r1, r2, v0, v1, v2;
 
-  l0 = glmm_load(m1[0]);    r0 = glmm_load(m2[0]);
+  l  = glmm_load(m1[0]);
-  l1 = glmm_load(m1[1]);    r1 = glmm_load(m2[1]);
+  r0 = glmm_load(m2[0]);
-  l2 = glmm_load(m1[2]);    r2 = glmm_load(m2[2]);
+  r1 = glmm_load(m2[1]);
+  r2 = glmm_load(m2[2]);
 
-  v0 = vmulq_f32(glmm_splat_x(r0), l0);
+  v0 = vmulq_f32(glmm_splat_x(r0), l);
-  v1 = vmulq_f32(glmm_splat_x(r1), l0);
+  v1 = vmulq_f32(glmm_splat_x(r1), l);
-  v2 = vmulq_f32(glmm_splat_x(r2), l0);
+  v2 = vmulq_f32(glmm_splat_x(r2), l);
 
-  v0 = glmm_fmadd(glmm_splat_y(r0), l1, v0);
+  l  = glmm_load(m1[1]);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l1, v1);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l1, v2);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
   
-  v0 = glmm_fmadd(glmm_splat_z(r0), l2, v0);
+  l  = glmm_load(m1[2]);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l2, v1);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l2, v2);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
 
   glmm_store(dest[0], v0);
   glmm_store(dest[1], v1);
@@ -91,7 +97,7 @@ glm_inv_tr_neon(mat4 mat) {
   x0 = glmm_fmadd(r0, glmm_splat_w(r0),
                   glmm_fmadd(r1, glmm_splat_w(r1),
                              vmulq_f32(r2, glmm_splat_w(r2))));
-  x0 = glmm_xor(x0, glmm_set1(-0.f));
+  x0 = vnegq_f32(x0);
 
   glmm_store(mat[0], r0);
   glmm_store(mat[1], r1);

include/cglm/simd/neon/mat4.h

@@ -43,32 +43,36 @@ void
 glm_mat4_mul_neon(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
-  glmm_128 l0, l1, l2, l3, r0, r1, r2, r3, v0, v1, v2, v3;
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
-  l0 = glmm_load(m1[0]);    r0 = glmm_load(m2[0]);
+  l  = glmm_load(m1[0]);
-  l1 = glmm_load(m1[1]);    r1 = glmm_load(m2[1]);
+  r0 = glmm_load(m2[0]);
-  l2 = glmm_load(m1[2]);    r2 = glmm_load(m2[2]);
+  r1 = glmm_load(m2[1]);
-  l3 = glmm_load(m1[3]);    r3 = glmm_load(m2[3]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
 
-  v0 = vmulq_f32(glmm_splat_x(r0), l0);
+  v0 = vmulq_f32(glmm_splat_x(r0), l);
-  v1 = vmulq_f32(glmm_splat_x(r1), l0);
+  v1 = vmulq_f32(glmm_splat_x(r1), l);
-  v2 = vmulq_f32(glmm_splat_x(r2), l0);
+  v2 = vmulq_f32(glmm_splat_x(r2), l);
-  v3 = vmulq_f32(glmm_splat_x(r3), l0);
+  v3 = vmulq_f32(glmm_splat_x(r3), l);
 
-  v0 = glmm_fmadd(glmm_splat_y(r0), l1, v0);
+  l  = glmm_load(m1[1]);
-  v1 = glmm_fmadd(glmm_splat_y(r1), l1, v1);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_y(r2), l1, v2);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-  v3 = glmm_fmadd(glmm_splat_y(r3), l1, v3);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
 
-  v0 = glmm_fmadd(glmm_splat_z(r0), l2, v0);
+  l  = glmm_load(m1[2]);
-  v1 = glmm_fmadd(glmm_splat_z(r1), l2, v1);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_z(r2), l2, v2);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-  v3 = glmm_fmadd(glmm_splat_z(r3), l2, v3);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
 
-  v0 = glmm_fmadd(glmm_splat_w(r0), l3, v0);
+  l  = glmm_load(m1[3]);
-  v1 = glmm_fmadd(glmm_splat_w(r1), l3, v1);
+  v0 = glmm_fmadd(glmm_splat_w(r0), l, v0);
-  v2 = glmm_fmadd(glmm_splat_w(r2), l3, v2);
+  v1 = glmm_fmadd(glmm_splat_w(r1), l, v1);
-  v3 = glmm_fmadd(glmm_splat_w(r3), l3, v3);
+  v2 = glmm_fmadd(glmm_splat_w(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
 
   glmm_store(dest[0], v0);
   glmm_store(dest[1], v1);

include/cglm/simd/sse2/affine.h

@@ -16,76 +16,76 @@ CGLM_INLINE
 void
 glm_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
-  __m128 l0, l1, l2, l3, r;
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
-  l0 = glmm_load(m1[0]);
+  l  = glmm_load(m1[0]);
-  l1 = glmm_load(m1[1]);
+  r0 = glmm_load(m2[0]);
-  l2 = glmm_load(m1[2]);
+  r1 = glmm_load(m2[1]);
-  l3 = glmm_load(m1[3]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
 
-  r = glmm_load(m2[0]);
+  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
-  glmm_store(dest[0],
+  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
+  v3 = _mm_mul_ps(glmm_splat_x(r3), l);
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
 
-  r = glmm_load(m2[1]);
+  l  = glmm_load(m1[1]);
-  glmm_store(dest[1],
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
 
-  r = glmm_load(m2[2]);
+  l  = glmm_load(m1[2]);
-  glmm_store(dest[2],
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
 
-  r = glmm_load(m2[3]);
+  l  = glmm_load(m1[3]);
-  glmm_store(dest[3],
+  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
-       glmm_fmadd(glmm_splat(r, 0), l0,
+
-                  glmm_fmadd(glmm_splat(r, 1), l1,
+  glmm_store(dest[0], v0);
-                             glmm_fmadd(glmm_splat(r, 2), l2,
+  glmm_store(dest[1], v1);
-                                        _mm_mul_ps(glmm_splat(r, 3), l3)))));
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], v3);
 }
 
 CGLM_INLINE
 void
 glm_mul_rot_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
-  __m128 l0, l1, l2, l3, r;
 
-  l0 = glmm_load(m1[0]);
+  glmm_128 l, r0, r1, r2, v0, v1, v2;
-  l1 = glmm_load(m1[1]);
-  l2 = glmm_load(m1[2]);
-  l3 = glmm_load(m1[3]);
 
-  r = glmm_load(m2[0]);
+  l  = glmm_load(m1[0]);
-  glmm_store(dest[0],
+  r0 = glmm_load(m2[0]);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  r1 = glmm_load(m2[1]);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
+  r2 = glmm_load(m2[2]);
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
 
-  r = glmm_load(m2[1]);
+  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
-  glmm_store(dest[1],
+  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
 
+  l  = glmm_load(m1[1]);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
 
-  r = glmm_load(m2[2]);
+  l  = glmm_load(m1[2]);
-  glmm_store(dest[2],
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
-             glmm_fmadd(glmm_splat(r, 0), l0,
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
-                        glmm_fmadd(glmm_splat(r, 1), l1,
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
-                                   _mm_mul_ps(glmm_splat(r, 2), l2))));
 
-  glmm_store(dest[3], l3);
+  glmm_store(dest[0], v0);
+  glmm_store(dest[1], v1);
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], glmm_load(m1[3]));
 }
 
 CGLM_INLINE
 void
 glm_inv_tr_sse2(mat4 mat) {
-  __m128 r0, r1, r2, r3, x0, x1;
+  __m128 r0, r1, r2, r3, x0, x1, x2, x3, x4, x5;
 
   r0 = glmm_load(mat[0]);
   r1 = glmm_load(mat[1]);
@@ -95,10 +95,13 @@ glm_inv_tr_sse2(mat4 mat) {
 
   _MM_TRANSPOSE4_PS(r0, r1, r2, x1);
 
-  x0 = glmm_fmadd(r0, glmm_shuff1(r3, 0, 0, 0, 0),
+  x2 = glmm_shuff1(r3, 0, 0, 0, 0);
-             glmm_fmadd(r1, glmm_shuff1(r3, 1, 1, 1, 1),
+  x3 = glmm_shuff1(r3, 1, 1, 1, 1);
-                        _mm_mul_ps(r2, glmm_shuff1(r3, 2, 2, 2, 2))));
+  x4 = glmm_shuff1(r3, 2, 2, 2, 2);
-  x0 = _mm_xor_ps(x0, _mm_set1_ps(-0.f));
+  x5 = _mm_set1_ps(-0.f);
+
+  x0 = glmm_fmadd(r0, x2, glmm_fmadd(r1, x3, _mm_mul_ps(r2, x4)));
+  x0 = _mm_xor_ps(x0, x5);
 
   x0 = _mm_add_ps(x0, x1);
 

include/cglm/simd/sse2/mat2.h

@@ -15,20 +15,23 @@
 CGLM_INLINE
 void
 glm_mat2_mul_sse2(mat2 m1, mat2 m2, mat2 dest) {
-  __m128 x0, x1, x2;
+  __m128 x0, x1, x2, x3, x4;
 
   x1 = glmm_load(m1[0]); /* d c b a */
   x2 = glmm_load(m2[0]); /* h g f e */
 
+  x3 = glmm_shuff1(x2, 2, 2, 0, 0);
+  x4 = glmm_shuff1(x2, 3, 3, 1, 1);
+  x0 = _mm_movelh_ps(x1, x1);
+  x2 = _mm_movehl_ps(x1, x1);
+
   /*
    dest[0][0] = a * e + c * f;
    dest[0][1] = b * e + d * f;
    dest[1][0] = a * g + c * h;
    dest[1][1] = b * g + d * h;
    */
-  x0 = glmm_fmadd(_mm_movelh_ps(x1, x1), glmm_shuff1(x2, 2, 2, 0, 0),
+  x0 = glmm_fmadd(x0, x3, _mm_mul_ps(x2, x4));
-                  _mm_mul_ps(_mm_movehl_ps(x1, x1),
-                             glmm_shuff1(x2, 3, 3, 1, 1)));
 
   glmm_store(dest[0], x0);
 }

include/cglm/simd/sse2/mat3.h

@@ -15,37 +15,61 @@
 CGLM_INLINE
 void
 glm_mat3_mul_sse2(mat3 m1, mat3 m2, mat3 dest) {
-  __m128 l0, l1, l2;
+  __m128 l0, l1, l2, r0, r1, r2, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
-  __m128 r0, r1, r2;
-  __m128 x0, x1, x2;
   
   l0 = _mm_loadu_ps(m1[0]);
   l1 = _mm_loadu_ps(&m1[1][1]);
-  l2 = _mm_set1_ps(m1[2][2]);
 
   r0 = _mm_loadu_ps(m2[0]);
   r1 = _mm_loadu_ps(&m2[1][1]);
-  r2 = _mm_set1_ps(m2[2][2]);
 
-  x1 = glmm_shuff2(l0, l1, 1, 0, 3, 3, 0, 3, 2, 0);
+  x8 = glmm_shuff1(l0, 0, 2, 1, 0);                     /* a00 a02 a01 a00 */
-  x2 = glmm_shuff2(l1, l2, 0, 0, 3, 2, 0, 2, 1, 0);
+  x1 = glmm_shuff1(r0, 3, 0, 0, 0);                     /* b10 b00 b00 b00 */
+  x2 = _mm_shuffle_ps(l0, l1, _MM_SHUFFLE(1, 0, 3, 3)); /* a12 a11 a10 a10 */
+  x3 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(2, 0, 3, 1)); /* b20 b11 b10 b01 */
+  x0 = _mm_mul_ps(x8, x1);
 
-  x0 = glmm_fmadd(glmm_shuff1(l0, 0, 2, 1, 0), glmm_shuff1(r0, 3, 0, 0, 0),
+  x6 = glmm_shuff1(l0, 1, 0, 2, 1);                     /* a01 a00 a02 a01 */
-                  glmm_fmadd(x1, glmm_shuff2(r0, r1, 0, 0, 1, 1, 2, 0, 0, 0),
+  x7 = glmm_shuff1(x3, 3, 3, 1, 1);                     /* b20 b20 b10 b10 */
-                             _mm_mul_ps(x2, glmm_shuff2(r0, r1, 1, 1, 2, 2, 2, 0, 0, 0))));
+  l2 = _mm_load_ss(&m1[2][2]);
+  r2 = _mm_load_ss(&m2[2][2]);
+  x1 = _mm_mul_ps(x6, x7);
+  l2 = glmm_shuff1(l2, 0, 0, 1, 0);                     /* a22 a22 0.f a22 */
+  r2 = glmm_shuff1(r2, 0, 0, 1, 0);                     /* b22 b22 0.f b22 */
 
-  _mm_storeu_ps(dest[0], x0);
+  x4 = glmm_shuff1(x2, 0, 3, 2, 0);                     /* a10 a12 a11 a10 */
+  x5 = glmm_shuff1(x2, 2, 0, 3, 2);                     /* a11 a10 a12 a11 */
+  x6 = glmm_shuff1(x3, 2, 0, 0, 0);                     /* b11 b01 b01 b01 */
+  x2 = glmm_shuff1(r1, 3, 3, 0, 0);                     /* b21 b21 b11 b11 */
 
-  x0 = glmm_fmadd(glmm_shuff1(l0, 1, 0, 2, 1), _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(2, 2, 3, 3)),
+  x8 = _mm_unpackhi_ps(x8, x4);                         /* a10 a00 a12 a02 */
-                  glmm_fmadd(glmm_shuff1(x1, 1, 0, 2, 1), glmm_shuff1(r1, 3, 3, 0, 0),
+  x9 = _mm_unpackhi_ps(x7, x2);                         /* b21 b20 b21 b20 */
-                             _mm_mul_ps(glmm_shuff1(x2, 1, 0, 2, 1),
-                                        _mm_shuffle_ps(r1, r2, _MM_SHUFFLE(0, 0, 1, 1)))));
 
-  _mm_storeu_ps(&dest[1][1], x0);
+  x0 = glmm_fmadd(x4, x6, x0);
+  x1 = glmm_fmadd(x5, x2, x1);
 
-  dest[2][2] = m1[0][2] * m2[2][0]
+  x2 = _mm_movehl_ps(l2, l1);                           /* a22 a22 a21 a20 */
-             + m1[1][2] * m2[2][1]
+  x3 = glmm_shuff1(x2, 0, 2, 1, 0);                     /* a20 a22 a21 a20 */
-             + m1[2][2] * m2[2][2];
+  x2 = glmm_shuff1(x2, 1, 0, 2, 1);                     /* a21 a20 a22 a21 */
+  x4 = _mm_shuffle_ps(r0, r1, _MM_SHUFFLE(1, 1, 2, 2)); /* b12 b12 b02 b02 */
+  
+  x5 = glmm_shuff1(x4, 3, 0, 0, 0);                     /* b12 b02 b02 b02 */
+  x4 = _mm_movehl_ps(r2, x4);                           /* b22 b22 b12 b12 */
+  x0 = glmm_fmadd(x3, x5, x0);
+  x1 = glmm_fmadd(x2, x4, x1);
+
+  /*
+   Dot Product : dest[2][2] =  a02 * b20 +
+                               a12 * b21 +
+                               a22 * b22 +
+                               0   * 00                                    */
+  x2 = _mm_movelh_ps(x8, l2);                           /* 0.f a22 a12 a02 */
+  x3 = _mm_movelh_ps(x9, r2);                           /* 0.f b22 b21 b20 */
+  x2 = glmm_vdots(x2, x3);
+
+  _mm_storeu_ps(&dest[0][0], x0);
+  _mm_storeu_ps(&dest[1][1], x1);
+  _mm_store_ss (&dest[2][2], x2);
 }
 
 #endif

include/cglm/simd/sse2/mat4.h

@@ -49,41 +49,63 @@ void
 glm_mat4_mul_sse2(mat4 m1, mat4 m2, mat4 dest) {
   /* D = R * L (Column-Major) */
 
-  __m128 l0, l1, l2, l3, r;
+  glmm_128 l, r0, r1, r2, r3, v0, v1, v2, v3;
 
-  l0 = glmm_load(m1[0]);
+  l  = glmm_load(m1[0]);
-  l1 = glmm_load(m1[1]);
+  r0 = glmm_load(m2[0]);
-  l2 = glmm_load(m1[2]);
+  r1 = glmm_load(m2[1]);
-  l3 = glmm_load(m1[3]);
+  r2 = glmm_load(m2[2]);
+  r3 = glmm_load(m2[3]);
 
-#define XX(C)                                                                 \
+  v0 = _mm_mul_ps(glmm_splat_x(r0), l);
-                                                                              \
+  v1 = _mm_mul_ps(glmm_splat_x(r1), l);
-  r = glmm_load(m2[C]);                                                       \
+  v2 = _mm_mul_ps(glmm_splat_x(r2), l);
-  glmm_store(dest[C],                                                         \
+  v3 = _mm_mul_ps(glmm_splat_x(r3), l);
-       glmm_fmadd(glmm_splat(r, 0), l0,                                       \
-                   glmm_fmadd(glmm_splat(r, 1), l1,                           \
-                             glmm_fmadd(glmm_splat(r, 2), l2,                 \
-                                         _mm_mul_ps(glmm_splat(r, 3), l3)))));
 
-  XX(0);
+  l  = glmm_load(m1[1]);
-  XX(1);
+  v0 = glmm_fmadd(glmm_splat_y(r0), l, v0);
-  XX(2);
+  v1 = glmm_fmadd(glmm_splat_y(r1), l, v1);
-  XX(3);
+  v2 = glmm_fmadd(glmm_splat_y(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_y(r3), l, v3);
 
-#undef XX
+  l  = glmm_load(m1[2]);
+  v0 = glmm_fmadd(glmm_splat_z(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_z(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_z(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_z(r3), l, v3);
+
+  l  = glmm_load(m1[3]);
+  v0 = glmm_fmadd(glmm_splat_w(r0), l, v0);
+  v1 = glmm_fmadd(glmm_splat_w(r1), l, v1);
+  v2 = glmm_fmadd(glmm_splat_w(r2), l, v2);
+  v3 = glmm_fmadd(glmm_splat_w(r3), l, v3);
+
+  glmm_store(dest[0], v0);
+  glmm_store(dest[1], v1);
+  glmm_store(dest[2], v2);
+  glmm_store(dest[3], v3);
 }
 
 CGLM_INLINE
 void
 glm_mat4_mulv_sse2(mat4 m, vec4 v, vec4 dest) {
-  __m128 x0, x1;
+  __m128 x0, x1, m0, m1, m2, m3, v0, v1, v2, v3;
+
+  m0 = glmm_load(m[0]);
+  m1 = glmm_load(m[1]);
+  m2 = glmm_load(m[2]);
+  m3 = glmm_load(m[3]);
 
   x0 = glmm_load(v);
-  x1 = glmm_fmadd(glmm_load(m[0]), glmm_splat(x0, 0),
+  v0 = glmm_splat_x(x0);
-                  glmm_fmadd(glmm_load(m[1]), glmm_splat(x0, 1),
+  v1 = glmm_splat_y(x0);
-                             glmm_fmadd(glmm_load(m[2]), glmm_splat(x0, 2),
+  v2 = glmm_splat_z(x0);
-                                        _mm_mul_ps(glmm_load(m[3]),
+  v3 = glmm_splat_w(x0);
-                                                   glmm_splat(x0, 3)))));
+
+  x1 = _mm_mul_ps(m3, v3);
+  x1 = glmm_fmadd(m2, v2, x1);
+  x1 = glmm_fmadd(m1, v1, x1);
+  x1 = glmm_fmadd(m0, v0, x1);
 
   glmm_store(dest, x1);
 }
@@ -153,87 +175,111 @@ glm_mat4_inv_fast_sse2(mat4 mat, mat4 dest) {
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
   
-  x0 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(3, 2, 3, 2));  /* p o l k */
+  x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
+  x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
   x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
   x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
-  x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
+  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
+  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
+
+  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0));  /* e e i i */
+  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
   x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
+  x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
+  
+  t0 = _mm_mul_ps(x3, x1);
+  t1 = _mm_mul_ps(x5, x1);
+  t2 = _mm_mul_ps(x5, x2);
+  t3 = _mm_mul_ps(x6, x1);
+  t4 = _mm_mul_ps(x6, x2);
+  t5 = _mm_mul_ps(x6, x4);
   
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
-  t0 = glmm_fnmadd(x2, x0, _mm_mul_ps(x3, x1));
+  t0 = glmm_fnmadd(x2, x0, t0);
-  
-  x4 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(2, 1, 2, 1)); /* o n k j */
-  x4 = glmm_shuff1(x4, 0, 2, 2, 2);                     /* j n n n */
-  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1)); /* f f j j */
   
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
-   t1 = glmm_fnmadd(x4, x0, _mm_mul_ps(x5, x1));
+   t1 = glmm_fnmadd(x4, x0, t1);
   
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
-  t2 = glmm_fnmadd(x4, x3, _mm_mul_ps(x5, x2));
+  t2 = glmm_fnmadd(x4, x3, t2);
-  
-  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0)); /* e e i i */
-  x7 = glmm_shuff2(r3, r2, 0, 0, 0, 0, 2, 0, 0, 0);     /* i m m m */
   
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
-  t3 = glmm_fnmadd(x7, x0, _mm_mul_ps(x6, x1));
+  t3 = glmm_fnmadd(x7, x0, t3);
   
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
-  t4 = glmm_fnmadd(x7, x3, _mm_mul_ps(x6, x2));
+  t4 = glmm_fnmadd(x7, x3, t4);
   
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
-  t5 = glmm_fnmadd(x7, x5, _mm_mul_ps(x6, x4));
+  t5 = glmm_fnmadd(x7, x5, t5);
   
-  x0 = glmm_shuff2(r1, r0, 0, 0, 0, 0, 2, 2, 2, 0); /* a a a e */
+  x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
-  x1 = glmm_shuff2(r1, r0, 1, 1, 1, 1, 2, 2, 2, 0); /* b b b f */
+  x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
-  x2 = glmm_shuff2(r1, r0, 2, 2, 2, 2, 2, 2, 2, 0); /* c c c g */
+  
-  x3 = glmm_shuff2(r1, r0, 3, 3, 3, 3, 2, 2, 2, 0); /* d d d h */
+  x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
+  x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
+  x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
+  x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
+  
+  v2 = _mm_mul_ps(x0, t1);
+  v1 = _mm_mul_ps(x0, t0);
+  v3 = _mm_mul_ps(x0, t2);
+  v0 = _mm_mul_ps(x1, t0);
+  
+  v2 = glmm_fnmadd(x1, t3, v2);
+  v3 = glmm_fnmadd(x1, t4, v3);
+  v0 = glmm_fnmadd(x2, t1, v0);
+  v1 = glmm_fnmadd(x2, t3, v1);
+  
+  v3 = glmm_fmadd(x2, t5, v3);
+  v0 = glmm_fmadd(x3, t2, v0);
+  v2 = glmm_fmadd(x3, t5, v2);
+  v1 = glmm_fmadd(x3, t4, v1);
 
   /*
    dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
    dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
-  v0 = _mm_xor_ps(glmm_fmadd(x3, t2, glmm_fnmadd(x2, t1, _mm_mul_ps(x1, t0))), x8);
+  v0 = _mm_xor_ps(v0, x8);
   
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
    dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
    dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
-  v2 = _mm_xor_ps(glmm_fmadd(x3, t5, glmm_fnmadd(x1, t3, _mm_mul_ps(x0, t1))), x8);
+  v2 = _mm_xor_ps(v2, x8);
 
   /*
    dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
    dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
    dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
    dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
-  v1 = _mm_xor_ps(glmm_fmadd(x3, t4, glmm_fnmadd(x2, t3, _mm_mul_ps(x0, t0))), x9);
+  v1 = _mm_xor_ps(v1, x9);
 
   /*
    dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
    dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
    dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
    dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
-  v3 = _mm_xor_ps(glmm_fmadd(x2, t5, glmm_fnmadd(x1, t4, _mm_mul_ps(x0, t2))), x9);
+  v3 = _mm_xor_ps(v3, x9);
 
   /* determinant */
   x0 = _mm_shuffle_ps(v0, v1, _MM_SHUFFLE(0, 0, 0, 0));
@@ -265,87 +311,111 @@ glm_mat4_inv_sse2(mat4 mat, mat4 dest) {
   r2 = glmm_load(mat[2]); /* l k j i */
   r3 = glmm_load(mat[3]); /* p o n m */
   
-  x0 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(3, 2, 3, 2));  /* p o l k */
+  x0 = _mm_movehl_ps(r3, r2);                            /* p o l k */
+  x3 = _mm_movelh_ps(r2, r3);                            /* n m j i */
   x1 = glmm_shuff1(x0, 1, 3, 3 ,3);                      /* l p p p */
   x2 = glmm_shuff1(x0, 0, 2, 2, 2);                      /* k o o o */
-  x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
+  x4 = glmm_shuff1(x3, 1, 3, 3, 3);                      /* j n n n */
+  x7 = glmm_shuff1(x3, 0, 2, 2, 2);                      /* i m m m */
+
+  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0));  /* e e i i */
+  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1));  /* f f j j */
   x3 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(2, 2, 2, 2));  /* g g k k */
+  x0 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(3, 3, 3, 3));  /* h h l l */
+  
+  t0 = _mm_mul_ps(x3, x1);
+  t1 = _mm_mul_ps(x5, x1);
+  t2 = _mm_mul_ps(x5, x2);
+  t3 = _mm_mul_ps(x6, x1);
+  t4 = _mm_mul_ps(x6, x2);
+  t5 = _mm_mul_ps(x6, x4);
   
   /* t1[0] = k * p - o * l;
      t1[0] = k * p - o * l;
      t2[0] = g * p - o * h;
      t3[0] = g * l - k * h; */
-  t0 = glmm_fnmadd(x2, x0, _mm_mul_ps(x3, x1));
+  t0 = glmm_fnmadd(x2, x0, t0);
-  
-  x4 = _mm_shuffle_ps(r2, r3, _MM_SHUFFLE(2, 1, 2, 1)); /* o n k j */
-  x4 = glmm_shuff1(x4, 0, 2, 2, 2);                     /* j n n n */
-  x5 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(1, 1, 1, 1)); /* f f j j */
   
   /* t1[1] = j * p - n * l;
      t1[1] = j * p - n * l;
      t2[1] = f * p - n * h;
      t3[1] = f * l - j * h; */
-   t1 = glmm_fnmadd(x4, x0, _mm_mul_ps(x5, x1));
+   t1 = glmm_fnmadd(x4, x0, t1);
   
   /* t1[2] = j * o - n * k
      t1[2] = j * o - n * k;
      t2[2] = f * o - n * g;
      t3[2] = f * k - j * g; */
-  t2 = glmm_fnmadd(x4, x3, _mm_mul_ps(x5, x2));
+  t2 = glmm_fnmadd(x4, x3, t2);
-  
-  x6 = _mm_shuffle_ps(r2, r1, _MM_SHUFFLE(0, 0, 0, 0)); /* e e i i */
-  x7 = glmm_shuff2(r3, r2, 0, 0, 0, 0, 2, 0, 0, 0);     /* i m m m */
   
   /* t1[3] = i * p - m * l;
      t1[3] = i * p - m * l;
      t2[3] = e * p - m * h;
      t3[3] = e * l - i * h; */
-  t3 = glmm_fnmadd(x7, x0, _mm_mul_ps(x6, x1));
+  t3 = glmm_fnmadd(x7, x0, t3);
   
   /* t1[4] = i * o - m * k;
      t1[4] = i * o - m * k;
      t2[4] = e * o - m * g;
      t3[4] = e * k - i * g; */
-  t4 = glmm_fnmadd(x7, x3, _mm_mul_ps(x6, x2));
+  t4 = glmm_fnmadd(x7, x3, t4);
   
   /* t1[5] = i * n - m * j;
      t1[5] = i * n - m * j;
      t2[5] = e * n - m * f;
      t3[5] = e * j - i * f; */
-  t5 = glmm_fnmadd(x7, x5, _mm_mul_ps(x6, x4));
+  t5 = glmm_fnmadd(x7, x5, t5);
   
-  x0 = glmm_shuff2(r1, r0, 0, 0, 0, 0, 2, 2, 2, 0); /* a a a e */
+  x4 = _mm_movelh_ps(r0, r1);        /* f e b a */
-  x1 = glmm_shuff2(r1, r0, 1, 1, 1, 1, 2, 2, 2, 0); /* b b b f */
+  x5 = _mm_movehl_ps(r1, r0);        /* h g d c */
-  x2 = glmm_shuff2(r1, r0, 2, 2, 2, 2, 2, 2, 2, 0); /* c c c g */
+  
-  x3 = glmm_shuff2(r1, r0, 3, 3, 3, 3, 2, 2, 2, 0); /* d d d h */
+  x0 = glmm_shuff1(x4, 0, 0, 0, 2);  /* a a a e */
+  x1 = glmm_shuff1(x4, 1, 1, 1, 3);  /* b b b f */
+  x2 = glmm_shuff1(x5, 0, 0, 0, 2);  /* c c c g */
+  x3 = glmm_shuff1(x5, 1, 1, 1, 3);  /* d d d h */
+  
+  v2 = _mm_mul_ps(x0, t1);
+  v1 = _mm_mul_ps(x0, t0);
+  v3 = _mm_mul_ps(x0, t2);
+  v0 = _mm_mul_ps(x1, t0);
+  
+  v2 = glmm_fnmadd(x1, t3, v2);
+  v3 = glmm_fnmadd(x1, t4, v3);
+  v0 = glmm_fnmadd(x2, t1, v0);
+  v1 = glmm_fnmadd(x2, t3, v1);
+  
+  v3 = glmm_fmadd(x2, t5, v3);
+  v0 = glmm_fmadd(x3, t2, v0);
+  v2 = glmm_fmadd(x3, t5, v2);
+  v1 = glmm_fmadd(x3, t4, v1);
 
   /*
    dest[0][0] =  f * t1[0] - g * t1[1] + h * t1[2];
    dest[0][1] =-(b * t1[0] - c * t1[1] + d * t1[2]);
    dest[0][2] =  b * t2[0] - c * t2[1] + d * t2[2];
    dest[0][3] =-(b * t3[0] - c * t3[1] + d * t3[2]); */
-  v0 = _mm_xor_ps(glmm_fmadd(x3, t2, glmm_fnmadd(x2, t1, _mm_mul_ps(x1, t0))), x8);
+  v0 = _mm_xor_ps(v0, x8);
   
   /*
    dest[2][0] =  e * t1[1] - f * t1[3] + h * t1[5];
    dest[2][1] =-(a * t1[1] - b * t1[3] + d * t1[5]);
    dest[2][2] =  a * t2[1] - b * t2[3] + d * t2[5];
    dest[2][3] =-(a * t3[1] - b * t3[3] + d * t3[5]);*/
-  v2 = _mm_xor_ps(glmm_fmadd(x3, t5, glmm_fnmadd(x1, t3, _mm_mul_ps(x0, t1))), x8);
+  v2 = _mm_xor_ps(v2, x8);
 
   /*
    dest[1][0] =-(e * t1[0] - g * t1[3] + h * t1[4]);
    dest[1][1] =  a * t1[0] - c * t1[3] + d * t1[4];
    dest[1][2] =-(a * t2[0] - c * t2[3] + d * t2[4]);
    dest[1][3] =  a * t3[0] - c * t3[3] + d * t3[4]; */
-  v1 = _mm_xor_ps(glmm_fmadd(x3, t4, glmm_fnmadd(x2, t3, _mm_mul_ps(x0, t0))), x9);
+  v1 = _mm_xor_ps(v1, x9);
 
   /*
    dest[3][0] =-(e * t1[2] - f * t1[4] + g * t1[5]);
    dest[3][1] =  a * t1[2] - b * t1[4] + c * t1[5];
    dest[3][2] =-(a * t2[2] - b * t2[4] + c * t2[5]);
    dest[3][3] =  a * t3[2] - b * t3[4] + c * t3[5]; */
-  v3 = _mm_xor_ps(glmm_fmadd(x2, t5, glmm_fnmadd(x1, t4, _mm_mul_ps(x0, t2))), x9);
+  v3 = _mm_xor_ps(v3, x9);
 
   /* determinant */
   x0 = _mm_shuffle_ps(v0, v1, _MM_SHUFFLE(0, 0, 0, 0));

include/cglm/simd/sse2/quat.h

@@ -22,21 +22,30 @@ glm_quat_mul_sse2(versor p, versor q, versor dest) {
      a1 a2 − b1 b2 − c1 c2 − d1 d2
    */
 
-  __m128 xp, xq, x0, r;
+  __m128 xp, xq, x1, x2, x3, r, x, y, z;
 
   xp = glmm_load(p); /* 3 2 1 0 */
   xq = glmm_load(q);
+  x1 = _mm_set_ps(-0.f, 0.f, -0.f, 0.f); /* TODO: _mm_set1_ss() + shuff ? */
+  r  = _mm_mul_ps(glmm_splat_w(xp), xq);
   
-  r  = _mm_mul_ps(glmm_splat(xp, 3), xq);
+  x2 = _mm_unpackhi_ps(x1, x1);
+  x3 = glmm_shuff1(x1, 3, 2, 0, 1);
+  x  = glmm_splat_x(xp);
+  y  = glmm_splat_y(xp);
+  z  = glmm_splat_z(xp);
 
-  x0 = _mm_xor_ps(glmm_splat(xp, 0), _mm_set_ps(-0.f, 0.f, -0.f, 0.f));
+  x  = _mm_xor_ps(x, x1);
-  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 0, 1, 2, 3)));
+  y  = _mm_xor_ps(y, x2);
+  z  = _mm_xor_ps(z, x3);
   
-  x0 = _mm_xor_ps(glmm_splat(xp, 1), _mm_set_ps(-0.f, -0.f, 0.f, 0.f));
+  x1 = glmm_shuff1(xq, 0, 1, 2, 3);
-  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 1, 0, 3, 2)));
+  x2 = glmm_shuff1(xq, 1, 0, 3, 2);
+  x3 = glmm_shuff1(xq, 2, 3, 0, 1);
   
-  x0 = _mm_xor_ps(glmm_splat(xp, 2), _mm_set_ps(-0.f, 0.f, 0.f, -0.f));
+  r  = glmm_fmadd(x, x1, r);
-  r  = _mm_add_ps(r, _mm_mul_ps(x0, glmm_shuff1(xq, 2, 3, 0, 1)));
+  r  = glmm_fmadd(y, x2, r);
+  r  = glmm_fmadd(z, x3, r);
 
   glmm_store(dest, r);
 }

include/cglm/struct/cam.h

@@ -9,10 +9,10 @@
  Functions:
    CGLM_INLINE mat4s glms_frustum(float left,    float right,
                                   float bottom,  float top,
-                                  float nearVal, float farVal)
+                                  float nearZ,   float farZ)
    CGLM_INLINE mat4s glms_ortho(float left,    float right,
                                 float bottom,  float top,
-                                float nearVal, float farVal)
+                                float nearZ,   float farZ)
    CGLM_INLINE mat4s glms_ortho_aabb(vec3s box[2]);
    CGLM_INLINE mat4s glms_ortho_aabb_p(vec3s box[2],  float padding);
    CGLM_INLINE mat4s glms_ortho_aabb_pz(vec3s box[2], float padding);
@@ -20,8 +20,8 @@
    CGLM_INLINE mat4s glms_ortho_default_s(float aspect, float size)
    CGLM_INLINE mat4s glms_perspective(float fovy,
                                       float aspect,
-                                      float nearVal,
+                                      float nearZ,
-                                      float farVal)
+                                      float farZ)
    CGLM_INLINE void  glms_persp_move_far(mat4s proj, float deltaFar)
    CGLM_INLINE mat4s glms_perspective_default(float aspect)
    CGLM_INLINE void  glms_perspective_resize(mat4s proj, float aspect)
@@ -36,8 +36,8 @@
    CGLM_INLINE void  glms_persp_decomp_x(mat4s proj, float *left, float *right)
    CGLM_INLINE void  glms_persp_decomp_y(mat4s proj, float *top, float *bottom)
    CGLM_INLINE void  glms_persp_decomp_z(mat4s proj, float *nearv, float *farv)
-   CGLM_INLINE void  glms_persp_decomp_far(mat4s proj, float *farVal)
+   CGLM_INLINE void  glms_persp_decomp_far(mat4s proj, float *farZ)
-   CGLM_INLINE void  glms_persp_decomp_near(mat4s proj, float *nearVal)
+   CGLM_INLINE void  glms_persp_decomp_near(mat4s proj, float *nearZ)
    CGLM_INLINE float glms_persp_fovy(mat4s proj)
    CGLM_INLINE float glms_persp_aspect(mat4s proj)
    CGLM_INLINE vec4s glms_persp_sizes(mat4s proj, float fovy)
@@ -51,6 +51,39 @@
 #include "../plane.h"
 #include "../cam.h"
 
+#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
+#  if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+#    include "clipspace/ortho_lh_zo.h"
+#    include "clipspace/persp_lh_zo.h"
+#    include "clipspace/view_lh_zo.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+#    include "clipspace/ortho_lh_no.h"
+#    include "clipspace/persp_lh_no.h"
+#    include "clipspace/view_lh_no.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+#    include "clipspace/ortho_rh_zo.h"
+#    include "clipspace/persp_rh_zo.h"
+#    include "clipspace/view_rh_zo.h"
+#  elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+#    include "clipspace/ortho_rh_no.h"
+#    include "clipspace/persp_rh_no.h"
+#    include "clipspace/view_rh_no.h"
+#  endif
+#else
+#  include "clipspace/ortho_lh_zo.h"
+#  include "clipspace/persp_lh_zo.h"
+#  include "clipspace/ortho_lh_no.h"
+#  include "clipspace/persp_lh_no.h"
+#  include "clipspace/ortho_rh_zo.h"
+#  include "clipspace/persp_rh_zo.h"
+#  include "clipspace/ortho_rh_no.h"
+#  include "clipspace/persp_rh_no.h"
+#  include "clipspace/view_lh_zo.h"
+#  include "clipspace/view_lh_no.h"
+#  include "clipspace/view_rh_zo.h"
+#  include "clipspace/view_rh_no.h"
+#endif
+
 /*!
  * @brief set up perspective peprojection matrix
  *
@@ -58,18 +91,24 @@
  * @param[in]  right   viewport.right
  * @param[in]  bottom  viewport.bottom
  * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping plane
+ * @param[in]  farZ    far clipping plane
  * @returns    result matrix
  */
 CGLM_INLINE
 mat4s
 glms_frustum(float left,   float right,
              float bottom, float top,
-             float nearVal, float farVal) {
+             float nearZ,  float farZ) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_frustum(left, right, bottom, top, nearVal, farVal, dest.raw);
+  return glms_frustum_lh_zo(left, right, bottom, top, nearZ, farZ);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_frustum_lh_no(left, right, bottom, top, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_frustum_rh_zo(left, right, bottom, top, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_frustum_rh_no(left, right, bottom, top, nearZ, farZ);
+#endif
 }
 
 /*!
@@ -79,18 +118,24 @@ glms_frustum(float left,    float right,
  * @param[in]  right   viewport.right
  * @param[in]  bottom  viewport.bottom
  * @param[in]  top     viewport.top
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping plane
+ * @param[in]  farZ    far clipping plane
  * @returns    result matrix
  */
 CGLM_INLINE
 mat4s
 glms_ortho(float left,   float right,
            float bottom, float top,
-           float nearVal, float farVal) {
+           float nearZ,  float farZ) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho(left, right, bottom, top, nearVal, farVal, dest.raw);
+  return glms_ortho_lh_zo(left, right, bottom, top, nearZ, farZ);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_lh_no(left, right, bottom, top, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_rh_zo(left, right, bottom, top, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_rh_no(left, right, bottom, top, nearZ, farZ);
+#endif
 }
 
 /*!
@@ -104,13 +149,15 @@ glms_ortho(float left,    float right,
 CGLM_INLINE
 mat4s
 glms_ortho_aabb(vec3s box[2]) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  vec3  rawBox[2];
+  return glms_ortho_aabb_lh_zo(box);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glms_vec3_unpack(rawBox, box, 2);
+  return glms_ortho_aabb_lh_no(box);
-  glm_ortho_aabb(rawBox, dest.raw);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-
+  return glms_ortho_aabb_rh_zo(box);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_rh_no(box);
+#endif
 }
 
 /*!
@@ -125,13 +172,15 @@ glms_ortho_aabb(vec3s box[2]) {
 CGLM_INLINE
 mat4s
 glms_ortho_aabb_p(vec3s box[2], float padding) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  vec3  rawBox[2];
+  return glms_ortho_aabb_p_lh_zo(box, padding);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glms_vec3_unpack(rawBox, box, 2);
+  return glms_ortho_aabb_p_lh_no(box, padding);
-  glm_ortho_aabb_p(rawBox, padding, dest.raw);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-
+  return glms_ortho_aabb_p_rh_zo(box, padding);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_p_rh_no(box, padding);
+#endif
 }
 
 /*!
@@ -146,13 +195,15 @@ glms_ortho_aabb_p(vec3s box[2], float padding) {
 CGLM_INLINE
 mat4s
 glms_ortho_aabb_pz(vec3s box[2], float padding) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  vec3  rawBox[2];
+  return glms_ortho_aabb_pz_lh_zo(box, padding);
-
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
-  glms_vec3_unpack(rawBox, box, 2);
+  return glms_ortho_aabb_pz_lh_no(box, padding);
-  glm_ortho_aabb_pz(rawBox, padding, dest.raw);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
-
+  return glms_ortho_aabb_pz_rh_zo(box, padding);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_pz_rh_no(box, padding);
+#endif
 }
 
 /*!
@@ -164,9 +215,15 @@ glms_ortho_aabb_pz(vec3s box[2], float padding) {
 CGLM_INLINE
 mat4s
 glms_ortho_default(float aspect) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_default(aspect, dest.raw);
+  return glms_ortho_default_lh_zo(aspect);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_default_lh_no(aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_default_rh_zo(aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_default_rh_no(aspect);
+#endif
 }
 
 /*!
@@ -179,9 +236,15 @@ glms_ortho_default(float aspect) {
 CGLM_INLINE
 mat4s
 glms_ortho_default_s(float aspect, float size) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_ortho_default_s(aspect, size, dest.raw);
+  return glms_ortho_default_s_lh_zo(aspect, size);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_default_s_lh_no(aspect, size);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_default_s_rh_zo(aspect, size);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_default_s_rh_no(aspect, size);
+#endif
 }
 
 /*!
@@ -189,30 +252,48 @@ glms_ortho_default_s(float aspect, float size) {
  *
  * @param[in]  fovy    field of view angle
  * @param[in]  aspect  aspect ratio ( width / height )
- * @param[in]  nearVal near clipping plane
+ * @param[in]  nearZ   near clipping plane
- * @param[in]  farVal  far clipping planes
+ * @param[in]  farZ    far clipping planes
  * @returns    result matrix
  */
 CGLM_INLINE
 mat4s
-glms_perspective(float fovy, float aspect, float nearVal, float farVal) {
+glms_perspective(float fovy, float aspect, float nearZ, float farZ) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_perspective(fovy, aspect, nearVal, farVal, dest.raw);
+  return glms_perspective_lh_zo(fovy, aspect, nearZ, farZ);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_perspective_lh_no(fovy, aspect, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_perspective_rh_zo(fovy, aspect, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_perspective_rh_no(fovy, aspect, nearZ, farZ);
+#endif
 }
 
 /*!
  * @brief extend perspective projection matrix's far distance
  *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glm_persp_move_far(prooj.raw, deltaFar) to avoid create new mat4
+ *       each time
+ *
  * this function does not guarantee far >= near, be aware of that!
  *
  * @param[in, out] proj      projection matrix to extend
  * @param[in]      deltaFar  distance from existing far (negative to shink)
  */
 CGLM_INLINE
-void
+mat4s
 glms_persp_move_far(mat4s proj, float deltaFar) {
-  glm_persp_move_far(proj.raw, deltaFar);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_persp_move_far_lh_zo(proj, deltaFar);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_persp_move_far_lh_no(proj, deltaFar);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_persp_move_far_rh_zo(proj, deltaFar);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_persp_move_far_rh_no(proj, deltaFar);
+#endif
 }
 
 /*!
@@ -225,9 +306,15 @@ glms_persp_move_far(mat4s proj, float deltaFar) {
 CGLM_INLINE
 mat4s
 glms_perspective_default(float aspect) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_perspective_default(aspect, dest.raw);
+  return glms_perspective_default_lh_zo(aspect);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_perspective_default_lh_no(aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_perspective_default_rh_zo(aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_perspective_default_rh_no(aspect);
+#endif
 }
 
 /*!
@@ -235,13 +322,25 @@ glms_perspective_default(float aspect) {
  *        this makes very easy to resize proj matrix when window /viewport
  *        reized
  *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_perspective_resize(proj.raw, aspect) to avoid create new mat4
+ *       each time
+ *
  * @param[in, out] proj   perspective projection matrix
  * @param[in]      aspect aspect ratio ( width / height )
  */
 CGLM_INLINE
-void
+mat4s
 glms_perspective_resize(mat4s proj, float aspect) {
-  glm_perspective_resize(aspect, proj.raw);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_perspective_resize_lh_zo(proj, aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_perspective_resize_lh_no(proj, aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_perspective_resize_rh_zo(proj, aspect);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_perspective_resize_rh_no(proj, aspect);
+#endif
 }
 
 /*!
@@ -258,9 +357,15 @@ glms_perspective_resize(mat4s proj, float aspect) {
 CGLM_INLINE
 mat4s
 glms_lookat(vec3s eye, vec3s center, vec3s up) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_lookat(eye.raw, center.raw, up.raw, dest.raw);
+  return glms_lookat_lh_zo(eye, center, up);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_lookat_lh_no(eye, center, up);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_lookat_rh_zo(eye, center, up);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_lookat_rh_no(eye, center, up);
+#endif
 }
 
 /*!
@@ -280,9 +385,15 @@ glms_lookat(vec3s eye, vec3s center, vec3s up) {
 CGLM_INLINE
 mat4s
 glms_look(vec3s eye, vec3s dir, vec3s up) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_look(eye.raw, dir.raw, up.raw, dest.raw);
+  return glms_look_lh_zo(eye, dir, up);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_look_lh_no(eye, dir, up);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_look_rh_zo(eye, dir, up);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_look_rh_no(eye, dir, up);
+#endif
 }
 
 /*!
@@ -298,17 +409,23 @@ glms_look(vec3s eye, vec3s dir, vec3s up) {
 CGLM_INLINE
 mat4s
 glms_look_anyup(vec3s eye, vec3s dir) {
-  mat4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_look_anyup(eye.raw, dir.raw, dest.raw);
+  return glms_look_anyup_lh_zo(eye, dir);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_look_anyup_lh_no(eye, dir);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_look_anyup_rh_zo(eye, dir);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_look_anyup_rh_no(eye, dir);
+#endif
 }
 
 /*!
  * @brief decomposes frustum values of perspective projection.
  *
  * @param[in]  proj    perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ   near
- * @param[out] farVal  far
+ * @param[out] farZ    far
  * @param[out] top     top
  * @param[out] bottom  bottom
  * @param[out] left    left
@@ -317,10 +434,18 @@ glms_look_anyup(vec3s eye, vec3s dir) {
 CGLM_INLINE
 void
 glms_persp_decomp(mat4s proj,
-                  float * __restrict nearVal, float * __restrict farVal,
+                  float * __restrict nearZ, float * __restrict farZ,
                   float * __restrict top,   float * __restrict bottom,
                   float * __restrict left,  float * __restrict right) {
-  glm_persp_decomp(proj.raw, nearVal, farVal, top, bottom, left, right);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_rh_no(proj, nearZ, farZ, top, bottom, left, right);
+#endif
 }
 
 /*!
@@ -333,7 +458,15 @@ glms_persp_decomp(mat4s proj,
 CGLM_INLINE
 void
 glms_persp_decompv(mat4s proj, float dest[6]) {
-  glm_persp_decompv(proj.raw, dest);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decompv_lh_zo(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decompv_lh_no(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decompv_rh_zo(proj, dest);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decompv_rh_no(proj, dest);
+#endif
 }
 
 /*!
@@ -349,7 +482,15 @@ void
 glms_persp_decomp_x(mat4s proj,
                     float * __restrict left,
                     float * __restrict right) {
-  glm_persp_decomp_x(proj.raw, left, right);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_x_lh_zo(proj, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_x_lh_no(proj, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_x_rh_zo(proj, left, right);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_x_rh_no(proj, left, right);
+#endif
 }
 
 /*!
@@ -365,7 +506,15 @@ void
 glms_persp_decomp_y(mat4s proj,
                     float * __restrict top,
                     float * __restrict bottom) {
-  glm_persp_decomp_y(proj.raw, top, bottom);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_y_lh_zo(proj, top, bottom);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_y_lh_no(proj, top, bottom);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_y_rh_zo(proj, top, bottom);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_y_rh_no(proj, top, bottom);
+#endif
 }
 
 /*!
@@ -373,39 +522,63 @@ glms_persp_decomp_y(mat4s proj,
  *        z stands for z axis (near / far axis)
  *
  * @param[in]  proj    perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ   near
- * @param[out] farVal  far
+ * @param[out] farZ    far
  */
 CGLM_INLINE
 void
 glms_persp_decomp_z(mat4s proj,
-                    float * __restrict nearVal,
+                    float * __restrict nearZ,
-                    float * __restrict farVal) {
+                    float * __restrict farZ) {
-  glm_persp_decomp_z(proj.raw, nearVal, farVal);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_z_lh_zo(proj, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_z_lh_no(proj, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_z_rh_zo(proj, nearZ, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_z_rh_no(proj, nearZ, farZ);
+#endif
 }
 
 /*!
  * @brief decomposes far value of perspective projection.
  *
  * @param[in]  proj   perspective projection matrix
- * @param[out] farVal far
+ * @param[out] farZ   far
  */
 CGLM_INLINE
 void
-glms_persp_decomp_far(mat4s proj, float * __restrict farVal) {
+glms_persp_decomp_far(mat4s proj, float * __restrict farZ) {
-  glm_persp_decomp_far(proj.raw, farVal);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_far_lh_zo(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_far_lh_no(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_far_rh_zo(proj, farZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_far_rh_no(proj, farZ);
+#endif
 }
 
 /*!
  * @brief decomposes near value of perspective projection.
  *
  * @param[in]  proj  perspective projection matrix
- * @param[out] nearVal near
+ * @param[out] nearZ near
  */
 CGLM_INLINE
 void
-glms_persp_decomp_near(mat4s proj, float * __restrict nearVal) {
+glms_persp_decomp_near(mat4s proj, float * __restrict nearZ) {
-  glm_persp_decomp_near(proj.raw, nearVal);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  glms_persp_decomp_near_lh_zo(proj, nearZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  glms_persp_decomp_near_lh_no(proj, nearZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  glms_persp_decomp_near_rh_zo(proj, nearZ);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  glms_persp_decomp_near_rh_no(proj, nearZ);
+#endif
 }
 
 /*!
@@ -419,7 +592,15 @@ glms_persp_decomp_near(mat4s proj, float * __restrict nearVal) {
 CGLM_INLINE
 float
 glms_persp_fovy(mat4s proj) {
-  return glm_persp_fovy(proj.raw);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_persp_fovy_lh_zo(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_persp_fovy_lh_no(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_persp_fovy_rh_zo(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_persp_fovy_rh_no(proj);
+#endif
 }
 
 /*!
@@ -430,7 +611,15 @@ glms_persp_fovy(mat4s proj) {
 CGLM_INLINE
 float
 glms_persp_aspect(mat4s proj) {
-  return glm_persp_aspect(proj.raw);
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_persp_aspect_lh_zo(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_persp_aspect_lh_no(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_persp_aspect_rh_zo(proj);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_persp_aspect_rh_no(proj);
+#endif
 }
 
 /*!
@@ -443,9 +632,15 @@ glms_persp_aspect(mat4s proj) {
 CGLM_INLINE
 vec4s
 glms_persp_sizes(mat4s proj, float fovy) {
-  vec4s dest;
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
-  glm_persp_sizes(proj.raw, fovy, dest.raw);
+  return glms_persp_sizes_lh_zo(proj, fovy);
-  return dest;
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_persp_sizes_lh_no(proj, fovy);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_persp_sizes_rh_zo(proj, fovy);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_persp_sizes_rh_no(proj, fovy);
+#endif
 }
 
 #endif /* cglms_cam_h */

include/cglm/struct/clipspace/ortho_lh_no.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_ortho_lh_no(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_ortho_aabb_lh_no(vec3s box[2]);
+   CGLM_INLINE mat4s glms_ortho_aabb_p_lh_no(vec3s box[2],  float padding);
+   CGLM_INLINE mat4s glms_ortho_aabb_pz_lh_no(vec3s box[2], float padding);
+   CGLM_INLINE mat4s glms_ortho_default_lh_no(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s_lh_no(float aspect, float size)
+ */
+
+#ifndef cglms_ortho_lh_no_h
+#define cglms_ortho_lh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_lh_no(float left,   float right,
+                 float bottom, float top,
+                 float nearZ,  float farZ) {
+  mat4s dest;
+  glm_ortho_lh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_lh_no(vec3s box[2]) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_lh_no(rawBox, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_p_lh_no(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_p_lh_no(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_pz_lh_no(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_pz_lh_no(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_lh_no(float aspect) {
+  mat4s dest;
+  glm_ortho_default_lh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s_lh_no(float aspect, float size) {
+  mat4s dest;
+  glm_ortho_default_s_lh_no(aspect, size, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_ortho_lh_no_h */

include/cglm/struct/clipspace/ortho_lh_zo.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_ortho_lh_zo(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_ortho_aabb_lh_zo(vec3s box[2]);
+   CGLM_INLINE mat4s glms_ortho_aabb_p_lh_zo(vec3s box[2],  float padding);
+   CGLM_INLINE mat4s glms_ortho_aabb_pz_lh_zo(vec3s box[2], float padding);
+   CGLM_INLINE mat4s glms_ortho_default_lh_zo(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s_lh_zo(float aspect, float size)
+ */
+
+#ifndef cglms_ortho_lh_zo_h
+#define cglms_ortho_lh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_lh_zo(float left,   float right,
+                 float bottom, float top,
+                 float nearZ,  float farZ) {
+  mat4s dest;
+  glm_ortho_lh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_lh_zo(vec3s box[2]) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_lh_zo(rawBox, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_p_lh_zo(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_p_lh_zo(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_pz_lh_zo(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_pz_lh_zo(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_lh_zo(float aspect) {
+  mat4s dest;
+  glm_ortho_default_lh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s_lh_zo(float aspect, float size) {
+  mat4s dest;
+  glm_ortho_default_s_lh_zo(aspect, size, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_ortho_lh_zo_h */

include/cglm/struct/clipspace/ortho_rh_no.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_ortho_rh_no(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_ortho_aabb_rh_no(vec3s box[2]);
+   CGLM_INLINE mat4s glms_ortho_aabb_p_rh_no(vec3s box[2],  float padding);
+   CGLM_INLINE mat4s glms_ortho_aabb_pz_rh_no(vec3s box[2], float padding);
+   CGLM_INLINE mat4s glms_ortho_default_rh_no(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s_rh_no(float aspect, float size)
+ */
+
+#ifndef cglms_ortho_rh_no_h
+#define cglms_ortho_rh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_rh_no(float left,   float right,
+                 float bottom, float top,
+                 float nearZ,  float farZ) {
+  mat4s dest;
+  glm_ortho_rh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_rh_no(vec3s box[2]) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_rh_no(rawBox, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_p_rh_no(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_p_rh_no(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_pz_rh_no(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_pz_rh_no(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_rh_no(float aspect) {
+  mat4s dest;
+  glm_ortho_default_rh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s_rh_no(float aspect, float size) {
+  mat4s dest;
+  glm_ortho_default_s_rh_no(aspect, size, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_ortho_rh_no_h */

include/cglm/struct/clipspace/ortho_rh_zo.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_ortho_rh_zo(float left,    float right,
+                                      float bottom,  float top,
+                                      float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_ortho_aabb_rh_zo(vec3s box[2]);
+   CGLM_INLINE mat4s glms_ortho_aabb_p_rh_zo(vec3s box[2],  float padding);
+   CGLM_INLINE mat4s glms_ortho_aabb_pz_rh_zo(vec3s box[2], float padding);
+   CGLM_INLINE mat4s glms_ortho_default_rh_zo(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s_rh_zo(float aspect, float size)
+ */
+
+#ifndef cglms_ortho_rh_zo_h
+#define cglms_ortho_rh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_rh_zo(float left,   float right,
+                 float bottom, float top,
+                 float nearZ,  float farZ) {
+  mat4s dest;
+  glm_ortho_rh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_rh_zo(vec3s box[2]) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_rh_zo(rawBox, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_p_rh_zo(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_p_rh_zo(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box     AABB
+ * @param[in]  padding padding for near and far
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb_pz_rh_zo(vec3s box[2], float padding) {
+  mat4s dest;
+  vec3  rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_ortho_aabb_pz_rh_zo(rawBox, padding, dest.raw);
+
+  return dest;
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_rh_zo(float aspect) {
+  mat4s dest;
+  glm_ortho_default_rh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s_rh_zo(float aspect, float size) {
+  mat4s dest;
+  glm_ortho_default_s_rh_zo(aspect, size, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_ortho_rh_zo_h */

include/cglm/struct/clipspace/persp_lh_no.h

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum_lh_no(float left,    float right,
+                                        float bottom,  float top,
+                                        float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_perspective_lh_no(float fovy,
+                                            float aspect,
+                                            float nearZ,
+                                            float farZ)
+   CGLM_INLINE void  glms_persp_move_far_lh_no(mat4s proj, float deltaFar)
+   CGLM_INLINE mat4s glms_perspective_default_lh_no(float aspect)
+   CGLM_INLINE void  glms_perspective_resize_lh_no(mat4s proj, float aspect)
+   CGLM_INLINE void  glms_persp_decomp_lh_no(mat4s  proj,
+                                             float *nearv, float *farv,
+                                             float *top,   float *bottom,
+                                             float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv_lh_no(mat4s proj, float dest[6])
+   CGLM_INLINE void  glms_persp_decomp_x_lh_no(mat4s proj, float *left, float *right)
+   CGLM_INLINE void  glms_persp_decomp_y_lh_no(mat4s proj, float *top, float *bottom)
+   CGLM_INLINE void  glms_persp_decomp_z_lh_no(mat4s proj, float *nearv, float *farv)
+   CGLM_INLINE void  glms_persp_decomp_far_lh_no(mat4s proj, float *farZ)
+   CGLM_INLINE void  glms_persp_decomp_near_lh_no(mat4s proj, float *nearZ)
+   CGLM_INLINE float glms_persp_fovy_lh_no(mat4s proj)
+   CGLM_INLINE float glms_persp_aspect_lh_no(mat4s proj)
+   CGLM_INLINE vec4s glms_persp_sizes_lh_no(mat4s proj, float fovy)
+ */
+
+#ifndef cglms_persp_lh_no_h
+#define cglms_persp_lh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_frustum_lh_no(float left,   float right,
+                   float bottom, float top,
+                   float nearZ,  float farZ) {
+  mat4s dest;
+  glm_frustum_lh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_lh_no(float fovy, float aspect, float nearZ, float farZ) {
+  mat4s dest;
+  glm_perspective_lh_no(fovy, aspect, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_persp_move_far_lh_no(prooj.raw, deltaFar) to avoid create new mat4
+ *       each time
+ *       
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+mat4s
+glms_persp_move_far_lh_no(mat4s proj, float deltaFar) {
+  mat4s dest;
+  dest = proj;
+  glm_persp_move_far_lh_no(dest.raw, deltaFar);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default_lh_no(float aspect) {
+  mat4s dest;
+  glm_perspective_default_lh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glm_perspective_resize_lh_no(proj.raw, aspect) to avoid create new mat4
+ *       each time
+ *       
+ * @param[in, out] proj   perspective projection matrix
+ * @param[in]      aspect aspect ratio ( width / height )
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_resize_lh_no(mat4s proj, float aspect) {
+  mat4s dest;
+  dest = proj;
+  glm_perspective_resize_lh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_lh_no(mat4s proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_lh_no(proj.raw, nearZ, farZ, top, bottom, left, right);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv_lh_no(mat4s proj, float dest[6]) {
+  glm_persp_decompv_lh_no(proj.raw, dest);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_x_lh_no(mat4s proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_lh_no(proj.raw, left, right);
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_y_lh_no(mat4s proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_lh_no(proj.raw, top, bottom);
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_z_lh_no(mat4s proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_lh_no(proj.raw, nearZ, farZ);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far_lh_no(mat4s proj, float * __restrict farZ) {
+  glm_persp_decomp_far_lh_no(proj.raw, farZ);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] nearZ near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near_lh_no(mat4s proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_lh_no(proj.raw, nearZ);
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_fovy_lh_no(mat4s proj) {
+  return glm_persp_fovy_lh_no(proj.raw);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect_lh_no(mat4s proj) {
+  return glm_persp_aspect_lh_no(proj.raw);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @returns    sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+vec4s
+glms_persp_sizes_lh_no(mat4s proj, float fovy) {
+  vec4s dest;
+  glm_persp_sizes_lh_no(proj.raw, fovy, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_persp_lh_no_h */

include/cglm/struct/clipspace/persp_lh_zo.h

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum_lh_zo(float left,    float right,
+                                        float bottom,  float top,
+                                        float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_perspective_lh_zo(float fovy,
+                                            float aspect,
+                                            float nearZ,
+                                            float farZ)
+   CGLM_INLINE void  glms_persp_move_far_lh_zo(mat4s proj, float deltaFar)
+   CGLM_INLINE mat4s glms_perspective_default_lh_zo(float aspect)
+   CGLM_INLINE void  glms_perspective_resize_lh_zo(mat4s proj, float aspect)
+   CGLM_INLINE void  glms_persp_decomp_lh_zo(mat4s  proj,
+                                             float *nearv, float *farv,
+                                             float *top,   float *bottom,
+                                             float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv_lh_zo(mat4s proj, float dest[6])
+   CGLM_INLINE void  glms_persp_decomp_x_lh_zo(mat4s proj, float *left, float *right)
+   CGLM_INLINE void  glms_persp_decomp_y_lh_zo(mat4s proj, float *top, float *bottom)
+   CGLM_INLINE void  glms_persp_decomp_z_lh_zo(mat4s proj, float *nearv, float *farv)
+   CGLM_INLINE void  glms_persp_decomp_far_lh_zo(mat4s proj, float *farZ)
+   CGLM_INLINE void  glms_persp_decomp_near_lh_zo(mat4s proj, float *nearZ)
+   CGLM_INLINE float glms_persp_fovy_lh_zo(mat4s proj)
+   CGLM_INLINE float glms_persp_aspect_lh_zo(mat4s proj)
+   CGLM_INLINE vec4s glms_persp_sizes_lh_zo(mat4s proj, float fovy)
+ */
+
+#ifndef cglms_persp_lh_zo_h
+#define cglms_persp_lh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_frustum_lh_zo(float left,   float right,
+                   float bottom, float top,
+                   float nearZ,  float farZ) {
+  mat4s dest;
+  glm_frustum_lh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_lh_zo(float fovy, float aspect, float nearZ, float farZ) {
+  mat4s dest;
+  glm_perspective_lh_zo(fovy, aspect, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_persp_move_far_lh_zo(prooj.raw, deltaFar) to avoid create new mat4
+ *       each time
+ *
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+mat4s
+glms_persp_move_far_lh_zo(mat4s proj, float deltaFar) {
+  mat4s dest;
+  dest = proj;
+  glm_persp_move_far_lh_zo(dest.raw, deltaFar);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default_lh_zo(float aspect) {
+  mat4s dest;
+  glm_perspective_default_lh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_perspective_resize_lh_zo(proj.raw, aspect) to avoid create new mat4
+ *       each time
+ *       
+ * @param[in, out] proj   perspective projection matrix
+ * @param[in]      aspect aspect ratio ( width / height )
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_resize_lh_zo(mat4s proj, float aspect) {
+  mat4s dest;
+  dest = proj;
+  glm_perspective_resize_lh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_lh_zo(mat4s proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_lh_zo(proj.raw, nearZ, farZ, top, bottom, left, right);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv_lh_zo(mat4s proj, float dest[6]) {
+  glm_persp_decompv_lh_zo(proj.raw, dest);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_x_lh_zo(mat4s proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_lh_zo(proj.raw, left, right);
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_y_lh_zo(mat4s proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_lh_zo(proj.raw, top, bottom);
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_z_lh_zo(mat4s proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_lh_zo(proj.raw, nearZ, farZ);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far_lh_zo(mat4s proj, float * __restrict farZ) {
+  glm_persp_decomp_far_lh_zo(proj.raw, farZ);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] nearZ near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near_lh_zo(mat4s proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_lh_zo(proj.raw, nearZ);
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_fovy_lh_zo(mat4s proj) {
+  return glm_persp_fovy_lh_zo(proj.raw);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect_lh_zo(mat4s proj) {
+  return glm_persp_aspect_lh_zo(proj.raw);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @returns    sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+vec4s
+glms_persp_sizes_lh_zo(mat4s proj, float fovy) {
+  vec4s dest;
+  glm_persp_sizes_lh_zo(proj.raw, fovy, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_persp_lh_zo_h */

include/cglm/struct/clipspace/persp_rh_no.h

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum_rh_no(float left,    float right,
+                                        float bottom,  float top,
+                                        float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_perspective_rh_no(float fovy,
+                                            float aspect,
+                                            float nearZ,
+                                            float farZ)
+   CGLM_INLINE void  glms_persp_move_far_rh_no(mat4s proj, float deltaFar)
+   CGLM_INLINE mat4s glms_perspective_default_rh_no(float aspect)
+   CGLM_INLINE void  glms_perspective_resize_rh_no(mat4s proj, float aspect)
+   CGLM_INLINE void  glms_persp_decomp_rh_no(mat4s  proj,
+                                             float *nearv, float *farv,
+                                             float *top,   float *bottom,
+                                             float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv_rh_no(mat4s proj, float dest[6])
+   CGLM_INLINE void  glms_persp_decomp_x_rh_no(mat4s proj, float *left, float *right)
+   CGLM_INLINE void  glms_persp_decomp_y_rh_no(mat4s proj, float *top, float *bottom)
+   CGLM_INLINE void  glms_persp_decomp_z_rh_no(mat4s proj, float *nearv, float *farv)
+   CGLM_INLINE void  glms_persp_decomp_far_rh_no(mat4s proj, float *farZ)
+   CGLM_INLINE void  glms_persp_decomp_near_rh_no(mat4s proj, float *nearZ)
+   CGLM_INLINE float glms_persp_fovy_rh_no(mat4s proj)
+   CGLM_INLINE float glms_persp_aspect_rh_no(mat4s proj)
+   CGLM_INLINE vec4s glms_persp_sizes_rh_no(mat4s proj, float fovy)
+ */
+
+#ifndef cglms_persp_rh_no_h
+#define cglms_persp_rh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_frustum_rh_no(float left,   float right,
+                   float bottom, float top,
+                   float nearZ,  float farZ) {
+  mat4s dest;
+  glm_frustum_rh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_rh_no(float fovy, float aspect, float nearZ, float farZ) {
+  mat4s dest;
+  glm_perspective_rh_no(fovy, aspect, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_persp_move_far_rh_no(prooj.raw, deltaFar) to avoid create new mat4
+ *       each time
+ *       s
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+mat4s
+glms_persp_move_far_rh_no(mat4s proj, float deltaFar) {
+  mat4s dest;
+  dest = proj;
+  glm_persp_move_far_rh_no(dest.raw, deltaFar);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default_rh_no(float aspect) {
+  mat4s dest;
+  glm_perspective_default_rh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glm_perspective_resize_rh_no(proj.raw, aspect) to avoid create new mat4
+ *       each time
+ *       
+ * @param[in, out] proj   perspective projection matrix
+ * @param[in]      aspect aspect ratio ( width / height )
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_resize_rh_no(mat4s proj, float aspect) {
+  mat4s dest;
+  dest = proj;
+  glm_perspective_resize_rh_no(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_rh_no(mat4s proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_rh_no(proj.raw, nearZ, farZ, top, bottom, left, right);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv_rh_no(mat4s proj, float dest[6]) {
+  glm_persp_decompv_rh_no(proj.raw, dest);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_x_rh_no(mat4s proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_rh_no(proj.raw, left, right);
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_y_rh_no(mat4s proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_rh_no(proj.raw, top, bottom);
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_z_rh_no(mat4s proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_rh_no(proj.raw, nearZ, farZ);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far_rh_no(mat4s proj, float * __restrict farZ) {
+  glm_persp_decomp_far_rh_no(proj.raw, farZ);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] nearZ near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near_rh_no(mat4s proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_rh_no(proj.raw, nearZ);
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_fovy_rh_no(mat4s proj) {
+  return glm_persp_fovy_rh_no(proj.raw);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect_rh_no(mat4s proj) {
+  return glm_persp_aspect_rh_no(proj.raw);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @returns    sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+vec4s
+glms_persp_sizes_rh_no(mat4s proj, float fovy) {
+  vec4s dest;
+  glm_persp_sizes_rh_no(proj.raw, fovy, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_persp_rh_no_h */

include/cglm/struct/clipspace/persp_rh_zo.h

@@ -0,0 +1,311 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum_rh_zo(float left,    float right,
+                                        float bottom,  float top,
+                                        float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_perspective_rh_zo(float fovy,
+                                            float aspect,
+                                            float nearZ,
+                                            float farZ)
+   CGLM_INLINE void  glms_persp_move_far_rh_zo(mat4s proj, float deltaFar)
+   CGLM_INLINE mat4s glms_perspective_default_rh_zo(float aspect)
+   CGLM_INLINE void  glms_perspective_resize_rh_zo(mat4s proj, float aspect)
+   CGLM_INLINE void  glms_persp_decomp_rh_zo(mat4s  proj,
+                                             float *nearv, float *farv,
+                                             float *top,   float *bottom,
+                                             float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv_rh_zo(mat4s proj, float dest[6])
+   CGLM_INLINE void  glms_persp_decomp_x_rh_zo(mat4s proj, float *left, float *right)
+   CGLM_INLINE void  glms_persp_decomp_y_rh_zo(mat4s proj, float *top, float *bottom)
+   CGLM_INLINE void  glms_persp_decomp_z_rh_zo(mat4s proj, float *nearv, float *farv)
+   CGLM_INLINE void  glms_persp_decomp_far_rh_zo(mat4s proj, float *farZ)
+   CGLM_INLINE void  glms_persp_decomp_near_rh_zo(mat4s proj, float *nearZ)
+   CGLM_INLINE float glms_persp_fovy_rh_zo(mat4s proj)
+   CGLM_INLINE float glms_persp_aspect_rh_zo(mat4s proj)
+   CGLM_INLINE vec4s glms_persp_sizes_rh_zo(mat4s proj, float fovy)
+ */
+
+#ifndef cglms_persp_rh_zo_h
+#define cglms_persp_rh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up perspective peprojection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  left    viewport.left
+ * @param[in]  right   viewport.right
+ * @param[in]  bottom  viewport.bottom
+ * @param[in]  top     viewport.top
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping plane
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_frustum_rh_zo(float left,   float right,
+                   float bottom, float top,
+                   float nearZ,  float farZ) {
+  mat4s dest;
+  glm_frustum_rh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  fovy    field of view angle
+ * @param[in]  aspect  aspect ratio ( width / height )
+ * @param[in]  nearZ   near clipping plane
+ * @param[in]  farZ    far clipping planes
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_rh_zo(float fovy, float aspect, float nearZ, float farZ) {
+  mat4s dest;
+  glm_perspective_rh_zo(fovy, aspect, nearZ, farZ, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief extend perspective projection matrix's far distance
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glms_persp_move_far_rh_zo(prooj.raw, deltaFar) to avoid create new mat4
+ *       each time
+ *       
+ * this function does not guarantee far >= near, be aware of that!
+ *
+ * @param[in, out] proj      projection matrix to extend
+ * @param[in]      deltaFar  distance from existing far (negative to shink)
+ */
+CGLM_INLINE
+mat4s
+glms_persp_move_far_rh_zo(mat4s proj, float deltaFar) {
+  mat4s dest;
+  dest = proj;
+  glm_persp_move_far_rh_zo(dest.raw, deltaFar);
+  return dest;
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default_rh_zo(float aspect) {
+  mat4s dest;
+  glm_perspective_default_rh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        this makes very easy to resize proj matrix when window /viewport
+ *        reized with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: if you dodn't want to create new matrix then use array api on struct.raw
+ *       like glm_perspective_resize_rh_zo(proj.raw, aspect) to avoid create new mat4
+ *       each time
+ *       
+ * @param[in, out] proj   perspective projection matrix
+ * @param[in]      aspect aspect ratio ( width / height )
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_resize_rh_zo(mat4s proj, float aspect) {
+  mat4s dest;
+  dest = proj;
+  glm_perspective_resize_rh_zo(aspect, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ * @param[out] top     top
+ * @param[out] bottom  bottom
+ * @param[out] left    left
+ * @param[out] right   right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_rh_zo(mat4s proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_rh_zo(proj.raw, nearZ, farZ, top, bottom, left, right);
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv_rh_zo(mat4s proj, float dest[6]) {
+  glm_persp_decompv_rh_zo(proj.raw, dest);
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        x stands for x axis (left / right axis)
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] left  left
+ * @param[out] right right
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_x_rh_zo(mat4s proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_rh_zo(proj.raw, left, right);
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        y stands for y axis (top / botom axis)
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] top    top
+ * @param[out] bottom bottom
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_y_rh_zo(mat4s proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_rh_zo(proj.raw, top, bottom);
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *        z stands for z axis (near / far axis)
+ *
+ * @param[in]  proj    perspective projection matrix
+ * @param[out] nearZ   near
+ * @param[out] farZ    far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_z_rh_zo(mat4s proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_rh_zo(proj.raw, nearZ, farZ);
+}
+
+/*!
+ * @brief decomposes far value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] farZ   far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far_rh_zo(mat4s proj, float * __restrict farZ) {
+  glm_persp_decomp_far_rh_zo(proj.raw, farZ);
+}
+
+/*!
+ * @brief decomposes near value of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj  perspective projection matrix
+ * @param[out] nearZ near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near_rh_zo(mat4s proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_rh_zo(proj.raw, nearZ);
+}
+
+/*!
+ * @brief returns field of view angle along the Y-axis (in radians)
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * if you need to degrees, use glm_deg to convert it or use this:
+ * fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_fovy_rh_zo(mat4s proj) {
+  return glm_persp_fovy_rh_zo(proj.raw);
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect_rh_zo(mat4s proj) {
+  return glm_persp_aspect_rh_zo(proj.raw);
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * @param[in]  proj perspective projection matrix
+ * @param[in]  fovy fovy (see brief)
+ * @returns    sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
+ */
+CGLM_INLINE
+vec4s
+glms_persp_sizes_rh_zo(mat4s proj, float fovy) {
+  vec4s dest;
+  glm_persp_sizes_rh_zo(proj.raw, fovy, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_persp_rh_zo_h */

include/cglm/struct/clipspace/view_lh_no.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_lookat_lh_no(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look_lh_no(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup_lh_no(vec3s eye, vec3s dir)
+ */
+
+#ifndef cglms_view_lh_no_h
+#define cglms_view_lh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_lookat_lh_no(vec3s eye, vec3s center, vec3s up) {
+  mat4s dest;
+  glm_lookat_lh_no(eye.raw, center.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_lh_no(vec3s eye, vec3s dir, vec3s up) {
+  mat4s dest;
+  glm_look_lh_no(eye.raw, dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_anyup_lh_no(vec3s eye, vec3s dir) {
+  mat4s dest;
+  glm_look_anyup_lh_no(eye.raw, dir.raw, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_view_lh_no_h */

include/cglm/struct/clipspace/view_lh_zo.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_lookat_lh_zo(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look_lh_zo(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup_lh_zo(vec3s eye, vec3s dir)
+ */
+
+#ifndef cglms_view_lh_zo_h
+#define cglms_view_lh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_lookat_lh_zo(vec3s eye, vec3s center, vec3s up) {
+  mat4s dest;
+  glm_lookat_lh_zo(eye.raw, center.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_lh_zo(vec3s eye, vec3s dir, vec3s up) {
+  mat4s dest;
+  glm_look_lh_zo(eye.raw, dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a left-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_anyup_lh_zo(vec3s eye, vec3s dir) {
+  mat4s dest;
+  glm_look_anyup_lh_zo(eye.raw, dir.raw, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_view_lh_zo_h */

include/cglm/struct/clipspace/view_rh_no.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_lookat_rh_no(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look_rh_no(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup_rh_no(vec3s eye, vec3s dir)
+ */
+
+#ifndef cglms_view_rh_no_h
+#define cglms_view_rh_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_lookat_rh_no(vec3s eye, vec3s center, vec3s up) {
+  mat4s dest;
+  glm_lookat_rh_no(eye.raw, center.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_rh_no(vec3s eye, vec3s dir, vec3s up) {
+  mat4s dest;
+  glm_look_rh_no(eye.raw, dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [-1, 1].
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_anyup_rh_no(vec3s eye, vec3s dir) {
+  mat4s dest;
+  glm_look_anyup_rh_no(eye.raw, dir.raw, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_view_rh_no_h */

include/cglm/struct/clipspace/view_rh_zo.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), htt../opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_lookat_rh_zo(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look_rh_zo(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup_rh_zo(vec3s eye, vec3s dir)
+ */
+
+#ifndef cglms_view_rh_zo_h
+#define cglms_view_rh_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  center center vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_lookat_rh_zo(vec3s eye, vec3s center, vec3s up) {
+  mat4s dest;
+  glm_lookat_rh_zo(eye.raw, center.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * convenient wrapper for lookat: if you only have direction not target self
+ * then this might be useful. Because you need to get target from direction.
+ *
+ * NOTE: The UP vector must not be parallel to the line of sight from
+ *       the eye point to the reference point
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @param[in]  up     up vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_rh_zo(vec3s eye, vec3s dir, vec3s up) {
+  mat4s dest;
+  glm_look_rh_zo(eye.raw, dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief set up view matrix
+ *        with a right-hand coordinate system and a
+ *        clip-space of [0, 1].
+ *
+ * convenient wrapper for look: if you only have direction and if you don't
+ * care what UP vector is then this might be useful to create view matrix
+ *
+ * @param[in]  eye    eye vector
+ * @param[in]  dir    direction vector
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_look_anyup_rh_zo(vec3s eye, vec3s dir) {
+  mat4s dest;
+  glm_look_anyup_rh_zo(eye.raw, dir.raw, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_view_rh_zo_h */

include/cglm/struct/quat.h

@@ -34,6 +34,7 @@
    CGLM_INLINE mat3s   glms_quat_mat3t(versors q)
    CGLM_INLINE versors glms_quat_lerp(versors from, versors to, float t)
    CGLM_INLINE versors glms_quat_lerpc(versors from, versors to, float t)
+   CGLM_INLINE versors glms_quat_nlerp(versors from, versors to, float t)
    CGLM_INLINE versors glms_quat_slerp(versors from, versors to, float t)
    CGLM_INLINE mat4s.  glms_quat_look(vec3s eye, versors ori)
    CGLM_INLINE versors glms_quat_for(vec3s dir, vec3s fwd, vec3s up)
@@ -401,6 +402,24 @@ glms_quat_lerpc(versors from, versors to, float t) {
   return dest;
 }
 
+/*!
+ * @brief interpolates between two quaternions
+ *        taking the shortest rotation path using
+ *        normalized linear interpolation (NLERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount)
+ * @param[out]  dest  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_nlerp(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_nlerp(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
 /*!
  * @brief interpolates between two quaternions
  *        using spherical linear interpolation (SLERP)

include/cglm/version.h

@@ -10,6 +10,6 @@
 
 #define CGLM_VERSION_MAJOR 0
 #define CGLM_VERSION_MINOR 8
-#define CGLM_VERSION_PATCH 2
+#define CGLM_VERSION_PATCH 3
 
 #endif /* cglm_version_h */

meson.build

@@ -1,5 +1,5 @@
 project('cglm', 'c',
-    version : '0.8.2', 
+    version : '0.8.3',
     license : 'mit',
     default_options : [
         'c_std=c11',
@@ -48,14 +48,28 @@ cglm_src = files(
     'src/sphere.c',
     'src/vec2.c',
     'src/vec3.c',
-    'src/vec4.c'
+    'src/vec4.c',
+    'src/clipspace/ortho_lh_no.c',
+    'src/clipspace/ortho_lh_zo.c',
+    'src/clipspace/ortho_rh_no.c',
+    'src/clipspace/ortho_rh_zo.c',
+    'src/clipspace/persp_lh_no.c',
+    'src/clipspace/persp_lh_zo.c',
+    'src/clipspace/persp_rh_no.c',
+    'src/clipspace/persp_rh_zo.c',
+    'src/clipspace/view_lh_no.c',
+    'src/clipspace/view_lh_zo.c',
+    'src/clipspace/view_rh_no.c',
+    'src/clipspace/view_rh_zo.c',
 )
 
 cglm_lib = library('cglm',
     cglm_src,
     install : cglm_install,
     dependencies : cglm_deps,
-    c_args : [ build_args, cglm_args ]
+    c_args : [ build_args, cglm_args ],
+    version : meson.project_version(),
+    soversion : '0'
 )
 
 cglm_dep = declare_dependency(
@@ -88,13 +102,17 @@ if get_option('build_tests') == true
 
 test_src = files(
     'test/runner.c',
-    'test/src/test_euler.c',
     'test/src/test_bezier.c',
     'test/src/test_cam.c',
-    'test/src/test_struct.c',
+    'test/src/test_cam_lh_no.c',
+    'test/src/test_cam_lh_zo.c',
+    'test/src/test_cam_rh_no.c',
+    'test/src/test_cam_rh_zo.c',
     'test/src/test_clamp.c',
     'test/src/test_common.c',
-    'test/src/tests.c'
+    'test/src/test_euler.c',
+    'test/src/tests.c',
+    'test/src/test_struct.c',
 )
 
 test_exe = executable('tests',

src/cam.c

@@ -10,38 +10,20 @@
 
 CGLM_EXPORT
 void
-glmc_frustum(float left,
+glmc_frustum(float left,   float right,
-             float right,
+             float bottom, float top,
-             float bottom,
+             float nearZ,  float farZ,
-             float top,
-             float nearVal,
-             float farVal,
              mat4 dest) {
-  glm_frustum(left,
+  glm_frustum(left, right, bottom, top, nearZ, farZ, dest);
-              right,
-              bottom,
-              top,
-              nearVal,
-              farVal,
-              dest);
 }
 
 CGLM_EXPORT
 void
-glmc_ortho(float left,
+glmc_ortho(float left,   float right,
-           float right,
+           float bottom, float top,
-           float bottom,
+           float nearZ,  float farZ,
-           float top,
-           float nearVal,
-           float farVal,
            mat4  dest) {
-  glm_ortho(left,
+  glm_ortho(left, right, bottom, top, nearZ, farZ, dest);
-            right,
-            bottom,
-            top,
-            nearVal,
-            farVal,
-            dest);
 }
 
 CGLM_EXPORT
@@ -76,16 +58,8 @@ glmc_ortho_default_s(float aspect, float size, mat4 dest) {
 
 CGLM_EXPORT
 void
-glmc_perspective(float fovy,
+glmc_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest) {
-                 float aspect,
+  glm_perspective(fovy, aspect, nearZ, farZ, dest);
-                 float nearVal,
-                 float farVal,
-                 mat4 dest) {
-  glm_perspective(fovy,
-                  aspect,
-                  nearVal,
-                  farVal,
-                  dest);
 }
 
 CGLM_EXPORT
@@ -108,10 +82,7 @@ glmc_perspective_resize(float aspect, mat4 proj) {
 
 CGLM_EXPORT
 void
-glmc_lookat(vec3 eye,
+glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
-            vec3 center,
-            vec3 up,
-            mat4 dest) {
   glm_lookat(eye, center, up, dest);
 }
 
@@ -130,13 +101,13 @@ glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
 CGLM_EXPORT
 void
 glmc_persp_decomp(mat4 proj,
-                  float * __restrict nearVal,
+                  float * __restrict nearZ,
-                  float * __restrict farVal,
+                  float * __restrict farZ,
                   float * __restrict top,
                   float * __restrict bottom,
                   float * __restrict left,
                   float * __restrict right) {
-  glm_persp_decomp(proj, nearVal, farVal, top, bottom, left, right);
+  glm_persp_decomp(proj, nearZ, farZ, top, bottom, left, right);
 }
 
 CGLM_EXPORT
@@ -164,21 +135,21 @@ glmc_persp_decomp_y(mat4 proj,
 CGLM_EXPORT
 void
 glmc_persp_decomp_z(mat4 proj,
-                    float * __restrict nearVal,
+                    float * __restrict nearZ,
-                    float * __restrict farVal) {
+                    float * __restrict farZ) {
-  glm_persp_decomp_z(proj, nearVal, farVal);
+  glm_persp_decomp_z(proj, nearZ, farZ);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_far(mat4 proj, float * __restrict farVal) {
+glmc_persp_decomp_far(mat4 proj, float * __restrict farZ) {
-  glm_persp_decomp_far(proj, farVal);
+  glm_persp_decomp_far(proj, farZ);
 }
 
 CGLM_EXPORT
 void
-glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
+glmc_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
-  glm_persp_decomp_near(proj, nearVal);
+  glm_persp_decomp_near(proj, nearZ);
 }
 
 CGLM_EXPORT

src/clipspace/ortho_lh_no.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/ortho_lh_no.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_lh_no(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ, float farZ,
+                 mat4  dest) {
+  glm_ortho_lh_no(left,   right,
+                  bottom, top,
+                  nearZ,  farZ,
+                  dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
+  glm_ortho_aabb_lh_no(box, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_p_lh_no(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_pz_lh_no(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_lh_no(float aspect, mat4 dest) {
+  glm_ortho_default_lh_no(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_lh_no(float aspect, float size, mat4 dest) {
+  glm_ortho_default_s_lh_no(aspect, size, dest);
+}

src/clipspace/ortho_lh_zo.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/ortho_lh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_lh_zo(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ, float farZ,
+                 mat4  dest) {
+  glm_ortho_lh_zo(left,   right,
+                  bottom, top,
+                  nearZ,  farZ,
+                  dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
+  glm_ortho_aabb_lh_zo(box, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_p_lh_zo(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_pz_lh_zo(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_lh_zo(float aspect, mat4 dest) {
+  glm_ortho_default_lh_zo(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_lh_zo(float aspect, float size, mat4 dest) {
+  glm_ortho_default_s_lh_zo(aspect, size, dest);
+}

src/clipspace/ortho_rh_no.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/ortho_rh_no.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_rh_no(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ, float farZ,
+                 mat4  dest) {
+  glm_ortho_rh_no(left,   right,
+                  bottom, top,
+                  nearZ,  farZ,
+                  dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
+  glm_ortho_aabb_rh_no(box, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_p_rh_no(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_pz_rh_no(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_rh_no(float aspect, mat4 dest) {
+  glm_ortho_default_rh_no(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_rh_no(float aspect, float size, mat4 dest) {
+  glm_ortho_default_s_rh_no(aspect, size, dest);
+}

src/clipspace/ortho_rh_zo.c

@@ -0,0 +1,51 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/ortho_rh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_ortho_rh_zo(float left,    float right,
+                 float bottom,  float top,
+                 float nearZ, float farZ,
+                 mat4  dest) {
+  glm_ortho_rh_zo(left,   right,
+                  bottom, top,
+                  nearZ,  farZ,
+                  dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
+  glm_ortho_aabb_rh_zo(box, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_p_rh_zo(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
+  glm_ortho_aabb_pz_rh_zo(box, padding, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_rh_zo(float aspect, mat4 dest) {
+  glm_ortho_default_rh_zo(aspect, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_ortho_default_s_rh_zo(float aspect, float size, mat4 dest) {
+  glm_ortho_default_s_rh_zo(aspect, size, dest);
+}

src/clipspace/persp_lh_no.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/clipspace/persp_lh_no.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_lh_no(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ, float farZ,
+                   mat4  dest) {
+  glm_frustum_lh_no(left, right,
+                    bottom, top,
+                    nearZ, farZ,
+                    dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective_lh_no(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest) {
+  glm_perspective_lh_no(fovy,
+                        aspect,
+                        nearVal,
+                        farVal,
+                        dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_lh_no(mat4 proj, float deltaFar) {
+  glm_persp_move_far_lh_no(proj, deltaFar);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_lh_no(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_lh_no(mat4 proj, float dest[6]) {
+  glm_persp_decompv_lh_no(proj, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_lh_no(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_lh_no(proj, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_lh_no(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_lh_no(proj, top, bottom);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_lh_no(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_lh_no(proj, nearZ, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
+  glm_persp_decomp_far_lh_no(proj, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_lh_no(proj, nearZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
+  glm_persp_sizes_lh_no(proj, fovy, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_lh_no(mat4 proj) {
+  return glm_persp_fovy_lh_no(proj);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_lh_no(mat4 proj) {
+  return glm_persp_aspect_lh_no(proj);
+}

src/clipspace/persp_lh_zo.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/clipspace/persp_lh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_lh_zo(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ, float farZ,
+                   mat4  dest) {
+  glm_frustum_lh_zo(left, right,
+                    bottom, top,
+                    nearZ, farZ,
+                    dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective_lh_zo(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest) {
+  glm_perspective_lh_zo(fovy,
+                        aspect,
+                        nearVal,
+                        farVal,
+                        dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
+  glm_persp_move_far_lh_zo(proj, deltaFar);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_lh_zo(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
+  glm_persp_decompv_lh_zo(proj, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_lh_zo(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_lh_zo(proj, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_lh_zo(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_lh_zo(proj, top, bottom);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_lh_zo(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
+  glm_persp_decomp_far_lh_zo(proj, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_lh_zo(proj, nearZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
+  glm_persp_sizes_lh_zo(proj, fovy, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_lh_zo(mat4 proj) {
+  return glm_persp_fovy_lh_zo(proj);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_lh_zo(mat4 proj) {
+  return glm_persp_aspect_lh_zo(proj);
+}

src/clipspace/persp_rh_no.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/clipspace/persp_rh_no.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_rh_no(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ, float farZ,
+                   mat4  dest) {
+  glm_frustum_rh_no(left, right,
+                    bottom, top,
+                    nearZ, farZ,
+                    dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective_rh_no(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest) {
+  glm_perspective_rh_no(fovy,
+                        aspect,
+                        nearVal,
+                        farVal,
+                        dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_rh_no(mat4 proj, float deltaFar) {
+  glm_persp_move_far_rh_no(proj, deltaFar);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_rh_no(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_rh_no(proj, nearZ, farZ, top, bottom, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_rh_no(mat4 proj, float dest[6]) {
+  glm_persp_decompv_rh_no(proj, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_rh_no(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_rh_no(proj, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_rh_no(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_rh_no(proj, top, bottom);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_rh_no(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_rh_no(proj, nearZ, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
+  glm_persp_decomp_far_rh_no(proj, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_rh_no(proj, nearZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
+  glm_persp_sizes_rh_no(proj, fovy, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_rh_no(mat4 proj) {
+  return glm_persp_fovy_rh_no(proj);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_rh_no(mat4 proj) {
+  return glm_persp_aspect_rh_no(proj);
+}

src/clipspace/persp_rh_zo.c

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/clipspace/persp_rh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_frustum_rh_zo(float left,    float right,
+                   float bottom,  float top,
+                   float nearZ, float farZ,
+                   mat4  dest) {
+  glm_frustum_rh_zo(left, right,
+                    bottom, top,
+                    nearZ, farZ,
+                    dest);
+}
+
+CGLM_EXPORT
+void
+glmc_perspective_rh_zo(float fovy,
+                       float aspect,
+                       float nearVal,
+                       float farVal,
+                       mat4 dest) {
+  glm_perspective_rh_zo(fovy,
+                        aspect,
+                        nearVal,
+                        farVal,
+                        dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
+  glm_persp_move_far_rh_zo(proj, deltaFar);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_rh_zo(mat4 proj,
+                        float * __restrict nearZ, float * __restrict farZ,
+                        float * __restrict top,   float * __restrict bottom,
+                        float * __restrict left,  float * __restrict right) {
+  glm_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
+  glm_persp_decompv_rh_zo(proj, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_x_rh_zo(mat4 proj,
+                          float * __restrict left,
+                          float * __restrict right) {
+  glm_persp_decomp_x_rh_zo(proj, left, right);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_y_rh_zo(mat4 proj,
+                          float * __restrict top,
+                          float * __restrict bottom) {
+  glm_persp_decomp_y_rh_zo(proj, top, bottom);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_z_rh_zo(mat4 proj,
+                          float * __restrict nearZ,
+                          float * __restrict farZ) {
+  glm_persp_decomp_z_rh_zo(proj, nearZ, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
+  glm_persp_decomp_far_rh_zo(proj, farZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
+  glm_persp_decomp_near_rh_zo(proj, nearZ);
+}
+
+CGLM_EXPORT
+void
+glmc_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
+  glm_persp_sizes_rh_zo(proj, fovy, dest);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_fovy_rh_zo(mat4 proj) {
+  return glm_persp_fovy_rh_zo(proj);
+}
+
+CGLM_EXPORT
+float
+glmc_persp_aspect_rh_zo(mat4 proj) {
+  return glm_persp_aspect_rh_zo(proj);
+}

src/clipspace/view_lh_no.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/view_lh_no.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_lh_no(eye, center, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_lh_no(eye, dir, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_lh_no(eye, dir, dest);
+}

src/clipspace/view_lh_zo.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/view_lh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_lh_zo(eye, center, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_lh_zo(eye, dir, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_lh_zo(eye, dir, dest);
+}

src/clipspace/view_rh_no.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/view_rh_no.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_rh_no(eye, center, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_rh_no(eye, dir, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_rh_no(eye, dir, dest);
+}

src/clipspace/view_rh_zo.c

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "../../include/cglm/cglm.h"
+#include "../../include/cglm/clipspace/view_rh_zo.h"
+
+CGLM_EXPORT
+void
+glmc_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
+  glm_lookat_rh_zo(eye, center, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
+  glm_look_rh_zo(eye, dir, up, dest);
+}
+
+CGLM_EXPORT
+void
+glmc_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
+  glm_look_anyup_rh_zo(eye, dir, dest);
+}

src/quat.c

@@ -170,6 +170,12 @@ glmc_quat_lerpc(versor from, versor to, float t, versor dest) {
   glm_quat_lerpc(from, to, t, dest);
 }
 
+CGLM_EXPORT
+void
+glmc_quat_nlerp(versor from, versor to, float t, versor dest) {
+  glm_quat_nlerp(from, to, t, dest);
+}
+
 CGLM_EXPORT
 void
 glmc_quat_slerp(versor from, versor to, float t, versor dest) {

test/CMakeLists.txt

@@ -6,6 +6,10 @@ set(TESTFILES
   src/test_euler.c
   src/test_bezier.c
   src/test_cam.c
+  src/test_cam_lh_zo.c
+  src/test_cam_rh_zo.c
+  src/test_cam_lh_no.c
+  src/test_cam_rh_no.c
   src/test_struct.c
   src/test_clamp.c
   src/test_common.c

test/include/common.h

@@ -20,6 +20,10 @@
 #  define _GNU_SOURCE /* for drand48() */
 #endif
 
+#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
+#  define CGLM_CLIPSPACE_INCLUDE_ALL
+#endif
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>

test/src/test_cam.c

@@ -27,14 +27,14 @@ TEST_IMPL(camera_lookat) {
 TEST_IMPL(camera_decomp) {
   mat4  proj, proj2;
   vec4  sizes;
-  float aspect, fovy, nearVal, farVal;
+  float aspect, fovy, nearZ, farZ;
 
   aspect  = 0.782f;
   fovy    = glm_rad(49.984f);
-  nearVal = 0.1f;
+  nearZ   = 0.1f;
-  farVal  = 100.0f;
+  farZ    = 100.0f;
 
-  glm_perspective(fovy, aspect, nearVal, farVal, proj);
+  glm_perspective(fovy, aspect, nearZ, farZ, proj);
   ASSERT(fabsf(aspect  - glm_persp_aspect(proj)) < GLM_FLT_EPSILON)
   ASSERT(fabsf(fovy    - glm_persp_fovy(proj))   < GLM_FLT_EPSILON)
   ASSERT(fabsf(49.984f - glm_deg(glm_persp_fovy(proj))) < GLM_FLT_EPSILON)
@@ -45,8 +45,8 @@ TEST_IMPL(camera_decomp) {
                sizes[0] * 0.5f,
               -sizes[1] * 0.5f,
                sizes[1] * 0.5f,
-               nearVal,
+               nearZ,
-               farVal,
+               farZ,
                proj2);
 
   ASSERTIFY(test_assert_mat4_eq(proj, proj2))

test/src/test_cam_lh_no.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(perspective_lh_no) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_lh_no(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2],  (zFarVal + zNearVal) / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3],  1.0f))
+  ASSERT(test_eq(dst[3][2], -2 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_lh_no*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] =  1.0020020f;
+  cmp[2][3] =  1.0000000f;
+  cmp[3][2] = -0.2002002f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}

test/src/test_cam_lh_zo.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(perspective_lh_zo) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_lh_zo(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2],  zFarVal / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3],  1.0f))
+  ASSERT(test_eq(dst[3][2], -1 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /* "Reference values" generated by GLM's glm::perspectiveLH_ZO */
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] =  1.0010010f;
+  cmp[2][3] =  1.0000000f;
+  cmp[3][2] = -0.1001001f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}

test/src/test_cam_rh_no.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(perspective_rh_no) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_rh_no(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1.0f / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1.0f / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2], -1.0f * (zFarVal + zNearVal) / (zFarVal - zNearVal)))
+  ASSERT(test_eq(dst[2][3], -1.0f))
+  ASSERT(test_eq(dst[3][2], -2 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_rh_no*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] = -1.0020020f;
+  cmp[2][3] = -1.0000000f;
+  cmp[3][2] = -0.2002002f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}

test/src/test_cam_rh_zo.c

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#include "test_common.h"
+
+TEST_IMPL(perspective_rh_zo) {
+  mat4 dst;
+  const float fovy     = glm_rad(45.0f);
+  const float aspect   = 640/480.0f;
+  const float zNearVal = 0.1f;
+  const float zFarVal  = 100.0f;
+
+  glm_perspective_rh_zo(fovy, aspect, zNearVal, zFarVal, dst);
+
+  /* Sanity mk. I: longhand version */
+  ASSERT(test_eq(dst[0][0],  1 / (tanf(fovy / 2) * aspect)))
+  ASSERT(test_eq(dst[1][1],  1 / tanf(fovy / 2)))
+  ASSERT(test_eq(dst[2][2], zFarVal / (zNearVal - zFarVal)))
+  ASSERT(test_eq(dst[2][3], -1.0f))
+  ASSERT(test_eq(dst[3][2], -1 * zFarVal * zNearVal / (zFarVal - zNearVal)))
+
+  /* Sanity mk. II */
+  /*reference test data for glm_perspective_rh_zo*/
+  mat4 cmp = {0};
+  cmp[0][0] =  1.8106601f;
+  cmp[1][1] =  2.4142134f;
+  cmp[2][2] = -1.0010010f;
+  cmp[2][3] = -1.0000000f;
+  cmp[3][2] = -0.1001001f;
+
+  return test_assert_mat4_eq(dst, cmp);
+}

test/src/test_quat.h

@@ -708,6 +708,38 @@ TEST_IMPL(GLM_PREFIX, quat_lerpc) {
   TEST_SUCCESS
 }
 
+TEST_IMPL(GLM_PREFIX, quat_nlerp) {
+  versor q1, q2, q3, q4;
+  vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;
+
+  glm_quatv(q1, glm_rad(30.0f), v1);
+  glm_quatv(q2, glm_rad(90.0f), v1);
+
+  GLM(quat_nlerp)(q1, q2, 1.0f, q3);
+  glm_quat_normalize(q2);
+  ASSERTIFY(test_assert_quat_eq(q2, q3));
+
+  glm_quatv(q1, glm_rad(30.001f), v1);
+  glm_quatv(q2, glm_rad(30.002f), v1);
+  GLM(quat_nlerp)(q1, q2, 0.7f, q3);
+  glm_quat_lerp(q1, q2, 0.7f, q4);
+  ASSERTIFY(test_assert_quat_eq(q3, q4));
+
+  glm_quatv(q1, glm_rad(30.0f), v1);
+  glm_quatv(q2, glm_rad(90.0f), v1);
+  GLM(quat_nlerp)(q1, q2, 0.5f, q3);
+
+  glm_quat_axis(q3, v2);
+  glm_vec3_normalize(v1);
+  glm_vec3_normalize(v2);
+
+  ASSERT(glm_quat_angle(q3) > glm_rad(30.0f));
+  ASSERT(glm_quat_angle(q3) < glm_rad(90.0f));
+  ASSERTIFY(test_assert_vec3_eq(v1, v2))
+
+  TEST_SUCCESS
+}
+
 TEST_IMPL(GLM_PREFIX, quat_slerp) {
   versor q1, q2, q3, q4;
   vec3 v1 = {10.0f, 0.0f, 0.0f}, v2;

test/tests.h

@@ -222,7 +222,11 @@ TEST_DECLARE(glmc_mat2_swap_col)
 TEST_DECLARE(glmc_mat2_swap_row)
 TEST_DECLARE(glmc_mat2_rmc)
 
-/* camera */
+/* camera (incl [LR]H cross [NZ]O) */
+TEST_DECLARE(perspective_lh_zo)
+TEST_DECLARE(perspective_rh_zo)
+TEST_DECLARE(perspective_lh_no)
+TEST_DECLARE(perspective_rh_no)
 TEST_DECLARE(camera_lookat)
 TEST_DECLARE(camera_decomp)
 
@@ -284,6 +288,7 @@ TEST_DECLARE(glm_quat_mat3)
 TEST_DECLARE(glm_quat_mat3t)
 TEST_DECLARE(glm_quat_lerp)
 TEST_DECLARE(glm_quat_lerpc)
+TEST_DECLARE(glm_quat_nlerp)
 TEST_DECLARE(glm_quat_slerp)
 TEST_DECLARE(glm_quat_look)
 TEST_DECLARE(glm_quat_for)
@@ -320,6 +325,7 @@ TEST_DECLARE(glmc_quat_mat3)
 TEST_DECLARE(glmc_quat_mat3t)
 TEST_DECLARE(glmc_quat_lerp)
 TEST_DECLARE(glmc_quat_lerpc)
+TEST_DECLARE(glmc_quat_nlerp)
 TEST_DECLARE(glmc_quat_slerp)
 TEST_DECLARE(glmc_quat_look)
 TEST_DECLARE(glmc_quat_for)
@@ -944,7 +950,11 @@ TEST_LIST {
   TEST_ENTRY(glmc_mat2_swap_row)
   TEST_ENTRY(glmc_mat2_rmc)
 
-  /* camera */
+  /* camera (incl [LR]H cross [NZ]O) */
+  TEST_ENTRY(perspective_lh_zo)
+  TEST_ENTRY(perspective_rh_zo)
+  TEST_ENTRY(perspective_lh_no)
+  TEST_ENTRY(perspective_rh_no)
   TEST_ENTRY(camera_lookat)
   TEST_ENTRY(camera_decomp)
   
@@ -1006,6 +1016,7 @@ TEST_LIST {
   TEST_ENTRY(glm_quat_mat3t)
   TEST_ENTRY(glm_quat_lerp)
   TEST_ENTRY(glm_quat_lerpc)
+  TEST_ENTRY(glm_quat_nlerp)
   TEST_ENTRY(glm_quat_slerp)
   TEST_ENTRY(glm_quat_look)
   TEST_ENTRY(glm_quat_for)
@@ -1042,6 +1053,7 @@ TEST_LIST {
   TEST_ENTRY(glmc_quat_mat3t)
   TEST_ENTRY(glmc_quat_lerp)
   TEST_ENTRY(glmc_quat_lerpc)
+  TEST_ENTRY(glmc_quat_nlerp)
   TEST_ENTRY(glmc_quat_slerp)
   TEST_ENTRY(glmc_quat_look)
   TEST_ENTRY(glmc_quat_for)

win/cglm-test.vcxproj

@@ -23,6 +23,10 @@
     <ClCompile Include="..\test\src\tests.c" />
     <ClCompile Include="..\test\src\test_bezier.c" />
     <ClCompile Include="..\test\src\test_cam.c" />
+    <ClCompile Include="..\test\src\test_cam_lh_no.c" />
+    <ClCompile Include="..\test\src\test_cam_lh_zo.c" />
+    <ClCompile Include="..\test\src\test_cam_rh_no.c" />
+    <ClCompile Include="..\test\src\test_cam_rh_zo.c" />
     <ClCompile Include="..\test\src\test_clamp.c" />
     <ClCompile Include="..\test\src\test_common.c" />
     <ClCompile Include="..\test\src\test_euler.c" />

win/cglm-test.vcxproj.filters

@@ -35,6 +35,18 @@
     <ClCompile Include="..\test\src\tests.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\test\src\test_cam_lh_no.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_cam_lh_zo.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_cam_rh_no.c">
+      <Filter>src</Filter>
+    </ClCompile>
+    <ClCompile Include="..\test\src\test_cam_rh_zo.c">
+      <Filter>src</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\test\tests.h">

win/cglm.vcxproj

@@ -24,6 +24,18 @@
     <ClCompile Include="..\src\bezier.c" />
     <ClCompile Include="..\src\box.c" />
     <ClCompile Include="..\src\cam.c" />
+    <ClCompile Include="..\src\clipspace\ortho_lh_no.c" />
+    <ClCompile Include="..\src\clipspace\ortho_lh_zo.c" />
+    <ClCompile Include="..\src\clipspace\ortho_rh_no.c" />
+    <ClCompile Include="..\src\clipspace\ortho_rh_zo.c" />
+    <ClCompile Include="..\src\clipspace\persp_lh_no.c" />
+    <ClCompile Include="..\src\clipspace\persp_lh_zo.c" />
+    <ClCompile Include="..\src\clipspace\persp_rh_no.c" />
+    <ClCompile Include="..\src\clipspace\persp_rh_zo.c" />
+    <ClCompile Include="..\src\clipspace\view_lh_no.c" />
+    <ClCompile Include="..\src\clipspace\view_lh_zo.c" />
+    <ClCompile Include="..\src\clipspace\view_rh_no.c" />
+    <ClCompile Include="..\src\clipspace\view_rh_zo.c" />
     <ClCompile Include="..\src\curve.c" />
     <ClCompile Include="..\src\ease.c" />
     <ClCompile Include="..\src\euler.c" />
@@ -54,6 +66,18 @@
     <ClInclude Include="..\include\cglm\call\bezier.h" />
     <ClInclude Include="..\include\cglm\call\box.h" />
     <ClInclude Include="..\include\cglm\call\cam.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_lh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_rh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_lh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_rh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\view_lh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\view_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\view_rh_no.h" />
+    <ClInclude Include="..\include\cglm\call\clipspace\view_rh_zo.h" />
     <ClInclude Include="..\include\cglm\call\curve.h" />
     <ClInclude Include="..\include\cglm\call\ease.h" />
     <ClInclude Include="..\include\cglm\call\euler.h" />
@@ -72,6 +96,21 @@
     <ClInclude Include="..\include\cglm\call\vec4.h" />
     <ClInclude Include="..\include\cglm\cam.h" />
     <ClInclude Include="..\include\cglm\cglm.h" />
+    <ClInclude Include="..\include\cglm\clipspace\ortho_lh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\ortho_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\clipspace\ortho_rh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\ortho_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\clipspace\persp.h" />
+    <ClInclude Include="..\include\cglm\clipspace\persp_lh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\persp_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\clipspace\persp_rh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\persp_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_lh.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_lh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_rh.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_rh_no.h" />
+    <ClInclude Include="..\include\cglm\clipspace\view_rh_zo.h" />
     <ClInclude Include="..\include\cglm\color.h" />
     <ClInclude Include="..\include\cglm\common.h" />
     <ClInclude Include="..\include\cglm\curve.h" />
@@ -106,6 +145,18 @@
     <ClInclude Include="..\include\cglm\struct\affine2d.h" />
     <ClInclude Include="..\include\cglm\struct\box.h" />
     <ClInclude Include="..\include\cglm\struct\cam.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_lh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_rh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_lh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_rh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_rh_zo.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_lh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_lh_zo.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_rh_no.h" />
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_rh_zo.h" />
     <ClInclude Include="..\include\cglm\struct\color.h" />
     <ClInclude Include="..\include\cglm\struct\curve.h" />
     <ClInclude Include="..\include\cglm\struct\euler.h" />

win/cglm.vcxproj.filters

@@ -1,10 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
-    </Filter>
     <Filter Include="src">
       <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
       <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
@@ -33,6 +29,18 @@
     <Filter Include="include\cglm\struct">
       <UniqueIdentifier>{0b5febe7-a88d-4330-94ae-305897a5e957}</UniqueIdentifier>
     </Filter>
+    <Filter Include="include\cglm\clipspace">
+      <UniqueIdentifier>{8044a657-123d-4a0e-8de1-f348fad7dadb}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="include\cglm\call\clipspace">
+      <UniqueIdentifier>{842a48fc-5c7e-4951-9623-64af96dfb95a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="include\cglm\struct\clipspace">
+      <UniqueIdentifier>{86101de1-0722-4c88-92a0-e6d71158354e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="src\clipspace">
+      <UniqueIdentifier>{98a166bb-ba2d-4649-a20f-ba6bf4ce6383}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="..\src\affine.c">
@@ -98,6 +106,42 @@
     <ClCompile Include="..\src\affine2d.c">
       <Filter>src</Filter>
     </ClCompile>
+    <ClCompile Include="..\src\clipspace\ortho_lh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\ortho_lh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\ortho_rh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\ortho_rh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\persp_lh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\persp_lh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\persp_rh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\persp_rh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\view_lh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\view_lh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\view_rh_no.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
+    <ClCompile Include="..\src\clipspace\view_rh_zo.c">
+      <Filter>src\clipspace</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="..\src\config.h">
@@ -379,5 +423,122 @@
     <ClInclude Include="..\include\cglm\simd\neon\quat.h">
       <Filter>include\cglm\simd\neon</Filter>
     </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\ortho_lh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\ortho_lh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\ortho_rh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\ortho_rh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\persp.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\persp_lh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\persp_lh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\persp_rh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\persp_rh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_lh.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_lh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_lh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_rh.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_rh_no.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\clipspace\view_rh_zo.h">
+      <Filter>include\cglm\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_lh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_lh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_rh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\ortho_rh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_lh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_lh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_rh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\persp_rh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\view_lh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\view_lh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\view_rh_no.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\call\clipspace\view_rh_zo.h">
+      <Filter>include\cglm\call\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_lh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_lh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_rh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\ortho_rh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_lh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_lh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_rh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\persp_rh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_lh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_lh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_rh_no.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
+    <ClInclude Include="..\include\cglm\struct\clipspace\view_rh_zo.h">
+      <Filter>include\cglm\struct\clipspace</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>