Compare commits

..
291 Commits
Author SHA1 Message Date
Recep Aslantas b9b570b78d fix armv7 quaternion normalization 2026-10-27 00:42:26 +03:00
Recep Aslantas a34ce6bfc6 ci: fix arm32 sdk 2026-10-27 00:42:26 +03:00
Recep Aslantas f32e015ec2 optimize quaternion matrix conversion 2026-10-27 00:13:24 +03:00
Recep Aslantas 0357f113ab ci: refresh supported runners 2026-10-27 00:03:25 +03:00
Recep Aslantas 5335c31ddd gitignore 2026-10-27 00:03:25 +03:00
Recep Aslantas 5c65419434 merge pull request #506 from dpirch/const-params
Add const to function parameters where possible
2026-10-26 22:28:36 +03:00
Daniel Pirch 44b6d7f332 add const to function parameters where possible
- Adds `const` qualifiers to read-only pointer and array parameters.
- Multi-dimentional array parameters use the `CGLM_CONST` macro instead,
  because for these `const` only works in C++ and C23 (with N2607).
- For `glm_mat4_mulN`, the matrices are not const-qualified although they
  are read-only, but changing the pointer type would require changing
  application code.
- Incorrect incorrect in/out in doc comments was fixed for
  `glm_ray_sphere`, `glm_swapf`, `glm_quat_rotate_at`.
2026-10-25 23:24:28 +01:00
Recep Aslantas 75a19a54d0 now working on v0.9.8 2026-10-25 21:44:32 +03:00
Recep Aslantas 888aca08d5 v0.9.7 2026-10-25 21:12:10 +03:00
Recep Aslantas 5390138d7f merge pull request #501 from tooold2rock-n-roll/tooold2rock-n-roll/500_glms_aabb2d_radius_bug
Tooold2rock n roll/500 glms aabb2d radius bug
2026-10-25 00:10:08 +03:00
Recep Aslantas 11d34be968 merge pull request #504 from fhgffy/fix/glm-spin-translation-502
affine: preserve translation in glm_spin
2026-10-25 00:02:24 +03:00
Recep Aslantas 1e65d6b52e merge pull request #505 from snowyukitty/fix/non-unit-quaternion-matrices
Fix non-unit quaternion rotation matrices
2026-10-24 23:48:26 +03:00
snowyukitty 8ff4f978c3 Fix non-unit quaternion rotation matrices 2026-10-10 03:59:20 +09:00
fhgffy d7b1e02778 affine: preserve translation in glm_spin 2026-10-04 20:31:02 +08:00
TooOld2Rock'nRoll 38a60f4f85 Adding vim files to gitignore. 2026-09-23 10:05:22 -03:00
TooOld2Rock'nRoll 81ec84493f Changing (size) for (diag) at aabb2d radius function. 2026-09-23 10:02:08 -03:00
Recep Aslantas 58d8c15a12 Merge pull request #499 from tooold2rock-n-roll/tooold2rock-n-roll/issue_n498_int2float_conversion_warnings
Fixing warning messages.
2026-07-29 18:21:01 +03:00
TooOld2Rock'nRoll bbd81a24d3 Fixing warning messages. 2026-07-29 10:37:03 -03:00
Recep Aslantas b7813d0edb Merge pull request #496 from 94xhn/fix/aabb-sphere-below-min-face-selection
box/aabb2d: fix wrong face selected below AABB min bound in sphere/circle test
2026-07-18 18:32:22 +03:00
94xhn 1c260ceb7d box/aabb2d: fix wrong face selected below AABB min bound in sphere/circle test
glm_aabb_sphere() and glm_aabb2d_circle() pick which box face to
measure axis distance to via `!(a - 1)`, where
`a = (s[i] < box[0][i]) + (s[i] > box[1][i])` is 1 for either
out-of-range direction. `!(a - 1)` always resolves to index 1
(the max face) whenever a == 1, so when the query point is below
the box's min bound on an axis, distance is measured to the wrong
(max) face instead of the min face, inflating dmin and producing
false-negative intersection results.

The above-max direction happens to pick the correct face already,
which is why this went unnoticed since the index-selection logic
was introduced in #180 (fix for #179).

Fix: index directly with the "above max" boolean
(s[i] > box[1][i]) instead of the derived !(a - 1) expression --
it's 0 for below-min (selects box[0], correct) and 1 for
above-max (selects box[1], correct), and is already computed as
part of `a`/`b`/`c` so no extra branching is introduced. Same fix
applied to both the 3D (box.h) and 2D (aabb2d.h) variants since
they share the identical pattern.

Verified against a hand-written Ericson/Graphics-Gems reference
point-AABB distance test: 200k randomized box/sphere fuzz cases
show 3418/200000 false negatives before this fix and 0/200000
after, with no change to the already-correct above-max and
fully-enclosed cases.
2026-07-18 18:06:58 +08:00
Recep Aslantas 49e4284773 build: add missing files 2026-07-16 16:56:37 +03:00
Recep Aslantas 46f46e5dcb Merge pull request #492 from FunkyAss/fix/call_api_pulls_inline
Fix "Call API pulls inline API"
2026-05-31 21:43:15 +03:00
Davide Del Zompo a97af506ce address review comments
- use relative includes for cglm/call/ headers
 - explicitly include stdio in cglm/call/io.h
 - update call documentation
2026-04-18 10:11:03 +03:00
Davide Del Zompo 454f032310 call API: don't include inline functions in header 2026-03-22 11:24:45 +02:00
Davide Del Zompo f0f05dadc5 Move glm_euler_seq to types.h 2026-03-22 11:11:46 +02:00
Recep Aslantas 83d5b2c973 docs: add infinite perspective 2026-02-10 22:59:46 +03:00
Recep Aslantas 7e1bdd0676 Merge pull request #489 from Lephar/master
Implement infinite perspective projection matrix creation functions
2026-02-10 22:45:21 +03:00
Ali Emre Gülcü 0dc17e5d47 Implement default infinite perspective projection matrix creation functions 2026-02-10 16:35:50 +03:00
Ali Emre Gülcü d6c6b4c542 Implement infinite perspective projection matrix creation functions 2026-02-10 12:30:11 +03:00
Recep Aslantas 0356534c0c Merge pull request #488 from lesleyrs/wextra
fix -ffast-math with -Wextra warnings
2026-01-31 14:44:49 +03:00
lesleyrs 5ff0d80c85 fix -ffast-math with -Wextra warnings 2026-01-22 16:09:11 +01:00
Recep Aslantas 1952042f2c Merge pull request #487 from tayoky/master
add glm_vecx_swap functions
2025-11-19 23:44:21 +03:00
tayoky 3aad5823ca add glm_vecx_swap functions 2025-11-15 10:39:14 +01:00
Recep Aslantas da957fa421 Merge pull request #483 from Lephar/master
Add missing glmc_perspective_resize_**_**() call/clipspace functions
2025-11-08 17:41:00 +03:00
Ali Emre Gülcü 47e5d48749 Add missing glmc_perspective_resize_**_**() call/clipspace functions 2025-11-05 09:56:28 +03:00
Recep Aslantas a4602f2d5f Merge pull request #478 from fd00/fix-make
Fix `make` on `srcdir != builddir`
2025-06-18 17:44:56 +03:00
Daisuke Fujimura (fd0) 6af4e0d565 Fix make on srcdir != builddir 2025-06-18 20:55:40 +09:00
Recep Aslantas a311dbfe4c Merge pull request #476 from aganm/double-promotion
Fix double-promotion warnings in tests
2025-05-13 12:33:55 +03:00
Michael Aganier a761088e15 Fix double-promotion warnings in tests 2025-05-12 17:38:21 -04:00
Recep Aslantas a886d6e170 Merge pull request #471 from under-view/feature/mat3-tables
mat3: add tables to docs & fix comments
2025-04-24 16:07:51 +03:00
Recep Aslantas 1a8b105ce6 Merge pull request #472 from under-view/mat2-docs-cleanup
mat2: docs cleanup
2025-04-24 16:07:31 +03:00
Vincent Davis Jr ec5f8074c4 mat2: docs cleanup
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-17 18:08:50 -04:00
Vincent Davis Jr 6f5fde8b52 mat3: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-17 14:22:00 -04:00
Recep Aslantas 9da4e78c2e Merge pull request #469 from under-view/feature/mat2-tables
mat2: add tables to docs & fix comments
2025-04-11 17:14:17 +03:00
Vincent Davis Jr 27a3ddc928 gitignore: ignore vim swp files
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-11 00:13:55 -04:00
Vincent Davis Jr 5d530cd8e0 mat2: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-11 00:13:54 -04:00
Vincent Davis Jr dde053a295 mat2x3[docs]: fix glm_mat2x3_zero parameters
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-05 09:58:49 -04:00
Recep Aslantas 2128235d42 Merge pull request #467 from recp/textrans
build texture transform matrix helper
2025-04-05 13:52:15 +03:00
Recep AslantasandCopilot 9fb418bcac Update include/cglm/mat3.h
Co-authored-by: Copilot <[email protected]>
2025-04-05 13:36:12 +03:00
Recep Aslantas 5fde20d65c build texture transform matrix helper 2025-04-05 13:32:47 +03:00
Recep Aslantas ebc65782f8 Merge pull request #466 from recp/integration_1 2025-04-05 06:32:01 +03:00
Recep Aslantas 1bd04c819b some apple simd framework integration helpers 2025-04-04 23:02:12 +03:00
Recep Aslantas 8560da0e70 define __cglm__ to publish cglm availability universally
in this way we wont need to check arbitrary header check e.g. cglm_common_h
2025-04-04 23:01:55 +03:00
Recep Aslantas ed7a658637 Merge pull request #465 from under-view/feature/mat4x3-tables
mat4x3: add tables to docs & fix comments
2025-04-04 22:57:01 +03:00
Recep Aslantas bcc475e2b7 Merge pull request #464 from under-view/feature/mat4x2-tables
mat4x2: add tables to docs & fix comments
2025-04-04 22:56:30 +03:00
Vincent Davis Jr bdca98ba48 mat4x2: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-04 13:29:10 -04:00
Vincent Davis Jr b33e29d50f mat4x3: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-04 13:22:27 -04:00
Vincent Davis Jr 4b3e9bb779 mat3x2: fix scale comment
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-04 11:04:44 -04:00
Recep Aslantas 214842db27 Merge pull request #462 from under-view/feature/mat3x4-tables
mat3x4: add tables to docs & fix comments
2025-04-03 21:42:27 +03:00
Recep Aslantas 60e4d6c188 Merge pull request #461 from under-view/feature/mat3x2-tables
mat3x2: add tables to docs & fix comments
2025-04-03 21:41:44 +03:00
Recep Aslantas 5063d4b2b0 Merge pull request #460 from under-view/feature/mat2x4-tables
mat2x4: add tables to docs & fix comments
2025-04-03 21:40:57 +03:00
Recep Aslantas a16bc2ae4a Merge pull request #459 from under-view/feature/mat2x3-tables
mat2x3: add tables to docs & fix comments
2025-04-03 21:38:32 +03:00
Vincent Davis Jr b694c97204 mat2x4: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-03 11:30:34 -04:00
Vincent Davis Jr 4791fe3f24 mat3x4: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-03 11:27:00 -04:00
Vincent Davis Jr b64067a94d mat3x2: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-03 01:22:55 -04:00
Vincent Davis Jr 43363e8c43 mat2x3: add tables to docs & fix comments
Signed-off-by: Vincent Davis Jr <[email protected]>
2025-04-02 19:59:20 -04:00
Recep Aslantas f3094cdc65 add missing almm_*_set1() to arm and wasm 2025-03-19 23:28:58 +03:00
Recep Aslantas a7bd64952e Update .gitignore 2025-03-19 23:28:26 +03:00
Recep Aslantas 4141298161 Merge pull request #452 from RolandMarchand/add-tau-constants
Added Tau constant definitions to types.h
2025-03-19 17:27:45 +03:00
Recep Aslantas 05979281ac Merge pull request #457 from MarcinKonowalczyk/typo
Typo
2025-03-19 17:24:56 +03:00
Recep Aslantas 4b3dcceb9d Merge pull request #456 from MarcinKonowalczyk/w-conversion
Add -Wconversion
2025-03-19 17:22:55 +03:00
Marcin cfb8cd9447 more mat4's 2025-03-18 14:17:35 +00:00
Marcin 8d01d1d135 mat4 in docs 2025-03-18 14:14:37 +00:00
Marcin c6caddc75e frand48 2025-03-18 13:30:59 +00:00
Marcin 8b810c2280 -Wconversion 2025-03-18 13:25:32 +00:00
Marcin fd3b21f5d7 newline 2025-03-18 13:24:28 +00:00
Marcin c1ea9e7a69 -Wextra and -Wpedantic 2025-03-18 13:24:23 +00:00
Roland Marchand 44b5952ec3 Added Tau constant definitions to types.h 2025-03-11 08:05:51 -04:00
Recep Aslantas 6e2976d415 Merge pull request #450 from ATMI/affine2d-post
Added 2D Post Transformations
2025-02-22 14:49:35 +03:00
Artemii Miasoedov 9a7f52202d Fixed broken formatting in test_common.c 2025-02-16 15:55:40 +03:00
Artemii Miasoedov e96b6a382d Added tests for 2D affine post transformations (translate, rotate, scale) 2025-02-16 15:50:53 +03:00
Artemii Miasoedov 091c475422 Implemented 2D affine post transformations (translate, rotate, scale) 2025-02-16 14:39:10 +03:00
Recep Aslantas 144d1e7c29 build: add missing call/aabb2d.h 2025-02-13 22:35:16 +03:00
Recep Aslantas 643700c05e now working on v0.9.6 2025-02-13 12:25:10 +03:00
Recep Aslantas fb4eac2ee0 Merge pull request #413 from recp/optimize-inv
WIP: More Optimizations and SIMD fixes for MSVC & ARM
2025-02-12 23:08:07 +03:00
Recep Aslantas 4d0a0a7025 Update wasm.h 2025-02-09 15:30:49 +03:00
Recep Aslantas a88d32c776 Merge branch 'master' into optimize-inv 2025-02-09 15:13:28 +03:00
Recep Aslantas 3bfd31af99 build, win: add missing files 2025-02-09 15:01:55 +03:00
Recep Aslantas 3ee809b9b3 Merge pull request #444 from wethu/wethu-docs-minor-fix-example-numbering
Fix numbering - opengl matrix uniform examples (docs)
2025-01-30 23:10:03 +03:00
Ellis 8cdf496baf Fix numbering 2025-01-30 21:39:17 +10:00
Recep Aslantas d42bff7773 Update ci.yml 2025-01-25 11:53:27 +03:00
Recep Aslantas 365d43bef4 Update ci.yml 2025-01-25 11:47:32 +03:00
Recep Aslantas 5770fdb336 ci: add arm builds 2025-01-25 11:08:06 +03:00
Recep Aslantas 042d84f058 ci: add arm builds 2025-01-25 10:58:48 +03:00
Recep Aslantas 70a1a946ee arm: use glmm_div where possible to fix ARMv7 <-> ARM64 2025-01-24 22:21:11 +03:00
Recep Aslantas 8ca1f19aa2 arm: use glmm_div where possible to fix ARMv7 <-> ARM64 2025-01-24 22:20:57 +03:00
Recep Aslantas adb3ac18c0 Merge branch 'master' into optimize-inv 2025-01-24 16:04:49 +03:00
Recep Aslantas 441f2657ab suppress param-name warns 2025-01-24 11:20:49 +03:00
Recep Aslantas 9b660e8bd0 Update cmake-wasm.yml 2025-01-23 14:10:04 +03:00
Recep Aslantas 40a2aca7ec Update cmake-wasm.yml 2025-01-23 13:55:14 +03:00
Recep Aslantas a48fa8be65 Update cmake-wasm.yml 2025-01-23 13:54:37 +03:00
Recep Aslantas 2f36faa70a Update cmake-wasm.yml 2025-01-23 13:45:19 +03:00
Recep Aslantas 36f59b7b6c Update cmake-wasm.yml 2025-01-23 13:39:30 +03:00
Recep Aslantas f4993318d2 Update ci.yml 2025-01-23 13:04:37 +03:00
Recep Aslantas 5672370e31 Update ci.yml 2025-01-23 12:49:52 +03:00
Recep Aslantas ae1b9a3982 Update ci.yml 2025-01-23 12:44:04 +03:00
Recep Aslantas a18d9c28e7 Update ci.yml 2025-01-23 12:41:08 +03:00
Recep Aslantas fc91f95bb2 Merge branch 'master' of https://github.com/recp/cglm 2025-01-23 12:24:49 +03:00
Recep Aslantas 39052494a2 Revert "Update ci.yml"
This reverts commit 488f782704.
2025-01-23 12:22:27 +03:00
Recep Aslantas 488f782704 Update ci.yml
Update ci.yml

Update ci.yml
2025-01-23 12:22:09 +03:00
Recep Aslantas 814c354337 Update ci.yml 2025-01-23 12:18:12 +03:00
Recep Aslantas 1ad56f0e94 Update ci.yml 2025-01-23 12:16:07 +03:00
Recep Aslantas cc54ad3f92 Update ci.yml 2025-01-23 12:15:22 +03:00
Recep Aslantas 3971ef8ef1 Update ci.yml 2025-01-23 01:09:20 +03:00
Recep Aslantas b4a3ed32d9 Update ci.yml 2025-01-23 01:07:32 +03:00
Recep Aslantas eb37a28ff5 Update ci.yml 2025-01-23 00:58:02 +03:00
Recep Aslantas 925f9c1d1a Update ci.yml 2025-01-23 00:50:36 +03:00
Recep Aslantas 9f74fd9597 Update ci.yml 2025-01-23 00:44:12 +03:00
Recep Aslantas 99937807cf Update ci.yml 2025-01-23 00:19:52 +03:00
Recep Aslantas cc79b440e7 Update ci.yml 2025-01-23 00:13:59 +03:00
Recep Aslantas e161c4d0a7 Update ci.yml 2025-01-23 00:06:00 +03:00
Recep Aslantas e8c791e91e Merge pull request #441 from MarcinKonowalczyk/perlin
Implement Perlin noise
2025-01-22 23:23:03 +03:00
Recep Aslantas 241b751d8c build, autotools: add missing file 2025-01-22 23:17:23 +03:00
Marcin dfc9969f85 vectorise fades
fix fade for vec2
2025-01-22 16:49:27 +00:00
Marcin 2b4aef2a29 glm__noiseDetail_fade_vec2 arg restrict 2025-01-22 16:49:26 +00:00
Marcin fd0131734f fix granNorm arg order 2025-01-22 16:49:26 +00:00
Marcin 9cfa40f423 glm__noiseDetail_taylorInvSqrt 2025-01-22 16:49:26 +00:00
Marcin b79347eb13 vdivq_f32 2025-01-22 16:49:26 +00:00
Marcin 450d747867 1/7 patch 2025-01-22 14:40:18 +00:00
Recep Aslantas 26e174db46 Merge pull request #442 from duarm/master
Rename struct/aabb2d.h functions to match aabb2d.h, add tests
2025-01-21 10:00:12 +03:00
Recep Aslantas e605c1d585 Update aabb2d.h 2025-01-21 09:59:48 +03:00
duarm f815918a74 rename struct/aabb2d.h functions to match aabb2d.h, add tests 2025-01-20 13:29:21 -03:00
Marcin 948642ff33 _glm_ -> glm__ for internal macros 2025-01-20 14:09:05 +00:00
Marcin 23c0f5f660 couple more // comments 2025-01-18 20:11:00 +00:00
Marcin d3ad1645fc purged // comments in noise.h 2025-01-18 20:11:00 +00:00
Marcin fa7bc07ae9 changed noiseDetail to #defines
_glm_noiseDetail_mod289
_glm_noiseDetail_permute
_glm_noiseDetail_fade_vec4
_glm_noiseDetail_fade_vec3
_glm_noiseDetail_fade_vec2
_glm_noiseDetail_taylorInvSqrt
_glm_noiseDetail_gradNorm_vec4
_glm_noiseDetail_gradNorm_vec3
_glm_noiseDetail_gradNorm_vec2
_glm_noiseDetail_i2gxyzw
_glm_noiseDetail_i2gxyz
_glm_noiseDetail_i2gxy
2025-01-18 20:11:00 +00:00
Marcin f32f18a373 sets -> fill 2025-01-18 20:10:59 +00:00
Marcin 082f1878dd glms_vec2_mods doc 2025-01-18 20:10:59 +00:00
Marcin 4b0e7dadd6 vec2 swizzle 2025-01-18 20:10:59 +00:00
Marcin b45bf1d571 switch deprecation in cglm/call.h to #define 2025-01-18 20:10:59 +00:00
Marcin 8493a6c0d3 fix cglm_vec3/4_swizzle 2025-01-18 20:10:59 +00:00
Marcin f50736aee7 vec2_step test 2025-01-18 20:10:59 +00:00
Marcin 6bc980f3d9 add missing vec2 step 2025-01-18 20:10:59 +00:00
Marcin 5cffcf74c4 missing glmc_vec2_stepr 2025-01-18 20:10:58 +00:00
Marcin fb469c779d missing doc 2025-01-18 20:10:58 +00:00
Marcin 8e69157052 missing vec4 steps and stepr 2025-01-18 20:10:58 +00:00
Marcin 6c0e3e9460 deprecate step_uni in favour of steps
This seems to be the newer naming system
2025-01-18 20:10:58 +00:00
Marcin 4ca0c536af steps and stepr test 2025-01-18 20:10:58 +00:00
Marcin 9a1206f3f1 steps and stepr boilerplate 2025-01-18 20:10:58 +00:00
Marcin c2ebef3867 change steps -> stepr and move to ext 2025-01-18 20:10:57 +00:00
Marcin 0e0eff71ce correct vec4_mods doc 2025-01-18 20:10:57 +00:00
Marcin 6620adcc16 fix invalid types in vec2_frac/floor 2025-01-18 20:10:57 +00:00
Marcin a986a4d741 add missing floor tests 2025-01-18 20:10:57 +00:00
Marcin 32e7d5cceb mods test 2025-01-18 20:10:57 +00:00
Marcin e14c730d5c mods boilerplate 2025-01-18 20:10:57 +00:00
Marcin fbf0014c82 missing vec4_floor doc 2025-01-18 20:10:56 +00:00
Marcin 0483362f5c move mods to ext 2025-01-18 20:10:56 +00:00
Marcin 35af0c04fe remove extra spaces from vec3.h and vec4.h 2025-01-18 13:19:29 +00:00
Marcin 66d51e5771 double spaces in other files 2025-01-18 13:19:29 +00:00
Marcin 5a3a16d9ad double spaces in noise.h 2025-01-18 13:19:29 +00:00
Marcin 651ad8ca32 vec2-ext docs 2025-01-18 12:57:33 +00:00
Marcin b1192c8638 vec3-ext docs 2025-01-18 12:57:33 +00:00
Marcin eaf2d7314e vec4-ext docs 2025-01-18 12:57:33 +00:00
Marcin 200b0875ba vec2_floor test 2025-01-18 12:57:32 +00:00
Marcin 9a25fab6f0 vec2_floor boilerplate 2025-01-18 12:57:32 +00:00
Marcin bfaf413a5d vec2_floor impl 2025-01-18 12:57:32 +00:00
Marcin 9594d0cc86 add missing glms_vec2_abs 2025-01-18 12:57:32 +00:00
Marcin 2890472a0b add missing test entry for vec2_abs 2025-01-18 12:57:32 +00:00
Marcin c48befca37 vec2_fract test 2025-01-18 12:57:32 +00:00
Marcin 3c9eecd0be vec2_fract boilerplate 2025-01-18 12:57:32 +00:00
Marcin a9fee1b4d7 vec2_fract 2025-01-18 12:57:31 +00:00
Marcin 52753672bb vec4_fract test 2025-01-18 12:57:31 +00:00
Marcin 68215526cf vec4_floor boilerplate 2025-01-18 12:57:31 +00:00
Marcin c27ef7e93b vec3_floor struct doc 2025-01-18 12:57:31 +00:00
Marcin 2ba561cc92 move vec4_floor to ext 2025-01-18 12:57:31 +00:00
Marcin e66f2f3df4 vec3_floor test 2025-01-18 12:57:31 +00:00
Marcin 967c9e0a09 vec3_floor boilerplate 2025-01-18 12:57:31 +00:00
Marcin 1637d2cef1 move vec3_floor to ext 2025-01-18 12:57:30 +00:00
Marcin 2acdd1e4d0 fix _glm_noiseDetail_gradNorm_vec2 2025-01-18 12:57:30 +00:00
Marcin 606ecbceaa vac_muls -> vec_scale 2025-01-18 12:57:30 +00:00
Marcin f1a72241b1 docs 2025-01-17 20:34:47 +00:00
Marcin 9085ed020a glm_perlin_vec2 test 2025-01-17 20:22:00 +00:00
Marcin 1377a94a17 glm_perlin_vec2 boilerplate 2025-01-17 20:21:59 +00:00
Marcin a98c270eee glm_perlin_vec2 impl 2025-01-17 20:21:59 +00:00
Marcin 83b67baa23 glm_perlin_vec3 docs 2025-01-17 16:40:07 +00:00
Marcin ae82a493f7 note 2025-01-17 16:38:19 +00:00
Marcin 98ab6fcbe0 glm_perlin_vec3 test 2025-01-17 16:38:19 +00:00
Marcin f0529646b2 glm_perlin_vec3 boilerplate 2025-01-17 16:38:19 +00:00
Marcin 585a999d79 docs 2025-01-17 16:38:19 +00:00
Marcin 5f241a2daf glm_perlin_vec3 impl 2025-01-17 16:38:19 +00:00
Marcin fbdc46b205 more doc 2025-01-17 16:38:18 +00:00
Marcin ae1bee7481 doc 2025-01-17 16:38:18 +00:00
Marcin a0d8803f76 perlin.h -> noise.h 2025-01-15 14:05:08 +00:00
Marcin 43c9f84c8c test_perlin 2025-01-15 13:35:10 +00:00
Marcin 71a0dc6c35 minor reshuffle 2025-01-15 13:35:10 +00:00
Marcin 5d34a04496 refactor gNorm 2025-01-15 13:35:10 +00:00
Marcin b54dff0124 minor comment 2025-01-15 13:35:10 +00:00
Marcin fda5406ac0 unnecessary zero init 2025-01-15 13:35:10 +00:00
Marcin f19dc13e39 missed bracket 2025-01-15 13:35:09 +00:00
Marcin f3f75a2727 impl but buggy 2025-01-15 13:35:09 +00:00
Marcin c3e16a53f4 work in progress 2025-01-15 13:35:09 +00:00
Marcin 8a2fd9cda9 docs boilerplate 2025-01-14 17:34:51 +00:00
Marcin 98f53c750d test boilerplate 2025-01-14 17:32:56 +00:00
Marcin 3e52d90ecb boilerplate 2025-01-14 17:32:46 +00:00
Marcin a4cd7e008d initial impl 2025-01-14 17:31:35 +00:00
Recep Aslantas 5861c37a93 Merge pull request #437 from master30f/readme-restructure
Restructure and rephrase README
2025-01-08 11:28:30 +03:00
zorby aae82c1d4a README: Add chapter about alignment 2025-01-04 11:51:43 +01:00
zorby 7e51ed88e8 README: Add Features 2025-01-04 11:23:37 +01:00
zorby 32a05a579b README: Move Struct API chapter 2025-01-04 11:22:52 +01:00
Recep Aslantas 9b67866154 Merge pull request #438 from master30f/file-cleanup
Remove .vscode and .gitmodules
2025-01-03 23:42:41 +03:00
zorby bab7d7bb12 Add .vscode to .gitignore 2025-01-03 17:09:44 +01:00
zorby 5a207d84bb Remove .gitmodules
See issue #436.
2025-01-03 10:43:47 +01:00
zorby 7783acae10 Remove .vscode
See issue #436.
2025-01-03 10:40:17 +01:00
zorby 9d079d3cc3 Restructure README 2024-12-30 13:50:11 +01:00
Recep Aslantas 054b2df004 vscode: disable formatOnSave 2024-12-03 14:27:06 +03:00
Recep Aslantas 93a2926a13 Merge pull request #430 from nitrix/feat/cmake-3.13
Bump CMake minimum version to 3.13
2024-09-10 14:06:45 +03:00
Alex Belanger 5484259328 Undid the formatting. 2024-09-09 10:35:24 -04:00
Alex Belanger e930737807 Bump CMake minimum version to 3.13 2024-09-09 10:06:09 -04:00
Recep Aslantas c12f318fab supress fast-math warns 2024-08-27 13:40:34 +03:00
Recep Aslantas b0f35203f9 suppress warns 2024-08-27 12:32:58 +03:00
Recep Aslantas ad009d4e49 doc: improve briefs 2024-08-27 12:29:43 +03:00
Recep Aslantas 2f619cdd6f newlines 2024-08-27 12:22:42 +03:00
Recep Aslantas 33e78ca2ad suppress warns about va-args 2024-08-27 12:13:28 +03:00
Recep Aslantas f82d570dec take -pedantic into account to validate CGLM_USE_ANONYMOUS_STRUCT 2024-08-27 11:58:34 +03:00
Recep Aslantas 48839a38a1 fix refract 2024-07-15 12:41:23 +03:00
Recep Aslantas d491108386 Merge pull request #423 from waywardmonkeys/reduce-typo-count
Reduce typo count.
2024-07-15 11:29:42 +03:00
Bruce Mitchener 068f6951b3 Reduce typo count. 2024-07-14 09:10:19 +07:00
Recep Aslantas ed731f991d Merge pull request #421 from myfreeer/patch-1
mat4: wasm simd128 for glm_mat4_inv
2024-07-03 17:06:53 +03:00
myfreeer 07dc9520a4 mat4: wasm simd128 for glm_mat4_inv
The function `glm_mat4_inv_wasm` has been implemented, but not used in `glm_mat4_inv`. This commit adds a conditional macro to add the case of wasm and simd128 case for calling `glm_mat4_inv_wasm`.
2024-07-03 20:04:50 +08:00
Recep Aslantas be0defb7ac Merge pull request #420 from not-kaz/master
Fixed 'missing-prototypes' warnings for some vec2 funcs.
2024-06-11 14:52:02 +03:00
Kaz 5b2c37f73b Fixed 'missing-prototypes' warnings for some vec2 funcs.
Using gcc and missing-prototypes flag shows warnings for:
glmc_vec2_fill, glmc_vec2_eq and glmc_vec2_eqv. 
Seems they were not added to call/vec2.h for some reason. This should fix the warnings.
2024-06-09 11:06:18 +02:00
Recep Aslantas a93a9ef9a2 Merge pull request #416 from telephone001/quat_slerp_longest
added quat_slerp_longest
2024-05-13 17:26:49 +03:00
Recep Aslantas c5b2afc1c4 Update quat.h 2024-05-13 17:20:28 +03:00
John Choi cd5ed1f4c4 added quat_slerp_longest 2024-05-10 22:32:25 -05:00
Recep Aslantas eb3a51e591 win: suppress C4996; use snprintf() instead of sprintf() 2024-04-22 21:33:31 +03:00
Recep Aslantas 44cd0ae4fd avx: optimize avx mat4 scale and mat4 mul 2024-04-13 00:33:57 +03:00
Recep Aslantas d75467f93f avx: implement transpose with AVX 2024-04-13 00:12:14 +03:00
Recep Aslantas 45c1beff51 simd: fix glmm_set1, glmm_splat 2024-04-12 21:53:20 +03:00
Recep Aslantas 14c567d9d9 sse: drop unused macros: glmm_shuff1x, glmm_shuff2 2024-04-11 21:57:46 +03:00
Recep Aslantas 480e1de048 sse: make use of int domain as default behavior if possible ( compiler may ignore it )
also use AVX's `_mm_permute_ps`for shuffling single vector
2024-04-11 21:57:16 +03:00
Recep Aslantas de66f0a67f glmm, avx: optimize splat macros 2024-04-10 23:49:18 +03:00
Recep Aslantas 68bdec4510 simd: use glmm_set1() to optimize broadcasting single float 2024-04-10 22:52:53 +03:00
Recep Aslantas 62c0448e25 simd, msvc: ensure required definitions are exist on msvc 2024-04-07 22:48:11 +03:00
Recep Aslantas 4f00ce0e52 sse: reduce some instructions in mat4 inv 2024-04-07 22:33:37 +03:00
Recep Aslantas a7845ffc44 msvc, simd: fix simd headers for _M_ARM64EC 2024-04-07 00:54:29 +03:00
Recep Aslantas bd941ed7fb arm, neon: fix neon support on GCC ARM 2024-04-06 14:23:36 +03:00
Recep Aslantas 87350f809b msvc bug: dont align types due to "ARM32 = C2719: formal parameter with requested alignment of 16 won't be aligned." on ARM32/MSVC
until a good solution.
2024-04-06 14:11:46 +03:00
Recep Aslantas f50a7a7d00 arm, neon: improve glm_mat4_inv_neon 2024-04-06 14:10:13 +03:00
Recep Aslantas b3308af146 arm: fix glmm_vhadd on ARM32 2024-04-06 14:09:52 +03:00
Recep Aslantas a94f839d6d Merge branch 'master' into optimize-inv 2024-04-04 00:31:08 +03:00
Recep Aslantas 0ff0e8948f Update mat4.h 2024-04-03 00:05:42 +03:00
Recep Aslantas 5b772d0eb4 neon: mat4_inv, reduce 1mul for two extra 2xor 2024-04-03 00:03:55 +03:00
Recep Aslantas c528ca1095 neon: mat4_inv remastered 2024-04-02 13:21:49 +03:00
Recep Aslantas f0e09776d7 arm, neon: optimize glmm_vhadd and add glmm_vdot 2024-04-02 02:36:16 +03:00
Recep Aslantas da4224ba32 now working on v0.9.5 2024-04-02 00:52:54 +03:00
Recep Aslantas 1796cc5ce2 Merge pull request #412 from recp/sse_only
separate SSE and SSE2
2024-04-01 17:52:06 +03:00
Recep Aslantas 568634a79e tests: dont test isinf == true on fast math 2024-04-01 16:48:58 +03:00
Recep Aslantas c9c7941a72 tests: dont test isnan on fast math 2024-04-01 14:10:38 +03:00
Recep Aslantas 4e929a81c2 Update x86.h 2024-04-01 13:26:08 +03:00
Recep Aslantas 1d09c41e18 make xor enable in SSEonly + fast math 2024-04-01 13:23:52 +03:00
Recep Aslantas d8e933b5b1 Update test_project.h 2024-04-01 13:23:22 +03:00
Recep Aslantas 8b15fd51ba common way to identify CGLM_FAST_MATH 2024-04-01 13:23:17 +03:00
Recep Aslantas 9ce0a3b625 tests: disable isnan check for min/max which may not work correctly especially in fast-math environment 2024-04-01 13:22:51 +03:00
Recep Aslantas 00d2e8a4cf suppress warnings 2024-04-01 01:46:25 +03:00
Recep Aslantas 35a12ed033 make SSE2-only features not available in SSE 2024-04-01 00:52:59 +03:00
Recep Aslantas 9ad7dd3fbc Merge pull request #409 from EasyIP2023/feature/expand-content-width
docs: expand wy-nav-content width to edge of screen
2024-03-31 23:44:40 +03:00
Recep Aslantas 28142b5912 Merge pull request #411 from EasyIP2023/bugfix/mat4x3-multiplication
mat4x3: fix multiplication functions
2024-03-31 23:44:00 +03:00
Recep Aslantas f07d75c680 Merge pull request #410 from EasyIP2023/bugfix/mat4x2-multiplication
mat4x2: fix multiplication functions
2024-03-31 23:43:11 +03:00
Recep Aslantas 17d8b83a38 Merge pull request #408 from EasyIP2023/bugfix/mat3x4-multiplication
mat3x4: fix multiplication functions
2024-03-31 23:41:40 +03:00
Recep Aslantas 32a477ef07 separate SSE and SSE2 2024-03-31 23:35:15 +03:00
Recep Aslantas e3ed9834a1 Update mat2x3.h 2024-03-31 23:06:50 +03:00
Recep Aslantas 8396bbf0b3 coding style 2024-03-31 23:06:30 +03:00
Vincent Davis Jr 013ac5dd07 docs: mat4x3 account for latest mulitplication changes
This also includes tables to explain how
mat4x3, column vectors, and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 14:43:31 -04:00
Vincent Davis Jr a0e3d3766f mat4x3: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 14:43:30 -04:00
Vincent Davis Jr fc7f0e13fd docs: mat3x4 account for latest mulitplication changes
This also includes tables to explain how
mat3x4, column vectors, and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 13:43:41 -04:00
Vincent Davis Jr 1340b5d512 mat3x4: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 13:43:39 -04:00
Vincent Davis Jr 85165dd3e3 docs: mat4x2 account for latest mulitplication changes
This also includes tables to explain how
mat4x2, column vectors, and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 13:40:43 -04:00
Vincent Davis Jr 3445f93fbc mat4x2: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 13:40:41 -04:00
Vincent Davis Jr d2642eb206 docs: expand wy-nav-content width to edge of screen
RTD theme's default is 800px as max width for the content,
but we have tables with tons of columns, which need the
full width of the view-port.

Comment from yocto project theme_overrides.css

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 12:22:13 -04:00
Recep Aslantas 929963c6eb Merge pull request #407 from EasyIP2023/bugfix/mat3x2-multiplication
mat3x2: fix multiplication functions
2024-03-31 13:40:58 +03:00
Recep Aslantas 25b33fab6b Merge pull request #405 from EasyIP2023/bugfix/mat2x4-mutli
mat2x4: fix multiplication functions
2024-03-31 13:40:45 +03:00
Recep Aslantas c9adbaabd7 Merge pull request #403 from EasyIP2023/bugfix/mat2x3-multiplication
mat2x3: fix multiplication functions
2024-03-31 13:36:39 +03:00
Recep Aslantas b22e8230d0 Merge pull request #406 from recp/I_macro
dont use I macro defined in standard
2024-03-31 13:30:42 +03:00
Vincent Davis Jr 54dfbc5a28 docs: mat2x4 account for latest mulitplication changes
This also includes tables to explain how
mat2x4, column vectors, and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 00:44:58 -04:00
Vincent Davis Jr 088c66029d docs: mat3x2 account for latest mulitplication changes
This also includes tables to explain how
mat3x2, column vectors, and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 00:39:27 -04:00
Vincent Davis Jr 2283c708c6 mat3x2: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-31 00:23:39 -04:00
Vincent Davis Jr 46864ba2f7 mat2x4: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-30 22:22:34 -04:00
Vincent Davis Jr c5dcb93c92 docs: mat2x3 account for latest mulitplication changes
This also includes tables to explain how
mat2x3, column vectors and row vectors are
represented. Also includes how resulting
matrix or vector is formed.

Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-30 22:08:23 -04:00
Vincent Davis Jr 050bc95264 mat2x3: fix multiplication functions
Signed-off-by: Vincent Davis Jr <[email protected]>
2024-03-30 22:08:19 -04:00
Recep Aslantas 8366e51b47 optimize mat4 scalar inv 2024-03-29 22:13:23 +03:00
Recep Aslantas 30b4ea80a9 optimize mat3 scalar inv 2024-03-29 20:59:54 +03:00
268 changed files with 11536 additions and 4972 deletions

No files matched your search

+492 -99
View File
@@ -8,25 +8,74 @@ on:
jobs:
build_autotools:
name: Autotools / ${{ matrix.os }}
name: Autotools / ${{ matrix.os }} / ${{ matrix.simd }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-12, macos-14, ubuntu-22.04]
include:
# x86/x64 builds
- { os: macos-26-intel, simd: none }
- { os: macos-26-intel, simd: sse }
- { os: macos-26-intel, simd: sse2 }
- { os: macos-26-intel, simd: sse3 }
- { os: macos-26-intel, simd: sse4 }
- { os: macos-26-intel, simd: avx }
- { os: macos-26-intel, simd: avx2 }
- { os: ubuntu-22.04, simd: none }
- { os: ubuntu-22.04, simd: sse }
- { os: ubuntu-22.04, simd: sse2 }
- { os: ubuntu-22.04, simd: sse3 }
- { os: ubuntu-22.04, simd: sse4 }
- { os: ubuntu-22.04, simd: avx }
- { os: ubuntu-22.04, simd: avx2 }
- { os: ubuntu-24.04, simd: none }
- { os: ubuntu-24.04, simd: sse }
- { os: ubuntu-24.04, simd: sse2 }
- { os: ubuntu-24.04, simd: sse3 }
- { os: ubuntu-24.04, simd: sse4 }
- { os: ubuntu-24.04, simd: avx }
- { os: ubuntu-24.04, simd: avx2 }
# ARM64 builds
- { os: macos-latest, simd: neon }
- { os: ubuntu-24.04-arm, simd: neon }
steps:
- uses: actions/checkout@v4
- name: Install Autotools
- name: Install Autotools on macOS
if: runner.os == 'macOS'
run: brew upgrade && brew install autoconf automake libtool
run: brew install autoconf automake libtool
- name: Install Autotools on Ubuntu
if: runner.os == 'Linux'
run: sudo apt-get install -y autoconf automake libtool
- name: Set SIMD flags
run: |
if [ "${{ matrix.simd }}" == "none" ]; then
export CFLAGS=""
elif [ "${{ matrix.simd }}" == "sse" ]; then
export CFLAGS="-msse"
elif [ "${{ matrix.simd }}" == "sse2" ]; then
export CFLAGS="-msse2"
elif [ "${{ matrix.simd }}" == "sse3" ]; then
export CFLAGS="-msse3"
elif [ "${{ matrix.simd }}" == "sse4" ]; then
export CFLAGS="-msse4"
elif [ "${{ matrix.simd }}" == "avx" ]; then
export CFLAGS="-mavx"
elif [ "${{ matrix.simd }}" == "avx2" ]; then
export CFLAGS="-mavx2"
elif [ "${{ matrix.simd }}" == "neon" ]; then
export CFLAGS="-mfpu=neon"
fi
- name: Generate Autotools
run: ./autogen.sh
- name: Configure Autotools
run: ./configure
run: ./configure CFLAGS="$CFLAGS"
- name: Build
run: make
@@ -36,7 +85,7 @@ jobs:
build_cmake_ios:
name: CMake / iOS
runs-on: macos-14
runs-on: macos-latest
steps:
- uses: actions/checkout@v4
@@ -55,20 +104,151 @@ jobs:
- name: Build
run: cmake --build build
build_cmake_ubuntu:
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }} / ${{ matrix.target.arch }} / ${{ matrix.target.simd }}
runs-on: ${{ matrix.target.os }}
strategy:
fail-fast: false
matrix:
target:
# GCC 11 builds
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: none }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse2 }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse3 }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse4 }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx }
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx2 }
# GCC 12 builds
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: none }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse2 }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse3 }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse4 }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: avx }
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: avx2 }
# GCC 13 builds
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: none }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse2 }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse3 }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse4 }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx }
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx2 }
# Clang 12 builds
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: none }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse2 }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse3 }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse4 }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx }
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx2 }
# Clang 15 builds
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: none }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse2 }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse3 }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse4 }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx }
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx2 }
# ARM64 builds
- { os: ubuntu-24.04-arm, cc: gcc-12, arch: arm64, simd: neon }
- { os: ubuntu-24.04-arm, cc: gcc-13, arch: arm64, simd: neon }
# ARMv7 builds
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: neon }
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: none }
steps:
- uses: actions/checkout@v4
- name: Install Compiler and Ninja
run: |
sudo apt-get update
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
sudo apt-get install -y gcc-12-arm-linux-gnueabihf qemu-user ninja-build
else
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
fi
- name: Set SIMD flags
run: |
if [ "${{ matrix.target.simd }}" == "none" ]; then
export CFLAGS=""
elif [ "${{ matrix.target.simd }}" == "sse" ]; then
export CFLAGS="-msse"
elif [ "${{ matrix.target.simd }}" == "sse2" ]; then
export CFLAGS="-msse2"
elif [ "${{ matrix.target.simd }}" == "sse3" ]; then
export CFLAGS="-msse3"
elif [ "${{ matrix.target.simd }}" == "sse4" ]; then
export CFLAGS="-msse4"
elif [ "${{ matrix.target.simd }}" == "avx" ]; then
export CFLAGS="-mavx"
elif [ "${{ matrix.target.simd }}" == "avx2" ]; then
export CFLAGS="-mavx2"
elif [ "${{ matrix.target.simd }}" == "neon" ]; then
export CFLAGS="-mfpu=neon"
fi
- name: Configure CMake
run: |
if [ "${{ matrix.target.arch }}" == "armv7" ]; then
# cross-compile ARMv7 and run its tests with QEMU
neon_flags="-mfpu=vfpv3-d16 -mfloat-abi=hard"
if [ "${{ matrix.target.simd }}" == "neon" ]; then
neon_flags="-mfpu=neon -mfloat-abi=hard"
fi
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
-DCMAKE_C_FLAGS="-march=armv7-a ${neon_flags}" \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
elif [ "${{ matrix.target.arch }}" == "arm64" ]; then
# Build for ARM64 (AArch64)
neon_flags=""
if [ "${{ matrix.target.simd }}" == "neon" ]; then
neon_flags="+simd" # Enable SIMD/NEON features on ARM64
else
neon_flags="+nosimd" # Explicitly disable SIMD/NEON
fi
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
-DCMAKE_C_FLAGS="$CFLAGS -march=armv8-a${neon_flags}" \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
else
# Normal build (x86/x64)
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
-DCMAKE_C_FLAGS="$CFLAGS" \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
fi
- name: Build
run: cmake --build build
- name: Test
working-directory: build
run: |
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
else
./tests
fi
build_cmake_macos:
name: CMake / ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-12, macos-14]
os: [macos-26-intel, macos-latest]
steps:
- uses: actions/checkout@v4
- name: Install Ninja
if: runner.os == 'macOS'
run: brew upgrade && brew install ninja
run: brew install ninja
- name: Configure CMake
run: |
@@ -86,76 +266,264 @@ jobs:
working-directory: build
run: ./tests
build_cmake_ubuntu:
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }}
runs-on: ${{ matrix.target.os }}
build_cmake:
name: CMake / ${{ matrix.os }} / ${{ matrix.simd }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
target:
- { os: ubuntu-20.04, cc: gcc-11 }
- { os: ubuntu-22.04, cc: gcc-12 }
- { os: ubuntu-22.04, cc: gcc-13 }
- { os: ubuntu-20.04, cc: clang-12 }
- { os: ubuntu-22.04, cc: clang-15 }
include:
# x86/x64 builds
- { os: macos-26-intel, simd: none }
- { os: macos-26-intel, simd: sse }
- { os: macos-26-intel, simd: sse2 }
- { os: macos-26-intel, simd: sse3 }
- { os: macos-26-intel, simd: sse4 }
- { os: macos-26-intel, simd: avx }
- { os: macos-26-intel, simd: avx2 }
- { os: windows-2022, simd: none }
- { os: windows-2022, simd: sse }
- { os: windows-2022, simd: sse2 }
- { os: windows-2022, simd: sse3 }
- { os: windows-2022, simd: sse4 }
- { os: windows-2022, simd: avx }
- { os: windows-2022, simd: avx2 }
# ARM64 builds
- { os: macos-latest, simd: neon }
steps:
- uses: actions/checkout@v4
- name: Install Compiler and Ninja
run: |
sudo apt-get update -y
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
- name: Install Ninja on macOS
if: runner.os == 'macOS'
run: brew install ninja
- name: Configure CMake
- name: Set SIMD flags (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
cmake \
-B build \
-GNinja \
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
-DCMAKE_BUILD_TYPE=Release \
-DCGLM_STATIC=ON \
-DCGLM_USE_TEST=ON
$simd = "${{ matrix.simd }}"
if ($simd -eq "none") {
$env:CFLAGS = ""
} elseif ($simd -eq "sse") {
$env:CFLAGS = "-arch:SSE"
} elseif ($simd -eq "sse2") {
$env:CFLAGS = "-arch:SSE2"
} elseif ($simd -eq "sse3") {
$env:CFLAGS = "-arch:SSE3"
} elseif ($simd -eq "sse4") {
$env:CFLAGS = "-arch:SSE4"
} elseif ($simd -eq "avx") {
$env:CFLAGS = "-arch:AVX"
} elseif ($simd -eq "avx2") {
$env:CFLAGS = "-arch:AVX2"
} elseif ($simd -eq "neon") {
$env:CFLAGS = "-arch:NEON"
}
- name: Set SIMD flags (Unix)
if: runner.os != 'Windows'
shell: bash
run: |
if [ "${{ matrix.simd }}" == "none" ]; then
export CFLAGS=""
elif [ "${{ matrix.simd }}" == "sse" ]; then
export CFLAGS="-msse"
elif [ "${{ matrix.simd }}" == "sse2" ]; then
export CFLAGS="-msse2"
elif [ "${{ matrix.simd }}" == "sse3" ]; then
export CFLAGS="-msse3"
elif [ "${{ matrix.simd }}" == "sse4" ]; then
export CFLAGS="-msse4"
elif [ "${{ matrix.simd }}" == "avx" ]; then
export CFLAGS="-mavx"
elif [ "${{ matrix.simd }}" == "avx2" ]; then
export CFLAGS="-mavx2"
elif [ "${{ matrix.simd }}" == "neon" ]; then
export CFLAGS="-mfpu=neon"
fi
- name: Configure CMake (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: cmake -B build -G "Visual Studio 17 2022" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="$env:CFLAGS" -DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
- name: Configure CMake (Unix)
if: runner.os != 'Windows'
shell: bash
run: cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="$CFLAGS" -DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
- name: Build
run: cmake --build build
- name: Test
- name: Test (Windows)
if: runner.os == 'Windows'
shell: pwsh
working-directory: build
run: .\Debug\tests.exe
- name: Test (Unix)
if: runner.os != 'Windows'
shell: bash
working-directory: build
run: ./tests
build_cmake_windows:
name: CMake / ${{ matrix.platform.name }}
build_meson:
name: Meson / ${{ matrix.os }} / ${{ matrix.simd }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
# x86/x64 builds
- { os: macos-26-intel, simd: none }
- { os: macos-26-intel, simd: sse }
- { os: macos-26-intel, simd: sse2 }
- { os: macos-26-intel, simd: sse3 }
- { os: macos-26-intel, simd: sse4 }
- { os: macos-26-intel, simd: avx }
- { os: macos-26-intel, simd: avx2 }
- { os: ubuntu-22.04, simd: none }
- { os: ubuntu-22.04, simd: sse }
- { os: ubuntu-22.04, simd: sse2 }
- { os: ubuntu-22.04, simd: sse3 }
- { os: ubuntu-22.04, simd: sse4 }
- { os: ubuntu-22.04, simd: avx }
- { os: ubuntu-22.04, simd: avx2 }
- { os: ubuntu-24.04, simd: none }
- { os: ubuntu-24.04, simd: sse }
- { os: ubuntu-24.04, simd: sse2 }
- { os: ubuntu-24.04, simd: sse3 }
- { os: ubuntu-24.04, simd: sse4 }
- { os: ubuntu-24.04, simd: avx }
- { os: ubuntu-24.04, simd: avx2 }
- { os: windows-2022, simd: none }
- { os: windows-2022, simd: sse }
- { os: windows-2022, simd: sse2 }
- { os: windows-2022, simd: sse3 }
- { os: windows-2022, simd: sse4 }
- { os: windows-2022, simd: avx }
- { os: windows-2022, simd: avx2 }
# ARM64 builds
- { os: macos-latest, simd: neon }
- { os: ubuntu-24.04-arm, simd: neon }
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
cache: 'pip'
- name: Install meson
run: python3 -m pip install meson ninja
- name: Set SIMD flags (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
$simd = "${{ matrix.simd }}"
if ($simd -eq "none") {
$env:CFLAGS = ""
} elseif ($simd -eq "sse") {
$env:CFLAGS = "-arch:SSE"
} elseif ($simd -eq "sse2") {
$env:CFLAGS = "-arch:SSE2"
} elseif ($simd -eq "sse3") {
$env:CFLAGS = "-arch:SSE3"
} elseif ($simd -eq "sse4") {
$env:CFLAGS = "-arch:SSE4"
} elseif ($simd -eq "avx") {
$env:CFLAGS = "-arch:AVX"
} elseif ($simd -eq "avx2") {
$env:CFLAGS = "-arch:AVX2"
} elseif ($simd -eq "neon") {
$env:CFLAGS = "-arch:NEON"
}
- name: Set SIMD flags (Unix)
if: runner.os != 'Windows'
shell: bash
run: |
if [ "${{ matrix.simd }}" == "none" ]; then
export CFLAGS=""
elif [ "${{ matrix.simd }}" == "sse" ]; then
export CFLAGS="-msse"
elif [ "${{ matrix.simd }}" == "sse2" ]; then
export CFLAGS="-msse2"
elif [ "${{ matrix.simd }}" == "sse3" ]; then
export CFLAGS="-msse3"
elif [ "${{ matrix.simd }}" == "sse4" ]; then
export CFLAGS="-msse4"
elif [ "${{ matrix.simd }}" == "avx" ]; then
export CFLAGS="-mavx"
elif [ "${{ matrix.simd }}" == "avx2" ]; then
export CFLAGS="-mavx2"
elif [ "${{ matrix.simd }}" == "neon" ]; then
export CFLAGS="-mfpu=neon"
fi
- name: Build with meson (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true -Dc_args="$env:CFLAGS"
meson test -C build
- name: Build with meson (Unix)
if: runner.os != 'Windows'
shell: bash
run: |
meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true -Dc_args="$CFLAGS"
meson test -C build
build_msbuild:
name: MSBuild / Windows / ${{ matrix.simd }}
runs-on: windows-2022
strategy:
fail-fast: false
matrix:
platform:
- { name: Windows (x64), flags: -A x64 }
- { name: Windows (x86), flags: -A Win32 }
- { name: Windows (clang-cl x64), flags: -T ClangCL -A x64 }
- { name: Windows (clang-cl x86), flags: -T ClangCL -A Win32 }
- { name: Windows (ARM), flags: -A ARM, skip_tests: true, skip_build: true } # This fails to build.
- { name: Windows (ARM64), flags: -A ARM64, skip_tests: true }
- { name: UWP (ARM64), flags: -A ARM64, -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0", skip_tests: true }
- { name: UWP (x64), flags: -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0", skip_tests: true }
simd: [none, sse, sse2, sse3, sse4, avx, avx2, neon]
steps:
- uses: actions/checkout@v4
- name: Configure CMake
run: cmake -B build `
-DCGLM_STATIC=ON `
-DCGLM_USE_TEST=ON `
${{ matrix.platform.flags }}
- uses: microsoft/setup-msbuild@v2
- name: Build
if: ${{ !matrix.platform.skip_build }}
run: cmake --build build --config Release --parallel
- name: Retarget solution
run: |
vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
$vsInstallPath = vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
& "$vsInstallPath\Common7\IDE\devenv.com" cglm.sln /Upgrade
- name: Test
if: ${{ !matrix.platform.skip_tests }}
working-directory: build
run: .\Release\tests.exe
- name: Set SIMD flags
run: |
if ($Env:SIMD -eq 'none') {
$Env:CFLAGS=""
} elseif ($Env:SIMD -eq 'sse') {
$Env:CFLAGS="-arch:SSE"
} elseif ($Env:SIMD -eq 'sse2') {
$Env:CFLAGS="-arch:SSE2"
} elseif ($Env:SIMD -eq 'sse3') {
$Env:CFLAGS="-arch:SSE3"
} elseif ($Env:SIMD -eq 'sse4') {
$Env:CFLAGS="-arch:SSE4"
} elseif ($Env:SIMD -eq 'avx') {
$Env:CFLAGS="-arch:AVX"
} elseif ($Env:SIMD -eq 'avx2') {
$Env:CFLAGS="-arch:AVX2"
} elseif ($Env:SIMD -eq 'neon') {
$Env:CFLAGS="-arch:NEON"
}
- name: Build (x86)
working-directory: win
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x86 /p:PlatformToolset=v143 /p:BuildInParallel=true /p:AdditionalOptions="$Env:CFLAGS"
- name: Build (x64)
working-directory: win
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x64 /p:PlatformToolset=v143 /p:BuildInParallel=true /p:AdditionalOptions="$Env:CFLAGS"
build_documentation:
name: Documentation
@@ -176,57 +544,13 @@ jobs:
working-directory: docs
run: sphinx-build -W --keep-going source build
build_meson:
name: Meson / ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-14, ubuntu-22.04]
steps:
- uses: actions/checkout@v4
- uses: actions/setup-python@v5
with:
python-version: '3.12'
cache: 'pip'
- name: Install meson
run: python3 -m pip install meson ninja
- name: Build
run: meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true
- name: Test
run: meson test -C build
build_msbuild:
name: MSBuild / Windows
runs-on: windows-2022
# This has no test yet.
# It could also try building for ARM, ARM64, ARM64EC, but those fail currently.
steps:
- uses: actions/checkout@v4
- uses: microsoft/setup-msbuild@v2
- name: Build (x86)
working-directory: win
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x86 /p:BuildInParallel=true
- name: Build (x64)
working-directory: win
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x64 /p:BuildInParallel=true
build_swift:
name: Swift ${{ matrix.swift }} / ${{ matrix.os }}
name: Swift / ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-12, macos-14, ubuntu-22.04]
os: [macos-26-intel, macos-latest, ubuntu-22.04]
# This has no test yet.
steps:
@@ -234,3 +558,72 @@ jobs:
- name: Build
run: swift build
build_cmake_arm:
name: CMake / ARM / ${{ matrix.os }} / ${{ matrix.arch }} / ${{ matrix.simd }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
# native ARM64 and cross-compiled ARMv7 builds
- { os: ubuntu-24.04-arm, arch: arm64, simd: neon }
- { os: ubuntu-24.04-arm, arch: armv7, simd: neon }
- { os: ubuntu-24.04-arm, arch: armv7, simd: none }
# Windows ARM builds are cross-compiled on x64 runners
- { os: windows-2022, arch: arm64, simd: neon }
- { os: windows-2022, arch: arm, simd: neon }
steps:
- uses: actions/checkout@v4
- name: Install Linux build tools
if: runner.os == 'Linux'
run: |
sudo apt-get update
sudo apt-get install -y ninja-build
if [ "${{ matrix.arch }}" = "armv7" ]; then
sudo apt-get install -y gcc-arm-linux-gnueabihf qemu-user
fi
- name: Configure CMake (Windows)
if: runner.os == 'Windows'
shell: pwsh
run: |
# ARM32 requires a Windows SDK older than 26100
$platform = "${{ matrix.arch == 'arm64' && 'ARM64' || 'ARM,version=10.0.22621.0' }}"
cmake -B build -G "Visual Studio 17 2022" -A $platform `
-DCMAKE_BUILD_TYPE=Release `
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
- name: Configure CMake (Unix)
if: runner.os == 'Linux'
shell: bash
run: |
if [ "${{ matrix.arch }}" = "armv7" ]; then
flags="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard"
if [ "${{ matrix.simd }}" = "neon" ]; then
flags="-march=armv7-a -mfpu=neon -mfloat-abi=hard"
fi
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
-DCMAKE_C_COMPILER=arm-linux-gnueabihf-gcc \
-DCMAKE_C_FLAGS="$flags" \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
else
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
fi
- name: Build
run: cmake --build build --config Release
- name: Test (Linux)
if: runner.os == 'Linux'
working-directory: build
run: |
if [ "${{ matrix.arch }}" = "armv7" ]; then
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
else
./tests
fi
+13 -1
View File
@@ -31,10 +31,22 @@ jobs:
wget --no-verbose https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${{matrix.wasi_sdk_version}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
tar xf wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
# Building a wasm library without needing to define a main():
# https://github.com/WebAssembly/wasi-sdk/issues/332
- name: Modify CMakeLists.txt for WASI
run: |
cat >> CMakeLists.txt <<'EOF'
if (CMAKE_SYSTEM_NAME STREQUAL "WASI")
target_link_options(${PROJECT_NAME} PRIVATE -mexec-model=reactor)
endif()
EOF
- name: Configure CMake
# Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
# See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}}" -DCMAKE_TOOLCHAIN_FILE=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0/share/cmake/wasi-sdk.cmake -DWASI_SDK_PREFIX=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0 -DCGLM_USE_TEST=ON
# Below suppress <<'clock' is deprecated: WASI lacks process-associated clocks; ...>> warns:
# -D_WASI_EMULATED_PROCESS_CLOCKS" -DCMAKE_EXE_LINKER_FLAGS="-lwasi-emulated-process-clocks
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}} -D_WASI_EMULATED_PROCESS_CLOCKS" -DCMAKE_EXE_LINKER_FLAGS="-lwasi-emulated-process-clocks" -DCMAKE_TOOLCHAIN_FILE=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0/share/cmake/wasi-sdk.cmake -DWASI_SDK_PREFIX=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0 -DCGLM_STATIC=ON -DCGLM_SHARED=OFF -DCGLM_USE_TEST=ON
- name: Build
# Build your program with the given configuration
+4 -4
View File
@@ -29,9 +29,9 @@ jobs:
run: |
cat << EOF > ${{github.workspace}}/meson_cross_emsdk.txt
[binaries]
c = '`which emcc`'
cpp = '`which em++`'
ar = '`which emar`'
c = '$(command -v emcc)'
cpp = '$(command -v em++)'
ar = '$(command -v emar)'
[built-in options]
@@ -50,7 +50,7 @@ jobs:
EOF
cat ${{github.workspace}}/meson_cross_emsdk.txt
- uses: actions/setup-python@v4
- uses: actions/setup-python@v5
- name: Install meson
run: |
+44 -2
View File
@@ -18,11 +18,13 @@ packages.config
/ar-lib
/autom4te.cache/
/compile
/config.cache
/config.guess
/config.log
/config.status
/config.sub
/configure
/configure~
/depcomp
/install-sh
/ltmain.sh
@@ -32,6 +34,18 @@ packages.config
.deps/
*.[oa]
*.l[oa]
*.so
*.so.*
*.dylib
*.dll
*.exe
*.pdb
*.ilk
*.exp
*.dSYM/
*.gcda
*.gcno
*.gcov
Makefile
Makefile.in
m4/*.m4
@@ -53,6 +67,7 @@ test/test_*
*.log
test/.libs/*
test/tests
/tests
cglm_arm/*
cglm_test_ios/*
cglm_test_iosTests/*
@@ -66,17 +81,44 @@ win/cglm_test_*
*.lib
*.tlog
win/x64
win/x85
win/x86
win/ARM/
win/ARM64/
win/ARM64EC/
win/Debug
cglm-test-ios*
/cglm.pc
test-driver
[email protected]
build/
/builddir/
build.ninja
.ninja_deps
.ninja_log
conftest.dir/*
confdefs.h
*.xcuserdatad
.idea
cmake-build-debug
cmake-build-*/
CMakeCache.txt
CMakeFiles/
cmake_install.cmake
CTestTestfile.cmake
/DartConfiguration.tcl
/Testing/
/CMakeUserPresets.json
/CPackConfig.cmake
/CPackSourceConfig.cmake
/_CPack_Packages/
/cglmConfig.cmake
/install_manifest*.txt
/cglm-*.tar.*
/cglm-*.zip
*.o.tmp
xcode/*
.vscode
.build
*.swp
.lastsession.vim
.vimrc
compile_commands.json
View File
Whitespace-only changes.
-20
View File
@@ -1,20 +0,0 @@
{
"configurations": [
{
"name": "Mac",
"includePath": [
"${workspaceFolder}/**"
],
"defines": [],
"macFrameworkPath": [
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
],
"compilerPath": "/usr/bin/clang",
"cStandard": "c23",
"cppStandard": "c++23",
"intelliSenseMode": "macos-clang-arm64",
"configurationProvider": "vector-of-bool.cmake-tools"
}
],
"version": 4
}
-31
View File
@@ -1,31 +0,0 @@
{
"C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools",
"restructuredtext.confPath": "${workspaceFolder}/docs/source",
"workbench.colorTheme": "Default Light+ Experimental",
"editor.fontSize": 14,
"workbench.colorCustomizations": {
"[Default Light*]": {
"editor.background": "#fefefe",
"sideBar.background": "#fefefe",
"sideBar.foreground": "#343436",
"sideBarTitle.foreground": "#343436",
"sideBar.border": "#e2e2e4",
"statusBar.background": "#fefefe",
"titleBar.activeBackground": "#fefefe",
"tab.activeBackground": "#f4fff4aa",
"tab.inactiveBackground": "#fefefe",
"activityBar.background": "#fefefe",
"editorGroupHeader.tabsBackground": "#fefefe"
},
"[Default Dark*]": {
"editor.background": "#1D1D25",
"sideBar.background": "#1D1D25",
"statusBar.background": "#1D1D25",
"titleBar.activeBackground": "#1D1D25",
"tab.activeBackground": "#2C2C3A",
"tab.inactiveBackground": "#1D1D25",
"activityBar.background": "#1D1D25",
"editorGroupHeader.tabsBackground": "#1D1D25"
}
},
}
+199
View File
@@ -0,0 +1,199 @@
# Building the library
cglm can be built using one of the following build systems:
## CMake (All platforms)
```bash
$ mkdir build
$ cd build
$ cmake .. # [Optional] -DCGLM_SHARED=ON
$ make
$ sudo make install # [Optional]
```
### Options with defaults
```CMake
option(CGLM_SHARED "Shared build" ON)
option(CGLM_STATIC "Static build" OFF)
option(CGLM_USE_C99 "" OFF) # C11
option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
```
### Including in a CMake project
#### Header only
This requires no building or installation of cglm.
* Example:
``` cmake
cmake_minimum_required(VERSION 3.8.2)
project(<Your Project Name>)
add_executable(${PROJECT_NAME} src/main.c)
target_link_libraries(${LIBRARY_NAME} PRIVATE
cglm_headers)
add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
```
#### Linked
* Example:
```cmake
cmake_minimum_required(VERSION 3.8.2)
project(<Your Project Name>)
add_executable(${PROJECT_NAME} src/main.c)
target_link_libraries(${LIBRARY_NAME} PRIVATE
cglm)
add_subdirectory(external/cglm/)
# or you can use find_package to configure cglm
```
### Using CMake to build for WebAssembly
Since math functions like `sinf` are used, this can not be targeted at `wasm32-unknown-unknown`, one of [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) or [emscripten](https://github.com/emscripten-core/emsdk) should be used.
Should note that shared build is not yet supported for WebAssembly.
For [simd128](https://github.com/WebAssembly/simd) support, add `-msimd128` to `CMAKE_C_FLAGS`, in command line `-DCMAKE_C_FLAGS="-msimd128"`.
For tests, the cmake option `CGLM_USE_TEST` would still work, you'll need a wasi runtime for running tests, see our [ci config file](.github/workflows/cmake-wasm.yml) for a detailed example.
#### WASI SDK
```bash
$ cmake .. \
-DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake \
-DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
```
Where `/path/to/wasi-sdk-19.0/` is the path to extracted [wasi sdk](https://github.com/WebAssembly/wasi-sdk).
In this case it would by default make a static build.
#### Emscripten
```bash
$ emcmake cmake .. \
-DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" \
-DCGLM_STATIC=ON
```
The `emcmake` here is the cmake wrapper for Emscripten from installed [emsdk](https://github.com/emscripten-core/emsdk).
## Meson (All platforms)
```bash
$ meson build # [Optional] --default-library=static
$ cd build
$ ninja
$ sudo ninja install # [Optional]
```
### Options with Defaults:
```meson
c_std=c11
buildtype=release
default_library=shared
build_tests=true # to run tests: ninja test
```
### Including in a Meson project
* Example:
```meson
# Clone cglm or create a cglm.wrap under <source_root>/subprojects
project('name', 'c')
cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
executable('exe', 'src/main.c', dependencies : cglm_dep)
```
## Swift (Swift Package Manager)
Currently only default build options are supported. Add **cglm** dependency to your project:
```swift
...
Package(
...
dependencies: [
...
.package(url: "https://github.com/recp/cglm", .branch("master")),
]
...
)
```
Now add **cgml** as a dependency to your target. Product choices are:
- **cglm** for inlined version of the library which can be linked only statically
- **cglmc** for a compiled version of the library with no linking limitation
```swift
...
.target(
...
dependencies: [
...
.product(name: "cglm", package: "cglm"),
]
...
)
...
```
## Unix (Autotools)
```bash
$ sh autogen.sh
$ ./configure
$ make
$ make check # [Optional]
$ [sudo] make install # [Optional]
```
This will also install pkg-config files so you can use
`pkg-config --cflags cglm` and `pkg-config --libs cglm` to retrieve compiler
and linker flags.
The files will be installed into the given prefix (usually `/usr/local` by
default on Linux), but your pkg-config may not be configured to actually check
there. You can figure out where it's looking by running `pkg-config --variable
pc_path pkg-config` and change the path the files are installed to via
`./configure --with-pkgconfigdir=/your/path`. Alternatively, you can add the
prefix path to your `PKG_CONFIG_PATH` environment variable.
## Windows (MSBuild)
Windows related build file and project files are located in `win` folder,
make sure you are inside `cglm/win` folder.
Code Analysis is enabled, so it may take awhile to build.
```Powershell
$ cd win
$ .\build.bat
```
if `msbuild` won't work (because of multi version VS) then try to build with `devenv`:
```Powershell
$ devenv cglm.sln /Build Release
```
### Running Tests on Windows
You can see test project in same visual studio solution file. It is enough to run that project to run tests.
# Building the documentation
First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html
then:
```bash
$ cd docs
$ sphinx-build source build
```
it will compile docs into build folder, you can run index.html inside that function.
+5 -3
View File
@@ -1,6 +1,6 @@
cmake_minimum_required(VERSION 3.8.2)
cmake_minimum_required(VERSION 3.13)
project(cglm
VERSION 0.9.4
VERSION 0.9.8
HOMEPAGE_URL https://github.com/recp/cglm
DESCRIPTION "OpenGL Mathematics (glm) for C"
LANGUAGES C
@@ -44,7 +44,7 @@ if(MSVC)
endforeach(flag_var)
endif()
else()
add_compile_options(-Wall)
add_compile_options(-Wall -Wextra -Wpedantic -Wconversion)
if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
add_compile_options(-O3)
@@ -93,8 +93,10 @@ add_library(${PROJECT_NAME}
src/mat4x2.c
src/mat4x3.c
src/plane.c
src/noise.c
src/frustum.c
src/box.c
src/aabb2d.c
src/project.c
src/sphere.c
src/ease.c
+10 -3
View File
@@ -23,7 +23,7 @@ checkCFLAGS = $(AM_CFLAGS) \
-std=gnu11 \
-O3 \
-DCGLM_DEFINE_PRINTS \
-I./include
-I$(srcdir)/include
check_PROGRAMS = test/tests
TESTS = $(check_PROGRAMS)
@@ -67,6 +67,7 @@ cglm_HEADERS = include/cglm/version.h \
include/cglm/util.h \
include/cglm/quat.h \
include/cglm/plane.h \
include/cglm/noise.h \
include/cglm/frustum.h \
include/cglm/box.h \
include/cglm/aabb2d.h \
@@ -78,7 +79,8 @@ cglm_HEADERS = include/cglm/version.h \
include/cglm/bezier.h \
include/cglm/applesimd.h \
include/cglm/ray.h \
include/cglm/affine2d.h
include/cglm/affine2d.h \
include/cglm/affine2d-post.h
cglm_clipspacedir=$(includedir)/cglm/clipspace
cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
@@ -120,6 +122,7 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
include/cglm/call/quat.h \
include/cglm/call/euler.h \
include/cglm/call/plane.h \
include/cglm/call/noise.h \
include/cglm/call/frustum.h \
include/cglm/call/box.h \
include/cglm/call/project.h \
@@ -129,7 +132,8 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
include/cglm/call/bezier.h \
include/cglm/call/ray.h \
include/cglm/call/affine.h \
include/cglm/call/affine2d.h
include/cglm/call/affine2d.h \
include/cglm/call/aabb2d.h
cglm_call_clipspacedir=$(includedir)/cglm/call/clipspace
cglm_call_clipspace_HEADERS = include/cglm/call/clipspace/persp_lh_no.h \
@@ -210,6 +214,7 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
include/cglm/struct/quat.h \
include/cglm/struct/euler.h \
include/cglm/struct/plane.h \
include/cglm/struct/noise.h \
include/cglm/struct/frustum.h \
include/cglm/struct/box.h \
include/cglm/struct/aabb2d.h \
@@ -261,6 +266,7 @@ libcglm_la_SOURCES=\
src/mat4x2.c \
src/mat4x3.c \
src/plane.c \
src/noise.c \
src/frustum.c \
src/box.c \
src/project.c \
@@ -270,6 +276,7 @@ libcglm_la_SOURCES=\
src/bezier.c \
src/ray.c \
src/affine2d.c \
src/aabb2d.c \
src/clipspace/ortho_lh_no.c \
src/clipspace/ortho_lh_zo.c \
src/clipspace/ortho_rh_no.c \
+98 -390
View File
@@ -39,73 +39,100 @@
<br>
<p align="center">
Highly optimized 2D|3D math library, also known as <b>OpenGL Mathematics (glm) for `C`</b>. <b>cglm</b> provides lot of utils to help math operations to be fast and quick to write. It is community friendly, feel free to bring any issues, bugs you faced.
A highly optimized 2D|3D math library. Also known as OpenGL Mathematics (glm) for C. <b>cglm</b> provides fast and ergonomic math functions to ease graphics programming. It is community friendly – feel free to report any bugs and issues you face. <br>
<i>If you're using C++, you might want to check out <a href="https://github.com/g-truc/glm">GLM</a></i>
</p>
- Allocation-free
- Header-only
- SIMD-optimized
- API-agnostic
---
#### 📚 Documentation
### 📚 Documentation
Almost all functions (inline versions) and parameters are documented inside the corresponding headers. <br />
Complete documentation: http://cglm.readthedocs.io
All functions and their parameters are documented above their declaration inside their corresponding headers. <br />
Alternatively, you can read the complete documentation [here](http://cglm.readthedocs.io).
#### 📌 Note for previous versions:
### 🔨 Building
- _dup (duplicate) is changed to _copy. For instance `glm_vec_dup -> glm_vec3_copy`
- OpenGL related functions are dropped to make this lib platform/third-party independent
- make sure you have latest version and feel free to report bugs, troubles
- **[bugfix]** euler angles was implemented in reverse order (extrinsic) it was fixed, now they are intrinsic. Make sure that
you have the latest version
- **[major change]** by starting v0.4.0, quaternions are stored as [x, y, z, w], it was [w, x, y, z] in v0.3.5 and earlier versions
- **[api rename]** by starting v0.4.5, **glm_simd** functions are renamed to **glmm_**
- **[new option]** by starting v0.4.5, you can disable alignment requirement, check options in docs.
- **[major change]** by starting v0.5.0, vec3 functions use **glm_vec3_** namespace, it was **glm_vec_** until v0.5.0
- **[major change]** by starting v0.5.1, built-in alignment is removed from **vec3** and **mat3** types
- **[major change]** by starting v0.7.3, inline print functions are disabled in release/production mode to eliminate print costs (see options in documentation). Print output also improved. You can disable colors if you need (see documentation)
- **[major change]** by starting v0.8.3, **cglm** supports alternative clipspace configurations e.g. Left Handed, Zero-to-One (_zo)... `CGLM_FORCE_DEPTH_ZERO_TO_ONE` and `CGLM_FORCE_LEFT_HANDED` is provided to control clipspace. You should be able to use **cglm** with Vulkan, DirectX and Metal now... see https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s
cglm can be used in it's entirety as a header-only library simply by including `cglm/cglm.h`. If you wish to link against it instead, it can be built using one of the supported build systems. Detailed information about building on individual platforms and build systems along with the instructions for building the documentation can be found in [BUILDING.md](./BUILDING.md).
#### 📌 Note for C++ developers:
If you are not aware of the original GLM library yet, you may also want to look at:
https://github.com/g-truc/glm
### ✅ Usage
#### 📌 Note for new comers (Important):
- `vec4` and `mat4` variables must be aligned. (There will be unaligned versions later)
- **in** and **[in, out]** parameters must be initialized (please). But **[out]** parameters not, initializing out param is also redundant
- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just include headers.
- if your debugger takes you to cglm headers then make sure you are not trying to copy vec4 to vec3 or alig issues...
- Welcome!
#### Header-only
#### 📌 Note for experienced developers:
- Since I'm testing this library in my projects, sometimes bugs occurs; finding that bug[s] and making improvements would be more easy with multiple developer/contributor and their projects or knowledge. Consider to make some tests if you suspect something is wrong and any feedbacks, contributions and bug reports are always welcome.
Include the `cglm/cglm.h` header and use functions with the `glm_` prefix.
```c
#include "cglm/cglm.h"
#### 📌 Allocations?
`cglm` doesn't alloc any memory on heap. So it doesn't provide any allocator. You should alloc memory for **out** parameters too if you pass pointer of memory location. Don't forget that **vec4** (also quat/**versor**) and **mat4** must be aligned (16-bytes), because *cglm* uses SIMD instructions to optimize most operations if available.
// ...
#### 📌 Returning vector or matrix... ?
vec2 vector;
glm_vec2_zero(vector);
```
**cglm** supports both *ARRAY API* and *STRUCT API*, so you can return structs if you utilize struct api (`glms_`).
#### Struct API
<hr/>
Include `cglm/struct.h` and use `glms_`.
```c
#include "cglm/struct.h"
<table>
<tbody>
<tr>
<td>
<div>Like some other graphics libraries (especially OpenGL) this library use Column-Major layout to keep matrices in the memory. </div>
<div>&nbsp;</div>
<div>In the future the library may support an option to use row-major layout, CURRENTLY if you need to row-major layout you will need to transpose it. </div>
</td>
<td>
<img src="https://upload.wikimedia.org/wikipedia/commons/3/3f/Matrix_Columns.svg" width="300px" />
</td>
</tr>
</tbody>
</table>
// ...
## 🚀 Features
- **scalar** and **simd** (sse, avx, neon...) optimizations
- option to use different clipspaces e.g. Left Handed, Zero-to-One... (currently right handed negative-one is default)
- array api and struct api, you can use arrays or structs.
vec2s vector = glms_vec2_zero();
```
#### Linked
Include `cglm/call.h` and use `glmc_`.
```c
#include "cglm/call.h"
// ...
vec2 vector;
glmc_vec2_zero(vector);
```
### ❗ Alignment
While cglm by default aligns what's necessary, it is possible to disable this by defining `CGLM_ALL_UNALIGNED`. If you're targeting machines with any kind of SIMD support, make sure that all `vec4`, `mat4` and `mat2` arguments you pass to cglm functions are aligned to prevent unexpected crashes, alternatively use the unaligned versions if present.
### Struct API
The struct API works as follows (note the `s` suffix on types, `glms_` prefix on functions and `GLMS_` on constants):
```C
#include <cglm/struct.h>
mat4s mat = GLMS_MAT4_IDENTITY_INIT;
mat4s inv = glms_mat4_inv(mat);
```
Struct functions generally take parameters *by copy* and *return* the results rather than taking pointers and writing to out parameters. That means your variables can usually be `const`, if you're into that.
The types used are actually unions that allow access to the same data in multiple ways. One of these involves anonymous structures available since C11. MSVC supports them in earlier versions out of the box and GCC/Clang as well if you enable `-fms-extensions`.
To explicitly enable anonymous structures `#define CGLM_USE_ANONYMOUS_STRUCT 1`, or `0` to disable them.
For backwards compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` to disable them. If you don't specify explicitly, cglm will attempt a best guess based on your compiler and C version.
### 📌 Migration notes:
- `_dup` (duplicate) functions were renamed to `_copy`. For instance: `glm_vec_dup` -> `glm_vec3_copy`.
- OpenGL related functions were dropped to make cglm API independent.
- **[bugfix]** Euler angles had been previously implemented in reverse order (extrinsic). This was fixed to be intrinsic.
- **[major change]** Starting with **v0.4.0**, quaternions are stored as [x, y, z, w]. Previously it was [w, x, y, z].
- **[api rename]** Starting with **v0.4.5**, `glm_simd_` functions are renamed to `glmm_`.
- **[new option]** Starting with **v0.4.5**, alignment requirements can be disabled. Read more in the documentation.
- **[major change]** Starting with **v0.5.0**, vec3 functions occupy the **glm_vec3_** namespace. This used to be **glm_vec_** in earlier versions.
- **[major change]** Starting with **v0.5.1**, `vec3` and `mat3` types are not aligned by default.
- **[major change]** Starting with **v0.7.3**, inline print functions are disabled by default in release mode to eliminate printing costs (see the Options chapter of the docs). <br> Colored output can be disabled (see documentation).
- **[major change]** Starting with **v0.8.3**, alternate clipspace configurations are supported. The `CGLM_FORCE_DEPTH_ZERO_TO_ONE` and `CGLM_FORCE_LEFT_HANDED` flags are provided to control clip depth and handedness. This makes it easier to incorporate cglm into projects using graphics APIs such as Vulkan or Metal. See https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s
### 🚀 Features
- scalar and simd (sse, avx, neon...) optimizations
- general purpose matrix operations (mat4, mat3)
- chain matrix multiplication (square only)
- general purpose vector operations (cross, dot, rotate, proj, angle...)
@@ -117,49 +144,35 @@ https://github.com/g-truc/glm
- quaternions
- euler angles / yaw-pitch-roll to matrix
- extract euler angles
- inline or pre-compiled function call
- frustum (extract view frustum planes, corners...)
- bounding box (AABB in Frustum (culling), crop, merge...)
- bounding sphere
- project, unproject
- easing functions
- curves
- curve interpolation helpers (S*M*C, deCasteljau...)
- helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
- curve interpolation helpers (SMC, deCasteljau...)
- comversion helpers from cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
- ray intersection helpers
- and others...
---
<hr />
<table>
<tbody>
<tr>
<td>
<div>Like other graphics libraries (especially OpenGL), cglm uses column-major layout to keep matrices in memory. </div>
<div>&nbsp;</div>
<div>While we might support row-major matrices in the future, currently if you need your matrices to be in row-major layout you have to transpose them. </div>
</td>
<td>
<img src="https://upload.wikimedia.org/wikipedia/commons/3/3f/Matrix_Columns.svg" width="300px" />
</td>
</tr>
</tbody>
</table>
You have two options to call a function/operation: inline or library call (link)
Almost all functions are marked inline (always_inline) so compiler will probably inline.
To call pre-compiled versions, just use `glmc_` (c stands for 'call') instead of `glm_`.
---
```C
#include <cglm/cglm.h> /* for inline */
#include <cglm/call.h> /* for library call (this also includes cglm.h) */
mat4 rot, trans, rt;
/* ... */
glm_mul(trans, rot, rt); /* inline */
glmc_mul(trans, rot, rt); /* call from library */
```
Most of math functions are optimized manually with SSE2 if available, if not? Dont worry there are non-sse versions of all operations
You can pass matrices and vectors as array to functions rather than get address.
```C
mat4 m = {
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1
};
glm_translate(m, (vec3){1.0f, 0.0f, 0.0f});
```
Library contains general purpose mat4 mul and inverse functions, and also contains some special forms (optimized) of these functions for affine transformations' matrices. If you want to multiply two affine transformation matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv
cglm contains general purpose mat4 product and inverse functions but also provides optimized versions for affine transformations. If you want to multiply two affine transformation matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv.
```C
/* multiplication */
mat4 modelMat;
@@ -169,311 +182,9 @@ glm_mul(T, R, modelMat);
glm_inv_tr(modelMat);
```
### Struct API
The struct API works as follows, note the `s` suffix on types, the `glms_` prefix on functions and the `GLMS_` prefix on constants:
```C
#include <cglm/struct.h>
mat4s mat = GLMS_MAT4_IDENTITY_INIT;
mat4s inv = glms_mat4_inv(mat);
```
Struct functions generally take their parameters as *values* and *return* their results, rather than taking pointers and writing to out parameters. That means your parameters can usually be `const`, if you're into that.
The types used are actually unions that allow access to the same data multiple ways. One of those ways involves anonymous structures, available since C11. MSVC also supports it for earlier C versions out of the box and GCC/Clang do if you enable `-fms-extensions`. To explicitly enable these anonymous structures, `#define CGLM_USE_ANONYMOUS_STRUCT` to `1`, to disable them, to `0`. For backward compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` (value is irrelevant) to disable them. If you don't specify explicitly, cglm will do a best guess based on your compiler and the C version you're using.
## 🔨 Build
### CMake (All platforms)
```bash
$ mkdir build
$ cd build
$ cmake .. # [Optional] -DCGLM_SHARED=ON
$ make
$ sudo make install # [Optional]
```
##### Cmake options with Defaults:
```CMake
option(CGLM_SHARED "Shared build" ON)
option(CGLM_STATIC "Static build" OFF)
option(CGLM_USE_C99 "" OFF) # C11
option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
```
#### Use as header-only library with your CMake project
This requires no building or installation of cglm.
* Example:
``` cmake
cmake_minimum_required(VERSION 3.8.2)
project(<Your Project Name>)
add_executable(${PROJECT_NAME} src/main.c)
target_link_libraries(${LIBRARY_NAME} PRIVATE
cglm_headers)
add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
```
#### Use with your CMake project
* Example:
```cmake
cmake_minimum_required(VERSION 3.8.2)
project(<Your Project Name>)
add_executable(${PROJECT_NAME} src/main.c)
target_link_libraries(${LIBRARY_NAME} PRIVATE
cglm)
add_subdirectory(external/cglm/)
# or you can use find_package to configure cglm
```
#### Use CMake to build for WebAssembly
Since math functions like `sinf` is used, this can not be targeted at `wasm32-unknown-unknown`, one of [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) or [emscripten](https://github.com/emscripten-core/emsdk) should be used.
Should note that shared build is not yet supported for WebAssembly.
For [simd128](https://github.com/WebAssembly/simd) support, add `-msimd128` to `CMAKE_C_FLAGS`, in command line `-DCMAKE_C_FLAGS="-msimd128"`.
For tests, the cmake option `CGLM_USE_TEST` would still work, you'll need a wasi runtime for running tests, see our [ci config file](.github/workflows/cmake-wasm.yml) for a detailed example.
##### Use CMake and WASI SDK to build for WebAssembly
```bash
$ cmake .. \
-DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake \
-DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
```
Where `/path/to/wasi-sdk-19.0/` is the path to extracted [wasi sdk](https://github.com/WebAssembly/wasi-sdk).
In this case it would by default make a static build.
##### Use CMake and Emscripten SDK to build for WebAssembly
```bash
$ emcmake cmake .. \
-DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" \
-DCGLM_STATIC=ON
```
The `emcmake` here is the cmake wrapper for Emscripten from installed [emsdk](https://github.com/emscripten-core/emsdk).
### Meson (All platforms)
```bash
$ meson build # [Optional] --default-library=static
$ cd build
$ ninja
$ sudo ninja install # [Optional]
```
##### Meson options with Defaults:
```meson
c_std=c11
buildtype=release
default_library=shared
build_tests=true # to run tests: ninja test
```
#### Use with your Meson project
* Example:
```meson
# Clone cglm or create a cglm.wrap under <source_root>/subprojects
project('name', 'c')
cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
executable('exe', 'src/main.c', dependencies : cglm_dep)
```
### Swift (Swift Package Manager)
Currently only default build options are supported. Add **cglm** dependency to your project:
```swift
...
Package(
...
dependencies: [
...
.package(url: "https://github.com/recp/cglm", .branch("master")),
]
...
)
```
Now add **cgml** as a dependency to your target. Product choices are:
- **cglm** for inlined version of the library which can be linked only statically
- **cglmc** for a compiled version of the library with no linking limitation
```swift
...
.target(
...
dependencies: [
...
.product(name: "cglm", package: "cglm"),
]
...
)
...
```
### Unix (Autotools)
```bash
$ sh autogen.sh
$ ./configure
$ make
$ make check # [Optional]
$ [sudo] make install # [Optional]
```
This will also install pkg-config files so you can use
`pkg-config --cflags cglm` and `pkg-config --libs cglm` to retrieve compiler
and linker flags.
The files will be installed into the given prefix (usually `/usr/local` by
default on Linux), but your pkg-config may not be configured to actually check
there. You can figure out where it's looking by running `pkg-config --variable
pc_path pkg-config` and change the path the files are installed to via
`./configure --with-pkgconfigdir=/your/path`. Alternatively, you can add the
prefix path to your `PKG_CONFIG_PATH` environment variable.
### Windows (MSBuild)
Windows related build file and project files are located in `win` folder,
make sure you are inside `cglm/win` folder.
Code Analysis is enabled, so it may take awhile to build.
```Powershell
$ cd win
$ .\build.bat
```
if `msbuild` won't work (because of multi version VS) then try to build with `devenv`:
```Powershell
$ devenv cglm.sln /Build Release
```
#### Running Tests on Windows
You can see test project in same visual studio solution file. It is enough to run that project to run tests.
### Building Docs
First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html
then:
```bash
$ cd docs
$ sphinx-build source build
```
it will compile docs into build folder, you can run index.html inside that function.
## How to use
If you want to use the inline versions of functions, then include the main header
```C
#include <cglm/cglm.h>
```
the header will include all headers. Then call the func you want e.g. rotate vector by axis:
```C
glm_vec3_rotate(v1, glm_rad(45), (vec3){1.0f, 0.0f, 0.0f});
```
some functions are overloaded :) e.g you can normalize vector:
```C
glm_vec3_normalize(vec);
```
this will normalize vec and store normalized vector into `vec` but if you will store normalized vector into another vector do this:
```C
glm_vec3_normalize_to(vec, result);
```
like this function you may see `_to` postfix, this functions store results to another variables and save temp memory
to call pre-compiled versions include header with `c` postfix, c means call. Pre-compiled versions are just wrappers.
```C
#include <cglm/call.h>
```
this header will include all headers with c postfix. You need to call functions with c posfix:
```C
glmc_vec3_normalize(vec);
```
Function usage and parameters are documented inside related headers. You may see same parameter passed twice in some examples like this:
```C
glm_mat4_mul(m1, m2, m1);
/* or */
glm_mat4_mul(m1, m1, m1);
```
the first two parameter are **[in]** and the last one is **[out]** parameter. After multiplying *m1* and *m2*, the result is stored in *m1*. This is why we send *m1* twice. You may store the result in a different matrix, this is just an example.
### Example: Computing MVP matrix
#### Option 1
```C
mat4 proj, view, model, mvp;
/* init proj, view and model ... */
glm_mat4_mul(proj, view, viewProj);
glm_mat4_mul(viewProj, model, mvp);
```
#### Option 2
```C
mat4 proj, view, model, mvp;
/* init proj, view and model ... */
glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
```
## How to send matrix to OpenGL
mat4 is array of vec4 and vec4 is array of floats. `glUniformMatrix4fv` functions accecpts `float*` as `value` (last param), so you can cast mat4 to float* or you can pass first column of matrix as beginning of memory of matrix:
Option 1: Send first column
```C
glUniformMatrix4fv(location, 1, GL_FALSE, matrix[0]);
/* array of matrices */
glUniformMatrix4fv(location, 1, GL_FALSE, matrix[0][0]);
```
Option 2: Cast matrix to pointer type (also valid for multiple dimensional arrays)
```C
glUniformMatrix4fv(location, 1, GL_FALSE, (float *)matrix);
```
You can pass matrices the same way to other APIs e.g. Vulkan, DX...
## Notes
- This library does not support double type... yet
- If headers are not working properly with your compiler, IDE please open an issue, because I'm using GCC and clang to test it maybe sometimes MSVC
**TODO:**
- [ ] Unit tests (In Progress)
- [ ] Unit tests for comparing cglm with glm results
- [x] Add version info
- [ ] Unaligned operations (e.g. `glm_umat4_mul`)
- [x] Extra documentation
- [x] ARM Neon Arch
## Contributors
This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]
<a href="https://github.com/recp/cglm/graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
@@ -498,6 +209,3 @@ Support this project by becoming a sponsor. Your logo will show up here with a l
<a href="https://opencollective.com/cglm/sponsor/7/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/7/avatar.svg"></a>
<a href="https://opencollective.com/cglm/sponsor/8/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/8/avatar.svg"></a>
<a href="https://opencollective.com/cglm/sponsor/9/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/9/avatar.svg"></a>
## License
MIT. check the LICENSE file
+1 -1
View File
@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
# Description
s.name = "cglm"
s.version = "0.9.3"
s.version = "0.9.8"
s.summary = "📽 Highly Optimized Graphics Math (glm) for C"
s.description = <<-DESC
cglm is math library for graphics programming for C. See the documentation or README for all features.
+1 -1
View File
@@ -7,7 +7,7 @@
#*****************************************************************************
AC_PREREQ([2.69])
AC_INIT([cglm], [0.9.4], [[email protected]])
AC_INIT([cglm], [0.9.8], [[email protected]])
AM_INIT_AUTOMAKE([-Wall foreign subdir-objects serial-tests])
# Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
+2 -2
View File
@@ -82,7 +82,7 @@ Functions documentation
| crops a bounding box with another one.
this could be useful for gettng a bbox which fits with view frustum and
this could be useful for getting a bbox which fits with view frustum and
object bounding boxes. In this case you crop view frustum box with objects
box
@@ -95,7 +95,7 @@ Functions documentation
| crops a bounding box with another one.
this could be useful for gettng a bbox which fits with view frustum and
this could be useful for getting a bbox which fits with view frustum and
object bounding boxes. In this case you crop view frustum box with objects
box
+1 -1
View File
@@ -117,7 +117,7 @@ Functions documentation
If you need to rotate object around itself e.g. center of object or at
some point [of object] then `glm_rotate_at()` would be better choice to do so.
Even if object's model transform is identiy, rotation may not be around
Even if object's model transform is identity, rotation may not be around
center of object if object does not lay out at ORIGIN perfectly.
Using `glm_rotate_at()` with center of bounding shape ( AABB, Sphere ... )
+1
View File
@@ -66,6 +66,7 @@ Follow the :doc:`build` documentation for this
ivec4
color
plane
noise
project
util
io
+1 -1
View File
@@ -9,7 +9,7 @@ By default struct api adds `s` suffix to every type name e.g. vec3s, mat4s, vers
Also struct api `s` suffix to namespace e.g. `glms_vec3_add`, `glms_mat4_mul` etc.
By starting v0.9.0, struct api namespace is configurable. We can omit **glms_** namespace or
even change it with custom name to move existing api integrations to **cglm** more easliy...
even change it with custom name to move existing api integrations to **cglm** more easily...
We can also add **s** to function names if we want e.g. `glms_vec3_add()` -> `vec3_add()` or `vec3s_add()`.
By including **cglm/struct.h** header you will include all struct api. It will also include **cglm/cglm.h** too.
+2 -2
View File
@@ -62,7 +62,7 @@ Functions documentation
| crops a bounding box with another one.
this could be useful for gettng a bbox which fits with view frustum and
this could be useful for getting a bbox which fits with view frustum and
object bounding boxes. In this case you crop view frustum box with objects
box
@@ -75,7 +75,7 @@ Functions documentation
| crops a bounding box with another one.
this could be useful for gettng a bbox which fits with view frustum and
this could be useful for getting a bbox which fits with view frustum and
object bounding boxes. In this case you crop view frustum box with objects
box
+3 -2
View File
@@ -15,5 +15,6 @@ It would be duplicate documentation also it
would be hard to sync documentation between inline and call version for me.
By including **clgm/cglm.h** you include all inline versions. To get precompiled
versions you need to include **cglm/call.h** header it also includes all
call versions plus *clgm/cglm.h* (inline versions)
versions you need to include **cglm/call.h** header. When using the
precompiled versions, explicitly including **cglm/cglm.h** is still necessary
for the inline versions to be included.
+31
View File
@@ -36,8 +36,10 @@ Functions:
#. :c:func:`glm_ortho_default`
#. :c:func:`glm_ortho_default_s`
#. :c:func:`glm_perspective`
#. :c:func:`glm_perspective_infinite`
#. :c:func:`glm_persp_move_far`
#. :c:func:`glm_perspective_default`
#. :c:func:`glm_perspective_default_infinite`
#. :c:func:`glm_perspective_resize`
#. :c:func:`glm_lookat`
#. :c:func:`glm_look`
@@ -146,6 +148,21 @@ Functions documentation
| *[in]* **farVal** far clipping planes
| *[out]* **dest** result matrix
.. c:function:: void glm_perspective_infinite(float fovy, float aspect, float nearZ, mat4 dest)
| set up perspective projection matrix with infinite far plane
The far clipping plane is pushed to infinity. This can improve depth
precision for distant objects and is required by some rendering techniques
such as shadow volumes. Dispatches to the appropriate clipspace variant
based on compile-time configuration (LH/RH, NO/ZO).
Parameters:
| *[in]* **fovy** field of view angle (in radians)
| *[in]* **aspect** aspect ratio ( width / height )
| *[in]* **nearZ** near clipping plane
| *[out]* **dest** result matrix
.. c:function:: void glm_persp_move_far(mat4 proj, float deltaFar)
| extend perspective projection matrix's far distance
@@ -165,6 +182,20 @@ Functions documentation
| *[in]* **aspect** aspect aspect ratio ( width / height )
| *[out]* **dest** result matrix
.. c:function:: void glm_perspective_default_infinite(float aspect, mat4 dest)
| set up infinite perspective projection matrix with default near
and angle values
Equivalent to calling :c:func:`glm_perspective_infinite` with
``fovy = GLM_PI_4`` (45°) and ``nearZ = 0.01``. Useful as a
quick drop-in when you need an infinite projection without tuning
the individual parameters.
Parameters:
| *[in]* **aspect** aspect ratio ( width / height )
| *[out]* **dest** result matrix
.. c:function:: void glm_perspective_resize(float aspect, mat4 proj)
| resize perspective matrix by aspect ratio ( width / height )
+7 -3
View File
@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
# built documents.
#
# The short X.Y version.
version = u'0.9.4'
version = u'0.9.8'
# The full version, including alpha/beta/rc tags.
release = u'0.9.4'
release = u'0.9.8'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
@@ -91,6 +91,7 @@ todo_include_todos = False
# a list of builtin themes.
#
html_theme = 'sphinx_rtd_theme'
pygments_style = 'monokai'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
@@ -111,8 +112,11 @@ html_theme_options = {
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ['_static']
html_static_path = ['sphinx-static']
# Add customm CSS and JS files
html_css_files = ['theme_overrides.css']
html_js_files = []
# -- Options for HTMLHelp output ------------------------------------------
+835 -155
View File
File diff suppressed because it is too large. Load diff
+144 -29
View File
@@ -23,68 +23,183 @@ Functions:
#. :c:func:`glm_mat2x3_transpose`
#. :c:func:`glm_mat2x3_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat2x3
:header: "", "column 1", "column 2"
"row 1", "m00", "m10"
"row 2", "m01", "m11"
"row 3", "m02", "m12"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest)
.. c:function:: void glm_mat2x3_copy(mat2x3 src, mat2x3 dest)
copy mat2x3 to another one (dest).
Copy mat2x3 (src) to mat2x3 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat2x3 (left)
| *[out]* **dest** destination (result, mat2x3)
.. c:function:: void glm_mat2x3_zero(mat2x3 mat)
.. csv-table:: mat2x3 **(src)**
:header: "", "column 1", "column 2"
make given matrix zero
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
.. csv-table:: mat2x3 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "b00 = a00", "b10 = a10"
"row 2", "b01 = a01", "b11 = a11"
"row 3", "b02 = a02", "b12 = a12"
.. c:function:: void glm_mat2x3_zero(mat2x3 m)
Zero out the mat2x3 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat2x3 (src, dest)
.. csv-table:: mat2x3 **(m)**
:header: "", "column 1", "column 2"
"row 1", "0.00", "2.00"
"row 2", "5.00", "4.00"
"row 3", "7.00", "6.00"
.. csv-table:: mat2x3 **(m)**
:header: "", "column 1", "column 2"
"row 1", "0.00", "0.00"
"row 2", "0.00", "0.00"
"row 3", "0.00", "0.00"
.. c:function:: void glm_mat2x3_make(const float * __restrict src, mat2x3 dest)
Create mat2x3 matrix from pointer
Create mat2x3 (dest) from pointer (src).
.. note:: **@src** must contain at least 6 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix2x3
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat2x3)
.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest)
.. csv-table:: float array (1x6) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
.. csv-table:: mat2x3 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "v0", "v3"
"row 2", "v1", "v4"
"row 3", "v2", "v5"
.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest)
Multiply mat2x3 (m1) by mat3x2 (m2) and store in mat3 (dest).
.. code-block:: c
glm_mat2x3_mul(mat2x3, mat3x2, mat2);
glm_mat2x3_mul(mat2x3, mat3x2, mat3);
Parameters:
| *[in]* **m1** left matrix (mat2x3)
| *[in]* **m2** right matrix (mat3x2)
| *[out]* **dest** destination matrix (mat2)
| *[in]* **m1** mat2x3 (left)
| *[in]* **m2** mat3x2 (right)
| *[out]* **dest** destination (result, mat3)
.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest)
.. csv-table:: mat2x3 **(m1)**
:header: "", "column 1", "column 2"
multiply mat2x3 with vec3 (column vector) and store in dest vector
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
.. csv-table:: mat3x2 **(m2)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00", "b10", "b20"
"row 2", "b01", "b11", "b21"
.. csv-table:: mat3 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21"
"row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21"
"row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21"
.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest)
Multiply mat2x3 (m) by vec2 (v) and store in vec3 (dest).
Parameters:
| *[in]* **m** mat2x3 (left)
| *[in]* **v** vec3 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat2x3 (left)
| *[in]* **v** vec2 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest)
.. csv-table:: mat2x3 **(m)**
:header: "", "column 1", "column 2"
transpose matrix and store in dest
"row 1", "m00", "m10"
"row 2", "m01", "m11"
"row 3", "m02", "m12"
.. csv-table:: column vec2 (1x2) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
.. csv-table:: column vec3 (1x3) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1"
"row 2", "m01 * v0 + m11 * v1"
"row 3", "m02 * v0 + m12 * v1"
.. c:function:: void glm_mat2x3_transpose(mat2x3 src, mat3x2 dest)
Transpose mat2x3 (src) and store in mat3x2 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat2x3 (left)
| *[out]* **dest** destination (result, mat3x2)
.. c:function:: void glm_mat2x3_scale(mat2x3 m, float s)
.. csv-table:: mat2x3 **(src)**
:header: "", "column 1", "column 2"
multiply matrix with scalar
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
.. csv-table:: mat3x2 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00 = a00", "b10 = a01", "b20 = a02"
"row 2", "b01 = a10", "b11 = a11", "b21 = a12"
.. c:function:: void glm_mat2x3_scale(mat2x3 m, float s)
Multiply mat2x3 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat2x3 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat2x3 **(m)**
:header: "", "column 1", "column 2"
"row 1", "m00 = m00 * s", "m10 = m10 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s"
"row 3", "m02 = m02 * s", "m12 = m12 * s"
+157 -28
View File
@@ -23,68 +23,197 @@ Functions:
#. :c:func:`glm_mat2x4_transpose`
#. :c:func:`glm_mat2x4_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat2x4
:header: "", "column 1", "column 2"
"row 1", "m00", "m10"
"row 2", "m01", "m11"
"row 3", "m02", "m12"
"row 4", "m03", "m13"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest)
.. c:function:: void glm_mat2x4_copy(mat2x4 src, mat2x4 dest)
copy mat2x4 to another one (dest).
Copy mat2x4 (src) to mat2x4 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat2x4 (left)
| *[out]* **dest** destination (result, mat2x4)
.. c:function:: void glm_mat2x4_zero(mat2x4 mat)
.. csv-table:: mat2x4 **(src)**
:header: "", "column 1", "column 2"
make given matrix zero
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
"row 4", "a03", "a13"
.. csv-table:: mat2x4 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "b00 = a00", "b10 = a10"
"row 2", "b01 = a01", "b11 = a11"
"row 3", "b02 = a02", "b12 = a12"
"row 4", "b03 = a03", "b13 = a13"
.. c:function:: void glm_mat2x4_zero(mat2x4 m)
Zero out the mat2x4 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat2x4 (src, dest)
.. csv-table:: mat2x4 **(m)**
:header: "", "column 1", "column 2"
"row 1", "0.00", "2.00"
"row 2", "5.00", "4.00"
"row 3", "7.00", "6.00"
"row 4", "23.00", "1.00"
.. csv-table:: mat2x4 **(m)**
:header: "", "column 1", "column 2"
"row 1", "0.00", "0.00"
"row 2", "0.00", "0.00"
"row 3", "0.00", "0.00"
"row 4", "0.00", "0.00"
.. c:function:: void glm_mat2x4_make(const float * __restrict src, mat2x4 dest)
Create mat2x4 matrix from pointer
Create mat2x4 (dest) from pointer (src).
.. note:: **@src** must contain at least 8 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix2x4
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat2x4)
.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest)
.. csv-table:: float array (1x8) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
"row 7", "v6"
"row 8", "v7"
.. csv-table:: mat2x4 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "v0", "v4"
"row 2", "v1", "v5"
"row 3", "v2", "v6"
"row 4", "v3", "v7"
.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest)
Multiply mat2x4 (m1) by mat4x2 (m2) and store in mat4 (dest).
.. code-block:: c
glm_mat2x4_mul(mat2x4, mat4x2, mat2);
glm_mat2x4_mul(mat2x4, mat4x2, mat4);
Parameters:
| *[in]* **m1** left matrix (mat2x4)
| *[in]* **m2** right matrix (mat4x2)
| *[out]* **dest** destination matrix (mat2)
| *[in]* **m1** mat2x4 (left)
| *[in]* **m2** mat4x2 (right)
| *[out]* **dest** destination (result, mat4)
.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest)
.. csv-table:: mat2x4 **(m1)**
:header: "", "column 1", "column 2"
multiply mat2x4 with vec4 (column vector) and store in dest vector
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
"row 4", "a03", "a13"
.. csv-table:: mat4x2 **(m2)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00", "b10", "b20", "b30"
"row 2", "b01", "b11", "b21", "b31"
.. csv-table:: mat4x4 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21", "a00 * b30 + a10 * b31"
"row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21", "a01 * b30 + a11 * b31"
"row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21", "a02 * b30 + a12 * b31"
"row 4", "a03 * b00 + a13 * b01", "a03 * b10 + a13 * b11", "a03 * b20 + a13 * b21", "a03 * b30 + a13 * b31"
.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest)
Multiply mat2x4 (m) by vec2 (v) and store in vec4 (dest).
Parameters:
| *[in]* **m** mat2x4 (left)
| *[in]* **v** vec4 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat2x4 (left)
| *[in]* **v** vec2 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest)
.. csv-table:: mat2x4 **(m)**
:header: "", "column 1", "column 2"
transpose matrix and store in dest
"row 1", "m00", "m10"
"row 2", "m01", "m11"
"row 3", "m02", "m12"
"row 4", "m03", "m13"
.. csv-table:: column vec2 (1x2) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
.. csv-table:: column vec4 (1x4) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1"
"row 2", "m01 * v0 + m11 * v1"
"row 3", "m02 * v0 + m12 * v1"
"row 4", "m03 * v0 + m13 * v1"
.. c:function:: void glm_mat2x4_transpose(mat2x4 src, mat4x2 dest)
Transpose mat2x4 (src) and store in mat4x2 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat2x4 (left)
| *[out]* **dest** destination (result, mat4x2)
.. csv-table:: mat2x4 **(src)**
:header: "", "column 1", "column 2"
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
"row 4", "a03", "a13"
.. csv-table:: mat4x2 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00 = a00", "b10 = a01", "b20 = a02", "b30 = a03"
"row 2", "b01 = a10", "b11 = a11", "b21 = a12", "b31 = a13"
.. c:function:: void glm_mat2x4_scale(mat2x4 m, float s)
multiply matrix with scalar
Multiply mat2x4 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat2x4 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat2x4 **(m)**
:header: "", "column 1", "column 2"
"row 1", "m00 = m00 * s", "m10 = m10 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s"
"row 3", "m02 = m02 * s", "m12 = m12 * s"
"row 4", "m03 = m03 * s", "m13 = m13 * s"
+1069 -85
View File
File diff suppressed because it is too large. Load diff
+135 -29
View File
@@ -23,68 +23,174 @@ Functions:
#. :c:func:`glm_mat3x2_transpose`
#. :c:func:`glm_mat3x2_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat3x2
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest)
.. c:function:: void glm_mat3x2_copy(mat3x2 src, mat3x2 dest)
copy mat3x2 to another one (dest).
Copy mat3x2 (src) to mat3x2 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat3x2 (left)
| *[out]* **dest** destination (result, mat3x2)
.. c:function:: void glm_mat3x2_zero(mat3x2 mat)
.. csv-table:: mat3x2 **(src)**
:header: "", "column 1", "column 2", "column 3"
make given matrix zero
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
.. csv-table:: mat3x2 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00 = a00", "b10 = a10", "b20 = a20"
"row 2", "b01 = a01", "b11 = a11", "b21 = a21"
.. c:function:: void glm_mat3x2_zero(mat3x2 m)
Zero out the mat3x2 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat3x2 (src, dest)
.. csv-table:: mat3x2 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "0.00", "2.00", "15.00"
"row 2", "5.00", "4.00", "6.00"
.. csv-table:: mat3x2 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "0.00", "0.00", "0.00"
"row 2", "0.00", "0.00", "0.00"
.. c:function:: void glm_mat3x2_make(const float * __restrict src, mat3x2 dest)
Create mat3x2 matrix from pointer
Create mat3x2 (dest) from pointer (src).
.. note:: **@src** must contain at least 6 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix3x2
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat3x2)
.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest)
.. csv-table:: float array (1x6) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
.. csv-table:: mat3x2 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "v0", "v2", "v4"
"row 2", "v1", "v3", "v5"
.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest)
Multiply mat3x2 (m1) by mat2x3 (m2) and store in mat2 (dest).
.. code-block:: c
glm_mat3x2_mul(mat3x2, mat2x3, mat3);
glm_mat3x2_mul(mat3x2, mat2x3, mat2);
Parameters:
| *[in]* **m1** left matrix (mat3x2)
| *[in]* **m2** right matrix (mat2x3)
| *[out]* **dest** destination matrix (mat3)
| *[in]* **m1** mat3x2 (left)
| *[in]* **m2** mat2x3 (right)
| *[out]* **dest** destination (result, mat2)
.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest)
.. csv-table:: mat3x2 **(m1)**
:header: "", "column 1", "column 2", "column 3"
multiply mat3x2 with vec2 (column vector) and store in dest vector
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
.. csv-table:: mat2x3 **(m2)**
:header: "", "column 1", "column 2"
"row 1", "b00", "b10"
"row 2", "b01", "b11"
"row 3", "b02", "b12"
.. csv-table:: mat2x2 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12"
"row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12"
.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest)
Multiply mat3x2 (m) by vec3 (v) and store in vec2 (dest).
Parameters:
| *[in]* **m** mat3x2 (left)
| *[in]* **v** vec3 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat3x2 (left)
| *[in]* **v** vec3 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest)
.. csv-table:: mat3x2 **(m)**
:header: "", "column 1", "column 2", "column 3"
transpose matrix and store in dest
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
.. csv-table:: column vec3 (1x3) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
.. csv-table:: column vec2 (1x2) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2"
"row 2", "m01 * v0 + m11 * v1 + m21 * v2"
.. c:function:: void glm_mat3x2_transpose(mat3x2 src, mat2x3 dest)
Transpose mat3x2 (src) and store in mat2x3 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat3x2 (left)
| *[out]* **dest** destination (result, mat2x3)
.. c:function:: void glm_mat3x2_scale(mat3x2 m, float s)
.. csv-table:: mat3x2 **(src)**
:header: "", "column 1", "column 2", "column 3"
multiply matrix with scalar
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
.. csv-table:: mat2x3 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "b00 = a00", "b10 = a01"
"row 2", "b01 = a10", "b11 = a11"
"row 3", "b02 = a20", "b12 = a21"
.. c:function:: void glm_mat3x2_scale(mat3x2 m, float s)
Multiply mat3x2 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat3x2 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat3x2 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s"
+165 -29
View File
@@ -23,68 +23,204 @@ Functions:
#. :c:func:`glm_mat3x4_transpose`
#. :c:func:`glm_mat3x4_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat3x4
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
"row 3", "m02", "m12", "m22"
"row 4", "m03", "m13", "m23"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest)
.. c:function:: void glm_mat3x4_copy(mat3x4 src, mat3x4 dest)
copy mat3x4 to another one (dest).
Copy mat3x4 (src) to mat3x4 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat3x4 (left)
| *[out]* **dest** destination (result, mat3x4)
.. c:function:: void glm_mat3x4_zero(mat3x4 mat)
.. csv-table:: mat3x4 **(src)**
:header: "", "column 1", "column 2", "column 3"
make given matrix zero
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
"row 3", "a02", "a12", "a22"
"row 4", "a03", "a13", "a23"
.. csv-table:: mat3x4 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00 = a00", "b10 = a10", "b20 = a20"
"row 2", "b01 = a01", "b11 = a11", "b21 = a21"
"row 3", "b02 = a02", "b12 = a12", "b22 = a22"
"row 4", "b03 = a03", "b13 = a13", "b23 = a23"
.. c:function:: void glm_mat3x4_zero(mat3x4 m)
Zero out the mat3x4 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat3x4 (src, dest)
.. csv-table:: mat3x4 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "0.00", "2.00", "78.00"
"row 2", "5.00", "4.00", "12.00"
"row 3", "7.00", "6.00", "32.00"
"row 4", "23.00", "1.00", "9.00"
.. csv-table:: mat3x4 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "0.00", "0.00", "0.00"
"row 2", "0.00", "0.00", "0.00"
"row 3", "0.00", "0.00", "0.00"
"row 4", "0.00", "0.00", "0.00"
.. c:function:: void glm_mat3x4_make(const float * __restrict src, mat3x4 dest)
Create mat3x4 matrix from pointer
Create mat3x4 (dest) from pointer (src).
.. note::: **@src** must contain at least 12 elements.
.. note:: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix3x4
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat3x4)
.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest)
.. csv-table:: float array (1x12) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
"row 7", "v6"
"row 8", "v7"
"row 9", "v8"
"row 10", "v9"
"row 11", "v10"
"row 12", "v11"
.. csv-table:: mat3x4 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "v0", "v4", "v8"
"row 2", "v1", "v5", "v9"
"row 3", "v2", "v6", "v10"
"row 4", "v3", "v7", "v11"
.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest)
Multiply mat3x4 (m1) by mat4x3 (m2) and store in mat4 (dest).
.. code-block:: c
glm_mat3x4_mul(mat3x4, mat4x3, mat3);
glm_mat3x4_mul(mat3x4, mat4x3, mat4);
Parameters:
| *[in]* **m1** left matrix (mat3x4)
| *[in]* **m2** right matrix (mat4x3)
| *[out]* **dest** destination matrix (mat3)
| *[in]* **m1** mat2x4 (left)
| *[in]* **m2** mat4x2 (right)
| *[out]* **dest** destination (result, mat4)
.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest)
.. csv-table:: mat3x4 **(m1)**
:header: "", "column 1", "column 2", "column 3"
multiply mat3x4 with vec4 (column vector) and store in dest vector
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
"row 3", "a02", "a12", "a22"
"row 4", "a03", "a13", "a23"
.. csv-table:: mat4x3 **(m2)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00", "b10", "b20", "b30"
"row 2", "b01", "b11", "b21", "b31"
"row 3", "b02", "b12", "b22", "b32"
.. csv-table:: mat4x4 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12", "a00 * b20 + a10 * b21 + a20 * b22", "a00 * b30 + a10 * b31 + a20 * b32"
"row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12", "a01 * b20 + a11 * b21 + a21 * b22", "a01 * b30 + a11 * b31 + a21 * b32"
"row 3", "a02 * b00 + a12 * b01 + a22 * b02", "a02 * b10 + a12 * b11 + a22 * b12", "a02 * b20 + a12 * b21 + a22 * b22", "a02 * b30 + a12 * b31 + a22 * b32"
"row 4", "a03 * b00 + a13 * b01 + a23 * b02", "a03 * b10 + a13 * b11 + a23 * b12", "a03 * b20 + a13 * b21 + a23 * b22", "a03 * b30 + a13 * b31 + a23 * b32"
.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest)
Multiply ma3x4 (m) by vec3 (v) and store in vec4 (dest).
Parameters:
| *[in]* **m** mat3x4 (left)
| *[in]* **v** vec4 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat3x4 (left)
| *[in]* **v** vec3 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest)
.. csv-table:: mat3x4 **(m)**
:header: "", "column 1", "column 2", "column 3"
transpose matrix and store in dest
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
"row 3", "m02", "m12", "m22"
"row 4", "m03", "m13", "m23"
.. csv-table:: column vec3 (1x3) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
.. csv-table:: column vec4 (1x4) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2"
"row 2", "m01 * v0 + m11 * v1 + m21 * v2"
"row 3", "m02 * v0 + m12 * v1 + m22 * v2"
"row 4", "m03 * v0 + m13 * v1 + m23 * v2"
.. c:function:: void glm_mat3x4_transpose(mat3x4 src, mat4x3 dest)
Transpose mat3x4 (src) and store in mat4x3 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat3x4 (left)
| *[out]* **dest** destination (result, mat4x3)
.. csv-table:: mat3x4 **(src)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
"row 3", "a02", "a12", "a22"
"row 4", "a03", "a13", "a23"
.. csv-table:: mat4x3 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00 = a00", "b10 = a01", "b20 = a02", "b30 = a03"
"row 2", "b01 = a10", "b11 = a11", "b21 = a12", "b31 = a13"
"row 3", "b02 = a20", "b12 = a21", "b22 = a22", "b32 = a23"
.. c:function:: void glm_mat3x4_scale(mat3x4 m, float s)
multiply matrix with scalar
Multiply mat3x4 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat3x4 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat3x4 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s"
"row 3", "m02 = m02 * s", "m12 = m12 * s", "m22 = m22 * s"
"row 4", "m03 = m03 * s", "m13 = m13 * s", "m23 = m23 * s"
+14 -1
View File
@@ -48,6 +48,7 @@ Functions:
#. :c:func:`glm_mat4_swap_row`
#. :c:func:`glm_mat4_rmc`
#. :c:func:`glm_mat4_make`
#. :c:func:`glm_mat4_textrans`
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
@@ -143,7 +144,7 @@ Functions documentation
.. code-block:: c
mat m1, m2, m3, m4, res;
mat4 m1, m2, m3, m4, res;
glm_mat4_mulN((mat4 *[]){&m1, &m2, &m3, &m4}, 4, res);
Parameters:
@@ -313,3 +314,15 @@ Functions documentation
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix4x4
.. c:function:: void glm_mat4_textrans(float sx, float sy, float rot, float tx, float ty, mat4 dest)
Create texture transformation matrix, rotation is in radians CCW/RH
Parameters:
| *[in]* **sx** scale x
| *[in]* **sy** scale y
| *[in]* **rot** rotation in radians CCW/RH
| *[in]* **tx** translation x
| *[in]* **ty** translation y
| *[out]* **dest** destination matrix3x3
+139 -28
View File
@@ -23,68 +23,179 @@ Functions:
#. :c:func:`glm_mat4x2_transpose`
#. :c:func:`glm_mat4x2_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat4x2
:header: "", "column 1", "column 2", "column 3", "column4"
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest)
.. c:function:: void glm_mat4x2_copy(mat4x2 src, mat4x2 dest)
copy mat4x2 to another one (dest).
Copy mat4x2 (src) to mat4x2 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat4x2 (left)
| *[out]* **dest** destination (result, mat4x2)
.. c:function:: void glm_mat4x2_zero(mat4x2 mat)
.. csv-table:: mat4x2 **(src)**
:header: "", "column 1", "column 2", "column 3", "column 4"
make given matrix zero
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
.. csv-table:: ma4x2 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00 = a00", "b10 = a10", "b20 = a20", "b30 = a30"
"row 2", "b01 = a01", "b11 = a11", "b21 = a21", "b31 = a31"
.. c:function:: void glm_mat4x2_zero(mat4x2 m)
Zero out the mat4x2 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat4x2 (src, dest)
.. csv-table:: mat4x2 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "0.00", "2.00", "15.00", "44.00"
"row 2", "5.00", "4.00", "6.00", "12.00"
.. csv-table:: mat4x2 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "0.00", "0.00", "0.00", "0.00"
"row 2", "0.00", "0.00", "0.00", "0.00"
.. c:function:: void glm_mat4x2_make(const float * __restrict src, mat4x2 dest)
Create mat4x2 matrix from pointer
Create mat4x2 (dest) from pointer (src).
.. note:: **@src** must contain at least 8 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix4x2
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat4x2)
.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest)
.. csv-table:: float array (1x8) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
"row 7", "v6"
"row 8", "v7"
.. csv-table:: mat4x2 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "v0", "v2", "v4", "v6"
"row 2", "v1", "v3", "v5", "v7"
.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest)
Multiply mat4x2 (m1) by mat2x4 (m2) and store in mat2 (dest).
.. code-block:: c
glm_mat4x2_mul(mat4x2, mat2x4, mat4);
glm_mat4x2_mul(mat4x2, mat2x4, mat2);
Parameters:
| *[in]* **m1** left matrix (mat4x2)
| *[in]* **m2** right matrix (mat2x4)
| *[out]* **dest** destination matrix (mat4)
| *[in]* **m1** mat4x2 (left)
| *[in]* **m2** mat2x4 (right)
| *[out]* **dest** destination (result, mat2)
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest)
.. csv-table:: mat4x2 **(m1)**
:header: "", "column 1", "column 2", "column 3", "column 4"
multiply mat4x2 with vec2 (column vector) and store in dest vector
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
.. csv-table:: mat2x4 **(m2)**
:header: "", "column 1", "column 2"
"row 1", "b00", "b10"
"row 2", "b01", "b11"
"row 3", "b02", "b12"
"row 4", "b03", "b13"
.. csv-table:: mat2x2 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13"
"row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13"
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest)
Multiply mat4x2 (m) by vec4 (v) and store in vec2 (dest).
Parameters:
| *[in]* **m** mat4x2 (left)
| *[in]* **v** vec2 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat4x2 (left)
| *[in]* **v** vec4 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest)
.. csv-table:: mat4x2 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
transpose matrix and store in dest
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
.. csv-table:: column vec4 (1x4) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
.. csv-table:: column vec2 (1x2) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3"
"row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3"
.. c:function:: void glm_mat4x2_transpose(mat4x2 src, mat2x4 dest)
Transpose mat4x2 (src) and store in mat2x4 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat4x2 (left)
| *[out]* **dest** destination (result, mat2x4)
.. csv-table:: mat4x2 **(src)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
.. csv-table:: mat2x4 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "b00 = a00", "b10 = a01"
"row 2", "b01 = a10", "b11 = a11"
"row 3", "b02 = a20", "b12 = a21"
"row 4", "b03 = a30", "b13 = a31"
.. c:function:: void glm_mat4x2_scale(mat4x2 m, float s)
multiply matrix with scalar
Multiply mat4x2 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat4x2 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat4x2 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s", "m30 = m30 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s", "m31 = m31 * s"
+156 -29
View File
@@ -23,68 +23,195 @@ Functions:
#. :c:func:`glm_mat4x3_transpose`
#. :c:func:`glm_mat4x3_scale`
Represented
~~~~~~~~~~~
.. csv-table:: mat4x3
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
"row 3", "m02", "m12", "m22", "m32"
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest)
.. c:function:: void glm_mat4x3_copy(mat4x3 src, mat4x3 dest)
copy mat4x3 to another one (dest).
Copy mat4x3 (src) to mat4x3 (dest).
Parameters:
| *[in]* **mat** source
| *[out]* **dest** destination
| *[in]* **src** mat4x3 (left)
| *[out]* **dest** destination (result, mat4x3)
.. c:function:: void glm_mat4x3_zero(mat4x3 mat)
.. csv-table:: mat4x3 **(src)**
:header: "", "column 1", "column 2", "column 3", "column 4"
make given matrix zero
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
"row 3", "a02", "a12", "a22", "a32"
.. csv-table:: mat4x3 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "b00 = a00", "b10 = a10", "b20 = a20", "b30 = a30"
"row 2", "b01 = a01", "b11 = a11", "b21 = a21", "b31 = a31"
"row 3", "b02 = a02", "b12 = a12", "b22 = a22", "b32 = a32"
.. c:function:: void glm_mat4x3_zero(mat4x3 m)
Zero out the mat4x3 (m).
Parameters:
| *[in,out]* **mat** matrix
| *[in, out]* **m** mat4x3 (src, dest)
.. csv-table:: mat4x3 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "0.00", "2.00", "15.00", "44.00"
"row 2", "5.00", "4.00", "6.00", "12.00"
"row 3", "88.00", "8.00", "4.30", "15.00"
.. csv-table:: mat4x3 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "0.00", "0.00", "0.00", "0.00"
"row 2", "0.00", "0.00", "0.00", "0.00"
"row3", "0.00", "0.00", "0.00", "0.00"
.. c:function:: void glm_mat4x3_make(const float * __restrict src, mat4x3 dest)
Create mat4x3 matrix from pointer
Create mat4x3 (dest) from pointer (src).
.. note:: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix4x3
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat4x3)
.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest)
.. csv-table:: float array (1x12) **(src)**
:header: "", "column 1"
multiply m1 and m2 to dest
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
"row 5", "v4"
"row 6", "v5"
"row 7", "v6"
"row 8", "v7"
"row 9", "v8"
"row 10", "v9"
"row 11", "v10"
"row 12", "v11"
.. csv-table:: mat4x3 **(dest)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "v0", "v3", "v6", "v9"
"row 2", "v1", "v4", "v7", "v10"
"row 3", "v2", "v5", "v8", "v11"
.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest)
Multiply mat4x3 (m1) by mat3x4 (m2) and store in mat3 (dest).
.. code-block:: c
glm_mat4x3_mul(mat4x3, mat3x4, mat4);
glm_mat4x3_mul(mat4x3, mat3x4, mat3);
Parameters:
| *[in]* **m1** left matrix (mat4x3)
| *[in]* **m2** right matrix (mat3x4)
| *[out]* **dest** destination matrix (mat4)
| *[in]* **m1** mat4x3 (left)
| *[in]* **m2** mat3x4 (right)
| *[out]* **dest** destination (result, mat3)
.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest)
.. csv-table:: mat4x3 **(m1)**
:header: "", "column 1", "column 2", "column 3", "column 4"
multiply mat4x3 with vec3 (column vector) and store in dest vector
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
"row 3", "a02", "a12", "a22", "a32"
.. csv-table:: mat3x4 **(m2)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00", "b10", "b20"
"row 2", "b01", "b11", "b21"
"row 3", "b02", "b12", "b22"
"row 4", "b03", "b13", "b23"
.. csv-table:: mat3x3 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13", "a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23"
"row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13", "a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23"
"row 3", "a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03", "a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13", "a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23"
.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest)
Multiply mat4x3 (m) by vec4 (v) and store in vec3 (dest).
Parameters:
| *[in]* **m** mat4x3 (left)
| *[in]* **v** vec3 (right, column vector)
| *[out]* **dest** destination (result, column vector)
| *[in]* **m** mat4x3 (left)
| *[in]* **v** vec4 (right, column vector)
| *[out]* **dest** destination (result, column vector)
.. c:function:: void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest)
.. csv-table:: mat4x3 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
transpose matrix and store in dest
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
"row 3", "m02", "m12", "m22", "m32"
.. csv-table:: column vec4 (1x4) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
"row 4", "v3"
.. csv-table:: column vec3 (1x3) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3"
"row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3"
"row 3", "m02 * v0 + m12 * v1 + m22 * v2 + m32 * v3"
.. c:function:: void glm_mat4x3_transpose(mat4x3 src, mat3x4 dest)
Transpose mat4x3 (src) and store in mat3x4 (dest).
Parameters:
| *[in]* **m** matrix
| *[out]* **dest** destination
| *[in]* **src** mat4x3 (left)
| *[out]* **dest** destination (result, mat3x4)
.. c:function:: void glm_mat4x3_scale(mat4x3 m, float s)
.. csv-table:: mat4x3 **(src)**
:header: "", "column 1", "column 2", "column 3", "column 4"
multiply matrix with scalar
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
"row 3", "a02", "a12", "a22", "a32"
.. csv-table:: mat3x4 **(dest)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "b00 = a00", "b10 = a01", "b20 = a02"
"row 2", "b01 = a10", "b11 = a11", "b21 = a12"
"row 3", "b02 = a20", "b12 = a21", "b22 = a22"
"row 4", "b03 = a30", "b13 = a31", "b23 = a32"
.. c:function:: void glm_mat4x3_scale(mat4x3 m, float s)
Multiply mat4x3 (m) by scalar constant (s).
Parameters:
| *[in, out]* **m** matrix
| *[in]* **s** scalar
| *[in, out]* **m** mat4x3 (src, dest)
| *[in]* **s** float (scalar)
.. csv-table:: mat4x3 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s", "m30 = m30 * s"
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s", "m31 = m31 * s"
"row 3", "m02 = m02 * s", "m12 = m12 * s", "m22 = m22 * s", "m32 = m32 * s"
+60
View File
@@ -0,0 +1,60 @@
.. default-domain:: C
perlin
================================================================================
Header: cglm/noise.h
Classic Perlin noise implementation.
Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise":
https://github.com/stegu/webgl-noise
Following Stefan Gustavson's paper "Simplex noise demystified":
http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
Implementation based on glm::perlin function:
https://github.com/g-truc/glm/blob/master/glm/gtc/noise.inl
Table of contents (click to go):
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Functions:
1. :c:func:`glm_perlin_vec4`
#. :c:func:`glm_perlin_vec3`
#. :c:func:`glm_perlin_vec2`
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
.. c:function:: float glm_perlin_vec4(vec4 point)
| Classic Perlin noise
Parameters:
| *[in]* **point** 4D point
Returns:
| noise value
.. c:function:: float glm_perlin_vec3(vec3 point)
| Classic Perlin noise
Parameters:
| *[in]* **point** 3D point
Returns:
| noise value
.. c:function:: float glm_perlin_vec2(vec2 point)
| Classic Perlin noise
Parameters:
| *[in]* **point** 2D point
Returns:
| noise value
+1 -1
View File
@@ -34,7 +34,7 @@ array of matrices:
/* ... */
glUniformMatrix4fv(location, count, GL_FALSE, matrix[0][0]);
1. Cast matrix to pointer
2. Cast matrix to pointer
--------------------------
.. code-block:: c
+1 -1
View File
@@ -76,7 +76,7 @@ SSE and SSE2 Shuffle Option
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**_mm_shuffle_ps** generates **shufps** instruction even if registers are same.
You can force it to generate **pshufd** instruction by defining
**CGLM_USE_INT_DOMAIN** macro. As default it is not defined.
**CGLM_NO_INT_DOMAIN** macro. As default it is not defined.
SSE3 and SSE4 Dot Product Options
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+15 -3
View File
@@ -11,9 +11,9 @@ Header: cglm/quat.h
What you can do with quaternions with existing functions is (Some of them):
- You can rotate transform matrix using quaterion
- You can rotate vector using quaterion
- You can create view matrix using quaterion
- You can rotate transform matrix using quaternion
- You can rotate vector using quaternion
- You can create view matrix using quaternion
- You can create a lookrotation (from source point to dest)
Table of contents (click to go):
@@ -55,6 +55,7 @@ Functions:
#. :c:func:`glm_quat_lerp`
#. :c:func:`glm_quat_nlerp`
#. :c:func:`glm_quat_slerp`
#. :c:func:`glm_quat_slerp_longest`
#. :c:func:`glm_quat_look`
#. :c:func:`glm_quat_for`
#. :c:func:`glm_quat_forp`
@@ -351,6 +352,17 @@ Functions documentation
| *[in]* **t** interpolant (amount) clamped between 0 and 1
| *[out]* **dest** result quaternion
.. c:function:: void glm_quat_slerp_longest(versor q, versor r, float t, versor dest)
| interpolates between two quaternions
| using spherical linear interpolation (SLERP) and always takes the longest path
Parameters:
| *[in]* **from** from
| *[in]* **to** to
| *[in]* **t** interpolant (amount) clamped between 0 and 1
| *[out]* **dest** result quaternion
.. c:function:: void glm_quat_look(vec3 eye, versor ori, mat4 dest)
| creates view matrix using quaternion as camera orientation
@@ -0,0 +1,12 @@
@media screen {
/* content column
*
* RTD theme's default is 800px as max width for the content, but we have
* tables with tons of columns, which need the full width of the view-port.
*
* Comment from yocto project theme_overrides.css
*/
.wy-nav-content{ max-width: none; }
}
+18
View File
@@ -27,6 +27,8 @@ Functions:
#. :c:func:`glm_vec2_isvalid`
#. :c:func:`glm_vec2_sign`
#. :c:func:`glm_vec2_abs`
#. :c:func:`glm_vec2_fract`
#. :c:func:`glm_vec2_floor`
#. :c:func:`glm_vec2_sqrt`
Functions documentation
@@ -134,6 +136,22 @@ Functions documentation
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec2_fract(vec2 v, vec2 dest)
get fractional part of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec2_floor(vec2 v, vec2 dest)
floor value of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec2_sqrt(vec2 v, vec2 dest)
square root of each vector item
+18
View File
@@ -28,6 +28,8 @@ Functions:
#. :c:func:`glm_vec3_isvalid`
#. :c:func:`glm_vec3_sign`
#. :c:func:`glm_vec3_abs`
#. :c:func:`glm_vec3_fract`
#. :c:func:`glm_vec3_floor`
#. :c:func:`glm_vec3_sqrt`
Functions documentation
@@ -151,6 +153,22 @@ Functions documentation
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec3_fract(vec3 v, vec3 dest)
fractional part of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec3_floor(vec3 v, vec3 dest)
floor of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector
.. c:function:: void glm_vec3_sqrt(vec3 v, vec3 dest)
square root of each vector item
+33
View File
@@ -23,6 +23,15 @@ Functions:
#. :c:func:`glm_vec4_eqv_eps`
#. :c:func:`glm_vec4_max`
#. :c:func:`glm_vec4_min`
#. :c:func:`glm_vec4_isnan`
#. :c:func:`glm_vec4_isinf`
#. :c:func:`glm_vec4_isvalid`
#. :c:func:`glm_vec4_sign`
#. :c:func:`glm_vec4_abs`
#. :c:func:`glm_vec4_fract`
#. :c:func:`glm_vec4_floor`
#. :c:func:`glm_vec4_sqrt`
Functions documentation
~~~~~~~~~~~~~~~~~~~~~~~
@@ -129,6 +138,30 @@ Functions documentation
| *[in]* **v** vector
| *[out]* **dest** sign vector (only keeps signs as -1, 0, -1)
.. c:function:: void glm_vec4_abs(vec4 v, vec4 dest)
absolute value of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector (abs(v))
.. c:function:: void glm_vec4_fract(vec4 v, vec4 dest)
fractional part of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector (fract(v))
.. c:function:: void glm_vec4_floor(vec4 v, vec4 dest)
floor of each vector item
Parameters:
| *[in]* **v** vector
| *[out]* **dest** destination vector (floor(v))
.. c:function:: void glm_vec4_sqrt(vec4 v, vec4 dest)
square root of each vector item
+20 -21
View File
@@ -35,7 +35,7 @@ glm_aabb2d_zero(vec2 aabb[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
glm_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]) {
glm_vec2_copy(aabb[0], dest[0]);
glm_vec2_copy(aabb[1], dest[1]);
}
@@ -49,7 +49,7 @@ glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
glm_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]) {
vec2 v[2], xa, xb, ya, yb;
glm_vec2_scale(m[0], aabb[0][0], xa);
@@ -84,7 +84,7 @@ glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
glm_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]) {
dest[0][0] = glm_min(aabb1[0][0], aabb2[0][0]);
dest[0][1] = glm_min(aabb1[0][1], aabb2[0][1]);
@@ -95,7 +95,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
/*!
* @brief crops a bounding aabb with another one.
*
* this could be useful for gettng a baabb which fits with view frustum and
* this could be useful for getting a baabb which fits with view frustum and
* object bounding aabbes. In this case you crop view frustum aabb with objects
* aabb
*
@@ -105,7 +105,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
glm_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]) {
dest[0][0] = glm_max(aabb[0][0], cropAabb[0][0]);
dest[0][1] = glm_max(aabb[0][1], cropAabb[0][1]);
@@ -116,7 +116,7 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
/*!
* @brief crops a bounding aabb with another one.
*
* this could be useful for gettng a baabb which fits with view frustum and
* this could be useful for getting a baabb which fits with view frustum and
* object bounding aabbes. In this case you crop view frustum aabb with objects
* aabb
*
@@ -127,9 +127,9 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_crop_until(vec2 aabb[2],
vec2 cropAabb[2],
vec2 clampAabb[2],
glm_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
CGLM_CONST vec2 cropAabb[2],
CGLM_CONST vec2 clampAabb[2],
vec2 dest[2]) {
glm_aabb2d_crop(aabb, cropAabb, dest);
glm_aabb2d_merge(clampAabb, dest, dest);
@@ -154,7 +154,7 @@ glm_aabb2d_invalidate(vec2 aabb[2]) {
*/
CGLM_INLINE
bool
glm_aabb2d_isvalid(vec2 aabb[2]) {
glm_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]) {
return glm_vec2_max(aabb[0]) != FLT_MAX
&& glm_vec2_min(aabb[1]) != -FLT_MAX;
}
@@ -166,7 +166,7 @@ glm_aabb2d_isvalid(vec2 aabb[2]) {
*/
CGLM_INLINE
float
glm_aabb2d_diag(vec2 aabb[2]) {
glm_aabb2d_diag(CGLM_CONST vec2 aabb[2]) {
return glm_vec2_distance(aabb[0], aabb[1]);
}
@@ -178,7 +178,7 @@ glm_aabb2d_diag(vec2 aabb[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
glm_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest) {
glm_vec2_sub(aabb[1], aabb[0], dest);
}
@@ -189,7 +189,7 @@ glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
*/
CGLM_INLINE
float
glm_aabb2d_radius(vec2 aabb[2]) {
glm_aabb2d_radius(CGLM_CONST vec2 aabb[2]) {
return glm_aabb2d_diag(aabb) * 0.5f;
}
@@ -201,7 +201,7 @@ glm_aabb2d_radius(vec2 aabb[2]) {
*/
CGLM_INLINE
void
glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
glm_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest) {
glm_vec2_center(aabb[0], aabb[1], dest);
}
@@ -213,7 +213,7 @@ glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
*/
CGLM_INLINE
bool
glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
glm_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
return (aabb[0][0] <= other[1][0] && aabb[1][0] >= other[0][0])
&& (aabb[0][1] <= other[1][1] && aabb[1][1] >= other[0][1]);
}
@@ -228,15 +228,15 @@ glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
*/
CGLM_INLINE
bool
glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
glm_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 c) {
float dmin;
int a, b;
a = (c[0] < aabb[0][0]) + (c[0] > aabb[1][0]);
b = (c[1] < aabb[0][1]) + (c[1] > aabb[1][1]);
dmin = glm_pow2((c[0] - aabb[!(a - 1)][0]) * (a != 0))
+ glm_pow2((c[1] - aabb[!(b - 1)][1]) * (b != 0));
dmin = glm_pow2((c[0] - aabb[c[0] > aabb[1][0]][0]) * (a != 0))
+ glm_pow2((c[1] - aabb[c[1] > aabb[1][1]][1]) * (b != 0));
return dmin <= glm_pow2(c[2]);
}
@@ -249,7 +249,7 @@ glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
*/
CGLM_INLINE
bool
glm_aabb2d_point(vec2 aabb[2], vec2 point) {
glm_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point) {
return (point[0] >= aabb[0][0] && point[0] <= aabb[1][0])
&& (point[1] >= aabb[0][1] && point[1] <= aabb[1][1]);
}
@@ -262,10 +262,9 @@ glm_aabb2d_point(vec2 aabb[2], vec2 point) {
*/
CGLM_INLINE
bool
glm_aabb2d_contains(vec2 aabb[2], vec2 other[2]) {
glm_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
return (aabb[0][0] <= other[0][0] && aabb[1][0] >= other[1][0])
&& (aabb[0][1] <= other[0][1] && aabb[1][1] >= other[1][1]);
}
#endif /* cglm_aabb2d_h */
+4 -4
View File
@@ -7,8 +7,8 @@
/*
Functions:
CGLM_INLINE void glm_mul(mat4 m1, mat4 m2, mat4 dest);
CGLM_INLINE void glm_mul_rot(mat4 m1, mat4 m2, mat4 dest);
CGLM_INLINE void glm_mul(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest);
CGLM_INLINE void glm_mul_rot(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest);
CGLM_INLINE void glm_inv_tr(mat4 mat);
*/
@@ -53,7 +53,7 @@
*/
CGLM_INLINE
void
glm_mul(mat4 m1, mat4 m2, mat4 dest) {
glm_mul(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest) {
#if defined(__wasm__) && defined(__wasm_simd128__)
glm_mul_wasm(m1, m2, dest);
#elif defined(__AVX__)
@@ -113,7 +113,7 @@ glm_mul(mat4 m1, mat4 m2, mat4 dest) {
*/
CGLM_INLINE
void
glm_mul_rot(mat4 m1, mat4 m2, mat4 dest) {
glm_mul_rot(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest) {
#if defined(__wasm__) && defined(__wasm_simd128__)
glm_mul_rot_wasm(m1, m2, dest);
#elif defined( __SSE__ ) || defined( __SSE2__ )
+16 -16
View File
@@ -10,17 +10,17 @@
/*
Functions:
CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translated(mat4 m, vec3 v);
CGLM_INLINE void glm_translated_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
CGLM_INLINE void glm_translated(mat4 m, const vec3 v);
CGLM_INLINE void glm_translated_x(mat4 m, float to);
CGLM_INLINE void glm_translated_y(mat4 m, float to);
CGLM_INLINE void glm_translated_z(mat4 m, float to);
CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotated_x(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_y(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated_z(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotated(mat4 m, float angle, const vec3 axis);
CGLM_INLINE void glm_rotated_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_INLINE void glm_spinned(mat4 m, float angle, const vec3 axis);
*/
#include "common.h"
@@ -41,7 +41,7 @@
*/
CGLM_INLINE
void
glm_translated(mat4 m, vec3 v) {
glm_translated(mat4 m, const vec3 v) {
glm_vec3_add(m[3], v, m[3]);
}
@@ -59,7 +59,7 @@ glm_translated(mat4 m, vec3 v) {
*/
CGLM_INLINE
void
glm_translated_to(mat4 m, vec3 v, mat4 dest) {
glm_translated_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
glm_mat4_copy(m, dest);
glm_translated(dest, v);
}
@@ -118,7 +118,7 @@ glm_translated_z(mat4 m, float z) {
*/
CGLM_INLINE
void
glm_rotated_x(mat4 m, float angle, mat4 dest) {
glm_rotated_x(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -145,7 +145,7 @@ glm_rotated_x(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotated_y(mat4 m, float angle, mat4 dest) {
glm_rotated_y(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -172,7 +172,7 @@ glm_rotated_y(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotated_z(mat4 m, float angle, mat4 dest) {
glm_rotated_z(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -198,7 +198,7 @@ glm_rotated_z(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotated(mat4 m, float angle, vec3 axis) {
glm_rotated(mat4 m, float angle, const vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_make(rot, angle, axis);
glm_mul_rot(rot, m, m);
@@ -217,7 +217,7 @@ glm_rotated(mat4 m, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
glm_rotated_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -238,7 +238,7 @@ glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_spinned(mat4 m, float angle, vec3 axis) {
glm_spinned(mat4 m, float angle, const vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_atm(rot, m[3], angle, axis);
glm_mat4_mul(rot, m, m);
+20 -20
View File
@@ -10,18 +10,18 @@
/*
Functions:
CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
CGLM_INLINE void glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
CGLM_INLINE void glm_translate(mat4 m, const vec3 v);
CGLM_INLINE void glm_translate_x(mat4 m, float to);
CGLM_INLINE void glm_translate_y(mat4 m, float to);
CGLM_INLINE void glm_translate_z(mat4 m, float to);
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate(mat4 m, float angle, const vec3 axis);
CGLM_INLINE void glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_INLINE void glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_INLINE void glm_spin(mat4 m, float angle, const vec3 axis);
*/
#include "common.h"
@@ -40,7 +40,7 @@
*/
CGLM_INLINE
void
glm_translate(mat4 m, vec3 v) {
glm_translate(mat4 m, const vec3 v) {
#if defined(CGLM_SIMD)
glmm_128 m0, m1, m2, m3;
@@ -72,7 +72,7 @@ glm_translate(mat4 m, vec3 v) {
*/
CGLM_INLINE
void
glm_translate_to(mat4 m, vec3 v, mat4 dest) {
glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
glm_mat4_copy(m, dest);
glm_translate(dest, v);
}
@@ -141,7 +141,7 @@ glm_translate_z(mat4 m, float z) {
*/
CGLM_INLINE
void
glm_rotate_x(mat4 m, float angle, mat4 dest) {
glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -166,7 +166,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate_y(mat4 m, float angle, mat4 dest) {
glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -191,7 +191,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate_z(mat4 m, float angle, mat4 dest) {
glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest) {
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
float c, s;
@@ -215,7 +215,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
* If you need to rotate object around itself e.g. center of object or at
* some point [of object] then `glm_rotate_at()` would be better choice to do so.
*
* Even if object's model transform is identiy, rotation may not be around
* Even if object's model transform is identity, rotation may not be around
* center of object if object does not lay out at ORIGIN perfectly.
*
* Using `glm_rotate_at()` with center of bounding shape ( AABB, Sphere ... )
@@ -233,7 +233,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
*/
CGLM_INLINE
void
glm_rotate(mat4 m, float angle, vec3 axis) {
glm_rotate(mat4 m, float angle, const vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_make(rot, angle, axis);
glm_mul_rot(m, rot, m);
@@ -250,7 +250,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -275,7 +275,7 @@ glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
CGLM_ALIGN(8) vec3 pivotInv;
glm_vec3_negate_to(pivot, pivotInv);
@@ -295,9 +295,9 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_spin(mat4 m, float angle, vec3 axis) {
glm_spin(mat4 m, float angle, const vec3 axis) {
CGLM_ALIGN_MAT mat4 rot;
glm_rotate_atm(rot, m[3], angle, axis);
glm_rotate_make(rot, angle, axis);
glm_mat4_mul(m, rot, m);
}
+18 -30
View File
@@ -7,28 +7,16 @@
/*
Functions:
CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
CGLM_INLINE void glm_translate_x(mat4 m, float to);
CGLM_INLINE void glm_translate_y(mat4 m, float to);
CGLM_INLINE void glm_translate_z(mat4 m, float to);
CGLM_INLINE void glm_translate_make(mat4 m, vec3 v);
CGLM_INLINE void glm_scale_to(mat4 m, vec3 v, mat4 dest);
CGLM_INLINE void glm_scale_make(mat4 m, vec3 v);
CGLM_INLINE void glm_scale(mat4 m, vec3 v);
CGLM_INLINE void glm_translate_make(mat4 m, const vec3 v);
CGLM_INLINE void glm_scale_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
CGLM_INLINE void glm_scale_make(mat4 m, const vec3 v);
CGLM_INLINE void glm_scale(mat4 m, const vec3 v);
CGLM_INLINE void glm_scale_uni(mat4 m, float s);
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
CGLM_INLINE void glm_rotate_make(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
CGLM_INLINE void glm_decompose_scalev(mat4 m, vec3 s);
CGLM_INLINE bool glm_uniscaled(mat4 m);
CGLM_INLINE void glm_decompose_rs(mat4 m, mat4 r, vec3 s);
CGLM_INLINE void glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
CGLM_INLINE void glm_rotate_make(mat4 m, float angle, const vec3 axis);
CGLM_INLINE void glm_decompose_scalev(CGLM_CONST mat4 m, vec3 s);
CGLM_INLINE bool glm_uniscaled(CGLM_CONST mat4 m);
CGLM_INLINE void glm_decompose_rs(CGLM_CONST mat4 m, mat4 r, vec3 s);
CGLM_INLINE void glm_decompose(CGLM_CONST mat4 m, vec4 t, mat4 r, vec3 s);
*/
#ifndef cglm_affine_h
@@ -49,7 +37,7 @@
*/
CGLM_INLINE
void
glm_translate_make(mat4 m, vec3 v) {
glm_translate_make(mat4 m, const vec3 v) {
glm_mat4_identity(m);
glm_vec3_copy(v, m[3]);
}
@@ -64,7 +52,7 @@ glm_translate_make(mat4 m, vec3 v) {
*/
CGLM_INLINE
void
glm_scale_to(mat4 m, vec3 v, mat4 dest) {
glm_scale_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
glm_vec4_scale(m[0], v[0], dest[0]);
glm_vec4_scale(m[1], v[1], dest[1]);
glm_vec4_scale(m[2], v[2], dest[2]);
@@ -80,7 +68,7 @@ glm_scale_to(mat4 m, vec3 v, mat4 dest) {
*/
CGLM_INLINE
void
glm_scale_make(mat4 m, vec3 v) {
glm_scale_make(mat4 m, const vec3 v) {
glm_mat4_identity(m);
m[0][0] = v[0];
m[1][1] = v[1];
@@ -96,7 +84,7 @@ glm_scale_make(mat4 m, vec3 v) {
*/
CGLM_INLINE
void
glm_scale(mat4 m, vec3 v) {
glm_scale(mat4 m, const vec3 v) {
glm_scale_to(m, v, m);
}
@@ -125,7 +113,7 @@ glm_scale_uni(mat4 m, float s) {
*/
CGLM_INLINE
void
glm_rotate_make(mat4 m, float angle, vec3 axis) {
glm_rotate_make(mat4 m, float angle, const vec3 axis) {
CGLM_ALIGN(8) vec3 axisn, v, vs;
float c;
@@ -155,7 +143,7 @@ glm_rotate_make(mat4 m, float angle, vec3 axis) {
*/
CGLM_INLINE
void
glm_decompose_scalev(mat4 m, vec3 s) {
glm_decompose_scalev(CGLM_CONST mat4 m, vec3 s) {
s[0] = glm_vec3_norm(m[0]);
s[1] = glm_vec3_norm(m[1]);
s[2] = glm_vec3_norm(m[2]);
@@ -171,7 +159,7 @@ glm_decompose_scalev(mat4 m, vec3 s) {
*/
CGLM_INLINE
bool
glm_uniscaled(mat4 m) {
glm_uniscaled(CGLM_CONST mat4 m) {
CGLM_ALIGN(8) vec3 s;
glm_decompose_scalev(m, s);
return glm_vec3_eq_all(s);
@@ -187,7 +175,7 @@ glm_uniscaled(mat4 m) {
*/
CGLM_INLINE
void
glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
glm_decompose_rs(CGLM_CONST mat4 m, mat4 r, vec3 s) {
CGLM_ALIGN(16) vec4 t = {0.0f, 0.0f, 0.0f, 1.0f};
CGLM_ALIGN(8) vec3 v;
@@ -227,7 +215,7 @@ glm_decompose_rs(mat4 m, mat4 r, vec3 s) {
*/
CGLM_INLINE
void
glm_decompose(mat4 m, vec4 t, mat4 r, vec3 s) {
glm_decompose(CGLM_CONST mat4 m, vec4 t, mat4 r, vec3 s) {
glm_vec4_copy(m[3], t);
glm_decompose_rs(m, r, s);
}
+132
View File
@@ -0,0 +1,132 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglm_affine2d_post_h
#define cglm_affine2d_post_h
/*
Functions:
CGLM_INLINE void glm_translated2d(mat3 m, const vec2 v);
CGLM_INLINE void glm_translated2d_x(mat3 m, float to);
CGLM_INLINE void glm_translated2d_y(mat3 m, float to);
CGLM_INLINE void glm_rotated2d(mat3 m, float angle);
CGLM_INLINE void glm_scaled2d(mat3 m, const vec2 v);
CGLM_INLINE void glm_scaled2d_uni(mat3 m, float s);
*/
#include "vec2.h"
/*!
* @brief translate existing transform matrix by v vector
* and store result in same matrix
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] v translate vector [x, y]
*/
CGLM_INLINE
void
glm_translated2d(mat3 m, const vec2 v) {
glm_vec2_add(m[2], v, m[2]);
}
/*!
* @brief translate existing transform matrix by x factor
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] x x factor
*/
CGLM_INLINE
void
glm_translated2d_x(mat3 m, float x) {
m[2][0] += x;
}
/*!
* @brief translate existing transform matrix by y factor
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] y y factor
*/
CGLM_INLINE
void
glm_translated2d_y(mat3 m, float y) {
m[2][1] += y;
}
/*!
* @brief rotate existing transform matrix by angle
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] angle angle (radians)
*/
CGLM_INLINE
void
glm_rotated2d(mat3 m, float angle) {
float c = cosf(angle),
s = sinf(angle),
m00 = m[0][0], m10 = m[1][0], m20 = m[2][0],
m01 = m[0][1], m11 = m[1][1], m21 = m[2][1];
m[0][0] = c * m00 - s * m01;
m[1][0] = c * m10 - s * m11;
m[2][0] = c * m20 - s * m21;
m[0][1] = s * m00 + c * m01;
m[1][1] = s * m10 + c * m11;
m[2][1] = s * m20 + c * m21;
}
/*!
* @brief scale existing 2d transform matrix by v vector
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] v scale vector [x, y]
*/
CGLM_INLINE
void
glm_scaled2d(mat3 m, const vec2 v) {
m[0][0] *= v[0];
m[1][0] *= v[0];
m[2][0] *= v[0];
m[0][1] *= v[1];
m[1][1] *= v[1];
m[2][1] *= v[1];
}
/*!
* @brief applies uniform scale to existing 2d transform matrix v = [s, s]
*
* this is POST transform, applies to existing transform as last transform
*
* @param[in, out] m affine transform
* @param[in] s scale factor
*/
CGLM_INLINE
void
glm_scaled2d_uni(mat3 m, float s) {
m[0][0] *= s;
m[1][0] *= s;
m[2][0] *= s;
m[0][1] *= s;
m[1][1] *= s;
m[2][1] *= s;
}
#endif /* cglm_affine2d_post_h */
+14 -14
View File
@@ -7,18 +7,18 @@
/*
Functions:
CGLM_INLINE void glm_translate2d(mat3 m, vec2 v)
CGLM_INLINE void glm_translate2d_to(mat3 m, vec2 v, mat3 dest)
CGLM_INLINE void glm_translate2d(mat3 m, const vec2 v)
CGLM_INLINE void glm_translate2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest)
CGLM_INLINE void glm_translate2d_x(mat3 m, float x)
CGLM_INLINE void glm_translate2d_y(mat3 m, float y)
CGLM_INLINE void glm_translate2d_make(mat3 m, vec2 v)
CGLM_INLINE void glm_scale2d_to(mat3 m, vec2 v, mat3 dest)
CGLM_INLINE void glm_scale2d_make(mat3 m, vec2 v)
CGLM_INLINE void glm_scale2d(mat3 m, vec2 v)
CGLM_INLINE void glm_translate2d_make(mat3 m, const vec2 v)
CGLM_INLINE void glm_scale2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest)
CGLM_INLINE void glm_scale2d_make(mat3 m, const vec2 v)
CGLM_INLINE void glm_scale2d(mat3 m, const vec2 v)
CGLM_INLINE void glm_scale2d_uni(mat3 m, float s)
CGLM_INLINE void glm_rotate2d_make(mat3 m, float angle)
CGLM_INLINE void glm_rotate2d(mat3 m, float angle)
CGLM_INLINE void glm_rotate2d_to(mat3 m, float angle, mat3 dest)
CGLM_INLINE void glm_rotate2d_to(CGLM_CONST mat3 m, float angle, mat3 dest)
*/
#ifndef cglm_affine2d_h
@@ -38,7 +38,7 @@
*/
CGLM_INLINE
void
glm_translate2d(mat3 m, vec2 v) {
glm_translate2d(mat3 m, const vec2 v) {
m[2][0] = m[0][0] * v[0] + m[1][0] * v[1] + m[2][0];
m[2][1] = m[0][1] * v[0] + m[1][1] * v[1] + m[2][1];
m[2][2] = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2];
@@ -56,7 +56,7 @@ glm_translate2d(mat3 m, vec2 v) {
*/
CGLM_INLINE
void
glm_translate2d_to(mat3 m, vec2 v, mat3 dest) {
glm_translate2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest) {
glm_mat3_copy(m, dest);
glm_translate2d(dest, v);
}
@@ -97,7 +97,7 @@ glm_translate2d_y(mat3 m, float y) {
*/
CGLM_INLINE
void
glm_translate2d_make(mat3 m, vec2 v) {
glm_translate2d_make(mat3 m, const vec2 v) {
glm_mat3_identity(m);
m[2][0] = v[0];
m[2][1] = v[1];
@@ -113,7 +113,7 @@ glm_translate2d_make(mat3 m, vec2 v) {
*/
CGLM_INLINE
void
glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
glm_scale2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest) {
dest[0][0] = m[0][0] * v[0];
dest[0][1] = m[0][1] * v[0];
dest[0][2] = m[0][2] * v[0];
@@ -135,7 +135,7 @@ glm_scale2d_to(mat3 m, vec2 v, mat3 dest) {
*/
CGLM_INLINE
void
glm_scale2d_make(mat3 m, vec2 v) {
glm_scale2d_make(mat3 m, const vec2 v) {
glm_mat3_identity(m);
m[0][0] = v[0];
m[1][1] = v[1];
@@ -150,7 +150,7 @@ glm_scale2d_make(mat3 m, vec2 v) {
*/
CGLM_INLINE
void
glm_scale2d(mat3 m, vec2 v) {
glm_scale2d(mat3 m, const vec2 v) {
m[0][0] = m[0][0] * v[0];
m[0][1] = m[0][1] * v[0];
m[0][2] = m[0][2] * v[0];
@@ -243,7 +243,7 @@ glm_rotate2d(mat3 m, float angle) {
*/
CGLM_INLINE
void
glm_rotate2d_to(mat3 m, float angle, mat3 dest) {
glm_rotate2d_to(CGLM_CONST mat3 m, float angle, mat3 dest) {
float m00 = m[0][0], m10 = m[1][0],
m01 = m[0][1], m11 = m[1][1],
m02 = m[0][2], m12 = m[1][2];
+51 -10
View File
@@ -14,16 +14,17 @@
&& defined(SIMD_VECTOR_TYPES)
#include "common.h"
#include "struct.h"
/*!
* @brief converts mat4 to Apple's simd type simd_float4x4
* @return simd_float4x4
*/
* @brief converts mat4 to Apple's simd type simd_float4x4
* @return simd_float4x4
*/
CGLM_INLINE
simd_float4x4
glm_mat4_applesimd(mat4 m) {
glm_mat4_applesimd(CGLM_CONST mat4 m) {
simd_float4x4 t;
t.columns[0][0] = m[0][0];
t.columns[0][1] = m[0][1];
t.columns[0][2] = m[0][2];
@@ -53,9 +54,9 @@ glm_mat4_applesimd(mat4 m) {
*/
CGLM_INLINE
simd_float3x3
glm_mat3_applesimd(mat3 m) {
glm_mat3_applesimd(CGLM_CONST mat3 m) {
simd_float3x3 t;
t.columns[0][0] = m[0][0];
t.columns[0][1] = m[0][1];
t.columns[0][2] = m[0][2];
@@ -77,19 +78,59 @@ glm_mat3_applesimd(mat3 m) {
*/
CGLM_INLINE
simd_float4
glm_vec4_applesimd(vec4 v) {
glm_vec4_applesimd(const vec4 v) {
return (simd_float4){v[0], v[1], v[2], v[3]};
}
/*!
* @brief converts vec3 to Apple's simd type simd_float3
* @return v
* @return simd_float3
*/
CGLM_INLINE
simd_float3
glm_vec3_applesimd(vec3 v) {
glm_vec3_applesimd(const vec3 v) {
return (simd_float3){v[0], v[1], v[2]};
}
/*!
* @brief generic function to convert cglm types to Apple's simd types
*
* Example usage:
* simd_float4x4 m = applesimd(mat4_value);
* simd_float3 v = applesimd(vec3_value);
*
* @param x cglm type (mat4, mat3, vec4, vec3)
* @return corresponding Apple simd type
*/
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
# define applesimd(x) _Generic((x), \
mat4: glm_mat4_applesimd, \
mat3: glm_mat3_applesimd, \
vec4: glm_vec4_applesimd, \
vec3: glm_vec3_applesimd \
)((x))
#endif
#ifdef cglm_types_struct_h
CGLM_INLINE simd_float4x4 glms_mat4_(applesimd)(mat4s m) { return glm_mat4_applesimd(m.raw); }
CGLM_INLINE simd_float3x3 glms_mat3_(applesimd)(mat3s m) { return glm_mat3_applesimd(m.raw); }
CGLM_INLINE simd_float4 glms_vec4_(applesimd)(vec4s v) { return glm_vec4_applesimd(v.raw); }
CGLM_INLINE simd_float3 glms_vec3_(applesimd)(vec3s v) { return glm_vec3_applesimd(v.raw); }
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
# undef applesimd
# define applesimd(x) _Generic((x), \
mat4: glm_mat4_applesimd, \
mat3: glm_mat3_applesimd, \
vec4: glm_vec4_applesimd, \
vec3: glm_vec3_applesimd, \
mat4s: glms_mat4_(applesimd), \
mat3s: glms_mat3_(applesimd), \
vec4s: glms_vec4_(applesimd), \
vec3s: glms_vec3_(applesimd) \
)((x))
#endif
#endif
#endif
#endif /* cglm_applesimd_h */
+22 -21
View File
@@ -22,7 +22,7 @@
*/
CGLM_INLINE
void
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
glm_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]) {
vec3 v[2], xa, xb, ya, yb, za, zb;
glm_vec3_scale(m[0], box[0][0], xa);
@@ -62,7 +62,7 @@ glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
glm_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_CONST vec3 box2[2], vec3 dest[2]) {
dest[0][0] = glm_min(box1[0][0], box2[0][0]);
dest[0][1] = glm_min(box1[0][1], box2[0][1]);
dest[0][2] = glm_min(box1[0][2], box2[0][2]);
@@ -75,7 +75,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
/*!
* @brief crops a bounding box with another one.
*
* this could be useful for gettng a bbox which fits with view frustum and
* this could be useful for getting a bbox which fits with view frustum and
* object bounding boxes. In this case you crop view frustum box with objects
* box
*
@@ -85,7 +85,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
glm_aabb_crop(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]) {
dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
@@ -98,7 +98,7 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
/*!
* @brief crops a bounding box with another one.
*
* this could be useful for gettng a bbox which fits with view frustum and
* this could be useful for getting a bbox which fits with view frustum and
* object bounding boxes. In this case you crop view frustum box with objects
* box
*
@@ -109,9 +109,9 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
*/
CGLM_INLINE
void
glm_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
glm_aabb_crop_until(CGLM_CONST vec3 box[2],
CGLM_CONST vec3 cropBox[2],
CGLM_CONST vec3 clampBox[2],
vec3 dest[2]) {
glm_aabb_crop(box, cropBox, dest);
glm_aabb_merge(clampBox, dest, dest);
@@ -133,8 +133,9 @@ glm_aabb_crop_until(vec3 box[2],
*/
CGLM_INLINE
bool
glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
float *p, dp;
glm_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]) {
const float *p;
float dp;
int i;
for (i = 0; i < 6; i++) {
@@ -169,7 +170,7 @@ glm_aabb_invalidate(vec3 box[2]) {
*/
CGLM_INLINE
bool
glm_aabb_isvalid(vec3 box[2]) {
glm_aabb_isvalid(CGLM_CONST vec3 box[2]) {
return glm_vec3_max(box[0]) != FLT_MAX
&& glm_vec3_min(box[1]) != -FLT_MAX;
}
@@ -181,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
*/
CGLM_INLINE
float
glm_aabb_size(vec3 box[2]) {
glm_aabb_size(CGLM_CONST vec3 box[2]) {
return glm_vec3_distance(box[0], box[1]);
}
@@ -192,7 +193,7 @@ glm_aabb_size(vec3 box[2]) {
*/
CGLM_INLINE
float
glm_aabb_radius(vec3 box[2]) {
glm_aabb_radius(CGLM_CONST vec3 box[2]) {
return glm_aabb_size(box) * 0.5f;
}
@@ -204,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
*/
CGLM_INLINE
void
glm_aabb_center(vec3 box[2], vec3 dest) {
glm_aabb_center(CGLM_CONST vec3 box[2], vec3 dest) {
glm_vec3_center(box[0], box[1], dest);
}
@@ -216,7 +217,7 @@ glm_aabb_center(vec3 box[2], vec3 dest) {
*/
CGLM_INLINE
bool
glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
glm_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
&& (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
&& (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
@@ -235,7 +236,7 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
*/
CGLM_INLINE
bool
glm_aabb_sphere(vec3 box[2], vec4 s) {
glm_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s) {
float dmin;
int a, b, c;
@@ -243,9 +244,9 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
dmin = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
+ glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
+ glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
dmin = glm_pow2((s[0] - box[s[0] > box[1][0]][0]) * (a != 0))
+ glm_pow2((s[1] - box[s[1] > box[1][1]][1]) * (b != 0))
+ glm_pow2((s[2] - box[s[2] > box[1][2]][2]) * (c != 0));
return dmin <= glm_pow2(s[3]);
}
@@ -258,7 +259,7 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
*/
CGLM_INLINE
bool
glm_aabb_point(vec3 box[2], vec3 point) {
glm_aabb_point(CGLM_CONST vec3 box[2], const vec3 point) {
return (point[0] >= box[0][0] && point[0] <= box[1][0])
&& (point[1] >= box[0][1] && point[1] <= box[1][1])
&& (point[2] >= box[0][2] && point[2] <= box[1][2]);
@@ -272,7 +273,7 @@ glm_aabb_point(vec3 box[2], vec3 point) {
*/
CGLM_INLINE
bool
glm_aabb_contains(vec3 box[2], vec3 other[2]) {
glm_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
&& (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
&& (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
+1 -1
View File
@@ -11,7 +11,6 @@
extern "C" {
#endif
#include "cglm.h"
#include "call/vec2.h"
#include "call/vec3.h"
#include "call/vec4.h"
@@ -32,6 +31,7 @@ extern "C" {
#include "call/quat.h"
#include "call/euler.h"
#include "call/plane.h"
#include "call/noise.h"
#include "call/frustum.h"
#include "call/aabb2d.h"
#include "call/box.h"
+17 -19
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
/* DEPRECATED! use _diag */
#define glmc_aabb2d_size(aabb) glmc_aabb2d_diag(aabb)
@@ -22,25 +22,25 @@ glmc_aabb2d_zero(vec2 aabb[2]);
CGLM_EXPORT
void
glmc_aabb2d_copy(vec2 aabb[2], vec2 dest[2]);
glmc_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]);
CGLM_EXPORT
void
glmc_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]);
glmc_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]);
CGLM_EXPORT
void
glmc_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]);
glmc_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]);
CGLM_EXPORT
void
glmc_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]);
glmc_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]);
CGLM_EXPORT
void
glmc_aabb2d_crop_until(vec2 aabb[2],
vec2 cropAabb[2],
vec2 clampAabb[2],
glmc_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
CGLM_CONST vec2 cropAabb[2],
CGLM_CONST vec2 clampAabb[2],
vec2 dest[2]);
CGLM_EXPORT
@@ -49,43 +49,41 @@ glmc_aabb2d_invalidate(vec2 aabb[2]);
CGLM_EXPORT
bool
glmc_aabb2d_isvalid(vec2 aabb[2]);
glmc_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]);
CGLM_EXPORT
float
glmc_aabb2d_diag(vec2 aabb[2]);
glmc_aabb2d_diag(CGLM_CONST vec2 aabb[2]);
CGLM_EXPORT
void
glmc_aabb2d_sizev(vec2 aabb[2], vec2 dest);
glmc_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest);
CGLM_EXPORT
float
glmc_aabb2d_radius(vec2 aabb[2]);
glmc_aabb2d_radius(CGLM_CONST vec2 aabb[2]);
CGLM_EXPORT
void
glmc_aabb2d_center(vec2 aabb[2], vec2 dest);
glmc_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest);
CGLM_EXPORT
bool
glmc_aabb2d_aabb(vec2 aabb[2], vec2 other[2]);
glmc_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
CGLM_EXPORT
bool
glmc_aabb2d_point(vec2 aabb[2], vec2 point);
glmc_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point);
CGLM_EXPORT
bool
glmc_aabb2d_contains(vec2 aabb[2], vec2 other[2]);
glmc_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
CGLM_EXPORT
bool
glmc_aabb2d_circle(vec2 aabb[2], vec3 s);
glmc_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 s);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_aabb2d_h */
+29 -29
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
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(CGLM_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(CGLM_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,61 +55,61 @@ glmc_scale_uni(mat4 m, float s);
CGLM_EXPORT
void
glmc_rotate_x(mat4 m, float rad, mat4 dest);
glmc_rotate_x(CGLM_CONST mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_y(mat4 m, float rad, mat4 dest);
glmc_rotate_y(CGLM_CONST mat4 m, float rad, mat4 dest);
CGLM_EXPORT
void
glmc_rotate_z(mat4 m, float rad, mat4 dest);
glmc_rotate_z(CGLM_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_spin(mat4 m, float angle, vec3 axis);
glmc_spin(mat4 m, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_decompose_scalev(mat4 m, vec3 s);
glmc_decompose_scalev(CGLM_CONST mat4 m, vec3 s);
CGLM_EXPORT
bool
glmc_uniscaled(mat4 m);
glmc_uniscaled(CGLM_CONST mat4 m);
CGLM_EXPORT
void
glmc_decompose_rs(mat4 m, mat4 r, vec3 s);
glmc_decompose_rs(CGLM_CONST mat4 m, mat4 r, vec3 s);
CGLM_EXPORT
void
glmc_decompose(mat4 m, vec4 t, mat4 r, vec3 s);
glmc_decompose(CGLM_CONST mat4 m, vec4 t, mat4 r, vec3 s);
/* affine-post */
CGLM_EXPORT
void
glmc_translated(mat4 m, vec3 v);
glmc_translated(mat4 m, const vec3 v);
CGLM_EXPORT
void
glmc_translated_to(mat4 m, vec3 v, mat4 dest);
glmc_translated_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
CGLM_EXPORT
void
@@ -125,37 +125,37 @@ glmc_translated_z(mat4 m, float z);
CGLM_EXPORT
void
glmc_rotated_x(mat4 m, float angle, mat4 dest);
glmc_rotated_x(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated_y(mat4 m, float angle, mat4 dest);
glmc_rotated_y(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated_z(mat4 m, float angle, mat4 dest);
glmc_rotated_z(CGLM_CONST mat4 m, float angle, mat4 dest);
CGLM_EXPORT
void
glmc_rotated(mat4 m, float angle, vec3 axis);
glmc_rotated(mat4 m, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
glmc_rotated_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
CGLM_EXPORT
void
glmc_spinned(mat4 m, float angle, vec3 axis);
glmc_spinned(mat4 m, float angle, const vec3 axis);
/* affine-mat */
CGLM_EXPORT
void
glmc_mul(mat4 m1, mat4 m2, mat4 dest);
glmc_mul(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mul_rot(mat4 m1, mat4 m2, mat4 dest);
glmc_mul_rot(CGLM_CONST mat4 m1, CGLM_CONST mat4 m2, mat4 dest);
CGLM_EXPORT
void
+8 -8
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_translate2d_make(mat3 m, vec2 v);
glmc_translate2d_make(mat3 m, const vec2 v);
CGLM_EXPORT
void
glmc_translate2d_to(mat3 m, vec2 v, mat3 dest);
glmc_translate2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest);
CGLM_EXPORT
void
glmc_translate2d(mat3 m, vec2 v);
glmc_translate2d(mat3 m, const vec2 v);
CGLM_EXPORT
void
@@ -35,15 +35,15 @@ glmc_translate2d_y(mat3 m, float to);
CGLM_EXPORT
void
glmc_scale2d_to(mat3 m, vec2 v, mat3 dest);
glmc_scale2d_to(CGLM_CONST mat3 m, const vec2 v, mat3 dest);
CGLM_EXPORT
void
glmc_scale2d_make(mat3 m, vec2 v);
glmc_scale2d_make(mat3 m, const vec2 v);
CGLM_EXPORT
void
glmc_scale2d(mat3 m, vec2 v);
glmc_scale2d(mat3 m, const vec2 v);
CGLM_EXPORT
void
@@ -59,7 +59,7 @@ glmc_rotate2d(mat3 m, float angle);
CGLM_EXPORT
void
glmc_rotate2d_to(mat3 m, float angle, mat3 dest);
glmc_rotate2d_to(CGLM_CONST mat3 m, float angle, mat3 dest);
#ifdef __cplusplus
}
+1 -1
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
float
+16 -17
View File
@@ -11,30 +11,30 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
glmc_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
glmc_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_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(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]);
CGLM_EXPORT
void
glmc_aabb_crop_until(vec3 box[2],
vec3 cropBox[2],
vec3 clampBox[2],
glmc_aabb_crop_until(CGLM_CONST vec3 box[2],
CGLM_CONST vec3 cropBox[2],
CGLM_CONST vec3 clampBox[2],
vec3 dest[2]);
CGLM_EXPORT
bool
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
glmc_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]);
CGLM_EXPORT
void
@@ -42,38 +42,37 @@ glmc_aabb_invalidate(vec3 box[2]);
CGLM_EXPORT
bool
glmc_aabb_isvalid(vec3 box[2]);
glmc_aabb_isvalid(CGLM_CONST vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_size(vec3 box[2]);
glmc_aabb_size(CGLM_CONST vec3 box[2]);
CGLM_EXPORT
float
glmc_aabb_radius(vec3 box[2]);
glmc_aabb_radius(CGLM_CONST vec3 box[2]);
CGLM_EXPORT
void
glmc_aabb_center(vec3 box[2], vec3 dest);
glmc_aabb_center(CGLM_CONST vec3 box[2], vec3 dest);
CGLM_EXPORT
bool
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
glmc_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_point(vec3 box[2], vec3 point);
glmc_aabb_point(CGLM_CONST vec3 box[2], const vec3 point);
CGLM_EXPORT
bool
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
glmc_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
CGLM_EXPORT
bool
glmc_aabb_sphere(vec3 box[2], vec4 s);
glmc_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_box_h */
+25 -17
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
@@ -29,15 +29,15 @@ glmc_ortho(float left, float right,
CGLM_EXPORT
void
glmc_ortho_aabb(vec3 box[2], mat4 dest);
glmc_ortho_aabb(CGLM_CONST vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p(CGLM_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(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
@@ -51,6 +51,10 @@ CGLM_EXPORT
void
glmc_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest);
CGLM_EXPORT
void
glmc_perspective_infinite(float fovy, float aspect, float nearZ, mat4 dest);
CGLM_EXPORT
void
glmc_persp_move_far(mat4 proj, float deltaFar);
@@ -59,25 +63,29 @@ CGLM_EXPORT
void
glmc_perspective_default(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_perspective_default_infinite(float aspect, mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize(float aspect, mat4 proj);
CGLM_EXPORT
void
glmc_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest);
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(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ,
float * __restrict top,
@@ -87,45 +95,45 @@ glmc_persp_decomp(mat4 proj,
CGLM_EXPORT
void
glmc_persp_decompv(mat4 proj, float dest[6]);
glmc_persp_decompv(CGLM_CONST mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x(mat4 proj,
glmc_persp_decomp_x(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y(mat4 proj,
glmc_persp_decomp_y(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z(mat4 proj,
glmc_persp_decomp_z(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far(mat4 proj, float * __restrict farZ);
glmc_persp_decomp_far(CGLM_CONST mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near(mat4 proj, float * __restrict nearZ);
glmc_persp_decomp_near(CGLM_CONST mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
float
glmc_persp_fovy(mat4 proj);
glmc_persp_fovy(CGLM_CONST mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect(mat4 proj);
glmc_persp_aspect(CGLM_CONST mat4 proj);
CGLM_EXPORT
void
glmc_persp_sizes(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes(CGLM_CONST mat4 proj, float fovy, vec4 dest);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -22,15 +22,15 @@ glmc_ortho_lh_no(float left, float right,
CGLM_EXPORT
void
glmc_ortho_aabb_lh_no(vec3 box[2], mat4 dest);
glmc_ortho_aabb_lh_no(CGLM_CONST vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p_lh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz_lh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
+4 -4
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -22,15 +22,15 @@ glmc_ortho_lh_zo(float left, float right,
CGLM_EXPORT
void
glmc_ortho_aabb_lh_zo(vec3 box[2], mat4 dest);
glmc_ortho_aabb_lh_zo(CGLM_CONST vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p_lh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz_lh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
+4 -4
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -22,15 +22,15 @@ glmc_ortho_rh_no(float left, float right,
CGLM_EXPORT
void
glmc_ortho_aabb_rh_no(vec3 box[2], mat4 dest);
glmc_ortho_aabb_rh_no(CGLM_CONST vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p_rh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz_rh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
+4 -4
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -22,15 +22,15 @@ glmc_ortho_rh_zo(float left, float right,
CGLM_EXPORT
void
glmc_ortho_aabb_rh_zo(vec3 box[2], mat4 dest);
glmc_ortho_aabb_rh_zo(CGLM_CONST vec3 box[2], mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_p_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
glmc_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest);
glmc_ortho_aabb_pz_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest);
CGLM_EXPORT
void
+15 -11
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -27,6 +27,10 @@ glmc_perspective_lh_no(float fovy,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize_lh_no(float aspect, mat4 proj);
CGLM_EXPORT
void
@@ -34,52 +38,52 @@ glmc_persp_move_far_lh_no(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_lh_no(mat4 proj,
glmc_persp_decomp_lh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_lh_no(mat4 proj, float dest[6]);
glmc_persp_decompv_lh_no(CGLM_CONST mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_lh_no(mat4 proj,
glmc_persp_decomp_x_lh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_lh_no(mat4 proj,
glmc_persp_decomp_y_lh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_lh_no(mat4 proj,
glmc_persp_decomp_z_lh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ);
glmc_persp_decomp_far_lh_no(CGLM_CONST mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ);
glmc_persp_decomp_near_lh_no(CGLM_CONST mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes_lh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_lh_no(mat4 proj);
glmc_persp_fovy_lh_no(CGLM_CONST mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_lh_no(mat4 proj);
glmc_persp_aspect_lh_no(CGLM_CONST mat4 proj);
#ifdef __cplusplus
}
+15 -11
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -27,6 +27,10 @@ glmc_perspective_lh_zo(float fovy,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize_lh_zo(float aspect, mat4 proj);
CGLM_EXPORT
void
@@ -34,52 +38,52 @@ glmc_persp_move_far_lh_zo(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_lh_zo(mat4 proj,
glmc_persp_decomp_lh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_lh_zo(mat4 proj, float dest[6]);
glmc_persp_decompv_lh_zo(CGLM_CONST mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_lh_zo(mat4 proj,
glmc_persp_decomp_x_lh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_lh_zo(mat4 proj,
glmc_persp_decomp_y_lh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_lh_zo(mat4 proj,
glmc_persp_decomp_z_lh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ);
glmc_persp_decomp_far_lh_zo(CGLM_CONST mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ);
glmc_persp_decomp_near_lh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes_lh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_lh_zo(mat4 proj);
glmc_persp_fovy_lh_zo(CGLM_CONST mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_lh_zo(mat4 proj);
glmc_persp_aspect_lh_zo(CGLM_CONST mat4 proj);
#ifdef __cplusplus
}
+15 -11
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -27,6 +27,10 @@ glmc_perspective_rh_no(float fovy,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize_rh_no(float aspect, mat4 proj);
CGLM_EXPORT
void
@@ -34,52 +38,52 @@ glmc_persp_move_far_rh_no(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_rh_no(mat4 proj,
glmc_persp_decomp_rh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_rh_no(mat4 proj, float dest[6]);
glmc_persp_decompv_rh_no(CGLM_CONST mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_rh_no(mat4 proj,
glmc_persp_decomp_x_rh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_rh_no(mat4 proj,
glmc_persp_decomp_y_rh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_rh_no(mat4 proj,
glmc_persp_decomp_z_rh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ);
glmc_persp_decomp_far_rh_no(CGLM_CONST mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ);
glmc_persp_decomp_near_rh_no(CGLM_CONST mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes_rh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_rh_no(mat4 proj);
glmc_persp_fovy_rh_no(CGLM_CONST mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_rh_no(mat4 proj);
glmc_persp_aspect_rh_no(CGLM_CONST mat4 proj);
#ifdef __cplusplus
}
+15 -11
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
@@ -27,6 +27,10 @@ glmc_perspective_rh_zo(float fovy,
float nearVal,
float farVal,
mat4 dest);
CGLM_EXPORT
void
glmc_perspective_resize_rh_zo(float aspect, mat4 proj);
CGLM_EXPORT
void
@@ -34,52 +38,52 @@ glmc_persp_move_far_rh_zo(mat4 proj, float deltaFar);
CGLM_EXPORT
void
glmc_persp_decomp_rh_zo(mat4 proj,
glmc_persp_decomp_rh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decompv_rh_zo(mat4 proj, float dest[6]);
glmc_persp_decompv_rh_zo(CGLM_CONST mat4 proj, float dest[6]);
CGLM_EXPORT
void
glmc_persp_decomp_x_rh_zo(mat4 proj,
glmc_persp_decomp_x_rh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right);
CGLM_EXPORT
void
glmc_persp_decomp_y_rh_zo(mat4 proj,
glmc_persp_decomp_y_rh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom);
CGLM_EXPORT
void
glmc_persp_decomp_z_rh_zo(mat4 proj,
glmc_persp_decomp_z_rh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ);
glmc_persp_decomp_far_rh_zo(CGLM_CONST mat4 proj, float * __restrict farZ);
CGLM_EXPORT
void
glmc_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ);
glmc_persp_decomp_near_rh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ);
CGLM_EXPORT
void
glmc_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest);
glmc_persp_sizes_rh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest);
CGLM_EXPORT
float
glmc_persp_fovy_rh_zo(mat4 proj);
glmc_persp_fovy_rh_zo(CGLM_CONST mat4 proj);
CGLM_EXPORT
float
glmc_persp_aspect_rh_zo(mat4 proj);
glmc_persp_aspect_rh_zo(CGLM_CONST mat4 proj);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
glmc_unprojecti_no(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest);
glmc_project_no(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z_no(vec3 pos, mat4 m);
glmc_project_z_no(const vec3 pos, CGLM_CONST mat4 m);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
glmc_unprojecti_zo(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest);
CGLM_EXPORT
void
glmc_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest);
glmc_project_zo(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z_zo(vec3 pos, mat4 m);
glmc_project_z_zo(const vec3 pos, CGLM_CONST mat4 m);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
glmc_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
glmc_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest);
glmc_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
glmc_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
glmc_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest);
glmc_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest);
glmc_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest);
glmc_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest);
glmc_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest);
#ifdef __cplusplus
}
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../../cglm.h"
#include "../../common.h"
CGLM_EXPORT
void
glmc_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest);
glmc_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest);
glmc_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest);
CGLM_EXPORT
void
glmc_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest);
glmc_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest);
#ifdef __cplusplus
}
+2 -2
View File
@@ -11,11 +11,11 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
float
glmc_smc(float s, mat4 m, vec4 c);
glmc_smc(float s, CGLM_CONST mat4 m, const vec4 c);
#ifdef __cplusplus
}
+1 -1
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
float
+16 -16
View File
@@ -11,67 +11,67 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_euler_angles(mat4 m, vec3 dest);
glmc_euler_angles(CGLM_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_seq axis, mat4 dest);
glmc_euler_by_order(const vec3 angles, glm_euler_seq axis, mat4 dest);
CGLM_EXPORT
void
glmc_euler_xyz_quat(vec3 angles, versor dest);
glmc_euler_xyz_quat(const vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_xzy_quat(vec3 angles, versor dest);
glmc_euler_xzy_quat(const vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_yxz_quat(vec3 angles, versor dest);
glmc_euler_yxz_quat(const vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_yzx_quat(vec3 angles, versor dest);
glmc_euler_yzx_quat(const vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_zxy_quat(vec3 angles, versor dest);
glmc_euler_zxy_quat(const vec3 angles, versor dest);
CGLM_EXPORT
void
glmc_euler_zyx_quat(vec3 angles, versor dest);
glmc_euler_zyx_quat(const vec3 angles, versor dest);
#ifdef __cplusplus
+6 -6
View File
@@ -11,27 +11,27 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_frustum_planes(mat4 m, vec4 dest[6]);
glmc_frustum_planes(CGLM_CONST mat4 m, vec4 dest[6]);
CGLM_EXPORT
void
glmc_frustum_corners(mat4 invMat, vec4 dest[8]);
glmc_frustum_corners(CGLM_CONST mat4 invMat, vec4 dest[8]);
CGLM_EXPORT
void
glmc_frustum_center(vec4 corners[8], vec4 dest);
glmc_frustum_center(CGLM_CONST vec4 corners[8], vec4 dest);
CGLM_EXPORT
void
glmc_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]);
glmc_frustum_box(CGLM_CONST vec4 corners[8], CGLM_CONST mat4 m, vec3 box[2]);
CGLM_EXPORT
void
glmc_frustum_corners_at(vec4 corners[8],
glmc_frustum_corners_at(CGLM_CONST vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]);
+7 -6
View File
@@ -12,31 +12,32 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
#include <stdio.h>
CGLM_EXPORT
void
glmc_mat4_print(mat4 matrix,
glmc_mat4_print(CGLM_CONST mat4 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_mat3_print(mat3 matrix,
glmc_mat3_print(CGLM_CONST mat3 matrix,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec4_print(vec4 vec,
glmc_vec4_print(const vec4 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_vec3_print(vec3 vec,
glmc_vec3_print(const vec3 vec,
FILE * __restrict ostream);
CGLM_EXPORT
void
glmc_versor_print(versor vec,
glmc_versor_print(const versor vec,
FILE * __restrict ostream);
#ifdef __cplusplus
+37 -37
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_ivec2(int * __restrict v, ivec2 dest);
glmc_ivec2(const int * __restrict v, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_copy(ivec2 a, ivec2 dest);
glmc_ivec2_copy(const ivec2 a, ivec2 dest);
CGLM_EXPORT
void
@@ -31,119 +31,119 @@ glmc_ivec2_one(ivec2 v);
CGLM_EXPORT
int
glmc_ivec2_dot(ivec2 a, ivec2 b);
glmc_ivec2_dot(const ivec2 a, const ivec2 b);
CGLM_EXPORT
int
glmc_ivec2_cross(ivec2 a, ivec2 b);
glmc_ivec2_cross(const ivec2 a, const ivec2 b);
CGLM_EXPORT
void
glmc_ivec2_add(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_add(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_adds(ivec2 v, int s, ivec2 dest);
glmc_ivec2_adds(const ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_sub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subs(ivec2 v, int s, ivec2 dest);
glmc_ivec2_subs(const ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_mul(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_scale(ivec2 v, int s, ivec2 dest);
glmc_ivec2_scale(const ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_div(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_div(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_divs(ivec2 v, int s, ivec2 dest);
glmc_ivec2_divs(const ivec2 v, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_mod(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_addadd(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_addadds(ivec2 a, int s, ivec2 dest);
glmc_ivec2_addadds(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_subadd(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subadds(ivec2 a, int s, ivec2 dest);
glmc_ivec2_subadds(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_muladd(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_muladds(ivec2 a, int s, ivec2 dest);
glmc_ivec2_muladds(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_maxadd(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_minadd(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_subsub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_subsubs(ivec2 a, int s, ivec2 dest);
glmc_ivec2_subsubs(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_addsub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_addsubs(ivec2 a, int s, ivec2 dest);
glmc_ivec2_addsubs(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_mulsub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_mulsubs(ivec2 a, int s, ivec2 dest);
glmc_ivec2_mulsubs(const ivec2 a, int s, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_maxsub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_minsub(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
int
glmc_ivec2_distance2(ivec2 a, ivec2 b);
glmc_ivec2_distance2(const ivec2 a, const ivec2 b);
CGLM_EXPORT
float
glmc_ivec2_distance(ivec2 a, ivec2 b);
glmc_ivec2_distance(const ivec2 a, const ivec2 b);
CGLM_EXPORT
void
@@ -151,19 +151,19 @@ glmc_ivec2_fill(ivec2 v, int val);
CGLM_EXPORT
bool
glmc_ivec2_eq(ivec2 v, int val);
glmc_ivec2_eq(const ivec2 v, int val);
CGLM_EXPORT
bool
glmc_ivec2_eqv(ivec2 a, ivec2 b);
glmc_ivec2_eqv(const ivec2 a, const ivec2 b);
CGLM_EXPORT
void
glmc_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_maxv(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
glmc_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest);
glmc_ivec2_minv(const ivec2 a, const ivec2 b, ivec2 dest);
CGLM_EXPORT
void
@@ -171,7 +171,7 @@ glmc_ivec2_clamp(ivec2 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec2_abs(ivec2 v, ivec2 dest);
glmc_ivec2_abs(const ivec2 v, ivec2 dest);
#ifdef __cplusplus
}
+38 -38
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_ivec3(ivec4 v4, ivec3 dest);
glmc_ivec3(const ivec4 v4, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_copy(ivec3 a, ivec3 dest);
glmc_ivec3_copy(const ivec3 a, ivec3 dest);
CGLM_EXPORT
void
@@ -31,123 +31,123 @@ glmc_ivec3_one(ivec3 v);
CGLM_EXPORT
int
glmc_ivec3_dot(ivec3 a, ivec3 b);
glmc_ivec3_dot(const ivec3 a, const ivec3 b);
CGLM_EXPORT
int
glmc_ivec3_norm2(ivec3 v);
glmc_ivec3_norm2(const ivec3 v);
CGLM_EXPORT
int
glmc_ivec3_norm(ivec3 v);
glmc_ivec3_norm(const ivec3 v);
CGLM_EXPORT
void
glmc_ivec3_add(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_add(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_adds(ivec3 v, int s, ivec3 dest);
glmc_ivec3_adds(const ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_sub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subs(ivec3 v, int s, ivec3 dest);
glmc_ivec3_subs(const ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_mul(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_scale(ivec3 v, int s, ivec3 dest);
glmc_ivec3_scale(const ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_div(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_div(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_divs(ivec3 v, int s, ivec3 dest);
glmc_ivec3_divs(const ivec3 v, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_mod(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_addadd(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_addadds(ivec3 a, int s, ivec3 dest);
glmc_ivec3_addadds(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_subadd(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subadds(ivec3 a, int s, ivec3 dest);
glmc_ivec3_subadds(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_muladd(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_muladds(ivec3 a, int s, ivec3 dest);
glmc_ivec3_muladds(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_maxadd(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_minadd(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_subsub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_subsubs(ivec3 a, int s, ivec3 dest);
glmc_ivec3_subsubs(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_addsub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_addsubs(ivec3 a, int s, ivec3 dest);
glmc_ivec3_addsubs(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_mulsub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_mulsubs(ivec3 a, int s, ivec3 dest);
glmc_ivec3_mulsubs(const ivec3 a, int s, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_maxsub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_minsub(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
int
glmc_ivec3_distance2(ivec3 a, ivec3 b);
glmc_ivec3_distance2(const ivec3 a, const ivec3 b);
CGLM_EXPORT
float
glmc_ivec3_distance(ivec3 a, ivec3 b);
glmc_ivec3_distance(const ivec3 a, const ivec3 b);
CGLM_EXPORT
void
@@ -155,19 +155,19 @@ glmc_ivec3_fill(ivec3 v, int val);
CGLM_EXPORT
bool
glmc_ivec3_eq(ivec3 v, int val);
glmc_ivec3_eq(const ivec3 v, int val);
CGLM_EXPORT
bool
glmc_ivec3_eqv(ivec3 a, ivec3 b);
glmc_ivec3_eqv(const ivec3 a, const ivec3 b);
CGLM_EXPORT
void
glmc_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_maxv(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
glmc_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest);
glmc_ivec3_minv(const ivec3 a, const ivec3 b, ivec3 dest);
CGLM_EXPORT
void
@@ -175,7 +175,7 @@ glmc_ivec3_clamp(ivec3 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec3_abs(ivec3 v, ivec3 dest);
glmc_ivec3_abs(const ivec3 v, ivec3 dest);
#ifdef __cplusplus
}
+30 -30
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_ivec4(ivec3 v3, int last, ivec4 dest);
glmc_ivec4(const ivec3 v3, int last, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_copy(ivec4 a, ivec4 dest);
glmc_ivec4_copy(const ivec4 a, ivec4 dest);
CGLM_EXPORT
void
@@ -31,107 +31,107 @@ glmc_ivec4_one(ivec4 v);
CGLM_EXPORT
void
glmc_ivec4_add(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_add(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_adds(ivec4 v, int s, ivec4 dest);
glmc_ivec4_adds(const ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_sub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subs(ivec4 v, int s, ivec4 dest);
glmc_ivec4_subs(const ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_mul(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_scale(ivec4 v, int s, ivec4 dest);
glmc_ivec4_scale(const ivec4 v, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_addadd(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_addadds(ivec4 a, int s, ivec4 dest);
glmc_ivec4_addadds(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_subadd(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subadds(ivec4 a, int s, ivec4 dest);
glmc_ivec4_subadds(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_muladd(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_muladds(ivec4 a, int s, ivec4 dest);
glmc_ivec4_muladds(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_maxadd(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_minadd(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_subsub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_subsubs(ivec4 a, int s, ivec4 dest);
glmc_ivec4_subsubs(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_addsub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_addsubs(ivec4 a, int s, ivec4 dest);
glmc_ivec4_addsubs(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_mulsub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_mulsubs(ivec4 a, int s, ivec4 dest);
glmc_ivec4_mulsubs(const ivec4 a, int s, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_maxsub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_minsub(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
int
glmc_ivec4_distance2(ivec4 a, ivec4 b);
glmc_ivec4_distance2(const ivec4 a, const ivec4 b);
CGLM_EXPORT
float
glmc_ivec4_distance(ivec4 a, ivec4 b);
glmc_ivec4_distance(const ivec4 a, const ivec4 b);
CGLM_EXPORT
void
glmc_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_maxv(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
glmc_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest);
glmc_ivec4_minv(const ivec4 a, const ivec4 b, ivec4 dest);
CGLM_EXPORT
void
@@ -139,7 +139,7 @@ glmc_ivec4_clamp(ivec4 v, int minVal, int maxVal);
CGLM_EXPORT
void
glmc_ivec4_abs(ivec4 v, ivec4 dest);
glmc_ivec4_abs(const ivec4 v, ivec4 dest);
#ifdef __cplusplus
}
+23 -23
View File
@@ -11,55 +11,51 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat2_copy(mat2 mat, mat2 dest);
glmc_mat2_make(const float * __restrict src, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_identity(mat2 mat);
glmc_mat2_copy(CGLM_CONST mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_identity_array(mat2 * __restrict mat, size_t count);
glmc_mat2_identity(mat2 m);
CGLM_EXPORT
void
glmc_mat2_zero(mat2 mat);
glmc_mat2_identity_array(mat2 * __restrict mats, size_t count);
CGLM_EXPORT
void
glmc_mat2_mul(mat2 m1, mat2 m2, mat2 dest);
glmc_mat2_zero(mat2 m);
CGLM_EXPORT
void
glmc_mat2_transpose_to(mat2 m, mat2 dest);
glmc_mat2_mul(CGLM_CONST mat2 m1, CGLM_CONST mat2 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_mulv(CGLM_CONST mat2 m, const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose_to(CGLM_CONST mat2 mat, mat2 dest);
CGLM_EXPORT
void
glmc_mat2_transpose(mat2 m);
CGLM_EXPORT
void
glmc_mat2_mulv(mat2 m, vec2 v, vec2 dest);
CGLM_EXPORT
float
glmc_mat2_trace(mat2 m);
CGLM_EXPORT
void
glmc_mat2_scale(mat2 m, float s);
CGLM_EXPORT
float
glmc_mat2_det(mat2 mat);
CGLM_EXPORT
void
glmc_mat2_inv(mat2 mat, mat2 dest);
glmc_mat2_inv(CGLM_CONST mat2 mat, mat2 dest);
CGLM_EXPORT
void
@@ -71,11 +67,15 @@ glmc_mat2_swap_row(mat2 mat, int row1, int row2);
CGLM_EXPORT
float
glmc_mat2_rmc(vec2 r, mat2 m, vec2 c);
glmc_mat2_trace(CGLM_CONST mat2 m);
CGLM_EXPORT
void
glmc_mat2_make(const float * __restrict src, mat2 dest);
float
glmc_mat2_det(CGLM_CONST mat2 m);
CGLM_EXPORT
float
glmc_mat2_rmc(const vec2 r, CGLM_CONST mat2 m, const vec2 c);
#ifdef __cplusplus
}
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat2x3_copy(mat2x3 mat, mat2x3 dest);
glmc_mat2x3_copy(CGLM_CONST mat2x3 src, mat2x3 dest);
CGLM_EXPORT
void
glmc_mat2x3_zero(mat2x3 mat);
glmc_mat2x3_zero(mat2x3 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat2x3_make(const float * __restrict src, mat2x3 dest);
CGLM_EXPORT
void
glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
glmc_mat2x3_mul(CGLM_CONST mat2x3 m1, CGLM_CONST mat3x2 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
glmc_mat2x3_mulv(CGLM_CONST mat2x3 m, const vec2 v, vec3 dest);
CGLM_EXPORT
void
glmc_mat2x3_transpose(mat2x3 m, mat3x2 dest);
glmc_mat2x3_transpose(CGLM_CONST mat2x3 src, mat3x2 dest);
CGLM_EXPORT
void
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat2x4_copy(mat2x4 mat, mat2x4 dest);
glmc_mat2x4_copy(CGLM_CONST mat2x4 src, mat2x4 dest);
CGLM_EXPORT
void
glmc_mat2x4_zero(mat2x4 mat);
glmc_mat2x4_zero(mat2x4 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat2x4_make(const float * __restrict src, mat2x4 dest);
CGLM_EXPORT
void
glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
glmc_mat2x4_mul(CGLM_CONST mat2x4 m1, CGLM_CONST mat4x2 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
glmc_mat2x4_mulv(CGLM_CONST mat2x4 m, const vec2 v, vec4 dest);
CGLM_EXPORT
void
glmc_mat2x4_transpose(mat2x4 m, mat4x2 dest);
glmc_mat2x4_transpose(CGLM_CONST mat2x4 src, mat4x2 dest);
CGLM_EXPORT
void
+14 -10
View File
@@ -11,14 +11,14 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_mat3_dup(mat, dest) glmc_mat3_copy(mat, dest)
CGLM_EXPORT
void
glmc_mat3_copy(mat3 mat, mat3 dest);
glmc_mat3_copy(CGLM_CONST mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -34,11 +34,11 @@ glmc_mat3_identity_array(mat3 * __restrict mat, size_t count);
CGLM_EXPORT
void
glmc_mat3_mul(mat3 m1, mat3 m2, mat3 dest);
glmc_mat3_mul(CGLM_CONST mat3 m1, CGLM_CONST mat3 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_transpose_to(mat3 m, mat3 dest);
glmc_mat3_transpose_to(CGLM_CONST mat3 m, mat3 dest);
CGLM_EXPORT
void
@@ -46,15 +46,15 @@ glmc_mat3_transpose(mat3 m);
CGLM_EXPORT
void
glmc_mat3_mulv(mat3 m, vec3 v, vec3 dest);
glmc_mat3_mulv(CGLM_CONST mat3 m, const vec3 v, vec3 dest);
CGLM_EXPORT
float
glmc_mat3_trace(mat3 m);
glmc_mat3_trace(CGLM_CONST mat3 m);
CGLM_EXPORT
void
glmc_mat3_quat(mat3 m, versor dest);
glmc_mat3_quat(CGLM_CONST mat3 m, versor dest);
CGLM_EXPORT
void
@@ -62,11 +62,11 @@ glmc_mat3_scale(mat3 m, float s);
CGLM_EXPORT
float
glmc_mat3_det(mat3 mat);
glmc_mat3_det(CGLM_CONST mat3 mat);
CGLM_EXPORT
void
glmc_mat3_inv(mat3 mat, mat3 dest);
glmc_mat3_inv(CGLM_CONST mat3 mat, mat3 dest);
CGLM_EXPORT
void
@@ -78,12 +78,16 @@ 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, CGLM_CONST mat3 m, const vec3 c);
CGLM_EXPORT
void
glmc_mat3_make(const float * __restrict src, mat3 dest);
CGLM_EXPORT
void
glmc_mat3_textrans(float sx, float sy, float rot, float tx, float ty, mat3 dest);
#ifdef __cplusplus
}
#endif
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat3x2_copy(mat3x2 mat, mat3x2 dest);
glmc_mat3x2_copy(CGLM_CONST mat3x2 src, mat3x2 dest);
CGLM_EXPORT
void
glmc_mat3x2_zero(mat3x2 mat);
glmc_mat3x2_zero(mat3x2 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat3x2_make(const float * __restrict src, mat3x2 dest);
CGLM_EXPORT
void
glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
glmc_mat3x2_mul(CGLM_CONST mat3x2 m1, CGLM_CONST mat2x3 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
glmc_mat3x2_mulv(CGLM_CONST mat3x2 m, const vec3 v, vec2 dest);
CGLM_EXPORT
void
glmc_mat3x2_transpose(mat3x2 m, mat2x3 dest);
glmc_mat3x2_transpose(CGLM_CONST mat3x2 src, mat2x3 dest);
CGLM_EXPORT
void
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat3x4_copy(mat3x4 mat, mat3x4 dest);
glmc_mat3x4_copy(CGLM_CONST mat3x4 src, mat3x4 dest);
CGLM_EXPORT
void
glmc_mat3x4_zero(mat3x4 mat);
glmc_mat3x4_zero(mat3x4 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat3x4_make(const float * __restrict src, mat3x4 dest);
CGLM_EXPORT
void
glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
glmc_mat3x4_mul(CGLM_CONST mat3x4 m1, CGLM_CONST mat4x3 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
glmc_mat3x4_mulv(CGLM_CONST mat3x4 m, const vec3 v, vec4 dest);
CGLM_EXPORT
void
glmc_mat3x4_transpose(mat3x4 m, mat4x3 dest);
glmc_mat3x4_transpose(CGLM_CONST mat3x4 src, mat4x3 dest);
CGLM_EXPORT
void
+22 -18
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_mat4_udup(mat, dest) glmc_mat4_ucopy(mat, dest)
@@ -19,11 +19,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_mat4_ucopy(mat4 mat, mat4 dest);
glmc_mat4_ucopy(CGLM_CONST mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_copy(mat4 mat, mat4 dest);
glmc_mat4_copy(CGLM_CONST mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -39,47 +39,47 @@ glmc_mat4_zero(mat4 mat);
CGLM_EXPORT
void
glmc_mat4_pick3(mat4 mat, mat3 dest);
glmc_mat4_pick3(CGLM_CONST mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_pick3t(mat4 mat, mat3 dest);
glmc_mat4_pick3t(CGLM_CONST mat4 mat, mat3 dest);
CGLM_EXPORT
void
glmc_mat4_ins3(mat3 mat, mat4 dest);
glmc_mat4_ins3(CGLM_CONST mat3 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_mul(mat4 m1, mat4 m2, mat4 dest);
glmc_mat4_mul(CGLM_CONST mat4 m1, CGLM_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(CGLM_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(CGLM_CONST mat4 m, const vec3 v, float last, vec3 dest);
CGLM_EXPORT
float
glmc_mat4_trace(mat4 m);
glmc_mat4_trace(CGLM_CONST mat4 m);
CGLM_EXPORT
float
glmc_mat4_trace3(mat4 m);
glmc_mat4_trace3(CGLM_CONST mat4 m);
CGLM_EXPORT
void
glmc_mat4_quat(mat4 m, versor dest);
glmc_mat4_quat(CGLM_CONST mat4 m, versor dest);
CGLM_EXPORT
void
glmc_mat4_transpose_to(mat4 m, mat4 dest);
glmc_mat4_transpose_to(CGLM_CONST mat4 m, mat4 dest);
CGLM_EXPORT
void
@@ -95,11 +95,11 @@ glmc_mat4_scale(mat4 m, float s);
CGLM_EXPORT
float
glmc_mat4_det(mat4 mat);
glmc_mat4_det(CGLM_CONST mat4 mat);
CGLM_EXPORT
void
glmc_mat4_inv(mat4 mat, mat4 dest);
glmc_mat4_inv(CGLM_CONST mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -107,7 +107,7 @@ glmc_mat4_inv_precise(mat4 mat, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_inv_fast(mat4 mat, mat4 dest);
glmc_mat4_inv_fast(CGLM_CONST mat4 mat, mat4 dest);
CGLM_EXPORT
void
@@ -119,12 +119,16 @@ 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, CGLM_CONST mat4 m, const vec4 c);
CGLM_EXPORT
void
glmc_mat4_make(const float * __restrict src, mat4 dest);
CGLM_EXPORT
void
glmc_mat4_textrans(float sx, float sy, float rot, float tx, float ty, mat4 dest);
#ifdef __cplusplus
}
#endif
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat4x2_copy(mat4x2 mat, mat4x2 dest);
glmc_mat4x2_copy(CGLM_CONST mat4x2 src, mat4x2 dest);
CGLM_EXPORT
void
glmc_mat4x2_zero(mat4x2 mat);
glmc_mat4x2_zero(mat4x2 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
glmc_mat4x2_mul(CGLM_CONST mat4x2 m1, CGLM_CONST mat2x4 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
glmc_mat4x2_mulv(CGLM_CONST mat4x2 m, const vec4 v, vec2 dest);
CGLM_EXPORT
void
glmc_mat4x2_transpose(mat4x2 m, mat2x4 dest);
glmc_mat4x2_transpose(CGLM_CONST mat4x2 src, mat2x4 dest);
CGLM_EXPORT
void
+6 -6
View File
@@ -11,15 +11,15 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_mat4x3_copy(mat4x3 mat, mat4x3 dest);
glmc_mat4x3_copy(CGLM_CONST mat4x3 src, mat4x3 dest);
CGLM_EXPORT
void
glmc_mat4x3_zero(mat4x3 mat);
glmc_mat4x3_zero(mat4x3 m);
CGLM_EXPORT
void
@@ -27,15 +27,15 @@ glmc_mat4x3_make(const float * __restrict src, mat4x3 dest);
CGLM_EXPORT
void
glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
glmc_mat4x3_mul(CGLM_CONST mat4x3 m1, CGLM_CONST mat3x4 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
glmc_mat4x3_mulv(CGLM_CONST mat4x3 m, const vec4 v, vec3 dest);
CGLM_EXPORT
void
glmc_mat4x3_transpose(mat4x3 m, mat3x4 dest);
glmc_mat4x3_transpose(CGLM_CONST mat4x3 src, mat3x4 dest);
CGLM_EXPORT
void
+31
View File
@@ -0,0 +1,31 @@
/*
* Copyright (c), Recep Aslantas.
*
* MIT License (MIT), http://opensource.org/licenses/MIT
* Full license can be found in the LICENSE file
*/
#ifndef cglmc_noise_h
#define cglmc_noise_h
#ifdef __cplusplus
extern "C" {
#endif
#include "../common.h"
CGLM_EXPORT
float
glmc_perlin_vec4(const vec4 point);
CGLM_EXPORT
float
glmc_perlin_vec3(const vec3 point);
CGLM_EXPORT
float
glmc_perlin_vec2(const vec2 point);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_noise_h */
+1 -1
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
+6 -8
View File
@@ -11,31 +11,29 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
glmc_unprojecti(const vec3 pos, CGLM_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, CGLM_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, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
CGLM_EXPORT
float
glmc_project_z(vec3 pos, mat4 m);
glmc_project_z(const vec3 pos, CGLM_CONST mat4 m);
CGLM_EXPORT
void
glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);
glmc_pickmatrix(const vec2 center, const vec2 size, const vec4 vp, mat4 dest);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_project_h */
+37 -33
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
@@ -31,23 +31,23 @@ 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
void
glmc_quat_from_vecs(vec3 a, vec3 b, versor dest);
glmc_quat_from_vecs(const vec3 a, const vec3 b, 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
@@ -55,111 +55,115 @@ 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, vec3 dest);
glmc_quat_axis(const versor q, vec3 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_lerpc(versor from, versor to, float t, versor dest);
glmc_quat_lerpc(const versor from, const versor to, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_nlerp(versor q, versor r, float t, versor dest);
glmc_quat_nlerp(const versor q, const versor r, 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_slerp_longest(const versor q, const versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_for(vec3 dir, vec3 up, versor dest);
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
CGLM_EXPORT
void
glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
glmc_quat_for(const vec3 dir, const vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
glmc_quat_forp(const vec3 from, const vec3 to, const vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
glmc_quat_rotate(CGLM_CONST mat4 m, const versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, 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, const versor q, const vec3 pivot);
CGLM_EXPORT
void
+11 -10
View File
@@ -10,28 +10,29 @@
#ifdef __cplusplus
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
bool
glmc_ray_triangle(vec3 origin,
vec3 direction,
vec3 v0,
vec3 v1,
vec3 v2,
glmc_ray_triangle(const vec3 origin,
const vec3 direction,
const vec3 v0,
const vec3 v1,
const vec3 v2,
float *d);
CGLM_EXPORT
bool
glmc_ray_sphere(vec3 origin,
vec3 dir,
vec4 s,
glmc_ray_sphere(const vec3 origin,
const vec3 dir,
const vec4 s,
float * __restrict t1,
float * __restrict t2);
CGLM_EXPORT
void
glmc_ray_at(vec3 orig, vec3 dir, float t, vec3 point);
glmc_ray_at(const vec3 orig, const vec3 dir, float t, vec3 point);
#ifdef __cplusplus
}
+6 -6
View File
@@ -11,27 +11,27 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
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, CGLM_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
}
+87 -43
View File
@@ -11,15 +11,27 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
glmc_vec2(float * __restrict v, vec2 dest);
glmc_vec2(const float * __restrict v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_copy(vec2 a, vec2 dest);
glmc_vec2_fill(vec2 v, float val);
CGLM_EXPORT
bool
glmc_vec2_eq(const vec2 v, float val);
CGLM_EXPORT
bool
glmc_vec2_eqv(const vec2 a, const vec2 b);
CGLM_EXPORT
void
glmc_vec2_copy(const vec2 a, vec2 dest);
CGLM_EXPORT
void
@@ -31,107 +43,107 @@ glmc_vec2_one(vec2 v);
CGLM_EXPORT
float
glmc_vec2_dot(vec2 a, vec2 b);
glmc_vec2_dot(const vec2 a, const vec2 b);
CGLM_EXPORT
float
glmc_vec2_cross(vec2 a, vec2 b);
glmc_vec2_cross(const vec2 a, const vec2 b);
CGLM_EXPORT
float
glmc_vec2_norm2(vec2 v);
glmc_vec2_norm2(const vec2 v);
CGLM_EXPORT
float
glmc_vec2_norm(vec2 v);
glmc_vec2_norm(const vec2 v);
CGLM_EXPORT
void
glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
glmc_vec2_add(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_adds(vec2 v, float s, vec2 dest);
glmc_vec2_adds(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_sub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subs(vec2 v, float s, vec2 dest);
glmc_vec2_subs(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
glmc_vec2_mul(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale(vec2 v, float s, vec2 dest);
glmc_vec2_scale(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
glmc_vec2_scale_as(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
glmc_vec2_div(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_divs(vec2 v, float s, vec2 dest);
glmc_vec2_divs(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
glmc_vec2_addadd(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
glmc_vec2_subadd(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
glmc_vec2_muladd(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_muladds(vec2 a, float s, vec2 dest);
glmc_vec2_muladds(const vec2 a, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
glmc_vec2_maxadd(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
glmc_vec2_minadd(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_subsub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_subsub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_addsub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_addsub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mulsub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_mulsub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mulsubs(vec2 a, float s, vec2 dest);
glmc_vec2_mulsubs(const vec2 a, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_maxsub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_maxsub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minsub(vec2 a, vec2 b, vec2 dest);
glmc_vec2_minsub(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_negate_to(vec2 v, vec2 dest);
glmc_vec2_negate_to(const vec2 v, vec2 dest);
CGLM_EXPORT
void
@@ -143,31 +155,31 @@ glmc_vec2_normalize(vec2 v);
CGLM_EXPORT
void
glmc_vec2_normalize_to(vec2 v, vec2 dest);
glmc_vec2_normalize_to(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
glmc_vec2_rotate(const vec2 v, float angle, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_center(vec2 a, vec2 b, vec2 dest);
glmc_vec2_center(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
float
glmc_vec2_distance2(vec2 a, vec2 b);
glmc_vec2_distance2(const vec2 a, const vec2 b);
CGLM_EXPORT
float
glmc_vec2_distance(vec2 a, vec2 b);
glmc_vec2_distance(const vec2 a, const vec2 b);
CGLM_EXPORT
void
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
glmc_vec2_maxv(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
glmc_vec2_minv(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
@@ -175,23 +187,51 @@ glmc_vec2_clamp(vec2 v, float minval, float maxval);
CGLM_EXPORT
void
glmc_vec2_abs(vec2 v, vec2 dest);
glmc_vec2_abs(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
glmc_vec2_fract(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
glmc_vec2_floor(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
glmc_vec2_mods(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
glmc_vec2_swizzle(const vec2 v, int mask, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_step(const vec2 edge, const vec2 x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_steps(float edge, const vec2 x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_stepr(const vec2 edge, float x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_conjugate(const vec2 a, vec2 dest);
CGLM_EXPORT
void
@@ -199,11 +239,15 @@ glmc_vec2_make(const float * __restrict src, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest);
glmc_vec2_reflect(const vec2 v, const vec2 n, vec2 dest);
CGLM_EXPORT
bool
glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest);
glmc_vec2_refract(const vec2 v, const vec2 n, float eta, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_swap(vec2 a, vec2 b);
#ifdef __cplusplus
}
+109 -88
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec_dup(v, dest) glmc_vec3_copy(v, dest)
@@ -19,14 +19,15 @@ extern "C" {
#define glmc_vec3_flipsign_to(v, dest) glmc_vec3_negate_to(v, dest)
#define glmc_vec3_inv(v) glmc_vec3_negate(v)
#define glmc_vec3_inv_to(v, dest) glmc_vec3_negate_to(v, dest)
#define glmc_vec3_step_uni(edge, x, dest) glmc_vec3_steps(edge, x, dest);
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,35 +39,35 @@ 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);
CGLM_EXPORT
float
glmc_vec3_norm_one(vec3 v);
glmc_vec3_norm2(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_inf(vec3 v);
glmc_vec3_norm_one(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_inf(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
@@ -74,87 +75,87 @@ 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
glmc_vec3_subsub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_subsub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_addsub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_addsub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mulsub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_mulsub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mulsubs(vec3 a, float s, vec3 dest);
glmc_vec3_mulsubs(const vec3 a, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_maxsub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_maxsub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_minsub(vec3 a, vec3 b, vec3 dest);
glmc_vec3_minsub(const vec3 a, const vec3 b, vec3 dest);
CGLM_EXPORT
void
@@ -162,47 +163,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(CGLM_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(CGLM_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
@@ -210,51 +211,51 @@ 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);
CGLM_EXPORT
void
glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_lerpc(const vec3 from, const vec3 to, float t, vec3 dest);
CGLM_INLINE
void
glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
glmc_vec3_mix(const vec3 from, const vec3 to, float t, vec3 dest) {
glmc_vec3_lerp(from, to, t, dest);
}
CGLM_INLINE
void
glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
glmc_vec3_mixc(const vec3 from, const vec3 to, float t, vec3 dest) {
glmc_vec3_lerpc(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_vec3_step_uni(float edge, vec3 x, vec3 dest);
glmc_vec3_step(const vec3 edge, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
glmc_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
glmc_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
glmc_vec3_smoothinterp(const vec3 from, const vec3 to, float t, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_swizzle(const vec3 v, int mask, vec3 dest);
/* ext */
@@ -265,70 +266,86 @@ glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
CGLM_EXPORT
void
glmc_vec3_broadcast(float val, vec3 d);
CGLM_EXPORT
void
glmc_vec3_fill(vec3 v, float val);
CGLM_EXPORT
bool
glmc_vec3_eq(vec3 v, float val);
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_abs(vec3 v, vec3 dest);
glmc_vec3_abs(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_fract(vec3 v, vec3 dest);
glmc_vec3_fract(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_floor(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mods(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_steps(float edge, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_stepr(const vec3 edge, float x, vec3 dest);
CGLM_EXPORT
float
glmc_vec3_hadd(vec3 v);
glmc_vec3_hadd(const vec3 v);
CGLM_EXPORT
void
glmc_vec3_sqrt(vec3 v, vec3 dest);
glmc_vec3_sqrt(const vec3 v, vec3 dest);
CGLM_EXPORT
void
@@ -336,15 +353,19 @@ glmc_vec3_make(const float * __restrict src, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
glmc_vec3_faceforward(const vec3 n, const vec3 v, const vec3 nref, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest);
glmc_vec3_reflect(const vec3 v, const vec3 n, vec3 dest);
CGLM_EXPORT
bool
glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
glmc_vec3_refract(const vec3 v, const vec3 n, float eta, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_swap(vec3 a, vec3 b);
#ifdef __cplusplus
}
+105 -85
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
/* DEPRECATED! use _copy, _ucopy versions */
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
@@ -20,10 +20,11 @@ extern "C" {
#define glmc_vec4_flipsign_to(v, dest) glmc_vec4_negate_to(v, dest)
#define glmc_vec4_inv(v) glmc_vec4_negate(v)
#define glmc_vec4_inv_to(v, dest) glmc_vec4_negate_to(v, dest)
#define glmc_vec4_step_uni(edge, x, dest) glmc_vec4_steps(edge, x, dest)
CGLM_EXPORT
void
glmc_vec4(vec3 v3, float last, vec4 dest);
glmc_vec4(const vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
@@ -35,39 +36,39 @@ 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);
CGLM_EXPORT
float
glmc_vec4_norm_one(vec4 v);
glmc_vec4_norm2(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_inf(vec4 v);
glmc_vec4_norm_one(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_inf(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
@@ -75,87 +76,87 @@ 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(vec4 v, float s, vec4 dest);
glmc_vec4_scale_as(const vec4 v, float s, vec4 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
glmc_vec4_subsub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_subsub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_addsub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_addsub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mulsub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_mulsub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mulsubs(vec4 a, float s, vec4 dest);
glmc_vec4_mulsubs(const vec4 a, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_maxsub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_maxsub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_minsub(vec4 a, vec4 b, vec4 dest);
glmc_vec4_minsub(const vec4 a, const vec4 b, vec4 dest);
CGLM_EXPORT
void
@@ -163,76 +164,76 @@ 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
float
glmc_vec4_distance2(vec4 a, vec4 b);
glmc_vec4_distance2(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
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
glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
glmc_vec4_lerpc(const vec4 from, const vec4 to, float t, vec4 dest);
CGLM_INLINE
void
glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
glmc_vec4_mix(const vec4 from, const vec4 to, float t, vec4 dest) {
glmc_vec4_lerp(from, to, t, dest);
}
CGLM_INLINE
void
glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
glmc_vec4_mixc(const vec4 from, const vec4 to, float t, vec4 dest) {
glmc_vec4_lerpc(from, to, t, dest);
}
CGLM_EXPORT
void
glmc_vec4_step_uni(float edge, vec4 x, vec4 dest);
glmc_vec4_step(const vec4 edge, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
glmc_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
glmc_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
glmc_vec4_smoothinterp(const vec4 from, const vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
glmc_vec4_smoothinterpc(const vec4 from, const vec4 to, float t, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_cubic(float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_swizzle(const vec4 v, int mask, vec4 dest);
/* ext */
CGLM_EXPORT
@@ -242,70 +243,86 @@ glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
CGLM_EXPORT
void
glmc_vec4_broadcast(float val, vec4 d);
CGLM_EXPORT
void
glmc_vec4_fill(vec4 v, float val);
CGLM_EXPORT
bool
glmc_vec4_eq(vec4 v, float val);
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_abs(vec4 v, vec4 dest);
glmc_vec4_abs(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_fract(vec4 v, vec4 dest);
glmc_vec4_fract(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_floor(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mods(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_steps(float edge, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_stepr(const vec4 edge, float x, vec4 dest);
CGLM_EXPORT
float
glmc_vec4_hadd(vec4 v);
glmc_vec4_hadd(const vec4 v);
CGLM_EXPORT
void
glmc_vec4_sqrt(vec4 v, vec4 dest);
glmc_vec4_sqrt(const vec4 v, vec4 dest);
CGLM_EXPORT
void
@@ -313,14 +330,17 @@ glmc_vec4_make(const float * __restrict src, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest);
glmc_vec4_reflect(const vec4 v, const vec4 n, vec4 dest);
CGLM_EXPORT
bool
glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
glmc_vec4_refract(const vec4 v, const vec4 n, float eta, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_swap(vec4 a, vec4 b);
#ifdef __cplusplus
}
#endif
#endif /* cglmc_vec4_h */
+82 -34
View File
@@ -15,9 +15,9 @@
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_aabb(CGLM_CONST vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p(CGLM_CONST vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz(CGLM_CONST vec3 box[2], float padding, mat4 dest)
CGLM_INLINE void glm_ortho_default(float aspect, mat4 dest)
CGLM_INLINE void glm_ortho_default_s(float aspect, float size, mat4 dest)
CGLM_INLINE void glm_perspective(float fovy,
@@ -25,24 +25,29 @@
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_infinite(float fovy,
float aspect,
float nearZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_default_infinite(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize(float aspect, mat4 proj)
CGLM_INLINE void glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_persp_decomp(mat4 proj,
float *nearZ, float *farZ,
float *top, float *bottom,
float *left, float *right)
CGLM_INLINE void glm_persp_decompv(mat4 proj, float dest[6])
CGLM_INLINE void glm_persp_decomp_x(mat4 proj, float *left, float *right)
CGLM_INLINE void glm_persp_decomp_y(mat4 proj, float *top, float *bottom)
CGLM_INLINE void glm_persp_decomp_z(mat4 proj, float *nearv, float *farv)
CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float *farZ)
CGLM_INLINE void glm_persp_decomp_near(mat4 proj, float *nearZ)
CGLM_INLINE float glm_persp_fovy(mat4 proj)
CGLM_INLINE float glm_persp_aspect(mat4 proj)
CGLM_INLINE void glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
CGLM_INLINE void glm_lookat(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup(const vec3 eye, const vec3 dir, mat4 dest)
CGLM_INLINE void glm_persp_decomp(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right)
CGLM_INLINE void glm_persp_decompv(CGLM_CONST mat4 proj, float dest[6])
CGLM_INLINE void glm_persp_decomp_x(CGLM_CONST mat4 proj, float * __restrict left, float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y(CGLM_CONST mat4 proj, float * __restrict top, float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z(CGLM_CONST mat4 proj, float * __restrict nearZ, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far(CGLM_CONST mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near(CGLM_CONST mat4 proj, float * __restrict nearZ)
CGLM_INLINE float glm_persp_fovy(CGLM_CONST mat4 proj)
CGLM_INLINE float glm_persp_aspect(CGLM_CONST mat4 proj)
CGLM_INLINE void glm_persp_sizes(CGLM_CONST mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_cam_h
@@ -87,7 +92,7 @@
#endif
/*!
* @brief set up perspective peprojection matrix
* @brief set up perspective projection matrix
*
* @param[in] left viewport.left
* @param[in] right viewport.right
@@ -152,7 +157,7 @@ glm_ortho(float left, float right,
*/
CGLM_INLINE
void
glm_ortho_aabb(vec3 box[2], mat4 dest) {
glm_ortho_aabb(CGLM_CONST vec3 box[2], mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_lh_zo(box, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -175,7 +180,7 @@ glm_ortho_aabb(vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_p_lh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -198,7 +203,7 @@ glm_ortho_aabb_p(vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_ortho_aabb_pz_lh_zo(box, padding, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -274,6 +279,28 @@ glm_perspective(float fovy, float aspect, float nearZ, float farZ, mat4 dest) {
#endif
}
/*!
* @brief set up perspective projection matrix with infinite far plane
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_infinite(float fovy, float aspect, float nearZ, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_perspective_infinite_lh_zo(fovy, aspect, nearZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_perspective_infinite_lh_no(fovy, aspect, nearZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_perspective_infinite_rh_zo(fovy, aspect, nearZ, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_perspective_infinite_rh_no(fovy, aspect, nearZ, dest);
#endif
}
/*!
* @brief extend perspective projection matrix's far distance
*
@@ -317,6 +344,27 @@ glm_perspective_default(float aspect, mat4 dest) {
#endif
}
/*!
* @brief set up infinite perspective projection matrix with default near
* and angle values
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_infinite(float aspect, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_perspective_default_infinite_lh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
glm_perspective_default_infinite_lh_no(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_ZO
glm_perspective_default_infinite_rh_zo(aspect, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_RH_NO
glm_perspective_default_infinite_rh_no(aspect, dest);
#endif
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
@@ -347,7 +395,7 @@ glm_perspective_resize(float aspect, mat4 proj) {
*/
CGLM_INLINE
void
glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_lookat_lh(eye, center, up, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -371,7 +419,7 @@ glm_lookat(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
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) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_look_lh(eye, dir, up, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -391,7 +439,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) {
#if CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_LH_BIT
glm_look_anyup_lh(eye, dir, dest);
#elif CGLM_CONFIG_CLIP_CONTROL & CGLM_CLIP_CONTROL_RH_BIT
@@ -412,7 +460,7 @@ glm_look_anyup(vec3 eye, vec3 dir, mat4 dest) {
*/
CGLM_INLINE
void
glm_persp_decomp(mat4 proj,
glm_persp_decomp(CGLM_CONST mat4 proj,
float * __restrict nearZ, float * __restrict farZ,
float * __restrict top, float * __restrict bottom,
float * __restrict left, float * __restrict right) {
@@ -436,7 +484,7 @@ glm_persp_decomp(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv(mat4 proj, float dest[6]) {
glm_persp_decompv(CGLM_CONST mat4 proj, float dest[6]) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decompv_lh_zo(proj, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -458,7 +506,7 @@ glm_persp_decompv(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x(mat4 proj,
glm_persp_decomp_x(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
@@ -482,7 +530,7 @@ glm_persp_decomp_x(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y(mat4 proj,
glm_persp_decomp_y(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
@@ -506,7 +554,7 @@ glm_persp_decomp_y(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
glm_persp_decomp_z(CGLM_CONST mat4 proj, float * __restrict nearZ, float * __restrict farZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_z_lh_zo(proj, nearZ, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -526,7 +574,7 @@ glm_persp_decomp_z(mat4 proj, float * __restrict nearZ, float * __restrict farZ)
*/
CGLM_INLINE
void
glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
glm_persp_decomp_far(CGLM_CONST mat4 proj, float * __restrict farZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_far_lh_zo(proj, farZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -546,7 +594,7 @@ glm_persp_decomp_far(mat4 proj, float * __restrict farZ) {
*/
CGLM_INLINE
void
glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
glm_persp_decomp_near(CGLM_CONST mat4 proj, float * __restrict nearZ) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_decomp_near_lh_zo(proj, nearZ);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
@@ -567,7 +615,7 @@ glm_persp_decomp_near(mat4 proj, float * __restrict nearZ) {
*/
CGLM_INLINE
void
glm_persp_sizes(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
#if CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_ZO
glm_persp_sizes_lh_zo(proj, fovy, dest);
#elif CGLM_CONFIG_CLIP_CONTROL == CGLM_CLIP_CONTROL_LH_NO
+2
View File
@@ -30,6 +30,7 @@
#include "quat.h"
#include "euler.h"
#include "plane.h"
#include "noise.h"
#include "aabb2d.h"
#include "box.h"
#include "color.h"
@@ -42,5 +43,6 @@
#include "bezier.h"
#include "ray.h"
#include "affine2d.h"
#include "affine2d-post.h"
#endif /* cglm_h */
+6 -6
View File
@@ -11,11 +11,11 @@
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_no(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_lh_no(CGLM_CONST vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_no(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_lh_no(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_pz_lh_no(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_lh_no(float aspect,
@@ -80,7 +80,7 @@ glm_ortho_lh_no(float left, float right,
*/
CGLM_INLINE
void
glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
glm_ortho_aabb_lh_no(CGLM_CONST vec3 box[2], mat4 dest) {
glm_ortho_lh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
@@ -100,7 +100,7 @@ glm_ortho_aabb_lh_no(vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p_lh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_no(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -120,7 +120,7 @@ glm_ortho_aabb_p_lh_no(vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_lh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz_lh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
+6 -6
View File
@@ -11,11 +11,11 @@
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_zo(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_lh_zo(CGLM_CONST vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_lh_zo(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_pz_lh_zo(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_lh_zo(float aspect,
@@ -78,7 +78,7 @@ glm_ortho_lh_zo(float left, float right,
*/
CGLM_INLINE
void
glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
glm_ortho_aabb_lh_zo(CGLM_CONST vec3 box[2], mat4 dest) {
glm_ortho_lh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
@@ -97,7 +97,7 @@ glm_ortho_aabb_lh_zo(vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p_lh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_zo(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -116,7 +116,7 @@ glm_ortho_aabb_p_lh_zo(vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_lh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz_lh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_lh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
+6 -6
View File
@@ -11,11 +11,11 @@
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_no(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_rh_no(CGLM_CONST vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_no(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_rh_no(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_pz_rh_no(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_rh_no(float aspect,
@@ -80,7 +80,7 @@ glm_ortho_rh_no(float left, float right,
*/
CGLM_INLINE
void
glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
glm_ortho_aabb_rh_no(CGLM_CONST vec3 box[2], mat4 dest) {
glm_ortho_rh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
@@ -100,7 +100,7 @@ glm_ortho_aabb_rh_no(vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p_rh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_no(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -120,7 +120,7 @@ glm_ortho_aabb_p_rh_no(vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_rh_no(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz_rh_no(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_no(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
+6 -6
View File
@@ -11,11 +11,11 @@
float bottom, float top,
float nearZ, float farZ,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_rh_zo(CGLM_CONST vec3 box[2], mat4 dest)
CGLM_INLINE void glm_ortho_aabb_p_rh_zo(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(CGLM_CONST vec3 box[2],
float padding,
mat4 dest)
CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
@@ -79,7 +79,7 @@ glm_ortho_rh_zo(float left, float right,
*/
CGLM_INLINE
void
glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
glm_ortho_aabb_rh_zo(CGLM_CONST vec3 box[2], mat4 dest) {
glm_ortho_rh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-box[1][2], -box[0][2],
@@ -99,7 +99,7 @@ glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_p_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_zo(box[0][0] - padding, box[1][0] + padding,
box[0][1] - padding, box[1][1] + padding,
-(box[1][2] + padding), -(box[0][2] - padding),
@@ -119,7 +119,7 @@ glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
*/
CGLM_INLINE
void
glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
glm_ortho_aabb_pz_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
glm_ortho_rh_zo(box[0][0], box[1][0],
box[0][1], box[1][1],
-(box[1][2] + padding), -(box[0][2] - padding),
Loaded 100 of 268 files, more files were not shown because too many files have changed in this diff. Show more