shweet/game-engine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
shweet
2024-04-11 01:05:03 -04:00
commit 3398c52f8b
272 changed files with 35195 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/cglm/affine-mat.h
+178
View File
@@ -0,0 +1,178 @@
/*
* 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_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_INLINE void glm_inv_tr(mat4 mat);
*/
#ifndef cglm_affine_mat_h
#define cglm_affine_mat_h
#include "common.h"
#include "mat4.h"
#include "mat3.h"
#ifdef CGLM_SSE_FP
# include "simd/sse2/affine.h"
#endif
#ifdef CGLM_AVX_FP
# include "simd/avx/affine.h"
#endif
#ifdef CGLM_NEON_FP
# include "simd/neon/affine.h"
#endif
/*!
* @brief this is similar to glm_mat4_mul but specialized to affine transform
*
* Matrix format should be:
* R R R X
* R R R Y
* R R R Z
* 0 0 0 W
*
* this reduces some multiplications. It should be faster than mat4_mul.
* if you are not sure about matrix format then DON'T use this! use mat4_mul
*
* @param[in] m1 affine matrix 1
* @param[in] m2 affine matrix 2
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_mul(mat4 m1, mat4 m2, mat4 dest) {
#ifdef __AVX__
glm_mul_avx(m1, m2, dest);
#elif defined( __SSE__ ) || defined( __SSE2__ )
glm_mul_sse2(m1, m2, dest);
#elif defined(CGLM_NEON_FP)
glm_mul_neon(m1, m2, dest);
#else
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2],
b30 = m2[3][0], b31 = m2[3][1], b32 = m2[3][2], b33 = m2[3][3];
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02;
dest[0][3] = a03 * b00 + a13 * b01 + a23 * b02;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12;
dest[1][3] = a03 * b10 + a13 * b11 + a23 * b12;
dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22;
dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22;
dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22;
dest[2][3] = a03 * b20 + a13 * b21 + a23 * b22;
dest[3][0] = a00 * b30 + a10 * b31 + a20 * b32 + a30 * b33;
dest[3][1] = a01 * b30 + a11 * b31 + a21 * b32 + a31 * b33;
dest[3][2] = a02 * b30 + a12 * b31 + a22 * b32 + a32 * b33;
dest[3][3] = a03 * b30 + a13 * b31 + a23 * b32 + a33 * b33;
#endif
}
/*!
* @brief this is similar to glm_mat4_mul but specialized to affine transform
*
* Right Matrix format should be:
* R R R 0
* R R R 0
* R R R 0
* 0 0 0 1
*
* this reduces some multiplications. It should be faster than mat4_mul.
* if you are not sure about matrix format then DON'T use this! use mat4_mul
*
* @param[in] m1 affine matrix 1
* @param[in] m2 affine matrix 2
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mul_rot_sse2(m1, m2, dest);
#elif defined(CGLM_NEON_FP)
glm_mul_rot_neon(m1, m2, dest);
#else
float a00 = m1[0][0], a01 = m1[0][1], a02 = m1[0][2], a03 = m1[0][3],
a10 = m1[1][0], a11 = m1[1][1], a12 = m1[1][2], a13 = m1[1][3],
a20 = m1[2][0], a21 = m1[2][1], a22 = m1[2][2], a23 = m1[2][3],
a30 = m1[3][0], a31 = m1[3][1], a32 = m1[3][2], a33 = m1[3][3],
b00 = m2[0][0], b01 = m2[0][1], b02 = m2[0][2],
b10 = m2[1][0], b11 = m2[1][1], b12 = m2[1][2],
b20 = m2[2][0], b21 = m2[2][1], b22 = m2[2][2];
dest[0][0] = a00 * b00 + a10 * b01 + a20 * b02;
dest[0][1] = a01 * b00 + a11 * b01 + a21 * b02;
dest[0][2] = a02 * b00 + a12 * b01 + a22 * b02;
dest[0][3] = a03 * b00 + a13 * b01 + a23 * b02;
dest[1][0] = a00 * b10 + a10 * b11 + a20 * b12;
dest[1][1] = a01 * b10 + a11 * b11 + a21 * b12;
dest[1][2] = a02 * b10 + a12 * b11 + a22 * b12;
dest[1][3] = a03 * b10 + a13 * b11 + a23 * b12;
dest[2][0] = a00 * b20 + a10 * b21 + a20 * b22;
dest[2][1] = a01 * b20 + a11 * b21 + a21 * b22;
dest[2][2] = a02 * b20 + a12 * b21 + a22 * b22;
dest[2][3] = a03 * b20 + a13 * b21 + a23 * b22;
dest[3][0] = a30;
dest[3][1] = a31;
dest[3][2] = a32;
dest[3][3] = a33;
#endif
}
/*!
* @brief inverse orthonormal rotation + translation matrix (ridig-body)
*
* @code
* X = | R T | X' = | R' -R'T |
* | 0 1 | | 0 1 |
* @endcode
*
* @param[in,out] mat matrix
*/
CGLM_INLINE
void
glm_inv_tr(mat4 mat) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_inv_tr_sse2(mat);
#elif defined(CGLM_NEON_FP)
glm_inv_tr_neon(mat);
#else
CGLM_ALIGN_MAT mat3 r;
CGLM_ALIGN(8) vec3 t;
/* rotate */
glm_mat4_pick3t(mat, r);
glm_mat4_ins3(r, mat);
/* translate */
glm_mat3_mulv(r, mat[3], t);
glm_vec3_negate(t);
glm_vec3_copy(t, mat[3]);
#endif
}
#endif /* cglm_affine_mat_h */
include/cglm/affine-post.h
+247
View File
@@ -0,0 +1,247 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_affine_post_h
#define cglm_affine_post_h
/*
Functions:
CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translated(mat4 m, vec3 v);
CGLM_INLINE void glm_translated_x(mat4 m, float to);
CGLM_INLINE void glm_translated_y(mat4 m, float to);
CGLM_INLINE void glm_translated_z(mat4 m, float to);
CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
*/
#include "common.h"
#include "util.h"
#include "vec3.h"
#include "vec4.h"
#include "mat4.h"
#include "affine-mat.h"
/*!
* @brief translate existing transform matrix by v vector
* and stores result in same matrix
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] v translate vector [x, y, z]
*/
CGLM_INLINE
void
glm_translated(mat4 m, vec3 v) {
glm_vec3_add(m[3], v, m[3]);
}
/*!
* @brief translate existing transform matrix by v vector
* and store result in dest
*
* source matrix will remain same
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in] m affine transfrom
* @param[in] v translate vector [x, y, z]
* @param[out] dest translated matrix
*/
CGLM_INLINE
void
glm_translated_to(mat4 m, vec3 v, mat4 dest) {
glm_mat4_copy(m, dest);
glm_translated(dest, v);
}
/*!
* @brief translate existing transform matrix by x factor
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] x x factor
*/
CGLM_INLINE
void
glm_translated_x(mat4 m, float x) {
m[3][0] += x;
}
/*!
* @brief translate existing transform matrix by y factor
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] y y factor
*/
CGLM_INLINE
void
glm_translated_y(mat4 m, float y) {
m[3][1] += y;
}
/*!
* @brief translate existing transform matrix by z factor
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] z z factor
*/
CGLM_INLINE
void
glm_translated_z(mat4 m, float z) {
m[3][2] += z;
}
/*!
* @brief rotate existing transform matrix around X axis by angle
* and store result in dest
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in] m affine transfrom
* @param[in] angle angle (radians)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotated_x(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[1][1] = c;
t[1][2] = s;
t[2][1] = -s;
t[2][2] = c;
glm_mul_rot(t, m, dest);
}
/*!
* @brief rotate existing transform matrix around Y axis by angle
* and store result in dest
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in] m affine transfrom
* @param[in] angle angle (radians)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotated_y(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[0][0] = c;
t[0][2] = -s;
t[2][0] = s;
t[2][2] = c;
glm_mul_rot(t, m, dest);
}
/*!
* @brief rotate existing transform matrix around Z axis by angle
* and store result in dest
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in] m affine transfrom
* @param[in] angle angle (radians)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotated_z(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[0][0] = c;
t[0][1] = s;
t[1][0] = -s;
t[1][1] = c;
glm_mul_rot(t, m, dest);
}
/*!
* @brief rotate existing transform matrix around given axis by angle
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotated(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_make(rot, angle, axis);
glm_mul_rot(rot, m, m);
}
/*!
* @brief rotate existing transform
* around given axis by angle at given pivot point (rotation center)
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] pivot rotation center
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
glm_translated(m, pivot);
glm_rotated(m, angle, axis);
glm_translated(m, pivotInv);
}
/*!
* @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
*
* this is POST transform, applies to existing transform as last transfrom
*
* @param[in, out] m affine transfrom
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_spinned(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_atm(rot, m[3], angle, axis);
glm_mat4_mul(rot, m, m);
}
#endif /* cglm_affine_post_h */
include/cglm/affine-pre.h
+285
View File
@@ -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
*/
#ifndef cglm_affine_pre_h
#define cglm_affine_pre_h
/*
Functions:
CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
CGLM_INLINE void glm_translate_x(mat4 m, float to);
CGLM_INLINE void glm_translate_y(mat4 m, float to);
CGLM_INLINE void glm_translate_z(mat4 m, float to);
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
*/
#include "common.h"
#include "util.h"
#include "vec3.h"
#include "vec4.h"
#include "mat4.h"
#include "affine-mat.h"
/*!
* @brief translate existing transform matrix by v vector
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] v translate vector [x, y, z]
*/
CGLM_INLINE
void
glm_translate(mat4 m, vec3 v) {
#if defined(CGLM_SIMD)
glmm_128 m0, m1, m2, m3;
m0 = glmm_load(m[0]);
m1 = glmm_load(m[1]);
m2 = glmm_load(m[2]);
m3 = glmm_load(m[3]);
glmm_store(m[3],
glmm_fmadd(m0, glmm_set1(v[0]),
glmm_fmadd(m1, glmm_set1(v[1]),
glmm_fmadd(m2, glmm_set1(v[2]), m3))));
#else
glm_vec4_muladds(m[0], v[0], m[3]);
glm_vec4_muladds(m[1], v[1], m[3]);
glm_vec4_muladds(m[2], v[2], m[3]);
#endif
}
/*!
* @brief translate existing transform matrix by v vector
* and store result in dest
*
* source matrix will remain same
*
* @param[in] m affine transfrom
* @param[in] v translate vector [x, y, z]
* @param[out] dest translated matrix
*/
CGLM_INLINE
void
glm_translate_to(mat4 m, vec3 v, mat4 dest) {
glm_mat4_copy(m, dest);
glm_translate(dest, v);
}
/*!
* @brief translate existing transform matrix by x factor
*
* @param[in, out] m affine transfrom
* @param[in] x x factor
*/
CGLM_INLINE
void
glm_translate_x(mat4 m, float x) {
#if defined(CGLM_SIMD)
glmm_store(m[3], glmm_fmadd(glmm_load(m[0]), glmm_set1(x), glmm_load(m[3])));
#else
vec4 v1;
glm_vec4_scale(m[0], x, v1);
glm_vec4_add(v1, m[3], m[3]);
#endif
}
/*!
* @brief translate existing transform matrix by y factor
*
* @param[in, out] m affine transfrom
* @param[in] y y factor
*/
CGLM_INLINE
void
glm_translate_y(mat4 m, float y) {
#if defined(CGLM_SIMD)
glmm_store(m[3], glmm_fmadd(glmm_load(m[1]), glmm_set1(y), glmm_load(m[3])));
#else
vec4 v1;
glm_vec4_scale(m[1], y, v1);
glm_vec4_add(v1, m[3], m[3]);
#endif
}
/*!
* @brief translate existing transform matrix by z factor
*
* @param[in, out] m affine transfrom
* @param[in] z z factor
*/
CGLM_INLINE
void
glm_translate_z(mat4 m, float z) {
#if defined(CGLM_SIMD)
glmm_store(m[3], glmm_fmadd(glmm_load(m[2]), glmm_set1(z), glmm_load(m[3])));
#else
vec4 v1;
glm_vec4_scale(m[2], z, v1);
glm_vec4_add(v1, m[3], m[3]);
#endif
}
/*!
* @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)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotate_x(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[1][1] = c;
t[1][2] = s;
t[2][1] = -s;
t[2][2] = c;
glm_mul_rot(m, t, dest);
}
/*!
* @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)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotate_y(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[0][0] = c;
t[0][2] = -s;
t[2][0] = s;
t[2][2] = c;
glm_mul_rot(m, t, dest);
}
/*!
* @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)
* @param[out] dest rotated matrix
*/
CGLM_INLINE
void
glm_rotate_z(mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
c = cosf(angle);
s = sinf(angle);
t[0][0] = c;
t[0][1] = s;
t[1][0] = -s;
t[1][1] = c;
glm_mul_rot(m, t, dest);
}
/*!
* @brief rotate existing transform matrix around given axis by angle
*
* @param[in, out] m affine transfrom
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotate(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_make(rot, angle, axis);
glm_mul_rot(m, rot, m);
}
/*!
* @brief rotate existing transform
* around given axis by angle at given pivot point (rotation center)
*
* @param[in, out] m affine transfrom
* @param[in] pivot rotation center
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
glm_translate(m, pivot);
glm_rotate(m, angle, axis);
glm_translate(m, pivotInv);
}
/*!
* @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[out] m affine transfrom
* @param[in] pivot rotation center
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
glm_translate_make(m, pivot);
glm_rotate(m, angle, axis);
glm_translate(m, pivotInv);
}
/*!
* @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
*
* @param[in, out] m affine transfrom
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_spin(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_atm(rot, m[3], angle, axis);
glm_mat4_mul(m, rot, m);
}
#endif /* cglm_affine_pre_h */
include/cglm/affine.h
+238
View File
@@ -0,0 +1,238 @@
/*
* 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_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
CGLM_INLINE void glm_translate_x(mat4 m, float to);
CGLM_INLINE void glm_translate_y(mat4 m, float to);
CGLM_INLINE void glm_translate_z(mat4 m, float to);
CGLM_INLINE void glm_translate_make(mat4 m, vec3 v);
CGLM_INLINE void glm_scale_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_scale_make(mat4 m, vec3 v);
CGLM_INLINE void glm_scale(mat4 m, vec3 v);
CGLM_INLINE void glm_scale_uni(mat4 m, float s);
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_make(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
CGLM_INLINE bool glm_uniscaled(mat4 m);
CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
CGLM_INLINE void glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
*/
#ifndef cglm_affine_h
#define cglm_affine_h
#include "common.h"
#include "util.h"
#include "vec3.h"
#include "vec4.h"
#include "mat4.h"
#include "affine-mat.h"
/*!
* @brief creates NEW translate transform matrix by v vector
*
* @param[out] m affine transfrom
* @param[in] v translate vector [x, y, z]
*/
CGLM_INLINE
void
glm_translate_make(mat4 m, vec3 v) {
glm_mat4_identity(m);
glm_vec3_copy(v, m[3]);
}
/*!
* @brief scale existing transform matrix by v vector
* and store result in dest
*
* @param[in] m affine transfrom
* @param[in] v scale vector [x, y, z]
* @param[out] dest scaled matrix
*/
CGLM_INLINE
void
glm_scale_to(mat4 m, vec3 v, mat4 dest) {
glm_vec4_scale(m[0], v[0], dest[0]);
glm_vec4_scale(m[1], v[1], dest[1]);
glm_vec4_scale(m[2], v[2], dest[2]);
glm_vec4_copy(m[3], dest[3]);
}
/*!
* @brief creates NEW scale matrix by v vector
*
* @param[out] m affine transfrom
* @param[in] v scale vector [x, y, z]
*/
CGLM_INLINE
void
glm_scale_make(mat4 m, vec3 v) {
glm_mat4_identity(m);
m[0][0] = v[0];
m[1][1] = v[1];
m[2][2] = v[2];
}
/*!
* @brief scales existing transform matrix by v vector
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] v scale vector [x, y, z]
*/
CGLM_INLINE
void
glm_scale(mat4 m, vec3 v) {
glm_scale_to(m, v, m);
}
/*!
* @brief applies uniform scale to existing transform matrix v = [s, s, s]
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] s scale factor
*/
CGLM_INLINE
void
glm_scale_uni(mat4 m, float s) {
CGLM_ALIGN(8) vec3 v = { s, s, s };
glm_scale_to(m, v, m);
}
/*!
* @brief creates NEW rotation matrix by angle and axis
*
* axis will be normalized so you don't need to normalize it
*
* @param[out] m affine transfrom
* @param[in] angle angle (radians)
* @param[in] axis axis
*/
CGLM_INLINE
void
glm_rotate_make(mat4 m, float angle, vec3 axis) {
CGLM_ALIGN(8) vec3 axisn, v, vs;
float c;
c = cosf(angle);
glm_vec3_normalize_to(axis, axisn);
glm_vec3_scale(axisn, 1.0f - c, v);
glm_vec3_scale(axisn, sinf(angle), vs);
glm_vec3_scale(axisn, v[0], m[0]);
glm_vec3_scale(axisn, v[1], m[1]);
glm_vec3_scale(axisn, v[2], m[2]);
m[0][0] += c; m[1][0] -= vs[2]; m[2][0] += vs[1];
m[0][1] += vs[2]; m[1][1] += c; m[2][1] -= vs[0];
m[0][2] -= vs[1]; m[1][2] += vs[0]; m[2][2] += c;
m[0][3] = m[1][3] = m[2][3] = m[3][0] = m[3][1] = m[3][2] = 0.0f;
m[3][3] = 1.0f;
}
/*!
* @brief decompose scale vector
*
* @param[in] m affine transform
* @param[out] s scale vector (Sx, Sy, Sz)
*/
CGLM_INLINE
void
glm_decompose_scalev(mat4 m, vec3 s) {
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
}
/*!
* @brief returns true if matrix is uniform scaled. This is helpful for
* creating normal matrix.
*
* @param[in] m m
*
* @return boolean
*/
CGLM_INLINE
bool
glm_uniscaled(mat4 m) {
CGLM_ALIGN(8) vec3 s;
glm_decompose_scalev(m, s);
return glm_vec3_eq_all(s);
}
/*!
* @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
glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
CGLM_ALIGN(8) vec3 v;
glm_vec4_copy(m[0], r[0]);
glm_vec4_copy(m[1], r[1]);
glm_vec4_copy(m[2], r[2]);
glm_vec4_copy(t, r[3]);
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
glm_vec4_scale(r[0], 1.0f/s[0], r[0]);
glm_vec4_scale(r[1], 1.0f/s[1], r[1]);
glm_vec4_scale(r[2], 1.0f/s[2], r[2]);
/* Note from Apple Open Source (assume that the matrix is orthonormal):
check for a coordinate system flip. If the determinant
is -1, then negate the matrix and the scaling factors. */
glm_vec3_cross(m[0], m[1], v);
if (glm_vec3_dot(v, m[2]) < 0.0f) {
glm_vec4_negate(r[0]);
glm_vec4_negate(r[1]);
glm_vec4_negate(r[2]);
glm_vec3_negate(s);
}
}
/*!
* @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
glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
glm_vec4_copy(m[3], t);
glm_decompose_rs(m, r, s);
}
#include "affine-pre.h"
#include "affine-post.h"
#endif /* cglm_affine_h */
include/cglm/affine2d.h
+268
View File
@@ -0,0 +1,268 @@
/*
* 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_translate2d(mat3 m, vec2 v)
CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
CGLM_INLINE void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
*/
#ifndef cglm_affine2d_h
#define cglm_affine2d_h
#include "common.h"
#include "util.h"
#include "vec2.h"
#include "mat3.h"
/*!
* @brief translate existing 2d transform matrix by v vector
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] v translate vector [x, y]
*/
CGLM_INLINE
void
glm_translate2d(mat3 m, vec2 v) {
m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
}
/*!
* @brief translate existing 2d transform matrix by v vector
* and store result in dest
*
* source matrix will remain same
*
* @param[in] m affine transfrom
* @param[in] v translate vector [x, y]
* @param[out] dest translated matrix
*/
CGLM_INLINE
void
glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
glm_mat3_copy(m, dest);
glm_translate2d(dest, v);
}
/*!
* @brief translate existing 2d transform matrix by x factor
*
* @param[in, out] m affine transfrom
* @param[in] x x factor
*/
CGLM_INLINE
void
glm_translate2d_x(mat3 m, float x) {
m[2][0] = m[0][0] * x + m[2][0];
m[2][1] = m[0][1] * x + m[2][1];
m[2][2] = m[0][2] * x + m[2][2];
}
/*!
* @brief translate existing 2d transform matrix by y factor
*
* @param[in, out] m affine transfrom
* @param[in] y y factor
*/
CGLM_INLINE
void
glm_translate2d_y(mat3 m, float y) {
m[2][0] = m[1][0] * y + m[2][0];
m[2][1] = m[1][1] * y + m[2][1];
m[2][2] = m[1][2] * y + m[2][2];
}
/*!
* @brief creates NEW translate 2d transform matrix by v vector
*
* @param[out] m affine transfrom
* @param[in] v translate vector [x, y]
*/
CGLM_INLINE
void
glm_translate2d_make(mat3 m, vec2 v) {
glm_mat3_identity(m);
m[2][0] = v[0];
m[2][1] = v[1];
}
/*!
* @brief scale existing 2d transform matrix by v vector
* and store result in dest
*
* @param[in] m affine transfrom
* @param[in] v scale vector [x, y]
* @param[out] dest scaled matrix
*/
CGLM_INLINE
void
glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
dest[0][0] = m[0][0] * v[0];
dest[0][1] = m[0][1] * v[0];
dest[0][2] = m[0][2] * v[0];
dest[1][0] = m[1][0] * v[1];
dest[1][1] = m[1][1] * v[1];
dest[1][2] = m[1][2] * v[1];
dest[2][0] = m[2][0];
dest[2][1] = m[2][1];
dest[2][2] = m[2][2];
}
/*!
* @brief creates NEW 2d scale matrix by v vector
*
* @param[out] m affine transfrom
* @param[in] v scale vector [x, y]
*/
CGLM_INLINE
void
glm_scale2d_make(mat3 m, vec2 v) {
glm_mat3_identity(m);
m[0][0] = v[0];
m[1][1] = v[1];
}
/*!
* @brief scales existing 2d transform matrix by v vector
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] v scale vector [x, y]
*/
CGLM_INLINE
void
glm_scale2d(mat3 m, vec2 v) {
m[0][0] = m[0][0] * v[0];
m[0][1] = m[0][1] * v[0];
m[0][2] = m[0][2] * v[0];
m[1][0] = m[1][0] * v[1];
m[1][1] = m[1][1] * v[1];
m[1][2] = m[1][2] * v[1];
}
/*!
* @brief applies uniform scale to existing 2d transform matrix v = [s, s]
* and stores result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] s scale factor
*/
CGLM_INLINE
void
glm_scale2d_uni(mat3 m, float s) {
m[0][0] = m[0][0] * s;
m[0][1] = m[0][1] * s;
m[0][2] = m[0][2] * s;
m[1][0] = m[1][0] * s;
m[1][1] = m[1][1] * s;
m[1][2] = m[1][2] * s;
}
/*!
* @brief creates NEW rotation matrix by angle around Z axis
*
* @param[out] m affine transfrom
* @param[in] angle angle (radians)
*/
CGLM_INLINE
void
glm_rotate2d_make(mat3 m, float angle) {
float c, s;
s = sinf(angle);
c = cosf(angle);
m[0][0] = c;
m[0][1] = s;
m[0][2] = 0;
m[1][0] = -s;
m[1][1] = c;
m[1][2] = 0;
m[2][0] = 0.0f;
m[2][1] = 0.0f;
m[2][2] = 1.0f;
}
/*!
* @brief rotate existing 2d transform matrix around Z axis by angle
* and store result in same matrix
*
* @param[in, out] m affine transfrom
* @param[in] angle angle (radians)
*/
CGLM_INLINE
void
glm_rotate2d(mat3 m, float angle) {
float m00 = m[0][0], m10 = m[1][0],
m01 = m[0][1], m11 = m[1][1],
m02 = m[0][2], m12 = m[1][2];
float c, s;
s = sinf(angle);
c = cosf(angle);
m[0][0] = m00 * c + m10 * s;
m[0][1] = m01 * c + m11 * s;
m[0][2] = m02 * c + m12 * s;
m[1][0] = m00 * -s + m10 * c;
m[1][1] = m01 * -s + m11 * c;
m[1][2] = m02 * -s + m12 * c;
}
/*!
* @brief rotate existing 2d transform matrix around Z axis by angle
* and store result in dest
*
* @param[in] m affine transfrom
* @param[in] angle angle (radians)
* @param[out] dest destination
*/
CGLM_INLINE
void
glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
float m00 = m[0][0], m10 = m[1][0],
m01 = m[0][1], m11 = m[1][1],
m02 = m[0][2], m12 = m[1][2];
float c, s;
s = sinf(angle);
c = cosf(angle);
dest[0][0] = m00 * c + m10 * s;
dest[0][1] = m01 * c + m11 * s;
dest[0][2] = m02 * c + m12 * s;
dest[1][0] = m00 * -s + m10 * c;
dest[1][1] = m01 * -s + m11 * c;
dest[1][2] = m02 * -s + m12 * c;
dest[2][0] = m[2][0];
dest[2][1] = m[2][1];
dest[2][2] = m[2][2];
}
#endif /* cglm_affine2d_h */
include/cglm/applesimd.h
+95
View File
@@ -0,0 +1,95 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_applesimd_h
#define cglm_applesimd_h
#if defined(__APPLE__) \
&& defined(SIMD_COMPILER_HAS_REQUIRED_FEATURES) \
&& defined(SIMD_BASE) \
&& defined(SIMD_TYPES) \
&& defined(SIMD_VECTOR_TYPES)
#include "common.h"
/*!
* @brief converts mat4 to Apple's simd type simd_float4x4
* @return simd_float4x4
*/
CGLM_INLINE
simd_float4x4
glm_mat4_applesimd(mat4 m) {
simd_float4x4 t;
t.columns[0][0] = m[0][0];
t.columns[0][1] = m[0][1];
t.columns[0][2] = m[0][2];
t.columns[0][3] = m[0][3];
t.columns[1][0] = m[1][0];
t.columns[1][1] = m[1][1];
t.columns[1][2] = m[1][2];
t.columns[1][3] = m[1][3];
t.columns[2][0] = m[2][0];
t.columns[2][1] = m[2][1];
t.columns[2][2] = m[2][2];
t.columns[2][3] = m[2][3];
t.columns[3][0] = m[3][0];
t.columns[3][1] = m[3][1];
t.columns[3][2] = m[3][2];
t.columns[3][3] = m[3][3];
return t;
}
/*!
* @brief converts mat3 to Apple's simd type simd_float3x3
* @return simd_float3x3
*/
CGLM_INLINE
simd_float3x3
glm_mat3_applesimd(mat3 m) {
simd_float3x3 t;
t.columns[0][0] = m[0][0];
t.columns[0][1] = m[0][1];
t.columns[0][2] = m[0][2];
t.columns[1][0] = m[1][0];
t.columns[1][1] = m[1][1];
t.columns[1][2] = m[1][2];
t.columns[2][0] = m[2][0];
t.columns[2][1] = m[2][1];
t.columns[2][2] = m[2][2];
return t;
}
/*!
* @brief converts vec4 to Apple's simd type simd_float4
* @return simd_float4
*/
CGLM_INLINE
simd_float4
glm_vec4_applesimd(vec4 v) {
return (simd_float4){v[0], v[1], v[2], v[3]};
}
/*!
* @brief converts vec3 to Apple's simd type simd_float3
* @return v
*/
CGLM_INLINE
simd_float3
glm_vec3_applesimd(vec3 v) {
return (simd_float3){v[0], v[1], v[2]};
}
#endif
#endif /* cglm_applesimd_h */
include/cglm/bezier.h
+154
View File
@@ -0,0 +1,154 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_bezier_h
#define cglm_bezier_h
#include "common.h"
#define GLM_BEZIER_MAT_INIT {{-1.0f, 3.0f, -3.0f, 1.0f}, \
{ 3.0f, -6.0f, 3.0f, 0.0f}, \
{-3.0f, 3.0f, 0.0f, 0.0f}, \
{ 1.0f, 0.0f, 0.0f, 0.0f}}
#define GLM_HERMITE_MAT_INIT {{ 2.0f, -3.0f, 0.0f, 1.0f}, \
{-2.0f, 3.0f, 0.0f, 0.0f}, \
{ 1.0f, -2.0f, 1.0f, 0.0f}, \
{ 1.0f, -1.0f, 0.0f, 0.0f}}
/* for C only */
#define GLM_BEZIER_MAT ((mat4)GLM_BEZIER_MAT_INIT)
#define GLM_HERMITE_MAT ((mat4)GLM_HERMITE_MAT_INIT)
#define CGLM_DECASTEL_EPS 1e-9f
#define CGLM_DECASTEL_MAX 1000.0f
#define CGLM_DECASTEL_SMALL 1e-20f
/*!
* @brief cubic bezier interpolation
*
* Formula:
* B(s) = P0*(1-s)^3 + 3*C0*s*(1-s)^2 + 3*C1*s^2*(1-s) + P1*s^3
*
* similar result using matrix:
* B(s) = glm_smc(t, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
*
* glm_eq(glm_smc(...), glm_bezier(...)) should return TRUE
*
* @param[in] s parameter between 0 and 1
* @param[in] p0 begin point
* @param[in] c0 control point 1
* @param[in] c1 control point 2
* @param[in] p1 end point
*
* @return B(s)
*/
CGLM_INLINE
float
glm_bezier(float s, float p0, float c0, float c1, float p1) {
float x, xx, ss, xs3, a;
x = 1.0f - s;
xx = x * x;
ss = s * s;
xs3 = (s - ss) * 3.0f;
a = p0 * xx + c0 * xs3;
return a + s * (c1 * xs3 + p1 * ss - a);
}
/*!
* @brief cubic hermite interpolation
*
* Formula:
* H(s) = P0*(2*s^3 - 3*s^2 + 1) + T0*(s^3 - 2*s^2 + s)
* + P1*(-2*s^3 + 3*s^2) + T1*(s^3 - s^2)
*
* similar result using matrix:
* H(s) = glm_smc(t, GLM_HERMITE_MAT, (vec4){p0, p1, c0, c1})
*
* glm_eq(glm_smc(...), glm_hermite(...)) should return TRUE
*
* @param[in] s parameter between 0 and 1
* @param[in] p0 begin point
* @param[in] t0 tangent 1
* @param[in] t1 tangent 2
* @param[in] p1 end point
*
* @return H(s)
*/
CGLM_INLINE
float
glm_hermite(float s, float p0, float t0, float t1, float p1) {
float ss, d, a, b, c, e, f;
ss = s * s;
a = ss + ss;
c = a + ss;
b = a * s;
d = s * ss;
f = d - ss;
e = b - c;
return p0 * (e + 1.0f) + t0 * (f - ss + s) + t1 * f - p1 * e;
}
/*!
* @brief iterative way to solve cubic equation
*
* @param[in] prm parameter between 0 and 1
* @param[in] p0 begin point
* @param[in] c0 control point 1
* @param[in] c1 control point 2
* @param[in] p1 end point
*
* @return parameter to use in cubic equation
*/
CGLM_INLINE
float
glm_decasteljau(float prm, float p0, float c0, float c1, float p1) {
float u, v, a, b, c, d, e, f;
int i;
if (prm - p0 < CGLM_DECASTEL_SMALL)
return 0.0f;
if (p1 - prm < CGLM_DECASTEL_SMALL)
return 1.0f;
u = 0.0f;
v = 1.0f;
for (i = 0; i < CGLM_DECASTEL_MAX; i++) {
/* de Casteljau Subdivision */
a = (p0 + c0) * 0.5f;
b = (c0 + c1) * 0.5f;
c = (c1 + p1) * 0.5f;
d = (a + b) * 0.5f;
e = (b + c) * 0.5f;
f = (d + e) * 0.5f; /* this one is on the curve! */
/* The curve point is close enough to our wanted t */
if (fabsf(f - prm) < CGLM_DECASTEL_EPS)
return glm_clamp_zo((u + v) * 0.5f);
/* dichotomy */
if (f < prm) {
p0 = f;
c0 = e;
c1 = c;
u = (u + v) * 0.5f;
} else {
c0 = a;
c1 = d;
p1 = f;
v = (u + v) * 0.5f;
}
}
return glm_clamp_zo((u + v) * 0.5f);
}
#endif /* cglm_bezier_h */
include/cglm/box.h
+281
View File
@@ -0,0 +1,281 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_box_h
#define cglm_box_h
#include "common.h"
#include "vec3.h"
#include "vec4.h"
#include "util.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
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
vec3 v[2], xa, xb, ya, yb, za, zb;
glm_vec3_scale(m[0], box[0][0], xa);
glm_vec3_scale(m[0], box[1][0], xb);
glm_vec3_scale(m[1], box[0][1], ya);
glm_vec3_scale(m[1], box[1][1], yb);
glm_vec3_scale(m[2], box[0][2], za);
glm_vec3_scale(m[2], box[1][2], zb);
/* translation + min(xa, xb) + min(ya, yb) + min(za, zb) */
glm_vec3(m[3], v[0]);
glm_vec3_minadd(xa, xb, v[0]);
glm_vec3_minadd(ya, yb, v[0]);
glm_vec3_minadd(za, zb, v[0]);
/* translation + max(xa, xb) + max(ya, yb) + max(za, zb) */
glm_vec3(m[3], v[1]);
glm_vec3_maxadd(xa, xb, v[1]);
glm_vec3_maxadd(ya, yb, v[1]);
glm_vec3_maxadd(za, zb, v[1]);
glm_vec3_copy(v[0], dest[0]);
glm_vec3_copy(v[1], dest[1]);
}
/*!
* @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
glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
dest[0][0] = glm_min(box1[0][0], box2[0][0]);
dest[0][1] = glm_min(box1[0][1], box2[0][1]);
dest[0][2] = glm_min(box1[0][2], box2[0][2]);
dest[1][0] = glm_max(box1[1][0], box2[1][0]);
dest[1][1] = glm_max(box1[1][1], box2[1][1]);
dest[1][2] = glm_max(box1[1][2], box2[1][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
glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
dest[1][0] = glm_min(box[1][0], cropBox[1][0]);
dest[1][1] = glm_min(box[1][1], cropBox[1][1]);
dest[1][2] = glm_min(box[1][2], cropBox[1][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
glm_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]) {
glm_aabb_crop(box, cropBox, dest);
glm_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
glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
float *p, dp;
int i;
for (i = 0; i < 6; i++) {
p = planes[i];
dp = p[0] * box[p[0] > 0.0f][0]
+ p[1] * box[p[1] > 0.0f][1]
+ p[2] * box[p[2] > 0.0f][2];
if (dp < -p[3])
return false;
}
return true;
}
/*!
* @brief invalidate AABB min and max values
*
* @param[in, out] box bounding box
*/
CGLM_INLINE
void
glm_aabb_invalidate(vec3 box[2]) {
glm_vec3_broadcast(FLT_MAX, box[0]);
glm_vec3_broadcast(-FLT_MAX, box[1]);
}
/*!
* @brief check if AABB is valid or not
*
* @param[in] box bounding box
*/
CGLM_INLINE
bool
glm_aabb_isvalid(vec3 box[2]) {
return glm_vec3_max(box[0]) != FLT_MAX
&& glm_vec3_min(box[1]) != -FLT_MAX;
}
/*!
* @brief distance between of min and max
*
* @param[in] box bounding box
*/
CGLM_INLINE
float
glm_aabb_size(vec3 box[2]) {
return glm_vec3_distance(box[0], box[1]);
}
/*!
* @brief radius of sphere which surrounds AABB
*
* @param[in] box bounding box
*/
CGLM_INLINE
float
glm_aabb_radius(vec3 box[2]) {
return glm_aabb_size(box) * 0.5f;
}
/*!
* @brief computes center point of AABB
*
* @param[in] box bounding box
* @param[out] dest center of bounding box
*/
CGLM_INLINE
void
glm_aabb_center(vec3 box[2], vec3 dest) {
glm_vec3_center(box[0], box[1], dest);
}
/*!
* @brief check if two AABB intersects
*
* @param[in] box bounding box
* @param[in] other other bounding box
*/
CGLM_INLINE
bool
glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
&& (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
&& (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
}
/*!
* @brief check if AABB intersects with sphere
*
* https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
* Solid Box - Solid Sphere test.
*
* Sphere Representation in cglm: [center.x, center.y, center.z, radii]
*
* @param[in] box solid bounding box
* @param[in] s solid sphere
*/
CGLM_INLINE
bool
glm_aabb_sphere(vec3 box[2], vec4 s) {
float dmin;
int a, b, c;
a = (s[0] < box[0][0]) + (s[0] > box[1][0]);
b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
dmin = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
+ glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
+ glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
return dmin <= glm_pow2(s[3]);
}
/*!
* @brief check if point is inside of AABB
*
* @param[in] box bounding box
* @param[in] point point
*/
CGLM_INLINE
bool
glm_aabb_point(vec3 box[2], vec3 point) {
return (point[0] >= box[0][0] && point[0] <= box[1][0])
&& (point[1] >= box[0][1] && point[1] <= box[1][1])
&& (point[2] >= box[0][2] && point[2] <= box[1][2]);
}
/*!
* @brief check if AABB contains other AABB
*
* @param[in] box bounding box
* @param[in] other other bounding box
*/
CGLM_INLINE
bool
glm_aabb_contains(vec3 box[2], vec3 other[2]) {
return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
&& (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
&& (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
}
#endif /* cglm_box_h */
include/cglm/call.h
+43
View File
@@ -0,0 +1,43 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_call_h
#define cglm_call_h
#ifdef __cplusplus
extern "C" {
#endif
#include "cglm.h"
#include "call/vec2.h"
#include "call/vec3.h"
#include "call/vec4.h"
#include "call/ivec2.h"
#include "call/ivec3.h"
#include "call/ivec4.h"
#include "call/mat2.h"
#include "call/mat3.h"
#include "call/mat4.h"
#include "call/affine.h"
#include "call/cam.h"
#include "call/quat.h"
#include "call/euler.h"
#include "call/plane.h"
#include "call/frustum.h"
#include "call/box.h"
#include "call/io.h"
#include "call/project.h"
#include "call/sphere.h"
#include "call/ease.h"
#include "call/curve.h"
#include "call/bezier.h"
#include "call/ray.h"
#include "call/affine2d.h"
#ifdef __cplusplus
}
#endif
#endif /* cglm_call_h */
include/cglm/call/affine.h
+167
View File
@@ -0,0 +1,167 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_affine_h
#define cglmc_affine_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_translate_make(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_translate(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_translate_x(mat4 m, float to);
CGLM_EXPORT
void
glmc_translate_y(mat4 m, float to);
CGLM_EXPORT
void
glmc_translate_z(mat4 m, float to);
CGLM_EXPORT
void
glmc_scale_make(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_scale_to(mat4 m, vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_scale(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_scale_uni(mat4 m, float s);
CGLM_EXPORT
void
glmc_rotate_x(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_y(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_z(mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_make(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_spin(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_decompose_scalev(mat4 m, vec3 s);
CGLM_EXPORT
bool
glmc_uniscaled(mat4 m);
CGLM_EXPORT
void
glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
CGLM_EXPORT
void
glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
/* affine-post */
CGLM_EXPORT
void
glmc_translated(mat4 m, vec3 v);
CGLM_EXPORT
void
glmc_translated_to(mat4 m, vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_translated_x(mat4 m, float x);
CGLM_EXPORT
void
glmc_translated_y(mat4 m, float y);
CGLM_EXPORT
void
glmc_translated_z(mat4 m, float z);
CGLM_EXPORT
void
glmc_rotated_x(mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated_y(mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated_z(mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated(mat4 m, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_spinned(mat4 m, float angle, vec3 axis);
/* affine-mat */
CGLM_EXPORT
void
glmc_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_inv_tr(mat4 mat);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_affine_h */
include/cglm/call/affine2d.h
+67
View File
@@ -0,0 +1,67 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_affine2d_h
#define cglmc_affine2d_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_translate2d_make(mat3 m, vec2 v);
CGLM_EXPORT
void
glmc_translate2d_to(mat3 m, vec2 v, mat3 dest);
CGLM_EXPORT
void
glmc_translate2d(mat3 m, vec2 v);
CGLM_EXPORT
void
glmc_translate2d_x(mat3 m, float to);
CGLM_EXPORT
void
glmc_translate2d_y(mat3 m, float to);
CGLM_EXPORT
void
glmc_scale2d_to(mat3 m, vec2 v, mat3 dest);
CGLM_EXPORT
void
glmc_scale2d_make(mat3 m, vec2 v);
CGLM_EXPORT
void
glmc_scale2d(mat3 m, vec2 v);
CGLM_EXPORT
void
glmc_scale2d_uni(mat3 m, float s);
CGLM_EXPORT
void
glmc_rotate2d_make(mat3 m, float angle);
CGLM_EXPORT
void
glmc_rotate2d(mat3 m, float angle);
CGLM_EXPORT
void
glmc_rotate2d_to(mat3 m, float angle, mat3 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_affine2d_h */
include/cglm/call/bezier.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_bezier_h
#define cglmc_bezier_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
float
glmc_bezier(float s, float p0, float c0, float c1, float p1);
CGLM_EXPORT
float
glmc_hermite(float s, float p0, float t0, float t1, float p1);
CGLM_EXPORT
float
glmc_decasteljau(float prm, float p0, float c0, float c1, float p1);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_bezier_h */
include/cglm/call/box.h
+79
View File
@@ -0,0 +1,79 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_box_h
#define cglmc_box_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]);
CGLM_EXPORT
bool
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
CGLM_EXPORT
void
glmc_aabb_invalidate(vec3 box[2]);
CGLM_EXPORT
bool
glmc_aabb_isvalid(vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_size(vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_radius(vec3 box[2]);
CGLM_EXPORT
void
glmc_aabb_center(vec3 box[2], vec3 dest);
CGLM_EXPORT
bool
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_point(vec3 box[2], vec3 point);
CGLM_EXPORT
bool
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_sphere(vec3 box[2], vec4 s);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_box_h */
include/cglm/call/cam.h
+133
View File
@@ -0,0 +1,133 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_cam_h
#define cglmc_cam_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_frustum(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_s(float aspect, float size, mat4 dest);
CGLM_EXPORT
void
glmc_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_perspective_default(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize(float aspect, mat4 proj);
CGLM_EXPORT
void
glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
CGLM_EXPORT
void
glmc_persp_decomp(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
float * __restrict bottom,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far(mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near(mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
float
glmc_persp_fovy(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect(mat4 proj);
CGLM_EXPORT
void
glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_cam_h */
include/cglm/call/clipspace/ortho_lh_no.h
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ortho_lh_no_h
#define cglmc_ortho_lh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_ortho_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_lh_no(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_lh_no(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_s_lh_no(float aspect, float size, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ortho_lh_no_h */
include/cglm/call/clipspace/ortho_lh_zo.h
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ortho_lh_zo_h
#define cglmc_ortho_lh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_ortho_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_lh_zo(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_lh_zo(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_s_lh_zo(float aspect, float size, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ortho_lh_zo_h */
include/cglm/call/clipspace/ortho_rh_no.h
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ortho_rh_no_h
#define cglmc_ortho_rh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_ortho_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_rh_no(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_rh_no(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_s_rh_no(float aspect, float size, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ortho_rh_no_h */
include/cglm/call/clipspace/ortho_rh_zo.h
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ortho_rh_zo_h
#define cglmc_ortho_rh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_ortho_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_rh_zo(vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_rh_zo(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_default_s_rh_zo(float aspect, float size, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ortho_rh_zo_h */
include/cglm/call/clipspace/persp_lh_no.h
+87
View File
@@ -0,0 +1,87 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_persp_lh_no_h
#define cglmc_persp_lh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_frustum_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_lh_no(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far_lh_no(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_lh_no(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_lh_no(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_lh_no(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_lh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_lh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_lh_no(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_lh_no(mat4 proj);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_persp_lh_no_h */
include/cglm/call/clipspace/persp_lh_zo.h
+87
View File
@@ -0,0 +1,87 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_persp_lh_zo_h
#define cglmc_persp_lh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_frustum_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_lh_zo(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far_lh_zo(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_lh_zo(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_lh_zo(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_lh_zo(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_lh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_lh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_lh_zo(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_lh_zo(mat4 proj);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_persp_lh_zo_h */
include/cglm/call/clipspace/persp_rh_no.h
+87
View File
@@ -0,0 +1,87 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_persp_rh_no_h
#define cglmc_persp_rh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_frustum_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_rh_no(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far_rh_no(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_rh_no(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_rh_no(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_rh_no(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_rh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_rh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_rh_no(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_rh_no(mat4 proj);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_persp_rh_no_h */
include/cglm/call/clipspace/persp_rh_zo.h
+87
View File
@@ -0,0 +1,87 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_persp_rh_zo_h
#define cglmc_persp_rh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_frustum_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_rh_zo(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far_rh_zo(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_rh_zo(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_rh_zo(mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_rh_zo(mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_rh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_rh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_rh_zo(mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_rh_zo(mat4 proj);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_persp_rh_zo_h */
include/cglm/call/clipspace/project_no.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_project_no_h
#define cglmc_project_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z_no(vec3 pos, mat4 m);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_project_no_h */
include/cglm/call/clipspace/project_zo.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_project_zo_h
#define cglmc_project_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z_zo(vec3 pos, mat4 m);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_project_zo_h */
include/cglm/call/clipspace/view_lh_no.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_view_lh_no_h
#define cglmc_view_lh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_view_lh_no_h */
include/cglm/call/clipspace/view_lh_zo.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_view_lh_zo_h
#define cglmc_view_lh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_view_lh_zo_h */
include/cglm/call/clipspace/view_rh_no.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_view_rh_no_h
#define cglmc_view_rh_no_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_view_rh_no_h */
include/cglm/call/clipspace/view_rh_zo.h
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_view_rh_zo_h
#define cglmc_view_rh_zo_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../../cglm.h"
CGLM_EXPORT
void
glmc_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_view_rh_zo_h */
include/cglm/call/curve.h
+23
View File
@@ -0,0 +1,23 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_curve_h
#define cglmc_curve_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
float
glmc_smc(float s, mat4 m, vec4 c);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_curve_h */
include/cglm/call/ease.h
+143
View File
@@ -0,0 +1,143 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ease_h
#define cglmc_ease_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
float
glmc_ease_linear(float t);
CGLM_EXPORT
float
glmc_ease_sine_in(float t);
CGLM_EXPORT
float
glmc_ease_sine_out(float t);
CGLM_EXPORT
float
glmc_ease_sine_inout(float t);
CGLM_EXPORT
float
glmc_ease_quad_in(float t);
CGLM_EXPORT
float
glmc_ease_quad_out(float t);
CGLM_EXPORT
float
glmc_ease_quad_inout(float t);
CGLM_EXPORT
float
glmc_ease_cubic_in(float t);
CGLM_EXPORT
float
glmc_ease_cubic_out(float t);
CGLM_EXPORT
float
glmc_ease_cubic_inout(float t);
CGLM_EXPORT
float
glmc_ease_quart_in(float t);
CGLM_EXPORT
float
glmc_ease_quart_out(float t);
CGLM_EXPORT
float
glmc_ease_quart_inout(float t);
CGLM_EXPORT
float
glmc_ease_quint_in(float t);
CGLM_EXPORT
float
glmc_ease_quint_out(float t);
CGLM_EXPORT
float
glmc_ease_quint_inout(float t);
CGLM_EXPORT
float
glmc_ease_exp_in(float t);
CGLM_EXPORT
float
glmc_ease_exp_out(float t);
CGLM_EXPORT
float
glmc_ease_exp_inout(float t);
CGLM_EXPORT
float
glmc_ease_circ_in(float t);
CGLM_EXPORT
float
glmc_ease_circ_out(float t);
CGLM_EXPORT
float
glmc_ease_circ_inout(float t);
CGLM_EXPORT
float
glmc_ease_back_in(float t);
CGLM_EXPORT
float
glmc_ease_back_out(float t);
CGLM_EXPORT
float
glmc_ease_back_inout(float t);
CGLM_EXPORT
float
glmc_ease_elast_in(float t);
CGLM_EXPORT
float
glmc_ease_elast_out(float t);
CGLM_EXPORT
float
glmc_ease_elast_inout(float t);
CGLM_EXPORT
float
glmc_ease_bounce_out(float t);
CGLM_EXPORT
float
glmc_ease_bounce_in(float t);
CGLM_EXPORT
float
glmc_ease_bounce_inout(float t);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ease_h */
include/cglm/call/euler.h
+55
View File
@@ -0,0 +1,55 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_euler_h
#define cglmc_euler_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_euler_angles(mat4 m, vec3 dest);
CGLM_EXPORT
void
glmc_euler(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xyz(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zyx(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zxy(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xzy(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yzx(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yxz(vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_by_order(vec3 angles, glm_euler_seq axis, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_euler_h */
include/cglm/call/frustum.h
+41
View File
@@ -0,0 +1,41 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_frustum_h
#define cglmc_frustum_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_frustum_planes(mat4 m, vec4 dest[6]);
CGLM_EXPORT
void
glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
CGLM_EXPORT
void
glmc_frustum_center(vec4 corners[8], vec4 dest);
CGLM_EXPORT
void
glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
CGLM_EXPORT
void
glmc_frustum_corners_at(vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_frustum_h */
include/cglm/call/io.h
+45
View File
@@ -0,0 +1,45 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_io_h
#define cglmc_io_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_mat4_print(mat4 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_mat3_print(mat3 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec4_print(vec4 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec3_print(vec3 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_versor_print(versor vec,
FILE * __restrict ostream);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_io_h */
include/cglm/call/ivec2.h
+83
View File
@@ -0,0 +1,83 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ivec2_h
#define cglmc_ivec2_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_ivec2(int * __restrict v, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_copy(ivec2 a, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_zero(ivec2 v);
CGLM_EXPORT
void
glmc_ivec2_one(ivec2 v);
CGLM_EXPORT
void
glmc_ivec2_add(ivec2 a, ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_adds(ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subs(ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_scale(ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
int
glmc_ivec2_distance2(ivec2 a, ivec2 b);
CGLM_EXPORT
float
glmc_ivec2_distance(ivec2 a, ivec2 b);
CGLM_EXPORT
void
glmc_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_clamp(ivec2 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec2_abs(ivec2 v, ivec2 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ivec2_h */
include/cglm/call/ivec3.h
+83
View File
@@ -0,0 +1,83 @@
/*
* Copyright (c);, Recep Aslantas.
*
* MIT License (MIT);, http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ivec3_h
#define cglmc_ivec3_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_ivec3(ivec4 v4, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_copy(ivec3 a, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_zero(ivec3 v);
CGLM_EXPORT
void
glmc_ivec3_one(ivec3 v);
CGLM_EXPORT
void
glmc_ivec3_add(ivec3 a, ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_adds(ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subs(ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_scale(ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
int
glmc_ivec3_distance2(ivec3 a, ivec3 b);
CGLM_EXPORT
float
glmc_ivec3_distance(ivec3 a, ivec3 b);
CGLM_EXPORT
void
glmc_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_clamp(ivec3 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec3_abs(ivec3 v, ivec3 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ivec3_h */
include/cglm/call/ivec4.h
+83
View File
@@ -0,0 +1,83 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_ivec4_h
#define cglmc_ivec4_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_ivec4(ivec3 v3, int last, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_copy(ivec4 a, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_zero(ivec4 v);
CGLM_EXPORT
void
glmc_ivec4_one(ivec4 v);
CGLM_EXPORT
void
glmc_ivec4_add(ivec4 a, ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_adds(ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subs(ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_scale(ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
int
glmc_ivec4_distance2(ivec4 a, ivec4 b);
CGLM_EXPORT
float
glmc_ivec4_distance(ivec4 a, ivec4 b);
CGLM_EXPORT
void
glmc_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_clamp(ivec4 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec4_abs(ivec4 v, ivec4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ivec4_h */
include/cglm/call/mat2.h
+79
View File
@@ -0,0 +1,79 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_mat2_h
#define cglmc_mat2_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_mat2_copy(mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_identity(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_identity_array(mat2 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat2_zero(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose_to(mat2 m, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose(mat2 m);
CGLM_EXPORT
void
glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
CGLM_EXPORT
float
glmc_mat2_trace(mat2 m);
CGLM_EXPORT
void
glmc_mat2_scale(mat2 m, float s);
CGLM_EXPORT
float
glmc_mat2_det(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_inv(mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_swap_col(mat2 mat, int col1, int col2);
CGLM_EXPORT
void
glmc_mat2_swap_row(mat2 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_mat2_h */
include/cglm/call/mat3.h
+86
View File
@@ -0,0 +1,86 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_mat3_h
#define cglmc_mat3_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_mat3_dup(mat, dest) glmc_mat3_copy(mat, dest)
CGLM_EXPORT
void
glmc_mat3_copy(mat3 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_identity(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_zero(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_transpose_to(mat3 m, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_transpose(mat3 m);
CGLM_EXPORT
void
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_mat3_trace(mat3 m);
CGLM_EXPORT
void
glmc_mat3_quat(mat3 m, versor dest);
CGLM_EXPORT
void
glmc_mat3_scale(mat3 m, float s);
CGLM_EXPORT
float
glmc_mat3_det(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_inv(mat3 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_swap_col(mat3 mat, int col1, int col2);
CGLM_EXPORT
void
glmc_mat3_swap_row(mat3 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_mat3_h */
include/cglm/call/mat4.h
+127
View File
@@ -0,0 +1,127 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_mat_h
#define cglmc_mat_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_mat4_udup(mat, dest) glmc_mat4_ucopy(mat, dest)
#define glmc_mat4_dup(mat, dest) glmc_mat4_copy(mat, dest)
CGLM_EXPORT
void
glmc_mat4_ucopy(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_copy(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_identity(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat4_zero(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_pick3(mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_pick3t(mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_ins3(mat3 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
CGLM_EXPORT
float
glmc_mat4_trace(mat4 m);
CGLM_EXPORT
float
glmc_mat4_trace3(mat4 m);
CGLM_EXPORT
void
glmc_mat4_quat(mat4 m, versor dest);
CGLM_EXPORT
void
glmc_mat4_transpose_to(mat4 m, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_transpose(mat4 m);
CGLM_EXPORT
void
glmc_mat4_scale_p(mat4 m, float s);
CGLM_EXPORT
void
glmc_mat4_scale(mat4 m, float s);
CGLM_EXPORT
float
glmc_mat4_det(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_inv(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_precise(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_fast(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_swap_col(mat4 mat, int col1, int col2);
CGLM_EXPORT
void
glmc_mat4_swap_row(mat4 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_mat_h */
include/cglm/call/plane.h
+23
View File
@@ -0,0 +1,23 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_plane_h
#define cglmc_plane_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_plane_normalize(vec4 plane);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_plane_h */
include/cglm/call/project.h
+41
View File
@@ -0,0 +1,41 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_project_h
#define cglmc_project_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z(vec3 pos, mat4 m);
CGLM_EXPORT
void
glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_project_h */
include/cglm/call/quat.h
+167
View File
@@ -0,0 +1,167 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_quat_h
#define cglmc_quat_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_quat_identity(versor q);
CGLM_EXPORT
void
glmc_quat_identity_array(versor * __restrict q, size_t count);
CGLM_EXPORT
void
glmc_quat_init(versor q, float x, float y, float z, float w);
CGLM_EXPORT
void
glmc_quat(versor q, float angle, float x, float y, float z);
CGLM_EXPORT
void
glmc_quatv(versor q, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_quat_copy(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_from_vecs(vec3 a, vec3 b, versor dest);
CGLM_EXPORT
float
glmc_quat_norm(versor q);
CGLM_EXPORT
void
glmc_quat_normalize_to(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_normalize(versor q);
CGLM_EXPORT
float
glmc_quat_dot(versor p, versor q);
CGLM_EXPORT
void
glmc_quat_conjugate(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_inv(versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_add(versor p, versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_sub(versor p, versor q, versor dest);
CGLM_EXPORT
float
glmc_quat_real(versor q);
CGLM_EXPORT
void
glmc_quat_imag(versor q, vec3 dest);
CGLM_EXPORT
void
glmc_quat_imagn(versor q, vec3 dest);
CGLM_EXPORT
float
glmc_quat_imaglen(versor q);
CGLM_EXPORT
float
glmc_quat_angle(versor q);
CGLM_EXPORT
void
glmc_quat_axis(versor q, vec3 dest);
CGLM_EXPORT
void
glmc_quat_mul(versor p, versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_mat4(versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat4t(versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat3(versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_mat3t(versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_lerp(versor from, versor to, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_lerpc(versor from, versor to, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_nlerp(versor q, versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_slerp(versor q, versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
CGLM_EXPORT
void
glmc_quat_for(vec3 dir, vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
CGLM_EXPORT
void
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_quat_h */
include/cglm/call/ray.h
+27
View File
@@ -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 cglmc_ray_h
#define cglmc_ray_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
bool
glmc_ray_triangle(vec3 origin,
vec3 direction,
vec3 v0,
vec3 v1,
vec3 v2,
float *d);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_ray_h */
include/cglm/call/sphere.h
+39
View File
@@ -0,0 +1,39 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_sphere_h
#define cglmc_sphere_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
float
glmc_sphere_radii(vec4 s);
CGLM_EXPORT
void
glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
CGLM_EXPORT
void
glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
CGLM_EXPORT
bool
glmc_sphere_sphere(vec4 s1, vec4 s2);
CGLM_EXPORT
bool
glmc_sphere_point(vec4 s, vec3 point);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_sphere_h */
include/cglm/call/vec2.h
+171
View File
@@ -0,0 +1,171 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_vec2_h
#define cglmc_vec2_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
CGLM_EXPORT
void
glmc_vec2(float * __restrict v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_copy(vec2 a, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_zero(vec2 v);
CGLM_EXPORT
void
glmc_vec2_one(vec2 v);
CGLM_EXPORT
float
glmc_vec2_dot(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_cross(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_norm2(vec2 v);
CGLM_EXPORT
float
glmc_vec2_norm(vec2 v);
CGLM_EXPORT
void
glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_adds(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subs(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_divs(vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladds(vec2 a, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_negate_to(vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_negate(vec2 v);
CGLM_EXPORT
void
glmc_vec2_normalize(vec2 v);
CGLM_EXPORT
void
glmc_vec2_normalize_to(vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
CGLM_EXPORT
float
glmc_vec2_distance2(vec2 a, vec2 b);
CGLM_EXPORT
float
glmc_vec2_distance(vec2 a, vec2 b);
CGLM_EXPORT
void
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_clamp(vec2 v, float minval, float maxval);
CGLM_EXPORT
void
glmc_vec2_abs(vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_vec2_h */
include/cglm/call/vec3.h
+312
View File
@@ -0,0 +1,312 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_vec3_h
#define cglmc_vec3_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec_dup(v, dest) glmc_vec3_copy(v, dest)
#define glmc_vec3_flipsign(v) glmc_vec3_negate(v)
#define glmc_vec3_flipsign_to(v, dest) glmc_vec3_negate_to(v, dest)
#define glmc_vec3_inv(v) glmc_vec3_negate(v)
#define glmc_vec3_inv_to(v, dest) glmc_vec3_negate_to(v, dest)
CGLM_EXPORT
void
glmc_vec3(vec4 v4, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_copy(vec3 a, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_zero(vec3 v);
CGLM_EXPORT
void
glmc_vec3_one(vec3 v);
CGLM_EXPORT
float
glmc_vec3_dot(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_norm(vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm2(vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_one(vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_inf(vec3 v);
CGLM_EXPORT
void
glmc_vec3_normalize_to(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_normalize(vec3 v);
CGLM_EXPORT
void
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_adds(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subs(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec3_scale(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_divs(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_negate(vec3 v);
CGLM_EXPORT
void
glmc_vec3_negate_to(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_angle(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
CGLM_EXPORT
void
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_distance2(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_distance(vec3 a, vec3 b);
CGLM_EXPORT
void
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec3_ortho(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
CGLM_INLINE
void
glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
glmc_vec3_lerp(from, to, t, dest);
}
CGLM_INLINE
void
glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
glmc_vec3_lerpc(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_vec3_step_uni(float edge, vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
/* ext */
CGLM_EXPORT
void
glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec3_broadcast(float val, vec3 d);
CGLM_EXPORT
void
glmc_vec3_fill(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_eps(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_all(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_eqv(vec3 a, vec3 b);
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(vec3 a, vec3 b);
CGLM_EXPORT
float
glmc_vec3_max(vec3 v);
CGLM_EXPORT
float
glmc_vec3_min(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isnan(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isinf(vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isvalid(vec3 v);
CGLM_EXPORT
void
glmc_vec3_sign(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_abs(vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_fract(vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_hadd(vec3 v);
CGLM_EXPORT
void
glmc_vec3_sqrt(vec3 v, vec3 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_vec3_h */
include/cglm/call/vec4.h
+290
View File
@@ -0,0 +1,290 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_vec4_h
#define cglmc_vec4_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
#define glmc_vec4_dup(v, dest) glmc_vec4_copy(v, dest)
#define glmc_vec4_flipsign(v) glmc_vec4_negate(v)
#define glmc_vec4_flipsign_to(v, dest) glmc_vec4_negate_to(v, dest)
#define glmc_vec4_inv(v) glmc_vec4_negate(v)
#define glmc_vec4_inv_to(v, dest) glmc_vec4_negate_to(v, dest)
CGLM_EXPORT
void
glmc_vec4(vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_zero(vec4 v);
CGLM_EXPORT
void
glmc_vec4_one(vec4 v);
CGLM_EXPORT
void
glmc_vec4_copy3(vec4 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_copy(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_ucopy(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_dot(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_norm(vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm2(vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_one(vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_inf(vec4 v);
CGLM_EXPORT
void
glmc_vec4_normalize_to(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_normalize(vec4 v);
CGLM_EXPORT
void
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_adds(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
glmc_vec4_scale(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_divs(vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_negate(vec4 v);
CGLM_EXPORT
void
glmc_vec4_negate_to(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_distance(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_distance2(vec4 a, vec4 b);
CGLM_EXPORT
void
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
CGLM_INLINE
void
glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
glmc_vec4_lerp(from, to, t, dest);
}
CGLM_INLINE
void
glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
glmc_vec4_lerpc(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_vec4_step_uni(float edge, vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_cubic(float s, vec4 dest);
/* ext */
CGLM_EXPORT
void
glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
glmc_vec4_broadcast(float val, vec4 d);
CGLM_EXPORT
void
glmc_vec4_fill(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_eps(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_all(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_eqv(vec4 a, vec4 b);
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(vec4 a, vec4 b);
CGLM_EXPORT
float
glmc_vec4_max(vec4 v);
CGLM_EXPORT
float
glmc_vec4_min(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isnan(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isinf(vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isvalid(vec4 v);
CGLM_EXPORT
void
glmc_vec4_sign(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_abs(vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_fract(vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_hadd(vec4 v);
CGLM_EXPORT
void
glmc_vec4_sqrt(vec4 v, vec4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_vec4_h */
include/cglm/cam.h
+582
View File
@@ -0,0 +1,582 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_frustum(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_default(float aspect, mat4 dest)
CGLM_INLINE void glm_ortho_default_s(float aspect, float size, mat4 dest)
CGLM_INLINE void glm_perspective(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize(float aspect, mat4 proj)
CGLM_INLINE void glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_persp_decomp(mat4 proj,
float *nearZ, float *farZ,
float *top, float *bottom,
float *left, float *right)
CGLM_INLINE void glm_persp_decompv(mat4 proj, float dest[6])
CGLM_INLINE void glm_persp_decomp_x(mat4 proj, float *left, float *right)
CGLM_INLINE void glm_persp_decomp_y(mat4 proj, float *top, float *bottom)
CGLM_INLINE void glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float *farZ)
CGLM_INLINE void glm_persp_decomp_near(mat4 proj, float *nearZ)
CGLM_INLINE float glm_persp_fovy(mat4 proj)
CGLM_INLINE float glm_persp_aspect(mat4 proj)
CGLM_INLINE void glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_cam_h
#define cglm_cam_h
#include "common.h"
#include "plane.h"
#include "clipspace/persp.h"
#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
# if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
# include "clipspace/ortho_lh_zo.h"
# include "clipspace/persp_lh_zo.h"
# include "clipspace/view_lh_zo.h"
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
# include "clipspace/ortho_lh_no.h"
# include "clipspace/persp_lh_no.h"
# include "clipspace/view_lh_no.h"
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
# include "clipspace/ortho_rh_zo.h"
# include "clipspace/persp_rh_zo.h"
# include "clipspace/view_rh_zo.h"
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
# include "clipspace/ortho_rh_no.h"
# include "clipspace/persp_rh_no.h"
# include "clipspace/view_rh_no.h"
# endif
#else
# include "clipspace/ortho_lh_zo.h"
# include "clipspace/persp_lh_zo.h"
# include "clipspace/ortho_lh_no.h"
# include "clipspace/persp_lh_no.h"
# include "clipspace/ortho_rh_zo.h"
# include "clipspace/persp_rh_zo.h"
# include "clipspace/ortho_rh_no.h"
# include "clipspace/persp_rh_no.h"
# include "clipspace/view_lh_zo.h"
# include "clipspace/view_lh_no.h"
# include "clipspace/view_rh_zo.h"
# include "clipspace/view_rh_no.h"
#endif
/*!
* @brief set up perspective peprojection matrix
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_frustum(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_frustum_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_frustum_lh_no(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_frustum_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_frustum_rh_no(left, right, bottom, top, nearZ, farZ, dest);
#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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_lh_zo(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_lh_no(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_rh_zo(left, right, bottom, top, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_rh_no(left, right, bottom, top, nearZ, farZ, dest);
#endif
}
/*!
* @brief set up orthographic projection matrix using bounding box
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb(vec3 box[2], mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_lh_zo(box, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_aabb_lh_no(box, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_aabb_rh_zo(box, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_aabb_rh_no(box, dest);
#endif
}
/*!
* @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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_p_lh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_aabb_p_lh_no(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_aabb_p_rh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_aabb_p_rh_no(box, padding, dest);
#endif
}
/*!
* @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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_pz_lh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_aabb_pz_lh_no(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_aabb_pz_rh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_aabb_pz_rh_no(box, padding, dest);
#endif
}
/*!
* @brief set up unit orthographic projection matrix
*
* @param[in] aspect aspect ration ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default(float aspect, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_default_lh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_default_lh_no(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_default_rh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_default_rh_no(aspect, dest);
#endif
}
/*!
* @brief set up orthographic projection matrix with given CUBE size
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in] size cube size
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_s(float aspect, float size, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_default_s_lh_zo(aspect, size, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_ortho_default_s_lh_no(aspect, size, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_ortho_default_s_rh_zo(aspect, size, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_ortho_default_s_rh_no(aspect, size, dest);
#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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_perspective_lh_zo(fovy, aspect, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_perspective_lh_no(fovy, aspect, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_perspective_rh_zo(fovy, aspect, nearZ, farZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_perspective_rh_no(fovy, aspect, nearZ, farZ, dest);
#endif
}
/*!
* @brief extend perspective projection matrix's far distance
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far(mat4 proj, float deltaFar) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_move_far_lh_zo(proj, deltaFar);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_move_far_lh_no(proj, deltaFar);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_move_far_rh_zo(proj, deltaFar);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_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 )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default(float aspect, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_perspective_default_lh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_perspective_default_lh_no(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_perspective_default_rh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_perspective_default_rh_no(aspect, dest);
#endif
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
* reized
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in, out] proj perspective projection matrix
*/
CGLM_INLINE
void
glm_perspective_resize(float aspect, mat4 proj) {
if (proj[0][0] == 0.0f)
return;
proj[0][0] = proj[1][1] / aspect;
}
/*!
* @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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_lookat_lh(eye, center, up, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
glm_lookat_rh(eye, center, up, dest);
#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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_look_lh(eye, dir, up, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
glm_look_rh(eye, dir, up, dest);
#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
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_look_anyup_lh(eye, dir, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
glm_look_anyup_rh(eye, dir, dest);
#endif
}
/*!
* @brief decomposes frustum values of perspective projection.
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
* @param[out] top top
* @param[out] bottom bottom
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp(mat4 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
glm_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_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
glm_persp_decompv(mat4 proj, float dest[6]) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decompv_lh_zo(proj, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decompv_lh_no(proj, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decompv_rh_zo(proj, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_persp_decompv_rh_no(proj, dest);
#endif
}
/*!
* @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
glm_persp_decomp_x(mat4 proj,
float * __restrict left,
float * __restrict right) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_x_lh_zo(proj, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_x_lh_no(proj, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_x_rh_zo(proj, left, right);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_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
glm_persp_decomp_y(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_y_lh_zo(proj, top, bottom);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_y_lh_no(proj, top, bottom);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_y_rh_zo(proj, top, bottom);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_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
glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_z_lh_no(proj, nearZ, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_z_rh_zo(proj, nearZ, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_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
glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_far_lh_zo(proj, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_far_lh_no(proj, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_far_rh_zo(proj, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_persp_decomp_far_rh_no(proj, farZ);
#endif
}
/*!
* @brief decomposes near value of perspective projection.
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
*/
CGLM_INLINE
void
glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_near_lh_zo(proj, nearZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_decomp_near_lh_no(proj, nearZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_decomp_near_rh_zo(proj, nearZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_persp_decomp_near_rh_no(proj, nearZ);
#endif
}
/*!
* @brief returns sizes of near and far planes of perspective projection
*
* @param[in] proj perspective projection matrix
* @param[in] fovy fovy (see brief)
* @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
*/
CGLM_INLINE
void
glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_sizes_lh_zo(proj, fovy, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_persp_sizes_lh_no(proj, fovy, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_persp_sizes_rh_zo(proj, fovy, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_persp_sizes_rh_no(proj, fovy, dest);
#endif
}
#endif /* cglm_cam_h */
include/cglm/cglm.h
+39
View File
@@ -0,0 +1,39 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_h
#define cglm_h
#include "common.h"
#include "vec2.h"
#include "vec3.h"
#include "vec4.h"
#include "ivec2.h"
#include "ivec3.h"
#include "ivec4.h"
#include "mat4.h"
#include "mat3.h"
#include "mat2.h"
#include "affine.h"
#include "cam.h"
#include "frustum.h"
#include "quat.h"
#include "euler.h"
#include "plane.h"
#include "box.h"
#include "color.h"
#include "util.h"
#include "io.h"
#include "project.h"
#include "sphere.h"
#include "ease.h"
#include "curve.h"
#include "bezier.h"
#include "ray.h"
#include "affine2d.h"
#endif /* cglm_h */
include/cglm/clipspace/ortho_lh_no.h
+183
View File
@@ -0,0 +1,183 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_ortho_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_no(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_lh_no(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_lh_no(float aspect,
mat4 dest)
CGLM_INLINE void glm_ortho_default_s_lh_no(float aspect,
float size,
mat4 dest)
*/
#ifndef cglm_ortho_lh_no_h
#define cglm_ortho_lh_no_h
#include "../common.h"
#include "../plane.h"
#include "../mat4.h"
/*!
* @brief set up orthographic projection matrix
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
dest[0][0] = 2.0f * rl;
dest[1][1] = 2.0f * tb;
dest[2][2] =-2.0f * fn;
dest[3][0] =-(right + left) * rl;
dest[3][1] =-(top + bottom) * tb;
dest[3][2] = (farZ + nearZ) * fn;
dest[3][3] = 1.0f;
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
glm_ortho_lh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_no(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding for near and far
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up unit orthographic projection matrix
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ration ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_lh_no(float aspect, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_lh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
return;
}
aspect = 1.0f / aspect;
glm_ortho_lh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
}
/*!
* @brief set up orthographic projection matrix with given CUBE size
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in] size cube size
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_s_lh_no(float aspect, float size, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_lh_no(-size * aspect,
size * aspect,
-size,
size,
-size - 100.0f,
size + 100.0f,
dest);
return;
}
glm_ortho_lh_no(-size,
size,
-size / aspect,
size / aspect,
-size - 100.0f,
size + 100.0f,
dest);
}
#endif /*cglm_ortho_lh_no_h*/
include/cglm/clipspace/ortho_lh_zo.h
+177
View File
@@ -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 void glm_ortho_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_zo(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_lh_zo(float aspect,
mat4 dest)
CGLM_INLINE void glm_ortho_default_s_lh_zo(float aspect,
float size,
mat4 dest)
*/
#ifndef cglm_ortho_lh_zo_h
#define cglm_ortho_lh_zo_h
#include "../common.h"
#include "../plane.h"
#include "../mat4.h"
/*!
* @brief set up orthographic projection matrix with a left-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
dest[0][0] = 2.0f * rl;
dest[1][1] = 2.0f * tb;
dest[2][2] =-fn;
dest[3][0] =-(right + left) * rl;
dest[3][1] =-(top + bottom) * tb;
dest[3][2] = nearZ * fn;
dest[3][3] = 1.0f;
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
glm_ortho_lh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_zo(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding for near and far
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up unit orthographic projection matrix
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* @param[in] aspect aspect ration ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_lh_zo(float aspect, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_lh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
return;
}
aspect = 1.0f / aspect;
glm_ortho_lh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
}
/*!
* @brief set up orthographic projection matrix with given CUBE size
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in] size cube size
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_s_lh_zo(float aspect, float size, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_lh_zo(-size * aspect,
size * aspect,
-size,
size,
-size - 100.0f,
size + 100.0f,
dest);
return;
}
glm_ortho_lh_zo(-size,
size,
-size / aspect,
size / aspect,
-size - 100.0f,
size + 100.0f,
dest);
}
#endif /*cglm_ortho_lh_zo_h*/
include/cglm/clipspace/ortho_rh_no.h
+183
View File
@@ -0,0 +1,183 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_ortho_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_no(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_rh_no(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_rh_no(float aspect,
mat4 dest)
CGLM_INLINE void glm_ortho_default_s_rh_no(float aspect,
float size,
mat4 dest)
*/
#ifndef cglm_ortho_rh_no_h
#define cglm_ortho_rh_no_h
#include "../common.h"
#include "../plane.h"
#include "../mat4.h"
/*!
* @brief set up orthographic projection matrix
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
dest[0][0] = 2.0f * rl;
dest[1][1] = 2.0f * tb;
dest[2][2] = 2.0f * fn;
dest[3][0] =-(right + left) * rl;
dest[3][1] =-(top + bottom) * tb;
dest[3][2] = (farZ + nearZ) * fn;
dest[3][3] = 1.0f;
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
glm_ortho_rh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_no(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding for near and far
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up unit orthographic projection matrix
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ration ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_rh_no(float aspect, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_rh_no(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
return;
}
aspect = 1.0f / aspect;
glm_ortho_rh_no(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
}
/*!
* @brief set up orthographic projection matrix with given CUBE size
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in] size cube size
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_s_rh_no(float aspect, float size, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_rh_no(-size * aspect,
size * aspect,
-size,
size,
-size - 100.0f,
size + 100.0f,
dest);
return;
}
glm_ortho_rh_no(-size,
size,
-size / aspect,
size / aspect,
-size - 100.0f,
size + 100.0f,
dest);
}
#endif /*cglm_ortho_rh_no_h*/
include/cglm/clipspace/ortho_rh_zo.h
+181
View File
@@ -0,0 +1,181 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_ortho_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
mat4 dest)
CGLM_INLINE void glm_ortho_default_s_rh_zo(float aspect,
float size,
mat4 dest)
*/
#ifndef cglm_ortho_rh_zo_h
#define cglm_ortho_rh_zo_h
#include "../common.h"
#include "../plane.h"
#include "../mat4.h"
/*!
* @brief set up orthographic projection matrix with a right-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
dest[0][0] = 2.0f * rl;
dest[1][1] = 2.0f * tb;
dest[2][2] = fn;
dest[3][0] =-(right + left) * rl;
dest[3][1] =-(top + bottom) * tb;
dest[3][2] = nearZ * fn;
dest[3][3] = 1.0f;
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a clip-space with depth
* values from zero to one.
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
glm_ortho_rh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a clip-space with depth
* values from zero to one.
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_zo(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up orthographic projection matrix using bounding box
* with a right-hand coordinate system and a clip-space with depth
* values from zero to one.
*
* bounding box (AABB) must be in view space
*
* @param[in] box AABB
* @param[in] padding padding for near and far
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
dest);
}
/*!
* @brief set up unit orthographic projection matrix with a right-hand
* coordinate system and a clip-space of [0, 1].
*
* @param[in] aspect aspect ration ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_rh_zo(float aspect, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_rh_zo(-aspect, aspect, -1.0f, 1.0f, -100.0f, 100.0f, dest);
return;
}
aspect = 1.0f / aspect;
glm_ortho_rh_zo(-1.0f, 1.0f, -aspect, aspect, -100.0f, 100.0f, dest);
}
/*!
* @brief set up orthographic projection matrix with given CUBE size
* with a right-hand coordinate system and a clip-space with depth
* values from zero to one.
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in] size cube size
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_ortho_default_s_rh_zo(float aspect, float size, mat4 dest) {
if (aspect >= 1.0f) {
glm_ortho_rh_zo(-size * aspect,
size * aspect,
-size,
size,
-size - 100.0f,
size + 100.0f,
dest);
return;
}
glm_ortho_rh_zo(-size,
size,
-size / aspect,
size / aspect,
-size - 100.0f,
size + 100.0f,
dest);
}
#endif /*cglm_ortho_rh_zo_h*/
include/cglm/clipspace/persp.h
+48
View File
@@ -0,0 +1,48 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float *farZ)
CGLM_INLINE float glm_persp_fovy(mat4 proj)
CGLM_INLINE float glm_persp_aspect(mat4 proj)
CGLM_INLINE void glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_h
#define cglm_persp_h
#include "../common.h"
#include "../plane.h"
#include "../mat4.h"
/*!
* @brief returns field of view angle along the Y-axis (in radians)
*
* if you need to degrees, use glm_deg to convert it or use this:
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_fovy(mat4 proj) {
return 2.0f * atanf(1.0f / proj[1][1]);
}
/*!
* @brief returns aspect ratio of perspective projection
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_aspect(mat4 proj) {
return proj[1][1] / proj[0][0];
}
#endif /* cglm_persp_h */
include/cglm/clipspace/persp_lh_no.h
+395
View File
@@ -0,0 +1,395 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_frustum_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_lh_no(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_lh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
float * __restrict bottom,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decompv_lh_no(mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_lh_no_h
#define cglm_persp_lh_no_h
#include "../common.h"
#include "persp.h"
/*!
* @brief set up perspective peprojection matrix
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_frustum_lh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn, nv;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
nv = 2.0f * nearZ;
dest[0][0] = nv * rl;
dest[1][1] = nv * tb;
dest[2][0] = (right + left) * rl;
dest[2][1] = (top + bottom) * tb;
dest[2][2] =-(farZ + nearZ) * fn;
dest[2][3] = 1.0f;
dest[3][2] = farZ * nv * fn;
}
/*!
* @brief set up perspective projection matrix
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping planes
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_lh_no(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest) {
float f, fn;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
fn = 1.0f / (nearZ - farZ);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] =-(nearZ + farZ) * fn;
dest[2][3] = 1.0f;
dest[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_lh_no(float aspect, mat4 dest) {
glm_perspective_lh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
* resized with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in, out] proj perspective projection matrix
*/
CGLM_INLINE
void
glm_perspective_resize_lh_no(float aspect, mat4 proj) {
if (proj[0][0] == 0.0f)
return;
proj[0][0] = proj[1][1] / aspect;
}
/*!
* @brief extend perspective projection matrix's far distance
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
float fn, farZ, nearZ, p22, p32;
p22 = -proj[2][2];
p32 = proj[3][2];
nearZ = p32 / (p22 - 1.0f);
farZ = p32 / (p22 + 1.0f) + deltaFar;
fn = 1.0f / (nearZ - farZ);
proj[2][2] = -(farZ + nearZ) * fn;
proj[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief decomposes frustum values of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
* @param[out] top top
* @param[out] bottom bottom
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_lh_no(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right) {
float m00, m11, m20, m21, m22, m32, n, f;
float n_m11, n_m00;
m00 = proj[0][0];
m11 = proj[1][1];
m20 = proj[2][0];
m21 = proj[2][1];
m22 =-proj[2][2];
m32 = proj[3][2];
n = m32 / (m22 - 1.0f);
f = m32 / (m22 + 1.0f);
n_m11 = n / m11;
n_m00 = n / m00;
*nearZ = n;
*farZ = f;
*bottom = n_m11 * (m21 - 1.0f);
*top = n_m11 * (m21 + 1.0f);
*left = n_m00 * (m20 - 1.0f);
*right = n_m00 * (m20 + 1.0f);
}
/*!
* @brief decomposes frustum values of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
* this makes easy to get all values at once
*
* @param[in] proj perspective projection matrix
* @param[out] dest array
*/
CGLM_INLINE
void
glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
/*!
* @brief decomposes left and right values of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
* x stands for x axis (left / right axis)
*
* @param[in] proj perspective projection matrix
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_x_lh_no(mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
m00 = proj[0][0];
m20 = proj[2][0];
m22 =-proj[2][2];
nearZ = proj[3][2] / (m22 - 1.0f);
*left = nearZ * (m20 - 1.0f) / m00;
*right = nearZ * (m20 + 1.0f) / m00;
}
/*!
* @brief decomposes top and bottom values of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
* y stands for y axis (top / botom axis)
*
* @param[in] proj perspective projection matrix
* @param[out] top top
* @param[out] bottom bottom
*/
CGLM_INLINE
void
glm_persp_decomp_y_lh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
m21 = proj[2][1];
m11 = proj[1][1];
m22 =-proj[2][2];
nearZ = proj[3][2] / (m22 - 1.0f);
*bottom = nearZ * (m21 - 1.0f) / m11;
*top = nearZ * (m21 + 1.0f) / m11;
}
/*!
* @brief decomposes near and far values of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
* z stands for z axis (near / far axis)
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_z_lh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
m32 = proj[3][2];
m22 =-proj[2][2];
*nearZ = m32 / (m22 - 1.0f);
*farZ = m32 / (m22 + 1.0f);
}
/*!
* @brief decomposes far value of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
}
/*!
* @brief decomposes near value of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
*/
CGLM_INLINE
void
glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
}
/*!
* @brief returns sizes of near and far planes of perspective projection
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[in] fovy fovy (see brief)
* @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
*/
CGLM_INLINE
void
glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
a = glm_persp_aspect(proj);
glm_persp_decomp_z_lh_no(proj, &nearZ, &farZ);
dest[1] = t * nearZ;
dest[3] = t * farZ;
dest[0] = a * dest[1];
dest[2] = a * dest[3];
}
/*!
* @brief returns field of view angle along the Y-axis (in radians)
* with a left-hand coordinate system and a clip-space of [-1, 1].
*
* if you need to degrees, use glm_deg to convert it or use this:
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_fovy_lh_no(mat4 proj) {
return glm_persp_fovy(proj);
}
/*!
* @brief returns aspect ratio of perspective projection
* with a left-hand coordinate system and a clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_aspect_lh_no(mat4 proj) {
return glm_persp_aspect(proj);
}
#endif /*cglm_cam_lh_no_h*/
include/cglm/clipspace/persp_lh_zo.h
+387
View File
@@ -0,0 +1,387 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_frustum_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_lh_zo(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_lh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
float * __restrict bottom,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_lh_zo_h
#define cglm_persp_lh_zo_h
#include "../common.h"
#include "persp.h"
/*!
* @brief set up perspective peprojection matrix with a left-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_frustum_lh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn, nv;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
nv = 2.0f * nearZ;
dest[0][0] = nv * rl;
dest[1][1] = nv * tb;
dest[2][0] = (right + left) * rl;
dest[2][1] = (top + bottom) * tb;
dest[2][2] =-farZ * fn;
dest[2][3] = 1.0f;
dest[3][2] = farZ * nearZ * fn;
}
/*!
* @brief set up perspective projection matrix with a left-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping planes
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_lh_zo(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest) {
float f, fn;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
fn = 1.0f / (nearZ - farZ);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] =-farZ * fn;
dest[2][3] = 1.0f;
dest[3][2] = nearZ * farZ * fn;
}
/*!
* @brief extend perspective projection matrix's far distance with a
* left-hand coordinate system and a clip-space with depth values
* from zero to one.
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
float fn, farZ, nearZ, p22, p32;
p22 = -proj[2][2];
p32 = proj[3][2];
nearZ = p32 / p22;
farZ = p32 / (p22 + 1.0f) + deltaFar;
fn = 1.0f / (nearZ - farZ);
proj[2][2] = -farZ * fn;
proj[3][2] = nearZ * farZ * fn;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_lh_zo(float aspect, mat4 dest) {
glm_perspective_lh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
* reized
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in, out] proj perspective projection matrix
*/
CGLM_INLINE
void
glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
if (proj[0][0] == 0.0f)
return;
proj[0][0] = proj[1][1] / aspect;
}
/*!
* @brief decomposes frustum values of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
* @param[out] top top
* @param[out] bottom bottom
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_lh_zo(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right) {
float m00, m11, m20, m21, m22, m32, n, f;
float n_m11, n_m00;
m00 = proj[0][0];
m11 = proj[1][1];
m20 = proj[2][0];
m21 = proj[2][1];
m22 =-proj[2][2];
m32 = proj[3][2];
n = m32 / m22;
f = m32 / (m22 + 1.0f);
n_m11 = n / m11;
n_m00 = n / m00;
*nearZ = n;
*farZ = f;
*bottom = n_m11 * (m21 - 1.0f);
*top = n_m11 * (m21 + 1.0f);
*left = n_m00 * (m20 - 1.0f);
*right = n_m00 * (m20 + 1.0f);
}
/*!
* @brief decomposes frustum values of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
* this makes easy to get all values at once
*
* @param[in] proj perspective projection matrix
* @param[out] dest array
*/
CGLM_INLINE
void
glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
/*!
* @brief decomposes left and right values of perspective projection (ZO).
* x stands for x axis (left / right axis)
*
* @param[in] proj perspective projection matrix
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_x_lh_zo(mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00;
m00 = proj[0][0];
m20 = proj[2][0];
nearZ = proj[3][2] / (proj[3][3]);
*left = nearZ * (m20 - 1.0f) / m00;
*right = nearZ * (m20 + 1.0f) / m00;
}
/*!
* @brief decomposes top and bottom values of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
* y stands for y axis (top / bottom axis)
*
* @param[in] proj perspective projection matrix
* @param[out] top top
* @param[out] bottom bottom
*/
CGLM_INLINE
void
glm_persp_decomp_y_lh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11;
m21 = proj[2][1];
m11 = proj[1][1];
nearZ = proj[3][2] / (proj[3][3]);
*bottom = nearZ * (m21 - 1) / m11;
*top = nearZ * (m21 + 1) / m11;
}
/*!
* @brief decomposes near and far values of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
* z stands for z axis (near / far axis)
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_z_lh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
m32 = proj[3][2];
m22 = -proj[2][2];
*nearZ = m32 / m22;
*farZ = m32 / (m22 + 1.0f);
}
/*!
* @brief decomposes far value of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
}
/*!
* @brief decomposes near value of perspective projection
* with angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
*/
CGLM_INLINE
void
glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / -proj[2][2];
}
/*!
* @brief returns sizes of near and far planes of perspective projection
* with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
* @param[in] fovy fovy (see brief)
* @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
*/
CGLM_INLINE
void
glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
a = glm_persp_aspect(proj);
glm_persp_decomp_z_lh_zo(proj, &nearZ, &farZ);
dest[1] = t * nearZ;
dest[3] = t * farZ;
dest[0] = a * dest[1];
dest[2] = a * dest[3];
}
/*!
* @brief returns field of view angle along the Y-axis (in radians)
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* if you need to degrees, use glm_deg to convert it or use this:
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_fovy_lh_zo(mat4 proj) {
return glm_persp_fovy(proj);
}
/*!
* @brief returns aspect ratio of perspective projection
* with a left-hand coordinate system and a clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_aspect_lh_zo(mat4 proj) {
return glm_persp_aspect(proj);
}
#endif /*cglm_persp_lh_zo_h*/
include/cglm/clipspace/persp_rh_no.h
+395
View File
@@ -0,0 +1,395 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_frustum_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_rh_no(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_rh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
float * __restrict bottom,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decompv_rh_no(mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_rh_no_h
#define cglm_persp_rh_no_h
#include "../common.h"
#include "persp.h"
/*!
* @brief set up perspective peprojection matrix
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_frustum_rh_no(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn, nv;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
nv = 2.0f * nearZ;
dest[0][0] = nv * rl;
dest[1][1] = nv * tb;
dest[2][0] = (right + left) * rl;
dest[2][1] = (top + bottom) * tb;
dest[2][2] = (farZ + nearZ) * fn;
dest[2][3] =-1.0f;
dest[3][2] = farZ * nv * fn;
}
/*!
* @brief set up perspective projection matrix
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping planes
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_rh_no(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest) {
float f, fn;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
fn = 1.0f / (nearZ - farZ);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] = (nearZ + farZ) * fn;
dest[2][3] =-1.0f;
dest[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_rh_no(float aspect, mat4 dest) {
glm_perspective_rh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
* resized with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in, out] proj perspective projection matrix
*/
CGLM_INLINE
void
glm_perspective_resize_rh_no(float aspect, mat4 proj) {
if (proj[0][0] == 0.0f)
return;
proj[0][0] = proj[1][1] / aspect;
}
/*!
* @brief extend perspective projection matrix's far distance
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
float fn, farZ, nearZ, p22, p32;
p22 = proj[2][2];
p32 = proj[3][2];
nearZ = p32 / (p22 - 1.0f);
farZ = p32 / (p22 + 1.0f) + deltaFar;
fn = 1.0f / (nearZ - farZ);
proj[2][2] = (farZ + nearZ) * fn;
proj[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief decomposes frustum values of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
* @param[out] top top
* @param[out] bottom bottom
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_rh_no(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right) {
float m00, m11, m20, m21, m22, m32, n, f;
float n_m11, n_m00;
m00 = proj[0][0];
m11 = proj[1][1];
m20 = proj[2][0];
m21 = proj[2][1];
m22 = proj[2][2];
m32 = proj[3][2];
n = m32 / (m22 - 1.0f);
f = m32 / (m22 + 1.0f);
n_m11 = n / m11;
n_m00 = n / m00;
*nearZ = n;
*farZ = f;
*bottom = n_m11 * (m21 - 1.0f);
*top = n_m11 * (m21 + 1.0f);
*left = n_m00 * (m20 - 1.0f);
*right = n_m00 * (m20 + 1.0f);
}
/*!
* @brief decomposes frustum values of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
* this makes easy to get all values at once
*
* @param[in] proj perspective projection matrix
* @param[out] dest array
*/
CGLM_INLINE
void
glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
/*!
* @brief decomposes left and right values of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
* x stands for x axis (left / right axis)
*
* @param[in] proj perspective projection matrix
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_x_rh_no(mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
m00 = proj[0][0];
m20 = proj[2][0];
m22 = proj[2][2];
nearZ = proj[3][2] / (m22 - 1.0f);
*left = nearZ * (m20 - 1.0f) / m00;
*right = nearZ * (m20 + 1.0f) / m00;
}
/*!
* @brief decomposes top and bottom values of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
* y stands for y axis (top / botom axis)
*
* @param[in] proj perspective projection matrix
* @param[out] top top
* @param[out] bottom bottom
*/
CGLM_INLINE
void
glm_persp_decomp_y_rh_no(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
m21 = proj[2][1];
m11 = proj[1][1];
m22 = proj[2][2];
nearZ = proj[3][2] / (m22 - 1.0f);
*bottom = nearZ * (m21 - 1.0f) / m11;
*top = nearZ * (m21 + 1.0f) / m11;
}
/*!
* @brief decomposes near and far values of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
* z stands for z axis (near / far axis)
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_z_rh_no(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
m32 = proj[3][2];
m22 = proj[2][2];
*nearZ = m32 / (m22 - 1.0f);
*farZ = m32 / (m22 + 1.0f);
}
/*!
* @brief decomposes far value of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (proj[2][2] + 1.0f);
}
/*!
* @brief decomposes near value of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
*/
CGLM_INLINE
void
glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / (proj[2][2] - 1.0f);
}
/*!
* @brief returns sizes of near and far planes of perspective projection
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
* @param[in] fovy fovy (see brief)
* @param[out] dest sizes order: [Wnear, Hnear, Wfar, Hfar]
*/
CGLM_INLINE
void
glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
a = glm_persp_aspect(proj);
glm_persp_decomp_z_rh_no(proj, &nearZ, &farZ);
dest[1] = t * nearZ;
dest[3] = t * farZ;
dest[0] = a * dest[1];
dest[2] = a * dest[3];
}
/*!
* @brief returns field of view angle along the Y-axis (in radians)
* with a right-hand coordinate system and a clip-space of [-1, 1].
*
* if you need to degrees, use glm_deg to convert it or use this:
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_fovy_rh_no(mat4 proj) {
return glm_persp_fovy(proj);
}
/*!
* @brief returns aspect ratio of perspective projection
* with a right-hand coordinate system and a clip-space of [-1, 1].
*
* @param[in] proj perspective projection matrix
*/
CGLM_INLINE
float
glm_persp_aspect_rh_no(mat4 proj) {
return glm_persp_aspect(proj);
}
#endif /*cglm_cam_rh_no_h*/
include/cglm/clipspace/persp_rh_zo.h
+389
View File
@@ -0,0 +1,389 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
/*
Functions:
CGLM_INLINE void glm_frustum_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_rh_zo(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_rh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
float * __restrict bottom,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_rh_zo_h
#define cglm_persp_rh_zo_h
#include "../common.h"
#include "persp.h"
/*!
* @brief set up perspective peprojection matrix with a right-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] left viewport.left
* @param[in] right viewport.right
* @param[in] bottom viewport.bottom
* @param[in] top viewport.top
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_frustum_rh_zo(float left, float right,
float bottom, float top,
float nearZ, float farZ,
mat4 dest) {
float rl, tb, fn, nv;
glm_mat4_zero(dest);
rl = 1.0f / (right - left);
tb = 1.0f / (top - bottom);
fn =-1.0f / (farZ - nearZ);
nv = 2.0f * nearZ;
dest[0][0] = nv * rl;
dest[1][1] = nv * tb;
dest[2][0] = (right + left) * rl;
dest[2][1] = (top + bottom) * tb;
dest[2][2] = farZ * fn;
dest[2][3] =-1.0f;
dest[3][2] = farZ * nearZ * fn;
}
/*!
* @brief set up perspective projection matrix with a right-hand coordinate
* system and a clip-space of [0, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[in] farZ far clipping planes
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_rh_zo(float fovy,
float aspect,
float nearZ,
float farZ,
mat4 dest) {
float f, fn;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
fn = 1.0f / (nearZ - farZ);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] = farZ * fn;
dest[2][3] =-1.0f;
dest[3][2] = nearZ * farZ * fn;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_rh_zo(float aspect, mat4 dest) {
glm_perspective_rh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
* resized with a right-hand coordinate system and a clip-space of
* [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[in, out] proj perspective projection matrix
*/
CGLM_INLINE
void
glm_perspective_resize_rh_zo(float aspect, mat4 proj) {
if (proj[0][0] == 0.0f)
return;
proj[0][0] = proj[1][1] / aspect;
}
/*!
* @brief extend perspective projection matrix's far distance with a
* right-hand coordinate system and a clip-space of [0, 1].
*
* this function does not guarantee far >= near, be aware of that!
*
* @param[in, out] proj projection matrix to extend
* @param[in] deltaFar distance from existing far (negative to shink)
*/
CGLM_INLINE
void
glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
float fn, farZ, nearZ, p22, p32;
p22 = proj[2][2];
p32 = proj[3][2];
nearZ = p32 / p22;
farZ = p32 / (p22 + 1.0f) + deltaFar;
fn = 1.0f / (nearZ - farZ);
proj[2][2] = farZ * fn;
proj[3][2] = nearZ * farZ * fn;
}
/*!
* @brief decomposes frustum values of perspective projection
* with angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
* @param[out] top top
* @param[out] bottom bottom
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_rh_zo(mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right) {
float m00, m11, m20, m21, m22, m32, n, f;
float n_m11, n_m00;
m00 = proj[0][0];
m11 = proj[1][1];
m20 = proj[2][0];
m21 = proj[2][1];
m22 = proj[2][2];
m32 = proj[3][2];
n = m32 / m22;
f = m32 / (m22 + 1.0f);
n_m11 = n / m11;
n_m00 = n / m00;
*nearZ = n;
*farZ = f;
*bottom = n_m11 * (m21 - 1.0f);
*top = n_m11 * (m21 + 1.0f);
*left = n_m00 * (m20 - 1.0f);
*right = n_m00 * (m20 + 1.0f);
}
/*!
* @brief decomposes frustum values of perspective projection
* with angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
* this makes easy to get all values at once
*
* @param[in] proj perspective projection matrix
* @param[out] dest array
*/
CGLM_INLINE
void
glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
/*!
* @brief decomposes left and right values of perspective projection (ZO).
* x stands for x axis (left / right axis)
*
* @param[in] proj perspective projection matrix
* @param[out] left left
* @param[out] right right
*/
CGLM_INLINE
void
glm_persp_decomp_x_rh_zo(mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
m00 = proj[0][0];
m20 = proj[2][0];
m22 = proj[2][2];
nearZ = proj[3][2] / m22;
*left = nearZ * (m20 - 1.0f) / m00;
*right = nearZ * (m20 + 1.0f) / m00;
}
/*!
* @brief decomposes top and bottom values of perspective projection
* with angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
* y stands for y axis (top / bottom axis)
*
* @param[in] proj perspective projection matrix
* @param[out] top top
* @param[out] bottom bottom
*/
CGLM_INLINE
void
glm_persp_decomp_y_rh_zo(mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
m21 = proj[2][1];
m11 = proj[1][1];
m22 = proj[2][2];
nearZ = proj[3][2] / m22;
*bottom = nearZ * (m21 - 1) / m11;
*top = nearZ * (m21 + 1) / m11;
}
/*!
* @brief decomposes near and far values of perspective projection
* with angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
* z stands for z axis (near / far axis)
*
* @param[in] proj perspective projection matrix
* @param[out] nearZ near
* @param[out] farZ far
*/
CGLM_INLINE
void
glm_persp_decomp_z_rh_zo(mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
m32 = proj[3][2];
m22 = proj[2][2];
*nearZ = m32 / m22;