mirror of
https://github.com/recp/cglm.git
synced 2026-11-16 18:07:35 -06:00
Compare commits
51
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 |
No files matched your search
+119
-135
@@ -15,20 +15,13 @@ jobs:
|
||||
matrix:
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-13, simd: none }
|
||||
- { os: macos-13, simd: sse }
|
||||
- { os: macos-13, simd: sse2 }
|
||||
- { os: macos-13, simd: sse3 }
|
||||
- { os: macos-13, simd: sse4 }
|
||||
- { os: macos-13, simd: avx }
|
||||
- { os: macos-13, simd: avx2 }
|
||||
- { os: macos-14, simd: none }
|
||||
- { os: macos-14, simd: sse }
|
||||
- { os: macos-14, simd: sse2 }
|
||||
- { os: macos-14, simd: sse3 }
|
||||
- { os: macos-14, simd: sse4 }
|
||||
- { os: macos-14, simd: avx }
|
||||
- { os: macos-14, simd: avx2 }
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: ubuntu-22.04, simd: none }
|
||||
- { os: ubuntu-22.04, simd: sse }
|
||||
- { os: ubuntu-22.04, simd: sse2 }
|
||||
@@ -44,17 +37,18 @@ jobs:
|
||||
- { os: ubuntu-24.04, simd: avx }
|
||||
- { os: ubuntu-24.04, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: ubuntu-latest-arm64, simd: neon }
|
||||
- { os: macos-latest, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Autotools on macOS
|
||||
if: runner.os == 'macOS'
|
||||
run: brew upgrade && brew install autoconf automake libtool
|
||||
run: brew install autoconf automake libtool
|
||||
|
||||
- name: Install Autotools on Ubuntu
|
||||
if: matrix.os == 'ubuntu-22.04' || matrix.os == 'ubuntu-24.04'
|
||||
if: runner.os == 'Linux'
|
||||
run: sudo apt-get install -y autoconf automake libtool
|
||||
|
||||
- name: Set SIMD flags
|
||||
@@ -91,7 +85,7 @@ jobs:
|
||||
|
||||
build_cmake_ios:
|
||||
name: CMake / iOS
|
||||
runs-on: macos-14
|
||||
runs-on: macos-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
@@ -112,19 +106,19 @@ jobs:
|
||||
|
||||
build_cmake_ubuntu:
|
||||
name: CMake / ${{ matrix.target.os }} / ${{ matrix.target.cc }} / ${{ matrix.target.arch }} / ${{ matrix.target.simd }}
|
||||
runs-on: ${{ matrix.target.arch == 'arm64' && 'ubuntu-latest-arm64' || matrix.target.os }}
|
||||
runs-on: ${{ matrix.target.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
target:
|
||||
# GCC 11 builds
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: none }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: avx }
|
||||
- { os: ubuntu-20.04, cc: gcc-11, arch: x64, simd: avx2 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: gcc-11, arch: x64, simd: avx2 }
|
||||
# GCC 12 builds
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: gcc-12, arch: x64, simd: sse }
|
||||
@@ -142,13 +136,13 @@ jobs:
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx }
|
||||
- { os: ubuntu-24.04, cc: gcc-13, arch: x64, simd: avx2 }
|
||||
# Clang 12 builds
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: none }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: avx }
|
||||
- { os: ubuntu-20.04, cc: clang-12, arch: x64, simd: avx2 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse2 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse3 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: sse4 }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: clang-12, arch: x64, simd: avx2 }
|
||||
# Clang 15 builds
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: none }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: sse }
|
||||
@@ -158,63 +152,61 @@ jobs:
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx }
|
||||
- { os: ubuntu-22.04, cc: clang-15, arch: x64, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: ubuntu-latest, cc: gcc-12, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-latest, cc: gcc-13, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, cc: gcc-12, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, cc: gcc-13, arch: arm64, simd: neon }
|
||||
# ARMv7 builds
|
||||
- { os: ubuntu-latest-arm64, cc: gcc-12, arch: armv7, simd: neon }
|
||||
- { os: ubuntu-latest-arm64, cc: gcc-12, arch: armv7, simd: none }
|
||||
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: neon }
|
||||
- { os: ubuntu-24.04, cc: arm-linux-gnueabihf-gcc-12, arch: armv7, simd: none }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Add Ubuntu Toolchain PPA
|
||||
if: matrix.target.os == 'ubuntu-20.04'
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y software-properties-common
|
||||
sudo add-apt-repository -y ppa:ubuntu-toolchain-r/test
|
||||
sudo apt-get update
|
||||
|
||||
- name: Install Compiler and Ninja
|
||||
run: |
|
||||
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
|
||||
sudo apt-get update
|
||||
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
|
||||
sudo apt-get install -y gcc-12-arm-linux-gnueabihf qemu-user ninja-build
|
||||
else
|
||||
sudo apt-get install -y ${{ matrix.target.cc }} ninja-build
|
||||
fi
|
||||
|
||||
- name: Set SIMD flags
|
||||
run: |
|
||||
if [ "${{ matrix.simd }}" == "none" ]; then
|
||||
if [ "${{ matrix.target.simd }}" == "none" ]; then
|
||||
export CFLAGS=""
|
||||
elif [ "${{ matrix.simd }}" == "sse" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "sse" ]; then
|
||||
export CFLAGS="-msse"
|
||||
elif [ "${{ matrix.simd }}" == "sse2" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "sse2" ]; then
|
||||
export CFLAGS="-msse2"
|
||||
elif [ "${{ matrix.simd }}" == "sse3" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "sse3" ]; then
|
||||
export CFLAGS="-msse3"
|
||||
elif [ "${{ matrix.simd }}" == "sse4" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "sse4" ]; then
|
||||
export CFLAGS="-msse4"
|
||||
elif [ "${{ matrix.simd }}" == "avx" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "avx" ]; then
|
||||
export CFLAGS="-mavx"
|
||||
elif [ "${{ matrix.simd }}" == "avx2" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "avx2" ]; then
|
||||
export CFLAGS="-mavx2"
|
||||
elif [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
elif [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
export CFLAGS="-mfpu=neon"
|
||||
fi
|
||||
|
||||
- name: Configure CMake
|
||||
run: |
|
||||
if [ "${{ matrix.target.arch }}" == "armv7" ]; then
|
||||
# Build for ARMv7
|
||||
neon_flags=""
|
||||
if [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
# cross-compile ARMv7 and run its tests with QEMU
|
||||
neon_flags="-mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
if [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
neon_flags="-mfpu=neon -mfloat-abi=hard"
|
||||
fi
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
|
||||
-DCMAKE_C_COMPILER=${{ matrix.target.cc }} \
|
||||
-DCMAKE_C_FLAGS="$CFLAGS -m32 -march=armv7-a ${neon_flags}" \
|
||||
-DCMAKE_C_FLAGS="-march=armv7-a ${neon_flags}" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
elif [ "${{ matrix.target.arch }}" == "arm64" ]; then
|
||||
# Build for ARM64 (AArch64)
|
||||
neon_flags=""
|
||||
if [ "${{ matrix.simd }}" == "neon" ]; then
|
||||
if [ "${{ matrix.target.simd }}" == "neon" ]; then
|
||||
neon_flags="+simd" # Enable SIMD/NEON features on ARM64
|
||||
else
|
||||
neon_flags="+nosimd" # Explicitly disable SIMD/NEON
|
||||
@@ -236,7 +228,12 @@ jobs:
|
||||
|
||||
- name: Test
|
||||
working-directory: build
|
||||
run: ./tests
|
||||
run: |
|
||||
if [ "${{ matrix.target.arch }}" = "armv7" ]; then
|
||||
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
|
||||
else
|
||||
./tests
|
||||
fi
|
||||
|
||||
build_cmake_macos:
|
||||
name: CMake / ${{ matrix.os }}
|
||||
@@ -244,14 +241,14 @@ jobs:
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-13, macos-14]
|
||||
os: [macos-26-intel, macos-latest]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Ninja
|
||||
if: runner.os == 'macOS'
|
||||
run: brew upgrade && brew install ninja
|
||||
run: brew install ninja
|
||||
|
||||
- name: Configure CMake
|
||||
run: |
|
||||
@@ -277,20 +274,13 @@ jobs:
|
||||
matrix:
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-13, simd: none }
|
||||
- { os: macos-13, simd: sse }
|
||||
- { os: macos-13, simd: sse2 }
|
||||
- { os: macos-13, simd: sse3 }
|
||||
- { os: macos-13, simd: sse4 }
|
||||
- { os: macos-13, simd: avx }
|
||||
- { os: macos-13, simd: avx2 }
|
||||
- { os: macos-14, simd: none }
|
||||
- { os: macos-14, simd: sse }
|
||||
- { os: macos-14, simd: sse2 }
|
||||
- { os: macos-14, simd: sse3 }
|
||||
- { os: macos-14, simd: sse4 }
|
||||
- { os: macos-14, simd: avx }
|
||||
- { os: macos-14, simd: avx2 }
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: windows-2022, simd: none }
|
||||
- { os: windows-2022, simd: sse }
|
||||
- { os: windows-2022, simd: sse2 }
|
||||
@@ -299,14 +289,14 @@ jobs:
|
||||
- { os: windows-2022, simd: avx }
|
||||
- { os: windows-2022, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: macos-14-arm64, simd: neon }
|
||||
- { os: macos-latest, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Ninja on macOS
|
||||
if: runner.os == 'macOS'
|
||||
run: brew upgrade && brew install ninja
|
||||
run: brew install ninja
|
||||
|
||||
- name: Set SIMD flags (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
@@ -380,19 +370,19 @@ jobs:
|
||||
|
||||
build_meson:
|
||||
name: Meson / ${{ matrix.os }} / ${{ matrix.simd }}
|
||||
runs-on: ${{ contains(matrix.os, 'arm64') && 'ubuntu-latest-arm64' || matrix.os }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
# x86/x64 builds
|
||||
- { os: macos-14, simd: none }
|
||||
- { os: macos-14, simd: sse }
|
||||
- { os: macos-14, simd: sse2 }
|
||||
- { os: macos-14, simd: sse3 }
|
||||
- { os: macos-14, simd: sse4 }
|
||||
- { os: macos-14, simd: avx }
|
||||
- { os: macos-14, simd: avx2 }
|
||||
- { os: macos-26-intel, simd: none }
|
||||
- { os: macos-26-intel, simd: sse }
|
||||
- { os: macos-26-intel, simd: sse2 }
|
||||
- { os: macos-26-intel, simd: sse3 }
|
||||
- { os: macos-26-intel, simd: sse4 }
|
||||
- { os: macos-26-intel, simd: avx }
|
||||
- { os: macos-26-intel, simd: avx2 }
|
||||
- { os: ubuntu-22.04, simd: none }
|
||||
- { os: ubuntu-22.04, simd: sse }
|
||||
- { os: ubuntu-22.04, simd: sse2 }
|
||||
@@ -415,7 +405,8 @@ jobs:
|
||||
- { os: windows-2022, simd: avx }
|
||||
- { os: windows-2022, simd: avx2 }
|
||||
# ARM64 builds
|
||||
- { os: ubuntu-latest-arm64, simd: neon }
|
||||
- { os: macos-latest, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
@@ -554,12 +545,12 @@ jobs:
|
||||
run: sphinx-build -W --keep-going source build
|
||||
|
||||
build_swift:
|
||||
name: Swift ${{ matrix.swift }} / ${{ matrix.os }}
|
||||
name: Swift / ${{ matrix.os }}
|
||||
runs-on: ${{ matrix.os }}
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [macos-13, macos-14, ubuntu-22.04]
|
||||
os: [macos-26-intel, macos-latest, ubuntu-22.04]
|
||||
|
||||
# This has no test yet.
|
||||
steps:
|
||||
@@ -575,71 +566,64 @@ jobs:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
include:
|
||||
# Linux ARM builds
|
||||
- os: ubuntu-latest-arm64
|
||||
arch: arm64
|
||||
simd: neon
|
||||
- os: ubuntu-latest-arm64
|
||||
arch: armv7
|
||||
simd: neon
|
||||
- os: ubuntu-latest-arm64
|
||||
arch: armv7
|
||||
simd: none
|
||||
# Windows ARM builds
|
||||
- os: windows-latest-arm64
|
||||
arch: arm64
|
||||
simd: neon
|
||||
- os: windows-latest-arm64
|
||||
arch: arm
|
||||
simd: neon
|
||||
- os: windows-latest-arm64
|
||||
arch: arm
|
||||
simd: none
|
||||
# native ARM64 and cross-compiled ARMv7 builds
|
||||
- { os: ubuntu-24.04-arm, arch: arm64, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, arch: armv7, simd: neon }
|
||||
- { os: ubuntu-24.04-arm, arch: armv7, simd: none }
|
||||
# Windows ARM builds are cross-compiled on x64 runners
|
||||
- { os: windows-2022, arch: arm64, simd: neon }
|
||||
- { os: windows-2022, arch: arm, simd: neon }
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- name: Install Linux build tools
|
||||
if: runner.os == 'Linux'
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y ninja-build
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
sudo apt-get install -y gcc-arm-linux-gnueabihf qemu-user
|
||||
fi
|
||||
|
||||
- name: Configure CMake (Windows)
|
||||
if: runner.os == 'Windows'
|
||||
shell: pwsh
|
||||
run: |
|
||||
$flags = ""
|
||||
if ("${{ matrix.arch }}" -eq "arm") {
|
||||
$flags = "-m32 -march=armv7-a"
|
||||
if ("${{ matrix.simd }}" -eq "neon") {
|
||||
$flags += " -mfpu=neon"
|
||||
}
|
||||
}
|
||||
elseif ("${{ matrix.simd }}" -eq "neon") {
|
||||
$flags = "-march=armv8-a+simd"
|
||||
}
|
||||
|
||||
cmake -B build -G "Visual Studio 17 2022" -A ${{ matrix.arch == 'arm64' && 'ARM64' || 'ARM' }} `
|
||||
# ARM32 requires a Windows SDK older than 26100
|
||||
$platform = "${{ matrix.arch == 'arm64' && 'ARM64' || 'ARM,version=10.0.22621.0' }}"
|
||||
cmake -B build -G "Visual Studio 17 2022" -A $platform `
|
||||
-DCMAKE_BUILD_TYPE=Release `
|
||||
-DCMAKE_C_FLAGS="$flags" `
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Configure CMake (Unix)
|
||||
if: runner.os != 'Windows'
|
||||
if: runner.os == 'Linux'
|
||||
shell: bash
|
||||
run: |
|
||||
flags=""
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
flags="-m32 -march=armv7-a"
|
||||
flags="-march=armv7-a -mfpu=vfpv3-d16 -mfloat-abi=hard"
|
||||
if [ "${{ matrix.simd }}" = "neon" ]; then
|
||||
flags="$flags -mfpu=neon -mfloat-abi=hard"
|
||||
flags="-march=armv7-a -mfpu=neon -mfloat-abi=hard"
|
||||
fi
|
||||
elif [ "${{ matrix.simd }}" = "neon" ]; then
|
||||
flags="-march=armv8-a+simd"
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_SYSTEM_NAME=Linux -DCMAKE_SYSTEM_PROCESSOR=arm \
|
||||
-DCMAKE_C_COMPILER=arm-linux-gnueabihf-gcc \
|
||||
-DCMAKE_C_FLAGS="$flags" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
else
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
fi
|
||||
|
||||
cmake -B build -GNinja -DCMAKE_BUILD_TYPE=Release \
|
||||
-DCMAKE_C_FLAGS="$flags" \
|
||||
-DCGLM_STATIC=ON -DCGLM_USE_TEST=ON
|
||||
|
||||
- name: Build
|
||||
run: cmake --build build
|
||||
run: cmake --build build --config Release
|
||||
|
||||
- name: Test
|
||||
- name: Test (Linux)
|
||||
if: runner.os == 'Linux'
|
||||
working-directory: build
|
||||
run: ./tests
|
||||
run: |
|
||||
if [ "${{ matrix.arch }}" = "armv7" ]; then
|
||||
qemu-arm -L /usr/arm-linux-gnueabihf ./tests
|
||||
else
|
||||
./tests
|
||||
fi
|
||||
@@ -35,9 +35,11 @@ jobs:
|
||||
# https://github.com/WebAssembly/wasi-sdk/issues/332
|
||||
- name: Modify CMakeLists.txt for WASI
|
||||
run: |
|
||||
echo 'if (CMAKE_SYSTEM_NAME STREQUAL "WASI")' >> CMakeLists.txt
|
||||
echo ' target_link_options(${PROJECT_NAME} PRIVATE -mexec-model=reactor)' >> CMakeLists.txt
|
||||
echo 'endif()' >> CMakeLists.txt
|
||||
cat >> CMakeLists.txt <<'EOF'
|
||||
if (CMAKE_SYSTEM_NAME STREQUAL "WASI")
|
||||
target_link_options(${PROJECT_NAME} PRIVATE -mexec-model=reactor)
|
||||
endif()
|
||||
EOF
|
||||
|
||||
- name: Configure CMake
|
||||
# Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
|
||||
|
||||
@@ -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: |
|
||||
|
||||
+42
-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,19 +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
|
||||
+1
-1
@@ -1,6 +1,6 @@
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
project(cglm
|
||||
VERSION 0.9.6
|
||||
VERSION 0.9.8
|
||||
HOMEPAGE_URL https://github.com/recp/cglm
|
||||
DESCRIPTION "OpenGL Mathematics (glm) for C"
|
||||
LANGUAGES C
|
||||
|
||||
+3
-2
@@ -23,7 +23,7 @@ checkCFLAGS = $(AM_CFLAGS) \
|
||||
-std=gnu11 \
|
||||
-O3 \
|
||||
-DCGLM_DEFINE_PRINTS \
|
||||
-I./include
|
||||
-I$(srcdir)/include
|
||||
|
||||
check_PROGRAMS = test/tests
|
||||
TESTS = $(check_PROGRAMS)
|
||||
@@ -79,7 +79,8 @@ cglm_HEADERS = include/cglm/version.h \
|
||||
include/cglm/bezier.h \
|
||||
include/cglm/applesimd.h \
|
||||
include/cglm/ray.h \
|
||||
include/cglm/affine2d.h
|
||||
include/cglm/affine2d.h \
|
||||
include/cglm/affine2d-post.h
|
||||
|
||||
cglm_clipspacedir=$(includedir)/cglm/clipspace
|
||||
cglm_clipspace_HEADERS = include/cglm/clipspace/persp.h \
|
||||
|
||||
+1
-1
@@ -2,7 +2,7 @@ Pod::Spec.new do |s|
|
||||
|
||||
# Description
|
||||
s.name = "cglm"
|
||||
s.version = "0.9.5"
|
||||
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.6], [[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.
|
||||
|
||||
@@ -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 )
|
||||
|
||||
+2
-2
@@ -62,9 +62,9 @@ author = u'Recep Aslantas'
|
||||
# built documents.
|
||||
#
|
||||
# The short X.Y version.
|
||||
version = u'0.9.6'
|
||||
version = u'0.9.8'
|
||||
# The full version, including alpha/beta/rc tags.
|
||||
release = u'0.9.6'
|
||||
release = u'0.9.8'
|
||||
|
||||
# The language for content autogenerated by Sphinx. Refer to documentation
|
||||
# for a list of supported languages.
|
||||
|
||||
+835
-155
File diff suppressed because it is too large.
Load diff
@@ -63,7 +63,7 @@ Functions documentation
|
||||
Zero out the mat2x3 (m).
|
||||
|
||||
Parameters:
|
||||
| *[in, out]* **mat** mat2x3 (src, dest)
|
||||
| *[in, out]* **m** mat2x3 (src, dest)
|
||||
|
||||
.. csv-table:: mat2x3 **(m)**
|
||||
:header: "", "column 1", "column 2"
|
||||
|
||||
+1069
-85
File diff suppressed because it is too large.
Load diff
@@ -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
|
||||
~~~~~~~~~~~~~~~~~~~~~~~
|
||||
@@ -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
|
||||
+18
-18
@@ -35,7 +35,7 @@ glm_aabb2d_zero(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
|
||||
glm_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]) {
|
||||
glm_vec2_copy(aabb[0], dest[0]);
|
||||
glm_vec2_copy(aabb[1], dest[1]);
|
||||
}
|
||||
@@ -49,7 +49,7 @@ glm_aabb2d_copy(vec2 aabb[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
|
||||
glm_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]) {
|
||||
vec2 v[2], xa, xb, ya, yb;
|
||||
|
||||
glm_vec2_scale(m[0], aabb[0][0], xa);
|
||||
@@ -84,7 +84,7 @@ glm_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
|
||||
glm_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]) {
|
||||
dest[0][0] = glm_min(aabb1[0][0], aabb2[0][0]);
|
||||
dest[0][1] = glm_min(aabb1[0][1], aabb2[0][1]);
|
||||
|
||||
@@ -105,7 +105,7 @@ glm_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
|
||||
glm_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]) {
|
||||
dest[0][0] = glm_max(aabb[0][0], cropAabb[0][0]);
|
||||
dest[0][1] = glm_max(aabb[0][1], cropAabb[0][1]);
|
||||
|
||||
@@ -127,9 +127,9 @@ glm_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_crop_until(vec2 aabb[2],
|
||||
vec2 cropAabb[2],
|
||||
vec2 clampAabb[2],
|
||||
glm_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
|
||||
CGLM_CONST vec2 cropAabb[2],
|
||||
CGLM_CONST vec2 clampAabb[2],
|
||||
vec2 dest[2]) {
|
||||
glm_aabb2d_crop(aabb, cropAabb, dest);
|
||||
glm_aabb2d_merge(clampAabb, dest, dest);
|
||||
@@ -154,7 +154,7 @@ glm_aabb2d_invalidate(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_isvalid(vec2 aabb[2]) {
|
||||
glm_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_vec2_max(aabb[0]) != FLT_MAX
|
||||
&& glm_vec2_min(aabb[1]) != -FLT_MAX;
|
||||
}
|
||||
@@ -166,7 +166,7 @@ glm_aabb2d_isvalid(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb2d_diag(vec2 aabb[2]) {
|
||||
glm_aabb2d_diag(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_vec2_distance(aabb[0], aabb[1]);
|
||||
}
|
||||
|
||||
@@ -178,7 +178,7 @@ glm_aabb2d_diag(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
|
||||
glm_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest) {
|
||||
glm_vec2_sub(aabb[1], aabb[0], dest);
|
||||
}
|
||||
|
||||
@@ -189,7 +189,7 @@ glm_aabb2d_sizev(vec2 aabb[2], vec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb2d_radius(vec2 aabb[2]) {
|
||||
glm_aabb2d_radius(CGLM_CONST vec2 aabb[2]) {
|
||||
return glm_aabb2d_diag(aabb) * 0.5f;
|
||||
}
|
||||
|
||||
@@ -201,7 +201,7 @@ glm_aabb2d_radius(vec2 aabb[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
|
||||
glm_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest) {
|
||||
glm_vec2_center(aabb[0], aabb[1], dest);
|
||||
}
|
||||
|
||||
@@ -213,7 +213,7 @@ glm_aabb2d_center(vec2 aabb[2], vec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
|
||||
glm_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
|
||||
return (aabb[0][0] <= other[1][0] && aabb[1][0] >= other[0][0])
|
||||
&& (aabb[0][1] <= other[1][1] && aabb[1][1] >= other[0][1]);
|
||||
}
|
||||
@@ -228,15 +228,15 @@ glm_aabb2d_aabb(vec2 aabb[2], vec2 other[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
|
||||
glm_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 c) {
|
||||
float dmin;
|
||||
int a, b;
|
||||
|
||||
a = (c[0] < aabb[0][0]) + (c[0] > aabb[1][0]);
|
||||
b = (c[1] < aabb[0][1]) + (c[1] > aabb[1][1]);
|
||||
|
||||
dmin = glm_pow2((c[0] - aabb[!(a - 1)][0]) * (a != 0))
|
||||
+ glm_pow2((c[1] - aabb[!(b - 1)][1]) * (b != 0));
|
||||
dmin = glm_pow2((c[0] - aabb[c[0] > aabb[1][0]][0]) * (a != 0))
|
||||
+ glm_pow2((c[1] - aabb[c[1] > aabb[1][1]][1]) * (b != 0));
|
||||
|
||||
return dmin <= glm_pow2(c[2]);
|
||||
}
|
||||
@@ -249,7 +249,7 @@ glm_aabb2d_circle(vec2 aabb[2], vec3 c) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_point(vec2 aabb[2], vec2 point) {
|
||||
glm_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point) {
|
||||
return (point[0] >= aabb[0][0] && point[0] <= aabb[1][0])
|
||||
&& (point[1] >= aabb[0][1] && point[1] <= aabb[1][1]);
|
||||
}
|
||||
@@ -262,7 +262,7 @@ glm_aabb2d_point(vec2 aabb[2], vec2 point) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb2d_contains(vec2 aabb[2], vec2 other[2]) {
|
||||
glm_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]) {
|
||||
return (aabb[0][0] <= other[0][0] && aabb[1][0] >= other[1][0])
|
||||
&& (aabb[0][1] <= other[0][1] && aabb[1][1] >= other[1][1]);
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
+19
-19
@@ -10,18 +10,18 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_translate_to(mat4 m, vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translate(mat4 m, vec3 v);
|
||||
CGLM_INLINE void glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest);
|
||||
CGLM_INLINE void glm_translate(mat4 m, const vec3 v);
|
||||
CGLM_INLINE void glm_translate_x(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translate_y(mat4 m, float to);
|
||||
CGLM_INLINE void glm_translate_z(mat4 m, float to);
|
||||
CGLM_INLINE void glm_rotate_x(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_y(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_z(mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_spin(mat4 m, float angle, vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest);
|
||||
CGLM_INLINE void glm_rotate(mat4 m, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis);
|
||||
CGLM_INLINE void glm_spin(mat4 m, float angle, const vec3 axis);
|
||||
*/
|
||||
|
||||
#include "common.h"
|
||||
@@ -40,7 +40,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translate(mat4 m, vec3 v) {
|
||||
glm_translate(mat4 m, const vec3 v) {
|
||||
#if defined(CGLM_SIMD)
|
||||
glmm_128 m0, m1, m2, m3;
|
||||
|
||||
@@ -72,7 +72,7 @@ glm_translate(mat4 m, vec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translate_to(mat4 m, vec3 v, mat4 dest) {
|
||||
glm_translate_to(CGLM_CONST mat4 m, const vec3 v, mat4 dest) {
|
||||
glm_mat4_copy(m, dest);
|
||||
glm_translate(dest, v);
|
||||
}
|
||||
@@ -141,7 +141,7 @@ glm_translate_z(mat4 m, float z) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_x(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_x(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -166,7 +166,7 @@ glm_rotate_x(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_y(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_y(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -191,7 +191,7 @@ glm_rotate_y(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_z(mat4 m, float angle, mat4 dest) {
|
||||
glm_rotate_z(CGLM_CONST mat4 m, float angle, mat4 dest) {
|
||||
CGLM_ALIGN_MAT mat4 t = GLM_MAT4_IDENTITY_INIT;
|
||||
float c, s;
|
||||
|
||||
@@ -233,7 +233,7 @@ glm_rotate_z(mat4 m, float angle, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate(mat4 m, float angle, vec3 axis) {
|
||||
glm_rotate(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_make(rot, angle, axis);
|
||||
glm_mul_rot(m, rot, m);
|
||||
@@ -250,7 +250,7 @@ glm_rotate(mat4 m, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
glm_rotate_at(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN(8) vec3 pivotInv;
|
||||
|
||||
glm_vec3_negate_to(pivot, pivotInv);
|
||||
@@ -275,7 +275,7 @@ glm_rotate_at(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
glm_rotate_atm(mat4 m, const vec3 pivot, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN(8) vec3 pivotInv;
|
||||
|
||||
glm_vec3_negate_to(pivot, pivotInv);
|
||||
@@ -295,9 +295,9 @@ glm_rotate_atm(mat4 m, vec3 pivot, float angle, vec3 axis) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_spin(mat4 m, float angle, vec3 axis) {
|
||||
glm_spin(mat4 m, float angle, const vec3 axis) {
|
||||
CGLM_ALIGN_MAT mat4 rot;
|
||||
glm_rotate_atm(rot, m[3], angle, axis);
|
||||
glm_rotate_make(rot, angle, axis);
|
||||
glm_mat4_mul(m, rot, m);
|
||||
}
|
||||
|
||||
|
||||
+18
-30
@@ -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);
|
||||
}
|
||||
|
||||
@@ -10,11 +10,11 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_translated2d(mat3 m, vec2 v);
|
||||
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, vec2 v);
|
||||
CGLM_INLINE void glm_scaled2d(mat3 m, const vec2 v);
|
||||
CGLM_INLINE void glm_scaled2d_uni(mat3 m, float s);
|
||||
*/
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_translated2d(mat3 m, vec2 v) {
|
||||
glm_translated2d(mat3 m, const vec2 v) {
|
||||
glm_vec2_add(m[2], v, m[2]);
|
||||
}
|
||||
|
||||
@@ -99,7 +99,7 @@ glm_rotated2d(mat3 m, float angle) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_scaled2d(mat3 m, vec2 v) {
|
||||
glm_scaled2d(mat3 m, const vec2 v) {
|
||||
m[0][0] *= v[0];
|
||||
m[1][0] *= v[0];
|
||||
m[2][0] *= v[0];
|
||||
|
||||
+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];
|
||||
|
||||
@@ -22,7 +22,7 @@
|
||||
*/
|
||||
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];
|
||||
@@ -54,7 +54,7 @@ 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];
|
||||
@@ -78,7 +78,7 @@ 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]};
|
||||
}
|
||||
|
||||
@@ -88,7 +88,7 @@ glm_vec4_applesimd(vec4 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
simd_float3
|
||||
glm_vec3_applesimd(vec3 v) {
|
||||
glm_vec3_applesimd(const vec3 v) {
|
||||
return (simd_float3){v[0], v[1], v[2]};
|
||||
}
|
||||
|
||||
|
||||
+20
-19
@@ -22,7 +22,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
|
||||
glm_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]) {
|
||||
vec3 v[2], xa, xb, ya, yb, za, zb;
|
||||
|
||||
glm_vec3_scale(m[0], box[0][0], xa);
|
||||
@@ -62,7 +62,7 @@ glm_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
|
||||
glm_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_CONST vec3 box2[2], vec3 dest[2]) {
|
||||
dest[0][0] = glm_min(box1[0][0], box2[0][0]);
|
||||
dest[0][1] = glm_min(box1[0][1], box2[0][1]);
|
||||
dest[0][2] = glm_min(box1[0][2], box2[0][2]);
|
||||
@@ -85,7 +85,7 @@ glm_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
|
||||
glm_aabb_crop(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]) {
|
||||
dest[0][0] = glm_max(box[0][0], cropBox[0][0]);
|
||||
dest[0][1] = glm_max(box[0][1], cropBox[0][1]);
|
||||
dest[0][2] = glm_max(box[0][2], cropBox[0][2]);
|
||||
@@ -109,9 +109,9 @@ glm_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_crop_until(vec3 box[2],
|
||||
vec3 cropBox[2],
|
||||
vec3 clampBox[2],
|
||||
glm_aabb_crop_until(CGLM_CONST vec3 box[2],
|
||||
CGLM_CONST vec3 cropBox[2],
|
||||
CGLM_CONST vec3 clampBox[2],
|
||||
vec3 dest[2]) {
|
||||
glm_aabb_crop(box, cropBox, dest);
|
||||
glm_aabb_merge(clampBox, dest, dest);
|
||||
@@ -133,8 +133,9 @@ glm_aabb_crop_until(vec3 box[2],
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_frustum(vec3 box[2], vec4 planes[6]) {
|
||||
float *p, dp;
|
||||
glm_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]) {
|
||||
const float *p;
|
||||
float dp;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < 6; i++) {
|
||||
@@ -169,7 +170,7 @@ glm_aabb_invalidate(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_isvalid(vec3 box[2]) {
|
||||
glm_aabb_isvalid(CGLM_CONST vec3 box[2]) {
|
||||
return glm_vec3_max(box[0]) != FLT_MAX
|
||||
&& glm_vec3_min(box[1]) != -FLT_MAX;
|
||||
}
|
||||
@@ -181,7 +182,7 @@ glm_aabb_isvalid(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb_size(vec3 box[2]) {
|
||||
glm_aabb_size(CGLM_CONST vec3 box[2]) {
|
||||
return glm_vec3_distance(box[0], box[1]);
|
||||
}
|
||||
|
||||
@@ -192,7 +193,7 @@ glm_aabb_size(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_aabb_radius(vec3 box[2]) {
|
||||
glm_aabb_radius(CGLM_CONST vec3 box[2]) {
|
||||
return glm_aabb_size(box) * 0.5f;
|
||||
}
|
||||
|
||||
@@ -204,7 +205,7 @@ glm_aabb_radius(vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_center(vec3 box[2], vec3 dest) {
|
||||
glm_aabb_center(CGLM_CONST vec3 box[2], vec3 dest) {
|
||||
glm_vec3_center(box[0], box[1], dest);
|
||||
}
|
||||
|
||||
@@ -216,7 +217,7 @@ glm_aabb_center(vec3 box[2], vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
|
||||
glm_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
|
||||
return (box[0][0] <= other[1][0] && box[1][0] >= other[0][0])
|
||||
&& (box[0][1] <= other[1][1] && box[1][1] >= other[0][1])
|
||||
&& (box[0][2] <= other[1][2] && box[1][2] >= other[0][2]);
|
||||
@@ -235,7 +236,7 @@ glm_aabb_aabb(vec3 box[2], vec3 other[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
glm_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s) {
|
||||
float dmin;
|
||||
int a, b, c;
|
||||
|
||||
@@ -243,9 +244,9 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
b = (s[1] < box[0][1]) + (s[1] > box[1][1]);
|
||||
c = (s[2] < box[0][2]) + (s[2] > box[1][2]);
|
||||
|
||||
dmin = glm_pow2((s[0] - box[!(a - 1)][0]) * (a != 0))
|
||||
+ glm_pow2((s[1] - box[!(b - 1)][1]) * (b != 0))
|
||||
+ glm_pow2((s[2] - box[!(c - 1)][2]) * (c != 0));
|
||||
dmin = glm_pow2((s[0] - box[s[0] > box[1][0]][0]) * (a != 0))
|
||||
+ glm_pow2((s[1] - box[s[1] > box[1][1]][1]) * (b != 0))
|
||||
+ glm_pow2((s[2] - box[s[2] > box[1][2]][2]) * (c != 0));
|
||||
|
||||
return dmin <= glm_pow2(s[3]);
|
||||
}
|
||||
@@ -258,7 +259,7 @@ glm_aabb_sphere(vec3 box[2], vec4 s) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_point(vec3 box[2], vec3 point) {
|
||||
glm_aabb_point(CGLM_CONST vec3 box[2], const vec3 point) {
|
||||
return (point[0] >= box[0][0] && point[0] <= box[1][0])
|
||||
&& (point[1] >= box[0][1] && point[1] <= box[1][1])
|
||||
&& (point[2] >= box[0][2] && point[2] <= box[1][2]);
|
||||
@@ -272,7 +273,7 @@ glm_aabb_point(vec3 box[2], vec3 point) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_aabb_contains(vec3 box[2], vec3 other[2]) {
|
||||
glm_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]) {
|
||||
return (box[0][0] <= other[0][0] && box[1][0] >= other[1][0])
|
||||
&& (box[0][1] <= other[0][1] && box[1][1] >= other[1][1])
|
||||
&& (box[0][2] <= other[0][2] && box[1][2] >= other[1][2]);
|
||||
|
||||
@@ -11,7 +11,6 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "cglm.h"
|
||||
#include "call/vec2.h"
|
||||
#include "call/vec3.h"
|
||||
#include "call/vec4.h"
|
||||
|
||||
+17
-17
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _diag */
|
||||
#define glmc_aabb2d_size(aabb) glmc_aabb2d_diag(aabb)
|
||||
@@ -22,25 +22,25 @@ glmc_aabb2d_zero(vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_copy(vec2 aabb[2], vec2 dest[2]);
|
||||
glmc_aabb2d_copy(CGLM_CONST vec2 aabb[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_transform(vec2 aabb[2], mat3 m, vec2 dest[2]);
|
||||
glmc_aabb2d_transform(CGLM_CONST vec2 aabb[2], CGLM_CONST mat3 m, vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_merge(vec2 aabb1[2], vec2 aabb2[2], vec2 dest[2]);
|
||||
glmc_aabb2d_merge(CGLM_CONST vec2 aabb1[2], CGLM_CONST vec2 aabb2[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_crop(vec2 aabb[2], vec2 cropAabb[2], vec2 dest[2]);
|
||||
glmc_aabb2d_crop(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 cropAabb[2], vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_crop_until(vec2 aabb[2],
|
||||
vec2 cropAabb[2],
|
||||
vec2 clampAabb[2],
|
||||
glmc_aabb2d_crop_until(CGLM_CONST vec2 aabb[2],
|
||||
CGLM_CONST vec2 cropAabb[2],
|
||||
CGLM_CONST vec2 clampAabb[2],
|
||||
vec2 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
@@ -49,39 +49,39 @@ glmc_aabb2d_invalidate(vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_isvalid(vec2 aabb[2]);
|
||||
glmc_aabb2d_isvalid(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb2d_diag(vec2 aabb[2]);
|
||||
glmc_aabb2d_diag(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_sizev(vec2 aabb[2], vec2 dest);
|
||||
glmc_aabb2d_sizev(CGLM_CONST vec2 aabb[2], vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb2d_radius(vec2 aabb[2]);
|
||||
glmc_aabb2d_radius(CGLM_CONST vec2 aabb[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb2d_center(vec2 aabb[2], vec2 dest);
|
||||
glmc_aabb2d_center(CGLM_CONST vec2 aabb[2], vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_aabb(vec2 aabb[2], vec2 other[2]);
|
||||
glmc_aabb2d_aabb(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_point(vec2 aabb[2], vec2 point);
|
||||
glmc_aabb2d_point(CGLM_CONST vec2 aabb[2], const vec2 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_contains(vec2 aabb[2], vec2 other[2]);
|
||||
glmc_aabb2d_contains(CGLM_CONST vec2 aabb[2], CGLM_CONST vec2 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb2d_circle(vec2 aabb[2], vec3 s);
|
||||
glmc_aabb2d_circle(CGLM_CONST vec2 aabb[2], const vec3 s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+29
-29
@@ -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
-16
@@ -11,30 +11,30 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_transform(vec3 box[2], mat4 m, vec3 dest[2]);
|
||||
glmc_aabb_transform(CGLM_CONST vec3 box[2], CGLM_CONST mat4 m, vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_merge(vec3 box1[2], vec3 box2[2], vec3 dest[2]);
|
||||
glmc_aabb_merge(CGLM_CONST vec3 box1[2], CGLM_CONST vec3 box2[2], vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_crop(vec3 box[2], vec3 cropBox[2], vec3 dest[2]);
|
||||
glmc_aabb_crop(CGLM_CONST vec3 box[2], CGLM_CONST vec3 cropBox[2], vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_crop_until(vec3 box[2],
|
||||
vec3 cropBox[2],
|
||||
vec3 clampBox[2],
|
||||
glmc_aabb_crop_until(CGLM_CONST vec3 box[2],
|
||||
CGLM_CONST vec3 cropBox[2],
|
||||
CGLM_CONST vec3 clampBox[2],
|
||||
vec3 dest[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_frustum(vec3 box[2], vec4 planes[6]);
|
||||
glmc_aabb_frustum(CGLM_CONST vec3 box[2], CGLM_CONST vec4 planes[6]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -42,35 +42,35 @@ glmc_aabb_invalidate(vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_isvalid(vec3 box[2]);
|
||||
glmc_aabb_isvalid(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb_size(vec3 box[2]);
|
||||
glmc_aabb_size(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_aabb_radius(vec3 box[2]);
|
||||
glmc_aabb_radius(CGLM_CONST vec3 box[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_aabb_center(vec3 box[2], vec3 dest);
|
||||
glmc_aabb_center(CGLM_CONST vec3 box[2], vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_aabb(vec3 box[2], vec3 other[2]);
|
||||
glmc_aabb_aabb(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_point(vec3 box[2], vec3 point);
|
||||
glmc_aabb_point(CGLM_CONST vec3 box[2], const vec3 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_contains(vec3 box[2], vec3 other[2]);
|
||||
glmc_aabb_contains(CGLM_CONST vec3 box[2], CGLM_CONST vec3 other[2]);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_aabb_sphere(vec3 box[2], vec4 s);
|
||||
glmc_aabb_sphere(CGLM_CONST vec3 box[2], const vec4 s);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+25
-17
@@ -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,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_copy(mat2x3 src, mat2x3 dest);
|
||||
glmc_mat2x3_copy(CGLM_CONST mat2x3 src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat2x3_make(const float * __restrict src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_mul(mat2x3 m1, mat3x2 m2, mat3 dest);
|
||||
glmc_mat2x3_mul(CGLM_CONST mat2x3 m1, CGLM_CONST mat3x2 m2, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_mulv(mat2x3 m, vec2 v, vec3 dest);
|
||||
glmc_mat2x3_mulv(CGLM_CONST mat2x3 m, const vec2 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x3_transpose(mat2x3 src, mat3x2 dest);
|
||||
glmc_mat2x3_transpose(CGLM_CONST mat2x3 src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_copy(mat2x4 src, mat2x4 dest);
|
||||
glmc_mat2x4_copy(CGLM_CONST mat2x4 src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat2x4_make(const float * __restrict src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_mul(mat2x4 m1, mat4x2 m2, mat4 dest);
|
||||
glmc_mat2x4_mul(CGLM_CONST mat2x4 m1, CGLM_CONST mat4x2 m2, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_mulv(mat2x4 m, vec2 v, vec4 dest);
|
||||
glmc_mat2x4_mulv(CGLM_CONST mat2x4 m, const vec2 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat2x4_transpose(mat2x4 src, 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,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_copy(mat3x2 src, mat3x2 dest);
|
||||
glmc_mat3x2_copy(CGLM_CONST mat3x2 src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat3x2_make(const float * __restrict src, mat3x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_mul(mat3x2 m1, mat2x3 m2, mat2 dest);
|
||||
glmc_mat3x2_mul(CGLM_CONST mat3x2 m1, CGLM_CONST mat2x3 m2, mat2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_mulv(mat3x2 m, vec3 v, vec2 dest);
|
||||
glmc_mat3x2_mulv(CGLM_CONST mat3x2 m, const vec3 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x2_transpose(mat3x2 src, mat2x3 dest);
|
||||
glmc_mat3x2_transpose(CGLM_CONST mat3x2 src, mat2x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_copy(mat3x4 src, mat3x4 dest);
|
||||
glmc_mat3x4_copy(CGLM_CONST mat3x4 src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat3x4_make(const float * __restrict src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_mul(mat3x4 m1, mat4x3 m2, mat4 dest);
|
||||
glmc_mat3x4_mul(CGLM_CONST mat3x4 m1, CGLM_CONST mat4x3 m2, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_mulv(mat3x4 m, vec3 v, vec4 dest);
|
||||
glmc_mat3x4_mulv(CGLM_CONST mat3x4 m, const vec3 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat3x4_transpose(mat3x4 src, 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,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_copy(mat4x2 src, mat4x2 dest);
|
||||
glmc_mat4x2_copy(CGLM_CONST mat4x2 src, mat4x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat4x2_make(const float * __restrict src, mat4x2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_mul(mat4x2 m1, mat2x4 m2, mat2 dest);
|
||||
glmc_mat4x2_mul(CGLM_CONST mat4x2 m1, CGLM_CONST mat2x4 m2, mat2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_mulv(mat4x2 m, vec4 v, vec2 dest);
|
||||
glmc_mat4x2_mulv(CGLM_CONST mat4x2 m, const vec4 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x2_transpose(mat4x2 src, mat2x4 dest);
|
||||
glmc_mat4x2_transpose(CGLM_CONST mat4x2 src, mat2x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_copy(mat4x3 src, mat4x3 dest);
|
||||
glmc_mat4x3_copy(CGLM_CONST mat4x3 src, mat4x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -27,15 +27,15 @@ glmc_mat4x3_make(const float * __restrict src, mat4x3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_mul(mat4x3 m1, mat3x4 m2, mat3 dest);
|
||||
glmc_mat4x3_mul(CGLM_CONST mat4x3 m1, CGLM_CONST mat3x4 m2, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_mulv(mat4x3 m, vec4 v, vec3 dest);
|
||||
glmc_mat4x3_mulv(CGLM_CONST mat4x3 m, const vec4 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_mat4x3_transpose(mat4x3 src, mat3x4 dest);
|
||||
glmc_mat4x3_transpose(CGLM_CONST mat4x3 src, mat3x4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,19 +11,19 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec4(vec4 point);
|
||||
glmc_perlin_vec4(const vec4 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec3(vec3 point);
|
||||
glmc_perlin_vec3(const vec3 point);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_perlin_vec2(vec2 point);
|
||||
glmc_perlin_vec2(const vec2 point);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
@@ -11,27 +11,27 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_unprojecti(vec3 pos, mat4 invMat, vec4 vp, vec3 dest);
|
||||
glmc_unprojecti(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_unproject(vec3 pos, mat4 m, vec4 vp, vec3 dest);
|
||||
glmc_unproject(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_project(vec3 pos, mat4 m, vec4 vp, vec3 dest);
|
||||
glmc_project(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_project_z(vec3 pos, mat4 m);
|
||||
glmc_project_z(const vec3 pos, CGLM_CONST mat4 m);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_pickmatrix(vec2 center, vec2 size, vec4 vp, mat4 dest);
|
||||
glmc_pickmatrix(const vec2 center, const vec2 size, const vec4 vp, mat4 dest);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+34
-34
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -31,23 +31,23 @@ glmc_quat(versor q, float angle, float x, float y, float z);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quatv(versor q, float angle, vec3 axis);
|
||||
glmc_quatv(versor q, float angle, const vec3 axis);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_copy(versor q, versor dest);
|
||||
glmc_quat_copy(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_from_vecs(vec3 a, vec3 b, versor dest);
|
||||
glmc_quat_from_vecs(const vec3 a, const vec3 b, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_norm(versor q);
|
||||
glmc_quat_norm(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_normalize_to(versor q, versor dest);
|
||||
glmc_quat_normalize_to(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -55,115 +55,115 @@ glmc_quat_normalize(versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_dot(versor p, versor q);
|
||||
glmc_quat_dot(const versor p, const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_conjugate(versor q, versor dest);
|
||||
glmc_quat_conjugate(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_inv(versor q, versor dest);
|
||||
glmc_quat_inv(const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_add(versor p, versor q, versor dest);
|
||||
glmc_quat_add(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_sub(versor p, versor q, versor dest);
|
||||
glmc_quat_sub(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_real(versor q);
|
||||
glmc_quat_real(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_imag(versor q, vec3 dest);
|
||||
glmc_quat_imag(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_imagn(versor q, vec3 dest);
|
||||
glmc_quat_imagn(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_imaglen(versor q);
|
||||
glmc_quat_imaglen(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_quat_angle(versor q);
|
||||
glmc_quat_angle(const versor q);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_axis(versor q, vec3 dest);
|
||||
glmc_quat_axis(const versor q, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mul(versor p, versor q, versor dest);
|
||||
glmc_quat_mul(const versor p, const versor q, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat4(versor q, mat4 dest);
|
||||
glmc_quat_mat4(const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat4t(versor q, mat4 dest);
|
||||
glmc_quat_mat4t(const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat3(versor q, mat3 dest);
|
||||
glmc_quat_mat3(const versor q, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_mat3t(versor q, mat3 dest);
|
||||
glmc_quat_mat3t(const versor q, mat3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_lerp(versor from, versor to, float t, versor dest);
|
||||
glmc_quat_lerp(const versor from, const versor to, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_lerpc(versor from, versor to, float t, versor dest);
|
||||
glmc_quat_lerpc(const versor from, const versor to, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_nlerp(versor q, versor r, float t, versor dest);
|
||||
glmc_quat_nlerp(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_slerp(versor q, versor r, float t, versor dest);
|
||||
glmc_quat_slerp(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_slerp_longest(versor q, versor r, float t, versor dest);
|
||||
glmc_quat_slerp_longest(const versor q, const versor r, float t, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_look(vec3 eye, versor ori, mat4 dest);
|
||||
glmc_quat_look(const vec3 eye, const versor ori, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_for(vec3 dir, vec3 up, versor dest);
|
||||
glmc_quat_for(const vec3 dir, const vec3 up, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_forp(vec3 from, vec3 to, vec3 up, versor dest);
|
||||
glmc_quat_forp(const vec3 from, const vec3 to, const vec3 up, versor dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotatev(versor from, vec3 to, vec3 dest);
|
||||
glmc_quat_rotatev(const versor from, const vec3 to, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate(mat4 m, versor q, mat4 dest);
|
||||
glmc_quat_rotate(CGLM_CONST mat4 m, const versor q, mat4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate_at(mat4 model, versor q, vec3 pivot);
|
||||
glmc_quat_rotate_at(mat4 model, const versor q, const vec3 pivot);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_quat_rotate_atm(mat4 m, versor q, vec3 pivot);
|
||||
glmc_quat_rotate_atm(mat4 m, const versor q, const vec3 pivot);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
|
||||
+11
-10
@@ -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
|
||||
}
|
||||
|
||||
+56
-52
@@ -11,11 +11,11 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2(float * __restrict v, vec2 dest);
|
||||
glmc_vec2(const float * __restrict v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -23,15 +23,15 @@ glmc_vec2_fill(vec2 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_eq(vec2 v, float val);
|
||||
glmc_vec2_eq(const vec2 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_eqv(vec2 a, vec2 b);
|
||||
glmc_vec2_eqv(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_copy(vec2 a, vec2 dest);
|
||||
glmc_vec2_copy(const vec2 a, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -43,107 +43,107 @@ glmc_vec2_one(vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_dot(vec2 a, vec2 b);
|
||||
glmc_vec2_dot(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_cross(vec2 a, vec2 b);
|
||||
glmc_vec2_cross(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_norm2(vec2 v);
|
||||
glmc_vec2_norm2(const vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_norm(vec2 v);
|
||||
glmc_vec2_norm(const vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_add(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_add(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_adds(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_adds(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_sub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_sub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subs(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_subs(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mul(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_mul(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_scale(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_scale(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_scale_as(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_scale_as(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_div(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_div(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_divs(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_divs(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_addadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_addadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_subadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_muladd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_muladd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_muladds(vec2 a, float s, vec2 dest);
|
||||
glmc_vec2_muladds(const vec2 a, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minadd(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minadd(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_subsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_subsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_addsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_addsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mulsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_mulsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mulsubs(vec2 a, float s, vec2 dest);
|
||||
glmc_vec2_mulsubs(const vec2 a, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minsub(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minsub(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_negate_to(vec2 v, vec2 dest);
|
||||
glmc_vec2_negate_to(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -155,31 +155,31 @@ glmc_vec2_normalize(vec2 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_normalize_to(vec2 v, vec2 dest);
|
||||
glmc_vec2_normalize_to(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_rotate(vec2 v, float angle, vec2 dest);
|
||||
glmc_vec2_rotate(const vec2 v, float angle, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_center(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_center(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_distance2(vec2 a, vec2 b);
|
||||
glmc_vec2_distance2(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec2_distance(vec2 a, vec2 b);
|
||||
glmc_vec2_distance(const vec2 a, const vec2 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_maxv(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_maxv(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_minv(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_minv(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -187,51 +187,51 @@ glmc_vec2_clamp(vec2 v, float minval, float maxval);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_abs(vec2 v, vec2 dest);
|
||||
glmc_vec2_abs(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_fract(vec2 v, vec2 dest);
|
||||
glmc_vec2_fract(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_floor(vec2 v, vec2 dest);
|
||||
glmc_vec2_floor(const vec2 v, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_mods(vec2 v, float s, vec2 dest);
|
||||
glmc_vec2_mods(const vec2 v, float s, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_swizzle(vec2 v, int mask, vec2 dest);
|
||||
glmc_vec2_swizzle(const vec2 v, int mask, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_lerp(vec2 from, vec2 to, float t, vec2 dest);
|
||||
glmc_vec2_lerp(const vec2 from, const vec2 to, float t, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_step(vec2 edge, vec2 x, vec2 dest);
|
||||
glmc_vec2_step(const vec2 edge, const vec2 x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_steps(float edge, vec2 x, vec2 dest);
|
||||
glmc_vec2_steps(float edge, const vec2 x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_stepr(vec2 edge, float x, vec2 dest);
|
||||
glmc_vec2_stepr(const vec2 edge, float x, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_mul(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_complex_mul(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_div(vec2 a, vec2 b, vec2 dest);
|
||||
glmc_vec2_complex_div(const vec2 a, const vec2 b, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_complex_conjugate(vec2 a, vec2 dest);
|
||||
glmc_vec2_complex_conjugate(const vec2 a, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -239,11 +239,15 @@ glmc_vec2_make(const float * __restrict src, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_reflect(vec2 v, vec2 n, vec2 dest);
|
||||
glmc_vec2_reflect(const vec2 v, const vec2 n, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec2_refract(vec2 v, vec2 n, float eta, vec2 dest);
|
||||
glmc_vec2_refract(const vec2 v, const vec2 n, float eta, vec2 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec2_swap(vec2 a, vec2 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+80
-76
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _copy, _ucopy versions */
|
||||
#define glmc_vec_dup(v, dest) glmc_vec3_copy(v, dest)
|
||||
@@ -23,11 +23,11 @@ extern "C" {
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3(vec4 v4, vec3 dest);
|
||||
glmc_vec3(const vec4 v4, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_copy(vec3 a, vec3 dest);
|
||||
glmc_vec3_copy(const vec3 a, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -39,35 +39,35 @@ glmc_vec3_one(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_dot(vec3 a, vec3 b);
|
||||
glmc_vec3_dot(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_cross(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_cross(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_crossn(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_crossn(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm(vec3 v);
|
||||
glmc_vec3_norm(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm2(vec3 v);
|
||||
glmc_vec3_norm2(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm_one(vec3 v);
|
||||
glmc_vec3_norm_one(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_norm_inf(vec3 v);
|
||||
glmc_vec3_norm_inf(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_normalize_to(vec3 v, vec3 dest);
|
||||
glmc_vec3_normalize_to(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -75,87 +75,87 @@ glmc_vec3_normalize(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_add(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_add(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_adds(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_adds(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_sub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subs(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_subs(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mul(vec3 a, vec3 b, vec3 d);
|
||||
glmc_vec3_mul(const vec3 a, const vec3 b, vec3 d);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_scale(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_scale(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_scale_as(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_scale_as(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_div(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_div(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_divs(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_divs(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_addadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_addadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_subadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_muladd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_muladd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_muladds(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_muladds(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minadd(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minadd(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_subsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_subsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_addsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_addsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mulsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_mulsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mulsubs(vec3 a, float s, vec3 dest);
|
||||
glmc_vec3_mulsubs(const vec3 a, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minsub(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minsub(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -163,47 +163,47 @@ glmc_vec3_negate(vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_negate_to(vec3 v, vec3 dest);
|
||||
glmc_vec3_negate_to(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_angle(vec3 a, vec3 b);
|
||||
glmc_vec3_angle(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate(vec3 v, float angle, vec3 axis);
|
||||
glmc_vec3_rotate(vec3 v, float angle, const vec3 axis);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate_m4(mat4 m, vec3 v, vec3 dest);
|
||||
glmc_vec3_rotate_m4(CGLM_CONST mat4 m, const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_rotate_m3(mat3 m, vec3 v, vec3 dest);
|
||||
glmc_vec3_rotate_m3(CGLM_CONST mat3 m, const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_proj(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_proj(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_center(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_center(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_distance2(vec3 a, vec3 b);
|
||||
glmc_vec3_distance2(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_distance(vec3 a, vec3 b);
|
||||
glmc_vec3_distance(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_maxv(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_maxv(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_minv(vec3 a, vec3 b, vec3 dest);
|
||||
glmc_vec3_minv(const vec3 a, const vec3 b, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -211,51 +211,51 @@ glmc_vec3_clamp(vec3 v, float minVal, float maxVal);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_ortho(vec3 v, vec3 dest);
|
||||
glmc_vec3_ortho(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_lerp(vec3 from, vec3 to, float t, vec3 dest);
|
||||
glmc_vec3_lerp(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_lerpc(vec3 from, vec3 to, float t, vec3 dest);
|
||||
glmc_vec3_lerpc(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec3_mix(vec3 from, vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_mix(const vec3 from, const vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_lerp(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec3_mixc(vec3 from, vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_mixc(const vec3 from, const vec3 to, float t, vec3 dest) {
|
||||
glmc_vec3_lerpc(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_step(vec3 edge, vec3 x, vec3 dest);
|
||||
glmc_vec3_step(const vec3 edge, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothstep_uni(float edge0, float edge1, vec3 x, vec3 dest);
|
||||
glmc_vec3_smoothstep_uni(float edge0, float edge1, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothstep(vec3 edge0, vec3 edge1, vec3 x, vec3 dest);
|
||||
glmc_vec3_smoothstep(const vec3 edge0, const vec3 edge1, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothinterp(vec3 from, vec3 to, float t, vec3 dest);
|
||||
glmc_vec3_smoothinterp(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_smoothinterpc(vec3 from, vec3 to, float t, vec3 dest);
|
||||
glmc_vec3_smoothinterpc(const vec3 from, const vec3 to, float t, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_swizzle(vec3 v, int mask, vec3 dest);
|
||||
glmc_vec3_swizzle(const vec3 v, int mask, vec3 dest);
|
||||
|
||||
/* ext */
|
||||
|
||||
@@ -273,79 +273,79 @@ glmc_vec3_fill(vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq(vec3 v, float val);
|
||||
glmc_vec3_eq(const vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq_eps(vec3 v, float val);
|
||||
glmc_vec3_eq_eps(const vec3 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eq_all(vec3 v);
|
||||
glmc_vec3_eq_all(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eqv(vec3 a, vec3 b);
|
||||
glmc_vec3_eqv(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_eqv_eps(vec3 a, vec3 b);
|
||||
glmc_vec3_eqv_eps(const vec3 a, const vec3 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_max(vec3 v);
|
||||
glmc_vec3_max(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_min(vec3 v);
|
||||
glmc_vec3_min(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isnan(vec3 v);
|
||||
glmc_vec3_isnan(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isinf(vec3 v);
|
||||
glmc_vec3_isinf(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_isvalid(vec3 v);
|
||||
glmc_vec3_isvalid(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sign(vec3 v, vec3 dest);
|
||||
glmc_vec3_sign(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_abs(vec3 v, vec3 dest);
|
||||
glmc_vec3_abs(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_fract(vec3 v, vec3 dest);
|
||||
glmc_vec3_fract(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_floor(vec3 v, vec3 dest);
|
||||
glmc_vec3_floor(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_mods(vec3 v, float s, vec3 dest);
|
||||
glmc_vec3_mods(const vec3 v, float s, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_steps(float edge, vec3 x, vec3 dest);
|
||||
glmc_vec3_steps(float edge, const vec3 x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_stepr(vec3 edge, float x, vec3 dest);
|
||||
glmc_vec3_stepr(const vec3 edge, float x, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec3_hadd(vec3 v);
|
||||
glmc_vec3_hadd(const vec3 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_sqrt(vec3 v, vec3 dest);
|
||||
glmc_vec3_sqrt(const vec3 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -353,15 +353,19 @@ glmc_vec3_make(const float * __restrict src, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_faceforward(vec3 n, vec3 v, vec3 nref, vec3 dest);
|
||||
glmc_vec3_faceforward(const vec3 n, const vec3 v, const vec3 nref, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_reflect(vec3 v, vec3 n, vec3 dest);
|
||||
glmc_vec3_reflect(const vec3 v, const vec3 n, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec3_refract(vec3 v, vec3 n, float eta, vec3 dest);
|
||||
glmc_vec3_refract(const vec3 v, const vec3 n, float eta, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec3_swap(vec3 a, vec3 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+72
-68
@@ -11,7 +11,7 @@
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include "../cglm.h"
|
||||
#include "../common.h"
|
||||
|
||||
/* DEPRECATED! use _copy, _ucopy versions */
|
||||
#define glmc_vec4_dup3(v, dest) glmc_vec4_copy3(v, dest)
|
||||
@@ -24,7 +24,7 @@ extern "C" {
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4(vec3 v3, float last, vec4 dest);
|
||||
glmc_vec4(const vec3 v3, float last, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -36,39 +36,39 @@ glmc_vec4_one(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_copy3(vec4 v, vec3 dest);
|
||||
glmc_vec4_copy3(const vec4 v, vec3 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_copy(vec4 v, vec4 dest);
|
||||
glmc_vec4_copy(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_ucopy(vec4 v, vec4 dest);
|
||||
glmc_vec4_ucopy(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_dot(vec4 a, vec4 b);
|
||||
glmc_vec4_dot(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm(vec4 v);
|
||||
glmc_vec4_norm(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm2(vec4 v);
|
||||
glmc_vec4_norm2(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm_one(vec4 v);
|
||||
glmc_vec4_norm_one(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_norm_inf(vec4 v);
|
||||
glmc_vec4_norm_inf(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_normalize_to(vec4 v, vec4 dest);
|
||||
glmc_vec4_normalize_to(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -76,87 +76,87 @@ glmc_vec4_normalize(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_add(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_add(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_adds(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_adds(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_sub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subs(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_subs(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mul(vec4 a, vec4 b, vec4 d);
|
||||
glmc_vec4_mul(const vec4 a, const vec4 b, vec4 d);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_scale(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_scale(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_scale_as(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_scale_as(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_div(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_div(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_divs(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_divs(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_addadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_addadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_subadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_muladd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_muladd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_muladds(vec4 a, float s, vec4 dest);
|
||||
glmc_vec4_muladds(const vec4 a, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minadd(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minadd(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_subsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_subsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_addsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_addsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mulsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_mulsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mulsubs(vec4 a, float s, vec4 dest);
|
||||
glmc_vec4_mulsubs(const vec4 a, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minsub(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minsub(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -164,23 +164,23 @@ glmc_vec4_negate(vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_negate_to(vec4 v, vec4 dest);
|
||||
glmc_vec4_negate_to(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_distance(vec4 a, vec4 b);
|
||||
glmc_vec4_distance(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_distance2(vec4 a, vec4 b);
|
||||
glmc_vec4_distance2(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_maxv(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_maxv(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_minv(vec4 a, vec4 b, vec4 dest);
|
||||
glmc_vec4_minv(const vec4 a, const vec4 b, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -188,43 +188,43 @@ glmc_vec4_clamp(vec4 v, float minVal, float maxVal);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_lerp(vec4 from, vec4 to, float t, vec4 dest);
|
||||
glmc_vec4_lerp(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_lerpc(vec4 from, vec4 to, float t, vec4 dest);
|
||||
glmc_vec4_lerpc(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec4_mix(vec4 from, vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_mix(const vec4 from, const vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_lerp(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glmc_vec4_mixc(vec4 from, vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_mixc(const vec4 from, const vec4 to, float t, vec4 dest) {
|
||||
glmc_vec4_lerpc(from, to, t, dest);
|
||||
}
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_step(vec4 edge, vec4 x, vec4 dest);
|
||||
glmc_vec4_step(const vec4 edge, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothstep_uni(float edge0, float edge1, vec4 x, vec4 dest);
|
||||
glmc_vec4_smoothstep_uni(float edge0, float edge1, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothstep(vec4 edge0, vec4 edge1, vec4 x, vec4 dest);
|
||||
glmc_vec4_smoothstep(const vec4 edge0, const vec4 edge1, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothinterp(vec4 from, vec4 to, float t, vec4 dest);
|
||||
glmc_vec4_smoothinterp(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_smoothinterpc(vec4 from, vec4 to, float t, vec4 dest);
|
||||
glmc_vec4_smoothinterpc(const vec4 from, const vec4 to, float t, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -232,7 +232,7 @@ glmc_vec4_cubic(float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_swizzle(vec4 v, int mask, vec4 dest);
|
||||
glmc_vec4_swizzle(const vec4 v, int mask, vec4 dest);
|
||||
|
||||
/* ext */
|
||||
|
||||
@@ -250,79 +250,79 @@ glmc_vec4_fill(vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq(vec4 v, float val);
|
||||
glmc_vec4_eq(const vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq_eps(vec4 v, float val);
|
||||
glmc_vec4_eq_eps(const vec4 v, float val);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eq_all(vec4 v);
|
||||
glmc_vec4_eq_all(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eqv(vec4 a, vec4 b);
|
||||
glmc_vec4_eqv(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_eqv_eps(vec4 a, vec4 b);
|
||||
glmc_vec4_eqv_eps(const vec4 a, const vec4 b);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_max(vec4 v);
|
||||
glmc_vec4_max(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_min(vec4 v);
|
||||
glmc_vec4_min(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isnan(vec4 v);
|
||||
glmc_vec4_isnan(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isinf(vec4 v);
|
||||
glmc_vec4_isinf(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_isvalid(vec4 v);
|
||||
glmc_vec4_isvalid(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sign(vec4 v, vec4 dest);
|
||||
glmc_vec4_sign(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_abs(vec4 v, vec4 dest);
|
||||
glmc_vec4_abs(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_fract(vec4 v, vec4 dest);
|
||||
glmc_vec4_fract(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_floor(vec4 v, vec4 dest);
|
||||
glmc_vec4_floor(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_mods(vec4 v, float s, vec4 dest);
|
||||
glmc_vec4_mods(const vec4 v, float s, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_steps(float edge, vec4 x, vec4 dest);
|
||||
glmc_vec4_steps(float edge, const vec4 x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_stepr(vec4 edge, float x, vec4 dest);
|
||||
glmc_vec4_stepr(const vec4 edge, float x, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
float
|
||||
glmc_vec4_hadd(vec4 v);
|
||||
glmc_vec4_hadd(const vec4 v);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_sqrt(vec4 v, vec4 dest);
|
||||
glmc_vec4_sqrt(const vec4 v, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
@@ -330,11 +330,15 @@ glmc_vec4_make(const float * __restrict src, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_reflect(vec4 v, vec4 n, vec4 dest);
|
||||
glmc_vec4_reflect(const vec4 v, const vec4 n, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
bool
|
||||
glmc_vec4_refract(vec4 v, vec4 n, float eta, vec4 dest);
|
||||
glmc_vec4_refract(const vec4 v, const vec4 n, float eta, vec4 dest);
|
||||
|
||||
CGLM_EXPORT
|
||||
void
|
||||
glmc_vec4_swap(vec4 a, vec4 b);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
+82
-34
@@ -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
|
||||
|
||||
@@ -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),
|
||||
|
||||
@@ -8,8 +8,8 @@
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_persp_decomp_far(mat4 proj, float *farZ)
|
||||
CGLM_INLINE float glm_persp_fovy(mat4 proj)
|
||||
CGLM_INLINE float glm_persp_aspect(mat4 proj)
|
||||
CGLM_INLINE float glm_persp_fovy(CGLM_CONST mat4 proj)
|
||||
CGLM_INLINE float glm_persp_aspect(CGLM_CONST mat4 proj)
|
||||
CGLM_INLINE void glm_persp_sizes(mat4 proj, float fovy, vec4 dest)
|
||||
*/
|
||||
|
||||
@@ -30,7 +30,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_fovy(mat4 proj) {
|
||||
glm_persp_fovy(CGLM_CONST mat4 proj) {
|
||||
return 2.0f * atanf(1.0f / proj[1][1]);
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ glm_persp_fovy(mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_aspect(mat4 proj) {
|
||||
glm_persp_aspect(CGLM_CONST mat4 proj) {
|
||||
return proj[1][1] / proj[0][0];
|
||||
}
|
||||
|
||||
|
||||
@@ -16,31 +16,36 @@
|
||||
float nearZ,
|
||||
float farZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_infinite_lh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_lh_no(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_infinite_lh_no(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_resize_lh_no(float aspect, mat4 proj)
|
||||
CGLM_INLINE void glm_persp_move_far_lh_no(mat4 proj,
|
||||
float deltaFar)
|
||||
CGLM_INLINE void glm_persp_decomp_lh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decompv_lh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decompv_lh_no(CGLM_CONST mat4 proj,
|
||||
float dest[6])
|
||||
CGLM_INLINE void glm_persp_decomp_x_lh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_x_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decomp_y_lh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_y_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom)
|
||||
CGLM_INLINE void glm_persp_decomp_z_lh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_z_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest)
|
||||
CGLM_INLINE void glm_persp_decomp_far_lh_no(CGLM_CONST mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_lh_no(CGLM_CONST mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_lh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_persp_lh_no_h
|
||||
@@ -116,7 +121,35 @@ glm_perspective_lh_no(float fovy,
|
||||
dest[2][2] =-(nearZ + farZ) * fn;
|
||||
dest[2][3] = 1.0f;
|
||||
dest[3][2] = 2.0f * nearZ * farZ * fn;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_infinite_lh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest) {
|
||||
float f;
|
||||
|
||||
glm_mat4_zero(dest);
|
||||
|
||||
f = 1.0f / tanf(fovy * 0.5f);
|
||||
|
||||
dest[0][0] = f / aspect;
|
||||
dest[1][1] = f;
|
||||
dest[2][2] = 1.0f;
|
||||
dest[2][3] = 1.0f;
|
||||
dest[3][2] =-2.0f * nearZ;
|
||||
}
|
||||
|
||||
/*!
|
||||
@@ -133,6 +166,20 @@ glm_perspective_default_lh_no(float aspect, mat4 dest) {
|
||||
glm_perspective_lh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix with default near
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_default_infinite_lh_no(float aspect, mat4 dest) {
|
||||
glm_perspective_infinite_lh_no(GLM_PI_4f, aspect, 0.01f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
@@ -192,7 +239,7 @@ glm_persp_move_far_lh_no(mat4 proj, float deltaFar) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_lh_no(mat4 proj,
|
||||
glm_persp_decomp_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
@@ -231,7 +278,7 @@ glm_persp_decomp_lh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
|
||||
glm_persp_decompv_lh_no(CGLM_CONST mat4 proj, float dest[6]) {
|
||||
glm_persp_decomp_lh_no(proj, &dest[0], &dest[1], &dest[2],
|
||||
&dest[3], &dest[4], &dest[5]);
|
||||
}
|
||||
@@ -248,7 +295,7 @@ glm_persp_decompv_lh_no(mat4 proj, float dest[6]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_x_lh_no(mat4 proj,
|
||||
glm_persp_decomp_x_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
float nearZ, m20, m00, m22;
|
||||
@@ -274,7 +321,7 @@ glm_persp_decomp_x_lh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_y_lh_no(mat4 proj,
|
||||
glm_persp_decomp_y_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
float nearZ, m21, m11, m22;
|
||||
@@ -300,7 +347,7 @@ glm_persp_decomp_y_lh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_z_lh_no(mat4 proj,
|
||||
glm_persp_decomp_z_lh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
float m32, m22;
|
||||
@@ -322,7 +369,7 @@ glm_persp_decomp_z_lh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_lh_no(CGLM_CONST mat4 proj, float * __restrict farZ) {
|
||||
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
|
||||
}
|
||||
|
||||
@@ -336,7 +383,7 @@ glm_persp_decomp_far_lh_no(mat4 proj, float * __restrict farZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_lh_no(CGLM_CONST mat4 proj, float * __restrict nearZ) {
|
||||
*nearZ = proj[3][2] / (-proj[2][2] - 1.0f);
|
||||
}
|
||||
|
||||
@@ -351,7 +398,7 @@ glm_persp_decomp_near_lh_no(mat4 proj, float * __restrict nearZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
|
||||
glm_persp_sizes_lh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
|
||||
float t, a, nearZ, farZ;
|
||||
|
||||
t = 2.0f * tanf(fovy * 0.5f);
|
||||
@@ -376,7 +423,7 @@ glm_persp_sizes_lh_no(mat4 proj, float fovy, vec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_fovy_lh_no(mat4 proj) {
|
||||
glm_persp_fovy_lh_no(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_fovy(proj);
|
||||
}
|
||||
|
||||
@@ -388,7 +435,7 @@ glm_persp_fovy_lh_no(mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_aspect_lh_no(mat4 proj) {
|
||||
glm_persp_aspect_lh_no(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_aspect(proj);
|
||||
}
|
||||
|
||||
|
||||
@@ -16,31 +16,36 @@
|
||||
float nearZ,
|
||||
float farZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_infinite_lh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_lh_zo(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_infinite_lh_zo(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_resize_lh_zo(float aspect, mat4 proj)
|
||||
CGLM_INLINE void glm_persp_move_far_lh_zo(mat4 proj,
|
||||
float deltaFar)
|
||||
CGLM_INLINE void glm_persp_decomp_lh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decompv_lh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decompv_lh_zo(CGLM_CONST mat4 proj,
|
||||
float dest[6])
|
||||
CGLM_INLINE void glm_persp_decomp_x_lh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_x_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decomp_y_lh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_y_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom)
|
||||
CGLM_INLINE void glm_persp_decomp_z_lh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_z_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest)
|
||||
CGLM_INLINE void glm_persp_decomp_far_lh_zo(CGLM_CONST mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_lh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_lh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_persp_lh_zo_h
|
||||
@@ -116,6 +121,35 @@ glm_perspective_lh_zo(float fovy,
|
||||
dest[3][2] = nearZ * farZ * fn;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix
|
||||
* with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_infinite_lh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest) {
|
||||
float f;
|
||||
|
||||
glm_mat4_zero(dest);
|
||||
|
||||
f = 1.0f / tanf(fovy * 0.5f);
|
||||
|
||||
dest[0][0] = f / aspect;
|
||||
dest[1][1] = f;
|
||||
dest[2][2] = 1.0f;
|
||||
dest[2][3] = 1.0f;
|
||||
dest[3][2] =-nearZ;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief extend perspective projection matrix's far distance with a
|
||||
* left-hand coordinate system and a clip-space with depth values
|
||||
@@ -144,7 +178,7 @@ glm_persp_move_far_lh_zo(mat4 proj, float deltaFar) {
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
@@ -156,6 +190,20 @@ glm_perspective_default_lh_zo(float aspect, mat4 dest) {
|
||||
glm_perspective_lh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix with default near
|
||||
* and angle values with a left-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_default_infinite_lh_zo(float aspect, mat4 dest) {
|
||||
glm_perspective_infinite_lh_zo(GLM_PI_4f, aspect, 0.01f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
@@ -188,7 +236,7 @@ glm_perspective_resize_lh_zo(float aspect, mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_lh_zo(mat4 proj,
|
||||
glm_persp_decomp_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
@@ -227,7 +275,7 @@ glm_persp_decomp_lh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
|
||||
glm_persp_decompv_lh_zo(CGLM_CONST mat4 proj, float dest[6]) {
|
||||
glm_persp_decomp_lh_zo(proj, &dest[0], &dest[1], &dest[2],
|
||||
&dest[3], &dest[4], &dest[5]);
|
||||
}
|
||||
@@ -242,7 +290,7 @@ glm_persp_decompv_lh_zo(mat4 proj, float dest[6]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_x_lh_zo(mat4 proj,
|
||||
glm_persp_decomp_x_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
float nearZ, m20, m00;
|
||||
@@ -267,7 +315,7 @@ glm_persp_decomp_x_lh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_y_lh_zo(mat4 proj,
|
||||
glm_persp_decomp_y_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
float nearZ, m21, m11;
|
||||
@@ -292,7 +340,7 @@ glm_persp_decomp_y_lh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_z_lh_zo(mat4 proj,
|
||||
glm_persp_decomp_z_lh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
float m32, m22;
|
||||
@@ -314,7 +362,7 @@ glm_persp_decomp_z_lh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_lh_zo(CGLM_CONST mat4 proj, float * __restrict farZ) {
|
||||
*farZ = proj[3][2] / (-proj[2][2] + 1.0f);
|
||||
}
|
||||
|
||||
@@ -328,7 +376,7 @@ glm_persp_decomp_far_lh_zo(mat4 proj, float * __restrict farZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_lh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ) {
|
||||
*nearZ = proj[3][2] / -proj[2][2];
|
||||
}
|
||||
|
||||
@@ -343,7 +391,7 @@ glm_persp_decomp_near_lh_zo(mat4 proj, float * __restrict nearZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
|
||||
glm_persp_sizes_lh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
|
||||
float t, a, nearZ, farZ;
|
||||
|
||||
t = 2.0f * tanf(fovy * 0.5f);
|
||||
@@ -368,7 +416,7 @@ glm_persp_sizes_lh_zo(mat4 proj, float fovy, vec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_fovy_lh_zo(mat4 proj) {
|
||||
glm_persp_fovy_lh_zo(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_fovy(proj);
|
||||
}
|
||||
|
||||
@@ -380,7 +428,7 @@ glm_persp_fovy_lh_zo(mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_aspect_lh_zo(mat4 proj) {
|
||||
glm_persp_aspect_lh_zo(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_aspect(proj);
|
||||
}
|
||||
|
||||
|
||||
@@ -16,31 +16,36 @@
|
||||
float nearZ,
|
||||
float farZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_infinite_rh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_rh_no(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_infinite_rh_no(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_resize_rh_no(float aspect, mat4 proj)
|
||||
CGLM_INLINE void glm_persp_move_far_rh_no(mat4 proj,
|
||||
float deltaFar)
|
||||
CGLM_INLINE void glm_persp_decomp_rh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decompv_rh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decompv_rh_no(CGLM_CONST mat4 proj,
|
||||
float dest[6])
|
||||
CGLM_INLINE void glm_persp_decomp_x_rh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_x_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decomp_y_rh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_y_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom)
|
||||
CGLM_INLINE void glm_persp_decomp_z_rh_no(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_z_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest)
|
||||
CGLM_INLINE void glm_persp_decomp_far_rh_no(CGLM_CONST mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_rh_no(CGLM_CONST mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_rh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_persp_rh_no_h
|
||||
@@ -116,7 +121,35 @@ glm_perspective_rh_no(float fovy,
|
||||
dest[2][2] = (nearZ + farZ) * fn;
|
||||
dest[2][3] =-1.0f;
|
||||
dest[3][2] = 2.0f * nearZ * farZ * fn;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_infinite_rh_no(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest) {
|
||||
float f;
|
||||
|
||||
glm_mat4_zero(dest);
|
||||
|
||||
f = 1.0f / tanf(fovy * 0.5f);
|
||||
|
||||
dest[0][0] = f / aspect;
|
||||
dest[1][1] = f;
|
||||
dest[2][2] =-1.0f;
|
||||
dest[2][3] =-1.0f;
|
||||
dest[3][2] =-2.0f * nearZ;
|
||||
}
|
||||
|
||||
/*!
|
||||
@@ -133,6 +166,20 @@ glm_perspective_default_rh_no(float aspect, mat4 dest) {
|
||||
glm_perspective_rh_no(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix with default near
|
||||
* and angle values with a right-hand coordinate system and a
|
||||
* clip-space of [-1, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_default_infinite_rh_no(float aspect, mat4 dest) {
|
||||
glm_perspective_infinite_rh_no(GLM_PI_4f, aspect, 0.01f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
@@ -192,7 +239,7 @@ glm_persp_move_far_rh_no(mat4 proj, float deltaFar) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_rh_no(mat4 proj,
|
||||
glm_persp_decomp_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
@@ -231,7 +278,7 @@ glm_persp_decomp_rh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
|
||||
glm_persp_decompv_rh_no(CGLM_CONST mat4 proj, float dest[6]) {
|
||||
glm_persp_decomp_rh_no(proj, &dest[0], &dest[1], &dest[2],
|
||||
&dest[3], &dest[4], &dest[5]);
|
||||
}
|
||||
@@ -248,7 +295,7 @@ glm_persp_decompv_rh_no(mat4 proj, float dest[6]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_x_rh_no(mat4 proj,
|
||||
glm_persp_decomp_x_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
float nearZ, m20, m00, m22;
|
||||
@@ -274,7 +321,7 @@ glm_persp_decomp_x_rh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_y_rh_no(mat4 proj,
|
||||
glm_persp_decomp_y_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
float nearZ, m21, m11, m22;
|
||||
@@ -300,7 +347,7 @@ glm_persp_decomp_y_rh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_z_rh_no(mat4 proj,
|
||||
glm_persp_decomp_z_rh_no(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
float m32, m22;
|
||||
@@ -322,7 +369,7 @@ glm_persp_decomp_z_rh_no(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_rh_no(CGLM_CONST mat4 proj, float * __restrict farZ) {
|
||||
*farZ = proj[3][2] / (proj[2][2] + 1.0f);
|
||||
}
|
||||
|
||||
@@ -336,7 +383,7 @@ glm_persp_decomp_far_rh_no(mat4 proj, float * __restrict farZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_rh_no(CGLM_CONST mat4 proj, float * __restrict nearZ) {
|
||||
*nearZ = proj[3][2] / (proj[2][2] - 1.0f);
|
||||
}
|
||||
|
||||
@@ -351,7 +398,7 @@ glm_persp_decomp_near_rh_no(mat4 proj, float * __restrict nearZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
|
||||
glm_persp_sizes_rh_no(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
|
||||
float t, a, nearZ, farZ;
|
||||
|
||||
t = 2.0f * tanf(fovy * 0.5f);
|
||||
@@ -376,7 +423,7 @@ glm_persp_sizes_rh_no(mat4 proj, float fovy, vec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_fovy_rh_no(mat4 proj) {
|
||||
glm_persp_fovy_rh_no(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_fovy(proj);
|
||||
}
|
||||
|
||||
@@ -388,7 +435,7 @@ glm_persp_fovy_rh_no(mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_aspect_rh_no(mat4 proj) {
|
||||
glm_persp_aspect_rh_no(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_aspect(proj);
|
||||
}
|
||||
|
||||
|
||||
@@ -16,31 +16,36 @@
|
||||
float nearZ,
|
||||
float farZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_infinite_rh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_rh_zo(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_default_infinite_rh_zo(float aspect, mat4 dest)
|
||||
CGLM_INLINE void glm_perspective_resize_rh_zo(float aspect, mat4 proj)
|
||||
CGLM_INLINE void glm_persp_move_far_rh_zo(mat4 proj,
|
||||
float deltaFar)
|
||||
CGLM_INLINE void glm_persp_decomp_rh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decompv_rh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decompv_rh_zo(CGLM_CONST mat4 proj,
|
||||
float dest[6])
|
||||
CGLM_INLINE void glm_persp_decomp_x_rh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_x_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right)
|
||||
CGLM_INLINE void glm_persp_decomp_y_rh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_y_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom)
|
||||
CGLM_INLINE void glm_persp_decomp_z_rh_zo(mat4 proj,
|
||||
CGLM_INLINE void glm_persp_decomp_z_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest)
|
||||
CGLM_INLINE void glm_persp_decomp_far_rh_zo(CGLM_CONST mat4 proj, float * __restrict farZ)
|
||||
CGLM_INLINE void glm_persp_decomp_near_rh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ)
|
||||
CGLM_INLINE void glm_persp_sizes_rh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_persp_rh_zo_h
|
||||
@@ -116,6 +121,35 @@ glm_perspective_rh_zo(float fovy,
|
||||
dest[3][2] = nearZ * farZ * fn;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix
|
||||
* with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] fovy field of view angle
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[in] nearZ near clipping plane
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_infinite_rh_zo(float fovy,
|
||||
float aspect,
|
||||
float nearZ,
|
||||
mat4 dest) {
|
||||
float f;
|
||||
|
||||
glm_mat4_zero(dest);
|
||||
|
||||
f = 1.0f / tanf(fovy * 0.5f);
|
||||
|
||||
dest[0][0] = f / aspect;
|
||||
dest[1][1] = f;
|
||||
dest[2][2] =-1.0f;
|
||||
dest[2][3] =-1.0f;
|
||||
dest[3][2] =-nearZ;
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up perspective projection matrix with default near/far
|
||||
* and angle values with a right-hand coordinate system and a
|
||||
@@ -130,6 +164,20 @@ glm_perspective_default_rh_zo(float aspect, mat4 dest) {
|
||||
glm_perspective_rh_zo(GLM_PI_4f, aspect, 0.01f, 100.0f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief set up infinite perspective projection matrix with default near
|
||||
* and angle values with a right-hand coordinate system and a
|
||||
* clip-space of [0, 1].
|
||||
*
|
||||
* @param[in] aspect aspect ratio ( width / height )
|
||||
* @param[out] dest result matrix
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_perspective_default_infinite_rh_zo(float aspect, mat4 dest) {
|
||||
glm_perspective_infinite_rh_zo(GLM_PI_4f, aspect, 0.01f, dest);
|
||||
}
|
||||
|
||||
/*!
|
||||
* @brief resize perspective matrix by aspect ratio ( width / height )
|
||||
* this makes very easy to resize proj matrix when window /viewport
|
||||
@@ -188,7 +236,7 @@ glm_persp_move_far_rh_zo(mat4 proj, float deltaFar) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_rh_zo(mat4 proj,
|
||||
glm_persp_decomp_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ, float * __restrict farZ,
|
||||
float * __restrict top, float * __restrict bottom,
|
||||
float * __restrict left, float * __restrict right) {
|
||||
@@ -227,7 +275,7 @@ glm_persp_decomp_rh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
|
||||
glm_persp_decompv_rh_zo(CGLM_CONST mat4 proj, float dest[6]) {
|
||||
glm_persp_decomp_rh_zo(proj, &dest[0], &dest[1], &dest[2],
|
||||
&dest[3], &dest[4], &dest[5]);
|
||||
}
|
||||
@@ -242,7 +290,7 @@ glm_persp_decompv_rh_zo(mat4 proj, float dest[6]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_x_rh_zo(mat4 proj,
|
||||
glm_persp_decomp_x_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict left,
|
||||
float * __restrict right) {
|
||||
float nearZ, m20, m00, m22;
|
||||
@@ -268,7 +316,7 @@ glm_persp_decomp_x_rh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_y_rh_zo(mat4 proj,
|
||||
glm_persp_decomp_y_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict top,
|
||||
float * __restrict bottom) {
|
||||
float nearZ, m21, m11, m22;
|
||||
@@ -294,7 +342,7 @@ glm_persp_decomp_y_rh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_z_rh_zo(mat4 proj,
|
||||
glm_persp_decomp_z_rh_zo(CGLM_CONST mat4 proj,
|
||||
float * __restrict nearZ,
|
||||
float * __restrict farZ) {
|
||||
float m32, m22;
|
||||
@@ -316,7 +364,7 @@ glm_persp_decomp_z_rh_zo(mat4 proj,
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
|
||||
glm_persp_decomp_far_rh_zo(CGLM_CONST mat4 proj, float * __restrict farZ) {
|
||||
*farZ = proj[3][2] / (proj[2][2] + 1.0f);
|
||||
}
|
||||
|
||||
@@ -330,7 +378,7 @@ glm_persp_decomp_far_rh_zo(mat4 proj, float * __restrict farZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
|
||||
glm_persp_decomp_near_rh_zo(CGLM_CONST mat4 proj, float * __restrict nearZ) {
|
||||
*nearZ = proj[3][2] / proj[2][2];
|
||||
}
|
||||
|
||||
@@ -345,7 +393,7 @@ glm_persp_decomp_near_rh_zo(mat4 proj, float * __restrict nearZ) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
|
||||
glm_persp_sizes_rh_zo(CGLM_CONST mat4 proj, float fovy, vec4 dest) {
|
||||
float t, a, nearZ, farZ;
|
||||
|
||||
t = 2.0f * tanf(fovy * 0.5f);
|
||||
@@ -370,7 +418,7 @@ glm_persp_sizes_rh_zo(mat4 proj, float fovy, vec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_fovy_rh_zo(mat4 proj) {
|
||||
glm_persp_fovy_rh_zo(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_fovy(proj);
|
||||
}
|
||||
|
||||
@@ -382,7 +430,7 @@ glm_persp_fovy_rh_zo(mat4 proj) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_persp_aspect_rh_zo(mat4 proj) {
|
||||
glm_persp_aspect_rh_zo(CGLM_CONST mat4 proj) {
|
||||
return glm_persp_aspect(proj);
|
||||
}
|
||||
|
||||
|
||||
@@ -41,7 +41,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
|
||||
glm_unprojecti_no(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest) {
|
||||
vec4 v;
|
||||
|
||||
v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
|
||||
@@ -68,7 +68,7 @@ glm_unprojecti_no(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
|
||||
glm_project_no(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest) {
|
||||
CGLM_ALIGN(16) vec4 pos4;
|
||||
|
||||
glm_vec4(pos, 1.0f, pos4);
|
||||
@@ -97,7 +97,7 @@ glm_project_no(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_project_z_no(vec3 v, mat4 m) {
|
||||
glm_project_z_no(const vec3 v, CGLM_CONST mat4 m) {
|
||||
float z, w;
|
||||
|
||||
z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
|
||||
|
||||
@@ -41,7 +41,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
|
||||
glm_unprojecti_zo(const vec3 pos, CGLM_CONST mat4 invMat, const vec4 vp, vec3 dest) {
|
||||
vec4 v;
|
||||
|
||||
v[0] = 2.0f * (pos[0] - vp[0]) / vp[2] - 1.0f;
|
||||
@@ -68,7 +68,7 @@ glm_unprojecti_zo(vec3 pos, mat4 invMat, vec4 vp, vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
|
||||
glm_project_zo(const vec3 pos, CGLM_CONST mat4 m, const vec4 vp, vec3 dest) {
|
||||
CGLM_ALIGN(16) vec4 pos4;
|
||||
|
||||
glm_vec4(pos, 1.0f, pos4);
|
||||
@@ -99,7 +99,7 @@ glm_project_zo(vec3 pos, mat4 m, vec4 vp, vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_project_z_zo(vec3 v, mat4 m) {
|
||||
glm_project_z_zo(const vec3 v, CGLM_CONST mat4 m) {
|
||||
float z, w;
|
||||
|
||||
z = m[0][2] * v[0] + m[1][2] * v[1] + m[2][2] * v[2] + m[3][2];
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_lh_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_lh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 f, u, s;
|
||||
|
||||
glm_vec3_sub(center, eye, f);
|
||||
@@ -72,7 +72,7 @@ glm_lookat_lh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_lh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 target;
|
||||
glm_vec3_add(eye, dir, target);
|
||||
glm_lookat_lh(eye, target, up, dest);
|
||||
@@ -90,7 +90,7 @@ glm_look_lh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_lh(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_lh(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 up;
|
||||
glm_vec3_ortho(dir, up);
|
||||
glm_look_lh(eye, dir, up, dest);
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_lh_no_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_lh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
glm_lookat_lh(eye, center, up, dest);
|
||||
}
|
||||
|
||||
@@ -51,7 +51,7 @@ glm_lookat_lh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_lh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
glm_look_lh(eye, dir, up, dest);
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ glm_look_lh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_lh_no(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_lh_no(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_lh(eye, dir, dest);
|
||||
}
|
||||
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_lh_zo_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_lh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
glm_lookat_lh(eye, center, up, dest);
|
||||
}
|
||||
|
||||
@@ -51,7 +51,7 @@ glm_lookat_lh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_lh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
glm_look_lh(eye, dir, up, dest);
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ glm_look_lh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_lh_zo(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_lh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_lh(eye, dir, dest);
|
||||
}
|
||||
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_rh_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_rh(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 f, u, s;
|
||||
|
||||
glm_vec3_sub(center, eye, f);
|
||||
@@ -72,7 +72,7 @@ glm_lookat_rh(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_rh(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 target;
|
||||
glm_vec3_add(eye, dir, target);
|
||||
glm_lookat_rh(eye, target, up, dest);
|
||||
@@ -90,7 +90,7 @@ glm_look_rh(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_rh(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_rh(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
CGLM_ALIGN(8) vec3 up;
|
||||
glm_vec3_ortho(dir, up);
|
||||
glm_look_rh(eye, dir, up, dest);
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_rh_no_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_rh_no(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
glm_lookat_rh(eye, center, up, dest);
|
||||
}
|
||||
|
||||
@@ -51,7 +51,7 @@ glm_lookat_rh_no(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_rh_no(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
glm_look_rh(eye, dir, up, dest);
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ glm_look_rh_no(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_rh_no(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_rh_no(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_rh(eye, dir, dest);
|
||||
}
|
||||
|
||||
|
||||
@@ -7,9 +7,9 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest)
|
||||
CGLM_INLINE void glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest)
|
||||
CGLM_INLINE void glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_view_rh_zo_h
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
glm_lookat_rh_zo(const vec3 eye, const vec3 center, const vec3 up, mat4 dest) {
|
||||
glm_lookat_rh(eye, center, up, dest);
|
||||
}
|
||||
|
||||
@@ -51,7 +51,7 @@ glm_lookat_rh_zo(vec3 eye, vec3 center, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
glm_look_rh_zo(const vec3 eye, const vec3 dir, const vec3 up, mat4 dest) {
|
||||
glm_look_rh(eye, dir, up, dest);
|
||||
}
|
||||
|
||||
@@ -67,7 +67,7 @@ glm_look_rh_zo(vec3 eye, vec3 dir, vec3 up, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_look_anyup_rh_zo(vec3 eye, vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_rh_zo(const vec3 eye, const vec3 dir, mat4 dest) {
|
||||
glm_look_anyup_rh(eye, dir, dest);
|
||||
}
|
||||
|
||||
|
||||
@@ -18,7 +18,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_luminance(vec3 rgb) {
|
||||
glm_luminance(const vec3 rgb) {
|
||||
vec3 l = {0.212671f, 0.715160f, 0.072169f};
|
||||
return glm_dot(rgb, l);
|
||||
}
|
||||
|
||||
@@ -39,6 +39,13 @@
|
||||
# define CGLM_INLINE static inline __attribute((always_inline))
|
||||
#endif
|
||||
|
||||
/* const qualifier for multi-dimensional array parameters (matN, vecN[M]), only possible in C23 and C++ */
|
||||
#if defined(__cplusplus) || (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202000L)
|
||||
# define CGLM_CONST const
|
||||
#else
|
||||
# define CGLM_CONST
|
||||
#endif
|
||||
|
||||
#if defined(__GNUC__) || defined(__clang__)
|
||||
# define CGLM_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
|
||||
# define CGLM_LIKELY(expr) __builtin_expect(!!(expr), 1)
|
||||
|
||||
@@ -31,7 +31,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_smc(float s, mat4 m, vec4 c) {
|
||||
glm_smc(float s, CGLM_CONST mat4 m, const vec4 c) {
|
||||
vec4 vs;
|
||||
glm_vec4_cubic(s, vs);
|
||||
return glm_mat4_rmc(vs, m, c);
|
||||
|
||||
+32
-51
@@ -18,24 +18,24 @@
|
||||
enum glm_euler_seq
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE glm_euler_seq glm_euler_order(int newOrder[3]);
|
||||
CGLM_INLINE void glm_euler_angles(mat4 m, vec3 dest);
|
||||
CGLM_INLINE void glm_euler(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_xyz(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_zyx(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_zxy(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_xzy(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_yzx(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_yxz(vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_by_order(vec3 angles,
|
||||
CGLM_INLINE glm_euler_seq glm_euler_order(const int ord[3]);
|
||||
CGLM_INLINE void glm_euler_angles(CGLM_CONST mat4 m, vec3 dest);
|
||||
CGLM_INLINE void glm_euler(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_xyz(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_zyx(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_zxy(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_xzy(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_yzx(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_yxz(const vec3 angles, mat4 dest);
|
||||
CGLM_INLINE void glm_euler_by_order(const vec3 angles,
|
||||
glm_euler_seq ord,
|
||||
mat4 dest);
|
||||
CGLM_INLINE void glm_euler_xyz_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xyz_quat(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat(const vec3 angles, versor dest);
|
||||
*/
|
||||
|
||||
#ifndef cglm_euler_h
|
||||
@@ -83,28 +83,9 @@
|
||||
# include "clipspace/view_rh_no.h"
|
||||
#endif
|
||||
|
||||
|
||||
/*!
|
||||
* if you have axis order like vec3 orderVec = [0, 1, 2] or [0, 2, 1]...
|
||||
* vector then you can convert it to this enum by doing this:
|
||||
* @code
|
||||
* glm_euler_seq order;
|
||||
* order = orderVec[0] | orderVec[1] << 2 | orderVec[2] << 4;
|
||||
* @endcode
|
||||
* you may need to explicit cast if required
|
||||
*/
|
||||
typedef enum glm_euler_seq {
|
||||
GLM_EULER_XYZ = 0 << 0 | 1 << 2 | 2 << 4,
|
||||
GLM_EULER_XZY = 0 << 0 | 2 << 2 | 1 << 4,
|
||||
GLM_EULER_YZX = 1 << 0 | 2 << 2 | 0 << 4,
|
||||
GLM_EULER_YXZ = 1 << 0 | 0 << 2 | 2 << 4,
|
||||
GLM_EULER_ZXY = 2 << 0 | 0 << 2 | 1 << 4,
|
||||
GLM_EULER_ZYX = 2 << 0 | 1 << 2 | 0 << 4
|
||||
} glm_euler_seq;
|
||||
|
||||
CGLM_INLINE
|
||||
glm_euler_seq
|
||||
glm_euler_order(int ord[3]) {
|
||||
glm_euler_order(const int ord[3]) {
|
||||
return (glm_euler_seq)(ord[0] << 0 | ord[1] << 2 | ord[2] << 4);
|
||||
}
|
||||
|
||||
@@ -116,7 +97,7 @@ glm_euler_order(int ord[3]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_angles(mat4 m, vec3 dest) {
|
||||
glm_euler_angles(CGLM_CONST mat4 m, vec3 dest) {
|
||||
float m00, m01, m10, m11, m20, m21, m22;
|
||||
float thetaX, thetaY, thetaZ;
|
||||
|
||||
@@ -154,7 +135,7 @@ glm_euler_angles(mat4 m, vec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xyz(vec3 angles, mat4 dest) {
|
||||
glm_euler_xyz(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, czsx, cxcz, sysz;
|
||||
|
||||
@@ -192,7 +173,7 @@ glm_euler_xyz(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler(vec3 angles, mat4 dest) {
|
||||
glm_euler(const vec3 angles, mat4 dest) {
|
||||
glm_euler_xyz(angles, dest);
|
||||
}
|
||||
|
||||
@@ -204,7 +185,7 @@ glm_euler(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xzy(vec3 angles, mat4 dest) {
|
||||
glm_euler_xzy(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, sxsy, cysx, cxsy, cxcy;
|
||||
|
||||
@@ -243,7 +224,7 @@ glm_euler_xzy(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yxz(vec3 angles, mat4 dest) {
|
||||
glm_euler_yxz(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, cycz, sysz, czsy, cysz;
|
||||
|
||||
@@ -282,7 +263,7 @@ glm_euler_yxz(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yzx(vec3 angles, mat4 dest) {
|
||||
glm_euler_yzx(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, sxsy, cxcy, cysx, cxsy;
|
||||
|
||||
@@ -321,7 +302,7 @@ glm_euler_yzx(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zxy(vec3 angles, mat4 dest) {
|
||||
glm_euler_zxy(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, cycz, sxsy, cysz;
|
||||
|
||||
@@ -359,7 +340,7 @@ glm_euler_zxy(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zyx(vec3 angles, mat4 dest) {
|
||||
glm_euler_zyx(const vec3 angles, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz, czsx, cxcz, sysz;
|
||||
|
||||
@@ -398,7 +379,7 @@ glm_euler_zyx(vec3 angles, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
|
||||
glm_euler_by_order(const vec3 angles, glm_euler_seq ord, mat4 dest) {
|
||||
float cx, cy, cz,
|
||||
sx, sy, sz;
|
||||
|
||||
@@ -504,7 +485,7 @@ glm_euler_by_order(vec3 angles, glm_euler_seq ord, mat4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xyz_quat(vec3 angles, versor dest) {
|
||||
glm_euler_xyz_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_xyz_quat_lh(angles, dest);
|
||||
#else
|
||||
@@ -521,7 +502,7 @@ glm_euler_xyz_quat(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xzy_quat(vec3 angles, versor dest) {
|
||||
glm_euler_xzy_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_xzy_quat_lh(angles, dest);
|
||||
#else
|
||||
@@ -538,7 +519,7 @@ glm_euler_xzy_quat(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yxz_quat(vec3 angles, versor dest) {
|
||||
glm_euler_yxz_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_yxz_quat_lh(angles, dest);
|
||||
#else
|
||||
@@ -555,7 +536,7 @@ glm_euler_yxz_quat(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yzx_quat(vec3 angles, versor dest) {
|
||||
glm_euler_yzx_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_yzx_quat_lh(angles, dest);
|
||||
#else
|
||||
@@ -572,7 +553,7 @@ glm_euler_yzx_quat(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zxy_quat(vec3 angles, versor dest) {
|
||||
glm_euler_zxy_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_zxy_quat_lh(angles, dest);
|
||||
#else
|
||||
@@ -589,7 +570,7 @@ glm_euler_zxy_quat(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zyx_quat(vec3 angles, versor dest) {
|
||||
glm_euler_zyx_quat(const vec3 angles, versor dest) {
|
||||
#ifdef CGLM_FORCE_LEFT_HANDED
|
||||
glm_euler_zyx_quat_lh(angles, dest);
|
||||
#else
|
||||
|
||||
@@ -69,7 +69,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_frustum_planes(mat4 m, vec4 dest[6]) {
|
||||
glm_frustum_planes(CGLM_CONST mat4 m, vec4 dest[6]) {
|
||||
mat4 t;
|
||||
|
||||
glm_mat4_transpose_to(m, t);
|
||||
@@ -114,7 +114,7 @@ glm_frustum_planes(mat4 m, vec4 dest[6]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
|
||||
glm_frustum_corners(CGLM_CONST mat4 invMat, vec4 dest[8]) {
|
||||
vec4 c[8];
|
||||
|
||||
/* indexOf(nearCoord) = indexOf(farCoord) + 4 */
|
||||
@@ -157,7 +157,7 @@ glm_frustum_corners(mat4 invMat, vec4 dest[8]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_frustum_center(vec4 corners[8], vec4 dest) {
|
||||
glm_frustum_center(CGLM_CONST vec4 corners[8], vec4 dest) {
|
||||
vec4 center;
|
||||
|
||||
glm_vec4_copy(corners[0], center);
|
||||
@@ -182,7 +182,7 @@ glm_frustum_center(vec4 corners[8], vec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
|
||||
glm_frustum_box(CGLM_CONST vec4 corners[8], CGLM_CONST mat4 m, vec3 box[2]) {
|
||||
vec4 v;
|
||||
vec3 min, max;
|
||||
int i;
|
||||
@@ -220,7 +220,7 @@ glm_frustum_box(vec4 corners[8], mat4 m, vec3 box[2]) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_frustum_corners_at(vec4 corners[8],
|
||||
glm_frustum_corners_at(CGLM_CONST vec4 corners[8],
|
||||
float splitDist,
|
||||
float farDist,
|
||||
vec4 planeCorners[4]) {
|
||||
|
||||
@@ -7,12 +7,12 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_euler_xyz_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat_lh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xyz_quat_lh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat_lh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat_lh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat_lh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat_lh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat_lh(const vec3 angles, versor dest);
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -35,7 +35,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xyz_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_xyz_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -58,7 +58,7 @@ glm_euler_xyz_quat_lh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xzy_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_xzy_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -81,7 +81,7 @@ glm_euler_xzy_quat_lh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yxz_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_yxz_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -104,7 +104,7 @@ glm_euler_yxz_quat_lh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yzx_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_yzx_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -127,7 +127,7 @@ glm_euler_yzx_quat_lh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zxy_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_zxy_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -150,7 +150,7 @@ glm_euler_zxy_quat_lh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zyx_quat_lh(vec3 angles, versor dest) {
|
||||
glm_euler_zyx_quat_lh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
|
||||
@@ -7,12 +7,12 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_euler_xyz_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat_rh(vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xyz_quat_rh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_xzy_quat_rh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yxz_quat_rh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_yzx_quat_rh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zxy_quat_rh(const vec3 angles, versor dest);
|
||||
CGLM_INLINE void glm_euler_zyx_quat_rh(const vec3 angles, versor dest);
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -34,7 +34,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xyz_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_xyz_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -58,7 +58,7 @@ glm_euler_xyz_quat_rh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_xzy_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_xzy_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -82,7 +82,7 @@ glm_euler_xzy_quat_rh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yxz_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_yxz_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -105,7 +105,7 @@ glm_euler_yxz_quat_rh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_yzx_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_yzx_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -129,7 +129,7 @@ glm_euler_yzx_quat_rh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zxy_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_zxy_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
@@ -152,7 +152,7 @@ glm_euler_zxy_quat_rh(vec3 angles, versor dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_euler_zyx_quat_rh(vec3 angles, versor dest) {
|
||||
glm_euler_zyx_quat_rh(const vec3 angles, versor dest) {
|
||||
float xc, yc, zc,
|
||||
xs, ys, zs;
|
||||
|
||||
|
||||
+21
-21
@@ -7,16 +7,16 @@
|
||||
|
||||
/*
|
||||
Functions:
|
||||
CGLM_INLINE void glm_mat4_print(mat4 matrix, FILE *ostream);
|
||||
CGLM_INLINE void glm_mat3_print(mat3 matrix, FILE *ostream);
|
||||
CGLM_INLINE void glm_vec4_print(vec4 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_ivec4_print(ivec4 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_vec3_print(vec3 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_ivec3_print(ivec3 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_vec2_print(vec2 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_ivec2_print(ivec2 vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_versor_print(versor vec, FILE *ostream);
|
||||
CGLM_INLINE void glm_arch_print(FILE *ostream);
|
||||
CGLM_INLINE void glm_mat4_print(CGLM_CONST mat4 matrix, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_mat3_print(CGLM_CONST mat3 matrix, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_vec4_print(const vec4 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_ivec4_print(const ivec4 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_vec3_print(const vec3 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_ivec3_print(const ivec3 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_vec2_print(const vec2 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_ivec2_print(const ivec2 vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_versor_print(const versor vec, FILE * __restrict ostream);
|
||||
CGLM_INLINE void glm_arch_print(FILE* __restrict ostream);
|
||||
*/
|
||||
|
||||
/*
|
||||
@@ -117,7 +117,7 @@ glm_arch_print_name(FILE* __restrict ostream) {
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_mat4_print(mat4 matrix,
|
||||
glm_mat4_print(CGLM_CONST mat4 matrix,
|
||||
FILE * __restrict ostream) {
|
||||
char buff[16];
|
||||
int i, j, cw[4], cwi;
|
||||
@@ -160,7 +160,7 @@ glm_mat4_print(mat4 matrix,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_mat3_print(mat3 matrix,
|
||||
glm_mat3_print(CGLM_CONST mat3 matrix,
|
||||
FILE * __restrict ostream) {
|
||||
char buff[16];
|
||||
int i, j, cw[4], cwi;
|
||||
@@ -202,7 +202,7 @@ glm_mat3_print(mat3 matrix,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_mat2_print(mat2 matrix,
|
||||
glm_mat2_print(CGLM_CONST mat2 matrix,
|
||||
FILE * __restrict ostream) {
|
||||
char buff[16];
|
||||
int i, j, cw[4], cwi;
|
||||
@@ -244,7 +244,7 @@ glm_mat2_print(mat2 matrix,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_vec4_print(vec4 vec,
|
||||
glm_vec4_print(const vec4 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -266,7 +266,7 @@ glm_vec4_print(vec4 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_print(ivec4 vec,
|
||||
glm_ivec4_print(const ivec4 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -284,7 +284,7 @@ glm_ivec4_print(ivec4 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_vec3_print(vec3 vec,
|
||||
glm_vec3_print(const vec3 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -306,7 +306,7 @@ glm_vec3_print(vec3 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_print(ivec3 vec,
|
||||
glm_ivec3_print(const ivec3 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -324,7 +324,7 @@ glm_ivec3_print(ivec3 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_vec2_print(vec2 vec,
|
||||
glm_vec2_print(const vec2 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -346,7 +346,7 @@ glm_vec2_print(vec2 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_print(ivec2 vec,
|
||||
glm_ivec2_print(const ivec2 vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -364,7 +364,7 @@ glm_ivec2_print(ivec2 vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_versor_print(versor vec,
|
||||
glm_versor_print(const versor vec,
|
||||
FILE * __restrict ostream) {
|
||||
int i;
|
||||
|
||||
@@ -387,7 +387,7 @@ glm_versor_print(versor vec,
|
||||
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_aabb_print(vec3 bbox[2],
|
||||
glm_aabb_print(CGLM_CONST vec3 bbox[2],
|
||||
const char * __restrict tag,
|
||||
FILE * __restrict ostream) {
|
||||
int i, j;
|
||||
|
||||
+72
-72
@@ -13,46 +13,46 @@
|
||||
GLM_IVEC2_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE void glm_ivec2(int * __restrict v, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_copy(ivec2 a, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2(const int * __restrict v, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_copy(const ivec2 a, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_zero(ivec2 v)
|
||||
CGLM_INLINE void glm_ivec2_one(ivec2 v)
|
||||
CGLM_INLINE int glm_ivec2_dot(ivec2 a, ivec2 b)
|
||||
CGLM_INLINE int glm_ivec2_cross(ivec2 a, ivec2 b)
|
||||
CGLM_INLINE void glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_adds(ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subs(ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_scale(ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_divs(ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addadds(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subadds(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_muladds(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE int glm_ivec2_distance2(ivec2 a, ivec2 b)
|
||||
CGLM_INLINE float glm_ivec2_distance(ivec2 a, ivec2 b)
|
||||
CGLM_INLINE int glm_ivec2_dot(const ivec2 a, const ivec2 b)
|
||||
CGLM_INLINE int glm_ivec2_cross(const ivec2 a, const ivec2 b)
|
||||
CGLM_INLINE void glm_ivec2_add(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_adds(const ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_sub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subs(const ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mul(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_scale(const ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_div(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_divs(const ivec2 v, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mod(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addadd(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addadds(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subadd(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subadds(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_muladd(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_muladds(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_maxadd(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minadd(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subsub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_subsubs(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addsub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_addsubs(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mulsub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_mulsubs(const ivec2 a, int s, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_maxsub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minsub(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE int glm_ivec2_distance2(const ivec2 a, const ivec2 b)
|
||||
CGLM_INLINE float glm_ivec2_distance(const ivec2 a, const ivec2 b)
|
||||
CGLM_INLINE void glm_ivec2_fill(ivec2 v, int val);
|
||||
CGLM_INLINE bool glm_ivec2_eq(ivec2 v, int val);
|
||||
CGLM_INLINE bool glm_ivec2_eqv(ivec2 a, ivec2 b);
|
||||
CGLM_INLINE void glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE bool glm_ivec2_eq(const ivec2 v, int val);
|
||||
CGLM_INLINE bool glm_ivec2_eqv(const ivec2 a, const ivec2 b);
|
||||
CGLM_INLINE void glm_ivec2_maxv(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_minv(const ivec2 a, const ivec2 b, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_clamp(ivec2 v, int minVal, int maxVal)
|
||||
CGLM_INLINE void glm_ivec2_abs(ivec2 v, ivec2 dest)
|
||||
CGLM_INLINE void glm_ivec2_abs(const ivec2 v, ivec2 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_ivec2_h
|
||||
@@ -75,7 +75,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2(int * __restrict v, ivec2 dest) {
|
||||
glm_ivec2(const int * __restrict v, ivec2 dest) {
|
||||
dest[0] = v[0];
|
||||
dest[1] = v[1];
|
||||
}
|
||||
@@ -88,7 +88,7 @@ glm_ivec2(int * __restrict v, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_copy(ivec2 a, ivec2 dest) {
|
||||
glm_ivec2_copy(const ivec2 a, ivec2 dest) {
|
||||
dest[0] = a[0];
|
||||
dest[1] = a[1];
|
||||
}
|
||||
@@ -125,7 +125,7 @@ glm_ivec2_one(ivec2 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec2_dot(ivec2 a, ivec2 b) {
|
||||
glm_ivec2_dot(const ivec2 a, const ivec2 b) {
|
||||
return a[0] * b[0] + a[1] * b[1];
|
||||
}
|
||||
|
||||
@@ -141,7 +141,7 @@ glm_ivec2_dot(ivec2 a, ivec2 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec2_cross(ivec2 a, ivec2 b) {
|
||||
glm_ivec2_cross(const ivec2 a, const ivec2 b) {
|
||||
return a[0] * b[1] - a[1] * b[0];
|
||||
}
|
||||
|
||||
@@ -154,7 +154,7 @@ glm_ivec2_cross(ivec2 a, ivec2 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_add(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] + b[0];
|
||||
dest[1] = a[1] + b[1];
|
||||
}
|
||||
@@ -168,7 +168,7 @@ glm_ivec2_add(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_adds(ivec2 v, int s, ivec2 dest) {
|
||||
glm_ivec2_adds(const ivec2 v, int s, ivec2 dest) {
|
||||
dest[0] = v[0] + s;
|
||||
dest[1] = v[1] + s;
|
||||
}
|
||||
@@ -182,7 +182,7 @@ glm_ivec2_adds(ivec2 v, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_sub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] - b[0];
|
||||
dest[1] = a[1] - b[1];
|
||||
}
|
||||
@@ -196,7 +196,7 @@ glm_ivec2_sub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_subs(ivec2 v, int s, ivec2 dest) {
|
||||
glm_ivec2_subs(const ivec2 v, int s, ivec2 dest) {
|
||||
dest[0] = v[0] - s;
|
||||
dest[1] = v[1] - s;
|
||||
}
|
||||
@@ -210,7 +210,7 @@ glm_ivec2_subs(ivec2 v, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_mul(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] * b[0];
|
||||
dest[1] = a[1] * b[1];
|
||||
}
|
||||
@@ -224,7 +224,7 @@ glm_ivec2_mul(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_scale(ivec2 v, int s, ivec2 dest) {
|
||||
glm_ivec2_scale(const ivec2 v, int s, ivec2 dest) {
|
||||
dest[0] = v[0] * s;
|
||||
dest[1] = v[1] * s;
|
||||
}
|
||||
@@ -238,7 +238,7 @@ glm_ivec2_scale(ivec2 v, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_div(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] / b[0];
|
||||
dest[1] = a[1] / b[1];
|
||||
}
|
||||
@@ -252,7 +252,7 @@ glm_ivec2_div(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_divs(ivec2 v, int s, ivec2 dest) {
|
||||
glm_ivec2_divs(const ivec2 v, int s, ivec2 dest) {
|
||||
dest[0] = v[0] / s;
|
||||
dest[1] = v[1] / s;
|
||||
}
|
||||
@@ -266,7 +266,7 @@ glm_ivec2_divs(ivec2 v, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_mod(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] % b[0];
|
||||
dest[1] = a[1] % b[1];
|
||||
}
|
||||
@@ -282,7 +282,7 @@ glm_ivec2_mod(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_addadd(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] += a[0] + b[0];
|
||||
dest[1] += a[1] + b[1];
|
||||
}
|
||||
@@ -298,7 +298,7 @@ glm_ivec2_addadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_addadds(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_addadds(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] += a[0] + s;
|
||||
dest[1] += a[1] + s;
|
||||
}
|
||||
@@ -314,7 +314,7 @@ glm_ivec2_addadds(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_subadd(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] += a[0] - b[0];
|
||||
dest[1] += a[1] - b[1];
|
||||
}
|
||||
@@ -330,7 +330,7 @@ glm_ivec2_subadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_subadds(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_subadds(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] += a[0] - s;
|
||||
dest[1] += a[1] - s;
|
||||
}
|
||||
@@ -346,7 +346,7 @@ glm_ivec2_subadds(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_muladd(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] += a[0] * b[0];
|
||||
dest[1] += a[1] * b[1];
|
||||
}
|
||||
@@ -362,7 +362,7 @@ glm_ivec2_muladd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_muladds(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_muladds(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] += a[0] * s;
|
||||
dest[1] += a[1] * s;
|
||||
}
|
||||
@@ -378,7 +378,7 @@ glm_ivec2_muladds(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_maxadd(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] += glm_imax(a[0], b[0]);
|
||||
dest[1] += glm_imax(a[1], b[1]);
|
||||
}
|
||||
@@ -394,7 +394,7 @@ glm_ivec2_maxadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_minadd(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] += glm_imin(a[0], b[0]);
|
||||
dest[1] += glm_imin(a[1], b[1]);
|
||||
}
|
||||
@@ -410,7 +410,7 @@ glm_ivec2_minadd(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_subsub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] -= a[0] - b[0];
|
||||
dest[1] -= a[1] - b[1];
|
||||
}
|
||||
@@ -426,7 +426,7 @@ glm_ivec2_subsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_subsubs(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] -= a[0] - s;
|
||||
dest[1] -= a[1] - s;
|
||||
}
|
||||
@@ -442,7 +442,7 @@ glm_ivec2_subsubs(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_addsub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] -= a[0] + b[0];
|
||||
dest[1] -= a[1] + b[1];
|
||||
}
|
||||
@@ -458,7 +458,7 @@ glm_ivec2_addsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_addsubs(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] -= a[0] + s;
|
||||
dest[1] -= a[1] + s;
|
||||
}
|
||||
@@ -474,7 +474,7 @@ glm_ivec2_addsubs(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_mulsub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] -= a[0] * b[0];
|
||||
dest[1] -= a[1] * b[1];
|
||||
}
|
||||
@@ -490,7 +490,7 @@ glm_ivec2_mulsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest) {
|
||||
glm_ivec2_mulsubs(const ivec2 a, int s, ivec2 dest) {
|
||||
dest[0] -= a[0] * s;
|
||||
dest[1] -= a[1] * s;
|
||||
}
|
||||
@@ -506,7 +506,7 @@ glm_ivec2_mulsubs(ivec2 a, int s, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_maxsub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] -= glm_imax(a[0], b[0]);
|
||||
dest[1] -= glm_imax(a[1], b[1]);
|
||||
}
|
||||
@@ -522,7 +522,7 @@ glm_ivec2_maxsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_minsub(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] -= glm_imin(a[0], b[0]);
|
||||
dest[1] -= glm_imin(a[1], b[1]);
|
||||
}
|
||||
@@ -536,7 +536,7 @@ glm_ivec2_minsub(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec2_distance2(ivec2 a, ivec2 b) {
|
||||
glm_ivec2_distance2(const ivec2 a, const ivec2 b) {
|
||||
int xd, yd;
|
||||
xd = a[0] - b[0];
|
||||
yd = a[1] - b[1];
|
||||
@@ -552,7 +552,7 @@ glm_ivec2_distance2(ivec2 a, ivec2 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_ivec2_distance(ivec2 a, ivec2 b) {
|
||||
glm_ivec2_distance(const ivec2 a, const ivec2 b) {
|
||||
return sqrtf((float)glm_ivec2_distance2(a, b));
|
||||
}
|
||||
|
||||
@@ -577,7 +577,7 @@ glm_ivec2_fill(ivec2 v, int val) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_ivec2_eq(ivec2 v, int val) {
|
||||
glm_ivec2_eq(const ivec2 v, int val) {
|
||||
return v[0] == val && v[0] == v[1];
|
||||
}
|
||||
|
||||
@@ -589,7 +589,7 @@ glm_ivec2_eq(ivec2 v, int val) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_ivec2_eqv(ivec2 a, ivec2 b) {
|
||||
glm_ivec2_eqv(const ivec2 a, const ivec2 b) {
|
||||
return a[0] == b[0]
|
||||
&& a[1] == b[1];
|
||||
}
|
||||
@@ -603,7 +603,7 @@ glm_ivec2_eqv(ivec2 a, ivec2 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_maxv(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] > b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] > b[1] ? a[1] : b[1];
|
||||
}
|
||||
@@ -617,7 +617,7 @@ glm_ivec2_maxv(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_minv(ivec2 a, ivec2 b, ivec2 dest) {
|
||||
glm_ivec2_minv(const ivec2 a, const ivec2 b, ivec2 dest) {
|
||||
dest[0] = a[0] < b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] < b[1] ? a[1] : b[1];
|
||||
}
|
||||
@@ -651,7 +651,7 @@ glm_ivec2_clamp(ivec2 v, int minVal, int maxVal) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec2_abs(ivec2 v, ivec2 dest) {
|
||||
glm_ivec2_abs(const ivec2 v, ivec2 dest) {
|
||||
dest[0] = abs(v[0]);
|
||||
dest[1] = abs(v[1]);
|
||||
}
|
||||
|
||||
+74
-74
@@ -13,47 +13,47 @@
|
||||
GLM_IVEC3_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE void glm_ivec3(ivec4 v4, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_copy(ivec3 a, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3(const ivec4 v4, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_copy(const ivec3 a, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_zero(ivec3 v)
|
||||
CGLM_INLINE void glm_ivec3_one(ivec3 v)
|
||||
CGLM_INLINE int glm_ivec3_dot(ivec3 a, ivec3 b)
|
||||
CGLM_INLINE int glm_ivec3_norm2(ivec3 v)
|
||||
CGLM_INLINE int glm_ivec3_norm(ivec3 v)
|
||||
CGLM_INLINE void glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_adds(ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subs(ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_scale(ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_divs(ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addadds(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subadds(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_muladds(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE int glm_ivec3_distance2(ivec3 a, ivec3 b)
|
||||
CGLM_INLINE float glm_ivec3_distance(ivec3 a, ivec3 b)
|
||||
CGLM_INLINE int glm_ivec3_dot(const ivec3 a, const ivec3 b)
|
||||
CGLM_INLINE int glm_ivec3_norm2(const ivec3 v)
|
||||
CGLM_INLINE int glm_ivec3_norm(const ivec3 v)
|
||||
CGLM_INLINE void glm_ivec3_add(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_adds(const ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_sub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subs(const ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mul(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_scale(const ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_div(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_divs(const ivec3 v, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mod(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addadd(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addadds(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subadd(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subadds(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_muladd(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_muladds(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_maxadd(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minadd(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subsub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_subsubs(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addsub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_addsubs(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mulsub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_mulsubs(const ivec3 a, int s, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_maxsub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minsub(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE int glm_ivec3_distance2(const ivec3 a, const ivec3 b)
|
||||
CGLM_INLINE float glm_ivec3_distance(const ivec3 a, const ivec3 b)
|
||||
CGLM_INLINE void glm_ivec3_fill(ivec3 v, int val);
|
||||
CGLM_INLINE bool glm_ivec3_eq(ivec3 v, int val);
|
||||
CGLM_INLINE bool glm_ivec3_eqv(ivec3 a, ivec3 b);
|
||||
CGLM_INLINE void glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE bool glm_ivec3_eq(const ivec3 v, int val);
|
||||
CGLM_INLINE bool glm_ivec3_eqv(const ivec3 a, const ivec3 b);
|
||||
CGLM_INLINE void glm_ivec3_maxv(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_minv(const ivec3 a, const ivec3 b, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_clamp(ivec3 v, int minVal, int maxVal)
|
||||
CGLM_INLINE void glm_ivec3_abs(ivec3 v, ivec3 dest)
|
||||
CGLM_INLINE void glm_ivec3_abs(const ivec3 v, ivec3 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_ivec3_h
|
||||
@@ -76,7 +76,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3(ivec4 v4, ivec3 dest) {
|
||||
glm_ivec3(const ivec4 v4, ivec3 dest) {
|
||||
dest[0] = v4[0];
|
||||
dest[1] = v4[1];
|
||||
dest[2] = v4[2];
|
||||
@@ -90,7 +90,7 @@ glm_ivec3(ivec4 v4, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_copy(ivec3 a, ivec3 dest) {
|
||||
glm_ivec3_copy(const ivec3 a, ivec3 dest) {
|
||||
dest[0] = a[0];
|
||||
dest[1] = a[1];
|
||||
dest[2] = a[2];
|
||||
@@ -128,7 +128,7 @@ glm_ivec3_one(ivec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec3_dot(ivec3 a, ivec3 b) {
|
||||
glm_ivec3_dot(const ivec3 a, const ivec3 b) {
|
||||
return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||||
}
|
||||
|
||||
@@ -145,7 +145,7 @@ glm_ivec3_dot(ivec3 a, ivec3 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec3_norm2(ivec3 v) {
|
||||
glm_ivec3_norm2(const ivec3 v) {
|
||||
return glm_ivec3_dot(v, v);
|
||||
}
|
||||
|
||||
@@ -159,7 +159,7 @@ glm_ivec3_norm2(ivec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec3_norm(ivec3 v) {
|
||||
glm_ivec3_norm(const ivec3 v) {
|
||||
return (int)sqrtf((float)glm_ivec3_norm2(v));
|
||||
}
|
||||
|
||||
@@ -172,7 +172,7 @@ glm_ivec3_norm(ivec3 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_add(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] + b[0];
|
||||
dest[1] = a[1] + b[1];
|
||||
dest[2] = a[2] + b[2];
|
||||
@@ -187,7 +187,7 @@ glm_ivec3_add(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_adds(ivec3 v, int s, ivec3 dest) {
|
||||
glm_ivec3_adds(const ivec3 v, int s, ivec3 dest) {
|
||||
dest[0] = v[0] + s;
|
||||
dest[1] = v[1] + s;
|
||||
dest[2] = v[2] + s;
|
||||
@@ -202,7 +202,7 @@ glm_ivec3_adds(ivec3 v, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_sub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] - b[0];
|
||||
dest[1] = a[1] - b[1];
|
||||
dest[2] = a[2] - b[2];
|
||||
@@ -217,7 +217,7 @@ glm_ivec3_sub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_subs(ivec3 v, int s, ivec3 dest) {
|
||||
glm_ivec3_subs(const ivec3 v, int s, ivec3 dest) {
|
||||
dest[0] = v[0] - s;
|
||||
dest[1] = v[1] - s;
|
||||
dest[2] = v[2] - s;
|
||||
@@ -232,7 +232,7 @@ glm_ivec3_subs(ivec3 v, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_mul(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] * b[0];
|
||||
dest[1] = a[1] * b[1];
|
||||
dest[2] = a[2] * b[2];
|
||||
@@ -247,7 +247,7 @@ glm_ivec3_mul(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_scale(ivec3 v, int s, ivec3 dest) {
|
||||
glm_ivec3_scale(const ivec3 v, int s, ivec3 dest) {
|
||||
dest[0] = v[0] * s;
|
||||
dest[1] = v[1] * s;
|
||||
dest[2] = v[2] * s;
|
||||
@@ -262,7 +262,7 @@ glm_ivec3_scale(ivec3 v, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_div(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] / b[0];
|
||||
dest[1] = a[1] / b[1];
|
||||
dest[2] = a[2] / b[2];
|
||||
@@ -277,7 +277,7 @@ glm_ivec3_div(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_divs(ivec3 v, int s, ivec3 dest) {
|
||||
glm_ivec3_divs(const ivec3 v, int s, ivec3 dest) {
|
||||
dest[0] = v[0] / s;
|
||||
dest[1] = v[1] / s;
|
||||
dest[2] = v[2] / s;
|
||||
@@ -294,7 +294,7 @@ glm_ivec3_divs(ivec3 v, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_mod(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] % b[0];
|
||||
dest[1] = a[1] % b[1];
|
||||
dest[2] = a[2] % b[2];
|
||||
@@ -311,7 +311,7 @@ glm_ivec3_mod(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_addadd(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] += a[0] + b[0];
|
||||
dest[1] += a[1] + b[1];
|
||||
dest[2] += a[2] + b[2];
|
||||
@@ -328,7 +328,7 @@ glm_ivec3_addadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_addadds(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_addadds(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] += a[0] + s;
|
||||
dest[1] += a[1] + s;
|
||||
dest[2] += a[2] + s;
|
||||
@@ -345,7 +345,7 @@ glm_ivec3_addadds(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_subadd(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] += a[0] - b[0];
|
||||
dest[1] += a[1] - b[1];
|
||||
dest[2] += a[2] - b[2];
|
||||
@@ -362,7 +362,7 @@ glm_ivec3_subadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_subadds(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_subadds(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] += a[0] - s;
|
||||
dest[1] += a[1] - s;
|
||||
dest[2] += a[2] - s;
|
||||
@@ -379,7 +379,7 @@ glm_ivec3_subadds(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_muladd(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] += a[0] * b[0];
|
||||
dest[1] += a[1] * b[1];
|
||||
dest[2] += a[2] * b[2];
|
||||
@@ -396,7 +396,7 @@ glm_ivec3_muladd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_muladds(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_muladds(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] += a[0] * s;
|
||||
dest[1] += a[1] * s;
|
||||
dest[2] += a[2] * s;
|
||||
@@ -413,7 +413,7 @@ glm_ivec3_muladds(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_maxadd(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] += glm_imax(a[0], b[0]);
|
||||
dest[1] += glm_imax(a[1], b[1]);
|
||||
dest[2] += glm_imax(a[2], b[2]);
|
||||
@@ -430,7 +430,7 @@ glm_ivec3_maxadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_minadd(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] += glm_imin(a[0], b[0]);
|
||||
dest[1] += glm_imin(a[1], b[1]);
|
||||
dest[2] += glm_imin(a[2], b[2]);
|
||||
@@ -447,7 +447,7 @@ glm_ivec3_minadd(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_subsub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] -= a[0] - b[0];
|
||||
dest[1] -= a[1] - b[1];
|
||||
dest[2] -= a[2] - b[2];
|
||||
@@ -464,7 +464,7 @@ glm_ivec3_subsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_subsubs(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] -= a[0] - s;
|
||||
dest[1] -= a[1] - s;
|
||||
dest[2] -= a[2] - s;
|
||||
@@ -481,7 +481,7 @@ glm_ivec3_subsubs(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_addsub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] -= a[0] + b[0];
|
||||
dest[1] -= a[1] + b[1];
|
||||
dest[2] -= a[2] + b[2];
|
||||
@@ -498,7 +498,7 @@ glm_ivec3_addsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_addsubs(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] -= a[0] + s;
|
||||
dest[1] -= a[1] + s;
|
||||
dest[2] -= a[2] + s;
|
||||
@@ -515,7 +515,7 @@ glm_ivec3_addsubs(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_mulsub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] -= a[0] * b[0];
|
||||
dest[1] -= a[1] * b[1];
|
||||
dest[2] -= a[2] * b[2];
|
||||
@@ -532,7 +532,7 @@ glm_ivec3_mulsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest) {
|
||||
glm_ivec3_mulsubs(const ivec3 a, int s, ivec3 dest) {
|
||||
dest[0] -= a[0] * s;
|
||||
dest[1] -= a[1] * s;
|
||||
dest[2] -= a[2] * s;
|
||||
@@ -549,7 +549,7 @@ glm_ivec3_mulsubs(ivec3 a, int s, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_maxsub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] -= glm_imax(a[0], b[0]);
|
||||
dest[1] -= glm_imax(a[1], b[1]);
|
||||
dest[2] -= glm_imax(a[2], b[2]);
|
||||
@@ -566,7 +566,7 @@ glm_ivec3_maxsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_minsub(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] -= glm_imin(a[0], b[0]);
|
||||
dest[1] -= glm_imin(a[1], b[1]);
|
||||
dest[2] -= glm_imin(a[2], b[2]);
|
||||
@@ -581,7 +581,7 @@ glm_ivec3_minsub(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec3_distance2(ivec3 a, ivec3 b) {
|
||||
glm_ivec3_distance2(const ivec3 a, const ivec3 b) {
|
||||
int xd, yd, zd;
|
||||
xd = a[0] - b[0];
|
||||
yd = a[1] - b[1];
|
||||
@@ -598,7 +598,7 @@ glm_ivec3_distance2(ivec3 a, ivec3 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_ivec3_distance(ivec3 a, ivec3 b) {
|
||||
glm_ivec3_distance(const ivec3 a, const ivec3 b) {
|
||||
return sqrtf((float)glm_ivec3_distance2(a, b));
|
||||
}
|
||||
|
||||
@@ -622,7 +622,7 @@ glm_ivec3_fill(ivec3 v, int val) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_ivec3_eq(ivec3 v, int val) {
|
||||
glm_ivec3_eq(const ivec3 v, int val) {
|
||||
return v[0] == val && v[0] == v[1] && v[0] == v[2];
|
||||
}
|
||||
|
||||
@@ -634,7 +634,7 @@ glm_ivec3_eq(ivec3 v, int val) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
bool
|
||||
glm_ivec3_eqv(ivec3 a, ivec3 b) {
|
||||
glm_ivec3_eqv(const ivec3 a, const ivec3 b) {
|
||||
return a[0] == b[0]
|
||||
&& a[1] == b[1]
|
||||
&& a[2] == b[2];
|
||||
@@ -649,7 +649,7 @@ glm_ivec3_eqv(ivec3 a, ivec3 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_maxv(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] > b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] > b[1] ? a[1] : b[1];
|
||||
dest[2] = a[2] > b[2] ? a[2] : b[2];
|
||||
@@ -664,7 +664,7 @@ glm_ivec3_maxv(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_minv(ivec3 a, ivec3 b, ivec3 dest) {
|
||||
glm_ivec3_minv(const ivec3 a, const ivec3 b, ivec3 dest) {
|
||||
dest[0] = a[0] < b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] < b[1] ? a[1] : b[1];
|
||||
dest[2] = a[2] < b[2] ? a[2] : b[2];
|
||||
@@ -704,7 +704,7 @@ glm_ivec3_clamp(ivec3 v, int minVal, int maxVal) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec3_abs(ivec3 v, ivec3 dest) {
|
||||
glm_ivec3_abs(const ivec3 v, ivec3 dest) {
|
||||
dest[0] = abs(v[0]);
|
||||
dest[1] = abs(v[1]);
|
||||
dest[2] = abs(v[2]);
|
||||
|
||||
+58
-58
@@ -13,38 +13,38 @@
|
||||
GLM_IVEC4_ZERO
|
||||
|
||||
Functions:
|
||||
CGLM_INLINE void glm_ivec4(ivec3 v3, int last, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_copy(ivec4 a, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4(const ivec3 v3, int last, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_copy(const ivec4 a, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_zero(ivec4 v)
|
||||
CGLM_INLINE void glm_ivec4_one(ivec4 v)
|
||||
CGLM_INLINE void glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_adds(ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subs(ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_scale(ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addadds(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subadds(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_muladds(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE int glm_ivec4_distance2(ivec4 a, ivec4 b)
|
||||
CGLM_INLINE float glm_ivec4_distance(ivec4 a, ivec4 b)
|
||||
CGLM_INLINE void glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_add(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_adds(const ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_sub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subs(const ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mul(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_scale(const ivec4 v, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addadd(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addadds(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subadd(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subadds(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_muladd(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_muladds(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_maxadd(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minadd(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subsub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_subsubs(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addsub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_addsubs(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mulsub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_mulsubs(const ivec4 a, int s, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_maxsub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minsub(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE int glm_ivec4_distance2(const ivec4 a, const ivec4 b)
|
||||
CGLM_INLINE float glm_ivec4_distance(const ivec4 a, const ivec4 b)
|
||||
CGLM_INLINE void glm_ivec4_maxv(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_minv(const ivec4 a, const ivec4 b, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_clamp(ivec4 v, int minVal, int maxVal)
|
||||
CGLM_INLINE void glm_ivec4_abs(ivec4 v, ivec4 dest)
|
||||
CGLM_INLINE void glm_ivec4_abs(const ivec4 v, ivec4 dest)
|
||||
*/
|
||||
|
||||
#ifndef cglm_ivec4_h
|
||||
@@ -68,7 +68,7 @@
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4(ivec3 v3, int last, ivec4 dest) {
|
||||
glm_ivec4(const ivec3 v3, int last, ivec4 dest) {
|
||||
dest[0] = v3[0];
|
||||
dest[1] = v3[1];
|
||||
dest[2] = v3[2];
|
||||
@@ -83,7 +83,7 @@ glm_ivec4(ivec3 v3, int last, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_copy(ivec4 a, ivec4 dest) {
|
||||
glm_ivec4_copy(const ivec4 a, ivec4 dest) {
|
||||
dest[0] = a[0];
|
||||
dest[1] = a[1];
|
||||
dest[2] = a[2];
|
||||
@@ -121,7 +121,7 @@ glm_ivec4_one(ivec4 v) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_add(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] = a[0] + b[0];
|
||||
dest[1] = a[1] + b[1];
|
||||
dest[2] = a[2] + b[2];
|
||||
@@ -137,7 +137,7 @@ glm_ivec4_add(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_adds(ivec4 v, int s, ivec4 dest) {
|
||||
glm_ivec4_adds(const ivec4 v, int s, ivec4 dest) {
|
||||
dest[0] = v[0] + s;
|
||||
dest[1] = v[1] + s;
|
||||
dest[2] = v[2] + s;
|
||||
@@ -153,7 +153,7 @@ glm_ivec4_adds(ivec4 v, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_sub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] = a[0] - b[0];
|
||||
dest[1] = a[1] - b[1];
|
||||
dest[2] = a[2] - b[2];
|
||||
@@ -169,7 +169,7 @@ glm_ivec4_sub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_subs(ivec4 v, int s, ivec4 dest) {
|
||||
glm_ivec4_subs(const ivec4 v, int s, ivec4 dest) {
|
||||
dest[0] = v[0] - s;
|
||||
dest[1] = v[1] - s;
|
||||
dest[2] = v[2] - s;
|
||||
@@ -185,7 +185,7 @@ glm_ivec4_subs(ivec4 v, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_mul(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] = a[0] * b[0];
|
||||
dest[1] = a[1] * b[1];
|
||||
dest[2] = a[2] * b[2];
|
||||
@@ -201,7 +201,7 @@ glm_ivec4_mul(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_scale(ivec4 v, int s, ivec4 dest) {
|
||||
glm_ivec4_scale(const ivec4 v, int s, ivec4 dest) {
|
||||
dest[0] = v[0] * s;
|
||||
dest[1] = v[1] * s;
|
||||
dest[2] = v[2] * s;
|
||||
@@ -219,7 +219,7 @@ glm_ivec4_scale(ivec4 v, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_addadd(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] += a[0] + b[0];
|
||||
dest[1] += a[1] + b[1];
|
||||
dest[2] += a[2] + b[2];
|
||||
@@ -237,7 +237,7 @@ glm_ivec4_addadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_addadds(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_addadds(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] += a[0] + s;
|
||||
dest[1] += a[1] + s;
|
||||
dest[2] += a[2] + s;
|
||||
@@ -255,7 +255,7 @@ glm_ivec4_addadds(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_subadd(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] += a[0] - b[0];
|
||||
dest[1] += a[1] - b[1];
|
||||
dest[2] += a[2] - b[2];
|
||||
@@ -273,7 +273,7 @@ glm_ivec4_subadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_subadds(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_subadds(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] += a[0] - s;
|
||||
dest[1] += a[1] - s;
|
||||
dest[2] += a[2] - s;
|
||||
@@ -291,7 +291,7 @@ glm_ivec4_subadds(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_muladd(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] += a[0] * b[0];
|
||||
dest[1] += a[1] * b[1];
|
||||
dest[2] += a[2] * b[2];
|
||||
@@ -309,7 +309,7 @@ glm_ivec4_muladd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_muladds(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_muladds(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] += a[0] * s;
|
||||
dest[1] += a[1] * s;
|
||||
dest[2] += a[2] * s;
|
||||
@@ -327,7 +327,7 @@ glm_ivec4_muladds(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_maxadd(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] += glm_imax(a[0], b[0]);
|
||||
dest[1] += glm_imax(a[1], b[1]);
|
||||
dest[2] += glm_imax(a[2], b[2]);
|
||||
@@ -345,7 +345,7 @@ glm_ivec4_maxadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_minadd(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] += glm_imin(a[0], b[0]);
|
||||
dest[1] += glm_imin(a[1], b[1]);
|
||||
dest[2] += glm_imin(a[2], b[2]);
|
||||
@@ -363,7 +363,7 @@ glm_ivec4_minadd(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_subsub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] -= a[0] - b[0];
|
||||
dest[1] -= a[1] - b[1];
|
||||
dest[2] -= a[2] - b[2];
|
||||
@@ -381,7 +381,7 @@ glm_ivec4_subsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_subsubs(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] -= a[0] - s;
|
||||
dest[1] -= a[1] - s;
|
||||
dest[2] -= a[2] - s;
|
||||
@@ -399,7 +399,7 @@ glm_ivec4_subsubs(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_addsub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] -= a[0] + b[0];
|
||||
dest[1] -= a[1] + b[1];
|
||||
dest[2] -= a[2] + b[2];
|
||||
@@ -417,7 +417,7 @@ glm_ivec4_addsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_addsubs(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] -= a[0] + s;
|
||||
dest[1] -= a[1] + s;
|
||||
dest[2] -= a[2] + s;
|
||||
@@ -435,7 +435,7 @@ glm_ivec4_addsubs(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_mulsub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] -= a[0] * b[0];
|
||||
dest[1] -= a[1] * b[1];
|
||||
dest[2] -= a[2] * b[2];
|
||||
@@ -453,7 +453,7 @@ glm_ivec4_mulsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest) {
|
||||
glm_ivec4_mulsubs(const ivec4 a, int s, ivec4 dest) {
|
||||
dest[0] -= a[0] * s;
|
||||
dest[1] -= a[1] * s;
|
||||
dest[2] -= a[2] * s;
|
||||
@@ -471,7 +471,7 @@ glm_ivec4_mulsubs(ivec4 a, int s, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_maxsub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] -= glm_imax(a[0], b[0]);
|
||||
dest[1] -= glm_imax(a[1], b[1]);
|
||||
dest[2] -= glm_imax(a[2], b[2]);
|
||||
@@ -489,7 +489,7 @@ glm_ivec4_maxsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_minsub(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] -= glm_imin(a[0], b[0]);
|
||||
dest[1] -= glm_imin(a[1], b[1]);
|
||||
dest[2] -= glm_imin(a[2], b[2]);
|
||||
@@ -505,7 +505,7 @@ glm_ivec4_minsub(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
int
|
||||
glm_ivec4_distance2(ivec4 a, ivec4 b) {
|
||||
glm_ivec4_distance2(const ivec4 a, const ivec4 b) {
|
||||
int xd, yd, zd, wd;
|
||||
xd = a[0] - b[0];
|
||||
yd = a[1] - b[1];
|
||||
@@ -523,7 +523,7 @@ glm_ivec4_distance2(ivec4 a, ivec4 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
float
|
||||
glm_ivec4_distance(ivec4 a, ivec4 b) {
|
||||
glm_ivec4_distance(const ivec4 a, const ivec4 b) {
|
||||
return sqrtf((float)glm_ivec4_distance2(a, b));
|
||||
}
|
||||
|
||||
@@ -536,7 +536,7 @@ glm_ivec4_distance(ivec4 a, ivec4 b) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_maxv(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] = a[0] > b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] > b[1] ? a[1] : b[1];
|
||||
dest[2] = a[2] > b[2] ? a[2] : b[2];
|
||||
@@ -552,7 +552,7 @@ glm_ivec4_maxv(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_minv(ivec4 a, ivec4 b, ivec4 dest) {
|
||||
glm_ivec4_minv(const ivec4 a, const ivec4 b, ivec4 dest) {
|
||||
dest[0] = a[0] < b[0] ? a[0] : b[0];
|
||||
dest[1] = a[1] < b[1] ? a[1] : b[1];
|
||||
dest[2] = a[2] < b[2] ? a[2] : b[2];
|
||||
@@ -598,7 +598,7 @@ glm_ivec4_clamp(ivec4 v, int minVal, int maxVal) {
|
||||
*/
|
||||
CGLM_INLINE
|
||||
void
|
||||
glm_ivec4_abs(ivec4 v, ivec4 dest) {
|
||||
glm_ivec4_abs(const ivec4 v, ivec4 dest) {
|
||||
dest[0] = abs(v[0]);
|
||||
dest[1] = abs(v[1]);
|
||||
dest[2] = abs(v[2]);
|
||||
|
||||
Loaded 100 of 207 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user