mirror of
https://github.com/recp/cglm.git
synced 2026-11-17 10:17:13 -06:00
Compare commits
291
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
b9b570b78d | ||
|
|
a34ce6bfc6 | ||
|
|
f32e015ec2 | ||
|
|
0357f113ab | ||
|
|
5335c31ddd | ||
|
|
5c65419434 | ||
|
|
44b6d7f332 | ||
|
|
75a19a54d0 | ||
|
|
888aca08d5 | ||
|
|
5390138d7f | ||
|
|
11d34be968 | ||
|
|
1e65d6b52e | ||
|
|
8ff4f978c3 | ||
|
|
d7b1e02778 | ||
|
|
38a60f4f85 | ||
|
|
81ec84493f | ||
|
|
58d8c15a12 | ||
|
|
bbd81a24d3 | ||
|
|
b7813d0edb | ||
|
|
1c260ceb7d | ||
|
|
49e4284773 | ||
|
|
46f46e5dcb | ||
|
|
a97af506ce | ||
|
|
454f032310 | ||
|
|
f0f05dadc5 | ||
|
|
83d5b2c973 | ||
|
|
7e1bdd0676 | ||
|
|
0dc17e5d47 | ||
|
|
d6c6b4c542 | ||
|
|
0356534c0c | ||
|
|
5ff0d80c85 | ||
|
|
1952042f2c | ||
|
|
3aad5823ca | ||
|
|
da957fa421 | ||
|
|
47e5d48749 | ||
|
|
a4602f2d5f | ||
|
|
6af4e0d565 | ||
|
|
a311dbfe4c | ||
|
|
a761088e15 | ||
|
|
a886d6e170 | ||
|
|
1a8b105ce6 | ||
|
|
ec5f8074c4 | ||
|
|
6f5fde8b52 | ||
|
|
9da4e78c2e | ||
|
|
27a3ddc928 | ||
|
|
5d530cd8e0 | ||
|
|
dde053a295 | ||
|
|
2128235d42 | ||
|
|
9fb418bcac | ||
|
|
5fde20d65c | ||
|
|
ebc65782f8 | ||
|
|
1bd04c819b | ||
|
|
8560da0e70 | ||
|
|
ed7a658637 | ||
|
|
bcc475e2b7 | ||
|
|
bdca98ba48 | ||
|
|
b33e29d50f | ||
|
|
4b3e9bb779 | ||
|
|
214842db27 | ||
|
|
60e4d6c188 | ||
|
|
5063d4b2b0 | ||
|
|
a16bc2ae4a | ||
|
|
b694c97204 | ||
|
|
4791fe3f24 | ||
|
|
b64067a94d | ||
|
|
43363e8c43 | ||
|
|
f3094cdc65 | ||
|
|
a7bd64952e | ||
|
|
4141298161 | ||
|
|
05979281ac | ||
|
|
4b3dcceb9d | ||
|
|
cfb8cd9447 | ||
|
|
8d01d1d135 | ||
|
|
c6caddc75e | ||
|
|
8b810c2280 | ||
|
|
fd3b21f5d7 | ||
|
|
c1ea9e7a69 | ||
|
|
44b5952ec3 | ||
|
|
6e2976d415 | ||
|
|
9a7f52202d | ||
|
|
e96b6a382d | ||
|
|
091c475422 | ||
|
|
144d1e7c29 | ||
|
|
643700c05e | ||
|
|
fb4eac2ee0 | ||
|
|
4d0a0a7025 | ||
|
|
a88d32c776 | ||
|
|
3bfd31af99 | ||
|
|
3ee809b9b3 | ||
|
|
8cdf496baf | ||
|
|
d42bff7773 | ||
|
|
365d43bef4 | ||
|
|
5770fdb336 | ||
|
|
042d84f058 | ||
|
|
70a1a946ee | ||
|
|
8ca1f19aa2 | ||
|
|
adb3ac18c0 | ||
|
|
441f2657ab | ||
|
|
9b660e8bd0 | ||
|
|
40a2aca7ec | ||
|
|
a48fa8be65 | ||
|
|
2f36faa70a | ||
|
|
36f59b7b6c | ||
|
|
f4993318d2 | ||
|
|
5672370e31 | ||
|
|
ae1b9a3982 | ||
|
|
a18d9c28e7 | ||
|
|
fc91f95bb2 | ||
|
|
39052494a2 | ||
|
|
488f782704 | ||
|
|
814c354337 | ||
|
|
1ad56f0e94 | ||
|
|
cc54ad3f92 | ||
|
|
3971ef8ef1 | ||
|
|
b4a3ed32d9 | ||
|
|
eb37a28ff5 | ||
|
|
925f9c1d1a | ||
|
|
9f74fd9597 | ||
|
|
99937807cf | ||
|
|
cc79b440e7 | ||
|
|
e161c4d0a7 | ||
|
|
e8c791e91e | ||
|
|
241b751d8c | ||
|
|
dfc9969f85 | ||
|
|
2b4aef2a29 | ||
|
|
fd0131734f | ||
|
|
9cfa40f423 | ||
|
|
b79347eb13 | ||
|
|
450d747867 | ||
|
|
26e174db46 | ||
|
|
e605c1d585 | ||
|
|
f815918a74 | ||
|
|
948642ff33 | ||
|
|
23c0f5f660 | ||
|
|
d3ad1645fc | ||
|
|
fa7bc07ae9 | ||
|
|
f32f18a373 | ||
|
|
082f1878dd | ||
|
|
4b0e7dadd6 | ||
|
|
b45bf1d571 | ||
|
|
8493a6c0d3 | ||
|
|
f50736aee7 | ||
|
|
6bc980f3d9 | ||
|
|
5cffcf74c4 | ||
|
|
fb469c779d | ||
|
|
8e69157052 | ||
|
|
6c0e3e9460 | ||
|
|
4ca0c536af | ||
|
|
9a1206f3f1 | ||
|
|
c2ebef3867 | ||
|
|
0e0eff71ce | ||
|
|
6620adcc16 | ||
|
|
a986a4d741 | ||
|
|
32e7d5cceb | ||
|
|
e14c730d5c | ||
|
|
fbf0014c82 | ||
|
|
0483362f5c | ||
|
|
35af0c04fe | ||
|
|
66d51e5771 | ||
|
|
5a3a16d9ad | ||
|
|
651ad8ca32 | ||
|
|
b1192c8638 | ||
|
|
eaf2d7314e | ||
|
|
200b0875ba | ||
|
|
9a25fab6f0 | ||
|
|
bfaf413a5d | ||
|
|
9594d0cc86 | ||
|
|
2890472a0b | ||
|
|
c48befca37 | ||
|
|
3c9eecd0be | ||
|
|
a9fee1b4d7 | ||
|
|
52753672bb | ||
|
|
68215526cf | ||
|
|
c27ef7e93b | ||
|
|
2ba561cc92 | ||
|
|
e66f2f3df4 | ||
|
|
967c9e0a09 | ||
|
|
1637d2cef1 | ||
|
|
2acdd1e4d0 | ||
|
|
606ecbceaa | ||
|
|
f1a72241b1 | ||
|
|
9085ed020a | ||
|
|
1377a94a17 | ||
|
|
a98c270eee | ||
|
|
83b67baa23 | ||
|
|
ae82a493f7 | ||
|
|
98ab6fcbe0 | ||
|
|
f0529646b2 | ||
|
|
585a999d79 | ||
|
|
5f241a2daf | ||
|
|
fbdc46b205 | ||
|
|
ae1bee7481 | ||
|
|
a0d8803f76 | ||
|
|
43c9f84c8c | ||
|
|
71a0dc6c35 | ||
|
|
5d34a04496 | ||
|
|
b54dff0124 | ||
|
|
fda5406ac0 | ||
|
|
f19dc13e39 | ||
|
|
f3f75a2727 | ||
|
|
c3e16a53f4 | ||
|
|
8a2fd9cda9 | ||
|
|
98f53c750d | ||
|
|
3e52d90ecb | ||
|
|
a4cd7e008d | ||
|
|
5861c37a93 | ||
|
|
aae82c1d4a | ||
|
|
7e51ed88e8 | ||
|
|
32a05a579b | ||
|
|
9b67866154 | ||
|
|
bab7d7bb12 | ||
|
|
5a207d84bb | ||
|
|
7783acae10 | ||
|
|
9d079d3cc3 | ||
|
|
054b2df004 | ||
|
|
93a2926a13 | ||
|
|
5484259328 | ||
|
|
e930737807 | ||
|
|
c12f318fab | ||
|
|
b0f35203f9 | ||
|
|
ad009d4e49 | ||
|
|
2f619cdd6f | ||
|
|
33e78ca2ad | ||
|
|
f82d570dec | ||
|
|
48839a38a1 | ||
|
|
d491108386 | ||
|
|
068f6951b3 | ||
|
|
ed731f991d | ||
|
|
07dc9520a4 | ||
|
|
be0defb7ac | ||
|
|
5b2c37f73b | ||
|
|
a93a9ef9a2 | ||
|
|
c5b2afc1c4 | ||
|
|
cd5ed1f4c4 | ||
|
|
eb3a51e591 | ||
|
|
44cd0ae4fd | ||
|
|
d75467f93f | ||
|
|
45c1beff51 | ||
|
|
14c567d9d9 | ||
|
|
480e1de048 | ||
|
|
de66f0a67f | ||
|
|
68bdec4510 | ||
|
|
62c0448e25 | ||
|
|
4f00ce0e52 | ||
|
|
a7845ffc44 | ||
|
|
bd941ed7fb | ||
|
|
87350f809b | ||
|
|
f50a7a7d00 | ||
|
|
b3308af146 | ||
|
|
a94f839d6d | ||
|
|
0ff0e8948f | ||
|
|
5b772d0eb4 | ||
|
|
c528ca1095 | ||
|
|
f0e09776d7 | ||
|
|
da4224ba32 | ||
|
|
1796cc5ce2 | ||
|
|
568634a79e | ||
|
|
c9c7941a72 | ||
|
|
4e929a81c2 | ||
|
|
1d09c41e18 | ||
|
|
d8e933b5b1 | ||
|
|
8b15fd51ba | ||
|
|
9ce0a3b625 | ||
|
|
00d2e8a4cf | ||
|
|
35a12ed033 | ||
|
|
9ad7dd3fbc | ||
|
|
28142b5912 | ||
|
|
f07d75c680 | ||
|
|
17d8b83a38 | ||
|
|
32a477ef07 | ||
|
|
e3ed9834a1 | ||
|
|
8396bbf0b3 | ||
|
|
013ac5dd07 | ||
|
|
a0e3d3766f | ||
|
|
fc7f0e13fd | ||
|
|
1340b5d512 | ||
|
|
85165dd3e3 | ||
|
|
3445f93fbc | ||
|
|
d2642eb206 | ||
|
|
929963c6eb | ||
|
|
25b33fab6b | ||
|
|
c9adbaabd7 | ||
|
|
b22e8230d0 | ||
|
|
54dfbc5a28 | ||
|
|
088c66029d | ||
|
|
2283c708c6 | ||
|
|
46864ba2f7 | ||
|
|
c5dcb93c92 | ||
|
|
050bc95264 | ||
|
|
8366e51b47 | ||
|
|
30b4ea80a9 |
No files matched your search
+492
-99
@@ -8,25 +8,74 @@ on:
|
||||
|
||||
jobs:
|
||||
build_autotools:
|
||||
name: Autotools / ${{ matrix.os }}
|
||||
name: Autotools / ${{ matrix.os }} / ${{ matrix.simd }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-12, macos-14, ubuntu-22.04]
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: ubuntu-22.04, simd: none }
|
||||
- { os: ubuntu-22.04, simd: sse }
|
||||
- { os: ubuntu-22.04, simd: sse2 }
|
||||
- { os: ubuntu-22.04, simd: sse3 }
|
||||
- { os: ubuntu-22.04, simd: sse4 }
|
||||
- { os: ubuntu-22.04, simd: avx }
|
||||
- { os: ubuntu-22.04, simd: avx2 }
|
||||
- { os: ubuntu-24.04, simd: none }
|
||||
- { os: ubuntu-24.04, simd: sse }
|
||||
- { os: ubuntu-24.04, simd: sse2 }
|
||||
- { os: ubuntu-24.04, simd: sse3 }
|
||||
- { os: ubuntu-24.04, simd: sse4 }
|
||||
- { os: ubuntu-24.04, simd: avx }
|
||||
- { os: ubuntu-24.04, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: macos-latest, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Autotools
|
||||
- name: Install Autotools on macOS
|
||||
if: runner.os == 'macOS'
|
||||
run: brew upgrade && brew install autoconf automake libtool
|
||||
run: brew install autoconf automake libtool
|
||||
|
||||
- name: Install Autotools on Ubuntu
|
||||
if: runner.os == 'Linux'
|
||||
run: sudo apt-get install -y autoconf automake libtool
|
||||
|
||||
- name: Set SIMD flags
|
||||
run: |
|
||||
if [ "${{ matrix.simd }}" == "none" ]; then
|
||||
export CFLAGS=""
|
||||
elif [ "${{ matrix.simd }}" == "sse" ]; then
|
||||
export CFLAGS="-msse"
|
||||
elif [ "${{ matrix.simd }}" == "sse2" ]; then
|
||||
export CFLAGS="-msse2"
|
||||
elif [ "${{ matrix.simd }}" == "sse3" ]; then
|
||||
export CFLAGS="-msse3"
|
||||
elif [ "${{ matrix.simd }}" == "sse4" ]; then
|
||||
export CFLAGS="-msse4"
|
||||
elif [ "${{ matrix.simd }}" == "avx" ]; then
|
||||
export CFLAGS="-mavx"
|
||||
elif [ "${{ matrix.simd }}" == "avx2" ]; then
|
||||
export CFLAGS="-mavx2"
|
||||
elif [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
export CFLAGS="-mfpu=neon"
|
||||
fi
|
||||
|
||||
- name: Generate Autotools
|
||||
run: ./autogen.sh
|
||||
|
||||
- name: Configure Autotools
|
||||
run: ./configure
|
||||
run: ./configure CFLAGS="$CFLAGS"
|
||||
|
||||
- name: Build
|
||||
run: make
|
||||
@@ -36,7 +85,7 @@ jobs:
|
||||
|
||||
build_cmake_ios:
|
||||
name: CMake / iOS
|
||||
runs-on: macos-14
|
||||
runs-on: macos-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
@@ -55,20 +104,151 @@ jobs:
|
||||
- name: Build
|
||||
run: cmake --build build
|
||||
|
||||
build_cmake_ubuntu:
|
||||
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }} / ${{ matrix.target.arch }} / ${{ matrix.target.simd }}
|
||||
runs-on: ${{ matrix.target.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
target:
|
||||
# GCC 11 builds
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx2 }
|
||||
# GCC 12 builds
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: avx2 }
|
||||
# GCC 13 builds
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: none }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx2 }
|
||||
# Clang 12 builds
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx2 }
|
||||
# Clang 15 builds
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: ubuntu-24.04-arm, cc: gcc-12, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, cc: gcc-13, arch: arm64, simd: neon }
|
||||
# ARMv7 builds
|
||||
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: neon }
|
||||
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: none }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Compiler and Ninja
|
||||
run: |
|
||||
sudo apt-get update
|
||||
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
|
||||
sudo apt-get install -y gcc-12-arm-linux-gnueabihf qemu-user ninja-build
|
||||
else
|
||||
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
|
||||
fi
|
||||
|
||||
- name: Set SIMD flags
|
||||
run: |
|
||||
if [ "${{ matrix.target.simd }}" == "none" ]; then
|
||||
export CFLAGS=""
|
||||
elif [ "${{ matrix.target.simd }}" == "sse" ]; then
|
||||
export CFLAGS="-msse"
|
||||
elif [ "${{ matrix.target.simd }}" == "sse2" ]; then
|
||||
export CFLAGS="-msse2"
|
||||
elif [ "${{ matrix.target.simd }}" == "sse3" ]; then
|
||||
export CFLAGS="-msse3"
|
||||
elif [ "${{ matrix.target.simd }}" == "sse4" ]; then
|
||||
export CFLAGS="-msse4"
|
||||
elif [ "${{ matrix.target.simd }}" == "avx" ]; then
|
||||
export CFLAGS="-mavx"
|
||||
elif [ "${{ matrix.target.simd }}" == "avx2" ]; then
|
||||
export CFLAGS="-mavx2"
|
||||
elif [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
export CFLAGS="-mfpu=neon"
|
||||
fi
|
||||
|
||||
- name: Configure CMake
|
||||
run: |
|
||||
if [ "${{ matrix.target.arch }}" == "armv7" ]; then
|
||||
# cross-compile ARMv7 and run its tests with QEMU
|
||||
neon_flags="-mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
if [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
neon_flags="-mfpu=neon -mfloat-abi=hard"
|
||||
fi
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
|
||||
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
|
||||
-DCMAKE_C_FLAGS="-march=armv7-a ${neon_flags}" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
elif [ "${{ matrix.target.arch }}" == "arm64" ]; then
|
||||
# Build for ARM64 (AArch64)
|
||||
neon_flags=""
|
||||
if [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
neon_flags="+simd" # Enable SIMD/NEON features on ARM64
|
||||
else
|
||||
neon_flags="+nosimd" # Explicitly disable SIMD/NEON
|
||||
fi
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
|
||||
-DCMAKE_C_FLAGS="$CFLAGS -march=armv8-a${neon_flags}" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
else
|
||||
# Normal build (x86/x64)
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
|
||||
-DCMAKE_C_FLAGS="$CFLAGS" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
fi
|
||||
|
||||
- name: Build
|
||||
run: cmake --build build
|
||||
|
||||
- name: Test
|
||||
working-directory: build
|
||||
run: |
|
||||
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
|
||||
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
|
||||
else
|
||||
./tests
|
||||
fi
|
||||
|
||||
build_cmake_macos:
|
||||
name: CMake / ${{ matrix.os }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-12, macos-14]
|
||||
os: [macos-26-intel, macos-latest]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Ninja
|
||||
if: runner.os == 'macOS'
|
||||
run: brew upgrade && brew install ninja
|
||||
run: brew install ninja
|
||||
|
||||
- name: Configure CMake
|
||||
run: |
|
||||
@@ -86,76 +266,264 @@ jobs:
|
||||
working-directory: build
|
||||
run: ./tests
|
||||
|
||||
build_cmake_ubuntu:
|
||||
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }}
|
||||
runs-on: ${{ matrix.target.os }}
|
||||
build_cmake:
|
||||
name: CMake / ${{ matrix.os }} / ${{ matrix.simd }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
target:
|
||||
- { os: ubuntu-20.04, cc: gcc-11 }
|
||||
- { os: ubuntu-22.04, cc: gcc-12 }
|
||||
- { os: ubuntu-22.04, cc: gcc-13 }
|
||||
- { os: ubuntu-20.04, cc: clang-12 }
|
||||
- { os: ubuntu-22.04, cc: clang-15 }
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: windows-2022, simd: none }
|
||||
- { os: windows-2022, simd: sse }
|
||||
- { os: windows-2022, simd: sse2 }
|
||||
- { os: windows-2022, simd: sse3 }
|
||||
- { os: windows-2022, simd: sse4 }
|
||||
- { os: windows-2022, simd: avx }
|
||||
- { os: windows-2022, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: macos-latest, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Compiler and Ninja
|
||||
run: |
|
||||
sudo apt-get update -y
|
||||
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
|
||||
- name: Install Ninja on macOS
|
||||
if: runner.os == 'macOS'
|
||||
run: brew install ninja
|
||||
|
||||
- name: Configure CMake
|
||||
- name: Set SIMD flags (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: |
|
||||
cmake \
|
||||
-B build \
|
||||
-GNinja \
|
||||
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
|
||||
-DCMAKE_BUILD_TYPE=Release \
|
||||
-DCGLM_STATIC=ON \
|
||||
-DCGLM_USE_TEST=ON
|
||||
$simd = "${{ matrix.simd }}"
|
||||
if ($simd -eq "none") {
|
||||
$env:CFLAGS = ""
|
||||
} elseif ($simd -eq "sse") {
|
||||
$env:CFLAGS = "-arch:SSE"
|
||||
} elseif ($simd -eq "sse2") {
|
||||
$env:CFLAGS = "-arch:SSE2"
|
||||
} elseif ($simd -eq "sse3") {
|
||||
$env:CFLAGS = "-arch:SSE3"
|
||||
} elseif ($simd -eq "sse4") {
|
||||
$env:CFLAGS = "-arch:SSE4"
|
||||
} elseif ($simd -eq "avx") {
|
||||
$env:CFLAGS = "-arch:AVX"
|
||||
} elseif ($simd -eq "avx2") {
|
||||
$env:CFLAGS = "-arch:AVX2"
|
||||
} elseif ($simd -eq "neon") {
|
||||
$env:CFLAGS = "-arch:NEON"
|
||||
}
|
||||
|
||||
- name: Set SIMD flags (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
if [ "${{ matrix.simd }}" == "none" ]; then
|
||||
export CFLAGS=""
|
||||
elif [ "${{ matrix.simd }}" == "sse" ]; then
|
||||
export CFLAGS="-msse"
|
||||
elif [ "${{ matrix.simd }}" == "sse2" ]; then
|
||||
export CFLAGS="-msse2"
|
||||
elif [ "${{ matrix.simd }}" == "sse3" ]; then
|
||||
export CFLAGS="-msse3"
|
||||
elif [ "${{ matrix.simd }}" == "sse4" ]; then
|
||||
export CFLAGS="-msse4"
|
||||
elif [ "${{ matrix.simd }}" == "avx" ]; then
|
||||
export CFLAGS="-mavx"
|
||||
elif [ "${{ matrix.simd }}" == "avx2" ]; then
|
||||
export CFLAGS="-mavx2"
|
||||
elif [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
export CFLAGS="-mfpu=neon"
|
||||
fi
|
||||
|
||||
- name: Configure CMake (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: cmake -B build -G "Visual Studio 17 2022" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="$env:CFLAGS" -DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Configure CMake (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
run: cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_FLAGS="$CFLAGS" -DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Build
|
||||
run: cmake --build build
|
||||
|
||||
- name: Test
|
||||
- name: Test (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
working-directory: build
|
||||
run: .\Debug\tests.exe
|
||||
|
||||
- name: Test (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
working-directory: build
|
||||
run: ./tests
|
||||
|
||||
build_cmake_windows:
|
||||
name: CMake / ${{ matrix.platform.name }}
|
||||
build_meson:
|
||||
name: Meson / ${{ matrix.os }} / ${{ matrix.simd }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: ubuntu-22.04, simd: none }
|
||||
- { os: ubuntu-22.04, simd: sse }
|
||||
- { os: ubuntu-22.04, simd: sse2 }
|
||||
- { os: ubuntu-22.04, simd: sse3 }
|
||||
- { os: ubuntu-22.04, simd: sse4 }
|
||||
- { os: ubuntu-22.04, simd: avx }
|
||||
- { os: ubuntu-22.04, simd: avx2 }
|
||||
- { os: ubuntu-24.04, simd: none }
|
||||
- { os: ubuntu-24.04, simd: sse }
|
||||
- { os: ubuntu-24.04, simd: sse2 }
|
||||
- { os: ubuntu-24.04, simd: sse3 }
|
||||
- { os: ubuntu-24.04, simd: sse4 }
|
||||
- { os: ubuntu-24.04, simd: avx }
|
||||
- { os: ubuntu-24.04, simd: avx2 }
|
||||
- { os: windows-2022, simd: none }
|
||||
- { os: windows-2022, simd: sse }
|
||||
- { os: windows-2022, simd: sse2 }
|
||||
- { os: windows-2022, simd: sse3 }
|
||||
- { os: windows-2022, simd: sse4 }
|
||||
- { os: windows-2022, simd: avx }
|
||||
- { os: windows-2022, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: macos-latest, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.12'
|
||||
cache: 'pip'
|
||||
|
||||
- name: Install meson
|
||||
run: python3 -m pip install meson ninja
|
||||
|
||||
- name: Set SIMD flags (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: |
|
||||
$simd = "${{ matrix.simd }}"
|
||||
if ($simd -eq "none") {
|
||||
$env:CFLAGS = ""
|
||||
} elseif ($simd -eq "sse") {
|
||||
$env:CFLAGS = "-arch:SSE"
|
||||
} elseif ($simd -eq "sse2") {
|
||||
$env:CFLAGS = "-arch:SSE2"
|
||||
} elseif ($simd -eq "sse3") {
|
||||
$env:CFLAGS = "-arch:SSE3"
|
||||
} elseif ($simd -eq "sse4") {
|
||||
$env:CFLAGS = "-arch:SSE4"
|
||||
} elseif ($simd -eq "avx") {
|
||||
$env:CFLAGS = "-arch:AVX"
|
||||
} elseif ($simd -eq "avx2") {
|
||||
$env:CFLAGS = "-arch:AVX2"
|
||||
} elseif ($simd -eq "neon") {
|
||||
$env:CFLAGS = "-arch:NEON"
|
||||
}
|
||||
|
||||
- name: Set SIMD flags (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
if [ "${{ matrix.simd }}" == "none" ]; then
|
||||
export CFLAGS=""
|
||||
elif [ "${{ matrix.simd }}" == "sse" ]; then
|
||||
export CFLAGS="-msse"
|
||||
elif [ "${{ matrix.simd }}" == "sse2" ]; then
|
||||
export CFLAGS="-msse2"
|
||||
elif [ "${{ matrix.simd }}" == "sse3" ]; then
|
||||
export CFLAGS="-msse3"
|
||||
elif [ "${{ matrix.simd }}" == "sse4" ]; then
|
||||
export CFLAGS="-msse4"
|
||||
elif [ "${{ matrix.simd }}" == "avx" ]; then
|
||||
export CFLAGS="-mavx"
|
||||
elif [ "${{ matrix.simd }}" == "avx2" ]; then
|
||||
export CFLAGS="-mavx2"
|
||||
elif [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
export CFLAGS="-mfpu=neon"
|
||||
fi
|
||||
|
||||
- name: Build with meson (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: |
|
||||
meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true -Dc_args="$env:CFLAGS"
|
||||
meson test -C build
|
||||
|
||||
- name: Build with meson (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
shell: bash
|
||||
run: |
|
||||
meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true -Dc_args="$CFLAGS"
|
||||
meson test -C build
|
||||
|
||||
build_msbuild:
|
||||
name: MSBuild / Windows / ${{ matrix.simd }}
|
||||
runs-on: windows-2022
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
platform:
|
||||
- { name: Windows (x64), flags: -A x64 }
|
||||
- { name: Windows (x86), flags: -A Win32 }
|
||||
- { name: Windows (clang-cl x64), flags: -T ClangCL -A x64 }
|
||||
- { name: Windows (clang-cl x86), flags: -T ClangCL -A Win32 }
|
||||
- { name: Windows (ARM), flags: -A ARM, skip_tests: true, skip_build: true } # This fails to build.
|
||||
- { name: Windows (ARM64), flags: -A ARM64, skip_tests: true }
|
||||
- { name: UWP (ARM64), flags: -A ARM64, -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0", skip_tests: true }
|
||||
- { name: UWP (x64), flags: -A x64 -DCMAKE_SYSTEM_NAME=WindowsStore -DCMAKE_SYSTEM_VERSION="10.0", skip_tests: true }
|
||||
simd: [none, sse, sse2, sse3, sse4, avx, avx2, neon]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Configure CMake
|
||||
run: cmake -B build `
|
||||
-DCGLM_STATIC=ON `
|
||||
-DCGLM_USE_TEST=ON `
|
||||
${{ matrix.platform.flags }}
|
||||
- uses: microsoft/setup-msbuild@v2
|
||||
|
||||
- name: Build
|
||||
if: ${{ !matrix.platform.skip_build }}
|
||||
run: cmake --build build --config Release --parallel
|
||||
- name: Retarget solution
|
||||
run: |
|
||||
vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
|
||||
$vsInstallPath = vswhere -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath
|
||||
& "$vsInstallPath\Common7\IDE\devenv.com" cglm.sln /Upgrade
|
||||
|
||||
- name: Test
|
||||
if: ${{ !matrix.platform.skip_tests }}
|
||||
working-directory: build
|
||||
run: .\Release\tests.exe
|
||||
- name: Set SIMD flags
|
||||
run: |
|
||||
if ($Env:SIMD -eq 'none') {
|
||||
$Env:CFLAGS=""
|
||||
} elseif ($Env:SIMD -eq 'sse') {
|
||||
$Env:CFLAGS="-arch:SSE"
|
||||
} elseif ($Env:SIMD -eq 'sse2') {
|
||||
$Env:CFLAGS="-arch:SSE2"
|
||||
} elseif ($Env:SIMD -eq 'sse3') {
|
||||
$Env:CFLAGS="-arch:SSE3"
|
||||
} elseif ($Env:SIMD -eq 'sse4') {
|
||||
$Env:CFLAGS="-arch:SSE4"
|
||||
} elseif ($Env:SIMD -eq 'avx') {
|
||||
$Env:CFLAGS="-arch:AVX"
|
||||
} elseif ($Env:SIMD -eq 'avx2') {
|
||||
$Env:CFLAGS="-arch:AVX2"
|
||||
} elseif ($Env:SIMD -eq 'neon') {
|
||||
$Env:CFLAGS="-arch:NEON"
|
||||
}
|
||||
|
||||
- name: Build (x86)
|
||||
working-directory: win
|
||||
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x86 /p:PlatformToolset=v143 /p:BuildInParallel=true /p:AdditionalOptions="$Env:CFLAGS"
|
||||
|
||||
- name: Build (x64)
|
||||
working-directory: win
|
||||
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x64 /p:PlatformToolset=v143 /p:BuildInParallel=true /p:AdditionalOptions="$Env:CFLAGS"
|
||||
|
||||
build_documentation:
|
||||
name: Documentation
|
||||
@@ -176,57 +544,13 @@ jobs:
|
||||
working-directory: docs
|
||||
run: sphinx-build -W --keep-going source build
|
||||
|
||||
build_meson:
|
||||
name: Meson / ${{ matrix.os }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-14, ubuntu-22.04]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-python@v5
|
||||
with:
|
||||
python-version: '3.12'
|
||||
cache: 'pip'
|
||||
|
||||
- name: Install meson
|
||||
run: python3 -m pip install meson ninja
|
||||
|
||||
- name: Build
|
||||
run: meson setup build -Dbuildtype=release --default-library=static -Dbuild_tests=true
|
||||
|
||||
- name: Test
|
||||
run: meson test -C build
|
||||
|
||||
build_msbuild:
|
||||
name: MSBuild / Windows
|
||||
runs-on: windows-2022
|
||||
|
||||
# This has no test yet.
|
||||
# It could also try building for ARM, ARM64, ARM64EC, but those fail currently.
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: microsoft/setup-msbuild@v2
|
||||
|
||||
- name: Build (x86)
|
||||
working-directory: win
|
||||
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x86 /p:BuildInParallel=true
|
||||
|
||||
- name: Build (x64)
|
||||
working-directory: win
|
||||
run: msbuild cglm.vcxproj /p:Configuration=Release /p:Platform=x64 /p:BuildInParallel=true
|
||||
|
||||
build_swift:
|
||||
name: Swift ${{ matrix.swift }} / ${{ matrix.os }}
|
||||
name: Swift / ${{ matrix.os }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-12, macos-14, ubuntu-22.04]
|
||||
os: [macos-26-intel, macos-latest, ubuntu-22.04]
|
||||
|
||||
# This has no test yet.
|
||||
steps:
|
||||
@@ -234,3 +558,72 @@ jobs:
|
||||
|
||||
- name: Build
|
||||
run: swift build
|
||||
|
||||
build_cmake_arm:
|
||||
name: CMake / ARM / ${{ matrix.os }} / ${{ matrix.arch }} / ${{ matrix.simd }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
# native ARM64 and cross-compiled ARMv7 builds
|
||||
- { os: ubuntu-24.04-arm, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, arch: armv7, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, arch: armv7, simd: none }
|
||||
# Windows ARM builds are cross-compiled on x64 runners
|
||||
- { os: windows-2022, arch: arm64, simd: neon }
|
||||
- { os: windows-2022, arch: arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Linux build tools
|
||||
if: runner.os == 'Linux'
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y ninja-build
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
sudo apt-get install -y gcc-arm-linux-gnueabihf qemu-user
|
||||
fi
|
||||
|
||||
- name: Configure CMake (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: |
|
||||
# ARM32 requires a Windows SDK older than 26100
|
||||
$platform = "${{ matrix.arch == 'arm64' && 'ARM64' || 'ARM,version=10.0.22621.0' }}"
|
||||
cmake -B build -G "Visual Studio 17 2022" -A $platform `
|
||||
-DCMAKE_BUILD_TYPE=Release `
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Configure CMake (Unix)
|
||||
if: runner.os == 'Linux'
|
||||
shell: bash
|
||||
run: |
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
flags="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
if [ "${{ matrix.simd }}" = "neon" ]; then
|
||||
flags="-march=armv7-a -mfpu=neon -mfloat-abi=hard"
|
||||
fi
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
|
||||
-DCMAKE_C_COMPILER=arm-linux-gnueabihf-gcc \
|
||||
-DCMAKE_C_FLAGS="$flags" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
else
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
fi
|
||||
|
||||
- name: Build
|
||||
run: cmake --build build --config Release
|
||||
|
||||
- name: Test (Linux)
|
||||
if: runner.os == 'Linux'
|
||||
working-directory: build
|
||||
run: |
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
|
||||
else
|
||||
./tests
|
||||
fi
|
||||
@@ -31,10 +31,22 @@ jobs:
|
||||
wget --no-verbose https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-${{matrix.wasi_sdk_version}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
|
||||
tar xf wasi-sdk-${{matrix.wasi_sdk_version}}.0-linux.tar.gz
|
||||
|
||||
# Building a wasm library without needing to define a main():
|
||||
# https://github.com/WebAssembly/wasi-sdk/issues/332
|
||||
- name: Modify CMakeLists.txt for WASI
|
||||
run: |
|
||||
cat >> CMakeLists.txt <<'EOF'
|
||||
if (CMAKE_SYSTEM_NAME STREQUAL "WASI")
|
||||
target_link_options(${PROJECT_NAME} PRIVATE -mexec-model=reactor)
|
||||
endif()
|
||||
EOF
|
||||
|
||||
- name: Configure CMake
|
||||
# Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
|
||||
# See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
|
||||
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}}" -DCMAKE_TOOLCHAIN_FILE=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0/share/cmake/wasi-sdk.cmake -DWASI_SDK_PREFIX=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0 -DCGLM_USE_TEST=ON
|
||||
# Below suppress <<'clock' is deprecated: WASI lacks process-associated clocks; ...>> warns:
|
||||
# -D_WASI_EMULATED_PROCESS_CLOCKS" -DCMAKE_EXE_LINKER_FLAGS="-lwasi-emulated-process-clocks
|
||||
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{matrix.BUILD_TYPE}} -DCMAKE_C_FLAGS="${{matrix.C_FLAGS}} -D_WASI_EMULATED_PROCESS_CLOCKS" -DCMAKE_EXE_LINKER_FLAGS="-lwasi-emulated-process-clocks" -DCMAKE_TOOLCHAIN_FILE=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0/share/cmake/wasi-sdk.cmake -DWASI_SDK_PREFIX=${{github.workspace}}/wasi-sdk-${{matrix.wasi_sdk_version}}.0 -DCGLM_STATIC=ON -DCGLM_SHARED=OFF -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Build
|
||||
# Build your program with the given configuration
|
||||
|
||||
@@ -29,9 +29,9 @@ jobs:
|
||||
run: |
|
||||
cat << EOF > ${{github.workspace}}/meson_cross_emsdk.txt
|
||||
[binaries]
|
||||
c = '`which emcc`'
|
||||
cpp = '`which em++`'
|
||||
ar = '`which emar`'
|
||||
c = '$(command -v emcc)'
|
||||
cpp = '$(command -v em++)'
|
||||
ar = '$(command -v emar)'
|
||||
|
||||
[built-in options]
|
||||
|
||||
@@ -50,7 +50,7 @@ jobs:
|
||||
EOF
|
||||
cat ${{github.workspace}}/meson_cross_emsdk.txt
|
||||
|
||||
- uses: actions/setup-python@v4
|
||||
- uses: actions/setup-python@v5
|
||||
|
||||
- name: Install meson
|
||||
run: |
|
||||
|
||||
+44
-2
@@ -18,11 +18,13 @@ packages.config
|
||||
/ar-lib
|
||||
/autom4te.cache/
|
||||
/compile
|
||||
/config.cache
|
||||
/config.guess
|
||||
/config.log
|
||||
/config.status
|
||||
/config.sub
|
||||
/configure
|
||||
/configure~
|
||||
/depcomp
|
||||
/install-sh
|
||||
/ltmain.sh
|
||||
@@ -32,6 +34,18 @@ packages.config
|
||||
.deps/
|
||||
*.[oa]
|
||||
*.l[oa]
|
||||
*.so
|
||||
*.so.*
|
||||
*.dylib
|
||||
*.dll
|
||||
*.exe
|
||||
*.pdb
|
||||
*.ilk
|
||||
*.exp
|
||||
*.dSYM/
|
||||
*.gcda
|
||||
*.gcno
|
||||
*.gcov
|
||||
Makefile
|
||||
Makefile.in
|
||||
m4/*.m4
|
||||
@@ -53,6 +67,7 @@ test/test_*
|
||||
*.log
|
||||
test/.libs/*
|
||||
test/tests
|
||||
/tests
|
||||
cglm_arm/*
|
||||
cglm_test_ios/*
|
||||
cglm_test_iosTests/*
|
||||
@@ -66,17 +81,44 @@ win/cglm_test_*
|
||||
*.lib
|
||||
*.tlog
|
||||
win/x64
|
||||
win/x85
|
||||
win/x86
|
||||
win/ARM/
|
||||
win/ARM64/
|
||||
win/ARM64EC/
|
||||
win/Debug
|
||||
cglm-test-ios*
|
||||
/cglm.pc
|
||||
test-driver
|
||||
[email protected]
|
||||
build/
|
||||
/builddir/
|
||||
build.ninja
|
||||
.ninja_deps
|
||||
.ninja_log
|
||||
conftest.dir/*
|
||||
confdefs.h
|
||||
*.xcuserdatad
|
||||
.idea
|
||||
cmake-build-debug
|
||||
cmake-build-*/
|
||||
CMakeCache.txt
|
||||
CMakeFiles/
|
||||
cmake_install.cmake
|
||||
CTestTestfile.cmake
|
||||
/DartConfiguration.tcl
|
||||
/Testing/
|
||||
/CMakeUserPresets.json
|
||||
/CPackConfig.cmake
|
||||
/CPackSourceConfig.cmake
|
||||
/_CPack_Packages/
|
||||
/cglmConfig.cmake
|
||||
/install_manifest*.txt
|
||||
/cglm-*.tar.*
|
||||
/cglm-*.zip
|
||||
*.o.tmp
|
||||
xcode/*
|
||||
.vscode
|
||||
.build
|
||||
*.swp
|
||||
.lastsession.vim
|
||||
.vimrc
|
||||
compile_commands.json
|
||||
Whitespace-only changes.
Vendored
-20
@@ -1,20 +0,0 @@
|
||||
{
|
||||
"configurations": [
|
||||
{
|
||||
"name": "Mac",
|
||||
"includePath": [
|
||||
"${workspaceFolder}/**"
|
||||
],
|
||||
"defines": [],
|
||||
"macFrameworkPath": [
|
||||
"/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks"
|
||||
],
|
||||
"compilerPath": "/usr/bin/clang",
|
||||
"cStandard": "c23",
|
||||
"cppStandard": "c++23",
|
||||
"intelliSenseMode": "macos-clang-arm64",
|
||||
"configurationProvider": "vector-of-bool.cmake-tools"
|
||||
}
|
||||
],
|
||||
"version": 4
|
||||
}
|
||||
Vendored
-31
@@ -1,31 +0,0 @@
|
||||
{
|
||||
"C_Cpp.default.configurationProvider": "vector-of-bool.cmake-tools",
|
||||
"restructuredtext.confPath": "${workspaceFolder}/docs/source",
|
||||
"workbench.colorTheme": "Default Light+ Experimental",
|
||||
"editor.fontSize": 14,
|
||||
"workbench.colorCustomizations": {
|
||||
"[Default Light*]": {
|
||||
"editor.background": "#fefefe",
|
||||
"sideBar.background": "#fefefe",
|
||||
"sideBar.foreground": "#343436",
|
||||
"sideBarTitle.foreground": "#343436",
|
||||
"sideBar.border": "#e2e2e4",
|
||||
"statusBar.background": "#fefefe",
|
||||
"titleBar.activeBackground": "#fefefe",
|
||||
"tab.activeBackground": "#f4fff4aa",
|
||||
"tab.inactiveBackground": "#fefefe",
|
||||
"activityBar.background": "#fefefe",
|
||||
"editorGroupHeader.tabsBackground": "#fefefe"
|
||||
},
|
||||
"[Default Dark*]": {
|
||||
"editor.background": "#1D1D25",
|
||||
"sideBar.background": "#1D1D25",
|
||||
"statusBar.background": "#1D1D25",
|
||||
"titleBar.activeBackground": "#1D1D25",
|
||||
"tab.activeBackground": "#2C2C3A",
|
||||
"tab.inactiveBackground": "#1D1D25",
|
||||
"activityBar.background": "#1D1D25",
|
||||
"editorGroupHeader.tabsBackground": "#1D1D25"
|
||||
}
|
||||
},
|
||||
}
|
||||
+199
@@ -0,0 +1,199 @@
|
||||
# Building the library
|
||||
|
||||
cglm can be built using one of the following build systems:
|
||||
|
||||
## CMake (All platforms)
|
||||
```bash
|
||||
$ mkdir build
|
||||
$ cd build
|
||||
$ cmake .. # [Optional] -DCGLM_SHARED=ON
|
||||
$ make
|
||||
$ sudo make install # [Optional]
|
||||
```
|
||||
|
||||
### Options with defaults
|
||||
|
||||
```CMake
|
||||
option(CGLM_SHARED "Shared build" ON)
|
||||
option(CGLM_STATIC "Static build" OFF)
|
||||
option(CGLM_USE_C99 "" OFF) # C11
|
||||
option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
|
||||
```
|
||||
|
||||
### Including in a CMake project
|
||||
|
||||
#### Header only
|
||||
|
||||
This requires no building or installation of cglm.
|
||||
|
||||
* Example:
|
||||
|
||||
``` cmake
|
||||
cmake_minimum_required(VERSION 3.8.2)
|
||||
|
||||
project(<Your Project Name>)
|
||||
|
||||
add_executable(${PROJECT_NAME} src/main.c)
|
||||
target_link_libraries(${LIBRARY_NAME} PRIVATE
|
||||
cglm_headers)
|
||||
|
||||
add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
|
||||
```
|
||||
|
||||
#### Linked
|
||||
|
||||
* Example:
|
||||
```cmake
|
||||
cmake_minimum_required(VERSION 3.8.2)
|
||||
|
||||
project(<Your Project Name>)
|
||||
|
||||
add_executable(${PROJECT_NAME} src/main.c)
|
||||
target_link_libraries(${LIBRARY_NAME} PRIVATE
|
||||
cglm)
|
||||
|
||||
add_subdirectory(external/cglm/)
|
||||
|
||||
# or you can use find_package to configure cglm
|
||||
```
|
||||
|
||||
### Using CMake to build for WebAssembly
|
||||
|
||||
Since math functions like `sinf` are used, this can not be targeted at `wasm32-unknown-unknown`, one of [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) or [emscripten](https://github.com/emscripten-core/emsdk) should be used.
|
||||
|
||||
Should note that shared build is not yet supported for WebAssembly.
|
||||
|
||||
For [simd128](https://github.com/WebAssembly/simd) support, add `-msimd128` to `CMAKE_C_FLAGS`, in command line `-DCMAKE_C_FLAGS="-msimd128"`.
|
||||
|
||||
For tests, the cmake option `CGLM_USE_TEST` would still work, you'll need a wasi runtime for running tests, see our [ci config file](.github/workflows/cmake-wasm.yml) for a detailed example.
|
||||
|
||||
#### WASI SDK
|
||||
|
||||
```bash
|
||||
$ cmake .. \
|
||||
-DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake \
|
||||
-DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
|
||||
```
|
||||
|
||||
Where `/path/to/wasi-sdk-19.0/` is the path to extracted [wasi sdk](https://github.com/WebAssembly/wasi-sdk).
|
||||
|
||||
In this case it would by default make a static build.
|
||||
|
||||
#### Emscripten
|
||||
|
||||
```bash
|
||||
$ emcmake cmake .. \
|
||||
-DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" \
|
||||
-DCGLM_STATIC=ON
|
||||
```
|
||||
|
||||
The `emcmake` here is the cmake wrapper for Emscripten from installed [emsdk](https://github.com/emscripten-core/emsdk).
|
||||
|
||||
## Meson (All platforms)
|
||||
|
||||
```bash
|
||||
$ meson build # [Optional] --default-library=static
|
||||
$ cd build
|
||||
$ ninja
|
||||
$ sudo ninja install # [Optional]
|
||||
```
|
||||
|
||||
### Options with Defaults:
|
||||
|
||||
```meson
|
||||
c_std=c11
|
||||
buildtype=release
|
||||
default_library=shared
|
||||
build_tests=true # to run tests: ninja test
|
||||
```
|
||||
### Including in a Meson project
|
||||
* Example:
|
||||
```meson
|
||||
# Clone cglm or create a cglm.wrap under <source_root>/subprojects
|
||||
project('name', 'c')
|
||||
|
||||
cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
|
||||
|
||||
executable('exe', 'src/main.c', dependencies : cglm_dep)
|
||||
```
|
||||
|
||||
## Swift (Swift Package Manager)
|
||||
|
||||
Currently only default build options are supported. Add **cglm** dependency to your project:
|
||||
|
||||
```swift
|
||||
...
|
||||
Package(
|
||||
...
|
||||
dependencies: [
|
||||
...
|
||||
.package(url: "https://github.com/recp/cglm", .branch("master")),
|
||||
]
|
||||
...
|
||||
)
|
||||
```
|
||||
|
||||
Now add **cgml** as a dependency to your target. Product choices are:
|
||||
- **cglm** for inlined version of the library which can be linked only statically
|
||||
- **cglmc** for a compiled version of the library with no linking limitation
|
||||
|
||||
```swift
|
||||
...
|
||||
.target(
|
||||
...
|
||||
dependencies: [
|
||||
...
|
||||
.product(name: "cglm", package: "cglm"),
|
||||
]
|
||||
...
|
||||
)
|
||||
...
|
||||
```
|
||||
|
||||
## Unix (Autotools)
|
||||
|
||||
```bash
|
||||
$ sh autogen.sh
|
||||
$ ./configure
|
||||
$ make
|
||||
$ make check # [Optional]
|
||||
$ [sudo] make install # [Optional]
|
||||
```
|
||||
|
||||
This will also install pkg-config files so you can use
|
||||
`pkg-config --cflags cglm` and `pkg-config --libs cglm` to retrieve compiler
|
||||
and linker flags.
|
||||
|
||||
The files will be installed into the given prefix (usually `/usr/local` by
|
||||
default on Linux), but your pkg-config may not be configured to actually check
|
||||
there. You can figure out where it's looking by running `pkg-config --variable
|
||||
pc_path pkg-config` and change the path the files are installed to via
|
||||
`./configure --with-pkgconfigdir=/your/path`. Alternatively, you can add the
|
||||
prefix path to your `PKG_CONFIG_PATH` environment variable.
|
||||
|
||||
## Windows (MSBuild)
|
||||
Windows related build file and project files are located in `win` folder,
|
||||
make sure you are inside `cglm/win` folder.
|
||||
Code Analysis is enabled, so it may take awhile to build.
|
||||
|
||||
```Powershell
|
||||
$ cd win
|
||||
$ .\build.bat
|
||||
```
|
||||
if `msbuild` won't work (because of multi version VS) then try to build with `devenv`:
|
||||
```Powershell
|
||||
$ devenv cglm.sln /Build Release
|
||||
```
|
||||
|
||||
### Running Tests on Windows
|
||||
|
||||
You can see test project in same visual studio solution file. It is enough to run that project to run tests.
|
||||
|
||||
# Building the documentation
|
||||
First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html
|
||||
then:
|
||||
```bash
|
||||
$ cd docs
|
||||
$ sphinx-build source build
|
||||
```
|
||||
it will compile docs into build folder, you can run index.html inside that function.
|
||||
+5
-3
@@ -1,6 +1,6 @@
|
||||
cmake_minimum_required(VERSION 3.8.2)
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
project(cglm
|
||||
VERSION 0.9.4
|
||||
VERSION 0.9.8
|
||||
HOMEPAGE_URL https://github.com/recp/cglm
|
||||
DESCRIPTION "OpenGL Mathematics (glm) for C"
|
||||
LANGUAGES C
|
||||
@@ -44,7 +44,7 @@ if(MSVC)
|
||||
endforeach(flag_var)
|
||||
endif()
|
||||
else()
|
||||
add_compile_options(-Wall)
|
||||
add_compile_options(-Wall -Wextra -Wpedantic -Wconversion)
|
||||
|
||||
if(NOT CMAKE_BUILD_TYPE MATCHES Debug)
|
||||
add_compile_options(-O3)
|
||||
@@ -93,8 +93,10 @@ add_library(${PROJECT_NAME}
|
||||
src/mat4x2.c
|
||||
src/mat4x3.c
|
||||
src/plane.c
|
||||
src/noise.c
|
||||
src/frustum.c
|
||||
src/box.c
|
||||
src/aabb2d.c
|
||||
src/project.c
|
||||
src/sphere.c
|
||||
src/ease.c
|
||||
|
||||
+10
-3
@@ -23,7 +23,7 @@ checkCFLAGS = $(AM_CFLAGS) \
|
||||
-std=gnu11 \
|
||||
-O3 \
|
||||
-DCGLM_DEFINE_PRINTS \
|
||||
-I./include
|
||||
-I$(srcdir)/include
|
||||
|
||||
check_PROGRAMS = test/tests
|
||||
TESTS = $(check_PROGRAMS)
|
||||
@@ -67,6 +67,7 @@ cglm_HEADERS = include/cglm/version.h \
|
||||
include/cglm/util.h \
|
||||
include/cglm/quat.h \
|
||||
include/cglm/plane.h \
|
||||
include/cglm/noise.h \
|
||||
include/cglm/frustum.h \
|
||||
include/cglm/box.h \
|
||||
include/cglm/aabb2d.h \
|
||||
@@ -78,7 +79,8 @@ cglm_HEADERS = include/cglm/version.h \
|
||||
include/cglm/bezier.h \
|
||||
include/cglm/applesimd.h \
|
||||
include/cglm/ray.h \
|
||||
include/cglm/affine2d.h
|
||||
include/cglm/affine2d.h \
|
||||
include/cglm/affine2d-post.h
|
||||
|
||||
cglm_clipspacedir=$(includedir)/cglm/clipspace
|
||||
cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
|
||||
@@ -120,6 +122,7 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
|
||||
include/cglm/call/quat.h \
|
||||
include/cglm/call/euler.h \
|
||||
include/cglm/call/plane.h \
|
||||
include/cglm/call/noise.h \
|
||||
include/cglm/call/frustum.h \
|
||||
include/cglm/call/box.h \
|
||||
include/cglm/call/project.h \
|
||||
@@ -129,7 +132,8 @@ cglm_call_HEADERS = include/cglm/call/mat4.h \
|
||||
include/cglm/call/bezier.h \
|
||||
include/cglm/call/ray.h \
|
||||
include/cglm/call/affine.h \
|
||||
include/cglm/call/affine2d.h
|
||||
include/cglm/call/affine2d.h \
|
||||
include/cglm/call/aabb2d.h
|
||||
|
||||
cglm_call_clipspacedir=$(includedir)/cglm/call/clipspace
|
||||
cglm_call_clipspace_HEADERS = include/cglm/call/clipspace/persp_lh_no.h \
|
||||
@@ -210,6 +214,7 @@ cglm_struct_HEADERS = include/cglm/struct/mat4.h \
|
||||
include/cglm/struct/quat.h \
|
||||
include/cglm/struct/euler.h \
|
||||
include/cglm/struct/plane.h \
|
||||
include/cglm/struct/noise.h \
|
||||
include/cglm/struct/frustum.h \
|
||||
include/cglm/struct/box.h \
|
||||
include/cglm/struct/aabb2d.h \
|
||||
@@ -261,6 +266,7 @@ libcglm_la_SOURCES=\
|
||||
src/mat4x2.c \
|
||||
src/mat4x3.c \
|
||||
src/plane.c \
|
||||
src/noise.c \
|
||||
src/frustum.c \
|
||||
src/box.c \
|
||||
src/project.c \
|
||||
@@ -270,6 +276,7 @@ libcglm_la_SOURCES=\
|
||||
src/bezier.c \
|
||||
src/ray.c \
|
||||
src/affine2d.c \
|
||||
src/aabb2d.c \
|
||||
src/clipspace/ortho_lh_no.c \
|
||||
src/clipspace/ortho_lh_zo.c \
|
||||
src/clipspace/ortho_rh_no.c \
|
||||
|
||||
@@ -39,73 +39,100 @@
|
||||
<br>
|
||||
|
||||
<p align="center">
|
||||
Highly optimized 2D|3D math library, also known as <b>OpenGL Mathematics (glm) for `C`</b>. <b>cglm</b> provides lot of utils to help math operations to be fast and quick to write. It is community friendly, feel free to bring any issues, bugs you faced.
|
||||
A highly optimized 2D|3D math library. Also known as OpenGL Mathematics (glm) for C. <b>cglm</b> provides fast and ergonomic math functions to ease graphics programming. It is community friendly – feel free to report any bugs and issues you face. <br>
|
||||
<i>If you're using C++, you might want to check out <a href="https://github.com/g-truc/glm">GLM</a></i>
|
||||
</p>
|
||||
|
||||
- Allocation-free
|
||||
- Header-only
|
||||
- SIMD-optimized
|
||||
- API-agnostic
|
||||
|
||||
---
|
||||
|
||||
#### 📚 Documentation
|
||||
### 📚 Documentation
|
||||
|
||||
Almost all functions (inline versions) and parameters are documented inside the corresponding headers. <br />
|
||||
Complete documentation: http://cglm.readthedocs.io
|
||||
All functions and their parameters are documented above their declaration inside their corresponding headers. <br />
|
||||
Alternatively, you can read the complete documentation [here](http://cglm.readthedocs.io).
|
||||
|
||||
#### 📌 Note for previous versions:
|
||||
### 🔨 Building
|
||||
|
||||
- _dup (duplicate) is changed to _copy. For instance `glm_vec_dup -> glm_vec3_copy`
|
||||
- OpenGL related functions are dropped to make this lib platform/third-party independent
|
||||
- make sure you have latest version and feel free to report bugs, troubles
|
||||
- **[bugfix]** euler angles was implemented in reverse order (extrinsic) it was fixed, now they are intrinsic. Make sure that
|
||||
you have the latest version
|
||||
- **[major change]** by starting v0.4.0, quaternions are stored as [x, y, z, w], it was [w, x, y, z] in v0.3.5 and earlier versions
|
||||
- **[api rename]** by starting v0.4.5, **glm_simd** functions are renamed to **glmm_**
|
||||
- **[new option]** by starting v0.4.5, you can disable alignment requirement, check options in docs.
|
||||
- **[major change]** by starting v0.5.0, vec3 functions use **glm_vec3_** namespace, it was **glm_vec_** until v0.5.0
|
||||
- **[major change]** by starting v0.5.1, built-in alignment is removed from **vec3** and **mat3** types
|
||||
- **[major change]** by starting v0.7.3, inline print functions are disabled in release/production mode to eliminate print costs (see options in documentation). Print output also improved. You can disable colors if you need (see documentation)
|
||||
- **[major change]** by starting v0.8.3, **cglm** supports alternative clipspace configurations e.g. Left Handed, Zero-to-One (_zo)... `CGLM_FORCE_DEPTH_ZERO_TO_ONE` and `CGLM_FORCE_LEFT_HANDED` is provided to control clipspace. You should be able to use **cglm** with Vulkan, DirectX and Metal now... see https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s
|
||||
cglm can be used in it's entirety as a header-only library simply by including `cglm/cglm.h`. If you wish to link against it instead, it can be built using one of the supported build systems. Detailed information about building on individual platforms and build systems along with the instructions for building the documentation can be found in [BUILDING.md](./BUILDING.md).
|
||||
|
||||
#### 📌 Note for C++ developers:
|
||||
If you are not aware of the original GLM library yet, you may also want to look at:
|
||||
https://github.com/g-truc/glm
|
||||
### ✅ Usage
|
||||
|
||||
#### 📌 Note for new comers (Important):
|
||||
- `vec4` and `mat4` variables must be aligned. (There will be unaligned versions later)
|
||||
- **in** and **[in, out]** parameters must be initialized (please). But **[out]** parameters not, initializing out param is also redundant
|
||||
- All functions are inline if you don't want to use pre-compiled versions with glmc_ prefix, you can ignore build process. Just include headers.
|
||||
- if your debugger takes you to cglm headers then make sure you are not trying to copy vec4 to vec3 or alig issues...
|
||||
- Welcome!
|
||||
#### Header-only
|
||||
|
||||
#### 📌 Note for experienced developers:
|
||||
- Since I'm testing this library in my projects, sometimes bugs occurs; finding that bug[s] and making improvements would be more easy with multiple developer/contributor and their projects or knowledge. Consider to make some tests if you suspect something is wrong and any feedbacks, contributions and bug reports are always welcome.
|
||||
Include the `cglm/cglm.h` header and use functions with the `glm_` prefix.
|
||||
```c
|
||||
#include "cglm/cglm.h"
|
||||
|
||||
#### 📌 Allocations?
|
||||
`cglm` doesn't alloc any memory on heap. So it doesn't provide any allocator. You should alloc memory for **out** parameters too if you pass pointer of memory location. Don't forget that **vec4** (also quat/**versor**) and **mat4** must be aligned (16-bytes), because *cglm* uses SIMD instructions to optimize most operations if available.
|
||||
// ...
|
||||
|
||||
#### 📌 Returning vector or matrix... ?
|
||||
vec2 vector;
|
||||
glm_vec2_zero(vector);
|
||||
```
|
||||
|
||||
**cglm** supports both *ARRAY API* and *STRUCT API*, so you can return structs if you utilize struct api (`glms_`).
|
||||
#### Struct API
|
||||
|
||||
<hr/>
|
||||
Include `cglm/struct.h` and use `glms_`.
|
||||
```c
|
||||
#include "cglm/struct.h"
|
||||
|
||||
<table>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>
|
||||
<div>Like some other graphics libraries (especially OpenGL) this library use Column-Major layout to keep matrices in the memory. </div>
|
||||
<div> </div>
|
||||
<div>In the future the library may support an option to use row-major layout, CURRENTLY if you need to row-major layout you will need to transpose it. </div>
|
||||
</td>
|
||||
<td>
|
||||
<img src="https://upload.wikimedia.org/wikipedia/commons/3/3f/Matrix_Columns.svg" width="300px" />
|
||||
</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
// ...
|
||||
|
||||
## 🚀 Features
|
||||
- **scalar** and **simd** (sse, avx, neon...) optimizations
|
||||
- option to use different clipspaces e.g. Left Handed, Zero-to-One... (currently right handed negative-one is default)
|
||||
- array api and struct api, you can use arrays or structs.
|
||||
vec2s vector = glms_vec2_zero();
|
||||
```
|
||||
|
||||
#### Linked
|
||||
|
||||
Include `cglm/call.h` and use `glmc_`.
|
||||
```c
|
||||
#include "cglm/call.h"
|
||||
|
||||
// ...
|
||||
|
||||
vec2 vector;
|
||||
glmc_vec2_zero(vector);
|
||||
```
|
||||
|
||||
### ❗ Alignment
|
||||
|
||||
While cglm by default aligns what's necessary, it is possible to disable this by defining `CGLM_ALL_UNALIGNED`. If you're targeting machines with any kind of SIMD support, make sure that all `vec4`, `mat4` and `mat2` arguments you pass to cglm functions are aligned to prevent unexpected crashes, alternatively use the unaligned versions if present.
|
||||
|
||||
### Struct API
|
||||
|
||||
The struct API works as follows (note the `s` suffix on types, `glms_` prefix on functions and `GLMS_` on constants):
|
||||
|
||||
```C
|
||||
#include <cglm/struct.h>
|
||||
|
||||
mat4s mat = GLMS_MAT4_IDENTITY_INIT;
|
||||
mat4s inv = glms_mat4_inv(mat);
|
||||
```
|
||||
|
||||
Struct functions generally take parameters *by copy* and *return* the results rather than taking pointers and writing to out parameters. That means your variables can usually be `const`, if you're into that.
|
||||
|
||||
The types used are actually unions that allow access to the same data in multiple ways. One of these involves anonymous structures available since C11. MSVC supports them in earlier versions out of the box and GCC/Clang as well if you enable `-fms-extensions`.
|
||||
To explicitly enable anonymous structures `#define CGLM_USE_ANONYMOUS_STRUCT 1`, or `0` to disable them.
|
||||
For backwards compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` to disable them. If you don't specify explicitly, cglm will attempt a best guess based on your compiler and C version.
|
||||
|
||||
### 📌 Migration notes:
|
||||
|
||||
- `_dup` (duplicate) functions were renamed to `_copy`. For instance: `glm_vec_dup` -> `glm_vec3_copy`.
|
||||
- OpenGL related functions were dropped to make cglm API independent.
|
||||
- **[bugfix]** Euler angles had been previously implemented in reverse order (extrinsic). This was fixed to be intrinsic.
|
||||
- **[major change]** Starting with **v0.4.0**, quaternions are stored as [x, y, z, w]. Previously it was [w, x, y, z].
|
||||
- **[api rename]** Starting with **v0.4.5**, `glm_simd_` functions are renamed to `glmm_`.
|
||||
- **[new option]** Starting with **v0.4.5**, alignment requirements can be disabled. Read more in the documentation.
|
||||
- **[major change]** Starting with **v0.5.0**, vec3 functions occupy the **glm_vec3_** namespace. This used to be **glm_vec_** in earlier versions.
|
||||
- **[major change]** Starting with **v0.5.1**, `vec3` and `mat3` types are not aligned by default.
|
||||
- **[major change]** Starting with **v0.7.3**, inline print functions are disabled by default in release mode to eliminate printing costs (see the Options chapter of the docs). <br> Colored output can be disabled (see documentation).
|
||||
- **[major change]** Starting with **v0.8.3**, alternate clipspace configurations are supported. The `CGLM_FORCE_DEPTH_ZERO_TO_ONE` and `CGLM_FORCE_LEFT_HANDED` flags are provided to control clip depth and handedness. This makes it easier to incorporate cglm into projects using graphics APIs such as Vulkan or Metal. See https://cglm.readthedocs.io/en/latest/opt.html#clipspace-option-s
|
||||
|
||||
### 🚀 Features
|
||||
|
||||
- scalar and simd (sse, avx, neon...) optimizations
|
||||
- general purpose matrix operations (mat4, mat3)
|
||||
- chain matrix multiplication (square only)
|
||||
- general purpose vector operations (cross, dot, rotate, proj, angle...)
|
||||
@@ -117,49 +144,35 @@ https://github.com/g-truc/glm
|
||||
- quaternions
|
||||
- euler angles / yaw-pitch-roll to matrix
|
||||
- extract euler angles
|
||||
- inline or pre-compiled function call
|
||||
- frustum (extract view frustum planes, corners...)
|
||||
- bounding box (AABB in Frustum (culling), crop, merge...)
|
||||
- bounding sphere
|
||||
- project, unproject
|
||||
- easing functions
|
||||
- curves
|
||||
- curve interpolation helpers (S*M*C, deCasteljau...)
|
||||
- helpers to convert cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
|
||||
- curve interpolation helpers (SMC, deCasteljau...)
|
||||
- comversion helpers from cglm types to Apple's simd library to pass cglm types to Metal GL without packing them on both sides
|
||||
- ray intersection helpers
|
||||
- and others...
|
||||
---
|
||||
|
||||
<hr />
|
||||
<table>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td>
|
||||
<div>Like other graphics libraries (especially OpenGL), cglm uses column-major layout to keep matrices in memory. </div>
|
||||
<div> </div>
|
||||
<div>While we might support row-major matrices in the future, currently if you need your matrices to be in row-major layout you have to transpose them. </div>
|
||||
</td>
|
||||
<td>
|
||||
<img src="https://upload.wikimedia.org/wikipedia/commons/3/3f/Matrix_Columns.svg" width="300px" />
|
||||
</td>
|
||||
</tr>
|
||||
</tbody>
|
||||
</table>
|
||||
|
||||
You have two options to call a function/operation: inline or library call (link)
|
||||
Almost all functions are marked inline (always_inline) so compiler will probably inline.
|
||||
To call pre-compiled versions, just use `glmc_` (c stands for 'call') instead of `glm_`.
|
||||
---
|
||||
|
||||
```C
|
||||
#include <cglm/cglm.h> /* for inline */
|
||||
#include <cglm/call.h> /* for library call (this also includes cglm.h) */
|
||||
|
||||
mat4 rot, trans, rt;
|
||||
/* ... */
|
||||
glm_mul(trans, rot, rt); /* inline */
|
||||
glmc_mul(trans, rot, rt); /* call from library */
|
||||
```
|
||||
Most of math functions are optimized manually with SSE2 if available, if not? Dont worry there are non-sse versions of all operations
|
||||
|
||||
You can pass matrices and vectors as array to functions rather than get address.
|
||||
|
||||
```C
|
||||
mat4 m = {
|
||||
1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1
|
||||
};
|
||||
|
||||
glm_translate(m, (vec3){1.0f, 0.0f, 0.0f});
|
||||
```
|
||||
|
||||
Library contains general purpose mat4 mul and inverse functions, and also contains some special forms (optimized) of these functions for affine transformations' matrices. If you want to multiply two affine transformation matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv
|
||||
cglm contains general purpose mat4 product and inverse functions but also provides optimized versions for affine transformations. If you want to multiply two affine transformation matrices you can use glm_mul instead of glm_mat4_mul and glm_inv_tr (ROT + TR) instead glm_mat4_inv.
|
||||
```C
|
||||
/* multiplication */
|
||||
mat4 modelMat;
|
||||
@@ -169,311 +182,9 @@ glm_mul(T, R, modelMat);
|
||||
glm_inv_tr(modelMat);
|
||||
```
|
||||
|
||||
### Struct API
|
||||
|
||||
The struct API works as follows, note the `s` suffix on types, the `glms_` prefix on functions and the `GLMS_` prefix on constants:
|
||||
|
||||
```C
|
||||
#include <cglm/struct.h>
|
||||
|
||||
mat4s mat = GLMS_MAT4_IDENTITY_INIT;
|
||||
mat4s inv = glms_mat4_inv(mat);
|
||||
```
|
||||
|
||||
Struct functions generally take their parameters as *values* and *return* their results, rather than taking pointers and writing to out parameters. That means your parameters can usually be `const`, if you're into that.
|
||||
|
||||
The types used are actually unions that allow access to the same data multiple ways. One of those ways involves anonymous structures, available since C11. MSVC also supports it for earlier C versions out of the box and GCC/Clang do if you enable `-fms-extensions`. To explicitly enable these anonymous structures, `#define CGLM_USE_ANONYMOUS_STRUCT` to `1`, to disable them, to `0`. For backward compatibility, you can also `#define CGLM_NO_ANONYMOUS_STRUCT` (value is irrelevant) to disable them. If you don't specify explicitly, cglm will do a best guess based on your compiler and the C version you're using.
|
||||
|
||||
## 🔨 Build
|
||||
|
||||
### CMake (All platforms)
|
||||
```bash
|
||||
$ mkdir build
|
||||
$ cd build
|
||||
$ cmake .. # [Optional] -DCGLM_SHARED=ON
|
||||
$ make
|
||||
$ sudo make install # [Optional]
|
||||
```
|
||||
|
||||
##### Cmake options with Defaults:
|
||||
|
||||
```CMake
|
||||
option(CGLM_SHARED "Shared build" ON)
|
||||
option(CGLM_STATIC "Static build" OFF)
|
||||
option(CGLM_USE_C99 "" OFF) # C11
|
||||
option(CGLM_USE_TEST "Enable Tests" OFF) # for make check - make test
|
||||
```
|
||||
|
||||
#### Use as header-only library with your CMake project
|
||||
|
||||
This requires no building or installation of cglm.
|
||||
|
||||
* Example:
|
||||
|
||||
``` cmake
|
||||
cmake_minimum_required(VERSION 3.8.2)
|
||||
|
||||
project(<Your Project Name>)
|
||||
|
||||
add_executable(${PROJECT_NAME} src/main.c)
|
||||
target_link_libraries(${LIBRARY_NAME} PRIVATE
|
||||
cglm_headers)
|
||||
|
||||
add_subdirectory(external/cglm/ EXCLUDE_FROM_ALL)
|
||||
```
|
||||
|
||||
#### Use with your CMake project
|
||||
* Example:
|
||||
```cmake
|
||||
cmake_minimum_required(VERSION 3.8.2)
|
||||
|
||||
project(<Your Project Name>)
|
||||
|
||||
add_executable(${PROJECT_NAME} src/main.c)
|
||||
target_link_libraries(${LIBRARY_NAME} PRIVATE
|
||||
cglm)
|
||||
|
||||
add_subdirectory(external/cglm/)
|
||||
|
||||
# or you can use find_package to configure cglm
|
||||
```
|
||||
|
||||
#### Use CMake to build for WebAssembly
|
||||
|
||||
Since math functions like `sinf` is used, this can not be targeted at `wasm32-unknown-unknown`, one of [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) or [emscripten](https://github.com/emscripten-core/emsdk) should be used.
|
||||
|
||||
Should note that shared build is not yet supported for WebAssembly.
|
||||
|
||||
For [simd128](https://github.com/WebAssembly/simd) support, add `-msimd128` to `CMAKE_C_FLAGS`, in command line `-DCMAKE_C_FLAGS="-msimd128"`.
|
||||
|
||||
For tests, the cmake option `CGLM_USE_TEST` would still work, you'll need a wasi runtime for running tests, see our [ci config file](.github/workflows/cmake-wasm.yml) for a detailed example.
|
||||
|
||||
##### Use CMake and WASI SDK to build for WebAssembly
|
||||
|
||||
```bash
|
||||
$ cmake .. \
|
||||
-DCMAKE_TOOLCHAIN_FILE=/path/to/wasi-sdk-19.0/share/cmake/wasi-sdk.cmake \
|
||||
-DWASI_SDK_PREFIX=/path/to/wasi-sdk-19.0
|
||||
```
|
||||
|
||||
Where `/path/to/wasi-sdk-19.0/` is the path to extracted [wasi sdk](https://github.com/WebAssembly/wasi-sdk).
|
||||
|
||||
In this case it would by default make a static build.
|
||||
|
||||
##### Use CMake and Emscripten SDK to build for WebAssembly
|
||||
|
||||
```bash
|
||||
$ emcmake cmake .. \
|
||||
-DCMAKE_EXE_LINKER_FLAGS="-s STANDALONE_WASM" \
|
||||
-DCGLM_STATIC=ON
|
||||
```
|
||||
|
||||
The `emcmake` here is the cmake wrapper for Emscripten from installed [emsdk](https://github.com/emscripten-core/emsdk).
|
||||
|
||||
### Meson (All platforms)
|
||||
|
||||
```bash
|
||||
$ meson build # [Optional] --default-library=static
|
||||
$ cd build
|
||||
$ ninja
|
||||
$ sudo ninja install # [Optional]
|
||||
```
|
||||
|
||||
##### Meson options with Defaults:
|
||||
|
||||
```meson
|
||||
c_std=c11
|
||||
buildtype=release
|
||||
default_library=shared
|
||||
build_tests=true # to run tests: ninja test
|
||||
```
|
||||
#### Use with your Meson project
|
||||
* Example:
|
||||
```meson
|
||||
# Clone cglm or create a cglm.wrap under <source_root>/subprojects
|
||||
project('name', 'c')
|
||||
|
||||
cglm_dep = dependency('cglm', fallback : 'cglm', 'cglm_dep')
|
||||
|
||||
executable('exe', 'src/main.c', dependencies : cglm_dep)
|
||||
```
|
||||
|
||||
### Swift (Swift Package Manager)
|
||||
|
||||
Currently only default build options are supported. Add **cglm** dependency to your project:
|
||||
|
||||
```swift
|
||||
...
|
||||
Package(
|
||||
...
|
||||
dependencies: [
|
||||
...
|
||||
.package(url: "https://github.com/recp/cglm", .branch("master")),
|
||||
]
|
||||
...
|
||||
)
|
||||
```
|
||||
|
||||
Now add **cgml** as a dependency to your target. Product choices are:
|
||||
- **cglm** for inlined version of the library which can be linked only statically
|
||||
- **cglmc** for a compiled version of the library with no linking limitation
|
||||
|
||||
```swift
|
||||
...
|
||||
.target(
|
||||
...
|
||||
dependencies: [
|
||||
...
|
||||
.product(name: "cglm", package: "cglm"),
|
||||
]
|
||||
...
|
||||
)
|
||||
...
|
||||
```
|
||||
|
||||
### Unix (Autotools)
|
||||
|
||||
```bash
|
||||
$ sh autogen.sh
|
||||
$ ./configure
|
||||
$ make
|
||||
$ make check # [Optional]
|
||||
$ [sudo] make install # [Optional]
|
||||
```
|
||||
|
||||
This will also install pkg-config files so you can use
|
||||
`pkg-config --cflags cglm` and `pkg-config --libs cglm` to retrieve compiler
|
||||
and linker flags.
|
||||
|
||||
The files will be installed into the given prefix (usually `/usr/local` by
|
||||
default on Linux), but your pkg-config may not be configured to actually check
|
||||
there. You can figure out where it's looking by running `pkg-config --variable
|
||||
pc_path pkg-config` and change the path the files are installed to via
|
||||
`./configure --with-pkgconfigdir=/your/path`. Alternatively, you can add the
|
||||
prefix path to your `PKG_CONFIG_PATH` environment variable.
|
||||
|
||||
### Windows (MSBuild)
|
||||
Windows related build file and project files are located in `win` folder,
|
||||
make sure you are inside `cglm/win` folder.
|
||||
Code Analysis is enabled, so it may take awhile to build.
|
||||
|
||||
```Powershell
|
||||
$ cd win
|
||||
$ .\build.bat
|
||||
```
|
||||
if `msbuild` won't work (because of multi version VS) then try to build with `devenv`:
|
||||
```Powershell
|
||||
$ devenv cglm.sln /Build Release
|
||||
```
|
||||
|
||||
#### Running Tests on Windows
|
||||
|
||||
You can see test project in same visual studio solution file. It is enough to run that project to run tests.
|
||||
|
||||
### Building Docs
|
||||
First you need install Sphinx: http://www.sphinx-doc.org/en/master/usage/installation.html
|
||||
then:
|
||||
```bash
|
||||
$ cd docs
|
||||
$ sphinx-build source build
|
||||
```
|
||||
it will compile docs into build folder, you can run index.html inside that function.
|
||||
|
||||
## How to use
|
||||
If you want to use the inline versions of functions, then include the main header
|
||||
```C
|
||||
#include <cglm/cglm.h>
|
||||
```
|
||||
the header will include all headers. Then call the func you want e.g. rotate vector by axis:
|
||||
```C
|
||||
glm_vec3_rotate(v1, glm_rad(45), (vec3){1.0f, 0.0f, 0.0f});
|
||||
```
|
||||
some functions are overloaded :) e.g you can normalize vector:
|
||||
```C
|
||||
glm_vec3_normalize(vec);
|
||||
```
|
||||
this will normalize vec and store normalized vector into `vec` but if you will store normalized vector into another vector do this:
|
||||
```C
|
||||
glm_vec3_normalize_to(vec, result);
|
||||
```
|
||||
like this function you may see `_to` postfix, this functions store results to another variables and save temp memory
|
||||
|
||||
|
||||
to call pre-compiled versions include header with `c` postfix, c means call. Pre-compiled versions are just wrappers.
|
||||
```C
|
||||
#include <cglm/call.h>
|
||||
```
|
||||
this header will include all headers with c postfix. You need to call functions with c posfix:
|
||||
```C
|
||||
glmc_vec3_normalize(vec);
|
||||
```
|
||||
|
||||
Function usage and parameters are documented inside related headers. You may see same parameter passed twice in some examples like this:
|
||||
```C
|
||||
glm_mat4_mul(m1, m2, m1);
|
||||
|
||||
/* or */
|
||||
glm_mat4_mul(m1, m1, m1);
|
||||
```
|
||||
the first two parameter are **[in]** and the last one is **[out]** parameter. After multiplying *m1* and *m2*, the result is stored in *m1*. This is why we send *m1* twice. You may store the result in a different matrix, this is just an example.
|
||||
|
||||
### Example: Computing MVP matrix
|
||||
|
||||
#### Option 1
|
||||
```C
|
||||
mat4 proj, view, model, mvp;
|
||||
|
||||
/* init proj, view and model ... */
|
||||
|
||||
glm_mat4_mul(proj, view, viewProj);
|
||||
glm_mat4_mul(viewProj, model, mvp);
|
||||
```
|
||||
|
||||
#### Option 2
|
||||
```C
|
||||
mat4 proj, view, model, mvp;
|
||||
|
||||
/* init proj, view and model ... */
|
||||
|
||||
glm_mat4_mulN((mat4 *[]){&proj, &view, &model}, 3, mvp);
|
||||
```
|
||||
|
||||
## How to send matrix to OpenGL
|
||||
|
||||
mat4 is array of vec4 and vec4 is array of floats. `glUniformMatrix4fv` functions accecpts `float*` as `value` (last param), so you can cast mat4 to float* or you can pass first column of matrix as beginning of memory of matrix:
|
||||
|
||||
Option 1: Send first column
|
||||
```C
|
||||
glUniformMatrix4fv(location, 1, GL_FALSE, matrix[0]);
|
||||
|
||||
/* array of matrices */
|
||||
glUniformMatrix4fv(location, 1, GL_FALSE, matrix[0][0]);
|
||||
```
|
||||
|
||||
Option 2: Cast matrix to pointer type (also valid for multiple dimensional arrays)
|
||||
```C
|
||||
glUniformMatrix4fv(location, 1, GL_FALSE, (float *)matrix);
|
||||
```
|
||||
|
||||
You can pass matrices the same way to other APIs e.g. Vulkan, DX...
|
||||
|
||||
## Notes
|
||||
|
||||
- This library does not support double type... yet
|
||||
- If headers are not working properly with your compiler, IDE please open an issue, because I'm using GCC and clang to test it maybe sometimes MSVC
|
||||
|
||||
**TODO:**
|
||||
- [ ] Unit tests (In Progress)
|
||||
- [ ] Unit tests for comparing cglm with glm results
|
||||
- [x] Add version info
|
||||
- [ ] Unaligned operations (e.g. `glm_umat4_mul`)
|
||||
- [x] Extra documentation
|
||||
- [x] ARM Neon Arch
|
||||
|
||||
|
||||
## Contributors
|
||||
|
||||
This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].
|
||||
This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)]
|
||||
<a href="https://github.com/recp/cglm/graphs/contributors"><img src="https://opencollective.com/cglm/contributors.svg?width=890&button=false" /></a>
|
||||
|
||||
|
||||
@@ -498,6 +209,3 @@ Support this project by becoming a sponsor. Your logo will show up here with a l
|
||||
<a href="https://opencollective.com/cglm/sponsor/7/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/7/avatar.svg"></a>
|
||||
<a href="https://opencollective.com/cglm/sponsor/8/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/8/avatar.svg"></a>
|
||||
<a href="https://opencollective.com/cglm/sponsor/9/website" target="_blank"><img src="https://opencollective.com/cglm/sponsor/9/avatar.svg"></a>
|
||||
|
||||
## License
|
||||
MIT. check the LICENSE file
|
||||
+1
-1
@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
|
||||
|
||||
# Description
|
||||
s.name = "cglm"
|
||||
s.version = "0.9.3"
|
||||
s.version = "0.9.8"
|
||||
s.summary = "📽 Highly Optimized Graphics Math (glm) for C"
|
||||
s.description = <<-DESC
|
||||
cglm is math library for graphics programming for C. See the documentation or README for all features.
|
||||
|
||||
+1
-1
@@ -7,7 +7,7 @@
|
||||
#*****************************************************************************
|
||||
|
||||
AC_PREREQ([2.69])
|
||||
AC_INIT([cglm], [0.9.4], [[email protected]])
|
||||
AC_INIT([cglm], [0.9.8], [[email protected]])
|
||||
AM_INIT_AUTOMAKE([-Wall foreign subdir-objects serial-tests])
|
||||
|
||||
# Don't use the default cflags (-O2 -g), we set ours manually in Makefile.am.
|
||||
|
||||
@@ -82,7 +82,7 @@ Functions documentation
|
||||
|
||||
| crops a bounding box with another one.
|
||||
|
||||
this could be useful for gettng a bbox which fits with view frustum and
|
||||
this could be useful for getting a bbox which fits with view frustum and
|
||||
object bounding boxes. In this case you crop view frustum box with objects
|
||||
box
|
||||
|
||||
@@ -95,7 +95,7 @@ Functions documentation
|
||||
|
||||
| crops a bounding box with another one.
|
||||
|
||||
this could be useful for gettng a bbox which fits with view frustum and
|
||||
this could be useful for getting a bbox which fits with view frustum and
|
||||
object bounding boxes. In this case you crop view frustum box with objects
|
||||
box
|
||||
|
||||
|
||||
@@ -117,7 +117,7 @@ Functions documentation
|
||||
If you need to rotate object around itself e.g. center of object or at
|
||||
some point [of object] then `glm_rotate_at()` would be better choice to do so.
|
||||
|
||||
Even if object's model transform is identiy, rotation may not be around
|
||||
Even if object's model transform is identity, rotation may not be around
|
||||
center of object if object does not lay out at ORIGIN perfectly.
|
||||
|
||||
Using `glm_rotate_at()` with center of bounding shape ( AABB, Sphere ... )
|
||||
|
||||
@@ -66,6 +66,7 @@ Follow the :doc:`build` documentation for this
|
||||
ivec4
|
||||
color
|
||||
plane
|
||||
noise
|
||||
project
|
||||
util
|
||||
io
|
||||
|
||||
@@ -9,7 +9,7 @@ By default struct api adds `s` suffix to every type name e.g. vec3s, mat4s, vers
|
||||
Also struct api `s` suffix to namespace e.g. `glms_vec3_add`, `glms_mat4_mul` etc.
|
||||
|
||||
By starting v0.9.0, struct api namespace is configurable. We can omit **glms_** namespace or
|
||||
even change it with custom name to move existing api integrations to **cglm** more easliy...
|
||||
even change it with custom name to move existing api integrations to **cglm** more easily...
|
||||
We can also add **s** to function names if we want e.g. `glms_vec3_add()` -> `vec3_add()` or `vec3s_add()`.
|
||||
|
||||
By including **cglm/struct.h** header you will include all struct api. It will also include **cglm/cglm.h** too.
|
||||
|
||||
+2
-2
@@ -62,7 +62,7 @@ Functions documentation
|
||||
|
||||
| crops a bounding box with another one.
|
||||
|
||||
this could be useful for gettng a bbox which fits with view frustum and
|
||||
this could be useful for getting a bbox which fits with view frustum and
|
||||
object bounding boxes. In this case you crop view frustum box with objects
|
||||
box
|
||||
|
||||
@@ -75,7 +75,7 @@ Functions documentation
|
||||
|
||||
| crops a bounding box with another one.
|
||||
|
||||
this could be useful for gettng a bbox which fits with view frustum and
|
||||
this could be useful for getting a bbox which fits with view frustum and
|
||||
object bounding boxes. In this case you crop view frustum box with objects
|
||||
box
|
||||
|
||||
|
||||
@@ -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.
|
||||
@@ -36,8 +36,10 @@ Functions:
|
||||
#. :c:func:`glm_ortho_default`
|
||||
#. :c:func:`glm_ortho_default_s`
|
||||
#. :c:func:`glm_perspective`
|
||||
#. :c:func:`glm_perspective_infinite`
|
||||
#. :c:func:`glm_persp_move_far`
|
||||
#. :c:func:`glm_perspective_default`
|
||||
#. :c:func:`glm_perspective_default_infinite`
|
||||
#. :c:func:`glm_perspective_resize`
|
||||
#. :c:func:`glm_lookat`
|
||||
#. :c:func:`glm_look`
|
||||
@@ -146,6 +148,21 @@ Functions documentation
|
||||
| *[in]* **farVal** far clipping planes
|
||||
| *[out]* **dest** result matrix
|
||||
|
||||
.. c:function:: void glm_perspective_infinite(float fovy, float aspect, float nearZ, mat4 dest)
|
||||
|
||||
| set up perspective projection matrix with infinite far plane
|
||||
|
||||
The far clipping plane is pushed to infinity. This can improve depth
|
||||
precision for distant objects and is required by some rendering techniques
|
||||
such as shadow volumes. Dispatches to the appropriate clipspace variant
|
||||
based on compile-time configuration (LH/RH, NO/ZO).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **fovy** field of view angle (in radians)
|
||||
| *[in]* **aspect** aspect ratio ( width / height )
|
||||
| *[in]* **nearZ** near clipping plane
|
||||
| *[out]* **dest** result matrix
|
||||
|
||||
.. c:function:: void glm_persp_move_far(mat4 proj, float deltaFar)
|
||||
|
||||
| extend perspective projection matrix's far distance
|
||||
@@ -165,6 +182,20 @@ Functions documentation
|
||||
| *[in]* **aspect** aspect aspect ratio ( width / height )
|
||||
| *[out]* **dest** result matrix
|
||||
|
||||
.. c:function:: void glm_perspective_default_infinite(float aspect, mat4 dest)
|
||||
|
||||
| set up infinite perspective projection matrix with default near
|
||||
and angle values
|
||||
|
||||
Equivalent to calling :c:func:`glm_perspective_infinite` with
|
||||
``fovy = GLM_PI_4`` (45°) and ``nearZ = 0.01``. Useful as a
|
||||
quick drop-in when you need an infinite projection without tuning
|
||||
the individual parameters.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **aspect** aspect ratio ( width / height )
|
||||
| *[out]* **dest** result matrix
|
||||
|
||||
.. c:function:: void glm_perspective_resize(float aspect, mat4 proj)
|
||||
|
||||
| resize perspective matrix by aspect ratio ( width / height )
|
||||
|
||||
+7
-3
@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
|
||||
# built documents.
|
||||
#
|
||||
# The short X.Y version.
|
||||
version = u'0.9.4'
|
||||
version = u'0.9.8'
|
||||
# The full version, including alpha/beta/rc tags.
|
||||
release = u'0.9.4'
|
||||
release = u'0.9.8'
|
||||
|
||||
# The language for content autogenerated by Sphinx. Refer to documentation
|
||||
# for a list of supported languages.
|
||||
@@ -91,6 +91,7 @@ todo_include_todos = False
|
||||
# a list of builtin themes.
|
||||
#
|
||||
html_theme = 'sphinx_rtd_theme'
|
||||
pygments_style = 'monokai'
|
||||
|
||||
# Theme options are theme-specific and customize the look and feel of a theme
|
||||
# further. For a list of options available for each theme, see the
|
||||
@@ -111,8 +112,11 @@ html_theme_options = {
|
||||
# Add any paths that contain custom static files (such as style sheets) here,
|
||||
# relative to this directory. They are copied after the builtin static files,
|
||||
# so a file named "default.css" will overwrite the builtin "default.css".
|
||||
# html_static_path = ['_static']
|
||||
html_static_path = ['sphinx-static']
|
||||
|
||||
# Add customm CSS and JS files
|
||||
html_css_files = ['theme_overrides.css']
|
||||
html_js_files = []
|
||||
|
||||
# -- Options for HTMLHelp output ------------------------------------------
|
||||
|
||||
|
||||
+835
-155
File diff suppressed because it is too large.
Load diff
+144
-29
@@ -23,68 +23,183 @@ Functions:
|
||||
#. :c:func:`glm_mat2x3_transpose`
|
||||
#. :c:func:`glm_mat2x3_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat2x3
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "m00", "m10"
|
||||
"row 2", "m01", "m11"
|
||||
"row 3", "m02", "m12"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat2x3_copy(mat2x3 mat, mat2x3 dest)
|
||||
.. c:function:: void glm_mat2x3_copy(mat2x3 src, mat2x3 dest)
|
||||
|
||||
copy mat2x3 to another one (dest).
|
||||
Copy mat2x3 (src) to mat2x3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat2x3 (left)
|
||||
| *[out]* **dest** destination (result, mat2x3)
|
||||
|
||||
.. c:function:: void glm_mat2x3_zero(mat2x3 mat)
|
||||
.. csv-table:: mat2x3 **(src)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
|
||||
.. csv-table:: mat2x3 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10"
|
||||
"row 2", "b01 = a01", "b11 = a11"
|
||||
"row 3", "b02 = a02", "b12 = a12"
|
||||
|
||||
.. c:function:: void glm_mat2x3_zero(mat2x3 m)
|
||||
|
||||
Zero out the mat2x3 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat2x3 (src, dest)
|
||||
|
||||
.. csv-table:: mat2x3 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "0.00", "2.00"
|
||||
"row 2", "5.00", "4.00"
|
||||
"row 3", "7.00", "6.00"
|
||||
|
||||
.. csv-table:: mat2x3 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00"
|
||||
"row 3", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat2x3_make(const float * __restrict src, mat2x3 dest)
|
||||
|
||||
Create mat2x3 matrix from pointer
|
||||
Create mat2x3 (dest) from pointer (src).
|
||||
|
||||
.. note:: **@src** must contain at least 6 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix2x3
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat2x3)
|
||||
|
||||
.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest)
|
||||
.. csv-table:: float array (1x6) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
|
||||
.. csv-table:: mat2x3 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "v0", "v3"
|
||||
"row 2", "v1", "v4"
|
||||
"row 3", "v2", "v5"
|
||||
|
||||
.. c:function:: void glm_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest)
|
||||
|
||||
Multiply mat2x3 (m1) by mat3x2 (m2) and store in mat3 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat2x3_mul(mat2x3, mat3x2, mat2);
|
||||
glm_mat2x3_mul(mat2x3, mat3x2, mat3);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat2x3)
|
||||
| *[in]* **m2** right matrix (mat3x2)
|
||||
| *[out]* **dest** destination matrix (mat2)
|
||||
| *[in]* **m1** mat2x3 (left)
|
||||
| *[in]* **m2** mat3x2 (right)
|
||||
| *[out]* **dest** destination (result, mat3)
|
||||
|
||||
.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest)
|
||||
.. csv-table:: mat2x3 **(m1)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
multiply mat2x3 with vec3 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
|
||||
.. csv-table:: mat3x2 **(m2)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00", "b10", "b20"
|
||||
"row 2", "b01", "b11", "b21"
|
||||
|
||||
.. csv-table:: mat3 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21"
|
||||
"row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21"
|
||||
"row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21"
|
||||
|
||||
.. c:function:: void glm_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest)
|
||||
|
||||
Multiply mat2x3 (m) by vec2 (v) and store in vec3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat2x3 (left)
|
||||
| *[in]* **v** vec3 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat2x3 (left)
|
||||
| *[in]* **v** vec2 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat2x3_transpose(mat2x3 m, mat3x2 dest)
|
||||
.. csv-table:: mat2x3 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10"
|
||||
"row 2", "m01", "m11"
|
||||
"row 3", "m02", "m12"
|
||||
|
||||
.. csv-table:: column vec2 (1x2) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
|
||||
.. csv-table:: column vec3 (1x3) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1"
|
||||
"row 2", "m01 * v0 + m11 * v1"
|
||||
"row 3", "m02 * v0 + m12 * v1"
|
||||
|
||||
.. c:function:: void glm_mat2x3_transpose(mat2x3 src, mat3x2 dest)
|
||||
|
||||
Transpose mat2x3 (src) and store in mat3x2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat2x3 (left)
|
||||
| *[out]* **dest** destination (result, mat3x2)
|
||||
|
||||
.. c:function:: void glm_mat2x3_scale(mat2x3 m, float s)
|
||||
.. csv-table:: mat2x3 **(src)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
multiply matrix with scalar
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
|
||||
.. csv-table:: mat3x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01", "b20 = a02"
|
||||
"row 2", "b01 = a10", "b11 = a11", "b21 = a12"
|
||||
|
||||
.. c:function:: void glm_mat2x3_scale(mat2x3 m, float s)
|
||||
|
||||
Multiply mat2x3 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat2x3 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat2x3 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s"
|
||||
"row 3", "m02 = m02 * s", "m12 = m12 * s"
|
||||
+157
-28
@@ -23,68 +23,197 @@ Functions:
|
||||
#. :c:func:`glm_mat2x4_transpose`
|
||||
#. :c:func:`glm_mat2x4_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat2x4
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "m00", "m10"
|
||||
"row 2", "m01", "m11"
|
||||
"row 3", "m02", "m12"
|
||||
"row 4", "m03", "m13"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat2x4_copy(mat2x4 mat, mat2x4 dest)
|
||||
.. c:function:: void glm_mat2x4_copy(mat2x4 src, mat2x4 dest)
|
||||
|
||||
copy mat2x4 to another one (dest).
|
||||
Copy mat2x4 (src) to mat2x4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat2x4 (left)
|
||||
| *[out]* **dest** destination (result, mat2x4)
|
||||
|
||||
.. c:function:: void glm_mat2x4_zero(mat2x4 mat)
|
||||
.. csv-table:: mat2x4 **(src)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
"row 4", "a03", "a13"
|
||||
|
||||
.. csv-table:: mat2x4 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10"
|
||||
"row 2", "b01 = a01", "b11 = a11"
|
||||
"row 3", "b02 = a02", "b12 = a12"
|
||||
"row 4", "b03 = a03", "b13 = a13"
|
||||
|
||||
.. c:function:: void glm_mat2x4_zero(mat2x4 m)
|
||||
|
||||
Zero out the mat2x4 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat2x4 (src, dest)
|
||||
|
||||
.. csv-table:: mat2x4 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "0.00", "2.00"
|
||||
"row 2", "5.00", "4.00"
|
||||
"row 3", "7.00", "6.00"
|
||||
"row 4", "23.00", "1.00"
|
||||
|
||||
.. csv-table:: mat2x4 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00"
|
||||
"row 3", "0.00", "0.00"
|
||||
"row 4", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat2x4_make(const float * __restrict src, mat2x4 dest)
|
||||
|
||||
Create mat2x4 matrix from pointer
|
||||
Create mat2x4 (dest) from pointer (src).
|
||||
|
||||
.. note:: **@src** must contain at least 8 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix2x4
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat2x4)
|
||||
|
||||
.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest)
|
||||
.. csv-table:: float array (1x8) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
"row 7", "v6"
|
||||
"row 8", "v7"
|
||||
|
||||
.. csv-table:: mat2x4 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "v0", "v4"
|
||||
"row 2", "v1", "v5"
|
||||
"row 3", "v2", "v6"
|
||||
"row 4", "v3", "v7"
|
||||
|
||||
.. c:function:: void glm_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest)
|
||||
|
||||
Multiply mat2x4 (m1) by mat4x2 (m2) and store in mat4 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat2x4_mul(mat2x4, mat4x2, mat2);
|
||||
glm_mat2x4_mul(mat2x4, mat4x2, mat4);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat2x4)
|
||||
| *[in]* **m2** right matrix (mat4x2)
|
||||
| *[out]* **dest** destination matrix (mat2)
|
||||
| *[in]* **m1** mat2x4 (left)
|
||||
| *[in]* **m2** mat4x2 (right)
|
||||
| *[out]* **dest** destination (result, mat4)
|
||||
|
||||
.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest)
|
||||
.. csv-table:: mat2x4 **(m1)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
multiply mat2x4 with vec4 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
"row 4", "a03", "a13"
|
||||
|
||||
.. csv-table:: mat4x2 **(m2)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00", "b10", "b20", "b30"
|
||||
"row 2", "b01", "b11", "b21", "b31"
|
||||
|
||||
.. csv-table:: mat4x4 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01", "a00 * b10 + a10 * b11", "a00 * b20 + a10 * b21", "a00 * b30 + a10 * b31"
|
||||
"row 2", "a01 * b00 + a11 * b01", "a01 * b10 + a11 * b11", "a01 * b20 + a11 * b21", "a01 * b30 + a11 * b31"
|
||||
"row 3", "a02 * b00 + a12 * b01", "a02 * b10 + a12 * b11", "a02 * b20 + a12 * b21", "a02 * b30 + a12 * b31"
|
||||
"row 4", "a03 * b00 + a13 * b01", "a03 * b10 + a13 * b11", "a03 * b20 + a13 * b21", "a03 * b30 + a13 * b31"
|
||||
|
||||
.. c:function:: void glm_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest)
|
||||
|
||||
Multiply mat2x4 (m) by vec2 (v) and store in vec4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat2x4 (left)
|
||||
| *[in]* **v** vec4 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat2x4 (left)
|
||||
| *[in]* **v** vec2 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat2x4_transpose(mat2x4 m, mat4x2 dest)
|
||||
.. csv-table:: mat2x4 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10"
|
||||
"row 2", "m01", "m11"
|
||||
"row 3", "m02", "m12"
|
||||
"row 4", "m03", "m13"
|
||||
|
||||
.. csv-table:: column vec2 (1x2) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
|
||||
.. csv-table:: column vec4 (1x4) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1"
|
||||
"row 2", "m01 * v0 + m11 * v1"
|
||||
"row 3", "m02 * v0 + m12 * v1"
|
||||
"row 4", "m03 * v0 + m13 * v1"
|
||||
|
||||
.. c:function:: void glm_mat2x4_transpose(mat2x4 src, mat4x2 dest)
|
||||
|
||||
Transpose mat2x4 (src) and store in mat4x2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat2x4 (left)
|
||||
| *[out]* **dest** destination (result, mat4x2)
|
||||
|
||||
.. csv-table:: mat2x4 **(src)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "a00", "a10"
|
||||
"row 2", "a01", "a11"
|
||||
"row 3", "a02", "a12"
|
||||
"row 4", "a03", "a13"
|
||||
|
||||
.. csv-table:: mat4x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01", "b20 = a02", "b30 = a03"
|
||||
"row 2", "b01 = a10", "b11 = a11", "b21 = a12", "b31 = a13"
|
||||
|
||||
.. c:function:: void glm_mat2x4_scale(mat2x4 m, float s)
|
||||
|
||||
multiply matrix with scalar
|
||||
Multiply mat2x4 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat2x4 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat2x4 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s"
|
||||
"row 3", "m02 = m02 * s", "m12 = m12 * s"
|
||||
"row 4", "m03 = m03 * s", "m13 = m13 * s"
|
||||
+1069
-85
File diff suppressed because it is too large.
Load diff
+135
-29
@@ -23,68 +23,174 @@ Functions:
|
||||
#. :c:func:`glm_mat3x2_transpose`
|
||||
#. :c:func:`glm_mat3x2_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat3x2
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "m00", "m10", "m20"
|
||||
"row 2", "m01", "m11", "m21"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat3x2_copy(mat3x2 mat, mat3x2 dest)
|
||||
.. c:function:: void glm_mat3x2_copy(mat3x2 src, mat3x2 dest)
|
||||
|
||||
copy mat3x2 to another one (dest).
|
||||
Copy mat3x2 (src) to mat3x2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat3x2 (left)
|
||||
| *[out]* **dest** destination (result, mat3x2)
|
||||
|
||||
.. c:function:: void glm_mat3x2_zero(mat3x2 mat)
|
||||
.. csv-table:: mat3x2 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
|
||||
.. csv-table:: mat3x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10", "b20 = a20"
|
||||
"row 2", "b01 = a01", "b11 = a11", "b21 = a21"
|
||||
|
||||
.. c:function:: void glm_mat3x2_zero(mat3x2 m)
|
||||
|
||||
Zero out the mat3x2 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat3x2 (src, dest)
|
||||
|
||||
.. csv-table:: mat3x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "0.00", "2.00", "15.00"
|
||||
"row 2", "5.00", "4.00", "6.00"
|
||||
|
||||
.. csv-table:: mat3x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "0.00", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat3x2_make(const float * __restrict src, mat3x2 dest)
|
||||
|
||||
Create mat3x2 matrix from pointer
|
||||
Create mat3x2 (dest) from pointer (src).
|
||||
|
||||
.. note:: **@src** must contain at least 6 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix3x2
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat3x2)
|
||||
|
||||
.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest)
|
||||
.. csv-table:: float array (1x6) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
|
||||
.. csv-table:: mat3x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "v0", "v2", "v4"
|
||||
"row 2", "v1", "v3", "v5"
|
||||
|
||||
.. c:function:: void glm_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest)
|
||||
|
||||
Multiply mat3x2 (m1) by mat2x3 (m2) and store in mat2 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat3x2_mul(mat3x2, mat2x3, mat3);
|
||||
glm_mat3x2_mul(mat3x2, mat2x3, mat2);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat3x2)
|
||||
| *[in]* **m2** right matrix (mat2x3)
|
||||
| *[out]* **dest** destination matrix (mat3)
|
||||
| *[in]* **m1** mat3x2 (left)
|
||||
| *[in]* **m2** mat2x3 (right)
|
||||
| *[out]* **dest** destination (result, mat2)
|
||||
|
||||
.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest)
|
||||
.. csv-table:: mat3x2 **(m1)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
multiply mat3x2 with vec2 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
|
||||
.. csv-table:: mat2x3 **(m2)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00", "b10"
|
||||
"row 2", "b01", "b11"
|
||||
"row 3", "b02", "b12"
|
||||
|
||||
.. csv-table:: mat2x2 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12"
|
||||
"row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12"
|
||||
|
||||
.. c:function:: void glm_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest)
|
||||
|
||||
Multiply mat3x2 (m) by vec3 (v) and store in vec2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat3x2 (left)
|
||||
| *[in]* **v** vec3 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat3x2 (left)
|
||||
| *[in]* **v** vec3 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat3x2_transpose(mat3x2 m, mat2x3 dest)
|
||||
.. csv-table:: mat3x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10", "m20"
|
||||
"row 2", "m01", "m11", "m21"
|
||||
|
||||
.. csv-table:: column vec3 (1x3) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
|
||||
.. csv-table:: column vec2 (1x2) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1 + m20 * v2"
|
||||
"row 2", "m01 * v0 + m11 * v1 + m21 * v2"
|
||||
|
||||
.. c:function:: void glm_mat3x2_transpose(mat3x2 src, mat2x3 dest)
|
||||
|
||||
Transpose mat3x2 (src) and store in mat2x3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat3x2 (left)
|
||||
| *[out]* **dest** destination (result, mat2x3)
|
||||
|
||||
.. c:function:: void glm_mat3x2_scale(mat3x2 m, float s)
|
||||
.. csv-table:: mat3x2 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
multiply matrix with scalar
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
|
||||
.. csv-table:: mat2x3 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01"
|
||||
"row 2", "b01 = a10", "b11 = a11"
|
||||
"row 3", "b02 = a20", "b12 = a21"
|
||||
|
||||
.. c:function:: void glm_mat3x2_scale(mat3x2 m, float s)
|
||||
|
||||
Multiply mat3x2 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat3x2 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat3x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s"
|
||||
+165
-29
@@ -23,68 +23,204 @@ Functions:
|
||||
#. :c:func:`glm_mat3x4_transpose`
|
||||
#. :c:func:`glm_mat3x4_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat3x4
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "m00", "m10", "m20"
|
||||
"row 2", "m01", "m11", "m21"
|
||||
"row 3", "m02", "m12", "m22"
|
||||
"row 4", "m03", "m13", "m23"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat3x4_copy(mat3x4 mat, mat3x4 dest)
|
||||
.. c:function:: void glm_mat3x4_copy(mat3x4 src, mat3x4 dest)
|
||||
|
||||
copy mat3x4 to another one (dest).
|
||||
Copy mat3x4 (src) to mat3x4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat3x4 (left)
|
||||
| *[out]* **dest** destination (result, mat3x4)
|
||||
|
||||
.. c:function:: void glm_mat3x4_zero(mat3x4 mat)
|
||||
.. csv-table:: mat3x4 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
"row 3", "a02", "a12", "a22"
|
||||
"row 4", "a03", "a13", "a23"
|
||||
|
||||
.. csv-table:: mat3x4 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10", "b20 = a20"
|
||||
"row 2", "b01 = a01", "b11 = a11", "b21 = a21"
|
||||
"row 3", "b02 = a02", "b12 = a12", "b22 = a22"
|
||||
"row 4", "b03 = a03", "b13 = a13", "b23 = a23"
|
||||
|
||||
.. c:function:: void glm_mat3x4_zero(mat3x4 m)
|
||||
|
||||
Zero out the mat3x4 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat3x4 (src, dest)
|
||||
|
||||
.. csv-table:: mat3x4 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "0.00", "2.00", "78.00"
|
||||
"row 2", "5.00", "4.00", "12.00"
|
||||
"row 3", "7.00", "6.00", "32.00"
|
||||
"row 4", "23.00", "1.00", "9.00"
|
||||
|
||||
.. csv-table:: mat3x4 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "0.00", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00", "0.00"
|
||||
"row 3", "0.00", "0.00", "0.00"
|
||||
"row 4", "0.00", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat3x4_make(const float * __restrict src, mat3x4 dest)
|
||||
|
||||
Create mat3x4 matrix from pointer
|
||||
Create mat3x4 (dest) from pointer (src).
|
||||
|
||||
.. note::: **@src** must contain at least 12 elements.
|
||||
.. note:: **@src** must contain at least 12 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix3x4
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat3x4)
|
||||
|
||||
.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest)
|
||||
.. csv-table:: float array (1x12) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
"row 7", "v6"
|
||||
"row 8", "v7"
|
||||
"row 9", "v8"
|
||||
"row 10", "v9"
|
||||
"row 11", "v10"
|
||||
"row 12", "v11"
|
||||
|
||||
.. csv-table:: mat3x4 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "v0", "v4", "v8"
|
||||
"row 2", "v1", "v5", "v9"
|
||||
"row 3", "v2", "v6", "v10"
|
||||
"row 4", "v3", "v7", "v11"
|
||||
|
||||
.. c:function:: void glm_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest)
|
||||
|
||||
Multiply mat3x4 (m1) by mat4x3 (m2) and store in mat4 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat3x4_mul(mat3x4, mat4x3, mat3);
|
||||
glm_mat3x4_mul(mat3x4, mat4x3, mat4);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat3x4)
|
||||
| *[in]* **m2** right matrix (mat4x3)
|
||||
| *[out]* **dest** destination matrix (mat3)
|
||||
| *[in]* **m1** mat2x4 (left)
|
||||
| *[in]* **m2** mat4x2 (right)
|
||||
| *[out]* **dest** destination (result, mat4)
|
||||
|
||||
.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest)
|
||||
.. csv-table:: mat3x4 **(m1)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
multiply mat3x4 with vec4 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
"row 3", "a02", "a12", "a22"
|
||||
"row 4", "a03", "a13", "a23"
|
||||
|
||||
.. csv-table:: mat4x3 **(m2)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00", "b10", "b20", "b30"
|
||||
"row 2", "b01", "b11", "b21", "b31"
|
||||
"row 3", "b02", "b12", "b22", "b32"
|
||||
|
||||
.. csv-table:: mat4x4 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01 + a20 * b02", "a00 * b10 + a10 * b11 + a20 * b12", "a00 * b20 + a10 * b21 + a20 * b22", "a00 * b30 + a10 * b31 + a20 * b32"
|
||||
"row 2", "a01 * b00 + a11 * b01 + a21 * b02", "a01 * b10 + a11 * b11 + a21 * b12", "a01 * b20 + a11 * b21 + a21 * b22", "a01 * b30 + a11 * b31 + a21 * b32"
|
||||
"row 3", "a02 * b00 + a12 * b01 + a22 * b02", "a02 * b10 + a12 * b11 + a22 * b12", "a02 * b20 + a12 * b21 + a22 * b22", "a02 * b30 + a12 * b31 + a22 * b32"
|
||||
"row 4", "a03 * b00 + a13 * b01 + a23 * b02", "a03 * b10 + a13 * b11 + a23 * b12", "a03 * b20 + a13 * b21 + a23 * b22", "a03 * b30 + a13 * b31 + a23 * b32"
|
||||
|
||||
.. c:function:: void glm_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest)
|
||||
|
||||
Multiply ma3x4 (m) by vec3 (v) and store in vec4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat3x4 (left)
|
||||
| *[in]* **v** vec4 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat3x4 (left)
|
||||
| *[in]* **v** vec3 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat3x4_transpose(mat3x4 m, mat4x3 dest)
|
||||
.. csv-table:: mat3x4 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10", "m20"
|
||||
"row 2", "m01", "m11", "m21"
|
||||
"row 3", "m02", "m12", "m22"
|
||||
"row 4", "m03", "m13", "m23"
|
||||
|
||||
.. csv-table:: column vec3 (1x3) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
|
||||
.. csv-table:: column vec4 (1x4) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1 + m20 * v2"
|
||||
"row 2", "m01 * v0 + m11 * v1 + m21 * v2"
|
||||
"row 3", "m02 * v0 + m12 * v1 + m22 * v2"
|
||||
"row 4", "m03 * v0 + m13 * v1 + m23 * v2"
|
||||
|
||||
.. c:function:: void glm_mat3x4_transpose(mat3x4 src, mat4x3 dest)
|
||||
|
||||
Transpose mat3x4 (src) and store in mat4x3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat3x4 (left)
|
||||
| *[out]* **dest** destination (result, mat4x3)
|
||||
|
||||
.. csv-table:: mat3x4 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "a00", "a10", "a20"
|
||||
"row 2", "a01", "a11", "a21"
|
||||
"row 3", "a02", "a12", "a22"
|
||||
"row 4", "a03", "a13", "a23"
|
||||
|
||||
.. csv-table:: mat4x3 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01", "b20 = a02", "b30 = a03"
|
||||
"row 2", "b01 = a10", "b11 = a11", "b21 = a12", "b31 = a13"
|
||||
"row 3", "b02 = a20", "b12 = a21", "b22 = a22", "b32 = a23"
|
||||
|
||||
.. c:function:: void glm_mat3x4_scale(mat3x4 m, float s)
|
||||
|
||||
multiply matrix with scalar
|
||||
Multiply mat3x4 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat3x4 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat3x4 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s"
|
||||
"row 3", "m02 = m02 * s", "m12 = m12 * s", "m22 = m22 * s"
|
||||
"row 4", "m03 = m03 * s", "m13 = m13 * s", "m23 = m23 * s"
|
||||
+14
-1
@@ -48,6 +48,7 @@ Functions:
|
||||
#. :c:func:`glm_mat4_swap_row`
|
||||
#. :c:func:`glm_mat4_rmc`
|
||||
#. :c:func:`glm_mat4_make`
|
||||
#. :c:func:`glm_mat4_textrans`
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@@ -143,7 +144,7 @@ Functions documentation
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
mat m1, m2, m3, m4, res;
|
||||
mat4 m1, m2, m3, m4, res;
|
||||
glm_mat4_mulN((mat4 *[]){&m1, &m2, &m3, &m4}, 4, res);
|
||||
|
||||
Parameters:
|
||||
@@ -313,3 +314,15 @@ Functions documentation
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix4x4
|
||||
|
||||
.. c:function:: void glm_mat4_textrans(float sx, float sy, float rot, float tx, float ty, mat4 dest)
|
||||
|
||||
Create texture transformation matrix, rotation is in radians CCW/RH
|
||||
|
||||
Parameters:
|
||||
| *[in]* **sx** scale x
|
||||
| *[in]* **sy** scale y
|
||||
| *[in]* **rot** rotation in radians CCW/RH
|
||||
| *[in]* **tx** translation x
|
||||
| *[in]* **ty** translation y
|
||||
| *[out]* **dest** destination matrix3x3
|
||||
+139
-28
@@ -23,68 +23,179 @@ Functions:
|
||||
#. :c:func:`glm_mat4x2_transpose`
|
||||
#. :c:func:`glm_mat4x2_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat4x2
|
||||
:header: "", "column 1", "column 2", "column 3", "column4"
|
||||
|
||||
"row 1", "m00", "m10", "m20", "m30"
|
||||
"row 2", "m01", "m11", "m21", "m31"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat4x2_copy(mat4x2 mat, mat4x2 dest)
|
||||
.. c:function:: void glm_mat4x2_copy(mat4x2 src, mat4x2 dest)
|
||||
|
||||
copy mat4x2 to another one (dest).
|
||||
Copy mat4x2 (src) to mat4x2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat4x2 (left)
|
||||
| *[out]* **dest** destination (result, mat4x2)
|
||||
|
||||
.. c:function:: void glm_mat4x2_zero(mat4x2 mat)
|
||||
.. csv-table:: mat4x2 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
|
||||
.. csv-table:: ma4x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10", "b20 = a20", "b30 = a30"
|
||||
"row 2", "b01 = a01", "b11 = a11", "b21 = a21", "b31 = a31"
|
||||
|
||||
.. c:function:: void glm_mat4x2_zero(mat4x2 m)
|
||||
|
||||
Zero out the mat4x2 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat4x2 (src, dest)
|
||||
|
||||
.. csv-table:: mat4x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "0.00", "2.00", "15.00", "44.00"
|
||||
"row 2", "5.00", "4.00", "6.00", "12.00"
|
||||
|
||||
.. csv-table:: mat4x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "0.00", "0.00", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat4x2_make(const float * __restrict src, mat4x2 dest)
|
||||
|
||||
Create mat4x2 matrix from pointer
|
||||
Create mat4x2 (dest) from pointer (src).
|
||||
|
||||
.. note:: **@src** must contain at least 8 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix4x2
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat4x2)
|
||||
|
||||
.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest)
|
||||
.. csv-table:: float array (1x8) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
"row 7", "v6"
|
||||
"row 8", "v7"
|
||||
|
||||
.. csv-table:: mat4x2 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "v0", "v2", "v4", "v6"
|
||||
"row 2", "v1", "v3", "v5", "v7"
|
||||
|
||||
.. c:function:: void glm_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest)
|
||||
|
||||
Multiply mat4x2 (m1) by mat2x4 (m2) and store in mat2 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat4x2_mul(mat4x2, mat2x4, mat4);
|
||||
glm_mat4x2_mul(mat4x2, mat2x4, mat2);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat4x2)
|
||||
| *[in]* **m2** right matrix (mat2x4)
|
||||
| *[out]* **dest** destination matrix (mat4)
|
||||
| *[in]* **m1** mat4x2 (left)
|
||||
| *[in]* **m2** mat2x4 (right)
|
||||
| *[out]* **dest** destination (result, mat2)
|
||||
|
||||
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest)
|
||||
.. csv-table:: mat4x2 **(m1)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
multiply mat4x2 with vec2 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
|
||||
.. csv-table:: mat2x4 **(m2)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00", "b10"
|
||||
"row 2", "b01", "b11"
|
||||
"row 3", "b02", "b12"
|
||||
"row 4", "b03", "b13"
|
||||
|
||||
.. csv-table:: mat2x2 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13"
|
||||
"row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13"
|
||||
|
||||
.. c:function:: void glm_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest)
|
||||
|
||||
Multiply mat4x2 (m) by vec4 (v) and store in vec2 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat4x2 (left)
|
||||
| *[in]* **v** vec2 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat4x2 (left)
|
||||
| *[in]* **v** vec4 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat4x2_transpose(mat4x2 m, mat2x4 dest)
|
||||
.. csv-table:: mat4x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10", "m20", "m30"
|
||||
"row 2", "m01", "m11", "m21", "m31"
|
||||
|
||||
.. csv-table:: column vec4 (1x4) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
|
||||
.. csv-table:: column vec2 (1x2) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3"
|
||||
"row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3"
|
||||
|
||||
.. c:function:: void glm_mat4x2_transpose(mat4x2 src, mat2x4 dest)
|
||||
|
||||
Transpose mat4x2 (src) and store in mat2x4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat4x2 (left)
|
||||
| *[out]* **dest** destination (result, mat2x4)
|
||||
|
||||
.. csv-table:: mat4x2 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
|
||||
.. csv-table:: mat2x4 **(dest)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01"
|
||||
"row 2", "b01 = a10", "b11 = a11"
|
||||
"row 3", "b02 = a20", "b12 = a21"
|
||||
"row 4", "b03 = a30", "b13 = a31"
|
||||
|
||||
.. c:function:: void glm_mat4x2_scale(mat4x2 m, float s)
|
||||
|
||||
multiply matrix with scalar
|
||||
Multiply mat4x2 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat4x2 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat4x2 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s", "m30 = m30 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s", "m31 = m31 * s"
|
||||
+156
-29
@@ -23,68 +23,195 @@ Functions:
|
||||
#. :c:func:`glm_mat4x3_transpose`
|
||||
#. :c:func:`glm_mat4x3_scale`
|
||||
|
||||
Represented
|
||||
~~~~~~~~~~~
|
||||
|
||||
.. csv-table:: mat4x3
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "m00", "m10", "m20", "m30"
|
||||
"row 2", "m01", "m11", "m21", "m31"
|
||||
"row 3", "m02", "m12", "m22", "m32"
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: void glm_mat4x3_copy(mat4x3 mat, mat4x3 dest)
|
||||
.. c:function:: void glm_mat4x3_copy(mat4x3 src, mat4x3 dest)
|
||||
|
||||
copy mat4x3 to another one (dest).
|
||||
Copy mat4x3 (src) to mat4x3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **mat** source
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat4x3 (left)
|
||||
| *[out]* **dest** destination (result, mat4x3)
|
||||
|
||||
.. c:function:: void glm_mat4x3_zero(mat4x3 mat)
|
||||
.. csv-table:: mat4x3 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
make given matrix zero
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
"row 3", "a02", "a12", "a22", "a32"
|
||||
|
||||
.. csv-table:: mat4x3 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a10", "b20 = a20", "b30 = a30"
|
||||
"row 2", "b01 = a01", "b11 = a11", "b21 = a21", "b31 = a31"
|
||||
"row 3", "b02 = a02", "b12 = a12", "b22 = a22", "b32 = a32"
|
||||
|
||||
.. c:function:: void glm_mat4x3_zero(mat4x3 m)
|
||||
|
||||
Zero out the mat4x3 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in,out]* **mat** matrix
|
||||
| *[in, out]* **m** mat4x3 (src, dest)
|
||||
|
||||
.. csv-table:: mat4x3 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "0.00", "2.00", "15.00", "44.00"
|
||||
"row 2", "5.00", "4.00", "6.00", "12.00"
|
||||
"row 3", "88.00", "8.00", "4.30", "15.00"
|
||||
|
||||
.. csv-table:: mat4x3 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "0.00", "0.00", "0.00", "0.00"
|
||||
"row 2", "0.00", "0.00", "0.00", "0.00"
|
||||
"row3", "0.00", "0.00", "0.00", "0.00"
|
||||
|
||||
.. c:function:: void glm_mat4x3_make(const float * __restrict src, mat4x3 dest)
|
||||
|
||||
Create mat4x3 matrix from pointer
|
||||
Create mat4x3 (dest) from pointer (src).
|
||||
|
||||
.. note:: **@src** must contain at least 12 elements.
|
||||
|
||||
Parameters:
|
||||
| *[in]* **src** pointer to an array of floats
|
||||
| *[out]* **dest** destination matrix4x3
|
||||
| *[in]* **src** pointer to an array of floats (left)
|
||||
| *[out]* **dest** destination (result, mat4x3)
|
||||
|
||||
.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest)
|
||||
.. csv-table:: float array (1x12) **(src)**
|
||||
:header: "", "column 1"
|
||||
|
||||
multiply m1 and m2 to dest
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
"row 5", "v4"
|
||||
"row 6", "v5"
|
||||
"row 7", "v6"
|
||||
"row 8", "v7"
|
||||
"row 9", "v8"
|
||||
"row 10", "v9"
|
||||
"row 11", "v10"
|
||||
"row 12", "v11"
|
||||
|
||||
.. csv-table:: mat4x3 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "v0", "v3", "v6", "v9"
|
||||
"row 2", "v1", "v4", "v7", "v10"
|
||||
"row 3", "v2", "v5", "v8", "v11"
|
||||
|
||||
.. c:function:: void glm_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest)
|
||||
|
||||
Multiply mat4x3 (m1) by mat3x4 (m2) and store in mat3 (dest).
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
glm_mat4x3_mul(mat4x3, mat3x4, mat4);
|
||||
glm_mat4x3_mul(mat4x3, mat3x4, mat3);
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m1** left matrix (mat4x3)
|
||||
| *[in]* **m2** right matrix (mat3x4)
|
||||
| *[out]* **dest** destination matrix (mat4)
|
||||
| *[in]* **m1** mat4x3 (left)
|
||||
| *[in]* **m2** mat3x4 (right)
|
||||
| *[out]* **dest** destination (result, mat3)
|
||||
|
||||
.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest)
|
||||
.. csv-table:: mat4x3 **(m1)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
multiply mat4x3 with vec3 (column vector) and store in dest vector
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
"row 3", "a02", "a12", "a22", "a32"
|
||||
|
||||
.. csv-table:: mat3x4 **(m2)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00", "b10", "b20"
|
||||
"row 2", "b01", "b11", "b21"
|
||||
"row 3", "b02", "b12", "b22"
|
||||
"row 4", "b03", "b13", "b23"
|
||||
|
||||
.. csv-table:: mat3x3 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "a00 * b00 + a10 * b01 + a20 * b02 + a30 * b03", "a00 * b10 + a10 * b11 + a20 * b12 + a30 * b13", "a00 * b20 + a10 * b21 + a20 * b22 + a30 * b23"
|
||||
"row 2", "a01 * b00 + a11 * b01 + a21 * b02 + a31 * b03", "a01 * b10 + a11 * b11 + a21 * b12 + a31 * b13", "a01 * b20 + a11 * b21 + a21 * b22 + a31 * b23"
|
||||
"row 3", "a02 * b00 + a12 * b01 + a22 * b02 + a32 * b03", "a02 * b10 + a12 * b11 + a22 * b12 + a32 * b13", "a02 * b20 + a12 * b21 + a22 * b22 + a32 * b23"
|
||||
|
||||
.. c:function:: void glm_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest)
|
||||
|
||||
Multiply mat4x3 (m) by vec4 (v) and store in vec3 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** mat4x3 (left)
|
||||
| *[in]* **v** vec3 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
| *[in]* **m** mat4x3 (left)
|
||||
| *[in]* **v** vec4 (right, column vector)
|
||||
| *[out]* **dest** destination (result, column vector)
|
||||
|
||||
.. c:function:: void glm_mat4x3_transpose(mat4x3 m, mat3x4 dest)
|
||||
.. csv-table:: mat4x3 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
transpose matrix and store in dest
|
||||
"row 1", "m00", "m10", "m20", "m30"
|
||||
"row 2", "m01", "m11", "m21", "m31"
|
||||
"row 3", "m02", "m12", "m22", "m32"
|
||||
|
||||
.. csv-table:: column vec4 (1x4) **(v)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "v0"
|
||||
"row 2", "v1"
|
||||
"row 3", "v2"
|
||||
"row 4", "v3"
|
||||
|
||||
.. csv-table:: column vec3 (1x3) **(dest)**
|
||||
:header: "", "column 1"
|
||||
|
||||
"row 1", "m00 * v0 + m10 * v1 + m20 * v2 + m30 * v3"
|
||||
"row 2", "m01 * v0 + m11 * v1 + m21 * v2 + m31 * v3"
|
||||
"row 3", "m02 * v0 + m12 * v1 + m22 * v2 + m32 * v3"
|
||||
|
||||
.. c:function:: void glm_mat4x3_transpose(mat4x3 src, mat3x4 dest)
|
||||
|
||||
Transpose mat4x3 (src) and store in mat3x4 (dest).
|
||||
|
||||
Parameters:
|
||||
| *[in]* **m** matrix
|
||||
| *[out]* **dest** destination
|
||||
| *[in]* **src** mat4x3 (left)
|
||||
| *[out]* **dest** destination (result, mat3x4)
|
||||
|
||||
.. c:function:: void glm_mat4x3_scale(mat4x3 m, float s)
|
||||
.. csv-table:: mat4x3 **(src)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
multiply matrix with scalar
|
||||
"row 1", "a00", "a10", "a20", "a30"
|
||||
"row 2", "a01", "a11", "a21", "a31"
|
||||
"row 3", "a02", "a12", "a22", "a32"
|
||||
|
||||
.. csv-table:: mat3x4 **(dest)**
|
||||
:header: "", "column 1", "column 2", "column 3"
|
||||
|
||||
"row 1", "b00 = a00", "b10 = a01", "b20 = a02"
|
||||
"row 2", "b01 = a10", "b11 = a11", "b21 = a12"
|
||||
"row 3", "b02 = a20", "b12 = a21", "b22 = a22"
|
||||
"row 4", "b03 = a30", "b13 = a31", "b23 = a32"
|
||||
|
||||
.. c:function:: void glm_mat4x3_scale(mat4x3 m, float s)
|
||||
|
||||
Multiply mat4x3 (m) by scalar constant (s).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **m** matrix
|
||||
| *[in]* **s** scalar
|
||||
| *[in, out]* **m** mat4x3 (src, dest)
|
||||
| *[in]* **s** float (scalar)
|
||||
|
||||
.. csv-table:: mat4x3 **(m)**
|
||||
:header: "", "column 1", "column 2", "column 3", "column 4"
|
||||
|
||||
"row 1", "m00 = m00 * s", "m10 = m10 * s", "m20 = m20 * s", "m30 = m30 * s"
|
||||
"row 2", "m01 = m01 * s", "m11 = m11 * s", "m21 = m21 * s", "m31 = m31 * s"
|
||||
"row 3", "m02 = m02 * s", "m12 = m12 * s", "m22 = m22 * s", "m32 = m32 * s"
|
||||
@@ -0,0 +1,60 @@
|
||||
.. default-domain:: C
|
||||
|
||||
perlin
|
||||
================================================================================
|
||||
|
||||
Header: cglm/noise.h
|
||||
|
||||
Classic Perlin noise implementation.
|
||||
|
||||
Based on the work of Stefan Gustavson and Ashima Arts on "webgl-noise":
|
||||
https://github.com/stegu/webgl-noise
|
||||
Following Stefan Gustavson's paper "Simplex noise demystified":
|
||||
http://www.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf
|
||||
|
||||
Implementation based on glm::perlin function:
|
||||
https://github.com/g-truc/glm/blob/master/glm/gtc/noise.inl
|
||||
|
||||
Table of contents (click to go):
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
Functions:
|
||||
|
||||
1. :c:func:`glm_perlin_vec4`
|
||||
#. :c:func:`glm_perlin_vec3`
|
||||
#. :c:func:`glm_perlin_vec2`
|
||||
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
.. c:function:: float glm_perlin_vec4(vec4 point)
|
||||
|
||||
| Classic Perlin noise
|
||||
|
||||
Parameters:
|
||||
| *[in]* **point** 4D point
|
||||
|
||||
Returns:
|
||||
| noise value
|
||||
|
||||
|
||||
.. c:function:: float glm_perlin_vec3(vec3 point)
|
||||
|
||||
| Classic Perlin noise
|
||||
|
||||
Parameters:
|
||||
| *[in]* **point** 3D point
|
||||
|
||||
Returns:
|
||||
| noise value
|
||||
|
||||
.. c:function:: float glm_perlin_vec2(vec2 point)
|
||||
|
||||
| Classic Perlin noise
|
||||
|
||||
Parameters:
|
||||
| *[in]* **point** 2D point
|
||||
|
||||
Returns:
|
||||
| noise value
|
||||
@@ -34,7 +34,7 @@ array of matrices:
|
||||
/* ... */
|
||||
glUniformMatrix4fv(location, count, GL_FALSE, matrix[0][0]);
|
||||
|
||||
1. Cast matrix to pointer
|
||||
2. Cast matrix to pointer
|
||||
--------------------------
|
||||
|
||||
.. code-block:: c
|
||||
|
||||
+1
-1
@@ -76,7 +76,7 @@ SSE and SSE2 Shuffle Option
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
**_mm_shuffle_ps** generates **shufps** instruction even if registers are same.
|
||||
You can force it to generate **pshufd** instruction by defining
|
||||
**CGLM_USE_INT_DOMAIN** macro. As default it is not defined.
|
||||
**CGLM_NO_INT_DOMAIN** macro. As default it is not defined.
|
||||
|
||||
SSE3 and SSE4 Dot Product Options
|
||||
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||
|
||||
+15
-3
@@ -11,9 +11,9 @@ Header: cglm/quat.h
|
||||
|
||||
What you can do with quaternions with existing functions is (Some of them):
|
||||
|
||||
- You can rotate transform matrix using quaterion
|
||||
- You can rotate vector using quaterion
|
||||
- You can create view matrix using quaterion
|
||||
- You can rotate transform matrix using quaternion
|
||||
- You can rotate vector using quaternion
|
||||
- You can create view matrix using quaternion
|
||||
- You can create a lookrotation (from source point to dest)
|
||||
|
||||
Table of contents (click to go):
|
||||
@@ -55,6 +55,7 @@ Functions:
|
||||
#. :c:func:`glm_quat_lerp`
|
||||
#. :c:func:`glm_quat_nlerp`
|
||||
#. :c:func:`glm_quat_slerp`
|
||||
#. :c:func:`glm_quat_slerp_longest`
|
||||
#. :c:func:`glm_quat_look`
|
||||
#. :c:func:`glm_quat_for`
|
||||
#. :c:func:`glm_quat_forp`
|
||||
@@ -351,6 +352,17 @@ Functions documentation
|
||||
| *[in]* **t** interpolant (amount) clamped between 0 and 1
|
||||
| *[out]* **dest** result quaternion
|
||||
|
||||
.. c:function:: void glm_quat_slerp_longest(versor q, versor r, float t, versor dest)
|
||||
|
||||
| interpolates between two quaternions
|
||||
| using spherical linear interpolation (SLERP) and always takes the longest path
|
||||
|
||||
Parameters:
|
||||
| *[in]* **from** from
|
||||
| *[in]* **to** to
|
||||
| *[in]* **t** interpolant (amount) clamped between 0 and 1
|
||||
| *[out]* **dest** result quaternion
|
||||
|
||||
.. c:function:: void glm_quat_look(vec3 eye, versor ori, mat4 dest)
|
||||
|
||||
| creates view matrix using quaternion as camera orientation
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
@media screen {
|
||||
/* content column
|
||||
*
|
||||
* RTD theme's default is 800px as max width for the content, but we have
|
||||
* tables with tons of columns, which need the full width of the view-port.
|
||||
*
|
||||
* Comment from yocto project theme_overrides.css
|
||||
*/
|
||||
|
||||
.wy-nav-content{ max-width: none; }
|
||||
|
||||
}
|
||||
@@ -27,6 +27,8 @@ Functions:
|
||||
#. :c:func:`glm_vec2_isvalid`
|
||||
#. :c:func:`glm_vec2_sign`
|
||||
#. :c:func:`glm_vec2_abs`
|
||||
#. :c:func:`glm_vec2_fract`
|
||||
#. :c:func:`glm_vec2_floor`
|
||||
#. :c:func:`glm_vec2_sqrt`
|
||||
|
||||
Functions documentation
|
||||
@@ -134,6 +136,22 @@ Functions documentation
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec2_fract(vec2 v, vec2 dest)
|
||||
|
||||
get fractional part of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec2_floor(vec2 v, vec2 dest)
|
||||
|
||||
floor value of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec2_sqrt(vec2 v, vec2 dest)
|
||||
|
||||
square root of each vector item
|
||||
|
||||
@@ -28,6 +28,8 @@ Functions:
|
||||
#. :c:func:`glm_vec3_isvalid`
|
||||
#. :c:func:`glm_vec3_sign`
|
||||
#. :c:func:`glm_vec3_abs`
|
||||
#. :c:func:`glm_vec3_fract`
|
||||
#. :c:func:`glm_vec3_floor`
|
||||
#. :c:func:`glm_vec3_sqrt`
|
||||
|
||||
Functions documentation
|
||||
@@ -151,6 +153,22 @@ Functions documentation
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec3_fract(vec3 v, vec3 dest)
|
||||
|
||||
fractional part of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec3_floor(vec3 v, vec3 dest)
|
||||
|
||||
floor of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector
|
||||
|
||||
.. c:function:: void glm_vec3_sqrt(vec3 v, vec3 dest)
|
||||
|
||||
square root of each vector item
|
||||
|
||||
@@ -23,6 +23,15 @@ Functions:
|
||||
#. :c:func:`glm_vec4_eqv_eps`
|
||||
#. :c:func:`glm_vec4_max`
|
||||
#. :c:func:`glm_vec4_min`
|
||||
#. :c:func:`glm_vec4_isnan`
|
||||
#. :c:func:`glm_vec4_isinf`
|
||||
#. :c:func:`glm_vec4_isvalid`
|
||||
#. :c:func:`glm_vec4_sign`
|
||||
#. :c:func:`glm_vec4_abs`
|
||||
#. :c:func:`glm_vec4_fract`
|
||||
#. :c:func:`glm_vec4_floor`
|
||||
#. :c:func:`glm_vec4_sqrt`
|
||||
|
||||
|
||||
Functions documentation
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@@ -129,6 +138,30 @@ Functions documentation
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** sign vector (only keeps signs as -1, 0, -1)
|
||||
|
||||
.. c:function:: void glm_vec4_abs(vec4 v, vec4 dest)
|
||||
|
||||
absolute value of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector (abs(v))
|
||||
|
||||
.. c:function:: void glm_vec4_fract(vec4 v, vec4 dest)
|
||||
|
||||
fractional part of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector (fract(v))
|
||||
|
||||
.. c:function:: void glm_vec4_floor(vec4 v, vec4 dest)
|
||||
|
||||
floor of each vector item
|
||||
|
||||
Parameters:
|
||||
| *[in]* **v** vector
|
||||
| *[out]* **dest** destination vector (floor(v))
|
||||
|
||||
.. c:function:: void glm_vec4_sqrt(vec4 v, vec4 dest)
|
||||
|
||||
square root of each vector item
|
||||
|
||||
+20
-21
@@ -35,7 +35,7 @@ glm_aabb2d_zero(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
|
||||
glm_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]) {
|
||||
glm_vec2_copy(aabb[0], dest[0]);
|
||||
glm_vec2_copy(aabb[1], dest[1]);
|
||||
}
|
||||
@@ -49,7 +49,7 @@ glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
|
||||
glm_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]) {
|
||||
vec2 v[2], xa, xb, ya, yb;
|
||||
|
||||
glm_vec2_scale(m[0], aabb[0][0], xa);
|
||||
@@ -84,7 +84,7 @@ glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
|
||||
glm_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]) {
|
||||
dest[0][0] = glm_min(aabb1[0][0], aabb2[0][0]);
|
||||
dest[0][1] = glm_min(aabb1[0][1], aabb2[0][1]);
|
||||
|
||||
@@ -95,7 +95,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
|
||||
/*!
|
||||
* @brief crops a bounding aabb with another one.
|
||||
*
|
||||
* this could be useful for gettng a baabb which fits with view frustum and
|
||||
* this could be useful for getting a baabb which fits with view frustum and
|
||||
* object bounding aabbes. In this case you crop view frustum aabb with objects
|
||||
* aabb
|
||||
*
|
||||
@@ -105,7 +105,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
|
||||
glm_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]) {
|
||||
dest[0][0] = glm_max(aabb[0][0], cropAabb[0][0]);
|
||||
dest[0][1] = glm_max(aabb[0][1], cropAabb[0][1]);
|
||||
|
||||
@@ -116,7 +116,7 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
|
||||
/*!
|
||||
* @brief crops a bounding aabb with another one.
|
||||
*
|
||||
* this could be useful for gettng a baabb which fits with view frustum and
|
||||
* this could be useful for getting a baabb which fits with view frustum and
|
||||
* object bounding aabbes. In this case you crop view frustum aabb with objects
|
||||
* aabb
|
||||
*
|
||||
@@ -127,9 +127,9 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_crop_until(vec2 aabb[2],
|
||||
vec2 cropAabb[2],
|
||||
vec2 clampAabb[2],
|
||||
glm_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
|
||||
CGLM_CONST vec2 cropAabb[2],
|
||||
CGLM_CONST vec2 clampAabb[2],
|
||||
vec2 dest[2]) {
|
||||
glm_aabb2d_crop(aabb, cropAabb, dest);
|
||||
glm_aabb2d_merge(clampAabb, dest, dest);
|
||||
@@ -154,7 +154,7 @@ glm_aabb2d_invalidate(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_isvalid(vec2 aabb[2]) {
|
||||
glm_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_vec2_max(aabb[0]) != FLT_MAX
|
||||
&& glm_vec2_min(aabb[1]) != -FLT_MAX;
|
||||
}
|
||||
@@ -166,7 +166,7 @@ glm_aabb2d_isvalid(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb2d_diag(vec2 aabb[2]) {
|
||||
glm_aabb2d_diag(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_vec2_distance(aabb[0], aabb[1]);
|
||||
}
|
||||
|
||||
@@ -178,7 +178,7 @@ glm_aabb2d_diag(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
|
||||
glm_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest) {
|
||||
glm_vec2_sub(aabb[1], aabb[0], dest);
|
||||
}
|
||||
|
||||
@@ -189,7 +189,7 @@ glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb2d_radius(vec2 aabb[2]) {
|
||||
glm_aabb2d_radius(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_aabb2d_diag(aabb) * 0.5f;
|
||||
}
|
||||
|
||||
@@ -201,7 +201,7 @@ glm_aabb2d_radius(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
|
||||
glm_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest) {
|
||||
glm_vec2_center(aabb[0], aabb[1], dest);
|
||||
}
|
||||
|
||||
@@ -213,7 +213,7 @@ glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
|
||||
glm_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
|
||||
return (aabb[0][0] <= other[1][0] && aabb[1][0] >= other[0][0])
|
||||
&& (aabb[0][1] <= other[1][1] && aabb[1][1] >= other[0][1]);
|
||||
}
|
||||
@@ -228,15 +228,15 @@ glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
|
||||
glm_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 c) {
|
||||
float dmin;
|
||||
int a, b;
|
||||
|
||||
a = (c[0] < aabb[0][0]) + (c[0] > aabb[1][0]);
|
||||
b = (c[1] < aabb[0][1]) + (c[1] > aabb[1][1]);
|
||||
|
||||
dmin = glm_pow2((c[0] - aabb[!(a - 1)][0]) * (a != 0))
|
||||
+ glm_pow2((c[1] - aabb[!(b - 1)][1]) * (b != 0));
|
||||
dmin = glm_pow2((c[0] - aabb[c[0] > aabb[1][0]][0]) * (a != 0))
|
||||
+ glm_pow2((c[1] - aabb[c[1] > aabb[1][1]][1]) * (b != 0));
|
||||
|
||||
return dmin <= glm_pow2(c[2]);
|
||||
}
|
||||
@@ -249,7 +249,7 @@ glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_point(vec2 aabb[2], vec2 point) {
|
||||
glm_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point) {
|
||||
return (point[0] >= aabb[0][0] && point[0] <= aabb[1][0])
|
||||
&& (point[1] >= aabb[0][1] && point[1] <= aabb[1][1]);
|
||||
}
|
||||
@@ -262,10 +262,9 @@ glm_aabb2d_point(vec2 aabb[2], vec2 point) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_contains(vec2 aabb[2], vec2 other[2]) {
|
||||
glm_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
|
||||
return (aabb[0][0] <= other[0][0] && aabb[1][0] >= other[1][0])
|
||||
&& (aabb[0][1] <= other[0][1] && aabb[1][1] >= other[1][1]);
|
||||
}
|
||||
|
||||
#endif /* cglm_aabb2d_h */
|
||||
|
||||
@@ -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
@@ -10,17 +10,17 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_translated_to(mat4 m, vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translated(mat4 m, vec3 v);
|
||||
CGLM_INLINE void glm_translated_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translated(mat4 m, const vec3 v);
|
||||
CGLM_INLINE void glm_translated_x(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translated_y(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translated_z(mat4 m, float to);
|
||||
CGLM_INLINE void glm_rotated_x(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated_y(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated_z(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_spinned(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotated_x(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated_y(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated_z(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotated(mat4 m, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_rotated_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_spinned(mat4 m, float angle, const vec3 axis);
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
@@ -41,7 +41,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translated(mat4 m, vec3 v) {
|
||||
glm_translated(mat4 m, const vec3 v) {
|
||||
glm_vec3_add(m[3], v, m[3]);
|
||||
}
|
||||
|
||||
@@ -59,7 +59,7 @@ glm_translated(mat4 m, vec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translated_to(mat4 m, vec3 v, mat4 dest) {
|
||||
glm_translated_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
|
||||
glm_mat4_copy(m, dest);
|
||||
glm_translated(dest, v);
|
||||
}
|
||||
@@ -118,7 +118,7 @@ glm_translated_z(mat4 m, float z) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotated_x(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotated_x(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -145,7 +145,7 @@ glm_rotated_x(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotated_y(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotated_y(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -172,7 +172,7 @@ glm_rotated_y(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotated_z(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotated_z(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -198,7 +198,7 @@ glm_rotated_z(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotated(mat4 m, float angle, vec3 axis) {
|
||||
glm_rotated(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_make(rot, angle, axis);
|
||||
glm_mul_rot(rot, m, m);
|
||||
@@ -217,7 +217,7 @@ glm_rotated(mat4 m, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
glm_rotated_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN(8) vec3 pivotInv;
|
||||
|
||||
glm_vec3_negate_to(pivot, pivotInv);
|
||||
@@ -238,7 +238,7 @@ glm_rotated_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_spinned(mat4 m, float angle, vec3 axis) {
|
||||
glm_spinned(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_atm(rot, m[3], angle, axis);
|
||||
glm_mat4_mul(rot, m, m);
|
||||
|
||||
+20
-20
@@ -10,18 +10,18 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
|
||||
CGLM_INLINE void glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translate(mat4 m, const vec3 v);
|
||||
CGLM_INLINE void glm_translate_x(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translate_y(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translate_z(mat4 m, float to);
|
||||
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate(mat4 m, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_spin(mat4 m, float angle, const vec3 axis);
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
@@ -40,7 +40,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translate(mat4 m, vec3 v) {
|
||||
glm_translate(mat4 m, const vec3 v) {
|
||||
#if defined(CGLM_SIMD)
|
||||
glmm_128 m0, m1, m2, m3;
|
||||
|
||||
@@ -72,7 +72,7 @@ glm_translate(mat4 m, vec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translate_to(mat4 m, vec3 v, mat4 dest) {
|
||||
glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
|
||||
glm_mat4_copy(m, dest);
|
||||
glm_translate(dest, v);
|
||||
}
|
||||
@@ -141,7 +141,7 @@ glm_translate_z(mat4 m, float z) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_x(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -166,7 +166,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_y(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -191,7 +191,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_z(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -215,7 +215,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
|
||||
* If you need to rotate object around itself e.g. center of object or at
|
||||
* some point [of object] then `glm_rotate_at()` would be better choice to do so.
|
||||
*
|
||||
* Even if object's model transform is identiy, rotation may not be around
|
||||
* Even if object's model transform is identity, rotation may not be around
|
||||
* center of object if object does not lay out at ORIGIN perfectly.
|
||||
*
|
||||
* Using `glm_rotate_at()` with center of bounding shape ( AABB, Sphere ... )
|
||||
@@ -233,7 +233,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate(mat4 m, float angle, vec3 axis) {
|
||||
glm_rotate(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_make(rot, angle, axis);
|
||||
glm_mul_rot(m, rot, m);
|
||||
@@ -250,7 +250,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN(8) vec3 pivotInv;
|
||||
|
||||
glm_vec3_negate_to(pivot, pivotInv);
|
||||
@@ -275,7 +275,7 @@ glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN(8) vec3 pivotInv;
|
||||
|
||||
glm_vec3_negate_to(pivot, pivotInv);
|
||||
@@ -295,9 +295,9 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_spin(mat4 m, float angle, vec3 axis) {
|
||||
glm_spin(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_atm(rot, m[3], angle, axis);
|
||||
glm_rotate_make(rot, angle, axis);
|
||||
glm_mat4_mul(m, rot, m);
|
||||
}
|
||||
|
||||
|
||||
+18
-30
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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
@@ -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
@@ -14,16 +14,17 @@
|
||||
&& defined(SIMD_VECTOR_TYPES)
|
||||
|
||||
#include "common.h"
|
||||
#include "struct.h"
|
||||
|
||||
/*!
|
||||
* @brief converts mat4 to Apple's simd type simd_float4x4
|
||||
* @return simd_float4x4
|
||||
*/
|
||||
* @brief converts mat4 to Apple's simd type simd_float4x4
|
||||
* @return simd_float4x4
|
||||
*/
|
||||
CGLM_INLINE
|
||||
simd_float4x4
|
||||
glm_mat4_applesimd(mat4 m) {
|
||||
glm_mat4_applesimd(CGLM_CONST mat4 m) {
|
||||
simd_float4x4 t;
|
||||
|
||||
|
||||
t.columns[0][0] = m[0][0];
|
||||
t.columns[0][1] = m[0][1];
|
||||
t.columns[0][2] = m[0][2];
|
||||
@@ -53,9 +54,9 @@ glm_mat4_applesimd(mat4 m) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
simd_float3x3
|
||||
glm_mat3_applesimd(mat3 m) {
|
||||
glm_mat3_applesimd(CGLM_CONST mat3 m) {
|
||||
simd_float3x3 t;
|
||||
|
||||
|
||||
t.columns[0][0] = m[0][0];
|
||||
t.columns[0][1] = m[0][1];
|
||||
t.columns[0][2] = m[0][2];
|
||||
@@ -77,19 +78,59 @@ glm_mat3_applesimd(mat3 m) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
simd_float4
|
||||
glm_vec4_applesimd(vec4 v) {
|
||||
glm_vec4_applesimd(const vec4 v) {
|
||||
return (simd_float4){v[0], v[1], v[2], v[3]};
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief converts vec3 to Apple's simd type simd_float3
|
||||
* @return v
|
||||
* @return simd_float3
|
||||
*/
|
||||
CGLM_INLINE
|
||||
simd_float3
|
||||
glm_vec3_applesimd(vec3 v) {
|
||||
glm_vec3_applesimd(const vec3 v) {
|
||||
return (simd_float3){v[0], v[1], v[2]};
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief generic function to convert cglm types to Apple's simd types
|
||||
*
|
||||
* Example usage:
|
||||
* simd_float4x4 m = applesimd(mat4_value);
|
||||
* simd_float3 v = applesimd(vec3_value);
|
||||
*
|
||||
* @param x cglm type (mat4, mat3, vec4, vec3)
|
||||
* @return corresponding Apple simd type
|
||||
*/
|
||||
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
|
||||
# define applesimd(x) _Generic((x), \
|
||||
mat4: glm_mat4_applesimd, \
|
||||
mat3: glm_mat3_applesimd, \
|
||||
vec4: glm_vec4_applesimd, \
|
||||
vec3: glm_vec3_applesimd \
|
||||
)((x))
|
||||
#endif
|
||||
|
||||
#ifdef cglm_types_struct_h
|
||||
CGLM_INLINE simd_float4x4 glms_mat4_(applesimd)(mat4s m) { return glm_mat4_applesimd(m.raw); }
|
||||
CGLM_INLINE simd_float3x3 glms_mat3_(applesimd)(mat3s m) { return glm_mat3_applesimd(m.raw); }
|
||||
CGLM_INLINE simd_float4 glms_vec4_(applesimd)(vec4s v) { return glm_vec4_applesimd(v.raw); }
|
||||
CGLM_INLINE simd_float3 glms_vec3_(applesimd)(vec3s v) { return glm_vec3_applesimd(v.raw); }
|
||||
|
||||
#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)
|
||||
# undef applesimd
|
||||
# define applesimd(x) _Generic((x), \
|
||||
mat4: glm_mat4_applesimd, \
|
||||
mat3: glm_mat3_applesimd, \
|
||||
vec4: glm_vec4_applesimd, \
|
||||
vec3: glm_vec3_applesimd, \
|
||||
mat4s: glms_mat4_(applesimd), \
|
||||
mat3s: glms_mat3_(applesimd), \
|
||||
vec4s: glms_vec4_(applesimd), \
|
||||
vec3s: glms_vec3_(applesimd) \
|
||||
)((x))
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* cglm_applesimd_h */
|
||||
+22
-21
@@ -22,7 +22,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
|
||||
glm_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]) {
|
||||
vec3 v[2], xa, xb, ya, yb, za, zb;
|
||||
|
||||
glm_vec3_scale(m[0], box[0][0], xa);
|
||||
@@ -62,7 +62,7 @@ glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
|
||||
glm_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_CONST vec3 box2[2], vec3 dest[2]) {
|
||||
dest[0][0] = glm_min(box1[0][0], box2[0][0]);
|
||||
dest[0][1] = glm_min(box1[0][1], box2[0][1]);
|
||||
dest[0][2] = glm_min(box1[0][2], box2[0][2]);
|
||||
@@ -75,7 +75,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
|
||||
/*!
|
||||
* @brief crops a bounding box with another one.
|
||||
*
|
||||
* this could be useful for gettng a bbox which fits with view frustum and
|
||||
* this could be useful for getting a bbox which fits with view frustum and
|
||||
* object bounding boxes. In this case you crop view frustum box with objects
|
||||
* box
|
||||
*
|
||||
@@ -85,7 +85,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
|
||||
glm_aabb_crop(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]) {
|
||||
dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
|
||||
dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
|
||||
dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
|
||||
@@ -98,7 +98,7 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
|
||||
/*!
|
||||
* @brief crops a bounding box with another one.
|
||||
*
|
||||
* this could be useful for gettng a bbox which fits with view frustum and
|
||||
* this could be useful for getting a bbox which fits with view frustum and
|
||||
* object bounding boxes. In this case you crop view frustum box with objects
|
||||
* box
|
||||
*
|
||||
@@ -109,9 +109,9 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_crop_until(vec3 box[2],
|
||||
vec3 cropBox[2],
|
||||
vec3 clampBox[2],
|
||||
glm_aabb_crop_until(CGLM_CONST vec3 box[2],
|
||||
CGLM_CONST vec3 cropBox[2],
|
||||
CGLM_CONST vec3 clampBox[2],
|
||||
vec3 dest[2]) {
|
||||
glm_aabb_crop(box, cropBox, dest);
|
||||
glm_aabb_merge(clampBox, dest, dest);
|
||||
@@ -133,8 +133,9 @@ glm_aabb_crop_until(vec3 box[2],
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
|
||||
float *p, dp;
|
||||
glm_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]) {
|
||||
const float *p;
|
||||
float dp;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
@@ -169,7 +170,7 @@ glm_aabb_invalidate(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_isvalid(vec3 box[2]) {
|
||||
glm_aabb_isvalid(CGLM_CONST vec3 box[2]) {
|
||||
return glm_vec3_max(box[0]) != FLT_MAX
|
||||
&& glm_vec3_min(box[1]) != -FLT_MAX;
|
||||
}
|
||||
@@ -181,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb_size(vec3 box[2]) {
|
||||
glm_aabb_size(CGLM_CONST vec3 box[2]) {
|
||||
return glm_vec3_distance(box[0], box[1]);
|
||||
}
|
||||
|
||||
@@ -192,7 +193,7 @@ glm_aabb_size(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb_radius(vec3 box[2]) {
|
||||
glm_aabb_radius(CGLM_CONST vec3 box[2]) {
|
||||
return glm_aabb_size(box) * 0.5f;
|
||||
}
|
||||
|
||||
@@ -204,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_center(vec3 box[2], vec3 dest) {
|
||||
glm_aabb_center(CGLM_CONST vec3 box[2], vec3 dest) {
|
||||
glm_vec3_center(box[0], box[1], dest);
|
||||
}
|
||||
|
||||
@@ -216,7 +217,7 @@ glm_aabb_center(vec3 box[2], vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
|
||||
glm_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
|
||||
return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
|
||||
&& (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
|
||||
&& (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
|
||||
@@ -235,7 +236,7 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
glm_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s) {
|
||||
float dmin;
|
||||
int a, b, c;
|
||||
|
||||
@@ -243,9 +244,9 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
|
||||
c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
|
||||
|
||||
dmin = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
|
||||
+ glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
|
||||
+ glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
|
||||
dmin = glm_pow2((s[0] - box[s[0] > box[1][0]][0]) * (a != 0))
|
||||
+ glm_pow2((s[1] - box[s[1] > box[1][1]][1]) * (b != 0))
|
||||
+ glm_pow2((s[2] - box[s[2] > box[1][2]][2]) * (c != 0));
|
||||
|
||||
return dmin <= glm_pow2(s[3]);
|
||||
}
|
||||
@@ -258,7 +259,7 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_point(vec3 box[2], vec3 point) {
|
||||
glm_aabb_point(CGLM_CONST vec3 box[2], const vec3 point) {
|
||||
return (point[0] >= box[0][0] && point[0] <= box[1][0])
|
||||
&& (point[1] >= box[0][1] && point[1] <= box[1][1])
|
||||
&& (point[2] >= box[0][2] && point[2] <= box[1][2]);
|
||||
@@ -272,7 +273,7 @@ glm_aabb_point(vec3 box[2], vec3 point) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_contains(vec3 box[2], vec3 other[2]) {
|
||||
glm_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
|
||||
return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
|
||||
&& (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
|
||||
&& (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
|
||||
|
||||
+1
-1
@@ -11,7 +11,6 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "cglm.h"
|
||||
#include "call/vec2.h"
|
||||
#include "call/vec3.h"
|
||||
#include "call/vec4.h"
|
||||
@@ -32,6 +31,7 @@ extern "C" {
|
||||
#include "call/quat.h"
|
||||
#include "call/euler.h"
|
||||
#include "call/plane.h"
|
||||
#include "call/noise.h"
|
||||
#include "call/frustum.h"
|
||||
#include "call/aabb2d.h"
|
||||
#include "call/box.h"
|
||||
|
||||
+17
-19
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _diag */
|
||||
#define glmc_aabb2d_size(aabb) glmc_aabb2d_diag(aabb)
|
||||
@@ -22,25 +22,25 @@ glmc_aabb2d_zero(vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_copy(vec2 aabb[2], vec2 dest[2]);
|
||||
glmc_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]);
|
||||
glmc_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]);
|
||||
glmc_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]);
|
||||
glmc_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_crop_until(vec2 aabb[2],
|
||||
vec2 cropAabb[2],
|
||||
vec2 clampAabb[2],
|
||||
glmc_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
|
||||
CGLM_CONST vec2 cropAabb[2],
|
||||
CGLM_CONST vec2 clampAabb[2],
|
||||
vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
@@ -49,43 +49,41 @@ glmc_aabb2d_invalidate(vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_isvalid(vec2 aabb[2]);
|
||||
glmc_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb2d_diag(vec2 aabb[2]);
|
||||
glmc_aabb2d_diag(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_sizev(vec2 aabb[2], vec2 dest);
|
||||
glmc_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb2d_radius(vec2 aabb[2]);
|
||||
glmc_aabb2d_radius(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_center(vec2 aabb[2], vec2 dest);
|
||||
glmc_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_aabb(vec2 aabb[2], vec2 other[2]);
|
||||
glmc_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_point(vec2 aabb[2], vec2 point);
|
||||
glmc_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_contains(vec2 aabb[2], vec2 other[2]);
|
||||
glmc_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_circle(vec2 aabb[2], vec3 s);
|
||||
glmc_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* cglmc_aabb2d_h */
|
||||
|
||||
|
||||
+29
-29
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
|
||||
+16
-17
@@ -11,30 +11,30 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
|
||||
glmc_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
|
||||
glmc_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_CONST vec3 box2[2], vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
|
||||
glmc_aabb_crop(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_crop_until(vec3 box[2],
|
||||
vec3 cropBox[2],
|
||||
vec3 clampBox[2],
|
||||
glmc_aabb_crop_until(CGLM_CONST vec3 box[2],
|
||||
CGLM_CONST vec3 cropBox[2],
|
||||
CGLM_CONST vec3 clampBox[2],
|
||||
vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
|
||||
glmc_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -42,38 +42,37 @@ glmc_aabb_invalidate(vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_isvalid(vec3 box[2]);
|
||||
glmc_aabb_isvalid(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb_size(vec3 box[2]);
|
||||
glmc_aabb_size(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb_radius(vec3 box[2]);
|
||||
glmc_aabb_radius(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_center(vec3 box[2], vec3 dest);
|
||||
glmc_aabb_center(CGLM_CONST vec3 box[2], vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
|
||||
glmc_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_point(vec3 box[2], vec3 point);
|
||||
glmc_aabb_point(CGLM_CONST vec3 box[2], const vec3 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
|
||||
glmc_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_sphere(vec3 box[2], vec4 s);
|
||||
glmc_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* cglmc_box_h */
|
||||
|
||||
+25
-17
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -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
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
|
||||
+16
-16
@@ -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
|
||||
|
||||
@@ -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]);
|
||||
|
||||
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
|
||||
}
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_copy(mat2x3 mat, mat2x3 dest);
|
||||
glmc_mat2x3_copy(CGLM_CONST mat2x3 src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_zero(mat2x3 mat);
|
||||
glmc_mat2x3_zero(mat2x3 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat2x3_make(const float * __restrict src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat2 dest);
|
||||
glmc_mat2x3_mul(CGLM_CONST mat2x3 m1, CGLM_CONST mat3x2 m2, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_mulv(mat2x3 m, vec3 v, vec2 dest);
|
||||
glmc_mat2x3_mulv(CGLM_CONST mat2x3 m, const vec2 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_transpose(mat2x3 m, mat3x2 dest);
|
||||
glmc_mat2x3_transpose(CGLM_CONST mat2x3 src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_copy(mat2x4 mat, mat2x4 dest);
|
||||
glmc_mat2x4_copy(CGLM_CONST mat2x4 src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_zero(mat2x4 mat);
|
||||
glmc_mat2x4_zero(mat2x4 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat2x4_make(const float * __restrict src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat2 dest);
|
||||
glmc_mat2x4_mul(CGLM_CONST mat2x4 m1, CGLM_CONST mat4x2 m2, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_mulv(mat2x4 m, vec4 v, vec2 dest);
|
||||
glmc_mat2x4_mulv(CGLM_CONST mat2x4 m, const vec2 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_transpose(mat2x4 m, mat4x2 dest);
|
||||
glmc_mat2x4_transpose(CGLM_CONST mat2x4 src, mat4x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
+14
-10
@@ -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
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_copy(mat3x2 mat, mat3x2 dest);
|
||||
glmc_mat3x2_copy(CGLM_CONST mat3x2 src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_zero(mat3x2 mat);
|
||||
glmc_mat3x2_zero(mat3x2 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat3x2_make(const float * __restrict src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat3 dest);
|
||||
glmc_mat3x2_mul(CGLM_CONST mat3x2 m1, CGLM_CONST mat2x3 m2, mat2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_mulv(mat3x2 m, vec2 v, vec3 dest);
|
||||
glmc_mat3x2_mulv(CGLM_CONST mat3x2 m, const vec3 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_transpose(mat3x2 m, mat2x3 dest);
|
||||
glmc_mat3x2_transpose(CGLM_CONST mat3x2 src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_copy(mat3x4 mat, mat3x4 dest);
|
||||
glmc_mat3x4_copy(CGLM_CONST mat3x4 src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_zero(mat3x4 mat);
|
||||
glmc_mat3x4_zero(mat3x4 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat3x4_make(const float * __restrict src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat3 dest);
|
||||
glmc_mat3x4_mul(CGLM_CONST mat3x4 m1, CGLM_CONST mat4x3 m2, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_mulv(mat3x4 m, vec4 v, vec3 dest);
|
||||
glmc_mat3x4_mulv(CGLM_CONST mat3x4 m, const vec3 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_transpose(mat3x4 m, mat4x3 dest);
|
||||
glmc_mat3x4_transpose(CGLM_CONST mat3x4 src, mat4x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
+22
-18
@@ -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
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_copy(mat4x2 mat, mat4x2 dest);
|
||||
glmc_mat4x2_copy(CGLM_CONST mat4x2 src, mat4x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_zero(mat4x2 mat);
|
||||
glmc_mat4x2_zero(mat4x2 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat4 dest);
|
||||
glmc_mat4x2_mul(CGLM_CONST mat4x2 m1, CGLM_CONST mat2x4 m2, mat2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_mulv(mat4x2 m, vec2 v, vec4 dest);
|
||||
glmc_mat4x2_mulv(CGLM_CONST mat4x2 m, const vec4 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_transpose(mat4x2 m, mat2x4 dest);
|
||||
glmc_mat4x2_transpose(CGLM_CONST mat4x2 src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,15 +11,15 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_copy(mat4x3 mat, mat4x3 dest);
|
||||
glmc_mat4x3_copy(CGLM_CONST mat4x3 src, mat4x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_zero(mat4x3 mat);
|
||||
glmc_mat4x3_zero(mat4x3 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat4x3_make(const float * __restrict src, mat4x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat4 dest);
|
||||
glmc_mat4x3_mul(CGLM_CONST mat4x3 m1, CGLM_CONST mat3x4 m2, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_mulv(mat4x3 m, vec3 v, vec4 dest);
|
||||
glmc_mat4x3_mulv(CGLM_CONST mat4x3 m, const vec4 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_transpose(mat4x3 m, mat3x4 dest);
|
||||
glmc_mat4x3_transpose(CGLM_CONST mat4x3 src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (c), Recep Aslantas.
|
||||
*
|
||||
* MIT License (MIT), http://opensource.org/licenses/MIT
|
||||
* Full license can be found in the LICENSE file
|
||||
*/
|
||||
|
||||
#ifndef cglmc_noise_h
|
||||
#define cglmc_noise_h
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec4(const vec4 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec3(const vec3 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec2(const vec2 point);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* cglmc_noise_h */
|
||||
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,31 +11,29 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
|
||||
glmc_unprojecti(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
|
||||
glmc_unproject(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
|
||||
glmc_project(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_project_z(vec3 pos, mat4 m);
|
||||
glmc_project_z(const vec3 pos, CGLM_CONST mat4 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);
|
||||
glmc_pickmatrix(const vec2 center, const vec2 size, const vec4 vp, mat4 dest);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* cglmc_project_h */
|
||||
|
||||
|
||||
+37
-33
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -31,23 +31,23 @@ glmc_quat(versor q, float angle, float x, float y, float z);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quatv(versor q, float angle, vec3 axis);
|
||||
glmc_quatv(versor q, float angle, const vec3 axis);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_copy(versor q, versor dest);
|
||||
glmc_quat_copy(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_from_vecs(vec3 a, vec3 b, versor dest);
|
||||
glmc_quat_from_vecs(const vec3 a, const vec3 b, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_norm(versor q);
|
||||
glmc_quat_norm(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_normalize_to(versor q, versor dest);
|
||||
glmc_quat_normalize_to(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -55,111 +55,115 @@ glmc_quat_normalize(versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_dot(versor p, versor q);
|
||||
glmc_quat_dot(const versor p, const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_conjugate(versor q, versor dest);
|
||||
glmc_quat_conjugate(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_inv(versor q, versor dest);
|
||||
glmc_quat_inv(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_add(versor p, versor q, versor dest);
|
||||
glmc_quat_add(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_sub(versor p, versor q, versor dest);
|
||||
glmc_quat_sub(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_real(versor q);
|
||||
glmc_quat_real(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_imag(versor q, vec3 dest);
|
||||
glmc_quat_imag(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_imagn(versor q, vec3 dest);
|
||||
glmc_quat_imagn(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_imaglen(versor q);
|
||||
glmc_quat_imaglen(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_angle(versor q);
|
||||
glmc_quat_angle(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_axis(versor q, vec3 dest);
|
||||
glmc_quat_axis(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mul(versor p, versor q, versor dest);
|
||||
glmc_quat_mul(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat4(versor q, mat4 dest);
|
||||
glmc_quat_mat4(const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat4t(versor q, mat4 dest);
|
||||
glmc_quat_mat4t(const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat3(versor q, mat3 dest);
|
||||
glmc_quat_mat3(const versor q, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat3t(versor q, mat3 dest);
|
||||
glmc_quat_mat3t(const versor q, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_lerp(versor from, versor to, float t, versor dest);
|
||||
glmc_quat_lerp(const versor from, const versor to, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_lerpc(versor from, versor to, float t, versor dest);
|
||||
glmc_quat_lerpc(const versor from, const versor to, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_nlerp(versor q, versor r, float t, versor dest);
|
||||
glmc_quat_nlerp(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_slerp(versor q, versor r, float t, versor dest);
|
||||
glmc_quat_slerp(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
|
||||
glmc_quat_slerp_longest(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_for(vec3 dir, vec3 up, versor dest);
|
||||
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
|
||||
glmc_quat_for(const vec3 dir, const vec3 up, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
|
||||
glmc_quat_forp(const vec3 from, const vec3 to, const vec3 up, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
|
||||
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
|
||||
glmc_quat_rotate(CGLM_CONST mat4 m, const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
|
||||
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
+11
-10
@@ -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
|
||||
}
|
||||
|
||||
@@ -11,27 +11,27 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_sphere_radii(vec4 s);
|
||||
glmc_sphere_radii(const vec4 s);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_sphere_transform(vec4 s, mat4 m, vec4 dest);
|
||||
glmc_sphere_transform(const vec4 s, CGLM_CONST mat4 m, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_sphere_merge(vec4 s1, vec4 s2, vec4 dest);
|
||||
glmc_sphere_merge(const vec4 s1, const vec4 s2, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_sphere_sphere(vec4 s1, vec4 s2);
|
||||
glmc_sphere_sphere(const vec4 s1, const vec4 s2);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_sphere_point(vec4 s, vec3 point);
|
||||
glmc_sphere_point(const vec4 s, const vec3 point);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+87
-43
@@ -11,15 +11,27 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2(float * __restrict v, vec2 dest);
|
||||
glmc_vec2(const float * __restrict v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_copy(vec2 a, vec2 dest);
|
||||
glmc_vec2_fill(vec2 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_eq(const vec2 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_eqv(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_copy(const vec2 a, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -31,107 +43,107 @@ glmc_vec2_one(vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_dot(vec2 a, vec2 b);
|
||||
glmc_vec2_dot(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_cross(vec2 a, vec2 b);
|
||||
glmc_vec2_cross(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_norm2(vec2 v);
|
||||
glmc_vec2_norm2(const vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_norm(vec2 v);
|
||||
glmc_vec2_norm(const vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_add(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_adds(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_adds(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_sub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subs(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_subs(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_mul(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_scale(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_scale(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_scale_as(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_div(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_divs(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_divs(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_addadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_subadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_muladd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_muladds(vec2 a, float s, vec2 dest);
|
||||
glmc_vec2_muladds(const vec2 a, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_subsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_addsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_addsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mulsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_mulsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mulsubs(vec2 a, float s, vec2 dest);
|
||||
glmc_vec2_mulsubs(const vec2 a, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_negate_to(vec2 v, vec2 dest);
|
||||
glmc_vec2_negate_to(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -143,31 +155,31 @@ glmc_vec2_normalize(vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_normalize_to(vec2 v, vec2 dest);
|
||||
glmc_vec2_normalize_to(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
|
||||
glmc_vec2_rotate(const vec2 v, float angle, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_center(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_center(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_distance2(vec2 a, vec2 b);
|
||||
glmc_vec2_distance2(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_distance(vec2 a, vec2 b);
|
||||
glmc_vec2_distance(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxv(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minv(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -175,23 +187,51 @@ glmc_vec2_clamp(vec2 v, float minval, float maxval);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_abs(vec2 v, vec2 dest);
|
||||
glmc_vec2_abs(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
|
||||
glmc_vec2_fract(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_floor(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_mods(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
|
||||
glmc_vec2_swizzle(const vec2 v, int mask, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_step(const vec2 edge, const vec2 x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_steps(float edge, const vec2 x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_stepr(const vec2 edge, float x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_conjugate(const vec2 a, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -199,11 +239,15 @@ glmc_vec2_make(const float * __restrict src, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest);
|
||||
glmc_vec2_reflect(const vec2 v, const vec2 n, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest);
|
||||
glmc_vec2_refract(const vec2 v, const vec2 n, float eta, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_swap(vec2 a, vec2 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+109
-88
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _copy, _ucopy versions */
|
||||
#define glmc_vec_dup(v, dest) glmc_vec3_copy(v, dest)
|
||||
@@ -19,14 +19,15 @@ extern "C" {
|
||||
#define glmc_vec3_flipsign_to(v, dest) glmc_vec3_negate_to(v, dest)
|
||||
#define glmc_vec3_inv(v) glmc_vec3_negate(v)
|
||||
#define glmc_vec3_inv_to(v, dest) glmc_vec3_negate_to(v, dest)
|
||||
#define glmc_vec3_step_uni(edge, x, dest) glmc_vec3_steps(edge, x, dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3(vec4 v4, vec3 dest);
|
||||
glmc_vec3(const vec4 v4, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_copy(vec3 a, vec3 dest);
|
||||
glmc_vec3_copy(const vec3 a, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -38,35 +39,35 @@ glmc_vec3_one(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_dot(vec3 a, vec3 b);
|
||||
glmc_vec3_dot(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm(vec3 v);
|
||||
glmc_vec3_norm(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm2(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm_one(vec3 v);
|
||||
glmc_vec3_norm2(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm_inf(vec3 v);
|
||||
glmc_vec3_norm_one(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm_inf(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_normalize_to(vec3 v, vec3 dest);
|
||||
glmc_vec3_normalize_to(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -74,87 +75,87 @@ glmc_vec3_normalize(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_adds(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_adds(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subs(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_subs(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
|
||||
glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_scale(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_scale(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_scale_as(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_divs(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_divs(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_muladds(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_subsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_addsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_addsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mulsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_mulsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mulsubs(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_mulsubs(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -162,47 +163,47 @@ glmc_vec3_negate(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_negate_to(vec3 v, vec3 dest);
|
||||
glmc_vec3_negate_to(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_angle(vec3 a, vec3 b);
|
||||
glmc_vec3_angle(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
|
||||
glmc_vec3_rotate(vec3 v, float angle, const vec3 axis);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
|
||||
glmc_vec3_rotate_m4(CGLM_CONST mat4 m, const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
|
||||
glmc_vec3_rotate_m3(CGLM_CONST mat3 m, const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_distance2(vec3 a, vec3 b);
|
||||
glmc_vec3_distance2(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_distance(vec3 a, vec3 b);
|
||||
glmc_vec3_distance(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -210,51 +211,51 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_ortho(vec3 v, vec3 dest);
|
||||
|
||||
glmc_vec3_ortho(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
|
||||
|
||||
glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
|
||||
|
||||
glmc_vec3_lerpc(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_mix(const vec3 from, const vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_lerp(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_mixc(const vec3 from, const vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_lerpc(from, to, t, dest);
|
||||
}
|
||||
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_step_uni(float edge, vec3 x, vec3 dest);
|
||||
|
||||
glmc_vec3_step(const vec3 edge, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
|
||||
|
||||
glmc_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
|
||||
|
||||
glmc_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
|
||||
|
||||
glmc_vec3_smoothinterp(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
|
||||
|
||||
glmc_vec3_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
|
||||
glmc_vec3_swizzle(const vec3 v, int mask, vec3 dest);
|
||||
|
||||
/* ext */
|
||||
|
||||
@@ -265,70 +266,86 @@ glmc_vec3_mulv(vec3 a, vec3 b, vec3 d);
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_broadcast(float val, vec3 d);
|
||||
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_fill(vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq(vec3 v, float val);
|
||||
glmc_vec3_eq(const vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq_eps(vec3 v, float val);
|
||||
glmc_vec3_eq_eps(const vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq_all(vec3 v);
|
||||
glmc_vec3_eq_all(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eqv(vec3 a, vec3 b);
|
||||
glmc_vec3_eqv(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eqv_eps(vec3 a, vec3 b);
|
||||
glmc_vec3_eqv_eps(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_max(vec3 v);
|
||||
glmc_vec3_max(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_min(vec3 v);
|
||||
glmc_vec3_min(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isnan(vec3 v);
|
||||
glmc_vec3_isnan(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isinf(vec3 v);
|
||||
glmc_vec3_isinf(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isvalid(vec3 v);
|
||||
glmc_vec3_isvalid(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sign(vec3 v, vec3 dest);
|
||||
|
||||
glmc_vec3_sign(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_abs(vec3 v, vec3 dest);
|
||||
|
||||
glmc_vec3_abs(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_fract(vec3 v, vec3 dest);
|
||||
|
||||
glmc_vec3_fract(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_floor(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mods(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_steps(float edge, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_stepr(const vec3 edge, float x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_hadd(vec3 v);
|
||||
glmc_vec3_hadd(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sqrt(vec3 v, vec3 dest);
|
||||
glmc_vec3_sqrt(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -336,15 +353,19 @@ glmc_vec3_make(const float * __restrict src, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
|
||||
glmc_vec3_faceforward(const vec3 n, const vec3 v, const vec3 nref, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest);
|
||||
glmc_vec3_reflect(const vec3 v, const vec3 n, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
|
||||
glmc_vec3_refract(const vec3 v, const vec3 n, float eta, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_swap(vec3 a, vec3 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+105
-85
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _copy, _ucopy versions */
|
||||
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
|
||||
@@ -20,10 +20,11 @@ extern "C" {
|
||||
#define glmc_vec4_flipsign_to(v, dest) glmc_vec4_negate_to(v, dest)
|
||||
#define glmc_vec4_inv(v) glmc_vec4_negate(v)
|
||||
#define glmc_vec4_inv_to(v, dest) glmc_vec4_negate_to(v, dest)
|
||||
#define glmc_vec4_step_uni(edge, x, dest) glmc_vec4_steps(edge, x, dest)
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4(vec3 v3, float last, vec4 dest);
|
||||
glmc_vec4(const vec3 v3, float last, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -35,39 +36,39 @@ glmc_vec4_one(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_copy3(vec4 v, vec3 dest);
|
||||
glmc_vec4_copy3(const vec4 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_copy(vec4 v, vec4 dest);
|
||||
glmc_vec4_copy(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_ucopy(vec4 v, vec4 dest);
|
||||
glmc_vec4_ucopy(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_dot(vec4 a, vec4 b);
|
||||
glmc_vec4_dot(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm(vec4 v);
|
||||
glmc_vec4_norm(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm2(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm_one(vec4 v);
|
||||
glmc_vec4_norm2(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm_inf(vec4 v);
|
||||
glmc_vec4_norm_one(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm_inf(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_normalize_to(vec4 v, vec4 dest);
|
||||
glmc_vec4_normalize_to(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -75,87 +76,87 @@ glmc_vec4_normalize(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_adds(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_adds(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subs(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_subs(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
|
||||
glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_scale(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_scale(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_scale_as(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_divs(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_divs(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
|
||||
glmc_vec4_muladds(const vec4 a, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_subsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_addsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_addsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mulsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_mulsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mulsubs(vec4 a, float s, vec4 dest);
|
||||
glmc_vec4_mulsubs(const vec4 a, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -163,76 +164,76 @@ glmc_vec4_negate(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_negate_to(vec4 v, vec4 dest);
|
||||
|
||||
glmc_vec4_negate_to(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_distance(vec4 a, vec4 b);
|
||||
|
||||
glmc_vec4_distance(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_distance2(vec4 a, vec4 b);
|
||||
glmc_vec4_distance2(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
|
||||
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
|
||||
|
||||
glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
|
||||
|
||||
glmc_vec4_lerpc(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_mix(const vec4 from, const vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_lerp(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_mixc(const vec4 from, const vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_lerpc(from, to, t, dest);
|
||||
}
|
||||
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_step_uni(float edge, vec4 x, vec4 dest);
|
||||
|
||||
glmc_vec4_step(const vec4 edge, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
|
||||
|
||||
glmc_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
|
||||
|
||||
glmc_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
|
||||
|
||||
glmc_vec4_smoothinterp(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
|
||||
glmc_vec4_smoothinterpc(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_cubic(float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_swizzle(const vec4 v, int mask, vec4 dest);
|
||||
|
||||
/* ext */
|
||||
|
||||
CGLM_EXPORT
|
||||
@@ -242,70 +243,86 @@ glmc_vec4_mulv(vec4 a, vec4 b, vec4 d);
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_broadcast(float val, vec4 d);
|
||||
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_fill(vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq(vec4 v, float val);
|
||||
glmc_vec4_eq(const vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq_eps(vec4 v, float val);
|
||||
glmc_vec4_eq_eps(const vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq_all(vec4 v);
|
||||
glmc_vec4_eq_all(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eqv(vec4 a, vec4 b);
|
||||
glmc_vec4_eqv(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eqv_eps(vec4 a, vec4 b);
|
||||
glmc_vec4_eqv_eps(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_max(vec4 v);
|
||||
glmc_vec4_max(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_min(vec4 v);
|
||||
glmc_vec4_min(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isnan(vec4 v);
|
||||
glmc_vec4_isnan(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isinf(vec4 v);
|
||||
glmc_vec4_isinf(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isvalid(vec4 v);
|
||||
glmc_vec4_isvalid(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sign(vec4 v, vec4 dest);
|
||||
|
||||
glmc_vec4_sign(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_abs(vec4 v, vec4 dest);
|
||||
|
||||
glmc_vec4_abs(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_fract(vec4 v, vec4 dest);
|
||||
|
||||
glmc_vec4_fract(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_floor(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mods(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_steps(float edge, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_stepr(const vec4 edge, float x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_hadd(vec4 v);
|
||||
glmc_vec4_hadd(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sqrt(vec4 v, vec4 dest);
|
||||
glmc_vec4_sqrt(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -313,14 +330,17 @@ glmc_vec4_make(const float * __restrict src, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest);
|
||||
glmc_vec4_reflect(const vec4 v, const vec4 n, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
|
||||
glmc_vec4_refract(const vec4 v, const vec4 n, float eta, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_swap(vec4 a, vec4 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
#endif /* cglmc_vec4_h */
|
||||
|
||||
+82
-34
@@ -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
|
||||
|
||||
@@ -30,6 +30,7 @@
|
||||
#include "quat.h"
|
||||
#include "euler.h"
|
||||
#include "plane.h"
|
||||
#include "noise.h"
|
||||
#include "aabb2d.h"
|
||||
#include "box.h"
|
||||
#include "color.h"
|
||||
@@ -42,5 +43,6 @@
|
||||
#include "bezier.h"
|
||||
#include "ray.h"
|
||||
#include "affine2d.h"
|
||||
#include "affine2d-post.h"
|
||||
|
||||
#endif /* cglm_h */
|
||||
@@ -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),
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
float bottom, float top,
|
||||
float nearZ, float farZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest)
|
||||
CGLM_INLINE void glm_ortho_aabb_p_rh_zo(vec3 box[2],
|
||||
CGLM_INLINE void glm_ortho_aabb_rh_zo(CGLM_CONST vec3 box[2], mat4 dest)
|
||||
CGLM_INLINE void glm_ortho_aabb_p_rh_zo(CGLM_CONST vec3 box[2],
|
||||
float padding,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(vec3 box[2],
|
||||
CGLM_INLINE void glm_ortho_aabb_pz_rh_zo(CGLM_CONST vec3 box[2],
|
||||
float padding,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_ortho_default_rh_zo(float aspect,
|
||||
@@ -79,7 +79,7 @@ glm_ortho_rh_zo(float left, float right,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
|
||||
glm_ortho_aabb_rh_zo(CGLM_CONST vec3 box[2], mat4 dest) {
|
||||
glm_ortho_rh_zo(box[0][0], box[1][0],
|
||||
box[0][1], box[1][1],
|
||||
-box[1][2], -box[0][2],
|
||||
@@ -99,7 +99,7 @@ glm_ortho_aabb_rh_zo(vec3 box[2], mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
|
||||
glm_ortho_aabb_p_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
|
||||
glm_ortho_rh_zo(box[0][0] - padding, box[1][0] + padding,
|
||||
box[0][1] - padding, box[1][1] + padding,
|
||||
-(box[1][2] + padding), -(box[0][2] - padding),
|
||||
@@ -119,7 +119,7 @@ glm_ortho_aabb_p_rh_zo(vec3 box[2], float padding, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ortho_aabb_pz_rh_zo(vec3 box[2], float padding, mat4 dest) {
|
||||
glm_ortho_aabb_pz_rh_zo(CGLM_CONST vec3 box[2], float padding, mat4 dest) {
|
||||
glm_ortho_rh_zo(box[0][0], box[1][0],
|
||||
box[0][1], box[1][1],
|
||||
-(box[1][2] + padding), -(box[0][2] - padding),
|
||||
|
||||
Loaded 100 of 268 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user