Compare commits

..
85 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
226 changed files with 7459 additions and 4196 deletions

No files matched your search

+119 -135
View File
@@ -15,20 +15,13 @@ jobs:
matrix:
include:
# x86/x64 builds
- { os: macos-13, simd: none }
- { os: macos-13, simd: sse }
- { os: macos-13, simd: sse2 }
- { os: macos-13, simd: sse3 }
- { os: macos-13, simd: sse4 }
- { os: macos-13, simd: avx }
- { os: macos-13, simd: avx2 }
- { os: macos-14, simd: none }
- { os: macos-14, simd: sse }
- { os: macos-14, simd: sse2 }
- { os: macos-14, simd: sse3 }
- { os: macos-14, simd: sse4 }
- { os: macos-14, simd: avx }
- { os: macos-14, simd: avx2 }
- { 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 }
@@ -44,17 +37,18 @@ jobs:
- { os: ubuntu-24.04, simd: avx }
- { os: ubuntu-24.04, simd: avx2 }
# ARM64 builds
- { os: ubuntu-latest-arm64, simd: neon }
- { os: macos-latest, simd: neon }
- { os: ubuntu-24.04-arm, simd: neon }
steps:
- uses: actions/checkout@v4
- 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: matrix.os == 'ubuntu-22.04' || matrix.os == 'ubuntu-24.04'
if: runner.os == 'Linux'
run: sudo apt-get install -y autoconf automake libtool
- name: Set SIMD flags
@@ -91,7 +85,7 @@ jobs:
build_cmake_ios:
name: CMake / iOS
runs-on: macos-14
runs-on: macos-latest
steps:
- uses: actions/checkout@v4
@@ -112,19 +106,19 @@ jobs:
build_cmake_ubuntu:
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }} / ${{ matrix.target.arch }} / ${{ matrix.target.simd }}
runs-on: ${{ matrix.target.arch == 'arm64' && 'ubuntu-latest-arm64' || matrix.target.os }}
runs-on: ${{ matrix.target.os }}
strategy:
fail-fast: false
matrix:
target:
# GCC 11 builds
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: none }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse2 }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse3 }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse4 }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: avx }
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: avx2 }
- { 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 }
@@ -142,13 +136,13 @@ jobs:
- { 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-20.04, cc: clang-12, arch: x64, simd: none }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse2 }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse3 }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse4 }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: avx }
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: avx2 }
- { 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 }
@@ -158,63 +152,61 @@ jobs:
- { 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-latest, cc: gcc-12, arch: arm64, simd: neon }
- { os: ubuntu-latest, cc: gcc-13, arch: arm64, simd: neon }
- { 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-latest-arm64, cc: gcc-12, arch: armv7, simd: neon }
- { os: ubuntu-latest-arm64, cc: gcc-12, arch: armv7, simd: none }
- { 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: Add Ubuntu Toolchain PPA
if: matrix.target.os == 'ubuntu-20.04'
run: |
sudo apt-get update
sudo apt-get install -y software-properties-common
sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
sudo apt-get update
- name: Install Compiler and Ninja
run: |
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
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.simd }}" == "none" ]; then
if [ "${{ matrix.target.simd }}" == "none" ]; then
export CFLAGS=""
elif [ "${{ matrix.simd }}" == "sse" ]; then
elif [ "${{ matrix.target.simd }}" == "sse" ]; then
export CFLAGS="-msse"
elif [ "${{ matrix.simd }}" == "sse2" ]; then
elif [ "${{ matrix.target.simd }}" == "sse2" ]; then
export CFLAGS="-msse2"
elif [ "${{ matrix.simd }}" == "sse3" ]; then
elif [ "${{ matrix.target.simd }}" == "sse3" ]; then
export CFLAGS="-msse3"
elif [ "${{ matrix.simd }}" == "sse4" ]; then
elif [ "${{ matrix.target.simd }}" == "sse4" ]; then
export CFLAGS="-msse4"
elif [ "${{ matrix.simd }}" == "avx" ]; then
elif [ "${{ matrix.target.simd }}" == "avx" ]; then
export CFLAGS="-mavx"
elif [ "${{ matrix.simd }}" == "avx2" ]; then
elif [ "${{ matrix.target.simd }}" == "avx2" ]; then
export CFLAGS="-mavx2"
elif [ "${{ matrix.simd }}" == "neon" ]; then
elif [ "${{ matrix.target.simd }}" == "neon" ]; then
export CFLAGS="-mfpu=neon"
fi
- name: Configure CMake
run: |
if [ "${{ matrix.target.arch }}" == "armv7" ]; then
# Build for ARMv7
neon_flags=""
if [ "${{ matrix.simd }}" == "neon" ]; 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="$CFLAGS -m32 -march=armv7-a ${neon_flags}" \
-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.simd }}" == "neon" ]; then
if [ "${{ matrix.target.simd }}" == "neon" ]; then
neon_flags="+simd" # Enable SIMD/NEON features on ARM64
else
neon_flags="+nosimd" # Explicitly disable SIMD/NEON
@@ -236,7 +228,12 @@ jobs:
- name: Test
working-directory: build
run: ./tests
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 }}
@@ -244,14 +241,14 @@ jobs:
strategy:
fail-fast: false
matrix:
os: [macos-13, 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: |
@@ -277,20 +274,13 @@ jobs:
matrix:
include:
# x86/x64 builds
- { os: macos-13, simd: none }
- { os: macos-13, simd: sse }
- { os: macos-13, simd: sse2 }
- { os: macos-13, simd: sse3 }
- { os: macos-13, simd: sse4 }
- { os: macos-13, simd: avx }
- { os: macos-13, simd: avx2 }
- { os: macos-14, simd: none }
- { os: macos-14, simd: sse }
- { os: macos-14, simd: sse2 }
- { os: macos-14, simd: sse3 }
- { os: macos-14, simd: sse4 }
- { os: macos-14, simd: avx }
- { os: macos-14, simd: avx2 }
- { 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 }
@@ -299,14 +289,14 @@ jobs:
- { os: windows-2022, simd: avx }
- { os: windows-2022, simd: avx2 }
# ARM64 builds
- { os: macos-14-arm64, simd: neon }
- { os: macos-latest, simd: neon }
steps:
- uses: actions/checkout@v4
- name: Install Ninja on macOS
if: runner.os == 'macOS'
run: brew upgrade && brew install ninja
run: brew install ninja
- name: Set SIMD flags (Windows)
if: runner.os == 'Windows'
@@ -380,19 +370,19 @@ jobs:
build_meson:
name: Meson / ${{ matrix.os }} / ${{ matrix.simd }}
runs-on: ${{ contains(matrix.os, 'arm64') && 'ubuntu-latest-arm64' || matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
include:
# x86/x64 builds
- { os: macos-14, simd: none }
- { os: macos-14, simd: sse }
- { os: macos-14, simd: sse2 }
- { os: macos-14, simd: sse3 }
- { os: macos-14, simd: sse4 }
- { os: macos-14, simd: avx }
- { os: macos-14, simd: avx2 }
- { 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 }
@@ -415,7 +405,8 @@ jobs:
- { os: windows-2022, simd: avx }
- { os: windows-2022, simd: avx2 }
# ARM64 builds
- { os: ubuntu-latest-arm64, simd: neon }
- { os: macos-latest, simd: neon }
- { os: ubuntu-24.04-arm, simd: neon }
steps:
- uses: actions/checkout@v4
@@ -554,12 +545,12 @@ jobs:
run: sphinx-build -W --keep-going source build
build_swift:
name: Swift ${{ matrix.swift }} / ${{ matrix.os }}
name: Swift / ${{ matrix.os }}
runs-on: ${{ matrix.os }}
strategy:
fail-fast: false
matrix:
os: [macos-13, macos-14, ubuntu-22.04]
os: [macos-26-intel, macos-latest, ubuntu-22.04]
# This has no test yet.
steps:
@@ -575,71 +566,64 @@ jobs:
fail-fast: false
matrix:
include:
# Linux ARM builds
- os: ubuntu-latest-arm64
arch: arm64
simd: neon
- os: ubuntu-latest-arm64
arch: armv7
simd: neon
- os: ubuntu-latest-arm64
arch: armv7
simd: none
# Windows ARM builds
- os: windows-latest-arm64
arch: arm64
simd: neon
- os: windows-latest-arm64
arch: arm
simd: neon
- os: windows-latest-arm64
arch: arm
simd: none
# 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: |
$flags = ""
if ("${{ matrix.arch }}" -eq "arm") {
$flags = "-m32 -march=armv7-a"
if ("${{ matrix.simd }}" -eq "neon") {
$flags += " -mfpu=neon"
}
}
elseif ("${{ matrix.simd }}" -eq "neon") {
$flags = "-march=armv8-a+simd"
}
cmake -B build -G "Visual Studio 17 2022" -A ${{ matrix.arch == 'arm64' && 'ARM64' || 'ARM' }} `
# 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 `
-DCMAKE_C_FLAGS="$flags" `
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
- name: Configure CMake (Unix)
if: runner.os != 'Windows'
if: runner.os == 'Linux'
shell: bash
run: |
flags=""
if [ "${{ matrix.arch }}" = "armv7" ]; then
flags="-m32 -march=armv7-a"
flags="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard"
if [ "${{ matrix.simd }}" = "neon" ]; then
flags="$flags -mfpu=neon -mfloat-abi=hard"
flags="-march=armv7-a -mfpu=neon -mfloat-abi=hard"
fi
elif [ "${{ matrix.simd }}" = "neon" ]; then
flags="-march=armv8-a+simd"
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
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
-DCMAKE_C_FLAGS="$flags" \
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
- name: Build
run: cmake --build build
run: cmake --build build --config Release
- name: Test
- name: Test (Linux)
if: runner.os == 'Linux'
working-directory: build
run: ./tests
run: |
if [ "${{ matrix.arch }}" = "armv7" ]; then
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
else
./tests
fi
+5 -3
View File
@@ -35,9 +35,11 @@ jobs:
# https://github.com/WebAssembly/wasi-sdk/issues/332
- name: Modify CMakeLists.txt for WASI
run: |
echo 'if (CMAKE_SYSTEM_NAME STREQUAL "WASI")' >> CMakeLists.txt
echo ' target_link_options(${PROJECT_NAME} PRIVATE -mexec-model=reactor)' >> CMakeLists.txt
echo 'endif()' >> CMakeLists.txt
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.
+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 -3
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,18 +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
.vscode
.build
*.swp
.lastsession.vim
.vimrc
compile_commands.json
+2 -2
View File
@@ -1,6 +1,6 @@
cmake_minimum_required(VERSION 3.13)
project(cglm
VERSION 0.9.5
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)
+5 -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)
@@ -79,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 \
@@ -131,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 \
+1 -1
View File
@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
# Description
s.name = "cglm"
s.version = "0.9.4"
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.5], [[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.
+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 )
+2 -2
View File
@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
# built documents.
#
# The short X.Y version.
version = u'0.9.5'
version = u'0.9.8'
# The full version, including alpha/beta/rc tags.
release = u'0.9.5'
release = u'0.9.8'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
+835 -155
View File
File diff suppressed because it is too large. Load diff
+117 -52
View File
@@ -36,58 +36,103 @@ Represented
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)
make given matrix zero
Parameters:
| *[in,out]* **mat** matrix
.. c:function:: void glm_mat2x3_make(const float * __restrict src, mat2x3 dest)
Create mat2x3 matrix from pointer
.. note:: **@src** must contain at least 6 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix2x3
.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest)
multiply m1 and m2 to dest
.. code-block:: c
glm_mat2x3_mul(mat2x3, mat3x2, mat3);
Parameters:
| *[in]* **m1** left matrix (mat2x3)
| *[in]* **m2** right matrix (mat3x2)
| *[out]* **dest** destination matrix (mat3)
.. csv-table:: mat2x3
.. csv-table:: mat2x3 **(src)**
:header: "", "column 1", "column 2"
"row 1", "a00", "a10"
"row 2", "a01", "a11"
"row 3", "a02", "a12"
.. csv-table:: mat3x2
.. 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]* **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 (dest) from pointer (src).
.. note:: **@src** must contain at least 6 elements.
Parameters:
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat2x3)
.. csv-table:: float array (1x6) **(src)**
:header: "", "column 1"
"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, mat3);
Parameters:
| *[in]* **m1** mat2x3 (left)
| *[in]* **m2** mat3x2 (right)
| *[out]* **dest** destination (result, mat3)
.. csv-table:: mat2x3 **(m1)**
:header: "", "column 1", "column 2"
"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:: mat3x3
.. 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"
@@ -96,45 +141,65 @@ Functions documentation
.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest)
multiply mat2x3 with vec2 (column vector) and store in dest column vector
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)
.. csv-table:: mat2x3
.. csv-table:: mat2x3 **(m)**
:header: "", "column 1", "column 2"
"row 1", "m00", "m10"
"row 2", "m01", "m11"
"row 3", "m02", "m12"
.. csv-table:: column vec2 (1x2)
.. csv-table:: column vec2 (1x2) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
.. csv-table:: column vec3 (1x3)
.. 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 m, mat3x2 dest)
.. c:function:: void glm_mat2x3_transpose(mat2x3 src, mat3x2 dest)
transpose matrix and store in 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"
+125 -51
View File
@@ -37,45 +37,15 @@ Represented
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)
make given matrix zero
Parameters:
| *[in,out]* **mat** matrix
.. c:function:: void glm_mat2x4_make(const float * __restrict src, mat2x4 dest)
Create mat2x4 matrix from pointer
.. note:: **@src** must contain at least 8 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix2x4
.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest)
multiply m1 and m2 to dest
.. code-block:: c
glm_mat2x4_mul(mat2x4, mat4x2, mat4);
Parameters:
| *[in]* **m1** left matrix (mat2x4)
| *[in]* **m2** right matrix (mat4x2)
| *[out]* **dest** destination matrix (mat4)
.. csv-table:: mat2x4
.. csv-table:: mat2x4 **(src)**
:header: "", "column 1", "column 2"
"row 1", "a00", "a10"
@@ -83,13 +53,95 @@ Functions documentation
"row 3", "a02", "a12"
"row 4", "a03", "a13"
.. csv-table:: mat4x2
.. 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]* **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 (dest) from pointer (src).
.. note:: **@src** must contain at least 8 elements.
Parameters:
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat2x4)
.. csv-table:: float array (1x8) **(src)**
:header: "", "column 1"
"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, mat4);
Parameters:
| *[in]* **m1** mat2x4 (left)
| *[in]* **m2** mat4x2 (right)
| *[out]* **dest** destination (result, mat4)
.. csv-table:: mat2x4 **(m1)**
:header: "", "column 1", "column 2"
"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
.. 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"
@@ -99,14 +151,14 @@ Functions documentation
.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest)
multiply mat2x4 with vec2 (column vector) and store in dest column vector
Multiply mat2x4 (m) by vec2 (v) and store in vec4 (dest).
Parameters:
| *[in]* **m** mat2x4 (left)
| *[in]* **v** vec2 (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)
.. csv-table:: mat2x4
.. csv-table:: mat2x4 **(m)**
:header: "", "column 1", "column 2"
"row 1", "m00", "m10"
@@ -114,13 +166,13 @@ Functions documentation
"row 3", "m02", "m12"
"row 4", "m03", "m13"
.. csv-table:: column vec2 (1x2)
.. csv-table:: column vec2 (1x2) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
.. csv-table:: column vec4 (1x4)
.. csv-table:: column vec4 (1x4) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1"
@@ -128,18 +180,40 @@ Functions documentation
"row 3", "m02 * v0 + m12 * v1"
"row 4", "m03 * v0 + m13 * v1"
.. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest)
.. c:function:: void glm_mat2x4_transpose(mat2x4 src, mat4x2 dest)
transpose matrix and store in 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
+91 -32
View File
@@ -35,58 +35,98 @@ Represented
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)
.. csv-table:: float array (1x6) **(src)**
:header: "", "column 1"
"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 m1 and m2 to dest
Multiply mat3x2 (m1) by mat2x3 (m2) and store in mat2 (dest).
.. code-block:: c
glm_mat3x2_mul(mat3x2, mat2x3, mat2);
Parameters:
| *[in]* **m1** left matrix (mat3x2)
| *[in]* **m2** right matrix (mat2x3)
| *[out]* **dest** destination matrix (mat2)
| *[in]* **m1** mat3x2 (left)
| *[in]* **m2** mat2x3 (right)
| *[out]* **dest** destination (result, mat2)
.. csv-table:: mat3x2
.. csv-table:: mat3x2 **(m1)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "a00", "a10", "a20"
"row 2", "a01", "a11", "a21"
.. csv-table:: mat2x3
.. csv-table:: mat2x3 **(m2)**
:header: "", "column 1", "column 2"
"row 1", "b00", "b10"
"row 2", "b01", "b11"
"row 3", "b02", "b12"
.. csv-table:: mat2x2
.. csv-table:: mat2x2 **(dest)**
:header: "", "column 1", "column 2"
"row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12"
@@ -94,44 +134,63 @@ Functions documentation
.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest)
multiply mat3x2 with vec3 (column vector) and store in dest vector
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)
.. csv-table:: mat3x2
.. csv-table:: mat3x2 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
.. csv-table:: column vec3 (1x3)
.. csv-table:: column vec3 (1x3) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
.. csv-table:: column vec2 (1x2)
.. 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 m, mat2x3 dest)
.. c:function:: void glm_mat3x2_transpose(mat3x2 src, mat2x3 dest)
transpose matrix and store in 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"
+130 -51
View File
@@ -37,45 +37,15 @@ Represented
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)
make given matrix zero
Parameters:
| *[in,out]* **mat** matrix
.. c:function:: void glm_mat3x4_make(const float * __restrict src, mat3x4 dest)
Create mat3x4 matrix from pointer
.. note::: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix3x4
.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest)
multiply m1 and m2 to dest
.. code-block:: c
glm_mat3x4_mul(mat3x4, mat4x3, mat4);
Parameters:
| *[in]* **m1** left matrix (mat3x4)
| *[in]* **m2** right matrix (mat4x3)
| *[out]* **dest** destination matrix (mat4)
.. csv-table:: mat3x4
.. csv-table:: mat3x4 **(src)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "a00", "a10", "a20"
@@ -83,14 +53,100 @@ Functions documentation
"row 3", "a02", "a12", "a22"
"row 4", "a03", "a13", "a23"
.. csv-table:: mat4x3
.. 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]* **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 (dest) from pointer (src).
.. note:: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat3x4)
.. csv-table:: float array (1x12) **(src)**
:header: "", "column 1"
"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, mat4);
Parameters:
| *[in]* **m1** mat2x4 (left)
| *[in]* **m2** mat4x2 (right)
| *[out]* **dest** destination (result, mat4)
.. csv-table:: mat3x4 **(m1)**
: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 **(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
.. 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"
@@ -100,14 +156,14 @@ Functions documentation
.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest)
multiply mat3x4 with vec3 (column vector) and store in dest vector
Multiply ma3x4 (m) by vec3 (v) and store in vec4 (dest).
Parameters:
| *[in]* **m** mat3x4 (left)
| *[in]* **v** vec3 (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)
.. csv-table:: mat3x4
.. csv-table:: mat3x4 **(m)**
:header: "", "column 1", "column 2", "column 3"
"row 1", "m00", "m10", "m20"
@@ -115,14 +171,14 @@ Functions documentation
"row 3", "m02", "m12", "m22"
"row 4", "m03", "m13", "m23"
.. csv-table:: column vec3 (1x3)
.. csv-table:: column vec3 (1x3) **(v)**
:header: "", "column 1"
"row 1", "v0"
"row 2", "v1"
"row 3", "v2"
.. csv-table:: column vec4 (1x4)
.. csv-table:: column vec4 (1x4) **(dest)**
:header: "", "column 1"
"row 1", "m00 * v0 + m10 * v1 + m20 * v2"
@@ -130,18 +186,41 @@ Functions documentation
"row 3", "m02 * v0 + m12 * v1 + m22 * v2"
"row 4", "m03 * v0 + m13 * v1 + m23 * v2"
.. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest)
.. c:function:: void glm_mat3x4_transpose(mat3x4 src, mat4x3 dest)
transpose matrix and store in 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
+96 -36
View File
@@ -35,51 +35,93 @@ Represented
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)
.. csv-table:: float array (1x8) **(src)**
:header: "", "column 1"
"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 m1 and m2 to dest
Multiply mat4x2 (m1) by mat2x4 (m2) and store in mat2 (dest).
.. code-block:: c
glm_mat4x2_mul(mat4x2, mat2x4, mat2);
Parameters:
| *[in]* **m1** left matrix (mat4x2)
| *[in]* **m2** right matrix (mat2x4)
| *[out]* **dest** destination matrix (mat2)
| *[in]* **m1** mat4x2 (left)
| *[in]* **m2** mat2x4 (right)
| *[out]* **dest** destination (result, mat2)
.. csv-table:: mat4x2
.. csv-table:: mat4x2 **(m1)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
.. csv-table:: mat2x4
.. csv-table:: mat2x4 **(m2)**
:header: "", "column 1", "column 2"
"row 1", "b00", "b10"
@@ -87,7 +129,7 @@ Functions documentation
"row 3", "b02", "b12"
"row 4", "b03", "b13"
.. csv-table:: mat2x2
.. 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"
@@ -95,22 +137,20 @@ Functions documentation
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest)
multiply mat4x2 with vec4 (column vector) and store in dest vector
Multiply mat4x2 (m) by vec4 (v) and store in vec2 (dest).
Parameters:
| *[in]* **m** mat4x2 (left)
| *[in]* **v** vec4 (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)
.. csv-table:: mat4x2
:header: "", "column 1", "column 2", "column 3"
.. csv-table:: mat4x2 **(m)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "m00", "m10", "m20"
"row 2", "m01", "m11", "m21"
"row 3", "m02", "m12", "m22"
"row 4", "m03", "m13", "m23"
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
.. csv-table:: column vec4 (1x4)
.. csv-table:: column vec4 (1x4) **(v)**
:header: "", "column 1"
"row 1", "v0"
@@ -118,24 +158,44 @@ Functions documentation
"row 3", "v2"
"row 4", "v3"
.. csv-table:: column vec2 (1x2)
.. 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 m, mat2x4 dest)
.. c:function:: void glm_mat4x2_transpose(mat4x2 src, mat2x4 dest)
transpose matrix and store in 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"
+126 -53
View File
@@ -27,7 +27,7 @@ Represented
~~~~~~~~~~~
.. csv-table:: mat4x3
:header: "", "column 1", "column 2", "column 3", "column4"
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "m00", "m10", "m20", "m30"
"row 2", "m01", "m11", "m21", "m31"
@@ -36,52 +36,103 @@ Represented
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)
make given matrix zero
Parameters:
| *[in,out]* **mat** matrix
.. c:function:: void glm_mat4x3_make(const float * __restrict src, mat4x3 dest)
Create mat4x3 matrix from pointer
.. note:: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats
| *[out]* **dest** destination matrix4x3
.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest)
multiply m1 and m2 to dest
.. code-block:: c
glm_mat4x3_mul(mat4x3, mat3x4, mat3);
Parameters:
| *[in]* **m1** left matrix (mat4x3)
| *[in]* **m2** right matrix (mat3x4)
| *[out]* **dest** destination matrix (mat3)
.. csv-table:: mat4x3
.. csv-table:: mat4x3 **(src)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"row 1", "a00", "a10", "a20", "a30"
"row 2", "a01", "a11", "a21", "a31"
"row 3", "a02", "a12", "a22", "a32"
.. csv-table:: mat3x4
.. 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]* **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 (dest) from pointer (src).
.. note:: **@src** must contain at least 12 elements.
Parameters:
| *[in]* **src** pointer to an array of floats (left)
| *[out]* **dest** destination (result, mat4x3)
.. csv-table:: float array (1x12) **(src)**
:header: "", "column 1"
"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, mat3);
Parameters:
| *[in]* **m1** mat4x3 (left)
| *[in]* **m2** mat3x4 (right)
| *[out]* **dest** destination (result, mat3)
.. csv-table:: mat4x3 **(m1)**
:header: "", "column 1", "column 2", "column 3", "column 4"
"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"
@@ -89,7 +140,7 @@ Functions documentation
"row 3", "b02", "b12", "b22"
"row 4", "b03", "b13", "b23"
.. csv-table:: mat3x3
.. 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"
@@ -98,21 +149,21 @@ Functions documentation
.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest)
multiply mat4x3 with vec4 (column vector) and store in dest column vector
Multiply mat4x3 (m) by vec4 (v) and store in vec3 (dest).
Parameters:
| *[in]* **m** mat4x3 (left)
| *[in]* **v** vec4 (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)
.. csv-table:: mat4x3
.. csv-table:: mat4x3 **(m)**
: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"
.. csv-table:: column vec4 (1x4)
.. csv-table:: column vec4 (1x4) **(v)**
:header: "", "column 1"
"row 1", "v0"
@@ -120,25 +171,47 @@ Functions documentation
"row 3", "v2"
"row 4", "v3"
.. csv-table:: column vec3 (1x3)
.. 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 m, mat3x4 dest)
.. c:function:: void glm_mat4x3_transpose(mat4x3 src, mat3x4 dest)
transpose matrix and store in 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"
+18 -18
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]);
@@ -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]);
@@ -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,7 +262,7 @@ 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]);
}
+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);
+19 -19
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;
@@ -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 */
+20 -19
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]);
@@ -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]);
@@ -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
View File
@@ -11,7 +11,6 @@
extern "C" {
#endif
#include "cglm.h"
#include "call/vec2.h"
#include "call/vec3.h"
#include "call/vec4.h"
+17 -17
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,39 +49,39 @@ 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
}
+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 -16
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,35 +42,35 @@ 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
}
+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, mat3 dest);
glmc_mat2x3_mul(CGLM_CONST mat2x3 m1, CGLM_CONST mat3x2 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat2x3_mulv(mat2x3 m, vec2 v, vec3 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, mat4 dest);
glmc_mat2x4_mul(CGLM_CONST mat2x4 m1, CGLM_CONST mat4x2 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat2x4_mulv(mat2x4 m, vec2 v, vec4 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, mat2 dest);
glmc_mat3x2_mul(CGLM_CONST mat3x2 m1, CGLM_CONST mat2x3 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat3x2_mulv(mat3x2 m, vec3 v, vec2 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, mat4 dest);
glmc_mat3x4_mul(CGLM_CONST mat3x4 m1, CGLM_CONST mat4x3 m2, mat4 dest);
CGLM_EXPORT
void
glmc_mat3x4_mulv(mat3x4 m, vec3 v, vec4 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, mat2 dest);
glmc_mat4x2_mul(CGLM_CONST mat4x2 m1, CGLM_CONST mat2x4 m2, mat2 dest);
CGLM_EXPORT
void
glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 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, mat3 dest);
glmc_mat4x3_mul(CGLM_CONST mat4x3 m1, CGLM_CONST mat3x4 m2, mat3 dest);
CGLM_EXPORT
void
glmc_mat4x3_mulv(mat4x3 m, vec4 v, vec3 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
+4 -4
View File
@@ -11,19 +11,19 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
float
glmc_perlin_vec4(vec4 point);
glmc_perlin_vec4(const vec4 point);
CGLM_EXPORT
float
glmc_perlin_vec3(vec3 point);
glmc_perlin_vec3(const vec3 point);
CGLM_EXPORT
float
glmc_perlin_vec2(vec2 point);
glmc_perlin_vec2(const vec2 point);
#ifdef __cplusplus
}
+1 -1
View File
@@ -11,7 +11,7 @@
extern "C" {
#endif
#include "../cglm.h"
#include "../common.h"
CGLM_EXPORT
void
+6 -6
View File
@@ -11,27 +11,27 @@
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
}
+34 -34
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,115 +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_slerp_longest(versor q, versor r, float t, versor dest);
glmc_quat_slerp_longest(const versor q, const versor r, float t, versor dest);
CGLM_EXPORT
void
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
CGLM_EXPORT
void
glmc_quat_for(vec3 dir, vec3 up, versor dest);
glmc_quat_for(const vec3 dir, const vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
glmc_quat_forp(const vec3 from, const vec3 to, const vec3 up, versor dest);
CGLM_EXPORT
void
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
CGLM_EXPORT
void
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
glmc_quat_rotate(CGLM_CONST mat4 m, const versor q, mat4 dest);
CGLM_EXPORT
void
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
CGLM_EXPORT
void
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
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
}
+56 -52
View File
@@ -11,11 +11,11 @@
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
@@ -23,15 +23,15 @@ glmc_vec2_fill(vec2 v, float val);
CGLM_EXPORT
bool
glmc_vec2_eq(vec2 v, float val);
glmc_vec2_eq(const vec2 v, float val);
CGLM_EXPORT
bool
glmc_vec2_eqv(vec2 a, vec2 b);
glmc_vec2_eqv(const vec2 a, const vec2 b);
CGLM_EXPORT
void
glmc_vec2_copy(vec2 a, vec2 dest);
glmc_vec2_copy(const vec2 a, vec2 dest);
CGLM_EXPORT
void
@@ -43,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
@@ -155,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
@@ -187,51 +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_fract(vec2 v, vec2 dest);
glmc_vec2_fract(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_floor(vec2 v, vec2 dest);
glmc_vec2_floor(const vec2 v, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_mods(vec2 v, float s, vec2 dest);
glmc_vec2_mods(const vec2 v, float s, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_swizzle(vec2 v, int mask, vec2 dest);
glmc_vec2_swizzle(const vec2 v, int mask, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
glmc_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_step(vec2 edge, vec2 x, vec2 dest);
glmc_vec2_step(const vec2 edge, const vec2 x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_steps(float edge, vec2 x, vec2 dest);
glmc_vec2_steps(float edge, const vec2 x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_stepr(vec2 edge, float x, vec2 dest);
glmc_vec2_stepr(const vec2 edge, float x, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
glmc_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
glmc_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest);
CGLM_EXPORT
void
glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
glmc_vec2_complex_conjugate(const vec2 a, vec2 dest);
CGLM_EXPORT
void
@@ -239,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
}
+80 -76
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)
@@ -23,11 +23,11 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec3(vec4 v4, vec3 dest);
glmc_vec3(const vec4 v4, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_copy(vec3 a, vec3 dest);
glmc_vec3_copy(const vec3 a, vec3 dest);
CGLM_EXPORT
void
@@ -39,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);
glmc_vec3_norm2(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_one(vec3 v);
glmc_vec3_norm_one(const vec3 v);
CGLM_EXPORT
float
glmc_vec3_norm_inf(vec3 v);
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
@@ -75,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
@@ -163,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
@@ -211,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(vec3 edge, vec3 x, vec3 dest);
glmc_vec3_step(const vec3 edge, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
glmc_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
glmc_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
glmc_vec3_smoothinterp(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_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_swizzle(vec3 v, int mask, vec3 dest);
glmc_vec3_swizzle(const vec3 v, int mask, vec3 dest);
/* ext */
@@ -273,79 +273,79 @@ 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(vec3 v, vec3 dest);
glmc_vec3_floor(const vec3 v, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_mods(vec3 v, float s, vec3 dest);
glmc_vec3_mods(const vec3 v, float s, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_steps(float edge, vec3 x, vec3 dest);
glmc_vec3_steps(float edge, const vec3 x, vec3 dest);
CGLM_EXPORT
void
glmc_vec3_stepr(vec3 edge, float x, vec3 dest);
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
@@ -353,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
}
+72 -68
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)
@@ -24,7 +24,7 @@ extern "C" {
CGLM_EXPORT
void
glmc_vec4(vec3 v3, float last, vec4 dest);
glmc_vec4(const vec3 v3, float last, vec4 dest);
CGLM_EXPORT
void
@@ -36,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);
glmc_vec4_norm2(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_one(vec4 v);
glmc_vec4_norm_one(const vec4 v);
CGLM_EXPORT
float
glmc_vec4_norm_inf(vec4 v);
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
@@ -76,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
@@ -164,23 +164,23 @@ 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
@@ -188,43 +188,43 @@ 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(vec4 edge, vec4 x, vec4 dest);
glmc_vec4_step(const vec4 edge, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
glmc_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
glmc_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
glmc_vec4_smoothinterp(const vec4 from, const 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
@@ -232,7 +232,7 @@ glmc_vec4_cubic(float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_swizzle(vec4 v, int mask, vec4 dest);
glmc_vec4_swizzle(const vec4 v, int mask, vec4 dest);
/* ext */
@@ -250,79 +250,79 @@ 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(vec4 v, vec4 dest);
glmc_vec4_floor(const vec4 v, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_mods(vec4 v, float s, vec4 dest);
glmc_vec4_mods(const vec4 v, float s, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_steps(float edge, vec4 x, vec4 dest);
glmc_vec4_steps(float edge, const vec4 x, vec4 dest);
CGLM_EXPORT
void
glmc_vec4_stepr(vec4 edge, float x, vec4 dest);
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
@@ -330,11 +330,15 @@ 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
}
+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
+1
View File
@@ -43,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),
+4 -4
View File
@@ -8,8 +8,8 @@
/*
Functions:
CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float *farZ)
CGLM_INLINE float glm_persp_fovy(mat4 proj)
CGLM_INLINE float glm_persp_aspect(mat4 proj)
CGLM_INLINE float glm_persp_fovy(CGLM_CONST mat4 proj)
CGLM_INLINE float glm_persp_aspect(CGLM_CONST mat4 proj)
CGLM_INLINE void glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
*/
@@ -30,7 +30,7 @@
*/
CGLM_INLINE
float
glm_persp_fovy(mat4 proj) {
glm_persp_fovy(CGLM_CONST mat4 proj) {
return 2.0f * atanf(1.0f / proj[1][1]);
}
@@ -41,7 +41,7 @@ glm_persp_fovy(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect(mat4 proj) {
glm_persp_aspect(CGLM_CONST mat4 proj) {
return proj[1][1] / proj[0][0];
}
+65 -18
View File
@@ -16,31 +16,36 @@
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_infinite_lh_no(float fovy,
float aspect,
float nearZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_lh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_default_infinite_lh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
CGLM_INLINE void glm_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_INLINE void glm_persp_decompv_lh_no(mat4 proj,
CGLM_INLINE void glm_persp_decompv_lh_no(CGLM_CONST mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_x_lh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_y_lh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_z_lh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
CGLM_INLINE void glm_persp_decomp_far_lh_no(CGLM_CONST mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_no(CGLM_CONST mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_lh_no_h
@@ -116,7 +121,35 @@ glm_perspective_lh_no(float fovy,
dest[2][2] =-(nearZ + farZ) * fn;
dest[2][3] = 1.0f;
dest[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief set up infinite perspective projection matrix
* with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_infinite_lh_no(float fovy,
float aspect,
float nearZ,
mat4 dest) {
float f;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] = 1.0f;
dest[2][3] = 1.0f;
dest[3][2] =-2.0f * nearZ;
}
/*!
@@ -133,6 +166,20 @@ glm_perspective_default_lh_no(float aspect, mat4 dest) {
glm_perspective_lh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief set up infinite perspective projection matrix with default near
* and angle values with a left-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_infinite_lh_no(float aspect, mat4 dest) {
glm_perspective_infinite_lh_no(GLM_PI_4f, aspect, 0.01f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
@@ -192,7 +239,7 @@ glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
*/
CGLM_INLINE
void
glm_persp_decomp_lh_no(mat4 proj,
glm_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) {
@@ -231,7 +278,7 @@ glm_persp_decomp_lh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
glm_persp_decompv_lh_no(CGLM_CONST mat4 proj, float dest[6]) {
glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -248,7 +295,7 @@ glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x_lh_no(mat4 proj,
glm_persp_decomp_x_lh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
@@ -274,7 +321,7 @@ glm_persp_decomp_x_lh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y_lh_no(mat4 proj,
glm_persp_decomp_y_lh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
@@ -300,7 +347,7 @@ glm_persp_decomp_y_lh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z_lh_no(mat4 proj,
glm_persp_decomp_z_lh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
@@ -322,7 +369,7 @@ glm_persp_decomp_z_lh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
glm_persp_decomp_far_lh_no(CGLM_CONST mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
}
@@ -336,7 +383,7 @@ glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
*/
CGLM_INLINE
void
glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
glm_persp_decomp_near_lh_no(CGLM_CONST mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
}
@@ -351,7 +398,7 @@ glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
*/
CGLM_INLINE
void
glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes_lh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
@@ -376,7 +423,7 @@ glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
*/
CGLM_INLINE
float
glm_persp_fovy_lh_no(mat4 proj) {
glm_persp_fovy_lh_no(CGLM_CONST mat4 proj) {
return glm_persp_fovy(proj);
}
@@ -388,7 +435,7 @@ glm_persp_fovy_lh_no(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect_lh_no(mat4 proj) {
glm_persp_aspect_lh_no(CGLM_CONST mat4 proj) {
return glm_persp_aspect(proj);
}
+67 -19
View File
@@ -16,31 +16,36 @@
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_infinite_lh_zo(float fovy,
float aspect,
float nearZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_lh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_default_infinite_lh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
CGLM_INLINE void glm_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_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decompv_lh_zo(CGLM_CONST mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_x_lh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_y_lh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_z_lh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
CGLM_INLINE void glm_persp_decomp_far_lh_zo(CGLM_CONST mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_lh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_lh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_lh_zo_h
@@ -116,6 +121,35 @@ glm_perspective_lh_zo(float fovy,
dest[3][2] = nearZ * farZ * fn;
}
/*!
* @brief set up infinite perspective projection matrix
* with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_infinite_lh_zo(float fovy,
float aspect,
float nearZ,
mat4 dest) {
float f;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] = 1.0f;
dest[2][3] = 1.0f;
dest[3][2] =-nearZ;
}
/*!
* @brief extend perspective projection matrix's far distance with a
* left-hand coordinate system and a clip-space with depth values
@@ -144,7 +178,7 @@ glm_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a left-hand coordinate system and a
* and angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
@@ -156,6 +190,20 @@ glm_perspective_default_lh_zo(float aspect, mat4 dest) {
glm_perspective_lh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief set up infinite perspective projection matrix with default near
* and angle values with a left-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_infinite_lh_zo(float aspect, mat4 dest) {
glm_perspective_infinite_lh_zo(GLM_PI_4f, aspect, 0.01f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
@@ -188,7 +236,7 @@ glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
*/
CGLM_INLINE
void
glm_persp_decomp_lh_zo(mat4 proj,
glm_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) {
@@ -227,7 +275,7 @@ glm_persp_decomp_lh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
glm_persp_decompv_lh_zo(CGLM_CONST mat4 proj, float dest[6]) {
glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -242,7 +290,7 @@ glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x_lh_zo(mat4 proj,
glm_persp_decomp_x_lh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00;
@@ -267,7 +315,7 @@ glm_persp_decomp_x_lh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y_lh_zo(mat4 proj,
glm_persp_decomp_y_lh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11;
@@ -292,7 +340,7 @@ glm_persp_decomp_y_lh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z_lh_zo(mat4 proj,
glm_persp_decomp_z_lh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
@@ -314,7 +362,7 @@ glm_persp_decomp_z_lh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
glm_persp_decomp_far_lh_zo(CGLM_CONST mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
}
@@ -328,7 +376,7 @@ glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
*/
CGLM_INLINE
void
glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
glm_persp_decomp_near_lh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / -proj[2][2];
}
@@ -343,7 +391,7 @@ glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
*/
CGLM_INLINE
void
glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes_lh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
@@ -368,7 +416,7 @@ glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
*/
CGLM_INLINE
float
glm_persp_fovy_lh_zo(mat4 proj) {
glm_persp_fovy_lh_zo(CGLM_CONST mat4 proj) {
return glm_persp_fovy(proj);
}
@@ -380,7 +428,7 @@ glm_persp_fovy_lh_zo(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect_lh_zo(mat4 proj) {
glm_persp_aspect_lh_zo(CGLM_CONST mat4 proj) {
return glm_persp_aspect(proj);
}
+65 -18
View File
@@ -16,31 +16,36 @@
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_infinite_rh_no(float fovy,
float aspect,
float nearZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_rh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_default_infinite_rh_no(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
CGLM_INLINE void glm_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_INLINE void glm_persp_decompv_rh_no(mat4 proj,
CGLM_INLINE void glm_persp_decompv_rh_no(CGLM_CONST mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_x_rh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_y_rh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
CGLM_INLINE void glm_persp_decomp_z_rh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
CGLM_INLINE void glm_persp_decomp_far_rh_no(CGLM_CONST mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_no(CGLM_CONST mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_rh_no_h
@@ -116,7 +121,35 @@ glm_perspective_rh_no(float fovy,
dest[2][2] = (nearZ + farZ) * fn;
dest[2][3] =-1.0f;
dest[3][2] = 2.0f * nearZ * farZ * fn;
}
/*!
* @brief set up infinite perspective projection matrix
* with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_infinite_rh_no(float fovy,
float aspect,
float nearZ,
mat4 dest) {
float f;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] =-1.0f;
dest[2][3] =-1.0f;
dest[3][2] =-2.0f * nearZ;
}
/*!
@@ -133,6 +166,20 @@ glm_perspective_default_rh_no(float aspect, mat4 dest) {
glm_perspective_rh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief set up infinite perspective projection matrix with default near
* and angle values with a right-hand coordinate system and a
* clip-space of [-1, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_infinite_rh_no(float aspect, mat4 dest) {
glm_perspective_infinite_rh_no(GLM_PI_4f, aspect, 0.01f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
@@ -192,7 +239,7 @@ glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
*/
CGLM_INLINE
void
glm_persp_decomp_rh_no(mat4 proj,
glm_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) {
@@ -231,7 +278,7 @@ glm_persp_decomp_rh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
glm_persp_decompv_rh_no(CGLM_CONST mat4 proj, float dest[6]) {
glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -248,7 +295,7 @@ glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x_rh_no(mat4 proj,
glm_persp_decomp_x_rh_no(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
@@ -274,7 +321,7 @@ glm_persp_decomp_x_rh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y_rh_no(mat4 proj,
glm_persp_decomp_y_rh_no(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
@@ -300,7 +347,7 @@ glm_persp_decomp_y_rh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z_rh_no(mat4 proj,
glm_persp_decomp_z_rh_no(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
@@ -322,7 +369,7 @@ glm_persp_decomp_z_rh_no(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
glm_persp_decomp_far_rh_no(CGLM_CONST mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (proj[2][2] + 1.0f);
}
@@ -336,7 +383,7 @@ glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
*/
CGLM_INLINE
void
glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
glm_persp_decomp_near_rh_no(CGLM_CONST mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / (proj[2][2] - 1.0f);
}
@@ -351,7 +398,7 @@ glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
*/
CGLM_INLINE
void
glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes_rh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
@@ -376,7 +423,7 @@ glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
*/
CGLM_INLINE
float
glm_persp_fovy_rh_no(mat4 proj) {
glm_persp_fovy_rh_no(CGLM_CONST mat4 proj) {
return glm_persp_fovy(proj);
}
@@ -388,7 +435,7 @@ glm_persp_fovy_rh_no(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect_rh_no(mat4 proj) {
glm_persp_aspect_rh_no(CGLM_CONST mat4 proj) {
return glm_persp_aspect(proj);
}
+66 -18
View File
@@ -16,31 +16,36 @@
float nearZ,
float farZ,
mat4 dest)
CGLM_INLINE void glm_perspective_infinite_rh_zo(float fovy,
float aspect,
float nearZ,
mat4 dest)
CGLM_INLINE void glm_perspective_default_rh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_default_infinite_rh_zo(float aspect, mat4 dest)
CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
float deltaFar)
CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
CGLM_INLINE void glm_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_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decompv_rh_zo(CGLM_CONST mat4 proj,
float dest[6])
CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_x_rh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right)
CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_y_rh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom)
CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
CGLM_INLINE void glm_persp_decomp_z_rh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
CGLM_INLINE void glm_persp_decomp_far_rh_zo(CGLM_CONST mat4 proj, float * __restrict farZ)
CGLM_INLINE void glm_persp_decomp_near_rh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ)
CGLM_INLINE void glm_persp_sizes_rh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest)
*/
#ifndef cglm_persp_rh_zo_h
@@ -116,6 +121,35 @@ glm_perspective_rh_zo(float fovy,
dest[3][2] = nearZ * farZ * fn;
}
/*!
* @brief set up infinite perspective projection matrix
* with a right-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] fovy field of view angle
* @param[in] aspect aspect ratio ( width / height )
* @param[in] nearZ near clipping plane
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_infinite_rh_zo(float fovy,
float aspect,
float nearZ,
mat4 dest) {
float f;
glm_mat4_zero(dest);
f = 1.0f / tanf(fovy * 0.5f);
dest[0][0] = f / aspect;
dest[1][1] = f;
dest[2][2] =-1.0f;
dest[2][3] =-1.0f;
dest[3][2] =-nearZ;
}
/*!
* @brief set up perspective projection matrix with default near/far
* and angle values with a right-hand coordinate system and a
@@ -130,6 +164,20 @@ glm_perspective_default_rh_zo(float aspect, mat4 dest) {
glm_perspective_rh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
}
/*!
* @brief set up infinite perspective projection matrix with default near
* and angle values with a right-hand coordinate system and a
* clip-space of [0, 1].
*
* @param[in] aspect aspect ratio ( width / height )
* @param[out] dest result matrix
*/
CGLM_INLINE
void
glm_perspective_default_infinite_rh_zo(float aspect, mat4 dest) {
glm_perspective_infinite_rh_zo(GLM_PI_4f, aspect, 0.01f, dest);
}
/*!
* @brief resize perspective matrix by aspect ratio ( width / height )
* this makes very easy to resize proj matrix when window /viewport
@@ -188,7 +236,7 @@ glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
*/
CGLM_INLINE
void
glm_persp_decomp_rh_zo(mat4 proj,
glm_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) {
@@ -227,7 +275,7 @@ glm_persp_decomp_rh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
glm_persp_decompv_rh_zo(CGLM_CONST mat4 proj, float dest[6]) {
glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
&dest[3], &dest[4], &dest[5]);
}
@@ -242,7 +290,7 @@ glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
*/
CGLM_INLINE
void
glm_persp_decomp_x_rh_zo(mat4 proj,
glm_persp_decomp_x_rh_zo(CGLM_CONST mat4 proj,
float * __restrict left,
float * __restrict right) {
float nearZ, m20, m00, m22;
@@ -268,7 +316,7 @@ glm_persp_decomp_x_rh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_y_rh_zo(mat4 proj,
glm_persp_decomp_y_rh_zo(CGLM_CONST mat4 proj,
float * __restrict top,
float * __restrict bottom) {
float nearZ, m21, m11, m22;
@@ -294,7 +342,7 @@ glm_persp_decomp_y_rh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_z_rh_zo(mat4 proj,
glm_persp_decomp_z_rh_zo(CGLM_CONST mat4 proj,
float * __restrict nearZ,
float * __restrict farZ) {
float m32, m22;
@@ -316,7 +364,7 @@ glm_persp_decomp_z_rh_zo(mat4 proj,
*/
CGLM_INLINE
void
glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
glm_persp_decomp_far_rh_zo(CGLM_CONST mat4 proj, float * __restrict farZ) {
*farZ = proj[3][2] / (proj[2][2] + 1.0f);
}
@@ -330,7 +378,7 @@ glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
*/
CGLM_INLINE
void
glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
glm_persp_decomp_near_rh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ) {
*nearZ = proj[3][2] / proj[2][2];
}
@@ -345,7 +393,7 @@ glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
*/
CGLM_INLINE
void
glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
glm_persp_sizes_rh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
float t, a, nearZ, farZ;
t = 2.0f * tanf(fovy * 0.5f);
@@ -370,7 +418,7 @@ glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
*/
CGLM_INLINE
float
glm_persp_fovy_rh_zo(mat4 proj) {
glm_persp_fovy_rh_zo(CGLM_CONST mat4 proj) {
return glm_persp_fovy(proj);
}
@@ -382,7 +430,7 @@ glm_persp_fovy_rh_zo(mat4 proj) {
*/
CGLM_INLINE
float
glm_persp_aspect_rh_zo(mat4 proj) {
glm_persp_aspect_rh_zo(CGLM_CONST mat4 proj) {
return glm_persp_aspect(proj);
}
+3 -3
View File
@@ -41,7 +41,7 @@
*/
CGLM_INLINE
void
glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
glm_unprojecti_no(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest) {
vec4 v;
v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -68,7 +68,7 @@ glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
*/
CGLM_INLINE
void
glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
glm_project_no(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest) {
CGLM_ALIGN(16) vec4 pos4;
glm_vec4(pos, 1.0f, pos4);
@@ -97,7 +97,7 @@ glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
*/
CGLM_INLINE
float
glm_project_z_no(vec3 v, mat4 m) {
glm_project_z_no(const vec3 v, CGLM_CONST mat4 m) {
float z, w;
z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+3 -3
View File
@@ -41,7 +41,7 @@
*/
CGLM_INLINE
void
glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
glm_unprojecti_zo(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest) {
vec4 v;
v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
@@ -68,7 +68,7 @@ glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
*/
CGLM_INLINE
void
glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
glm_project_zo(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest) {
CGLM_ALIGN(16) vec4 pos4;
glm_vec4(pos, 1.0f, pos4);
@@ -99,7 +99,7 @@ glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
*/
CGLM_INLINE
float
glm_project_z_zo(vec3 v, mat4 m) {
glm_project_z_zo(const vec3 v, CGLM_CONST mat4 m) {
float z, w;
z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_lh_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 f, u, s;
glm_vec3_sub(center, eye, f);
@@ -72,7 +72,7 @@ glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 target;
glm_vec3_add(eye, dir, target);
glm_lookat_lh(eye, target, up, dest);
@@ -90,7 +90,7 @@ glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest) {
CGLM_ALIGN(8) vec3 up;
glm_vec3_ortho(dir, up);
glm_look_lh(eye, dir, up, dest);
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_lh_no_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
glm_lookat_lh(eye, center, up, dest);
}
@@ -51,7 +51,7 @@ glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glm_look_lh(eye, dir, up, dest);
}
@@ -67,7 +67,7 @@ glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest) {
glm_look_anyup_lh(eye, dir, dest);
}
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_lh_zo_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
glm_lookat_lh(eye, center, up, dest);
}
@@ -51,7 +51,7 @@ glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glm_look_lh(eye, dir, up, dest);
}
@@ -67,7 +67,7 @@ glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
glm_look_anyup_lh(eye, dir, dest);
}
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_rh_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 f, u, s;
glm_vec3_sub(center, eye, f);
@@ -72,7 +72,7 @@ glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
CGLM_ALIGN(8) vec3 target;
glm_vec3_add(eye, dir, target);
glm_lookat_rh(eye, target, up, dest);
@@ -90,7 +90,7 @@ glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest) {
CGLM_ALIGN(8) vec3 up;
glm_vec3_ortho(dir, up);
glm_look_rh(eye, dir, up, dest);
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_rh_no_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
glm_lookat_rh(eye, center, up, dest);
}
@@ -51,7 +51,7 @@ glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glm_look_rh(eye, dir, up, dest);
}
@@ -67,7 +67,7 @@ glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest) {
glm_look_anyup_rh(eye, dir, dest);
}
+6 -6
View File
@@ -7,9 +7,9 @@
/*
Functions:
CGLM_INLINE void glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest)
CGLM_INLINE void glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
CGLM_INLINE void glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest)
*/
#ifndef cglm_view_rh_zo_h
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
void
glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
glm_lookat_rh(eye, center, up, dest);
}
@@ -51,7 +51,7 @@ glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
glm_look_rh(eye, dir, up, dest);
}
@@ -67,7 +67,7 @@ glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
*/
CGLM_INLINE
void
glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
glm_look_anyup_rh(eye, dir, dest);
}
+1 -1
View File
@@ -18,7 +18,7 @@
*/
CGLM_INLINE
float
glm_luminance(vec3 rgb) {
glm_luminance(const vec3 rgb) {
vec3 l = {0.212671f, 0.715160f, 0.072169f};
return glm_dot(rgb, l);
}
+9
View File
@@ -8,6 +8,8 @@
#ifndef cglm_common_h
#define cglm_common_h
#define __cglm__ 1
#ifndef _USE_MATH_DEFINES
# define _USE_MATH_DEFINES /* for windows */
#endif
@@ -37,6 +39,13 @@
# define CGLM_INLINE static inline __attribute((always_inline))
#endif
/* const qualifier for multi-dimensional array parameters (matN, vecN[M]), only possible in C23 and C++ */
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L)
# define CGLM_CONST const
#else
# define CGLM_CONST
#endif
#if defined(__GNUC__) || defined(__clang__)
# define CGLM_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
# define CGLM_LIKELY(expr) __builtin_expect(!!(expr), 1)
+1 -1
View File
@@ -31,7 +31,7 @@
*/
CGLM_INLINE
float
glm_smc(float s, mat4 m, vec4 c) {
glm_smc(float s, CGLM_CONST mat4 m, const vec4 c) {
vec4 vs;
glm_vec4_cubic(s, vs);
return glm_mat4_rmc(vs, m, c);
+32 -51
View File
@@ -18,24 +18,24 @@
enum glm_euler_seq
Functions:
CGLM_INLINE glm_euler_seq glm_euler_order(int newOrder[3]);
CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_by_order(vec3 angles,
CGLM_INLINE glm_euler_seq glm_euler_order(const int ord[3]);
CGLM_INLINE void glm_euler_angles(CGLM_CONST mat4 m, vec3 dest);
CGLM_INLINE void glm_euler(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_xyz(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_zyx(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_zxy(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_xzy(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_yzx(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_yxz(const vec3 angles, mat4 dest);
CGLM_INLINE void glm_euler_by_order(const vec3 angles,
glm_euler_seq ord,
mat4 dest);
CGLM_INLINE void glm_euler_xyz_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_xzy_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yxz_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yzx_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zxy_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zyx_quat(vec3 angles, versor dest);
CGLM_INLINE void glm_euler_xyz_quat(const vec3 angles, versor dest);
CGLM_INLINE void glm_euler_xzy_quat(const vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yxz_quat(const vec3 angles, versor dest);
CGLM_INLINE void glm_euler_yzx_quat(const vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zxy_quat(const vec3 angles, versor dest);
CGLM_INLINE void glm_euler_zyx_quat(const vec3 angles, versor dest);
*/
#ifndef cglm_euler_h
@@ -83,28 +83,9 @@
# include "clipspace/view_rh_no.h"
#endif
/*!
* if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
* vector then you can convert it to this enum by doing this:
* @code
* glm_euler_seq order;
* order = orderVec[0] | orderVec[1] << 2 | orderVec[2] << 4;
* @endcode
* you may need to explicit cast if required
*/
typedef enum glm_euler_seq {
GLM_EULER_XYZ = 0 << 0 | 1 << 2 | 2 << 4,
GLM_EULER_XZY = 0 << 0 | 2 << 2 | 1 << 4,
GLM_EULER_YZX = 1 << 0 | 2 << 2 | 0 << 4,
GLM_EULER_YXZ = 1 << 0 | 0 << 2 | 2 << 4,
GLM_EULER_ZXY = 2 << 0 | 0 << 2 | 1 << 4,
GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
} glm_euler_seq;
CGLM_INLINE
glm_euler_seq
glm_euler_order(int ord[3]) {
glm_euler_order(const int ord[3]) {
return (glm_euler_seq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
}
@@ -116,7 +97,7 @@ glm_euler_order(int ord[3]) {
*/
CGLM_INLINE
void
glm_euler_angles(mat4 m, vec3 dest) {
glm_euler_angles(CGLM_CONST mat4 m, vec3 dest) {
float m00, m01, m10, m11, m20, m21, m22;
float thetaX, thetaY, thetaZ;
@@ -154,7 +135,7 @@ glm_euler_angles(mat4 m, vec3 dest) {
*/
CGLM_INLINE
void
glm_euler_xyz(vec3 angles, mat4 dest) {
glm_euler_xyz(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, czsx, cxcz, sysz;
@@ -192,7 +173,7 @@ glm_euler_xyz(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler(vec3 angles, mat4 dest) {
glm_euler(const vec3 angles, mat4 dest) {
glm_euler_xyz(angles, dest);
}
@@ -204,7 +185,7 @@ glm_euler(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_xzy(vec3 angles, mat4 dest) {
glm_euler_xzy(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, sxsy, cysx, cxsy, cxcy;
@@ -243,7 +224,7 @@ glm_euler_xzy(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_yxz(vec3 angles, mat4 dest) {
glm_euler_yxz(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, cycz, sysz, czsy, cysz;
@@ -282,7 +263,7 @@ glm_euler_yxz(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_yzx(vec3 angles, mat4 dest) {
glm_euler_yzx(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, sxsy, cxcy, cysx, cxsy;
@@ -321,7 +302,7 @@ glm_euler_yzx(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_zxy(vec3 angles, mat4 dest) {
glm_euler_zxy(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, cycz, sxsy, cysz;
@@ -359,7 +340,7 @@ glm_euler_zxy(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_zyx(vec3 angles, mat4 dest) {
glm_euler_zyx(const vec3 angles, mat4 dest) {
float cx, cy, cz,
sx, sy, sz, czsx, cxcz, sysz;
@@ -398,7 +379,7 @@ glm_euler_zyx(vec3 angles, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
glm_euler_by_order(const vec3 angles, glm_euler_seq ord, mat4 dest) {
float cx, cy, cz,
sx, sy, sz;
@@ -504,7 +485,7 @@ glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
*/
CGLM_INLINE
void
glm_euler_xyz_quat(vec3 angles, versor dest) {
glm_euler_xyz_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_xyz_quat_lh(angles, dest);
#else
@@ -521,7 +502,7 @@ glm_euler_xyz_quat(vec3 angles, versor dest) {
*/
CGLM_INLINE
void
glm_euler_xzy_quat(vec3 angles, versor dest) {
glm_euler_xzy_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_xzy_quat_lh(angles, dest);
#else
@@ -538,7 +519,7 @@ glm_euler_xzy_quat(vec3 angles, versor dest) {
*/
CGLM_INLINE
void
glm_euler_yxz_quat(vec3 angles, versor dest) {
glm_euler_yxz_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_yxz_quat_lh(angles, dest);
#else
@@ -555,7 +536,7 @@ glm_euler_yxz_quat(vec3 angles, versor dest) {
*/
CGLM_INLINE
void
glm_euler_yzx_quat(vec3 angles, versor dest) {
glm_euler_yzx_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_yzx_quat_lh(angles, dest);
#else
@@ -572,7 +553,7 @@ glm_euler_yzx_quat(vec3 angles, versor dest) {
*/
CGLM_INLINE
void
glm_euler_zxy_quat(vec3 angles, versor dest) {
glm_euler_zxy_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_zxy_quat_lh(angles, dest);
#else
@@ -589,7 +570,7 @@ glm_euler_zxy_quat(vec3 angles, versor dest) {
*/
CGLM_INLINE
void
glm_euler_zyx_quat(vec3 angles, versor dest) {
glm_euler_zyx_quat(const vec3 angles, versor dest) {
#ifdef CGLM_FORCE_LEFT_HANDED
glm_euler_zyx_quat_lh(angles, dest);
#else
+5 -5
View File
@@ -69,7 +69,7 @@
*/
CGLM_INLINE
void
glm_frustum_planes(mat4 m, vec4 dest[6]) {
glm_frustum_planes(CGLM_CONST mat4 m, vec4 dest[6]) {
mat4 t;
glm_mat4_transpose_to(m, t);
@@ -114,7 +114,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) {
*/
CGLM_INLINE
void
glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
glm_frustum_corners(CGLM_CONST mat4 invMat, vec4 dest[8]) {
vec4 c[8];
/* indexOf(nearCoord) = indexOf(farCoord) + 4 */
@@ -157,7 +157,7 @@ glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
*/
CGLM_INLINE
void
glm_frustum_center(vec4 corners[8], vec4 dest) {
glm_frustum_center(CGLM_CONST vec4 corners[8], vec4 dest) {
vec4 center;
glm_vec4_copy(corners[0], center);
@@ -182,7 +182,7 @@ glm_frustum_center(vec4 corners[8], vec4 dest) {
*/
CGLM_INLINE
void
glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
glm_frustum_box(CGLM_CONST vec4 corners[8], CGLM_CONST mat4 m, vec3 box[2]) {
vec4 v;
vec3 min, max;
int i;
@@ -220,7 +220,7 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
*/
CGLM_INLINE
void
glm_frustum_corners_at(vec4 corners[8],
glm_frustum_corners_at(CGLM_CONST vec4 corners[8],
float splitDist,
float farDist,
vec4 planeCorners[4]) {
Loaded 100 of 226 files, more files were not shown because too many files have changed in this diff. Show more