initial commit

This commit is contained in:
Erin Catto 2026-05-10 13:36:52 -07:00
commit 573e1a9fa3
220 changed files with 150440 additions and 0 deletions

42
.clang-format Normal file
View file

@ -0,0 +1,42 @@
# Reference: https://clang.llvm.org/docs/ClangFormatStyleOptions.html
# /c/Program Files/Microsoft Visual Studio/2022/Community/VC/Tools/Llvm/bin
# default values:
# https://github.com/llvm/llvm-project/blob/main/clang/lib/Format/Format.cpp
---
Language: Cpp
BasedOnStyle: Microsoft
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: true
AfterUnion: true
BeforeWhile: true
ColumnLimit: 130
PointerAlignment: Left
UseTab: Always
BreakConstructorInitializers: BeforeComma
InsertNewlineAtEOF: true
IncludeBlocks: Regroup
IncludeCategories:
- Regex: '^"(box3d\/)'
Priority: 2
- Regex: '^<.*'
Priority: 3
- Regex: '^".*'
Priority: 1
IndentExternBlock: NoIndent
IndentCaseLabels: true
IndentAccessModifiers: false
AccessModifierOffset: -4
SpacesInParens: Custom
SpacesInParensOptions:
ExceptDoubleParentheses: false
InConditionalStatements: true
InCStyleCasts: false
InEmptyParentheses: false
Other: true

10
.gitattributes vendored Normal file
View file

@ -0,0 +1,10 @@
* text=auto
*.c text
*.cpp text
*.h text
*.md text
*.txt text
*.sh text eol=lf
*.ttf binary

14
.github/FUNDING.yml vendored Normal file
View file

@ -0,0 +1,14 @@
# These are supported funding model platforms
github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
github: [erincatto]

1
.github/issue_template.md vendored Normal file
View file

@ -0,0 +1 @@
Thank you for filing an issue!

1
.github/pull_request_template.md vendored Normal file
View file

@ -0,0 +1 @@
Pull requests for Box3D code are not accepted. Please consider filing an issue instead.

119
.github/workflows/build.yml vendored Normal file
View file

@ -0,0 +1,119 @@
# https://docs.github.com/en/actions
name: CI Build
on:
push:
branches: [ main ]
pull_request:
branches: [ main ]
env:
BUILD_TYPE: Debug
jobs:
build-ubuntu-gcc:
name: ubuntu-gcc
runs-on: ubuntu-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 4
steps:
- uses: actions/checkout@v4
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBOX3D_SAMPLES=OFF -DBUILD_SHARED_LIBS=OFF -DBOX3D_VALIDATE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
- name: Test
working-directory: ${{github.workspace}}/build
run: ./bin/test
build-ubuntu-clang:
name: ubuntu-clang
runs-on: ubuntu-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 4
steps:
- uses: actions/checkout@v4
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DCMAKE_CXX_COMPILER=clang++-18 -DCMAKE_C_COMPILER=clang-18 -DCMAKE_C_FLAGS="-fsanitize=thread -fno-omit-frame-pointer" -DCMAKE_CXX_FLAGS="-fsanitize=thread -fno-omit-frame-pointer" -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=thread" -DBOX3D_SAMPLES=OFF -DBUILD_SHARED_LIBS=OFF -DBOX3D_VALIDATE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
- name: Test
working-directory: ${{github.workspace}}/build
run: ./bin/test
build-macos:
name: macos
runs-on: macos-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 4
steps:
- uses: actions/checkout@v4
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBOX3D_SAMPLES=OFF -DBOX3D_SANITIZE=ON -DBUILD_SHARED_LIBS=OFF -DBOX3D_VALIDATE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
- name: Test
working-directory: ${{github.workspace}}/build
run: ./bin/test
build-windows:
name: windows
runs-on: windows-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 4
steps:
- uses: actions/checkout@v3
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBOX3D_SAMPLES=OFF -DBOX3D_VALIDATE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON
- name: Build
run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
- name: Test
working-directory: ${{github.workspace}}/build
run: ./bin/${{env.BUILD_TYPE}}/test
samples-windows:
name: samples-windows
runs-on: windows-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 6
steps:
- uses: actions/checkout@v4
- name: Setup MSVC dev command prompt
uses: TheMrMilchmann/setup-msvc-dev@v3
with:
arch: x64
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Release -DBOX3D_SAMPLES=ON -DBUILD_SHARED_LIBS=OFF -DBOX3D_UNIT_TESTS=OFF
- name: Build
run: cmake --build ${{github.workspace}}/build --config Release
samples-macos:
name: samples-macos
runs-on: macos-latest
if: github.event_name == 'push' || github.event.pull_request.draft == false
timeout-minutes: 6
steps:
- uses: actions/checkout@v4
- name: Configure CMake
run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=Release -DBOX3D_SAMPLES=ON -DBUILD_SHARED_LIBS=OFF -DBOX3D_UNIT_TESTS=OFF
- name: Build
run: cmake --build ${{github.workspace}}/build --config Release

14
.gitignore vendored Normal file
View file

@ -0,0 +1,14 @@
build/
imgui.ini
settings.ini
.vscode/
.vs/
.cap
.DS_Store
CMakeUserPresets.json
.cache/
.idea/
.claude/
.tmp/
AGENTS.md
GEMINI.md

155
CMakeLists.txt Normal file
View file

@ -0,0 +1,155 @@
cmake_minimum_required(VERSION 3.22)
include(FetchContent)
include(CMakeDependentOption)
project(box3d
VERSION 0.1.0
DESCRIPTION "A 3D physics engine for games"
HOMEPAGE_URL "https://box2d.org"
LANGUAGES C CXX
)
# stuff to help debug cmake
# message(STATUS "cmake tool chain: ${CMAKE_TOOLCHAIN_FILE}")
# message(STATUS "cmake source dir: ${CMAKE_SOURCE_DIR}")
# message(STATUS "library postfix: ${CMAKE_DEBUG_POSTFIX}")
message(STATUS "CMake C compiler: ${CMAKE_C_COMPILER_ID}")
message(STATUS "CMake C++ compiler: ${CMAKE_CXX_COMPILER_ID}")
message(STATUS "CMake system name: ${CMAKE_SYSTEM_NAME}")
message(STATUS "CMake host system processor: ${CMAKE_HOST_SYSTEM_PROCESSOR}")
# static link to make leak checking easier (_crtBreakAlloc)
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>")
if (MSVC OR APPLE OR UNIX)
option(BOX3D_SANITIZE "Enable sanitizers for some builds" OFF)
set(BOX3D_SANITIZER_TYPE "address" CACHE STRING "Type of sanitizer to use (address, thread, undefined, memory)")
set_property(CACHE BOX3D_SANITIZER_TYPE PROPERTY STRINGS "address" "thread" "undefined" "memory")
if(BOX3D_SANITIZE)
message(STATUS "Box3D Sanitize: ${BOX3D_SANITIZER_TYPE}")
# sanitizers need to apply to all compiled libraries to work well
if(MSVC)
# address sanitizer only in the debug build
add_compile_options("$<$<CONFIG:Debug>:/fsanitize=address>")
add_link_options("$<$<CONFIG:Debug>:/INCREMENTAL:NO>")
elseif(APPLE)
# more sanitizers on Apple clang
if(BOX3D_SANITIZER_TYPE STREQUAL "thread")
add_compile_options(-fsanitize=thread -fno-omit-frame-pointer)
add_link_options(-fsanitize=thread)
elseif(BOX3D_SANITIZER_TYPE STREQUAL "undefined")
add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
add_link_options(-fsanitize=undefined)
else()
# default to address sanitizer
add_compile_options(-fsanitize=address -fsanitize-address-use-after-scope -fsanitize=undefined)
add_link_options(-fsanitize=address -fsanitize-address-use-after-scope -fsanitize=undefined)
endif()
elseif(UNIX)
# Linux/WSL2 sanitizer support
if(BOX3D_SANITIZER_TYPE STREQUAL "thread")
# Disable ASLR first to avoid crash on launch
# echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
add_compile_options(-fsanitize=thread -fno-omit-frame-pointer -fPIE)
add_link_options(-fsanitize=thread -pie)
elseif(BOX3D_SANITIZER_TYPE STREQUAL "undefined")
add_compile_options(-fsanitize=undefined -fno-omit-frame-pointer)
add_link_options(-fsanitize=undefined)
elseif(BOX3D_SANITIZER_TYPE STREQUAL "memory")
add_compile_options(-fsanitize=memory -fno-omit-frame-pointer)
add_link_options(-fsanitize=memory)
else()
# default to address sanitizer
add_compile_options(-fsanitize=address -fno-omit-frame-pointer)
add_link_options(-fsanitize=address)
endif()
endif()
else()
if(MSVC)
# enable hot reloading
add_compile_options("$<$<CONFIG:Debug>:/ZI>")
add_link_options("$<$<CONFIG:Debug>:/INCREMENTAL>")
endif()
endif()
endif()
# Deterministic math
# https://box2d.org/posts/2024/08/determinism/
if (MINGW OR APPLE OR UNIX)
add_compile_options(-ffp-contract=off)
endif()
option(BOX3D_DISABLE_SIMD "Disable SIMD math (slower)" OFF)
option(BOX3D_COMPILE_WARNING_AS_ERROR "Compile warnings as errors" OFF)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(CMAKE_VERBOSE_MAKEFILE ON)
# Needed for samples.exe to find box2d.dll
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
add_subdirectory(src)
# This hides samples, test, and doxygen from apps that use box3d via FetchContent
if(PROJECT_IS_TOP_LEVEL)
option(BOX3D_SAMPLES "Build the Box3D samples" ON)
option(BOX3D_BENCHMARKS "Build the Box3D benchmarks" OFF)
option(BOX3D_DOCS "Build the Box3D documentation" OFF)
option(BOX3D_PROFILE "Enable profiling with Tracy" OFF)
option(BOX3D_VALIDATE "Enable heavy validation" ON)
option(BOX3D_UNIT_TESTS "Build the Box3D unit tests" ON)
if(BOX3D_UNIT_TESTS OR BOX3D_SAMPLES OR BOX3D_BENCHMARKS)
# Emscripten pthread support
if(EMSCRIPTEN)
set(EMSCRIPTEN_PTHREADS_COMPILER_FLAGS "-pthread -s USE_PTHREADS=1")
set(EMSCRIPTEN_PTHREADS_LINKER_FLAGS "${EMSCRIPTEN_PTHREADS_COMPILER_FLAGS} -s ALLOW_MEMORY_GROWTH")
string(APPEND CMAKE_C_FLAGS " ${EMSCRIPTEN_PTHREADS_COMPILER_FLAGS}")
string(APPEND CMAKE_CXX_FLAGS " ${EMSCRIPTEN_PTHREADS_COMPILER_FLAGS}")
string(APPEND CMAKE_EXE_LINKER_FLAGS " ${EMSCRIPTEN_PTHREADS_LINKER_FLAGS}")
endif()
add_subdirectory(shared)
endif()
# Tests need static linkage because they test internal Box3D functions
if(NOT BUILD_SHARED_LIBS AND BOX3D_UNIT_TESTS)
message(STATUS "Adding Box3D unit tests")
add_subdirectory(test)
set_target_properties(test PROPERTIES XCODE_GENERATE_SCHEME TRUE)
else()
message(STATUS "Skipping Box3D unit tests")
endif()
if(BOX3D_SAMPLES)
add_subdirectory(samples)
# default startup project for Visual Studio
if(MSVC)
set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT samples)
set_property(TARGET samples PROPERTY VS_DEBUGGER_WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
endif()
set_target_properties(samples PROPERTIES
XCODE_GENERATE_SCHEME TRUE
XCODE_SCHEME_WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}")
endif()
if(BOX3D_BENCHMARKS)
add_subdirectory(benchmark)
set_target_properties(benchmark PROPERTIES XCODE_GENERATE_SCHEME TRUE)
endif()
if(BOX3D_DOCS)
# todo
# add_subdirectory(docs)
endif()
endif()
# https://stackoverflow.com/questions/72635402/how-to-set-working-directory-in-cmake-visual-studio-2022
# launch.vs.json
# "currentDir": "${workspaceRoot}"

98
README.md Normal file
View file

@ -0,0 +1,98 @@
![Box3D Logo](https://box2d.org/images/logo.svg)
# Build Status
[![Build Status](https://github.com/erincatto/box3d/actions/workflows/build.yml/badge.svg)](https://github.com/erincatto/box3d/actions)
# Box3D
Box3D is a 3D physics engine for games.
[![Box3D Version 3.0 Release Demo](https://img.youtube.com/vi/dAoM-xjOWtA/0.jpg)](https://www.youtube.com/watch?v=dAoM-xjOWtA)
## Features
### Collision
- Continuous collision detection
- Contact events
- Convex polygons, capsules, circles, rounded polygons, segments, and chains
- Multiple shapes per body
- Collision filtering
- Ray casts, shape casts, and overlap queries
- Sensor system
### Physics
- Robust _Soft Step_ rigid body solver
- Continuous physics for fast translations and rotations
- Island based sleep
- Revolute, prismatic, distance, mouse joint, weld, and wheel joints
- Joint limits, motors, springs, and friction
- Joint and contact forces
- Body movement events and sleep notification
### System
- Data-oriented design
- Written in portable C17
- Extensive multithreading and SIMD
- Optimized for large piles of bodies
### Samples
- OpenGL with GLFW
- Graphical user interface with imgui
- Many samples to demonstrate features and performance
## Building All Platforms
- Install [CMake](https://cmake.org/)
- Install [git](https://git-scm.com/)
- Ensure these run from the command line
## Building for Visual Studio
- Install [Visual Studio](https://visualstudio.microsoft.com/)
- Run `build_vs2026.bat`
- Open and build `build/box3d.slnx`
## Building for Linux
- Run `build.sh` from a bash shell
- Results are in the build sub-folder
## Building for Xcode
- mkdir build
- cd build
- cmake -G Xcode ..
- Open `box3d.xcodeproj`
- Select the samples scheme
- Build and run the samples
## Building and installing
- mkdir build
- cd build
- cmake ..
- cmake --build . --config Release
- cmake --install . (might need sudo)
## Compatibility
The Box3D library and samples build and run on Windows, Linux, and Mac.
You will need a compiler that supports C17 to build the Box3D library.
You will need a compiler that supports C++20 to build the samples.
Box3D uses SSE2 and Neon SIMD math to improve performance. This can be disabled by defining `BOX3D_DISABLE_SIMD`.
## Documentation
- [Manual](https://box2d.org/documentation/)
## Community
- [Discord](https://discord.gg/NKYgCBP)
## Contributing
Please do not submit pull requests. Instead, please file an issue for bugs or feature requests. For support, please visit the Discord server.
# Giving Feedback
Please file an issue or start a chat on discord. You can also use [GitHub Discussions](https://github.com/erincatto/box3d/discussions).
## License
Box3D is developed by Erin Catto and uses the [MIT license](https://en.wikipedia.org/wiki/MIT_License).
## Sponsorship
Support development of Box3D through [Github Sponsors](https://github.com/sponsors/erincatto).
Please consider starring this repository and subscribing to my [YouTube channel](https://www.youtube.com/@erin_catto).

13
benchmark/CMakeLists.txt Normal file
View file

@ -0,0 +1,13 @@
# Benchmark app
set(BOX3D_BENCHMARK_FILES
main.c
)
add_executable(benchmark ${BOX3D_BENCHMARK_FILES})
set_target_properties(benchmark PROPERTIES C_STANDARD 17)
target_link_libraries(benchmark PRIVATE box3d shared)
source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} PREFIX "" FILES ${BOX3D_BENCHMARK_FILES})

View file

@ -0,0 +1,9 @@
threads,ms
1,0
2,0
3,0
4,0
5,0
6,0
7,0
8,5488.14
1 threads ms
2 1 0
3 2 0
4 3 0
5 4 0
6 5 0
7 6 0
8 7 0
9 8 5488.14

View file

@ -0,0 +1,9 @@
threads,ms
1,730.575
2,424.323
3,324.045
4,276.202
5,242.944
6,226.599
7,211.694
8,205.856
1 threads ms
2 1 730.575
3 2 424.323
4 3 324.045
5 4 276.202
6 5 242.944
7 6 226.599
8 7 211.694
9 8 205.856

View file

@ -0,0 +1,9 @@
threads,ms
1,462.769
2,292.812
3,230.578
4,197.733
5,178.241
6,166.567
7,161.298
8,157.091
1 threads ms
2 1 462.769
3 2 292.812
4 3 230.578
5 4 197.733
6 5 178.241
7 6 166.567
8 7 161.298
9 8 157.091

View file

@ -0,0 +1,9 @@
threads,ms
1,1796.4
2,954.375
3,641.176
4,481.819
5,390.785
6,328.059
7,287.637
8,258.124
1 threads ms
2 1 1796.4
3 2 954.375
4 3 641.176
5 4 481.819
6 5 390.785
7 6 328.059
8 7 287.637
9 8 258.124

View file

@ -0,0 +1,9 @@
threads,ms
1,24717.7
2,13513.9
3,9716.35
4,7493.39
5,6140.22
6,5221.34
7,4550.24
8,4106.65
1 threads ms
2 1 24717.7
3 2 13513.9
4 3 9716.35
5 4 7493.39
6 5 6140.22
7 6 5221.34
8 7 4550.24
9 8 4106.65

View file

@ -0,0 +1,9 @@
threads,ms
1,1682.1
2,878.51
3,613.252
4,478.075
5,387.426
6,337.026
7,294.737
8,270.737
1 threads ms
2 1 1682.1
3 2 878.51
4 3 613.252
5 4 478.075
6 5 387.426
7 6 337.026
8 7 294.737
9 8 270.737

View file

@ -0,0 +1,9 @@
threads,ms
1,2575.34
2,1278.03
3,878.515
4,629.084
5,507.933
6,413.473
7,362.456
8,320.241
1 threads ms
2 1 2575.34
3 2 1278.03
4 3 878.515
5 4 629.084
6 5 507.933
7 6 413.473
8 7 362.456
9 8 320.241

View file

@ -0,0 +1,9 @@
threads,ms
1,2627.76
2,1427.39
3,1012.48
4,796.119
5,664.231
6,577.576
7,518.164
8,483.436
1 threads ms
2 1 2627.76
3 2 1427.39
4 3 1012.48
5 4 796.119
6 5 664.231
7 6 577.576
8 7 518.164
9 8 483.436

View file

@ -0,0 +1,9 @@
threads,ms
1,31480.4
2,17010.7
3,11890.1
4,9295.49
5,7696.31
6,6645.53
7,5843.28
8,5249.02
1 threads ms
2 1 31480.4
3 2 17010.7
4 3 11890.1
5 4 9295.49
6 5 7696.31
7 6 6645.53
8 7 5843.28
9 8 5249.02

View file

@ -0,0 +1,9 @@
threads,ms
1,726.988
2,430.503
3,324.672
4,268.082
5,232.24
6,213.849
7,199.971
8,193.328
1 threads ms
2 1 726.988
3 2 430.503
4 3 324.672
5 4 268.082
6 5 232.24
7 6 213.849
8 7 199.971
9 8 193.328

344
benchmark/main.c Normal file
View file

@ -0,0 +1,344 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#if defined( _MSC_VER ) && !defined( _CRT_SECURE_NO_WARNINGS )
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "benchmarks.h"
#include "utils.h"
#include "box3d/box3d.h"
#include "box3d/constants.h"
#include "box3d/math_functions.h"
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef TRACY_ENABLE
#include <tracy/TracyC.h>
#endif
#define ARRAY_COUNT( A ) (int)( sizeof( A ) / sizeof( A[0] ) )
#define MAYBE_UNUSED( x ) ( (void)( x ) )
typedef void CapacityFcn( b3Capacity* capacity );
typedef void CreateFcn( b3WorldId worldId );
typedef void DestroyFcn( void );
typedef void StepFcn( b3WorldId worldId, int stepCount );
typedef struct Benchmark
{
const char* name;
CapacityFcn* capacityFcn;
CreateFcn* createFcn;
DestroyFcn* destroyFcn;
StepFcn* stepFcn;
int totalStepCount;
} Benchmark;
static void MinProfile( b3Profile* p1, const b3Profile* p2 )
{
p1->step = b3MinFloat( p1->step, p2->step );
p1->pairs = b3MinFloat( p1->pairs, p2->pairs );
p1->collide = b3MinFloat( p1->collide, p2->collide );
p1->constraints = b3MinFloat( p1->constraints, p2->constraints );
p1->transforms = b3MinFloat( p1->transforms, p2->transforms );
p1->refit = b3MinFloat( p1->refit, p2->refit );
p1->sleepIslands = b3MinFloat( p1->sleepIslands, p2->sleepIslands );
}
// Box3D benchmark application. On Windows it is important to use affinity avoid cross CCD
// usage or efficiency cores. Also on Windows create a power plan with Processor power management
// Min/Max of 99%. This prevents boosting and makes the benchmarks more repeatable.
// Affinity [0x01 0x02 0x04 0x08 0x10 0x20 0x40 0x80]
// Run all benchmarks with 1 to 8 threads.
// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=8
// Run all benchmarks with 4 workers only.
// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=4 -w=4
// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=4 -w=4 -b=5 -r=5
// Run benchmark 3 with 4 workers and repeat 20 times. Record the step times.
// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=4 -w=4 -b=3 -r=20 -s
// Run benchmark 3 with 4 workers and run once. Disable continuous collision. Record the step times.
// start /affinity 0x5555 .\build\bin\Release\benchmark.exe -t=4 -w=4 -b=3 -r=1 -nc -s
int main( int argc, char** argv )
{
#ifdef TRACY_ENABLE
___tracy_startup_profiler();
#endif
Benchmark benchmarks[] = {
{ "compound_capsules", NULL, CreateCompoundCapsules, DestroyCompoundCapsules, NULL, 500 },
{ "compound_hulls", NULL, CreateCompoundHulls, DestroyCompoundHulls, NULL, 500 },
{ "joint_grid", NULL, CreateJointGrid, NULL, NULL, 100 },
{ "junkyard", NULL, CreateJunkyard, NULL, StepJunkyard, 500 },
{ "large_pyramid", NULL, CreateLargePyramid, NULL, NULL, 200 },
{ "many_pyramids", NULL, CreateManyPyramids, NULL, NULL, 100 },
{ "rain", GetRainCapacity, CreateRain, DestroyRain, StepRain, 400 },
{ "washer", GetWasherCapacity, CreateWasher, NULL, NULL, 1000 },
{ "welded_hulls", NULL, CreateWeldedHulls, DestroyWeldedHulls, NULL, 500 },
//{ "smash", CreateSmash, NULL, 300 },
//{ "spinner", CreateSpinner, StepSpinner, 1400 },
//{ "tumbler", CreateTumbler, NULL, 750 },
};
int benchmarkCount = ARRAY_COUNT( benchmarks );
int maxSteps = benchmarks[0].totalStepCount;
for ( int i = 1; i < benchmarkCount; ++i )
{
maxSteps = b3MaxInt( maxSteps, benchmarks[i].totalStepCount );
}
b3Profile maxProfile = {
.step = FLT_MAX,
.pairs = FLT_MAX,
.collide = FLT_MAX,
.solve = FLT_MAX,
.solverSetup = FLT_MAX,
.constraints = FLT_MAX,
.prepareConstraints = FLT_MAX,
.integrateVelocities = FLT_MAX,
.warmStart = FLT_MAX,
.solveImpulses = FLT_MAX,
.integratePositions = FLT_MAX,
.relaxImpulses = FLT_MAX,
.applyRestitution = FLT_MAX,
.storeImpulses = FLT_MAX,
.splitIslands = FLT_MAX,
.transforms = FLT_MAX,
.hitEvents = FLT_MAX,
.refit = FLT_MAX,
.bullets = FLT_MAX,
.sleepIslands = FLT_MAX,
};
b3Profile* profiles = malloc( maxSteps * sizeof( b3Profile ) );
for ( int i = 0; i < maxSteps; ++i )
{
profiles[i] = maxProfile;
}
int maxThreadCount = GetNumberOfCores();
int runCount = 4;
int singleBenchmark = -1;
int singleWorkerCount = -1;
b3Counters counters = { 0 };
bool enableContinuous = true;
bool recordStepTimes = false;
assert( maxThreadCount <= B3_MAX_WORKERS );
for ( int i = 1; i < argc; ++i )
{
const char* arg = argv[i];
if ( strncmp( arg, "-t=", 3 ) == 0 )
{
int threadCount = atoi( arg + 3 );
maxThreadCount = b3ClampInt( threadCount, 1, maxThreadCount );
}
else if ( strncmp( arg, "-b=", 3 ) == 0 )
{
singleBenchmark = atoi( arg + 3 );
singleBenchmark = b3ClampInt( singleBenchmark, 0, benchmarkCount - 1 );
}
else if ( strncmp( arg, "-w=", 3 ) == 0 )
{
singleWorkerCount = atoi( arg + 3 );
}
else if ( strncmp( arg, "-r=", 3 ) == 0 )
{
runCount = b3ClampInt( atoi( arg + 3 ), 1, 1000 );
}
else if ( strncmp( arg, "-nc", 3 ) == 0 )
{
enableContinuous = false;
printf( "Continuous disabled\n" );
}
else if ( strncmp( arg, "-s", 3 ) == 0 )
{
recordStepTimes = true;
}
else if ( strcmp( arg, "-h" ) == 0 )
{
printf( "Usage\n"
"-t=<integer>: the maximum number of threads to use\n"
"-b=<integer>: run a single benchmark\n"
"-w=<integer>: run a single worker count\n"
"-r=<integer>: number of repeats (default is 4)\n"
"-s: record step times\n" );
exit( 0 );
}
}
if ( singleWorkerCount != -1 )
{
singleWorkerCount = b3ClampInt( singleWorkerCount, 1, maxThreadCount );
}
printf( "Starting benchmarks\n" );
printf( "======================================\n" );
for ( int benchmarkIndex = 0; benchmarkIndex < benchmarkCount; ++benchmarkIndex )
{
if ( singleBenchmark != -1 && benchmarkIndex != singleBenchmark )
{
continue;
}
#ifdef NDEBUG
int stepCount = benchmarks[benchmarkIndex].totalStepCount;
#else
int stepCount = 10;
#endif
Benchmark* benchmark = benchmarks + benchmarkIndex;
bool countersAcquired = false;
printf( "benchmark: %s, steps = %d\n", benchmarks[benchmarkIndex].name, stepCount );
float minTime[B3_MAX_WORKERS] = { 0 };
for ( int threadCount = 1; threadCount <= maxThreadCount; ++threadCount )
{
if ( singleWorkerCount != -1 && singleWorkerCount != threadCount )
{
continue;
}
printf( "thread count: %d\n", threadCount );
for ( int runIndex = 0; runIndex < runCount; ++runIndex )
{
b3WorldDef worldDef = b3DefaultWorldDef();
worldDef.enableContinuous = enableContinuous;
worldDef.workerCount = threadCount;
if (benchmark->capacityFcn != NULL)
{
benchmark->capacityFcn( &worldDef.capacity );
}
b3WorldId worldId = b3CreateWorld( &worldDef );
benchmark->createFcn( worldId );
float timeStep = 1.0f / 60.0f;
int subStepCount = 4;
// Initial step can be expensive and skew benchmark
if ( benchmark->stepFcn != NULL )
{
benchmark->stepFcn( worldId, 0 );
}
assert( stepCount <= maxSteps );
b3World_Step( worldId, timeStep, subStepCount );
\
b3Profile profile = b3World_GetProfile( worldId );
MinProfile( profiles + 0, &profile );
uint64_t ticks = b3GetTicks();
for ( int stepIndex = 1; stepIndex < stepCount; ++stepIndex )
{
if ( benchmark->stepFcn != NULL )
{
benchmark->stepFcn( worldId, stepIndex );
}
b3World_Step( worldId, timeStep, subStepCount );
\
profile = b3World_GetProfile( worldId );
MinProfile( profiles + stepIndex, &profile );
}
float ms = b3GetMilliseconds( ticks );
printf( "run %d : %g (ms)\n", runIndex, ms );
if ( runIndex == 0 )
{
minTime[threadCount - 1] = ms;
}
else
{
minTime[threadCount - 1] = b3MinFloat( minTime[threadCount - 1], ms );
}
if ( countersAcquired == false )
{
counters = b3World_GetCounters( worldId );
countersAcquired = true;
}
if ( benchmark->destroyFcn != NULL )
{
benchmark->destroyFcn();
}
b3DestroyWorld( worldId );
}
if ( recordStepTimes )
{
char fileName[64] = { 0 };
snprintf( fileName, 64, "%s_t%d.dat", benchmarks[benchmarkIndex].name, threadCount );
FILE* file = fopen( fileName, "w" );
if ( file == NULL )
{
continue;
}
for ( int stepIndex = 0; stepIndex < stepCount; ++stepIndex )
{
b3Profile p = profiles[stepIndex];
fprintf( file, "%g %g %g %g %g %g %g\n", p.step, p.pairs, p.collide, p.constraints, p.transforms,
p.refit, p.sleepIslands );
}
fclose( file );
}
}
printf( "body %d / shape %d / contact %d / joint %d / stack %d\n\n", counters.bodyCount, counters.shapeCount,
counters.contactCount, counters.jointCount, counters.stackUsed );
char fileName[64] = { 0 };
snprintf( fileName, 64, "%s.csv", benchmarks[benchmarkIndex].name );
FILE* file = fopen( fileName, "w" );
if ( file == NULL )
{
continue;
}
fprintf( file, "threads,ms\n" );
for ( int threadIndex = 1; threadIndex <= maxThreadCount; ++threadIndex )
{
fprintf( file, "%d,%g\n", threadIndex, minTime[threadIndex - 1] );
}
fclose( file );
}
printf( "======================================\n" );
printf( "All benchmarks complete!\n" );
free( profiles );
#ifdef TRACY_ENABLE
___tracy_shutdown_profiler();
#endif
return 0;
}

9
build.sh Normal file
View file

@ -0,0 +1,9 @@
#!/usr/bin/env bash
# Use this to build Box3D on any system with a bash shell
rm -rf build
# I haven't been able to get Wayland working on WSL but X11 works.
# https://www.glfw.org/docs/latest/compile.html
cmake -S . -B build -DGLFW_BUILD_WAYLAND=OFF
cmake --build build

24
build_vs2026.bat Normal file
View file

@ -0,0 +1,24 @@
@echo off
rem Use this batch file to generate Visual Studio 2026 project files for box3d.
rem
rem Usage:
rem build_vs2026.bat Configure or update project files in build\
rem build_vs2026.bat fresh Delete build\ first, then configure from scratch
rem
rem Re-running without "fresh" updates the existing project files in place.
rem CMake rewrites .vcxproj/.sln files atomically, so this works even while
rem Visual Studio has the solution open -- VS will detect the change and
rem prompt to reload.
if /i "%~1"=="fresh" (
if exist build (
echo Fresh build requested, removing build\ ...
rmdir /s /q build
if exist build (
echo ERROR: failed to remove build\ -- is something holding files open?
exit /b 1
)
)
)
cmake -S . -B build -G "Visual Studio 18 2026"

View file

@ -0,0 +1,85 @@
b3Vec3 gravity = {0, -10, 0};
b3World_SetGravity(m_worldId, gravity);
std::vector<b3BodyId> bodies;
std::vector<b3JointId> joints;
{
b3BodyDef bd = b3DefaultBodyDef();
bd.name = "cube";
bd.type = b3BodyType(2);
bd.position = {-7.98573353e-07, 0.499929696, -9.86034479e-07};
bd.rotation = {{-4.03613463e-08, 0.825855613, 4.68083634e-08}, 0.563881755};
bd.linearVelocity = {2.47239775e-08, -1.7695136e-08, 8.65693384e-09};
bd.angularVelocity = {1.73163173e-08, -4.2026933e-15, -4.94549042e-08};
bd.linearDamping = 0;
bd.angularDamping = 0;
bd.enableSleep = bool(1);
bd.isAwake = bool(1);
bd.gravityScale = 1;
b3BodyId bodyId = b3CreateBody(m_worldId, &bd);
bodies.push_back(bodyId);
{
b3ShapeDef sd = b3DefaultShapeDef();
sd.density = 1000;
sd.isSensor = bool(0);
sd.filter.categoryBits = 0x1;
sd.filter.maskBits = 0xffffffffffffffff;
sd.filter.groupIndex = 0;
sd.baseMaterial.friction = 0.600000024;
sd.baseMaterial.restitution = 0;
sd.baseMaterial.rollingResistance = 0;
b3Vec3 vs[8];
vs[0] = {0.5, 0.5, 0.5};
vs[1] = {-0.5, 0.5, 0.5};
vs[2] = {-0.5, -0.5, 0.5};
vs[3] = {0.5, -0.5, 0.5};
vs[4] = {0.5, 0.5, -0.5};
vs[5] = {-0.5, 0.5, -0.5};
vs[6] = {-0.5, -0.5, -0.5};
vs[7] = {0.5, -0.5, -0.5};
b3Hull* hull = b3CreateHull(vs, 8, 8);
b3CreateHullShape(bodyId, &sd, hull);
b3DestroyHull(hull);
}
}
{
b3BodyDef bd = b3DefaultBodyDef();
bd.name = "ground";
bd.type = b3BodyType(0);
bd.position = {0, -1, 0};
bd.rotation = {{0, 0, 0}, 1};
bd.linearVelocity = {0, 0, 0};
bd.angularVelocity = {0, 0, 0};
bd.linearDamping = 0;
bd.angularDamping = 0;
bd.enableSleep = bool(1);
bd.isAwake = bool(0);
bd.gravityScale = 1;
b3BodyId bodyId = b3CreateBody(m_worldId, &bd);
bodies.push_back(bodyId);
{
b3ShapeDef sd = b3DefaultShapeDef();
sd.density = 1000;
sd.isSensor = bool(0);
sd.filter.categoryBits = 0x1;
sd.filter.maskBits = 0xffffffffffffffff;
sd.filter.groupIndex = 0;
sd.baseMaterial.friction = 0.600000024;
sd.baseMaterial.restitution = 0;
sd.baseMaterial.rollingResistance = 0;
b3Vec3 vs[8];
vs[0] = {15, 1, 15};
vs[1] = {-15, 1, 15};
vs[2] = {-15, -1, 15};
vs[3] = {15, -1, 15};
vs[4] = {15, 1, -15};
vs[5] = {-15, 1, -15};
vs[6] = {-15, -1, -15};
vs[7] = {15, -1, -15};
b3Hull* hull = b3CreateHull(vs, 8, 8);
b3CreateHullShape(bodyId, &sd, hull);
b3DestroyHull(hull);
}
}

Binary file not shown.

4971
data/meshes/building.obj Normal file

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

76
data/meshes/conveyor.obj Normal file
View file

@ -0,0 +1,76 @@
# Blender 4.5.0
# www.blender.org
o Cube
v 2.168610 1.000000 -8.647873
v 2.168610 -1.000000 -8.647873
v 2.076996 1.000000 7.657975
v 2.076996 -1.000000 7.657975
v -4.037379 1.000000 -13.208730
v -4.037379 -1.000000 -13.208730
v -4.037379 1.000000 13.208730
v -4.037379 -1.000000 13.208730
v 7.006480 -1.000000 16.726564
v 7.006480 1.000000 16.726564
v 6.719464 1.000000 9.863844
v 6.719464 -1.000000 9.863844
v 16.463598 -1.000000 12.302612
v 16.463598 1.000000 12.302612
v 10.010764 1.000000 7.959058
v 10.010764 -1.000000 7.959058
v 16.463598 -1.000000 -11.446518
v 16.463598 1.000000 -11.446518
v 9.855768 1.000000 -7.927011
v 9.855768 -1.000000 -7.927011
v 7.919923 -1.000000 -16.801933
v 7.919923 1.000000 -16.801933
v 6.476316 1.000000 -9.520320
v 6.476316 -1.000000 -9.520320
s 1
f 5 3 1
f 4 9 8
f 7 6 8
f 6 4 8
f 1 4 2
f 2 21 24
f 3 10 11
f 3 12 4
f 8 10 7
f 9 16 13
f 15 18 19
f 11 16 12
f 10 15 11
f 9 14 10
f 20 21 17
f 13 18 14
f 16 17 13
f 15 20 16
f 19 24 20
f 19 22 23
f 17 22 18
f 1 22 5
f 2 23 1
f 5 21 6
f 5 7 3
f 4 12 9
f 7 5 6
f 6 2 4
f 1 3 4
f 2 6 21
f 3 7 10
f 3 11 12
f 8 9 10
f 9 12 16
f 15 14 18
f 11 15 16
f 10 14 15
f 9 13 14
f 20 24 21
f 13 17 18
f 16 20 17
f 15 19 20
f 19 23 24
f 19 18 22
f 17 21 22
f 1 23 22
f 2 24 23
f 5 22 21

View file

@ -0,0 +1,4 @@
v 1 0 1
v 1 0 -1
v -1 0 -1
f 1 2 3

42
data/meshes/stairs.obj Normal file
View file

@ -0,0 +1,42 @@
# Blender 4.1.1
# www.blender.org
o Cube
v -1.423823 -0.087425 1.000000
v -1.423823 -0.087425 -1.000000
v 1.423823 -0.087425 1.000000
v 1.423823 1.912575 1.000000
v 1.423823 -0.087425 -1.000000
v 1.423823 1.912575 -1.000000
v 0.711911 1.912575 1.000000
v -1.423823 0.412575 1.000000
v 0.711911 1.537575 1.000000
v 0.177978 1.537575 1.000000
v 0.177978 1.162575 1.000000
v -0.355956 1.162575 1.000000
v -0.355956 0.787575 1.000000
v -0.889889 0.787575 1.000000
v -0.889889 0.412575 1.000000
v -1.423823 0.412575 -1.000000
v 0.711911 1.912575 -1.000000
v -0.889889 0.412575 -1.000000
v -0.889889 0.787575 -1.000000
v -0.355956 0.787575 -1.000000
v -0.355956 1.162575 -1.000000
v 0.177978 1.162575 -1.000000
v 0.177978 1.537575 -1.000000
v 0.711911 1.537575 -1.000000
s 0
f 6 17 7 4
f 5 6 4 3
f 1 8 16 2
f 2 5 3 1
f 2 16 18 19 20 21 22 23 24 17 6 5
f 7 17 24 9
f 9 24 23 10
f 10 23 22 11
f 11 22 21 12
f 12 21 20 13
f 13 20 19 14
f 14 19 18 15
f 15 18 16 8
f 3 4 7 9 10 11 12 13 14 15 8 1

258
data/meshes/test_map01.obj Normal file
View file

@ -0,0 +1,258 @@
# Blender 4.1.1
# www.blender.org
o Cube
v -20.000000 -1.000000 20.000000
v -20.000000 0.000000 20.000000
v -20.000000 -1.000000 -20.000000
v -20.000000 0.000000 -20.000000
v 20.000000 -1.000000 20.000000
v 20.000000 0.000000 20.000000
v 20.000000 -1.000000 -20.000000
v 20.000000 0.000000 -20.000000
s 0
f 1 2 4 3
f 3 4 8 7
f 7 8 6 5
f 5 6 2 1
f 3 7 5 1
f 8 4 2 6
o Cube.001
v -1.000000 0.500000 11.454407
v -1.000000 2.500000 11.454407
v -1.000000 0.500000 9.454407
v -1.000000 2.500000 9.454407
v 1.000000 0.500000 11.454407
v 1.000000 2.500000 11.454407
v 1.000000 0.500000 9.454407
v 1.000000 2.500000 9.454407
s 0
f 9 10 12 11
f 11 12 16 15
f 15 16 14 13
f 13 14 10 9
f 11 15 13 9
f 16 12 10 14
o Cube.002
v -9.640553 -0.538823 -5.348382
v -9.761864 -0.053763 -5.348382
v -9.640553 -0.538823 -9.348381
v -9.761864 -0.053763 -9.348381
v 9.761864 4.313619 -5.348382
v 9.640553 4.798679 -5.348382
v 9.761864 4.313619 -9.348381
v 9.640553 4.798679 -9.348381
s 0
f 17 18 20 19
f 19 20 24 23
f 23 24 22 21
f 21 22 18 17
f 19 23 21 17
f 24 20 18 22
o Cylinder
v 0.000000 0.250000 -1.000000
v 0.000000 0.250000 1.000000
v 0.057403 0.238582 -1.000000
v 0.057403 0.238582 1.000000
v 0.106066 0.206066 -1.000000
v 0.106066 0.206066 1.000000
v 0.138582 0.157403 -1.000000
v 0.138582 0.157402 1.000000
v 0.150000 0.100000 -1.000000
v 0.150000 0.100000 1.000000
v 0.138582 0.042598 -1.000000
v 0.138582 0.042597 1.000000
v 0.106066 -0.006066 -1.000000
v 0.106066 -0.006066 1.000000
v 0.057403 -0.038582 -1.000000
v 0.057403 -0.038582 1.000000
v 0.000000 -0.050000 -1.000000
v 0.000000 -0.050000 1.000000
v -0.057403 -0.038582 -1.000000
v -0.057403 -0.038582 1.000000
v -0.106066 -0.006066 -1.000000
v -0.106066 -0.006066 1.000000
v -0.138582 0.042598 -1.000000
v -0.138582 0.042597 1.000000
v -0.150000 0.100000 -1.000000
v -0.150000 0.100000 1.000000
v -0.138582 0.157403 -1.000000
v -0.138582 0.157402 1.000000
v -0.106066 0.206066 -1.000000
v -0.106066 0.206066 1.000000
v -0.057403 0.238582 -1.000000
v -0.057403 0.238582 1.000000
s 0
f 25 26 28 27
f 27 28 30 29
f 29 30 32 31
f 31 32 34 33
f 33 34 36 35
f 35 36 38 37
f 37 38 40 39
f 39 40 42 41
f 41 42 44 43
f 43 44 46 45
f 45 46 48 47
f 47 48 50 49
f 49 50 52 51
f 51 52 54 53
f 28 26 56 54 52 50 48 46 44 42 40 38 36 34 32 30
f 53 54 56 55
f 55 56 26 25
f 25 27 29 31 33 35 37 39 41 43 45 47 49 51 53 55
o Cylinder.001
v 1.916919 0.250000 -1.000000
v 1.916919 0.250000 1.000000
v 1.974321 0.238582 -1.000000
v 1.974321 0.238582 1.000000
v 2.022985 0.206066 -1.000000
v 2.022985 0.206066 1.000000
v 2.055501 0.157403 -1.000000
v 2.055501 0.157402 1.000000
v 2.066919 0.100000 -1.000000
v 2.066919 0.100000 1.000000
v 2.055501 0.042598 -1.000000
v 2.055501 0.042597 1.000000
v 2.022985 -0.006066 -1.000000
v 2.022985 -0.006066 1.000000
v 1.974321 -0.038582 -1.000000
v 1.974321 -0.038582 1.000000
v 1.916919 -0.050000 -1.000000
v 1.916919 -0.050000 1.000000
v 1.859516 -0.038582 -1.000000
v 1.859516 -0.038582 1.000000
v 1.810853 -0.006066 -1.000000
v 1.810853 -0.006066 1.000000
v 1.778337 0.042598 -1.000000
v 1.778337 0.042597 1.000000
v 1.766919 0.100000 -1.000000
v 1.766919 0.100000 1.000000
v 1.778337 0.157403 -1.000000
v 1.778337 0.157402 1.000000
v 1.810853 0.206066 -1.000000
v 1.810853 0.206066 1.000000
v 1.859516 0.238582 -1.000000
v 1.859516 0.238582 1.000000
s 0
f 57 58 60 59
f 59 60 62 61
f 61 62 64 63
f 63 64 66 65
f 65 66 68 67
f 67 68 70 69
f 69 70 72 71
f 71 72 74 73
f 73 74 76 75
f 75 76 78 77
f 77 78 80 79
f 79 80 82 81
f 81 82 84 83
f 83 84 86 85
f 60 58 88 86 84 82 80 78 76 74 72 70 68 66 64 62
f 85 86 88 87
f 87 88 58 57
f 57 59 61 63 65 67 69 71 73 75 77 79 81 83 85 87
o Cylinder.002
v 2.280946 0.250000 -1.000000
v 2.280946 0.250000 1.000000
v 2.338348 0.238582 -1.000000
v 2.338348 0.238582 1.000000
v 2.387012 0.206066 -1.000000
v 2.387012 0.206066 1.000000
v 2.419528 0.157403 -1.000000
v 2.419528 0.157402 1.000000
v 2.430946 0.100000 -1.000000
v 2.430946 0.100000 1.000000
v 2.419528 0.042598 -1.000000
v 2.419528 0.042597 1.000000
v 2.387012 -0.006066 -1.000000
v 2.387012 -0.006066 1.000000
v 2.338348 -0.038582 -1.000000
v 2.338348 -0.038582 1.000000
v 2.280946 -0.050000 -1.000000
v 2.280946 -0.050000 1.000000
v 2.223543 -0.038582 -1.000000
v 2.223543 -0.038582 1.000000
v 2.174880 -0.006066 -1.000000
v 2.174880 -0.006066 1.000000
v 2.142364 0.042598 -1.000000
v 2.142364 0.042597 1.000000
v 2.130946 0.100000 -1.000000
v 2.130946 0.100000 1.000000
v 2.142364 0.157403 -1.000000
v 2.142364 0.157402 1.000000
v 2.174880 0.206066 -1.000000
v 2.174880 0.206066 1.000000
v 2.223543 0.238582 -1.000000
v 2.223543 0.238582 1.000000
s 0
f 89 90 92 91
f 91 92 94 93
f 93 94 96 95
f 95 96 98 97
f 97 98 100 99
f 99 100 102 101
f 101 102 104 103
f 103 104 106 105
f 105 106 108 107
f 107 108 110 109
f 109 110 112 111
f 111 112 114 113
f 113 114 116 115
f 115 116 118 117
f 92 90 120 118 116 114 112 110 108 106 104 102 100 98 96 94
f 117 118 120 119
f 119 120 90 89
f 89 91 93 95 97 99 101 103 105 107 109 111 113 115 117 119
o Cylinder.003
v 2.636716 0.250000 -1.000000
v 2.636716 0.250000 1.000000
v 2.694119 0.238582 -1.000000
v 2.694119 0.238582 1.000000
v 2.742782 0.206066 -1.000000
v 2.742782 0.206066 1.000000
v 2.775298 0.157403 -1.000000
v 2.775298 0.157402 1.000000
v 2.786716 0.100000 -1.000000
v 2.786716 0.100000 1.000000
v 2.775298 0.042598 -1.000000
v 2.775298 0.042597 1.000000
v 2.742782 -0.006066 -1.000000
v 2.742782 -0.006066 1.000000
v 2.694119 -0.038582 -1.000000
v 2.694119 -0.038582 1.000000
v 2.636716 -0.050000 -1.000000
v 2.636716 -0.050000 1.000000
v 2.579314 -0.038582 -1.000000
v 2.579314 -0.038582 1.000000
v 2.530650 -0.006066 -1.000000
v 2.530650 -0.006066 1.000000
v 2.498134 0.042598 -1.000000
v 2.498134 0.042597 1.000000
v 2.486716 0.100000 -1.000000
v 2.486716 0.100000 1.000000
v 2.498134 0.157403 -1.000000
v 2.498134 0.157402 1.000000
v 2.530650 0.206066 -1.000000
v 2.530650 0.206066 1.000000
v 2.579314 0.238582 -1.000000
v 2.579314 0.238582 1.000000
s 0
f 121 122 124 123
f 123 124 126 125
f 125 126 128 127
f 127 128 130 129
f 129 130 132 131
f 131 132 134 133
f 133 134 136 135
f 135 136 138 137
f 137 138 140 139
f 139 140 142 141
f 141 142 144 143
f 143 144 146 145
f 145 146 148 147
f 147 148 150 149
f 124 122 152 150 148 146 144 142 140 138 136 134 132 130 128 126
f 149 150 152 151
f 151 152 122 121
f 121 123 125 127 129 131 133 135 137 139 141 143 145 147 149 151

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

File diff suppressed because it is too large Load diff

288
data/trees/bounds01.txt Normal file
View file

@ -0,0 +1,288 @@
-90.039993286 -0.039999999 -90.039993286 -74.960006714 0.039999999 -74.960006714
-87.289993286 -4.789999962 -83.539993286 -77.710006714 4.789999962 -81.460006714
-90.039993286 -0.039999999 -75.039993286 -74.960006714 0.039999999 -59.959999084
-87.289993286 -4.789999962 -68.539993286 -77.710006714 4.789999962 -66.460006714
-90.039993286 -0.039999999 -60.040000916 -74.960006714 0.039999999 -44.959999084
-87.289993286 -4.789999962 -53.540000916 -77.710006714 4.789999962 -51.459999084
-90.039993286 -0.039999999 -45.040000916 -74.960006714 0.039999999 -29.959999084
-87.289993286 -4.789999962 -38.540000916 -77.710006714 4.789999962 -36.459999084
-90.039993286 -0.039999999 -30.040000916 -74.960006714 0.039999999 -14.959999084
-87.289993286 -4.789999962 -23.540000916 -77.710006714 4.789999962 -21.459999084
-90.039993286 -0.039999999 -15.040000916 -74.960006714 0.039999999 0.039999999
-87.289993286 -4.789999962 -8.540000916 -77.710006714 4.789999962 -6.460000038
-90.039993286 -0.039999999 -0.039999999 -74.960006714 0.039999999 15.040000916
-87.289993286 -4.789999962 6.460000038 -77.710006714 4.789999962 8.540000916
-90.039993286 -0.039999999 14.959999084 -74.960006714 0.039999999 30.040000916
-87.289993286 -4.789999962 21.459999084 -77.710006714 4.789999962 23.540000916
-90.039993286 -0.039999999 29.959999084 -74.960006714 0.039999999 45.040000916
-87.289993286 -4.789999962 36.459999084 -77.710006714 4.789999962 38.540000916
-90.039993286 -0.039999999 44.959999084 -74.960006714 0.039999999 60.040000916
-87.289993286 -4.789999962 51.459999084 -77.710006714 4.789999962 53.540000916
-90.039993286 -0.039999999 59.959999084 -74.960006714 0.039999999 75.039993286
-87.289993286 -4.789999962 66.460006714 -77.710006714 4.789999962 68.539993286
-90.039993286 -0.039999999 74.960006714 -74.960006714 0.039999999 90.039993286
-87.289993286 -4.789999962 81.460006714 -77.710006714 4.789999962 83.539993286
-75.039993286 -0.039999999 -90.039993286 -59.959999084 0.039999999 -74.960006714
-72.289993286 -4.789999962 -83.539993286 -62.709999084 4.789999962 -81.460006714
-75.039993286 -0.039999999 -75.039993286 -59.959999084 0.039999999 -59.959999084
-72.289993286 -4.789999962 -68.539993286 -62.709999084 4.789999962 -66.460006714
-75.039993286 -0.039999999 -60.040000916 -59.959999084 0.039999999 -44.959999084
-72.289993286 -4.789999962 -53.540000916 -62.709999084 4.789999962 -51.459999084
-75.039993286 -0.039999999 -45.040000916 -59.959999084 0.039999999 -29.959999084
-72.289993286 -4.789999962 -38.540000916 -62.709999084 4.789999962 -36.459999084
-75.039993286 -0.039999999 -30.040000916 -59.959999084 0.039999999 -14.959999084
-72.289993286 -4.789999962 -23.540000916 -62.709999084 4.789999962 -21.459999084
-75.039993286 -0.039999999 -15.040000916 -59.959999084 0.039999999 0.039999999
-72.289993286 -4.789999962 -8.540000916 -62.709999084 4.789999962 -6.460000038
-75.039993286 -0.039999999 -0.039999999 -59.959999084 0.039999999 15.040000916
-72.289993286 -4.789999962 6.460000038 -62.709999084 4.789999962 8.540000916
-75.039993286 -0.039999999 14.959999084 -59.959999084 0.039999999 30.040000916
-72.289993286 -4.789999962 21.459999084 -62.709999084 4.789999962 23.540000916
-75.039993286 -0.039999999 29.959999084 -59.959999084 0.039999999 45.040000916
-72.289993286 -4.789999962 36.459999084 -62.709999084 4.789999962 38.540000916
-75.039993286 -0.039999999 44.959999084 -59.959999084 0.039999999 60.040000916
-72.289993286 -4.789999962 51.459999084 -62.709999084 4.789999962 53.540000916
-75.039993286 -0.039999999 59.959999084 -59.959999084 0.039999999 75.039993286
-72.289993286 -4.789999962 66.460006714 -62.709999084 4.789999962 68.539993286
-75.039993286 -0.039999999 74.960006714 -59.959999084 0.039999999 90.039993286
-72.289993286 -4.789999962 81.460006714 -62.709999084 4.789999962 83.539993286
-60.040000916 -0.039999999 -90.039993286 -44.959999084 0.039999999 -74.960006714
-57.290000916 -4.789999962 -83.539993286 -47.709999084 4.789999962 -81.460006714
-60.040000916 -0.039999999 -75.039993286 -44.959999084 0.039999999 -59.959999084
-57.290000916 -4.789999962 -68.539993286 -47.709999084 4.789999962 -66.460006714
-60.040000916 -0.039999999 -60.040000916 -44.959999084 0.039999999 -44.959999084
-57.290000916 -4.789999962 -53.540000916 -47.709999084 4.789999962 -51.459999084
-60.040000916 -0.039999999 -45.040000916 -44.959999084 0.039999999 -29.959999084
-57.290000916 -4.789999962 -38.540000916 -47.709999084 4.789999962 -36.459999084
-60.040000916 -0.039999999 -30.040000916 -44.959999084 0.039999999 -14.959999084
-57.290000916 -4.789999962 -23.540000916 -47.709999084 4.789999962 -21.459999084
-60.040000916 -0.039999999 -15.040000916 -44.959999084 0.039999999 0.039999999
-57.290000916 -4.789999962 -8.540000916 -47.709999084 4.789999962 -6.460000038
-60.040000916 -0.039999999 -0.039999999 -44.959999084 0.039999999 15.040000916
-57.290000916 -4.789999962 6.460000038 -47.709999084 4.789999962 8.540000916
-60.040000916 -0.039999999 14.959999084 -44.959999084 0.039999999 30.040000916
-57.290000916 -4.789999962 21.459999084 -47.709999084 4.789999962 23.540000916
-60.040000916 -0.039999999 29.959999084 -44.959999084 0.039999999 45.040000916
-57.290000916 -4.789999962 36.459999084 -47.709999084 4.789999962 38.540000916
-60.040000916 -0.039999999 44.959999084 -44.959999084 0.039999999 60.040000916
-57.290000916 -4.789999962 51.459999084 -47.709999084 4.789999962 53.540000916
-60.040000916 -0.039999999 59.959999084 -44.959999084 0.039999999 75.039993286
-57.290000916 -4.789999962 66.460006714 -47.709999084 4.789999962 68.539993286
-60.040000916 -0.039999999 74.960006714 -44.959999084 0.039999999 90.039993286
-57.290000916 -4.789999962 81.460006714 -47.709999084 4.789999962 83.539993286
-45.040000916 -0.039999999 -90.039993286 -29.959999084 0.039999999 -74.960006714
-42.290000916 -4.789999962 -83.539993286 -32.709999084 4.789999962 -81.460006714
-45.040000916 -0.039999999 -75.039993286 -29.959999084 0.039999999 -59.959999084
-42.290000916 -4.789999962 -68.539993286 -32.709999084 4.789999962 -66.460006714
-45.040000916 -0.039999999 -60.040000916 -29.959999084 0.039999999 -44.959999084
-42.290000916 -4.789999962 -53.540000916 -32.709999084 4.789999962 -51.459999084
-45.040000916 -0.039999999 -45.040000916 -29.959999084 0.039999999 -29.959999084
-42.290000916 -4.789999962 -38.540000916 -32.709999084 4.789999962 -36.459999084
-45.040000916 -0.039999999 -30.040000916 -29.959999084 0.039999999 -14.959999084
-42.290000916 -4.789999962 -23.540000916 -32.709999084 4.789999962 -21.459999084
-45.040000916 -0.039999999 -15.040000916 -29.959999084 0.039999999 0.039999999
-42.290000916 -4.789999962 -8.540000916 -32.709999084 4.789999962 -6.460000038
-45.040000916 -0.039999999 -0.039999999 -29.959999084 0.039999999 15.040000916
-42.290000916 -4.789999962 6.460000038 -32.709999084 4.789999962 8.540000916
-45.040000916 -0.039999999 14.959999084 -29.959999084 0.039999999 30.040000916
-42.290000916 -4.789999962 21.459999084 -32.709999084 4.789999962 23.540000916
-45.040000916 -0.039999999 29.959999084 -29.959999084 0.039999999 45.040000916
-42.290000916 -4.789999962 36.459999084 -32.709999084 4.789999962 38.540000916
-45.040000916 -0.039999999 44.959999084 -29.959999084 0.039999999 60.040000916
-42.290000916 -4.789999962 51.459999084 -32.709999084 4.789999962 53.540000916
-45.040000916 -0.039999999 59.959999084 -29.959999084 0.039999999 75.039993286
-42.290000916 -4.789999962 66.460006714 -32.709999084 4.789999962 68.539993286
-45.040000916 -0.039999999 74.960006714 -29.959999084 0.039999999 90.039993286
-42.290000916 -4.789999962 81.460006714 -32.709999084 4.789999962 83.539993286
-30.040000916 -0.039999999 -90.039993286 -14.959999084 0.039999999 -74.960006714
-27.290000916 -4.789999962 -83.539993286 -17.709999084 4.789999962 -81.460006714
-30.040000916 -0.039999999 -75.039993286 -14.959999084 0.039999999 -59.959999084
-27.290000916 -4.789999962 -68.539993286 -17.709999084 4.789999962 -66.460006714
-30.040000916 -0.039999999 -60.040000916 -14.959999084 0.039999999 -44.959999084
-27.290000916 -4.789999962 -53.540000916 -17.709999084 4.789999962 -51.459999084
-30.040000916 -0.039999999 -45.040000916 -14.959999084 0.039999999 -29.959999084
-27.290000916 -4.789999962 -38.540000916 -17.709999084 4.789999962 -36.459999084
-30.040000916 -0.039999999 -30.040000916 -14.959999084 0.039999999 -14.959999084
-27.290000916 -4.789999962 -23.540000916 -17.709999084 4.789999962 -21.459999084
-30.040000916 -0.039999999 -15.040000916 -14.959999084 0.039999999 0.039999999
-27.290000916 -4.789999962 -8.540000916 -17.709999084 4.789999962 -6.460000038
-30.040000916 -0.039999999 -0.039999999 -14.959999084 0.039999999 15.040000916
-27.290000916 -4.789999962 6.460000038 -17.709999084 4.789999962 8.540000916
-30.040000916 -0.039999999 14.959999084 -14.959999084 0.039999999 30.040000916
-27.290000916 -4.789999962 21.459999084 -17.709999084 4.789999962 23.540000916
-30.040000916 -0.039999999 29.959999084 -14.959999084 0.039999999 45.040000916
-27.290000916 -4.789999962 36.459999084 -17.709999084 4.789999962 38.540000916
-30.040000916 -0.039999999 44.959999084 -14.959999084 0.039999999 60.040000916
-27.290000916 -4.789999962 51.459999084 -17.709999084 4.789999962 53.540000916
-30.040000916 -0.039999999 59.959999084 -14.959999084 0.039999999 75.039993286
-27.290000916 -4.789999962 66.460006714 -17.709999084 4.789999962 68.539993286
-30.040000916 -0.039999999 74.960006714 -14.959999084 0.039999999 90.039993286
-27.290000916 -4.789999962 81.460006714 -17.709999084 4.789999962 83.539993286
-15.040000916 -0.039999999 -90.039993286 0.039999999 0.039999999 -74.960006714
-12.290000916 -4.789999962 -83.539993286 -2.710000038 4.789999962 -81.460006714
-15.040000916 -0.039999999 -75.039993286 0.039999999 0.039999999 -59.959999084
-12.290000916 -4.789999962 -68.539993286 -2.710000038 4.789999962 -66.460006714
-15.040000916 -0.039999999 -60.040000916 0.039999999 0.039999999 -44.959999084
-12.290000916 -4.789999962 -53.540000916 -2.710000038 4.789999962 -51.459999084
-15.040000916 -0.039999999 -45.040000916 0.039999999 0.039999999 -29.959999084
-12.290000916 -4.789999962 -38.540000916 -2.710000038 4.789999962 -36.459999084
-15.040000916 -0.039999999 -30.040000916 0.039999999 0.039999999 -14.959999084
-12.290000916 -4.789999962 -23.540000916 -2.710000038 4.789999962 -21.459999084
-15.040000916 -0.039999999 -15.040000916 0.039999999 0.039999999 0.039999999
-12.290000916 -4.789999962 -8.540000916 -2.710000038 4.789999962 -6.460000038
-15.040000916 -0.039999999 -0.039999999 0.039999999 0.039999999 15.040000916
-12.290000916 -4.789999962 6.460000038 -2.710000038 4.789999962 8.540000916
-15.040000916 -0.039999999 14.959999084 0.039999999 0.039999999 30.040000916
-12.290000916 -4.789999962 21.459999084 -2.710000038 4.789999962 23.540000916
-15.040000916 -0.039999999 29.959999084 0.039999999 0.039999999 45.040000916
-12.290000916 -4.789999962 36.459999084 -2.710000038 4.789999962 38.540000916
-15.040000916 -0.039999999 44.959999084 0.039999999 0.039999999 60.040000916
-12.290000916 -4.789999962 51.459999084 -2.710000038 4.789999962 53.540000916
-15.040000916 -0.039999999 59.959999084 0.039999999 0.039999999 75.039993286
-12.290000916 -4.789999962 66.460006714 -2.710000038 4.789999962 68.539993286
-15.040000916 -0.039999999 74.960006714 0.039999999 0.039999999 90.039993286
-12.290000916 -4.789999962 81.460006714 -2.710000038 4.789999962 83.539993286
-0.039999999 -0.039999999 -90.039993286 15.040000916 0.039999999 -74.960006714
2.710000038 -4.789999962 -83.539993286 12.290000916 4.789999962 -81.460006714
-0.039999999 -0.039999999 -75.039993286 15.040000916 0.039999999 -59.959999084
2.710000038 -4.789999962 -68.539993286 12.290000916 4.789999962 -66.460006714
-0.039999999 -0.039999999 -60.040000916 15.040000916 0.039999999 -44.959999084
2.710000038 -4.789999962 -53.540000916 12.290000916 4.789999962 -51.459999084
-0.039999999 -0.039999999 -45.040000916 15.040000916 0.039999999 -29.959999084
2.710000038 -4.789999962 -38.540000916 12.290000916 4.789999962 -36.459999084
-0.039999999 -0.039999999 -30.040000916 15.040000916 0.039999999 -14.959999084
2.710000038 -4.789999962 -23.540000916 12.290000916 4.789999962 -21.459999084
-0.039999999 -0.039999999 -15.040000916 15.040000916 0.039999999 0.039999999
2.710000038 -4.789999962 -8.540000916 12.290000916 4.789999962 -6.460000038
-0.039999999 -0.039999999 -0.039999999 15.040000916 0.039999999 15.040000916
2.710000038 -4.789999962 6.460000038 12.290000916 4.789999962 8.540000916
-0.039999999 -0.039999999 14.959999084 15.040000916 0.039999999 30.040000916
2.710000038 -4.789999962 21.459999084 12.290000916 4.789999962 23.540000916
-0.039999999 -0.039999999 29.959999084 15.040000916 0.039999999 45.040000916
2.710000038 -4.789999962 36.459999084 12.290000916 4.789999962 38.540000916
-0.039999999 -0.039999999 44.959999084 15.040000916 0.039999999 60.040000916
2.710000038 -4.789999962 51.459999084 12.290000916 4.789999962 53.540000916
-0.039999999 -0.039999999 59.959999084 15.040000916 0.039999999 75.039993286
2.710000038 -4.789999962 66.460006714 12.290000916 4.789999962 68.539993286
-0.039999999 -0.039999999 74.960006714 15.040000916 0.039999999 90.039993286
2.710000038 -4.789999962 81.460006714 12.290000916 4.789999962 83.539993286
14.959999084 -0.039999999 -90.039993286 30.040000916 0.039999999 -74.960006714
17.709999084 -4.789999962 -83.539993286 27.290000916 4.789999962 -81.460006714
14.959999084 -0.039999999 -75.039993286 30.040000916 0.039999999 -59.959999084
17.709999084 -4.789999962 -68.539993286 27.290000916 4.789999962 -66.460006714
14.959999084 -0.039999999 -60.040000916 30.040000916 0.039999999 -44.959999084
17.709999084 -4.789999962 -53.540000916 27.290000916 4.789999962 -51.459999084
14.959999084 -0.039999999 -45.040000916 30.040000916 0.039999999 -29.959999084
17.709999084 -4.789999962 -38.540000916 27.290000916 4.789999962 -36.459999084
14.959999084 -0.039999999 -30.040000916 30.040000916 0.039999999 -14.959999084
17.709999084 -4.789999962 -23.540000916 27.290000916 4.789999962 -21.459999084
14.959999084 -0.039999999 -15.040000916 30.040000916 0.039999999 0.039999999
17.709999084 -4.789999962 -8.540000916 27.290000916 4.789999962 -6.460000038
14.959999084 -0.039999999 -0.039999999 30.040000916 0.039999999 15.040000916
17.709999084 -4.789999962 6.460000038 27.290000916 4.789999962 8.540000916
14.959999084 -0.039999999 14.959999084 30.040000916 0.039999999 30.040000916
17.709999084 -4.789999962 21.459999084 27.290000916 4.789999962 23.540000916
14.959999084 -0.039999999 29.959999084 30.040000916 0.039999999 45.040000916
17.709999084 -4.789999962 36.459999084 27.290000916 4.789999962 38.540000916
14.959999084 -0.039999999 44.959999084 30.040000916 0.039999999 60.040000916
17.709999084 -4.789999962 51.459999084 27.290000916 4.789999962 53.540000916
14.959999084 -0.039999999 59.959999084 30.040000916 0.039999999 75.039993286
17.709999084 -4.789999962 66.460006714 27.290000916 4.789999962 68.539993286
14.959999084 -0.039999999 74.960006714 30.040000916 0.039999999 90.039993286
17.709999084 -4.789999962 81.460006714 27.290000916 4.789999962 83.539993286
29.959999084 -0.039999999 -90.039993286 45.040000916 0.039999999 -74.960006714
32.709999084 -4.789999962 -83.539993286 42.290000916 4.789999962 -81.460006714
29.959999084 -0.039999999 -75.039993286 45.040000916 0.039999999 -59.959999084
32.709999084 -4.789999962 -68.539993286 42.290000916 4.789999962 -66.460006714
29.959999084 -0.039999999 -60.040000916 45.040000916 0.039999999 -44.959999084
32.709999084 -4.789999962 -53.540000916 42.290000916 4.789999962 -51.459999084
29.959999084 -0.039999999 -45.040000916 45.040000916 0.039999999 -29.959999084
32.709999084 -4.789999962 -38.540000916 42.290000916 4.789999962 -36.459999084
29.959999084 -0.039999999 -30.040000916 45.040000916 0.039999999 -14.959999084
32.709999084 -4.789999962 -23.540000916 42.290000916 4.789999962 -21.459999084
29.959999084 -0.039999999 -15.040000916 45.040000916 0.039999999 0.039999999
32.709999084 -4.789999962 -8.540000916 42.290000916 4.789999962 -6.460000038
29.959999084 -0.039999999 -0.039999999 45.040000916 0.039999999 15.040000916
32.709999084 -4.789999962 6.460000038 42.290000916 4.789999962 8.540000916
29.959999084 -0.039999999 14.959999084 45.040000916 0.039999999 30.040000916
32.709999084 -4.789999962 21.459999084 42.290000916 4.789999962 23.540000916
29.959999084 -0.039999999 29.959999084 45.040000916 0.039999999 45.040000916
32.709999084 -4.789999962 36.459999084 42.290000916 4.789999962 38.540000916
29.959999084 -0.039999999 44.959999084 45.040000916 0.039999999 60.040000916
32.709999084 -4.789999962 51.459999084 42.290000916 4.789999962 53.540000916
29.959999084 -0.039999999 59.959999084 45.040000916 0.039999999 75.039993286
32.709999084 -4.789999962 66.460006714 42.290000916 4.789999962 68.539993286
29.959999084 -0.039999999 74.960006714 45.040000916 0.039999999 90.039993286
32.709999084 -4.789999962 81.460006714 42.290000916 4.789999962 83.539993286
44.959999084 -0.039999999 -90.039993286 60.040000916 0.039999999 -74.960006714
47.709999084 -4.789999962 -83.539993286 57.290000916 4.789999962 -81.460006714
44.959999084 -0.039999999 -75.039993286 60.040000916 0.039999999 -59.959999084
47.709999084 -4.789999962 -68.539993286 57.290000916 4.789999962 -66.460006714
44.959999084 -0.039999999 -60.040000916 60.040000916 0.039999999 -44.959999084
47.709999084 -4.789999962 -53.540000916 57.290000916 4.789999962 -51.459999084
44.959999084 -0.039999999 -45.040000916 60.040000916 0.039999999 -29.959999084
47.709999084 -4.789999962 -38.540000916 57.290000916 4.789999962 -36.459999084
44.959999084 -0.039999999 -30.040000916 60.040000916 0.039999999 -14.959999084
47.709999084 -4.789999962 -23.540000916 57.290000916 4.789999962 -21.459999084
44.959999084 -0.039999999 -15.040000916 60.040000916 0.039999999 0.039999999
47.709999084 -4.789999962 -8.540000916 57.290000916 4.789999962 -6.460000038
44.959999084 -0.039999999 -0.039999999 60.040000916 0.039999999 15.040000916
47.709999084 -4.789999962 6.460000038 57.290000916 4.789999962 8.540000916
44.959999084 -0.039999999 14.959999084 60.040000916 0.039999999 30.040000916
47.709999084 -4.789999962 21.459999084 57.290000916 4.789999962 23.540000916
44.959999084 -0.039999999 29.959999084 60.040000916 0.039999999 45.040000916
47.709999084 -4.789999962 36.459999084 57.290000916 4.789999962 38.540000916
44.959999084 -0.039999999 44.959999084 60.040000916 0.039999999 60.040000916
47.709999084 -4.789999962 51.459999084 57.290000916 4.789999962 53.540000916
44.959999084 -0.039999999 59.959999084 60.040000916 0.039999999 75.039993286
47.709999084 -4.789999962 66.460006714 57.290000916 4.789999962 68.539993286
44.959999084 -0.039999999 74.960006714 60.040000916 0.039999999 90.039993286
47.709999084 -4.789999962 81.460006714 57.290000916 4.789999962 83.539993286
59.959999084 -0.039999999 -90.039993286 75.039993286 0.039999999 -74.960006714
62.709999084 -4.789999962 -83.539993286 72.289993286 4.789999962 -81.460006714
59.959999084 -0.039999999 -75.039993286 75.039993286 0.039999999 -59.959999084
62.709999084 -4.789999962 -68.539993286 72.289993286 4.789999962 -66.460006714
59.959999084 -0.039999999 -60.040000916 75.039993286 0.039999999 -44.959999084
62.709999084 -4.789999962 -53.540000916 72.289993286 4.789999962 -51.459999084
59.959999084 -0.039999999 -45.040000916 75.039993286 0.039999999 -29.959999084
62.709999084 -4.789999962 -38.540000916 72.289993286 4.789999962 -36.459999084
59.959999084 -0.039999999 -30.040000916 75.039993286 0.039999999 -14.959999084
62.709999084 -4.789999962 -23.540000916 72.289993286 4.789999962 -21.459999084
59.959999084 -0.039999999 -15.040000916 75.039993286 0.039999999 0.039999999
62.709999084 -4.789999962 -8.540000916 72.289993286 4.789999962 -6.460000038
59.959999084 -0.039999999 -0.039999999 75.039993286 0.039999999 15.040000916
62.709999084 -4.789999962 6.460000038 72.289993286 4.789999962 8.540000916
59.959999084 -0.039999999 14.959999084 75.039993286 0.039999999 30.040000916
62.709999084 -4.789999962 21.459999084 72.289993286 4.789999962 23.540000916
59.959999084 -0.039999999 29.959999084 75.039993286 0.039999999 45.040000916
62.709999084 -4.789999962 36.459999084 72.289993286 4.789999962 38.540000916
59.959999084 -0.039999999 44.959999084 75.039993286 0.039999999 60.040000916
62.709999084 -4.789999962 51.459999084 72.289993286 4.789999962 53.540000916
59.959999084 -0.039999999 59.959999084 75.039993286 0.039999999 75.039993286
62.709999084 -4.789999962 66.460006714 72.289993286 4.789999962 68.539993286
59.959999084 -0.039999999 74.960006714 75.039993286 0.039999999 90.039993286
62.709999084 -4.789999962 81.460006714 72.289993286 4.789999962 83.539993286
74.960006714 -0.039999999 -90.039993286 90.039993286 0.039999999 -74.960006714
77.710006714 -4.789999962 -83.539993286 87.289993286 4.789999962 -81.460006714
74.960006714 -0.039999999 -75.039993286 90.039993286 0.039999999 -59.959999084
77.710006714 -4.789999962 -68.539993286 87.289993286 4.789999962 -66.460006714
74.960006714 -0.039999999 -60.040000916 90.039993286 0.039999999 -44.959999084
77.710006714 -4.789999962 -53.540000916 87.289993286 4.789999962 -51.459999084
74.960006714 -0.039999999 -45.040000916 90.039993286 0.039999999 -29.959999084
77.710006714 -4.789999962 -38.540000916 87.289993286 4.789999962 -36.459999084
74.960006714 -0.039999999 -30.040000916 90.039993286 0.039999999 -14.959999084
77.710006714 -4.789999962 -23.540000916 87.289993286 4.789999962 -21.459999084
74.960006714 -0.039999999 -15.040000916 90.039993286 0.039999999 0.039999999
77.710006714 -4.789999962 -8.540000916 87.289993286 4.789999962 -6.460000038
74.960006714 -0.039999999 -0.039999999 90.039993286 0.039999999 15.040000916
77.710006714 -4.789999962 6.460000038 87.289993286 4.789999962 8.540000916
74.960006714 -0.039999999 14.959999084 90.039993286 0.039999999 30.040000916
77.710006714 -4.789999962 21.459999084 87.289993286 4.789999962 23.540000916
74.960006714 -0.039999999 29.959999084 90.039993286 0.039999999 45.040000916
77.710006714 -4.789999962 36.459999084 87.289993286 4.789999962 38.540000916
74.960006714 -0.039999999 44.959999084 90.039993286 0.039999999 60.040000916
77.710006714 -4.789999962 51.459999084 87.289993286 4.789999962 53.540000916
74.960006714 -0.039999999 59.959999084 90.039993286 0.039999999 75.039993286
77.710006714 -4.789999962 66.460006714 87.289993286 4.789999962 68.539993286
74.960006714 -0.039999999 74.960006714 90.039993286 0.039999999 90.039993286
77.710006714 -4.789999962 81.460006714 87.289993286 4.789999962 83.539993286

4221
data/trees/bounds02.txt Normal file

File diff suppressed because it is too large Load diff

268
data/trees/bounds03.txt Normal file
View file

@ -0,0 +1,268 @@
-5600 9300 1800 -5400 9600 2100
-5000 9300 1800 -4800 9600 2100
-5300 8600 1800 -5100 8900 2100
-4900 9300 1800 -4700 9600 2100
-5300 9300 1800 -5100 9600 2100
-5500 9300 1800 -5300 9600 2100
-5700 9300 1800 -5500 9600 2100
-5400 9300 1800 -5200 9600 2100
-5200 9300 1800 -5000 9600 2100
-5000 8200 1800 -4700 8600 2200
-5100 9300 1800 -4900 9600 2100
3200 -1500 5200 3400 -1300 5400
3200 700 5200 3400 900 5400
2100 700 5200 2300 900 5400
1100 -900 5200 1300 -700 5400
-1200 0 5200 -1000 200 5400
-1900 800 5800 -1700 1000 6000
-1900 -600 5800 -1700 -400 6000
-1200 -1100 5600 -1000 -900 5800
-1500 -600 4800 -1300 -400 5000
-1500 500 4800 -1300 700 5000
200 500 4800 400 700 5000
200 -900 4800 400 -700 5000
1500 -900 4800 1700 -700 5000
1500 400 4800 1700 600 5000
3700 -500 4400 3900 -300 4600
3200 400 4400 3400 600 4600
2300 200 4200 2500 400 4400
800 -500 4200 1000 -300 4400
-2300 -1000 4200 -2100 -800 4400
-2300 -100 4200 -2100 100 4400
-2300 800 4200 -2100 1000 4400
-2300 800 3400 -2100 1000 3600
-1200 800 3400 -1000 1000 3600
-1200 -600 3400 -1000 -400 3600
-2200 -1000 3400 -2000 -800 3600
500 -100 3400 700 100 3600
900 700 3400 1100 900 3600
900 -1100 3400 1100 -900 3600
900 -1100 3800 1100 -900 4000
600 900 3800 800 1100 4000
600 -100 3800 800 100 4000
900 -1000 2800 1100 -800 3000
900 0 2800 1100 200 3000
900 800 2800 1100 1000 3000
-500 900 2800 -300 1100 3000
-2300 900 2800 -2100 1100 3000
-2000 200 3000 -1800 400 3200
-1500 -1100 3000 -1300 -900 3200
-2300 -300 3000 -2100 -100 3200
-3200 -300 3000 -3000 -100 3200
-3200 -1500 3000 -3000 -1300 3200
-2900 -2300 3000 -2700 -2100 3200
-2800 -1100 3400 -2600 -900 3600
-2700 100 3400 -2500 300 3600
-2700 1400 3400 -2500 1600 3600
-3800 1400 3400 -3600 1600 3600
-3500 2500 3400 -3300 2700 3600
-2200 1400 3400 -2000 1600 3600
-1400 1400 3600 -1200 1600 3800
-1400 2400 3600 -1200 2600 3800
-1400 3200 3600 -1200 3400 3800
-1800 3900 3400 -1600 4100 3600
-2200 3700 3400 -2000 3900 3600
-1900 4000 3000 -1700 4200 3200
-1500 3300 3000 -1300 3500 3200
-2300 3300 3000 -2100 3500 3200
-2300 2100 2800 -2100 2300 3000
-2300 1300 2800 -2100 1500 3000
-3800 1300 3000 -3600 1500 3200
-2700 1300 3000 -2500 1500 3200
-2700 1300 2200 -2500 1500 2400
-3700 1300 2200 -3500 1500 2400
-3300 -300 2200 -3100 -100 2400
-3300 -1500 2200 -3100 -1300 2400
-4500 300 2200 -4300 500 2400
-4500 -2100 2200 -4300 -1900 2400
-4500 -3100 2200 -4300 -2900 2400
-4500 -3300 1800 -4300 -3100 2000
-3200 -4800 2300 -3000 -4600 2500
-3200 -5800 2300 -3000 -5600 2500
-2300 -6300 2300 -2100 -6100 2500
-2300 -5300 2300 -2100 -5100 2500
-3100 -5700 2700 -2900 -5500 2900
-2800 -5700 3100 -2600 -5500 3300
-2400 -7100 3100 -2200 -6900 3300
-1600 -7100 3100 -1400 -6900 3300
-1300 -6500 3100 -1100 -6300 3300
-1300 -5100 3100 -1100 -4900 3300
-1800 -4500 3100 -1600 -4300 3300
-2600 -4500 3100 -2400 -4300 3300
-600 -1600 3400 -400 -1400 3600
300 -1700 3800 500 -1500 4000
-200 -2000 4400 0 -1800 4600
-6000 -1200 2200 -5800 -1000 2400
-7000 -1200 2200 -6800 -1000 2400
-6500 -1800 1800 -6300 -1600 2000
-6500 600 1800 -6300 800 2000
-6700 1400 1800 -6500 1600 2000
-6300 2600 1800 -6100 2800 2000
-6300 2600 2200 -6100 2800 2400
-6800 2600 2200 -6600 2800 2400
-6300 1000 2200 -6100 1200 2400
-6400 3600 2200 -6200 3800 2400
-6800 3900 2200 -6600 4100 2400
-6800 4400 2200 -6600 4600 2400
-6800 4400 1800 -6600 4600 2000
-6900 3800 1800 -6700 4000 2000
-7500 3800 1800 -7300 4000 2000
-7500 3300 1400 -7300 3500 1600
-4600 4500 1800 -4400 4700 2000
-4600 4100 2200 -4400 4300 2400
-4300 3600 1800 -4100 3800 2000
-4500 2400 2200 -4300 2600 2400
-4700 3600 2600 -4500 3800 2800
-4000 3600 2800 -3800 3800 3000
-2800 2600 2600 -2600 2800 2800
-2000 4500 3000 -1800 4700 3200
100 1400 4200 300 1600 4400
3600 700 4400 3800 900 4600
6200 -4600 6500 6400 -4400 6700
100 200 6800 300 400 7000
100 -400 6800 300 -200 7000
300 -400 6000 500 -200 6200
300 500 6000 500 700 6200
1100 500 6000 1300 700 6200
-2300 -1600 3400 -2100 -1400 3600
-1200 -1600 3400 -1000 -1400 3600
-1600 -4300 2300 -1400 -4100 2500
-2900 -4300 2300 -2700 -4100 2500
-3400 -7300 2300 -3200 -7100 2500
-4700 -7300 1800 -4500 -7100 2000
-4700 -6000 1800 -4500 -5800 2000
-4700 -4700 1800 -4500 -4500 2000
-5900 -4100 1800 -5700 -3900 2000
-5900 -6100 1800 -5700 -5900 2000
-5900 -7400 1800 -5700 -7200 2000
-6900 -3000 1800 -6700 -2800 2000
-6900 -100 1800 -6700 100 2000
-6100 200 1800 -5900 400 2000
-5800 900 1800 -5600 1100 2000
-5800 1800 1800 -5600 2000 2000
-5900 2800 1800 -5700 3000 2000
-6100 4300 1800 -5900 4500 2000
-6100 5900 1800 -5900 6100 2000
-6100 7200 1800 -5900 7400 2000
-4900 7200 1800 -4700 7400 2000
-4800 6200 1800 -4600 6400 2000
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100
-100 -100 -100 100 100 100

311
extern/glad/include/KHR/khrplatform.h vendored Normal file
View file

@ -0,0 +1,311 @@
#ifndef __khrplatform_h_
#define __khrplatform_h_
/*
** Copyright (c) 2008-2018 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/
/* Khronos platform-specific types and definitions.
*
* The master copy of khrplatform.h is maintained in the Khronos EGL
* Registry repository at https://github.com/KhronosGroup/EGL-Registry
* The last semantic modification to khrplatform.h was at commit ID:
* 67a3e0864c2d75ea5287b9f3d2eb74a745936692
*
* Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file.
* Please submit changes by filing pull requests or issues on
* the EGL Registry repository linked above.
*
*
* See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf
*
* This file should be included as
* #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines.
*
* The types in khrplatform.h should only be used to define API-specific types.
*
* Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size
* khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean.
*
* Tokens defined in khrplatform.h:
*
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
*
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
*
* Calling convention macros defined in this file:
* KHRONOS_APICALL
* KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES
*
* These may be used in function prototypes as:
*
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1,
* int arg2) KHRONOS_APIATTRIBUTES;
*/
#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
# define KHRONOS_STATIC 1
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL
*-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype.
*/
#if defined(KHRONOS_STATIC)
/* If the preprocessor constant KHRONOS_STATIC is defined, make the
* header compatible with static linking. */
# define KHRONOS_APICALL
#elif defined(_WIN32)
# define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C
#elif defined(__ANDROID__)
# define KHRONOS_APICALL __attribute__((visibility("default")))
#else
# define KHRONOS_APICALL
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY
*-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function
* name in the function prototype.
*/
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall
#else
# define KHRONOS_APIENTRY
#endif
/*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES
*-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments.
*/
#if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp
#else
#define KHRONOS_APIATTRIBUTES
#endif
/*-------------------------------------------------------------------------
* basic type definitions
*-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/*
* Using <stdint.h>
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
/*
* To support platform where unsigned long cannot be used interchangeably with
* inptr_t (e.g. CHERI-extended ISAs), we can use the stdint.h intptr_t.
* Ideally, we could just use (u)intptr_t everywhere, but this could result in
* ABI breakage if khronos_uintptr_t is changed from unsigned long to
* unsigned long long or similar (this results in different C++ name mangling).
* To avoid changes for existing platforms, we restrict usage of intptr_t to
* platforms where the size of a pointer is larger than the size of long.
*/
#if defined(__SIZEOF_LONG__) && defined(__SIZEOF_POINTER__)
#if __SIZEOF_POINTER__ > __SIZEOF_LONG__
#define KHRONOS_USE_INTPTR_T
#endif
#endif
#elif defined(__VMS ) || defined(__sgi)
/*
* Using <inttypes.h>
*/
#include <inttypes.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/*
* Win32
*/
typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__)
/*
* Sun or Digital
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t;
#else
typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#elif 0
/*
* Hypothetical platform with no float or int64 support
*/
typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0
#else
/*
* Generic fallback
*/
#include <stdint.h>
typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1
#endif
/*
* Types that are (so far) the same on all platforms
*/
typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t;
/*
* Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use.
*/
#ifdef KHRONOS_USE_INTPTR_T
typedef intptr_t khronos_intptr_t;
typedef uintptr_t khronos_uintptr_t;
#elif defined(_WIN64)
typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t;
#else
typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t;
#endif
#if defined(_WIN64)
typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t;
#else
typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t;
#endif
#if KHRONOS_SUPPORT_FLOAT
/*
* Float type
*/
typedef float khronos_float_t;
#endif
#if KHRONOS_SUPPORT_INT64
/* Time types
*
* These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned.
*/
typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif
/*
* Dummy value used to pad enum types to 32 bits.
*/
#ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif
/*
* Enumerated boolean type
*
* Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE.
*/
typedef enum {
KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */

4133
extern/glad/include/glad/glad.h vendored Normal file

File diff suppressed because it is too large Load diff

2121
extern/glad/src/glad.c vendored Normal file

File diff suppressed because it is too large Load diff

7987
extern/stb/stb_image.h vendored Normal file

File diff suppressed because it is too large Load diff

169
include/box3d/base.h Normal file
View file

@ -0,0 +1,169 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
// clang-format off
//
// Shared library macros
#if defined(_WIN32) && defined(box3d_EXPORTS)
// build the Windows DLL
#define BOX3D_EXPORT __declspec(dllexport)
#elif defined(_WIN32) && defined(BOX3D_DLL)
// using the Windows DLL
#define BOX3D_EXPORT __declspec(dllimport)
#elif defined(box3d_EXPORTS)
// building or using the shared library
#define BOX3D_EXPORT __attribute__((visibility("default")))
#else
// static library
#define BOX3D_EXPORT
#endif
// C++ macros
#ifdef __cplusplus
#define B3_API extern "C" BOX3D_EXPORT
#define B3_INLINE inline
#if defined( _MSC_VER )
#define B3_FORCE_INLINE __forceinline
#elif defined( __GNUC__ ) || defined( __clang__ )
#define B3_FORCE_INLINE inline __attribute__((always_inline))
#else
#define B3_FORCE_INLINE inline
#endif
#define B3_LITERAL(T) T
#define B3_ZERO_INIT {}
#else
#define B3_API BOX3D_EXPORT
#define B3_INLINE static inline
#if defined( _MSC_VER )
#define B3_FORCE_INLINE static __forceinline
#elif defined( __GNUC__ ) || defined( __clang__ )
#define B3_FORCE_INLINE static inline __attribute__((always_inline))
#else
#define B3_FORCE_INLINE static inline
#endif
/// Used for C literals like (b3Vec3){1.0f, 2.0f, 3.0f} where C++ requires b3Vec3{1.0f, 2.0f, 3.0f}
#define B3_LITERAL(T) (T)
#define B3_ZERO_INIT {0}
#endif
// clang-format on
#if defined( BOX3D_VALIDATE ) && !defined( NDEBUG )
#define B3_ENABLE_VALIDATION 1
#else
#define B3_ENABLE_VALIDATION 0
#endif
/**
* @defgroup base Base
* Base functionality
* @{
*/
/// This is used to indicate null for interfaces that work with indices instead of pointers
#define B3_NULL_INDEX -1
/// Prototype for user allocation function.
/// @param size the allocation size in bytes
/// @param alignment the required alignment, guaranteed to be a power of 2
typedef void* b3AllocFcn( int32_t size, int32_t alignment );
/// Prototype for user free function.
/// @param mem the memory previously allocated through `b3AllocFcn`
typedef void b3FreeFcn( void* mem );
/// Prototype for the user assert callback. Return 0 to skip the debugger break.
typedef int b3AssertFcn( const char* condition, const char* fileName, int lineNumber );
/// Prototype for user log callback. Used to log warnings.
typedef void b3LogFcn( const char* message );
/// This allows the user to override the allocation functions. These should be
/// set during application startup.
B3_API void b3SetAllocator( b3AllocFcn* allocFcn, b3FreeFcn* freeFcn );
/// Total bytes allocated by Box3D
B3_API int32_t b3GetByteCount( void );
/// Override the default assert callback.
/// @param assertFcn a non-null assert callback
B3_API void b3SetAssertFcn( b3AssertFcn* assertFcn );
// see https://github.com/scottt/debugbreak
#if defined( _MSC_VER )
#define B3_BREAKPOINT __debugbreak()
#elif defined( __GNUC__ ) || defined( __clang__ )
#define B3_BREAKPOINT __builtin_trap()
#else
// Unknown compiler
#include <assert.h>
#define B3_BREAKPOINT assert( 0 )
#endif
#if !defined( NDEBUG ) || defined( B3_ENABLE_ASSERT )
B3_API int b3InternalAssert( const char* condition, const char* fileName, int lineNumber );
#define B3_ASSERT( condition ) \
( (void)( ( !!( condition ) ) || ( b3InternalAssert( #condition, __FILE__, (int)( __LINE__ ) ), 0 ) ) )
#else
#define B3_ASSERT( ... ) ( (void)0 )
#endif
#if B3_ENABLE_VALIDATION
// Floating point tolerance checks should use this instead of the regular assertion
#define B3_VALIDATE( condition ) B3_ASSERT( condition )
#else
#define B3_VALIDATE( ... ) ( (void)0 )
#endif
/// Override the default logging callback.
B3_API void b3SetLogFcn( b3LogFcn* logFcn );
/// Version numbering scheme.
/// See https://semver.org/
typedef struct b3Version
{
/// Significant changes
int major;
/// Incremental changes
int minor;
/// Bug fixes
int revision;
} b3Version;
/// Get the current version of Box2D
B3_API b3Version b3GetVersion( void );
/**@}*/
//! @cond
/// Get the absolute number of system ticks. The value is platform specific.
B3_API uint64_t b3GetTicks( void );
/// Get the milliseconds passed from an initial tick value.
B3_API float b3GetMilliseconds( uint64_t ticks );
/// Get the milliseconds passed from an initial tick value.
B3_API float b3GetMillisecondsAndReset( uint64_t* ticks );
/// Yield to be used in a busy loop.
B3_API void b3Yield( void );
// Simple djb2 hash function for determinism testing
#define B3_HASH_INIT 5381
B3_API uint32_t b3Hash( uint32_t hash, const uint8_t* data, int count );
// Dump file support functions
B3_API void b3WriteBinaryFile( void* data, int size, const char* fileName );
B3_API void* b3ReadBinaryFile( const char* prefix, const char* fileName, int* memSize );
//! @endcond

1492
include/box3d/box3d.h Normal file

File diff suppressed because it is too large Load diff

1543
include/box3d/collision.h Normal file

File diff suppressed because it is too large Load diff

82
include/box3d/constants.h Normal file
View file

@ -0,0 +1,82 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "base.h"
/// Box2D bases all length units on meters, but you may need different units for your game.
/// You can set this value to use different units. This should be done at application startup
/// and only modified once. Default value is 1.
/// @warning This must be modified before any calls to Box2D
B3_API void b3SetLengthUnitsPerMeter( float lengthUnits );
/// Get the current length units per meter.
B3_API float b3GetLengthUnitsPerMeter( void );
// Used to detect bad values. Positions greater than about 16km will have precision
// problems, so 100km as a limit should be fine in all cases.
#define B3_HUGE ( 100000.0f * b3GetLengthUnitsPerMeter() )
/// Maximum parallel workers. Used for some fixed size arrays.
#define B3_MAX_WORKERS 32
/// Maximum number of tasks queued per world step. b2EnqueueTaskCallback will never be called
/// more than this per world step. This is related to B3_MAX_WORKERS. With 32 workers,
/// the maximum observed task count is 130. This allows an external task system to use a fixed
/// size array for Box3D task, which may help with creating stable user task pointers.
#define B3_MAX_TASKS 256
// Maximum number of colors in the constraint graph. Constraints that cannot
// find a color are added to the overflow set which are solved single-threaded.
// The compound barrel benchmark has minor overflow with 24 colors
#define B3_GRAPH_COLOR_COUNT 24
// Number of contact point buckets for counting the number of contact points per
// shape contact pair. This is just for reporting and doesn't affect simulation.
#define B3_CONTACT_MANIFOLD_COUNT_BUCKETS 8
// A small length used as a collision and constraint tolerance. Usually it is
// chosen to be numerically significant, but visually insignificant. In meters.
// @warning modifying this can have a significant impact on stability
#define B3_LINEAR_SLOP ( 0.005f * b3GetLengthUnitsPerMeter() )
#define B3_MIN_CAPSULE_LENGTH ( B3_LINEAR_SLOP )
// The distance between shapes where they are considered overlapped. This is needed
// because GJK may return small positive values for overlapped shapes in degenerate
// configurations.
#define B3_OVERLAP_SLOP ( 0.1f * B3_LINEAR_SLOP )
// Maximum number of simultaneous worlds that can be allocated
#ifndef B3_MAX_WORLDS
#define B3_MAX_WORLDS 128
#endif
// The maximum rotation of a body per time step. This limit is very large and is used
// to prevent numerical problems. You shouldn't need to adjust this.
// @warning increasing this to 0.5f * b3_pi or greater will break continuous collision.
#define B3_MAX_ROTATION ( 0.25f * B3_PI )
// @warning modifying this can have a significant impact on performance and stability
#define B3_SPECULATIVE_DISTANCE ( 4.0f * B3_LINEAR_SLOP )
/// The default contact recycling distance.
#define B3_CONTACT_RECYCLE_DISTANCE ( 10.0f * B3_LINEAR_SLOP )
// This is used to fatten AABBs in the dynamic tree. This allows proxies
// to move by a small amount without triggering a tree adjustment. This is in meters.
// @warning modifying this can have a significant impact on performance
#define B3_AABB_MARGIN ( 0.05f * b3GetLengthUnitsPerMeter() )
// The time that a body must be still before it will go to sleep. In seconds.
#define B3_TIME_TO_SLEEP 0.5f
// Body and shape name lengths
#define B3_NAME_LENGTH 64
// These generous limits allow for easy hashing. See b3ShapePairKey.
#define B3_SHAPE_POWER 22
#define B3_CHILD_POWER ( 64 - 2 * B3_SHAPE_POWER )
#define B3_MAX_SHAPES ( 1 << B3_SHAPE_POWER )
#define B3_MAX_CHILD_SHAPES ( 1 << B3_CHILD_POWER )

172
include/box3d/id.h Normal file
View file

@ -0,0 +1,172 @@
// SPDX-FileCopyrightText: 2023 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
// Note: this file should be stand-alone
/**
* @defgroup id Ids
* These ids serve as handles to internal Box2D objects.
* These should be considered opaque data and passed by value.
* Include this header if you need the id types and not the whole Box2D API.
* All ids are considered null if initialized to zero.
*
* For example in C++:
*
* @code{.cxx}
* b3WorldId worldId = {};
* @endcode
*
* Or in C:
*
* @code{.c}
* b3WorldId worldId = {0};
* @endcode
*
* These are both considered null.
*
* @warning Do not use the internals of these ids. They are subject to change. Ids should be treated as opaque objects.
* @warning You should use ids to access objects in Box2D. Do not access files within the src folder. Such usage is unsupported.
* @{
*/
/// World id references a world instance. This should be treated as an opaque handle.
typedef struct b3WorldId
{
uint16_t index1;
uint16_t generation;
} b3WorldId;
/// Body id references a body instance. This should be treated as an opaque handle.
typedef struct b3BodyId
{
int32_t index1;
uint16_t world0;
uint16_t generation;
} b3BodyId;
/// Shape id references a shape instance. This should be treated as an opaque handle.
typedef struct b3ShapeId
{
int32_t index1;
uint16_t world0;
uint16_t generation;
} b3ShapeId;
/// Joint id references a joint instance. This should be treated as an opaque handle.
typedef struct b3JointId
{
int32_t index1;
uint16_t world0;
uint16_t generation;
} b3JointId;
/// Contact id references a contact instance. This should be treated as an opaque handled.
typedef struct b3ContactId
{
int32_t index1;
uint16_t world0;
int16_t padding;
uint32_t generation;
} b3ContactId;
#ifdef __cplusplus
#define B3_NULL_ID {}
#define B3_ID_INLINE inline
#else
#define B3_NULL_ID { 0 }
#define B3_ID_INLINE static inline
#endif
/// Use these to make your identifiers null.
/// You may also use zero initialization to get null.
static const b3WorldId b3_nullWorldId = B3_NULL_ID;
static const b3BodyId b3_nullBodyId = B3_NULL_ID;
static const b3ShapeId b3_nullShapeId = B3_NULL_ID;
static const b3JointId b3_nullJointId = B3_NULL_ID;
static const b3ContactId b3_nullContactId = B3_NULL_ID;
/// Macro to determine if any id is null.
#define B3_IS_NULL( id ) ( id.index1 == 0 )
/// Macro to determine if any id is non-null.
#define B3_IS_NON_NULL( id ) ( id.index1 != 0 )
/// Compare two ids for equality. Doesn't work for b3WorldId. Don't mix types.
#define B3_ID_EQUALS( id1, id2 ) ( id1.index1 == id2.index1 && id1.world0 == id2.world0 && id1.generation == id2.generation )
/// Store a world id into a uint32_t.
B3_ID_INLINE uint32_t b3StoreWorldId( b3WorldId id )
{
return ( (uint32_t)id.index1 << 16 ) | (uint32_t)id.generation;
}
/// Load a uint32_t into a world id.
B3_ID_INLINE b3WorldId b3LoadWorldId( uint32_t x )
{
b3WorldId id = { (uint16_t)( x >> 16 ), (uint16_t)( x ) };
return id;
}
/// Store a body id into a uint64_t.
B3_ID_INLINE uint64_t b3StoreBodyId( b3BodyId id )
{
return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.generation;
}
/// Load a uint64_t into a body id.
B3_ID_INLINE b3BodyId b3LoadBodyId( uint64_t x )
{
b3BodyId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
return id;
}
/// Store a shape id into a uint64_t.
B3_ID_INLINE uint64_t b3StoreShapeId( b3ShapeId id )
{
return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.generation;
}
/// Load a uint64_t into a shape id.
B3_ID_INLINE b3ShapeId b3LoadShapeId( uint64_t x )
{
b3ShapeId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
return id;
}
/// Store a joint id into a uint64_t.
B3_ID_INLINE uint64_t b3StoreJointId( b3JointId id )
{
return ( (uint64_t)id.index1 << 32 ) | ( (uint64_t)id.world0 ) << 16 | (uint64_t)id.generation;
}
/// Load a uint64_t into a joint id.
B3_ID_INLINE b3JointId b3LoadJointId( uint64_t x )
{
b3JointId id = { (int32_t)( x >> 32 ), (uint16_t)( x >> 16 ), (uint16_t)( x ) };
return id;
}
/// Store a contact id into 16 bytes
B3_ID_INLINE void b3StoreContactId( b3ContactId id, uint32_t values[3] )
{
values[0] = (uint32_t)id.index1;
values[1] = (uint32_t)id.world0;
values[2] = (uint32_t)id.generation;
}
/// Load a two uint64_t into a contact id.
B3_ID_INLINE b3ContactId b3LoadContactId( uint32_t values[3] )
{
b3ContactId id;
id.index1 = (int32_t)values[0];
id.world0 = (uint16_t)values[1];
id.padding = 0;
id.generation = (uint32_t)values[2];
return id;
}
/**@}*/

File diff suppressed because it is too large Load diff

1523
include/box3d/types.h Normal file

File diff suppressed because it is too large Load diff

149
samples/CMakeLists.txt Normal file
View file

@ -0,0 +1,149 @@
# Samples app
option(BUILD_SHARED_LIBS "Build using shared libraries" OFF)
# set(FETCHCONTENT_QUIET FALSE)
# glad for OpenGL API
set(GLAD_DIR ${CMAKE_SOURCE_DIR}/extern/glad)
add_library(
glad STATIC
${GLAD_DIR}/src/glad.c
${GLAD_DIR}/include/glad/glad.h
${GLAD_DIR}/include/KHR/khrplatform.h
)
target_include_directories(glad PUBLIC ${GLAD_DIR}/include)
# glfw for windowing and input
SET(GLFW_BUILD_DOCS OFF CACHE BOOL "GLFW Docs")
SET(GLFW_BUILD_EXAMPLES OFF CACHE BOOL "GLFW Examples")
SET(GLFW_BUILD_TESTS OFF CACHE BOOL "GLFW Tests")
SET(GLFW_INSTALL OFF CACHE BOOL "GLFW Install")
FetchContent_Declare(
glfw
GIT_REPOSITORY https://github.com/glfw/glfw.git
GIT_TAG master
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
FetchContent_MakeAvailable(glfw)
# imgui and glfw backend for GUI
# https://gist.github.com/jeffamstutz/992723dfabac4e3ffff265eb71a24cd9
# Modified to pin to a specific imgui release
FetchContent_Populate(imgui
URL https://github.com/ocornut/imgui/archive/refs/tags/v1.92.5.zip
SOURCE_DIR ${CMAKE_SOURCE_DIR}/build/imgui
)
set(IMGUI_DIR ${CMAKE_SOURCE_DIR}/build/imgui)
add_library(imgui STATIC
${IMGUI_DIR}/imconfig.h
${IMGUI_DIR}/imgui.h
${IMGUI_DIR}/imstb_truetype.h
${IMGUI_DIR}/imgui.cpp
${IMGUI_DIR}/imgui_draw.cpp
${IMGUI_DIR}/imgui_demo.cpp
${IMGUI_DIR}/imgui_tables.cpp
${IMGUI_DIR}/imgui_widgets.cpp
${IMGUI_DIR}/backends/imgui_impl_glfw.cpp
${IMGUI_DIR}/backends/imgui_impl_opengl3.cpp
)
target_link_libraries(imgui PUBLIC glfw glad)
target_include_directories(imgui PUBLIC ${IMGUI_DIR} ${IMGUI_DIR}/backends)
# The sample app also uses stb_truetype and this keeps the symbols separate
target_compile_definitions(imgui PRIVATE IMGUI_STB_NAMESPACE=imgui_stb)
set_target_properties(imgui PROPERTIES
CXX_STANDARD 20
CXX_STANDARD_REQUIRED YES
CXX_EXTENSIONS NO
)
# implot for drawing real time plots
FetchContent_Declare(
implot
GIT_REPOSITORY https://github.com/epezent/implot.git
GIT_TAG v0.17
GIT_SHALLOW TRUE
GIT_PROGRESS TRUE
)
FetchContent_MakeAvailable(implot)
add_library(implot STATIC
${implot_SOURCE_DIR}/implot.cpp
${implot_SOURCE_DIR}/implot_items.cpp
${implot_SOURCE_DIR}/implot_demo.cpp
${implot_SOURCE_DIR}/implot.h
${implot_SOURCE_DIR}/implot_internal.h
)
target_link_libraries(implot PUBLIC imgui)
target_include_directories(implot PUBLIC ${implot_SOURCE_DIR})
set (BOX3D_SAMPLE_FILES
camera.cpp
camera.h
earcut.h
font.cpp
font.h
geo_buffer.cpp
geo_buffer.h
jsmn.h
main.cpp
mesh_loader.cpp
mesh_loader.h
renderer.cpp
renderer.h
sample.cpp
sample.h
scene.cpp
scene.h
shader.cpp
shader.h
ssao_buffer.cpp
ssao_buffer.h
stb_image_write.h
stb_truetype.h
tiny_obj_loader.h
utility.h
sample_benchmark.cpp
sample_bodies.cpp
sample_character.cpp
sample_collision.cpp
sample_compound.cpp
sample_continuous.cpp
sample_determinism.cpp
sample_events.cpp
sample_geometry.cpp
sample_issues.cpp
sample_joint.cpp
sample_manifold.cpp
sample_mesh.cpp
sample_ragdoll.cpp
sample_robustness.cpp
sample_shapes.cpp
sample_stacking.cpp
sample_tree.cpp
)
add_executable(samples ${BOX3D_SAMPLE_FILES})
target_include_directories(samples PRIVATE ${CMAKE_SOURCE_DIR}/data)
target_include_directories(samples PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
target_link_libraries(samples PRIVATE box3d shared glfw imgui implot glad)
set_target_properties(samples PROPERTIES
CMAKE_COMPILE_WARNING_AS_ERROR ON
CXX_STANDARD 20
CXX_STANDARD_REQUIRED YES
CXX_EXTENSIONS NO
)
source_group(TREE ${CMAKE_CURRENT_SOURCE_DIR} FILES ${BOX3D_SAMPLE_FILES})
message(STATUS "runtime = ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
message(STATUS "binary = ${CMAKE_CURRENT_BINARY_DIR}")

330
samples/camera.cpp Normal file
View file

@ -0,0 +1,330 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include <glad/glad.h>
// prevent clang format sorting glad.h with glfw3.h
#include <GLFW/glfw3.h>
// ImGui
#include <imgui.h>
#include <imgui_internal.h>
Matrix4 MakeOrthographicMatrix( float left, float right, float bottom, float top, float near, float far)
{
Matrix4 m;
m.cx = Vector4{ 2.0f / (right - left), 0.0f, 0.0f, 0.0f };
m.cy = Vector4{ 0.0f, 2.0f / (top - bottom), 0.0f, 0.0f };
m.cz = Vector4{ 0.0f, 0.0f, -2.0f / (far - near), 0.0f };
m.cw.x = -(right + left) / (right - left);
m.cw.y = -(top + bottom) / (top - bottom);
m.cw.z = -(far + near) / (far - near);
m.cw.w = 1.0f;
return m;
}
Camera::Camera()
{
m_yaw = 0.0f;
m_pitch = 0.0f;
m_radius = 1.0f;
m_speed = 20.0f;
m_pivot = b3Vec3_zero;
m_nearPlane = 0.02f;
m_farPlane = 100000.0f;
m_fovY = 50.0f;
m_tanY = tanf( 0.5f * B3_DEG_TO_RAD * m_fovY );
m_thirdPerson = false;
m_bufferWidth = 1920;
m_bufferHeight = 1080;
Resize(1920, 1080);
UpdateTransform();
}
void Camera::Resize( int width, int height )
{
m_width = b3MaxInt(width, 1 );
m_height = b3MaxInt(height, 1 );
m_ratio = float( m_width ) / float( m_height );
m_nearHeight = 2.0f * m_nearPlane * m_tanY;
m_nearWidth = m_ratio * m_nearHeight;
m_farHeight = m_farPlane * ( m_nearHeight / m_nearPlane );
m_farWidth = m_farPlane * ( m_nearWidth / m_nearPlane );
}
b3Vec3 Camera::GetRight() const
{
return m_right;
}
b3Vec3 Camera::GetUp() const
{
return m_up;
}
b3Vec3 Camera::GetForward() const
{
return m_forward;
}
b3Vec3 Camera::GetPosition() const
{
return m_position;
}
void Camera::Frame( b3AABB bounds)
{
b3Vec3 center = b3AABB_Center(bounds);
b3Vec3 extent = b3AABB_Extents(bounds);
float height = 2.0f * b3MaxFloat(extent.x, b3MaxFloat(extent.y, extent.z ) );
float radius = 0.5f * height / tanf( 0.5f * B3_DEG_TO_RAD * m_fovY );
m_pivot = center;
m_radius = 1.25f * radius;
}
void Camera::SetView( float yaw, float pitch, float radius, b3Vec3 pivot)
{
m_yaw = yaw;
m_pitch = pitch;
m_radius = radius;
m_pivot = pivot;
UpdateTransform();
}
Matrix4 Camera::GetWorldMatrix() const
{
Matrix4 m;
m.cx = { m_right.x, m_right.y, m_right.z, 0.0f };
m.cy = { m_up.x, m_up.y, m_up.z, 0.0f };
m.cz = { m_forward.x, m_forward.y, m_forward.z, 0.0f };
m.cw = { m_position.x, m_position.y, m_position.z, 1.0f };
return m;
}
static Matrix4 InvertOrtho( const Matrix4& m)
{
// [ R | t ]
// M = [ --+-- ]
// [ 0 | 1 ]
//
// y = M * x -> y = R * x + t -> x = R^-1 * (y - t) -> x = R^-1 * y - R^-1 * t
//
// [ R | t ]-1 [ R^-1 | -R^-1 * t ]
// M^-1 = [ --+-- ] = [ -----+---------- ]
// [ 0 | 1 ] [ 0 | 1 ]
b3Matrix3 r;
r.cx = {m.cx.x, m.cx.y, m.cx.z };
r.cy = {m.cy.x, m.cy.y, m.cy.z };
r.cz = {m.cz.x, m.cz.y, m.cz.z };
b3Matrix3 invR = b3InvertMatrix(r);
b3Vec3 t{m.cw.x, m.cw.y, m.cw.z };
b3Vec3 invRXT = invR * t;
Matrix4 out;
out.cx = {invR.cx.x, invR.cx.y, invR.cx.z, 0.0f };
out.cy = {invR.cy.x, invR.cy.y, invR.cy.z, 0.0f };
out.cz = {invR.cz.x, invR.cz.y, invR.cz.z, 0.0f };
out.cw = { -invRXT.x, -invRXT.y, -invRXT.z, 1.0f };
return out;
}
Matrix4 Camera::GetViewMatrix() const
{
Matrix4 v = GetWorldMatrix();
v = InvertOrtho(v);
return v;
}
// http://www.songho.ca/opengl/gl_projectionmatrix.html
// https://unspecified.wordpress.com/2012/06/21/calculating-the-gluperspective-matrix-and-other-opengl-matrix-maths/
// https://software.intel.com/en-us/articles/alternatives-to-using-z-bias-to-fix-z-fighting-issues
static Matrix4 Perspective( float fieldOfViewY, float aspectRatio, float nearPlane, float farPlane)
{
float cot = 1.0f / tanf( 0.5f * fieldOfViewY);
float depth = farPlane - nearPlane;
Matrix4 out;
out.cx = {cot / aspectRatio, 0.0f, 0.0f, 0.0f };
out.cy = { 0.0f, cot, 0.0f, 0.0f };
out.cz = { 0.0f, 0.0f, -(nearPlane + farPlane) / depth, -1.0f };
out.cw = { 0.0f, 0.0f, -2.0f * nearPlane * farPlane / depth, 0.0f };
return out;
}
Matrix4 Camera::GetProjectionMatrix() const
{
return Perspective( B3_DEG_TO_RAD * m_fovY, m_ratio, m_nearPlane, m_farPlane );
}
PickRay Camera::BuildPickRay( float x, float y) const
{
// Use similar triangles to build pick ray
// Scale, flip, shift into frustum coordinates
float xRatio = x / m_width - 0.5f;
float yRatio = 0.5f - y / m_height;
// Near plane coordinates using ratio
float xNear = xRatio * m_nearWidth;
float yNear = yRatio * m_nearHeight;
// Far plane coordinates using ratio
float xFar = xRatio * m_farWidth;
float yFar = yRatio * m_farHeight;
// Coordinates of near and far plane points in camera space
Vector4 nearPoint{xNear, yNear, -m_nearPlane, 1.0f };
Vector4 farPoint{xFar, yFar, -m_farPlane, 1.0f };
// Convert to world space
Matrix4 m = GetWorldMatrix();
nearPoint = MulMV(m, nearPoint);
farPoint = MulMV(m, farPoint);
PickRay ray;
ray.origin = {nearPoint.x, nearPoint.y, nearPoint.z };
ray.translation = b3Vec3{farPoint.x, farPoint.y, farPoint.z } - ray.origin;
return ray;
}
bool Camera::WorldToScreen( float& xScreen, float& yScreen, b3Vec3 worldPoint) const
{
Matrix4 view = GetViewMatrix();
Vector4 cameraPoint = MulMV(view, Vector4{ worldPoint.x, worldPoint.y, worldPoint.z, 1.0f });
float x = cameraPoint.x;
float y = cameraPoint.y;
float z = cameraPoint.z;
// Frustum comes out the back of the camera
if (z > -m_nearPlane || z < -m_farPlane )
{
return false;
}
// Find the frustum size at depth Z
float heightAtZ = -2.0f * z * m_tanY;
float widthAtZ = m_ratio * heightAtZ;
// Compute ratios of the point within the frustum rectangle at Z
float xRatio = x / widthAtZ;
float yRatio = y / heightAtZ;
// Shift, flip, and scale
xScreen = (xRatio + 0.5f ) * m_width;
yScreen = ( 0.5f - yRatio) * m_height;
return true;
}
void Camera::Update( GLFWwindow* window, float elapsedTime)
{
ImGuiIO& io = ImGui::GetIO();
if ( m_thirdPerson )
{
const float sensitivity = 1.0f;
m_radius -= sensitivity * io.MouseWheel;
m_radius = b3MaxFloat( 0.25f, m_radius );
return;
}
if (io.KeyAlt )
{
// Orbit
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Left ) )
{
const float sensitivity = 0.2f;
m_yaw -= sensitivity * io.MouseDelta.x;
m_pitch += sensitivity * io.MouseDelta.y;
m_pitch = b3ClampFloat( m_pitch, -85.0f, 85.0f );
}
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Middle ) )
{
const float sensitivity = 0.01f;
m_pivot -= sensitivity * io.MouseDelta.x * m_right;
m_pivot += sensitivity * io.MouseDelta.y * m_up;
}
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Right ) )
{
const float sensitivity = 0.02f;
m_radius -= sensitivity * io.MouseDelta.y;
m_radius = b3MaxFloat( 0.001f, m_radius );
}
const float sensitivity = 1.0f;
m_radius -= sensitivity * io.MouseWheel;
m_radius = b3MaxFloat( 0.001f, m_radius );
UpdateTransform();
}
else if ( ImGui::IsMouseDown( ImGuiMouseButton_Right ) )
{
m_speed += io.MouseWheel;
m_speed = b3ClampFloat( m_speed, 0.001f * 60.0f, 500.0f * 60.0f );
if ( ImGui::IsMouseDragging( ImGuiMouseButton_Right ) )
{
const float sensitivity = 0.2f;
m_yaw -= sensitivity * io.MouseDelta.x;
m_pitch += sensitivity * io.MouseDelta.y;
m_pitch = b3ClampFloat( m_pitch, -85.0f, 85.0f );
float sinYaw = sinf( B3_DEG_TO_RAD * m_yaw ), cosYaw = cosf( B3_DEG_TO_RAD * m_yaw );
float sinPitch = sinf( B3_DEG_TO_RAD * m_pitch ), cosPitch = cosf( B3_DEG_TO_RAD * m_pitch );
m_forward = {sinYaw * cosPitch, sinPitch, cosYaw * cosPitch};
m_up = { 0.0f, 1.0f, 0.0f };
m_up = b3Normalize( m_up - b3Dot( m_forward, m_up ) * m_forward );
m_right = b3Normalize( b3Cross( m_up, m_forward ) );
}
// Smoother with GLFW
if ( glfwGetKey(window, GLFW_KEY_W ) )
{
m_position -= m_speed * elapsedTime * m_forward;
}
if ( glfwGetKey(window, GLFW_KEY_S ) )
{
m_position += m_speed * elapsedTime * m_forward;
}
if ( glfwGetKey(window, GLFW_KEY_A ) )
{
m_position -= m_speed * elapsedTime * m_right;
}
if ( glfwGetKey(window, GLFW_KEY_D ) )
{
m_position += m_speed * elapsedTime * m_right;
}
m_pivot = m_position - m_radius * m_forward;
}
}
void Camera::UpdateTransform()
{
m_yaw = B3_RAD_TO_DEG * b3UnwindAngle( B3_DEG_TO_RAD * m_yaw );
float sinYaw = sinf( B3_DEG_TO_RAD * m_yaw ), cosYaw = cosf( B3_DEG_TO_RAD * m_yaw );
float sinPitch = sinf( B3_DEG_TO_RAD * m_pitch ), cosPitch = cosf( B3_DEG_TO_RAD * m_pitch );
m_forward = {sinYaw * cosPitch, sinPitch, cosYaw * cosPitch};
m_up = { 0.0f, 1.0f, 0.0f };
m_up = b3Normalize( m_up - b3Dot( m_forward, m_up ) * m_forward );
m_right = b3Normalize( b3Cross( m_up, m_forward ) );
m_position = m_pivot + m_radius * m_forward;
}

85
samples/camera.h Normal file
View file

@ -0,0 +1,85 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "utility.h"
#include "box3d/types.h"
struct GLFWwindow;
struct PickRay
{
b3Vec3 origin;
b3Vec3 translation;
};
struct Camera
{
Camera();
// Window
void Resize( int width, int height );
// View
b3Vec3 GetRight() const;
b3Vec3 GetUp() const;
b3Vec3 GetForward() const;
b3Vec3 GetPosition() const;
void Frame( b3AABB bounds);
void SetView( float yaw, float pitch, float radius, b3Vec3 pivot = b3Vec3_zero );
Matrix4 GetWorldMatrix() const;
Matrix4 GetViewMatrix() const;
// Projection
Matrix4 GetProjectionMatrix() const;
PickRay BuildPickRay( float x, float y) const;
bool WorldToScreen( float& xScreen, float& yScreen, b3Vec3 worldPoint) const;
// Control
void Update( GLFWwindow* window, float elapsedTime);
void UpdateTransform();
// Window
int m_width;
int m_height;
// Frame buffer
int m_bufferWidth;
int m_bufferHeight;
// View yaw in degrees
float m_yaw;
// View pitch in degrees
float m_pitch;
float m_radius;
b3Vec3 m_pivot;
float m_speed;
// Projection
float m_fovY;
float m_tanY;
float m_ratio;
float m_nearPlane;
float m_farPlane;
float m_nearWidth;
float m_nearHeight;
float m_farWidth;
float m_farHeight;
// World coordinates
b3Vec3 m_right;
b3Vec3 m_up;
b3Vec3 m_forward;
b3Vec3 m_position;
bool m_thirdPerson;
};

820
samples/earcut.h Normal file
View file

@ -0,0 +1,820 @@
#pragma once
#include <algorithm>
#include <cassert>
#include <cmath>
#include <memory>
#include <vector>
namespace mapbox {
namespace util {
template <std::size_t I, typename T> struct nth {
inline static typename std::tuple_element<I, T>::type
get(const T& t) { return std::get<I>(t); };
};
}
namespace detail {
template <typename N = uint32_t>
class Earcut {
public:
std::vector<N> indices;
std::size_t vertices = 0;
template <typename Polygon>
void operator()(const Polygon& points);
private:
struct Node {
Node(N index, double x_, double y_) : i(index), x(x_), y(y_) {}
Node(const Node&) = delete;
Node& operator=(const Node&) = delete;
Node(Node&&) = delete;
Node& operator=(Node&&) = delete;
const N i;
const double x;
const double y;
// previous and next vertice nodes in a polygon ring
Node* prev = nullptr;
Node* next = nullptr;
// z-order curve value
int32_t z = 0;
// previous and next nodes in z-order
Node* prevZ = nullptr;
Node* nextZ = nullptr;
// indicates whether this is a steiner point
bool steiner = false;
};
template <typename Ring> Node* linkedList(const Ring& points, const bool clockwise);
Node* filterPoints(Node* start, Node* end = nullptr);
void earcutLinked(Node* ear, int pass = 0);
bool isEar(Node* ear);
bool isEarHashed(Node* ear);
Node* cureLocalIntersections(Node* start);
void splitEarcut(Node* start);
template <typename Polygon> Node* eliminateHoles(const Polygon& points, Node* outerNode);
Node* eliminateHole(Node* hole, Node* outerNode);
Node* findHoleBridge(Node* hole, Node* outerNode);
bool sectorContainsSector(const Node* m, const Node* p);
void indexCurve(Node* start);
Node* sortLinked(Node* list);
int32_t zOrder(const double x_, const double y_);
Node* getLeftmost(Node* start);
bool pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const;
bool isValidDiagonal(Node* a, Node* b);
double area(const Node* p, const Node* q, const Node* r) const;
bool equals(const Node* p1, const Node* p2);
bool intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2);
bool onSegment(const Node* p, const Node* q, const Node* r);
int sign(double val);
bool intersectsPolygon(const Node* a, const Node* b);
bool locallyInside(const Node* a, const Node* b);
bool middleInside(const Node* a, const Node* b);
Node* splitPolygon(Node* a, Node* b);
template <typename Point> Node* insertNode(std::size_t i, const Point& p, Node* last);
void removeNode(Node* p);
bool hashing;
double minX, maxX;
double minY, maxY;
double inv_size = 0;
template <typename T, typename Alloc = std::allocator<T>>
class ObjectPool {
public:
ObjectPool() { }
ObjectPool(std::size_t blockSize_) {
reset(blockSize_);
}
~ObjectPool() {
clear();
}
template <typename... Args>
T* construct(Args&&... args) {
if (currentIndex >= blockSize) {
currentBlock = alloc_traits::allocate(alloc, blockSize);
allocations.emplace_back(currentBlock);
currentIndex = 0;
}
T* object = &currentBlock[currentIndex++];
alloc_traits::construct(alloc, object, std::forward<Args>(args)...);
return object;
}
void reset(std::size_t newBlockSize) {
for (auto allocation : allocations) {
alloc_traits::deallocate(alloc, allocation, blockSize);
}
allocations.clear();
blockSize = std::max<std::size_t>(1, newBlockSize);
currentBlock = nullptr;
currentIndex = blockSize;
}
void clear() { reset(blockSize); }
private:
T* currentBlock = nullptr;
std::size_t currentIndex = 1;
std::size_t blockSize = 1;
std::vector<T*> allocations;
Alloc alloc;
typedef typename std::allocator_traits<Alloc> alloc_traits;
};
ObjectPool<Node> nodes;
};
template <typename N> template <typename Polygon>
void Earcut<N>::operator()(const Polygon& points) {
// reset
indices.clear();
vertices = 0;
if (points.empty()) return;
double x;
double y;
int threshold = 80;
std::size_t len = 0;
for (size_t i = 0; threshold >= 0 && i < points.size(); i++) {
threshold -= static_cast<int>(points[i].size());
len += points[i].size();
}
//estimate size of nodes and indices
nodes.reset(len * 3 / 2);
indices.reserve(len + points[0].size());
Node* outerNode = linkedList(points[0], true);
if (!outerNode || outerNode->prev == outerNode->next) return;
if (points.size() > 1) outerNode = eliminateHoles(points, outerNode);
// if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
hashing = threshold < 0;
if (hashing) {
Node* p = outerNode->next;
minX = maxX = outerNode->x;
minY = maxY = outerNode->y;
do {
x = p->x;
y = p->y;
minX = std::min<double>(minX, x);
minY = std::min<double>(minY, y);
maxX = std::max<double>(maxX, x);
maxY = std::max<double>(maxY, y);
p = p->next;
} while (p != outerNode);
// minX, minY and size are later used to transform coords into integers for z-order calculation
inv_size = std::max<double>(maxX - minX, maxY - minY);
inv_size = inv_size != .0 ? (1. / inv_size) : .0;
}
earcutLinked(outerNode);
nodes.clear();
}
// create a circular doubly linked list from polygon points in the specified winding order
template <typename N> template <typename Ring>
typename Earcut<N>::Node*
Earcut<N>::linkedList(const Ring& points, const bool clockwise) {
using Point = typename Ring::value_type;
double sum = 0;
const std::size_t len = points.size();
std::size_t i, j;
Node* last = nullptr;
// calculate original winding order of a polygon ring
for (i = 0, j = len > 0 ? len - 1 : 0; i < len; j = i++) {
const auto& p1 = points[i];
const auto& p2 = points[j];
const double p20 = util::nth<0, Point>::get(p2);
const double p10 = util::nth<0, Point>::get(p1);
const double p11 = util::nth<1, Point>::get(p1);
const double p21 = util::nth<1, Point>::get(p2);
sum += (p20 - p10) * (p11 + p21);
}
// link points into circular doubly-linked list in the specified winding order
if (clockwise == (sum > 0)) {
for (i = 0; i < len; i++) last = insertNode(vertices + i, points[i], last);
} else {
for (i = len; i-- > 0;) last = insertNode(vertices + i, points[i], last);
}
if (last && equals(last, last->next)) {
removeNode(last);
last = last->next;
}
vertices += len;
return last;
}
// eliminate colinear or duplicate points
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::filterPoints(Node* start, Node* end) {
if (!end) end = start;
Node* p = start;
bool again;
do {
again = false;
if (!p->steiner && (equals(p, p->next) || area(p->prev, p, p->next) == 0)) {
removeNode(p);
p = end = p->prev;
if (p == p->next) break;
again = true;
} else {
p = p->next;
}
} while (again || p != end);
return end;
}
// main ear slicing loop which triangulates a polygon (given as a linked list)
template <typename N>
void Earcut<N>::earcutLinked(Node* ear, int pass) {
if (!ear) return;
// interlink polygon nodes in z-order
if (!pass && hashing) indexCurve(ear);
Node* stop = ear;
Node* prev;
Node* next;
int iterations = 0;
// iterate through ears, slicing them one by one
while (ear->prev != ear->next) {
iterations++;
prev = ear->prev;
next = ear->next;
if (hashing ? isEarHashed(ear) : isEar(ear)) {
// cut off the triangle
indices.emplace_back(prev->i);
indices.emplace_back(ear->i);
indices.emplace_back(next->i);
removeNode(ear);
// skipping the next vertice leads to less sliver triangles
ear = next->next;
stop = next->next;
continue;
}
ear = next;
// if we looped through the whole remaining polygon and can't find any more ears
if (ear == stop) {
// try filtering points and slicing again
if (!pass) earcutLinked(filterPoints(ear), 1);
// if this didn't work, try curing all small self-intersections locally
else if (pass == 1) {
ear = cureLocalIntersections(filterPoints(ear));
earcutLinked(ear, 2);
// as a last resort, try splitting the remaining polygon into two
} else if (pass == 2) splitEarcut(ear);
break;
}
}
}
// check whether a polygon node forms a valid ear with adjacent nodes
template <typename N>
bool Earcut<N>::isEar(Node* ear) {
const Node* a = ear->prev;
const Node* b = ear;
const Node* c = ear->next;
if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
// now make sure we don't have other points inside the potential ear
Node* p = ear->next->next;
while (p != ear->prev) {
if (pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
area(p->prev, p, p->next) >= 0) return false;
p = p->next;
}
return true;
}
template <typename N>
bool Earcut<N>::isEarHashed(Node* ear) {
const Node* a = ear->prev;
const Node* b = ear;
const Node* c = ear->next;
if (area(a, b, c) >= 0) return false; // reflex, can't be an ear
// triangle bbox; min & max are calculated like this for speed
const double minTX = std::min<double>(a->x, std::min<double>(b->x, c->x));
const double minTY = std::min<double>(a->y, std::min<double>(b->y, c->y));
const double maxTX = std::max<double>(a->x, std::max<double>(b->x, c->x));
const double maxTY = std::max<double>(a->y, std::max<double>(b->y, c->y));
// z-order range for the current triangle bbox;
const int32_t minZ = zOrder(minTX, minTY);
const int32_t maxZ = zOrder(maxTX, maxTY);
// first look for points inside the triangle in increasing z-order
Node* p = ear->nextZ;
while (p && p->z <= maxZ) {
if (p != ear->prev && p != ear->next &&
pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
area(p->prev, p, p->next) >= 0) return false;
p = p->nextZ;
}
// then look for points in decreasing z-order
p = ear->prevZ;
while (p && p->z >= minZ) {
if (p != ear->prev && p != ear->next &&
pointInTriangle(a->x, a->y, b->x, b->y, c->x, c->y, p->x, p->y) &&
area(p->prev, p, p->next) >= 0) return false;
p = p->prevZ;
}
return true;
}
// go through all polygon nodes and cure small local self-intersections
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::cureLocalIntersections(Node* start) {
Node* p = start;
do {
Node* a = p->prev;
Node* b = p->next->next;
// a self-intersection where edge (v[i-1],v[i]) intersects (v[i+1],v[i+2])
if (!equals(a, b) && intersects(a, p, p->next, b) && locallyInside(a, b) && locallyInside(b, a)) {
indices.emplace_back(a->i);
indices.emplace_back(p->i);
indices.emplace_back(b->i);
// remove two nodes involved
removeNode(p);
removeNode(p->next);
p = start = b;
}
p = p->next;
} while (p != start);
return filterPoints(p);
}
// try splitting polygon into two and triangulate them independently
template <typename N>
void Earcut<N>::splitEarcut(Node* start) {
// look for a valid diagonal that divides the polygon into two
Node* a = start;
do {
Node* b = a->next->next;
while (b != a->prev) {
if (a->i != b->i && isValidDiagonal(a, b)) {
// split the polygon in two by the diagonal
Node* c = splitPolygon(a, b);
// filter colinear points around the cuts
a = filterPoints(a, a->next);
c = filterPoints(c, c->next);
// run earcut on each half
earcutLinked(a);
earcutLinked(c);
return;
}
b = b->next;
}
a = a->next;
} while (a != start);
}
// link every hole into the outer loop, producing a single-ring polygon without holes
template <typename N> template <typename Polygon>
typename Earcut<N>::Node*
Earcut<N>::eliminateHoles(const Polygon& points, Node* outerNode) {
const size_t len = points.size();
std::vector<Node*> queue;
for (size_t i = 1; i < len; i++) {
Node* list = linkedList(points[i], false);
if (list) {
if (list == list->next) list->steiner = true;
queue.push_back(getLeftmost(list));
}
}
std::sort(queue.begin(), queue.end(), [](const Node* a, const Node* b) {
return a->x < b->x;
});
// process holes from left to right
for (size_t i = 0; i < queue.size(); i++) {
outerNode = eliminateHole(queue[i], outerNode);
outerNode = filterPoints(outerNode, outerNode->next);
}
return outerNode;
}
// find a bridge between vertices that connects hole with an outer ring and and link it
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::eliminateHole(Node* hole, Node* outerNode) {
Node* bridge = findHoleBridge(hole, outerNode);
if (!bridge) {
return outerNode;
}
Node* bridgeReverse = splitPolygon(bridge, hole);
// filter collinear points around the cuts
Node* filteredBridge = filterPoints(bridge, bridge->next);
filterPoints(bridgeReverse, bridgeReverse->next);
// Check if input node was removed by the filtering
return outerNode == bridge ? filteredBridge : outerNode;
}
// David Eberly's algorithm for finding a bridge between hole and outer polygon
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::findHoleBridge(Node* hole, Node* outerNode) {
Node* p = outerNode;
double hx = hole->x;
double hy = hole->y;
double qx = -std::numeric_limits<double>::infinity();
Node* m = nullptr;
// find a segment intersected by a ray from the hole's leftmost Vertex to the left;
// segment's endpoint with lesser x will be potential connection Vertex
do {
if (hy <= p->y && hy >= p->next->y && p->next->y != p->y) {
double x = p->x + (hy - p->y) * (p->next->x - p->x) / (p->next->y - p->y);
if (x <= hx && x > qx) {
qx = x;
if (x == hx) {
if (hy == p->y) return p;
if (hy == p->next->y) return p->next;
}
m = p->x < p->next->x ? p : p->next;
}
}
p = p->next;
} while (p != outerNode);
if (!m) return 0;
if (hx == qx) return m; // hole touches outer segment; pick leftmost endpoint
// look for points inside the triangle of hole Vertex, segment intersection and endpoint;
// if there are no points found, we have a valid connection;
// otherwise choose the Vertex of the minimum angle with the ray as connection Vertex
const Node* stop = m;
double tanMin = std::numeric_limits<double>::infinity();
double tanCur = 0;
p = m;
double mx = m->x;
double my = m->y;
do {
if (hx >= p->x && p->x >= mx && hx != p->x &&
pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p->x, p->y)) {
tanCur = std::abs(hy - p->y) / (hx - p->x); // tangential
if (locallyInside(p, hole) &&
(tanCur < tanMin || (tanCur == tanMin && (p->x > m->x || sectorContainsSector(m, p))))) {
m = p;
tanMin = tanCur;
}
}
p = p->next;
} while (p != stop);
return m;
}
// whether sector in vertex m contains sector in vertex p in the same coordinates
template <typename N>
bool Earcut<N>::sectorContainsSector(const Node* m, const Node* p) {
return area(m->prev, m, p->prev) < 0 && area(p->next, m, m->next) < 0;
}
// interlink polygon nodes in z-order
template <typename N>
void Earcut<N>::indexCurve(Node* start) {
assert(start);
Node* p = start;
do {
p->z = p->z ? p->z : zOrder(p->x, p->y);
p->prevZ = p->prev;
p->nextZ = p->next;
p = p->next;
} while (p != start);
p->prevZ->nextZ = nullptr;
p->prevZ = nullptr;
sortLinked(p);
}
// Simon Tatham's linked list merge sort algorithm
// http://www.chiark.greenend.org.uk/~sgtatham/algorithms/listsort.html
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::sortLinked(Node* list) {
assert(list);
Node* p;
Node* q;
Node* e;
Node* tail;
int i, numMerges, pSize, qSize;
int inSize = 1;
for (;;) {
p = list;
list = nullptr;
tail = nullptr;
numMerges = 0;
while (p) {
numMerges++;
q = p;
pSize = 0;
for (i = 0; i < inSize; i++) {
pSize++;
q = q->nextZ;
if (!q) break;
}
qSize = inSize;
while (pSize > 0 || (qSize > 0 && q)) {
if (pSize == 0) {
e = q;
q = q->nextZ;
qSize--;
} else if (qSize == 0 || !q) {
e = p;
p = p->nextZ;
pSize--;
} else if (p->z <= q->z) {
e = p;
p = p->nextZ;
pSize--;
} else {
e = q;
q = q->nextZ;
qSize--;
}
if (tail) tail->nextZ = e;
else list = e;
e->prevZ = tail;
tail = e;
}
p = q;
}
tail->nextZ = nullptr;
if (numMerges <= 1) return list;
inSize *= 2;
}
}
// z-order of a Vertex given coords and size of the data bounding box
template <typename N>
int32_t Earcut<N>::zOrder(const double x_, const double y_) {
// coords are transformed into non-negative 15-bit integer range
int32_t x = static_cast<int32_t>(32767.0 * (x_ - minX) * inv_size);
int32_t y = static_cast<int32_t>(32767.0 * (y_ - minY) * inv_size);
x = (x | (x << 8)) & 0x00FF00FF;
x = (x | (x << 4)) & 0x0F0F0F0F;
x = (x | (x << 2)) & 0x33333333;
x = (x | (x << 1)) & 0x55555555;
y = (y | (y << 8)) & 0x00FF00FF;
y = (y | (y << 4)) & 0x0F0F0F0F;
y = (y | (y << 2)) & 0x33333333;
y = (y | (y << 1)) & 0x55555555;
return x | (y << 1);
}
// find the leftmost node of a polygon ring
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::getLeftmost(Node* start) {
Node* p = start;
Node* leftmost = start;
do {
if (p->x < leftmost->x || (p->x == leftmost->x && p->y < leftmost->y))
leftmost = p;
p = p->next;
} while (p != start);
return leftmost;
}
// check if a point lies within a convex triangle
template <typename N>
bool Earcut<N>::pointInTriangle(double ax, double ay, double bx, double by, double cx, double cy, double px, double py) const {
return (cx - px) * (ay - py) - (ax - px) * (cy - py) >= 0 &&
(ax - px) * (by - py) - (bx - px) * (ay - py) >= 0 &&
(bx - px) * (cy - py) - (cx - px) * (by - py) >= 0;
}
// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
template <typename N>
bool Earcut<N>::isValidDiagonal(Node* a, Node* b) {
return a->next->i != b->i && a->prev->i != b->i && !intersectsPolygon(a, b) && // dones't intersect other edges
((locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && // locally visible
(area(a->prev, a, b->prev) != 0.0 || area(a, b->prev, b) != 0.0)) || // does not create opposite-facing sectors
(equals(a, b) && area(a->prev, a, a->next) > 0 && area(b->prev, b, b->next) > 0)); // special zero-length case
}
// signed area of a triangle
template <typename N>
double Earcut<N>::area(const Node* p, const Node* q, const Node* r) const {
return (q->y - p->y) * (r->x - q->x) - (q->x - p->x) * (r->y - q->y);
}
// check if two points are equal
template <typename N>
bool Earcut<N>::equals(const Node* p1, const Node* p2) {
return p1->x == p2->x && p1->y == p2->y;
}
// check if two segments intersect
template <typename N>
bool Earcut<N>::intersects(const Node* p1, const Node* q1, const Node* p2, const Node* q2) {
int o1 = sign(area(p1, q1, p2));
int o2 = sign(area(p1, q1, q2));
int o3 = sign(area(p2, q2, p1));
int o4 = sign(area(p2, q2, q1));
if (o1 != o2 && o3 != o4) return true; // general case
if (o1 == 0 && onSegment(p1, p2, q1)) return true; // p1, q1 and p2 are collinear and p2 lies on p1q1
if (o2 == 0 && onSegment(p1, q2, q1)) return true; // p1, q1 and q2 are collinear and q2 lies on p1q1
if (o3 == 0 && onSegment(p2, p1, q2)) return true; // p2, q2 and p1 are collinear and p1 lies on p2q2
if (o4 == 0 && onSegment(p2, q1, q2)) return true; // p2, q2 and q1 are collinear and q1 lies on p2q2
return false;
}
// for collinear points p, q, r, check if point q lies on segment pr
template <typename N>
bool Earcut<N>::onSegment(const Node* p, const Node* q, const Node* r) {
return q->x <= std::max<double>(p->x, r->x) &&
q->x >= std::min<double>(p->x, r->x) &&
q->y <= std::max<double>(p->y, r->y) &&
q->y >= std::min<double>(p->y, r->y);
}
template <typename N>
int Earcut<N>::sign(double val) {
return (0.0 < val) - (val < 0.0);
}
// check if a polygon diagonal intersects any polygon segments
template <typename N>
bool Earcut<N>::intersectsPolygon(const Node* a, const Node* b) {
const Node* p = a;
do {
if (p->i != a->i && p->next->i != a->i && p->i != b->i && p->next->i != b->i &&
intersects(p, p->next, a, b)) return true;
p = p->next;
} while (p != a);
return false;
}
// check if a polygon diagonal is locally inside the polygon
template <typename N>
bool Earcut<N>::locallyInside(const Node* a, const Node* b) {
return area(a->prev, a, a->next) < 0 ?
area(a, b, a->next) >= 0 && area(a, a->prev, b) >= 0 :
area(a, b, a->prev) < 0 || area(a, a->next, b) < 0;
}
// check if the middle Vertex of a polygon diagonal is inside the polygon
template <typename N>
bool Earcut<N>::middleInside(const Node* a, const Node* b) {
const Node* p = a;
bool inside = false;
double px = (a->x + b->x) / 2;
double py = (a->y + b->y) / 2;
do {
if (((p->y > py) != (p->next->y > py)) && p->next->y != p->y &&
(px < (p->next->x - p->x) * (py - p->y) / (p->next->y - p->y) + p->x))
inside = !inside;
p = p->next;
} while (p != a);
return inside;
}
// link two polygon vertices with a bridge; if the vertices belong to the same ring, it splits
// polygon into two; if one belongs to the outer ring and another to a hole, it merges it into a
// single ring
template <typename N>
typename Earcut<N>::Node*
Earcut<N>::splitPolygon(Node* a, Node* b) {
Node* a2 = nodes.construct(a->i, a->x, a->y);
Node* b2 = nodes.construct(b->i, b->x, b->y);
Node* an = a->next;
Node* bp = b->prev;
a->next = b;
b->prev = a;
a2->next = an;
an->prev = a2;
b2->next = a2;
a2->prev = b2;
bp->next = b2;
b2->prev = bp;
return b2;
}
// create a node and util::optionally link it with previous one (in a circular doubly linked list)
template <typename N> template <typename Point>
typename Earcut<N>::Node*
Earcut<N>::insertNode(std::size_t i, const Point& pt, Node* last) {
Node* p = nodes.construct(static_cast<N>(i), util::nth<0, Point>::get(pt), util::nth<1, Point>::get(pt));
if (!last) {
p->prev = p;
p->next = p;
} else {
assert(last);
p->next = last->next;
p->prev = last;
last->next->prev = p;
last->next = p;
}
return p;
}
template <typename N>
void Earcut<N>::removeNode(Node* p) {
p->next->prev = p->prev;
p->prev->next = p->next;
if (p->prevZ) p->prevZ->nextZ = p->nextZ;
if (p->nextZ) p->nextZ->prevZ = p->prevZ;
}
}
template <typename N = uint32_t, typename Polygon>
std::vector<N> earcut(const Polygon& poly) {
mapbox::detail::Earcut<N> earcut;
earcut(poly);
return std::move(earcut.indices);
}
}

276
samples/font.cpp Normal file
View file

@ -0,0 +1,276 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#if defined( _MSC_VER ) && !defined( _CRT_SECURE_NO_WARNINGS )
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "font.h"
#include "camera.h"
#include "shader.h"
#include "utility.h"
#define STBTT_STATIC
#define STB_TRUETYPE_IMPLEMENTATION
#include "stb_truetype.h"
//#define STB_IMAGE_WRITE_IMPLEMENTATION
//#include "stb_image_write.h"
#include "glad/glad.h"
#include <stdio.h>
#include <vector>
static const char* vertexShaderSrc = R"(
#version 330 core
layout (location = 0) in vec2 aPosition;
layout (location = 1) in vec2 aUV;
layout (location = 2) in vec4 aColor;
out vec4 color;
out vec2 uv;
uniform mat4 ProjectionMatrix;
void main()
{
gl_Position = ProjectionMatrix * vec4(aPosition, 0.0, 1.0);
color = aColor;
uv = aUV;
}
)";
static const char* fragmentShaderSrc = R"(
#version 330 core
in vec4 color;
in vec2 uv;
uniform sampler2D FontAtlas;
out vec4 fragColor;
void main()
{
fragColor = vec4(color.rgb, color.a * texture(FontAtlas, uv).r);
}
)";
Font::Font( const Camera* camera, float fontSize )
{
m_camera = camera;
m_fontSize = fontSize;
m_characters = (stbtt_bakedchar*)malloc( m_characterCount * sizeof( stbtt_bakedchar ) );
m_textureId = 0;
m_vaoId = 0;
m_vboId = 0;
m_programId = 0;
}
Font::~Font()
{
if ( m_programId != 0 )
{
DestroyShader( m_programId );
}
glDeleteBuffers( 1, &m_vboId );
glDeleteVertexArrays( 1, &m_vaoId );
if ( m_textureId != 0 )
{
glDeleteTextures( 1, &m_textureId );
}
free( m_characters );
}
void Font::AddText( float x, float y, b3HexColor color, const char* text )
{
if (text == nullptr)
{
return;
}
b3Vec3 position = { x, y, 0.0f };
RGBA8 c = MakeRGBA8( color );
int pw = m_atlasWidth;
int ph = m_atlasHeight;
int i = 0;
while ( text[i] != 0 )
{
int index = (int)text[i] - m_firstCharacter;
if ( 0 <= index && index < m_characterCount )
{
// 1=opengl
stbtt_aligned_quad q;
stbtt_GetBakedQuad( m_characters, pw, ph, index, &position.x, &position.y, &q, 1 );
Vertex v1 = { { q.x0, q.y0 }, { q.s0, q.t0 }, c };
Vertex v2 = { { q.x1, q.y0 }, { q.s1, q.t0 }, c };
Vertex v3 = { { q.x1, q.y1 }, { q.s1, q.t1 }, c };
Vertex v4 = { { q.x0, q.y1 }, { q.s0, q.t1 }, c };
m_vertices.push_back( v1 );
m_vertices.push_back( v3 );
m_vertices.push_back( v2 );
m_vertices.push_back( v1 );
m_vertices.push_back( v4 );
m_vertices.push_back( v3 );
}
i += 1;
}
}
void Font::Flush()
{
Matrix4 projectionMatrix = MakeOrthographicMatrix( 0.0f, m_camera->m_width, m_camera->m_height, 0.0f, -1.0f, 1.0f );
glUseProgram( m_programId );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glDisable( GL_DEPTH_TEST );
int slot = 0;
glActiveTexture( GL_TEXTURE0 + slot );
glBindTexture( GL_TEXTURE_2D, m_textureId );
glBindVertexArray( m_vaoId );
glBindBuffer( GL_ARRAY_BUFFER, m_vboId );
int textureUniform = glGetUniformLocation( m_programId, "FontAtlas" );
glUniform1i( textureUniform, slot );
int matrixUniform = glGetUniformLocation( m_programId, "ProjectionMatrix" );
glUniformMatrix4fv( matrixUniform, 1, GL_FALSE, &projectionMatrix.cx.x );
int totalVertexCount = int( m_vertices.size() );
int drawCallCount = ( totalVertexCount / m_vboCapacity ) + 1;
for ( int i = 0; i < drawCallCount; i++ )
{
const Vertex* data = m_vertices.data() + i * m_vboCapacity;
int vertexCount;
if ( i == drawCallCount - 1 )
{
vertexCount = totalVertexCount % m_vboCapacity;
}
else
{
vertexCount = m_vboCapacity;
}
// todo macOS optimization?
// glBufferData( GL_ARRAY_BUFFER, m_vboCapacity * sizeof( Vertex ), nullptr, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, vertexCount * sizeof( Vertex ), data );
glDrawArrays( GL_TRIANGLES, 0, vertexCount );
}
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );
glBindTexture( GL_TEXTURE_2D, 0 );
glDisable( GL_BLEND );
glEnable( GL_DEPTH_TEST );
CheckOpenGL();
m_vertices.clear();
}
bool Font::Initialize( const char* path )
{
// Create atlas
FILE* file = fopen( path, "rb" );
if ( file == nullptr )
{
assert( false );
return false;
}
int fileBufferCapacity = 1 << 20;
unsigned char* fileBuffer = (unsigned char*)malloc( fileBufferCapacity * sizeof( unsigned char ) );
fread( fileBuffer, 1, fileBufferCapacity, file );
int pw = m_atlasWidth;
int ph = m_atlasHeight;
unsigned char* tempBitmap = (unsigned char*)malloc( pw * ph * sizeof( unsigned char ) );
stbtt_BakeFontBitmap( fileBuffer, 0, m_fontSize, tempBitmap, pw, ph, m_firstCharacter, m_characterCount, m_characters );
glGenTextures( 1, &m_textureId );
glBindTexture( GL_TEXTURE_2D, m_textureId );
glTexImage2D( GL_TEXTURE_2D, 0, GL_R8, pw, ph, 0, GL_RED, GL_UNSIGNED_BYTE, tempBitmap );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
// stbi_write_png( "build/fontAtlas.png", pw, ph, 1, tempBitmap, pw );
fclose( file );
free( fileBuffer );
free( tempBitmap );
fileBuffer = nullptr;
tempBitmap = nullptr;
m_programId = CreateProgramFromStrings( vertexShaderSrc, fragmentShaderSrc );
if ( m_programId == 0 )
{
return false;
}
// Setting up the VAO and VBO
glGenBuffers( 1, &m_vboId );
glBindBuffer( GL_ARRAY_BUFFER, m_vboId );
glBufferData( GL_ARRAY_BUFFER, m_vboCapacity * sizeof( Vertex ), nullptr, GL_DYNAMIC_DRAW );
glGenVertexArrays( 1, &m_vaoId );
glBindVertexArray( m_vaoId );
// position attribute
glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, sizeof( Vertex ), (void*)offsetof( Vertex, position ) );
glEnableVertexAttribArray( 0 );
// uv attribute
glVertexAttribPointer( 1, 2, GL_FLOAT, GL_FALSE, sizeof( Vertex ), (void*)offsetof( Vertex, uv ) );
glEnableVertexAttribArray( 1 );
// color attribute will be expanded to floats using normalization
glVertexAttribPointer( 2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof( Vertex ), (void*)offsetof( Vertex, color ) );
glEnableVertexAttribArray( 2 );
glBindVertexArray( 0 );
CheckOpenGL();
return true;
}
// For testing
// Matrix4 MakeProjectionMatrix( float width, float height )
//{
// Matrix4 m;
// m.cx = { 2.0f / width, 0.0f, 0.0f, 0.0f };
// m.cy = { 0.0f, 2.0f / height, 0.0f, 0.0f };
// m.cz = { 0.0f, 0.0f, -1.0f, 0.0f };
// m.cw = { -1.0f, -1.0f, 0.0f, 1.0f };
// return m;
//}
Font* Font::Create( const Camera* camera, const char* path, int fontSize )
{
Font* font = new Font( camera, fontSize );
if ( font->Initialize( path ) == false )
{
delete font;
font = nullptr;
}
return font;
}

51
samples/font.h Normal file
View file

@ -0,0 +1,51 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "box3d/types.h"
#include "utility.h"
#include "stb_truetype.h"
#include <vector>
struct Camera;
struct Vertex
{
b3Vec2 position;
b3Vec2 uv;
RGBA8 color;
};
class Font
{
public:
static Font* Create( const Camera* camera, const char* path, int fontSize );
~Font();
void AddText( float x, float y, b3HexColor color, const char* text);
void Flush( );
private:
Font( const Camera* camera, float fontSize );
bool Initialize( const char* path );
static constexpr int m_firstCharacter = 32;
static constexpr int m_characterCount = 96;
static constexpr int m_atlasWidth = 512;
static constexpr int m_atlasHeight = 512;
// The number of vertices the vbo can hold
static constexpr int m_vboCapacity = 6 * 10000;
const Camera* m_camera;
float m_fontSize;
stbtt_bakedchar* m_characters;
std::vector<Vertex> m_vertices;
unsigned int m_textureId;
uint32_t m_vaoId;
uint32_t m_vboId;
uint32_t m_programId;
};

150
samples/geo_buffer.cpp Normal file
View file

@ -0,0 +1,150 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "geo_buffer.h"
#include <glad/glad.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
struct GeoBuffer
{
int32_t width, height;
uint32_t frameBufferId;
uint32_t positionId;
uint32_t normalId;
uint32_t albedoId;
uint32_t depthTextureId;
};
GeoBuffer* CreateGeoBuffer(int32_t width, int32_t height)
{
GeoBuffer* buffer = new GeoBuffer;
buffer->width = width;
buffer->height = height;
glGenFramebuffers(1, &buffer->frameBufferId);
glBindFramebuffer(GL_FRAMEBUFFER, buffer->frameBufferId);
// position color buffer
glGenTextures(1, &buffer->positionId);
glBindTexture(GL_TEXTURE_2D, buffer->positionId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer->positionId, 0);
// normal color buffer
glGenTextures(1, &buffer->normalId);
glBindTexture(GL_TEXTURE_2D, buffer->normalId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, buffer->normalId, 0);
// color + specular color buffer
glGenTextures(1, &buffer->albedoId);
glBindTexture(GL_TEXTURE_2D, buffer->albedoId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, buffer->albedoId, 0);
// tell OpenGL which color attachments we'll use (of this framebuffer) for rendering
const unsigned int attachments[3] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2};
glDrawBuffers(3, attachments);
// create and attach depth buffer as a texture
// Using a texture instead of a renderbuffer avoids a slow blit path on Apple Silicon
glGenTextures(1, &buffer->depthTextureId);
glBindTexture(GL_TEXTURE_2D, buffer->depthTextureId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, buffer->depthTextureId, 0);
// finally check if framebuffer is complete
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "Failed to initialize glad\n");
free(buffer);
return nullptr;
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return buffer;
}
void BindGeoBuffer(GeoBuffer* buffer)
{
glBindFramebuffer(GL_FRAMEBUFFER, buffer->frameBufferId);
// Clear each attachment to zero independently of the global glClearColor, so the
// deferred lighting pass can identify sky pixels by gPosition.xyz == 0.
static const GLfloat zero[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
glClearBufferfv(GL_COLOR, 0, zero);
glClearBufferfv(GL_COLOR, 1, zero);
glClearBufferfv(GL_COLOR, 2, zero);
glClear(GL_DEPTH_BUFFER_BIT);
}
#if 0
void tbBindGeoPositionNormal(GeoBuffer* buffer)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, buffer->positionId);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, buffer->normalId);
}
#endif
void BindGeoTextures(GeoBuffer* buffer)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, buffer->positionId);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, buffer->normalId);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, buffer->albedoId);
}
void BindGeoPosition(GeoBuffer* buffer, int textureUnit)
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(GL_TEXTURE_2D, buffer->positionId);
}
void BindGeoDepthTexture(GeoBuffer* buffer, int textureUnit)
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(GL_TEXTURE_2D, buffer->depthTextureId);
}
#if 0
void tbResize(GeoBuffer* buffer, int32_t width, int32_t height)
{
glBindTexture(GL_TEXTURE_2D, buffer->positionId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
glBindTexture(GL_TEXTURE_2D, buffer->normalId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, nullptr);
glBindTexture(GL_TEXTURE_2D, buffer->albedoId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
}
#endif
void DestroyGeoBuffer(GeoBuffer* buffer)
{
glDeleteFramebuffers(1, &buffer->frameBufferId);
glDeleteTextures(1, &buffer->positionId);
glDeleteTextures(1, &buffer->normalId);
glDeleteTextures(1, &buffer->albedoId);
glDeleteTextures(1, &buffer->depthTextureId);
delete buffer;
}

17
samples/geo_buffer.h Normal file
View file

@ -0,0 +1,17 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct GeoBuffer;
GeoBuffer* CreateGeoBuffer(int32_t width, int32_t height);
void DestroyGeoBuffer(GeoBuffer* buffer);
void BindGeoBuffer(GeoBuffer* buffer);
//void tbBindGeoPositionNormal(GeoBuffer* buffer);
void BindGeoTextures(GeoBuffer* buffer);
void BindGeoPosition(GeoBuffer* buffer, int textureUnit);
void BindGeoDepthTexture(GeoBuffer* buffer, int textureUnit);

156
samples/imconfig.h Normal file
View file

@ -0,0 +1,156 @@
//-----------------------------------------------------------------------------
// DEAR IMGUI COMPILE-TIME OPTIONS
// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
//-----------------------------------------------------------------------------
// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your
// modifications to it) B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own
// file without touching this template.
//-----------------------------------------------------------------------------
// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the
// imgui*.cpp files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on
// data structures. Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure
// layouts. Call IMGUI_CHECKVERSION() from your .cpp file to verify that the data structures your files are using are matching the
// ones imgui.cpp is using.
//-----------------------------------------------------------------------------
#pragma once
//---- Define assertion handler. Defaults to calling assert().
// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single
// statement.
// #define IM_ASSERT(_EXPR) MyAssert(_EXPR)
// #define IM_ASSERT(_EXPR) ((void)(_EXPR)) // Disable asserts
//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee
// backward nor forward ABI compatibility.
// - Windows DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() +
// SetAllocatorFunctions()
// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more
// details.
// #define IMGUI_API __declspec(dllexport) // MSVC Windows: DLL export
// #define IMGUI_API __declspec(dllimport) // MSVC Windows: DLL import
// #define IMGUI_API __attribute__((visibility("default"))) // GCC/Clang: override visibility when set is hidden
//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to clean your code of
//obsolete function/names. #define IMGUI_DISABLE_OBSOLETE_FUNCTIONS #define IMGUI_DISABLE_OBSOLETE_KEYIO // 1.87+ disable legacy
// io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This is automatically done by IMGUI_DISABLE_OBSOLETE_FUNCTIONS.
//---- Disable all of Dear ImGui or don't implement standard windows/tools.
// It is very strongly recommended to NOT disable the demo windows and debug tool during development. They are extremely useful in
// day to day work. Please read comments in imgui_demo.cpp.
// #define IMGUI_DISABLE // Disable everything: all headers and source files will be empty.
// #define IMGUI_DISABLE_DEMO_WINDOWS // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be
// empty. #define IMGUI_DISABLE_DEBUG_TOOLS // Disable metrics/debugger and other debug tools:
// ShowMetricsWindow(), ShowDebugLogWindow() and ShowIDStackToolWindow() will be empty.
//---- Don't implement some functions to reduce linkage requirements.
// #define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS // [Win32] Don't implement default clipboard handler. Won't use and
// link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a) #define
// IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with Visual Studio] Implement default IME handler
// (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW) #define
// IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS // [Win32] [Default with non-Visual Studio compilers] Don't implement default
// IME handler (won't require imm32.lib/.a) #define IMGUI_DISABLE_WIN32_FUNCTIONS // [Win32] Won't use and
// link with any Win32 function (clipboard, IME). #define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS // [OSX] Implement
// default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
// #define IMGUI_DISABLE_DEFAULT_SHELL_FUNCTIONS // Don't implement default platform_io.Platform_OpenInShellFn()
// handler (Win32: ShellExecute(), require shell32.lib/.a, Mac/Linux: use system("")). #define
// IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS // Don't implement ImFormatString/ImFormatStringV so you can implement them
// yourself (e.g. if you don't want to link with vsnprintf) #define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS // Don't
// implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself. #define
// IMGUI_DISABLE_FILE_FUNCTIONS // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and
// ImFileHandle at all (replace them with dummies) #define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS // Don't implement
// ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link
// with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function. #define IMGUI_DISABLE_DEFAULT_ALLOCATORS //
// Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call
// ImGui::SetAllocatorFunctions(). #define IMGUI_DISABLE_SSE // Disable use of SSE intrinsics even
// if available
//---- Enable Test Engine / Automation features.
// #define IMGUI_ENABLE_TEST_ENGINE // Enable imgui_test_engine hooks. Generally set automatically by
// include "imgui_te_config.h", see Test Engine for details.
//---- Include imgui_user.h at the end of imgui.h as a convenience
// May be convenient for some users to only explicitly include vanilla imgui.h and have extra stuff included.
// #define IMGUI_INCLUDE_IMGUI_USER_H
// #define IMGUI_USER_H_FILENAME "my_folder/my_imgui_user.h"
//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
// #define IMGUI_USE_BGRA_PACKED_COLOR
//---- Use 32-bit for ImWchar (default is 16-bit) to support Unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons,
//dingbats, symbols, shapes, ancient languages, etc...) #define IMGUI_USE_WCHAR32
//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
// #define IMGUI_STB_TRUETYPE_FILENAME "my_folder/stb_truetype.h"
// #define IMGUI_STB_RECT_PACK_FILENAME "my_folder/stb_rect_pack.h"
// #define IMGUI_STB_SPRINTF_FILENAME "my_folder/stb_sprintf.h" // only used if IMGUI_USE_STB_SPRINTF is defined.
// #define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
// #define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
// #define IMGUI_DISABLE_STB_SPRINTF_IMPLEMENTATION // only disabled if IMGUI_USE_STB_SPRINTF is defined.
//---- Use stb_sprintf.h for a faster implementation of vsnprintf instead of the one from libc (unless
//IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
// Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats
// provided by stb_sprintf.h.
// #define IMGUI_USE_STB_SPRINTF
//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
// Requires FreeType headers to be available in the include path. Requires program to be compiled with
// 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided). On Windows you may use vcpkg
// with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
#define IMGUI_ENABLE_FREETYPE
//---- Use FreeType+lunasvg library to render OpenType SVG fonts (SVGinOT)
// Requires lunasvg headers to be available in the include path + program to be linked with the lunasvg library (not provided).
// Only works in combination with IMGUI_ENABLE_FREETYPE.
// (implementation is based on Freetype's rsvg-port.c which is licensed under CeCILL-C Free Software License Agreement)
// #define IMGUI_ENABLE_FREETYPE_LUNASVG
//---- Use stb_truetype to build and rasterize the font atlas (default)
// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
// #define IMGUI_ENABLE_STB_TRUETYPE
//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
// This will be inlined as part of ImVec2 and ImVec4 class declarations.
/*
#define IM_VEC2_CLASS_EXTRA \
constexpr ImVec2(const MyVec2& f) : x(f.x), y(f.y) {} \
operator MyVec2() const { return MyVec2(x,y); }
#define IM_VEC4_CLASS_EXTRA \
constexpr ImVec4(const MyVec4& f) : x(f.x), y(f.y), z(f.z), w(f.w) {} \
operator MyVec4() const { return MyVec4(x,y,z,w); }
*/
//---- ...Or use Dear ImGui's own very basic math operators.
// #define IMGUI_DEFINE_MATH_OPERATORS
//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
// #define ImDrawIdx unsigned int
//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
// struct ImDrawList;
// struct ImDrawCmd;
// typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
// #define ImDrawCallback MyImDrawCallback
//---- Debug Tools: Macro to break in Debugger (we provide a default implementation of this in the codebase)
// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
// #define IM_DEBUG_BREAK IM_ASSERT(0)
// #define IM_DEBUG_BREAK __debugbreak()
//---- Debug Tools: Enable slower asserts
// #define IMGUI_DEBUG_PARANOID
//---- Tip: You can add extra functions within the ImGui:: namespace from anywhere (e.g. your own sources/header files)
/*
namespace ImGui
{
void MyFunction(const char* name, MyMatrix44* mtx);
}
*/

471
samples/jsmn.h Normal file
View file

@ -0,0 +1,471 @@
/*
* MIT License
*
* Copyright (c) 2010 Serge Zaitsev
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef JSMN_H
#define JSMN_H
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
#ifdef JSMN_STATIC
#define JSMN_API static
#else
#define JSMN_API extern
#endif
/**
* JSON type identifier. Basic types are:
* o Object
* o Array
* o String
* o Other primitive: number, boolean (true/false) or null
*/
typedef enum {
JSMN_UNDEFINED = 0,
JSMN_OBJECT = 1 << 0,
JSMN_ARRAY = 1 << 1,
JSMN_STRING = 1 << 2,
JSMN_PRIMITIVE = 1 << 3
} jsmntype_t;
enum jsmnerr {
/* Not enough tokens were provided */
JSMN_ERROR_NOMEM = -1,
/* Invalid character inside JSON string */
JSMN_ERROR_INVAL = -2,
/* The string is not a full JSON packet, more bytes expected */
JSMN_ERROR_PART = -3
};
/**
* JSON token description.
* type type (object, array, string etc.)
* start start position in JSON data string
* end end position in JSON data string
*/
typedef struct jsmntok {
jsmntype_t type;
int start;
int end;
int size;
#ifdef JSMN_PARENT_LINKS
int parent;
#endif
} jsmntok_t;
/**
* JSON parser. Contains an array of token blocks available. Also stores
* the string being parsed now and current position in that string.
*/
typedef struct jsmn_parser {
unsigned int pos; /* offset in the JSON string */
unsigned int toknext; /* next token to allocate */
int toksuper; /* superior token node, e.g. parent object or array */
} jsmn_parser;
/**
* Create JSON parser over an array of tokens
*/
JSMN_API void jsmn_init(jsmn_parser *parser);
/**
* Run JSON parser. It parses a JSON data string into and array of tokens, each
* describing
* a single JSON object.
*/
JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len,
jsmntok_t *tokens, const unsigned int num_tokens);
#ifndef JSMN_HEADER
/**
* Allocates a fresh unused token from the token pool.
*/
static jsmntok_t *jsmn_alloc_token(jsmn_parser *parser, jsmntok_t *tokens,
const size_t num_tokens) {
jsmntok_t *tok;
if (parser->toknext >= num_tokens) {
return NULL;
}
tok = &tokens[parser->toknext++];
tok->start = tok->end = -1;
tok->size = 0;
#ifdef JSMN_PARENT_LINKS
tok->parent = -1;
#endif
return tok;
}
/**
* Fills token type and boundaries.
*/
static void jsmn_fill_token(jsmntok_t *token, const jsmntype_t type,
const int start, const int end) {
token->type = type;
token->start = start;
token->end = end;
token->size = 0;
}
/**
* Fills next available token with JSON primitive.
*/
static int jsmn_parse_primitive(jsmn_parser *parser, const char *js,
const size_t len, jsmntok_t *tokens,
const size_t num_tokens) {
jsmntok_t *token;
int start;
start = parser->pos;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
switch (js[parser->pos]) {
#ifndef JSMN_STRICT
/* In strict mode primitive must be followed by "," or "}" or "]" */
case ':':
#endif
case '\t':
case '\r':
case '\n':
case ' ':
case ',':
case ']':
case '}':
goto found;
default:
/* to quiet a warning from gcc*/
break;
}
if (js[parser->pos] < 32 || js[parser->pos] >= 127) {
parser->pos = start;
return JSMN_ERROR_INVAL;
}
}
#ifdef JSMN_STRICT
/* In strict mode primitive must be followed by a comma/object/array */
parser->pos = start;
return JSMN_ERROR_PART;
#endif
found:
if (tokens == NULL) {
parser->pos--;
return 0;
}
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) {
parser->pos = start;
return JSMN_ERROR_NOMEM;
}
jsmn_fill_token(token, JSMN_PRIMITIVE, start, parser->pos);
#ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper;
#endif
parser->pos--;
return 0;
}
/**
* Fills next token with JSON string.
*/
static int jsmn_parse_string(jsmn_parser *parser, const char *js,
const size_t len, jsmntok_t *tokens,
const size_t num_tokens) {
jsmntok_t *token;
int start = parser->pos;
/* Skip starting quote */
parser->pos++;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c = js[parser->pos];
/* Quote: end of string */
if (c == '\"') {
if (tokens == NULL) {
return 0;
}
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) {
parser->pos = start;
return JSMN_ERROR_NOMEM;
}
jsmn_fill_token(token, JSMN_STRING, start + 1, parser->pos);
#ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper;
#endif
return 0;
}
/* Backslash: Quoted symbol expected */
if (c == '\\' && parser->pos + 1 < len) {
int i;
parser->pos++;
switch (js[parser->pos]) {
/* Allowed escaped symbols */
case '\"':
case '/':
case '\\':
case 'b':
case 'f':
case 'r':
case 'n':
case 't':
break;
/* Allows escaped symbol \uXXXX */
case 'u':
parser->pos++;
for (i = 0; i < 4 && parser->pos < len && js[parser->pos] != '\0';
i++) {
/* If it isn't a hex character we have an error */
if (!((js[parser->pos] >= 48 && js[parser->pos] <= 57) || /* 0-9 */
(js[parser->pos] >= 65 && js[parser->pos] <= 70) || /* A-F */
(js[parser->pos] >= 97 && js[parser->pos] <= 102))) { /* a-f */
parser->pos = start;
return JSMN_ERROR_INVAL;
}
parser->pos++;
}
parser->pos--;
break;
/* Unexpected symbol */
default:
parser->pos = start;
return JSMN_ERROR_INVAL;
}
}
}
parser->pos = start;
return JSMN_ERROR_PART;
}
/**
* Parse JSON string and fill tokens.
*/
JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len,
jsmntok_t *tokens, const unsigned int num_tokens) {
int r;
int i;
jsmntok_t *token;
int count = parser->toknext;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c;
jsmntype_t type;
c = js[parser->pos];
switch (c) {
case '{':
case '[':
count++;
if (tokens == NULL) {
break;
}
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) {
return JSMN_ERROR_NOMEM;
}
if (parser->toksuper != -1) {
jsmntok_t *t = &tokens[parser->toksuper];
#ifdef JSMN_STRICT
/* In strict mode an object or array can't become a key */
if (t->type == JSMN_OBJECT) {
return JSMN_ERROR_INVAL;
}
#endif
t->size++;
#ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper;
#endif
}
token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
token->start = parser->pos;
parser->toksuper = parser->toknext - 1;
break;
case '}':
case ']':
if (tokens == NULL) {
break;
}
type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
#ifdef JSMN_PARENT_LINKS
if (parser->toknext < 1) {
return JSMN_ERROR_INVAL;
}
token = &tokens[parser->toknext - 1];
for (;;) {
if (token->start != -1 && token->end == -1) {
if (token->type != type) {
return JSMN_ERROR_INVAL;
}
token->end = parser->pos + 1;
parser->toksuper = token->parent;
break;
}
if (token->parent == -1) {
if (token->type != type || parser->toksuper == -1) {
return JSMN_ERROR_INVAL;
}
break;
}
token = &tokens[token->parent];
}
#else
for (i = parser->toknext - 1; i >= 0; i--) {
token = &tokens[i];
if (token->start != -1 && token->end == -1) {
if (token->type != type) {
return JSMN_ERROR_INVAL;
}
parser->toksuper = -1;
token->end = parser->pos + 1;
break;
}
}
/* Error if unmatched closing bracket */
if (i == -1) {
return JSMN_ERROR_INVAL;
}
for (; i >= 0; i--) {
token = &tokens[i];
if (token->start != -1 && token->end == -1) {
parser->toksuper = i;
break;
}
}
#endif
break;
case '\"':
r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
if (r < 0) {
return r;
}
count++;
if (parser->toksuper != -1 && tokens != NULL) {
tokens[parser->toksuper].size++;
}
break;
case '\t':
case '\r':
case '\n':
case ' ':
break;
case ':':
parser->toksuper = parser->toknext - 1;
break;
case ',':
if (tokens != NULL && parser->toksuper != -1 &&
tokens[parser->toksuper].type != JSMN_ARRAY &&
tokens[parser->toksuper].type != JSMN_OBJECT) {
#ifdef JSMN_PARENT_LINKS
parser->toksuper = tokens[parser->toksuper].parent;
#else
for (i = parser->toknext - 1; i >= 0; i--) {
if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
if (tokens[i].start != -1 && tokens[i].end == -1) {
parser->toksuper = i;
break;
}
}
}
#endif
}
break;
#ifdef JSMN_STRICT
/* In strict mode primitives are: numbers and booleans */
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 't':
case 'f':
case 'n':
/* And they must not be keys of the object */
if (tokens != NULL && parser->toksuper != -1) {
const jsmntok_t *t = &tokens[parser->toksuper];
if (t->type == JSMN_OBJECT ||
(t->type == JSMN_STRING && t->size != 0)) {
return JSMN_ERROR_INVAL;
}
}
#else
/* In non-strict mode every unquoted value is a primitive */
default:
#endif
r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
if (r < 0) {
return r;
}
count++;
if (parser->toksuper != -1 && tokens != NULL) {
tokens[parser->toksuper].size++;
}
break;
#ifdef JSMN_STRICT
/* Unexpected char in strict mode */
default:
return JSMN_ERROR_INVAL;
#endif
}
}
if (tokens != NULL) {
for (i = parser->toknext - 1; i >= 0; i--) {
/* Unmatched opened object or array */
if (tokens[i].start != -1 && tokens[i].end == -1) {
return JSMN_ERROR_PART;
}
}
}
return count;
}
/**
* Creates a new parser based over a given buffer with an array of tokens
* available.
*/
JSMN_API void jsmn_init(jsmn_parser *parser) {
parser->pos = 0;
parser->toknext = 0;
parser->toksuper = -1;
}
#endif /* JSMN_HEADER */
#ifdef __cplusplus
}
#endif
#endif /* JSMN_H */

356
samples/main.cpp Normal file
View file

@ -0,0 +1,356 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
// CRT's memory leak detection
#if defined( _WIN64 )
#ifndef _CRTDBG_MAP_ALLOC
#define _CRTDBG_MAP_ALLOC
#endif
#include <crtdbg.h>
#endif
// clang-format off
#include "glad/glad.h"
#include "GLFW/glfw3.h"
// clang-format on
#include "font.h"
#include "imgui.h"
#include "imgui_impl_glfw.h"
#include "imgui_impl_opengl3.h"
#include "implot.h"
#include "renderer.h"
#include "sample.h"
#include "shader.h"
#include <stdio.h>
#ifdef TRACY_ENABLE
#include <client/TracyProfiler.hpp>
#endif
// imgui notes
// high-dpi support: https://github.com/ocornut/imgui/issues/5081
// linear blending:
// http://arkanis.de/weblog/2023-08-14-simple-good-quality-subpixel-text-rendering-in-opengl-with-stb-truetype-and-dual-source-blending
inline bool IsPowerOfTwo( int32_t x )
{
return ( x != 0 ) && ( ( x & ( x - 1 ) ) == 0 );
}
void* AllocFcn( int32_t size, int32_t alignment )
{
// Allocation must be a multiple of alignment or risk a seg fault
// https://en.cppreference.com/w/c/memory/aligned_alloc
assert( IsPowerOfTwo( alignment ) );
size_t sizeAligned = ( ( size - 1 ) | ( alignment - 1 ) ) + 1;
assert( ( sizeAligned & ( alignment - 1 ) ) == 0 );
#if defined( _MSC_VER )
void* ptr = _aligned_malloc( sizeAligned, alignment );
#else
void* ptr = aligned_alloc( alignment, sizeAligned );
#endif
assert( ptr != nullptr );
return ptr;
}
void FreeFcn( void* mem )
{
#if defined( _MSC_VER )
_aligned_free( mem );
#else
free( mem );
#endif
}
static int AssertHandler( const char* cond, const char* file, int line )
{
printf( "Box3D Assert: %s, %s, line %d\n", cond, file, line );
return 1;
}
#define WINDOW_TITLE "Box3D v0.1.0"
static int s_windowWidth = 1920;
static int s_windowHeight = 1080;
static int s_bufferWidth = s_windowWidth;
static int s_bufferHeight = s_windowHeight;
Font* s_font = nullptr;
SampleManager s_manager;
static void WindowSizeCallback( GLFWwindow* window, int width, int height )
{
s_windowWidth = width;
s_windowHeight = height;
glfwGetFramebufferSize( window, &s_bufferWidth, &s_bufferHeight );
s_manager.Resize( s_windowWidth, s_windowHeight, s_bufferWidth, s_bufferHeight );
}
static void ErrorCallback( int error, const char* description )
{
// Report GLFW error
printf( "GLFW Error %d: %s", error, description );
}
static void KeyCallback( GLFWwindow* window, int key, int scancode, int action, int mods )
{
ImGui_ImplGlfw_KeyCallback( window, key, scancode, action, mods );
if ( ImGui::GetIO().WantCaptureKeyboard )
{
return;
}
s_manager.Keyboard( key, action, mods );
}
void CharCallback( GLFWwindow* window, unsigned int character )
{
ImGui_ImplGlfw_CharCallback( window, character );
}
static void MouseButtonCallback( GLFWwindow* window, int button, int action, int modifiers )
{
ImGui_ImplGlfw_MouseButtonCallback( window, button, action, modifiers );
if ( ImGui::GetIO().WantCaptureMouse )
{
return;
}
double xd, yd;
glfwGetCursorPos( window, &xd, &yd );
b3Vec2 ps = { float( xd ), float( yd ) };
// Use the mouse to move things around.
if ( button == GLFW_MOUSE_BUTTON_1 )
{
if ( action == GLFW_PRESS )
{
s_manager.m_sample->MouseDown( ps, button, modifiers );
}
if ( action == GLFW_RELEASE )
{
s_manager.m_sample->MouseUp( ps, button );
}
}
}
static void MouseMotionCallback( GLFWwindow* window, double x, double y )
{
b3Vec2 ps = { float( x ), float( y ) };
ImGui_ImplGlfw_CursorPosCallback( window, ps.x, ps.y );
s_manager.m_sample->MouseMove( ps );
}
static void ScrollCallback( GLFWwindow* window, double deltaX, double deltaY )
{
ImGui_ImplGlfw_ScrollCallback( window, deltaX, deltaY );
}
static void Startup( GLFWwindow* window )
{
// Initialize font
s_font = Font::Create( &s_manager.m_context.camera, "data/fonts/Roboto-Medium.ttf", 18.0f );
if ( s_font == nullptr )
{
exit( EXIT_FAILURE );
}
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImPlot::CreateContext();
// Setup Platform/Renderer bindings
ImGui_ImplGlfw_InitForOpenGL( window, false );
ImGui_ImplOpenGL3_Init();
ImGuiIO& io = ImGui::GetIO();
io.Fonts->AddFontFromFileTTF( "data/fonts/Roboto-Medium.ttf", 16.0f );
// Initialize test manager
s_manager.Startup( window, s_windowWidth, s_windowHeight, s_bufferWidth, s_bufferHeight );
}
static void Render( GLFWwindow* window, float elapsedTime )
{
// Start the Dear ImGui frame
ImGui_ImplOpenGL3_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
glViewport( 0, 0, s_bufferWidth, s_bufferHeight );
glClearColor( 0.3f, 0.3f, 0.3f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
s_manager.Render( window, elapsedTime );
int y = s_windowHeight - 10;
int triangleIndex = s_manager.m_sample->m_triangleIndex;
uint64_t materialId = s_manager.m_sample->m_userMaterialId;
const Camera* camera = &s_manager.m_context.camera;
static char buffer[128];
snprintf( buffer, 128, "%.1f ms - step %d - camera (%g, %g, %g, %g) - tri %d - mat %d", 1000.0f * elapsedTime, s_manager.m_sample->m_stepCount,
camera->m_yaw, camera->m_pitch, camera->m_radius, camera->m_speed, triangleIndex, (int)materialId );
DrawText( 10, y, b3_colorLightGray, buffer );
if ( s_font != nullptr )
{
s_font->Flush();
}
//ImGui::ShowDemoWindow();
//ImPlot::ShowDemoWindow();
ImGui::Render();
ImGui_ImplOpenGL3_RenderDrawData( ImGui::GetDrawData() );
// Platform functions may have changed the current OpenGL context
glfwMakeContextCurrent( window );
glfwSwapBuffers( window );
}
static void Shutdown( GLFWwindow* window )
{
// Shutdown test manager
s_manager.Shutdown( window );
ImGui_ImplOpenGL3_Shutdown();
ImGui_ImplGlfw_Shutdown();
ImPlot::DestroyContext();
ImGui::DestroyContext();
delete s_font;
s_font = nullptr;
}
int main()
{
#if defined( _WIN64 )
// Enable run-time memory check for debug builds
// How to break at the leaking allocation, in the watch window enter this variable
// and set it to the allocation number in {}. Do this at the first line in main.
// https://learn.microsoft.com/en-us/troubleshoot/developer/visualstudio/cpp/libraries/use-rtbreakalloc-debug-memory-allocation
//_CrtSetBreakAlloc(1392);
_CrtSetReportMode( _CRT_WARN, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE );
_CrtSetReportFile( _CRT_WARN, _CRTDBG_FILE_STDOUT );
//_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
#ifdef TRACY_ENABLE
tracy::StartupProfiler();
#endif
b3SetAllocator( AllocFcn, FreeFcn );
b3SetAssertFcn( AssertHandler );
// Initialize GLFW
glfwSetErrorCallback( ErrorCallback );
if ( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
return -1;
}
// Create OpenGL window
glfwWindowHint( GLFW_CONTEXT_VERSION_MAJOR, 4 );
glfwWindowHint( GLFW_CONTEXT_VERSION_MINOR, 1 );
glfwWindowHint( GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );
// MSAA
glfwWindowHint( GLFW_SAMPLES, 4 );
GLFWwindow* window = glfwCreateWindow( s_windowWidth, s_windowHeight, WINDOW_TITLE, nullptr, nullptr );
if ( window == nullptr )
{
glfwTerminate();
return -1;
}
glfwGetWindowSize( window, &s_windowWidth, &s_windowHeight );
glfwGetFramebufferSize( window, &s_bufferWidth, &s_bufferHeight );
// Set window callbacks
glfwSetKeyCallback( window, KeyCallback );
glfwSetCharCallback( window, CharCallback );
glfwSetCursorPosCallback( window, MouseMotionCallback );
glfwSetMouseButtonCallback( window, MouseButtonCallback );
glfwSetScrollCallback( window, ScrollCallback );
glfwSetWindowSizeCallback( window, WindowSizeCallback );
// Make OpenGL context current
glfwMakeContextCurrent( window );
// This enables v-sync
// glfwSwapInterval( 1 );
// Setup GLAD bindings
if ( !gladLoadGL() )
{
fprintf( stderr, "Failed to initialize glad\n" );
glfwTerminate();
return -1;
}
{
const char* glVersionString = (const char*)glGetString( GL_VERSION );
const char* glslVersionString = (const char*)glGetString( GL_SHADING_LANGUAGE_VERSION );
printf( "OpenGL %s, GLSL %s\n", glVersionString, glslVersionString );
}
Startup( window );
glEnable( GL_DEPTH_TEST );
float frameTime = 0.0f;
while ( !glfwWindowShouldClose( window ) )
{
glfwPollEvents();
if (s_manager.m_context.minimized)
{
continue;
}
double time1 = glfwGetTime();
s_manager.Step();
Render( window, frameTime );
// Limit frame rate to 60Hz
double time2 = glfwGetTime();
double targetTime = time1 + 1.0 / 60.0;
while ( time2 < targetTime )
{
b3Yield();
time2 = glfwGetTime();
}
frameTime = float( time2 - time1 );
}
Shutdown( window );
glfwDestroyWindow( window );
glfwTerminate();
#ifdef TRACY_ENABLE
tracy::ShutdownProfiler();
#endif
#if defined( _WIN64 )
_CrtDumpMemoryLeaks();
#endif
return 0;
}

172
samples/mesh_loader.cpp Normal file
View file

@ -0,0 +1,172 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "mesh_loader.h"
#include "box3d/collision.h"
#include "box3d/math_functions.h"
#define TINYOBJLOADER_IMPLEMENTATION
#define TINYOBJLOADER_USE_MAPBOX_EARCUT
#include "tiny_obj_loader.h"
#include <iostream>
// Load a wavefront obj file using tiny obj loader and earcut for triangulation.
void LoadTempMesh( const char* path, TempMesh* tempMesh, float scale, bool zUp )
{
std::string inputFile = path;
tinyobj::ObjReaderConfig readerConfig;
readerConfig.triangulate = true;
readerConfig.mtl_search_path = "./"; // Path to material files
tinyobj::ObjReader reader;
if ( !reader.ParseFromFile( inputFile, readerConfig ) )
{
if ( !reader.Error().empty() )
{
std::cerr << "TinyObjReader: " << reader.Error();
}
exit( 1 );
}
if ( !reader.Warning().empty() )
{
std::cout << "TinyObjReader: " << reader.Warning();
}
const tinyobj::attrib_t& attrib = reader.GetAttrib();
const std::vector<tinyobj::shape_t>& shapes = reader.GetShapes();
// const std::vector<tinyobj::material_t>& objMaterials = reader.GetMaterials();
tempMesh->vertices.clear();
tempMesh->indices.clear();
tempMesh->materialIndices.clear();
int vertexCount = int( attrib.vertices.size() / 3 );
for ( int i = 0; i < vertexCount; i++ )
{
float x = scale * attrib.vertices[3 * i + 0];
float y = scale * attrib.vertices[3 * i + 1];
float z = scale * attrib.vertices[3 * i + 2];
b3Vec3 vertex = zUp ? b3Vec3{ y, z, x } : b3Vec3{ x, y, z };
tempMesh->vertices.push_back( vertex );
}
// Loop over shapes
int shapeCount = (int)shapes.size();
int materialIndex = 0;
for ( int shapeIndex = 0; shapeIndex < shapeCount; ++shapeIndex )
{
int faceCount = (int)shapes[shapeIndex].mesh.num_face_vertices.size();
int baseIndex = 0;
for ( int faceIndex = 0; faceIndex < faceCount; ++faceIndex )
{
int faceVertexCount = (int)shapes[shapeIndex].mesh.num_face_vertices[faceIndex];
// todo only triangles for now
if ( faceVertexCount != 3 )
{
baseIndex += faceVertexCount;
continue;
}
for ( int vertexIndex = 0; vertexIndex < faceVertexCount; ++vertexIndex )
{
tinyobj::index_t idx = shapes[shapeIndex].mesh.indices[baseIndex + vertexIndex];
tempMesh->indices.push_back( idx.vertex_index );
}
tempMesh->materialIndices.push_back( materialIndex );
materialIndex = ( materialIndex + 1 ) % 3;
baseIndex += faceVertexCount;
}
}
}
b3MeshData* CreateMeshData( const char* path, float scale, bool zUp, bool useMedianSplit, bool identifyConvexEdges, bool weldVertices )
{
std::string inputFile = path;
tinyobj::ObjReaderConfig readerConfig;
readerConfig.triangulate = true;
readerConfig.mtl_search_path = "./"; // Path to material files
tinyobj::ObjReader reader;
if ( !reader.ParseFromFile( inputFile, readerConfig ) )
{
if ( !reader.Error().empty() )
{
std::cerr << "TinyObjReader: " << reader.Error();
}
exit( 1 );
}
if ( !reader.Warning().empty() )
{
std::cout << "TinyObjReader: " << reader.Warning();
}
const tinyobj::attrib_t& attrib = reader.GetAttrib();
const std::vector<tinyobj::shape_t>& shapes = reader.GetShapes();
// const std::vector<tinyobj::material_t>& objMaterials = reader.GetMaterials();
TempMesh mesh;
int vertexCount = int( attrib.vertices.size() / 3 );
for ( int i = 0; i < vertexCount; i++ )
{
float x = scale * attrib.vertices[3 * i + 0];
float y = scale * attrib.vertices[3 * i + 1];
float z = scale * attrib.vertices[3 * i + 2];
b3Vec3 vertex = zUp ? b3Vec3{ y, z, x } : b3Vec3{ x, y, z };
mesh.vertices.push_back( vertex );
}
// Loop over shapes
int shapeCount = (int)shapes.size();
int materialIndex = 0;
for ( int shapeIndex = 0; shapeIndex < shapeCount; ++shapeIndex )
{
int faceCount = (int)shapes[shapeIndex].mesh.num_face_vertices.size();
int baseIndex = 0;
for ( int faceIndex = 0; faceIndex < faceCount; ++faceIndex )
{
int faceVertexCount = (int)shapes[shapeIndex].mesh.num_face_vertices[faceIndex];
// todo only triangles for now
if ( faceVertexCount != 3 )
{
baseIndex += faceVertexCount;
continue;
}
for ( int vertexIndex = 0; vertexIndex < faceVertexCount; ++vertexIndex )
{
tinyobj::index_t idx = shapes[shapeIndex].mesh.indices[baseIndex + vertexIndex];
mesh.indices.push_back( idx.vertex_index );
}
mesh.materialIndices.push_back( materialIndex );
materialIndex = ( materialIndex + 1 ) % 3;
baseIndex += faceVertexCount;
}
}
b3MeshDef def = {};
def.vertices = mesh.vertices.data();
def.vertexCount = (int)mesh.vertices.size();
def.indices = mesh.indices.data();
def.triangleCount = (int)mesh.indices.size() / 3;
def.materialIndices = mesh.materialIndices.data();
def.useMedianSplit = useMedianSplit;
def.identifyEdges = identifyConvexEdges;
def.weldVertices = weldVertices;
def.weldTolerance = 0.002f;
b3MeshData* meshData = b3CreateMesh( &def, nullptr, 0 );
return meshData;
}

21
samples/mesh_loader.h Normal file
View file

@ -0,0 +1,21 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "box3d/math_functions.h"
#include <vector>
struct b3MeshData;
b3MeshData* CreateMeshData( const char* path, float scale, bool zUp, bool useMedianSplit, bool identifyConvexEdges,
bool weldVertices );
struct TempMesh
{
std::vector<b3Vec3> vertices;
std::vector<int> indices;
std::vector<uint8_t> materialIndices;
};
void LoadTempMesh( const char* path, TempMesh* tempMesh, float scale, bool zUp );

783
samples/renderer.cpp Normal file
View file

@ -0,0 +1,783 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "renderer.h"
#include "camera.h"
#include "font.h"
#include "sample.h"
#include "scene.h"
#include "shader.h"
#include "box3d/collision.h"
#include "box3d/math_functions.h"
// clang-format off
#include <glad/glad.h>
#include <GLFW/glfw3.h>
// clang-format on
#include "box3d/box3d.h"
#include <algorithm>
#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include <vector>
struct PointData
{
b3Vec3 position;
float size;
RGBA8 rgba;
};
struct PointDraw
{
enum
{
e_batchSize = 2048
};
std::vector<PointData> Points;
uint32_t programId;
uint32_t vaoId;
uint32_t vboId;
int ProjectionUniform;
int ViewUniform;
int SizeUniform;
};
PointDraw* CreateDebugPoints()
{
const char* vs = R"(
#version 330 core
uniform mat4 projection;
uniform mat4 view;
layout(location = 0) in vec3 point;
layout(location = 1) in vec4 color;
layout(location = 2) in float size;
out vec4 f_color;
void main(void)
{
gl_Position = projection * view * vec4(point, 1.0f);
f_color = color;
gl_PointSize = size;
}
)";
const char* fs = R"(
#version 330 core
in vec4 f_color;
out vec4 color;
void main(void)
{
color = f_color;
}
)";
PointDraw* draw = new PointDraw;
draw->programId = CreateProgramFromStrings( vs, fs );
draw->ProjectionUniform = GetUniformLocation( draw->programId, "projection" );
draw->ViewUniform = GetUniformLocation( draw->programId, "view" );
constexpr int vertexAttribute = 0;
constexpr int sizeAttribute = 1;
constexpr int colorAttribute = 2;
// Generate
glGenVertexArrays( 1, &draw->vaoId );
glGenBuffers( 1, &draw->vboId );
glBindVertexArray( draw->vaoId );
glEnableVertexAttribArray( vertexAttribute );
glEnableVertexAttribArray( sizeAttribute );
glEnableVertexAttribArray( colorAttribute );
// Vertex buffer
glBindBuffer( GL_ARRAY_BUFFER, draw->vboId );
glBufferData( GL_ARRAY_BUFFER, PointDraw::e_batchSize * sizeof( PointData ), nullptr, GL_DYNAMIC_DRAW );
glVertexAttribPointer( vertexAttribute, 3, GL_FLOAT, GL_FALSE, sizeof( PointData ), (void*)offsetof( PointData, position ) );
glVertexAttribPointer( colorAttribute, 4, GL_FLOAT, GL_FALSE, sizeof( PointData ), (void*)offsetof( PointData, size ) );
// save bandwidth by expanding color to floats in the shader
glVertexAttribPointer( sizeAttribute, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof( PointData ), (void*)offsetof( PointData, rgba ) );
CheckOpenGL();
// Cleanup
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );
return draw;
}
void DestroyDebugPoints( PointDraw* draw )
{
if ( draw->vaoId )
{
glDeleteVertexArrays( 1, &draw->vaoId );
glDeleteBuffers( 1, &draw->vboId );
draw->vaoId = 0;
}
DestroyShader( draw->programId );
draw->programId = 0;
delete draw;
}
void AddPoint( PointDraw* draw, b3Vec3 point, float size, b3HexColor color )
{
draw->Points.push_back( { point, size, MakeRGBA8( color ) } );
}
void FlushPoints( PointDraw* draw, Camera* camera )
{
if ( draw->Points.size() == 0 )
{
return;
}
glDepthFunc( GL_LEQUAL );
glUseProgram( draw->programId );
Matrix4 projection = camera->GetProjectionMatrix();
Matrix4 view = camera->GetViewMatrix();
SetUniformMatrix4( draw->ProjectionUniform, projection );
SetUniformMatrix4( draw->ViewUniform, view );
glBindVertexArray( draw->vaoId );
int totalCount = (int)draw->Points.size();
PointData* points = draw->Points.data();
while ( totalCount > 0 )
{
int count = b3MinInt( totalCount, PointDraw::e_batchSize );
glBindBuffer( GL_ARRAY_BUFFER, draw->vboId );
// todo macOS optimization?
// glBufferData( GL_ARRAY_BUFFER, PointDraw::e_batchSize * sizeof( PointData ), nullptr, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, count * sizeof( PointData ), points );
glEnable( GL_PROGRAM_POINT_SIZE );
glDrawArrays( GL_POINTS, 0, count );
glDisable( GL_PROGRAM_POINT_SIZE );
points += count;
totalCount -= count;
}
CheckOpenGL();
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );
glUseProgram( 0 );
draw->Points.clear();
}
struct LinePoint
{
b3Vec3 position;
RGBA8 rgba;
};
struct LineDraw
{
enum
{
e_batchSize = 2048
};
std::vector<LinePoint> points;
uint32_t programId;
uint32_t VaoId;
uint32_t VboId;
int ProjectionUniform;
int ViewUniform;
};
LineDraw* CreateDebugLines()
{
const char* vs = R"(
#version 330 core
uniform mat4 projection;
uniform mat4 view;
layout(location = 0) in vec3 point;
layout(location = 1) in vec4 color;
out vec4 f_color;
void main(void)
{
gl_Position = projection * view * vec4(point, 1.0f);
f_color = color;
}
)";
const char* fs = R"(
#version 330 core
in vec4 f_color;
out vec4 color;
void main(void)
{
color = f_color;
}
)";
LineDraw* draw = new LineDraw;
draw->programId = CreateProgramFromStrings( vs, fs );
draw->ProjectionUniform = GetUniformLocation( draw->programId, "projection" );
draw->ViewUniform = GetUniformLocation( draw->programId, "view" );
constexpr int vertexAttribute = 0;
constexpr int colorAttribute = 1;
// Generate
glGenVertexArrays( 1, &draw->VaoId );
glGenBuffers( 1, &draw->VboId );
glBindVertexArray( draw->VaoId );
glEnableVertexAttribArray( vertexAttribute );
glEnableVertexAttribArray( colorAttribute );
// Vertex buffer
glBindBuffer( GL_ARRAY_BUFFER, draw->VboId );
glBufferData( GL_ARRAY_BUFFER, LineDraw::e_batchSize * sizeof( LinePoint ), nullptr, GL_DYNAMIC_DRAW );
glVertexAttribPointer( vertexAttribute, 3, GL_FLOAT, GL_FALSE, sizeof( LinePoint ),
(void*)offsetof( LinePoint, position ) );
// save bandwidth by expanding color to floats in the shader
glVertexAttribPointer( colorAttribute, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof( LinePoint ),
(void*)offsetof( LinePoint, rgba ) );
CheckOpenGL();
// Cleanup
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );
return draw;
}
void DestroyDebugLines( LineDraw* draw )
{
if ( draw->VaoId )
{
glDeleteVertexArrays( 1, &draw->VaoId );
glDeleteBuffers( 1, &draw->VboId );
draw->VaoId = 0;
}
DestroyShader( draw->programId );
draw->programId = 0;
delete draw;
}
void AddLine( LineDraw* draw, b3Vec3 point1, b3Vec3 point2, b3HexColor color )
{
draw->points.push_back( { point1, MakeRGBA8( color ) } );
draw->points.push_back( { point2, MakeRGBA8( color ) } );
}
void FlushLines( LineDraw* draw, Camera* camera )
{
if ( draw->points.size() == 0 )
{
return;
}
// WARNING: very slow
//glEnable( GL_LINE_SMOOTH );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glUseProgram( draw->programId );
Matrix4 projection = camera->GetProjectionMatrix();
Matrix4 view = camera->GetViewMatrix();
SetUniformMatrix4( draw->ProjectionUniform, projection );
SetUniformMatrix4( draw->ViewUniform, view );
glBindVertexArray( draw->VaoId );
glBindBuffer( GL_ARRAY_BUFFER, draw->VboId );
int count = (int)draw->points.size();
LinePoint* points = draw->points.data();
while ( count > 0 )
{
int batchCount = b3MinInt( count, LineDraw::e_batchSize );
// todo buffer orphaning for macOS?
// glBufferData( GL_ARRAY_BUFFER, LineDraw::e_batchSize * sizeof( LinePoint ), nullptr, GL_DYNAMIC_DRAW );
glBufferSubData( GL_ARRAY_BUFFER, 0, batchCount * sizeof( LinePoint ), points );
glDrawArrays( GL_LINES, 0, batchCount );
points += batchCount;
count -= batchCount;
}
CheckOpenGL();
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glBindVertexArray( 0 );
glUseProgram( 0 );
glDisable( GL_BLEND );
draw->points.clear();
}
static DebugShape* CreateDebugSphere( const b3Sphere* sphere )
{
DebugShape* s = new DebugShape;
s->type = DebugShapeType::sphere;
s->sphere.center = sphere->center;
s->sphere.radius = sphere->radius;
return s;
}
static DebugShape* CreateDebugCapsule( const b3Capsule* capsule, Arena arena )
{
DebugShape* s = new DebugShape;
s->type = DebugShapeType::capsule;
s->capsule.center1 = capsule->center1;
s->capsule.center2 = capsule->center2;
s->capsule.radius = capsule->radius;
return s;
}
static DebugShape* CreateDebugCompound(Scene* scene, const b3Compound* compound, Arena arena )
{
DebugShape* s = new DebugShape;
memset( s, 0, sizeof( DebugShape ) );
s->type = DebugShapeType::compound;
// Capsules
s->compound.capsuleCount = compound->capsuleCount;
DebugCapsule* debugCapsules = new DebugCapsule[s->compound.capsuleCount];
for (int i = 0; i < s->compound.capsuleCount; ++i)
{
b3CompoundCapsule element = b3GetCompoundCapsule( compound, i );
debugCapsules[i].center1 = element.capsule.center1;
debugCapsules[i].center2 = element.capsule.center2;
debugCapsules[i].radius = element.capsule.radius;
}
s->compound.capsules = debugCapsules;
// Hulls
s->compound.hullCount = compound->hullCount;
DebugHull* debugHulls = new DebugHull[s->compound.hullCount];
for (int i = 0; i < s->compound.hullCount; ++i)
{
b3CompoundHull hull = b3GetCompoundHull( compound, i );
uint32_t id = CreateInstanceHull( scene, hull.hull, arena );
debugHulls[i].transform = hull.transform;
debugHulls[i].id = id;
}
s->compound.hulls = debugHulls;
// Meshes
s->compound.meshCount = compound->meshCount;
DebugMesh* debugMeshes = new DebugMesh[s->compound.meshCount];
for ( int i = 0; i < s->compound.meshCount; ++i )
{
b3CompoundMesh mesh = b3GetCompoundMesh( compound, i );
uint32_t id = CreateInstanceMesh( scene, mesh.meshData, arena );
debugMeshes[i].transform = mesh.transform;
debugMeshes[i].scale = mesh.scale;
debugMeshes[i].id = id;
}
s->compound.meshes = debugMeshes;
// Spheres
s->compound.sphereCount = compound->sphereCount;
DebugSphere* debugSpheres = new DebugSphere[s->compound.sphereCount];
for (int i = 0; i < s->compound.sphereCount; ++i)
{
b3CompoundSphere sphere = b3GetCompoundSphere( compound, i );
debugSpheres[i].center = sphere.sphere.center;
debugSpheres[i].radius = sphere.sphere.radius;
}
s->compound.spheres = debugSpheres;
return s;
}
static void DestroyDebugCompound( DebugCompound* compound )
{
delete[] compound->capsules;
delete[] compound->hulls;
delete[] compound->meshes;
delete[] compound->spheres;
}
static DebugShape* CreateDebugHull( Scene* scene, const b3Hull* hull, Arena arena )
{
uint32_t id = CreateInstanceHull( scene, hull, arena );
DebugShape* s = new DebugShape;
s->type = DebugShapeType::hull;
s->hull.id = id;
s->hull.transform = b3Transform_identity;
return s;
}
static DebugShape* CreateDebugMesh( Scene* scene, const b3Mesh* mesh, Arena arena )
{
uint32_t id = CreateInstanceMesh( scene, mesh->data, arena );
DebugShape* s = new DebugShape;
s->type = DebugShapeType::mesh;
s->mesh.id = id;
s->mesh.transform = b3Transform_identity;
s->mesh.scale = mesh->scale;
return s;
}
static DebugShape* CreateDebugHeightField( Scene* scene, const b3HeightField* heightField, Arena arena )
{
uint32_t id = CreateInstanceHeightField( scene, heightField, arena );
DebugShape* s = new DebugShape;
s->type = DebugShapeType::heightField;
s->heightField.id = id;
return s;
}
void* CreateDebugShape( const b3DebugShape* debugShape, void* context )
{
SampleContext* sampleContext = static_cast<SampleContext*>( context );
DebugShape* s = nullptr;
switch ( debugShape->type )
{
case b3_capsuleShape:
s = CreateDebugCapsule( debugShape->capsule, sampleContext->arena );
break;
case b3_compoundShape:
s = CreateDebugCompound( sampleContext->scene, debugShape->compound, sampleContext->arena );
break;
case b3_hullShape:
s = CreateDebugHull( sampleContext->scene, debugShape->hull, sampleContext->arena );
break;
case b3_meshShape:
s = CreateDebugMesh( sampleContext->scene, debugShape->mesh, sampleContext->arena );
break;
case b3_heightShape:
s = CreateDebugHeightField( sampleContext->scene, debugShape->heightField, sampleContext->arena );
break;
case b3_sphereShape:
s = CreateDebugSphere( debugShape->sphere );
break;
default:
break;
}
if (s != nullptr)
{
b3BodyId bodyId = b3Shape_GetBody( debugShape->shapeId );
s->bodyType = b3Body_GetType( bodyId );
}
else
{
s->bodyType = b3_staticBody;
}
return s;
}
void DestroyDebugShape( void* userShape, void* context )
{
DebugShape* s = static_cast<DebugShape*>( userShape );
switch ( s->type )
{
case DebugShapeType::compound:
DestroyDebugCompound( &s->compound );
break;
default:
break;
}
delete s;
}
extern Font* s_font;
void DrawText( int x, int y, b3HexColor color, const char* text )
{
s_font->AddText( x, y, color, text );
}
void DrawFormat( int x, int y, b3HexColor color, const char* format, ... )
{
va_list args;
va_start( args, format );
char text[512];
vsnprintf( text, sizeof( text ), format, args );
DrawText( x, y, color, text );
va_end( args );
}
void DrawWorldString( Camera* camera, b3Vec3 point, b3HexColor color, const char* format, ... )
{
float x, y;
bool valid = camera->WorldToScreen( x, y, point );
if ( valid )
{
va_list args;
va_start( args, format );
char text[512];
vsnprintf( text, sizeof( text ), format, args );
DrawText( (int)x, (int)y, color, text );
va_end( args );
}
}
static void DrawDisc( Scene* scene, b3Vec3 center, b3Vec3 normal, float radius, b3HexColor color )
{
b3Vec3 tangent1 = b3Perp( normal );
b3Vec3 tangent2 = b3Cross( normal, tangent1 );
int n = 9;
float delta = B3_PI / (float)n;
b3CosSin cs = b3ComputeCosSin( delta );
float x1 = radius, y1 = 0.0f;
b3Vec3 vertex1 = center + x1 * tangent1 + y1 * tangent2;
for ( int i = 0; i < 2 * n; ++i )
{
float x2 = cs.cosine * x1 - cs.sine * y1;
float y2 = cs.sine * x1 + cs.cosine * y1;
b3Vec3 vertex2 = center + x2 * tangent1 + y2 * tangent2;
DrawLine( scene, vertex1, vertex2, color );
x1 = x2;
y1 = y2;
vertex1 = vertex2;
}
}
static void DrawArc( Scene* scene, b3Vec3 center, b3Vec3 normal, float radius, b3Vec3 start, float maxAngle, b3HexColor color )
{
b3Vec3 tangent1 = b3Normalize( start );
b3Vec3 tangent2 = b3Cross( normal, tangent1 );
for ( float angle = 0.0f; angle < maxAngle; angle += 5.0f )
{
float alpha1 = B3_DEG_TO_RAD * ( angle + 0.0f );
b3Vec3 vertex1 = center + b3Cos( alpha1 ) * radius * tangent1 + b3Sin( alpha1 ) * radius * tangent2;
float alpha2 = B3_DEG_TO_RAD * ( angle + 5.0f );
b3Vec3 vertex2 = center + b3Cos( alpha2 ) * radius * tangent1 + b3Sin( alpha2 ) * radius * tangent2;
DrawLine( scene, vertex1, vertex2, color );
}
}
void DrawGrid( Scene* scene, int size )
{
float grid = float( size );
for ( int x = -size; x <= size; ++x )
{
if ( x == 0 )
{
DrawLine( scene, { 0.0f, 0.0f, -grid }, { 0.0f, 0.0f, 0.0f }, b3_colorLightGray );
DrawLine( scene, { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, grid }, b3_colorBlue );
}
else if ( ( x % 10 ) == 0 )
{
DrawLine( scene, { float( x ), 0.0f, -grid }, { float( x ), 0.0f, grid }, b3_colorDarkGray );
}
else
{
DrawLine( scene, { float( x ), 0.0f, -grid }, { float( x ), 0.0f, grid }, b3_colorGray );
}
}
for ( int z = -size; z <= size; ++z )
{
if ( z == 0 )
{
DrawLine( scene, { -grid, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }, b3_colorLightGray );
DrawLine( scene, { 0.0f, 0.0f, 0.0f }, { grid, 0.0f, 0.0f }, b3_colorRed );
}
else if ( ( z % 10 ) == 0 )
{
DrawLine( scene, { -grid, 0.0f, float( z ) }, { grid, 0.0f, float( z ) }, b3_colorDarkGray );
}
else
{
DrawLine( scene, { -grid, 0.0f, float( z ) }, { grid, 0.0f, float( z ) }, b3_colorGray );
}
}
}
void DrawCross( Scene* scene, b3Vec3 center, float radius, b3HexColor color )
{
DrawLine( scene, center - b3Vec3{ radius, 0.0, 0.0f }, center + b3Vec3{ radius, 0.0f, 0.0f }, color );
DrawLine( scene, center - b3Vec3{ 0.0f, radius, 0.0f }, center + b3Vec3{ 0.0f, radius, 0.0f }, color );
DrawLine( scene, center - b3Vec3{ 0.0f, 0.0f, radius }, center + b3Vec3{ 0.0f, 0.0f, radius }, color );
}
void DrawSphere( Scene* scene, const b3Transform& transform, const b3Sphere& sphere, b3HexColor color )
{
b3Vec3 center = b3TransformPoint( transform, sphere.center );
float radius = sphere.radius;
b3Vec3 axisX = b3RotateVector( transform.q, { 1.0f, 0.0f, 0.0f } );
b3Vec3 axisY = b3RotateVector( transform.q, { 0.0f, 1.0f, 0.0f } );
b3Vec3 axisZ = b3RotateVector( transform.q, { 0.0f, 0.0f, 1.0f } );
DrawDisc( scene, center, axisX, radius, color );
DrawDisc( scene, center, axisY, radius, color );
DrawDisc( scene, center, axisZ, radius, color );
}
void DrawCapsule( Scene* scene, const b3Transform& transform, const b3Capsule& capsule, b3HexColor color )
{
b3Vec3 center1 = b3TransformPoint( transform, capsule.center1 );
b3Vec3 center2 = b3TransformPoint( transform, capsule.center2 );
float radius = capsule.radius;
b3Vec3 normal = b3Normalize( center2 - center1 );
b3Vec3 tangent1 = b3Perp( normal );
b3Vec3 tangent2 = b3Cross( normal, tangent1 );
DrawLine( scene, center1 + radius * tangent1, center2 + radius * tangent1, color );
DrawLine( scene, center1 + radius * tangent2, center2 + radius * tangent2, color );
DrawLine( scene, center1 - radius * tangent1, center2 - radius * tangent1, color );
DrawLine( scene, center1 - radius * tangent2, center2 - radius * tangent2, color );
DrawArc( scene, center1, -tangent1, radius, tangent2, 180.0f, color );
DrawArc( scene, center1, tangent2, radius, tangent1, 180.0f, color );
DrawArc( scene, center2, tangent1, radius, tangent2, 180.0f, color );
DrawArc( scene, center2, -tangent2, radius, tangent1, 180.0f, color );
DrawDisc( scene, center1, normal, radius, color );
DrawDisc( scene, center2, normal, radius, color );
}
void DrawHull( Scene* scene, const b3Transform& transform, const b3Hull* hull, b3HexColor color, bool drawNormals )
{
const b3HullHalfEdge* edges = b3GetHullEdges( hull );
const b3Vec3* points = b3GetHullPoints( hull );
for ( int edgeIndex = 0; edgeIndex < hull->edgeCount; edgeIndex += 2 )
{
const b3HullHalfEdge* edge = edges + edgeIndex + 0;
const b3HullHalfEdge* twin = edges + edgeIndex + 1;
b3Vec3 vertex1 = b3TransformPoint( transform, points[edge->origin] );
b3Vec3 vertex2 = b3TransformPoint( transform, points[twin->origin] );
DrawLine( scene, vertex1, vertex2, color );
}
if (drawNormals)
{
const b3HullFace* faces = b3GetHullFaces( hull );
const b3Plane* planes = b3GetHullPlanes( hull );
int faceCount = hull->faceCount;
for (int i = 0; i < faceCount; ++i)
{
uint8_t startEdgeIndex = faces[i].edge;
uint8_t edgeIndex = startEdgeIndex;
int count = 0;
b3Vec3 p1 = b3Vec3_zero;
do
{
const b3HullHalfEdge* edge = edges + edgeIndex;
p1 += points[edge->origin];
count += 1;
edgeIndex = edge->next;
}
while ( edgeIndex != startEdgeIndex );
assert( count > 0 );
p1 = b3MulSV( 1.0f / count, p1 );
b3Vec3 p2 = p1 + 0.2f * planes[i].normal;
p1 = b3TransformPoint( transform, p1 );
p2 = b3TransformPoint( transform, p2 );
DrawLine( scene, p1, p2, b3_colorWhite );
DrawPoint( scene, p1, 6.0f, b3_colorLime );
}
}
}
void DrawEllipsoid( Scene* scene, const b3Transform& transform, b3Vec3 radius, b3HexColor color )
{
b3Vec3 ex = { 1.0f, 0.0, 0.0f };
b3Vec3 ey = { 0.0f, 1.0, 0.0f };
b3Vec3 ez = { 0.0f, 0.0, 1.0f };
for ( float angle = 0.0f; angle < 360.0f; angle += 5.0f )
{
float alpha1 = B3_DEG_TO_RAD * ( angle + 0.0f );
float alpha2 = B3_DEG_TO_RAD * ( angle + 5.0f );
// XY - Plane
{
b3Vec3 vertex1 = radius * ( b3Cos( alpha1 ) * ex + b3Sin( alpha1 ) * ey );
b3Vec3 vertex2 = radius * ( b3Cos( alpha2 ) * ex + b3Sin( alpha2 ) * ey );
vertex1 = b3TransformPoint( transform, vertex1 );
vertex2 = b3TransformPoint( transform, vertex2 );
DrawLine( scene, vertex1, vertex2, color );
}
// XZ - Plane
{
b3Vec3 vertex1 = radius * ( b3Cos( alpha1 ) * ex + b3Sin( alpha1 ) * ez );
b3Vec3 vertex2 = radius * ( b3Cos( alpha2 ) * ex + b3Sin( alpha2 ) * ez );
vertex1 = b3TransformPoint( transform, vertex1 );
vertex2 = b3TransformPoint( transform, vertex2 );
DrawLine( scene, vertex1, vertex2, color );
}
// YZ - Plane
{
b3Vec3 vertex1 = radius * ( b3Cos( alpha1 ) * ex + b3Sin( alpha1 ) * ez );
b3Vec3 vertex2 = radius * ( b3Cos( alpha2 ) * ey + b3Sin( alpha2 ) * ez );
vertex1 = b3TransformPoint( transform, vertex1 );
vertex2 = b3TransformPoint( transform, vertex2 );
DrawLine( scene, vertex1, vertex2, color );
}
}
}
void DrawTransform( Scene* scene, const b3Transform& transform, float length )
{
b3Vec3 p = transform.p;
b3Vec3 ax = b3RotateVector( transform.q, { 1.0f, 0.0f, 0.0f } );
b3Vec3 ay = b3RotateVector( transform.q, { 0.0f, 1.0f, 0.0f } );
b3Vec3 az = b3RotateVector( transform.q, { 0.0f, 0.0f, 1.0f } );
DrawLine( scene, p, p + length * ax, b3_colorRed );
DrawLine( scene, p, p + length * ay, b3_colorGreen );
DrawLine( scene, p, p + length * az, b3_colorBlue );
}

44
samples/renderer.h Normal file
View file

@ -0,0 +1,44 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "utility.h"
struct b3Capsule;
struct b3DebugShape;
struct b3Hull;
struct b3MeshData;
struct b3Sphere;
struct Camera;
struct LineDraw;
struct PointDraw;
struct Scene;
void* CreateDebugShape( const b3DebugShape* debugShape, void* context );
void DestroyDebugShape( void* userShape, void* userContext );
void DrawText( int x, int y, b3HexColor color, const char* text );
void DrawFormat( int x, int y, b3HexColor color, const char* format, ... );
void DrawWorldString( Camera* camera, b3Vec3 point, b3HexColor color, const char* format, ... );
void DrawGrid( Scene* scene, int size );
void DrawCross( Scene* scene, b3Vec3 center, float radius, b3HexColor color );
void DrawSphere( Scene* scene, const b3Transform& transform, const b3Sphere& sphere, b3HexColor color );
void DrawCapsule( Scene* scene, const b3Transform& transform, const b3Capsule& capsule, b3HexColor color );
void DrawHull( Scene* scene, const b3Transform& transform, const b3Hull* hull, b3HexColor color, bool drawNormals );
void DrawEllipsoid( Scene* scene, const b3Transform& transform, b3Vec3 radius, b3HexColor color );
void DrawTransform( Scene* scene, const b3Transform& transform, float length );
// Debug points
PointDraw* CreateDebugPoints();
void DestroyDebugPoints( PointDraw* draw );
void AddPoint( PointDraw* draw, b3Vec3 point, float size, b3HexColor color );
void FlushPoints( PointDraw* draw, Camera* camera );
// Debug lines
LineDraw* CreateDebugLines();
void DestroyDebugLines( LineDraw* draw );
void AddLine( LineDraw* draw, b3Vec3 point1, b3Vec3 point2, b3HexColor color );
void FlushLines( LineDraw* draw, Camera* camera );

1757
samples/sample.cpp Normal file

File diff suppressed because it is too large Load diff

215
samples/sample.h Normal file
View file

@ -0,0 +1,215 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "camera.h"
class Font;
struct MouseEvent;
struct MouseMoveEvent;
struct MouseWheelEvent;
struct Scene;
struct GLFWwindow;
struct SampleContext
{
void Save();
void Load();
GLFWwindow* window = nullptr;
Camera camera;
Arena arena;
Scene* scene = nullptr;
bool minimized = false;
class Sample* sample = nullptr;
b3Capacity capacity;
b3DebugDraw debugDraw;
int windowWidth = 1920;
int windowHeight = 1080;
// Used to shift the origin and test round-off problems
b3Vec3 origin = b3Vec3_zero;
float hertz = 60.0f;
float recycleDistance = 0.05f;
int subStepCount = 4;
int workerCount = 1;
bool transparentDynamic = false;
bool drawCounters = false;
bool drawProfile = false;
bool frameTime = false;
bool transparent = false;
bool enableWarmStarting = true;
bool enableContinuous = true;
bool enableSleep = true;
bool pause = false;
int singleStep = 0;
bool restart = false;
int sampleIndex = 0;
};
class Sample
{
public:
explicit Sample( SampleContext* context );
virtual ~Sample();
void CreateWorld( b3Capacity* capacity );
// Update and render are split to support pausing the simulation
virtual void Step();
virtual void Render();
virtual void UpdateUI();
virtual void Keyboard( int key, int action, int modifiers )
{
}
virtual void MouseDown( b3Vec2 p, int button, int modifiers );
virtual void MouseUp( b3Vec2 p, int button );
virtual void MouseMove( b3Vec2 p );
void ToggleThirdPerson();
void DrawTextLine( const char* text, ... );
void ResetProfile();
#if defined( NDEBUG )
static constexpr bool m_isDebug = false;
#else
static constexpr bool m_isDebug = true;
#endif
static constexpr int m_maxTasks = 64;
static constexpr int m_maxThreads = 64;
static constexpr int m_profileCapacity = 512;
SampleContext* m_context;
GLFWwindow* m_window;
Scene* m_scene;
Camera* m_camera;
b3WorldId m_worldId;
b3Vec3 m_mousePoint;
b3BodyId m_mouseBodyId;
b3JointId m_mouseJointId;
float m_mouseFraction;
float m_mouseForceScale;
float m_launchSpeedScale;
int m_stepCount;
int m_textLine;
int m_textIncrement;
int m_triangleIndex;
uint64_t m_userMaterialId;
b3Profile m_profiles[m_profileCapacity];
int m_currentProfileIndex;
int m_profileReadIndex;
int m_profileWriteIndex;
b3Vec2 m_mouseLast;
b3Vec2 m_mouseDelta;
bool m_didStep;
bool m_stepWhilePaused;
bool m_haveMouseLast;
};
#define MAX_SAMPLES 256
typedef Sample* SampleCreateFcn( SampleContext* context );
struct SampleEntry
{
const char* Category;
const char* Name;
SampleCreateFcn* CreateFcn;
};
class SampleManager
{
public:
static int Register( const char* category, const char* name, SampleCreateFcn* fcn );
void Startup( GLFWwindow* window, int width, int height, int bufferWidth, int bufferHeight );
void Step();
void Resize( int width, int height, int bufferWidth, int bufferHeight );
void Render( GLFWwindow* window, float elapsedTime );
void Shutdown( GLFWwindow* window );
void Keyboard( int key, int action, int modifiers );
void CreateSample();
void RenderScene( GLFWwindow* window, float elapsedTime );
void UpdateUI( GLFWwindow* window );
static SampleEntry sEntries[MAX_SAMPLES];
static int sEntryCount;
SampleContext m_context;
Sample* m_sample = nullptr;
bool m_showMenu = true;
};
struct CastClosestContext
{
b3ShapeId shapeId;
b3Vec3 point;
b3Vec3 normal;
float fraction;
uint64_t materialId;
int childIndex;
int triangleIndex;
bool hit;
};
float CastClosestCallback( b3ShapeId shapeId, b3Vec3 point, b3Vec3 normal, float fraction, uint64_t materialId,
int triangleIndex, int childIndex, void* context );
struct MoverShapeUserData
{
float maxPush;
bool clipVelocity;
};
struct PlaneExtra
{
b3Vec3 point;
b3ShapeId shapeId;
};
struct CharacterMover
{
static constexpr int m_planeCapacity = 8;
static constexpr float m_jumpSpeed = 5.0f;
static constexpr float m_maxSpeed = 6.0f;
static constexpr float m_minSpeed = 0.01f;
static constexpr float m_stopSpeed = 1.0f;
static constexpr float m_accelerate = 30.0f;
static constexpr float m_friction = 4.0f;
static constexpr float m_gravity = 15.0f;
void Initialize( Sample* sample, b3Vec3 position );
void SolveMove( float timeStep, b3Vec3 forward, b3Vec3 right, b3Vec2 throttle, bool clipVelocity );
void Step( b3ShapeId* ignoreShapes, int ignoreCount, bool clipVelocity );
Sample* m_sample;
b3Transform m_transform;
b3Vec3 m_velocity;
b3Capsule m_capsule;
b3CollisionPlane m_planes[m_planeCapacity] = {};
PlaneExtra m_planeExtras[m_planeCapacity] = {};
int m_planeCount;
int m_totalIterations;
float m_pogoVelocity;
bool m_onGround;
bool m_sprint;
// Transient
b3ShapeId* m_ignoreShapeIds;
int m_ignoreCount;
};

1468
samples/sample_benchmark.cpp Normal file

File diff suppressed because it is too large Load diff

965
samples/sample_bodies.cpp Normal file
View file

@ -0,0 +1,965 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "GLFW/glfw3.h"
#include "camera.h"
#include "imgui.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
class BodyType : public Sample
{
public:
explicit BodyType( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 30.0f, { 0.0f, 1.5f, 0.0f } );
}
m_type = b3_dynamicBody;
m_isEnabled = true;
b3BodyId groundId = b3_nullBodyId;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position.y = -1.0f;
bodyDef.name = "ground";
groundId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 20.0f, 1.0f, 20.0f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
// Define attachment
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { -2.0f, 3.0f, 0.0f };
bodyDef.name = "attach1";
m_attachmentId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 0.5f, 2.0f, 0.5f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1.0f;
b3CreateHullShape( m_attachmentId, &shapeDef, &box.base );
}
// Define second attachment
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = m_type;
bodyDef.isEnabled = m_isEnabled;
bodyDef.position = { 3.0f, 3.0f };
bodyDef.name = "attach2";
m_secondAttachmentId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 0.5f, 2.0f, 0.5f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1.0f;
b3CreateHullShape( m_secondAttachmentId, &shapeDef, &box.base );
}
// Define platform
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = m_type;
bodyDef.isEnabled = m_isEnabled;
bodyDef.position = { -4.0f, 5.0f };
bodyDef.name = "platform";
m_platformId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeTransformedBoxHull(
0.5f, 4.0f, 0.5f, { { 4.0f, 0.0f, 0.0f }, b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) } );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
b3CreateHullShape( m_platformId, &shapeDef, &box.base );
b3RevoluteJointDef revoluteDef = b3DefaultRevoluteJointDef();
b3Vec3 pivot = { -2.0f, 5.0f, 0.0f };
revoluteDef.base.bodyIdA = m_attachmentId;
revoluteDef.base.bodyIdB = m_platformId;
revoluteDef.base.localFrameA.p = b3Body_GetLocalPoint( m_attachmentId, pivot );
revoluteDef.base.localFrameB.p = b3Body_GetLocalPoint( m_platformId, pivot );
revoluteDef.maxMotorTorque = 50.0f;
revoluteDef.enableMotor = true;
b3CreateRevoluteJoint( m_worldId, &revoluteDef );
pivot = { 3.0f, 5.0f };
revoluteDef.base.bodyIdA = m_secondAttachmentId;
revoluteDef.base.bodyIdB = m_platformId;
revoluteDef.base.localFrameA.p = b3Body_GetLocalPoint( m_secondAttachmentId, pivot );
revoluteDef.base.localFrameB.p = b3Body_GetLocalPoint( m_platformId, pivot );
revoluteDef.maxMotorTorque = 50.0f;
revoluteDef.enableMotor = true;
b3CreateRevoluteJoint( m_worldId, &revoluteDef );
b3PrismaticJointDef prismaticDef = b3DefaultPrismaticJointDef();
b3Vec3 anchor = { 0.0f, 5.0f, 0.0f };
prismaticDef.base.bodyIdA = groundId;
prismaticDef.base.bodyIdB = m_platformId;
prismaticDef.base.localFrameA.p = b3Body_GetLocalPoint( groundId, anchor );
prismaticDef.base.localFrameB.p = b3Body_GetLocalPoint( m_platformId, anchor );
prismaticDef.maxMotorForce = 1000.0f;
prismaticDef.motorSpeed = 0.0f;
prismaticDef.enableMotor = true;
prismaticDef.lowerTranslation = -10.0f;
prismaticDef.upperTranslation = 10.0f;
prismaticDef.enableLimit = true;
b3CreatePrismaticJoint( m_worldId, &prismaticDef );
m_speed = 3.0f;
}
// Create a payload
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { -3.0f, 8.0f };
bodyDef.name = "crate1";
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 0.75f, 0.75f, 0.75f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
// Create a second payload
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = m_type;
bodyDef.isEnabled = m_isEnabled;
bodyDef.position = { 2.0f, 8.0f };
bodyDef.name = "crate2";
m_secondPayloadId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 0.75f, 0.75f, 0.75f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
b3CreateHullShape( m_secondPayloadId, &shapeDef, &box.base );
}
// Create a separate body on the ground
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = m_type;
bodyDef.isEnabled = m_isEnabled;
bodyDef.position = { 8.0f, 0.2f };
bodyDef.name = "debris";
m_touchingBodyId = b3CreateBody( m_worldId, &bodyDef );
b3Capsule capsule = { { 0.0f, 0.0f }, { 1.0f, 0.0f }, 0.25f };
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
b3CreateCapsuleShape( m_touchingBodyId, &shapeDef, &capsule );
}
// Create a separate floating body
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = m_type;
bodyDef.isEnabled = m_isEnabled;
bodyDef.position = { -8.0f, 12.0f };
bodyDef.gravityScale = 0.0f;
bodyDef.name = "floater";
m_floatingBodyId = b3CreateBody( m_worldId, &bodyDef );
b3Sphere sphere = { { 0.0f, 0.5f, 0.0f }, 0.25f };
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
b3CreateSphereShape( m_floatingBodyId, &shapeDef, &sphere );
}
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 11.0f * fontSize;
ImGui::SetNextWindowPos( ImVec2( 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 9.0f * fontSize, height ) );
ImGui::Begin( "Body Type", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
if ( ImGui::RadioButton( "Static", m_type == b3_staticBody ) )
{
m_type = b3_staticBody;
b3Body_SetType( m_platformId, b3_staticBody );
b3Body_SetType( m_secondAttachmentId, b3_staticBody );
b3Body_SetType( m_secondPayloadId, b3_staticBody );
b3Body_SetType( m_touchingBodyId, b3_staticBody );
b3Body_SetType( m_floatingBodyId, b3_staticBody );
}
if ( ImGui::RadioButton( "Kinematic", m_type == b3_kinematicBody ) )
{
m_type = b3_kinematicBody;
b3Body_SetType( m_platformId, b3_kinematicBody );
b3Body_SetLinearVelocity( m_platformId, { -m_speed, 0.0f } );
b3Body_SetAngularVelocity( m_platformId, b3Vec3_zero );
b3Body_SetType( m_secondAttachmentId, b3_kinematicBody );
b3Body_SetLinearVelocity( m_secondAttachmentId, b3Vec3_zero );
b3Body_SetAngularVelocity( m_secondAttachmentId, b3Vec3_zero );
b3Body_SetType( m_secondPayloadId, b3_kinematicBody );
b3Body_SetType( m_touchingBodyId, b3_kinematicBody );
b3Body_SetType( m_floatingBodyId, b3_kinematicBody );
}
if ( ImGui::RadioButton( "Dynamic", m_type == b3_dynamicBody ) )
{
m_type = b3_dynamicBody;
b3Body_SetType( m_platformId, b3_dynamicBody );
b3Body_SetType( m_secondAttachmentId, b3_dynamicBody );
b3Body_SetType( m_secondPayloadId, b3_dynamicBody );
b3Body_SetType( m_touchingBodyId, b3_dynamicBody );
b3Body_SetType( m_floatingBodyId, b3_dynamicBody );
}
if ( ImGui::Checkbox( "Enable", &m_isEnabled ) )
{
if ( m_isEnabled )
{
b3Body_Enable( m_attachmentId );
b3Body_Enable( m_secondPayloadId );
b3Body_Enable( m_floatingBodyId );
}
else
{
b3Body_Disable( m_attachmentId );
b3Body_Disable( m_secondPayloadId );
b3Body_Disable( m_floatingBodyId );
}
}
ImGui::End();
}
void Step() override
{
// Drive the kinematic body.
if ( m_type == b3_kinematicBody )
{
b3Vec3 p = b3Body_GetPosition( m_platformId );
b3Vec3 v = b3Body_GetLinearVelocity( m_platformId );
if ( ( p.x < -14.0f && v.x < 0.0f ) || ( p.x > 6.0f && v.x > 0.0f ) )
{
v.x = -v.x;
b3Body_SetLinearVelocity( m_platformId, v );
}
}
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new BodyType( context );
}
b3BodyId m_attachmentId;
b3BodyId m_secondAttachmentId;
b3BodyId m_platformId;
b3BodyId m_secondPayloadId;
b3BodyId m_touchingBodyId;
b3BodyId m_floatingBodyId;
b3BodyType m_type;
float m_speed;
bool m_isEnabled;
};
static int sampleBodyType = SampleManager::Register( "Bodies", "Body Type", BodyType::Create );
class SpinningBooks : public Sample
{
public:
explicit SpinningBooks( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 10.0f, { 0.0f, 1.0f, 0.0f } );
}
b3BoxHull box = b3MakeBoxHull( 0.35f, 0.08f, 0.5f );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.gravityScale = 0.0f;
b3ShapeDef shapeDef = b3DefaultShapeDef();
bodyDef.position = { -2.0f, 2.0f, 0.0f };
bodyDef.angularVelocity = { 5.0f, 0.01f, 0.01f };
b3BodyId body1 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body1, &shapeDef, &box.base );
bodyDef.position = { 0.0f, 2.0f, 0.0f };
bodyDef.angularVelocity = { 0.01f, 5.0f, 0.01f };
b3BodyId body2 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body2, &shapeDef, &box.base );
bodyDef.position = { 2.0f, 2.0f, 0.0f };
bodyDef.angularVelocity = { 0.01f, 0.01f, -5.0f };
b3BodyId body3 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body3, &shapeDef, &box.base );
}
void Render() override
{
DrawGrid( m_scene, 10 );
Sample::Render();
}
static Sample* Create( SampleContext* context )
{
return new SpinningBooks( context );
}
};
static int sampleBook = SampleManager::Register( "Bodies", "Spinning Book", SpinningBooks::Create );
// Dzhanibekov effect
class GyroscopicTorque : public Sample
{
public:
explicit GyroscopicTorque( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 20.0f, 4.0f, { 0.0f, 2.0f, 0.0f } );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 2.0f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisX, -0.5f * B3_PI );
bodyDef.angularVelocity = { 0.01f, 0.01f, 10.0f };
bodyDef.gravityScale = 0.0f;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Hull* cylinder = b3CreateCylinder( 0.6f, 0.15f, 0.0f, 32 );
b3BoxHull box = b3MakeBoxHull( 1.0f, 0.05f, 0.1f );
b3CreateHullShape( bodyId, &shapeDef, cylinder );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3DestroyHull( cylinder );
}
void Render() override
{
Sample::Render();
DrawGrid( m_scene, 10 );
}
static Sample* Create( SampleContext* sampleContext )
{
return new GyroscopicTorque( sampleContext );
}
};
static int sampleGyroscopicTorque = SampleManager::Register( "Bodies", "Gyroscopic Torque", GyroscopicTorque::Create );
class Weeble : public Sample
{
public:
static Sample* Create( SampleContext* context )
{
return new Weeble( context );
}
explicit Weeble( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 25.0f, 25.0f, b3Vec3_zero );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundBody = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 32.0f, 1.0f, 32.0f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( groundBody, &shapeDef, &box.base );
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 3.0f, 0.0f };
m_weebleId = b3CreateBody( m_worldId, &bodyDef );
b3Capsule capsule = { { 0.0f, -1.0f }, { 0.0f, 1.0f }, 1.0f };
shapeDef.baseMaterial.rollingResistance = 0.1f;
b3CreateCapsuleShape( m_weebleId, &shapeDef, &capsule );
float mass = b3Body_GetMass( m_weebleId );
b3Matrix3 inertiaTensor = b3Body_GetLocalRotationalInertia( m_weebleId );
b3Vec3 offset = { 0.0f, -1.5f, 0.0f };
// See: https://en.wikipedia.org/wiki/Parallel_axis_theorem
inertiaTensor += b3Steiner( mass, offset );
b3MassData massData = {
.mass = mass,
.center = offset,
.inertia = inertiaTensor,
};
b3Body_SetMassData( m_weebleId, massData );
m_explosionPosition = { 0.0f, -0.1f, 0.0f };
m_explosionRadius = 8.0f;
m_explosionMagnitude = 10000.0f;
}
void UpdateUI() override
{
float height = 120.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 200.0f, height ) );
ImGui::Begin( "Weeble", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
if ( ImGui::Button( "Teleport" ) )
{
b3Body_SetTransform( m_weebleId, { 0.0f, 5.0f, 0.0f }, b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.95f * B3_PI ) );
b3Body_SetAwake( m_weebleId, true );
}
if ( ImGui::Button( "Explode" ) )
{
b3ExplosionDef def = b3DefaultExplosionDef();
def.position = m_explosionPosition;
def.radius = m_explosionRadius;
def.falloff = 0.1f;
def.impulsePerArea = m_explosionMagnitude;
b3World_Explode( m_worldId, &def );
}
ImGui::PushItemWidth( 100.0f );
ImGui::SliderFloat( "Magnitude", &m_explosionMagnitude, -100000.0f, 100000.0f, "%.0f" );
ImGui::PopItemWidth();
ImGui::End();
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.1f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 4.0f );
}
void Step() override
{
Sample::Step();
b3Sphere sphere = { b3Vec3_zero, m_explosionRadius };
DrawSphere( m_scene, { m_explosionPosition, b3Quat_identity }, sphere, b3_colorAzure );
// This shows how to get the velocity of a point on a body
b3Vec3 localPoint = { 0.0f, 2.0f, 0.0f };
b3Vec3 worldPoint = b3Body_GetWorldPoint( m_weebleId, localPoint );
b3Vec3 v1 = b3Body_GetLocalPointVelocity( m_weebleId, localPoint );
b3Vec3 v2 = b3Body_GetWorldPointVelocity( m_weebleId, worldPoint );
b3Vec3 offset = { 0.05f, 0.0f };
DrawLine( m_scene, worldPoint, worldPoint + v1, b3_colorRed );
DrawLine( m_scene, worldPoint + offset, worldPoint + v2 + offset, b3_colorGreen );
}
b3BodyId m_weebleId;
b3Vec3 m_explosionPosition;
float m_explosionRadius;
float m_explosionMagnitude;
};
static int sampleWeeble = SampleManager::Register( "Bodies", "Weeble", Weeble::Create );
class DisableBody : public Sample
{
public:
enum
{
e_count = 4
};
explicit DisableBody( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 25.0f, 10.0f, b3Vec3_zero );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundBody = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 25.0f, 1.0f, 25.0f );
b3CreateHullShape( groundBody, &shapeDef, &box.base );
float linkRadius = 0.1f;
float linkLength = 5.0f * linkRadius;
b3Capsule capsule = { { 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, linkLength }, linkRadius };
b3BodyId parentId = {};
for ( int link = 0; link < e_count; ++link )
{
bodyDef.position = { 0.0f, 0.8f * float( e_count ) * linkLength, link * linkLength };
bodyDef.type = B3_IS_NULL( parentId ) ? b3_kinematicBody : b3_dynamicBody;
b3BodyId childId = b3CreateBody( m_worldId, &bodyDef );
b3CreateCapsuleShape( childId, &shapeDef, &capsule );
m_bodyIds[link] = childId;
if ( B3_IS_NON_NULL( parentId ) )
{
b3WeldJointDef jointDef = b3DefaultWeldJointDef();
jointDef.base.bodyIdA = parentId;
jointDef.base.bodyIdB = childId;
jointDef.base.localFrameA.p = { 0.0f, 0.0f, linkLength };
jointDef.angularHertz = 10.0f;
jointDef.angularDampingRatio = 1.0f;
b3CreateWeldJoint( m_worldId, &jointDef );
}
parentId = childId;
}
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 3.0f, 3.0f, 0.0f };
m_ballId = b3CreateBody( m_worldId, &bodyDef );
b3Sphere sphere = { { 0.0f, 0.0f, 0.0f }, 0.5f };
b3CreateSphereShape( m_ballId, &shapeDef, &sphere );
}
void UpdateUI() override
{
float height = 100.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 200.0f, height ) );
ImGui::Begin( "Distance", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
{
bool enabled = b3Body_IsEnabled( m_bodyIds[2] );
if ( ImGui::Checkbox( "Enable Link", &enabled ) )
{
if ( enabled )
{
b3Body_Enable( m_bodyIds[2] );
}
else
{
b3Body_Disable( m_bodyIds[2] );
}
}
}
{
bool enabled = b3Body_IsEnabled( m_ballId );
if ( ImGui::Checkbox( "Enable Ball", &enabled ) )
{
if ( enabled )
{
b3Body_Enable( m_ballId );
}
else
{
b3Body_Disable( m_ballId );
}
}
}
ImGui::End();
}
void Step() override
{
b3Body_ApplyLinearImpulseToCenter( m_bodyIds[2], { 0.0f, 0.1f, 0.0f }, true );
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new DisableBody( context );
}
b3BodyId m_bodyIds[e_count];
b3BodyId m_ballId;
};
static int sampleDisable = SampleManager::Register( "Bodies", "Disable", DisableBody::Create );
class BodyCast : public Sample
{
public:
explicit BodyCast( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 120.0f, 30.0f, 20.0f, { 0.0f, 1.5f, 0.0f } );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_kinematicBody;
bodyDef.position = { 5.0f, 5.0f, 0.0f };
bodyDef.angularVelocity = { 0.1f, -0.1f, 0.1f };
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
m_cylinder = b3CreateCylinder( 2.0f, 0.5f, 0.0f, 16 );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_bodyId, &shapeDef, m_cylinder );
m_transform.p = { -10.0f, 2.0f, 0.0f };
m_transform.q = b3MakeQuatFromAxisAngle( b3Normalize( { 1.0f, -2.0f, 3.0f } ), 0.75f * B3_PI );
m_baseTranslation = b3Vec3_zero;
m_baseX = 0;
m_baseY = 0;
m_origin = b3Vec3_zero;
m_tracking = false;
}
~BodyCast() override
{
b3DestroyHull( m_cylinder );
}
void MouseDown( b3Vec2 p, int button, int modifiers ) override
{
if ( button == 0 && modifiers == GLFW_MOD_ALT )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
m_origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_baseTranslation = m_transform.p;
m_tracking = true;
}
else
{
m_tracking = false;
}
}
void MouseMove( b3Vec2 p ) override
{
if ( m_tracking )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3Vec3 origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_transform.p = m_baseTranslation + origin - m_origin;
}
}
void Render() override
{
Sample::Render();
DrawGrid( m_scene, 10 );
b3Transform transform = { { 0.0f, 0.1f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 4.0f );
DrawHull( m_scene, m_transform, m_cylinder, b3_colorBlue, false );
}
void Step() override
{
// Cast ray
{
b3BodyRayCastInput input = {};
input.origin = { -9.75f, 3.0f, -4.0f };
input.translation = { 0.0f, 0.0f, 8.0f };
input.filter = b3DefaultQueryFilter();
input.maxFraction = 1.0f;
b3BodyCastResult result = b3Body_CastRay( m_bodyId, &input, m_transform );
DrawLine( m_scene, input.origin, input.origin + input.maxFraction * input.translation, b3_colorCyan );
if ( result.hit )
{
DrawLine( m_scene, result.point, result.point + 0.2f * result.normal, b3_colorYellow );
DrawPoint( m_scene, result.point, 10.0f, b3_colorYellow );
}
DrawPoint( m_scene, input.origin, 10.0f, b3_colorGreen );
DrawPoint( m_scene, input.origin + input.translation, 10.0f, b3_colorRed );
}
// Cast sphere
{
b3Sphere sphere = { { -14.5f, 2.5f, 0.5f }, 0.2f };
b3BodyShapeCastInput input = {};
input.proxy = { &sphere.center, 1, sphere.radius };
input.translation = { 8.0f, 0.0f, 0.0f };
input.filter = b3DefaultQueryFilter();
input.maxFraction = 1.0f;
input.canEncroach = true;
b3BodyCastResult result = b3Body_CastShape( m_bodyId, &input, m_transform );
if ( result.hit )
{
b3Transform transform = { result.fraction * input.translation, b3Quat_identity };
DrawSphere( m_scene, transform, sphere, b3_colorGreen );
DrawLine( m_scene, result.point, result.point + 0.2f * result.normal, b3_colorYellow );
}
else
{
b3Transform transform = { input.maxFraction * input.translation, b3Quat_identity };
DrawSphere( m_scene, transform, sphere, b3_colorWhite );
}
DrawLine( m_scene, sphere.center, sphere.center + input.maxFraction * input.translation, b3_colorWhite );
DrawPoint( m_scene, sphere.center, 10.0f, b3_colorGreen );
DrawPoint( m_scene, sphere.center + input.maxFraction * input.translation, 10.0f, b3_colorRed );
}
// Overlap capsule
{
b3Capsule capsule = { { -10.5f, 2.0f, 0.5f }, { -9.5f, 1.0f, 0.5f }, 0.5f };
b3ShapeProxy proxy = { &capsule.center1, 2, capsule.radius };
bool overlaps = b3Body_OverlapShape( m_bodyId, &proxy, b3DefaultQueryFilter(), m_transform );
if ( overlaps )
{
DrawCapsule( m_scene, b3Transform_identity, capsule, b3_colorGreen );
}
else
{
DrawCapsule( m_scene, b3Transform_identity, capsule, b3_colorGray );
}
}
// Collide capsule
{
b3Capsule capsule = { { -10.25f, 2.0f, -0.75f }, { -10.25f, 3.0f, -0.75f }, 0.3f };
b3BodyPlaneResult bodyPlanes[4];
int count = b3Body_CollideMover( m_bodyId, bodyPlanes, 4, &capsule, b3DefaultQueryFilter(), m_transform );
DrawCapsule( m_scene, b3Transform_identity, capsule, b3_colorPurple );
for ( int i = 0; i < count; ++i )
{
b3PlaneResult result = bodyPlanes[i].result;
DrawPlane( m_scene, result.plane.normal, result.point, b3_colorOrange );
}
}
}
static Sample* Create( SampleContext* context )
{
return new BodyCast( context );
}
b3Hull* m_cylinder;
b3BodyId m_bodyId;
b3Transform m_transform;
b3Vec3 m_baseTranslation;
b3Vec3 m_origin;
int m_baseX;
int m_baseY;
bool m_tracking;
};
static int sampleBodyCast = SampleManager::Register( "Bodies", "Cast", BodyCast::Create );
// This shows how to drive a kinematic body to reach a target
class Kinematic : public Sample
{
public:
explicit Kinematic( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 10.0f, { 0.0f, 1.5f, 0.0f } );
}
m_amplitude = 2.0f;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_kinematicBody;
bodyDef.position.x = 2.0f * m_amplitude;
bodyDef.position.y = m_amplitude;
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull box = b3MakeBoxHull( 0.1f, 1.0f, 0.2f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_bodyId, &shapeDef, &box.base );
}
m_time = 0.0f;
}
void Render() override
{
Sample::Render();
DrawGrid( m_scene, 10 );
DrawTransform( m_scene, b3Transform_identity, 4.0f );
}
void Step() override
{
float timeStep = m_context->hertz > 0.0f ? 1.0f / m_context->hertz : 0.0f;
if ( m_context->pause && m_context->singleStep == 0 )
{
timeStep = 0.0f;
}
float delay = 2.0f;
if ( timeStep > 0.0f && m_time > delay )
{
float t = m_time - delay;
b3Vec3 point;
point.x = 2.0f * m_amplitude * cosf( t );
point.y = m_amplitude * ( sinf( 2.0f * t ) + 1.0f );
point.z = 0.0f;
b3Quat rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 2.0f * t );
b3Vec3 axis = b3RotateVector( rotation, { 0.0f, 1.0f, 0.0f } );
DrawLine( m_scene, point - 0.5f * axis, point + 0.5f * axis, b3_colorPlum );
DrawPoint( m_scene, point, 10.0f, b3_colorPlum );
b3Body_SetTargetTransform( m_bodyId, { point, rotation }, timeStep, true );
}
Sample::Step();
m_time += timeStep;
}
static Sample* Create( SampleContext* context )
{
return new Kinematic( context );
}
b3BodyId m_bodyId;
float m_amplitude;
float m_time;
};
static int sampleKinematic = SampleManager::Register( "Bodies", "Kinematic", Kinematic::Create );
class LockMixing : public Sample
{
public:
explicit LockMixing( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 40.0f, b3Vec3_zero );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 15.0f, 1.0f, 15.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
b3BoxHull cube = b3MakeBoxHull( 1.0f, 1.0f, 1.0f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.name = "free";
bodyDef.position = { 0.0f, 2.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.name = "angular xz";
bodyDef.position = { 2.0f, 2.0f, 0.0f };
bodyDef.motionLocks.angularX = true;
//bodyDef.motionLocks.angularY = true;
bodyDef.motionLocks.angularZ = true;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.name = "linear xyz";
bodyDef.position = { -2.0f, 2.0f, 0.0f };
bodyDef.motionLocks.linearX = true;
bodyDef.motionLocks.linearY = true;
bodyDef.motionLocks.linearZ = true;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.name = "full";
bodyDef.position = { 0.0f, 1.0f, 2.0f };
bodyDef.motionLocks.linearX = true;
bodyDef.motionLocks.linearY = true;
bodyDef.motionLocks.linearZ = true;
bodyDef.motionLocks.angularX = true;
bodyDef.motionLocks.angularY = true;
bodyDef.motionLocks.angularZ = true;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "static";
bodyDef.position = { 0.0f, 1.0f, -3.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
}
static Sample* Create( SampleContext* context )
{
return new LockMixing( context );
}
};
static int sampleLockMixing = SampleManager::Register( "Bodies", "Lock Mixing", LockMixing::Create );

View file

@ -0,0 +1,438 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "mesh_loader.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
#include <glad/glad.h>
// prevent clang format sorting glad.h with glfw3.h
#include <GLFW/glfw3.h>
#include <imgui.h>
class CapsulePlane : public Sample
{
public:
static Sample* Create( SampleContext* context )
{
return new CapsulePlane( context );
}
explicit CapsulePlane( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 120.0f, 30.0f, 20.0f, { 0.0f, 1.5f, 0.0f } );
}
m_transform = { { 0.0f, 1.0f, 0.4f }, b3Quat_identity };
m_capsule = { { 0.0f, -0.5f, 0.0f }, { 0.0f, 0.5f, 0.0f }, 0.25f };
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 1.0f, 1.0f };
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
b3CreateHullShape( body, &shapeDef, &box.base );
m_baseTranslation = b3Vec3_zero;
m_baseX = 0;
m_baseY = 0;
m_origin = b3Vec3_zero;
m_tracking = false;
m_planeCount = 0;
}
void Solve()
{
b3PlaneSolverResult result = b3SolvePlanes( b3Vec3_zero, m_planes, m_planeCount );
m_transform.p += result.delta;
}
void Render() override
{
Sample::Render();
DrawGrid( m_scene, 10 );
DrawLine( m_scene, b3Vec3_zero, 2.0f * b3Vec3_axisX, b3_colorRed );
DrawLine( m_scene, b3Vec3_zero, 2.0f * b3Vec3_axisY, b3_colorGreen );
DrawLine( m_scene, b3Vec3_zero, 2.0f * b3Vec3_axisZ, b3_colorBlue );
}
void UpdateUI() override
{
ImGui::SetNextWindowPos( ImVec2( 10.0f, 600.0f ) );
ImGui::SetNextWindowSize( ImVec2( 240.0f, 80.0f ) );
ImGui::Begin( "Capsule Plane", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
if ( ImGui::Button( "Solve" ) )
{
Solve();
}
ImGui::End();
}
static bool PlaneResultFcn( b3ShapeId shape, const b3PlaneResult* results, int planeCount, void* context )
{
CapsulePlane* self = static_cast<CapsulePlane*>( context );
for ( int i = 0; i < planeCount && self->m_planeCount < 3; ++i )
{
self->m_planes[self->m_planeCount] = { results[i].plane, FLT_MAX, 0.0f, true };
self->m_planeCount += 1;
}
return true;
}
void MouseDown( b3Vec2 p, int button, int modifiers ) override
{
if ( button == 0 && ( modifiers & GLFW_MOD_ALT ) == 0 )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
m_origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_baseTranslation = m_transform.p;
m_tracking = true;
}
}
void MouseUp( b3Vec2 p, int button ) override
{
m_tracking = false;
}
void MouseMove( b3Vec2 p ) override
{
if ( m_tracking )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3Vec3 origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_transform.p = m_baseTranslation + origin - m_origin;
}
}
void Step() override
{
m_planeCount = 0;
DrawCapsule( m_scene, m_transform, m_capsule, b3_colorGreen );
b3QueryFilter filter = b3DefaultQueryFilter();
b3Capsule capsule = { m_capsule.center1 + m_transform.p, m_capsule.center2 + m_transform.p, m_capsule.radius };
b3World_CollideMover( m_worldId, &capsule, filter, PlaneResultFcn, this );
for ( int i = 0; i < m_planeCount; ++i )
{
b3Plane plane = m_planes[i].plane;
b3Vec3 p1 = m_transform.p + ( plane.offset - m_capsule.radius ) * plane.normal;
b3Vec3 p2 = p1 + 0.1f * plane.normal;
DrawPoint( m_scene, p1, 5.0f, b3_colorYellow );
DrawLine( m_scene, p1, p2, b3_colorYellow );
}
}
static constexpr int m_planeCapacity = 3;
b3Transform m_transform;
b3Capsule m_capsule;
b3CollisionPlane m_planes[m_planeCapacity] = {};
int m_planeCount;
b3Vec3 m_baseTranslation;
b3Vec3 m_origin;
int m_baseX;
int m_baseY;
bool m_tracking;
};
static int sampleCapsulePlane = SampleManager::Register( "Character", "CapsulePlane", CapsulePlane::Create );
class BasicMover : public Sample
{
public:
explicit BasicMover( SampleContext* context )
: Sample( context )
{
b3Vec3 moverPosition = { 7.5f, 0.75f, 9.0f };
if ( m_context->restart == false )
{
m_camera->SetView( 120.0f, 30.0f, 5.0f, moverPosition );
}
m_mover.Initialize( this, moverPosition );
{
m_levelMesh = CreateMeshData( "data/meshes/test_map01.obj", 1.0f, false, false, true, true );
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3SurfaceMaterial materials[3];
materials[0] = { 0.6f, 0.0f, 0 };
materials[1] = { 0.6f, 1.0f, 1 };
materials[2] = { 0.1f, 0.0f, 2 };
shapeDef.materials = materials;
shapeDef.materialCount = 3;
b3CreateMeshShape( body, &shapeDef, m_levelMesh, b3Vec3_one );
// b3Transform transform = { { 0.0f, 1.0f, 14.0f }, b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.75f * B3_PI ) };
// b3BoxHull box = b3MakeTransformedBoxHull( 5.0f, 1.0f, 0.5f, transform );
// b3CreateHullShape( body, &shapeDef, &box.base );
{
b3Transform transform = { { 4.0f, 1.0f, 14.0f }, b3Quat_identity };
b3BoxHull box = b3MakeTransformedBoxHull( 1.0f, 1.0f, 1.0f, transform );
b3CreateHullShape( body, &shapeDef, &box.base );
}
{
b3Transform transform = { { 4.0f, 1.0f, 13.95f }, b3Quat_identity };
b3BoxHull box = b3MakeTransformedBoxHull( 1.0f, 1.0f, 1.0f, transform );
b3CreateHullShape( body, &shapeDef, &box.base );
}
{
b3Transform transform = { { 5.8f, 1.0f, 13.7f }, b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.1f * B3_PI ) };
b3BoxHull box = b3MakeTransformedBoxHull( 1.0f, 1.0f, 1.0f, transform );
b3CreateHullShape( body, &shapeDef, &box.base );
}
}
{
m_stairs = CreateMeshData( "data/meshes/stairs.obj", 1.0f, false, false, true, true );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { -10.0f, 0.0f, 0.0f };
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateMeshShape( body, &shapeDef, m_stairs, { 0.75f, 0.75f, -1.5f } );
}
{
m_torus = b3CreateTorusMesh( 10, 12, 2.0f, 1.0f );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { -10.0f, 1.0f, -8.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.5f * B3_PI );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateMeshShape( body, &shapeDef, m_torus, { -0.75f, 1.5f, 0.5f } );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 20.0f, 0.0f, 0.0f };
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
m_heightField = b3CreateWave( 50.0f, 50.0f, b3Vec3_one, 0.02f, 0.04f, true );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3SurfaceMaterial materials[3];
materials[0] = { 0.6f, 0.0f, 0 };
materials[1] = { 0.6f, 1.0f, 1 };
materials[2] = { 0.1f, 0.0f, 2 };
shapeDef.materials = materials;
shapeDef.materialCount = 3;
b3CreateHeightFieldShape( body, &shapeDef, m_heightField );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 1.4f, 6.0f };
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_enemyShape.maxPush = 1.0f;
m_enemyShape.clipVelocity = true;
b3Capsule capsule = {
{ 0.0f, -0.5f, 0.0f },
{ 0.0f, 0.5f, 0.0f },
0.3f,
};
//shapeDef.filter = { 2u, ~0u, 0 };
shapeDef.userData = &m_enemyShape;
shapeDef.baseMaterial.customColor = b3_colorMediumVioletRed;
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateCapsuleShape( body, &shapeDef, &capsule );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 1.4f, 5.0f };
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_friendlyShape.maxPush = 0.01f;
m_friendlyShape.clipVelocity = false;
b3Capsule capsule = {
{ 0.0f, -0.5f, 0.0f },
{ 0.0f, 0.5f, 0.0f },
0.3f,
};
shapeDef.filter = { 2u, ~0u, 0 };
shapeDef.userData = &m_friendlyShape;
shapeDef.baseMaterial.customColor = b3_colorLimeGreen;
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateCapsuleShape( body, &shapeDef, &capsule );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 7.0f, 5.0f, 0.0f };
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Sphere sphere = { b3Vec3_zero, 0.5f };
b3CreateSphereShape( body, &shapeDef, &sphere );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 7.0f, 2.0f, -3.0f };
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.customColor = b3_colorFloralWhite;
b3BoxHull box = b3MakeBoxHull( 0.5f, 0.25f, 0.5f );
m_ignoreShapeId = b3CreateHullShape( body, &shapeDef, &box.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
bodyDef.type = b3_dynamicBody;
bodyDef.position = { -2.0f, 1.6f, 0.0f };
bodyDef.gravityScale = 2.0f;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1000.0f;
b3BoxHull box = b3MakeBoxHull( 0.75f, 1.5f, 0.1f );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3Quat axisQuat = b3ComputeQuatBetweenUnitVectors( b3Vec3_axisZ, b3Vec3_axisY );
b3Vec3 offset = { -0.75f, 0.0f, 0.0f };
b3RevoluteJointDef jointDef = b3DefaultRevoluteJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Add( bodyDef.position, offset );
jointDef.base.localFrameA.q = axisQuat;
jointDef.base.localFrameB.p = offset;
jointDef.base.localFrameB.q = axisQuat;
jointDef.enableLimit = true;
jointDef.lowerAngle = B3_DEG_TO_RAD * -90.0f;
jointDef.upperAngle = B3_DEG_TO_RAD * 90.0f;
jointDef.enableSpring = true;
jointDef.hertz = 1.0f;
jointDef.dampingRatio = 0.5f;
jointDef.enableMotor = false;
jointDef.maxMotorTorque = 100.0f;
jointDef.base.drawScale = 2.0f;
b3CreateRevoluteJoint( m_worldId, &jointDef );
}
//{
// b3BodyDef BodyDef = b3DefaultBodyDef();
// BodyDef.type = b3_dynamicBody;
// BodyDef.position = { 25.0f, 5.0f, 10.0f };
// b3BodyId Body = b3CreateBody(m_worldId, &bodyDef );
// b3ShapeDef ShapeDef = b3DefaultShapeDef();
// b3Sphere Sphere = { b3Vec3_zero, 0.5f };
// Body->AddSphere( &ShapeDef, Sphere );
//}
m_camera->m_thirdPerson = true;
m_clipVelocity = true;
glfwSetInputMode( m_window, GLFW_CURSOR, GLFW_CURSOR_DISABLED );
//m_haveMouseLast = false;
//m_mouseLast = { 0.0f, 0.0f };
//m_mouseDelta = { 0.0f, 0.0f };
}
~BasicMover() override
{
m_camera->m_thirdPerson = false;
glfwSetInputMode( m_window, GLFW_CURSOR, GLFW_CURSOR_NORMAL );
b3DestroyMesh( m_levelMesh );
b3DestroyMesh( m_stairs );
b3DestroyMesh( m_torus );
b3DestroyHeightField( m_heightField );
}
void Render() override
{
Sample::Render();
DrawTransform( m_scene, { { 0.0f, 0.0f, 0.02f }, b3Quat_identity }, 2.0f );
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 9.0f * fontSize;
ImGui::SetNextWindowPos( ImVec2( 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 19.0f * fontSize, height ) );
ImGui::Begin( "Mover", nullptr, ImGuiWindowFlags_NoResize );
bool thirdPerson = m_camera->m_thirdPerson;
if ( ImGui::Checkbox( "Third Person (Key: T)", &thirdPerson ) )
{
ToggleThirdPerson();
}
ImGui::Checkbox( "Clip Velocity", &m_clipVelocity );
ImGui::End();
}
void Keyboard( int key, int action, int mods ) override
{
if ( key == GLFW_KEY_T && action == GLFW_PRESS )
{
ToggleThirdPerson();
}
}
void Step() override
{
m_mover.Step(&m_ignoreShapeId, 1, m_clipVelocity);
DrawTextLine( "third person (T) = %d", m_camera->m_thirdPerson );
DrawTextLine( "deltaX = %g, deltaY = %g", m_mouseDelta.x, m_mouseDelta.y );
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new BasicMover( context );
}
CharacterMover m_mover;
MoverShapeUserData m_enemyShape;
MoverShapeUserData m_friendlyShape;
b3MeshData* m_levelMesh;
b3MeshData* m_stairs;
b3MeshData* m_torus;
b3HeightField* m_heightField;
b3ShapeId m_ignoreShapeId;
bool m_clipVelocity;
};
static int sampleMover = SampleManager::Register( "Character", "Mover", BasicMover::Create );

2821
samples/sample_collision.cpp Normal file

File diff suppressed because it is too large Load diff

800
samples/sample_compound.cpp Normal file
View file

@ -0,0 +1,800 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "human.h"
#include "mesh_loader.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "utils.h"
#include "box3d/box3d.h"
#include <imgui.h>
class SimpleCompound : public Sample
{
public:
explicit SimpleCompound( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 45.0f, b3Vec3_zero );
}
{
float a = 4.0f;
b3Vec3 extents = { a, 0.125f * a, a };
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
b3BoxHull box = b3MakeBoxHull( extents.x, extents.y, extents.z );
b3Transform hullTransform;
hullTransform.p = { 1.0f, -0.125f * a, 0.0f };
hullTransform.q = b3MakeQuatFromAxisAngle( b3Normalize({ 1.0f, 0.0f, 1.0f }), 0.0f * B3_PI );
b3CompoundHullDef hullDef = {
.hull = &box.base,
.transform = hullTransform,
.material = material,
};
b3CompoundDef def = {};
def.hulls = &hullDef;
def.hullCount = 1;
m_compound = b3CreateCompound( &def );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 2.0f, -1.0f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( { 0.0f, 1.0f, 0.0f }, 0.25f * B3_PI );
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
}
b3World_SetContactRecycleDistance( m_worldId, 0.0f );
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 2.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Sphere sphere = { b3Vec3_zero, 0.25f };
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
//{
// b3BodyDef bodyDef = b3DefaultBodyDef();
// bodyDef.type = b3_dynamicBody;
// bodyDef.position = { 0.0f, 10.0f, 2.0f };
// b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
// b3ShapeDef shapeDef = b3DefaultShapeDef();
// b3BoxHull box = b3MakeBoxHull( 0.2f, 0.3f, 0.4f );
// b3CreateHullShape( bodyId, &shapeDef, &box.base );
//}
m_launchSpeedScale = 1.0f;
}
~SimpleCompound() override
{
b3DestroyCompound( m_compound );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 1.0f );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree height = %d", height );
}
static Sample* Create( SampleContext* context )
{
return new SimpleCompound( context );
}
b3Compound* m_compound;
};
static int sampleSimple = SampleManager::Register( "Compound", "Simple", SimpleCompound::Create );
class CompoundSpheres : public Sample
{
public:
explicit CompoundSpheres( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 45.0f, b3Vec3_zero );
}
float h = 10.0f;
b3Vec3 lower = { -h, -h, -h };
b3Vec3 upper = { h, h, h };
b3CompoundSphereDef spheres[m_count];
for ( int i = 0; i < m_count; ++i )
{
spheres[i].sphere.center = RandomVec3( lower, upper );
spheres[i].sphere.radius = RandomFloatRange( 0.01f * h, 0.05f * h );
spheres[i].material = b3DefaultSurfaceMaterial();
}
b3CompoundDef def = {};
def.spheres = spheres;
def.sphereCount = m_count;
m_compound = b3CreateCompound( &def );
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
}
~CompoundSpheres() override
{
b3DestroyCompound( m_compound );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 1.0f );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree height = %d", height );
}
static Sample* Create( SampleContext* context )
{
return new CompoundSpheres( context );
}
static constexpr int m_count = 20;
b3Compound* m_compound;
};
static int sampleCompoundSpheres = SampleManager::Register( "Compound", "Spheres", CompoundSpheres::Create );
class CompoundHulls : public Sample
{
public:
explicit CompoundHulls( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 45.0f, b3Vec3_zero );
}
float h = 10.0f;
b3Vec3 lower = { -h, -h, -h };
b3Vec3 upper = { h, h, h };
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
b3BoxHull boxHulls[m_count];
b3CompoundHullDef hulls[m_count];
for ( int i = 0; i < m_count; ++i )
{
b3Vec3 extents = {
.x = RandomFloatRange( 0.01f * h, 0.05f * h ),
.y = RandomFloatRange( 0.01f * h, 0.05f * h ),
.z = RandomFloatRange( 0.01f * h, 0.05f * h ),
};
b3Transform transform;
transform.p = RandomVec3( lower, upper );
transform.q = RandomQuat();
boxHulls[i] = b3MakeBoxHull( extents.x, extents.y, extents.z );
hulls[i].hull = &boxHulls[i].base;
hulls[i].transform = transform;
hulls[i].material = material;
}
b3CompoundDef def = {};
def.hulls = hulls;
def.hullCount = m_count;
m_compound = b3CreateCompound( &def );
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
}
~CompoundHulls() override
{
b3DestroyCompound( m_compound );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 1.0f );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree height = %d", height );
}
static Sample* Create( SampleContext* context )
{
return new CompoundHulls( context );
}
static constexpr int m_count = 20;
b3Compound* m_compound;
};
static int sampleCompoundHulls = SampleManager::Register( "Compound", "Hulls", CompoundHulls::Create );
class TileFloor : public Sample
{
public:
explicit TileFloor( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 45.0f, b3Vec3_zero );
}
{
constexpr int gridCount = 50;
constexpr int boxCount = gridCount * gridCount;
float a = 4.0f;
b3Vec3 extents = { a, 0.5f * a, a };
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
b3BoxHull box = b3MakeBoxHull( extents.x, extents.y, extents.z );
// Must allocate to avoid stack overflow
b3CompoundHullDef* hulls = new b3CompoundHullDef[boxCount];
b3Transform transform = b3Transform_identity;
int index = 0;
for ( int i = 0; i < gridCount; ++i )
{
transform.p.x = ( 2.0f * i - gridCount ) * a;
for ( int j = 0; j < gridCount; ++j )
{
transform.p.z = ( 2.0f * j - gridCount ) * a;
transform.p.y = RandomFloatRange( -0.5f, 0.25f ) * a;
assert( index < boxCount );
hulls[index].hull = &box.base;
hulls[index].transform = transform;
hulls[index].material = material;
index += 1;
}
}
b3CompoundDef def = {};
def.hulls = hulls;
def.hullCount = boxCount;
m_compound = b3CreateCompound( &def );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { -2.0f, 1.0f, -3.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Normalize( { 1.0f, -1.0f, 0.5f } ), 0.0f );
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
delete[] hulls;
hulls = nullptr;
}
//b3World_SetContactRecycleDistance( m_worldId, 0.0f );
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 3.0f, 12.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Sphere sphere = { b3Vec3_zero, 0.25f };
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
#if 0
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 10.0f, 2.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 0.2f, 0.3f, 0.4f );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
#endif
}
~TileFloor() override
{
b3DestroyCompound( m_compound );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 1.0f );
DrawTextLine( "compound hull count = %d, mesh count = %d", m_compound->hullCount, m_compound->meshCount );
DrawTextLine( "compound byte count = %d", m_compound->byteCount );
int treeBytes = b3DynamicTree_GetByteCount( &m_compound->tree );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree byte count = %d, height = %d", treeBytes, height );
}
static Sample* Create( SampleContext* context )
{
return new TileFloor( context );
}
b3Compound* m_compound;
};
static int sampleTileFloor = SampleManager::Register( "Compound", "Tile Floor", TileFloor::Create );
class MeshTile : public Sample
{
public:
explicit MeshTile( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 45.0f, b3Vec3_zero );
}
{
constexpr int gridCount = 2;
constexpr int boxCount = gridCount * gridCount;
float a = 4.0f;
b3Vec3 extents = { a, 0.5f * a, a };
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
b3MeshData* box = b3CreateBoxMesh( { 0.0f, 0.0f, 0.0f }, extents, true );
b3CompoundMeshDef* meshes = new b3CompoundMeshDef[boxCount];
b3Transform transform = b3Transform_identity;
transform.p.y = -0.5f * a;
int index = 0;
for ( int i = 0; i < gridCount; ++i )
{
transform.p.x = ( 2.0f * i - gridCount ) * a;
for ( int j = 0; j < gridCount; ++j )
{
transform.p.z = ( 2.0f * j - gridCount ) * a;
transform.p.y = RandomFloatRange( -0.5f, 0.25f ) * a;
assert( index < boxCount );
meshes[index].meshData = box;
meshes[index].transform = transform;
meshes[index].scale = { 1.0f, 1.0f, 1.0f };
meshes[index].materials = &material;
meshes[index].materialCount = 1;
index += 1;
}
}
b3CompoundDef def = {};
def.meshes = meshes;
def.meshCount = boxCount;
m_compound = b3CreateCompound( &def );
delete[] meshes;
b3DestroyMesh( box );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
}
#if 0
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 3.0f, 12.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Sphere sphere = { b3Vec3_zero, 0.25f };
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
#endif
//{
// b3BodyDef bodyDef = b3DefaultBodyDef();
// bodyDef.type = b3_dynamicBody;
// bodyDef.position = { 0.0f, 10.0f, 2.0f };
// b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
// b3ShapeDef shapeDef = b3DefaultShapeDef();
// b3BoxHull box = b3MakeBoxHull( 0.2f, 0.3f, 0.4f );
// b3CreateHullShape( bodyId, &shapeDef, &box.base );
//}
}
~MeshTile() override
{
b3DestroyCompound( m_compound );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 1.0f );
DrawTextLine( "compound instance count = %d, byte count = %d", m_compound->meshCount, m_compound->byteCount );
int treeBytes = b3DynamicTree_GetByteCount( &m_compound->tree );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree byte count = %d, height = %d", treeBytes, height );
}
static Sample* Create( SampleContext* context )
{
return new MeshTile( context );
}
b3Compound* m_compound;
};
static int sampleCompoundMesh = SampleManager::Register( "Compound", "Mesh Tile", MeshTile::Create );
static bool OverlapResultFcn( b3ShapeId shapeId, void* context )
{
(void)shapeId;
bool* overlap = (bool*)context;
*overlap = true;
return false;
}
class Village : public Sample
{
public:
explicit Village( SampleContext* context )
: Sample( context )
{
constexpr int gridCount = m_isDebug ? 8 : 200;
constexpr float a = 4.0f;
m_worldWidth = 2.0f * gridCount * a;
b3Vec3 position = { 0.0f, 10.0f, 0.0f };
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 10.0f, 5.0f, position );
}
m_launchSpeedScale = 1.0f;
m_mover.Initialize( this, position );
{
constexpr int capsuleCapacity = gridCount * gridCount / 8 + 1;
constexpr int hullCount = gridCount * gridCount;
constexpr int sphereCapacity = gridCount * gridCount / 8 + 1;
b3Vec3 extents = { a, 0.5f * a, a };
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
b3BoxHull box = b3MakeBoxHull( extents.x, extents.y, extents.z );
// Must allocate to avoid stack overflow
b3CompoundCapsuleDef* capsules = new b3CompoundCapsuleDef[capsuleCapacity];
b3CompoundHullDef* hulls = new b3CompoundHullDef[hullCount];
b3CompoundSphereDef* spheres = new b3CompoundSphereDef[sphereCapacity];
b3Transform transform = b3Transform_identity;
int capsuleIndex = 0;
int hullIndex = 0;
int sphereIndex = 0;
for ( int i = 0; i < gridCount; ++i )
{
transform.p.x = ( 2.0f * i - gridCount ) * a;
for ( int j = 0; j < gridCount; ++j )
{
transform.p.z = ( 2.0f * j - gridCount ) * a;
transform.p.y = RandomFloatRange( -0.25f, 0.125f ) * a;
assert( hullIndex < hullCount );
if ( ( i & 1 ) && ( j & 1 ) )
{
b3Vec3 p1 = transform.p + RandomVec3( { -a, a, -a }, { a, 2.0f * a, a } );
b3Vec3 p2 = transform.p + RandomVec3( { -a, a, -a }, { a, 2.0f * a, a } );
float radius = RandomFloatRange( 0.1f, 0.5f );
if ( capsuleIndex < sphereIndex )
{
assert( capsuleIndex < capsuleCapacity );
capsules[capsuleIndex].capsule = { p1, p2, radius };
capsules[capsuleIndex].material = material;
capsuleIndex += 1;
}
else
{
assert( sphereIndex < capsuleCapacity );
spheres[sphereIndex].sphere = { p1, radius };
spheres[sphereIndex].material = material;
sphereIndex += 1;
}
}
hulls[hullIndex].hull = &box.base;
hulls[hullIndex].transform = transform;
hulls[hullIndex].material = material;
hullIndex += 1;
}
}
assert( capsuleIndex <= capsuleCapacity );
assert( hullIndex == hullCount );
assert( sphereIndex <= sphereCapacity );
constexpr int meshGridCount = gridCount / 4;
constexpr int meshCount = meshGridCount * meshGridCount;
constexpr float b = 4.0f * a;
constexpr int materialCapacity = 5;
b3SurfaceMaterial meshMaterials[materialCapacity];
b3MeshData* buildingMesh = CreateMeshData( "data/meshes/building.obj", 1.0f, false, false, true, true );
int materialCount = buildingMesh->materialCount;
assert( materialCount <= materialCapacity );
for ( int i = 0; i < materialCount; ++i )
{
meshMaterials[i] = b3DefaultSurfaceMaterial();
if ( i == 0 )
{
meshMaterials[i].friction = 0.0f;
}
else if ( i == 1 )
{
meshMaterials[i].restitution = 0.5f;
}
meshMaterials[i].userMaterialId = i + 42;
}
b3CompoundMeshDef* meshes = new b3CompoundMeshDef[meshCount];
transform = b3Transform_identity;
int meshIndex = 0;
for ( int i = 0; i < meshGridCount; ++i )
{
transform.p.x = ( 2.0f * i - meshGridCount ) * b + 0.5f * b;
for ( int j = 0; j < meshGridCount; ++j )
{
transform.p.y = 0.5f * a;
transform.p.z = ( 2.0f * j - meshGridCount ) * b + 0.5f * b;
transform.q = b3MakeQuatFromAxisAngle( { 0.0f, 1.0f, 0.0 }, RandomFloatRange( -B3_PI, B3_PI ) );
assert( meshIndex < meshCount );
meshes[meshIndex].meshData = buildingMesh;
meshes[meshIndex].transform = transform;
meshes[meshIndex].scale = RandomVec3( { 0.5f, 0.5f, 0.5f }, { 2.0f, 2.0f, 2.0f } );
if ( meshIndex & 1 )
{
meshes[meshIndex].scale.x = -meshes[meshIndex].scale.x;
}
if ( meshIndex & 3 )
{
meshes[meshIndex].scale.z = -meshes[meshIndex].scale.z;
}
meshes[meshIndex].materials = meshMaterials;
meshes[meshIndex].materialCount = materialCount;
meshIndex += 1;
}
}
assert( meshIndex == meshCount );
b3CompoundDef def = {};
def.capsules = capsules;
def.capsuleCount = capsuleIndex;
def.hullCount = hullCount;
def.hulls = hulls;
def.hullCount = hullCount;
def.meshes = meshes;
def.meshCount = meshCount;
def.spheres = spheres;
def.sphereCount = sphereIndex;
m_compound = b3CreateCompound( &def );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { -1.0f, -0.5f, 2.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( {0.0f, 1.0f, 0.0f}, -1.15f * B3_PI );
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
(void)b3CreateCompoundShape( groundId, &shapeDef, m_compound );
delete[] capsules;
capsules = nullptr;
delete[] hulls;
hulls = nullptr;
delete[] meshes;
meshes = nullptr;
delete[] spheres;
spheres = nullptr;
b3DestroyMesh( buildingMesh );
}
m_rayOrigin = { -0.45f * m_worldWidth, 20.0f, -0.45f * m_worldWidth };
}
~Village() override
{
b3DestroyCompound( m_compound );
}
void Keyboard( int key, int action, int mods ) override
{
if ( key == 'T' && action == 1 )
{
ToggleThirdPerson();
}
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.01f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 4.0f );
DrawTextLine( "surface type = %d", m_userMaterialId );
DrawTextLine( "compound capsules/hulls/meshes/sphere = %d / %d / %d / %d", m_compound->capsuleCount,
m_compound->hullCount, m_compound->meshCount, m_compound->sphereCount );
DrawTextLine( "compound byte count = %d", m_compound->byteCount );
int treeBytes = b3DynamicTree_GetByteCount( &m_compound->tree );
int height = b3DynamicTree_GetHeight( &m_compound->tree );
DrawTextLine( "compound tree byte count = %d, height = %d", treeBytes, height );
}
void Step() override
{
m_mover.Step( nullptr, 0, true );
DrawTextLine( "third person (T) = %d", m_camera->m_thirdPerson );
b3Vec3 translation = { 10.0f, -40.0f, -5.0f };
b3QueryFilter filter = b3DefaultQueryFilter();
{
CastClosestContext context = {};
(void)b3World_CastRay( m_worldId, m_rayOrigin, translation, filter, CastClosestCallback, &context );
DrawLine( m_scene, m_rayOrigin, m_rayOrigin + translation, b3_colorAliceBlue );
if ( context.hit )
{
b3Vec3 p1 = context.point;
b3Vec3 p2 = b3MulAdd( p1, 0.5f, context.normal );
DrawLine( m_scene, p1, p2, b3_colorYellow );
DrawPoint( m_scene, p1, 8.0f, b3_colorLightCoral );
DrawTextLine( "ray hit triangle/child/material = %d / %d / %d", context.triangleIndex, context.childIndex,
context.materialId );
}
else
{
DrawTextLine( "ray miss" );
}
}
{
CastClosestContext context = {};
b3Vec3 origin = b3Sub( m_rayOrigin, { 1.0f, 0.0f, 1.0f } );
b3ShapeProxy proxy = { &origin, 1, 0.25f };
b3World_CastShape( m_worldId, &proxy, translation, filter, CastClosestCallback, &context );
DrawLine( m_scene, origin, origin + translation, b3_colorAliceBlue );
if ( context.hit )
{
b3Vec3 position = b3MulAdd( origin, context.fraction, translation );
b3Vec3 p1 = context.point;
b3Vec3 p2 = b3MulAdd( p1, 0.5f, context.normal );
DrawLine( m_scene, p1, p2, b3_colorYellow );
DrawPoint( m_scene, p1, 8.0f, b3_colorLightCoral );
b3Sphere sphere = { position, 0.25f };
DrawSphere( m_scene, b3Transform_identity, sphere, b3_colorOrchid );
DrawTextLine( "shape hit triangle/child/material = %d / %d / %d", context.triangleIndex, context.childIndex,
context.materialId );
}
else
{
DrawTextLine( "shape miss" );
}
}
{
bool overlap = false;
b3Vec3 origin = { m_rayOrigin.x - 1.0f, 2.0f, m_rayOrigin.z - 1.0f };
b3ShapeProxy proxy = { &origin, 1, 0.3f };
b3World_OverlapShape( m_worldId, &proxy, filter, OverlapResultFcn, &overlap );
b3HexColor color = overlap ? b3_colorDarkMagenta : b3_colorDarkSeaGreen;
b3Sphere sphere = { origin, 0.3f };
DrawSphere( m_scene, b3Transform_identity, sphere, color );
}
if ( m_rayOrigin.x > 0.45f * m_worldWidth )
{
m_rayOrigin.x = -0.45f * m_worldWidth;
m_rayOrigin.z += 8.0f;
}
if ( m_rayOrigin.z > 0.45f * m_worldWidth )
{
m_rayOrigin.z = -0.45f * m_worldWidth;
}
float timeStep = 0.0f;
if ( m_context->pause == false || m_context->singleStep > 0 )
{
timeStep = m_context->hertz > 0.0f ? 1.0f / m_context->hertz : 0.0f;
}
m_rayOrigin.x += 2.0f * timeStep;
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new Village( context );
}
b3Compound* m_compound;
CharacterMover m_mover;
float m_worldWidth;
b3Vec3 m_rayOrigin;
};
static int sampleVillage = SampleManager::Register( "Compound", "Village", Village::Create );

File diff suppressed because it is too large Load diff

View file

@ -0,0 +1,59 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "determinism.h"
#include "sample.h"
#include "scene.h"
#include <stdio.h>
class FallingRagdolls : public Sample
{
public:
explicit FallingRagdolls( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 40.0f, b3Vec3_zero );
}
m_data = CreateFallingRagdolls( m_worldId );
m_done = false;
}
~FallingRagdolls() override
{
DestroyFallingRagdolls( &m_data );
}
void Step( ) override
{
Sample::Step( );
if ( m_done == false )
{
m_done = UpdateFallingRagdolls( m_worldId, &m_data );
if (m_done)
{
printf( "sleep step = %d, hash = 0x%08X\n", m_data.sleepStep, m_data.hash );
}
}
else
{
DrawTextLine( "sleep step = %d, hash = 0x%08X", m_data.sleepStep, m_data.hash );
}
}
static Sample* Create( SampleContext* context )
{
return new FallingRagdolls( context );
}
FallingRagdollData m_data;
bool m_done;
};
static int sampleFallingRagdolls = SampleManager::Register( "Determinism", "Falling Ragdolls", FallingRagdolls::Create );

918
samples/sample_events.cpp Normal file
View file

@ -0,0 +1,918 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "GLFW/glfw3.h"
#include "camera.h"
#include "imgui.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "utils.h"
#include "box3d/box3d.h"
#include <assert.h>
class SensorVisit : public Sample
{
public:
static Sample* Create( SampleContext* context )
{
return new SensorVisit( context );
}
explicit SensorVisit( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 20.0f, { 0.0f, 5.0f, 0.0f } );
}
// Visitor
b3BoxHull dynamicBox = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 12.5f, 0.0f };
b3BodyId dynamicBody = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.enableSensorEvents = true;
b3CreateHullShape( dynamicBody, &shapeDef, &dynamicBox.base );
// Sensor
b3BoxHull sensorBox = b3MakeBoxHull( 2.0f, 2.0f, 2.0f );
bodyDef.type = b3_kinematicBody;
bodyDef.position = { 0.0f, 2.0f, 0.0f };
b3BodyId sensorBody = b3CreateBody( m_worldId, &bodyDef );
shapeDef.isSensor = true;
shapeDef.enableSensorEvents = true;
m_sensorShapeId = b3CreateHullShape( sensorBody, &shapeDef, &sensorBox.base );
}
void Render() override
{
DrawGrid( m_scene, 10 );
Sample::Render();
}
void Step() override
{
Sample::Step();
b3SensorEvents events = b3World_GetSensorEvents( m_worldId );
for ( int i = 0; i < events.beginCount; ++i )
{
b3SensorBeginTouchEvent* event = events.beginEvents + i;
if ( B3_ID_EQUALS( event->sensorShapeId, m_sensorShapeId ) )
{
b3BodyId bodyId = b3Shape_GetBody( event->visitorShapeId );
b3DestroyBody( bodyId );
break;
}
}
}
b3ShapeId m_sensorShapeId;
};
static int sampleSensorVisit = SampleManager::Register( "Events", "Sensor Visit", SensorVisit::Create );
class HitEvent : public Sample
{
public:
enum
{
e_maxEvents = 32,
};
static Sample* Create( SampleContext* context )
{
return new HitEvent( context );
}
explicit HitEvent( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 100.0f, { 0.0f, 5.0f, 0.0f } );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
constexpr int materialCount = 6;
m_gridMesh = b3CreateGridMesh( 20, 20, 8.0f, materialCount, true );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3SurfaceMaterial materials[materialCount];
for ( int i = 0; i < materialCount; ++i )
{
materials[i] = b3DefaultSurfaceMaterial();
materials[i].userMaterialId = i + 1;
}
shapeDef.materials = materials;
shapeDef.materialCount = materialCount;
b3CreateMeshShape( groundId, &shapeDef, m_gridMesh, b3Vec3_one );
// b3BoxHull groundBox = b3MakeTransformedBoxHull( 80.0f, 1.0f, 80.0f, { { 0.0f, -1.0f, 0.0f }, b3Quat_identity } );
// b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
}
b3WeldJointDef jointDef = b3DefaultWeldJointDef();
jointDef.angularHertz = 10.0f;
jointDef.angularDampingRatio = 2.0f;
float r = 0.75f;
float y = r;
float l = 1.5f;
float offset = 0.05f;
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.enableHitEvents = true;
shapeDef.baseMaterial.rollingResistance = 0.2f;
shapeDef.baseMaterial.userMaterialId = 42;
shapeDef.updateBodyMass = false;
b3Vec3 origin = { 0.0f, 0.0f, 0.0f };
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = origin;
b3BodyId prevBodyId = {};
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
int shapeCount = 22;
float velocityScale = 0.5f;
int shapesPerBody = 3;
for ( int i = 0; i < shapeCount; ++i )
{
b3Capsule capsule = { { offset, y, 0.0f }, { 0.0f, y + l, -offset }, r };
b3CreateCapsuleShape( bodyId, &shapeDef, &capsule );
if ( ( i + 1 ) % shapesPerBody == 0 || i == shapeCount - 1 )
{
b3Body_ApplyMassFromShapes( bodyId );
b3Vec3 center = b3Body_GetWorldCenterOfMass( bodyId );
b3Vec3 omega = { 0.0f, 0.0f, -1.0f * velocityScale };
b3Vec3 v = b3Cross( omega, center - origin );
b3Body_SetAngularVelocity( bodyId, omega );
b3Body_SetLinearVelocity( bodyId, v );
if ( i < shapeCount - 1 )
{
prevBodyId = bodyId;
if ( i < shapeCount - 1 )
{
bodyId = b3CreateBody( m_worldId, &bodyDef );
if ( B3_IS_NON_NULL( prevBodyId ) )
{
jointDef.base.bodyIdA = prevBodyId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = { 0.0f, y + l + r, 0.0f };
jointDef.base.localFrameB.p = { 0.0f, y + l + r, 0.0f };
b3CreateWeldJoint( m_worldId, &jointDef );
}
velocityScale *= 0.75f;
}
}
}
y += l + 2.0f * r;
r = 0.95f * r;
offset = -offset;
}
m_eventCount = 0;
}
~HitEvent() override
{
b3DestroyMesh( m_gridMesh );
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.1f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 4.0f );
for ( int i = 0; i < m_eventCount; ++i )
{
// void DrawLine(Scene * Scene, b3Vector3 Vertex1, b3Vector3 Vertex2, b3Color Color);
// void DrawPoint(Scene * Scene, b3Vector3 Point, b3Color Color, float Size);
b3Vec3 p1 = m_events[i].point;
DrawPoint( m_scene, m_events[i].point, 10.0f, b3_colorYellow );
b3Vec3 p2 = p1 - m_events[i].approachSpeed * m_events[i].normal;
DrawLine( m_scene, p1, p2, b3_colorYellow );
DrawWorldString( m_camera, p1, b3_colorWhite, "%.1f, %d", m_events[i].approachSpeed, m_events[i].userMaterialIdA );
}
DrawTextLine( "event count = %d", m_eventCount );
}
void Step() override
{
Sample::Step();
b3ContactEvents events = b3World_GetContactEvents( m_worldId );
for ( int i = 0; i < events.hitCount && m_eventCount < e_maxEvents; ++i )
{
m_events[m_eventCount] = events.hitEvents[i];
m_eventCount += 1;
}
}
static constexpr int m_maxEvents = 32;
b3MeshData* m_gridMesh;
b3ContactHitEvent m_events[m_maxEvents] = {};
int m_eventCount;
};
static int sampleHitEvent = SampleManager::Register( "Events", "Hit", HitEvent::Create );
class MoveEvent : public Sample
{
public:
explicit MoveEvent( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 40.0f, { 0.0f, 5.0f, 0.0f } );
EnableGrid( m_scene, true );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
b3ShapeDef shapeDef = b3DefaultShapeDef();
bodyDef.type = b3_staticBody;
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundBody = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull groundBox = b3MakeBoxHull( 40.0f, 1.0f, 40.0f );
b3CreateHullShape( groundBody, &shapeDef, &groundBox.base );
b3Vec3 pivot = { 0.0f, 1.0f, 0.0f };
bodyDef.type = b3_dynamicBody;
bodyDef.position = pivot;
bodyDef.name = "big box";
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
m_localPivot = b3Body_GetLocalPoint( m_bodyId, pivot );
shapeDef.enableHitEvents = true;
b3BoxHull dynamicBox = b3MakeTransformedBoxHull( 0.5f, 10.0f, 0.5f, { { 0.0f, 10.0f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( m_bodyId, &shapeDef, &dynamicBox.base );
b3Vec3 center = b3Body_GetWorldCenterOfMass( m_bodyId );
b3Vec3 r = pivot - center;
float rr = b3LengthSquared( r );
if ( rr > 0.0f )
{
b3Vec3 v = { -10.0f, 0.0f, 0.0f };
b3Vec3 omega = ( 1.0f / rr ) * b3Cross( v, r );
b3Body_SetAngularVelocity( m_bodyId, omega );
b3Body_SetLinearVelocity( m_bodyId, v );
}
}
void Render() override
{
Sample::Render();
b3Transform transform = { { 0.0f, 0.1f, 0.0f }, b3Quat_identity };
DrawTransform( m_scene, transform, 4.0f );
b3Vec3 vp = b3Body_GetLocalPointVelocity( m_bodyId, m_localPivot );
b3Vec3 v = b3Body_GetLinearVelocity( m_bodyId );
b3Vec3 omega = b3Body_GetAngularVelocity( m_bodyId );
DrawTextLine( "vp = [%.2f, %.2f, %.2f], v = [%.2f, %.2f, %.2f], w = [%.2f, %.2f, %.2f]", vp.x, vp.y, vp.z, v.x, v.y, v.z,
omega.x, omega.y, omega.z );
}
void Step() override
{
Sample::Step();
b3BodyEvents moveEvents = b3World_GetBodyEvents( m_worldId );
for ( int i = 0; i < moveEvents.moveCount; ++i )
{
b3BodyId body = moveEvents.moveEvents[i].bodyId;
if ( moveEvents.moveEvents[i].fellAsleep )
{
DrawTextLine( "%s fell asleep", b3Body_GetName( body ) );
}
else
{
DrawTextLine( "%s moved", b3Body_GetName( body ) );
}
}
}
static Sample* Create( SampleContext* context )
{
return new MoveEvent( context );
}
b3BodyId m_bodyId;
b3Vec3 m_localPivot;
};
static int sampleMoveEvent = SampleManager::Register( "Events", "Move", MoveEvent::Create );
// This sample shows how to break joints when the internal reaction force becomes large. Instead of polling, this uses events.
class JointEvent : public Sample
{
public:
enum
{
e_count = 6
};
explicit JointEvent( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 40.0f, { 0.0f, 5.0f, 0.0f } );
EnableGrid( m_scene, true );
}
b3BodyId groundId;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeTransformedBoxHull( 20.0f, 1.0f, 20.0f, { { 0.0f, -1.0f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
for ( int i = 0; i < e_count; ++i )
{
m_jointIds[i] = b3_nullJointId;
}
b3Vec3 position = { -12.5f, 10.0, 0.0f };
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.enableSleep = false;
b3BoxHull box = b3MakeBoxHull( 1.0f, 1.0f, 0.5f );
int index = 0;
float forceThreshold = 3000.0f;
float torqueThreshold = 10000.0f;
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1.0f;
// distance joint
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
float length = 2.0f;
b3Vec3 pivot1 = { position.x, position.y + 1.0f + length, 0.0f };
b3Vec3 pivot2 = { position.x, position.y + 1.0f, 0.0f };
b3DistanceJointDef jointDef = b3DefaultDistanceJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( jointDef.base.bodyIdA, pivot1 );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( jointDef.base.bodyIdB, pivot2 );
jointDef.length = length;
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreateDistanceJoint( m_worldId, &jointDef );
}
position.x += 5.0f;
++index;
// motor joint
#if 0
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3MotorJointDef jointDef = b3DefaultMotorJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = position;
jointDef.maxForce = 1000.0f;
jointDef.maxTorque = 20.0f;
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreateMotorJoint( m_worldId, &jointDef );
}
#else
m_jointIds[index] = {};
#endif
position.x += 5.0f;
++index;
// prismatic joint
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3Vec3 pivot = { position.x - 1.0f, position.y, 0.0f };
b3PrismaticJointDef jointDef = b3DefaultPrismaticJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( jointDef.base.bodyIdA, pivot );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( jointDef.base.bodyIdB, pivot );
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreatePrismaticJoint( m_worldId, &jointDef );
}
position.x += 5.0f;
++index;
// revolute joint
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3Vec3 pivot = { position.x - 1.0f, position.y, 0.0f };
b3RevoluteJointDef jointDef = b3DefaultRevoluteJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( jointDef.base.bodyIdA, pivot );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( jointDef.base.bodyIdB, pivot );
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreateRevoluteJoint( m_worldId, &jointDef );
}
position.x += 5.0f;
++index;
// weld joint
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3Vec3 pivot = { position.x - 1.0f, position.y, 0.0f };
b3WeldJointDef jointDef = b3DefaultWeldJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( jointDef.base.bodyIdA, pivot );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( jointDef.base.bodyIdB, pivot );
jointDef.angularHertz = 2.0f;
jointDef.angularDampingRatio = 0.5f;
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreateWeldJoint( m_worldId, &jointDef );
}
position.x += 5.0f;
++index;
// wheel joint
#if 0
{
assert( index < e_count );
bodyDef.position = position;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
b3Vec3 pivot = { position.x - 1.0f, position.y, 0.0f };
b3WheelJointDef jointDef = b3DefaultWheelJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( jointDef.base.bodyIdA, pivot );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( jointDef.base.bodyIdB, pivot );
jointDef.hertz = 1.0f;
jointDef.dampingRatio = 0.7f;
jointDef.lowerTranslation = -1.0f;
jointDef.upperTranslation = 1.0f;
jointDef.enableLimit = true;
jointDef.enableMotor = true;
jointDef.maxMotorTorque = 10.0f;
jointDef.motorSpeed = 1.0f;
jointDef.base.forceThreshold = forceThreshold;
jointDef.base.torqueThreshold = torqueThreshold;
jointDef.base.collideConnected = true;
jointDef.base.userData = (void*)(intptr_t)index;
m_jointIds[index] = b3CreateWheelJoint( m_worldId, &jointDef );
}
#else
m_jointIds[index] = {};
#endif
position.x += 5.0f;
++index;
}
void Step() override
{
Sample::Step();
// Process joint events
b3JointEvents events = b3World_GetJointEvents( m_worldId );
for ( int i = 0; i < events.count; ++i )
{
// Destroy the joint if it is still valid
const b3JointEvent* event = events.jointEvents + i;
if ( b3Joint_IsValid( event->jointId ) )
{
int index = (int)(intptr_t)event->userData;
assert( 0 <= index && index < e_count );
b3DestroyJoint( event->jointId, true );
m_jointIds[index] = b3_nullJointId;
}
}
}
static Sample* Create( SampleContext* context )
{
return new JointEvent( context );
}
b3JointId m_jointIds[e_count];
};
static int sampleJointEvent = SampleManager::Register( "Events", "Joint", JointEvent::Create );
class PersistentContact : public Sample
{
public:
explicit PersistentContact( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 40.0f, { 0.0f, 5.0f, 0.0f } );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
m_meshData = b3CreateGridMesh( 20, 20, 2.0f, 2, true );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateMeshShape( groundId, &shapeDef, m_meshData, b3Vec3_one );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { -18.0f, 1.0f, 0.5f };
bodyDef.linearVelocity = { 4.0f, 0.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 20.0f;
shapeDef.enableContactEvents = true;
shapeDef.baseMaterial.rollingResistance = 0.01f;
b3Sphere sphere = { b3Vec3_zero, 0.5f };
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
m_contactId = b3_nullContactId;
}
~PersistentContact() override
{
b3DestroyMesh( m_meshData );
}
void Step() override
{
Sample::Step();
b3ContactEvents events = b3World_GetContactEvents( m_worldId );
for ( int i = 0; i < events.beginCount && i < 1; ++i )
{
m_contactId = events.beginEvents[i].contactId;
}
for ( int i = 0; i < events.endCount; ++i )
{
if ( B3_ID_EQUALS( m_contactId, events.endEvents[i].contactId ) )
{
m_contactId = b3_nullContactId;
break;
}
}
if ( B3_IS_NON_NULL( m_contactId ) && b3Contact_IsValid( m_contactId ) )
{
b3ContactData data = b3Contact_GetData( m_contactId );
b3Vec3 centerOfMass = b3Body_GetWorldCenterOfMass( b3Shape_GetBody( data.shapeIdA ) );
for ( int i = 0; i < data.manifoldCount; ++i )
{
const b3Manifold* manifold = data.manifolds + i;
b3Vec3 normal = manifold->normal;
for ( int j = 0; j < manifold->pointCount; ++j )
{
const b3ManifoldPoint* manifoldPoint = manifold->points + i;
b3Vec3 p1 = manifoldPoint->anchorA + centerOfMass;
b3Vec3 p2 = p1 + manifoldPoint->totalNormalImpulse * normal;
DrawLine( m_scene, p1, p2, b3_colorCrimson );
DrawPoint( m_scene, p1, 6.0f, b3_colorCrimson );
DrawWorldString( m_camera, p1, b3_colorGray, "%.2f", manifoldPoint->totalNormalImpulse );
}
}
}
else
{
m_contactId = b3_nullContactId;
}
}
static Sample* Create( SampleContext* context )
{
return new PersistentContact( context );
}
b3ContactId m_contactId;
b3MeshData* m_meshData;
};
static int samplePersistentContact = SampleManager::Register( "Events", "Persistent Contact", PersistentContact::Create );
class SensorHits : public Sample
{
public:
explicit SensorHits( SampleContext* context )
: Sample( context )
, m_transforms{}
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 40.0f, { 0.0f, 5.0f, 0.0f } );
EnableGrid( m_scene, true );
}
b3BodyId groundId;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull groundBox = b3MakeOffsetBoxHull( 10.0f, 1.0f, 10.0f, {0.0f, -1.0f, 0.0f} );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
b3BoxHull wallBox = b3MakeTransformedBoxHull( 0.1f, 5.0f, 5.0f, { { 10.0f, 5.0f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( groundId, &shapeDef, &wallBox.base );
}
m_gridMesh = b3CreateGridMesh( 2, 2, 5.0f, 0, true );
// Static sensor
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "static sensor";
bodyDef.position = { -4.0f, 6.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI );
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.isSensor = true;
shapeDef.enableSensorEvents = true;
m_staticSensorId = b3CreateMeshShape( bodyId, &shapeDef, m_gridMesh, b3Vec3_one );
}
// Kinematic sensor
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "kinematic sensor";
bodyDef.type = b3_kinematicBody;
bodyDef.position = { 0.0f, 6.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI );
bodyDef.linearVelocity = { 0.5f, 0.0f };
m_kinematicBodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.isSensor = true;
shapeDef.enableSensorEvents = true;
m_kinematicSensorId = b3CreateMeshShape( m_kinematicBodyId, &shapeDef, m_gridMesh, b3Vec3_one );
}
// Dynamic sensor
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "dynamic sensor";
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 4.0f, 1.0f };
m_dynamicBodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.isSensor = true;
shapeDef.enableSensorEvents = true;
b3Capsule capsule = { { 0.0f, 1.0f }, { 0.0f, 9.0f }, 0.1f };
m_dynamicSensorId = b3CreateCapsuleShape( m_dynamicBodyId, &shapeDef, &capsule );
b3Vec3 pivot = bodyDef.position + b3Vec3{ 0.0f, 6.0f, 0.0f };
b3PrismaticJointDef jointDef = b3DefaultPrismaticJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.bodyIdB = m_dynamicBodyId;
jointDef.base.localFrameA.p = b3Body_GetLocalPoint( groundId, pivot );
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( m_dynamicBodyId, pivot );
jointDef.enableMotor = true;
jointDef.maxMotorForce = 1000.0f;
jointDef.motorSpeed = 0.5f;
m_jointId = b3CreatePrismaticJoint( m_worldId, &jointDef );
}
m_beginCount = 0;
m_endCount = 0;
m_bodyId = {};
m_shapeId = {};
m_transformCount = 0;
m_isBullet = true;
Launch();
}
~SensorHits() override
{
b3DestroyMesh( m_gridMesh );
}
void Launch()
{
if ( B3_IS_NON_NULL( m_bodyId ) )
{
b3DestroyBody( m_bodyId );
}
m_transformCount = 0;
m_beginCount = 0;
m_endCount = 0;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { -26.7f, 6.0f };
float speed = RandomFloatRange( 200.0f, 300.0f );
bodyDef.linearVelocity = { speed, 0.0f };
bodyDef.isBullet = m_isBullet;
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.enableSensorEvents = true;
shapeDef.baseMaterial.friction = 0.8f;
shapeDef.baseMaterial.rollingResistance = 0.01f;
b3Sphere sphere = { { 0.0f, 0.0f }, 0.25f };
m_shapeId = b3CreateSphereShape( m_bodyId, &shapeDef, &sphere );
}
void UpdateUI() override
{
float height = 120.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_context->camera.m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 120.0f, height ) );
ImGui::Begin( "Sensor Hit", nullptr, ImGuiWindowFlags_NoResize );
ImGui::Checkbox( "Bullet", &m_isBullet );
if ( ImGui::Button( "Launch" ) || glfwGetKey( m_context->window, GLFW_KEY_B ) == GLFW_PRESS )
{
Launch();
}
ImGui::End();
}
void CollectTransforms( b3ShapeId sensorShapeId )
{
constexpr int capacity = 5;
b3ShapeId visitorIds[capacity];
int count = b3Shape_GetSensorData( sensorShapeId, visitorIds, capacity );
for ( int i = 0; i < count && m_transformCount < m_transformCapacity; ++i )
{
b3BodyId sensorBodyId = b3Shape_GetBody( sensorShapeId );
m_transforms[m_transformCount] = b3Body_GetTransform( sensorBodyId );
m_transforms[m_transformCount].p = b3Body_GetWorldCenterOfMass( sensorBodyId );
m_transformCount += 1;
}
}
void Step() override
{
b3Vec3 p = b3Body_GetPosition( m_kinematicBodyId );
if ( p.x > 1.0f )
{
b3Body_SetLinearVelocity( m_kinematicBodyId, { -0.5f, 0.0f } );
}
else if ( p.x < -1.0f )
{
b3Body_SetLinearVelocity( m_kinematicBodyId, { 0.5f, 0.0f } );
}
float x = b3PrismaticJoint_GetTranslation( m_jointId );
if ( x > 1.0f )
{
b3PrismaticJoint_SetMotorSpeed( m_jointId, -0.5f );
}
else if ( x < -1.0f )
{
b3PrismaticJoint_SetMotorSpeed( m_jointId, 0.5f );
}
Sample::Step();
for ( int i = 0; i < m_transformCount; ++i )
{
DrawTransform( m_scene, m_transforms[i], 0.1f );
}
b3SensorEvents sensorEvents = b3World_GetSensorEvents( m_worldId );
m_beginCount += sensorEvents.beginCount;
m_endCount += sensorEvents.endCount;
for ( int i = 0; i < sensorEvents.beginCount; ++i )
{
const b3SensorBeginTouchEvent* event = sensorEvents.beginEvents + i;
CollectTransforms( event->sensorShapeId );
}
DrawTextLine( "begin touch count = %d", m_beginCount );
DrawTextLine( "end touch count = %d", m_endCount );
}
static Sample* Create( SampleContext* context )
{
return new SensorHits( context );
}
b3MeshData* m_gridMesh;
b3ShapeId m_staticSensorId;
b3ShapeId m_kinematicSensorId;
b3ShapeId m_dynamicSensorId;
b3BodyId m_kinematicBodyId;
b3BodyId m_dynamicBodyId;
b3JointId m_jointId;
b3BodyId m_bodyId;
b3ShapeId m_shapeId;
static constexpr int m_transformCapacity = 20;
int m_transformCount;
b3Transform m_transforms[m_transformCapacity];
bool m_isBullet;
int m_beginCount;
int m_endCount;
};
static int sampleSensorHits = SampleManager::Register( "Events", "Sensor Hits", SensorHits::Create );

651
samples/sample_geometry.cpp Normal file
View file

@ -0,0 +1,651 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "utils.h"
#include <imgui.h>
class BoxHull : public Sample
{
public:
explicit BoxHull( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_hull = nullptr;
m_halfWidths = { 1.0f, 0.5f, 0.25f };
m_postScale = { 1.0f, 1.0f, 1.0f };
m_rotation = { 0.0f, 0.0f, 0.0f };
m_transform = b3Transform_identity;
UpdateRotation();
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
~BoxHull() override
{
b3DestroyHull( m_hull );
}
void UpdateRotation()
{
b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisX, B3_DEG_TO_RAD * m_rotation.x );
b3Quat qy = b3MakeQuatFromAxisAngle( b3Vec3_axisY, B3_DEG_TO_RAD * m_rotation.y );
b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, B3_DEG_TO_RAD * m_rotation.z );
m_transform.q = b3MulQuat( qz, b3MulQuat( qy, qx ) );
}
void CreateHulls( b3Vec3 h, b3Transform transform, b3Vec3 postScale )
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
m_hull = nullptr;
}
b3Vec3 scale = b3SafeScale( postScale );
b3Vec3 points[8];
points[0] = scale * b3TransformPoint( transform, { h.x, h.y, h.z } );
points[1] = scale * b3TransformPoint( transform, { h.x, h.y, -h.z } );
points[2] = scale * b3TransformPoint( transform, { h.x, -h.y, h.z } );
points[3] = scale * b3TransformPoint( transform, { h.x, -h.y, -h.z } );
points[4] = scale * b3TransformPoint( transform, { -h.x, h.y, h.z } );
points[5] = scale * b3TransformPoint( transform, { -h.x, h.y, -h.z } );
points[6] = scale * b3TransformPoint( transform, { -h.x, -h.y, h.z } );
points[7] = scale * b3TransformPoint( transform, { -h.x, -h.y, -h.z } );
m_hull = b3CreateHull( points, 8, 8 );
m_box = b3MakeScaledBoxHull( h, transform, postScale );
}
void UpdateUI() override
{
float height = 180.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 350.0f, height ) );
ImGui::Begin( "Box Hull", nullptr, 0 );
ImGui::PushItemWidth( 320.0f );
if ( ImGui::SliderFloat3( "h", &m_halfWidths.x, 0.1f, 2.0f, "%.1f" ) )
{
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
if ( ImGui::SliderFloat3( "c", &m_transform.p.x, -2.0f, 2.0f, "%.1f" ) )
{
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
if ( ImGui::SliderFloat3( "r", &m_rotation.x, -180.0f, 180.0f, "%.0f" ) )
{
UpdateRotation();
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
if ( ImGui::SliderFloat3( "s", &m_postScale.x, -2.0f, 2.0f, "%.1f" ) )
{
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
ImGui::PopItemWidth();
if ( ImGui::Button( "refresh" ) )
{
CreateHulls( m_halfWidths, m_transform, m_postScale );
}
ImGui::End();
}
void Render() override
{
DrawHull( m_scene, b3Transform_identity, m_hull, b3_colorYellow, true );
DrawHull( m_scene, b3Transform_identity, &m_box.base, b3_colorCyan, true );
DrawTransform( m_scene, b3Transform_identity, 1.0f );
Sample::Render();
}
static Sample* Create( SampleContext* sampleContext )
{
return new BoxHull( sampleContext );
}
b3Vec3 m_halfWidths;
b3Vec3 m_rotation;
b3Transform m_transform;
b3Vec3 m_postScale;
b3BoxHull m_box;
b3Hull* m_hull;
};
static int sampleBoxHull = SampleManager::Register( "Geometry", "Box Hull", BoxHull::Create );
class Hull : public Sample
{
public:
explicit Hull( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_hull = nullptr;
// this fails because it generates too many edges
b3Vec3 points[] = {
{ -3.9866004, 75.4595108, 28.3783073 }, { -13.1079493, 73.080368, 28.296587 },
{ -18.6611958, 72.0040894, 16.9292431 }, { 4.82537603, 79.2908554, 22.2369995 },
{ -12.7315464, 79.2187576, 2.94275379 }, { -21.806488, 78.7758865, 0.985544085 },
{ -27.7619209, 73.3481522, 11.9647141 }, { -22.3994541, 72.2203826, 21.4116211 },
{ -25.3797474, 76.7417755, 27.9124985 }, { -22.7552319, 77.0559006, 29.4733639 },
{ -6.81736374, 78.3484726, 36.8649979 }, { 3.62397718, 85.5270843, 29.2077713 },
{ 7.90363788, 84.121231, 18.2612896 }, { -12.3809223, 84.5280533, -0.43230924 },
{ 5.83599472, 95.2908325, 4.4423275 }, { -22.5541401, 89.9094467, -4.87791252 },
{ -43.9060402, 78.5287094, 1.32877088 }, { -42.6015129, 76.7829742, 7.67437983 },
{ -25.735527, 78.1218796, 27.908411 }, { -23.5183544, 77.6326675, 29.1178799 },
{ 2.0977366, 100.430191, 34.3929482 }, { 1.09743047, 103.952553, 35.5656395 },
{ 8.50175952, 96.0529861, 8.73674774 }, { 2.52570295, 103.303696, 32.2314339 },
{ -20.099781, 89.4923248, -4.15468454 }, { 2.8092947, 123.516098, -1.12693477 },
{ -43.9318161, 79.1106186, 1.39006138 }, { -23.358511, 90.9599686, -4.25683546 },
{ 2.10804915, 123.603645, -1.38435471 }, { -44.1329117, 78.7192383, 1.54941654 },
{ -42.4365158, 77.725357, 8.14835929 }, { -43.204792, 77.5811691, 7.14319515 },
{ -44.17416, 78.7810363, 2.50146222 }, { -32.8975143, 99.1221771, 7.55588436 },
{ -0.624746263, 110.070351, 32.7381058 }, { 0.00431228895, 109.14341, 33.6411133 },
{ -0.58865279, 122.980537, 16.6554794 }, { 2.18539238, 124.324593, -0.620266676 },
{ -1.02177501, 123.881721, 16.8230057 }, { 1.9842999, 124.571777, -0.321986318 },
{ 1.86570692, 124.365791, -0.599836588 }, { -43.591507, 78.1373291, 6.1135149 },
{ -43.8235397, 79.2239074, 3.48619604 }, { -43.591507, 78.50811, 5.54555655 },
{ 1.21086729, 124.49453, 1.07543683 }, { -1.86223853, 124.195847, 15.6257992 },
{ -1.46520972, 124.355492, 16.9864483 }, { 1.654302, 124.612976, 0.621887207 },
};
static_assert( sizeof( points ) / sizeof( points[0] ) < m_capacity, "bad" );
m_count = sizeof( points ) / sizeof( points[0] );
for ( int i = 0; i < m_count; ++i )
{
m_points[i] = 0.01f * points[i];
}
// This shift shouldn't be necessary but I'm doing it so the hull
// appears on the screen.
// for ( int i = 0; i < m_count; ++i )
//{
// m_points[i] -= m_points[0];
// m_points[i] *= 0.01f;
//}
m_hull = b3CreateHull( m_points, m_count, 16 );
(void)m_hull;
}
~Hull() override
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
}
}
void Render() override
{
if ( m_hull != nullptr )
{
DrawHull( m_scene, b3Transform_identity, m_hull, b3_colorYellow, true );
}
DrawTransform( m_scene, b3Transform_identity, 1.0f );
Sample::Render();
}
static Sample* Create( SampleContext* sampleContext )
{
return new Hull( sampleContext );
}
static constexpr int m_capacity = 64;
b3Hull* m_hull;
b3Vec3 m_points[m_capacity];
int m_count;
};
static int sampleHull = SampleManager::Register( "Geometry", "Hull", Hull::Create );
class HullReduction : public Sample
{
public:
enum Type
{
e_box,
e_sphere,
};
explicit HullReduction( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_hull = nullptr;
m_type = e_sphere;
m_count = 16;
GeneratePoints();
GenerateHull();
}
void GeneratePoints()
{
g_randomSeed = 42;
if ( m_type == e_box )
{
b3Vec3 lower = { -2.0f, -2.0f, -2.0f };
b3Vec3 upper = { 2.0f, 2.0f, 2.0f };
b3AABB box = { { -1.0f, -1.0f, -1.0f }, { 1.0f, 1.0f, 1.0f } };
float a = 0.001f;
b3AABB noise = { { -a, -a, -a }, { a, a, a } };
for ( int i = 0; i < m_capacity; ++i )
{
b3Vec3 p = RandomVec3( lower, upper );
p = b3Clamp( p, box.lowerBound, box.upperBound );
b3Vec3 f = RandomVec3( noise.lowerBound, noise.upperBound );
m_points[i] = b3Add(p, f);
}
}
else
{
for ( int i = 0; i < m_capacity; ++i )
{
m_points[i] = RandomUnitVector();
}
}
}
void GenerateHull()
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
}
m_hull = b3CreateHull( m_points, m_capacity, m_count );
}
~HullReduction() override
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
}
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 12.0f * fontSize;
ImGui::SetNextWindowPos( { 1.0f * fontSize, m_camera->m_height - height - 3.0f * fontSize }, ImGuiCond_Once );
ImGui::SetNextWindowSize( { 16.0f * fontSize, height } );
ImGui::Begin( "Hull Reduction", nullptr, ImGuiWindowFlags_NoResize );
if ( ImGui::RadioButton( "Box", m_type == e_box ) )
{
m_type = e_box;
GeneratePoints();
GenerateHull();
}
if ( ImGui::RadioButton( "Sphere", m_type == e_sphere ) )
{
m_type = e_sphere;
GeneratePoints();
GenerateHull();
}
if ( ImGui::SliderInt( "count", &m_count, 4, m_capacity ) )
{
GenerateHull();
}
ImGui::End();
}
void Render() override
{
if ( m_hull != nullptr )
{
DrawHull( m_scene, b3Transform_identity, m_hull, b3_colorYellow, true );
DrawTextLine( "v/f/e = %d/%d/%d", m_hull->vertexCount, m_hull->faceCount, m_hull->edgeCount / 2 );
}
DrawTransform( m_scene, b3Transform_identity, 1.0f );
Sample::Render();
}
static Sample* Create( SampleContext* sampleContext )
{
return new HullReduction( sampleContext );
}
static constexpr int m_capacity = 128;
Type m_type;
b3Hull* m_hull;
b3Vec3 m_points[m_capacity];
int m_count;
};
static int sampleHullReduction = SampleManager::Register( "Geometry", "Hull Reduction", HullReduction::Create );
class HullScale : public Sample
{
public:
explicit HullScale( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_original = b3CreateCylinder( 1.0f, 0.5f, 0.0f, 9 );
m_box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
// m_original = &m_box.base;
m_scale = { 1.0f, 1.0f, 1.0f };
m_angles = b3Vec3_zero;
m_offset = b3Vec3_zero;
m_hull = b3CloneAndTransformHull( m_original, b3Transform_identity, m_scale );
}
~HullScale() override
{
if ( m_original != &m_box.base )
{
b3DestroyHull( m_original );
}
b3DestroyHull( m_hull );
}
void UpdateHull()
{
b3DestroyHull( m_hull );
b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisX, m_angles.x * B3_PI / 180.0f );
b3Quat qy = b3MakeQuatFromAxisAngle( b3Vec3_axisY, m_angles.y * B3_PI / 180.0f );
b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, m_angles.z * B3_PI / 180.0f );
b3Quat q = b3MulQuat( qz, b3MulQuat( qy, qx ) );
m_hull = b3CloneAndTransformHull( m_original, { m_offset, q }, m_scale );
}
void Render() override
{
b3Transform transform1 = { { -2.0f, 0.0f, 0.0f }, b3Quat_identity };
b3Transform transform2 = { { 2.0f, 0.0f, 0.0f }, b3Quat_identity };
DrawHull( m_scene, transform1, m_original, b3_colorGreen, true );
DrawHull( m_scene, transform2, m_hull, b3_colorYellow, true );
DrawTransform( m_scene, b3Transform_identity, 1.0f );
DrawTextLine( "hull 1: area = %g, volume = %g, radius = %g", m_original->surfaceArea, m_original->volume,
m_original->innerRadius );
DrawTextLine( "hull 2: area = %g, volume = %g, radius = %g", m_hull->surfaceArea, m_hull->volume, m_hull->innerRadius );
Sample::Render();
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 18.0f * fontSize;
ImGui::SetNextWindowPos( { 1.0f * fontSize, m_camera->m_height - height - 3.0f * fontSize }, ImGuiCond_Once );
ImGui::SetNextWindowSize( { 18.0f * fontSize, height } );
ImGui::Begin( "Hull Scale", nullptr, ImGuiWindowFlags_NoResize );
if ( ImGui::SliderFloat( "sx", &m_scale.x, -2.0f, 2.0f, "%.1f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "sy", &m_scale.y, -2.0f, 2.0f, "%.1f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "sz", &m_scale.z, -2.0f, 2.0f, "%.1f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "rx", &m_angles.x, -180.0f, 180.0f, "%.0f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "ry", &m_angles.y, -180.0f, 180.0f, "%.0f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "rz", &m_angles.z, -180.0f, 180.0f, "%.0f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "px", &m_offset.x, -1.0f, 1.0f, "%.1f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "py", &m_offset.y, -1.0f, 1.0f, "%.1f" ) )
{
UpdateHull();
}
if ( ImGui::SliderFloat( "pz", &m_offset.z, -1.0f, 1.0f, "%.1f" ) )
{
UpdateHull();
}
ImGui::End();
}
static Sample* Create( SampleContext* sampleContext )
{
return new HullScale( sampleContext );
}
b3BoxHull m_box;
b3Hull* m_original;
b3Hull* m_hull;
b3Vec3 m_angles;
b3Vec3 m_scale;
b3Vec3 m_offset;
};
static int sampleHullScale = SampleManager::Register( "Geometry", "Hull Scale", HullScale::Create );
class CapsuleMass : public Sample
{
public:
explicit CapsuleMass( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_radius = 1.0f;
m_length = 2.0f;
m_sides = 6;
m_capsule = { { -0.5f * m_length, 0.0f, 0.0f }, { 0.5f * m_length, 0.0f, 0.0f }, m_radius };
m_box = b3MakeBoxHull( m_radius + 0.5f * m_length, m_radius, m_radius );
m_hull = nullptr;
CreateCapsuleHull( m_sides );
}
~CapsuleMass() override
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
}
}
void CreateCapsuleHull( int sides )
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
m_hull = nullptr;
}
constexpr int N = m_maxSides;
constexpr int M = 2 * N * N;
b3Vec3 points[M];
if ( sides > N )
{
return;
}
int count = 2 * sides * sides;
float d = B3_PI / ( sides - 1.0f );
float angle1 = -0.5f * B3_PI;
int index = 0;
for ( int i = 0; i < sides; ++i )
{
float s1 = sinf( angle1 );
float c1 = cosf( angle1 );
float angle2 = -0.5f * B3_PI;
for ( int j = 0; j < sides; ++j )
{
points[index].x = 1.0f + m_radius * c1;
points[index].y = m_radius * s1 * cosf( angle2 );
points[index].z = m_radius * s1 * sinf( angle2 );
angle2 += d;
index += 1;
}
angle1 += d;
}
angle1 = 0.5f * B3_PI;
for ( int i = 0; i < sides; ++i )
{
float s1 = sinf( angle1 );
float c1 = cosf( angle1 );
float angle2 = -0.5f * B3_PI;
for ( int j = 0; j < sides; ++j )
{
points[index].x = -1.0f + m_radius * c1;
points[index].y = m_radius * s1 * cosf( angle2 );
points[index].z = m_radius * s1 * sinf( angle2 );
angle2 += d;
index += 1;
}
angle1 += d;
}
assert( index == count );
m_hull = b3CreateHull( points, count, count );
}
void Render() override
{
DrawCapsule( m_scene, b3Transform_identity, m_capsule, b3_colorAqua );
DrawHull( m_scene, b3Transform_identity, &m_box.base, b3_colorBlueViolet, true );
if ( m_hull != nullptr )
{
DrawHull( m_scene, b3Transform_identity, m_hull, b3_colorYellow, true );
}
DrawTransform( m_scene, b3Transform_identity, 1.0f );
if ( m_hull != nullptr )
{
b3MassData lowerMassData = b3ComputeHullMass( m_hull, 1.0f );
b3MassData massData = b3ComputeCapsuleMass( &m_capsule, 1.0f );
b3MassData upperMassData = b3ComputeHullMass( &m_box.base, 1.0f );
DrawTextLine( "mass hull: %g", lowerMassData.mass );
DrawTextLine( "mass capsule: %g", massData.mass );
DrawTextLine( "mass box: %g", upperMassData.mass );
m_textLine += m_textIncrement;
DrawTextLine( "Ixx hull: %g", lowerMassData.inertia.cx.x );
DrawTextLine( "Ixx capsule: %g", massData.inertia.cx.x );
DrawTextLine( "Ixx box: %g", upperMassData.inertia.cx.x );
m_textLine += m_textIncrement;
DrawTextLine( "Iyy hull: %g", lowerMassData.inertia.cy.y );
DrawTextLine( "Iyy capsule: %g", massData.inertia.cy.y );
DrawTextLine( "Iyy box: %g", upperMassData.inertia.cy.y );
m_textLine += m_textIncrement;
DrawTextLine( "Izz hull: %g", lowerMassData.inertia.cz.z );
DrawTextLine( "Izz capsule: %g", massData.inertia.cz.z );
DrawTextLine( "Izz box: %g", upperMassData.inertia.cz.z );
}
Sample::Render();
}
void UpdateUI() override
{
float height = 180.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 350.0f, height ) );
ImGui::Begin( "Mass Data", nullptr, 0 );
if ( ImGui::SliderInt( "sides", &m_sides, 3, m_maxSides ) )
{
CreateCapsuleHull( m_sides );
}
ImGui::End();
}
static Sample* Create( SampleContext* sampleContext )
{
return new CapsuleMass( sampleContext );
}
// Limited by edge count
static constexpr int m_maxSides = 6;
b3Capsule m_capsule;
b3BoxHull m_box;
b3Hull* m_hull;
float m_radius;
float m_length;
int m_sides;
};
static int sampleCapsuleMass = SampleManager::Register( "Geometry", "Capsule Mass", CapsuleMass::Create );

401
samples/sample_issues.cpp Normal file
View file

@ -0,0 +1,401 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "imgui.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
#include <vector>
class DumpLoader : public Sample
{
public:
explicit DumpLoader( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 15.0f, { 0.0f, 2.0f, 0.0f } );
//m_camera->SetView( 45.0f, 30.0f, 300.0f, { 3910.62109f, 9862.50293f, 875.395081f } );
}
b3SetLengthUnitsPerMeter( 1.0f );
const char* dumpPrefix = "data/dumps/single_box/";
#include "dumps/single_box/box3d_dump.inl"
}
~DumpLoader() override
{
for (b3MeshData* md : m_meshes)
{
b3DestroyMesh( md );
}
b3SetLengthUnitsPerMeter( 1.0f );
}
static Sample* Create( SampleContext* context )
{
return new DumpLoader( context );
}
std::vector<b3MeshData*> m_meshes;
};
static int sampleDumpLoader = SampleManager::Register( "Issues", "Dump Loader", DumpLoader::Create );
class Crash : public Sample
{
public:
explicit Crash( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 15.0f, { 0.0f, 2.0f, 0.0f } );
}
b3BodyId groundId;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_gridMesh = b3CreateGridMesh( 20, 20, 2, 0, true );
b3CreateMeshShape( groundId, &shapeDef, m_gridMesh, b3Vec3_one );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 2.0f, 4.0f, 0.0f };
m_bodyId1 = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
b3CreateHullShape( m_bodyId1, &shapeDef, &box.base );
bodyDef.position = { -2.0f, 4.0f, 0.0f };
m_bodyId2 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( m_bodyId2, &shapeDef, &box.base );
}
~Crash() override
{
b3DestroyMesh( m_gridMesh );
}
void UpdateUI() override
{
float height = 320.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 300.0f, height ) );
ImGui::Begin( "Crash", nullptr, ImGuiWindowFlags_NoResize );
if ( ImGui::Button( "Add Joint" ) )
{
b3WeldJointDef jointDef = b3DefaultWeldJointDef();
jointDef.base.bodyIdA = m_bodyId1;
jointDef.base.bodyIdB = m_bodyId2;
b3CreateWeldJoint( m_worldId, &jointDef );
}
ImGui::End();
}
static Sample* Create( SampleContext* context )
{
return new Crash( context );
}
b3BodyId m_bodyId1;
b3BodyId m_bodyId2;
b3MeshData* m_gridMesh;
};
static int sampleCrash = SampleManager::Register( "Issues", "Crash", Crash::Create );
class MultiplePrismatic : public Sample
{
public:
explicit MultiplePrismatic( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 0.0f, 65.0f, { 0.0f, 0.0f, 0.0f } );
}
b3BodyId groundId;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
groundId = b3CreateBody( m_worldId, &bodyDef );
}
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
b3PrismaticJointDef jointDef = b3DefaultPrismaticJointDef();
jointDef.base.bodyIdA = groundId;
jointDef.base.localFrameA.p = { 0.0f, 0.0f, 0.0f };
jointDef.base.localFrameB.p = { 0.0f, -0.6f, 0.0f };
jointDef.base.drawScale = 2.0f;
jointDef.base.constraintHertz = 240.0f;
jointDef.lowerTranslation = -6.0f;
jointDef.upperTranslation = 6.0f;
jointDef.enableLimit = true;
for ( int i = 0; i < 6; ++i )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 0.6f + 1.2f * i, 0.0f };
bodyDef.type = b3_dynamicBody;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
jointDef.base.bodyIdB = bodyId;
b3CreatePrismaticJoint( m_worldId, &jointDef );
jointDef.base.bodyIdA = bodyId;
jointDef.base.localFrameA.p = { 0.0f, 0.6f, 0.0f };
}
// huge mouse force
m_mouseForceScale = 1000000.0f;
}
static Sample* Create( SampleContext* context )
{
return new MultiplePrismatic( context );
}
};
static int sampleMultiplePrismatic = SampleManager::Register( "Issues", "Multiple Prismatic", MultiplePrismatic::Create );
class HullCrash : public Sample
{
public:
explicit HullCrash( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero );
}
m_hull = nullptr;
#if 0
// bad hull SM_Waterfall_MED_Wide_01
b3Vec3 points[] = {
{ 0.100183107, -498.925385, -1275.39966 }, { 0.100183107, -498.925415, 0.125000000 },
{ 0.100183107, 486.343750, 0.125000000 }, { 0.100183107, 486.343719, -1275.39966 },
{ -395.117462, 486.343781, -1462.43750 }, { -395.117462, 486.343750, -96.7426758 },
{ -395.117462, -498.925415, -96.7424469 }, { -395.117462, -498.925446, -1462.52612 },
{ -186.979691, 486.294891, -1462.47949 }, { -298.250000, 486.294891, 0.125000000 },
{ -395.121216, 486.294891, -1462.52612 }, { -186.984360, -498.913361, -1462.48413 },
{ -298.250000, -498.913361, 0.125000000 },
};
#elif 1
b3Vec3 points[] = {
{ 100.000000, -142.292389, 130.826111 }, { 99.5354385, -71.3011093, 130.826111 },
{ 99.5930862, -80.1112213, -100.000000 }, { 100.000000, -142.292389, -100.000000 },
{ 99.5930862, -80.1112213, 130.826111 },
};
#else
b3Vec3 points[] = {
{ -11.3861933, -24.2451687, -12.0037909 }, { -11.3889809, -24.2466526, -11.9013014 },
{ -11.3804407, -24.3151531, -12.0046492 }, { -11.3832273, -24.3166409, -11.9021587 },
{ -14.4396200, -24.3636723, -12.1324549 }, { -14.4432650, -24.3655701, -12.0299988 },
{ -14.4356947, -24.4337788, -12.1336164 }, { -14.4393377, -24.4356804, -12.0311594 },
};
#endif
static_assert( sizeof( points ) / sizeof( points[0] ) < m_capacity, "bad" );
m_count = sizeof( points ) / sizeof( points[0] );
for ( int i = 0; i < m_count; ++i )
{
m_points[i] = 0.01f * points[i];
}
// This shift shouldn't be necessary but I'm doing it so the hull
// appears on the screen.
// for ( int i = 0; i < m_count; ++i )
//{
// m_points[i] -= m_points[0];
// m_points[i] *= 0.01f;
//}
m_hull = b3CreateHull( m_points, m_count, m_count );
(void)m_hull;
}
~HullCrash() override
{
if ( m_hull != nullptr )
{
b3DestroyHull( m_hull );
}
}
void Render() override
{
if ( m_hull != nullptr )
{
DrawHull( m_scene, b3Transform_identity, m_hull, b3_colorYellow, true );
}
else
{
for (int i = 0; i < m_count; ++i)
{
DrawPoint( m_scene, m_points[i], 5.0f, b3_colorWhite );
}
}
DrawTransform( m_scene, b3Transform_identity, 1.0f );
Sample::Render();
}
static Sample* Create( SampleContext* sampleContext )
{
return new HullCrash( sampleContext );
}
static constexpr int m_capacity = 64;
b3Hull* m_hull;
b3Vec3 m_points[m_capacity];
int m_count;
};
static int sampleHullCrash = SampleManager::Register( "Issues", "Hull Crash", HullCrash::Create );
class ConvexJitter : public Sample
{
public:
explicit ConvexJitter( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 10.0f, { 0.0f, 2.0f, 0.0f } );
EnableGrid( m_scene, true );
}
#if 1
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 10.0f, 1.0f, 10.0f );
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
#endif
float s = 0.01f;
{
b3Vec3 b = { -459.292877f, 217.398331f, 1.00115335f };
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { s * b.x, s * b.z + 2.0f, s * b.y };
bodyDef.rotation = { { 0.0f, -0.707106769f, 0.0f }, 0.707106769f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
constexpr int count = 16;
b3Vec3 points[count];
points[0] = { -44.8770714, -91.6598053, -1.92012548 };
points[1] = { -92.5001831, 51.0151291, 15.8006573 };
points[2] = { -91.0282211, -9.44371605, 15.6148796 };
points[3] = { 90.2375641, 77.3870087, 15.9356089 };
points[4] = { -85.5353241, 91.3750992, -1.36629653 };
points[5] = { 88.9092178, -87.2975464, -1.86754704 };
points[6] = { 83.7932816, -89.8572235, 15.4168339 };
points[7] = { 87.0243988, 88.9776535, -1.32423306 };
points[8] = { -91.6564941, -85.4949493, 15.3782759 };
points[9] = { -90.2922516, -87.2074127, -1.92012548 };
points[10] = { -87.2944870, 89.9510498, 15.9215889 };
points[11] = { 79.2338104, 89.9690781, 15.9724140 };
points[12] = { -91.6744461, 81.0823212, -1.39959598 };
points[13] = { 90.3452759, -76.4459610, 15.4588966 };
points[14] = { -87.4021912, -89.2263107, 15.3677588 };
points[15] = { 76.3258057, 92.0059967, 1.82873762 };
for ( int i = 0; i < count; ++i )
{
b3Vec3 p = points[i];
points[i] = { s * p.x, s * p.z, s * p.y };
}
b3Hull* hull = b3CreateHull( points, count, count );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
{
b3Vec3 b = { -402.321838f, 157.310364f, 16.8169250f };
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { s * b.x, s * b.z + 2.0f, s * b.y };
bodyDef.rotation = { { 0.0f, -0.00152086187f, 0.0f }, 0.999998868f };
bodyDef.type = b3_dynamicBody;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = 0.1f;
constexpr int count = 18;
b3Vec3 points[count];
points[0] = { 29.5000000, 17.1488495, 0.175081104 };
points[1] = { 29.5000000, -17.2990532, 0.125000000 };
points[2] = { 29.4840164, -17.3057766, 24.0200863 };
points[3] = { 29.4840164, 17.1648350, 24.1781254 };
points[4] = { -29.1345520, 17.5529804, 0.125000000 };
points[5] = { -29.1345520, 17.5529804, 23.7899799 };
points[6] = { -29.1441040, 16.9679585, 24.3750000 };
points[7] = { -29.1345520, -17.2990532, 24.3750000 };
points[8] = { -29.1345520, -17.2990532, 0.175081253 };
points[9] = { 29.0720215, 17.5529785, 0.125000000 };
points[10] = { 29.0859070, 17.5629406, 23.8120594 };
points[11] = { 29.1401348, -17.2990532, 24.3750000 };
points[12] = { 29.1123581, 16.9722290, 24.4027710 };
points[13] = { 29.3944912, 17.2543602, 24.1206398 };
points[14] = { -29.1345520, -17.2990532, 24.0759430 };
points[15] = { -29.1345520, -16.9722252, 24.4027710 };
points[16] = { 29.1123619, -16.9722271, 24.4027729 };
points[17] = { 29.5000000, 17.3429642, 24.0000000 };
for ( int i = 0; i < count; ++i )
{
b3Vec3 p = points[i];
points[i] = { s * p.x, s * p.z, s * p.y };
}
b3Hull* hull = b3CreateHull( points, count, count );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
}
static Sample* Create( SampleContext* context )
{
return new ConvexJitter( context );
}
};
static int sampleConvexJitter = SampleManager::Register( "Issues", "Convex Jitter", ConvexJitter::Create );

2784
samples/sample_joint.cpp Normal file

File diff suppressed because it is too large Load diff

940
samples/sample_manifold.cpp Normal file
View file

@ -0,0 +1,940 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "GLFW/glfw3.h"
#include "camera.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include "box3d/constants.h"
#include <imgui.h>
class Manifold : public Sample
{
public:
explicit Manifold( SampleContext* sampleContext )
: Sample( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 35.0f, 30.0f, 50.0f, { 0.0f, 5.0f, 0.0f } );
}
memset( m_points, 0, sizeof( m_points ) );
m_manifold = {};
m_manifold.points = m_points;
{
m_transformA.p = { 3.5f, 0.5f, 0.0f };
m_transformA.q = b3MakeQuatFromAxisAngle( { 0.0f, 1.0f, 0.0f }, 0.5f * B3_PI );
}
{
m_transformB.p = { 0.0f, 1.5f, 3.5f };
m_transformB.q = b3Quat_identity;
}
m_simplexCache = {};
m_satCache = {};
m_manualFeature = 0;
m_baseTranslation = b3Vec3_zero;
m_baseQuaternion = b3Quat_identity;
m_baseX = 0;
m_baseY = 0;
m_origin = b3Vec3_zero;
m_useCache = false;
m_tracking = false;
m_rotating = false;
}
void Render() override
{
DrawTextLine( "origin: %g %g %g", m_origin.x, m_origin.y, m_origin.z );
DrawTextLine( "count = %d", m_manifold.pointCount );
DrawTransform( m_scene, b3Transform_identity, 1.0f );
if ( m_manifold.pointCount == 0 )
{
return;
}
float length = 0.5f * b3GetLengthUnitsPerMeter();
b3Vec3 normal = b3RotateVector( m_transformA.q, m_manifold.normal );
for ( int pointIndex = 0; pointIndex < m_manifold.pointCount; ++pointIndex )
{
const b3LocalManifoldPoint& manifoldPoint = m_manifold.points[pointIndex];
b3Vec3 point = b3TransformPoint( m_transformA, manifoldPoint.point );
DrawLine( m_scene, point, point + length * normal, b3_colorWhite );
if ( manifoldPoint.separation > 0.0f )
{
DrawPoint( m_scene, point, 10.0f, b3_colorWhite );
}
else
{
DrawPoint( m_scene, point, 10.0f, b3_colorYellow );
}
DrawWorldString( m_camera, point, b3_colorWhite, " %.3f", manifoldPoint.separation );
b3Vec3 perp = b3Perp( normal );
b3FeaturePair pair = manifoldPoint.pair;
DrawWorldString( m_camera, point + 0.025f * normal + 0.05f * perp, b3_colorPapayaWhip, " %X:%X %X:%X", pair.owner1,
pair.index1, pair.owner2, pair.index2 );
}
Sample::Render();
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 12.0f * fontSize;
ImGui::SetNextWindowPos( ImVec2( 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 10.0f * fontSize, height ) );
ImGui::Begin( "Manifold", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
ImGui::Checkbox( "Use cache", &m_useCache );
if ( m_useCache )
{
ImGui::RadioButton( "auto", &m_manualFeature, 0 );
ImGui::RadioButton( "faceA", &m_manualFeature, 1 );
ImGui::RadioButton( "faceB", &m_manualFeature, 2 );
ImGui::RadioButton( "edgePair", &m_manualFeature, 3 );
}
ImGui::End();
}
void MouseDown( b3Vec2 p, int button, int modifiers ) override
{
if ( button == 0 && ( modifiers & GLFW_MOD_ALT ) == 0 )
{
if ( modifiers & GLFW_MOD_SHIFT )
{
m_baseX = p.x;
m_baseY = p.y;
m_baseQuaternion = m_transformB.q;
m_rotating = true;
}
else
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
m_origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_baseTranslation = m_transformB.p;
m_tracking = true;
}
}
}
void MouseUp( b3Vec2 p, int button ) override
{
m_tracking = false;
m_rotating = false;
}
void MouseMove( b3Vec2 p ) override
{
if ( m_tracking )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3Vec3 origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_transformB.p = m_baseTranslation + origin - m_origin;
}
if ( m_rotating )
{
int x = p.x;
int y = p.y;
b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.01f * ( x - m_baseX ) );
b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.01f * ( y - m_baseY ) );
m_transformB.q = b3NormalizeQuat( b3MulQuat( m_baseQuaternion, b3MulQuat( qx, qz ) ) );
}
}
static constexpr int m_pointCapacity = 64;
b3LocalManifold m_manifold;
b3LocalManifoldPoint m_points[m_pointCapacity];
b3Transform m_transformA;
b3Transform m_transformB;
b3Vec3 m_baseTranslation;
b3Quat m_baseQuaternion;
b3Vec3 m_origin;
b3SimplexCache m_simplexCache;
b3SATCache m_satCache;
int m_manualFeature;
int m_baseX;
int m_baseY;
bool m_useCache;
bool m_tracking;
bool m_rotating;
};
class TriangleManifold : public Sample
{
public:
explicit TriangleManifold( SampleContext* sampleContext )
: Sample( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 35.0f, 30.0f, 50.0f, { 0.0f, 5.0f, 0.0f } );
}
m_manifold = {};
memset( m_points, 0, sizeof( m_points ) );
m_manifold.points = m_points;
{
m_transformA.p = { 3.5f, 0.5f, 0.0f };
m_transformA.q = b3MakeQuatFromAxisAngle( { 0.0f, 1.0f, 0.0f }, 0.5f * B3_PI );
}
{
m_transformB.p = { 0.0f, 1.5f, 3.5f };
m_transformB.q = b3Quat_identity;
}
m_simplexCache = {};
m_satCache = {};
m_baseTranslation = b3Vec3_zero;
m_baseQuaternion = b3Quat_identity;
m_baseX = 0;
m_baseY = 0;
m_origin = b3Vec3_zero;
m_useCache = false;
m_tracking = false;
m_rotating = false;
m_manualFeature = 0;
}
void Render() override
{
DrawTextLine( "origin: %g %g %g", m_origin.x, m_origin.y, m_origin.z );
DrawTextLine( "count = %d", m_manifold.pointCount );
DrawTextLine( "feature = %d", m_manifold.feature );
DrawTextLine( "cache hit = %d", m_satCache.hit );
DrawTransform( m_scene, b3Transform_identity, 1.0f );
if ( m_manifold.pointCount > 0 )
{
float length = 0.5f * b3GetLengthUnitsPerMeter();
for ( int pointIndex = 0; pointIndex < m_manifold.pointCount; ++pointIndex )
{
const b3LocalManifoldPoint& manifoldPoint = m_manifold.points[pointIndex];
b3Vec3 point = manifoldPoint.point;
DrawLine( m_scene, point, point + length * m_manifold.normal, b3_colorWhite );
if ( manifoldPoint.separation > 0.0f )
{
DrawPoint( m_scene, point, 10.0f, b3_colorWhite );
}
else
{
DrawPoint( m_scene, point, 10.0f, b3_colorYellow );
}
DrawWorldString( m_camera, point, b3_colorWhite, " %.2f", 100.0f * manifoldPoint.separation );
b3FeaturePair pair = manifoldPoint.pair;
DrawWorldString( m_camera, point + 0.025f * m_manifold.normal, b3_colorPapayaWhip, " %X:%X %X:%X", pair.owner1,
pair.index1, pair.owner2, pair.index2 );
}
}
b3Vec3 p1 = b3TransformPoint( m_transformA, m_triangle[0] );
b3Vec3 p2 = b3TransformPoint( m_transformA, m_triangle[1] );
b3Vec3 p3 = b3TransformPoint( m_transformA, m_triangle[2] );
DrawFace( m_scene, p1, p2, p3, b3_colorCyan );
DrawWorldString( m_camera, p1, b3_colorWhite, "0" );
DrawWorldString( m_camera, p2, b3_colorWhite, "1" );
DrawWorldString( m_camera, p3, b3_colorWhite, "2" );
b3Vec3 center = 1.0f / 3.0f * ( p1 + p2 + p3 );
b3Vec3 normal = b3Normalize( b3Cross( p2 - p1, p3 - p1 ) );
DrawArrow( m_scene, center, center + 0.5f * normal, 0.05f, b3_colorMediumPurple );
Sample::Render();
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 12.0f * fontSize;
ImGui::SetNextWindowPos( ImVec2( 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 10.0f * fontSize, height ) );
ImGui::Begin( "Triangle Manifold", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
ImGui::Checkbox( "Use cache", &m_useCache );
if ( m_useCache )
{
ImGui::RadioButton( "auto", &m_manualFeature, 0 );
ImGui::RadioButton( "faceA", &m_manualFeature, 1 );
ImGui::RadioButton( "faceB", &m_manualFeature, 2 );
ImGui::RadioButton( "edgePair", &m_manualFeature, 3 );
}
ImGui::End();
}
void MouseDown( b3Vec2 p, int button, int modifiers ) override
{
if ( button == 0 && ( modifiers & GLFW_MOD_ALT ) == 0 )
{
if ( modifiers & GLFW_MOD_SHIFT )
{
m_baseX = p.x;
m_baseY = p.y;
m_baseQuaternion = m_transformB.q;
m_rotating = true;
}
else
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
m_origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_baseTranslation = m_transformB.p;
m_tracking = true;
}
}
}
void MouseUp( b3Vec2 p, int button ) override
{
m_tracking = false;
m_rotating = false;
}
void MouseMove( b3Vec2 p ) override
{
if ( m_tracking )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3Vec3 origin = pickRay.origin + 10.0f * b3Normalize( pickRay.translation );
m_transformB.p = m_baseTranslation + origin - m_origin;
}
if ( m_rotating )
{
int x = p.x;
int y = p.y;
b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.01f * ( x - m_baseX ) );
b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.01f * ( y - m_baseY ) );
m_transformB.q = b3NormalizeQuat( b3MulQuat( m_baseQuaternion, b3MulQuat( qx, qz ) ) );
}
}
static constexpr int m_pointCapacity = 8;
b3LocalManifold m_manifold;
b3LocalManifoldPoint m_points[m_pointCapacity];
b3Transform m_transformA;
b3Transform m_transformB;
b3Vec3 m_triangle[3] = {};
b3Vec3 m_baseTranslation;
b3Quat m_baseQuaternion;
b3Vec3 m_origin;
b3SimplexCache m_simplexCache;
b3SATCache m_satCache;
int m_manualFeature;
int m_baseX;
int m_baseY;
bool m_useCache;
bool m_tracking;
bool m_rotating;
};
class SphereAndSphere : public Manifold
{
public:
explicit SphereAndSphere( SampleContext* sampleContext )
: Manifold( sampleContext )
{
m_sphere = { { 0.5f, 0.0f, -0.25f }, 2.0f };
}
void Render() override
{
DrawSphere( m_scene, m_transformA, m_sphere, b3_colorGreen );
DrawSphere( m_scene, m_transformB, m_sphere, b3_colorCyan );
Manifold::Render();
}
void Step() override
{
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideSpheres( &m_manifold, m_pointCapacity, &m_sphere, &m_sphere, transformBtoA );
}
static Sample* Create( SampleContext* sampleContext )
{
return new SphereAndSphere( sampleContext );
}
b3Sphere m_sphere;
};
static int sampleCollideSpheres = SampleManager::Register( "Manifold", "Sphere vs Sphere", SphereAndSphere::Create );
class CapsuleAndSphere : public Manifold
{
public:
static Sample* Create( SampleContext* sampleContext )
{
return new CapsuleAndSphere( sampleContext );
}
explicit CapsuleAndSphere( SampleContext* sampleContext )
: Manifold( sampleContext )
{
m_capsule = { { -2.0f, 0.0f, 0.0f }, { 2.0f, 0.0f, 0.0f }, 1.0f };
m_sphere = { { 0.0f, 0.0f, 0.0f }, 2.0f };
m_transformA = { { 0.0f, 0.0f, 0.0f }, b3Quat_identity };
m_transformB = { { -4.0f, 0.0f, 0.0f }, b3Quat_identity };
}
void Render() override
{
DrawCapsule( m_scene, m_transformA, m_capsule, b3_colorCyan );
DrawSphere( m_scene, m_transformB, m_sphere, b3_colorGreen );
Manifold::Render();
}
void Step() override
{
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideCapsuleAndSphere( &m_manifold, m_pointCapacity, &m_capsule, &m_sphere, transformBtoA );
}
b3Sphere m_sphere;
b3Capsule m_capsule;
};
static int sampleSphereAndCapsule = SampleManager::Register( "Manifold", "Capsule vs Sphere", CapsuleAndSphere::Create );
class HullAndSphere : public Manifold
{
public:
explicit HullAndSphere( SampleContext* sampleContext )
: Manifold( sampleContext )
{
m_sphere = { { 0.0f, 0.0f, 0.0f }, 1.0f };
m_hull = b3MakeBoxHull( 2.0f, 0.5f, 0.5f );
m_transformA = { { 0.0f, 0.0f, 0.0f }, b3Quat_identity };
m_transformB = { { 1.5f, 0.0f, 0.0f }, b3Quat_identity };
}
void Render() override
{
DrawHull( m_scene, m_transformA, &m_hull.base, b3_colorCyan, false );
DrawSphere( m_scene, m_transformB, m_sphere, b3_colorGreen );
Manifold::Render();
}
void Step() override
{
if ( m_useCache == false )
{
m_simplexCache = {};
}
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideHullAndSphere( &m_manifold, m_pointCapacity, &m_hull.base, &m_sphere, transformBtoA, &m_simplexCache );
}
static Sample* Create( SampleContext* sampleContext )
{
return new HullAndSphere( sampleContext );
}
b3Sphere m_sphere;
b3BoxHull m_hull;
};
static int sampleSphereAndHull = SampleManager::Register( "Manifold", "Hull vs Sphere", HullAndSphere::Create );
class TriangleAndSphere : public TriangleManifold
{
public:
static Sample* Create( SampleContext* sampleContext )
{
return new TriangleAndSphere( sampleContext );
}
explicit TriangleAndSphere( SampleContext* sampleContext )
: TriangleManifold( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 10.0f, b3Vec3_zero );
}
m_sphere = { { 0.0f, 0.0f, 0.0f }, 1.0f };
m_triangle[0] = { 0.0f, 0.0f, 0.0f };
m_triangle[1] = { 4.0f, 0.0f, 4.0f };
m_triangle[2] = { 4.0f, 0.0f, 0.0f };
// b3Quat qA = b3MakeQuatFromAxisAngle( { 0.0f, 1.0f, 0.0f }, 2.0f );
// m_transformA = { { 1.0f, 1.0f, 0.0f }, qA };
m_transformA = b3Transform_identity;
m_transformB = { { 2.0f, 0.5f, 1.0f }, b3Quat_identity };
}
void Render() override
{
DrawSphere( m_scene, m_transformB, m_sphere, b3_colorGreen );
TriangleManifold::Render();
}
void Step() override
{
// Convert triangle to frame B
b3Transform xf = b3InvMulTransforms( m_transformB, m_transformA );
b3Vec3 localTriangle[3] = {
b3TransformPoint( xf, m_triangle[0] ),
b3TransformPoint( xf, m_triangle[1] ),
b3TransformPoint( xf, m_triangle[2] ),
};
b3CollideSphereAndTriangle( &m_manifold, m_pointCapacity, &m_sphere, localTriangle );
// Convert manifold from frame B to world space
m_manifold.normal = b3RotateVector( m_transformB.q, m_manifold.normal );
for ( int i = 0; i < m_manifold.pointCount; ++i )
{
m_manifold.points[i].point = b3TransformPoint( m_transformB, m_manifold.points[i].point );
}
}
b3Sphere m_sphere;
};
static int sampleSphereAndTriangle = SampleManager::Register( "Manifold", "Triangle vs Sphere", TriangleAndSphere::Create );
class CapsuleAndCapsule : public Manifold
{
public:
explicit CapsuleAndCapsule( SampleContext* sampleContext )
: Manifold( sampleContext )
{
m_capsule = { { -2.0f, 0.0f, 0.0f }, { 2.0f, 0.0f, 0.0f }, 1.0f };
m_transformA = { { 1.0f, 1.0f, 0.0f }, b3Quat_identity };
m_transformB = { { -4.0f, 1.0f, 0.0f }, b3Quat_identity };
}
void Render() override
{
DrawCapsule( m_scene, m_transformA, m_capsule, b3_colorGreen );
DrawCapsule( m_scene, m_transformB, m_capsule, b3_colorCyan );
Manifold::Render();
}
void Step() override
{
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideCapsules( &m_manifold, m_pointCapacity, &m_capsule, &m_capsule, transformBtoA );
}
static Sample* Create( SampleContext* sampleContext )
{
return new CapsuleAndCapsule( sampleContext );
}
b3Capsule m_capsule;
};
static int sampleCapsuleAndCapsule = SampleManager::Register( "Manifold", "Capsule vs Capsule", CapsuleAndCapsule::Create );
class CapsuleAndHull : public Manifold
{
public:
explicit CapsuleAndHull( SampleContext* sampleContext )
: Manifold( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 5.0f, b3Vec3_zero );
}
m_capsule = { { -1.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f }, 0.5f };
m_hull = b3MakeBoxHull( 1.0f, 0.5f, 0.5f );
m_transformA = { { 0.0f, 0.0f, 0.0f }, b3Quat_identity };
m_transformB = { { 0.0f, 1.0f, 0.0f }, b3Quat_identity };
/*
p [ 1.58523774, 0.729615569, 0.451690674 ] b3Vec3
q [ [ -0.00256555085, -0.0201825816, 0.126076236 ], 0.991811991 ] b3Quat
*/
// m_capsule = {
// { 0.0799999982, -0.0151330000, -0.0918010026 }, { -0.0799999982, -0.0151330000, -0.0918010026 }, 0.100000001 };
// m_hull = b3CreateBox( { 0.5f, 1.0f, 1.5f } );
m_transformB = { { 1.58523774, 0.729615569, 0.451690674 },
{ { -0.00256555085, -0.0201825816, 0.126076236 }, 0.991811991 } };
}
void Render() override
{
DrawHull( m_scene, m_transformA, &m_hull.base, b3_colorCyan, false );
DrawCapsule( m_scene, m_transformB, m_capsule, b3_colorGreen );
Manifold::Render();
}
void Step() override
{
if ( m_useCache == false )
{
m_simplexCache = {};
}
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideHullAndCapsule( &m_manifold, m_pointCapacity, &m_hull.base, &m_capsule, transformBtoA, &m_simplexCache );
}
static Sample* Create( SampleContext* sampleContext )
{
return new CapsuleAndHull( sampleContext );
}
b3BoxHull m_hull;
b3Capsule m_capsule;
};
static int sampleCapsuleAndHull = SampleManager::Register( "Manifold", "Capsule vs Hull", CapsuleAndHull::Create );
class TriangleAndCapsule : public TriangleManifold
{
public:
static Sample* Create( SampleContext* sampleContext )
{
return new TriangleAndCapsule( sampleContext );
}
explicit TriangleAndCapsule( SampleContext* sampleContext )
: TriangleManifold( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 10.0f, b3Vec3_zero );
}
m_capsule = { { 0.0f, -0.2f, 0.0f }, { 0.0f, 0.2f, 0.0f }, 0.05f };
m_triangle[0] = { -4.0f, 0.0f, -4.0f };
m_triangle[1] = { -4.0f, 0.0f, 0.0f };
m_triangle[2] = { 0.0f, 0.0f, 0.0f };
m_transformA = b3Transform_identity;
m_transformB = { { 0.0f, 0.5f, 0.0f }, b3Quat_identity };
m_transformB.q = b3MakeQuatFromAxisAngle( { 0.0f, 0.0f, 1.0f }, 0.5f * B3_PI );
m_transformB = { { -0.500000000, 0.123778239, -0.500000000 },
{ { -0.157559350, 0.294042289, 0.821513653 }, -0.462417006 } };
}
void Render() override
{
DrawCapsule( m_scene, m_transformB, m_capsule, b3_colorGreen );
DrawTransform( m_scene, m_transformB, 0.1f );
TriangleManifold::Render();
}
void Step() override
{
if ( m_useCache == false )
{
m_simplexCache = {};
}
// Put triangle into capsule coordinates
b3Transform xf = b3InvMulTransforms( m_transformB, m_transformA );
b3Vec3 localTriangle[3] = {
b3TransformPoint( xf, m_triangle[0] ),
b3TransformPoint( xf, m_triangle[1] ),
b3TransformPoint( xf, m_triangle[2] ),
};
b3CollideCapsuleAndTriangle( &m_manifold, m_pointCapacity, &m_capsule, localTriangle, &m_simplexCache );
// Convert manifold from frame B to world space
m_manifold.normal = b3RotateVector( m_transformB.q, m_manifold.normal );
for ( int i = 0; i < m_manifold.pointCount; ++i )
{
m_manifold.points[i].point = b3TransformPoint( m_transformB, m_manifold.points[i].point );
}
}
b3Capsule m_capsule;
};
static int sampleCapsuleAndTriangle = SampleManager::Register( "Manifold", "Triangle vs Capsule", TriangleAndCapsule::Create );
class HullAndHull : public Manifold
{
public:
explicit HullAndHull( SampleContext* context )
: Manifold( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 4.0f, b3Vec3_zero );
}
// m_boxA = b3MakeTransformedBoxHull( 0.5f, 0.5f, 0.5f, { { 0.0f, -0.5f, 0.0f }, b3Quat_identity } );
b3Transform transform = { { 1.0f, 0.5f, 0.0f }, b3Quat_identity };
m_boxA = b3MakeTransformedBoxHull( 0.5f, 1.0f, 1.0f, transform );
// m_hull = CreateConvex( 0.6f, 0.0f, 0.95f, 1.0f, context->arena );
m_hullA = &m_boxA.base;
m_boxB = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
// m_hull = CreateConvex( 0.6f, 0.0f, 0.95f, 1.0f, context->arena );
m_hullB = &m_boxB.base;
/*
- xfA {p=[ -10.0000000, 0.00000000, -10.0000000 ] q=[ [ 0.00000000, 0.00000000, 0.00000000 ], 1.00000000 ] } b3Transform
+ p [ -10.0000000, 0.00000000, -10.0000000 ] b3Vec3
+ q [ [ 0.00000000, 0.00000000, 0.00000000 ], 1.00000000 ] b3Quat
- xfB {p=[ -10.0000000, 1.00000000, -10.0000000 ] q=[ [ 0.00000000, 0.00000000, 0.00000000 ], 1.00000000 ] } b3Transform
+ p [ -10.0000000, 1.00000000, -10.0000000 ] b3Vec3
+ q [ [ 0.00000000, 0.00000000, 0.00000000 ], 1.00000000 ] b3Quat
*/
m_transformA = { { 0.0f, 0.0f, 0.0f }, b3Quat_identity };
m_transformB = { { 0.0f, 0.0f, 0.0f }, b3Quat_identity };
/*
p [ 0.691772044, 0.951781273, 0.0741987228 ] b3Vec3
q [ [ -0.00162522844, -0.0456664972, 0.0355294086 ], 0.998323441 ] b3Quat
*/
// m_transformB = { { 0.691772044, 0.951781273, 0.0741987228 },
// { { -0.00162522844, -0.0456664972, 0.0355294086 }, 0.998323441 } };
m_satCache = {};
}
~HullAndHull() override
{
if ( m_hullA != &m_boxA.base )
{
b3DestroyHull( m_hullA );
}
if ( m_hullB != &m_boxB.base )
{
b3DestroyHull( m_hullB );
}
}
b3Hull* CreateConvex( float radius1, float height1, float radius2, float height2, Arena arena ) const
{
const int sideCount = 32;
const float deltaAlpha = 2.0f * B3_PI / sideCount;
int vertexCount = 2 * sideCount;
b3Vec3* vertexBase = static_cast<b3Vec3*>( arena.Allocate( vertexCount * sizeof( b3Vec3 ) ) );
float alpha = 0.0f;
for ( int sideIndex = 0; sideIndex < sideCount; ++sideIndex )
{
b3CosSin cs = b3ComputeCosSin( alpha );
float x1 = radius1 * cs.cosine;
float z1 = radius1 * cs.sine;
float x2 = radius2 * cs.cosine;
float z2 = radius2 * cs.sine;
vertexBase[2 * sideIndex + 0] = { x1, height1, z1 };
vertexBase[2 * sideIndex + 1] = { x2, height2, z2 };
alpha += deltaAlpha;
}
return b3CreateHull( vertexBase, vertexCount, vertexCount );
}
void Render() override
{
DrawHull( m_scene, m_transformA, m_hullA, b3_colorGreen, false );
DrawHull( m_scene, m_transformB, m_hullB, b3_colorCyan, false );
Manifold::Render();
}
void Step() override
{
if ( m_useCache == true )
{
if ( m_manualFeature == 1 )
{
m_satCache.type = b3_manualFaceAxisA;
}
else if ( m_manualFeature == 2 )
{
m_satCache.type = b3_manualFaceAxisB;
}
else if ( m_manualFeature == 3 )
{
m_satCache.type = b3_manualEdgePairAxis;
}
}
else
{
m_satCache = {};
}
b3Transform transformBtoA = b3InvMulTransforms( m_transformA, m_transformB );
b3CollideHulls( &m_manifold, m_pointCapacity, m_hullA, m_hullB, transformBtoA, &m_satCache );
DrawTextLine( "SAT type: %d", m_satCache.type );
}
static Sample* Create( SampleContext* sampleContext )
{
return new HullAndHull( sampleContext );
}
b3BoxHull m_boxA;
b3BoxHull m_boxB;
b3Hull* m_hullA;
b3Hull* m_hullB;
};
static int sampleCollideHulls = SampleManager::Register( "Manifold", "Hull vs Hull", HullAndHull::Create );
class TriangleAndHull : public TriangleManifold
{
public:
static Sample* Create( SampleContext* sampleContext )
{
return new TriangleAndHull( sampleContext );
}
explicit TriangleAndHull( SampleContext* sampleContext )
: TriangleManifold( sampleContext )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 3.0f, b3Vec3_zero );
}
m_triangle[0] = { 1.00000000, 0, 1.00000000 };
m_triangle[1] = { 1.00000000, 0, 0.00000000 };
m_triangle[2] = { 0.00000000, 0, 0.00000000 };
m_boxHull = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
m_transformA = b3Transform_identity;
m_transformB = b3Transform_identity;
m_transformB.p = { 0.0f, 0.45f, 0.1f };
// b3MeshEdgeFlags
m_flags = 0;
/*
* separation -0.0415397286 float
type 2 '\x2' unsigned char
indexA 0 '\0' unsigned char
indexB 1 '\x1' unsigned char
hit 1 '\x1' unsigned char
*/
m_satCache = {
.separation = -0.0107582733f,
.type = 1,
.indexA = 0,
.indexB = 4,
};
m_satCache = {};
m_useCache = false;
m_cylinder = b3CreateCylinder( 0.4f, 0.05f, 0.0f, 6 );
m_hull = &m_boxHull.base;
}
~TriangleAndHull() override
{
b3DestroyHull( m_cylinder );
}
void Render() override
{
DrawHull( m_scene, m_transformB, m_hull, b3_colorGreen, false );
b3Transform xf;
xf.p = b3TransformPoint( m_transformB, m_hull->center );
xf.q = m_transformB.q;
DrawTransform( m_scene, xf, 0.1f );
TriangleManifold::Render();
}
void Step() override
{
if ( m_useCache == true )
{
if ( m_manualFeature == 1 )
{
m_satCache.type = b3_manualFaceAxisA;
}
else if ( m_manualFeature == 2 )
{
m_satCache.type = b3_manualFaceAxisB;
}
else if ( m_manualFeature == 3 )
{
m_satCache.type = b3_manualEdgePairAxis;
}
}
else
{
m_satCache = {};
}
b3Transform xf = b3InvMulTransforms( m_transformB, m_transformA );
b3Vec3 localTriangle[3] = {
b3TransformPoint( xf, m_triangle[0] ),
b3TransformPoint( xf, m_triangle[1] ),
b3TransformPoint( xf, m_triangle[2] ),
};
b3CollideHullAndTriangle( &m_manifold, m_pointCapacity, m_hull, localTriangle, m_flags, &m_satCache );
// Convert manifold from frame B to world space
m_manifold.normal = b3RotateVector( m_transformB.q, m_manifold.normal );
for ( int i = 0; i < m_manifold.pointCount; ++i )
{
m_manifold.points[i].point = b3TransformPoint( m_transformB, m_manifold.points[i].point );
}
}
int m_flags;
b3BoxHull m_boxHull;
b3Hull* m_cylinder;
b3Hull* m_hull;
};
static int sampleHullAndTriangle = SampleManager::Register( "Manifold", "Triangle vs Hull", TriangleAndHull::Create );

1523
samples/sample_mesh.cpp Normal file

File diff suppressed because it is too large Load diff

484
samples/sample_ragdoll.cpp Normal file
View file

@ -0,0 +1,484 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "human.h"
#include "imgui.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
class RagdollOnBox : public Sample
{
public:
explicit RagdollOnBox( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 6.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 10.0f, 1.0f, 10.0f );
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
m_jointFrictionTorque = 5.0f;
m_jointHertz = 1.0f;
m_jointDampingRatio = 0.7f;
m_human = {};
Spawn();
}
void Spawn()
{
CreateHuman( &m_human, m_worldId, { 0.0f, 2.0f, 0.0f }, m_jointFrictionTorque, m_jointHertz, m_jointDampingRatio, 1,
nullptr, false );
// Human_ApplyRandomAngularImpulse( &m_human, 10.0f );
}
void UpdateUI() override
{
float height = 140.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 350.0f, height ) );
ImGui::Begin( "Ragdoll on Box", nullptr, ImGuiWindowFlags_NoResize );
ImGui::PushItemWidth( 200.0f );
if ( ImGui::SliderFloat( "Joint Friction", &m_jointFrictionTorque, 0.0f, 20.0f, "%3.0f" ) )
{
Human_SetJointFrictionTorque( &m_human, m_jointFrictionTorque );
}
if ( ImGui::SliderFloat( "Hertz", &m_jointHertz, 0.0f, 20.0f, "%3.1f" ) )
{
Human_SetJointSpringHertz( &m_human, m_jointHertz );
}
if ( ImGui::SliderFloat( "Damping", &m_jointDampingRatio, 0.0f, 4.0f, "%3.1f" ) )
{
Human_SetJointDampingRatio( &m_human, m_jointDampingRatio );
}
if ( ImGui::Button( "Respawn" ) )
{
DestroyHuman( &m_human );
Spawn();
}
ImGui::PopItemWidth();
ImGui::End();
}
static Sample* Create( SampleContext* context )
{
return new RagdollOnBox( context );
}
Human m_human;
float m_jointFrictionTorque;
float m_jointHertz;
float m_jointDampingRatio;
};
static int sampleRagdollOnBox = SampleManager::Register( "Ragdoll", "Box", RagdollOnBox::Create );
class RagdollOnMesh : public Sample
{
public:
explicit RagdollOnMesh( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 6.0f, b3Vec3_zero );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
m_groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_groundMesh = b3CreateGridMesh( 20, 20, 2.0f, 2, true );
b3CreateMeshShape( m_groundId, &shapeDef, m_groundMesh, b3Vec3_one );
}
{
b3Transform transform;
transform.p = { 0.0f, 5.0f, -20.0f };
transform.q = b3Quat_identity;
b3BoxHull wallBox = b3MakeTransformedBoxHull( 20.0f, 5.0f, 0.1f, transform );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base );
}
{
b3Transform transform;
transform.p = { 0.0f, 5.0f, 20.0f };
transform.q = b3Quat_identity;
b3BoxHull wallBox = b3MakeTransformedBoxHull( 20.0f, 5.0f, 0.1f, transform );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base );
}
{
b3Transform transform;
transform.p = { -20.0f, 5.0f, 0.0f };
transform.q = b3Quat_identity;
b3BoxHull wallBox = b3MakeTransformedBoxHull( 0.1f, 5.0f, 20.0f, transform );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base );
}
{
b3Transform transform;
transform.p = { 20.0f, 5.0f, 0.0f };
transform.q = b3Quat_identity;
b3BoxHull wallBox = b3MakeTransformedBoxHull( 0.1f, 5.0f, 20.0f, transform );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base );
}
m_jointFrictionTorque = 5.0f;
m_jointHertz = 2.0f;
m_jointDampingRatio = 0.7f;
m_human = {};
Spawn();
}
~RagdollOnMesh() override
{
b3DestroyMesh( m_groundMesh );
}
void Spawn()
{
CreateHuman( &m_human, m_worldId, { 0.0f, 1.0f, 0.0f }, m_jointFrictionTorque, m_jointHertz, m_jointDampingRatio, 1,
nullptr, false );
// Human_AlignSpring( &m_human, m_worldId, m_groundId, 25.0f, 1.0f );
// Human_ApplyRandomAngularImpulse( &m_human, 10.0f );
// b3Body_SetType( m_human.bones[bone_thigh_l].bodyId, b3_kinematicBody );
// b3Body_SetType( m_human.bones[bone_thigh_r].bodyId, b3_kinematicBody );
// b3Body_SetType( m_human.bones[bone_pelvis].bodyId, b3_kinematicBody );
// Human_CreateMotorAnchors( &m_human, m_worldId );
Human_CreateParallelAnchors( &m_human, m_worldId );
}
void UpdateUI() override
{
float height = 140.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_camera->m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 350.0f, height ) );
ImGui::Begin( "Ragdoll", nullptr, ImGuiWindowFlags_NoResize );
ImGui::PushItemWidth( 200.0f );
if ( ImGui::SliderFloat( "Joint Friction", &m_jointFrictionTorque, 0.0f, 20.0f, "%3.0f" ) )
{
Human_SetJointFrictionTorque( &m_human, m_jointFrictionTorque );
}
if ( ImGui::SliderFloat( "Hertz", &m_jointHertz, 0.0f, 20.0f, "%3.1f" ) )
{
Human_SetJointSpringHertz( &m_human, m_jointHertz );
}
if ( ImGui::SliderFloat( "Damping", &m_jointDampingRatio, 0.0f, 4.0f, "%3.1f" ) )
{
Human_SetJointDampingRatio( &m_human, m_jointDampingRatio );
}
if ( ImGui::Button( "Respawn" ) )
{
DestroyHuman( &m_human );
Spawn();
}
ImGui::PopItemWidth();
ImGui::End();
}
static Sample* Create( SampleContext* context )
{
return new RagdollOnMesh( context );
}
b3MeshData* m_groundMesh;
b3BodyId m_groundId;
Human m_human;
float m_jointFrictionTorque;
float m_jointHertz;
float m_jointDampingRatio;
};
static int sampleRagdollMesh = SampleManager::Register( "Ragdoll", "Mesh", RagdollOnMesh::Create );
class RagdollPile : public Sample
{
public:
enum
{
#ifdef NDEBUG
e_count = 20
#else
e_count = 8
#endif
};
explicit RagdollPile( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 180.0f, 30.0f, 20.0f, b3Vec3_zero );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_groundMesh = b3CreateGridMesh( 20, 20, 1.0f, 1, true );
b3CreateMeshShape( groundId, &shapeDef, m_groundMesh, b3Vec3_one );
for ( int i = 0; i < e_count; ++i )
{
b3Vec3 position = { 0.1f * i, 2.0f + 0.5f * i, -0.1f * i };
float torque = 10.0f;
float hertz = 0.5f;
float damping = 0.7f;
int groupIndex = i;
void* userData = nullptr;
bool colorize = false;
CreateHuman( m_humans + i, m_worldId, position, torque, hertz, damping, groupIndex, userData, colorize );
}
}
~RagdollPile() override
{
b3DestroyMesh( m_groundMesh );
}
static Sample* Create( SampleContext* context )
{
return new RagdollPile( context );
}
b3MeshData* m_groundMesh;
Human m_humans[e_count] = {};
};
static int sampleRagdollPile = SampleManager::Register( "Ragdoll", "Pile", RagdollPile::Create );
class RagdollIncline : public Sample
{
public:
explicit RagdollIncline( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( -20.0f, 30.0f, 25.0f, b3Vec3_zero );
}
b3ShapeDef shapeDef = b3DefaultShapeDef();
m_groundMesh = b3CreateGridMesh( 4, 4, 2.0f, 1, true );
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { -10.0f, 2.0f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, -0.2f * B3_PI );
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3CreateMeshShape( groundId, &shapeDef, m_groundMesh, b3Vec3_one );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 0.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3Vec3 scale = { 4.0f, 4.0f, 4.0f };
b3CreateMeshShape( groundId, &shapeDef, m_groundMesh, scale );
}
m_human = {};
b3Vec3 position = { -12.0f, 6.0f, 0.0f };
float torque = 10.0f;
float hertz = 2.0f;
float damping = 0.7f;
int groupIndex = 1;
void* userData = nullptr;
bool colorize = false;
CreateHuman( &m_human, m_worldId, position, torque, hertz, damping, groupIndex, userData, colorize );
m_time = 0.0f;
m_motorized = true;
}
~RagdollIncline() override
{
b3DestroyMesh( m_groundMesh );
}
void Step() override
{
if ( m_time > 2.0f && m_motorized == true )
{
Human_SetJointFrictionTorque( &m_human, 0.5f );
Human_SetJointSpringHertz( &m_human, 0.5f );
m_motorized = false;
}
m_time += m_context->hertz > 0.0f ? 1.0f / m_context->hertz : 0.0f;
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new RagdollIncline( context );
}
b3MeshData* m_groundMesh;
Human m_human;
float m_time;
bool m_motorized;
};
static int sampleRagdollIncline = SampleManager::Register( "Ragdoll", "Incline", RagdollIncline::Create );
#if 0
class RagdollPose : public Sample
{
public:
static Sample* Create( SampleContext* context )
{
return new RagdollPose( context );
}
explicit RagdollPose( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 6.0f, b3Vec3_zero );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, 0.0f, 0.0f };
// bodyDef.rotation = b3Rotation(B3_VEC3_AXIS_Y, 0.25f * B3_PI);
b3BodyId groundId = m_worldId->CreateBody( &bodyDef );
m_ground = b3CreateGrid( 4, 2.0f, 0.0f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
groundId->AddMesh( &shapeDef, m_ground );
b3Hull* Hull = b3CreateOffsetBox( { { -3.0f, 0.5f, 0.0f }, b3Quat_identity }, { 0.25f, 0.5f, 3.0f } );
groundId->AddHull( &shapeDef, Hull );
b3DestroyHull( Hull );
m_motorized = false;
m_motorHertz = 1.0f;
m_human.Spawn( m_worldId, { 0.0f, 0.1f, 0.0f }, m_motorHertz, m_motorized );
m_poseControl = true;
m_poseHertz = 2.0f;
m_human.EnablePoseControl( m_worldId, m_poseHertz, m_poseControl );
m_time = 0.0f;
{
b3Hull* Cylinder = b3CreateCylinder( 0.5f, 0.5f, 0.0f, 16 );
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 3.0f, 0.5f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( B3_VEC3_AXIS_Z, 0.5f * B3_PI );
b3BodyId Body = m_worldId->CreateBody( &bodyDef );
Body->AddHull( &shapeDef, Cylinder );
b3DestroyHull( Cylinder );
}
m_angle = 0.0f;
m_angularVelocity = 0.0f;
}
~RagdollPose() override
{
b3DestroyMesh( m_ground );
}
void OnRenderUI( GLFWwindow* ) override
{
ImGui::SetNextWindowPos( ImVec2( 10.0f, 600.0f ) );
ImGui::SetNextWindowSize( ImVec2( 260.0f, 160.0f ) );
ImGui::Begin( "Pose", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
if ( ImGui::Checkbox( "motors", &m_motorized ) )
{
m_human.EnableMotors( m_motorized );
m_human.AdjustMotors( m_motorHertz );
}
if ( ImGui::SliderFloat( "motor hertz", &m_motorHertz, 0.01f, 20.0f, "%.2f" ) )
{
m_human.AdjustMotors( m_motorHertz );
}
if ( ImGui::Checkbox( "pose", &m_poseControl ) )
{
m_human.EnablePoseControl( m_worldId, m_poseHertz, m_poseControl );
}
if ( ImGui::SliderFloat( "pose hertz", &m_poseHertz, 0.01f, 8.0f, "%.2f" ) )
{
m_human.AdjustPoseControl( m_poseHertz );
}
ImGui::SliderFloat( "omega", &m_angularVelocity, 0.0f, 8.0f, "%.1f" );
ImGui::End();
}
void OnUpdate() override
{
float timeStep = 1.0f / m_context->Settings.Frequency;
m_time += timeStep;
if ( m_poseControl )
{
b3Transform transform = m_human.m_rootBody->GetTransform();
transform.p.x = 4.0f * sinf( 0.5f * m_time );
transform.p.y = 0.5f * ( cosf( 1.0f * m_time + B3_PI ) + 1.0f );
m_angle += m_angularVelocity * timeStep;
transform.q = b3MakeQuatFromAxisAngle( B3_VEC3_AXIS_Y, m_angle );
m_human.DriveBase( transform, timeStep );
}
// transform = mHuman.m_bones[0].poseJoint->GetRelativeTransform();
// transform.Translation.Y = 0.5f * ( cosf( 1.0f * mTime + B3_PI ) + 1.0f );
// mHuman.m_bones[0].poseJoint->SetRelativeTransform( transform );
Sample::OnUpdate();
}
b3MeshData* m_ground;
Human m_human;
float m_time;
float m_motorHertz;
float m_poseHertz;
float m_angle;
float m_angularVelocity;
bool m_motorized;
bool m_poseControl;
};
static int sampleRagodllPose = SampleManager::Register( "Ragdoll", "Pose", RagdollPose::Create );
#endif

View file

@ -0,0 +1,404 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
#include <imgui.h>
#include <stdlib.h>
// Pyramid with heavy box on top
class HighMassRatio1 : public Sample
{
public:
explicit HighMassRatio1( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 20.0f, 50.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
float extent = 1.0f;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeTransformedBoxHull( 50.0f, 1.0f, 50.0f, { { 0.0f, -1.0f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3BoxHull box = b3MakeBoxHull( extent, extent, extent );
b3ShapeDef shapeDef = b3DefaultShapeDef();
for ( int j = 0; j < 3; ++j )
{
int count = 10;
float offset = -20.0f * extent + 2.0f * ( count + 1.0f ) * extent * j;
float y = extent;
while ( count > 0 )
{
for ( int i = 0; i < count; ++i )
{
float coeff = i - 0.5f * count;
float yy = count == 1 ? y + 2.0f : y;
bodyDef.position = { 2.0f * coeff * extent + offset, yy, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
shapeDef.density = count == 1 ? ( j + 1.0f ) * 100.0f : 1.0f;
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
--count;
y += 2.0f * extent;
}
}
}
}
static Sample* Create( SampleContext* context )
{
return new HighMassRatio1( context );
}
};
static int sampleHighMassRatio1 = SampleManager::Register( "Robustness", "HighMassRatio1", HighMassRatio1::Create );
class OverlapRecovery : public Sample
{
public:
explicit OverlapRecovery( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 45.0f, 20.0f, 50.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
m_bodyIds = nullptr;
m_bodyCount = 0;
m_baseCount = 4;
m_overlap = 0.25f;
m_extent = 0.5f;
m_speed = 3.0f;
m_hertz = 30.0f;
m_dampingRatio = 10.0f;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeTransformedBoxHull( 20.0f, 1.0f, 20.0f, { { 0.0f, -1.0f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( groundId, &shapeDef, &box.base );
}
CreateScene();
}
~OverlapRecovery() override
{
free( m_bodyIds );
}
void CreateScene()
{
for ( int i = 0; i < m_bodyCount; ++i )
{
b3DestroyBody( m_bodyIds[i] );
}
b3World_SetContactTuning( m_worldId, m_hertz, m_dampingRatio, m_speed );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3BoxHull box = b3MakeBoxHull( m_extent, m_extent, m_extent );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1.0f;
m_bodyCount = m_baseCount * ( m_baseCount + 1 ) / 2;
m_bodyIds = (b3BodyId*)realloc( m_bodyIds, m_bodyCount * sizeof( b3BodyId ) );
int bodyIndex = 0;
float fraction = 1.0f - m_overlap;
float y = m_extent;
for ( int i = 0; i < m_baseCount; ++i )
{
float x = fraction * m_extent * ( i - m_baseCount );
for ( int j = i; j < m_baseCount; ++j )
{
bodyDef.position = { x, y };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
m_bodyIds[bodyIndex++] = bodyId;
x += 2.0f * fraction * m_extent;
}
y += 2.0f * fraction * m_extent;
}
assert( bodyIndex == m_bodyCount );
}
void UpdateUI() override
{
float height = 220.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_context->camera.m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 220.0f, height ) );
ImGui::Begin( "Overlap Recovery", nullptr, ImGuiWindowFlags_NoResize );
ImGui::PushItemWidth( 100.0f );
bool changed = false;
changed = changed || ImGui::SliderFloat( "Extent", &m_extent, 0.1f, 1.0f, "%.1f" );
changed = changed || ImGui::SliderInt( "Base Count", &m_baseCount, 1, 10 );
changed = changed || ImGui::SliderFloat( "Overlap", &m_overlap, 0.0f, 1.0f, "%.2f" );
changed = changed || ImGui::SliderFloat( "Speed", &m_speed, 0.0f, 10.0f, "%.1f" );
changed = changed || ImGui::SliderFloat( "Hertz", &m_hertz, 0.0f, 240.0f, "%.f" );
changed = changed || ImGui::SliderFloat( "Damping Ratio", &m_dampingRatio, 0.0f, 20.0f, "%.1f" );
changed = changed || ImGui::Button( "Reset Scene" );
if ( changed )
{
CreateScene();
}
ImGui::PopItemWidth();
ImGui::End();
}
static Sample* Create( SampleContext* context )
{
return new OverlapRecovery( context );
}
b3BodyId* m_bodyIds;
int m_bodyCount;
int m_baseCount;
float m_overlap;
float m_extent;
float m_speed;
float m_hertz;
float m_dampingRatio;
};
static int sampleOverlapRecovery = SampleManager::Register( "Robustness", "Overlap Recovery", OverlapRecovery::Create );
class Cart : public Sample
{
public:
explicit Cart( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 30.0f, 15.0f, { 0.0f, 2.0f, 0.0f } );
//context->settings.subStepCount = 12;
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull groundBox = b3MakeBoxHull( 20.0f, 1.0f, 20.0f );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
}
b3World_SetGravity( m_worldId, { 0, -22, 0 } );
m_contactHertz = 240.0f;
m_contactDampingRatio = 10.0f;
m_contactSpeed = 0.5f;
b3World_SetContactTuning( m_worldId, m_contactHertz, m_contactDampingRatio, m_contactSpeed );
m_constraintHertz = 240.0f;
m_constraintDampingRatio = 0.0f;
m_chassisId = {};
m_wheelId1 = {};
m_wheelId2 = {};
m_wheelId3 = {};
m_wheelId4 = {};
m_jointId1 = {};
m_jointId2 = {};
m_jointId3 = {};
m_jointId4 = {};
CreateScene();
}
void CreateScene()
{
if ( B3_IS_NON_NULL( m_chassisId ) )
{
b3DestroyBody( m_chassisId );
}
if ( B3_IS_NON_NULL( m_wheelId1 ) )
{
b3DestroyBody( m_wheelId1 );
}
if ( B3_IS_NON_NULL( m_wheelId2 ) )
{
b3DestroyBody( m_wheelId2 );
}
if ( B3_IS_NON_NULL( m_wheelId3 ) )
{
b3DestroyBody( m_wheelId3 );
}
if ( B3_IS_NON_NULL( m_wheelId4 ) )
{
b3DestroyBody( m_wheelId4 );
}
float yBase = 1.0f;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, yBase, 0.0f };
m_chassisId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 1000.0f;
b3BoxHull box = b3MakeTransformedBoxHull( 1.0f, 0.25f, 0.5f, { { 0.0f, 0.25f, 0.0f }, b3Quat_identity } );
b3CreateHullShape( m_chassisId, &shapeDef, &box.base );
shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = 0.02f;
shapeDef.density = 200.0f;
b3Sphere sphere = { b3Vec3_zero, 0.1f };
bodyDef.position = { -0.9f, yBase - 0.15f, 0.4f };
m_wheelId1 = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( m_wheelId1, &shapeDef, &sphere );
bodyDef.position = { 0.9f, yBase - 0.15f, 0.4f };
m_wheelId2 = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( m_wheelId2, &shapeDef, &sphere );
bodyDef.position = { 0.9f, yBase - 0.15f, -0.4f };
m_wheelId3 = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( m_wheelId3, &shapeDef, &sphere );
bodyDef.position = { -0.9f, yBase - 0.15f, -0.4f };
m_wheelId4 = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( m_wheelId4, &shapeDef, &sphere );
b3SphericalJointDef jointDef = b3DefaultSphericalJointDef();
jointDef.base.constraintHertz = m_constraintHertz;
jointDef.base.constraintDampingRatio = m_constraintDampingRatio;
jointDef.base.drawScale = 0.5f;
jointDef.base.bodyIdA = m_chassisId;
jointDef.base.bodyIdB = m_wheelId1;
jointDef.base.localFrameA.p = { -0.9f, -0.15f, 0.4f };
jointDef.base.localFrameB.p = { 0.0f, 0.0f, 0.0f };
m_jointId1 = b3CreateSphericalJoint( m_worldId, &jointDef );
jointDef.base.bodyIdA = m_chassisId;
jointDef.base.bodyIdB = m_wheelId2;
jointDef.base.localFrameA.p = { 0.9f, -0.15f, 0.4f };
jointDef.base.localFrameB.p = { 0.0f, 0.0f, 0.0f };
m_jointId2 = b3CreateSphericalJoint( m_worldId, &jointDef );
jointDef.base.bodyIdA = m_chassisId;
jointDef.base.bodyIdB = m_wheelId3;
jointDef.base.localFrameA.p = { 0.9f, -0.15f, -0.4f };
jointDef.base.localFrameB.p = { 0.0f, 0.0f, 0.0f };
m_jointId3 = b3CreateSphericalJoint( m_worldId, &jointDef );
jointDef.base.bodyIdA = m_chassisId;
jointDef.base.bodyIdB = m_wheelId4;
jointDef.base.localFrameA.p = { -0.9f, -0.15f, -0.4f };
jointDef.base.localFrameB.p = { 0.0f, 0.0f, 0.0f };
m_jointId4 = b3CreateSphericalJoint( m_worldId, &jointDef );
}
void UpdateUI() override
{
float height = 240.0f;
ImGui::SetNextWindowPos( ImVec2( 10.0f, m_context->camera.m_height - height - 50.0f ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 320.0f, height ) );
ImGui::Begin( "Cart", nullptr, ImGuiWindowFlags_NoResize );
ImGui::PushItemWidth( 200.0f );
bool changed = false;
ImGui::Text( "Contact" );
changed = changed || ImGui::SliderFloat( "Hertz##contact", &m_contactHertz, 0.0f, 240.0f, "%.f" );
changed = changed || ImGui::SliderFloat( "Damping Ratio##contact", &m_contactDampingRatio, 0.0f, 100.0f, "%.f" );
changed = changed || ImGui::SliderFloat( "Speed", &m_contactSpeed, 0.0f, 5.0f, "%.1f" );
if ( changed )
{
b3World_SetContactTuning( m_worldId, m_contactHertz, m_contactDampingRatio, m_contactSpeed );
CreateScene();
}
ImGui::Separator();
changed = false;
ImGui::Text( "Joint" );
changed = changed || ImGui::SliderFloat( "Hertz##joint", &m_constraintHertz, 0.0f, 240.0f, "%.f" );
changed = changed || ImGui::SliderFloat( "Damping Ratio##joint", &m_constraintDampingRatio, 0.0f, 20.0f, "%.f" );
ImGui::Separator();
changed = changed || ImGui::Button( "Reset Scene" );
if ( changed )
{
b3Joint_SetConstraintTuning( m_jointId1, m_constraintHertz, m_constraintDampingRatio );
b3Joint_SetConstraintTuning( m_jointId2, m_constraintHertz, m_constraintDampingRatio );
b3Joint_SetConstraintTuning( m_jointId3, m_constraintHertz, m_constraintDampingRatio );
b3Joint_SetConstraintTuning( m_jointId4, m_constraintHertz, m_constraintDampingRatio );
CreateScene();
}
ImGui::PopItemWidth();
ImGui::End();
}
static Sample* Create( SampleContext* context )
{
return new Cart( context );
}
b3BodyId m_chassisId;
b3BodyId m_wheelId1;
b3BodyId m_wheelId2;
b3BodyId m_wheelId3;
b3BodyId m_wheelId4;
b3JointId m_jointId1;
b3JointId m_jointId2;
b3JointId m_jointId3;
b3JointId m_jointId4;
float m_contactHertz;
float m_contactDampingRatio;
float m_contactSpeed;
float m_constraintHertz;
float m_constraintDampingRatio;
};
static int sampleCart = SampleManager::Register( "Robustness", "Cart", Cart::Create );

1145
samples/sample_shapes.cpp Normal file

File diff suppressed because it is too large Load diff

955
samples/sample_stacking.cpp Normal file
View file

@ -0,0 +1,955 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "camera.h"
#include "human.h"
#include "imgui.h"
#include "mesh_loader.h"
#include "sample.h"
#include "scene.h"
#include "box3d/box3d.h"
class CardHouseThick : public Sample
{
public:
explicit CardHouseThick( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 25.0f, 10.0f, { 0.0f, 2.0f, 0.0f } );
EnableGrid( m_scene, true );
}
const float alpha = 25.0f * B3_DEG_TO_RAD;
const float width = 0.38f;
const float height = 0.98f;
const float depth = 0.08f;
float offsetX = 0.5f * height * b3Sin( alpha ) + 0.045f;
float offsetY = 0.5f * height * b3Cos( alpha ) + 0.035f;
b3BodyDef bodyDef = b3DefaultBodyDef();
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull mGround = b3MakeOffsetBoxHull( 10.0f, 1.0f, 10.0f, {0.0f, -1.0f, 0.0f} );
b3BodyId groundBody = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( groundBody, &shapeDef, &mGround.base );
b3BoxHull box = b3MakeBoxHull( 0.5f * depth, 0.5f * height, 0.5f * width );
AddVerticalRow( 4, -6.0f * offsetX, offsetX, offsetY, alpha, box );
AddHorizontalRow( 3, -4.0f * offsetX, 4.0f * offsetX, 2.0f * offsetY + 0.04f, box );
AddVerticalRow( 3, -4.0f * offsetX, offsetX, 3.0f * offsetY + 0.08f, alpha, box );
AddHorizontalRow( 2, -2.0f * offsetX, 4.0f * offsetX, 4.0f * offsetY + 0.12f, box );
AddVerticalRow( 2, -2.0f * offsetX, offsetX, 5.0f * offsetY + 0.16f, alpha, box );
AddHorizontalRow( 1, -0.0f * offsetX, 4.0f * offsetX, 6.0f * offsetY + 0.20f, box );
AddVerticalRow( 1, -0.0f * offsetX, offsetX, 7.0f * offsetY + 0.24f, alpha, box );
}
void AddVerticalRow( int n, float startX, float offsetX, float startY, float alpha, const b3BoxHull& box )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.friction = 0.8f;
for ( int index = 0; index < n; ++index )
{
bodyDef.position = { startX - offsetX, startY, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, -alpha );
b3BodyId body1 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body1, &shapeDef, &box.base );
bodyDef.position = { startX + offsetX, startY, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, alpha );
b3BodyId body2 = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body2, &shapeDef, &box.base );
startX += 4.0f * offsetX;
}
}
void AddHorizontalRow( int n, float startX, float offsetX, float startY, const b3BoxHull& box )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.friction = 0.8f;
for ( int index = 0; index < n; ++index )
{
bodyDef.position = { startX + index * offsetX, startY, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI );
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body, &shapeDef, &box.base );
}
}
static Sample* Create( SampleContext* context )
{
return new CardHouseThick( context );
}
};
static int sampleCardHouseThick = SampleManager::Register( "Stacking", "Card House Thick", CardHouseThick::Create );
// From PEEL
class CardHouse : public Sample
{
public:
explicit CardHouse( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
b3Vec3 pivot = { 0.75, 1.0, 0.4f };
m_camera->SetView( 0.0f, 15.0f, 3.0f, pivot );
EnableGrid( m_scene, true );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -2.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.friction = 0.7f;
b3BoxHull groundBox = b3MakeBoxHull( 40.0f, 2.0f, 40.0f );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
float cardHeight = 0.2f;
float cardThickness = 0.001f;
float cardDepth = 0.1f;
float angle0 = 25.0f * B3_PI / 180.0f;
float angle1 = -25.0f * B3_PI / 180.0f;
float angle2 = 0.5f * B3_PI;
// todo box hull is limiting the minimum thickness, breaking this test
b3BoxHull cardBox = b3MakeBoxHull( cardThickness, cardHeight, cardDepth );
bodyDef.type = b3_dynamicBody;
int Nb = 5;
float z0 = 0.0f;
float y = cardHeight - 0.02f;
while ( Nb )
{
float z = z0;
for ( int i = 0; i < Nb; i++ )
{
if ( i != Nb - 1 )
{
bodyDef.position = { z + 0.25f, y + cardHeight - 0.015f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, angle2 );
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cardBox.base );
}
bodyDef.position = { z, y, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, angle1 );
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cardBox.base );
z += 0.175f;
bodyDef.position = { z, y, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, angle0 );
bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &cardBox.base );
z += 0.175f;
}
y += cardHeight * 2.0f - 0.03f;
z0 += 0.175f;
Nb--;
}
}
static Sample* Create( SampleContext* context )
{
return new CardHouse( context );
}
};
static int sampleCardHouse = SampleManager::Register( "Stacking", "Card House", CardHouse::Create );
class SphereStack : public Sample
{
public:
explicit SphereStack( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 50.0f, {0.0f, 10.0f, 0.0f} );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 15.0f, 1.0f, 15.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
float r = 0.5f;
b3Sphere sphere = { b3Vec3_zero, r };
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = 0.1f;
float y = 1.5f * r;
for ( int i = 0; i < 30; ++i )
{
bodyDef.name = "sphere";
//bodyDef.position.x = 0.1f * i;
bodyDef.position.y = y;
bodyDef.angularVelocity = { 0.0f, 0.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
if ( i == 0 )
{
m_bodyId = bodyId;
}
// shapeDef.density = 1.0f + 4.0f * i;
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
y += 3.0f * r;
}
}
void Step() override
{
// b3Vec3 p = b3Body_GetPosition( m_bodyId );
// printf( "%g %g %g\n", p.x, p.y, p.z );
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new SphereStack( context );
}
b3BodyId m_bodyId;
};
static int sampleSphereStack = SampleManager::Register( "Stacking", "Sphere Stack", SphereStack::Create );
class SingleBox : public Sample
{
public:
explicit SingleBox( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 25.0f, 10.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 15.0f, 1.0f, 15.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
#if 1
{
b3BoxHull cube = b3MakeBoxHull( 0.5f, 0.5f, 0.5f );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "cube";
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 0.5f, 0.0f };
//bodyDef.linearVelocity = { 4.0f, 0.0f, 0.0f };
bodyDef.angularVelocity = { 0.0f, 10.0f, 0.0f };
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3CreateHullShape( m_bodyId, &shapeDef, &cube.base );
}
#else
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "capsule";
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 2.0f, 0.0f };
m_bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3Capsule capsule = { { -0.25f, 0.0f }, { 0.25f, 0.0f }, 0.1f };
b3CreateCapsuleShape( m_bodyId, &shapeDef, &capsule );
}
#endif
}
void Step() override
{
Sample::Step();
b3Vec3 position = b3Body_GetPosition( m_bodyId );
DrawTextLine( "(x, y, z) = (%.2g, %.2g, %.2g)", position.x, position.y, position.z );
}
static Sample* Create( SampleContext* context )
{
return new SingleBox( context );
}
b3BodyId m_bodyId;
};
static int sampleSingleBox = SampleManager::Register( "Stacking", "Single Box", SingleBox::Create );
class Cylinder : public Sample
{
public:
explicit Cylinder( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 10.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 10.0f, 1.0f, 10.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
{
m_hull = b3CreateCylinder( 1.0f, 0.25f, 0.0f, 12 );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "cylinder";
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 2.0f, 0.0f };
bodyDef.linearVelocity = { 0.0f, 0.0f, 0.0f };
// bodyDef.angularVelocity = { 0.0f, 5.0f, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = 0.05f;
b3CreateHullShape( bodyId, &shapeDef, m_hull );
}
m_context->debugDraw.forceScale = 0.01f;
}
~Cylinder() override
{
b3DestroyHull( m_hull );
}
void Step() override
{
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new Cylinder( context );
}
b3Hull* m_hull;
};
static int sampleCylinder = SampleManager::Register( "Stacking", "Cylinder", Cylinder::Create );
class CylinderStack : public Sample
{
public:
explicit CylinderStack( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 15.0f, {0.0f, 5.0f, 0.0f} );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 10.0f, 1.0f, 10.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
m_hull = b3CreateCylinder( 1.0f, 0.5f, 0.0f, 15 );
b3Vec3 scales[4] = {
b3Vec3_one,
{ -0.75f, 1.0f, 1.0f },
{ 1.2f, 1.0f, -0.9f },
{ 0.9f, 0.9f, 0.9f },
};
for ( int i = 0; i < 10; ++i )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "cylinder";
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 0.0f + 1.1f * i, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
//shapeDef.baseMaterial.rollingResistance = 0.1f;
b3CreateTransformedHullShape( bodyId, &shapeDef, m_hull, b3Transform_identity, scales[i % 4] );
}
m_context->debugDraw.forceScale = 0.001f;
}
~CylinderStack() override
{
b3DestroyHull( m_hull );
}
void Step() override
{
Sample::Step();
}
static Sample* Create( SampleContext* context )
{
return new CylinderStack( context );
}
b3Hull* m_hull;
};
static int sampleCylinderStack = SampleManager::Register( "Stacking", "Cylinder Stack", CylinderStack::Create );
class BoxStack : public Sample
{
public:
explicit BoxStack( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 50.0f, {0.0f, 20.0f, 0.0f} );
EnableGrid( m_scene, true );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "ground";
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull hull = b3MakeBoxHull( 40.0f, 1.0f, 40.0f );
b3CreateHullShape( groundId, &shapeDef, &hull.base );
}
float a = 0.5f;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "cube";
bodyDef.type = b3_dynamicBody;
b3BoxHull cube = b3MakeBoxHull( a, a, a );
// b3Quat q = b3MakeQuatFromAxisAngle( { 1.0f, 0.0f, 0.0f }, 0.5f * B3_PI );
for ( int i = 0; i < 40; ++i )
{
bodyDef.position = { 0.0f, 1.5f * a + 2.5f * a * i, 0.0f };
// bodyDef.rotation = b3MulQuat( q, bodyDef.rotation );
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = 0.1f;
b3CreateHullShape( bodyId, &shapeDef, &cube.base );
}
//{
// b3BoxHull wide = b3MakeBoxHull( 2.0f, 0.6f, 0.6f );
// b3BodyDef bodyDef = b3DefaultBodyDef();
// bodyDef.name = "wide";
// bodyDef.type = b3_dynamicBody;
// bodyDef.position = { 0.0f, 0.6f + 1.0f * m_count, 0.0f };
// b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
// b3ShapeDef shapeDef = b3DefaultShapeDef();
// b3CreateHullShape( bodyId, &shapeDef, &wide.base );
//}
}
static Sample* Create( SampleContext* context )
{
return new BoxStack( context );
}
};
static int sampleBoxStack = SampleManager::Register( "Stacking", "Box Stack", BoxStack::Create );
class JengaStack : public Sample
{
public:
explicit JengaStack( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 35.0f, 15.0f, 30.0f, { 0.0f, 10.0f, 0.0f } );
EnableGrid( m_scene, true );
}
m_shapeType = b3_hullShape;
CreateStack();
}
void CreateStack()
{
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull groundBox = b3MakeBoxHull( 50.0f, 1.0f, 50.0f );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
}
{
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.rollingResistance = m_shapeType == b3_capsuleShape ? 0.1f : 0.01f;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3BoxHull box = b3MakeBoxHull( 2.5f, 0.25f, 0.25f );
b3Capsule capsule = { { -2.5f, 0.0f, 0.0f }, { 2.5f, 0.0f, 0.0f }, 0.25f };
for ( int i = 0; i < m_size; ++i )
{
float alpha = ( i & 1 ) == 1 ? 0.0f : 0.5f * B3_PI;
float x = ( i & 1 ) == 0 ? 1.75f : 0.0f;
float z = ( i & 1 ) == 0 ? 0.0f : 1.75f;
bodyDef.position = { x, 0.5f * i + 0.25f, z };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisY, alpha );
b3BodyId boxBody1 = b3CreateBody( m_worldId, &bodyDef );
bodyDef.position = { -x, 0.5f * i + 0.25f, -z };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisY, alpha );
b3BodyId boxBody2 = b3CreateBody( m_worldId, &bodyDef );
if ( m_shapeType == b3_capsuleShape )
{
b3CreateCapsuleShape( boxBody1, &shapeDef, &capsule );
b3CreateCapsuleShape( boxBody2, &shapeDef, &capsule );
}
else
{
b3CreateHullShape( boxBody1, &shapeDef, &box.base );
b3CreateHullShape( boxBody2, &shapeDef, &box.base );
}
}
}
}
void UpdateUI() override
{
float fontSize = ImGui::GetFontSize();
float height = 6.0f * fontSize;
ImGui::SetNextWindowPos( ImVec2( 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize ), ImGuiCond_Once );
ImGui::SetNextWindowSize( ImVec2( 8.0f * fontSize, height ) );
ImGui::Begin( "Jenga Stack", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
b3Capacity capacity = {};
if ( ImGui::RadioButton( "Capsule", m_shapeType == b3_capsuleShape ) )
{
m_shapeType = b3_capsuleShape;
CreateWorld( &capacity );
CreateStack();
}
if ( ImGui::RadioButton( "Hull", m_shapeType == b3_hullShape ) )
{
m_shapeType = b3_hullShape;
CreateWorld( &capacity );
CreateStack();
}
ImGui::End();
Sample::UpdateUI();
}
static Sample* Create( SampleContext* context )
{
return new JengaStack( context );
}
static constexpr int m_size = 40;
b3ShapeType m_shapeType;
};
static int sampleJengaStack = SampleManager::Register( "Stacking", "Jenga Stack", JengaStack::Create );
class Dominoes : public Sample
{
public:
explicit Dominoes( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 50.0f, b3Vec3_zero );
EnableGrid( m_scene, true );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundBody = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull groundBox = b3MakeBoxHull( 80.0f, 1.0f, 80.0f );
b3CreateHullShape( groundBody, &shapeDef, &groundBox.base );
constexpr int n = m_isDebug ? 2 : 30;
b3BoxHull box = b3MakeBoxHull( 0.2f, 0.8f, 0.05f );
for ( int ring = 0; ring < n; ++ring )
{
float radius = 7.0f + 1.1f * ring;
CreateRing( radius, box );
}
}
void CreateRing( float radius, b3BoxHull& box )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
b3ShapeDef shapeDef = b3DefaultShapeDef();
for ( float alpha = 0; alpha <= 360.0f; alpha += 2.0f )
// for (float Alpha = 0; Alpha <= 4.0f; Alpha += 4.0f)
{
b3CosSin cs = b3ComputeCosSin( B3_DEG_TO_RAD * alpha );
b3Vec3 position = { radius * cs.cosine, 0.8f, radius * cs.sine };
b3Vec3 normal = { cs.cosine, 0.0f, cs.sine };
position -= alpha / 630.0f * normal;
b3Quat orientation = b3MakeQuatFromAxisAngle( b3Vec3_axisY, -B3_DEG_TO_RAD * alpha );
bodyDef.position = position;
bodyDef.rotation = orientation;
b3BodyId body = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( body, &shapeDef, &box.base );
if ( alpha == 0.0f )
{
b3Body_ApplyLinearImpulse( body, { 0.0f, 0.0f, 25.0f }, position + b3Vec3{ 0.0f, 0.8f, 0.0f }, true );
}
}
}
static Sample* Create( SampleContext* context )
{
return new Dominoes( context );
}
};
static int sampleDominoes = SampleManager::Register( "Stacking", "Dominoes", Dominoes::Create );
// This wedge shape can have an incorrect manifold if not handled correctly
class Wedge : public Sample
{
public:
static Sample* Create( SampleContext* context )
{
return new Wedge( context );
}
explicit Wedge( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 77.0f, 10.0f, 5.0f );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull groundBox = b3MakeBoxHull( 25.0f, 1.0f, 25.0f );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
b3Vec3 vertices[] = {
{ -1.0, 1.0f, -0.1f }, { 1.0, 1.0f, -0.1f }, { -1.0, 1.0f, 0.1f },
{ 1.0, 1.0f, 0.1f }, { -0.5, 0.5f, 0.0f }, { 0.5, 0.5f, 0.0f },
};
m_wedgeHull = b3CreateHull( vertices, 6, 6 );
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 1.0f, 0.0f };
b3BodyId wedgeBody = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( wedgeBody, &shapeDef, m_wedgeHull );
}
~Wedge() override
{
b3DestroyHull( m_wedgeHull );
}
b3Hull* m_wedgeHull;
};
static int sampleWedge = SampleManager::Register( "Stacking", "Wedge", Wedge::Create );
// jitter
/*
*+ position [ -459.292877, 217.398331, 1.00115335 ] b3Vec3
+ rotation [ [ -0.00000000, 0.00000000, -0.707106769 ], 0.707106769 ] b3Quat
points[0] = { -44.8770714, -91.6598053, -1.92012548 };
points[1] = { -92.5001831, 51.0151291, 15.8006573 };
points[2] = { -91.0282211, -9.44371605, 15.6148796 };
points[3] = { 90.2375641, 77.3870087, 15.9356089 };
points[4] = { -85.5353241, 91.3750992, -1.36629653 };
points[5] = { 88.9092178, -87.2975464, -1.86754704 };
points[6] = { 83.7932816, -89.8572235, 15.4168339 };
points[7] = { 87.0243988, 88.9776535, -1.32423306 };
points[8] = { -91.6564941, -85.4949493, 15.3782759 };
points[9] = { -90.2922516, -87.2074127, -1.92012548 };
points[10] = { -87.2944870, 89.9510498, 15.9215889 };
points[11] = { 79.2338104, 89.9690781, 15.9724140 };
points[12] = { -91.6744461, 81.0823212, -1.39959598 };
points[13] = { 90.3452759, -76.4459610, 15.4588966 };
points[14] = { -87.4021912, -89.2263107, 15.3677588 };
points[15] = { 76.3258057, 92.0059967, 1.82873762 };
*/
/*
*
*+ position [ -402.321838, 157.310364, 16.8169250 ] b3Vec3
+ rotation [ [ -0.00000000, 0.00000000, -0.00152086187 ], 0.999998868 ] b3Quat
*
points[0] = { 29.5000000, 17.1488495, 0.175081104 };
points[1] = { 29.5000000, -17.2990532, 0.125000000 };
points[2] = { 29.4840164, -17.3057766, 24.0200863 };
points[3] = { 29.4840164, 17.1648350, 24.1781254 };
points[4] = { -29.1345520, 17.5529804, 0.125000000 };
points[5] = { -29.1345520, 17.5529804, 23.7899799 };
points[6] = { -29.1441040, 16.9679585, 24.3750000 };
points[7] = { -29.1345520, -17.2990532, 24.3750000 };
points[8] = { -29.1345520, -17.2990532, 0.175081253 };
points[9] = { 29.0720215, 17.5529785, 0.125000000 };
points[10] = { 29.0859070, 17.5629406, 23.8120594 };
points[11] = { 29.1401348, -17.2990532, 24.3750000 };
points[12] = { 29.1123581, 16.9722290, 24.4027710 };
points[13] = { 29.3944912, 17.2543602, 24.1206398 };
points[14] = { -29.1345520, -17.2990532, 24.0759430 };
points[15] = { -29.1345520, -16.9722252, 24.4027710 };
points[16] = { 29.1123619, -16.9722271, 24.4027729 };
points[17] = { 29.5000000, 17.3429642, 24.0000000 };
*/
class Arch : public Sample
{
public:
explicit Arch( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 0.0f, 15.0f, 30.0f, { 0.0f, 5.0f, 0.0f } );
EnableGrid( m_scene, true );
}
b3Vec3 ps1[9] = { { 16.0f, 0.0f, 0.0f },
{ 14.93803712795643f, 5.133601056842984f, 0.0f },
{ 13.79871746027416f, 10.24928069555078f, 0.0f },
{ 12.56252963284711f, 15.34107019122473f, 0.0f },
{ 11.20040987372525f, 20.39856541571217f, 0.0f },
{ 9.66521217819836f, 25.40369899225096f, 0.0f },
{ 7.87179930638133f, 30.3179337000085f, 0.0f },
{ 5.635199558196225f, 35.03820717801641f, 0.0f },
{ 2.405937953536585f, 39.09554102558315f, 0.0f } };
b3Vec3 ps2[9] = { { 24.0f, 0.0f, 0.0f },
{ 22.33619528222415f, 6.02299846205841f, 0.0f },
{ 20.54936888969905f, 12.00964361211476f, 0.0f },
{ 18.60854610798073f, 17.9470321677465f, 0.0f },
{ 16.46769273811807f, 23.81367936585418f, 0.0f },
{ 14.05325025774858f, 29.57079353071012f, 0.0f },
{ 11.23551045834022f, 35.13775818285372f, 0.0f },
{ 7.752568160730571f, 40.30450679009583f, 0.0f },
{ 3.016931552701656f, 44.28891593799322f, 0.0f } };
float scale = 0.25f;
for ( int i = 0; i < 9; ++i )
{
ps1[i].x *= scale;
ps1[i].y *= scale;
ps2[i].x *= scale;
ps2[i].y *= scale;
}
const float halfDepth = 0.5f;
b3ShapeDef shapeDef = b3DefaultShapeDef();
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull groundBox = b3MakeBoxHull( 50.0f, 1.0f, 50.0f );
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
for ( int i = 0; i < 8; ++i )
{
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3Vec3 ps[8] = {
{ ps1[i].x, ps1[i].y, -halfDepth }, { ps2[i].x, ps2[i].y, -halfDepth },
{ ps2[i + 1].x, ps2[i + 1].y, -halfDepth }, { ps1[i + 1].x, ps1[i + 1].y, -halfDepth },
{ ps1[i].x, ps1[i].y, halfDepth }, { ps2[i].x, ps2[i].y, halfDepth },
{ ps2[i + 1].x, ps2[i + 1].y, halfDepth }, { ps1[i + 1].x, ps1[i + 1].y, halfDepth },
};
b3Hull* hull = b3CreateHull( ps, 8, 8 );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
for ( int i = 0; i < 8; ++i )
{
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3Vec3 ps[8] = {
{ -ps2[i].x, ps2[i].y, -halfDepth }, { -ps1[i].x, ps1[i].y, -halfDepth },
{ -ps1[i + 1].x, ps1[i + 1].y, -halfDepth }, { -ps2[i + 1].x, ps2[i + 1].y, -halfDepth },
{ -ps2[i].x, ps2[i].y, halfDepth }, { -ps1[i].x, ps1[i].y, halfDepth },
{ -ps1[i + 1].x, ps1[i + 1].y, halfDepth }, { -ps2[i + 1].x, ps2[i + 1].y, halfDepth },
};
b3Hull* hull = b3CreateHull( ps, 8, 8 );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
{
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3Vec3 ps[8] = {
{ ps1[8].x, ps1[8].y, -halfDepth }, { ps2[8].x, ps2[8].y, -halfDepth },
{ -ps2[8].x, ps2[8].y, -halfDepth }, { -ps1[8].x, ps1[8].y, -halfDepth },
{ ps1[8].x, ps1[8].y, halfDepth }, { ps2[8].x, ps2[8].y, halfDepth },
{ -ps2[8].x, ps2[8].y, halfDepth }, { -ps1[8].x, ps1[8].y, halfDepth },
};
b3Hull* hull = b3CreateHull( ps, 8, 8 );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
for ( int i = 0; i < 4; ++i )
{
b3BoxHull box = b3MakeBoxHull( 2.0f, 0.5f, halfDepth );
bodyDef.position = { 0.0f, 0.5f + ps2[8].y + 1.0f * i, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
}
static Sample* Create( SampleContext* context )
{
return new Arch( context );
}
};
static int sampleArch = SampleManager::Register( "Stacking", "Arch", Arch::Create );
class Pyramid2D : public Sample
{
public:
explicit Pyramid2D( SampleContext* context )
: Sample( context )
{
if ( m_context->restart == false )
{
m_camera->SetView( 0.0f, 30.0f, 50.0f, { 0.0f, 5.0f, 0.0f } );
}
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 0.0f, -1.0f, 0.0f };
b3BodyId groundId = b3CreateBody( m_worldId, &bodyDef );
b3BoxHull groundBox = b3MakeBoxHull( 50.0f, 1.0f, 50.0f );
b3ShapeDef shapeDef = b3DefaultShapeDef();
// shapeDef.filter = { 1, ~0u, 0 };
b3CreateHullShape( groundId, &shapeDef, &groundBox.base );
}
float a = 1.0f;
b3BoxHull box = b3MakeBoxHull( a, a, a );
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.motionLocks.linearZ = true;
bodyDef.motionLocks.angularX = true;
bodyDef.motionLocks.angularY = true;
b3ShapeDef shapeDef = b3DefaultShapeDef();
for ( int row = 0; row < m_size; ++row )
{
for ( int column = 0; column < m_size - row; ++column )
{
bodyDef.position = { ( -20.0f + 2.0f * column + row ) * a, ( 1.5f + 2.5f * row ) * a, 0.0f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
}
}
static Sample* Create( SampleContext* context )
{
return new Pyramid2D( context );
}
static constexpr int m_size = 12;
};
static int samplePyramid2D = SampleManager::Register( "Stacking", "Pyramid2D", Pyramid2D::Create );

848
samples/sample_tree.cpp Normal file
View file

@ -0,0 +1,848 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#if defined( _MSC_VER ) && !defined( _CRT_SECURE_NO_WARNINGS )
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "camera.h"
#include "imgui.h"
#include "utils.h"
#include "renderer.h"
#include "sample.h"
#include "scene.h"
#include <queue>
#include <stdio.h>
#include <unordered_map>
#include <vector>
constexpr int colorCount = 12;
b3HexColor colors[colorCount] = {
b3_colorRoyalBlue, b3_colorPink, b3_colorLightGreen, b3_colorOrange, b3_colorYellow, b3_colorViolet,
b3_colorAqua, b3_colorCoral, b3_colorLightGray, b3_colorMoccasin, b3_colorLavender, b3_colorMediumOrchid,
};
struct FileConfig
{
float scale;
bool zUp;
};
struct Proxy
{
b3AABB aabb;
int proxyId;
int queryTimeStamp;
int rayTimeStamp;
};
struct Ray
{
b3Vec3 origin, translation;
};
#ifdef _WIN32
#include <immintrin.h>
// Warning: this code has not been validated
void ClosestPointAVX2( const float* aabbMinX, const float* aabbMinY, const float* aabbMinZ, const float* aabbMaxX,
const float* aabbMaxY, const float* aabbMaxZ, int proxyCount, b3Vec3 point, b3Vec3* outClosestPoint,
float* outMinDistSq )
{
const __m256 px = _mm256_set1_ps( point.x );
const __m256 py = _mm256_set1_ps( point.y );
const __m256 pz = _mm256_set1_ps( point.z );
__m256 bestDistSq = _mm256_set1_ps( FLT_MAX );
__m256i bestIndex = _mm256_set1_epi32( -1 );
int j = 0;
for ( ; j + 8 <= proxyCount; j += 8 )
{
// Load AABB bounds for 8 proxies
__m256 minX = _mm256_loadu_ps( aabbMinX + j );
__m256 minY = _mm256_loadu_ps( aabbMinY + j );
__m256 minZ = _mm256_loadu_ps( aabbMinZ + j );
__m256 maxX = _mm256_loadu_ps( aabbMaxX + j );
__m256 maxY = _mm256_loadu_ps( aabbMaxY + j );
__m256 maxZ = _mm256_loadu_ps( aabbMaxZ + j );
// Closest point on AABB to point: clamp each coordinate
__m256 cx = _mm256_min_ps( _mm256_max_ps( px, minX ), maxX );
__m256 cy = _mm256_min_ps( _mm256_max_ps( py, minY ), maxY );
__m256 cz = _mm256_min_ps( _mm256_max_ps( pz, minZ ), maxZ );
// d = point - closest
__m256 dx = _mm256_sub_ps( px, cx );
__m256 dy = _mm256_sub_ps( py, cy );
__m256 dz = _mm256_sub_ps( pz, cz );
__m256 dx2 = _mm256_mul_ps( dx, dx );
__m256 dy2 = _mm256_mul_ps( dy, dy );
__m256 dz2 = _mm256_mul_ps( dz, dz );
__m256 distSq = _mm256_add_ps( _mm256_add_ps( dx2, dy2 ), dz2 );
// Compare to current best
__m256 mask = _mm256_cmp_ps( distSq, bestDistSq, _CMP_LT_OQ );
bestDistSq = _mm256_blendv_ps( bestDistSq, distSq, mask );
__m256i indices = _mm256_set_epi32( j + 7, j + 6, j + 5, j + 4, j + 3, j + 2, j + 1, j + 0 );
// Tracks the 8 best indices
bestIndex =
_mm256_castps_si256( _mm256_blendv_ps( _mm256_castsi256_ps( bestIndex ), _mm256_castsi256_ps( indices ), mask ) );
}
// Now find the best index among the best 8.
alignas( 32 ) float distBuf[8];
alignas( 32 ) int indexBuf[8];
_mm256_store_ps( distBuf, bestDistSq );
_mm256_store_si256( (__m256i*)indexBuf, bestIndex );
float minDist = distBuf[0];
int minIdx = indexBuf[0];
for ( int k = 1; k < 8; ++k )
{
if ( distBuf[k] < minDist )
{
minDist = distBuf[k];
minIdx = indexBuf[k];
}
}
// Remainder
for ( ; j < proxyCount; ++j )
{
float cx = b3MinFloat( b3MaxFloat( point.x, aabbMinX[j] ), aabbMaxX[j] );
float cy = b3MinFloat( b3MaxFloat( point.y, aabbMinY[j] ), aabbMaxY[j] );
float cz = b3MinFloat( b3MaxFloat( point.z, aabbMinZ[j] ), aabbMaxZ[j] );
float dx = point.x - cx;
float dy = point.y - cy;
float dz = point.z - cz;
float d2 = dx * dx + dy * dy + dz * dz;
if ( d2 < minDist )
{
minDist = d2;
minIdx = j;
}
}
b3Vec3 cp;
cp.x = b3MinFloat( b3MaxFloat( point.x, aabbMinX[minIdx] ), aabbMaxX[minIdx] );
cp.y = b3MinFloat( b3MaxFloat( point.y, aabbMinY[minIdx] ), aabbMaxY[minIdx] );
cp.z = b3MinFloat( b3MaxFloat( point.z, aabbMinZ[minIdx] ), aabbMaxZ[minIdx] );
*outClosestPoint = cp;
*outMinDistSq = minDist;
}
#endif
class TreeBenchmark : public Sample
{
public:
explicit TreeBenchmark( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 45.0f, 45.0f, 250.0f, b3Vec3_zero );
}
m_fileNames[0] = { "bounds01" };
m_fileNames[1] = { "bounds02" };
m_fileNames[2] = { "bounds03" };
m_config[0] = { 1.0f, false };
m_config[1] = { 1.0f, false };
m_config[2] = { 0.01f, false };
m_fileIndex = 0;
m_closestPoint = b3Vec3_zero;
m_timeStamp = 1;
m_doOverlap = false;
m_doClosest = false;
m_doRay = false;
m_testIndex = 0;
m_rayTime = 0.0f;
m_overlapTime = 0.0f;
m_closestTime = 0.0f;
m_haveClosest = false;
m_buildTime = 0.0f;
m_areaRatio = 0.0f;
m_drawDistance = 1.0f;
m_loadScale = 1.0f;
m_height = 0;
m_tree = {};
m_aabbMinX = nullptr;
m_aabbMinY = nullptr;
m_aabbMinZ = nullptr;
m_aabbMaxX = nullptr;
m_aabbMaxY = nullptr;
m_aabbMaxZ = nullptr;
CreateTree();
}
~TreeBenchmark() override
{
b3DynamicTree_Destroy( &m_tree );
#ifdef _WIN32
_aligned_free( m_aabbMinX );
_aligned_free( m_aabbMinY );
_aligned_free( m_aabbMinZ );
_aligned_free( m_aabbMaxX );
_aligned_free( m_aabbMaxY );
_aligned_free( m_aabbMaxZ );
#endif
}
// Breath-first search to compute node depth values start with 0 at the root.
int ComputeDepths()
{
m_depths.resize( m_tree.nodeCapacity, 0 );
int* queue = (int*)malloc( m_tree.nodeCount * sizeof( int ) );
int front = 0;
int back = 0;
b3TreeNode* nodes = m_tree.nodes;
queue[0] = m_tree.root;
back += 1;
int depth = 0;
while ( back > front )
{
int index = queue[front];
front += 1;
b3TreeNode* node = nodes + index;
if ( node->parent == B3_NULL_INDEX )
{
m_depths[index] = 0;
}
else
{
m_depths[index] = m_depths[node->parent] + 1;
depth = b3MaxInt( depth, m_depths[index] );
}
if ( ( node->flags & b3_leafNode ) == 0 )
{
B3_ASSERT( back < m_tree.nodeCount - 1 );
queue[back++] = node->children.child1;
queue[back++] = node->children.child2;
}
}
free( queue );
return depth;
}
void CreateTree()
{
if ( m_tree.nodeCapacity > 0 )
{
b3DynamicTree_Destroy( &m_tree );
m_tree = {};
}
m_proxies.clear();
#ifdef _WIN32
_aligned_free( m_aabbMinX );
_aligned_free( m_aabbMinY );
_aligned_free( m_aabbMinZ );
_aligned_free( m_aabbMaxX );
_aligned_free( m_aabbMaxY );
_aligned_free( m_aabbMaxZ );
#endif
m_tree = b3DynamicTree_Create( 512 );
char filePath[64] = {};
snprintf( filePath, 64, "data/trees/%s.txt", m_fileNames[m_fileIndex] );
float scale = m_config[m_fileIndex].scale;
bool zUp = m_config[m_fileIndex].zUp;
FILE* file = fopen( filePath, "r" );
if ( file == nullptr )
{
return;
}
constexpr int bufferSize = 512;
char buffer[bufferSize];
int maxArea = 0.0f;
int maxAreaIndex = -1;
uint64_t key = 0;
while ( fgets( buffer, sizeof( buffer ), file ) )
{
char* trim = buffer;
while ( *trim == ' ' || *trim == '\t' )
{
++trim;
}
if ( *trim == '\0' || *trim == '\n' || *trim == '#' )
{
continue;
}
Proxy rec = {};
float b1, b2, b3, b4, b5, b6;
int parsed = sscanf( buffer, "%f %f %f %f %f %f", &b1, &b2, &b3, &b4, &b5, &b6 );
if ( parsed != 6 )
{
fprintf( stderr, "Skipping malformed line: %s", buffer );
continue;
}
if ( zUp )
{
rec.aabb.lowerBound.x = scale * b1;
rec.aabb.lowerBound.y = scale * b3;
rec.aabb.lowerBound.z = scale * b2;
rec.aabb.upperBound.x = scale * b4;
rec.aabb.upperBound.y = scale * b6;
rec.aabb.upperBound.z = scale * b5;
}
else
{
rec.aabb.lowerBound.x = scale * b1;
rec.aabb.lowerBound.y = scale * b2;
rec.aabb.lowerBound.z = scale * b3;
rec.aabb.upperBound.x = scale * b4;
rec.aabb.upperBound.y = scale * b5;
rec.aabb.upperBound.z = scale * b6;
}
float area = b3AABB_Area( rec.aabb );
if ( area > maxArea )
{
maxArea = area;
maxAreaIndex = (int)m_proxies.size();
}
m_proxies[key] = rec;
key += 1;
// if ( m_proxies.size() == 320 )
//{
// break;
// }
}
#ifdef _WIN32
int proxyCount = m_proxies.size();
m_aabbMinX = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMinY = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMinZ = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxX = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxY = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxZ = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
for ( int i = 0; i < proxyCount; ++i )
{
b3Vec3 lb = m_proxies[i].aabb.lowerBound;
b3Vec3 ub = m_proxies[i].aabb.upperBound;
m_aabbMinX[i] = lb.x;
m_aabbMinY[i] = lb.y;
m_aabbMinZ[i] = lb.z;
m_aabbMaxX[i] = ub.x;
m_aabbMaxY[i] = ub.y;
m_aabbMaxZ[i] = ub.z;
}
#endif
printf( "max index = %d\n", maxAreaIndex );
// constexpr int n = m_isDebug ? 1000 : INT_MAX;
uint64_t ticks = b3GetTicks();
int count = (int)m_proxies.size();
for ( int i = 0; i < count; ++i )
{
// Arbitrary category bits to ensure correctness
m_proxies[i].proxyId = b3DynamicTree_CreateProxy( &m_tree, m_proxies[i].aabb, 1, i );
m_proxies[i].queryTimeStamp = 0;
m_proxies[i].rayTimeStamp = 0;
}
m_buildTime = b3GetMilliseconds( ticks );
b3DynamicTree_Validate( &m_tree );
m_areaRatio = b3DynamicTree_GetAreaRatio( &m_tree );
m_height = ComputeDepths();
m_drawLevel = -1;
Generate();
}
void LoadTree()
{
if ( m_tree.nodeCapacity > 0 )
{
b3DynamicTree_Destroy( &m_tree );
m_tree = {};
}
m_proxies.clear();
#ifdef _WIN32
_aligned_free( m_aabbMinX );
_aligned_free( m_aabbMinY );
_aligned_free( m_aabbMinZ );
_aligned_free( m_aabbMaxX );
_aligned_free( m_aabbMaxY );
_aligned_free( m_aabbMaxZ );
#endif
{
//bool zUp = true;
m_tree = b3DynamicTree_Load( m_saveFileName, m_loadScale );
}
constexpr int bufferSize = 512;
char buffer[bufferSize];
int maxArea = 0.0f;
int maxAreaIndex = -1;
for ( int i = 0; i < m_tree.nodeCapacity; ++i )
{
b3TreeNode* node = m_tree.nodes + i;
if ( ( node->flags & b3_leafNode ) == 0 )
{
continue;
}
assert( node->flags & b3_allocatedNode );
Proxy proxy = {};
proxy.aabb = node->aabb;
float area = b3AABB_Area( proxy.aabb );
if ( area > maxArea )
{
maxArea = area;
maxAreaIndex = (int)m_proxies.size();
}
proxy.proxyId = i;
m_proxies[node->userData] = proxy;
}
#ifdef _WIN32
int proxyCount = m_proxies.size();
m_aabbMinX = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMinY = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMinZ = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxX = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxY = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
m_aabbMaxZ = (float*)_aligned_malloc( proxyCount * sizeof( float ), 32 );
for ( int i = 0; i < proxyCount; ++i )
{
b3Vec3 lb = m_proxies[i].aabb.lowerBound;
b3Vec3 ub = m_proxies[i].aabb.upperBound;
m_aabbMinX[i] = lb.x;
m_aabbMinY[i] = lb.y;
m_aabbMinZ[i] = lb.z;
m_aabbMaxX[i] = ub.x;
m_aabbMaxY[i] = ub.y;
m_aabbMaxZ[i] = ub.z;
}
#endif
printf( "max index = %d\n", maxAreaIndex );
// constexpr int n = m_isDebug ? 1000 : INT_MAX;
m_buildTime = 0.0f;
b3DynamicTree_Validate( &m_tree );
m_areaRatio = b3DynamicTree_GetAreaRatio( &m_tree );
m_height = ComputeDepths();
m_drawLevel = -1;
Generate();
}
static float RayCallback( const b3RayCastInput* input, int proxyId, uint64_t userData, void* context )
{
TreeBenchmark* sample = static_cast<TreeBenchmark*>( context );
Proxy& proxy = sample->m_proxies[userData];
proxy.rayTimeStamp = sample->m_timeStamp;
return 1.0f;
}
static bool QueryCallback( int proxyId, uint64_t userData, void* context )
{
TreeBenchmark* sample = static_cast<TreeBenchmark*>( context );
Proxy& proxy = sample->m_proxies[userData];
proxy.queryTimeStamp = sample->m_timeStamp;
return true;
}
static float ClosetPointCallback( float minDistanceSquared, int proxyId, uint64_t userData, void* context )
{
(void)proxyId;
TreeBenchmark* sample = static_cast<TreeBenchmark*>( context );
int testIndex = sample->m_testIndex;
Proxy& proxy = sample->m_proxies[userData];
proxy.queryTimeStamp = sample->m_timeStamp;
b3Vec3 queryPoint = sample->m_closestPointQueries[testIndex].center;
b3Vec3 closestPoint = b3ClosestPointToAABB( queryPoint, proxy.aabb );
float distanceSquared = b3DistanceSquared( queryPoint, closestPoint );
if ( distanceSquared < minDistanceSquared )
{
sample->m_closestPoint = closestPoint;
sample->m_haveClosest = true;
}
return distanceSquared;
}
void Generate()
{
srand( 42 );
b3AABB bounds = m_tree.nodes[m_tree.root].aabb;
b3Vec3 extents = b3AABB_Extents( bounds );
float radius = ( extents.x + extents.y + extents.z ) / 3.0f;
for ( int i = 0; i < m_testCount; ++i )
{
m_rays[i].origin = RandomVec3( bounds.lowerBound, bounds.upperBound );
b3Vec3 end = RandomVec3( bounds.lowerBound, bounds.upperBound );
m_rays[i].translation = end - m_rays[i].origin;
float s = RandomFloatRange( 0.01f, 0.2f );
b3Vec3 c = RandomVec3( bounds.lowerBound, bounds.upperBound );
b3Vec3 p1 = c - s * extents;
b3Vec3 p2 = c + s * extents;
m_overlapQueries[i].lowerBound = b3Min( p1, p2 );
m_overlapQueries[i].upperBound = b3Max( p1, p2 );
m_closestPointQueries[i] = {
.center = c,
.radius = s * radius,
};
}
}
void Profile()
{
uint64_t ticks = b3GetTicks();
for ( int i = 0; i < m_testCount; ++i )
{
Ray ray = m_rays[i];
b3RayCastInput input = { ray.origin, ray.translation, 1.0f };
b3DynamicTree_RayCast( &m_tree, &input, B3_DEFAULT_MASK_BITS, false, RayCallback, this );
}
m_rayTime = b3GetMillisecondsAndReset( &ticks );
for ( int i = 0; i < m_testCount; ++i )
{
b3DynamicTree_Query( &m_tree, m_overlapQueries[i], B3_DEFAULT_MASK_BITS, false, QueryCallback, this );
}
m_overlapTime = b3GetMilliseconds( ticks );
#if 0 && defined( _WIN32 )
// brute force avx2
int proxyCount = (int)m_proxies.size();
for ( int i = 0; i < m_testCount; ++i )
{
b3Vec3 point = m_closestPointQueries[i].center;
float minDistSq;
b3Vec3 closest;
ClosestPointAVX2( m_aabbMinX, m_aabbMinY, m_aabbMinZ, m_aabbMaxX, m_aabbMaxY, m_aabbMaxZ, proxyCount, point, &closest,
&minDistSq );
m_closestPoint = closest;
m_haveClosest = true;
}
#elif 0
// Brute force
int proxyCount = (int)m_proxies.size();
for ( int i = 0; i < m_testCount; ++i )
{
b3Vec3 point = m_closestPointQueries[i].center;
float minDistanceSquared = FLT_MAX;
m_haveClosest = false;
for ( int j = 0; j < proxyCount; ++j )
{
b3Vec3 closestPoint = b3ClosestPointToAABB( point, m_proxies[j].aabb );
float d = b3DistanceSquared( point, closestPoint );
if ( d < minDistanceSquared )
{
m_closestPoint = closestPoint;
m_haveClosest = true;
minDistanceSquared = d;
}
}
}
#else
for ( int i = 0; i < m_testCount; ++i )
{
b3Vec3 point = m_closestPointQueries[i].center;
float radius = m_closestPointQueries[i].radius;
float distanceSquared = radius * radius;
m_closestPoint = point;
m_haveClosest = false;
b3DynamicTree_QueryClosest( &m_tree, point, B3_DEFAULT_MASK_BITS, false, ClosetPointCallback, this,
&distanceSquared );
}
#endif
m_closestTime = b3GetMilliseconds( ticks );
}
void UpdateUI() override
{
DrawTextLine( "leaves = %d, height = %d, area = %g", m_tree.proxyCount, m_height, m_areaRatio );
DrawTextLine( "build time = %g ms", m_buildTime );
DrawTextLine( "total: ray = %g ms, overlap = %g ms, closest = %g ms", m_rayTime, m_overlapTime, m_closestTime );
float s = 1000.0f / m_testCount;
DrawTextLine( "ave: ray = %g us, overlap = %g us, closest = %g us", s * m_rayTime, s * m_overlapTime, s * m_closestTime );
float fontSize = ImGui::GetFontSize();
float height = 23.0f * fontSize;
ImGui::SetNextWindowPos( { 0.5f * fontSize, m_camera->m_height - height - 2.0f * fontSize }, ImGuiCond_Once );
ImGui::SetNextWindowSize( { 18.0f * fontSize, height } );
ImGui::Begin( "Tree", nullptr, ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize );
if ( ImGui::Combo( "File", &m_fileIndex, m_fileNames, m_fileCount ) )
{
CreateTree();
}
if ( ImGui::Button( "Top Down" ) )
{
uint64_t ticks = b3GetTicks();
b3DynamicTree_Rebuild( &m_tree, true );
m_buildTime = b3GetMilliseconds( ticks );
m_areaRatio = b3DynamicTree_GetAreaRatio( &m_tree );
m_height = ComputeDepths();
}
ImGui::Separator();
ImGui::Checkbox( "Ray Cast", &m_doRay );
ImGui::Checkbox( "Overlap", &m_doOverlap );
ImGui::Checkbox( "Closet Point", &m_doClosest );
if ( ImGui::Button( "Profile" ) )
{
Profile();
}
ImGui::SliderInt( "Test", &m_testIndex, 0, m_testCount - 1 );
ImGui::SliderInt( "Level", &m_drawLevel, -1, m_height );
ImGui::SliderFloat( "Kilometers", &m_drawDistance, 0.5f, 20.0f, "%.1f" );
if ( ImGui::Button( "Save" ) )
{
b3DynamicTree_Save( &m_tree, m_saveFileName );
}
if ( ImGui::Button( "Load" ) )
{
LoadTree();
}
ImGui::SliderFloat( "Load Scale", &m_loadScale, 0.01f, 1.0f );
ImGui::End();
}
void Render() override
{
Sample::Render();
DrawTransform( m_scene, b3Transform_identity, 2.0f );
b3Vec3 cp = m_camera->GetPosition();
b3TreeNode* nodes = m_tree.nodes;
float distSquared = m_drawDistance * m_drawDistance * 1000.0f * 1000.0f;
if ( m_drawLevel >= 0 )
{
constexpr int colorCount = 20;
b3HexColor colors[colorCount] = {
b3_colorAliceBlue, b3_colorAntiqueWhite, b3_colorAqua, b3_colorAquamarine, b3_colorAzure,
b3_colorBeige, b3_colorBisque, b3_colorBlanchedAlmond, b3_colorBlue, b3_colorBlueViolet,
b3_colorBrown, b3_colorBurlywood, b3_colorCadetBlue, b3_colorChartreuse, b3_colorChocolate,
b3_colorCoral, b3_colorCornflowerBlue, b3_colorCornsilk, b3_colorCrimson, b3_colorCyan,
};
int capacity = m_tree.nodeCapacity;
for ( int i = 0; i < capacity; ++i )
{
b3TreeNode* node = nodes + i;
if ( m_depths[i] != m_drawLevel || ( node->flags & b3_allocatedNode ) == 0 )
{
// skip internal nodes
continue;
}
b3Vec3 c = b3AABB_Center( node->aabb );
if ( m_drawLevel < 10 || b3DistanceSquared( c, cp ) < distSquared )
{
DrawBounds( m_scene, node->aabb, 0.0f, colors[m_drawLevel % colorCount] );
}
}
}
else
{
uint16_t requiredFlags = b3_allocatedNode | b3_leafNode;
for ( int i = 0; i < m_tree.nodeCapacity; ++i )
{
b3TreeNode* node = nodes + i;
if ( node->flags != requiredFlags )
{
continue;
}
b3Vec3 c = b3AABB_Center( node->aabb );
if ( b3DistanceSquared( c, cp ) > distSquared )
{
continue;
}
Proxy& proxy = m_proxies[node->userData];
if ( proxy.queryTimeStamp == m_timeStamp || proxy.rayTimeStamp == m_timeStamp )
{
DrawBounds( m_scene, node->aabb, 0.0f, b3_colorLightGray );
}
else
{
// float extension = 0.01f * node->height;
float extension = 0.0f;
DrawBounds( m_scene, node->aabb, extension, b3_colorLightBlue );
}
}
}
if ( m_doRay )
{
Ray ray = m_rays[m_testIndex];
DrawLine( m_scene, ray.origin, ray.origin + ray.translation, b3_colorRed );
}
if ( m_doOverlap )
{
DrawBounds( m_scene, m_overlapQueries[m_testIndex], 0.0f, b3_colorRed );
}
if ( m_doClosest )
{
DrawSphere( m_scene, b3Transform_identity, m_closestPointQueries[m_testIndex], b3_colorCyan );
if ( m_haveClosest )
{
DrawPoint( m_scene, m_closestPoint, 15.0f, b3_colorOrange );
}
}
}
void Step() override
{
Sample::Step();
++m_timeStamp;
if ( m_doRay )
{
Ray ray = m_rays[m_testIndex];
b3RayCastInput input = { ray.origin, ray.translation, 1.0f };
b3DynamicTree_RayCast( &m_tree, &input, B3_DEFAULT_MASK_BITS, false, RayCallback, this );
}
if ( m_doOverlap )
{
b3DynamicTree_Query( &m_tree, m_overlapQueries[m_testIndex], B3_DEFAULT_MASK_BITS, false, QueryCallback, this );
}
if ( m_doClosest )
{
b3Vec3 point = m_closestPointQueries[m_testIndex].center;
float radius = m_closestPointQueries[m_testIndex].radius;
float distanceSquared = radius * radius;
m_closestPoint = point;
m_haveClosest = false;
b3DynamicTree_QueryClosest( &m_tree, point, B3_DEFAULT_MASK_BITS, false, ClosetPointCallback, this,
&distanceSquared );
}
// constexpr int n = m_isDebug ? 0 : 100;
// for ( int i = 0; i < n; ++i )
//{
// Profile();
// }
}
static Sample* Create( SampleContext* context )
{
return new TreeBenchmark( context );
}
static constexpr int m_fileCount = 3;
static constexpr int m_testCount = 1024;
static constexpr const char* m_saveFileName = "tree.dt";
const char* m_fileNames[m_fileCount];
FileConfig m_config[m_fileCount];
int m_fileIndex;
float* m_aabbMinX;
float* m_aabbMinY;
float* m_aabbMinZ;
float* m_aabbMaxX;
float* m_aabbMaxY;
float* m_aabbMaxZ;
std::unordered_map<uint64_t, Proxy> m_proxies;
std::vector<uint16_t> m_depths;
b3DynamicTree m_tree;
Ray m_rays[m_testCount];
b3AABB m_overlapQueries[m_testCount];
b3Sphere m_closestPointQueries[m_testCount];
b3Vec3 m_closestPoint;
float m_areaRatio;
float m_rayTime;
float m_overlapTime;
float m_closestTime;
float m_buildTime;
float m_drawDistance;
float m_loadScale;
int m_testIndex;
int m_timeStamp;
int m_drawLevel;
int m_height;
bool m_haveClosest;
bool m_doOverlap;
bool m_doClosest;
bool m_doRay;
};
static int sampleTree = SampleManager::Register( "Tree", "Benchmark", TreeBenchmark::Create );

2320
samples/scene.cpp Normal file

File diff suppressed because it is too large Load diff

147
samples/scene.h Normal file
View file

@ -0,0 +1,147 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "utility.h"
#include "box3d/math_functions.h"
struct Camera;
struct b3DebugShape;
struct Scene;
struct UniqueMesh;
enum struct DebugShapeType
{
capsule,
compound,
hull,
heightField,
mesh,
sphere,
};
struct DebugSphere
{
b3Vec3 center;
float radius;
};
struct DebugCapsule
{
b3Vec3 center1, center2;
float radius;
};
struct DebugHeightField
{
uint32_t id;
};
struct DebugHull
{
b3Transform transform;
uint32_t id;
};
struct DebugMesh
{
b3Transform transform;
b3Vec3 scale;
uint32_t id;
};
struct DebugCompound
{
DebugCapsule* capsules;
int capsuleCount;
DebugHull* hulls;
int hullCount;
DebugMesh* meshes;
int meshCount;
DebugSphere* spheres;
int sphereCount;
};
struct DebugShape
{
DebugShapeType type;
b3BodyType bodyType;
union
{
DebugCapsule capsule;
DebugCompound compound;
DebugHeightField heightField;
DebugHull hull;
DebugMesh mesh;
DebugSphere sphere;
};
};
Scene* CreateScene( const Camera* camera, Arena arena );
void DestroyScene( Scene* scene );
// Register a hull and get an id to render it later
uint32_t CreateInstanceHull( Scene* scene, const b3Hull* hull, Arena arena );
// Register a mesh and get an id to render it later
uint32_t CreateInstanceMesh( Scene* scene, const b3MeshData* meshData, Arena arena );
// Register a height field and get an id to render it later
uint32_t CreateInstanceHeightField( Scene* scene, const b3HeightField* heightField, Arena arena );
// This should be called when a sample is destroyed to avoid leaking instances
void DestroySharedMeshes( Scene* scene );
void ResizeScene( Scene* scene, const Camera* camera );
// UniqueMesh CreateUniqueMesh( const b3Vec3* vertexPositions, const b3Vec3* vertexNormals, int triangleCount,
// const int* triangleIndices, const Edge* edges, int edgeCount, const int* materials,
// Arena arena );
// void DestroyUniqueMesh( UniqueMesh* shape );
void DrawDebugShape( Scene* scene, DebugShape* debugShape, b3Transform transform, b3HexColor color, float alpha );
void DrawScene( Scene* scene, Camera* camera );
void DrawCube( Scene* scene, b3Transform transform, b3HexColor color, const Matrix4& view, const Matrix4& projection );
void DrawDebugCube( Scene* scene, b3Transform transform, b3HexColor color );
struct SceneAOSettings
{
float radius;
float bias;
float minScale;
float power;
float direct;
bool aoOnly;
};
// Mutable view of the scene's SSAO parameters. Pointer is valid for the lifetime of the scene.
SceneAOSettings* GetAOSettings( Scene* scene );
void EnableShadows( Scene* scene, bool useShadows );
bool AreShadowsEnabled( Scene* scene );
void EnableSSAO( Scene* scene, bool enable );
bool IsSSAOEnabled( Scene* scene );
// World-space ground grid drawn on near-horizontal upward faces. Useful on
// flat-box ground; should be disabled for samples whose ground is a mesh
// (the mesh's triangle wireframe already provides the grid signal).
void EnableGrid( Scene* scene, bool enable );
bool IsGridEnabled( Scene* scene );
void DrawPoint( Scene* scene, b3Vec3 point, float size, b3HexColor color );
void DrawLine( Scene* scene, b3Vec3 point1, b3Vec3 point2, b3HexColor color );
void DrawPlane( Scene* scene, b3Vec3 normal, b3Vec3 point, b3HexColor color );
void DrawArrow( Scene* scene, b3Vec3 point1, b3Vec3 point2, float size, b3HexColor color );
void DrawBounds( Scene* scene, b3AABB bounds, float extension, b3HexColor color );
void DrawBox( Scene* scene, b3Vec3 extents, b3Transform transform, b3HexColor color );
void DrawFace( Scene* scene, b3Vec3 vertex1, b3Vec3 vertex2, b3Vec3 vertex3, b3HexColor color );

465
samples/shader.cpp Normal file
View file

@ -0,0 +1,465 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#if defined( _MSC_VER ) && !defined( _CRT_SECURE_NO_WARNINGS )
#define _CRT_SECURE_NO_WARNINGS
#endif
#include "shader.h"
#include <assert.h>
#include <glad/glad.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <string>
void CheckOpenGL()
{
GLenum errCode = glGetError();
if ( errCode != GL_NO_ERROR )
{
fprintf( stderr, "OpenGL error = %d\n", errCode );
assert( false );
}
}
void DumpGLInfo( bool dumpExtensions )
{
const GLubyte* renderer = glGetString( GL_RENDERER );
const GLubyte* vendor = glGetString( GL_VENDOR );
const GLubyte* version = glGetString( GL_VERSION );
const GLubyte* glslVersion = glGetString( GL_SHADING_LANGUAGE_VERSION );
int major, minor;
glGetIntegerv( GL_MAJOR_VERSION, &major );
glGetIntegerv( GL_MINOR_VERSION, &minor );
printf( "-------------------------------------------------------------\n" );
printf( "GL Vendor : %s\n", vendor );
printf( "GL Renderer : %s\n", renderer );
printf( "GL Version : %s\n", version );
printf( "GL Version : %d.%d\n", major, minor );
printf( "GLSL Version : %s\n", glslVersion );
printf( "-------------------------------------------------------------\n" );
if ( dumpExtensions )
{
int nExtensions;
glGetIntegerv( GL_NUM_EXTENSIONS, &nExtensions );
for ( int i = 0; i < nExtensions; i++ )
{
printf( "%s\n", glGetStringi( GL_EXTENSIONS, i ) );
}
}
}
static void PrintLog( uint32_t object )
{
int length = 0;
if ( glIsShader( object ) )
{
glGetShaderiv( object, GL_INFO_LOG_LENGTH, &length );
}
else if ( glIsProgram( object ) )
{
glGetProgramiv( object, GL_INFO_LOG_LENGTH, &length );
}
else
{
fprintf( stderr, "printlog: Not a shader or a program\n" );
return;
}
char* log = static_cast<char*>( malloc( length * sizeof( char ) ) );
if ( glIsShader( object ) )
{
glGetShaderInfoLog( object, length, nullptr, log );
}
else if ( glIsProgram( object ) )
{
glGetProgramInfoLog( object, length, nullptr, log );
}
fprintf( stderr, "%s", log );
free( log );
}
static uint32_t CreateShaderFromString( const char* source, GLenum type )
{
uint32_t shader = glCreateShader( type );
const char* sources[] = { source };
glShaderSource( shader, 1, sources, nullptr );
glCompileShader( shader );
int success = GL_FALSE;
glGetShaderiv( shader, GL_COMPILE_STATUS, &success );
if ( success == GL_FALSE )
{
fprintf( stderr, "Error compiling shader of type %d!\n", type );
PrintLog( shader );
}
return shader;
}
static bool ReadFile( const char* filename, std::string& out )
{
FILE* file = fopen( filename, "rb" );
if ( file == nullptr )
{
return false;
}
fseek( file, 0, SEEK_END );
long size = ftell( file );
fseek( file, 0, SEEK_SET );
out.resize( (size_t)size );
if ( size > 0 )
{
fread( &out[0], 1, (size_t)size, file );
}
fclose( file );
return true;
}
static std::string DirectoryOf( const char* path )
{
const char* lastSep = nullptr;
for ( const char* p = path; *p; ++p )
{
if ( *p == '/' || *p == '\\' )
{
lastSep = p;
}
}
return lastSep ? std::string( path, lastSep + 1 ) : std::string();
}
// Substitutes lines of the form `#include "name"` with the contents of that
// file (resolved relative to `baseDir`). Recursive but not cyclic-safe — keep
// the include graph a DAG. Emits `#line` directives so compile errors keep
// readable line numbers in both the parent and the included file.
static bool ResolveIncludes( const std::string& source, const std::string& baseDir, std::string& out )
{
out.reserve( out.size() + source.size() * 2 );
int lineNo = 1;
size_t i = 0;
while ( i < source.size() )
{
size_t lineStart = i;
size_t lineEnd = source.find( '\n', i );
if ( lineEnd == std::string::npos )
{
lineEnd = source.size();
}
size_t t = lineStart;
while ( t < lineEnd && ( source[t] == ' ' || source[t] == '\t' ) )
{
t++;
}
bool isInclude = false;
std::string includeName;
if ( lineEnd >= t + 9 && source.compare( t, 8, "#include" ) == 0 &&
( source[t + 8] == ' ' || source[t + 8] == '\t' ) )
{
size_t q1 = source.find( '"', t + 8 );
size_t q2 = ( q1 != std::string::npos && q1 < lineEnd ) ? source.find( '"', q1 + 1 ) : std::string::npos;
if ( q1 != std::string::npos && q2 != std::string::npos && q2 < lineEnd )
{
isInclude = true;
includeName = source.substr( q1 + 1, q2 - q1 - 1 );
}
}
if ( isInclude )
{
std::string includePath = baseDir + includeName;
std::string includedRaw;
if ( !ReadFile( includePath.c_str(), includedRaw ) )
{
fprintf( stderr, "Cannot open include '%s'\n", includePath.c_str() );
return false;
}
char hdr[64];
snprintf( hdr, sizeof( hdr ), "#line 1\n" );
out += hdr;
if ( !ResolveIncludes( includedRaw, DirectoryOf( includePath.c_str() ), out ) )
{
return false;
}
if ( !out.empty() && out.back() != '\n' )
{
out += '\n';
}
snprintf( hdr, sizeof( hdr ), "#line %d\n", lineNo + 1 );
out += hdr;
}
else
{
out.append( source, lineStart, lineEnd - lineStart );
out += '\n';
}
i = ( lineEnd < source.size() ) ? lineEnd + 1 : lineEnd;
lineNo++;
}
return true;
}
static uint32_t CreateShaderFromFile( const char* filename, GLenum type )
{
std::string raw;
if ( !ReadFile( filename, raw ) )
{
fprintf( stderr, "Error opening %s\n", filename );
return 0;
}
std::string source;
if ( !ResolveIncludes( raw, DirectoryOf( filename ), source ) )
{
fprintf( stderr, "Error resolving includes in %s\n", filename );
return 0;
}
uint32_t shader = glCreateShader( type );
const char* sources[] = { source.c_str() };
glShaderSource( shader, 1, sources, nullptr );
glCompileShader( shader );
int success = GL_FALSE;
glGetShaderiv( shader, GL_COMPILE_STATUS, &success );
if ( success == GL_FALSE )
{
fprintf( stderr, "Error compiling shader of type %d in %s!\n", type, filename );
PrintLog( shader );
}
return shader;
}
uint32_t CreateProgramFromFiles( const char* vertexPath, const char* fragmentPath )
{
uint32_t vertex = CreateShaderFromFile( vertexPath, GL_VERTEX_SHADER );
if ( vertex == 0 )
{
return 0;
}
uint32_t fragment = CreateShaderFromFile( fragmentPath, GL_FRAGMENT_SHADER );
if ( fragment == 0 )
{
return 0;
}
uint32_t program = glCreateProgram();
glAttachShader( program, vertex );
glAttachShader( program, fragment );
glLinkProgram( program );
int success = GL_FALSE;
glGetProgramiv( program, GL_LINK_STATUS, &success );
if ( success == GL_FALSE )
{
fprintf( stderr, "glLinkProgram:" );
PrintLog( program );
return 0;
}
glDeleteShader( vertex );
glDeleteShader( fragment );
return program;
}
uint32_t CreateProgramFromStrings( const char* vs, const char* fs )
{
uint32_t vertex = CreateShaderFromString( vs, GL_VERTEX_SHADER );
if ( vertex == 0 )
{
return 0;
}
uint32_t fragment = CreateShaderFromString( fs, GL_FRAGMENT_SHADER );
if ( fragment == 0 )
{
return 0;
}
uint32_t programId = glCreateProgram();
glAttachShader( programId, vertex );
glAttachShader( programId, fragment );
glLinkProgram( programId );
int success = GL_FALSE;
glGetProgramiv( programId, GL_LINK_STATUS, &success );
if ( success == GL_FALSE )
{
fprintf( stderr, "glLinkProgram:" );
PrintLog( programId );
return 0;
}
glDeleteShader( vertex );
glDeleteShader( fragment );
return programId;
}
void DestroyShader( uint32_t programId )
{
glDeleteProgram( programId );
}
int GetUniformLocation( uint32_t programId, const char* name )
{
return glGetUniformLocation( programId, name );
}
void SetUniformBool( int location, bool value )
{
glUniform1i( location, (int)value );
}
void SetUniformInt( int location, int value )
{
glUniform1i( location, value );
}
void SetUniformFloat( int location, float value )
{
glUniform1f( location, value );
}
void SetUniformVec3( int location, b3Vec3 value )
{
glUniform3fv( location, 1, &value.x );
}
void SetUniformVec3( int location, float x, float y, float z )
{
glUniform3f( location, x, y, z );
}
void SetUniformVec4( int location, Vector4 value )
{
glUniform4fv( location, 1, &value.x );
}
void SetUniformColor( int location, RGBAf value )
{
glUniform4fv( location, 1, &value.r );
}
void SetUniformVec4( int location, float x, float y, float z, float w )
{
glUniform4f( location, x, y, z, w );
}
void SetUniformMatrix4( int location, const Matrix4& mat )
{
glUniformMatrix4fv( location, 1, GL_FALSE, &mat.cx.x );
}
void SetUniformBool( uint32_t programId, const char* name, bool value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform1i( location, (int)value );
}
else
{
location += 0;
}
}
void SetUniformInt( uint32_t programId, const char* name, int value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform1i( location, value );
}
}
void SetUniformFloat( uint32_t programId, const char* name, float value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform1f( location, value );
}
}
void SetUniformVec3( uint32_t programId, const char* name, b3Vec3 value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform3fv( location, 1, &value.x );
}
}
void SetUniformVec3( uint32_t programId, const char* name, float x, float y, float z )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform3f( location, x, y, z );
}
}
void SetUniformVec4( uint32_t programId, const char* name, Vector4 value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform4fv( location, 1, &value.x );
}
}
void SetUniformVec4( uint32_t programId, const char* name, float x, float y, float z, float w )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform4f( location, x, y, z, w );
}
}
void SetUniformColor( uint32_t programId, const char* name, RGBAf value )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniform4fv( location, 1, &value.r );
}
}
void SetUniformMatrix4( uint32_t programId, const char* name, const Matrix4& mat )
{
int location = glGetUniformLocation( programId, name );
if ( location != -1 )
{
glUniformMatrix4fv( location, 1, GL_FALSE, &mat.cx.x );
}
}

39
samples/shader.h Normal file
View file

@ -0,0 +1,39 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "utility.h"
#include "box3d/types.h"
uint32_t CreateProgramFromFiles( const char* vertexPath, const char* fragmentPath );
uint32_t CreateProgramFromStrings( const char* vs, const char* fs );
void DestroyShader( uint32_t programId );
// todo these are low value wrappers
int GetUniformLocation( uint32_t programId, const char* name );
void SetUniformBool( int location, bool value );
void SetUniformInt( int location, int value );
void SetUniformFloat( int location, float value );
void SetUniformVec3( int location, b3Vec3 value );
void SetUniformVec3( int location, float x, float y, float z );
void SetUniformVec4( int location, Vector4 value );
void SetUniformVec4( int location, float x, float y, float z, float w );
void SetUniformColor( int location, RGBAf value );
void SetUniformMatrix4( int location, const Matrix4& mat );
void SetUniformBool( uint32_t programId, const char* name, bool value );
void SetUniformInt( uint32_t programId, const char* name, int value );
void SetUniformFloat( uint32_t programId, const char* name, float value );
void SetUniformVec3( uint32_t programId, const char* name, b3Vec3 value );
void SetUniformVec3( uint32_t programId, const char* name, float x, float y, float z );
void SetUniformVec4( uint32_t programId, const char* name, Vector4 value );
void SetUniformVec4( uint32_t programId, const char* name, float x, float y, float z, float w );
void SetUniformColor( uint32_t programId, const char* name, RGBAf value );
void SetUniformMatrix4( uint32_t programId, const char* name, const Matrix4& mat );
void CheckOpenGL();
void DumpGLInfo( bool dumpExtensions );

163
samples/ssao_buffer.cpp Normal file
View file

@ -0,0 +1,163 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#include "ssao_buffer.h"
#include "box3d/math_functions.h"
#include "shader.h"
#include <glad/glad.h>
#include <stdlib.h>
#include <random>
#include <stdint.h>
#include <stdio.h>
#include "geo_buffer.h"
struct SsaoBuffer
{
int32_t width, height;
uint32_t frameBufferId;
uint32_t blurFrameBufferId;
uint32_t colorBufferId;
uint32_t blurColorBufferId;
b3Vec3 ssaoKernel[32];
uint32_t noiseTexture;
};
SsaoBuffer* CreateSsaoBuffer(int32_t width, int32_t height)
{
SsaoBuffer* buffer = (SsaoBuffer*)malloc(sizeof(SsaoBuffer));
buffer->width = width;
buffer->height = height;
// frame buffer
glGenFramebuffers(1, &buffer->frameBufferId);
glBindFramebuffer(GL_FRAMEBUFFER, buffer->frameBufferId);
// color buffer
glGenTextures(1, &buffer->colorBufferId);
glBindTexture(GL_TEXTURE_2D, buffer->colorBufferId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer->colorBufferId, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "SSAO Framebuffer not complete!\n");
free(buffer);
return nullptr;
}
// blur frame buffer
glGenFramebuffers(1, &buffer->blurFrameBufferId);
glBindFramebuffer(GL_FRAMEBUFFER, buffer->blurFrameBufferId);
// blur color buffer
glGenTextures(1, &buffer->blurColorBufferId);
glBindTexture(GL_TEXTURE_2D, buffer->blurColorBufferId);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RED, width, height, 0, GL_RED, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, buffer->blurColorBufferId, 0);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "SSAO Blur Framebuffer not complete!\n");
free(buffer);
return nullptr;
}
// unbind frame buffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// generate sample kernel
std::uniform_real_distribution<float> randomFloats(0.0f, 1.0f); // generates random floats between 0.0 and 1.0
std::default_random_engine generator;
for (uint32_t i = 0; i < 32; ++i)
{
b3Vec3 sample{randomFloats(generator) * 2.0f - 1.0f, randomFloats(generator) * 2.0f - 1.0f, randomFloats(generator)};
sample = b3Normalize(sample);
sample = randomFloats(generator) * sample;
float scale = float(i) / 32.0f;
// scale samples s.t. they're more aligned to center of kernel
scale = b3LerpFloat(0.1f, 1.0f, scale * scale);
sample = scale * sample;
buffer->ssaoKernel[i] = sample;
}
// random sample kernel tangent vectors stuffed into a texture
b3Vec3 ssaoNoise[16];
for (b3Vec3& noise : ssaoNoise)
{
// rotate around z-axis (in tangent space)
noise = {randomFloats(generator) * 2.0f - 1.0f, randomFloats(generator) * 2.0f - 1.0f, 0.0f};
}
glGenTextures(1, &buffer->noiseTexture);
glBindTexture(GL_TEXTURE_2D, buffer->noiseTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 4, 4, 0, GL_RGB, GL_FLOAT, &ssaoNoise[0]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
return buffer;
}
void BindSsaoBuffer(SsaoBuffer* buffer)
{
glBindFramebuffer(GL_FRAMEBUFFER, buffer->frameBufferId);
glClear(GL_COLOR_BUFFER_BIT);
}
void SetSsaoSamples(SsaoBuffer* buffer, uint32_t ssaoShader)
{
// Send kernel + rotation
for (uint32_t i = 0; i < 32; ++i)
{
char sampleName[32];
snprintf(sampleName, 32, "samples[%d]", i);
SetUniformVec3(ssaoShader, sampleName, buffer->ssaoKernel[i]);
}
}
void BindSsaoTextures(SsaoBuffer* buffer)
{
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, buffer->noiseTexture);
}
void BindSsaoBlurBuffer(SsaoBuffer* buffer)
{
glBindFramebuffer(GL_FRAMEBUFFER, buffer->blurFrameBufferId);
glClear(GL_COLOR_BUFFER_BIT);
}
void BindSsaoColorTexture(SsaoBuffer* buffer)
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, buffer->colorBufferId);
}
void BindSsaoBlurTexture(SsaoBuffer* buffer)
{
glActiveTexture(GL_TEXTURE3);
glBindTexture(GL_TEXTURE_2D, buffer->blurColorBufferId);
}
void DestroySsaoBuffer(SsaoBuffer* buffer)
{
glDeleteFramebuffers(1, &buffer->frameBufferId);
glDeleteFramebuffers(1, &buffer->blurFrameBufferId);
glDeleteTextures(1, &buffer->colorBufferId);
glDeleteTextures(1, &buffer->blurColorBufferId);
glDeleteTextures(1, &buffer->noiseTexture);
free(buffer);
}

21
samples/ssao_buffer.h Normal file
View file

@ -0,0 +1,21 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include <stdint.h>
struct SsaoBuffer;
struct GeoBuffer;
SsaoBuffer* CreateSsaoBuffer(int32_t width, int32_t height);
void BindSsaoBuffer(SsaoBuffer* buffer);
void SetSsaoSamples(SsaoBuffer* buffer, uint32_t ssaoShader);
void BindSsaoTextures(SsaoBuffer* buffer);
void BindSsaoBlurBuffer(SsaoBuffer* buffer);
void BindSsaoColorTexture(SsaoBuffer* buffer);
void BindSsaoBlurTexture(SsaoBuffer* buffer);
void DestroySsaoBuffer(SsaoBuffer* buffer);

1724
samples/stb_image_write.h Normal file

File diff suppressed because it is too large Load diff

5079
samples/stb_truetype.h Normal file

File diff suppressed because it is too large Load diff

3499
samples/tiny_obj_loader.h Normal file

File diff suppressed because it is too large Load diff

118
samples/utility.h Normal file
View file

@ -0,0 +1,118 @@
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT
#pragma once
#include "box3d/types.h"
struct Vector4
{
float x, y, z, w;
};
struct Matrix4
{
Vector4 cx, cy, cz, cw;
};
inline Matrix4 MakeMatrix4( const b3Transform& transform, b3Vec3 scale )
{
b3Matrix3 m3 = b3MakeMatrixFromQuat( transform.q );
Matrix4 m = {};
m.cx = { scale.x * m3.cx.x, scale.x * m3.cx.y, scale.x * m3.cx.z, 0.0f };
m.cy = { scale.y * m3.cy.x, scale.y * m3.cy.y, scale.y * m3.cy.z, 0.0f };
m.cz = { scale.z * m3.cz.x, scale.z * m3.cz.y, scale.z * m3.cz.z, 0.0f };
m.cw = { transform.p.x, transform.p.y, transform.p.z, 1.0f };
return m;
}
inline Matrix4 MakeMatrix4( const b3Transform& transform, float scale )
{
b3Matrix3 m3 = b3MakeMatrixFromQuat( transform.q );
Matrix4 m = {};
m.cx = { scale * m3.cx.x, scale * m3.cx.y, scale * m3.cx.z, 0.0f };
m.cy = { scale * m3.cy.x, scale * m3.cy.y, scale * m3.cy.z, 0.0f };
m.cz = { scale * m3.cz.x, scale * m3.cz.y, scale * m3.cz.z, 0.0f };
m.cw = { transform.p.x, transform.p.y, transform.p.z, 1.0f };
return m;
}
inline Vector4 MulMV( const Matrix4& m, Vector4 a )
{
Vector4 b;
b.x = m.cx.x * a.x + m.cy.x * a.y + m.cz.x * a.z + m.cw.x * a.w;
b.y = m.cx.y * a.x + m.cy.y * a.y + m.cz.y * a.z + m.cw.y * a.w;
b.z = m.cx.z * a.x + m.cy.z * a.y + m.cz.z * a.z + m.cw.z * a.w;
b.w = m.cx.w * a.x + m.cy.w * a.y + m.cz.w * a.z + m.cw.w * a.w;
return b;
}
inline Matrix4 MulMM( const Matrix4& a, const Matrix4& b )
{
Matrix4 c;
c.cx = MulMV( a, b.cx );
c.cy = MulMV( a, b.cy );
c.cz = MulMV( a, b.cz );
c.cw = MulMV( a, b.cw );
return c;
}
struct RGBA8
{
uint8_t r, g, b, a;
};
inline RGBA8 MakeRGBA8( b3HexColor h, float alpha )
{
RGBA8 color;
color.r = ( h >> 16 ) & 0xFF;
color.g = ( h >> 8 ) & 0xFF;
color.b = h & 0xFF;
color.a = uint8_t( 255.0f * alpha + 0.5f );
return color;
}
inline RGBA8 MakeRGBA8( b3HexColor h )
{
RGBA8 color;
color.r = ( h >> 16 ) & 0xFF;
color.g = ( h >> 8 ) & 0xFF;
color.b = h & 0xFF;
color.a = 0xFF;
return color;
}
struct RGBAf
{
float r, g, b, a;
};
inline RGBAf MakeRGBAf( b3HexColor h, float alpha )
{
RGBAf color;
color.r = ( ( h >> 16 ) & 0xFF ) / 255.0f;
color.g = ( ( h >> 8 ) & 0xFF ) / 255.0f;
color.b = ( h & 0xFF ) / 255.0f;
color.a = alpha;
return color;
}
inline RGBAf MakeRGBAf( b3HexColor h )
{
return MakeRGBAf( h, 1.0f );
}
Matrix4 MakeOrthographicMatrix( float left, float right, float bottom, float top, float near, float far );
struct Arena
{
void Create( int byteCount );
void Destroy();
void* Allocate( int byteCount );
void Clear();
char* data;
int capacity;
int index;
};

80
shaders/common.glsl Normal file
View file

@ -0,0 +1,80 @@
// Shared constants and helpers used across deferred and forward fragment shaders.
// Included via the loader's `#include "common.glsl"` directive (no `#version`
// here; the including shader provides it).
//
// All color constants are authored in sRGB (display) space and converted to
// linear at use. Intensities are linear-space scalars.
vec3 SrgbToLinear(vec3 c) { return pow(c, vec3(2.2)); }
vec3 LinearToSrgb(vec3 c) { return pow(c, vec3(1.0 / 2.2)); }
vec3 ACESFilm(vec3 x)
{
float a = 2.51, b = 0.03, c = 2.43, d = 0.59, e = 0.14;
return clamp((x * (a * x + b)) / (x * (c * x + d) + e), 0.0, 1.0);
}
const vec3 SUN_COLOR_SRGB = vec3(1.00, 0.97, 0.92);
const float SUN_INTENSITY = 0.5;
const vec3 SKY_AMBIENT_SRGB = vec3(0.55, 0.60, 0.68);
const vec3 GROUND_AMBIENT_SRGB = vec3(0.22, 0.20, 0.17);
const float AMBIENT_INTENSITY = 0.4;
const float SPEC_POWER = 32.0;
const float SPEC_SCALE = 0.20;
const vec3 SKY_ZENITH_SRGB = vec3(0.28, 0.48, 0.78);
const vec3 SKY_HORIZON_SRGB = vec3(0.55, 0.65, 0.78);
const vec3 SKY_GROUND_SRGB = vec3(0.28, 0.25, 0.22);
const vec3 SUN_DISK_SRGB = vec3(1.00, 0.97, 0.85);
const float SUN_DISK_BRIGHT = 8.0;
const vec3 SUN_HALO_SRGB = vec3(1.00, 0.92, 0.78);
const float SUN_HALO_BRIGHT = 0.35;
const float FOG_DENSITY = 0.002;
vec3 SkyColor(vec3 rayDir, vec3 sunDir)
{
float t = clamp(rayDir.y, -1.0, 1.0);
vec3 skySrgb = (t >= 0.0)
? mix(SKY_HORIZON_SRGB, SKY_ZENITH_SRGB, pow(t, 1.2))
: mix(SKY_HORIZON_SRGB, SKY_GROUND_SRGB, pow(-t, 0.50));
vec3 sky = SrgbToLinear(skySrgb);
float sunCos = max(dot(rayDir, sunDir), 0.0);
sky += SrgbToLinear(SUN_DISK_SRGB) * SUN_DISK_BRIGHT * pow(sunCos, 800.0);
sky += SrgbToLinear(SUN_HALO_SRGB) * SUN_HALO_BRIGHT * pow(sunCos, 8.0);
return sky;
}
// Hemispheric ambient term for a +Y-up world. N is world-space normal.
vec3 HemisphericAmbient(vec3 N)
{
float hemi = 0.5 + 0.5 * N.y;
return AMBIENT_INTENSITY * mix(SrgbToLinear(GROUND_AMBIENT_SRGB),
SrgbToLinear(SKY_AMBIENT_SRGB), hemi);
}
// TPDF (triangular) dither for 8-bit sRGB output. Two independent IGN samples
// give noise in [-1, +1] LSB; converting smooth gradients (sky, fog) from
// hard contour bands into high-frequency texture the eye averages out. Apply
// AFTER LinearToSrgb so quantization happens in display space.
vec3 DitherSrgb(vec3 c, vec2 fragCoord)
{
const vec2 magic = vec2(0.06711056, 0.00583715);
const float k = 52.9829189;
float r1 = fract(k * fract(dot(fragCoord, magic)));
float r2 = fract(k * fract(dot(fragCoord + 7.0, magic)));
float t = r1 + r2 - 1.0;
return c + vec3(t) * (1.0 / 255.0);
}
// Anti-aliased 1-pixel-wide world-space grid. uv is the tiled coordinate
// (e.g. worldXZ divided by the desired cell size). Returns ~1.0 on a line,
// ~0.0 in the cell interior; fwidth filtering keeps the line crisp at any
// distance and prevents the grid from aliasing on far receivers.
float WorldGrid(vec2 uv)
{
vec2 grid = abs(fract(uv - 0.5) - 0.5);
vec2 line = grid / fwidth(uv);
return 1.0 - smoothstep(0.0, 1.5, min(line.x, line.y));
}

View file

@ -0,0 +1,253 @@
#version 330 core
#include "common.glsl"
out vec4 outColor;
in vec2 TexCoords;
uniform sampler2D gPosition; // view-space position (xyz=0 for sky)
uniform sampler2D gNormal; // view-space normal
uniform sampler2D gAlbedoSpec; // sRGB albedo, a specular strength
uniform sampler2D ssao;
uniform sampler2DShadow shadowMap;
uniform mat4 lightSpaceMatrix;
uniform mat4 cameraMatrix; // camera-to-world
uniform float worldTexelSize; // world-space span of one shadow-map texel
uniform float lightZRange; // lightFarPlane - lightNearPlane, in world units
// Sun + sky
uniform vec3 sunDirWorld; // normalized, points from scene toward sun
uniform float tanHalfFovY;
uniform float aspectRatio;
uniform bool useSSAO;
uniform bool useShadow;
uniform bool useGrid;
uniform float aoPower;
uniform float aoDirect;
uniform bool aoOnly;
// Vogel disk (phyllotaxis spiral) sampling. Produces naturally well-distributed
// taps for any sample count, and the rotation phase is just an additive angle
// per tap — no rotation matrix needed.
const float GOLDEN_ANGLE = 2.39996323;
const int PCF_TAP_COUNT = 32;
const float PCF_RADIUS_TEXELS = 3.0;
float ShadowCalculation(vec4 lightSpacePos, vec3 worldNormal, vec3 worldPos)
{
vec3 projCoords = lightSpacePos.xyz / lightSpacePos.w;
projCoords = projCoords * 0.5 + 0.5;
// dFdx/dFdy must run before any early return so neighboring fragments in the
// 2x2 quad always reach this point with valid projCoords values.
vec3 ddxCoords = dFdx(projCoords);
vec3 ddyCoords = dFdy(projCoords);
if (projCoords.z > 1.0 || projCoords.z < 0.0) return 0.0;
// Soft-fade near the shadow map boundary so geometry just outside the fitted
// frustum doesn't produce a hard cutoff line. Falls off over the outer 6%
// of the xy range and outer 10% of the depth range.
vec2 edge = min(projCoords.xy, 1.0 - projCoords.xy);
float xyFade = smoothstep(0.0, 0.06, min(edge.x, edge.y));
float zFade = 1.0 - smoothstep(0.90, 1.0, projCoords.z);
float fade = xyFade * zFade;
if (fade <= 0.0) return 0.0;
// Receiver-plane depth bias: convert the screen-space gradient of projCoords.z
// into a gradient with respect to shadow-map UV via the inverse Jacobian.
// Each PCF tap then gets the depth the receiver surface would *actually* have
// at that tap's offset, so per-texel acne disappears without lifting shadows
// off contact via a large constant bias.
//
// Silhouette guard: at object edges, dFdx/dFdy mix samples from two unrelated
// surfaces, producing a meaningless gradient that would over-bias the test
// and paint a bright fringe along the silhouette. fwidth flags that case and
// we fall back to a constant bias for those fragments.
vec2 dzduv = vec2(0.0);
// True silhouettes (adjacent pixels on different surfaces) have huge zWidth,
// close to 1.0. Continuous surfaces even at grazing angles stay well below.
float zWidth = abs(ddxCoords.z) + abs(ddyCoords.z);
bool onSilhouette = zWidth > 0.3;
if (!onSilhouette)
{
float det = ddxCoords.x * ddyCoords.y - ddxCoords.y * ddyCoords.x;
if (abs(det) > 1e-8)
{
float invDet = 1.0 / det;
dzduv.x = (ddyCoords.y * ddxCoords.z - ddxCoords.y * ddyCoords.z) * invDet;
dzduv.y = (ddxCoords.x * ddyCoords.z - ddyCoords.x * ddxCoords.z) * invDet;
}
// Clamp loose enough to cover legitimate steep slopes (e.g. surfaces
// nearly aligned with the light direction) but still finite.
dzduv = clamp(dzduv, vec2(-2.0), vec2(2.0));
}
vec2 texelSize = 1.0 / textureSize(shadowMap, 0);
// Adapt PCF kernel radius to the screen pixel's footprint in shadow texels.
// At far view distances each screen pixel covers many shadow texels; a
// fixed 3-texel disk fits *inside* a single pixel, so adjacent pixels see
// nearly the same texel set just rotated differently — that resonates with
// the texel grid into the swirly moire visible on distant flat receivers.
// Growing the kernel with the footprint makes the taps actually average
// over the pixel's shadow-texel coverage, and as a bonus distant shadows
// get the gentle softening they should naturally have. Clamped so very
// distant geometry doesn't blow the kernel up to a useless smear.
float footprintTexels = max(length(ddxCoords.xy), length(ddyCoords.xy)) / texelSize.x;
float radiusTexels = clamp(footprintTexels, PCF_RADIUS_TEXELS, 8.0);
vec2 sampleScale = radiusTexels * texelSize;
// Hardware bilinear PCF samples a 2x2 texel neighborhood against a single
// refZ, but the four stored depths differ by up to dzduv * 0.5 * texelSize.
// Without absorbing that, half the bilinear neighbors pass and half fail,
// producing the residual banding RPDB alone can't kill. Scaling the bias
// with the receiver slope keeps adjacent texels on the same side of the
// comparison.
float slopeBias = (abs(dzduv.x) + abs(dzduv.y)) * texelSize.x;
// World-unit bias floor: the existing constants are in normalized [0,1]
// light-space depth, but the geometric scale that actually causes acne
// (stacked-brick seams, hull-on-hull contacts) is in world units. A
// 1-world-unit caster spans `1.0 / lightZRange` of normalized depth, so
// any bias smaller than that lets self-shadow bands appear at every
// brick interface. Floor it at ~half a world unit so the bias adapts
// automatically to camera distance (which controls lightZRange).
float minBias = 0.5 / max(lightZRange, 1.0);
float bias = max(minBias, onSilhouette ? 0.003 : (slopeBias + 0.0005));
// Per-pixel rotation phase. At extreme grazing angles each screen pixel
// covers many shadow texels and rotation makes adjacent pixels sample
// wildly different texel subsets — that resonates with the texel grid into
// visible moire. Fade rotation out as the receiver becomes foreshortened.
//
// Use Interleaved Gradient Noise (Jimenez 2014) for the angle. The basic
// fract(sin(dot(...))*43758.5453) hash has low-frequency structure that
// shows through as concentric/swirl moire when each screen pixel covers
// many shadow texels (distant view of a flat receiver). IGN was designed
// for shader dithering and decorrelates much better at neighboring pixels.
float rotStrength = 1.0 - smoothstep(0.05, 0.20, zWidth);
float ign = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
float phi = ign * 6.2831853 * rotStrength;
// Vogel-disk PCF: each tap is one rotation step further around the golden-
// angle spiral, with radius growing as sqrt(i/N) so density is uniform
// across the disk. sampler2DShadow + GL_LEQUAL returns 1.0 when refZ <=
// storedDepth (lit), with hardware bilinear PCF inside each tap thanks to
// GL_LINEAR filtering on the depth texture.
float lit = 0.0;
float invN = 1.0 / float(PCF_TAP_COUNT);
for (int i = 0; i < PCF_TAP_COUNT; ++i)
{
float r = sqrt((float(i) + 0.5) * invN);
float theta = float(i) * GOLDEN_ANGLE + phi;
vec2 offset = vec2(cos(theta), sin(theta)) * r * sampleScale;
float refZ = projCoords.z + dot(dzduv, offset) - bias;
lit += texture(shadowMap, vec3(projCoords.xy + offset, refZ));
}
return (1.0 - lit * invN) * fade;
}
void main()
{
vec2 ndc = TexCoords * 2.0 - 1.0;
vec3 camRight = cameraMatrix[0].xyz;
vec3 camUp = cameraMatrix[1].xyz;
vec3 camForward = -cameraMatrix[2].xyz;
vec3 viewDirWorld = normalize(
camForward
+ ndc.x * tanHalfFovY * aspectRatio * camRight
+ ndc.y * tanHalfFovY * camUp
);
vec3 viewPos = texture(gPosition, TexCoords).rgb;
vec3 viewNormal = texture(gNormal, TexCoords).rgb;
vec3 albedoSrgb = texture(gAlbedoSpec, TexCoords).rgb;
float specStrength = texture(gAlbedoSpec, TexCoords).a;
float ao = useSSAO ? texture(ssao, TexCoords).r : 1.0;
if (viewPos.z == 0.0)
{
// AO-only debug still shows sky as sky so the geometry framing reads.
vec3 sky = LinearToSrgb(ACESFilm(SkyColor(viewDirWorld, sunDirWorld)));
outColor = vec4(DitherSrgb(sky, gl_FragCoord.xy), 1.0);
return;
}
if (aoOnly)
{
// Bypass tonemap so AO of 1.0 reads as pure white.
outColor = vec4(vec3(ao), 1.0);
return;
}
vec3 baseColor = SrgbToLinear(albedoSrgb);
vec3 worldPos = (cameraMatrix * vec4(viewPos, 1.0)).xyz;
vec3 worldNormal = normalize(mat3(cameraMatrix) * viewNormal);
// World-space grid on near-horizontal upward faces. Two tiers so distance
// reads at any zoom: minor lines every 1 unit, major every 5. fwidth keeps
// each line ~1 pixel wide regardless of camera distance, which both
// avoids aliasing and produces a natural "fade with distance" since lines
// sub-pixel-merge into the surface tint as they recede. The orientation
// gate lets the same grid apply to stacked-cube tops without leaking onto
// walls or sloped faces. Disabled per-sample on mesh-collision grounds
// where the wireframe overlay already provides the same signal.
if (useGrid && abs(worldPos.y) < 0.5)
{
float groundFactor = smoothstep(0.95, 0.99, worldNormal.y);
if (groundFactor > 0.0)
{
float minor = WorldGrid(worldPos.xz);
float major = WorldGrid(worldPos.xz * 0.2);
float gridDarken = (1.0 - 0.15 * minor) * (1.0 - 0.40 * major);
baseColor *= mix(1.0, gridDarken, groundFactor);
}
}
float aoFactor = pow(ao, aoPower);
vec3 ambient = HemisphericAmbient(worldNormal) * aoFactor;
vec3 sunColor = SrgbToLinear(SUN_COLOR_SRGB) * SUN_INTENSITY;
float NdotL = max(dot(worldNormal, sunDirWorld), 0.0);
vec3 diffuse = NdotL * sunColor;
vec3 viewDirToCam = -viewDirWorld;
vec3 halfDir = normalize(sunDirWorld + viewDirToCam);
float spec = pow(max(dot(worldNormal, halfDir), 0.0), SPEC_POWER);
vec3 specular = spec * specStrength * SPEC_SCALE * sunColor;
float shadow = 0.0;
if (useShadow)
{
// Normal-offset bias: push the receiver point along the world normal
// before projecting to light space. RPDB inside ShadowCalculation
// handles per-tap bias well on flat receivers, but its Jacobian breaks
// down at grazing angles where dzduv saturates the ±2 clamp. Offsetting
// along N concentrates extra bias exactly on faces near-perpendicular
// to the light (NdotL near 0), killing the residual acne RPDB misses.
vec3 biasedWorldPos = worldPos + worldNormal * worldTexelSize * 1.5 * (1.0 - NdotL);
vec4 lightSpacePos = lightSpaceMatrix * vec4(biasedWorldPos, 1.0);
shadow = ShadowCalculation(lightSpacePos, worldNormal, worldPos);
}
// todo for disabling shadows
// shadow = 0.0f;
// Physically AO should only modulate indirect light, but direct sun overwhelms ambient on
// sunlit surfaces and the contact darkening disappears. aoDirect dials in a controllable
// amount of AO on the direct term — a fudge, but the only way to get visible contact AO
// on a brightly lit floor without a separate contact-shadow pass.
float directAO = mix(1.0, aoFactor, aoDirect);
vec3 color = baseColor * (ambient + (1.0 - shadow) * (diffuse + specular) * directAO);
float dist = length(viewPos);
float fog = 1.0 - exp(-FOG_DENSITY * dist);
color = mix(color, SkyColor(viewDirWorld, sunDirWorld), fog);
outColor = vec4(DitherSrgb(LinearToSrgb(ACESFilm(color)), gl_FragCoord.xy), 1.0);
}

View file

@ -0,0 +1,10 @@
#version 330 core
in vec2 TexCoords;
uniform sampler2D depthTexture;
void main()
{
gl_FragDepth = texture(depthTexture, TexCoords).r;
}

5
shaders/empty.fs Normal file
View file

@ -0,0 +1,5 @@
#version 330 core
void main()
{
}

10
shaders/forward.fs Normal file
View file

@ -0,0 +1,10 @@
#version 330 core
layout (location = 0) out vec4 fragmentColor;
in vec3 overrideColor;
void main()
{
fragmentColor = vec4(overrideColor, 1.0);
}

17
shaders/forward.vs Normal file
View file

@ -0,0 +1,17 @@
#version 330 core
layout (location = 0) in vec3 v_position;
layout (location = 1) in int v_flags;
uniform mat4 projection;
uniform mat4 view;
uniform mat4 model;
uniform vec3 color;
out vec3 overrideColor;
void main()
{
overrideColor = v_flags != 0 ? vec3(0.9, 0.9, 0.9) : color;
gl_Position = projection * view * model * vec4(v_position, 1.0);
}

Some files were not shown because too many files have changed in this diff Show more