first commit
This commit is contained in:
dox
184
include/cglm/struct/affine-post.h
Normal file
184
include/cglm/struct/affine-post.h
Normal file
@ -0,0 +1,184 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_translated(mat4s m, vec3s v);
|
||||
CGLM_INLINE mat4s glms_translated_x(mat4s m, float x);
|
||||
CGLM_INLINE mat4s glms_translated_y(mat4s m, float y);
|
||||
CGLM_INLINE mat4s glms_translated_z(mat4s m, float z);
|
||||
CGLM_INLINE mat4s glms_rotated_x(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotated_y(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotated_z(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotated(mat4s m, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_spinned(mat4s m, float angle, vec3s axis);
|
||||
*/
|
||||
|
||||
#ifndef cglms_affines_post_h
|
||||
#define cglms_affines_post_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../affine.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by v vector
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] v translate vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translated(mat4s m, vec3s v) {
|
||||
glm_translated(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by x factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] x x factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translated_x(mat4s m, float x) {
|
||||
glm_translated_x(m.raw, x);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by y factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] y y factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translated_y(mat4s m, float y) {
|
||||
glm_translated_y(m.raw, y);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by z factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] z z factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translated_z(mat4s m, float z) {
|
||||
glm_translated_z(m.raw, z);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around X axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotated_x(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotated_x(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around Y axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotated_y(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotated_y(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around Z axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotated_z(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotated_z(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around given axis by angle
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotated(mat4s m, float angle, vec3s axis) {
|
||||
glm_rotated(m.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform
|
||||
* around given axis by angle at given pivot point (rotation center)
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] pivot rotation center
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotated_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
|
||||
glm_rotated_at(m.raw, pivot.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_spinned(mat4s m, float angle, vec3s axis) {
|
||||
glm_spinned(m.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
#endif /* cglms_affines_post_h */
|
||||
184
include/cglm/struct/affine-pre.h
Normal file
184
include/cglm/struct/affine-pre.h
Normal file
@ -0,0 +1,184 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_translate(mat4s m, vec3s v);
|
||||
CGLM_INLINE mat4s glms_translate_x(mat4s m, float x);
|
||||
CGLM_INLINE mat4s glms_translate_y(mat4s m, float y);
|
||||
CGLM_INLINE mat4s glms_translate_z(mat4s m, float z);
|
||||
CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate(mat4s m, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_spin(mat4s m, float angle, vec3s axis);
|
||||
*/
|
||||
|
||||
#ifndef cglms_affines_pre_h
|
||||
#define cglms_affines_pre_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../affine.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by v vector
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] v translate vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translate(mat4s m, vec3s v) {
|
||||
glm_translate(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by x factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] x x factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translate_x(mat4s m, float x) {
|
||||
glm_translate_x(m.raw, x);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by y factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] y y factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translate_y(mat4s m, float y) {
|
||||
glm_translate_y(m.raw, y);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing transform matrix by z factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] z z factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translate_z(mat4s m, float z) {
|
||||
glm_translate_z(m.raw, z);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around X axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_x(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotate_x(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around Y axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_y(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotate_y(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around Z axis by angle
|
||||
* and store result in dest
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns rotated matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_z(mat4s m, float angle) {
|
||||
mat4s r;
|
||||
glm_rotate_z(m.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around given axis by angle
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate(mat4s m, float angle, vec3s axis) {
|
||||
glm_rotate(m.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform
|
||||
* around given axis by angle at given pivot point (rotation center)
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] pivot rotation center
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis) {
|
||||
glm_rotate_at(m.raw, pivot.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix around given axis by angle around self (doesn't affected by position)
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_spin(mat4s m, float angle, vec3s axis) {
|
||||
glm_spin(m.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
#endif /* cglms_affines_pre_h */
|
||||
200
include/cglm/struct/affine.h
Normal file
200
include/cglm/struct/affine.h
Normal file
@ -0,0 +1,200 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_translate(mat4s m, vec3s v);
|
||||
CGLM_INLINE mat4s glms_translate_x(mat4s m, float x);
|
||||
CGLM_INLINE mat4s glms_translate_y(mat4s m, float y);
|
||||
CGLM_INLINE mat4s glms_translate_z(mat4s m, float z);
|
||||
CGLM_INLINE mat4s glms_translate_make(vec3s v);
|
||||
CGLM_INLINE mat4s glms_scale_to(mat4s m, vec3s v);
|
||||
CGLM_INLINE mat4s glms_scale_make(vec3s v);
|
||||
CGLM_INLINE mat4s glms_scale(mat4s m, vec3s v);
|
||||
CGLM_INLINE mat4s glms_scale_uni(mat4s m, float s);
|
||||
CGLM_INLINE mat4s glms_rotate_x(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate_y(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate_z(mat4s m, float angle);
|
||||
CGLM_INLINE mat4s glms_rotate_make(float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_rotate(mat4s m, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_rotate_at(mat4s m, vec3s pivot, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis);
|
||||
CGLM_INLINE mat4s glms_spin(mat4s m, float angle, vec3s axis);
|
||||
CGLM_INLINE vec3s glms_decompose_scalev(mat4s m);
|
||||
CGLM_INLINE bool glms_uniscaled(mat4s m);
|
||||
CGLM_INLINE void glms_decompose_rs(mat4s m, mat4s * r, vec3s * s);
|
||||
CGLM_INLINE void glms_decompose(mat4s m, vec4s t, mat4s * r, vec3s * s);
|
||||
*/
|
||||
|
||||
#ifndef cglms_affines_h
|
||||
#define cglms_affines_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../affine.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief creates NEW translate transform matrix by v vector
|
||||
*
|
||||
* @param[in] v translate vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_translate_make(vec3s v) {
|
||||
mat4s m;
|
||||
glm_translate_make(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW scale matrix by v vector
|
||||
*
|
||||
* @param[in] v scale vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_scale_make(vec3s v) {
|
||||
mat4s m;
|
||||
glm_scale_make(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scales existing transform matrix by v vector
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] v scale vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_scale(mat4s m, vec3s v) {
|
||||
mat4s r;
|
||||
glm_scale_to(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief applies uniform scale to existing transform matrix v = [s, s, s]
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] s scale factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_scale_uni(mat4s m, float s) {
|
||||
glm_scale_uni(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW rotation matrix by angle and axis
|
||||
*
|
||||
* axis will be normalized so you don't need to normalize it
|
||||
*
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_make(float angle, vec3s axis) {
|
||||
mat4s m;
|
||||
glm_rotate_make(m.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW rotation matrix by angle and axis at given point
|
||||
*
|
||||
* this creates rotation matrix, it assumes you don't have a matrix
|
||||
*
|
||||
* this should work faster than glm_rotate_at because it reduces
|
||||
* one glm_translate.
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] pivot rotation center
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_rotate_atm(mat4s m, vec3s pivot, float angle, vec3s axis) {
|
||||
glm_rotate_atm(m.raw, pivot.raw, angle, axis.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decompose scale vector
|
||||
*
|
||||
* @param[in] m affine transform
|
||||
* @returns scale vector (Sx, Sy, Sz)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_decompose_scalev(mat4s m) {
|
||||
vec3s r;
|
||||
glm_decompose_scalev(m.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns true if matrix is uniform scaled. This is helpful for
|
||||
* creating normal matrix.
|
||||
*
|
||||
* @param[in] m m
|
||||
*
|
||||
* @return boolean
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_uniscaled(mat4s m) {
|
||||
return glm_uniscaled(m.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decompose rotation matrix (mat4) and scale vector [Sx, Sy, Sz]
|
||||
* DON'T pass projected matrix here
|
||||
*
|
||||
* @param[in] m affine transform
|
||||
* @param[out] r rotation matrix
|
||||
* @param[out] s scale matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_decompose_rs(mat4s m, mat4s * __restrict r, vec3s * __restrict s) {
|
||||
glm_decompose_rs(m.raw, r->raw, s->raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decompose affine transform, TODO: extract shear factors.
|
||||
* DON'T pass projected matrix here
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[out] t translation vector
|
||||
* @param[out] r rotation matrix (mat4)
|
||||
* @param[out] s scaling vector [X, Y, Z]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_decompose(mat4s m, vec4s * __restrict t, mat4s * __restrict r, vec3s * __restrict s) {
|
||||
glm_decompose(m.raw, t->raw, r->raw, s->raw);
|
||||
}
|
||||
|
||||
#include "affine-pre.h"
|
||||
#include "affine-post.h"
|
||||
|
||||
#endif /* cglms_affines_h */
|
||||
177
include/cglm/struct/affine2d.h
Normal file
177
include/cglm/struct/affine2d.h
Normal 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 mat3s glms_translate2d(mat3 m, vec2 v)
|
||||
CGLM_INLINE mat3s glms_translate2d_x(mat3s m, float x)
|
||||
CGLM_INLINE mat3s glms_translate2d_y(mat3s m, float y)
|
||||
CGLM_INLINE mat3s glms_translate2d_make(vec2s v)
|
||||
CGLM_INLINE mat3s glms_scale2d_make(vec2s v)
|
||||
CGLM_INLINE mat3s glms_scale2d(mat3s m, vec2s v)
|
||||
CGLM_INLINE mat3s glms_scale2d_uni(mat3s m, float s)
|
||||
CGLM_INLINE mat3s glms_rotate2d_make(float angle)
|
||||
CGLM_INLINE mat3s glms_rotate2d(mat3s m, float angle)
|
||||
CGLM_INLINE mat3s glms_rotate2d_to(mat3s m, float angle)
|
||||
*/
|
||||
|
||||
#ifndef cglms_affine2ds_h
|
||||
#define cglms_affine2ds_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../affine2d.h"
|
||||
#include "vec3.h"
|
||||
#include "mat3.h"
|
||||
|
||||
/*!
|
||||
* @brief translate existing 2d transform matrix by v vector
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] v translate vector [x, y]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_translate2d(mat3s m, vec2s v) {
|
||||
glm_translate2d(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing 2d transform matrix by x factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] x x factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_translate2d_x(mat3s m, float x) {
|
||||
glm_translate2d_x(m.raw, x);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief translate existing 2d transform matrix by y factor
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] y y factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_translate2d_y(mat3s m, float y) {
|
||||
glm_translate2d_y(m.raw, y);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW translate 2d transform matrix by v vector
|
||||
*
|
||||
* @param[in] v translate vector [x, y]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_translate2d_make(vec2s v) {
|
||||
mat3s m;
|
||||
glm_translate2d_make(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW 2d scale matrix by v vector
|
||||
*
|
||||
* @param[in] v scale vector [x, y]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_scale2d_make(vec2s v) {
|
||||
mat3s m;
|
||||
glm_scale2d_make(m.raw, v.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scales existing 2d transform matrix by v vector
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] v scale vector [x, y, z]
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_scale2d(mat3s m, vec2s v) {
|
||||
mat3s r;
|
||||
glm_scale2d_to(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief applies uniform scale to existing 2d transform matrix v = [s, s, s]
|
||||
* and stores result in same matrix
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] s scale factor
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_scale2d_uni(mat3s m, float s) {
|
||||
glm_scale2d_uni(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW 2d rotation matrix by angle and axis
|
||||
*
|
||||
* axis will be normalized so you don't need to normalize it
|
||||
*
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_rotate2d_make(float angle) {
|
||||
mat3s m;
|
||||
glm_rotate2d_make(m.raw, angle);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing 2d transform matrix around given axis by angle
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_rotate2d(mat3s m, float angle) {
|
||||
glm_rotate2d(m.raw, angle);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing 2d transform matrix around given axis by angle
|
||||
*
|
||||
* @param[in] m affine transfrom
|
||||
* @param[in] angle angle (radians)
|
||||
* @returns affine transfrom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_rotate2d_to(mat3s m, float angle) {
|
||||
glm_rotate2d(m.raw, angle);
|
||||
return m;
|
||||
}
|
||||
|
||||
#endif /* cglms_affine2ds_h */
|
||||
256
include/cglm/struct/box.h
Normal file
256
include/cglm/struct/box.h
Normal file
@ -0,0 +1,256 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_boxs_h
|
||||
#define cglms_boxs_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../box.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief apply transform to Axis-Aligned Bounding Box
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] m transform matrix
|
||||
* @param[out] dest transformed bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_transform(vec3s box[2], mat4s m, vec3s dest[2]) {
|
||||
vec3 rawBox[2];
|
||||
vec3 rawDest[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_aabb_transform(rawBox, m.raw, rawDest);
|
||||
glms_vec3_pack(dest, rawDest, 2);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief merges two AABB bounding box and creates new one
|
||||
*
|
||||
* two box must be in same space, if one of box is in different space then
|
||||
* you should consider to convert it's space by glm_box_space
|
||||
*
|
||||
* @param[in] box1 bounding box 1
|
||||
* @param[in] box2 bounding box 2
|
||||
* @param[out] dest merged bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_merge(vec3s box1[2], vec3s box2[2], vec3s dest[2]) {
|
||||
vec3 rawBox1[2];
|
||||
vec3 rawBox2[2];
|
||||
vec3 rawDest[2];
|
||||
|
||||
glms_vec3_unpack(rawBox1, box1, 2);
|
||||
glms_vec3_unpack(rawBox2, box2, 2);
|
||||
glm_aabb_merge(rawBox1, rawBox2, rawDest);
|
||||
glms_vec3_pack(dest, rawDest, 2);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief crops a bounding box with another one.
|
||||
*
|
||||
* this could be useful for gettng a bbox which fits with view frustum and
|
||||
* object bounding boxes. In this case you crop view frustum box with objects
|
||||
* box
|
||||
*
|
||||
* @param[in] box bounding box 1
|
||||
* @param[in] cropBox crop box
|
||||
* @param[out] dest cropped bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_crop(vec3s box[2], vec3s cropBox[2], vec3s dest[2]) {
|
||||
vec3 rawBox[2];
|
||||
vec3 rawCropBox[2];
|
||||
vec3 rawDest[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glms_vec3_unpack(rawCropBox, cropBox, 2);
|
||||
glm_aabb_crop(rawBox, rawCropBox, rawDest);
|
||||
glms_vec3_pack(dest, rawDest, 2);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief crops a bounding box with another one.
|
||||
*
|
||||
* this could be useful for gettng a bbox which fits with view frustum and
|
||||
* object bounding boxes. In this case you crop view frustum box with objects
|
||||
* box
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] cropBox crop box
|
||||
* @param[in] clampBox miniumum box
|
||||
* @param[out] dest cropped bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_crop_until(vec3s box[2],
|
||||
vec3s cropBox[2],
|
||||
vec3s clampBox[2],
|
||||
vec3s dest[2]) {
|
||||
glms_aabb_crop(box, cropBox, dest);
|
||||
glms_aabb_merge(clampBox, dest, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if AABB intersects with frustum planes
|
||||
*
|
||||
* this could be useful for frustum culling using AABB.
|
||||
*
|
||||
* OPTIMIZATION HINT:
|
||||
* if planes order is similar to LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR
|
||||
* then this method should run even faster because it would only use two
|
||||
* planes if object is not inside the two planes
|
||||
* fortunately cglm extracts planes as this order! just pass what you got!
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] planes frustum planes
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_frustum(vec3s box[2], vec4s planes[6]) {
|
||||
vec3 rawBox[2];
|
||||
vec4 rawPlanes[6];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glms_vec4_unpack(rawPlanes, planes, 6);
|
||||
return glm_aabb_frustum(rawBox, rawPlanes);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief invalidate AABB min and max values
|
||||
*
|
||||
* @param[in, out] box bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_invalidate(vec3s box[2]) {
|
||||
box[0] = glms_vec3_broadcast(FLT_MAX);
|
||||
box[1] = glms_vec3_broadcast(-FLT_MAX);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if AABB is valid or not
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_isvalid(vec3s box[2]) {
|
||||
vec3 rawBox[2];
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
return glm_aabb_isvalid(rawBox);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief distance between of min and max
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_aabb_size(vec3s box[2]) {
|
||||
return glm_vec3_distance(box[0].raw, box[1].raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief radius of sphere which surrounds AABB
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_aabb_radius(vec3s box[2]) {
|
||||
return glms_aabb_size(box) * 0.5f;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief computes center point of AABB
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @returns center of bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_aabb_center(vec3s box[2]) {
|
||||
return glms_vec3_center(box[0], box[1]);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if two AABB intersects
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] other other bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_aabb(vec3s box[2], vec3s other[2]) {
|
||||
vec3 rawBox[2];
|
||||
vec3 rawOther[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glms_vec3_unpack(rawOther, other, 2);
|
||||
return glm_aabb_aabb(rawBox, rawOther);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if AABB intersects with sphere
|
||||
*
|
||||
* https://github.com/erich666/GraphicsGems/blob/master/gems/BoxSphere.c
|
||||
* Solid Box - Solid Sphere test.
|
||||
*
|
||||
* @param[in] box solid bounding box
|
||||
* @param[in] s solid sphere
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_sphere(vec3s box[2], vec4s s) {
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
return glm_aabb_sphere(rawBox, s.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if point is inside of AABB
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] point point
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_point(vec3s box[2], vec3s point) {
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
return glm_aabb_point(rawBox, point.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if AABB contains other AABB
|
||||
*
|
||||
* @param[in] box bounding box
|
||||
* @param[in] other other bounding box
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_aabb_contains(vec3s box[2], vec3s other[2]) {
|
||||
vec3 rawBox[2];
|
||||
vec3 rawOther[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glms_vec3_unpack(rawOther, other, 2);
|
||||
return glm_aabb_contains(rawBox, rawOther);
|
||||
}
|
||||
|
||||
#endif /* cglms_boxs_h */
|
||||
646
include/cglm/struct/cam.h
Normal file
646
include/cglm/struct/cam.h
Normal file
@ -0,0 +1,646 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_frustum(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho_aabb(vec3s box[2]);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_p(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_pz(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_default(float aspect)
|
||||
CGLM_INLINE mat4s glms_ortho_default_s(float aspect, float size)
|
||||
CGLM_INLINE mat4s glms_perspective(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
float farZ)
|
||||
CGLM_INLINE void glms_persp_move_far(mat4s proj, float deltaFar)
|
||||
CGLM_INLINE mat4s glms_perspective_default(float aspect)
|
||||
CGLM_INLINE void glms_perspective_resize(mat4s proj, float aspect)
|
||||
CGLM_INLINE mat4s glms_lookat(vec3s eye, vec3s center, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look(vec3s eye, vec3s dir, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_anyup(vec3s eye, vec3s dir)
|
||||
CGLM_INLINE void glms_persp_decomp(mat4s proj,
|
||||
float *nearv, float *farv,
|
||||
float *top, float *bottom,
|
||||
float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decompv(mat4s proj, float dest[6])
|
||||
CGLM_INLINE void glms_persp_decomp_x(mat4s proj, float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decomp_y(mat4s proj, float *top, float *bottom)
|
||||
CGLM_INLINE void glms_persp_decomp_z(mat4s proj, float *nearv, float *farv)
|
||||
CGLM_INLINE void glms_persp_decomp_far(mat4s proj, float *farZ)
|
||||
CGLM_INLINE void glms_persp_decomp_near(mat4s proj, float *nearZ)
|
||||
CGLM_INLINE float glms_persp_fovy(mat4s proj)
|
||||
CGLM_INLINE float glms_persp_aspect(mat4s proj)
|
||||
CGLM_INLINE vec4s glms_persp_sizes(mat4s proj, float fovy)
|
||||
*/
|
||||
|
||||
#ifndef cglms_cam_h
|
||||
#define cglms_cam_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../plane.h"
|
||||
#include "../cam.h"
|
||||
|
||||
#ifndef CGLM_CLIPSPACE_INCLUDE_ALL
|
||||
# if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
# include "clipspace/ortho_lh_zo.h"
|
||||
# include "clipspace/persp_lh_zo.h"
|
||||
# include "clipspace/view_lh_zo.h"
|
||||
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
# include "clipspace/ortho_lh_no.h"
|
||||
# include "clipspace/persp_lh_no.h"
|
||||
# include "clipspace/view_lh_no.h"
|
||||
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
# include "clipspace/ortho_rh_zo.h"
|
||||
# include "clipspace/persp_rh_zo.h"
|
||||
# include "clipspace/view_rh_zo.h"
|
||||
# elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
# include "clipspace/ortho_rh_no.h"
|
||||
# include "clipspace/persp_rh_no.h"
|
||||
# include "clipspace/view_rh_no.h"
|
||||
# endif
|
||||
#else
|
||||
# include "clipspace/ortho_lh_zo.h"
|
||||
# include "clipspace/persp_lh_zo.h"
|
||||
# include "clipspace/ortho_lh_no.h"
|
||||
# include "clipspace/persp_lh_no.h"
|
||||
# include "clipspace/ortho_rh_zo.h"
|
||||
# include "clipspace/persp_rh_zo.h"
|
||||
# include "clipspace/ortho_rh_no.h"
|
||||
# include "clipspace/persp_rh_no.h"
|
||||
# include "clipspace/view_lh_zo.h"
|
||||
# include "clipspace/view_lh_no.h"
|
||||
# include "clipspace/view_rh_zo.h"
|
||||
# include "clipspace/view_rh_no.h"
|
||||
#endif
|
||||
|
||||
/*!
|
||||
* @brief set up perspective peprojection matrix
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_frustum(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_frustum_lh_zo(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_frustum_lh_no(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_frustum_rh_zo(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_frustum_rh_no(left, right, bottom, top, nearZ, farZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_lh_zo(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_lh_no(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_rh_zo(left, right, bottom, top, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_rh_no(left, right, bottom, top, nearZ, farZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb(vec3s box[2]) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_aabb_lh_zo(box);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_aabb_lh_no(box);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_aabb_rh_zo(box);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_aabb_rh_no(box);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_p(vec3s box[2], float padding) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_aabb_p_lh_zo(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_aabb_p_lh_no(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_aabb_p_rh_zo(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_aabb_p_rh_no(box, padding);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding for near and far
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_pz(vec3s box[2], float padding) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_aabb_pz_lh_zo(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_aabb_pz_lh_no(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_aabb_pz_rh_zo(box, padding);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_aabb_pz_rh_no(box, padding);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up unit orthographic projection matrix
|
||||
*
|
||||
* @param[in] aspect aspect ration ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default(float aspect) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_default_lh_zo(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_default_lh_no(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_default_rh_zo(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_default_rh_no(aspect);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix with given CUBE size
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] size cube size
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_s(float aspect, float size) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_ortho_default_s_lh_zo(aspect, size);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_ortho_default_s_lh_no(aspect, size);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_ortho_default_s_rh_zo(aspect, size);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_ortho_default_s_rh_no(aspect, size);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping planes
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective(float fovy, float aspect, float nearZ, float farZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_perspective_lh_zo(fovy, aspect, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_perspective_lh_no(fovy, aspect, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_perspective_rh_zo(fovy, aspect, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_perspective_rh_no(fovy, aspect, nearZ, farZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glm_persp_move_far(prooj.raw, deltaFar) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* this function does not guarantee far >= near, be aware of that!
|
||||
*
|
||||
* @param[in, out] proj projection matrix to extend
|
||||
* @param[in] deltaFar distance from existing far (negative to shink)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_persp_move_far(mat4s proj, float deltaFar) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_persp_move_far_lh_zo(proj, deltaFar);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_persp_move_far_lh_no(proj, deltaFar);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_persp_move_far_rh_zo(proj, deltaFar);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_persp_move_far_rh_no(proj, deltaFar);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_default(float aspect) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_perspective_default_lh_zo(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_perspective_default_lh_no(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_perspective_default_rh_zo(aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_perspective_default_rh_no(aspect);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
* reized
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_perspective_resize(proj.raw, aspect) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* @param[in, out] proj perspective projection matrix
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_resize(mat4s proj, float aspect) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_perspective_resize_lh_zo(proj, aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_perspective_resize_lh_no(proj, aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_perspective_resize_rh_zo(proj, aspect);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_perspective_resize_rh_no(proj, aspect);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] center center vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_lookat(vec3s eye, vec3s center, vec3s up) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_lookat_lh_zo(eye, center, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_lookat_lh_no(eye, center, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_lookat_rh_zo(eye, center, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_lookat_rh_no(eye, center, up);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
*
|
||||
* convenient wrapper for lookat: if you only have direction not target self
|
||||
* then this might be useful. Because you need to get target from direction.
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look(vec3s eye, vec3s dir, vec3s up) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_look_lh_zo(eye, dir, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_look_lh_no(eye, dir, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_look_rh_zo(eye, dir, up);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_look_rh_no(eye, dir, up);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
*
|
||||
* convenient wrapper for look: if you only have direction and if you don't
|
||||
* care what UP vector is then this might be useful to create view matrix
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_anyup(vec3s eye, vec3s dir) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_look_anyup_lh_zo(eye, dir);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_look_anyup_lh_no(eye, dir);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_look_anyup_rh_zo(eye, dir);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_look_anyup_rh_no(eye, dir);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp(mat4s proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_lh_zo(proj, nearZ, farZ, top, bottom, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_lh_no(proj, nearZ, farZ, top, bottom, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_rh_zo(proj, nearZ, farZ, top, bottom, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_rh_no(proj, nearZ, farZ, top, bottom, left, right);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* this makes easy to get all values at once
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] dest array
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decompv(mat4s proj, float dest[6]) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decompv_lh_zo(proj, dest);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decompv_lh_no(proj, dest);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decompv_rh_zo(proj, dest);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decompv_rh_no(proj, dest);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes left and right values of perspective projection.
|
||||
* x stands for x axis (left / right axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_x(mat4s proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_x_lh_zo(proj, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_x_lh_no(proj, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_x_rh_zo(proj, left, right);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_x_rh_no(proj, left, right);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes top and bottom values of perspective projection.
|
||||
* y stands for y axis (top / botom axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_y(mat4s proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_y_lh_zo(proj, top, bottom);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_y_lh_no(proj, top, bottom);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_y_rh_zo(proj, top, bottom);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_y_rh_no(proj, top, bottom);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near and far values of perspective projection.
|
||||
* z stands for z axis (near / far axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_z(mat4s proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_z_lh_zo(proj, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_z_lh_no(proj, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_z_rh_zo(proj, nearZ, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_z_rh_no(proj, nearZ, farZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes far value of perspective projection.
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_far(mat4s proj, float * __restrict farZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_far_lh_zo(proj, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_far_lh_no(proj, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_far_rh_zo(proj, farZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_far_rh_no(proj, farZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near value of perspective projection.
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_near(mat4s proj, float * __restrict nearZ) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
glms_persp_decomp_near_lh_zo(proj, nearZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
glms_persp_decomp_near_lh_no(proj, nearZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
glms_persp_decomp_near_rh_zo(proj, nearZ);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
glms_persp_decomp_near_rh_no(proj, nearZ);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns field of view angle along the Y-axis (in radians)
|
||||
*
|
||||
* if you need to degrees, use glm_deg to convert it or use this:
|
||||
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_fovy(mat4s proj) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_persp_fovy_lh_zo(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_persp_fovy_lh_no(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_persp_fovy_rh_zo(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_persp_fovy_rh_no(proj);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns aspect ratio of perspective projection
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_aspect(mat4s proj) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_persp_aspect_lh_zo(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_persp_aspect_lh_no(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_persp_aspect_rh_zo(proj);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_persp_aspect_rh_no(proj);
|
||||
#endif
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns sizes of near and far planes of perspective projection
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[in] fovy fovy (see brief)
|
||||
* @returns sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_persp_sizes(mat4s proj, float fovy) {
|
||||
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
|
||||
return glms_persp_sizes_lh_zo(proj, fovy);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
|
||||
return glms_persp_sizes_lh_no(proj, fovy);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
|
||||
return glms_persp_sizes_rh_zo(proj, fovy);
|
||||
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
|
||||
return glms_persp_sizes_rh_no(proj, fovy);
|
||||
#endif
|
||||
}
|
||||
|
||||
#endif /* cglms_cam_h */
|
||||
152
include/cglm/struct/clipspace/ortho_lh_no.h
Normal file
152
include/cglm/struct/clipspace/ortho_lh_no.h
Normal file
@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_ortho_lh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_lh_no(vec3s box[2]);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_p_lh_no(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_pz_lh_no(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_default_lh_no(float aspect)
|
||||
CGLM_INLINE mat4s glms_ortho_default_s_lh_no(float aspect, float size)
|
||||
*/
|
||||
|
||||
#ifndef cglms_ortho_lh_no_h
|
||||
#define cglms_ortho_lh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_lh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_ortho_lh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_lh_no(vec3s box[2]) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_lh_no(rawBox, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_p_lh_no(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_p_lh_no(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding for near and far
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_pz_lh_no(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_pz_lh_no(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up unit orthographic projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ration ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_lh_no(float aspect) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_lh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix with given CUBE size
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] size cube size
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_s_lh_no(float aspect, float size) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_s_lh_no(aspect, size, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_ortho_lh_no_h */
|
||||
152
include/cglm/struct/clipspace/ortho_lh_zo.h
Normal file
152
include/cglm/struct/clipspace/ortho_lh_zo.h
Normal file
@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_ortho_lh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_lh_zo(vec3s box[2]);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_p_lh_zo(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_pz_lh_zo(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_default_lh_zo(float aspect)
|
||||
CGLM_INLINE mat4s glms_ortho_default_s_lh_zo(float aspect, float size)
|
||||
*/
|
||||
|
||||
#ifndef cglms_ortho_lh_zo_h
|
||||
#define cglms_ortho_lh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_lh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_ortho_lh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_lh_zo(vec3s box[2]) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_lh_zo(rawBox, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_p_lh_zo(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_p_lh_zo(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding for near and far
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_pz_lh_zo(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_pz_lh_zo(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up unit orthographic projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ration ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_lh_zo(float aspect) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_lh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix with given CUBE size
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] size cube size
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_s_lh_zo(float aspect, float size) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_s_lh_zo(aspect, size, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_ortho_lh_zo_h */
|
||||
152
include/cglm/struct/clipspace/ortho_rh_no.h
Normal file
152
include/cglm/struct/clipspace/ortho_rh_no.h
Normal file
@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_ortho_rh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_rh_no(vec3s box[2]);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_p_rh_no(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_pz_rh_no(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_default_rh_no(float aspect)
|
||||
CGLM_INLINE mat4s glms_ortho_default_s_rh_no(float aspect, float size)
|
||||
*/
|
||||
|
||||
#ifndef cglms_ortho_rh_no_h
|
||||
#define cglms_ortho_rh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_rh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_ortho_rh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_rh_no(vec3s box[2]) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_rh_no(rawBox, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_p_rh_no(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_p_rh_no(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding for near and far
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_pz_rh_no(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_pz_rh_no(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up unit orthographic projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ration ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_rh_no(float aspect) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_rh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix with given CUBE size
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] size cube size
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_s_rh_no(float aspect, float size) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_s_rh_no(aspect, size, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_ortho_rh_no_h */
|
||||
152
include/cglm/struct/clipspace/ortho_rh_zo.h
Normal file
152
include/cglm/struct/clipspace/ortho_rh_zo.h
Normal file
@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_ortho_rh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_rh_zo(vec3s box[2]);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_p_rh_zo(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_aabb_pz_rh_zo(vec3s box[2], float padding);
|
||||
CGLM_INLINE mat4s glms_ortho_default_rh_zo(float aspect)
|
||||
CGLM_INLINE mat4s glms_ortho_default_s_rh_zo(float aspect, float size)
|
||||
*/
|
||||
|
||||
#ifndef cglms_ortho_rh_zo_h
|
||||
#define cglms_ortho_rh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_rh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_ortho_rh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_rh_zo(vec3s box[2]) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_rh_zo(rawBox, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_p_rh_zo(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_p_rh_zo(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix using bounding box
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* bounding box (AABB) must be in view space
|
||||
*
|
||||
* @param[in] box AABB
|
||||
* @param[in] padding padding for near and far
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_aabb_pz_rh_zo(vec3s box[2], float padding) {
|
||||
mat4s dest;
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec3_unpack(rawBox, box, 2);
|
||||
glm_ortho_aabb_pz_rh_zo(rawBox, padding, dest.raw);
|
||||
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up unit orthographic projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ration ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_rh_zo(float aspect) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_rh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up orthographic projection matrix with given CUBE size
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] size cube size
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_ortho_default_s_rh_zo(float aspect, float size) {
|
||||
mat4s dest;
|
||||
glm_ortho_default_s_rh_zo(aspect, size, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_ortho_rh_zo_h */
|
||||
311
include/cglm/struct/clipspace/persp_lh_no.h
Normal file
311
include/cglm/struct/clipspace/persp_lh_no.h
Normal file
@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_frustum_lh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_perspective_lh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
float farZ)
|
||||
CGLM_INLINE void glms_persp_move_far_lh_no(mat4s proj, float deltaFar)
|
||||
CGLM_INLINE mat4s glms_perspective_default_lh_no(float aspect)
|
||||
CGLM_INLINE void glms_perspective_resize_lh_no(mat4s proj, float aspect)
|
||||
CGLM_INLINE void glms_persp_decomp_lh_no(mat4s proj,
|
||||
float *nearv, float *farv,
|
||||
float *top, float *bottom,
|
||||
float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decompv_lh_no(mat4s proj, float dest[6])
|
||||
CGLM_INLINE void glms_persp_decomp_x_lh_no(mat4s proj, float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decomp_y_lh_no(mat4s proj, float *top, float *bottom)
|
||||
CGLM_INLINE void glms_persp_decomp_z_lh_no(mat4s proj, float *nearv, float *farv)
|
||||
CGLM_INLINE void glms_persp_decomp_far_lh_no(mat4s proj, float *farZ)
|
||||
CGLM_INLINE void glms_persp_decomp_near_lh_no(mat4s proj, float *nearZ)
|
||||
CGLM_INLINE float glms_persp_fovy_lh_no(mat4s proj)
|
||||
CGLM_INLINE float glms_persp_aspect_lh_no(mat4s proj)
|
||||
CGLM_INLINE vec4s glms_persp_sizes_lh_no(mat4s proj, float fovy)
|
||||
*/
|
||||
|
||||
#ifndef cglms_persp_lh_no_h
|
||||
#define cglms_persp_lh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up perspective peprojection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_frustum_lh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_frustum_lh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping planes
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_lh_no(float fovy, float aspect, float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_perspective_lh_no(fovy, aspect, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_persp_move_far_lh_no(prooj.raw, deltaFar) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* this function does not guarantee far >= near, be aware of that!
|
||||
*
|
||||
* @param[in, out] proj projection matrix to extend
|
||||
* @param[in] deltaFar distance from existing far (negative to shink)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_persp_move_far_lh_no(mat4s proj, float deltaFar) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_persp_move_far_lh_no(dest.raw, deltaFar);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_default_lh_no(float aspect) {
|
||||
mat4s dest;
|
||||
glm_perspective_default_lh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
* reized with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glm_perspective_resize_lh_no(proj.raw, aspect) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* @param[in, out] proj perspective projection matrix
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_resize_lh_no(mat4s proj, float aspect) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_perspective_resize_lh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_lh_no(mat4s proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
glm_persp_decomp_lh_no(proj.raw, nearZ, farZ, top, bottom, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* this makes easy to get all values at once
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] dest array
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decompv_lh_no(mat4s proj, float dest[6]) {
|
||||
glm_persp_decompv_lh_no(proj.raw, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes left and right values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* x stands for x axis (left / right axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_x_lh_no(mat4s proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
glm_persp_decomp_x_lh_no(proj.raw, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes top and bottom values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* y stands for y axis (top / botom axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_y_lh_no(mat4s proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
glm_persp_decomp_y_lh_no(proj.raw, top, bottom);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near and far values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* z stands for z axis (near / far axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_z_lh_no(mat4s proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
glm_persp_decomp_z_lh_no(proj.raw, nearZ, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes far value of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_far_lh_no(mat4s proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_lh_no(proj.raw, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near value of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_near_lh_no(mat4s proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_lh_no(proj.raw, nearZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns field of view angle along the Y-axis (in radians)
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* if you need to degrees, use glm_deg to convert it or use this:
|
||||
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_fovy_lh_no(mat4s proj) {
|
||||
return glm_persp_fovy_lh_no(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns aspect ratio of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_aspect_lh_no(mat4s proj) {
|
||||
return glm_persp_aspect_lh_no(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns sizes of near and far planes of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[in] fovy fovy (see brief)
|
||||
* @returns sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_persp_sizes_lh_no(mat4s proj, float fovy) {
|
||||
vec4s dest;
|
||||
glm_persp_sizes_lh_no(proj.raw, fovy, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_persp_lh_no_h */
|
||||
311
include/cglm/struct/clipspace/persp_lh_zo.h
Normal file
311
include/cglm/struct/clipspace/persp_lh_zo.h
Normal file
@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_frustum_lh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_perspective_lh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
float farZ)
|
||||
CGLM_INLINE void glms_persp_move_far_lh_zo(mat4s proj, float deltaFar)
|
||||
CGLM_INLINE mat4s glms_perspective_default_lh_zo(float aspect)
|
||||
CGLM_INLINE void glms_perspective_resize_lh_zo(mat4s proj, float aspect)
|
||||
CGLM_INLINE void glms_persp_decomp_lh_zo(mat4s proj,
|
||||
float *nearv, float *farv,
|
||||
float *top, float *bottom,
|
||||
float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decompv_lh_zo(mat4s proj, float dest[6])
|
||||
CGLM_INLINE void glms_persp_decomp_x_lh_zo(mat4s proj, float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decomp_y_lh_zo(mat4s proj, float *top, float *bottom)
|
||||
CGLM_INLINE void glms_persp_decomp_z_lh_zo(mat4s proj, float *nearv, float *farv)
|
||||
CGLM_INLINE void glms_persp_decomp_far_lh_zo(mat4s proj, float *farZ)
|
||||
CGLM_INLINE void glms_persp_decomp_near_lh_zo(mat4s proj, float *nearZ)
|
||||
CGLM_INLINE float glms_persp_fovy_lh_zo(mat4s proj)
|
||||
CGLM_INLINE float glms_persp_aspect_lh_zo(mat4s proj)
|
||||
CGLM_INLINE vec4s glms_persp_sizes_lh_zo(mat4s proj, float fovy)
|
||||
*/
|
||||
|
||||
#ifndef cglms_persp_lh_zo_h
|
||||
#define cglms_persp_lh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up perspective peprojection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_frustum_lh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_frustum_lh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping planes
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_lh_zo(float fovy, float aspect, float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_perspective_lh_zo(fovy, aspect, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_persp_move_far_lh_zo(prooj.raw, deltaFar) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* this function does not guarantee far >= near, be aware of that!
|
||||
*
|
||||
* @param[in, out] proj projection matrix to extend
|
||||
* @param[in] deltaFar distance from existing far (negative to shink)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_persp_move_far_lh_zo(mat4s proj, float deltaFar) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_persp_move_far_lh_zo(dest.raw, deltaFar);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_default_lh_zo(float aspect) {
|
||||
mat4s dest;
|
||||
glm_perspective_default_lh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
* reized with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_perspective_resize_lh_zo(proj.raw, aspect) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* @param[in, out] proj perspective projection matrix
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_resize_lh_zo(mat4s proj, float aspect) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_perspective_resize_lh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_lh_zo(mat4s proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
glm_persp_decomp_lh_zo(proj.raw, nearZ, farZ, top, bottom, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* this makes easy to get all values at once
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] dest array
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decompv_lh_zo(mat4s proj, float dest[6]) {
|
||||
glm_persp_decompv_lh_zo(proj.raw, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes left and right values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* x stands for x axis (left / right axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_x_lh_zo(mat4s proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
glm_persp_decomp_x_lh_zo(proj.raw, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes top and bottom values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* y stands for y axis (top / botom axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_y_lh_zo(mat4s proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
glm_persp_decomp_y_lh_zo(proj.raw, top, bottom);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near and far values of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* z stands for z axis (near / far axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_z_lh_zo(mat4s proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
glm_persp_decomp_z_lh_zo(proj.raw, nearZ, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes far value of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_far_lh_zo(mat4s proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_lh_zo(proj.raw, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near value of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_near_lh_zo(mat4s proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_lh_zo(proj.raw, nearZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns field of view angle along the Y-axis (in radians)
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* if you need to degrees, use glm_deg to convert it or use this:
|
||||
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_fovy_lh_zo(mat4s proj) {
|
||||
return glm_persp_fovy_lh_zo(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns aspect ratio of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_aspect_lh_zo(mat4s proj) {
|
||||
return glm_persp_aspect_lh_zo(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns sizes of near and far planes of perspective projection
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[in] fovy fovy (see brief)
|
||||
* @returns sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_persp_sizes_lh_zo(mat4s proj, float fovy) {
|
||||
vec4s dest;
|
||||
glm_persp_sizes_lh_zo(proj.raw, fovy, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_persp_lh_zo_h */
|
||||
311
include/cglm/struct/clipspace/persp_rh_no.h
Normal file
311
include/cglm/struct/clipspace/persp_rh_no.h
Normal file
@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_frustum_rh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_perspective_rh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
float farZ)
|
||||
CGLM_INLINE void glms_persp_move_far_rh_no(mat4s proj, float deltaFar)
|
||||
CGLM_INLINE mat4s glms_perspective_default_rh_no(float aspect)
|
||||
CGLM_INLINE void glms_perspective_resize_rh_no(mat4s proj, float aspect)
|
||||
CGLM_INLINE void glms_persp_decomp_rh_no(mat4s proj,
|
||||
float *nearv, float *farv,
|
||||
float *top, float *bottom,
|
||||
float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decompv_rh_no(mat4s proj, float dest[6])
|
||||
CGLM_INLINE void glms_persp_decomp_x_rh_no(mat4s proj, float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decomp_y_rh_no(mat4s proj, float *top, float *bottom)
|
||||
CGLM_INLINE void glms_persp_decomp_z_rh_no(mat4s proj, float *nearv, float *farv)
|
||||
CGLM_INLINE void glms_persp_decomp_far_rh_no(mat4s proj, float *farZ)
|
||||
CGLM_INLINE void glms_persp_decomp_near_rh_no(mat4s proj, float *nearZ)
|
||||
CGLM_INLINE float glms_persp_fovy_rh_no(mat4s proj)
|
||||
CGLM_INLINE float glms_persp_aspect_rh_no(mat4s proj)
|
||||
CGLM_INLINE vec4s glms_persp_sizes_rh_no(mat4s proj, float fovy)
|
||||
*/
|
||||
|
||||
#ifndef cglms_persp_rh_no_h
|
||||
#define cglms_persp_rh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up perspective peprojection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_frustum_rh_no(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_frustum_rh_no(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping planes
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_rh_no(float fovy, float aspect, float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_perspective_rh_no(fovy, aspect, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_persp_move_far_rh_no(prooj.raw, deltaFar) to avoid create new mat4
|
||||
* each time
|
||||
* s
|
||||
* this function does not guarantee far >= near, be aware of that!
|
||||
*
|
||||
* @param[in, out] proj projection matrix to extend
|
||||
* @param[in] deltaFar distance from existing far (negative to shink)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_persp_move_far_rh_no(mat4s proj, float deltaFar) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_persp_move_far_rh_no(dest.raw, deltaFar);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_default_rh_no(float aspect) {
|
||||
mat4s dest;
|
||||
glm_perspective_default_rh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
* reized with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glm_perspective_resize_rh_no(proj.raw, aspect) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* @param[in, out] proj perspective projection matrix
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_resize_rh_no(mat4s proj, float aspect) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_perspective_resize_rh_no(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_rh_no(mat4s proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
glm_persp_decomp_rh_no(proj.raw, nearZ, farZ, top, bottom, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* this makes easy to get all values at once
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] dest array
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decompv_rh_no(mat4s proj, float dest[6]) {
|
||||
glm_persp_decompv_rh_no(proj.raw, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes left and right values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* x stands for x axis (left / right axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_x_rh_no(mat4s proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
glm_persp_decomp_x_rh_no(proj.raw, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes top and bottom values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* y stands for y axis (top / botom axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_y_rh_no(mat4s proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
glm_persp_decomp_y_rh_no(proj.raw, top, bottom);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near and far values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
* z stands for z axis (near / far axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_z_rh_no(mat4s proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
glm_persp_decomp_z_rh_no(proj.raw, nearZ, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes far value of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_far_rh_no(mat4s proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_rh_no(proj.raw, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near value of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_near_rh_no(mat4s proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_rh_no(proj.raw, nearZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns field of view angle along the Y-axis (in radians)
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* if you need to degrees, use glm_deg to convert it or use this:
|
||||
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_fovy_rh_no(mat4s proj) {
|
||||
return glm_persp_fovy_rh_no(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns aspect ratio of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_aspect_rh_no(mat4s proj) {
|
||||
return glm_persp_aspect_rh_no(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns sizes of near and far planes of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[in] fovy fovy (see brief)
|
||||
* @returns sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_persp_sizes_rh_no(mat4s proj, float fovy) {
|
||||
vec4s dest;
|
||||
glm_persp_sizes_rh_no(proj.raw, fovy, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_persp_rh_no_h */
|
||||
311
include/cglm/struct/clipspace/persp_rh_zo.h
Normal file
311
include/cglm/struct/clipspace/persp_rh_zo.h
Normal file
@ -0,0 +1,311 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_frustum_rh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ)
|
||||
CGLM_INLINE mat4s glms_perspective_rh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
float farZ)
|
||||
CGLM_INLINE void glms_persp_move_far_rh_zo(mat4s proj, float deltaFar)
|
||||
CGLM_INLINE mat4s glms_perspective_default_rh_zo(float aspect)
|
||||
CGLM_INLINE void glms_perspective_resize_rh_zo(mat4s proj, float aspect)
|
||||
CGLM_INLINE void glms_persp_decomp_rh_zo(mat4s proj,
|
||||
float *nearv, float *farv,
|
||||
float *top, float *bottom,
|
||||
float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decompv_rh_zo(mat4s proj, float dest[6])
|
||||
CGLM_INLINE void glms_persp_decomp_x_rh_zo(mat4s proj, float *left, float *right)
|
||||
CGLM_INLINE void glms_persp_decomp_y_rh_zo(mat4s proj, float *top, float *bottom)
|
||||
CGLM_INLINE void glms_persp_decomp_z_rh_zo(mat4s proj, float *nearv, float *farv)
|
||||
CGLM_INLINE void glms_persp_decomp_far_rh_zo(mat4s proj, float *farZ)
|
||||
CGLM_INLINE void glms_persp_decomp_near_rh_zo(mat4s proj, float *nearZ)
|
||||
CGLM_INLINE float glms_persp_fovy_rh_zo(mat4s proj)
|
||||
CGLM_INLINE float glms_persp_aspect_rh_zo(mat4s proj)
|
||||
CGLM_INLINE vec4s glms_persp_sizes_rh_zo(mat4s proj, float fovy)
|
||||
*/
|
||||
|
||||
#ifndef cglms_persp_rh_zo_h
|
||||
#define cglms_persp_rh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up perspective peprojection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] left viewport.left
|
||||
* @param[in] right viewport.right
|
||||
* @param[in] bottom viewport.bottom
|
||||
* @param[in] top viewport.top
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping plane
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_frustum_rh_zo(float left, float right,
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_frustum_rh_zo(left, right, bottom, top, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[in] farZ far clipping planes
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_rh_zo(float fovy, float aspect, float nearZ, float farZ) {
|
||||
mat4s dest;
|
||||
glm_perspective_rh_zo(fovy, aspect, nearZ, farZ, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glms_persp_move_far_rh_zo(prooj.raw, deltaFar) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* this function does not guarantee far >= near, be aware of that!
|
||||
*
|
||||
* @param[in, out] proj projection matrix to extend
|
||||
* @param[in] deltaFar distance from existing far (negative to shink)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_persp_move_far_rh_zo(mat4s proj, float deltaFar) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_persp_move_far_rh_zo(dest.raw, deltaFar);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_default_rh_zo(float aspect) {
|
||||
mat4s dest;
|
||||
glm_perspective_default_rh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
* reized with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: if you dodn't want to create new matrix then use array api on struct.raw
|
||||
* like glm_perspective_resize_rh_zo(proj.raw, aspect) to avoid create new mat4
|
||||
* each time
|
||||
*
|
||||
* @param[in, out] proj perspective projection matrix
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_perspective_resize_rh_zo(mat4s proj, float aspect) {
|
||||
mat4s dest;
|
||||
dest = proj;
|
||||
glm_perspective_resize_rh_zo(aspect, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_rh_zo(mat4s proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
glm_persp_decomp_rh_zo(proj.raw, nearZ, farZ, top, bottom, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes frustum values of perspective projection.
|
||||
* this makes easy to get all values at once
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] dest array
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decompv_rh_zo(mat4s proj, float dest[6]) {
|
||||
glm_persp_decompv_rh_zo(proj.raw, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes left and right values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* x stands for x axis (left / right axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] left left
|
||||
* @param[out] right right
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_x_rh_zo(mat4s proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
glm_persp_decomp_x_rh_zo(proj.raw, left, right);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes top and bottom values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* y stands for y axis (top / botom axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] top top
|
||||
* @param[out] bottom bottom
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_y_rh_zo(mat4s proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
glm_persp_decomp_y_rh_zo(proj.raw, top, bottom);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near and far values of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
* z stands for z axis (near / far axis)
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_z_rh_zo(mat4s proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
glm_persp_decomp_z_rh_zo(proj.raw, nearZ, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes far value of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] farZ far
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_far_rh_zo(mat4s proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_rh_zo(proj.raw, farZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief decomposes near value of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[out] nearZ near
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_persp_decomp_near_rh_zo(mat4s proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_rh_zo(proj.raw, nearZ);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns field of view angle along the Y-axis (in radians)
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* if you need to degrees, use glm_deg to convert it or use this:
|
||||
* fovy_deg = glm_deg(glm_persp_fovy(projMatrix))
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_fovy_rh_zo(mat4s proj) {
|
||||
return glm_persp_fovy_rh_zo(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns aspect ratio of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_persp_aspect_rh_zo(mat4s proj) {
|
||||
return glm_persp_aspect_rh_zo(proj.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns sizes of near and far planes of perspective projection
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] proj perspective projection matrix
|
||||
* @param[in] fovy fovy (see brief)
|
||||
* @returns sizes as vector, sizes order: [Wnear, Hnear, Wfar, Hfar]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_persp_sizes_rh_zo(mat4s proj, float fovy) {
|
||||
vec4s dest;
|
||||
glm_persp_sizes_rh_zo(proj.raw, fovy, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_persp_rh_zo_h */
|
||||
96
include/cglm/struct/clipspace/project_no.h
Normal file
96
include/cglm/struct/clipspace/project_no.h
Normal file
@ -0,0 +1,96 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
|
||||
CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
|
||||
*/
|
||||
|
||||
#ifndef cglms_project_no_h
|
||||
#define cglms_project_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief maps the specified viewport coordinates into specified space [1]
|
||||
* the matrix should contain projection matrix.
|
||||
*
|
||||
* if you don't have ( and don't want to have ) an inverse matrix then use
|
||||
* glm_unproject version. You may use existing inverse of matrix in somewhere
|
||||
* else, this is why glm_unprojecti exists to save save inversion cost
|
||||
*
|
||||
* [1] space:
|
||||
* 1- if m = invProj: View Space
|
||||
* 2- if m = invViewProj: World Space
|
||||
* 3- if m = invMVP: Object Space
|
||||
*
|
||||
* You probably want to map the coordinates into object space
|
||||
* so use invMVP as m
|
||||
*
|
||||
* Computing viewProj:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
* glm_mat4_inv(viewProj, invMVP);
|
||||
*
|
||||
* @param[in] pos point/position in viewport coordinates
|
||||
* @param[in] invMat matrix (see brief)
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
*
|
||||
* @returns unprojected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
|
||||
vec3s dest;
|
||||
glm_unprojecti_no(pos.raw, invMat.raw, vp.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief map object coordinates to window coordinates
|
||||
*
|
||||
* Computing MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] pos object coordinates
|
||||
* @param[in] m MVP matrix
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
*
|
||||
* @returns projected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest) {
|
||||
vec3s dest;
|
||||
glm_project_no(pos.raw, m.raw, vp.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief map object's z coordinate to window coordinates
|
||||
*
|
||||
* Computing MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] v object coordinates
|
||||
* @param[in] m MVP matrix
|
||||
*
|
||||
* @returns projected z coordinate
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_project_z_no(vec3s v, mat4s m) {
|
||||
return glm_project_z_no(v.raw, m.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_project_rh_no_h */
|
||||
96
include/cglm/struct/clipspace/project_zo.h
Normal file
96
include/cglm/struct/clipspace/project_zo.h
Normal file
@ -0,0 +1,96 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec3s glms_unprojecti_no(vec3s pos, mat4s invMat, vec4s vp, vec3 dest)
|
||||
CGLM_INLINE vec3s glms_project_no(vec3s pos, mat4s m, vec4s vp, vec3s dest)
|
||||
*/
|
||||
|
||||
#ifndef cglms_project_zo_h
|
||||
#define cglms_project_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief maps the specified viewport coordinates into specified space [1]
|
||||
* the matrix should contain projection matrix.
|
||||
*
|
||||
* if you don't have ( and don't want to have ) an inverse matrix then use
|
||||
* glm_unproject version. You may use existing inverse of matrix in somewhere
|
||||
* else, this is why glm_unprojecti exists to save save inversion cost
|
||||
*
|
||||
* [1] space:
|
||||
* 1- if m = invProj: View Space
|
||||
* 2- if m = invViewProj: World Space
|
||||
* 3- if m = invMVP: Object Space
|
||||
*
|
||||
* You probably want to map the coordinates into object space
|
||||
* so use invMVP as m
|
||||
*
|
||||
* Computing viewProj:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
* glm_mat4_inv(viewProj, invMVP);
|
||||
*
|
||||
* @param[in] pos point/position in viewport coordinates
|
||||
* @param[in] invMat matrix (see brief)
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
*
|
||||
* @returns unprojected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_unprojecti_zo(vec3s pos, mat4s invMat, vec4s vp, vec3 dest) {
|
||||
vec3s dest;
|
||||
glm_unprojecti_zo(pos.raw, invMat.raw, vp.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief map object coordinates to window coordinates
|
||||
*
|
||||
* Computing MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] pos object coordinates
|
||||
* @param[in] m MVP matrix
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
*
|
||||
* @returns projected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_project_zo(vec3s pos, mat4s m, vec4s vp, vec3 dest) {
|
||||
vec3s dest;
|
||||
glm_project_zo(pos.raw, m.raw, vp.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief map object's z coordinate to window coordinates
|
||||
*
|
||||
* Computing MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] v object coordinates
|
||||
* @param[in] m MVP matrix
|
||||
*
|
||||
* @returns projected z coordinate
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_project_z_zo(vec3s v, mat4s m) {
|
||||
return glm_project_z_zo(v.raw, m.raw);
|
||||
}
|
||||
|
||||
#endif /* cglm_project_zo_h */
|
||||
88
include/cglm/struct/clipspace/view_lh_no.h
Normal file
88
include/cglm/struct/clipspace/view_lh_no.h
Normal file
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_lookat_lh_no(vec3s eye, vec3s center, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_lh_no(vec3s eye, vec3s dir, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_anyup_lh_no(vec3s eye, vec3s dir)
|
||||
*/
|
||||
|
||||
#ifndef cglms_view_lh_no_h
|
||||
#define cglms_view_lh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] center center vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_lookat_lh_no(vec3s eye, vec3s center, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_lookat_lh_no(eye.raw, center.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* convenient wrapper for lookat: if you only have direction not target self
|
||||
* then this might be useful. Because you need to get target from direction.
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_lh_no(vec3s eye, vec3s dir, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_look_lh_no(eye.raw, dir.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* convenient wrapper for look: if you only have direction and if you don't
|
||||
* care what UP vector is then this might be useful to create view matrix
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_anyup_lh_no(vec3s eye, vec3s dir) {
|
||||
mat4s dest;
|
||||
glm_look_anyup_lh_no(eye.raw, dir.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_view_lh_no_h */
|
||||
88
include/cglm/struct/clipspace/view_lh_zo.h
Normal file
88
include/cglm/struct/clipspace/view_lh_zo.h
Normal file
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_lookat_lh_zo(vec3s eye, vec3s center, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_lh_zo(vec3s eye, vec3s dir, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_anyup_lh_zo(vec3s eye, vec3s dir)
|
||||
*/
|
||||
|
||||
#ifndef cglms_view_lh_zo_h
|
||||
#define cglms_view_lh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] center center vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_lookat_lh_zo(vec3s eye, vec3s center, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_lookat_lh_zo(eye.raw, center.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* convenient wrapper for lookat: if you only have direction not target self
|
||||
* then this might be useful. Because you need to get target from direction.
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_lh_zo(vec3s eye, vec3s dir, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_look_lh_zo(eye.raw, dir.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* convenient wrapper for look: if you only have direction and if you don't
|
||||
* care what UP vector is then this might be useful to create view matrix
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_anyup_lh_zo(vec3s eye, vec3s dir) {
|
||||
mat4s dest;
|
||||
glm_look_anyup_lh_zo(eye.raw, dir.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_view_lh_zo_h */
|
||||
88
include/cglm/struct/clipspace/view_rh_no.h
Normal file
88
include/cglm/struct/clipspace/view_rh_no.h
Normal file
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_lookat_rh_no(vec3s eye, vec3s center, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_rh_no(vec3s eye, vec3s dir, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_anyup_rh_no(vec3s eye, vec3s dir)
|
||||
*/
|
||||
|
||||
#ifndef cglms_view_rh_no_h
|
||||
#define cglms_view_rh_no_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] center center vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_lookat_rh_no(vec3s eye, vec3s center, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_lookat_rh_no(eye.raw, center.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* convenient wrapper for lookat: if you only have direction not target self
|
||||
* then this might be useful. Because you need to get target from direction.
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_rh_no(vec3s eye, vec3s dir, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_look_rh_no(eye.raw, dir.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* convenient wrapper for look: if you only have direction and if you don't
|
||||
* care what UP vector is then this might be useful to create view matrix
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_anyup_rh_no(vec3s eye, vec3s dir) {
|
||||
mat4s dest;
|
||||
glm_look_anyup_rh_no(eye.raw, dir.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_view_rh_no_h */
|
||||
88
include/cglm/struct/clipspace/view_rh_zo.h
Normal file
88
include/cglm/struct/clipspace/view_rh_zo.h
Normal file
@ -0,0 +1,88 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_lookat_rh_zo(vec3s eye, vec3s center, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_rh_zo(vec3s eye, vec3s dir, vec3s up)
|
||||
CGLM_INLINE mat4s glms_look_anyup_rh_zo(vec3s eye, vec3s dir)
|
||||
*/
|
||||
|
||||
#ifndef cglms_view_rh_zo_h
|
||||
#define cglms_view_rh_zo_h
|
||||
|
||||
#include "../../common.h"
|
||||
#include "../../types-struct.h"
|
||||
#include "../../plane.h"
|
||||
#include "../../cam.h"
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] center center vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_lookat_rh_zo(vec3s eye, vec3s center, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_lookat_rh_zo(eye.raw, center.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* convenient wrapper for lookat: if you only have direction not target self
|
||||
* then this might be useful. Because you need to get target from direction.
|
||||
*
|
||||
* NOTE: The UP vector must not be parallel to the line of sight from
|
||||
* the eye point to the reference point
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @param[in] up up vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_rh_zo(vec3s eye, vec3s dir, vec3s up) {
|
||||
mat4s dest;
|
||||
glm_look_rh_zo(eye.raw, dir.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up view matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* convenient wrapper for look: if you only have direction and if you don't
|
||||
* care what UP vector is then this might be useful to create view matrix
|
||||
*
|
||||
* @param[in] eye eye vector
|
||||
* @param[in] dir direction vector
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_look_anyup_rh_zo(vec3s eye, vec3s dir) {
|
||||
mat4s dest;
|
||||
glm_look_anyup_rh_zo(eye.raw, dir.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_view_rh_zo_h */
|
||||
27
include/cglm/struct/color.h
Normal file
27
include/cglm/struct/color.h
Normal 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 cglms_colors_h
|
||||
#define cglms_colors_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../color.h"
|
||||
#include "vec3.h"
|
||||
|
||||
/*!
|
||||
* @brief averages the color channels into one value
|
||||
*
|
||||
* @param[in] rgb RGB color
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_luminance(vec3s rgb) {
|
||||
return glm_luminance(rgb.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_colors_h */
|
||||
40
include/cglm/struct/curve.h
Normal file
40
include/cglm/struct/curve.h
Normal file
@ -0,0 +1,40 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_curves_h
|
||||
#define cglms_curves_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../curve.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief helper function to calculate S*M*C multiplication for curves
|
||||
*
|
||||
* This function does not encourage you to use SMC,
|
||||
* instead it is a helper if you use SMC.
|
||||
*
|
||||
* if you want to specify S as vector then use more generic glm_mat4_rmc() func.
|
||||
*
|
||||
* Example usage:
|
||||
* B(s) = glm_smc(s, GLM_BEZIER_MAT, (vec4){p0, c0, c1, p1})
|
||||
*
|
||||
* @param[in] s parameter between 0 and 1 (this will be [s3, s2, s, 1])
|
||||
* @param[in] m basis matrix
|
||||
* @param[in] c position/control vector
|
||||
*
|
||||
* @return B(s)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_smc(float s, mat4s m, vec4s c) {
|
||||
return glm_smc(s, m.raw, c.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_curves_h */
|
||||
152
include/cglm/struct/euler.h
Normal file
152
include/cglm/struct/euler.h
Normal file
@ -0,0 +1,152 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
NOTE:
|
||||
angles must be passed as [X-Angle, Y-Angle, Z-angle] order
|
||||
For instance you don't pass angles as [Z-Angle, X-Angle, Y-angle] to
|
||||
glm_euler_zxy funciton, All RELATED functions accept angles same order
|
||||
which is [X, Y, Z].
|
||||
*/
|
||||
|
||||
/*
|
||||
Types:
|
||||
enum glm_euler_seq
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE vec3s glms_euler_angles(mat4s m)
|
||||
CGLM_INLINE mat4s glms_euler_xyz(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_xzy(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_yxz(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_yzx(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_zxy(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_zyx(vec3s angles)
|
||||
CGLM_INLINE mat4s glms_euler_by_order(vec3s angles, glm_euler_seq ord)
|
||||
*/
|
||||
|
||||
#ifndef cglms_euler_h
|
||||
#define cglms_euler_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../euler.h"
|
||||
|
||||
/*!
|
||||
* @brief extract euler angles (in radians) using xyz order
|
||||
*
|
||||
* @param[in] m affine transform
|
||||
* @returns angles vector [x, y, z]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_euler_angles(mat4s m) {
|
||||
vec3s dest;
|
||||
glm_euler_angles(m.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_xyz(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_xyz(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_xzy(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_xzy(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_yxz(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_yxz(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_yzx(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_yzx(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_zxy(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_zxy(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_zyx(vec3s angles) {
|
||||
mat4s dest;
|
||||
glm_euler_zyx(angles.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief build rotation matrix from euler angles
|
||||
*
|
||||
* @param[in] angles angles as vector [Xangle, Yangle, Zangle]
|
||||
* @param[in] ord euler order
|
||||
* @returns rotation matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_euler_by_order(vec3s angles, glm_euler_seq ord) {
|
||||
mat4s dest;
|
||||
glm_euler_by_order(angles.raw, ord, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_euler_h */
|
||||
155
include/cglm/struct/frustum.h
Normal file
155
include/cglm/struct/frustum.h
Normal file
@ -0,0 +1,155 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_frustums_h
|
||||
#define cglms_frustums_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../frustum.h"
|
||||
#include "plane.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/* you can override clip space coords
|
||||
but you have to provide all with same name
|
||||
e.g.: define GLM_CSCOORD_LBN {0.0f, 0.0f, 1.0f, 1.0f} */
|
||||
#ifndef GLM_CUSTOM_CLIPSPACE
|
||||
|
||||
/* near */
|
||||
#define GLMS_CSCOORD_LBN {-1.0f, -1.0f, -1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_LTN {-1.0f, 1.0f, -1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_RTN { 1.0f, 1.0f, -1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_RBN { 1.0f, -1.0f, -1.0f, 1.0f}
|
||||
|
||||
/* far */
|
||||
#define GLMS_CSCOORD_LBF {-1.0f, -1.0f, 1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_LTF {-1.0f, 1.0f, 1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_RTF { 1.0f, 1.0f, 1.0f, 1.0f}
|
||||
#define GLMS_CSCOORD_RBF { 1.0f, -1.0f, 1.0f, 1.0f}
|
||||
|
||||
#endif
|
||||
|
||||
/*!
|
||||
* @brief extracts view frustum planes
|
||||
*
|
||||
* planes' space:
|
||||
* 1- if m = proj: View Space
|
||||
* 2- if m = viewProj: World Space
|
||||
* 3- if m = MVP: Object Space
|
||||
*
|
||||
* You probably want to extract planes in world space so use viewProj as m
|
||||
* Computing viewProj:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
*
|
||||
* Exracted planes order: [left, right, bottom, top, near, far]
|
||||
*
|
||||
* @param[in] m matrix (see brief)
|
||||
* @param[out] dest extracted view frustum planes (see brief)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_frustum_planes(mat4s m, vec4s dest[6]) {
|
||||
vec4 rawDest[6];
|
||||
glm_frustum_planes(m.raw, rawDest);
|
||||
glms_vec4_pack(dest, rawDest, 6);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extracts view frustum corners using clip-space coordinates
|
||||
*
|
||||
* corners' space:
|
||||
* 1- if m = invViewProj: World Space
|
||||
* 2- if m = invMVP: Object Space
|
||||
*
|
||||
* You probably want to extract corners in world space so use invViewProj
|
||||
* Computing invViewProj:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* ...
|
||||
* glm_mat4_inv(viewProj, invViewProj);
|
||||
*
|
||||
* if you have a near coord at i index, you can get it's far coord by i + 4
|
||||
*
|
||||
* Find center coordinates:
|
||||
* for (j = 0; j < 4; j++) {
|
||||
* glm_vec3_center(corners[i], corners[i + 4], centerCorners[i]);
|
||||
* }
|
||||
*
|
||||
* @param[in] invMat matrix (see brief)
|
||||
* @param[out] dest exracted view frustum corners (see brief)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_frustum_corners(mat4s invMat, vec4s dest[8]) {
|
||||
vec4 rawDest[8];
|
||||
glm_frustum_corners(invMat.raw, rawDest);
|
||||
glms_vec4_pack(dest, rawDest, 8);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief finds center of view frustum
|
||||
*
|
||||
* @param[in] corners view frustum corners
|
||||
* @returns view frustum center
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_frustum_center(vec4s corners[8]) {
|
||||
vec4 rawCorners[8];
|
||||
vec4s r;
|
||||
|
||||
glms_vec4_unpack(rawCorners, corners, 8);
|
||||
glm_frustum_center(rawCorners, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief finds bounding box of frustum relative to given matrix e.g. view mat
|
||||
*
|
||||
* @param[in] corners view frustum corners
|
||||
* @param[in] m matrix to convert existing conners
|
||||
* @param[out] box bounding box as array [min, max]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_frustum_box(vec4s corners[8], mat4s m, vec3s box[2]) {
|
||||
vec4 rawCorners[8];
|
||||
vec3 rawBox[2];
|
||||
|
||||
glms_vec4_unpack(rawCorners, corners, 8);
|
||||
glm_frustum_box(rawCorners, m.raw, rawBox);
|
||||
glms_vec3_pack(box, rawBox, 2);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief finds planes corners which is between near and far planes (parallel)
|
||||
*
|
||||
* this will be helpful if you want to split a frustum e.g. CSM/PSSM. This will
|
||||
* find planes' corners but you will need to one more plane.
|
||||
* Actually you have it, it is near, far or created previously with this func ;)
|
||||
*
|
||||
* @param[in] corners view frustum corners
|
||||
* @param[in] splitDist split distance
|
||||
* @param[in] farDist far distance (zFar)
|
||||
* @param[out] planeCorners plane corners [LB, LT, RT, RB]
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_frustum_corners_at(vec4s corners[8],
|
||||
float splitDist,
|
||||
float farDist,
|
||||
vec4s planeCorners[4]) {
|
||||
vec4 rawCorners[8];
|
||||
vec4 rawPlaneCorners[4];
|
||||
|
||||
glms_vec4_unpack(rawCorners, corners, 8);
|
||||
glm_frustum_corners_at(rawCorners, splitDist, farDist, rawPlaneCorners);
|
||||
glms_vec4_pack(planeCorners, rawPlaneCorners, 8);
|
||||
}
|
||||
|
||||
#endif /* cglms_frustums_h */
|
||||
82
include/cglm/struct/io.h
Normal file
82
include/cglm/struct/io.h
Normal file
@ -0,0 +1,82 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_mat4_print(mat4 matrix, FILE *ostream);
|
||||
CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
|
||||
CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
|
||||
*/
|
||||
|
||||
#ifndef cglms_ios_h
|
||||
#define cglms_ios_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../io.h"
|
||||
#include "mat4.h"
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_mat4_print(mat4s matrix,
|
||||
FILE * __restrict ostream) {
|
||||
|
||||
glm_mat4_print(matrix.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_mat3_print(mat3s matrix,
|
||||
FILE * __restrict ostream) {
|
||||
glm_mat3_print(matrix.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec4_print(vec4s vec,
|
||||
FILE * __restrict ostream) {
|
||||
glm_vec4_print(vec.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec3_print(vec3s vec,
|
||||
FILE * __restrict ostream) {
|
||||
glm_vec3_print(vec.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_ivec3_print(ivec3s vec,
|
||||
FILE * __restrict ostream) {
|
||||
glm_ivec3_print(vec.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_versor_print(versors vec,
|
||||
FILE * __restrict ostream) {
|
||||
glm_versor_print(vec.raw, ostream);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_aabb_print(vec3s bbox[2],
|
||||
const char * __restrict tag,
|
||||
FILE * __restrict ostream) {
|
||||
vec3 rawBbox[2];
|
||||
|
||||
glms_vec3_unpack(rawBbox, bbox, 2);
|
||||
glm_aabb_print(rawBbox, tag, ostream);
|
||||
}
|
||||
|
||||
#endif /* cglms_ios_h */
|
||||
258
include/cglm/struct/mat2.h
Normal file
258
include/cglm/struct/mat2.h
Normal file
@ -0,0 +1,258 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLM_MAT2_IDENTITY_INIT
|
||||
GLM_MAT2_ZERO_INIT
|
||||
GLM_MAT2_IDENTITY
|
||||
GLM_MAT2_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE void glms_mat2_identity(mat2 mat)
|
||||
CGLM_INLINE void glms_mat2_identity_array(mat2 * restrict mat, size_t count)
|
||||
CGLM_INLINE void glms_mat2_zero(mat2 mat)
|
||||
CGLM_INLINE void glms_mat2_mul(mat2 m1, mat2 m2, mat2 dest)
|
||||
CGLM_INLINE void glms_mat2_transpose_to(mat2 m, mat2 dest)
|
||||
CGLM_INLINE void glms_mat2_transpose(mat2 m)
|
||||
CGLM_INLINE void glms_mat2_mulv(mat2 m, vec2 v, vec2 dest)
|
||||
CGLM_INLINE float glms_mat2_trace(mat2 m)
|
||||
CGLM_INLINE void glms_mat2_scale(mat2 m, float s)
|
||||
CGLM_INLINE float glms_mat2_det(mat2 mat)
|
||||
CGLM_INLINE void glms_mat2_inv(mat2 mat, mat2 dest)
|
||||
CGLM_INLINE void glms_mat2_swap_col(mat2 mat, int col1, int col2)
|
||||
CGLM_INLINE void glms_mat2_swap_row(mat2 mat, int row1, int row2)
|
||||
CGLM_INLINE float glms_mat2_rmc(vec2 r, mat2 m, vec2 c)
|
||||
*/
|
||||
|
||||
#ifndef cglms_mat2_h
|
||||
#define cglms_mat2_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../mat2.h"
|
||||
|
||||
#define GLMS_MAT2_IDENTITY_INIT {GLM_MAT2_IDENTITY_INIT}
|
||||
#define GLMS_MAT2_ZERO_INIT {GLM_MAT2_ZERO_INIT}
|
||||
|
||||
/* for C only */
|
||||
#define GLMS_MAT2_IDENTITY ((mat3s)GLMS_MAT2_IDENTITY_INIT)
|
||||
#define GLMS_MAT2_ZERO ((mat3s)GLMS_MAT2_ZERO_INIT)
|
||||
|
||||
/*!
|
||||
* @brief make given matrix identity. It is identical with below,
|
||||
* but it is more easy to do that with this func especially for members
|
||||
* e.g. glm_mat2_identity(aStruct->aMatrix);
|
||||
*
|
||||
* @code
|
||||
* glm_mat2_copy(GLM_MAT2_IDENTITY, mat); // C only
|
||||
*
|
||||
* // or
|
||||
* mat2 mat = GLM_MAT2_IDENTITY_INIT;
|
||||
* @endcode
|
||||
*
|
||||
* @returns identity matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_identity(void) {
|
||||
mat2s r;
|
||||
glm_mat2_identity(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix array's each element identity matrix
|
||||
*
|
||||
* @param[in, out] mat matrix array (must be aligned (16)
|
||||
* if alignment is not disabled)
|
||||
*
|
||||
* @param[in] count count of matrices
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_mat2_identity_array(mat2s * __restrict mat, size_t count) {
|
||||
CGLM_ALIGN_MAT mat2s t = GLMS_MAT2_IDENTITY_INIT;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
glm_mat2_copy(t.raw, mat[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix zero.
|
||||
*
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_zero(void) {
|
||||
mat2s r;
|
||||
glm_mat2_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply m1 and m2 to dest
|
||||
*
|
||||
* m1, m2 and dest matrices can be same matrix, it is possible to write this:
|
||||
*
|
||||
* @code
|
||||
* mat2 m = GLM_MAT2_IDENTITY_INIT;
|
||||
* glm_mat2_mul(m, m, m);
|
||||
* @endcode
|
||||
*
|
||||
* @param[in] m1 left matrix
|
||||
* @param[in] m2 right matrix
|
||||
*
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_mul(mat2s m1, mat2s m2) {
|
||||
mat2s r;
|
||||
glm_mat2_mul(m1.raw, m2.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief transpose mat2
|
||||
*
|
||||
* @param[in] m matrix to transpose
|
||||
*
|
||||
* @returns transposed matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_transpose(mat2s m) {
|
||||
glm_mat2_transpose(m.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply mat2 with vec2 (column vector) and store in dest vector
|
||||
*
|
||||
* @param[in] m mat2 (left)
|
||||
* @param[in] v vec2 (right, column vector)
|
||||
* @returns vec2 (result, column vector)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_mat2_mulv(mat2s m, vec2s v) {
|
||||
vec2s r;
|
||||
glm_mat2_mulv(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief trace of matrix
|
||||
*
|
||||
* sum of the elements on the main diagonal from upper left to the lower right
|
||||
*
|
||||
* @param[in] m matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat2_trace(mat2s m) {
|
||||
return glm_mat2_trace(m.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scale (multiply with scalar) matrix
|
||||
*
|
||||
* multiply matrix with scalar
|
||||
*
|
||||
* @param[in, out] m matrix
|
||||
* @param[in] s scalar
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_scale(mat2s m, float s) {
|
||||
glm_mat2_scale(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mat2 determinant
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
*
|
||||
* @return determinant
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat2_det(mat2s mat) {
|
||||
return glm_mat2_det(mat.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inverse mat2 and store in dest
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_inv(mat2s mat) {
|
||||
mat2s r;
|
||||
glm_mat2_inv(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix columns
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] col1 col1
|
||||
* @param[in] col2 col2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_swap_col(mat2s mat, int col1, int col2) {
|
||||
glm_mat2_swap_col(mat.raw, col1, col2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix rows
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] row1 row1
|
||||
* @param[in] row2 row2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat2s
|
||||
glms_mat2_swap_row(mat2s mat, int row1, int row2) {
|
||||
glm_mat2_swap_row(mat.raw, row1, row2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief helper for R (row vector) * M (matrix) * C (column vector)
|
||||
*
|
||||
* rmc stands for Row * Matrix * Column
|
||||
*
|
||||
* the result is scalar because R * M = Matrix1x2 (row vector),
|
||||
* then Matrix1x2 * Vec2 (column vector) = Matrix1x1 (Scalar)
|
||||
*
|
||||
* @param[in] r row vector or matrix1x2
|
||||
* @param[in] m matrix2x2
|
||||
* @param[in] c column vector or matrix2x1
|
||||
*
|
||||
* @return scalar value e.g. Matrix1x1
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat2_rmc(vec2s r, mat2s m, vec2s c) {
|
||||
return glm_mat2_rmc(r.raw, m.raw, c.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_mat2_h */
|
||||
285
include/cglm/struct/mat3.h
Normal file
285
include/cglm/struct/mat3.h
Normal 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
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_MAT3_IDENTITY_INIT
|
||||
GLMS_MAT3_ZERO_INIT
|
||||
GLMS_MAT3_IDENTITY
|
||||
GLMS_MAT3_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE mat3s glms_mat3_copy(mat3s mat);
|
||||
CGLM_INLINE mat3s glms_mat3_identity(void);
|
||||
CGLM_INLINE void glms_mat3_identity_array(mat3s * __restrict mat, size_t count);
|
||||
CGLM_INLINE mat3s glms_mat3_zero(void);
|
||||
CGLM_INLINE mat3s glms_mat3_mul(mat3s m1, mat3s m2);
|
||||
CGLM_INLINE ma3s glms_mat3_transpose(mat3s m);
|
||||
CGLM_INLINE vec3s glms_mat3_mulv(mat3s m, vec3s v);
|
||||
CGLM_INLINE float glms_mat3_trace(mat3s m);
|
||||
CGLM_INLINE versor glms_mat3_quat(mat3s m);
|
||||
CGLM_INLINE mat3s glms_mat3_scale(mat3s m, float s);
|
||||
CGLM_INLINE float glms_mat3_det(mat3s mat);
|
||||
CGLM_INLINE mat3s glms_mat3_inv(mat3s mat);
|
||||
CGLM_INLINE mat3s glms_mat3_swap_col(mat3s mat, int col1, int col2);
|
||||
CGLM_INLINE mat3s glms_mat3_swap_row(mat3s mat, int row1, int row2);
|
||||
CGLM_INLINE float glms_mat3_rmc(vec3s r, mat3s m, vec3s c);
|
||||
*/
|
||||
|
||||
#ifndef cglms_mat3s_h
|
||||
#define cglms_mat3s_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../mat3.h"
|
||||
#include "vec3.h"
|
||||
|
||||
#define GLMS_MAT3_IDENTITY_INIT {GLM_MAT3_IDENTITY_INIT}
|
||||
#define GLMS_MAT3_ZERO_INIT {GLM_MAT3_ZERO_INIT}
|
||||
|
||||
/* for C only */
|
||||
#define GLMS_MAT3_IDENTITY ((mat3s)GLMS_MAT3_IDENTITY_INIT)
|
||||
#define GLMS_MAT3_ZERO ((mat3s)GLMS_MAT3_ZERO_INIT)
|
||||
|
||||
/*!
|
||||
* @brief copy all members of [mat] to [dest]
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_copy(mat3s mat) {
|
||||
mat3s r;
|
||||
glm_mat3_copy(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix identity. It is identical with below,
|
||||
* but it is more easy to do that with this func especially for members
|
||||
* e.g. glm_mat3_identity(aStruct->aMatrix);
|
||||
*
|
||||
* @code
|
||||
* glm_mat3_copy(GLM_MAT3_IDENTITY, mat); // C only
|
||||
*
|
||||
* // or
|
||||
* mat3 mat = GLM_MAT3_IDENTITY_INIT;
|
||||
* @endcode
|
||||
*
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_identity(void) {
|
||||
mat3s r;
|
||||
glm_mat3_identity(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix array's each element identity matrix
|
||||
*
|
||||
* @param[in, out] mat matrix array (must be aligned (16/32)
|
||||
* if alignment is not disabled)
|
||||
*
|
||||
* @param[in] count count of matrices
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_mat3_identity_array(mat3s * __restrict mat, size_t count) {
|
||||
CGLM_ALIGN_MAT mat3s t = GLMS_MAT3_IDENTITY_INIT;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
glm_mat3_copy(t.raw, mat[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix zero.
|
||||
*
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_zero(void) {
|
||||
mat3s r;
|
||||
glm_mat3_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply m1 and m2 to dest
|
||||
*
|
||||
* m1, m2 and dest matrices can be same matrix, it is possible to write this:
|
||||
*
|
||||
* @code
|
||||
* mat3 m = GLM_MAT3_IDENTITY_INIT;
|
||||
* glm_mat3_mul(m, m, m);
|
||||
* @endcode
|
||||
*
|
||||
* @param[in] m1 left matrix
|
||||
* @param[in] m2 right matrix
|
||||
* @returns destination matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_mul(mat3s m1, mat3s m2) {
|
||||
mat3s r;
|
||||
glm_mat3_mul(m1.raw, m2.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief tranpose mat3 and store result in same matrix
|
||||
*
|
||||
* @param[in, out] m source and dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_transpose(mat3s m) {
|
||||
glm_mat3_transpose(m.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply mat3 with vec3 (column vector) and store in dest vector
|
||||
*
|
||||
* @param[in] m mat3 (left)
|
||||
* @param[in] v vec3 (right, column vector)
|
||||
* @returns vec3 (result, column vector)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_mat3_mulv(mat3s m, vec3s v) {
|
||||
vec3s r;
|
||||
glm_mat3_mulv(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief trace of matrix
|
||||
*
|
||||
* sum of the elements on the main diagonal from upper left to the lower right
|
||||
*
|
||||
* @param[in] m matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat3_trace(mat3s m) {
|
||||
return glm_mat3_trace(m.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert mat3 to quaternion
|
||||
*
|
||||
* @param[in] m rotation matrix
|
||||
* @returns destination quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_mat3_quat(mat3s m) {
|
||||
versors r;
|
||||
glm_mat3_quat(m.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scale (multiply with scalar) matrix
|
||||
*
|
||||
* multiply matrix with scalar
|
||||
*
|
||||
* @param[in] m matrix
|
||||
* @param[in] s scalar
|
||||
* @returns scaled matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_scale(mat3s m, float s) {
|
||||
glm_mat3_scale(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mat3 determinant
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
*
|
||||
* @return determinant
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat3_det(mat3s mat) {
|
||||
return glm_mat3_det(mat.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inverse mat3 and store in dest
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @returns inverse matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_inv(mat3s mat) {
|
||||
mat3s r;
|
||||
glm_mat3_inv(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix columns
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] col1 col1
|
||||
* @param[in] col2 col2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_swap_col(mat3s mat, int col1, int col2) {
|
||||
glm_mat3_swap_col(mat.raw, col1, col2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix rows
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] row1 row1
|
||||
* @param[in] row2 row2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat3_swap_row(mat3s mat, int row1, int row2) {
|
||||
glm_mat3_swap_row(mat.raw, row1, row2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief helper for R (row vector) * M (matrix) * C (column vector)
|
||||
*
|
||||
* rmc stands for Row * Matrix * Column
|
||||
*
|
||||
* the result is scalar because R * M = Matrix1x3 (row vector),
|
||||
* then Matrix1x3 * Vec3 (column vector) = Matrix1x1 (Scalar)
|
||||
*
|
||||
* @param[in] r row vector or matrix1x3
|
||||
* @param[in] m matrix3x3
|
||||
* @param[in] c column vector or matrix3x1
|
||||
*
|
||||
* @return scalar value e.g. Matrix1x1
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat3_rmc(vec3s r, mat3s m, vec3s c) {
|
||||
return glm_mat3_rmc(r.raw, m.raw, c.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_mat3s_h */
|
||||
459
include/cglm/struct/mat4.h
Normal file
459
include/cglm/struct/mat4.h
Normal file
@ -0,0 +1,459 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*!
|
||||
* Most of functions in this header are optimized manually with SIMD
|
||||
* if available. You dont need to call/incude SIMD headers manually
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_MAT4_IDENTITY_INIT
|
||||
GLMS_MAT4_ZERO_INIT
|
||||
GLMS_MAT4_IDENTITY
|
||||
GLMS_MAT4_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE mat4s glms_mat4_ucopy(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_copy(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_identity(void);
|
||||
CGLM_INLINE void glms_mat4_identity_array(mat4s * __restrict mat, size_t count);
|
||||
CGLM_INLINE mat4s glms_mat4_zero(void);
|
||||
CGLM_INLINE mat3s glms_mat4_pick3(mat4s mat);
|
||||
CGLM_INLINE mat3s glms_mat4_pick3t(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_ins3(mat3s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_mul(mat4s m1, mat4s m2);
|
||||
CGLM_INLINE mat4s glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len);
|
||||
CGLM_INLINE vec4s glms_mat4_mulv(mat4s m, vec4s v);
|
||||
CGLM_INLINE float glms_mat4_trace(mat4s m);
|
||||
CGLM_INLINE float glms_mat4_trace3(mat4s m);
|
||||
CGLM_INLINE versors glms_mat4_quat(mat4s m);
|
||||
CGLM_INLINE vec3s glms_mat4_mulv3(mat4s m, vec3s v, float last);
|
||||
CGLM_INLINE mat4s glms_mat4_transpose(mat4s m);
|
||||
CGLM_INLINE mat4s glms_mat4_scale_p(mat4s m, float s);
|
||||
CGLM_INLINE mat4s glms_mat4_scale(mat4s m, float s);
|
||||
CGLM_INLINE float glms_mat4_det(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_inv(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_inv_fast(mat4s mat);
|
||||
CGLM_INLINE mat4s glms_mat4_swap_col(mat4s mat, int col1, int col2);
|
||||
CGLM_INLINE mat4s glms_mat4_swap_row(mat4s mat, int row1, int row2);
|
||||
CGLM_INLINE float glms_mat4_rmc(vec4s r, mat4s m, vec4s c);
|
||||
*/
|
||||
|
||||
#ifndef cglms_mat4s_h
|
||||
#define cglms_mat4s_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../mat4.h"
|
||||
#include "vec4.h"
|
||||
#include "vec3.h"
|
||||
|
||||
#define GLMS_MAT4_IDENTITY_INIT {GLM_MAT4_IDENTITY_INIT}
|
||||
#define GLMS_MAT4_ZERO_INIT {GLM_MAT4_ZERO_INIT}
|
||||
|
||||
/* for C only */
|
||||
#define GLMS_MAT4_IDENTITY ((mat4s)GLMS_MAT4_IDENTITY_INIT)
|
||||
#define GLMS_MAT4_ZERO ((mat4s)GLMS_MAT4_ZERO_INIT)
|
||||
|
||||
/*!
|
||||
* @brief copy all members of [mat] to [dest]
|
||||
*
|
||||
* matrix may not be aligned, u stands for unaligned, this may be useful when
|
||||
* copying a matrix from external source e.g. asset importer...
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_ucopy(mat4s mat) {
|
||||
mat4s r;
|
||||
glm_mat4_ucopy(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy all members of [mat] to [dest]
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_copy(mat4s mat) {
|
||||
mat4s r;
|
||||
glm_mat4_copy(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix identity. It is identical with below,
|
||||
* but it is more easy to do that with this func especially for members
|
||||
* e.g. glm_mat4_identity(aStruct->aMatrix);
|
||||
*
|
||||
* @code
|
||||
* glm_mat4_copy(GLM_MAT4_IDENTITY, mat); // C only
|
||||
*
|
||||
* // or
|
||||
* mat4 mat = GLM_MAT4_IDENTITY_INIT;
|
||||
* @endcode
|
||||
*
|
||||
* @retuns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_identity(void) {
|
||||
mat4s r;
|
||||
glm_mat4_identity(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix array's each element identity matrix
|
||||
*
|
||||
* @param[in, out] mat matrix array (must be aligned (16/32)
|
||||
* if alignment is not disabled)
|
||||
*
|
||||
* @param[in] count count of matrices
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_mat4_identity_array(mat4s * __restrict mat, size_t count) {
|
||||
CGLM_ALIGN_MAT mat4s t = GLMS_MAT4_IDENTITY_INIT;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
glm_mat4_copy(t.raw, mat[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given matrix zero.
|
||||
*
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_zero(void) {
|
||||
mat4s r;
|
||||
glm_mat4_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy upper-left of mat4 to mat3
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat4_pick3(mat4s mat) {
|
||||
mat3s r;
|
||||
glm_mat4_pick3(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy upper-left of mat4 to mat3 (transposed)
|
||||
*
|
||||
* the postfix t stands for transpose
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_mat4_pick3t(mat4s mat) {
|
||||
mat3s r;
|
||||
glm_mat4_pick3t(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy mat3 to mat4's upper-left
|
||||
*
|
||||
* @param[in] mat source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_ins3(mat3s mat) {
|
||||
mat4s r;
|
||||
glm_mat4_ins3(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply m1 and m2 to dest
|
||||
*
|
||||
* m1, m2 and dest matrices can be same matrix, it is possible to write this:
|
||||
*
|
||||
* @code
|
||||
* mat4 m = GLM_MAT4_IDENTITY_INIT;
|
||||
* glm_mat4_mul(m, m, m);
|
||||
* @endcode
|
||||
*
|
||||
* @param[in] m1 left matrix
|
||||
* @param[in] m2 right matrix
|
||||
* @returns destination matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_mul(mat4s m1, mat4s m2) {
|
||||
mat4s r;
|
||||
glm_mat4_mul(m1.raw, m2.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mupliply N mat4 matrices and store result in dest
|
||||
*
|
||||
* this function lets you multiply multiple (more than two or more...) matrices
|
||||
* <br><br>multiplication will be done in loop, this may reduce instructions
|
||||
* size but if <b>len</b> is too small then compiler may unroll whole loop,
|
||||
* usage:
|
||||
* @code
|
||||
* mat m1, m2, m3, m4, res;
|
||||
*
|
||||
* res = glm_mat4_mulN((mat4 *[]){&m1, &m2, &m3, &m4}, 4);
|
||||
* @endcode
|
||||
*
|
||||
* @warning matrices parameter is pointer array not mat4 array!
|
||||
*
|
||||
* @param[in] matrices mat4 * array
|
||||
* @param[in] len matrices count
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_mulN(mat4s * __restrict matrices[], uint32_t len) {
|
||||
CGLM_ALIGN_MAT mat4s r = GLMS_MAT4_IDENTITY_INIT;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
r = glms_mat4_mul(r, *matrices[i]);
|
||||
}
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply mat4 with vec4 (column vector) and store in dest vector
|
||||
*
|
||||
* @param[in] m mat4 (left)
|
||||
* @param[in] v vec4 (right, column vector)
|
||||
* @returns vec4 (result, column vector)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_mat4_mulv(mat4s m, vec4s v) {
|
||||
vec4s r;
|
||||
glm_mat4_mulv(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief trace of matrix
|
||||
*
|
||||
* sum of the elements on the main diagonal from upper left to the lower right
|
||||
*
|
||||
* @param[in] m matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat4_trace(mat4s m) {
|
||||
return glm_mat4_trace(m.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief trace of matrix (rotation part)
|
||||
*
|
||||
* sum of the elements on the main diagonal from upper left to the lower right
|
||||
*
|
||||
* @param[in] m matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat4_trace3(mat4s m) {
|
||||
return glm_mat4_trace3(m.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert mat4's rotation part to quaternion
|
||||
*
|
||||
* @param[in] m affine matrix
|
||||
* @returns destination quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_mat4_quat(mat4s m) {
|
||||
versors r;
|
||||
glm_mat4_quat(m.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply vector with mat4
|
||||
*
|
||||
* @param[in] m mat4(affine transform)
|
||||
* @param[in] v vec3
|
||||
* @param[in] last 4th item to make it vec4
|
||||
* @returns result vector (vec3)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_mat4_mulv3(mat4s m, vec3s v, float last) {
|
||||
vec3s r;
|
||||
glm_mat4_mulv3(m.raw, v.raw, last, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief tranpose mat4 and store result in same matrix
|
||||
*
|
||||
* @param[in] m source
|
||||
* @returns result
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_transpose(mat4s m) {
|
||||
glm_mat4_transpose(m.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scale (multiply with scalar) matrix without simd optimization
|
||||
*
|
||||
* multiply matrix with scalar
|
||||
*
|
||||
* @param[in] m matrix
|
||||
* @param[in] s scalar
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_scale_p(mat4s m, float s) {
|
||||
glm_mat4_scale_p(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief scale (multiply with scalar) matrix
|
||||
*
|
||||
* multiply matrix with scalar
|
||||
*
|
||||
* @param[in] m matrix
|
||||
* @param[in] s scalar
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_scale(mat4s m, float s) {
|
||||
glm_mat4_scale(m.raw, s);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mat4 determinant
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
*
|
||||
* @return determinant
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat4_det(mat4s mat) {
|
||||
return glm_mat4_det(mat.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inverse mat4 and store in dest
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @returns inverse matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_inv(mat4s mat) {
|
||||
mat4s r;
|
||||
glm_mat4_inv(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inverse mat4 and store in dest
|
||||
*
|
||||
* this func uses reciprocal approximation without extra corrections
|
||||
* e.g Newton-Raphson. this should work faster than normal,
|
||||
* to get more precise use glm_mat4_inv version.
|
||||
*
|
||||
* NOTE: You will lose precision, glm_mat4_inv is more accurate
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @returns inverse matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_inv_fast(mat4s mat) {
|
||||
mat4s r;
|
||||
glm_mat4_inv_fast(mat.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix columns
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] col1 col1
|
||||
* @param[in] col2 col2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_swap_col(mat4s mat, int col1, int col2) {
|
||||
glm_mat4_swap_col(mat.raw, col1, col2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swap two matrix rows
|
||||
*
|
||||
* @param[in] mat matrix
|
||||
* @param[in] row1 row1
|
||||
* @param[in] row2 row2
|
||||
* @returns matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_mat4_swap_row(mat4s mat, int row1, int row2) {
|
||||
glm_mat4_swap_row(mat.raw, row1, row2);
|
||||
return mat;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief helper for R (row vector) * M (matrix) * C (column vector)
|
||||
*
|
||||
* rmc stands for Row * Matrix * Column
|
||||
*
|
||||
* the result is scalar because R * M = Matrix1x4 (row vector),
|
||||
* then Matrix1x4 * Vec4 (column vector) = Matrix1x1 (Scalar)
|
||||
*
|
||||
* @param[in] r row vector or matrix1x4
|
||||
* @param[in] m matrix4x4
|
||||
* @param[in] c column vector or matrix4x1
|
||||
*
|
||||
* @return scalar value e.g. B(s)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_mat4_rmc(vec4s r, mat4s m, vec4s c) {
|
||||
return glm_mat4_rmc(r.raw, m.raw, c.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_mat4s_h */
|
||||
40
include/cglm/struct/plane.h
Normal file
40
include/cglm/struct/plane.h
Normal file
@ -0,0 +1,40 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_planes_h
|
||||
#define cglms_planes_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../plane.h"
|
||||
#include "vec4.h"
|
||||
|
||||
/*
|
||||
Plane equation: Ax + By + Cz + D = 0;
|
||||
|
||||
It stored in vec4 as [A, B, C, D]. (A, B, C) is normal and D is distance
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec4s glms_plane_normalize(vec4s plane);
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @brief normalizes a plane
|
||||
*
|
||||
* @param[in] plane plane to normalize
|
||||
* @returns normalized plane
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_plane_normalize(vec4s plane) {
|
||||
glm_plane_normalize(plane.raw);
|
||||
return plane;
|
||||
}
|
||||
|
||||
#endif /* cglms_planes_h */
|
||||
120
include/cglm/struct/project.h
Normal file
120
include/cglm/struct/project.h
Normal file
@ -0,0 +1,120 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_projects_h
|
||||
#define cglms_projects_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../project.h"
|
||||
#include "vec3.h"
|
||||
#include "vec4.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*!
|
||||
* @brief maps the specified viewport coordinates into specified space [1]
|
||||
* the matrix should contain projection matrix.
|
||||
*
|
||||
* if you don't have ( and don't want to have ) an inverse matrix then use
|
||||
* glm_unproject version. You may use existing inverse of matrix in somewhere
|
||||
* else, this is why glm_unprojecti exists to save save inversion cost
|
||||
*
|
||||
* [1] space:
|
||||
* 1- if m = invProj: View Space
|
||||
* 2- if m = invViewProj: World Space
|
||||
* 3- if m = invMVP: Object Space
|
||||
*
|
||||
* You probably want to map the coordinates into object space
|
||||
* so use invMVP as m
|
||||
*
|
||||
* Computing viewProj:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
* glm_mat4_inv(viewProj, invMVP);
|
||||
*
|
||||
* @param[in] pos point/position in viewport coordinates
|
||||
* @param[in] invMat matrix (see brief)
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
* @returns unprojected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_unprojecti(vec3s pos, mat4s invMat, vec4s vp) {
|
||||
vec3s r;
|
||||
glm_unprojecti(pos.raw, invMat.raw, vp.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief maps the specified viewport coordinates into specified space [1]
|
||||
* the matrix should contain projection matrix.
|
||||
*
|
||||
* this is same as glm_unprojecti except this function get inverse matrix for
|
||||
* you.
|
||||
*
|
||||
* [1] space:
|
||||
* 1- if m = proj: View Space
|
||||
* 2- if m = viewProj: World Space
|
||||
* 3- if m = MVP: Object Space
|
||||
*
|
||||
* You probably want to map the coordinates into object space
|
||||
* so use MVP as m
|
||||
*
|
||||
* Computing viewProj and MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] pos point/position in viewport coordinates
|
||||
* @param[in] m matrix (see brief)
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
* @returns unprojected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_unproject(vec3s pos, mat4s m, vec4s vp) {
|
||||
vec3s r;
|
||||
glm_unproject(pos.raw, m.raw, vp.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief map object coordinates to window coordinates
|
||||
*
|
||||
* Computing MVP:
|
||||
* glm_mat4_mul(proj, view, viewProj);
|
||||
* glm_mat4_mul(viewProj, model, MVP);
|
||||
*
|
||||
* @param[in] pos object coordinates
|
||||
* @param[in] m MVP matrix
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
* @returns projected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_project(vec3s pos, mat4s m, vec4s vp) {
|
||||
vec3s r;
|
||||
glm_project(pos.raw, m.raw, vp.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief define a picking region
|
||||
*
|
||||
* @param[in] center center [x, y] of a picking region in window coordinates
|
||||
* @param[in] size size [width, height] of the picking region in window coordinates
|
||||
* @param[in] vp viewport as [x, y, width, height]
|
||||
* @returns projected coordinates
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_pickmatrix(vec2s center, vec2s size, vec4s vp) {
|
||||
mat4s res;
|
||||
glm_pickmatrix(center.raw, size.raw, vp.raw, res.raw);
|
||||
return res;
|
||||
}
|
||||
|
||||
#endif /* cglms_projects_h */
|
||||
565
include/cglm/struct/quat.h
Normal file
565
include/cglm/struct/quat.h
Normal file
@ -0,0 +1,565 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_QUAT_IDENTITY_INIT
|
||||
GLMS_QUAT_IDENTITY
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE versors glms_quat_identity(void)
|
||||
CGLM_INLINE void glms_quat_identity_array(versor *q, size_t count)
|
||||
CGLM_INLINE versors glms_quat_init(float x, float y, float z, float w)
|
||||
CGLM_INLINE versors glms_quatv(float angle, vec3s axis)
|
||||
CGLM_INLINE versors glms_quat(float angle, float x, float y, float z)
|
||||
CGLM_INLINE versors glms_quat_from_vecs(vec3s a, vec3s b)
|
||||
CGLM_INLINE float glms_quat_norm(versors q)
|
||||
CGLM_INLINE versors glms_quat_normalize(versors q)
|
||||
CGLM_INLINE float glms_quat_dot(versors p, versors q)
|
||||
CGLM_INLINE versors glms_quat_conjugate(versors q)
|
||||
CGLM_INLINE versors glms_quat_inv(versors q)
|
||||
CGLM_INLINE versors glms_quat_add(versors p, versors q)
|
||||
CGLM_INLINE versors glms_quat_sub(versors p, versors q)
|
||||
CGLM_INLINE vec3s glms_quat_imagn(versors q)
|
||||
CGLM_INLINE float glms_quat_imaglen(versors q)
|
||||
CGLM_INLINE float glms_quat_angle(versors q)
|
||||
CGLM_INLINE vec3s glms_quat_axis(versors q)
|
||||
CGLM_INLINE versors glms_quat_mul(versors p, versors q)
|
||||
CGLM_INLINE mat4s glms_quat_mat4(versors q)
|
||||
CGLM_INLINE mat4s glms_quat_mat4t(versors q)
|
||||
CGLM_INLINE mat3s glms_quat_mat3(versors q)
|
||||
CGLM_INLINE mat3s glms_quat_mat3t(versors q)
|
||||
CGLM_INLINE versors glms_quat_lerp(versors from, versors to, float t)
|
||||
CGLM_INLINE versors glms_quat_lerpc(versors from, versors to, float t)
|
||||
CGLM_INLINE versors glms_quat_nlerp(versors from, versors to, float t)
|
||||
CGLM_INLINE versors glms_quat_slerp(versors from, versors to, float t)
|
||||
CGLM_INLINE mat4s. glms_quat_look(vec3s eye, versors ori)
|
||||
CGLM_INLINE versors glms_quat_for(vec3s dir, vec3s fwd, vec3s up)
|
||||
CGLM_INLINE versors glms_quat_forp(vec3s from, vec3s to, vec3s fwd, vec3s up)
|
||||
CGLM_INLINE vec3s glms_quat_rotatev(versors q, vec3s v)
|
||||
CGLM_INLINE mat4s glms_quat_rotate(mat4s m, versors q)
|
||||
CGLM_INLINE mat4s glms_quat_rotate_at(mat4s m, versors q, vec3s pivot)
|
||||
CGLM_INLINE mat4s glms_quat_rotate_atm(versors q, vec3s pivot)
|
||||
*/
|
||||
|
||||
#ifndef cglms_quat_h
|
||||
#define cglms_quat_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../plane.h"
|
||||
#include "../quat.h"
|
||||
|
||||
/*
|
||||
* IMPORTANT:
|
||||
* ----------------------------------------------------------------------------
|
||||
* cglm stores quat as [x, y, z, w] since v0.3.6
|
||||
*
|
||||
* it was [w, x, y, z] before v0.3.6 it has been changed to [x, y, z, w]
|
||||
* with v0.3.6 version.
|
||||
* ----------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
#define GLMS_QUAT_IDENTITY_INIT {GLM_QUAT_IDENTITY_INIT}
|
||||
#define GLMS_QUAT_IDENTITY ((versors)GLMS_QUAT_IDENTITY_INIT)
|
||||
|
||||
/*!
|
||||
* @brief makes given quat to identity
|
||||
*
|
||||
* @returns identity quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_identity(void) {
|
||||
versors dest;
|
||||
glm_quat_identity(dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make given quaternion array's each element identity quaternion
|
||||
*
|
||||
* @param[in, out] q quat array (must be aligned (16)
|
||||
* if alignment is not disabled)
|
||||
*
|
||||
* @param[in] count count of quaternions
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_quat_identity_array(versors * __restrict q, size_t count) {
|
||||
CGLM_ALIGN(16) versor v = GLM_QUAT_IDENTITY_INIT;
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
glm_vec4_copy(v, q[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inits quaterion with raw values
|
||||
*
|
||||
* @param[in] x x
|
||||
* @param[in] y y
|
||||
* @param[in] z z
|
||||
* @param[in] w w (real part)
|
||||
* @returns quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_init(float x, float y, float z, float w) {
|
||||
versors dest;
|
||||
glm_quat_init(dest.raw, x, y, z, w);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW quaternion with axis vector
|
||||
*
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] axis axis
|
||||
* @returns quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quatv(float angle, vec3s axis) {
|
||||
versors dest;
|
||||
glm_quatv(dest.raw, angle, axis.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates NEW quaternion with individual axis components
|
||||
*
|
||||
* @param[in] angle angle (radians)
|
||||
* @param[in] x axis.x
|
||||
* @param[in] y axis.y
|
||||
* @param[in] z axis.z
|
||||
* @returns quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat(float angle, float x, float y, float z) {
|
||||
versors dest;
|
||||
glm_quat(dest.raw, angle, x, y, z);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief compute quaternion rotating vector A to vector B
|
||||
*
|
||||
* @param[in] a vec3 (must have unit length)
|
||||
* @param[in] b vec3 (must have unit length)
|
||||
* @returns quaternion (of unit length)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_from_vecs(vec3s a, vec3s b) {
|
||||
versors dest;
|
||||
glm_quat_from_vecs(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns norm (magnitude) of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_quat_norm(versors q) {
|
||||
return glm_quat_norm(q.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief normalize quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_normalize(versors q) {
|
||||
versors dest;
|
||||
glm_quat_normalize_to(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief dot product of two quaternion
|
||||
*
|
||||
* @param[in] p quaternion 1
|
||||
* @param[in] q quaternion 2
|
||||
* @returns dot product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_quat_dot(versors p, versors q) {
|
||||
return glm_quat_dot(p.raw, q.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief conjugate of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns conjugate
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_conjugate(versors q) {
|
||||
versors dest;
|
||||
glm_quat_conjugate(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief inverse of non-zero quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns inverse quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_inv(versors q) {
|
||||
versors dest;
|
||||
glm_quat_inv(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add (componentwise) two quaternions and store result in dest
|
||||
*
|
||||
* @param[in] p quaternion 1
|
||||
* @param[in] q quaternion 2
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_add(versors p, versors q) {
|
||||
versors dest;
|
||||
glm_quat_add(p.raw, q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract (componentwise) two quaternions and store result in dest
|
||||
*
|
||||
* @param[in] p quaternion 1
|
||||
* @param[in] q quaternion 2
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_sub(versors p, versors q) {
|
||||
versors dest;
|
||||
glm_quat_sub(p.raw, q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns normalized imaginary part of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_quat_imagn(versors q) {
|
||||
vec3s dest;
|
||||
glm_normalize_to(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns length of imaginary part of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_quat_imaglen(versors q) {
|
||||
return glm_quat_imaglen(q.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief returns angle of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_quat_angle(versors q) {
|
||||
return glm_quat_angle(q.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief axis of quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns axis of quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_quat_axis(versors q) {
|
||||
vec3s dest;
|
||||
glm_quat_axis(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiplies two quaternion and stores result in dest
|
||||
* this is also called Hamilton Product
|
||||
*
|
||||
* According to WikiPedia:
|
||||
* The product of two rotation quaternions [clarification needed] will be
|
||||
* equivalent to the rotation q followed by the rotation p
|
||||
*
|
||||
* @param[in] p quaternion 1
|
||||
* @param[in] q quaternion 2
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_mul(versors p, versors q) {
|
||||
versors dest;
|
||||
glm_quat_mul(p.raw, q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert quaternion to mat4
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_mat4(versors q) {
|
||||
mat4s dest;
|
||||
glm_quat_mat4(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert quaternion to mat4 (transposed)
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns result matrix as transposed
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_mat4t(versors q) {
|
||||
mat4s dest;
|
||||
glm_quat_mat4t(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert quaternion to mat3
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_quat_mat3(versors q) {
|
||||
mat3s dest;
|
||||
glm_quat_mat3(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief convert quaternion to mat3 (transposed)
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat3s
|
||||
glms_quat_mat3t(versors q) {
|
||||
mat3s dest;
|
||||
glm_quat_mat3t(q.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief interpolates between two quaternions
|
||||
* using linear interpolation (LERP)
|
||||
*
|
||||
* @param[in] from from
|
||||
* @param[in] to to
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_lerp(versors from, versors to, float t) {
|
||||
versors dest;
|
||||
glm_quat_lerp(from.raw, to.raw, t, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief interpolates between two quaternions
|
||||
* using linear interpolation (LERP)
|
||||
*
|
||||
* @param[in] from from
|
||||
* @param[in] to to
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_lerpc(versors from, versors to, float t) {
|
||||
versors dest;
|
||||
glm_quat_lerpc(from.raw, to.raw, t, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief interpolates between two quaternions
|
||||
* taking the shortest rotation path using
|
||||
* normalized linear interpolation (NLERP)
|
||||
*
|
||||
* @param[in] from from
|
||||
* @param[in] to to
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_nlerp(versors from, versors to, float t) {
|
||||
versors dest;
|
||||
glm_quat_nlerp(from.raw, to.raw, t, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief interpolates between two quaternions
|
||||
* using spherical linear interpolation (SLERP)
|
||||
*
|
||||
* @param[in] from from
|
||||
* @param[in] to to
|
||||
* @param[in] t amout
|
||||
* @returns result quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_slerp(versors from, versors to, float t) {
|
||||
versors dest;
|
||||
glm_quat_slerp(from.raw, to.raw, t, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates view matrix using quaternion as camera orientation
|
||||
*
|
||||
* @param[in] eye eye
|
||||
* @param[in] ori orientation in world space as quaternion
|
||||
* @returns view matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_look(vec3s eye, versors ori) {
|
||||
mat4s dest;
|
||||
glm_quat_look(eye.raw, ori.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates look rotation quaternion
|
||||
*
|
||||
* @param[in] dir direction to look
|
||||
* @param[in] up up vector
|
||||
* @returns destination quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_for(vec3s dir, vec3s up) {
|
||||
versors dest;
|
||||
glm_quat_for(dir.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief creates look rotation quaternion using source and
|
||||
* destination positions p suffix stands for position
|
||||
*
|
||||
* @param[in] from source point
|
||||
* @param[in] to destination point
|
||||
* @param[in] up up vector
|
||||
* @returns destination quaternion
|
||||
*/
|
||||
CGLM_INLINE
|
||||
versors
|
||||
glms_quat_forp(vec3s from, vec3s to, vec3s up) {
|
||||
versors dest;
|
||||
glm_quat_forp(from.raw, to.raw, up.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate vector using using quaternion
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @param[in] v vector to rotate
|
||||
* @returns rotated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_quat_rotatev(versors q, vec3s v) {
|
||||
vec3s dest;
|
||||
glm_quat_rotatev(q.raw, v.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix using quaternion
|
||||
*
|
||||
* @param[in] m existing transform matrix
|
||||
* @param[in] q quaternion
|
||||
* @returns rotated matrix/transform
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_rotate(mat4s m, versors q) {
|
||||
glm_quat_rotate(m.raw, q.raw, m.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate existing transform matrix using quaternion at pivot point
|
||||
*
|
||||
* @param[in, out] m existing transform matrix
|
||||
* @param[in] q quaternion
|
||||
* @returns pivot
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_rotate_at(mat4s m, versors q, vec3s pivot) {
|
||||
glm_quat_rotate_at(m.raw, q.raw, pivot.raw);
|
||||
return m;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate NEW transform matrix using quaternion at pivot point
|
||||
*
|
||||
* this creates rotation matrix, it assumes you don't have a matrix
|
||||
*
|
||||
* this should work faster than glm_quat_rotate_at because it reduces
|
||||
* one glm_translate.
|
||||
*
|
||||
* @param[in] q quaternion
|
||||
* @returns pivot
|
||||
*/
|
||||
CGLM_INLINE
|
||||
mat4s
|
||||
glms_quat_rotate_atm(versors q, vec3s pivot) {
|
||||
mat4s dest;
|
||||
glm_quat_rotate_atm(dest.raw, q.raw, pivot.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_quat_h */
|
||||
93
include/cglm/struct/sphere.h
Normal file
93
include/cglm/struct/sphere.h
Normal file
@ -0,0 +1,93 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglms_spheres_h
|
||||
#define cglms_spheres_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../sphere.h"
|
||||
#include "mat4.h"
|
||||
|
||||
/*
|
||||
Sphere Representation in cglm: [center.x, center.y, center.z, radii]
|
||||
|
||||
You could use this representation or you can convert it to vec4 before call
|
||||
any function
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @brief helper for getting sphere radius
|
||||
*
|
||||
* @param[in] s sphere
|
||||
*
|
||||
* @return returns radii
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_sphere_radii(vec4s s) {
|
||||
return glm_sphere_radii(s.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief apply transform to sphere, it is just wrapper for glm_mat4_mulv3
|
||||
*
|
||||
* @param[in] s sphere
|
||||
* @param[in] m transform matrix
|
||||
* @returns transformed sphere
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_sphere_transform(vec4s s, mat4s m) {
|
||||
vec4s r;
|
||||
glm_sphere_transform(s.raw, m.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief merges two spheres and creates a new one
|
||||
*
|
||||
* two sphere must be in same space, for instance if one in world space then
|
||||
* the other must be in world space too, not in local space.
|
||||
*
|
||||
* @param[in] s1 sphere 1
|
||||
* @param[in] s2 sphere 2
|
||||
* returns merged/extended sphere
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_sphere_merge(vec4s s1, vec4s s2) {
|
||||
vec4s r;
|
||||
glm_sphere_merge(s1.raw, s2.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if two sphere intersects
|
||||
*
|
||||
* @param[in] s1 sphere
|
||||
* @param[in] s2 other sphere
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_sphere_sphere(vec4s s1, vec4s s2) {
|
||||
return glm_sphere_sphere(s1.raw, s2.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if sphere intersects with point
|
||||
*
|
||||
* @param[in] s sphere
|
||||
* @param[in] point point
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_sphere_point(vec4s s, vec3s point) {
|
||||
return glm_sphere_point(s.raw, point.raw);
|
||||
}
|
||||
|
||||
#endif /* cglms_spheres_h */
|
||||
239
include/cglm/struct/vec2-ext.h
Normal file
239
include/cglm/struct/vec2-ext.h
Normal file
@ -0,0 +1,239 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @brief SIMD like functions
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec2s glms_vec2_fill(float val)
|
||||
CGLM_INLINE bool glms_vec2_eq(vec2s v, float val)
|
||||
CGLM_INLINE bool glms_vec2_eq_eps(vec2s v, float val)
|
||||
CGLM_INLINE bool glms_vec2_eq_all(vec2s v)
|
||||
CGLM_INLINE bool glms_vec2_eqv(vec2s a, vec2s b)
|
||||
CGLM_INLINE bool glms_vec2_eqv_eps(vec2s a, vec2s b)
|
||||
CGLM_INLINE float glms_vec2_max(vec2s v)
|
||||
CGLM_INLINE float glms_vec2_min(vec2s v)
|
||||
CGLM_INLINE bool glms_vec2_isnan(vec2s v)
|
||||
CGLM_INLINE bool glms_vec2_isinf(vec2s v)
|
||||
CGLM_INLINE bool glms_vec2_isvalid(vec2s v)
|
||||
CGLM_INLINE vec2s glms_vec2_sign(vec2s v)
|
||||
CGLM_INLINE vec2s glms_vec2_sqrt(vec2s v)
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec2s_ext_h
|
||||
#define cglms_vec2s_ext_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec2-ext.h"
|
||||
|
||||
/*!
|
||||
* @brief fill a vector with specified value
|
||||
*
|
||||
* @param[in] val value
|
||||
* @returns dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_fill(float val) {
|
||||
vec2s r;
|
||||
glm_vec2_fill(r.raw, val);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (without epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_eq(vec2s v, float val) {
|
||||
return glm_vec2_eq(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (with epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_eq_eps(vec2s v, float val) {
|
||||
return glm_vec2_eq_eps(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vectors members are equal (without epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_eq_all(vec2s v) {
|
||||
return glm_vec2_eq_all(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (without epsilon)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_eqv(vec2s a, vec2s b) {
|
||||
return glm_vec2_eqv(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (with epsilon)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_eqv_eps(vec2s a, vec2s b) {
|
||||
return glm_vec2_eqv_eps(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max value of vector
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_max(vec2s v) {
|
||||
return glm_vec2_max(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min value of vector
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_min(vec2s v) {
|
||||
return glm_vec2_min(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are NaN (not a number)
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_isnan(vec2s v) {
|
||||
return glm_vec2_isnan(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are INFINITY
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_isinf(vec2s v) {
|
||||
return glm_vec2_isinf(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are valid number
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec2_isvalid(vec2s v) {
|
||||
return glm_vec2_isvalid(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief get sign of 32 bit float as +1, -1, 0
|
||||
*
|
||||
* Important: It returns 0 for zero/NaN input
|
||||
*
|
||||
* @param v vector
|
||||
* @returns sign vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_sign(vec2s v) {
|
||||
vec2s r;
|
||||
glm_vec2_sign(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief square root of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_sqrt(vec2s v) {
|
||||
vec2s r;
|
||||
glm_vec2_sqrt(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief treat vectors as complex numbers and multiply them as such.
|
||||
*
|
||||
* @param[in] a left number
|
||||
* @param[in] b right number
|
||||
* @param[out] dest destination number
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_complex_mul(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_complex_mul(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief treat vectors as complex numbers and divide them as such.
|
||||
*
|
||||
* @param[in] a left number (numerator)
|
||||
* @param[in] b right number (denominator)
|
||||
* @param[out] dest destination number
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_complex_div(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_complex_div(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief treat the vector as a complex number and conjugate it as such.
|
||||
*
|
||||
* @param[in] a the number
|
||||
* @param[out] dest destination number
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_complex_conjugate(vec2s a, vec2s dest) {
|
||||
glm_vec2_complex_conjugate(a.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec2s_ext_h */
|
||||
561
include/cglm/struct/vec2.h
Normal file
561
include/cglm/struct/vec2.h
Normal file
@ -0,0 +1,561 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_VEC2_ONE_INIT
|
||||
GLMS_VEC2_ZERO_INIT
|
||||
GLMS_VEC2_ONE
|
||||
GLMS_VEC2_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE vec2s glms_vec2(vec3s v3)
|
||||
CGLM_INLINE void glms_vec2_pack(vec2s dst[], vec2 src[], size_t len)
|
||||
CGLM_INLINE void glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len)
|
||||
CGLM_INLINE vec2s glms_vec2_zero(void)
|
||||
CGLM_INLINE vec2s glms_vec2_one(void)
|
||||
CGLM_INLINE float glms_vec2_dot(vec2s a, vec2s b)
|
||||
CGLM_INLINE float glms_vec2_cross(vec2s a, vec2s b)
|
||||
CGLM_INLINE float glms_vec2_norm2(vec2s v)
|
||||
CGLM_INLINE float glms_vec2_norm(vec2s v)
|
||||
CGLM_INLINE vec2s glms_vec2_add(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_adds(vec2s a, float s)
|
||||
CGLM_INLINE vec2s glms_vec2_sub(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_subs(vec2s a, float s)
|
||||
CGLM_INLINE vec2s glms_vec2_mul(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_scale(vec2s v, float s)
|
||||
CGLM_INLINE vec2s glms_vec2_scale_as(vec2s v, float s)
|
||||
CGLM_INLINE vec2s glms_vec2_div(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_divs(vec2s a, float s)
|
||||
CGLM_INLINE vec2s glms_vec2_addadd(vec2s a, vec2s b, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_subadd(vec2s a, vec2s b, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_muladd(vec2s a, vec2s b, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_muladds(vec2s a, float s, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_minadd(vec2s a, vec2s b, vec2s dest)
|
||||
CGLM_INLINE vec2s glms_vec2_negate(vec2s v)
|
||||
CGLM_INLINE vec2s glms_vec2_normalize(vec2s v)
|
||||
CGLM_INLINE vec2s glms_vec2_rotate(vec2s v, float angle, vec2s axis)
|
||||
CGLM_INLINE float glms_vec2_distance(vec2s a, vec2s b)
|
||||
CGLM_INLINE float glms_vec2_distance2(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_maxv(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_minv(vec2s a, vec2s b)
|
||||
CGLM_INLINE vec2s glms_vec2_clamp(vec2s v, float minVal, float maxVal)
|
||||
CGLM_INLINE vec2s glms_vec2_lerp(vec2s from, vec2s to, float t)
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec2s_h
|
||||
#define cglms_vec2s_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec2.h"
|
||||
#include "vec2-ext.h"
|
||||
|
||||
#define GLMS_VEC2_ONE_INIT {GLM_VEC2_ONE_INIT}
|
||||
#define GLMS_VEC2_ZERO_INIT {GLM_VEC2_ZERO_INIT}
|
||||
|
||||
#define GLMS_VEC2_ONE ((vec2s)GLMS_VEC2_ONE_INIT)
|
||||
#define GLMS_VEC2_ZERO ((vec2s)GLMS_VEC2_ZERO_INIT)
|
||||
|
||||
/*!
|
||||
* @brief init vec2 using vec2
|
||||
*
|
||||
* @param[in] v3 vector3
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2(vec3s v3) {
|
||||
vec2s r;
|
||||
glm_vec2(v3.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief pack an array of vec2 into an array of vec2s
|
||||
*
|
||||
* @param[out] dst array of vec2
|
||||
* @param[in] src array of vec2s
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec2_pack(vec2s dst[], vec2 src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec2_copy(src[i], dst[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief unpack an array of vec2s into an array of vec2
|
||||
*
|
||||
* @param[out] dst array of vec2s
|
||||
* @param[in] src array of vec2
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec2_unpack(vec2 dst[], vec2s src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec2_copy(src[i].raw, dst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector zero
|
||||
*
|
||||
* @returns zero vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_zero(void) {
|
||||
vec2s r;
|
||||
glm_vec2_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector one
|
||||
*
|
||||
* @returns one vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_one(void) {
|
||||
vec2s r;
|
||||
glm_vec2_one(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec2 dot product
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
*
|
||||
* @return dot product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_dot(vec2s a, vec2s b) {
|
||||
return glm_vec2_dot(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec2 cross product
|
||||
*
|
||||
* REF: http://allenchou.net/2013/07/cross-product-of-2d-vectors/
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
*
|
||||
* @return Z component of cross product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_cross(vec2s a, vec2s b) {
|
||||
return glm_vec2_cross(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm * norm (magnitude) of vec
|
||||
*
|
||||
* we can use this func instead of calling norm * norm, because it would call
|
||||
* sqrtf fuction twice but with this func we can avoid func call, maybe this is
|
||||
* not good name for this func
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return norm * norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_norm2(vec2s v) {
|
||||
return glm_vec2_norm2(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm (magnitude) of vec2
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_norm(vec2s v) {
|
||||
return glm_vec2_norm(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add a vector to b vector store result in dest
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_add(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_add(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add scalar to v vector store result in dest (d = v + s)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_adds(vec2s a, float s) {
|
||||
vec2s r;
|
||||
glm_vec2_adds(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract b vector from a vector store result in dest
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_sub(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_sub(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract scalar from v vector store result in dest (d = v - s)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_subs(vec2s a, float s) {
|
||||
vec2s r;
|
||||
glm_vec2_subs(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply two vector (component-wise multiplication)
|
||||
*
|
||||
* @param a vector1
|
||||
* @param b vector2
|
||||
* @returns v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_mul(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_mul(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply/scale vec2 vector with scalar: result = v * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_scale(vec2s v, float s) {
|
||||
vec2s r;
|
||||
glm_vec2_scale(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vec2 vector scale as specified: result = unit(v) * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_scale_as(vec2s v, float s) {
|
||||
vec2s r;
|
||||
glm_vec2_scale_as(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vector with another component-wise division: d = a / b
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_div(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_div(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vector with scalar: d = v / s
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns result = (a[0]/s, a[1]/s, a[2]/s)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_divs(vec2s a, float s) {
|
||||
vec2s r;
|
||||
glm_vec2_divs(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add two vectors and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a + b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_addadd(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_addadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief sub two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a + b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_subadd(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_subadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_muladd(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_muladd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul vector with scalar and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_muladds(vec2s a, float s, vec2s dest) {
|
||||
glm_vec2_muladds(a.raw, s, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add max of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += max(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_maxadd(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_maxadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add min of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += min(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_minadd(vec2s a, vec2s b, vec2s dest) {
|
||||
glm_vec2_minadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief negate vector components
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns negated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_negate(vec2s v) {
|
||||
glm_vec2_negate(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief normalize vec2 and store result in same vec
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns normalized vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_normalize(vec2s v) {
|
||||
glm_vec2_normalize(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate vec2 by angle using Rodrigues' rotation formula
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] angle angle by radians
|
||||
* @returns rotated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_rotate(vec2s v, float angle) {
|
||||
vec2s r;
|
||||
glm_vec2_rotate(v.raw, angle, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return distance
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_distance(vec2s a, vec2s b) {
|
||||
return glm_vec2_distance(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief squared distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return squared distance (distance * distance)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec2_distance2(vec2s a, vec2s b) {
|
||||
return glm_vec2_distance2(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_maxv(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_maxv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_minv(vec2s a, vec2s b) {
|
||||
vec2s r;
|
||||
glm_vec2_minv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief clamp vector's individual members between min and max values
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] minVal minimum value
|
||||
* @param[in] maxVal maximum value
|
||||
* @returns clamped vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_clamp(vec2s v, float minVal, float maxVal) {
|
||||
glm_vec2_clamp(v.raw, minVal, maxVal);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec2s
|
||||
glms_vec2_lerp(vec2s from, vec2s to, float t) {
|
||||
vec2s r;
|
||||
glm_vec2_lerp(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec2s_h */
|
||||
257
include/cglm/struct/vec3-ext.h
Normal file
257
include/cglm/struct/vec3-ext.h
Normal file
@ -0,0 +1,257 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @brief SIMD like functions
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec3s glms_vec3_broadcast(float val);
|
||||
CGLM_INLINE vec3s glms_vec3_fill(float val);
|
||||
CGLM_INLINE bool glms_vec3_eq(vec3s v, float val);
|
||||
CGLM_INLINE bool glms_vec3_eq_eps(vec3s v, float val);
|
||||
CGLM_INLINE bool glms_vec3_eq_all(vec3s v);
|
||||
CGLM_INLINE bool glms_vec3_eqv(vec3s a, vec3s b);
|
||||
CGLM_INLINE bool glms_vec3_eqv_eps(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_vec3_max(vec3s v);
|
||||
CGLM_INLINE float glms_vec3_min(vec3s v);
|
||||
CGLM_INLINE bool glms_vec3_isnan(vec3s v);
|
||||
CGLM_INLINE bool glms_vec3_isinf(vec3s v);
|
||||
CGLM_INLINE bool glms_vec3_isvalid(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_sign(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_abs(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_fract(vec3s v);
|
||||
CGLM_INLINE float glms_vec3_hadd(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_sqrt(vec3s v);
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec3s_ext_h
|
||||
#define cglms_vec3s_ext_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec3-ext.h"
|
||||
|
||||
/*!
|
||||
* @brief fill a vector with specified value
|
||||
*
|
||||
* @param[in] val value
|
||||
* @returns dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_broadcast(float val) {
|
||||
vec3s r;
|
||||
glm_vec3_broadcast(val, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief fill a vector with specified value
|
||||
*
|
||||
* @param[in] val value
|
||||
* @returns dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_fill(float val) {
|
||||
vec3s r;
|
||||
glm_vec3_fill(r.raw, val);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (without epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_eq(vec3s v, float val) {
|
||||
return glm_vec3_eq(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (with epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_eq_eps(vec3s v, float val) {
|
||||
return glm_vec3_eq_eps(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vectors members are equal (without epsilon)
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_eq_all(vec3s v) {
|
||||
return glm_vec3_eq_all(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (without epsilon)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_eqv(vec3s a, vec3s b) {
|
||||
return glm_vec3_eqv(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (with epsilon)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_eqv_eps(vec3s a, vec3s b) {
|
||||
return glm_vec3_eqv_eps(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max value of vector
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_max(vec3s v) {
|
||||
return glm_vec3_max(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min value of vector
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_min(vec3s v) {
|
||||
return glm_vec3_min(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are NaN (not a number)
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_isnan(vec3s v) {
|
||||
return glm_vec3_isnan(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are INFINITY
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_isinf(vec3s v) {
|
||||
return glm_vec3_isinf(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are valid number
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec3_isvalid(vec3s v) {
|
||||
return glm_vec3_isvalid(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief get sign of 32 bit float as +1, -1, 0
|
||||
*
|
||||
* Important: It returns 0 for zero/NaN input
|
||||
*
|
||||
* @param v vector
|
||||
* @returns sign vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_sign(vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_sign(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief absolute value of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @return destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_abs(vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_abs(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief fractional part of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @return dest destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_fract(vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_fract(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vector reduction by summation
|
||||
* @warning could overflow
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @return sum of all vector's elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_hadd(vec3s v) {
|
||||
return glm_vec3_hadd(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief square root of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_sqrt(vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_sqrt(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec3s_ext_h */
|
||||
970
include/cglm/struct/vec3.h
Normal file
970
include/cglm/struct/vec3.h
Normal file
@ -0,0 +1,970 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_VEC3_ONE_INIT
|
||||
GLMS_VEC3_ZERO_INIT
|
||||
GLMS_VEC3_ONE
|
||||
GLMS_VEC3_ZERO
|
||||
GLMS_YUP
|
||||
GLMS_ZUP
|
||||
GLMS_XUP
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE vec3s glms_vec3(vec4s v4);
|
||||
CGLM_INLINE void glms_vec3_pack(vec3s dst[], vec3 src[], size_t len);
|
||||
CGLM_INLINE void glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len);
|
||||
CGLM_INLINE vec3s glms_vec3_zero(void);
|
||||
CGLM_INLINE vec3s glms_vec3_one(void);
|
||||
CGLM_INLINE float glms_vec3_dot(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_vec3_norm2(vec3s v);
|
||||
CGLM_INLINE float glms_vec3_norm(vec3s v);
|
||||
CGLM_INLINE float glms_vec3_norm_one(vec3s v);
|
||||
CGLM_INLINE float glms_vec3_norm_inf(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_add(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_adds(vec3s a, float s);
|
||||
CGLM_INLINE vec3s glms_vec3_sub(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_subs(vec3s a, float s);
|
||||
CGLM_INLINE vec3s glms_vec3_mul(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_scale(vec3s v, float s);
|
||||
CGLM_INLINE vec3s glms_vec3_scale_as(vec3s v, float s);
|
||||
CGLM_INLINE vec3s glms_vec3_div(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_divs(vec3s a, float s);
|
||||
CGLM_INLINE vec3s glms_vec3_addadd(vec3s a, vec3s b, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_subadd(vec3s a, vec3s b, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_muladd(vec3s a, vec3s b, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_muladds(vec3s a, float s, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_minadd(vec3s a, vec3s b, vec3s dest);
|
||||
CGLM_INLINE vec3s glms_vec3_flipsign(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_negate(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_inv(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_normalize(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_cross(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_crossn(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_vec3_angle(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_rotate(vec3s v, float angle, vec3s axis);
|
||||
CGLM_INLINE vec3s glms_vec3_rotate_m4(mat4s m, vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_rotate_m3(mat3s m, vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_proj(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_center(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_vec3_distance(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_vec3_distance2(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_maxv(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_minv(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_vec3_ortho(vec3s v);
|
||||
CGLM_INLINE vec3s glms_vec3_clamp(vec3s v, float minVal, float maxVal);
|
||||
CGLM_INLINE vec3s glms_vec3_lerp(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_lerpc(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_mix(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_mixc(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_step_uni(float edge, vec3s x);
|
||||
CGLM_INLINE vec3s glms_vec3_step(vec3s edge, vec3s x);
|
||||
CGLM_INLINE vec3s glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x);
|
||||
CGLM_INLINE vec3s glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x);
|
||||
CGLM_INLINE vec3s glms_vec3_smoothinterp(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_smoothinterpc(vec3s from, vec3s to, float t);
|
||||
CGLM_INLINE vec3s glms_vec3_swizzle(vec3s v, int mask);
|
||||
|
||||
Convenient:
|
||||
CGLM_INLINE vec3s glms_cross(vec3s a, vec3s b);
|
||||
CGLM_INLINE float glms_dot(vec3s a, vec3s b);
|
||||
CGLM_INLINE vec3s glms_normalize(vec3s v);
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec3s_h
|
||||
#define cglms_vec3s_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec3.h"
|
||||
#include "vec3-ext.h"
|
||||
|
||||
#define GLMS_VEC3_ONE_INIT {GLM_VEC3_ONE_INIT}
|
||||
#define GLMS_VEC3_ZERO_INIT {GLM_VEC3_ZERO_INIT}
|
||||
|
||||
#define GLMS_VEC3_ONE ((vec3s)GLMS_VEC3_ONE_INIT)
|
||||
#define GLMS_VEC3_ZERO ((vec3s)GLMS_VEC3_ZERO_INIT)
|
||||
|
||||
#define GLMS_YUP ((vec3s){{0.0f, 1.0f, 0.0f}})
|
||||
#define GLMS_ZUP ((vec3s){{0.0f, 0.0f, 1.0f}})
|
||||
#define GLMS_XUP ((vec3s){{1.0f, 0.0f, 0.0f}})
|
||||
|
||||
/*!
|
||||
* @brief init vec3 using vec4
|
||||
*
|
||||
* @param[in] v4 vector4
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3(vec4s v4) {
|
||||
vec3s r;
|
||||
glm_vec3(v4.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief pack an array of vec3 into an array of vec3s
|
||||
*
|
||||
* @param[out] dst array of vec3
|
||||
* @param[in] src array of vec3s
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec3_pack(vec3s dst[], vec3 src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec3_copy(src[i], dst[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief unpack an array of vec3s into an array of vec3
|
||||
*
|
||||
* @param[out] dst array of vec3s
|
||||
* @param[in] src array of vec3
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec3_unpack(vec3 dst[], vec3s src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec3_copy(src[i].raw, dst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector zero
|
||||
*
|
||||
* @returns zero vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_zero(void) {
|
||||
vec3s r;
|
||||
glm_vec3_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector one
|
||||
*
|
||||
* @returns one vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_one(void) {
|
||||
vec3s r;
|
||||
glm_vec3_one(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec3 dot product
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
*
|
||||
* @return dot product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_dot(vec3s a, vec3s b) {
|
||||
return glm_vec3_dot(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm * norm (magnitude) of vec
|
||||
*
|
||||
* we can use this func instead of calling norm * norm, because it would call
|
||||
* sqrtf fuction twice but with this func we can avoid func call, maybe this is
|
||||
* not good name for this func
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return norm * norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_norm2(vec3s v) {
|
||||
return glm_vec3_norm2(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm (magnitude) of vec3
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_norm(vec3s v) {
|
||||
return glm_vec3_norm(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief L1 norm of vec3
|
||||
* Also known as Manhattan Distance or Taxicab norm.
|
||||
* L1 Norm is the sum of the magnitudes of the vectors in a space.
|
||||
* It is calculated as the sum of the absolute values of the vector components.
|
||||
* In this norm, all the components of the vector are weighted equally.
|
||||
*
|
||||
* This computes:
|
||||
* R = |v[0]| + |v[1]| + |v[2]|
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return L1 norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_norm_one(vec3s v) {
|
||||
return glm_vec3_norm_one(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief Infinity norm of vec3
|
||||
* Also known as Maximum norm.
|
||||
* Infinity Norm is the largest magnitude among each element of a vector.
|
||||
* It is calculated as the maximum of the absolute values of the vector components.
|
||||
*
|
||||
* This computes:
|
||||
* inf norm = max(|v[0]|, |v[1]|, |v[2]|)
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return Infinity norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_norm_inf(vec3s v) {
|
||||
return glm_vec3_norm_inf(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add a vector to b vector store result in dest
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_add(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_add(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add scalar to v vector store result in dest (d = v + s)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_adds(vec3s a, float s) {
|
||||
vec3s r;
|
||||
glm_vec3_adds(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract b vector from a vector store result in dest
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_sub(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_sub(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract scalar from v vector store result in dest (d = v - s)
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_subs(vec3s a, float s) {
|
||||
vec3s r;
|
||||
glm_vec3_subs(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply two vector (component-wise multiplication)
|
||||
*
|
||||
* @param a vector1
|
||||
* @param b vector2
|
||||
* @returns v3 = (a[0] * b[0], a[1] * b[1], a[2] * b[2])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_mul(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_mul(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply/scale vec3 vector with scalar: result = v * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_scale(vec3s v, float s) {
|
||||
vec3s r;
|
||||
glm_vec3_scale(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vec3 vector scale as specified: result = unit(v) * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_scale_as(vec3s v, float s) {
|
||||
vec3s r;
|
||||
glm_vec3_scale_as(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vector with another component-wise division: d = a / b
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_div(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_div(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vector with scalar: d = v / s
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns result = (a[0]/s, a[1]/s, a[2]/s)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_divs(vec3s a, float s) {
|
||||
vec3s r;
|
||||
glm_vec3_divs(a.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add two vectors and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a + b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_addadd(vec3s a, vec3s b, vec3s dest) {
|
||||
glm_vec3_addadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief sub two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a + b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_subadd(vec3s a, vec3s b, vec3s dest) {
|
||||
glm_vec3_subadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_muladd(vec3s a, vec3s b, vec3s dest) {
|
||||
glm_vec3_muladd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul vector with scalar and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_muladds(vec3s a, float s, vec3s dest) {
|
||||
glm_vec3_muladds(a.raw, s, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add max of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += max(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_maxadd(vec3s a, vec3s b, vec3s dest) {
|
||||
glm_vec3_maxadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add min of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += min(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_minadd(vec3s a, vec3s b, vec3s dest) {
|
||||
glm_vec3_minadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief negate vector components and store result in dest
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns result vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_flipsign(vec3s v) {
|
||||
glm_vec3_flipsign(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief negate vector components
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns negated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_negate(vec3s v) {
|
||||
glm_vec3_negate(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief normalize vec3 and store result in same vec
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns normalized vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_normalize(vec3s v) {
|
||||
glm_vec3_normalize(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief cross product of two vector (RH)
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_cross(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_cross(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief cross product of two vector (RH) and normalize the result
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_crossn(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_crossn(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief angle betwen two vector
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
*
|
||||
* @return angle as radians
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_angle(vec3s a, vec3s b) {
|
||||
return glm_vec3_angle(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief rotate vec3 around axis by angle using Rodrigues' rotation formula
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] axis axis vector (must be unit vector)
|
||||
* @param[in] angle angle by radians
|
||||
* @returns rotated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_rotate(vec3s v, float angle, vec3s axis) {
|
||||
glm_vec3_rotate(v.raw, angle, axis.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief apply rotation matrix to vector
|
||||
*
|
||||
* matrix format should be (no perspective):
|
||||
* a b c x
|
||||
* e f g y
|
||||
* i j k z
|
||||
* 0 0 0 w
|
||||
*
|
||||
* @param[in] m affine matrix or rot matrix
|
||||
* @param[in] v vector
|
||||
* @returns rotated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_rotate_m4(mat4s m, vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_rotate_m4(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief apply rotation matrix to vector
|
||||
*
|
||||
* @param[in] m affine matrix or rot matrix
|
||||
* @param[in] v vector
|
||||
* @returns rotated vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_rotate_m3(mat3s m, vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_rotate_m3(m.raw, v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief project a vector onto b vector
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns projected vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_proj(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_proj(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief find center point of two vector
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns center point
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_center(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_center(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return distance
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_distance(vec3s a, vec3s b) {
|
||||
return glm_vec3_distance(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief squared distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return squared distance (distance * distance)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec3_distance2(vec3s a, vec3s b) {
|
||||
return glm_vec3_distance2(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_maxv(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_maxv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_minv(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_vec3_minv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief possible orthogonal/perpendicular vector
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns orthogonal/perpendicular vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_ortho(vec3s v) {
|
||||
vec3s r;
|
||||
glm_vec3_ortho(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief clamp vector's individual members between min and max values
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] minVal minimum value
|
||||
* @param[in] maxVal maximum value
|
||||
* @returns clamped vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_clamp(vec3s v, float minVal, float maxVal) {
|
||||
glm_vec3_clamp(v.raw, minVal, maxVal);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_lerp(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_lerp(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_lerpc(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_lerpc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_mix(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_mix(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_mixc(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_mixc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function (unidimensional)
|
||||
*
|
||||
* @param[in] edge threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns 0.0 if x < edge, else 1.0
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_step_uni(float edge, vec3s x) {
|
||||
vec3s r;
|
||||
glm_vec3_step_uni(edge, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function
|
||||
*
|
||||
* @param[in] edge threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns 0.0 if x < edge, else 1.0
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_step(vec3s edge, vec3s x) {
|
||||
vec3s r;
|
||||
glm_vec3_step(edge.raw, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function with a smooth transition (unidimensional)
|
||||
*
|
||||
* @param[in] edge0 low threshold
|
||||
* @param[in] edge1 high threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_smoothstep_uni(float edge0, float edge1, vec3s x) {
|
||||
vec3s r;
|
||||
glm_vec3_smoothstep_uni(edge0, edge1, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function with a smooth transition
|
||||
*
|
||||
* @param[in] edge0 low threshold
|
||||
* @param[in] edge1 high threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_smoothstep(vec3s edge0, vec3s edge1, vec3s x) {
|
||||
vec3s r;
|
||||
glm_vec3_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief smooth Hermite interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_smoothinterp(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_smoothinterp(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief smooth Hermite interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_smoothinterpc(vec3s from, vec3s to, float t) {
|
||||
vec3s r;
|
||||
glm_vec3_smoothinterpc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec3 cross product
|
||||
*
|
||||
* this is just convenient wrapper
|
||||
*
|
||||
* @param[in] a source 1
|
||||
* @param[in] b source 2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_cross(vec3s a, vec3s b) {
|
||||
vec3s r;
|
||||
glm_cross(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec3 dot product
|
||||
*
|
||||
* this is just convenient wrapper
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return dot product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_dot(vec3s a, vec3s b) {
|
||||
return glm_dot(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief normalize vec3 and store result in same vec
|
||||
*
|
||||
* this is just convenient wrapper
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns normalized vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_normalize(vec3s v) {
|
||||
glm_normalize(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swizzle vector components
|
||||
*
|
||||
* you can use existin masks e.g. GLM_XXX, GLM_ZYX
|
||||
*
|
||||
* @param[in] v source
|
||||
* @param[in] mask mask
|
||||
* @returns swizzled vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec3_swizzle(vec3s v, int mask) {
|
||||
vec3s dest;
|
||||
glm_vec3_swizzle(v.raw, mask, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec3s_h */
|
||||
257
include/cglm/struct/vec4-ext.h
Normal file
257
include/cglm/struct/vec4-ext.h
Normal file
@ -0,0 +1,257 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @brief SIMD like functions
|
||||
*/
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE vec4s glms_vec4_broadcast(float val);
|
||||
CGLM_INLINE vec4s glms_vec4_fill(float val);
|
||||
CGLM_INLINE bool glms_vec4_eq(vec4s v, float val);
|
||||
CGLM_INLINE bool glms_vec4_eq_eps(vec4s v, float val);
|
||||
CGLM_INLINE bool glms_vec4_eq_all(vec4s v);
|
||||
CGLM_INLINE bool glms_vec4_eqv(vec4s a, vec4s b);
|
||||
CGLM_INLINE bool glms_vec4_eqv_eps(vec4s a, vec4s b);
|
||||
CGLM_INLINE float glms_vec4_max(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_min(vec4s v);
|
||||
CGLM_INLINE bool glms_vec4_isnan(vec4s v);
|
||||
CGLM_INLINE bool glms_vec4_isinf(vec4s v);
|
||||
CGLM_INLINE bool glms_vec4_isvalid(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_sign(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_abs(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_fract(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_hadd(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_sqrt(vec4s v);
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec4s_ext_h
|
||||
#define cglms_vec4s_ext_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec4-ext.h"
|
||||
|
||||
/*!
|
||||
* @brief fill a vector with specified value
|
||||
*
|
||||
* @param val value
|
||||
* @returns dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_broadcast(float val) {
|
||||
vec4s r;
|
||||
glm_vec4_broadcast(val, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief fill a vector with specified value
|
||||
*
|
||||
* @param val value
|
||||
* @returns dest
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_fill(float val) {
|
||||
vec4s r;
|
||||
glm_vec4_fill(r.raw, val);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (without epsilon)
|
||||
*
|
||||
* @param v vector
|
||||
* @param val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_eq(vec4s v, float val) {
|
||||
return glm_vec4_eq(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to value (with epsilon)
|
||||
*
|
||||
* @param v vector
|
||||
* @param val value
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_eq_eps(vec4s v, float val) {
|
||||
return glm_vec4_eq_eps(v.raw, val);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vectors members are equal (without epsilon)
|
||||
*
|
||||
* @param v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_eq_all(vec4s v) {
|
||||
return glm_vec4_eq_all(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (without epsilon)
|
||||
*
|
||||
* @param a vector
|
||||
* @param b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_eqv(vec4s a, vec4s b) {
|
||||
return glm_vec4_eqv(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if vector is equal to another (with epsilon)
|
||||
*
|
||||
* @param a vector
|
||||
* @param b vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_eqv_eps(vec4s a, vec4s b) {
|
||||
return glm_vec4_eqv_eps(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max value of vector
|
||||
*
|
||||
* @param v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_max(vec4s v) {
|
||||
return glm_vec4_max(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min value of vector
|
||||
*
|
||||
* @param v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_min(vec4s v) {
|
||||
return glm_vec4_min(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if one of items is NaN (not a number)
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_isnan(vec4s v) {
|
||||
return glm_vec4_isnan(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if one of items is INFINITY
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_isinf(vec4s v) {
|
||||
return glm_vec4_isinf(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief check if all items are valid number
|
||||
* you should only use this in DEBUG mode or very critical asserts
|
||||
*
|
||||
* @param[in] v vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glms_vec4_isvalid(vec4s v) {
|
||||
return glm_vec4_isvalid(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief get sign of 32 bit float as +1, -1, 0
|
||||
*
|
||||
* Important: It returns 0 for zero/NaN input
|
||||
*
|
||||
* @param v vector
|
||||
* @returns sign vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_sign(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_sign(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief absolute value of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_abs(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_abs(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief fractional part of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns dest destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_fract(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_fract(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vector reduction by summation
|
||||
* @warning could overflow
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @return sum of all vector's elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_hadd(vec4s v) {
|
||||
return glm_vec4_hadd(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief square root of each vector item
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_sqrt(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_sqrt(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec4s_ext_h */
|
||||
814
include/cglm/struct/vec4.h
Normal file
814
include/cglm/struct/vec4.h
Normal file
@ -0,0 +1,814 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
/*
|
||||
Macros:
|
||||
GLMS_VEC4_ONE_INIT
|
||||
GLMS_VEC4_BLACK_INIT
|
||||
GLMS_VEC4_ZERO_INIT
|
||||
GLMS_VEC4_ONE
|
||||
GLMS_VEC4_BLACK
|
||||
GLMS_VEC4_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE vec4s glms_vec4(vec3s v3, float last);
|
||||
CGLM_INLINE vec3s glms_vec4_copy3(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_copy(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_ucopy(vec4s v);
|
||||
CGLM_INLINE void glms_vec4_pack(vec4s dst[], vec4 src[], size_t len);
|
||||
CGLM_INLINE void glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len);
|
||||
CGLM_INLINE float glms_vec4_dot(vec4s a, vec4s b);
|
||||
CGLM_INLINE float glms_vec4_norm2(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_norm(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_norm_one(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_norm_inf(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_add(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_adds(vec4s v, float s);
|
||||
CGLM_INLINE vec4s glms_vec4_sub(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_subs(vec4s v, float s);
|
||||
CGLM_INLINE vec4s glms_vec4_mul(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_scale(vec4s v, float s);
|
||||
CGLM_INLINE vec4s glms_vec4_scale_as(vec4s v, float s);
|
||||
CGLM_INLINE vec4s glms_vec4_div(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_divs(vec4s v, float s);
|
||||
CGLM_INLINE vec4s glms_vec4_addadd(vec4s a, vec4s b, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_subadd(vec4s a, vec4s b, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_muladd(vec4s a, vec4s b, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_muladds(vec4s a, float s, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_minadd(vec4s a, vec4s b, vec4s dest);
|
||||
CGLM_INLINE vec4s glms_vec4_negate(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_inv(vec4s v);
|
||||
CGLM_INLINE vec4s glms_vec4_normalize(vec4s v);
|
||||
CGLM_INLINE float glms_vec4_distance(vec4s a, vec4s b);
|
||||
CGLM_INLINE float glms_vec4_distance2(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_maxv(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_minv(vec4s a, vec4s b);
|
||||
CGLM_INLINE vec4s glms_vec4_clamp(vec4s v, float minVal, float maxVal);
|
||||
CGLM_INLINE vec4s glms_vec4_lerp(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_lerpc(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_mix(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_mixc(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_step_uni(float edge, vec4s x);
|
||||
CGLM_INLINE vec4s glms_vec4_step(vec4s edge, vec4s x);
|
||||
CGLM_INLINE vec4s glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x);
|
||||
CGLM_INLINE vec4s glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x);
|
||||
CGLM_INLINE vec4s glms_vec4_smoothinterp(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_smoothinterpc(vec4s from, vec4s to, float t);
|
||||
CGLM_INLINE vec4s glms_vec4_cubic(float s);
|
||||
CGLM_INLINE vec4s glms_vec4_swizzle(vec4s v, int mask);
|
||||
*/
|
||||
|
||||
#ifndef cglms_vec4s_h
|
||||
#define cglms_vec4s_h
|
||||
|
||||
#include "../common.h"
|
||||
#include "../types-struct.h"
|
||||
#include "../util.h"
|
||||
#include "../vec4.h"
|
||||
#include "vec4-ext.h"
|
||||
|
||||
#define GLMS_VEC4_ONE_INIT {GLM_VEC4_ONE_INIT}
|
||||
#define GLMS_VEC4_BLACK_INIT {GLM_VEC4_BLACK_INIT}
|
||||
#define GLMS_VEC4_ZERO_INIT {GLM_VEC4_ZERO_INIT}
|
||||
|
||||
#define GLMS_VEC4_ONE ((vec4s)GLM_VEC4_ONE_INIT)
|
||||
#define GLMS_VEC4_BLACK ((vec4s)GLM_VEC4_BLACK_INIT)
|
||||
#define GLMS_VEC4_ZERO ((vec4s)GLM_VEC4_ZERO_INIT)
|
||||
|
||||
/*!
|
||||
* @brief init vec4 using vec3
|
||||
*
|
||||
* @param[in] v3 vector3
|
||||
* @param[in] last last item
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4(vec3s v3, float last) {
|
||||
vec4s r;
|
||||
glm_vec4(v3.raw, last, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy first 3 members of [a] to [dest]
|
||||
*
|
||||
* @param[in] v source
|
||||
* @returns vec3
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec3s
|
||||
glms_vec4_copy3(vec4s v) {
|
||||
vec3s r;
|
||||
glm_vec4_copy3(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy all members of [a] to [dest]
|
||||
*
|
||||
* @param[in] v source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_copy(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_copy(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief copy all members of [a] to [dest]
|
||||
*
|
||||
* alignment is not required
|
||||
*
|
||||
* @param[in] v source
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_ucopy(vec4s v) {
|
||||
vec4s r;
|
||||
glm_vec4_ucopy(v.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief pack an array of vec4 into an array of vec4s
|
||||
*
|
||||
* @param[out] dst array of vec4
|
||||
* @param[in] src array of vec4s
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec4_pack(vec4s dst[], vec4 src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec4_copy(src[i], dst[i].raw);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief unpack an array of vec4s into an array of vec4
|
||||
*
|
||||
* @param[out] dst array of vec4s
|
||||
* @param[in] src array of vec4
|
||||
* @param[in] len number of elements
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glms_vec4_unpack(vec4 dst[], vec4s src[], size_t len) {
|
||||
size_t i;
|
||||
|
||||
for (i = 0; i < len; i++) {
|
||||
glm_vec4_copy(src[i].raw, dst[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector zero
|
||||
*
|
||||
* @returns zero vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_zero(void) {
|
||||
vec4s r;
|
||||
glm_vec4_zero(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vector one
|
||||
*
|
||||
* @returns one vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_one(void) {
|
||||
vec4s r;
|
||||
glm_vec4_one(r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief vec4 dot product
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
*
|
||||
* @return dot product
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_dot(vec4s a, vec4s b) {
|
||||
return glm_vec4_dot(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm * norm (magnitude) of vec
|
||||
*
|
||||
* we can use this func instead of calling norm * norm, because it would call
|
||||
* sqrtf fuction twice but with this func we can avoid func call, maybe this is
|
||||
* not good name for this func
|
||||
*
|
||||
* @param[in] v vec4
|
||||
*
|
||||
* @return norm * norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_norm2(vec4s v) {
|
||||
return glm_vec4_norm2(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief norm (magnitude) of vec4
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_norm(vec4s v) {
|
||||
return glm_vec4_norm(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief L1 norm of vec4
|
||||
* Also known as Manhattan Distance or Taxicab norm.
|
||||
* L1 Norm is the sum of the magnitudes of the vectors in a space.
|
||||
* It is calculated as the sum of the absolute values of the vector components.
|
||||
* In this norm, all the components of the vector are weighted equally.
|
||||
*
|
||||
* This computes:
|
||||
* R = |v[0]| + |v[1]| + |v[2]| + |v[3]|
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return L1 norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_norm_one(vec4s v) {
|
||||
return glm_vec4_norm_one(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief Infinity norm of vec4
|
||||
* Also known as Maximum norm.
|
||||
* Infinity Norm is the largest magnitude among each element of a vector.
|
||||
* It is calculated as the maximum of the absolute values of the vector components.
|
||||
*
|
||||
* This computes:
|
||||
* inf norm = max(|v[0]|, |v[1]|, |v[2]|, |v[3]|)
|
||||
*
|
||||
* @param[in] v vector
|
||||
*
|
||||
* @return Infinity norm
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_norm_inf(vec4s v) {
|
||||
return glm_vec4_norm_inf(v.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add b vector to a vector store result in dest
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_add(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_add(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add scalar to v vector store result in dest (d = v + vec(s))
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_adds(vec4s v, float s) {
|
||||
vec4s r;
|
||||
glm_vec4_adds(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract b vector from a vector store result in dest (d = a - b)
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_sub(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_sub(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief subtract scalar from v vector store result in dest (d = v - vec(s))
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_subs(vec4s v, float s) {
|
||||
vec4s r;
|
||||
glm_vec4_subs(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply two vector (component-wise multiplication)
|
||||
*
|
||||
* @param a vector1
|
||||
* @param b vector2
|
||||
* @returns dest = (a[0] * b[0], a[1] * b[1], a[2] * b[2], a[3] * b[3])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_mul(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_mul(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief multiply/scale vec4 vector with scalar: result = v * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_scale(vec4s v, float s) {
|
||||
vec4s r;
|
||||
glm_vec4_scale(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief make vec4 vector scale as specified: result = unit(v) * s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_scale_as(vec4s v, float s) {
|
||||
vec4s r;
|
||||
glm_vec4_scale_as(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vector with another component-wise division: d = a / b
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns result = (a[0]/b[0], a[1]/b[1], a[2]/b[2], a[3]/b[3])
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_div(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_div(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief div vec4 vector with scalar: d = v / s
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] s scalar
|
||||
* @returns destination vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_divs(vec4s v, float s) {
|
||||
vec4s r;
|
||||
glm_vec4_divs(v.raw, s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add two vectors and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a + b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_addadd(vec4s a, vec4s b, vec4s dest) {
|
||||
glm_vec4_addadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief sub two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a - b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_subadd(vec4s a, vec4s b, vec4s dest) {
|
||||
glm_vec4_subadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul two vectors and add result to dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_muladd(vec4s a, vec4s b, vec4s dest) {
|
||||
glm_vec4_muladd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief mul vector with scalar and add result to sum
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector
|
||||
* @param[in] s scalar
|
||||
* @returns dest += (a * b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_muladds(vec4s a, float s, vec4s dest) {
|
||||
glm_vec4_muladds(a.raw, s, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add max of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += max(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_maxadd(vec4s a, vec4s b, vec4s dest) {
|
||||
glm_vec4_maxadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief add min of two vector to result/dest
|
||||
*
|
||||
* it applies += operator so dest must be initialized
|
||||
*
|
||||
* @param[in] a vector 1
|
||||
* @param[in] b vector 2
|
||||
* @returns dest += min(a, b)
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_minadd(vec4s a, vec4s b, vec4s dest) {
|
||||
glm_vec4_minadd(a.raw, b.raw, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief negate vector components and store result in dest
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns result vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_negate(vec4s v) {
|
||||
glm_vec4_negate(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief normalize vec4 and store result in same vec
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @returns normalized vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_normalize(vec4s v) {
|
||||
glm_vec4_normalize(v.raw);
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return returns distance
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_distance(vec4s a, vec4s b) {
|
||||
return glm_vec4_distance(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief squared distance between two vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @return returns squared distance
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glms_vec4_distance2(vec4s a, vec4s b) {
|
||||
return glm_vec4_distance2(a.raw, b.raw);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief max values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_maxv(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_maxv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief min values of vectors
|
||||
*
|
||||
* @param[in] a vector1
|
||||
* @param[in] b vector2
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_minv(vec4s a, vec4s b) {
|
||||
vec4s r;
|
||||
glm_vec4_minv(a.raw, b.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief clamp vector's individual members between min and max values
|
||||
*
|
||||
* @param[in] v vector
|
||||
* @param[in] minVal minimum value
|
||||
* @param[in] maxVal maximum value
|
||||
* @returns clamped vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_clamp(vec4s v, float minVal, float maxVal) {
|
||||
glm_vec4_clamp(v.raw, minVal, maxVal);
|
||||
return v;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_lerp(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_lerp(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_lerpc(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_lerpc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_mix(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_mix(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief linear interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_mixc(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_mixc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function (unidimensional)
|
||||
*
|
||||
* @param[in] edge threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns 0.0 if x < edge, else 1.0
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_step_uni(float edge, vec4s x) {
|
||||
vec4s r;
|
||||
glm_vec4_step_uni(edge, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function
|
||||
*
|
||||
* @param[in] edge threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns 0.0 if x < edge, else 1.0
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_step(vec4s edge, vec4s x) {
|
||||
vec4s r;
|
||||
glm_vec4_step(edge.raw, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function with a smooth transition (unidimensional)
|
||||
*
|
||||
* @param[in] edge0 low threshold
|
||||
* @param[in] edge1 high threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_smoothstep_uni(float edge0, float edge1, vec4s x) {
|
||||
vec4s r;
|
||||
glm_vec4_smoothstep_uni(edge0, edge1, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief threshold function with a smooth transition
|
||||
*
|
||||
* @param[in] edge0 low threshold
|
||||
* @param[in] edge1 high threshold
|
||||
* @param[in] x value to test against threshold
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_smoothstep(vec4s edge0, vec4s edge1, vec4s x) {
|
||||
vec4s r;
|
||||
glm_vec4_smoothstep(edge0.raw, edge1.raw, x.raw, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief smooth Hermite interpolation between two vectors
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount)
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_smoothinterp(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_smoothinterp(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief smooth Hermite interpolation between two vectors (clamped)
|
||||
*
|
||||
* formula: from + s * (to - from)
|
||||
*
|
||||
* @param[in] from from value
|
||||
* @param[in] to to value
|
||||
* @param[in] t interpolant (amount) clamped between 0 and 1
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_smoothinterpc(vec4s from, vec4s to, float t) {
|
||||
vec4s r;
|
||||
glm_vec4_smoothinterpc(from.raw, to.raw, t, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief helper to fill vec4 as [S^3, S^2, S, 1]
|
||||
*
|
||||
* @param[in] s parameter
|
||||
* @returns destination
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_cubic(float s) {
|
||||
vec4s r;
|
||||
glm_vec4_cubic(s, r.raw);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief swizzle vector components
|
||||
*
|
||||
* you can use existin masks e.g. GLM_XXXX, GLM_WZYX
|
||||
*
|
||||
* @param[in] v source
|
||||
* @param[in] mask mask
|
||||
* @returns swizzled vector
|
||||
*/
|
||||
CGLM_INLINE
|
||||
vec4s
|
||||
glms_vec4_swizzle(vec4s v, int mask) {
|
||||
vec4s dest;
|
||||
glm_vec4_swizzle(v.raw, mask, dest.raw);
|
||||
return dest;
|
||||
}
|
||||
|
||||
#endif /* cglms_vec4s_h */
|
||||
Reference in New Issue
Block a user