first commit

include/cglm/struct/affine-post.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_translated(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_translated_x(mat4s m, float x);
+   CGLM_INLINE mat4s glms_translated_y(mat4s m, float y);
+   CGLM_INLINE mat4s glms_translated_z(mat4s m, float z);
+   CGLM_INLINE mat4s glms_rotated_x(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated_y(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated_z(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotated(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_spinned(mat4s m, float angle, vec3s axis);
+ */
+
+#ifndef cglms_affines_post_h
+#define cglms_affines_post_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       v   translate vector [x, y, z]
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translated(mat4s m, vec3s v) {
+  glm_translated(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by x factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       x   x factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translated_x(mat4s m, float x) {
+  glm_translated_x(m.raw, x);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by y factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       y   y factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translated_y(mat4s m, float y) {
+  glm_translated_y(m.raw, y);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by z factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       z   z factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translated_z(mat4s m, float z) {
+  glm_translated_z(m.raw, z);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around X axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotated_x(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_x(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Y axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotated_y(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_y(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Z axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotated_z(mat4s m, float angle) {
+  mat4s r;
+  glm_rotated_z(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotated(mat4s m, float angle, vec3s axis) {
+  glm_rotated(m.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform
+ *        around given axis by angle at given pivot point (rotation center)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       pivot   rotation center
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                 affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotated_at(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_spinned(mat4s m, float angle, vec3s axis) {
+  glm_spinned(m.raw, angle, axis.raw);
+  return m;
+}
+
+#endif /* cglms_affines_post_h */

include/cglm/struct/affine-pre.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_translate(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_translate_x(mat4s m, float x);
+   CGLM_INLINE mat4s glms_translate_y(mat4s m, float y);
+   CGLM_INLINE mat4s glms_translate_z(mat4s m, float z);
+   CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_spin(mat4s m, float angle, vec3s axis);
+ */
+
+#ifndef cglms_affines_pre_h
+#define cglms_affines_pre_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief translate existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       v   translate vector [x, y, z]
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate(mat4s m, vec3s v) {
+  glm_translate(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by x factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       x   x factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_x(mat4s m, float x) {
+  glm_translate_x(m.raw, x);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by y factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       y   y factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_y(mat4s m, float y) {
+  glm_translate_y(m.raw, y);
+  return m;
+}
+
+/*!
+ * @brief translate existing transform matrix by z factor
+ *
+ * @param[in]       m   affine transfrom
+ * @param[in]       z   z factor
+ * @returns             affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_z(mat4s m, float z) {
+  glm_translate_z(m.raw, z);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around X axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_x(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_x(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Y axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_y(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_y(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around Z axis by angle
+ *        and store result in dest
+ *
+ * @param[in]   m       affine transfrom
+ * @param[in]   angle   angle (radians)
+ * @returns             rotated matrix
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_z(mat4s m, float angle) {
+  mat4s r;
+  glm_rotate_z(m.raw, angle, r.raw);
+  return r;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate(mat4s m, float angle, vec3s axis) {
+  glm_rotate(m.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform
+ *        around given axis by angle at given pivot point (rotation center)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       pivot   rotation center
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                 affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotate_at(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
+ *
+ * @param[in]       m       affine transfrom
+ * @param[in]       angle   angle (radians)
+ * @param[in]       axis    axis
+ * @returns                affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_spin(mat4s m, float angle, vec3s axis) {
+  glm_spin(m.raw, angle, axis.raw);
+  return m;
+}
+
+#endif /* cglms_affines_pre_h */

include/cglm/struct/affine.h

@@ -0,0 +1,200 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_translate(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_translate_x(mat4s m, float x);
+   CGLM_INLINE mat4s glms_translate_y(mat4s m, float y);
+   CGLM_INLINE mat4s glms_translate_z(mat4s m, float z);
+   CGLM_INLINE mat4s glms_translate_make(vec3s v);
+   CGLM_INLINE mat4s glms_scale_to(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_scale_make(vec3s v);
+   CGLM_INLINE mat4s glms_scale(mat4s m, vec3s v);
+   CGLM_INLINE mat4s glms_scale_uni(mat4s m, float s);
+   CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle);
+   CGLM_INLINE mat4s glms_rotate_make(float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis);
+   CGLM_INLINE mat4s glms_spin(mat4s m, float angle, vec3s axis);
+   CGLM_INLINE vec3s glms_decompose_scalev(mat4s m);
+   CGLM_INLINE bool  glms_uniscaled(mat4s m);
+   CGLM_INLINE void  glms_decompose_rs(mat4s m, mat4s * r, vec3s * s);
+   CGLM_INLINE void  glms_decompose(mat4s m, vec4s t, mat4s * r, vec3s * s);
+ */
+
+#ifndef cglms_affines_h
+#define cglms_affines_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief creates NEW translate transform matrix by v vector
+ *
+ * @param[in]   v   translate vector [x, y, z]
+ * @returns         affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_translate_make(vec3s v) {
+  mat4s m;
+  glm_translate_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW scale matrix by v vector
+ *
+ * @param[in]   v  scale vector [x, y, z]
+ * @returns affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale_make(vec3s v) {
+  mat4s m;
+  glm_scale_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief scales existing transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]    m   affine transfrom
+ * @param[in]    v   scale vector [x, y, z]
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale(mat4s m, vec3s v) {
+  mat4s r;
+  glm_scale_to(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief applies uniform scale to existing transform matrix v = [s, s, s]
+ *        and stores result in same matrix
+ *
+ * @param[in]    m   affine transfrom
+ * @param[in]    s   scale factor
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_scale_uni(mat4s m, float s) {
+  glm_scale_uni(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief creates NEW rotation matrix by angle and axis
+ *
+ * axis will be normalized so you don't need to normalize it
+ *
+ * @param[in]  angle  angle (radians)
+ * @param[in]  axis   axis
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_make(float angle, vec3s axis) {
+  mat4s m;
+  glm_rotate_make(m.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW rotation matrix by angle and axis at given point
+ *
+ * this creates rotation matrix, it assumes you don't have a matrix
+ *
+ * this should work faster than glm_rotate_at because it reduces
+ * one glm_translate.
+ *
+ * @param[in]  m      affine transfrom
+ * @param[in]  pivot  rotation center
+ * @param[in]  angle  angle (radians)
+ * @param[in]  axis   axis
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat4s
+glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis) {
+  glm_rotate_atm(m.raw, pivot.raw, angle, axis.raw);
+  return m;
+}
+
+/*!
+ * @brief decompose scale vector
+ *
+ * @param[in]  m  affine transform
+ * @returns       scale vector (Sx, Sy, Sz)
+ */
+CGLM_INLINE
+vec3s
+glms_decompose_scalev(mat4s m) {
+  vec3s r;
+  glm_decompose_scalev(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief returns true if matrix is uniform scaled. This is helpful for
+ *        creating normal matrix.
+ *
+ * @param[in] m m
+ *
+ * @return boolean
+ */
+CGLM_INLINE
+bool
+glms_uniscaled(mat4s m) {
+  return glm_uniscaled(m.raw);
+}
+
+/*!
+ * @brief decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
+ *        DON'T pass projected matrix here
+ *
+ * @param[in]  m affine transform
+ * @param[out] r rotation matrix
+ * @param[out] s scale matrix
+ */
+CGLM_INLINE
+void
+glms_decompose_rs(mat4s m, mat4s * __restrict r, vec3s * __restrict s) {
+  glm_decompose_rs(m.raw, r->raw, s->raw);
+}
+
+/*!
+ * @brief decompose affine transform, TODO: extract shear factors.
+ *        DON'T pass projected matrix here
+ *
+ * @param[in]  m affine transfrom
+ * @param[out] t translation vector
+ * @param[out] r rotation matrix (mat4)
+ * @param[out] s scaling vector [X, Y, Z]
+ */
+CGLM_INLINE
+void
+glms_decompose(mat4s m, vec4s * __restrict t, mat4s * __restrict r, vec3s * __restrict s) {
+  glm_decompose(m.raw, t->raw, r->raw, s->raw);
+}
+
+#include "affine-pre.h"
+#include "affine-post.h"
+
+#endif /* cglms_affines_h */

include/cglm/struct/affine2d.h

@@ -0,0 +1,177 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat3s glms_translate2d(mat3 m, vec2 v)
+   CGLM_INLINE mat3s glms_translate2d_x(mat3s m, float x)
+   CGLM_INLINE mat3s glms_translate2d_y(mat3s m, float y)
+   CGLM_INLINE mat3s glms_translate2d_make(vec2s v)
+   CGLM_INLINE mat3s glms_scale2d_make(vec2s v)
+   CGLM_INLINE mat3s glms_scale2d(mat3s m, vec2s v)
+   CGLM_INLINE mat3s glms_scale2d_uni(mat3s m, float s)
+   CGLM_INLINE mat3s glms_rotate2d_make(float angle)
+   CGLM_INLINE mat3s glms_rotate2d(mat3s m, float angle)
+   CGLM_INLINE mat3s glms_rotate2d_to(mat3s m, float angle)
+ */
+
+#ifndef cglms_affine2ds_h
+#define cglms_affine2ds_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../affine2d.h"
+#include "vec3.h"
+#include "mat3.h"
+
+/*!
+ * @brief translate existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] v  translate vector [x, y]
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d(mat3s m, vec2s v) {
+  glm_translate2d(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by x factor
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] x  x factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_x(mat3s m, float x) {
+  glm_translate2d_x(m.raw, x);
+  return m;
+}
+
+/*!
+ * @brief translate existing 2d transform matrix by y factor
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] y  y factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_y(mat3s m, float y) {
+  glm_translate2d_y(m.raw, y);
+  return m;
+}
+
+/*!
+ * @brief creates NEW translate 2d transform matrix by v vector
+ *
+ * @param[in] v  translate vector [x, y]
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_translate2d_make(vec2s v) {
+  mat3s m;
+  glm_translate2d_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief creates NEW 2d scale matrix by v vector
+ *
+ * @param[in]   v  scale vector [x, y]
+ * @returns affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d_make(vec2s v) {
+  mat3s m;
+  glm_scale2d_make(m.raw, v.raw);
+  return m;
+}
+
+/*!
+ * @brief scales existing 2d transform matrix by v vector
+ *        and stores result in same matrix
+ *
+ * @param[in]  m  affine transfrom
+ * @param[in]  v  scale vector [x, y, z]
+ * @returns       affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d(mat3s m, vec2s v) {
+  mat3s r;
+  glm_scale2d_to(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief applies uniform scale to existing 2d transform matrix v = [s, s, s]
+ *        and stores result in same matrix
+ *
+ * @param[in] m  affine transfrom
+ * @param[in] s  scale factor
+ * @returns      affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_scale2d_uni(mat3s m, float s) {
+  glm_scale2d_uni(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief creates NEW 2d rotation matrix by angle and axis
+ *
+ * axis will be normalized so you don't need to normalize it
+ *
+ * @param[in]  angle  angle (radians)
+ * @returns           affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d_make(float angle) {
+  mat3s m;
+  glm_rotate2d_make(m.raw, angle);
+  return m;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around given axis by angle
+ *
+ * @param[in] m      affine transfrom
+ * @param[in] angle  angle (radians)
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d(mat3s m, float angle) {
+  glm_rotate2d(m.raw, angle);
+  return m;
+}
+
+/*!
+ * @brief rotate existing 2d transform matrix around given axis by angle
+ *
+ * @param[in] m      affine transfrom
+ * @param[in] angle  angle (radians)
+ * @returns          affine transfrom
+ */
+CGLM_INLINE
+mat3s
+glms_rotate2d_to(mat3s m, float angle) {
+  glm_rotate2d(m.raw, angle);
+  return m;
+}
+
+#endif /* cglms_affine2ds_h */

include/cglm/struct/box.h

@@ -0,0 +1,256 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_boxs_h
+#define cglms_boxs_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../box.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief apply transform to Axis-Aligned Bounding Box
+ *
+ * @param[in]  box  bounding box
+ * @param[in]  m    transform matrix
+ * @param[out] dest transformed bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_transform(vec3s box[2], mat4s m, vec3s dest[2]) {
+  vec3 rawBox[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glm_aabb_transform(rawBox, m.raw, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief merges two AABB bounding box and creates new one
+ *
+ * two box must be in same space, if one of box is in different space then
+ * you should consider to convert it's space by glm_box_space
+ *
+ * @param[in]  box1 bounding box 1
+ * @param[in]  box2 bounding box 2
+ * @param[out] dest merged bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_merge(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
+  vec3 rawBox1[2];
+  vec3 rawBox2[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox1, box1, 2);
+  glms_vec3_unpack(rawBox2, box2, 2);
+  glm_aabb_merge(rawBox1, rawBox2, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief crops a bounding box with another one.
+ *
+ * this could be useful for gettng a bbox which fits with view frustum and
+ * object bounding boxes. In this case you crop view frustum box with objects
+ * box
+ *
+ * @param[in]  box     bounding box 1
+ * @param[in]  cropBox crop box
+ * @param[out] dest    cropped bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_crop(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
+  vec3 rawBox[2];
+  vec3 rawCropBox[2];
+  vec3 rawDest[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawCropBox, cropBox, 2);
+  glm_aabb_crop(rawBox, rawCropBox, rawDest);
+  glms_vec3_pack(dest, rawDest, 2);
+}
+
+/*!
+ * @brief crops a bounding box with another one.
+ *
+ * this could be useful for gettng a bbox which fits with view frustum and
+ * object bounding boxes. In this case you crop view frustum box with objects
+ * box
+ *
+ * @param[in]  box      bounding box
+ * @param[in]  cropBox  crop box
+ * @param[in]  clampBox miniumum box
+ * @param[out] dest     cropped bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_crop_until(vec3s box[2],
+                     vec3s cropBox[2],
+                     vec3s clampBox[2],
+                     vec3s dest[2]) {
+  glms_aabb_crop(box, cropBox, dest);
+  glms_aabb_merge(clampBox, dest, dest);
+}
+
+/*!
+ * @brief check if AABB intersects with frustum planes
+ *
+ * this could be useful for frustum culling using AABB.
+ *
+ * OPTIMIZATION HINT:
+ *  if planes order is similar to LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR
+ *  then this method should run even faster because it would only use two
+ *  planes if object is not inside the two planes
+ *  fortunately cglm extracts planes as this order! just pass what you got!
+ *
+ * @param[in]  box     bounding box
+ * @param[in]  planes  frustum planes
+ */
+CGLM_INLINE
+bool
+glms_aabb_frustum(vec3s box[2], vec4s planes[6]) {
+  vec3 rawBox[2];
+  vec4 rawPlanes[6];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec4_unpack(rawPlanes, planes, 6);
+  return glm_aabb_frustum(rawBox, rawPlanes);
+}
+
+/*!
+ * @brief invalidate AABB min and max values
+ *
+ * @param[in, out]  box bounding box
+ */
+CGLM_INLINE
+void
+glms_aabb_invalidate(vec3s box[2]) {
+  box[0] = glms_vec3_broadcast(FLT_MAX);
+  box[1] = glms_vec3_broadcast(-FLT_MAX);
+}
+
+/*!
+ * @brief check if AABB is valid or not
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_isvalid(vec3s box[2]) {
+  vec3 rawBox[2];
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_isvalid(rawBox);
+}
+
+/*!
+ * @brief distance between of min and max
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+float
+glms_aabb_size(vec3s box[2]) {
+  return glm_vec3_distance(box[0].raw, box[1].raw);
+}
+
+/*!
+ * @brief radius of sphere which surrounds AABB
+ *
+ * @param[in]  box bounding box
+ */
+CGLM_INLINE
+float
+glms_aabb_radius(vec3s box[2]) {
+  return glms_aabb_size(box) * 0.5f;
+}
+
+/*!
+ * @brief computes center point of AABB
+ *
+ * @param[in]   box  bounding box
+ * @returns center of bounding box
+ */
+CGLM_INLINE
+vec3s
+glms_aabb_center(vec3s box[2]) {
+  return glms_vec3_center(box[0], box[1]);
+}
+
+/*!
+ * @brief check if two AABB intersects
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_aabb(vec3s box[2], vec3s other[2]) {
+  vec3 rawBox[2];
+  vec3 rawOther[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawOther, other, 2);
+  return glm_aabb_aabb(rawBox, rawOther);
+}
+
+/*!
+ * @brief check if AABB intersects with sphere
+ *
+ * https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
+ * Solid Box - Solid Sphere test.
+ *
+ * @param[in]   box    solid bounding box
+ * @param[in]   s      solid sphere
+ */
+CGLM_INLINE
+bool
+glms_aabb_sphere(vec3s box[2], vec4s s) {
+  vec3 rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_sphere(rawBox, s.raw);
+}
+
+/*!
+ * @brief check if point is inside of AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glms_aabb_point(vec3s box[2], vec3s point) {
+  vec3 rawBox[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  return glm_aabb_point(rawBox, point.raw);
+}
+
+/*!
+ * @brief check if AABB contains other AABB
+ *
+ * @param[in]   box    bounding box
+ * @param[in]   other  other bounding box
+ */
+CGLM_INLINE
+bool
+glms_aabb_contains(vec3s box[2], vec3s other[2]) {
+  vec3 rawBox[2];
+  vec3 rawOther[2];
+
+  glms_vec3_unpack(rawBox, box, 2);
+  glms_vec3_unpack(rawOther, other, 2);
+  return glm_aabb_contains(rawBox, rawOther);
+}
+
+#endif /* cglms_boxs_h */

include/cglm/struct/cam.h

@@ -0,0 +1,646 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE mat4s glms_frustum(float left,    float right,
+                                  float bottom,  float top,
+                                  float nearZ,   float farZ)
+   CGLM_INLINE mat4s glms_ortho(float left,    float right,
+                                float bottom,  float top,
+                                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);
+   CGLM_INLINE mat4s glms_ortho_default(float aspect)
+   CGLM_INLINE mat4s glms_ortho_default_s(float aspect, float size)
+   CGLM_INLINE mat4s glms_perspective(float fovy,
+                                      float aspect,
+                                      float nearZ,
+                                      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)
+   CGLM_INLINE mat4s glms_lookat(vec3s eye, vec3s center, vec3s up)
+   CGLM_INLINE mat4s glms_look(vec3s eye, vec3s dir, vec3s up)
+   CGLM_INLINE mat4s glms_look_anyup(vec3s eye, vec3s dir)
+   CGLM_INLINE void  glms_persp_decomp(mat4s  proj,
+                                       float *nearv, float *farv,
+                                       float *top,   float *bottom,
+                                       float *left,  float *right)
+   CGLM_INLINE void  glms_persp_decompv(mat4s proj, float dest[6])
+   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 *farZ)
+   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)
+ */
+
+#ifndef cglms_cam_h
+#define cglms_cam_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#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
+ *
+ * @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(float left,   float right,
+             float bottom, float top,
+             float nearZ,  float farZ) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_frustum_lh_zo(left, right, bottom, top, nearZ, farZ);
+#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
+}
+
+/*!
+ * @brief set up orthographic projection matrix
+ *
+ * @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(float left,   float right,
+           float bottom, float top,
+           float nearZ,  float farZ) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_lh_zo(left, right, bottom, top, nearZ, farZ);
+#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
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * bounding box (AABB) must be in view space
+ *
+ * @param[in]  box   AABB
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_aabb(vec3s box[2]) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_aabb_lh_zo(box);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_aabb_lh_no(box);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_aabb_rh_zo(box);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_rh_no(box);
+#endif
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * 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(vec3s box[2], float padding) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_aabb_p_lh_zo(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_aabb_p_lh_no(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_aabb_p_rh_zo(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_p_rh_no(box, padding);
+#endif
+}
+
+/*!
+ * @brief set up orthographic projection matrix using bounding box
+ *
+ * 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(vec3s box[2], float padding) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_aabb_pz_lh_zo(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+  return glms_ortho_aabb_pz_lh_no(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
+  return glms_ortho_aabb_pz_rh_zo(box, padding);
+#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
+  return glms_ortho_aabb_pz_rh_no(box, padding);
+#endif
+}
+
+/*!
+ * @brief set up unit orthographic projection matrix
+ *
+ * @param[in]  aspect aspect ration ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default(float aspect) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_default_lh_zo(aspect);
+#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
+}
+
+/*!
+ * @brief set up orthographic projection matrix with given CUBE size
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @param[in]  size   cube size
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_ortho_default_s(float aspect, float size) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_ortho_default_s_lh_zo(aspect, size);
+#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
+}
+
+/*!
+ * @brief set up perspective projection matrix
+ *
+ * @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(float fovy, float aspect, float nearZ, float farZ) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_perspective_lh_zo(fovy, aspect, nearZ, farZ);
+#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
+mat4s
+glms_persp_move_far(mat4s proj, float 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
+}
+
+/*!
+ * @brief set up perspective projection matrix with default near/far
+ *        and angle values
+ *
+ * @param[in]  aspect aspect ratio ( width / height )
+ * @returns    result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_perspective_default(float aspect) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_perspective_default_lh_zo(aspect);
+#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
+}
+
+/*!
+ * @brief resize perspective matrix by aspect ratio ( width / height )
+ *        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
+mat4s
+glms_perspective_resize(mat4s proj, float aspect) {
+#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
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * 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(vec3s eye, vec3s center, vec3s up) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_lookat_lh_zo(eye, center, up);
+#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
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * 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(vec3s eye, vec3s dir, vec3s up) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_look_lh_zo(eye, dir, up);
+#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
+}
+
+/*!
+ * @brief set up view matrix
+ *
+ * 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(vec3s eye, vec3s dir) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_look_anyup_lh_zo(eye, dir);
+#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] 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(mat4s proj,
+                  float * __restrict nearZ, float * __restrict farZ,
+                  float * __restrict top,   float * __restrict bottom,
+                  float * __restrict left,  float * __restrict 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
+}
+
+/*!
+ * @brief decomposes frustum values of perspective projection.
+ *        this makes easy to get all values at once
+ *
+ * @param[in]  proj   perspective projection matrix
+ * @param[out] dest   array
+ */
+CGLM_INLINE
+void
+glms_persp_decompv(mat4s proj, float dest[6]) {
+#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
+}
+
+/*!
+ * @brief decomposes left and right values of perspective projection.
+ *        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(mat4s proj,
+                    float * __restrict left,
+                    float * __restrict 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
+}
+
+/*!
+ * @brief decomposes top and bottom values of perspective projection.
+ *        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(mat4s proj,
+                    float * __restrict top,
+                    float * __restrict 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
+}
+
+/*!
+ * @brief decomposes near and far values of perspective projection.
+ *        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(mat4s proj,
+                    float * __restrict nearZ,
+                    float * __restrict farZ) {
+#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] farZ   far
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_far(mat4s proj, float * __restrict farZ) {
+#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] nearZ near
+ */
+CGLM_INLINE
+void
+glms_persp_decomp_near(mat4s proj, float * __restrict nearZ) {
+#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
+}
+
+/*!
+ * @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
+glms_persp_fovy(mat4s proj) {
+#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
+}
+
+/*!
+ * @brief returns aspect ratio of perspective projection
+ *
+ * @param[in] proj perspective projection matrix
+ */
+CGLM_INLINE
+float
+glms_persp_aspect(mat4s proj) {
+#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
+}
+
+/*!
+ * @brief returns sizes of near and far planes of perspective projection
+ *
+ * @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(mat4s proj, float fovy) {
+#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
+  return glms_persp_sizes_lh_zo(proj, fovy);
+#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), http://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), http://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), http://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), http://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), http://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), http://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), http://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), http://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/project_no.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
+   CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
+ */
+
+#ifndef cglms_project_no_h
+#define cglms_project_no_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * if you don't have ( and don't want to have ) an inverse matrix then use
+ * glm_unproject version. You may use existing inverse of matrix in somewhere
+ * else, this is why glm_unprojecti exists to save save inversion cost
+ *
+ * [1] space:
+ *  1- if m = invProj:     View Space
+ *  2- if m = invViewProj: World Space
+ *  3- if m = invMVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use invMVP as m
+ *
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *   glm_mat4_inv(viewProj, invMVP);
+ *
+ * @param[in]  pos          point/position in viewport coordinates
+ * @param[in]  invMat   matrix (see brief)
+ * @param[in]  vp            viewport as [x, y, width, height]
+ *
+ * @returns unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_unprojecti_no(pos.raw, invMat.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object coordinates to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      object coordinates
+ * @param[in]  m          MVP matrix
+ * @param[in]  vp        viewport as [x, y, width, height]
+ *
+ * @returns projected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest) {
+  vec3s dest;
+  glm_project_no(pos.raw, m.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v object coordinates
+ * @param[in]  m MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+vec3s
+glms_project_z_no(vec3s v, mat4s m) {
+  return glm_project_z_no(v.raw, m.raw);
+}
+
+#endif /* cglms_project_rh_no_h */

include/cglm/struct/clipspace/project_zo.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
+   CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
+ */
+
+#ifndef cglms_project_zo_h
+#define cglms_project_zo_h
+
+#include "../../common.h"
+#include "../../types-struct.h"
+#include "../../plane.h"
+#include "../../cam.h"
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * if you don't have ( and don't want to have ) an inverse matrix then use
+ * glm_unproject version. You may use existing inverse of matrix in somewhere
+ * else, this is why glm_unprojecti exists to save save inversion cost
+ *
+ * [1] space:
+ *  1- if m = invProj:     View Space
+ *  2- if m = invViewProj: World Space
+ *  3- if m = invMVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use invMVP as m
+ *
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *   glm_mat4_inv(viewProj, invMVP);
+ *
+ * @param[in]  pos          point/position in viewport coordinates
+ * @param[in]  invMat   matrix (see brief)
+ * @param[in]  vp            viewport as [x, y, width, height]
+ *
+ * @returns unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unprojecti_zo(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_unprojecti_zo(pos.raw, invMat.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object coordinates to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      object coordinates
+ * @param[in]  m          MVP matrix
+ * @param[in]  vp        viewport as [x, y, width, height]
+ *
+ * @returns projected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_project_zo(vec3s pos, mat4s m, vec4s vp, vec3 dest) {
+  vec3s dest;
+  glm_project_zo(pos.raw, m.raw, vp.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief map object's z coordinate to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  v object coordinates
+ * @param[in]  m MVP matrix
+ *
+ * @returns projected z coordinate
+ */
+CGLM_INLINE
+vec3s
+glms_project_z_zo(vec3s v, mat4s m) {
+  return glm_project_z_zo(v.raw, m.raw);
+}
+
+#endif /* cglm_project_zo_h */

include/cglm/struct/clipspace/view_lh_no.h

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://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), http://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), http://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), http://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/color.h

@@ -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
+ */
+
+#ifndef cglms_colors_h
+#define cglms_colors_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../color.h"
+#include "vec3.h"
+
+/*!
+ * @brief averages the color channels into one value
+ *
+ * @param[in]  rgb RGB color
+ */
+CGLM_INLINE
+float
+glms_luminance(vec3s rgb) {
+  return glm_luminance(rgb.raw);
+}
+
+#endif /* cglms_colors_h */

include/cglm/struct/curve.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_curves_h
+#define cglms_curves_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../curve.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief helper function to calculate S*M*C multiplication for curves
+ *
+ * This function does not encourage you to use SMC,
+ * instead it is a helper if you use SMC.
+ *
+ * if you want to specify S as vector then use more generic glm_mat4_rmc() func.
+ *
+ * Example usage:
+ *  B(s) = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
+ *
+ * @param[in]  s  parameter between 0 and 1 (this will be [s3, s2, s, 1])
+ * @param[in]  m  basis matrix
+ * @param[in]  c  position/control vector
+ *
+ * @return B(s)
+ */
+CGLM_INLINE
+float
+glms_smc(float s, mat4s m, vec4s c) {
+  return glm_smc(s, m.raw, c.raw);
+}
+
+#endif /* cglms_curves_h */

include/cglm/struct/euler.h

@@ -0,0 +1,152 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ NOTE:
+  angles must be passed as [X-Angle, Y-Angle, Z-angle] order
+  For instance you don't pass angles as [Z-Angle, X-Angle, Y-angle] to
+  glm_euler_zxy funciton, All RELATED functions accept angles same order
+  which is [X, Y, Z].
+ */
+
+/*
+ Types:
+   enum glm_euler_seq
+
+ Functions:
+   CGLM_INLINE vec3s glms_euler_angles(mat4s m)
+   CGLM_INLINE mat4s glms_euler_xyz(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_xzy(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_yxz(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_yzx(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_zxy(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_zyx(vec3s angles)
+   CGLM_INLINE mat4s glms_euler_by_order(vec3s angles, glm_euler_seq ord)
+ */
+
+#ifndef cglms_euler_h
+#define cglms_euler_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../euler.h"
+
+/*!
+ * @brief extract euler angles (in radians) using xyz order
+ *
+ * @param[in]  m    affine transform
+ * @returns angles vector [x, y, z]
+ */
+CGLM_INLINE
+vec3s
+glms_euler_angles(mat4s m) {
+  vec3s dest;
+  glm_euler_angles(m.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_xyz(vec3s angles) {
+  mat4s dest;
+  glm_euler_xyz(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_xzy(vec3s angles) {
+  mat4s dest;
+  glm_euler_xzy(angles.raw, dest.raw);
+  return dest;
+}
+
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_yxz(vec3s angles) {
+  mat4s dest;
+  glm_euler_yxz(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_yzx(vec3s angles) {
+  mat4s dest;
+  glm_euler_yzx(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_zxy(vec3s angles) {
+  mat4s dest;
+  glm_euler_zxy(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_zyx(vec3s angles) {
+  mat4s dest;
+  glm_euler_zyx(angles.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief build rotation matrix from euler angles
+ *
+ * @param[in]  angles angles as vector [Xangle, Yangle, Zangle]
+ * @param[in]  ord    euler order
+ * @returns rotation matrix
+ */
+CGLM_INLINE
+mat4s
+glms_euler_by_order(vec3s angles, glm_euler_seq ord) {
+  mat4s dest;
+  glm_euler_by_order(angles.raw, ord, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_euler_h */

include/cglm/struct/frustum.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_frustums_h
+#define cglms_frustums_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../frustum.h"
+#include "plane.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/* you can override clip space coords
+   but you have to provide all with same name
+   e.g.: define GLM_CSCOORD_LBN {0.0f, 0.0f, 1.0f, 1.0f} */
+#ifndef GLM_CUSTOM_CLIPSPACE
+
+/* near */
+#define GLMS_CSCOORD_LBN {-1.0f, -1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_LTN {-1.0f,  1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_RTN { 1.0f,  1.0f, -1.0f, 1.0f}
+#define GLMS_CSCOORD_RBN { 1.0f, -1.0f, -1.0f, 1.0f}
+
+/* far */
+#define GLMS_CSCOORD_LBF {-1.0f, -1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_LTF {-1.0f,  1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_RTF { 1.0f,  1.0f,  1.0f, 1.0f}
+#define GLMS_CSCOORD_RBF { 1.0f, -1.0f,  1.0f, 1.0f}
+
+#endif
+
+/*!
+ * @brief extracts view frustum planes
+ *
+ * planes' space:
+ *  1- if m = proj:     View Space
+ *  2- if m = viewProj: World Space
+ *  3- if m = MVP:      Object Space
+ *
+ * You probably want to extract planes in world space so use viewProj as m
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *
+ * Exracted planes order: [left, right, bottom, top, near, far]
+ *
+ * @param[in]  m    matrix (see brief)
+ * @param[out] dest extracted view frustum planes (see brief)
+ */
+CGLM_INLINE
+void
+glms_frustum_planes(mat4s m, vec4s dest[6]) {
+  vec4 rawDest[6];
+  glm_frustum_planes(m.raw, rawDest);
+  glms_vec4_pack(dest, rawDest, 6);
+}
+
+/*!
+ * @brief extracts view frustum corners using clip-space coordinates
+ *
+ * corners' space:
+ *  1- if m = invViewProj: World Space
+ *  2- if m = invMVP:      Object Space
+ *
+ * You probably want to extract corners in world space so use invViewProj
+ * Computing invViewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   ...
+ *   glm_mat4_inv(viewProj, invViewProj);
+ *
+ * if you have a near coord at i index, you can get it's far coord by i + 4
+ *
+ * Find center coordinates:
+ *   for (j = 0; j < 4; j++) {
+ *     glm_vec3_center(corners[i], corners[i + 4], centerCorners[i]);
+ *   }
+ *
+ * @param[in]  invMat matrix (see brief)
+ * @param[out] dest   exracted view frustum corners (see brief)
+ */
+CGLM_INLINE
+void
+glms_frustum_corners(mat4s invMat, vec4s dest[8]) {
+  vec4 rawDest[8];
+  glm_frustum_corners(invMat.raw, rawDest);
+  glms_vec4_pack(dest, rawDest, 8);
+}
+
+/*!
+ * @brief finds center of view frustum
+ *
+ * @param[in]  corners view frustum corners
+ * @returns            view frustum center
+ */
+CGLM_INLINE
+vec4s
+glms_frustum_center(vec4s corners[8]) {
+  vec4 rawCorners[8];
+  vec4s r;
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_center(rawCorners, r.raw);
+  return r;
+}
+
+/*!
+ * @brief finds bounding box of frustum relative to given matrix e.g. view mat
+ *
+ * @param[in]  corners view frustum corners
+ * @param[in]  m       matrix to convert existing conners
+ * @param[out] box     bounding box as array [min, max]
+ */
+CGLM_INLINE
+void
+glms_frustum_box(vec4s corners[8], mat4s m, vec3s box[2]) {
+  vec4 rawCorners[8];
+  vec3 rawBox[2];
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_box(rawCorners, m.raw, rawBox);
+  glms_vec3_pack(box, rawBox, 2);
+}
+
+/*!
+ * @brief finds planes corners which is between near and far planes (parallel)
+ *
+ * this will be helpful if you want to split a frustum e.g. CSM/PSSM. This will
+ * find planes' corners but you will need to one more plane.
+ * Actually you have it, it is near, far or created previously with this func ;)
+ *
+ * @param[in]  corners view  frustum corners
+ * @param[in]  splitDist     split distance
+ * @param[in]  farDist       far distance (zFar)
+ * @param[out] planeCorners  plane corners [LB, LT, RT, RB]
+ */
+CGLM_INLINE
+void
+glms_frustum_corners_at(vec4s corners[8],
+                        float splitDist,
+                        float farDist,
+                        vec4s planeCorners[4]) {
+  vec4 rawCorners[8];
+  vec4 rawPlaneCorners[4];
+
+  glms_vec4_unpack(rawCorners, corners, 8);
+  glm_frustum_corners_at(rawCorners, splitDist, farDist, rawPlaneCorners);
+  glms_vec4_pack(planeCorners, rawPlaneCorners, 8);
+}
+
+#endif /* cglms_frustums_h */

include/cglm/struct/io.h

@@ -0,0 +1,82 @@
+/*
+ * 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_mat4_print(mat4 matrix, FILE *ostream);
+   CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
+   CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
+   CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
+   CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
+ */
+
+#ifndef cglms_ios_h
+#define cglms_ios_h
+
+#include "../common.h"
+#include "../io.h"
+#include "mat4.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+CGLM_INLINE
+void
+glms_mat4_print(mat4s             matrix,
+                FILE * __restrict ostream) {
+
+  glm_mat4_print(matrix.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_mat3_print(mat3s             matrix,
+                FILE * __restrict ostream) {
+  glm_mat3_print(matrix.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_vec4_print(vec4s             vec,
+                FILE * __restrict ostream) {
+  glm_vec4_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_vec3_print(vec3s             vec,
+                FILE * __restrict ostream) {
+  glm_vec3_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_ivec3_print(ivec3s            vec,
+                 FILE * __restrict ostream) {
+  glm_ivec3_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_versor_print(versors           vec,
+                  FILE * __restrict ostream) {
+  glm_versor_print(vec.raw, ostream);
+}
+
+CGLM_INLINE
+void
+glms_aabb_print(vec3s                   bbox[2],
+                const char * __restrict tag,
+                FILE       * __restrict ostream) {
+  vec3 rawBbox[2];
+
+  glms_vec3_unpack(rawBbox, bbox, 2);
+  glm_aabb_print(rawBbox, tag, ostream);
+}
+
+#endif /* cglms_ios_h */

include/cglm/struct/mat2.h

@@ -0,0 +1,258 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLM_MAT2_IDENTITY_INIT
+   GLM_MAT2_ZERO_INIT
+   GLM_MAT2_IDENTITY
+   GLM_MAT2_ZERO
+
+ Functions:
+   CGLM_INLINE void  glms_mat2_identity(mat2 mat)
+   CGLM_INLINE void  glms_mat2_identity_array(mat2 * restrict mat, size_t count)
+   CGLM_INLINE void  glms_mat2_zero(mat2 mat)
+   CGLM_INLINE void  glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose_to(mat2 m, mat2 dest)
+   CGLM_INLINE void  glms_mat2_transpose(mat2 m)
+   CGLM_INLINE void  glms_mat2_mulv(mat2 m, vec2 v, vec2 dest)
+   CGLM_INLINE float glms_mat2_trace(mat2 m)
+   CGLM_INLINE void  glms_mat2_scale(mat2 m, float s)
+   CGLM_INLINE float glms_mat2_det(mat2 mat)
+   CGLM_INLINE void  glms_mat2_inv(mat2 mat, mat2 dest)
+   CGLM_INLINE void  glms_mat2_swap_col(mat2 mat, int col1, int col2)
+   CGLM_INLINE void  glms_mat2_swap_row(mat2 mat, int row1, int row2)
+   CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
+ */
+
+#ifndef cglms_mat2_h
+#define cglms_mat2_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat2.h"
+
+#define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
+#define GLMS_MAT2_ZERO_INIT     {GLM_MAT2_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
+#define GLMS_MAT2_ZERO     ((mat3s)GLMS_MAT2_ZERO_INIT)
+
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat2_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat2 mat = GLM_MAT2_IDENTITY_INIT;
+ * @endcode
+ *
+ * @returns identity matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_identity(void) {
+  mat2s r;
+  glm_mat2_identity(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat2_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_zero(void) {
+  mat2s r;
+  glm_mat2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat2 m = GLM_MAT2_IDENTITY_INIT;
+ * glm_mat2_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ *
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_mul(mat2s m1, mat2s m2) {
+  mat2s r;
+  glm_mat2_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief transpose mat2
+ *
+ * @param[in] m matrix to transpose
+ *
+ * @returns transposed matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_transpose(mat2s m) {
+  glm_mat2_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief multiply mat2 with vec2 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat2 (left)
+ * @param[in]  v    vec2 (right, column vector)
+ * @returns         vec2 (result, column vector)
+ */
+CGLM_INLINE
+vec2s
+glms_mat2_mulv(mat2s m, vec2s v) {
+  vec2s r;
+  glm_mat2_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat2_trace(mat2s m) {
+  return glm_mat2_trace(m.raw);
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in, out] m matrix
+ * @param[in]      s scalar
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_scale(mat2s m, float s) {
+  glm_mat2_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat2 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat2_det(mat2s mat) {
+  return glm_mat2_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat2 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_inv(mat2s mat) {
+  mat2s r;
+  glm_mat2_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in] mat  matrix
+ * @param[in] col1 col1
+ * @param[in] col2 col2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_col(mat2s mat, int col1, int col2) {
+  glm_mat2_swap_col(mat.raw, col1, col2);
+  return mat;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in] mat  matrix
+ * @param[in] row1 row1
+ * @param[in] row2 row2
+ * @returns matrix
+ */
+CGLM_INLINE
+mat2s
+glms_mat2_swap_row(mat2s mat, int row1, int row2) {
+  glm_mat2_swap_row(mat.raw, row1, row2);
+  return mat;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x2 (row vector),
+ * then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x2
+ * @param[in]  m   matrix2x2
+ * @param[in]  c   column vector or matrix2x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
+  return glm_mat2_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat2_h */

include/cglm/struct/mat3.h

@@ -0,0 +1,285 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_MAT3_IDENTITY_INIT
+   GLMS_MAT3_ZERO_INIT
+   GLMS_MAT3_IDENTITY
+   GLMS_MAT3_ZERO
+
+ Functions:
+   CGLM_INLINE mat3s  glms_mat3_copy(mat3s mat);
+   CGLM_INLINE mat3s  glms_mat3_identity(void);
+   CGLM_INLINE void   glms_mat3_identity_array(mat3s * __restrict mat, size_t count);
+   CGLM_INLINE mat3s  glms_mat3_zero(void);
+   CGLM_INLINE mat3s  glms_mat3_mul(mat3s m1, mat3s m2);
+   CGLM_INLINE ma3s   glms_mat3_transpose(mat3s m);
+   CGLM_INLINE vec3s  glms_mat3_mulv(mat3s m, vec3s v);
+   CGLM_INLINE float  glms_mat3_trace(mat3s m);
+   CGLM_INLINE versor glms_mat3_quat(mat3s m);
+   CGLM_INLINE mat3s  glms_mat3_scale(mat3s m, float s);
+   CGLM_INLINE float  glms_mat3_det(mat3s mat);
+   CGLM_INLINE mat3s  glms_mat3_inv(mat3s mat);
+   CGLM_INLINE mat3s  glms_mat3_swap_col(mat3s mat, int col1, int col2);
+   CGLM_INLINE mat3s  glms_mat3_swap_row(mat3s mat, int row1, int row2);
+   CGLM_INLINE float  glms_mat3_rmc(vec3s r, mat3s m, vec3s c);
+ */
+
+#ifndef cglms_mat3s_h
+#define cglms_mat3s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat3.h"
+#include "vec3.h"
+
+#define GLMS_MAT3_IDENTITY_INIT  {GLM_MAT3_IDENTITY_INIT}
+#define GLMS_MAT3_ZERO_INIT      {GLM_MAT3_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT3_IDENTITY ((mat3s)GLMS_MAT3_IDENTITY_INIT)
+#define GLMS_MAT3_ZERO     ((mat3s)GLMS_MAT3_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_copy(mat3s mat) {
+  mat3s r;
+  glm_mat3_copy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix identity. It is identical with below,
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat3_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat3_copy(GLM_MAT3_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat3 mat = GLM_MAT3_IDENTITY_INIT;
+ * @endcode
+ *
+ * @returns  destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_identity(void) {
+  mat3s r;
+  glm_mat3_identity(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16/32)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat3s t = GLMS_MAT3_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat3_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_zero(void) {
+  mat3s r;
+  glm_mat3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat3 m = GLM_MAT3_IDENTITY_INIT;
+ * glm_mat3_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_mul(mat3s m1, mat3s m2) {
+  mat3s r;
+  glm_mat3_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief tranpose mat3 and store result in same matrix
+ *
+ * @param[in, out] m source and dest
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_transpose(mat3s m) {
+  glm_mat3_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief multiply mat3 with vec3 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat3 (left)
+ * @param[in]  v    vec3 (right, column vector)
+ * @returns         vec3 (result, column vector)
+ */
+CGLM_INLINE
+vec3s
+glms_mat3_mulv(mat3s m, vec3s v) {
+  vec3s r;
+  glm_mat3_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat3_trace(mat3s m) {
+  return glm_mat3_trace(m.raw);
+}
+
+/*!
+ * @brief convert mat3 to quaternion
+ *
+ * @param[in]  m    rotation matrix
+ * @returns         destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_mat3_quat(mat3s m) {
+  versors r;
+  glm_mat3_quat(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in]      m matrix
+ * @param[in]      s scalar
+ * @returns          scaled matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_scale(mat3s m, float s) {
+  glm_mat3_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat3 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat3_det(mat3s mat) {
+  return glm_mat3_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat3 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_inv(mat3s mat) {
+  mat3s r;
+  glm_mat3_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in]     mat  matrix
+ * @param[in]     col1 col1
+ * @param[in]     col2 col2
+ * @returns            matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_swap_col(mat3s mat, int col1, int col2) {
+  glm_mat3_swap_col(mat.raw, col1, col2);
+  return mat;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in]     mat  matrix
+ * @param[in]     row1 row1
+ * @param[in]     row2 row2
+ * @returns            matrix
+ */
+CGLM_INLINE
+mat3s
+glms_mat3_swap_row(mat3s mat, int row1, int row2) {
+  glm_mat3_swap_row(mat.raw, row1, row2);
+  return mat;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x3 (row vector),
+ * then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x3
+ * @param[in]  m   matrix3x3
+ * @param[in]  c   column vector or matrix3x1
+ *
+ * @return scalar value e.g. Matrix1x1
+ */
+CGLM_INLINE
+float
+glms_mat3_rmc(vec3s r, mat3s m, vec3s c) {
+  return glm_mat3_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat3s_h */

include/cglm/struct/mat4.h

@@ -0,0 +1,459 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * Most of functions in this header are optimized manually with SIMD
+ * if available. You dont need to call/incude SIMD headers manually
+ */
+
+/*
+ Macros:
+   GLMS_MAT4_IDENTITY_INIT
+   GLMS_MAT4_ZERO_INIT
+   GLMS_MAT4_IDENTITY
+   GLMS_MAT4_ZERO
+
+ Functions:
+   CGLM_INLINE mat4s   glms_mat4_ucopy(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_copy(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_identity(void);
+   CGLM_INLINE void    glms_mat4_identity_array(mat4s * __restrict mat, size_t count);
+   CGLM_INLINE mat4s   glms_mat4_zero(void);
+   CGLM_INLINE mat3s   glms_mat4_pick3(mat4s mat);
+   CGLM_INLINE mat3s   glms_mat4_pick3t(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_ins3(mat3s mat);
+   CGLM_INLINE mat4s   glms_mat4_mul(mat4s m1, mat4s m2);
+   CGLM_INLINE mat4s   glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len);
+   CGLM_INLINE vec4s   glms_mat4_mulv(mat4s m, vec4s v);
+   CGLM_INLINE float   glms_mat4_trace(mat4s m);
+   CGLM_INLINE float   glms_mat4_trace3(mat4s m);
+   CGLM_INLINE versors glms_mat4_quat(mat4s m);
+   CGLM_INLINE vec3s   glms_mat4_mulv3(mat4s m, vec3s v, float last);
+   CGLM_INLINE mat4s   glms_mat4_transpose(mat4s m);
+   CGLM_INLINE mat4s   glms_mat4_scale_p(mat4s m, float s);
+   CGLM_INLINE mat4s   glms_mat4_scale(mat4s m, float s);
+   CGLM_INLINE float   glms_mat4_det(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_inv(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_inv_fast(mat4s mat);
+   CGLM_INLINE mat4s   glms_mat4_swap_col(mat4s mat, int col1, int col2);
+   CGLM_INLINE mat4s   glms_mat4_swap_row(mat4s mat, int row1, int row2);
+   CGLM_INLINE float   glms_mat4_rmc(vec4s r, mat4s m, vec4s c);
+ */
+
+#ifndef cglms_mat4s_h
+#define cglms_mat4s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../mat4.h"
+#include "vec4.h"
+#include "vec3.h"
+
+#define GLMS_MAT4_IDENTITY_INIT  {GLM_MAT4_IDENTITY_INIT}
+#define GLMS_MAT4_ZERO_INIT      {GLM_MAT4_ZERO_INIT}
+
+/* for C only */
+#define GLMS_MAT4_IDENTITY ((mat4s)GLMS_MAT4_IDENTITY_INIT)
+#define GLMS_MAT4_ZERO     ((mat4s)GLMS_MAT4_ZERO_INIT)
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * matrix may not be aligned, u stands for unaligned, this may be useful when
+ * copying a matrix from external source e.g. asset importer...
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_ucopy(mat4s mat) {
+  mat4s r;
+  glm_mat4_ucopy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [mat] to [dest]
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_copy(mat4s mat) {
+  mat4s r;
+  glm_mat4_copy(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix identity. It is identical with below, 
+ *        but it is more easy to do that with this func especially for members
+ *        e.g. glm_mat4_identity(aStruct->aMatrix);
+ *
+ * @code
+ * glm_mat4_copy(GLM_MAT4_IDENTITY, mat); // C only
+ *
+ * // or
+ * mat4 mat = GLM_MAT4_IDENTITY_INIT;
+ * @endcode
+ *
+ * @retuns  destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_identity(void) {
+  mat4s r;
+  glm_mat4_identity(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make given matrix array's each element identity matrix
+ *
+ * @param[in, out]  mat   matrix array (must be aligned (16/32)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of matrices
+ */
+CGLM_INLINE
+void
+glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
+  CGLM_ALIGN_MAT mat4s t = GLMS_MAT4_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_mat4_copy(t.raw, mat[i].raw);
+  }
+}
+
+/*!
+ * @brief make given matrix zero.
+ *
+ * @returns  matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_zero(void) {
+  mat4s r;
+  glm_mat4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy upper-left of mat4 to mat3
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat4_pick3(mat4s mat) {
+  mat3s r;
+  glm_mat4_pick3(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy upper-left of mat4 to mat3 (transposed)
+ *
+ * the postfix t stands for transpose
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat3s
+glms_mat4_pick3t(mat4s mat) {
+  mat3s r;
+  glm_mat4_pick3t(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy mat3 to mat4's upper-left
+ *
+ * @param[in]  mat  source
+ * @returns         destination
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_ins3(mat3s mat) {
+  mat4s r;
+  glm_mat4_ins3(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply m1 and m2 to dest
+ *
+ * m1, m2 and dest matrices can be same matrix, it is possible to write this:
+ *
+ * @code
+ * mat4 m = GLM_MAT4_IDENTITY_INIT;
+ * glm_mat4_mul(m, m, m);
+ * @endcode
+ *
+ * @param[in]  m1   left matrix
+ * @param[in]  m2   right matrix
+ * @returns         destination matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_mul(mat4s m1, mat4s m2) {
+  mat4s r;
+  glm_mat4_mul(m1.raw, m2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief mupliply N mat4 matrices and store result in dest
+ *
+ * this function lets you multiply multiple (more than two or more...) matrices
+ * <br><br>multiplication will be done in loop, this may reduce instructions
+ * size but if <b>len</b> is too small then compiler may unroll whole loop,
+ * usage:
+ * @code
+ * mat m1, m2, m3, m4, res;
+ *
+ * res = glm_mat4_mulN((mat4 *[]){&m1, &m2, &m3, &m4}, 4);
+ * @endcode
+ *
+ * @warning matrices parameter is pointer array not mat4 array!
+ *
+ * @param[in]  matrices mat4 * array
+ * @param[in]  len      matrices count
+ * @returns             result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len) {
+  CGLM_ALIGN_MAT mat4s r = GLMS_MAT4_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    r = glms_mat4_mul(r, *matrices[i]);
+  }
+  
+  return r;
+}
+
+/*!
+ * @brief multiply mat4 with vec4 (column vector) and store in dest vector
+ *
+ * @param[in]  m    mat4 (left)
+ * @param[in]  v    vec4 (right, column vector)
+ * @returns         vec4 (result, column vector)
+ */
+CGLM_INLINE
+vec4s
+glms_mat4_mulv(mat4s m, vec4s v) {
+  vec4s r;
+  glm_mat4_mulv(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief trace of matrix
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat4_trace(mat4s m) {
+  return glm_mat4_trace(m.raw);
+}
+
+/*!
+ * @brief trace of matrix (rotation part)
+ *
+ * sum of the elements on the main diagonal from upper left to the lower right
+ *
+ * @param[in]  m matrix
+ */
+CGLM_INLINE
+float
+glms_mat4_trace3(mat4s m) {
+  return glm_mat4_trace3(m.raw);
+}
+
+/*!
+ * @brief convert mat4's rotation part to quaternion
+ *
+ * @param[in]  m    affine matrix
+ * @returns         destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_mat4_quat(mat4s m) {
+  versors r;
+  glm_mat4_quat(m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply vector with mat4
+ *
+ * @param[in]  m    mat4(affine transform)
+ * @param[in]  v    vec3
+ * @param[in]  last 4th item to make it vec4
+ * @returns         result vector (vec3)
+ */
+CGLM_INLINE
+vec3s
+glms_mat4_mulv3(mat4s m, vec3s v, float last) {
+  vec3s r;
+  glm_mat4_mulv3(m.raw, v.raw, last, r.raw);
+  return r;
+}
+
+/*!
+ * @brief tranpose mat4 and store result in same matrix
+ *
+ * @param[in] m source
+ * @returns     result
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_transpose(mat4s m) {
+  glm_mat4_transpose(m.raw);
+  return m;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix without simd optimization
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in] m matrix
+ * @param[in] s scalar
+ * @returns     matrix    
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_scale_p(mat4s m, float s) {
+  glm_mat4_scale_p(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief scale (multiply with scalar) matrix
+ *
+ * multiply matrix with scalar
+ *
+ * @param[in] m matrix
+ * @param[in] s scalar
+ * @returns     matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_scale(mat4s m, float s) {
+  glm_mat4_scale(m.raw, s);
+  return m;
+}
+
+/*!
+ * @brief mat4 determinant
+ *
+ * @param[in] mat matrix
+ *
+ * @return determinant
+ */
+CGLM_INLINE
+float
+glms_mat4_det(mat4s mat) {
+  return glm_mat4_det(mat.raw);
+}
+
+/*!
+ * @brief inverse mat4 and store in dest
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_inv(mat4s mat) {
+  mat4s r;
+  glm_mat4_inv(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief inverse mat4 and store in dest
+ *
+ * this func uses reciprocal approximation without extra corrections
+ * e.g Newton-Raphson. this should work faster than normal,
+ * to get more precise use glm_mat4_inv version.
+ *
+ * NOTE: You will lose precision, glm_mat4_inv is more accurate
+ *
+ * @param[in]  mat  matrix
+ * @returns         inverse matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_inv_fast(mat4s mat) {
+  mat4s r;
+  glm_mat4_inv_fast(mat.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swap two matrix columns
+ *
+ * @param[in] mat  matrix
+ * @param[in] col1 col1
+ * @param[in] col2 col2
+ * @returns        matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_swap_col(mat4s mat, int col1, int col2) {
+  glm_mat4_swap_col(mat.raw, col1, col2);
+  return mat;
+}
+
+/*!
+ * @brief swap two matrix rows
+ *
+ * @param[in] mat  matrix
+ * @param[in] row1 row1
+ * @param[in] row2 row2
+ * @returns        matrix
+ */
+CGLM_INLINE
+mat4s
+glms_mat4_swap_row(mat4s mat, int row1, int row2) {
+  glm_mat4_swap_row(mat.raw, row1, row2);
+  return mat;
+}
+
+/*!
+ * @brief helper for  R (row vector) * M (matrix) * C (column vector)
+ *
+ * rmc stands for Row * Matrix * Column
+ *
+ * the result is scalar because R * M = Matrix1x4 (row vector),
+ * then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
+ *
+ * @param[in]  r   row vector or matrix1x4
+ * @param[in]  m   matrix4x4
+ * @param[in]  c   column vector or matrix4x1
+ *
+ * @return scalar value e.g. B(s)
+ */
+CGLM_INLINE
+float
+glms_mat4_rmc(vec4s r, mat4s m, vec4s c) {
+  return glm_mat4_rmc(r.raw, m.raw, c.raw);
+}
+
+#endif /* cglms_mat4s_h */

include/cglm/struct/plane.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_planes_h
+#define cglms_planes_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../plane.h"
+#include "vec4.h"
+
+/*
+ Plane equation:  Ax + By + Cz + D = 0;
+
+ It stored in vec4 as [A, B, C, D]. (A, B, C) is normal and D is distance
+*/
+
+/*
+ Functions:
+   CGLM_INLINE vec4s glms_plane_normalize(vec4s plane);
+ */
+
+/*!
+ * @brief normalizes a plane
+ *
+ * @param[in] plane plane to normalize
+ * @returns         normalized plane
+ */
+CGLM_INLINE
+vec4s
+glms_plane_normalize(vec4s plane) {
+  glm_plane_normalize(plane.raw);
+  return plane;
+}
+
+#endif /* cglms_planes_h */

include/cglm/struct/project.h

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_projects_h
+#define cglms_projects_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../project.h"
+#include "vec3.h"
+#include "vec4.h"
+#include "mat4.h"
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * if you don't have ( and don't want to have ) an inverse matrix then use
+ * glm_unproject version. You may use existing inverse of matrix in somewhere
+ * else, this is why glm_unprojecti exists to save save inversion cost
+ *
+ * [1] space:
+ *  1- if m = invProj:     View Space
+ *  2- if m = invViewProj: World Space
+ *  3- if m = invMVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use invMVP as m
+ *
+ * Computing viewProj:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *   glm_mat4_inv(viewProj, invMVP);
+ *
+ * @param[in]  pos      point/position in viewport coordinates
+ * @param[in]  invMat   matrix (see brief)
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns             unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unprojecti(vec3s pos, mat4s invMat, vec4s vp) {
+  vec3s r;
+  glm_unprojecti(pos.raw, invMat.raw, vp.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief maps the specified viewport coordinates into specified space [1]
+ *        the matrix should contain projection matrix.
+ *
+ * this is same as glm_unprojecti except this function get inverse matrix for
+ * you.
+ *
+ * [1] space:
+ *  1- if m = proj:     View Space
+ *  2- if m = viewProj: World Space
+ *  3- if m = MVP:      Object Space
+ *
+ * You probably want to map the coordinates into object space
+ * so use MVP as m
+ *
+ * Computing viewProj and MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      point/position in viewport coordinates
+ * @param[in]  m        matrix (see brief)
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns             unprojected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_unproject(vec3s pos, mat4s m, vec4s vp) {
+  vec3s r;
+  glm_unproject(pos.raw, m.raw, vp.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief map object coordinates to window coordinates
+ *
+ * Computing MVP:
+ *   glm_mat4_mul(proj, view, viewProj);
+ *   glm_mat4_mul(viewProj, model, MVP);
+ *
+ * @param[in]  pos      object coordinates
+ * @param[in]  m        MVP matrix
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns projected coordinates
+ */
+CGLM_INLINE
+vec3s
+glms_project(vec3s pos, mat4s m, vec4s vp) {
+  vec3s r;
+  glm_project(pos.raw, m.raw, vp.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief define a picking region
+ *
+ * @param[in]  center   center [x, y] of a picking region in window coordinates
+ * @param[in]  size     size [width, height] of the picking region in window coordinates
+ * @param[in]  vp       viewport as [x, y, width, height]
+ * @returns projected coordinates
+ */
+CGLM_INLINE
+mat4s
+glms_pickmatrix(vec2s center, vec2s size, vec4s vp) {
+  mat4s res;
+  glm_pickmatrix(center.raw, size.raw, vp.raw, res.raw);
+  return res;
+}
+
+#endif /* cglms_projects_h */

include/cglm/struct/quat.h

@@ -0,0 +1,565 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_QUAT_IDENTITY_INIT
+   GLMS_QUAT_IDENTITY
+
+ Functions:
+   CGLM_INLINE versors glms_quat_identity(void)
+   CGLM_INLINE void    glms_quat_identity_array(versor *q, size_t count)
+   CGLM_INLINE versors glms_quat_init(float x, float y, float z, float w)
+   CGLM_INLINE versors glms_quatv(float angle, vec3s axis)
+   CGLM_INLINE versors glms_quat(float angle, float x, float y, float z)
+   CGLM_INLINE versors glms_quat_from_vecs(vec3s a, vec3s b)
+   CGLM_INLINE float   glms_quat_norm(versors q)
+   CGLM_INLINE versors glms_quat_normalize(versors q)
+   CGLM_INLINE float   glms_quat_dot(versors p, versors q)
+   CGLM_INLINE versors glms_quat_conjugate(versors q)
+   CGLM_INLINE versors glms_quat_inv(versors q)
+   CGLM_INLINE versors glms_quat_add(versors p, versors q)
+   CGLM_INLINE versors glms_quat_sub(versors p, versors q)
+   CGLM_INLINE vec3s   glms_quat_imagn(versors q)
+   CGLM_INLINE float   glms_quat_imaglen(versors q)
+   CGLM_INLINE float   glms_quat_angle(versors q)
+   CGLM_INLINE vec3s   glms_quat_axis(versors q)
+   CGLM_INLINE versors glms_quat_mul(versors p, versors q)
+   CGLM_INLINE mat4s   glms_quat_mat4(versors q)
+   CGLM_INLINE mat4s   glms_quat_mat4t(versors q)
+   CGLM_INLINE mat3s   glms_quat_mat3(versors q)
+   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)
+   CGLM_INLINE versors glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up)
+   CGLM_INLINE vec3s   glms_quat_rotatev(versors q, vec3s v)
+   CGLM_INLINE mat4s   glms_quat_rotate(mat4s m, versors q)
+   CGLM_INLINE mat4s   glms_quat_rotate_at(mat4s m, versors q, vec3s pivot)
+   CGLM_INLINE mat4s   glms_quat_rotate_atm(versors q, vec3s pivot)
+ */
+
+#ifndef cglms_quat_h
+#define cglms_quat_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../plane.h"
+#include "../quat.h"
+
+/*
+ * IMPORTANT:
+ * ----------------------------------------------------------------------------
+ * cglm stores quat as [x, y, z, w] since v0.3.6
+ *
+ * it was [w, x, y, z] before v0.3.6 it has been changed to [x, y, z, w]
+ * with v0.3.6 version.
+ * ----------------------------------------------------------------------------
+ */
+
+#define GLMS_QUAT_IDENTITY_INIT  {GLM_QUAT_IDENTITY_INIT}
+#define GLMS_QUAT_IDENTITY       ((versors)GLMS_QUAT_IDENTITY_INIT)
+
+/*!
+ * @brief makes given quat to identity
+ *
+ * @returns identity quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_identity(void) {
+  versors dest;
+  glm_quat_identity(dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief make given quaternion array's each element identity quaternion
+ *
+ * @param[in, out]  q     quat array (must be aligned (16)
+ *                        if alignment is not disabled)
+ *
+ * @param[in]       count count of quaternions
+ */
+CGLM_INLINE
+void
+glms_quat_identity_array(versors * __restrict q, size_t count) {
+  CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
+  size_t i;
+
+  for (i = 0; i < count; i++) {
+    glm_vec4_copy(v, q[i].raw);
+  }
+}
+
+/*!
+ * @brief inits quaterion with raw values
+ *
+ * @param[in]   x     x
+ * @param[in]   y     y
+ * @param[in]   z     z
+ * @param[in]   w     w (real part)
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_init(float x, float y, float z, float w) {
+  versors dest;
+  glm_quat_init(dest.raw, x, y, z, w);
+  return dest;
+}
+
+/*!
+ * @brief creates NEW quaternion with axis vector
+ *
+ * @param[in]   angle angle (radians)
+ * @param[in]   axis  axis
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quatv(float angle, vec3s axis) {
+  versors dest;
+  glm_quatv(dest.raw, angle, axis.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates NEW quaternion with individual axis components
+ *
+ * @param[in]   angle angle (radians)
+ * @param[in]   x     axis.x
+ * @param[in]   y     axis.y
+ * @param[in]   z     axis.z
+ * @returns quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat(float angle, float x, float y, float z) {
+  versors dest;
+  glm_quat(dest.raw, angle, x, y, z);
+  return dest;
+}
+
+/*!
+ * @brief compute quaternion rotating vector A to vector B
+ *
+ * @param[in]   a     vec3 (must have unit length)
+ * @param[in]   b     vec3 (must have unit length)
+ * @returns     quaternion (of unit length)
+ */
+CGLM_INLINE
+versors
+glms_quat_from_vecs(vec3s a, vec3s b) {
+  versors dest;
+  glm_quat_from_vecs(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief returns norm (magnitude) of quaternion
+ *
+ * @param[in]  q  quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_norm(versors q) {
+  return glm_quat_norm(q.raw);
+}
+
+/*!
+ * @brief normalize quaternion
+ *
+ * @param[in]  q  quaternion
+ * @returns    quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_normalize(versors q) {
+  versors dest;
+  glm_quat_normalize_to(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief dot product of two quaternion
+ *
+ * @param[in]  p  quaternion 1
+ * @param[in]  q  quaternion 2
+ * @returns    dot product
+ */
+CGLM_INLINE
+float
+glms_quat_dot(versors p, versors q) {
+  return glm_quat_dot(p.raw, q.raw);
+}
+
+/*!
+ * @brief conjugate of quaternion
+ *
+ * @param[in]   q     quaternion
+ * @returns    conjugate
+ */
+CGLM_INLINE
+versors
+glms_quat_conjugate(versors q) {
+  versors dest;
+  glm_quat_conjugate(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief inverse of non-zero quaternion
+ *
+ * @param[in]  q    quaternion
+ * @returns    inverse quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_inv(versors q) {
+  versors dest;
+  glm_quat_inv(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add (componentwise) two quaternions and store result in dest
+ *
+ * @param[in]   p    quaternion 1
+ * @param[in]   q    quaternion 2
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_add(versors p, versors q) {
+  versors dest;
+  glm_quat_add(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief subtract (componentwise) two quaternions and store result in dest
+ *
+ * @param[in]   p    quaternion 1
+ * @param[in]   q    quaternion 2
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_sub(versors p, versors q) {
+  versors dest;
+  glm_quat_sub(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief returns normalized imaginary part of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+vec3s
+glms_quat_imagn(versors q) {
+  vec3s dest;
+  glm_normalize_to(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief returns length of imaginary part of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_imaglen(versors q) {
+  return glm_quat_imaglen(q.raw);
+}
+
+/*!
+ * @brief returns angle of quaternion
+ *
+ * @param[in]   q    quaternion
+ */
+CGLM_INLINE
+float
+glms_quat_angle(versors q) {
+  return glm_quat_angle(q.raw);
+}
+
+/*!
+ * @brief axis of quaternion
+ *
+ * @param[in]   q    quaternion
+ * @returns axis of quaternion
+ */
+CGLM_INLINE
+vec3s
+glms_quat_axis(versors q) {
+  vec3s dest;
+  glm_quat_axis(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief multiplies two quaternion and stores result in dest
+ *        this is also called Hamilton Product
+ *
+ * According to WikiPedia:
+ * The product of two rotation quaternions [clarification needed] will be
+ * equivalent to the rotation q followed by the rotation p
+ *
+ * @param[in]   p     quaternion 1
+ * @param[in]   q     quaternion 2
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_mul(versors p, versors q) {
+  versors dest;
+  glm_quat_mul(p.raw, q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat4
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat4s
+glms_quat_mat4(versors q) {
+  mat4s dest;
+  glm_quat_mat4(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat4 (transposed)
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix as transposed
+ */
+CGLM_INLINE
+mat4s
+glms_quat_mat4t(versors q) {
+  mat4s dest;
+  glm_quat_mat4t(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat3
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat3s
+glms_quat_mat3(versors q) {
+  mat3s dest;
+  glm_quat_mat3(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief convert quaternion to mat3 (transposed)
+ *
+ * @param[in]   q     quaternion
+ * @returns  result matrix
+ */
+CGLM_INLINE
+mat3s
+glms_quat_mat3t(versors q) {
+  mat3s dest;
+  glm_quat_mat3t(q.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief interpolates between two quaternions
+ *        using linear interpolation (LERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount)
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_lerp(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_lerp(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief interpolates between two quaternions
+ *        using linear interpolation (LERP)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns  result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_lerpc(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_lerpc(from.raw, to.raw, t, dest.raw);
+  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)
+ * @returns 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)
+ *
+ * @param[in]   from  from
+ * @param[in]   to    to
+ * @param[in]   t     amout
+ * @returns result quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_slerp(versors from, versors to, float t) {
+  versors dest;
+  glm_quat_slerp(from.raw, to.raw, t, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates view matrix using quaternion as camera orientation
+ *
+ * @param[in]   eye   eye
+ * @param[in]   ori   orientation in world space as quaternion
+ * @returns  view matrix
+ */
+CGLM_INLINE
+mat4s
+glms_quat_look(vec3s eye, versors ori) {
+  mat4s dest;
+  glm_quat_look(eye.raw, ori.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates look rotation quaternion
+ *
+ * @param[in]   dir   direction to look
+ * @param[in]   up    up vector
+ * @returns  destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_for(vec3s dir, vec3s up) {
+  versors dest;
+  glm_quat_for(dir.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief creates look rotation quaternion using source and
+ *        destination positions p suffix stands for position
+ *
+ * @param[in]   from  source point
+ * @param[in]   to    destination point
+ * @param[in]   up    up vector
+ * @returns  destination quaternion
+ */
+CGLM_INLINE
+versors
+glms_quat_forp(vec3s from, vec3s to, vec3s up) {
+  versors dest;
+  glm_quat_forp(from.raw, to.raw, up.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief rotate vector using using quaternion
+ *
+ * @param[in]   q     quaternion
+ * @param[in]   v     vector to rotate
+ * @returns  rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_quat_rotatev(versors q, vec3s v) {
+  vec3s dest;
+  glm_quat_rotatev(q.raw, v.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief rotate existing transform matrix using quaternion
+ *
+ * @param[in]   m     existing transform matrix
+ * @param[in]   q     quaternion
+ * @returns  rotated matrix/transform
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate(mat4s m, versors q) {
+  glm_quat_rotate(m.raw, q.raw, m.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate existing transform matrix using quaternion at pivot point
+ *
+ * @param[in, out]   m     existing transform matrix
+ * @param[in]        q     quaternion
+ * @returns pivot
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate_at(mat4s m, versors q, vec3s pivot) {
+  glm_quat_rotate_at(m.raw, q.raw, pivot.raw);
+  return m;
+}
+
+/*!
+ * @brief rotate NEW transform matrix using quaternion at pivot point
+ *
+ * this creates rotation matrix, it assumes you don't have a matrix
+ *
+ * this should work faster than glm_quat_rotate_at because it reduces
+ * one glm_translate.
+ *
+ * @param[in]   q     quaternion
+ * @returns pivot
+ */
+CGLM_INLINE
+mat4s
+glms_quat_rotate_atm(versors q, vec3s pivot) {
+  mat4s dest;
+  glm_quat_rotate_atm(dest.raw, q.raw, pivot.raw);
+  return dest;
+}
+
+#endif /* cglms_quat_h */

include/cglm/struct/sphere.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+#ifndef cglms_spheres_h
+#define cglms_spheres_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../sphere.h"
+#include "mat4.h"
+
+/*
+  Sphere Representation in cglm: [center.x, center.y, center.z, radii]
+
+  You could use this representation or you can convert it to vec4 before call
+  any function
+ */
+
+/*!
+ * @brief helper for getting sphere radius
+ *
+ * @param[in]   s  sphere
+ *
+ * @return returns radii
+ */
+CGLM_INLINE
+float
+glms_sphere_radii(vec4s s) {
+  return glm_sphere_radii(s.raw);
+}
+
+/*!
+ * @brief apply transform to sphere, it is just wrapper for glm_mat4_mulv3
+ *
+ * @param[in]  s    sphere
+ * @param[in]  m    transform matrix
+ * @returns         transformed sphere
+ */
+CGLM_INLINE
+vec4s
+glms_sphere_transform(vec4s s, mat4s m) {
+  vec4s r;
+  glm_sphere_transform(s.raw, m.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief merges two spheres and creates a new one
+ *
+ * two sphere must be in same space, for instance if one in world space then
+ * the other must be in world space too, not in local space.
+ *
+ * @param[in]  s1   sphere 1
+ * @param[in]  s2   sphere 2
+ * returns          merged/extended sphere
+ */
+CGLM_INLINE
+vec4s
+glms_sphere_merge(vec4s s1, vec4s s2) {
+  vec4s r;
+  glm_sphere_merge(s1.raw, s2.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief check if two sphere intersects
+ *
+ * @param[in]   s1  sphere
+ * @param[in]   s2  other sphere
+ */
+CGLM_INLINE
+bool
+glms_sphere_sphere(vec4s s1, vec4s s2) {
+  return glm_sphere_sphere(s1.raw, s2.raw);
+}
+
+/*!
+ * @brief check if sphere intersects with point
+ *
+ * @param[in]   s      sphere
+ * @param[in]   point  point
+ */
+CGLM_INLINE
+bool
+glms_sphere_point(vec4s s, vec3s point) {
+  return glm_sphere_point(s.raw, point.raw);
+}
+
+#endif /* cglms_spheres_h */

include/cglm/struct/vec2-ext.h

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec2s glms_vec2_fill(float val)
+   CGLM_INLINE bool  glms_vec2_eq(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_eps(vec2s v, float val)
+   CGLM_INLINE bool  glms_vec2_eq_all(vec2s v)
+   CGLM_INLINE bool  glms_vec2_eqv(vec2s a, vec2s b)
+   CGLM_INLINE bool  glms_vec2_eqv_eps(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_max(vec2s v)
+   CGLM_INLINE float glms_vec2_min(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isnan(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isinf(vec2s v)
+   CGLM_INLINE bool  glms_vec2_isvalid(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sign(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_sqrt(vec2s v)
+ */
+
+#ifndef cglms_vec2s_ext_h
+#define cglms_vec2s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_fill(float val) {
+  vec2s r;
+  glm_vec2_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq(vec2s v, float val) {
+  return glm_vec2_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_eps(vec2s v, float val) {
+  return glm_vec2_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eq_all(vec2s v) {
+  return glm_vec2_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv(vec2s a, vec2s b) {
+  return glm_vec2_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_eqv_eps(vec2s a, vec2s b) {
+  return glm_vec2_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_max(vec2s v) {
+  return glm_vec2_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec2_min(vec2s v) {
+  return glm_vec2_min(v.raw);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isnan(vec2s v) {
+  return glm_vec2_isnan(v.raw);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isinf(vec2s v) {
+  return glm_vec2_isinf(v.raw);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec2_isvalid(vec2s v) {
+  return glm_vec2_isvalid(v.raw);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param   v   vector
+ * @returns     sign vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sign(vec2s v) {
+  vec2s r;
+  glm_vec2_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sqrt(vec2s v) {
+  vec2s r;
+  glm_vec2_sqrt(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief treat vectors as complex numbers and multiply them as such.
+ *
+ * @param[in]  a    left number
+ * @param[in]  b    right number
+ * @param[out] dest destination number
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_complex_mul(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_complex_mul(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief treat vectors as complex numbers and divide them as such.
+ *
+ * @param[in]  a    left number (numerator)
+ * @param[in]  b    right number (denominator)
+ * @param[out] dest destination number
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_complex_div(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_complex_div(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief treat the vector as a complex number and conjugate it as such.
+ *
+ * @param[in]  a    the number
+ * @param[out] dest destination number
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_complex_conjugate(vec2s a, vec2s dest) {
+  glm_vec2_complex_conjugate(a.raw, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_vec2s_ext_h */

include/cglm/struct/vec2.h

@@ -0,0 +1,561 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC2_ONE_INIT
+   GLMS_VEC2_ZERO_INIT
+   GLMS_VEC2_ONE
+   GLMS_VEC2_ZERO
+
+ Functions:
+   CGLM_INLINE vec2s glms_vec2(vec3s v3)
+   CGLM_INLINE void  glms_vec2_pack(vec2s dst[], vec2 src[], size_t len)
+   CGLM_INLINE void  glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len)
+   CGLM_INLINE vec2s glms_vec2_zero(void)
+   CGLM_INLINE vec2s glms_vec2_one(void)
+   CGLM_INLINE float glms_vec2_dot(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_cross(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_norm2(vec2s v)
+   CGLM_INLINE float glms_vec2_norm(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_add(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_adds(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_sub(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_subs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_mul(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_scale(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_scale_as(vec2s v, float s)
+   CGLM_INLINE vec2s glms_vec2_div(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_divs(vec2s a, float s)
+   CGLM_INLINE vec2s glms_vec2_addadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_subadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_muladds(vec2s a, float s, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_minadd(vec2s a, vec2s b, vec2s dest)
+   CGLM_INLINE vec2s glms_vec2_negate(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_normalize(vec2s v)
+   CGLM_INLINE vec2s glms_vec2_rotate(vec2s v, float angle, vec2s axis)
+   CGLM_INLINE float glms_vec2_distance(vec2s a, vec2s b)
+   CGLM_INLINE float glms_vec2_distance2(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_maxv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
+   CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
+   CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
+ */
+
+#ifndef cglms_vec2s_h
+#define cglms_vec2s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec2.h"
+#include "vec2-ext.h"
+
+#define GLMS_VEC2_ONE_INIT   {GLM_VEC2_ONE_INIT}
+#define GLMS_VEC2_ZERO_INIT  {GLM_VEC2_ZERO_INIT}
+
+#define GLMS_VEC2_ONE  ((vec2s)GLMS_VEC2_ONE_INIT)
+#define GLMS_VEC2_ZERO ((vec2s)GLMS_VEC2_ZERO_INIT)
+
+/*!
+ * @brief init vec2 using vec2
+ *
+ * @param[in]  v3   vector3
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2(vec3s v3) {
+  vec2s r;
+  glm_vec2(v3.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec2 into an array of vec2s
+ *
+ * @param[out] dst array of vec2
+ * @param[in]  src array of vec2s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec2s into an array of vec2
+ *
+ * @param[out] dst array of vec2s
+ * @param[in]  src array of vec2
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec2_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns zero vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_zero(void) {
+  vec2s r;
+  glm_vec2_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns one vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_one(void) {
+  vec2s r;
+  glm_vec2_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec2 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec2_dot(vec2s a, vec2s b) {
+  return glm_vec2_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief vec2 cross product
+ *
+ * REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
+ *
+ * @param[in]  a vector1
+ * @param[in]  b vector2
+ *
+ * @return Z component of cross product
+ */
+CGLM_INLINE
+float
+glms_vec2_cross(vec2s a, vec2s b) {
+  return glm_vec2_cross(a.raw, b.raw);
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm2(vec2s v) {
+  return glm_vec2_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec2
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec2_norm(vec2s v) {
+  return glm_vec2_norm(v.raw);
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_add(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_adds(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_adds(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_sub(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_subs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param     a     vector1
+ * @param     b     vector2
+ * @returns         v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_mul(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec2 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec2 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_scale_as(vec2s v, float s) {
+  vec2s r;
+  glm_vec2_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_div(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_divs(vec2s a, float s) {
+  vec2s r;
+  glm_vec2_divs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_muladds(vec2s a, float s, vec2s dest) {
+  glm_vec2_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += max(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += min(a, b)
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
+  glm_vec2_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in]  v  vector
+ * @returns       negated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_negate(vec2s v) {
+  glm_vec2_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec2 and store result in same vec
+ *
+ * @param[in] v vector
+ * @returns     normalized vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_normalize(vec2s v) {
+  glm_vec2_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief rotate vec2 by angle using Rodrigues' rotation formula
+ *
+ * @param[in]     v     vector
+ * @param[in]     angle angle by radians
+ * @returns             rotated vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_rotate(vec2s v, float angle) {
+  vec2s r;
+  glm_vec2_rotate(v.raw, angle, r.raw);
+  return r;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      distance
+ */
+CGLM_INLINE
+float
+glms_vec2_distance(vec2s a, vec2s b) {
+  return glm_vec2_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glms_vec2_distance2(vec2s a, vec2s b) {
+  return glm_vec2_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_maxv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_minv(vec2s a, vec2s b) {
+  vec2s r;
+  glm_vec2_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in]       v       vector
+ * @param[in]       minVal  minimum value
+ * @param[in]       maxVal  maximum value
+ * @returns                 clamped vector
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
+  glm_vec2_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec2s
+glms_vec2_lerp(vec2s from, vec2s to, float t) {
+  vec2s r;
+  glm_vec2_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec2s_h */

include/cglm/struct/vec3-ext.h

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec3s glms_vec3_broadcast(float val);
+   CGLM_INLINE vec3s glms_vec3_fill(float val);
+   CGLM_INLINE bool  glms_vec3_eq(vec3s v, float val);
+   CGLM_INLINE bool  glms_vec3_eq_eps(vec3s v, float val);
+   CGLM_INLINE bool  glms_vec3_eq_all(vec3s v);
+   CGLM_INLINE bool  glms_vec3_eqv(vec3s a, vec3s b);
+   CGLM_INLINE bool  glms_vec3_eqv_eps(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_max(vec3s v);
+   CGLM_INLINE float glms_vec3_min(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isnan(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isinf(vec3s v);
+   CGLM_INLINE bool  glms_vec3_isvalid(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_sign(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_abs(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_fract(vec3s v);
+   CGLM_INLINE float glms_vec3_hadd(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_sqrt(vec3s v);
+ */
+
+#ifndef cglms_vec3s_ext_h
+#define cglms_vec3s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_broadcast(float val) {
+  vec3s r;
+  glm_vec3_broadcast(val, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param[in]  val  value
+ * @returns         dest
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_fill(float val) {
+  vec3s r;
+  glm_vec3_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec3_eq(vec3s v, float val) {
+  return glm_vec3_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param[in] v   vector
+ * @param[in] val value
+ */
+CGLM_INLINE
+bool
+glms_vec3_eq_eps(vec3s v, float val) {
+  return glm_vec3_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param[in] v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_eq_all(vec3s v) {
+  return glm_vec3_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_eqv(vec3s a, vec3s b) {
+  return glm_vec3_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param[in] a vector
+ * @param[in] b vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_eqv_eps(vec3s a, vec3s b) {
+  return glm_vec3_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec3_max(vec3s v) {
+  return glm_vec3_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+float
+glms_vec3_min(vec3s v) {
+  return glm_vec3_min(v.raw);
+}
+
+/*!
+ * @brief check if all items are NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_isnan(vec3s v) {
+  return glm_vec3_isnan(v.raw);
+}
+
+/*!
+ * @brief check if all items are INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_isinf(vec3s v) {
+  return glm_vec3_isinf(v.raw);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec3_isvalid(vec3s v) {
+  return glm_vec3_isvalid(v.raw);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param   v   vector
+ * @returns     sign vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_sign(vec3s v) {
+  vec3s r;
+  glm_vec3_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @return          destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_abs(vec3s v) {
+  vec3s r;
+  glm_vec3_abs(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @return          dest destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_fract(vec3s v) {
+  vec3s r;
+  glm_vec3_fract(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]  v    vector
+ * @return     sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glms_vec3_hadd(vec3s v) {
+  return glm_vec3_hadd(v.raw);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_sqrt(vec3s v) {
+  vec3s r;
+  glm_vec3_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec3s_ext_h */

include/cglm/struct/vec3.h

@@ -0,0 +1,970 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC3_ONE_INIT
+   GLMS_VEC3_ZERO_INIT
+   GLMS_VEC3_ONE
+   GLMS_VEC3_ZERO
+   GLMS_YUP
+   GLMS_ZUP
+   GLMS_XUP
+
+ Functions:
+   CGLM_INLINE vec3s glms_vec3(vec4s v4);
+   CGLM_INLINE void  glms_vec3_pack(vec3s dst[], vec3 src[], size_t len);
+   CGLM_INLINE void  glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len);
+   CGLM_INLINE vec3s glms_vec3_zero(void);
+   CGLM_INLINE vec3s glms_vec3_one(void);
+   CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_norm2(vec3s v);
+   CGLM_INLINE float glms_vec3_norm(vec3s v);
+   CGLM_INLINE float glms_vec3_norm_one(vec3s v);
+   CGLM_INLINE float glms_vec3_norm_inf(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s);
+   CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s);
+   CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s);
+   CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest);
+   CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_negate(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_inv(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_normalize(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis);
+   CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v);
+   CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v);
+   CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_distance(vec3s a, vec3s b);
+   CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_vec3_ortho(vec3s v);
+   CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal);
+   CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_lerpc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_mix(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_mixc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_step_uni(float edge, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_step(vec3s edge, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x);
+   CGLM_INLINE vec3s glms_vec3_smoothinterp(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
+   CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
+
+ Convenient:
+   CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
+   CGLM_INLINE float glms_dot(vec3s a, vec3s b);
+   CGLM_INLINE vec3s glms_normalize(vec3s v);
+ */
+
+#ifndef cglms_vec3s_h
+#define cglms_vec3s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec3.h"
+#include "vec3-ext.h"
+
+#define GLMS_VEC3_ONE_INIT   {GLM_VEC3_ONE_INIT}
+#define GLMS_VEC3_ZERO_INIT  {GLM_VEC3_ZERO_INIT}
+
+#define GLMS_VEC3_ONE  ((vec3s)GLMS_VEC3_ONE_INIT)
+#define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT)
+
+#define GLMS_YUP  ((vec3s){{0.0f, 1.0f, 0.0f}})
+#define GLMS_ZUP  ((vec3s){{0.0f, 0.0f, 1.0f}})
+#define GLMS_XUP  ((vec3s){{1.0f, 0.0f, 0.0f}})
+
+/*!
+ * @brief init vec3 using vec4
+ *
+ * @param[in]  v4   vector4
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3(vec4s v4) {
+  vec3s r;
+  glm_vec3(v4.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec3 into an array of vec3s
+ *
+ * @param[out] dst array of vec3
+ * @param[in]  src array of vec3s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec3_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec3s into an array of vec3
+ *
+ * @param[out] dst array of vec3s
+ * @param[in]  src array of vec3
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec3_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns       zero vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_zero(void) {
+  vec3s r;
+  glm_vec3_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns       one vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_one(void) {
+  vec3s r;
+  glm_vec3_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec3_dot(vec3s a, vec3s b) {
+  return glm_vec3_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vector
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm2(vec3s v) {
+  return glm_vec3_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec3
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm(vec3s v) {
+  return glm_vec3_norm(v.raw);
+}
+
+/*!
+ * @brief L1 norm of vec3
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * R = |v[0]| + |v[1]| + |v[2]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm_one(vec3s v) {
+  return glm_vec3_norm_one(v.raw);
+}
+
+/*!
+ * @brief Infinity norm of vec3
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|)
+ *
+ * @param[in] v vector
+ *
+ * @return Infinity norm
+ */
+CGLM_INLINE
+float
+glms_vec3_norm_inf(vec3s v) {
+  return glm_vec3_norm_inf(v.raw);
+}
+
+/*!
+ * @brief add a vector to b vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_add(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_adds(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_adds(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_sub(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - s)
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_subs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_subs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param     a     vector1
+ * @param     b     vector2
+ * @returns         v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_mul(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec3 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_scale(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec3 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_scale_as(vec3s v, float s) {
+  vec3s r;
+  glm_vec3_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_div(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with scalar: d = v / s
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         result = (a[0]/s, a[1]/s, a[2]/s)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_divs(vec3s a, float s) {
+  vec3s r;
+  glm_vec3_divs(a.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_muladds(vec3s a, float s, vec3s dest) {
+  glm_vec3_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += max(a, b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += min(a, b)
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
+  glm_vec3_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]   v     vector
+ * @returns           result vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_flipsign(vec3s v) {
+  glm_vec3_flipsign(v.raw);
+  return v;
+}
+
+/*!
+ * @brief negate vector components
+ *
+ * @param[in]  v  vector
+ * @returns       negated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_negate(vec3s v) {
+  glm_vec3_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec3 and store result in same vec
+ *
+ * @param[in] v vector
+ * @returns     normalized vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_normalize(vec3s v) {
+  glm_vec3_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief cross product of two vector (RH)
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief cross product of two vector (RH) and normalize the result
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_crossn(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_crossn(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief angle betwen two vector
+ *
+ * @param[in] a  vector1
+ * @param[in] b  vector2
+ *
+ * @return angle as radians
+ */
+CGLM_INLINE
+float
+glms_vec3_angle(vec3s a, vec3s b) {
+  return glm_vec3_angle(a.raw, b.raw);
+}
+
+/*!
+ * @brief rotate vec3 around axis by angle using Rodrigues' rotation formula
+ *
+ * @param[in]     v     vector
+ * @param[in]     axis  axis vector (must be unit vector)
+ * @param[in]     angle angle by radians
+ * @returns             rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
+  glm_vec3_rotate(v.raw, angle, axis.raw);
+  return v;
+}
+
+/*!
+ * @brief apply rotation matrix to vector
+ *
+ *  matrix format should be (no perspective):
+ *   a  b  c  x
+ *   e  f  g  y
+ *   i  j  k  z
+ *   0  0  0  w
+ *
+ * @param[in]  m    affine matrix or rot matrix
+ * @param[in]  v    vector
+ * @returns         rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m4(mat4s m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m4(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief apply rotation matrix to vector
+ *
+ * @param[in]  m    affine matrix or rot matrix
+ * @param[in]  v    vector
+ * @returns         rotated vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_rotate_m3(mat3s m, vec3s v) {
+  vec3s r;
+  glm_vec3_rotate_m3(m.raw, v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief project a vector onto b vector
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         projected vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_proj(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_proj(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/**
+ * @brief find center point of two vector
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         center point
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_center(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_center(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      distance
+ */
+CGLM_INLINE
+float
+glms_vec3_distance(vec3s a, vec3s b) {
+  return glm_vec3_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      squared distance (distance * distance)
+ */
+CGLM_INLINE
+float
+glms_vec3_distance2(vec3s a, vec3s b) {
+  return glm_vec3_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_maxv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_minv(vec3s a, vec3s b) {
+  vec3s r;
+  glm_vec3_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief possible orthogonal/perpendicular vector
+ *
+ * @param[in]  v    vector
+ * @returns         orthogonal/perpendicular vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_ortho(vec3s v) {
+  vec3s r;
+  glm_vec3_ortho(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in]       v       vector
+ * @param[in]       minVal  minimum value
+ * @param[in]       maxVal  maximum value
+ * @returns                 clamped vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
+  glm_vec3_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_lerp(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_lerpc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_lerpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_mix(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_mix(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns           destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_mixc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_mixc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_step_uni(float edge, vec3s x) {
+  vec3s r;
+  glm_vec3_step_uni(edge, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_step(vec3s edge, vec3s x) {
+  vec3s r;
+  glm_vec3_step(edge.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
+  vec3s r;
+  glm_vec3_smoothstep_uni(edge0, edge1, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
+  vec3s r;
+  glm_vec3_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount)
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_smoothinterp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount) clamped between 0 and 1
+ * @returns             destination
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_smoothinterpc(vec3s from, vec3s to, float t) {
+  vec3s r;
+  glm_vec3_smoothinterpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 cross product
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in]  a  source 1
+ * @param[in]  b  source 2
+ * @returns       destination
+ */
+CGLM_INLINE
+vec3s
+glms_cross(vec3s a, vec3s b) {
+  vec3s r;
+  glm_cross(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec3 dot product
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return      dot product
+ */
+CGLM_INLINE
+float
+glms_dot(vec3s a, vec3s b) {
+  return glm_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief normalize vec3 and store result in same vec
+ *
+ * this is just convenient wrapper
+ *
+ * @param[in]   v   vector
+ * @returns         normalized vector
+ */
+CGLM_INLINE
+vec3s
+glms_normalize(vec3s v) {
+  glm_normalize(v.raw);
+  return v;
+}
+
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXX, GLM_ZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @returns swizzled vector
+ */
+CGLM_INLINE
+vec3s
+glms_vec3_swizzle(vec3s v, int mask) {
+  vec3s dest;
+  glm_vec3_swizzle(v.raw, mask, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_vec3s_h */

include/cglm/struct/vec4-ext.h

@@ -0,0 +1,257 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*!
+ * @brief SIMD like functions
+ */
+
+/*
+ Functions:
+   CGLM_INLINE vec4s glms_vec4_broadcast(float val);
+   CGLM_INLINE vec4s glms_vec4_fill(float val);
+   CGLM_INLINE bool  glms_vec4_eq(vec4s v, float val);
+   CGLM_INLINE bool  glms_vec4_eq_eps(vec4s v, float val);
+   CGLM_INLINE bool  glms_vec4_eq_all(vec4s v);
+   CGLM_INLINE bool  glms_vec4_eqv(vec4s a, vec4s b);
+   CGLM_INLINE bool  glms_vec4_eqv_eps(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_max(vec4s v);
+   CGLM_INLINE float glms_vec4_min(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isnan(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isinf(vec4s v);
+   CGLM_INLINE bool  glms_vec4_isvalid(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_sign(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_abs(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_fract(vec4s v);
+   CGLM_INLINE float glms_vec4_hadd(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_sqrt(vec4s v);
+ */
+
+#ifndef cglms_vec4s_ext_h
+#define cglms_vec4s_ext_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4-ext.h"
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @returns   dest
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_broadcast(float val) {
+  vec4s r;
+  glm_vec4_broadcast(val, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fill a vector with specified value
+ *
+ * @param val value
+ * @returns   dest
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_fill(float val) {
+  vec4s r;
+  glm_vec4_fill(r.raw, val);
+  return r;
+}
+
+/*!
+ * @brief check if vector is equal to value (without epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq(vec4s v, float val) {
+  return glm_vec4_eq(v.raw, val);
+}
+
+/*!
+ * @brief check if vector is equal to value (with epsilon)
+ *
+ * @param v   vector
+ * @param val value
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq_eps(vec4s v, float val) {
+  return glm_vec4_eq_eps(v.raw, val);
+}
+
+/*!
+ * @brief check if vectors members are equal (without epsilon)
+ *
+ * @param v   vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eq_all(vec4s v) {
+  return glm_vec4_eq_all(v.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (without epsilon)
+ *
+ * @param a vector
+ * @param b vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eqv(vec4s a, vec4s b) {
+  return glm_vec4_eqv(a.raw, b.raw);
+}
+
+/*!
+ * @brief check if vector is equal to another (with epsilon)
+ *
+ * @param a vector
+ * @param b vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_eqv_eps(vec4s a, vec4s b) {
+  return glm_vec4_eqv_eps(a.raw, b.raw);
+}
+
+/*!
+ * @brief max value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glms_vec4_max(vec4s v) {
+  return glm_vec4_max(v.raw);
+}
+
+/*!
+ * @brief min value of vector
+ *
+ * @param v vector
+ */
+CGLM_INLINE
+float
+glms_vec4_min(vec4s v) {
+  return glm_vec4_min(v.raw);
+}
+
+/*!
+ * @brief check if one of items is NaN (not a number)
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_isnan(vec4s v) {
+  return glm_vec4_isnan(v.raw);
+}
+
+/*!
+ * @brief check if one of items is INFINITY
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_isinf(vec4s v) {
+  return glm_vec4_isinf(v.raw);
+}
+
+/*!
+ * @brief check if all items are valid number
+ *        you should only use this in DEBUG mode or very critical asserts
+ *
+ * @param[in] v vector
+ */
+CGLM_INLINE
+bool
+glms_vec4_isvalid(vec4s v) {
+  return glm_vec4_isvalid(v.raw);
+}
+
+/*!
+ * @brief get sign of 32 bit float as +1, -1, 0
+ *
+ * Important: It returns 0 for zero/NaN input
+ *
+ * @param   v   vector
+ * @returns     sign vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_sign(vec4s v) {
+  vec4s r;
+  glm_vec4_sign(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief absolute value of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_abs(vec4s v) {
+  vec4s r;
+  glm_vec4_abs(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief fractional part of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns          dest destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_fract(vec4s v) {
+  vec4s r;
+  glm_vec4_fract(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief vector reduction by summation
+ * @warning could overflow
+ *
+ * @param[in]  v    vector
+ * @return     sum of all vector's elements
+ */
+CGLM_INLINE
+float
+glms_vec4_hadd(vec4s v) {
+  return glm_vec4_hadd(v.raw);
+}
+
+/*!
+ * @brief square root of each vector item
+ *
+ * @param[in]  v    vector
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_sqrt(vec4s v) {
+  vec4s r;
+  glm_vec4_sqrt(v.raw, r.raw);
+  return r;
+}
+
+#endif /* cglms_vec4s_ext_h */

include/cglm/struct/vec4.h

@@ -0,0 +1,814 @@
+/*
+ * Copyright (c), Recep Aslantas.
+ *
+ * MIT License (MIT), http://opensource.org/licenses/MIT
+ * Full license can be found in the LICENSE file
+ */
+
+/*
+ Macros:
+   GLMS_VEC4_ONE_INIT
+   GLMS_VEC4_BLACK_INIT
+   GLMS_VEC4_ZERO_INIT
+   GLMS_VEC4_ONE
+   GLMS_VEC4_BLACK
+   GLMS_VEC4_ZERO
+
+ Functions:
+   CGLM_INLINE vec4s glms_vec4(vec3s v3, float last);
+   CGLM_INLINE vec3s glms_vec4_copy3(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_copy(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_ucopy(vec4s v);
+   CGLM_INLINE void  glms_vec4_pack(vec4s dst[], vec4 src[], size_t len);
+   CGLM_INLINE void  glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len);
+   CGLM_INLINE float glms_vec4_dot(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_norm2(vec4s v);
+   CGLM_INLINE float glms_vec4_norm(vec4s v);
+   CGLM_INLINE float glms_vec4_norm_one(vec4s v);
+   CGLM_INLINE float glms_vec4_norm_inf(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_add(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_adds(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_sub(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_subs(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_mul(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_scale(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_scale_as(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_div(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_divs(vec4s v, float s);
+   CGLM_INLINE vec4s glms_vec4_addadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_subadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_muladd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_muladds(vec4s a, float s, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_minadd(vec4s a, vec4s b, vec4s dest);
+   CGLM_INLINE vec4s glms_vec4_negate(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_inv(vec4s v);
+   CGLM_INLINE vec4s glms_vec4_normalize(vec4s v);
+   CGLM_INLINE float glms_vec4_distance(vec4s a, vec4s b);
+   CGLM_INLINE float glms_vec4_distance2(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_maxv(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_minv(vec4s a, vec4s b);
+   CGLM_INLINE vec4s glms_vec4_clamp(vec4s v, float minVal, float maxVal);
+   CGLM_INLINE vec4s glms_vec4_lerp(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_lerpc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_mix(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_mixc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_step_uni(float edge, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_step(vec4s edge, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x);
+   CGLM_INLINE vec4s glms_vec4_smoothinterp(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_smoothinterpc(vec4s from, vec4s to, float t);
+   CGLM_INLINE vec4s glms_vec4_cubic(float s);
+   CGLM_INLINE vec4s glms_vec4_swizzle(vec4s v, int mask);
+ */
+
+#ifndef cglms_vec4s_h
+#define cglms_vec4s_h
+
+#include "../common.h"
+#include "../types-struct.h"
+#include "../util.h"
+#include "../vec4.h"
+#include "vec4-ext.h"
+
+#define GLMS_VEC4_ONE_INIT   {GLM_VEC4_ONE_INIT}
+#define GLMS_VEC4_BLACK_INIT {GLM_VEC4_BLACK_INIT}
+#define GLMS_VEC4_ZERO_INIT  {GLM_VEC4_ZERO_INIT}
+
+#define GLMS_VEC4_ONE        ((vec4s)GLM_VEC4_ONE_INIT)
+#define GLMS_VEC4_BLACK      ((vec4s)GLM_VEC4_BLACK_INIT)
+#define GLMS_VEC4_ZERO       ((vec4s)GLM_VEC4_ZERO_INIT)
+
+/*!
+ * @brief init vec4 using vec3
+ *
+ * @param[in]  v3   vector3
+ * @param[in]  last last item
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4(vec3s v3, float last) {
+  vec4s r;
+  glm_vec4(v3.raw, last, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy first 3 members of [a] to [dest]
+ *
+ * @param[in]  v    source
+ * @returns         vec3
+ */
+CGLM_INLINE
+vec3s
+glms_vec4_copy3(vec4s v) {
+  vec3s r;
+  glm_vec4_copy3(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * @param[in]  v    source
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_copy(vec4s v) {
+  vec4s r;
+  glm_vec4_copy(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief copy all members of [a] to [dest]
+ *
+ * alignment is not required
+ *
+ * @param[in]  v    source
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_ucopy(vec4s v) {
+  vec4s r;
+  glm_vec4_ucopy(v.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief pack an array of vec4 into an array of vec4s
+ *
+ * @param[out] dst array of vec4
+ * @param[in]  src array of vec4s
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec4_copy(src[i], dst[i].raw);
+  }
+}
+
+/*!
+ * @brief unpack an array of vec4s into an array of vec4
+ *
+ * @param[out] dst array of vec4s
+ * @param[in]  src array of vec4
+ * @param[in]  len number of elements
+ */
+CGLM_INLINE
+void
+glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
+  size_t i;
+
+  for (i = 0; i < len; i++) {
+    glm_vec4_copy(src[i].raw, dst[i]);
+  }
+}
+
+/*!
+ * @brief make vector zero
+ *
+ * @returns      zero vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_zero(void) {
+  vec4s r;
+  glm_vec4_zero(r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vector one
+ *
+ * @returns      one vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_one(void) {
+  vec4s r;
+  glm_vec4_one(r.raw);
+  return r;
+}
+
+/*!
+ * @brief vec4 dot product
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ *
+ * @return dot product
+ */
+CGLM_INLINE
+float
+glms_vec4_dot(vec4s a, vec4s b) {
+  return glm_vec4_dot(a.raw, b.raw);
+}
+
+/*!
+ * @brief norm * norm (magnitude) of vec
+ *
+ * we can use this func instead of calling norm * norm, because it would call
+ * sqrtf fuction twice but with this func we can avoid func call, maybe this is
+ * not good name for this func
+ *
+ * @param[in] v vec4
+ *
+ * @return norm * norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm2(vec4s v) {
+  return glm_vec4_norm2(v.raw);
+}
+
+/*!
+ * @brief norm (magnitude) of vec4
+ *
+ * @param[in] v vector
+ *
+ * @return norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm(vec4s v) {
+  return glm_vec4_norm(v.raw);
+}
+
+/*!
+ * @brief L1 norm of vec4
+ * Also known as Manhattan Distance or Taxicab norm.
+ * L1 Norm is the sum of the magnitudes of the vectors in a space.
+ * It is calculated as the sum of the absolute values of the vector components.
+ * In this norm, all the components of the vector are weighted equally.
+ *
+ * This computes:
+ * R = |v[0]| + |v[1]| + |v[2]| + |v[3]|
+ *
+ * @param[in] v vector
+ *
+ * @return L1 norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm_one(vec4s v) {
+  return glm_vec4_norm_one(v.raw);
+}
+
+/*!
+ * @brief Infinity norm of vec4
+ * Also known as Maximum norm.
+ * Infinity Norm is the largest magnitude among each element of a vector.
+ * It is calculated as the maximum of the absolute values of the vector components.
+ *
+ * This computes:
+ * inf norm = max(|v[0]|, |v[1]|, |v[2]|, |v[3]|)
+ *
+ * @param[in] v vector
+ *
+ * @return Infinity norm
+ */
+CGLM_INLINE
+float
+glms_vec4_norm_inf(vec4s v) {
+  return glm_vec4_norm_inf(v.raw);
+}
+
+/*!
+ * @brief add b vector to a vector store result in dest
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_add(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_add(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add scalar to v vector store result in dest (d = v + vec(s))
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_adds(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_adds(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract b vector from a vector store result in dest (d = a - b)
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_sub(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_sub(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief subtract scalar from v vector store result in dest (d = v - vec(s))
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_subs(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_subs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply two vector (component-wise multiplication)
+ *
+ * @param a    vector1
+ * @param b    vector2
+ * @returns    dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_mul(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_mul(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief multiply/scale vec4 vector with scalar: result = v * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_scale(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_scale(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief make vec4 vector scale as specified: result = unit(v) * s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_scale_as(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_scale_as(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vector with another component-wise division: d = a / b
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         result = (a[0]/b[0], a[1]/b[1], a[2]/b[2], a[3]/b[3])
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_div(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_div(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief div vec4 vector with scalar: d = v / s
+ *
+ * @param[in]  v    vector
+ * @param[in]  s    scalar
+ * @returns         destination vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_divs(vec4s v, float s) {
+  vec4s r;
+  glm_vec4_divs(v.raw, s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief add two vectors and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a + b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_addadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief sub two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a - b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_subadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul two vectors and add result to dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_muladd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief mul vector with scalar and add result to sum
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector
+ * @param[in]  s    scalar
+ * @returns         dest += (a * b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_muladds(vec4s a, float s, vec4s dest) {
+  glm_vec4_muladds(a.raw, s, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add max of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += max(a, b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_maxadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief add min of two vector to result/dest
+ *
+ * it applies += operator so dest must be initialized
+ *
+ * @param[in]  a    vector 1
+ * @param[in]  b    vector 2
+ * @returns         dest += min(a, b)
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) {
+  glm_vec4_minadd(a.raw, b.raw, dest.raw);
+  return dest;
+}
+
+/*!
+ * @brief negate vector components and store result in dest
+ *
+ * @param[in]  v     vector
+ * @returns          result vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_negate(vec4s v) {
+  glm_vec4_negate(v.raw);
+  return v;
+}
+
+/*!
+ * @brief normalize vec4 and store result in same vec
+ *
+ * @param[in] v   vector
+ * @returns       normalized vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_normalize(vec4s v) {
+  glm_vec4_normalize(v.raw);
+  return v;
+}
+
+/**
+ * @brief distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns distance
+ */
+CGLM_INLINE
+float
+glms_vec4_distance(vec4s a, vec4s b) {
+  return glm_vec4_distance(a.raw, b.raw);
+}
+
+/**
+ * @brief squared distance between two vectors
+ *
+ * @param[in] a vector1
+ * @param[in] b vector2
+ * @return returns squared distance
+ */
+CGLM_INLINE
+float
+glms_vec4_distance2(vec4s a, vec4s b) {
+  return glm_vec4_distance2(a.raw, b.raw);
+}
+
+/*!
+ * @brief max values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_maxv(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_maxv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief min values of vectors
+ *
+ * @param[in]  a    vector1
+ * @param[in]  b    vector2
+ * @returns         destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_minv(vec4s a, vec4s b) {
+  vec4s r;
+  glm_vec4_minv(a.raw, b.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief clamp vector's individual members between min and max values
+ *
+ * @param[in]       v       vector
+ * @param[in]       minVal  minimum value
+ * @param[in]       maxVal  maximum value
+ * @returns                 clamped vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
+  glm_vec4_clamp(v.raw, minVal, maxVal);
+  return v;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_lerp(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_lerp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_lerpc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_lerpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount)
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_mix(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_mix(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief linear interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from  from value
+ * @param[in]   to    to value
+ * @param[in]   t     interpolant (amount) clamped between 0 and 1
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_mixc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_mixc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function (unidimensional)
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_step_uni(float edge, vec4s x) {
+  vec4s r;
+  glm_vec4_step_uni(edge, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function
+ *
+ * @param[in]   edge    threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             0.0 if x < edge, else 1.0
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_step(vec4s edge, vec4s x) {
+  vec4s r;
+  glm_vec4_step(edge.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition (unidimensional)
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x) {
+  vec4s r;
+  glm_vec4_smoothstep_uni(edge0, edge1, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief threshold function with a smooth transition
+ *
+ * @param[in]   edge0   low threshold
+ * @param[in]   edge1   high threshold
+ * @param[in]   x       value to test against threshold
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x) {
+  vec4s r;
+  glm_vec4_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount)
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothinterp(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_smoothinterp(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief smooth Hermite interpolation between two vectors (clamped)
+ *
+ * formula:  from + s * (to - from)
+ *
+ * @param[in]   from    from value
+ * @param[in]   to      to value
+ * @param[in]   t       interpolant (amount) clamped between 0 and 1
+ * @returns             destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_smoothinterpc(vec4s from, vec4s to, float t) {
+  vec4s r;
+  glm_vec4_smoothinterpc(from.raw, to.raw, t, r.raw);
+  return r;
+}
+
+/*!
+ * @brief helper to fill vec4 as [S^3, S^2, S, 1]
+ *
+ * @param[in]   s     parameter
+ * @returns           destination
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_cubic(float s) {
+  vec4s r;
+  glm_vec4_cubic(s, r.raw);
+  return r;
+}
+
+/*!
+ * @brief swizzle vector components
+ *
+ * you can use existin masks e.g. GLM_XXXX, GLM_WZYX
+ *
+ * @param[in]  v    source
+ * @param[in]  mask mask
+ * @returns swizzled vector
+ */
+CGLM_INLINE
+vec4s
+glms_vec4_swizzle(vec4s v, int mask) {
+  vec4s dest;
+  glm_vec4_swizzle(v.raw, mask, dest.raw);
+  return dest;
+}
+
+#endif /* cglms_vec4s_h */