External/cglm
1
0
Fork 0
mirror of https://github.com/recp/cglm.git synced 2025-12-26 02:25:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

mark readonly parameters as const (continue)

Browse Source
This commit is contained in:
Recep Aslantas
2019-04-28 21:48:19 +03:00
parent 6ed275734b
commit 392565f920
31 changed files with 525 additions and 517 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
include/cglm/call/affine.h
View File

@@ -15,15 +15,15 @@ extern "C" {
CGLM_EXPORT
void
glmc_translate_make(mat4 m, vec3 v);
glmc_translate_make(mat4 m, const vec3 v);
CGLM_EXPORT
void
glmc_translate_to(mat4 m, vec3 v, mat4 dest);
glmc_translate_to(const mat4 m, const vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_translate(mat4 m, vec3 v);
glmc_translate(mat4 m, const vec3 v);
CGLM_EXPORT
void
@@ -39,15 +39,15 @@ glmc_translate_z(mat4 m, float to);
CGLM_EXPORT
void
glmc_scale_make(mat4 m, vec3 v);
glmc_scale_make(mat4 m, const vec3 v);
CGLM_EXPORT
void
glmc_scale_to(mat4 m, vec3 v, mat4 dest);
glmc_scale_to(const mat4 m, const vec3 v, mat4 dest);
CGLM_EXPORT
void
glmc_scale(mat4 m, vec3 v);
glmc_scale(mat4 m, const vec3 v);
CGLM_EXPORT
void
@@ -55,57 +55,57 @@ glmc_scale_uni(mat4 m, float s);
CGLM_EXPORT
void
glmc_rotate_x(mat4 m, float rad, mat4 dest);
glmc_rotate_x(const mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_y(mat4 m, float rad, mat4 dest);
glmc_rotate_y(const mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_z(mat4 m, float rad, mat4 dest);
glmc_rotate_z(const mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_make(mat4 m, float angle, vec3 axis);
glmc_rotate_make(mat4 m, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_rotate(mat4 m, float angle, vec3 axis);
glmc_rotate(mat4 m, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
glmc_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
glmc_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_decompose_scalev(mat4 m, vec3 s);
glmc_decompose_scalev(const mat4 m, vec3 s);
CGLM_EXPORT
bool
glmc_uniscaled(mat4 m);
glmc_uniscaled(const mat4 m);
CGLM_EXPORT
void
glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
glmc_decompose_rs(const mat4 m, mat4 r, vec3 s);
CGLM_EXPORT
void
glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
glmc_decompose(const mat4 m, vec4 t, mat4 r, vec3 s);
/* affine-mat */
CGLM_EXPORT
void
glmc_mul(mat4 m1, mat4 m2, mat4 dest);
glmc_mul(const mat4 m1, const mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
glmc_mul_rot(const mat4 m1, const mat4 m2, mat4 dest);
CGLM_EXPORT
void

32
include/cglm/call/box.h
View File

@@ -15,26 +15,26 @@ extern "C" {
CGLM_EXPORT
void
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
glmc_aabb_transform(const vec3 box[2], const mat4 m, vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
glmc_aabb_merge(const vec3 box1[2], const vec3 box2[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
glmc_aabb_crop(const vec3 box[2], const vec3 cropBox[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
vec3 dest[2]);
glmc_aabb_crop_until(const vec3 box[2],
const vec3 cropBox[2],
const vec3 clampBox[2],
vec3 dest[2]);
CGLM_EXPORT
bool
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
glmc_aabb_frustum(const vec3 box[2], vec4 planes[6]);
CGLM_EXPORT
void
@@ -42,35 +42,35 @@ glmc_aabb_invalidate(vec3 box[2]);
CGLM_EXPORT
bool
glmc_aabb_isvalid(vec3 box[2]);
glmc_aabb_isvalid(const vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_size(vec3 box[2]);
glmc_aabb_size(const vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_radius(vec3 box[2]);
glmc_aabb_radius(const vec3 box[2]);
CGLM_EXPORT
void
glmc_aabb_center(vec3 box[2], vec3 dest);
glmc_aabb_center(const vec3 box[2], vec3 dest);
CGLM_EXPORT
bool
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
glmc_aabb_aabb(const vec3 box[2], const vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_point(vec3 box[2], vec3 point);
glmc_aabb_point(const vec3 box[2], const vec3 point);
CGLM_EXPORT
bool
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
glmc_aabb_contains(const vec3 box[2], const vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_sphere(vec3 box[2], vec4 s);
glmc_aabb_sphere(const vec3 box[2], const vec4 s);
#ifdef __cplusplus
}

38
include/cglm/call/cam.h
View File

@@ -21,7 +21,7 @@ glmc_frustum(float left,
float top,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
@@ -31,19 +31,19 @@ glmc_ortho(float left,
float top,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb(vec3 box[2], mat4 dest);
glmc_ortho_aabb(const vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p(const vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz(const vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
@@ -59,7 +59,7 @@ glmc_perspective(float fovy,
float aspect,
float nearVal,
float farVal,
mat4 dest);
mat4 dest);
CGLM_EXPORT
void
@@ -75,19 +75,19 @@ glmc_perspective_resize(float aspect, mat4 proj);
CGLM_EXPORT
void
glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
glmc_lookat(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look(vec3 eye, vec3 dir, vec3 up, mat4 dest);
glmc_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup(vec3 eye, vec3 dir, mat4 dest);
glmc_look_anyup(const vec3 eye, const vec3 dir, mat4 dest);
CGLM_EXPORT
void
glmc_persp_decomp(mat4 proj,
glmc_persp_decomp(const mat4 proj,
float * __restrict nearVal,
float * __restrict farVal,
float * __restrict top,
@@ -97,45 +97,45 @@ glmc_persp_decomp(mat4 proj,
CGLM_EXPORT
void
glmc_persp_decompv(mat4 proj, float dest[6]);
glmc_persp_decompv(const mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x(mat4 proj,
glmc_persp_decomp_x(const mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y(mat4 proj,
glmc_persp_decomp_y(const mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z(mat4 proj,
glmc_persp_decomp_z(const mat4 proj,
float * __restrict nearVal,
float * __restrict farVal);
CGLM_EXPORT
void
glmc_persp_decomp_far(mat4 proj, float * __restrict farVal);
glmc_persp_decomp_far(const mat4 proj, float * __restrict farVal);
CGLM_EXPORT
void
glmc_persp_decomp_near(mat4 proj, float * __restrict nearVal);
glmc_persp_decomp_near(const mat4 proj, float * __restrict nearVal);
CGLM_EXPORT
float
glmc_persp_fovy(mat4 proj);
glmc_persp_fovy(const mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect(mat4 proj);
glmc_persp_aspect(const mat4 proj);
CGLM_EXPORT
void
glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes(const mat4 proj, float fovy, vec4 dest);
#ifdef __cplusplus
}

2
include/cglm/call/curve.h
View File

@@ -15,7 +15,7 @@ extern "C" {
CGLM_EXPORT
float
glmc_smc(float s, mat4 m, vec4 c);
glmc_smc(float s, const mat4 m, const vec4 c);
#ifdef __cplusplus
}

18
include/cglm/call/euler.h
View File

@@ -15,39 +15,39 @@ extern "C" {
CGLM_EXPORT
void
glmc_euler_angles(mat4 m, vec3 dest);
glmc_euler_angles(const mat4 m, vec3 dest);
CGLM_EXPORT
void
glmc_euler(vec3 angles, mat4 dest);
glmc_euler(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xyz(vec3 angles, mat4 dest);
glmc_euler_xyz(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zyx(vec3 angles, mat4 dest);
glmc_euler_zyx(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_zxy(vec3 angles, mat4 dest);
glmc_euler_zxy(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xzy(vec3 angles, mat4 dest);
glmc_euler_xzy(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yzx(vec3 angles, mat4 dest);
glmc_euler_yzx(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_yxz(vec3 angles, mat4 dest);
glmc_euler_yxz(const vec3 angles, mat4 dest);
CGLM_EXPORT
void
glmc_euler_by_order(vec3 angles, glm_euler_sq axis, mat4 dest);
glmc_euler_by_order(const vec3 angles, glm_euler_sq axis, mat4 dest);
#ifdef __cplusplus
}

16
include/cglm/call/frustum.h
View File

@@ -15,26 +15,26 @@ extern "C" {
CGLM_EXPORT
void
glmc_frustum_planes(mat4 m, vec4 dest[6]);
glmc_frustum_planes(const mat4 m, vec4 dest[6]);
CGLM_EXPORT
void
glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
glmc_frustum_corners(const mat4 invMat, vec4 dest[8]);
CGLM_EXPORT
void
glmc_frustum_center(vec4 corners[8], vec4 dest);
glmc_frustum_center(const vec4 corners[8], vec4 dest);
CGLM_EXPORT
void
glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
glmc_frustum_box(const vec4 corners[8], const mat4 m, vec3 box[2]);
CGLM_EXPORT
void
glmc_frustum_corners_at(vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
glmc_frustum_corners_at(const vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
#ifdef __cplusplus
}
#endif

20
include/cglm/call/io.h
View File

@@ -15,28 +15,28 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat4_print(mat4 matrix,
FILE * __restrict ostream);
glmc_mat4_print(const mat4 matrix,
FILE * const __restrict ostream);
CGLM_EXPORT
void
glmc_mat3_print(mat3 matrix,
FILE * __restrict ostream);
glmc_mat3_print(const mat3 matrix,
FILE * const __restrict ostream);
CGLM_EXPORT
void
glmc_vec4_print(vec4 vec,
FILE * __restrict ostream);
glmc_vec4_print(const vec4 vec,
FILE * const __restrict ostream);
CGLM_EXPORT
void
glmc_vec3_print(vec3 vec,
FILE * __restrict ostream);
glmc_vec3_print(const vec3 vec,
FILE * const __restrict ostream);
CGLM_EXPORT
void
glmc_versor_print(versor vec,
FILE * __restrict ostream);
glmc_versor_print(const versor vec,
FILE * const __restrict ostream);
#ifdef __cplusplus
}

20
include/cglm/call/mat3.h
View File

@@ -18,7 +18,7 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat3_copy(mat3 mat, mat3 dest);
glmc_mat3_copy(const mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -26,15 +26,15 @@ glmc_mat3_identity(mat3 mat);
CGLM_EXPORT
void
glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
glmc_mat3_identity_array(mat3 * const __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
glmc_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_transpose_to(mat3 m, mat3 dest);
glmc_mat3_transpose_to(const mat3 m, mat3 dest);
CGLM_EXPORT
void
@@ -42,15 +42,15 @@ glmc_mat3_transpose(mat3 m);
CGLM_EXPORT
void
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
glmc_mat3_mulv(const mat3 m, const vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_mat3_trace(mat3 m);
glmc_mat3_trace(const mat3 m);
CGLM_EXPORT
void
glmc_mat3_quat(mat3 m, versor dest);
glmc_mat3_quat(const mat3 m, versor dest);
CGLM_EXPORT
void
@@ -58,11 +58,11 @@ glmc_mat3_scale(mat3 m, float s);
CGLM_EXPORT
float
glmc_mat3_det(mat3 mat);
glmc_mat3_det(const mat3 mat);
CGLM_EXPORT
void
glmc_mat3_inv(mat3 mat, mat3 dest);
glmc_mat3_inv(const mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -74,7 +74,7 @@ glmc_mat3_swap_row(mat3 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat3_rmc(vec3 r, mat3 m, vec3 c);
glmc_mat3_rmc(const vec3 r, const mat3 m, const vec3 c);
#ifdef __cplusplus
}

38
include/cglm/call/mat4.h
View File

@@ -19,11 +19,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat4_ucopy(mat4 mat, mat4 dest);
glmc_mat4_ucopy(const mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_copy(mat4 mat, mat4 dest);
glmc_mat4_copy(const mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -31,51 +31,51 @@ glmc_mat4_identity(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_identity_array(mat4 * __restrict mat, size_t count);
glmc_mat4_identity_array(mat4 * const __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat4_pick3(mat4 mat, mat3 dest);
glmc_mat4_pick3(const mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_pick3t(mat4 mat, mat3 dest);
glmc_mat4_pick3t(const mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_ins3(mat3 mat, mat4 dest);
glmc_mat4_ins3(const mat3 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
glmc_mat4_mul(const mat4 m1, const mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulN(mat4 * __restrict matrices[], uint32_t len, mat4 dest);
glmc_mat4_mulN(mat4 * const __restrict matrices[], uint32_t len, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv(mat4 m, vec4 v, vec4 dest);
glmc_mat4_mulv(const mat4 m, const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_mat4_mulv3(mat4 m, vec3 v, float last, vec3 dest);
glmc_mat4_mulv3(const mat4 m, const vec3 v, float last, vec3 dest);
CGLM_EXPORT
float
glmc_mat4_trace(mat4 m);
glmc_mat4_trace(const mat4 m);
CGLM_EXPORT
float
glmc_mat4_trace3(mat4 m);
glmc_mat4_trace3(const mat4 m);
CGLM_EXPORT
void
glmc_mat4_quat(mat4 m, versor dest);
glmc_mat4_quat(const mat4 m, versor dest);
CGLM_EXPORT
void
glmc_mat4_transpose_to(mat4 m, mat4 dest);
glmc_mat4_transpose_to(const mat4 m, mat4 dest);
CGLM_EXPORT
void
@@ -91,19 +91,19 @@ glmc_mat4_scale(mat4 m, float s);
CGLM_EXPORT
float
glmc_mat4_det(mat4 mat);
glmc_mat4_det(const mat4 mat);
CGLM_EXPORT
void
glmc_mat4_inv(mat4 mat, mat4 dest);
glmc_mat4_inv(const mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_precise(mat4 mat, mat4 dest);
glmc_mat4_inv_precise(const mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_fast(mat4 mat, mat4 dest);
glmc_mat4_inv_fast(const mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -115,7 +115,7 @@ glmc_mat4_swap_row(mat4 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat4_rmc(vec4 r, mat4 m, vec4 c);
glmc_mat4_rmc(const vec4 r, const mat4 m, const vec4 c);
#ifdef __cplusplus
}

6
include/cglm/call/project.h
View File

@@ -15,15 +15,15 @@ extern "C" {
CGLM_EXPORT
void
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
glmc_unprojecti(const vec3 pos, const mat4 invMat, const vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
glmc_unproject(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
glmc_project(const vec3 pos, const mat4 m, const vec4 vp, vec3 dest);
#ifdef __cplusplus
}

64
include/cglm/call/quat.h
View File

@@ -19,7 +19,7 @@ glmc_quat_identity(versor q);
CGLM_EXPORT
void
glmc_quat_identity_array(versor * __restrict q, size_t count);
glmc_quat_identity_array(versor * const __restrict q, size_t count);
CGLM_EXPORT
void
@@ -31,19 +31,19 @@ glmc_quat(versor q, float angle, float x, float y, float z);
CGLM_EXPORT
void
glmc_quatv(versor q, float angle, vec3 axis);
glmc_quatv(versor q, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_quat_copy(versor q, versor dest);
glmc_quat_copy(const versor q, versor dest);
CGLM_EXPORT
float
glmc_quat_norm(versor q);
glmc_quat_norm(const versor q);
CGLM_EXPORT
void
glmc_quat_normalize_to(versor q, versor dest);
glmc_quat_normalize_to(const versor q, versor dest);
CGLM_EXPORT
void
@@ -51,103 +51,107 @@ glmc_quat_normalize(versor q);
CGLM_EXPORT
float
glmc_quat_dot(versor p, versor q);
glmc_quat_dot(const versor p, const versor q);
CGLM_EXPORT
void
glmc_quat_conjugate(versor q, versor dest);
glmc_quat_conjugate(const versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_inv(versor q, versor dest);
glmc_quat_inv(const versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_add(versor p, versor q, versor dest);
glmc_quat_add(const versor p, const versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_sub(versor p, versor q, versor dest);
glmc_quat_sub(const versor p, const versor q, versor dest);
CGLM_EXPORT
float
glmc_quat_real(versor q);
glmc_quat_real(const versor q);
CGLM_EXPORT
void
glmc_quat_imag(versor q, vec3 dest);
glmc_quat_imag(const versor q, vec3 dest);
CGLM_EXPORT
void
glmc_quat_imagn(versor q, vec3 dest);
glmc_quat_imagn(const versor q, vec3 dest);
CGLM_EXPORT
float
glmc_quat_imaglen(versor q);
glmc_quat_imaglen(const versor q);
CGLM_EXPORT
float
glmc_quat_angle(versor q);
glmc_quat_angle(const versor q);
CGLM_EXPORT
void
glmc_quat_axis(versor q, versor dest);
glmc_quat_axis(const versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_mul(versor p, versor q, versor dest);
glmc_quat_mul(const versor p, const versor q, versor dest);
CGLM_EXPORT
void
glmc_quat_mat4(versor q, mat4 dest);
glmc_quat_mat4(const versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat4t(versor q, mat4 dest);
glmc_quat_mat4t(const versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_mat3(versor q, mat3 dest);
glmc_quat_mat3(const versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_mat3t(versor q, mat3 dest);
glmc_quat_mat3t(const versor q, mat3 dest);
CGLM_EXPORT
void
glmc_quat_lerp(versor from, versor to, float t, versor dest);
glmc_quat_lerp(const versor from, const versor to, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_slerp(versor q, versor r, float t, versor dest);
glmc_quat_slerp(const versor q, const versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
CGLM_EXPORT
void
glmc_quat_for(vec3 dir, vec3 fwd, vec3 up, versor dest);
glmc_quat_for(const vec3 dir, const vec3 fwd, const vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_forp(vec3 from, vec3 to, vec3 fwd, vec3 up, versor dest);
glmc_quat_forp(const vec3 from,
const vec3 to,
const vec3 fwd,
const vec3 up,
versor dest);
CGLM_EXPORT
void
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
CGLM_EXPORT
void
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
glmc_quat_rotate(const mat4 m, const versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
#ifdef __cplusplus
}

10
include/cglm/call/sphere.h
View File

@@ -15,23 +15,23 @@ extern "C" {
CGLM_EXPORT
float
glmc_sphere_radii(vec4 s);
glmc_sphere_radii(const vec4 s);
CGLM_EXPORT
void
glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
glmc_sphere_transform(const vec4 s, const mat4 m, vec4 dest);
CGLM_EXPORT
void
glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest);
CGLM_EXPORT
bool
glmc_sphere_sphere(vec4 s1, vec4 s2);
glmc_sphere_sphere(const vec4 s1, const vec4 s2);
CGLM_EXPORT
bool
glmc_sphere_point(vec4 s, vec3 point);
glmc_sphere_point(const vec4 s, const vec3 point);
#ifdef __cplusplus
}

98
include/cglm/call/vec3.h
View File

@@ -22,11 +22,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec3(vec4 v4, vec3 dest);
glmc_vec3(const vec4 v4, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_copy(vec3 a, vec3 dest);
glmc_vec3_copy(const vec3 a, vec3 dest);
CGLM_EXPORT
void
@@ -38,27 +38,27 @@ glmc_vec3_one(vec3 v);
CGLM_EXPORT
float
glmc_vec3_dot(vec3 a, vec3 b);
glmc_vec3_dot(const vec3 a, const vec3 b);
CGLM_EXPORT
void
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_norm(vec3 v);
glmc_vec3_norm(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm2(vec3 v);
glmc_vec3_norm2(const vec3 v);
CGLM_EXPORT
void
glmc_vec3_normalize_to(vec3 v, vec3 dest);
glmc_vec3_normalize_to(const vec3 v, vec3 dest);
CGLM_EXPORT
void
@@ -66,63 +66,63 @@ glmc_vec3_normalize(vec3 v);
CGLM_EXPORT
void
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_adds(vec3 v, float s, vec3 dest);
glmc_vec3_adds(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subs(vec3 v, float s, vec3 dest);
glmc_vec3_subs(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec3_scale(vec3 v, float s, vec3 dest);
glmc_vec3_scale(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
glmc_vec3_scale_as(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_divs(vec3 a, float s, vec3 dest);
glmc_vec3_divs(const vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
glmc_vec3_muladds(const vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -130,47 +130,47 @@ glmc_vec3_negate(vec3 v);
CGLM_EXPORT
void
glmc_vec3_negate_to(vec3 v, vec3 dest);
glmc_vec3_negate_to(const vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_angle(vec3 a, vec3 b);
glmc_vec3_angle(const vec3 a, const vec3 b);
CGLM_EXPORT
void
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
glmc_vec3_rotate(vec3 v, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
glmc_vec3_rotate_m4(const mat4 m, const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
glmc_vec3_rotate_m3(const mat3 m, const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_distance2(vec3 a, vec3 b);
glmc_vec3_distance2(const vec3 a, const vec3 b);
CGLM_EXPORT
float
glmc_vec3_distance(vec3 a, vec3 b);
glmc_vec3_distance(const vec3 a, const vec3 b);
CGLM_EXPORT
void
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -178,17 +178,17 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec3_ortho(vec3 v, vec3 dest);
glmc_vec3_ortho(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
/* ext */
CGLM_EXPORT
void
glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
glmc_vec3_mulv(const vec3 a, const vec3 b, vec3 d);
CGLM_EXPORT
void
@@ -196,51 +196,51 @@ glmc_vec3_broadcast(float val, vec3 d);
CGLM_EXPORT
bool
glmc_vec3_eq(vec3 v, float val);
glmc_vec3_eq(const vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_eps(vec3 v, float val);
glmc_vec3_eq_eps(const vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq_all(vec3 v);
glmc_vec3_eq_all(const vec3 v);
CGLM_EXPORT
bool
glmc_vec3_eqv(vec3 a, vec3 b);
glmc_vec3_eqv(const vec3 a, const vec3 b);
CGLM_EXPORT
bool
glmc_vec3_eqv_eps(vec3 a, vec3 b);
glmc_vec3_eqv_eps(const vec3 a, const vec3 b);
CGLM_EXPORT
float
glmc_vec3_max(vec3 v);
glmc_vec3_max(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_min(vec3 v);
glmc_vec3_min(const vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isnan(vec3 v);
glmc_vec3_isnan(const vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isinf(vec3 v);
glmc_vec3_isinf(const vec3 v);
CGLM_EXPORT
bool
glmc_vec3_isvalid(vec3 v);
glmc_vec3_isvalid(const vec3 v);
CGLM_EXPORT
void
glmc_vec3_sign(vec3 v, vec3 dest);
glmc_vec3_sign(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_sqrt(vec3 v, vec3 dest);
glmc_vec3_sqrt(const vec3 v, vec3 dest);
#ifdef __cplusplus
}

82
include/cglm/call/vec4.h
View File

@@ -23,7 +23,7 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec4(vec3 v3, float last, vec4 dest);
glmc_vec4(const vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
@@ -35,31 +35,31 @@ glmc_vec4_one(vec4 v);
CGLM_EXPORT
void
glmc_vec4_copy3(vec4 v, vec3 dest);
glmc_vec4_copy3(const vec4 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_copy(vec4 v, vec4 dest);
glmc_vec4_copy(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_ucopy(vec4 v, vec4 dest);
glmc_vec4_ucopy(const vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_dot(vec4 a, vec4 b);
glmc_vec4_dot(const vec4 a, const vec4 b);
CGLM_EXPORT
float
glmc_vec4_norm(vec4 v);
glmc_vec4_norm(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm2(vec4 v);
glmc_vec4_norm2(const vec4 v);
CGLM_EXPORT
void
glmc_vec4_normalize_to(vec4 v, vec4 dest);
glmc_vec4_normalize_to(const vec4 v, vec4 dest);
CGLM_EXPORT
void
@@ -67,63 +67,63 @@ glmc_vec4_normalize(vec4 v);
CGLM_EXPORT
void
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_adds(vec4 v, float s, vec4 dest);
glmc_vec4_adds(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subs(vec4 v, float s, vec4 dest);
glmc_vec4_subs(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d);
CGLM_EXPORT
void
glmc_vec4_scale(vec4 v, float s, vec4 dest);
glmc_vec4_scale(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_scale_as(vec3 v, float s, vec3 dest);
glmc_vec4_scale_as(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_divs(vec4 v, float s, vec4 dest);
glmc_vec4_divs(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
glmc_vec4_muladds(const vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -131,19 +131,19 @@ glmc_vec4_negate(vec4 v);
CGLM_EXPORT
void
glmc_vec4_negate_to(vec4 v, vec4 dest);
glmc_vec4_negate_to(const vec4 v, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_distance(vec4 a, vec4 b);
glmc_vec4_distance(const vec4 a, const vec4 b);
CGLM_EXPORT
void
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -151,7 +151,7 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
CGLM_EXPORT
void
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
@@ -161,7 +161,7 @@ glmc_vec4_cubic(float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
glmc_vec4_mulv(const vec4 a, const vec4 b, vec4 d);
CGLM_EXPORT
void
@@ -169,51 +169,51 @@ glmc_vec4_broadcast(float val, vec4 d);
CGLM_EXPORT
bool
glmc_vec4_eq(vec4 v, float val);
glmc_vec4_eq(const vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_eps(vec4 v, float val);
glmc_vec4_eq_eps(const vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq_all(vec4 v);
glmc_vec4_eq_all(const vec4 v);
CGLM_EXPORT
bool
glmc_vec4_eqv(vec4 a, vec4 b);
glmc_vec4_eqv(const vec4 a, const vec4 b);
CGLM_EXPORT
bool
glmc_vec4_eqv_eps(vec4 a, vec4 b);
glmc_vec4_eqv_eps(const vec4 a, const vec4 b);
CGLM_EXPORT
float
glmc_vec4_max(vec4 v);
glmc_vec4_max(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_min(vec4 v);
glmc_vec4_min(const vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isnan(vec4 v);
glmc_vec4_isnan(const vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isinf(vec4 v);
glmc_vec4_isinf(const vec4 v);
CGLM_EXPORT
bool
glmc_vec4_isvalid(vec4 v);
glmc_vec4_isvalid(const vec4 v);
CGLM_EXPORT
void
glmc_vec4_sign(vec4 v, vec4 dest);
glmc_vec4_sign(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_sqrt(vec4 v, vec4 dest);
glmc_vec4_sqrt(const vec4 v, vec4 dest);
#ifdef __cplusplus
}

24
include/cglm/cam.h
View File

@@ -380,7 +380,7 @@ glm_lookat(const vec3 eye,
*/
CGLM_INLINE
void
glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 target;
glm_vec3_add(eye, dir, target);
glm_lookat(eye, target, up, dest);
@@ -398,7 +398,7 @@ glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup(const vec3 eye, const vec3 dir, mat4 dest) {
CGLM_ALIGN(8) vec3 up;
glm_vec3_ortho(dir, up);
glm_look(eye, dir, up, dest);
@@ -417,7 +417,7 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
*/
CGLM_INLINE
void
glm_persp_decomp(mat4 proj,
glm_persp_decomp(const mat4 proj,
float * __restrict nearVal,
float * __restrict farVal,
float * __restrict top,
@@ -457,7 +457,7 @@ glm_persp_decomp(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv(mat4 proj, float dest[6]) {
glm_persp_decompv(const mat4 proj, float dest[6]) {
glm_persp_decomp(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -472,7 +472,7 @@ glm_persp_decompv(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x(mat4 proj,
glm_persp_decomp_x(const mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearVal, m20, m00;
@@ -495,7 +495,7 @@ glm_persp_decomp_x(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y(mat4 proj,
glm_persp_decomp_y(const mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearVal, m21, m11;
@@ -518,7 +518,7 @@ glm_persp_decomp_y(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z(mat4 proj,
glm_persp_decomp_z(const mat4 proj,
float * __restrict nearVal,
float * __restrict farVal) {
float m32, m22;
@@ -538,7 +538,7 @@ glm_persp_decomp_z(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
glm_persp_decomp_far(const mat4 proj, float * __restrict farVal) {
*farVal = proj[3][2] / (proj[2][2] + 1.0f);
}
@@ -550,7 +550,7 @@ glm_persp_decomp_far(mat4 proj, float * __restrict farVal) {
*/
CGLM_INLINE
void
glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
glm_persp_decomp_near(const mat4 proj, float * __restrict nearVal) {
*nearVal = proj[3][2] / (proj[2][2] - 1.0f);
}
@@ -564,7 +564,7 @@ glm_persp_decomp_near(mat4 proj, float * __restrict nearVal) {
*/
CGLM_INLINE
float
glm_persp_fovy(mat4 proj) {
glm_persp_fovy(const mat4 proj) {
return 2.0f * atanf(1.0f / proj[1][1]);
}
@@ -575,7 +575,7 @@ glm_persp_fovy(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect(mat4 proj) {
glm_persp_aspect(const mat4 proj) {
return proj[1][1] / proj[0][0];
}
@@ -588,7 +588,7 @@ glm_persp_aspect(mat4 proj) {
*/
CGLM_INLINE
void
glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes(const mat4 proj, float fovy, vec4 dest) {
float t, a, nearVal, farVal;
t = 2.0f * tanf(fovy * 0.5f);

28
include/cglm/io.h
View File

@@ -25,8 +25,8 @@
CGLM_INLINE
void
glm_mat4_print(mat4 matrix,
FILE * __restrict ostream) {
glm_mat4_print(const mat4 matrix,
FILE * const __restrict ostream) {
int i;
int j;
@@ -55,8 +55,8 @@ glm_mat4_print(mat4 matrix,
CGLM_INLINE
void
glm_mat3_print(mat3 matrix,
FILE * __restrict ostream) {
glm_mat3_print(const mat3 matrix,
FILE * const __restrict ostream) {
int i;
int j;
@@ -85,8 +85,8 @@ glm_mat3_print(mat3 matrix,
CGLM_INLINE
void
glm_vec4_print(vec4 vec,
FILE * __restrict ostream) {
glm_vec4_print(const vec4 vec,
FILE * const __restrict ostream) {
int i;
#define m 4
@@ -107,8 +107,8 @@ glm_vec4_print(vec4 vec,
CGLM_INLINE
void
glm_vec3_print(vec3 vec,
FILE * __restrict ostream) {
glm_vec3_print(const vec3 vec,
FILE * const __restrict ostream) {
int i;
#define m 3
@@ -129,8 +129,8 @@ glm_vec3_print(vec3 vec,
CGLM_INLINE
void
glm_ivec3_print(ivec3 vec,
FILE * __restrict ostream) {
glm_ivec3_print(const ivec3 vec,
FILE * const __restrict ostream) {
int i;
#define m 3
@@ -151,8 +151,8 @@ glm_ivec3_print(ivec3 vec,
CGLM_INLINE
void
glm_versor_print(versor vec,
FILE * __restrict ostream) {
glm_versor_print(const versor vec,
FILE * const __restrict ostream) {
int i;
#define m 4
@@ -173,9 +173,9 @@ glm_versor_print(versor vec,
CGLM_INLINE
void
glm_aabb_print(vec3 bbox[2],
glm_aabb_print(const vec3 bbox[2],
const char * __restrict tag,
FILE * __restrict ostream) {
FILE * const __restrict ostream) {
int i, j;
#define m 3

20
include/cglm/mat3.h
View File

@@ -65,7 +65,7 @@
*/
CGLM_INLINE
void
glm_mat3_copy(mat3 mat, mat3 dest) {
glm_mat3_copy(const mat3 mat, mat3 dest) {
dest[0][0] = mat[0][0];
dest[0][1] = mat[0][1];
dest[0][2] = mat[0][2];
@@ -110,7 +110,7 @@ glm_mat3_identity(mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_identity_array(mat3 * __restrict mat, size_t count) {
glm_mat3_identity_array(mat3 * const __restrict mat, size_t count) {
CGLM_ALIGN_MAT mat3 t = GLM_MAT3_IDENTITY_INIT;
size_t i;
@@ -147,7 +147,7 @@ glm_mat3_zero(mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
glm_mat3_mul(const mat3 m1, const mat3 m2, mat3 dest) {
#if defined( __SSE__ ) || defined( __SSE2__ )
glm_mat3_mul_sse2(m1, m2, dest);
#else
@@ -181,7 +181,7 @@ glm_mat3_mul(mat3 m1, mat3 m2, mat3 dest) {
*/
CGLM_INLINE
void
glm_mat3_transpose_to(mat3 m, mat3 dest) {
glm_mat3_transpose_to(const mat3 m, mat3 dest) {
dest[0][0] = m[0][0];
dest[0][1] = m[1][0];
dest[0][2] = m[2][0];
@@ -227,7 +227,7 @@ glm_mat3_transpose(mat3 m) {
*/
CGLM_INLINE
void
glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
glm_mat3_mulv(const mat3 m, const vec3 v, vec3 dest) {
dest[0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0] * v[2];
dest[1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1] * v[2];
dest[2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2];
@@ -242,7 +242,7 @@ glm_mat3_mulv(mat3 m, vec3 v, vec3 dest) {
*/
CGLM_INLINE
float
glm_mat3_trace(mat3 m) {
glm_mat3_trace(const mat3 m) {
return m[0][0] + m[1][1] + m[2][2];
}
@@ -254,7 +254,7 @@ glm_mat3_trace(mat3 m) {
*/
CGLM_INLINE
void
glm_mat3_quat(mat3 m, versor dest) {
glm_mat3_quat(const mat3 m, versor dest) {
float trace, r, rinv;
/* it seems using like m12 instead of m[1][2] causes extra instructions */
@@ -320,7 +320,7 @@ glm_mat3_scale(mat3 m, float s) {
*/
CGLM_INLINE
float
glm_mat3_det(mat3 mat) {
glm_mat3_det(const mat3 mat) {
float a = mat[0][0], b = mat[0][1], c = mat[0][2],
d = mat[1][0], e = mat[1][1], f = mat[1][2],
g = mat[2][0], h = mat[2][1], i = mat[2][2];
@@ -336,7 +336,7 @@ glm_mat3_det(mat3 mat) {
*/
CGLM_INLINE
void
glm_mat3_inv(mat3 mat, mat3 dest) {
glm_mat3_inv(const mat3 mat, mat3 dest) {
float det;
float a = mat[0][0], b = mat[0][1], c = mat[0][2],
d = mat[1][0], e = mat[1][1], f = mat[1][2],
@@ -413,7 +413,7 @@ glm_mat3_swap_row(mat3 mat, int row1, int row2) {
*/
CGLM_INLINE
float
glm_mat3_rmc(vec3 r, mat3 m, vec3 c) {
glm_mat3_rmc(const vec3 r, const mat3 m, const vec3 c) {
vec3 tmp;
glm_mat3_mulv(m, c, tmp);
return glm_vec3_dot(r, tmp);