box3d/samples/sample.cpp
2026-11-16 20:51:34 -08:00

2456 lines
74 KiB
C++

// 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 "sample.h"
#include "benchmarks.h"
#include "gfx/debug_adapter.h"
#include "gfx/draw.h"
#include "gfx/gtao.h"
#include "gfx/keycodes.h"
#include "gfx/renderer.h"
#include "gfx/shadow.h"
#include "gfx/text.h"
#include "host/gui.h"
#include "human.h"
#include "imgui.h"
#include "implot.h"
#include "jsmn.h"
#include "sokol_app.h"
#include "utils.h"
#include "box3d/box3d.h"
#include <ctype.h>
#include <filesystem>
#include <nfd.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define INFO_PANEL_WIDTH 20.0f
// Load a file. You must free the character array.
static char* ReadFile( int& size, const char* filename )
{
FILE* file = fopen( filename, "rb" );
if ( file == nullptr )
{
return nullptr;
}
fseek( file, 0, SEEK_END );
long length = ftell( file );
fseek( file, 0, SEEK_SET );
if ( length <= 0 )
{
fclose( file );
return nullptr;
}
size = static_cast<int>( length );
char* data = (char*)malloc( size + 1 );
if ( data == nullptr )
{
fclose( file );
return nullptr;
}
// Short read means a truncated or racing file, so treat it as no file at all
size_t read = fread( data, 1, size, file );
fclose( file );
if ( read != (size_t)size )
{
free( data );
return nullptr;
}
data[size] = 0;
return data;
}
static const char* settingsFileName = "settings.ini";
// Polled key state, fed from the host event loop (see main.cpp). Indexed by
// sokol keycode; samples read it through the KEY_* aliases in gfx/keycodes.h.
static bool s_keyDown[512];
bool IsKeyDown( int key )
{
return (unsigned)key < 512u ? s_keyDown[key] : false;
}
void SetKeyDown( int key, bool down )
{
if ( (unsigned)key < 512u )
{
s_keyDown[key] = down;
}
}
void ClearKeysDown()
{
memset( s_keyDown, 0, sizeof( s_keyDown ) );
}
void SampleContext::Save()
{
const b3DebugDraw* gd = GetGuiDraw();
int gtaoQuality = GetGtaoTraceParams().quality;
FILE* file = fopen( settingsFileName, "w" );
if ( file == nullptr )
{
return;
}
fprintf( file, "{\n" );
fprintf( file, " \"sampleIndex\": %d,\n", sampleIndex );
fprintf( file, " \"drawShapes\": %s,\n", gd->drawShapes ? "true" : "false" );
fprintf( file, " \"enableShadows\": %s,\n", enableShadows ? "true" : "false" );
fprintf( file, " \"enableGtao\": %s,\n", enableGtao ? "true" : "false" );
fprintf( file, " \"gtaoQuality\": %d,\n", gtaoQuality );
fprintf( file, " \"enableIbl\": %s,\n", GetIblEnabled() ? "true" : "false" );
fprintf( file, " \"exposure\": %g,\n", GetExposure() );
fprintf( file, " \"sunStrength\": %g,\n", GetSun().strength );
fprintf( file, " \"shadowSplitLambda\": %g,\n", GetShadowSplitLambda() );
fprintf( file, " \"debugView\": %d,\n", debugView );
fprintf( file, " \"drawDistance\": %g,\n", drawDistance );
fprintf( file, " \"showHullEdges\": %s,\n", GetEdgeOverlayParams().showHulls ? "true" : "false" );
fprintf( file, " \"showEdgeConvexity\": %s,\n", GetEdgeOverlayParams().showEdgeConvexity ? "true" : "false" );
fprintf( file, " \"edgeAlpha\": %g,\n", GetEdgeOverlayParams().alphaScale );
fprintf( file, " \"showMetrics\": %s,\n", showMetrics ? "true" : "false" );
fprintf( file, " \"showProfile\": %s,\n", showProfile ? "true" : "false" );
fprintf( file, " \"replayKeyframeBudgetMB\": %d,\n", replayKeyframeBudgetMB );
fprintf( file, " \"replayKeyframeMinInterval\": %d\n", replayKeyframeMinInterval );
fprintf( file, "}\n" );
fclose( file );
}
#define MAX_TOKENS 64
static int jsoneq( const char* json, jsmntok_t* tok, const char* s )
{
if ( tok->type == JSMN_STRING && (int)strlen( s ) == tok->end - tok->start &&
strncmp( json + tok->start, s, tok->end - tok->start ) == 0 )
{
return 0;
}
return -1;
}
// Tokens are not terminated, so copy before handing one to strtof or strtol.
// The settings file is hand editable, so truncate a long token rather than
// trusting it to fit.
static void CopyToken( char* buffer, int capacity, const char* json, const jsmntok_t& tok )
{
int count = tok.end - tok.start;
if ( count > capacity - 1 )
{
count = capacity - 1;
}
memcpy( buffer, json + tok.start, count );
buffer[count] = 0;
}
static float ParseFloat( const char* json, const jsmntok_t& tok )
{
char buffer[32];
CopyToken( buffer, (int)sizeof( buffer ), json, tok );
return strtof( buffer, nullptr );
}
static int ParseInt( const char* json, const jsmntok_t& tok )
{
char buffer[32];
CopyToken( buffer, (int)sizeof( buffer ), json, tok );
return (int)strtol( buffer, nullptr, 10 );
}
void SampleContext::Load()
{
recycleDistance = B3_CONTACT_RECYCLE_DISTANCE;
int size = 0;
char* data = ReadFile( size, settingsFileName );
if ( data == nullptr )
{
return;
}
// Settings file exists, so it is not a new user.
newUser = false;
jsmn_parser parser;
jsmntok_t tokens[MAX_TOKENS];
jsmn_init( &parser );
int tokenCount = jsmn_parse( &parser, data, size, tokens, MAX_TOKENS );
for ( int i = 0; i < tokenCount; ++i )
{
if ( jsoneq( data, &tokens[i], "sampleIndex" ) == 0 )
{
sampleIndex = ParseInt( data, tokens[i + 1] );
if ( sampleIndex < 0 )
{
sampleIndex = 0;
}
else if ( sampleIndex >= g_sampleCount )
{
sampleIndex = g_sampleCount - 1;
}
}
else if ( jsoneq( data, &tokens[i], "drawShapes" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
GetGuiDraw()->drawShapes = strncmp( s, "true", 4 ) == 0;
}
else if ( jsoneq( data, &tokens[i], "enableShadows" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
enableShadows = strncmp( s, "true", 4 ) == 0;
}
else if ( jsoneq( data, &tokens[i], "enableGtao" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
enableGtao = strncmp( s, "true", 4 ) == 0;
}
else if ( jsoneq( data, &tokens[i], "gtaoQuality" ) == 0 )
{
int quality = b3ClampInt( ParseInt( data, tokens[i + 1] ), 0, 2 );
GtaoTraceParams p = GetGtaoTraceParams();
p.quality = (AmbientOcclusionQuality)quality;
SetGtaoTraceParams( p );
}
else if ( jsoneq( data, &tokens[i], "enableIbl" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
SetIblEnabled( strncmp( s, "true", 4 ) == 0 );
}
else if ( jsoneq( data, &tokens[i], "exposure" ) == 0 )
{
SetExposure( ParseFloat( data, tokens[i + 1] ) );
}
else if ( jsoneq( data, &tokens[i], "sunStrength" ) == 0 )
{
Sun sun = GetSun();
sun.strength = ParseFloat( data, tokens[i + 1] );
SetSun( sun );
}
else if ( jsoneq( data, &tokens[i], "shadowSplitLambda" ) == 0 )
{
SetShadowSplitLambda( ParseFloat( data, tokens[i + 1] ) );
}
else if ( jsoneq( data, &tokens[i], "debugView" ) == 0 )
{
debugView = b3ClampInt( ParseInt( data, tokens[i + 1] ), 0, 4 );
}
else if ( jsoneq( data, &tokens[i], "drawDistance" ) == 0 )
{
drawDistance = b3ClampFloat( ParseFloat( data, tokens[i + 1] ), 1.0f, Camera::kViewDistance );
}
else if ( jsoneq( data, &tokens[i], "showHullEdges" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
EdgeOverlayParams p = GetEdgeOverlayParams();
p.showHulls = strncmp( s, "true", 4 ) == 0;
SetEdgeOverlayParams( &p );
}
else if ( jsoneq( data, &tokens[i], "showEdgeConvexity" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
EdgeOverlayParams p = GetEdgeOverlayParams();
p.showEdgeConvexity = strncmp( s, "true", 4 ) == 0;
SetEdgeOverlayParams( &p );
}
else if ( jsoneq( data, &tokens[i], "edgeAlpha" ) == 0 )
{
EdgeOverlayParams p = GetEdgeOverlayParams();
p.alphaScale = b3ClampFloat( ParseFloat( data, tokens[i + 1] ), 0.0f, 4.0f );
SetEdgeOverlayParams( &p );
}
else if ( jsoneq( data, &tokens[i], "showMetrics" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
showMetrics = strncmp( s, "true", 4 ) == 0;
}
else if ( jsoneq( data, &tokens[i], "showProfile" ) == 0 )
{
const char* s = data + tokens[i + 1].start;
showProfile = strncmp( s, "true", 4 ) == 0;
}
else if ( jsoneq( data, &tokens[i], "replayKeyframeBudgetMB" ) == 0 )
{
replayKeyframeBudgetMB = b3ClampInt( ParseInt( data, tokens[i + 1] ), 64, 4096 );
}
else if ( jsoneq( data, &tokens[i], "replayKeyframeMinInterval" ) == 0 )
{
replayKeyframeMinInterval = b3ClampInt( ParseInt( data, tokens[i + 1] ), 1, 1024 );
}
}
free( data );
}
Sample::Sample( SampleContext* context )
{
m_context = context;
m_camera = &m_context->camera;
if ( m_camera->m_thirdPerson )
{
sapp_lock_mouse( false );
m_camera->m_thirdPerson = false;
}
m_worldId = b3_nullWorldId;
m_recording = nullptr;
m_recordStartStep = 0;
m_mouseBodyId = {};
m_mouseJointId = {};
m_mouseFraction = 0.0f;
m_mouseForceScale = 100.0f;
m_textX = 5;
m_textLine = 0;
m_textIncrement = 22;
m_stepCount = 0;
m_userMaterialId = 0;
memset( m_profiles, 0, sizeof( m_profiles ) );
m_currentProfileIndex = 0;
m_profileReadIndex = 0;
m_profileWriteIndex = 0;
m_stepWhilePaused = true;
m_didStep = false;
m_haveMouseLast = false;
m_mouseLast = { 0.0f, 0.0f };
m_mouseDelta = { 0.0f, 0.0f };
m_launchSpeedScale = 5.0f;
m_shadowSplitNear = 0.0f;
m_shadowSplitFar = 0.0f;
g_randomSeed = RAND_SEED;
b3Capacity capacity = {};
CreateWorld( &capacity );
}
Sample::~Sample()
{
ResetAdapterPool();
ResetGroundShapeId();
if ( B3_IS_NON_NULL( m_worldId ) )
{
FinishRecording();
b3DestroyWorld( m_worldId );
}
}
void Sample::StartRecording()
{
if ( m_recording != nullptr )
{
return;
}
// Snapshot the live world as the seed, so recording can begin at any step boundary.
m_recording = b3CreateRecording( 0 );
b3World_StartRecording( m_worldId, m_recording );
m_recordStartStep = m_stepCount;
}
void Sample::FinishRecording()
{
if ( m_recording == nullptr )
{
return;
}
b3World_StopRecording( m_worldId );
// The buffer is freed either way, so a failed write has to be said out loud
if ( b3SaveRecordingToFile( m_recording, m_context->recordingFile ) )
{
snprintf( m_context->savedRecordingFile, sizeof( m_context->savedRecordingFile ), "%s", m_context->recordingFile );
}
else
{
fprintf( stderr, "Failed to write recording '%s'\n", m_context->recordingFile );
}
b3DestroyRecording( m_recording );
m_recording = nullptr;
}
void Sample::CreateWorld( b3Capacity* capacity )
{
if ( B3_IS_NON_NULL( m_worldId ) )
{
FinishRecording();
b3DestroyWorld( m_worldId );
}
m_mouseBodyId = {};
m_mouseJointId = {};
m_mousePoint = {};
b3WorldDef worldDef = b3DefaultWorldDef();
worldDef.workerCount = m_context->workerCount;
worldDef.enableSleep = m_context->enableSleep;
AttachToWorldDef( &worldDef );
if ( capacity != nullptr )
{
worldDef.capacity = *capacity;
}
m_worldId = b3CreateWorld( &worldDef );
b3World_SetContactRecycleDistance( m_worldId, m_context->recycleDistance );
}
void Sample::ResetText()
{
// Below the menu bar when the UI shows. Hidden, the minimal HUD owns the
// top-left, so start lower.
float fontSize = ImGui::GetFontSize();
if ( m_context->showUI )
{
m_textLine = (int)( ImGui::GetFrameHeight() + 0.5f * fontSize );
}
else
{
m_textLine = (int)( 3.0f * fontSize );
}
m_textX = 5;
if ( IsProfileVisible() )
{
m_textX += (int)( GetProfilePanelWidth() + 0.5f * fontSize );
}
}
void Sample::Step()
{
m_didStep = false;
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_context->singleStep = b3MaxInt( 0, m_context->singleStep - 1 );
}
if ( B3_IS_NON_NULL( m_mouseJointId ) && b3Joint_IsValid( m_mouseJointId ) == false )
{
// The world or attached body was destroyed.
m_mouseJointId = {};
if ( B3_IS_NON_NULL( m_mouseBodyId ) )
{
b3DestroyBody( m_mouseBodyId );
m_mouseBodyId = {};
}
}
if ( B3_IS_NON_NULL( m_mouseBodyId ) && timeStep > 0.0f )
{
b3Body_SetTargetTransform( m_mouseBodyId, { m_mousePoint, b3Quat_identity }, timeStep, true );
}
b3World_EnableSleeping( m_worldId, m_context->enableSleep );
b3World_EnableWarmStarting( m_worldId, m_context->enableWarmStarting );
b3World_EnableContinuous( m_worldId, m_context->enableContinuous );
b3World_SetRestitutionIterations( m_worldId, m_context->restitutionIterations );
b3World_EnableRestitutionPropagation( m_worldId, m_context->enableRestitutionPropagation );
b3World_EnableSSE2Fallback( m_worldId, m_context->enableSSE2Fallback );
if ( timeStep > 0.0f || m_stepWhilePaused )
{
b3World_Step( m_worldId, timeStep, m_context->subStepCount );
}
if ( timeStep > 0.0f )
{
m_stepCount += 1;
m_didStep = true;
if ( m_profileWriteIndex - m_profileReadIndex == m_profileCapacity )
{
m_profileReadIndex += 1;
}
m_currentProfileIndex = m_profileWriteIndex & ( m_profileCapacity - 1 );
m_profiles[m_currentProfileIndex] = b3World_GetProfile( m_worldId );
m_profileWriteIndex += 1;
}
m_triangleIndex = -1;
m_userMaterialId = 0;
// Cursor pick feeds the surface type readout only. Highlighting is selection driven.
if ( m_camera->m_thirdPerson == false )
{
PickRay pickRay = m_camera->BuildPickRay( m_context->mouseX, m_context->mouseY );
b3QueryFilter filter = b3DefaultQueryFilter();
filter.name = "pick";
b3RayResult result = b3World_CastRayClosest( m_worldId, pickRay.origin, pickRay.translation, filter );
if ( result.hit )
{
if ( b3Shape_GetType( result.shapeId ) == b3_meshShape )
{
m_triangleIndex = result.triangleIndex;
}
m_userMaterialId = result.userMaterialId;
}
}
// The frame latched the origin before Step, but a third person follow moves the eye while
// stepping, so refresh it here. Shapes come back demoted to float against this origin, the same
// relative frame the translation free view renders, so everything stays precise far from the origin.
SetDrawOrigin( m_camera->DrawOrigin() );
b3DebugDraw debugDraw;
MakeDebugDraw( &debugDraw );
// Box3D uses this to decide which shapes enter the draw set and lazily fire
// createDebugShape. The camera derives it from the view distance, in length units
// around the simulation eye, matching the broad-phase tree and the far plane.
const b3AABB drawBox = m_camera->DrawBounds();
// A caster between the view and the sun is off screen but still darkens what
// is on screen, so the draw set has to reach past the view box. Bounds come
// back in the eye-relative frame the view inverse maps into, hence the offset.
b3Vec3 casterLo, casterHi;
const Mat4 viewInv = m_camera->ViewInverse();
const Mat4 projInv = m_camera->ProjInverse();
GetShadowCasterBounds( &viewInv, &projInv, &casterLo, &casterHi );
const b3AABB casterBox = b3OffsetAABB( { casterLo, casterHi }, m_camera->DrawOrigin() );
debugDraw.drawingBounds.lowerBound = b3Min( drawBox.lowerBound, casterBox.lowerBound );
debugDraw.drawingBounds.upperBound = b3Max( drawBox.upperBound, casterBox.upperBound );
// Compound child culling keeps the tighter view box. Widening it there would
// cull nothing.
SetViewBounds( drawBox );
ApplyGuiFlags( &debugDraw );
b3World_Draw( m_worldId, &debugDraw, B3_DEFAULT_MASK_BITS );
}
bool Sample::FocusBounds( b3AABB* )
{
return false;
}
float Sample::InfoPanelWidthEm() const
{
return INFO_PANEL_WIDTH;
}
b3BodyId Sample::FocusBody() const
{
return GetSelectedBody();
}
void Sample::FocusHome()
{
m_camera->m_pivot = m_context->homePivot;
m_camera->SetOrbit( m_context->homeYaw, m_context->homePitch, m_context->homeRadius );
}
void FrameSelection( SampleContext* context )
{
// A non-body selection such as a recorded query supplies its own bounds and takes priority over
// the hovered body. With nothing selected the sample decides what home is. The replay viewer fits
// its recording, which lives in a player-owned world rather than the base world.
Sample* sample = context->sample;
Camera& cam = context->camera;
float aspect = cam.m_height > 0 ? (float)cam.m_width / (float)cam.m_height : 1.0f;
b3AABB bounds;
if ( sample->FocusBounds( &bounds ) )
{
cam.Frame( bounds, aspect, 1.5f );
return;
}
b3BodyId bodyId = sample->FocusBody();
if ( B3_IS_NON_NULL( bodyId ) )
{
cam.Frame( b3Body_ComputeAABB( bodyId ), aspect, 1.5f );
return;
}
sample->FocusHome();
}
void Sample::ResetProfile()
{
// Keeps the elapsed recording length intact across a profile reset
m_recordStartStep -= m_stepCount;
m_stepCount = 0;
memset( m_profiles, 0, sizeof( m_profiles ) );
m_currentProfileIndex = 0;
m_profileReadIndex = 0;
m_profileWriteIndex = 0;
}
b3BodyId Sample::AddGroundBox( float extent )
{
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( extent, 1.0f, extent );
b3ShapeId shapeId = b3CreateHullShape( groundId, &shapeDef, &hull.base );
// Draw the ground with the procedural grid material
SetGroundShape( shapeId );
return groundId;
}
struct RowDef
{
const char* name;
int indent;
ImU32 color;
};
float AddSegment( ImDrawList* dl, float availWidth, float t, float stepNow, ImU32 col, float x, ImVec2 cursor, float barHeight )
{
float w = availWidth * ( t / stepNow );
if ( w > 0.0f )
{
dl->AddRectFilled( ImVec2( x, cursor.y ), ImVec2( x + w, cursor.y + barHeight ), col );
x += w;
}
return x;
}
#define PROFILE_SECTION_WIDTH 8.0f
#define PROFILE_INDENT_WIDTH 0.75f
#define PROFILE_VALUE_WIDTH 3.0f
#define PROFILE_BAR_WIDTH 4.0f
#define PROFILE_COLUMN_COUNT 5
// Shared by the profile panel and the frame time plot so the two views read alike
static const ImU32 s_colorStep = IM_COL32( 230, 230, 230, 255 );
static const ImU32 s_colorPairs = IM_COL32( 102, 153, 255, 255 );
static const ImU32 s_colorCollide = IM_COL32( 255, 140, 51, 255 );
static const ImU32 s_colorSolve = IM_COL32( 102, 204, 102, 255 );
static const ImU32 s_colorSolveChild = IM_COL32( 150, 190, 150, 255 );
static const ImU32 s_colorConstraintChild = IM_COL32( 110, 200, 190, 255 );
static const ImU32 s_colorSensors = IM_COL32( 200, 120, 220, 255 );
static const ImU32 s_colorOther = IM_COL32( 140, 140, 140, 255 );
// Well apart from both row background shades so the track reads the same on every row
static const ImU32 s_colorTrack = IM_COL32( 70, 70, 74, 255 );
bool Sample::IsProfileVisible() const
{
return m_context->showUI && m_context->showProfile && HasProfile();
}
float Sample::GetProfilePanelWidth() const
{
if ( IsProfileVisible() == false )
{
return 0.0f;
}
const ImGuiStyle& style = ImGui::GetStyle();
float fontSize = ImGui::GetFontSize();
float width = PROFILE_SECTION_WIDTH + 3.0f * PROFILE_VALUE_WIDTH + PROFILE_BAR_WIDTH;
return width * fontSize + 2.0f * PROFILE_COLUMN_COUNT * style.CellPadding.x + 2.0f * style.WindowPadding.x;
}
// Left profile panel (I). Full height under the menu bar, clear of the right info panel.
void Sample::DrawProfile()
{
if ( IsProfileVisible() == false )
{
return;
}
float fontSize = ImGui::GetFontSize();
float menuBarHeight = ImGui::GetFrameHeight();
float panelWidth = GetProfilePanelWidth();
ImGui::SetNextWindowPos( { 0.5f * fontSize, menuBarHeight + 0.5f * fontSize } );
ImGui::SetNextWindowSize( { panelWidth, m_camera->m_height - menuBarHeight - fontSize } );
ImGui::Begin( "Profile", nullptr,
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoTitleBar );
int count = m_profileWriteIndex - m_profileReadIndex;
// Unroll ring buffer into per-field histories.
constexpr int kRowCount = 22;
float histories[kRowCount][m_profileCapacity];
float totals[kRowCount] = {};
for ( int i = 0; i < count; ++i )
{
int idx = ( m_profileReadIndex + i ) & ( m_profileCapacity - 1 );
const b3Profile& p = m_profiles[idx];
histories[0][i] = p.step;
histories[1][i] = p.pairs;
histories[2][i] = p.collide;
histories[3][i] = p.solve;
histories[4][i] = p.solverSetup;
histories[5][i] = p.constraints;
histories[6][i] = p.prepareConstraints;
histories[7][i] = p.integrateVelocities;
histories[8][i] = p.warmStart;
histories[9][i] = p.solveImpulses;
histories[10][i] = p.integratePositions;
histories[11][i] = p.relaxImpulses;
histories[12][i] = p.restitution;
histories[13][i] = p.storeImpulses;
histories[14][i] = p.splitIslands;
histories[15][i] = p.transforms;
histories[16][i] = p.jointEvents;
histories[17][i] = p.hitEvents;
histories[18][i] = p.refit;
histories[19][i] = p.sleepIslands;
histories[20][i] = p.bullets;
histories[21][i] = p.sensors;
for ( int j = 0; j < kRowCount; ++j )
{
totals[j] += histories[j][i];
}
}
// Smoothed over the last few frames so bars don't jitter visibly.
constexpr int kNowWindow = 10;
float now[kRowCount] = {};
{
int n = count < kNowWindow ? count : kNowWindow;
if ( n > 0 )
{
float inv = 1.0f / n;
for ( int r = 0; r < kRowCount; ++r )
{
float sum = 0.0f;
for ( int i = count - n; i < count; ++i )
{
sum += histories[r][i];
}
now[r] = sum * inv;
}
}
}
float avg[kRowCount] = {};
if ( count > 0 )
{
float scale = 1.0f / count;
for ( int i = 0; i < kRowCount; ++i )
{
avg[i] = scale * totals[i];
}
}
float rowMax[kRowCount] = {};
for ( int r = 0; r < kRowCount; ++r )
{
for ( int i = 0; i < count; ++i )
{
if ( histories[r][i] > rowMax[r] )
{
rowMax[r] = histories[r][i];
}
}
}
const RowDef rows[kRowCount] = {
{ "step", 0, s_colorStep },
{ "pairs", 0, s_colorPairs },
{ "collide", 0, s_colorCollide },
{ "solve", 0, s_colorSolve },
{ "setup", 1, s_colorSolveChild },
{ "constraints", 1, s_colorSolveChild },
{ "prepare", 2, s_colorConstraintChild },
{ "velocities", 2, s_colorConstraintChild },
{ "warm start", 2, s_colorConstraintChild },
{ "bias", 2, s_colorConstraintChild },
{ "positions", 2, s_colorConstraintChild },
{ "relax", 2, s_colorConstraintChild },
{ "restitution", 2, s_colorConstraintChild },
{ "store", 2, s_colorConstraintChild },
{ "split", 2, s_colorConstraintChild },
{ "transforms", 1, s_colorSolveChild },
{ "joint events", 1, s_colorSolveChild },
{ "hit events", 1, s_colorSolveChild },
{ "refit BVH", 1, s_colorSolveChild },
{ "sleep", 1, s_colorSolveChild },
{ "bullets", 1, s_colorSolveChild },
{ "sensors", 0, s_colorSensors },
};
float stepNow = b3MaxFloat( now[0], 0.001f );
if ( ImGui::Button( "Reset" ) )
{
ResetProfile();
}
ImGui::SameLine();
ImGui::Text( " step %.2f ms", now[0] );
// Flame strip: step subdivided by top-level children.
{
float pairsT = now[1];
float collideT = now[2];
float solveT = now[3];
float sensorsT = now[21];
float otherT = b3MaxFloat( stepNow - pairsT - collideT - solveT - sensorsT, 0.0f );
float availWidth = ImGui::GetContentRegionAvail().x;
float barHeight = 1.5f * fontSize;
ImDrawList* dl = ImGui::GetWindowDrawList();
ImVec2 cursor = ImGui::GetCursorScreenPos();
float x = cursor.x;
x = AddSegment( dl, availWidth, pairsT, stepNow, s_colorPairs, x, cursor, barHeight );
x = AddSegment( dl, availWidth, collideT, stepNow, s_colorCollide, x, cursor, barHeight );
x = AddSegment( dl, availWidth, solveT, stepNow, s_colorSolve, x, cursor, barHeight );
x = AddSegment( dl, availWidth, sensorsT, stepNow, s_colorSensors, x, cursor, barHeight );
x = AddSegment( dl, availWidth, otherT, stepNow, s_colorOther, x, cursor, barHeight );
ImGui::Dummy( ImVec2( availWidth, barHeight ) );
}
const ImGuiTableFlags tableFlags = ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit;
if ( ImGui::BeginTable( "profile", PROFILE_COLUMN_COUNT, tableFlags ) )
{
ImGui::TableSetupColumn( "section", ImGuiTableColumnFlags_WidthFixed, PROFILE_SECTION_WIDTH * fontSize );
ImGui::TableSetupColumn( "now", ImGuiTableColumnFlags_WidthFixed, PROFILE_VALUE_WIDTH * fontSize );
ImGui::TableSetupColumn( "avg", ImGuiTableColumnFlags_WidthFixed, PROFILE_VALUE_WIDTH * fontSize );
ImGui::TableSetupColumn( "max", ImGuiTableColumnFlags_WidthFixed, PROFILE_VALUE_WIDTH * fontSize );
ImGui::TableSetupColumn( "%", ImGuiTableColumnFlags_WidthFixed, PROFILE_BAR_WIDTH * fontSize );
ImGui::TableHeadersRow();
for ( int r = 0; r < kRowCount; ++r )
{
const RowDef& d = rows[r];
ImGui::TableNextRow();
ImGui::TableNextColumn();
float indent = d.indent * PROFILE_INDENT_WIDTH * fontSize;
ImGui::SetCursorPosX( ImGui::GetCursorPosX() + indent );
ImGui::PushStyleColor( ImGuiCol_Text, d.color );
ImGui::TextUnformatted( d.name );
ImGui::PopStyleColor();
// Dim rows that would print as zero so the costly sections stand out
bool idle = avg[r] < 0.005f;
if ( idle )
{
ImGui::PushStyleColor( ImGuiCol_Text, ImGui::GetStyleColorVec4( ImGuiCol_TextDisabled ) );
}
ImGui::TableNextColumn();
ImGui::Text( "%6.2f", now[r] );
ImGui::TableNextColumn();
ImGui::Text( "%6.2f", avg[r] );
ImGui::TableNextColumn();
ImGui::Text( "%6.2f", rowMax[r] );
if ( idle )
{
ImGui::PopStyleColor();
}
ImGui::TableNextColumn();
// The step itself is measured against the frame budget to show headroom
bool isBudget = r == 0 && m_context->hertz > 0.0f;
float reference = isBudget ? 1000.0f / m_context->hertz : stepNow;
float frac = b3ClampFloat( now[r] / reference, 0.0f, 1.0f );
// Text line height instead of a framed progress bar keeps the rows tight
float barWidth = ImGui::GetContentRegionAvail().x;
float barHeight = ImGui::GetTextLineHeight();
ImVec2 p = ImGui::GetCursorScreenPos();
ImDrawList* drawList = ImGui::GetWindowDrawList();
drawList->AddRectFilled( p, ImVec2( p.x + barWidth, p.y + barHeight ), s_colorTrack );
drawList->AddRectFilled( p, ImVec2( p.x + frac * barWidth, p.y + barHeight ), d.color );
ImGui::Dummy( ImVec2( barWidth, barHeight ) );
if ( isBudget )
{
ImGui::SetItemTooltip( "%.0f%% of %.1f ms frame", 100.0f * now[r] / reference, reference );
}
else
{
ImGui::SetItemTooltip( "%.0f%% of step", 100.0f * now[r] / reference );
}
}
ImGui::EndTable();
}
ImGui::End();
}
// Vertical bars scaled to a shared maximum, one per value. Stands in for a table that would not
// fit the drawer, so the caller reports each bar's count from the returned hover index.
static int DrawBarChart( const char* id, const int* values, const ImU32* colors, int count, int scaleMax, ImVec2 size )
{
ImVec2 origin = ImGui::GetCursorScreenPos();
ImGui::InvisibleButton( id, size );
bool hovered = ImGui::IsItemHovered();
float mouseX = ImGui::GetIO().MousePos.x;
ImDrawList* drawList = ImGui::GetWindowDrawList();
float slot = size.x / count;
float gap = b3MinFloat( 2.0f, 0.25f * slot );
float invMax = scaleMax > 0 ? 1.0f / scaleMax : 0.0f;
float bottom = origin.y + size.y;
int hoveredIndex = -1;
for ( int i = 0; i < count; ++i )
{
float x0 = origin.x + i * slot;
float x1 = x0 + slot - gap;
// Empty slots still show, so a gap in the sequence reads as a gap
drawList->AddRectFilled( ImVec2( x0, origin.y ), ImVec2( x1, bottom ), s_colorTrack );
float height = b3ClampFloat( values[i] * invMax, 0.0f, 1.0f ) * size.y;
if ( values[i] > 0 )
{
// A tiny count keeps a visible sliver
height = b3MaxFloat( height, 1.0f );
drawList->AddRectFilled( ImVec2( x0, bottom - height ), ImVec2( x1, bottom ), colors[i] );
}
if ( hovered && x0 <= mouseX && mouseX < x0 + slot )
{
hoveredIndex = i;
drawList->AddRect( ImVec2( x0, origin.y ), ImVec2( x1, bottom ), IM_COL32( 255, 255, 255, 200 ) );
}
}
return hoveredIndex;
}
// Bottom metrics drawer (M). Tabs: the ImPlot frame time chart, Counters, and Renderer.
// Anchored along the window bottom, between the profile panel and the right info panel.
void Sample::DrawMetrics()
{
if ( m_context->showMetrics == false )
{
return;
}
float fontSize = ImGui::GetFontSize();
float menuWidth = InfoPanelWidthEm() * fontSize;
float drawerHeight = 16.0f * fontSize;
float drawerX = 0.5f * fontSize;
if ( IsProfileVisible() )
{
drawerX += GetProfilePanelWidth() + 0.5f * fontSize;
}
float drawerWidth = m_camera->m_width - menuWidth - fontSize - drawerX;
ImGui::SetNextWindowPos( { drawerX, m_camera->m_height - drawerHeight - 0.5f * fontSize } );
ImGui::SetNextWindowSize( { drawerWidth, drawerHeight } );
ImGui::Begin( "Metrics", nullptr,
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoTitleBar );
if ( ImGui::BeginTabBar( "MetricsTabs", ImGuiTabBarFlags_None ) == false )
{
ImGui::End();
return;
}
if ( HasProfile() && ImGui::BeginTabItem( "Frame Time" ) )
{
float maxValue = 0.0f;
float times[m_profileCapacity];
float stepTimes[m_profileCapacity];
float pairsTimes[m_profileCapacity];
float collideTimes[m_profileCapacity];
float solveTimes[m_profileCapacity];
float sensorsTimes[m_profileCapacity];
int count = m_profileWriteIndex - m_profileReadIndex;
for ( int i = 0; i < count; ++i )
{
int index = ( m_profileReadIndex + i ) & ( m_profileCapacity - 1 );
times[i] = i / 60.0f;
stepTimes[i] = m_profiles[index].step;
pairsTimes[i] = m_profiles[index].pairs;
collideTimes[i] = m_profiles[index].collide;
solveTimes[i] = m_profiles[index].solve;
sensorsTimes[i] = m_profiles[index].sensors;
maxValue = b3MaxFloat( stepTimes[i], maxValue );
}
// ImPlot picks a 5 second major interval at this width, leaving one bright line among the half seconds
ImPlot::PushStyleVar( ImPlotStyleVar_MinorAlpha, 1.0f );
ImPlot::PushStyleColor( ImPlotCol_AxisGrid, IM_COL32( 255, 255, 255, 15 ) );
ImVec2 plotSize = ImGui::GetContentRegionAvail();
if ( ImPlot::BeginPlot( "Profile", plotSize, ImPlotFlags_NoTitle ) )
{
ImPlot::SetupAxes( nullptr, "ms" );
ImPlot::SetupAxisLimits( ImAxis_X1, 0.0, m_profileCapacity / 60.0 );
ImPlot::SetupAxisLimits( ImAxis_Y1, 0.0, b3MaxFloat( maxValue, 1.0f ) * 1.05, ImPlotCond_Always );
ImPlot::SetNextLineStyle( ImGui::ColorConvertU32ToFloat4( s_colorStep ) );
ImPlot::PlotLine( "step", times, stepTimes, count );
ImPlot::SetNextLineStyle( ImGui::ColorConvertU32ToFloat4( s_colorPairs ) );
ImPlot::PlotLine( "pairs", times, pairsTimes, count );
ImPlot::SetNextLineStyle( ImGui::ColorConvertU32ToFloat4( s_colorCollide ) );
ImPlot::PlotLine( "collide", times, collideTimes, count );
ImPlot::SetNextLineStyle( ImGui::ColorConvertU32ToFloat4( s_colorSolve ) );
ImPlot::PlotLine( "solve", times, solveTimes, count );
ImPlot::SetNextLineStyle( ImGui::ColorConvertU32ToFloat4( s_colorSensors ) );
ImPlot::PlotLine( "sensors", times, sensorsTimes, count );
ImPlot::EndPlot();
}
ImPlot::PopStyleColor();
ImPlot::PopStyleVar();
ImGui::EndTabItem();
}
if ( ImGui::BeginTabItem( "Counters" ) )
{
b3WorldId worldId = GetMetricsWorldId();
b3Counters s = b3World_GetCounters( worldId );
b3Capacity c = b3World_GetMaxCapacity( worldId );
constexpr int colorCount = sizeof( s.colorCounts ) / sizeof( s.colorCounts[0] );
constexpr int overflowIndex = colorCount - 1;
constexpr int manifoldBucketCount = sizeof( s.manifoldCounts ) / sizeof( s.manifoldCounts[0] );
// Four fixed columns side by side so the whole tab fits the drawer without scrolling
const ImGuiTableFlags tableFlags = ImGuiTableFlags_BordersInnerV | ImGuiTableFlags_SizingFixedFit;
if ( ImGui::BeginTable( "counters_layout", 4, tableFlags ) )
{
ImGui::TableSetupColumn( "world", ImGuiTableColumnFlags_WidthFixed, 11.0f * fontSize );
ImGui::TableSetupColumn( "memory", ImGuiTableColumnFlags_WidthFixed, 9.0f * fontSize );
ImGui::TableSetupColumn( "collision", ImGuiTableColumnFlags_WidthFixed, 11.0f * fontSize );
ImGui::TableSetupColumn( "solver", ImGuiTableColumnFlags_WidthStretch );
ImGui::TableHeadersRow();
ImGui::TableNextRow();
ImGui::TableNextColumn();
ImGui::Text( "bodies %d / %d", s.bodyCount, c.staticBodyCount + c.dynamicBodyCount );
ImGui::SetItemTooltip( "max static %d, dynamic %d", c.staticBodyCount, c.dynamicBodyCount );
ImGui::Text( "shapes %d / %d", s.shapeCount, c.staticShapeCount + c.dynamicShapeCount );
ImGui::SetItemTooltip( "max static %d, dynamic %d", c.staticShapeCount, c.dynamicShapeCount );
ImGui::Text( "contacts %d / %d", s.contactCount, c.contactCount );
ImGui::SetItemTooltip( "current / max" );
ImGui::Text( "joints %d", s.jointCount );
ImGui::Text( "islands %d", s.islandCount );
ImGui::Text( "tasks %d", s.taskCount );
ImGui::TableNextColumn();
ImGui::Text( "static tree %d", s.staticTreeHeight );
ImGui::SetItemTooltip( "tree height" );
ImGui::Text( "movable tree %d", s.treeHeight );
ImGui::SetItemTooltip( "tree height" );
ImGui::Text( "world %lld K", (long long)( s.byteCount / 1024 ) );
ImGui::Text( "stack %d K", s.stackUsed / 1024 );
ImGui::Text( "arena %d K", s.arenaCapacity / 1024 );
ImGui::TableNextColumn();
ImGui::Text( "sat %d / %d", s.satCallCount, s.satCacheHitCount );
ImGui::SetItemTooltip( "SAT calls / cache hits" );
ImGui::Text( "toi %d / %d / %d", s.distanceIterations, s.pushBackIterations, s.rootIterations );
ImGui::SetItemTooltip( "TOI distance / push back / root iterations" );
// The world clamps into the second to last bucket, so the last is always empty and the
// second to last means that many or more
constexpr int manifoldBarCount = manifoldBucketCount - 1;
int totalManifolds = 0;
int maxManifolds = 0;
ImU32 manifoldColors[manifoldBarCount];
for ( int i = 0; i < manifoldBarCount; ++i )
{
totalManifolds += s.manifoldCounts[i];
maxManifolds = b3MaxInt( maxManifolds, s.manifoldCounts[i] );
manifoldColors[i] = s_colorPairs;
}
ImGui::TextDisabled( "manifolds per pair" );
ImVec2 manifoldSize = { ImGui::GetContentRegionAvail().x, 4.0f * fontSize };
int hoveredBucket =
DrawBarChart( "##manifolds", s.manifoldCounts, manifoldColors, manifoldBarCount, maxManifolds, manifoldSize );
if ( hoveredBucket >= 0 )
{
const char* plus = hoveredBucket == manifoldBarCount - 1 ? "+" : "";
ImGui::SetTooltip( "%d%s manifolds: %d of %d pairs", hoveredBucket + 1, plus, s.manifoldCounts[hoveredBucket],
totalManifolds );
}
ImGui::TableNextColumn();
// Bars are scaled to the largest normal color so the distribution shape reads clearly. Overflow
// gets a share bar of its own below to flag coupling problems.
int totalCount = 0;
int maxCount = 0;
ImU32 colors[overflowIndex];
for ( int i = 0; i < colorCount; ++i )
{
totalCount += s.colorCounts[i];
if ( i != overflowIndex )
{
maxCount = b3MaxInt( maxCount, s.colorCounts[i] );
uint32_t hex = static_cast<uint32_t>( b3GetGraphColor( i ) );
colors[i] = IM_COL32( ( hex >> 16 ) & 0xFF, ( hex >> 8 ) & 0xFF, hex & 0xFF, 255 );
}
}
int overflowCount = s.colorCounts[overflowIndex];
ImGui::Text( "%d constraints across %d colors", totalCount, overflowIndex );
ImVec2 colorSize = { ImGui::GetContentRegionAvail().x, 5.0f * fontSize };
int hoveredColor = DrawBarChart( "##colors", s.colorCounts, colors, overflowIndex, maxCount, colorSize );
if ( hoveredColor >= 0 )
{
ImGui::SetTooltip( "color %d: %d", hoveredColor, s.colorCounts[hoveredColor] );
}
// Overflow and recycling share a line to keep the column within the drawer height
float halfWidth = 0.5f * ( ImGui::GetContentRegionAvail().x - ImGui::GetStyle().ItemSpacing.x );
float overflowFrac = totalCount > 0 ? (float)overflowCount / (float)totalCount : 0.0f;
char overflowOverlay[32];
snprintf( overflowOverlay, sizeof( overflowOverlay ), "overflow %d", overflowCount );
ImGui::PushStyleColor( ImGuiCol_PlotHistogram, IM_COL32( 220, 60, 60, 255 ) );
ImGui::ProgressBar( overflowFrac, ImVec2( halfWidth, 0.0f ), overflowOverlay );
ImGui::PopStyleColor();
ImGui::SetItemTooltip( "Constraints in the overflow color, solved serially" );
ImGui::SameLine();
float recycledFrac = s.awakeContactCount > 0
? b3ClampFloat( (float)s.recycledContactCount / (float)s.awakeContactCount, 0.0f, 1.0f )
: 0.0f;
char recycledOverlay[48];
snprintf( recycledOverlay, sizeof( recycledOverlay ), "recycled %d / %d", s.recycledContactCount,
s.awakeContactCount );
ImGui::ProgressBar( recycledFrac, ImVec2( -FLT_MIN, 0.0f ), recycledOverlay );
ImGui::SetItemTooltip( "Awake contacts that reused last step's manifold" );
ImGui::EndTable();
}
ImGui::EndTabItem();
}
if ( ImGui::BeginTabItem( "Renderer" ) )
{
const RenderStats st = GetRenderStats();
// Display-link frame time vs the RenderFrame submit cost, both
// EMA-smoothed so the readout doesn't flicker.
const float frameMs = (float)( sapp_frame_duration() * 1000.0 );
static float smoothedFrameMs = 0.0f;
static float smoothedCpuMs = 0.0f;
smoothedFrameMs = ( smoothedFrameMs <= 0.0f ) ? frameMs : smoothedFrameMs * 0.9f + frameMs * 0.1f;
smoothedCpuMs = ( smoothedCpuMs <= 0.0f ) ? st.frameTimeMs : smoothedCpuMs * 0.9f + st.frameTimeMs * 0.1f;
const float fps = ( smoothedFrameMs > 0.0f ) ? ( 1000.0f / smoothedFrameMs ) : 0.0f;
const char* backend = "?";
switch ( sg_query_backend() )
{
case SG_BACKEND_D3D11:
backend = "D3D11";
break;
case SG_BACKEND_METAL_MACOS:
backend = "Metal";
break;
case SG_BACKEND_GLCORE:
backend = "GLCORE";
break;
case SG_BACKEND_GLES3:
backend = "GLES3";
break;
case SG_BACKEND_WGPU:
backend = "WGPU";
break;
default:
break;
}
ImGui::Text( "%s %.2f ms (%.0f FPS) CPU %.2f ms", backend, smoothedFrameMs, fps, smoothedCpuMs );
ImGui::Text( "draw calls %d (approx)", st.drawCallCount );
ImGui::Separator();
ImGui::Text( "opaque cubes %d spheres %d capsules %d geom %d (%d spans)", st.cubeCount, st.sphereCount,
st.capsuleCount, st.geomInstanceCount, st.geomSpanCount );
ImGui::Text( "transp. cubes %d spheres %d capsules %d geom %d", st.cubeCountXp, st.sphereCountXp, st.capsuleCountXp,
st.geomInstanceCountXp );
ImGui::Text( "overlays lines %d points %d", st.lineCount, st.pointCount );
ImGui::EndTabItem();
}
// Sample-specific tabs (the Replay viewer adds Timeline here).
DrawMetricsTab();
ImGui::EndTabBar();
ImGui::End();
}
void Sample::MouseDown( b3Vec2 p, int button, int modifiers )
{
if ( m_camera->m_thirdPerson )
{
return;
}
if ( button == 0 && modifiers == 0 )
{
// Plain click selects the body under the cursor, any type. Empty space clears.
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3QueryFilter filter = b3DefaultQueryFilter();
filter.name = "select";
b3RayResult result = b3World_CastRayClosest( m_worldId, pickRay.origin, pickRay.translation, filter );
if ( result.hit )
{
SetSelectedBody( b3Shape_GetBody( result.shapeId ) );
}
else
{
ClearSelection();
}
}
else if ( button == 0 && modifiers == MOD_CTRL )
{
// Ctrl click grabs a dynamic body with a kinematic mouse body and a motor joint.
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3QueryFilter filter = b3DefaultQueryFilter();
filter.name = "grab";
b3RayResult result = b3World_CastRayClosest( m_worldId, pickRay.origin, pickRay.translation, filter );
b3BodyId bodyId = result.hit ? b3Shape_GetBody( result.shapeId ) : b3_nullBodyId;
if ( result.hit && b3Body_GetType( bodyId ) == b3_dynamicBody )
{
m_mousePoint = result.point;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_kinematicBody;
bodyDef.position = m_mousePoint;
bodyDef.enableSleep = false;
m_mouseBodyId = b3CreateBody( m_worldId, &bodyDef );
// Grabbing also selects so the body stays highlighted while dragged.
SetSelectedBody( bodyId );
b3MotorJointDef jointDef = b3DefaultMotorJointDef();
jointDef.base.bodyIdA = m_mouseBodyId;
jointDef.base.bodyIdB = bodyId;
jointDef.base.localFrameB.p = b3Body_GetLocalPoint( bodyId, result.point );
jointDef.linearHertz = 7.5f;
jointDef.linearDampingRatio = 1.0f;
b3MassData massData = b3Body_GetMassData( bodyId );
float g = b3Length( b3World_GetGravity( m_worldId ) );
float mg = massData.mass * g;
jointDef.maxSpringForce = m_mouseForceScale * mg;
if ( massData.mass > 0.0f )
{
// This acts like angular friction
float trace = massData.inertia.cx.x + massData.inertia.cy.y + massData.inertia.cz.z;
float lever = sqrtf( trace / ( 3.0f * massData.mass ) );
jointDef.maxVelocityTorque = 0.5f * lever * mg;
}
m_mouseJointId = b3CreateMotorJoint( m_worldId, &jointDef );
b3Body_SetAwake( bodyId, true );
m_mouseFraction = result.fraction;
}
}
else if ( modifiers & MOD_SHIFT )
{
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
b3Vec3 direction = b3Normalize( pickRay.translation );
b3ShapeDef shapeDef = b3DefaultShapeDef();
if ( modifiers & MOD_CTRL )
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = pickRay.origin + 2.0f * direction;
bodyDef.linearVelocity = ( 10.0f * m_launchSpeedScale ) * direction;
bodyDef.isBullet = true;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3HullData* hull = b3CreateCylinder( 2.0f, 0.15f, 0.0f, 6 );
b3CreateHullShape( bodyId, &shapeDef, hull );
b3DestroyHull( hull );
}
else if ( modifiers & MOD_ALT )
{
b3Pos position = pickRay.origin + 2.0f * direction;
Human human = {};
CreateHuman( &human, m_worldId, position, 1.0f, 1.0f, 1.0f, 0, nullptr, true );
Human_SetBullet( &human, true );
Human_SetVelocity( &human, ( 10.0f * m_launchSpeedScale ) * direction );
}
else
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = pickRay.origin + 2.0f * direction;
bodyDef.linearVelocity = ( 20.0f * m_launchSpeedScale ) * direction;
bodyDef.isBullet = true;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3Sphere sphere = { b3Vec3_zero, 0.25f };
shapeDef.density *= 4.0f;
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
}
}
void Sample::MouseUp( b3Vec2 p, int button )
{
if ( b3Joint_IsValid( m_mouseJointId ) )
{
b3DestroyJoint( m_mouseJointId, true );
}
if ( b3Body_IsValid( m_mouseBodyId ) )
{
b3DestroyBody( m_mouseBodyId );
}
m_mouseJointId = b3_nullJointId;
m_mouseBodyId = b3_nullBodyId;
m_mouseFraction = 0.0f;
}
void Sample::MouseMove( b3Vec2 p )
{
if ( m_camera->m_thirdPerson )
{
// The cursor is locked in third person, so look uses the host's
// relative deltas. Camera angles are radians here (host camera).
m_mouseDelta = { m_context->mouseDX, m_context->mouseDY };
const float sensitivity = 0.1f * B3_DEG_TO_RAD;
m_camera->m_yaw -= 2.0f * sensitivity * m_mouseDelta.x;
m_camera->m_pitch += sensitivity * m_mouseDelta.y;
m_camera->m_pitch = b3ClampFloat( m_camera->m_pitch, -85.0f * B3_DEG_TO_RAD, 85.0f * B3_DEG_TO_RAD );
}
PickRay pickRay = m_camera->BuildPickRay( p.x, p.y );
if ( B3_IS_NON_NULL( m_mouseJointId ) )
{
m_mousePoint = pickRay.origin + m_mouseFraction * pickRay.translation;
}
}
void Sample::DrawTextLine( const char* text, ... )
{
va_list args;
va_start( args, text );
char buffer[512];
vsnprintf( buffer, sizeof( buffer ), text, args );
va_end( args );
// The text arena keeps 63 characters per string, so wrap long lines at spaces and indent the rest
constexpr int capacity = 63;
constexpr int indent = 2;
const char* start = buffer;
bool first = true;
while ( true )
{
int width = first ? capacity : capacity - indent;
int length = (int)strlen( start );
int cut = length;
if ( length > width )
{
cut = width;
while ( cut > 0 && start[cut] != ' ' )
{
cut -= 1;
}
if ( cut == 0 )
{
cut = width;
}
}
char line[capacity + 1];
int offset = first ? 0 : indent;
memset( line, ' ', offset );
memcpy( line + offset, start, cut );
line[offset + cut] = '\0';
DrawScreenString( m_textX, m_textLine, MakeColor( b3_colorWhite ), line );
m_textLine += m_textIncrement;
start += cut;
while ( *start == ' ' )
{
start += 1;
}
if ( *start == '\0' )
{
break;
}
first = false;
}
}
SampleEntry g_sampleEntries[MAX_SAMPLES];
int g_sampleCount = 0;
int g_replayIndex = -1;
int RegisterSample( const char* category, const char* name, SampleCreateFcn* fcn )
{
int index = g_sampleCount;
if ( index < MAX_SAMPLES )
{
g_sampleEntries[index] = { category, name, fcn };
g_sampleCount += 1;
return index;
}
return -1;
}
// Like RegisterSample but remembers the index so the Replay menu can switch to the viewer.
int RegisterReplay( const char* category, const char* name, SampleCreateFcn* fcn )
{
int index = RegisterSample( category, name, fcn );
if ( index >= 0 )
{
g_replayIndex = index;
}
return index;
}
void SelectSample( SampleContext* context, int selection, bool restart )
{
if ( selection < 0 || selection >= g_sampleCount )
{
// Out of range: keep the current sample rather than calling a null factory.
return;
}
if ( restart == false )
{
context->pause = false;
}
// Steps queued in a sample that never consumes them must not play out in the next one
context->singleStep = 0;
// delete tolerates the first selection, before any sample exists.
delete context->sample;
context->sample = nullptr;
context->sampleIndex = selection;
context->restart = restart;
context->sample = g_sampleEntries[selection].CreateFcn( context );
// A restart keeps the camera where it was, so the original starting view stays home
if ( restart == false )
{
context->homePivot = context->camera.m_pivot;
context->homeYaw = context->camera.m_yaw;
context->homePitch = context->camera.m_pitch;
context->homeRadius = context->camera.m_radius;
}
// A sample that knows where its content sits relative to its camera says
// so, and is taken at its word. The ceiling below guards a guess, not a
// measurement, so capping an explicit request would only hide it.
if ( context->sample->m_shadowSplitFar > 0.0f )
{
// A sample wanting only more reach leaves the near end at zero.
float splitNear = context->sample->m_shadowSplitNear;
SetShadowSplits( splitNear > 0.0f ? splitNear : SHADOW_SPLIT_NEAR, context->sample->m_shadowSplitFar );
}
else
{
// Otherwise fit the range to the world bounds. The bounds are a poor
// proxy for how far shadows need to reach: a ground plate stretches
// the diagonal well past anything worth shadowing, so the ceiling
// matters more than the estimate.
b3AABB bounds = b3World_GetBounds( context->sample->m_worldId );
float diagonal = b3Distance( bounds.lowerBound, bounds.upperBound );
SetShadowSplits( SHADOW_SPLIT_NEAR, b3ClampFloat( diagonal, SHADOW_SPLIT_FAR, SHADOW_SPLIT_FAR_MAX ) );
}
// Samples read restart only while constructing, to keep the camera across a
// restart. Clear it so a later switch starts fresh.
context->restart = false;
}
void OpenReplayFileDialog( SampleContext* context )
{
if ( g_replayIndex < 0 )
{
return;
}
if ( NFD_Init() != NFD_OKAY )
{
return;
}
nfdu8char_t* outPath = nullptr;
nfdu8filteritem_t filter[1] = { { "Box3D recording", "b3rec" } };
// Start in the working directory, where recordings are saved by default. A
// deleted or unreadable working directory just means no starting point.
std::error_code ec;
std::u8string cwd = std::filesystem::current_path( ec ).u8string();
const nfdu8char_t* defaultPath = ec ? nullptr : reinterpret_cast<const nfdu8char_t*>( cwd.c_str() );
if ( NFD_OpenDialogU8( &outPath, filter, 1, defaultPath ) == NFD_OKAY )
{
snprintf( context->replayFile, sizeof( context->replayFile ), "%s", outPath );
NFD_FreePathU8( outPath );
SelectSample( context, g_replayIndex, false );
}
NFD_Quit();
}
// Subsequence fuzzy match. Returns a score (higher is better) or -1 if the
// needle is not a subsequence of the haystack. Bonuses for a prefix match, a
// word start, and a contiguous run, so "stack" ranks Pyramid > Stack sensibly.
static int FuzzyScore( const char* needle, const char* haystack )
{
if ( needle == nullptr || needle[0] == '\0' )
{
return 0;
}
int score = 0;
int hi = 0;
int prevMatchHi = -2;
for ( int ni = 0; needle[ni] != '\0'; ++ni )
{
int nc = tolower( (unsigned char)needle[ni] );
while ( haystack[hi] != '\0' && tolower( (unsigned char)haystack[hi] ) != nc )
{
++hi;
}
if ( haystack[hi] == '\0' )
{
return -1;
}
int bonus = 1;
if ( hi == 0 )
{
bonus += 10; // prefix
}
else if ( !isalnum( (unsigned char)haystack[hi - 1] ) )
{
bonus += 5; // word start
}
if ( hi == prevMatchHi + 1 )
{
bonus += 3; // contiguous run
}
score += bonus;
prevMatchHi = hi;
++hi;
}
return score;
}
struct Scored
{
int idx;
int score;
};
// Filter and rank the sample registry against the picker query. Name matches
// outweigh category-only matches. Equal scores keep the sorted registry order.
static void RebuildPicker( const char* q, int* outFiltered, int* outCount )
{
static Scored scored[MAX_SAMPLES];
int n = 0;
for ( int i = 0; i < g_sampleCount; ++i )
{
int nameScore = FuzzyScore( q, g_sampleEntries[i].Name );
int catScore = FuzzyScore( q, g_sampleEntries[i].Category );
int best = -1;
if ( nameScore >= 0 )
{
best = nameScore * 2;
}
if ( catScore >= 0 && catScore > best )
{
best = catScore;
}
if ( best < 0 )
{
continue;
}
scored[n].idx = i;
scored[n].score = best;
n += 1;
}
// Stable insertion sort by score descending.
for ( int i = 1; i < n; ++i )
{
Scored tmp = scored[i];
int j = i - 1;
while ( j >= 0 && scored[j].score < tmp.score )
{
scored[j + 1] = scored[j];
--j;
}
scored[j + 1] = tmp;
}
for ( int i = 0; i < n; ++i )
{
outFiltered[i] = scored[i].idx;
}
*outCount = n;
}
static void DrawRow( const char* key, const char* desc )
{
ImGui::TableNextRow();
ImGui::TableSetColumnIndex( 0 );
ImGui::TextUnformatted( key );
ImGui::TableSetColumnIndex( 1 );
ImGui::TextUnformatted( desc );
}
// b3HexColor (0xRRGGBB) to an opaque ImVec4 for panel text. Distinct from
// gfx/utility.h's MakeColor, which returns the renderer's linear Vec4.
static ImVec4 HexColor( b3HexColor hexColor )
{
uint32_t h = (uint32_t)hexColor;
ImU32 color = IM_COL32( ( h >> 16 ) & 0xFF, ( h >> 8 ) & 0xFF, h & 0xFF, 255 );
return ImGui::ColorConvertU32ToFloat4( color );
}
// Abbreviated render controls: mostly visualization/debug toggles plus a single
// exposure slider. The deep GTAO knobs and most edge/outline parameters keep
// their renderer defaults, only the edge convexity coloring is exposed.
static void DrawRenderMenu( SampleContext& ctx )
{
ImGui::MenuItem( "Shadows", nullptr, &ctx.enableShadows );
if ( ImGui::BeginMenu( "Cascades" ) )
{
ImGui::PushItemWidth( 8.0f * ImGui::GetFontSize() );
// Where the split distribution starts, not where shadows start. Raising
// it hands the whole working volume to the first cascade and coarsens
// it to suit. The c0 row below is what to steer by: it says how far the
// sharp cascade reaches and what one of its texels costs.
float splitNear = GetShadowSplitNear();
if ( ImGui::SliderFloat( "Start", &splitNear, 0.1f, 30.0f, "%.1f m" ) )
{
SetShadowSplits( splitNear, GetShadowSplitFar() );
}
// Selecting a sample refits the range to the world, so a value dialed
// in here survives only until the next sample switch.
float splitFar = GetShadowSplitFar();
if ( ImGui::SliderFloat( "Range", &splitFar, 10.0f, 200.0f, "%.0f m" ) )
{
SetShadowSplitFar( splitFar );
}
float lambda = GetShadowSplitLambda();
if ( ImGui::SliderFloat( "Distribution", &lambda, 0.0f, 1.0f, "%.2f" ) )
{
SetShadowSplitLambda( lambda );
}
ImGui::PopItemWidth();
// Where each cascade ends and how much world one of its texels covers.
// A quality cliff at a boundary is the step between two neighboring
// texel sizes, which is easier to read here than off the image.
if ( ImGui::BeginTable( "cascades", 3, ImGuiTableFlags_SizingFixedFit ) )
{
ImGui::TableSetupColumn( "csm" );
ImGui::TableSetupColumn( "far" );
ImGui::TableSetupColumn( "texel" );
ImGui::TableHeadersRow();
for ( int i = 0; i < SHADOW_CASCADE_COUNT; ++i )
{
ImGui::TableNextRow();
ImGui::TableSetColumnIndex( 0 );
ImGui::Text( "%d", i );
ImGui::TableSetColumnIndex( 1 );
ImGui::Text( "%.1f m", GetCascadeFarViewZ( i ) );
ImGui::TableSetColumnIndex( 2 );
ImGui::Text( "%.0f mm", 1000.0f * GetCascadeTexelWorld( i ) );
}
ImGui::EndTable();
}
ImGui::EndMenu();
}
if ( ImGui::BeginMenu( "GTAO" ) )
{
ImGui::MenuItem( "Enable", nullptr, &ctx.enableGtao );
GtaoTraceParams p = GetGtaoTraceParams();
int quality = p.quality;
static const char* qualityNames[] = { "Medium", "High", "Ultra" };
if ( ImGui::Combo( "Quality", &quality, qualityNames, 3 ) )
{
p.quality = (AmbientOcclusionQuality)quality;
SetGtaoTraceParams( p );
}
ImGui::EndMenu();
}
bool ibl = GetIblEnabled();
if ( ImGui::MenuItem( "IBL", nullptr, &ibl ) )
{
SetIblEnabled( ibl );
}
EdgeOverlayParams edgeParams = GetEdgeOverlayParams();
if ( ImGui::MenuItem( "Hull Edges", nullptr, &edgeParams.showHulls ) )
{
SetEdgeOverlayParams( &edgeParams );
}
if ( ImGui::MenuItem( "Edge Convexity", nullptr, &edgeParams.showEdgeConvexity ) )
{
SetEdgeOverlayParams( &edgeParams );
}
ImGui::Separator();
ImGui::PushItemWidth( 8.0f * ImGui::GetFontSize() );
if ( ImGui::SliderFloat( "Edge Alpha", &edgeParams.alphaScale, 0.0f, 4.0f, "%.2f" ) )
{
SetEdgeOverlayParams( &edgeParams );
}
float ev = GetExposure();
if ( ImGui::SliderFloat( "Exposure", &ev, -8.0f, 4.0f, "%.2f" ) )
{
SetExposure( ev );
}
Sun sun = GetSun();
if ( ImGui::SliderFloat( "Sun", &sun.strength, 0.0f, 1.0f, "%.2f" ) )
{
SetSun( sun );
}
ImGui::PopItemWidth();
ImGui::Separator();
if ( ImGui::BeginMenu( "Debug View" ) )
{
static const char* viewNames[] = {
"0 - lit", "1 - view-space distance", "2 - CSM cascade", "3 - view-space normal", "4 - raw GTAO",
};
for ( int i = 0; i < 5; ++i )
{
if ( ImGui::RadioButton( viewNames[i], ctx.debugView == i ) )
{
ctx.debugView = i;
}
}
ImGui::EndMenu();
}
}
static void DrawMenuBar( SampleContext* context )
{
b3DebugDraw* gd = GetGuiDraw();
float fontSize = ImGui::GetFontSize();
if ( ImGui::BeginMainMenuBar() )
{
if ( ImGui::BeginMenu( "Sim" ) )
{
ImGui::MenuItem( "Pause", "P", &context->pause );
if ( ImGui::MenuItem( "Single Step", "." ) )
{
context->singleStep += 1;
}
if ( ImGui::MenuItem( "Restart", "R" ) )
{
SelectSample( context, context->sampleIndex, true );
}
ImGui::Separator();
if ( ImGui::MenuItem( "Previous Sample", "[" ) )
{
SelectSample( context, ( context->sampleIndex + g_sampleCount - 1 ) % g_sampleCount, false );
}
if ( ImGui::MenuItem( "Next Sample", "]" ) )
{
SelectSample( context, ( context->sampleIndex + 1 ) % g_sampleCount, false );
}
ImGui::Separator();
if ( ImGui::MenuItem( "Reset Profile" ) )
{
context->sample->ResetProfile();
}
if ( ImGui::MenuItem( "Dump Mem Stats" ) )
{
b3World_DumpMemoryStats( context->sample->m_worldId );
}
ImGui::Separator();
if ( ImGui::MenuItem( "Quit", "Ctrl+Q" ) )
{
sapp_request_quit();
}
ImGui::EndMenu();
}
if ( ImGui::BeginMenu( "View" ) )
{
if ( ImGui::MenuItem( "Hide UI", "Tab" ) )
{
context->showUI = false;
}
if ( ImGui::MenuItem( "Hide UI and Text", "Shift+Tab" ) )
{
context->showUI = false;
context->showText = false;
}
if ( ImGui::MenuItem( "Frame Selection", "F" ) )
{
FrameSelection( context );
}
if ( ImGui::MenuItem( "Reset Camera", "Home" ) )
{
context->sample->FocusHome();
}
ImGui::MenuItem( "Shapes", nullptr, &gd->drawShapes );
if ( ImGui::BeginMenu( "Transparency" ) )
{
ImGui::MenuItem( "Dynamic", nullptr, &context->transparentDynamic );
ImGui::MenuItem( "Kinematic", nullptr, &context->transparentKinematic );
ImGui::EndMenu();
}
ImGui::MenuItem( "Joints", nullptr, &gd->drawJoints );
ImGui::MenuItem( "Joint Extras", nullptr, &gd->drawJointExtras );
ImGui::MenuItem( "Bounds", nullptr, &gd->drawBounds );
ImGui::MenuItem( "Mass", nullptr, &gd->drawMass );
ImGui::MenuItem( "Sleep", nullptr, &gd->drawSleep );
ImGui::MenuItem( "Body Names", nullptr, &gd->drawBodyNames );
ImGui::MenuItem( "Graph Colors", nullptr, &gd->drawGraphColors );
ImGui::MenuItem( "Islands", nullptr, &gd->drawIslands );
ImGui::Separator();
ImGui::MenuItem( "Contact Points", nullptr, &gd->drawContacts );
ImGui::MenuItem( "Contact Normals", nullptr, &gd->drawContactNormals );
ImGui::MenuItem( "Contact Features", nullptr, &gd->drawContactFeatures );
ImGui::MenuItem( "Contact Forces", nullptr, &gd->drawContactForces );
if ( ImGui::BeginMenu( "Anchor" ) )
{
if ( ImGui::MenuItem( "Anchor A", nullptr, gd->drawAnchorA == true ) )
{
gd->drawAnchorA = true;
}
if ( ImGui::MenuItem( "Anchor B", nullptr, gd->drawAnchorA == false ) )
{
gd->drawAnchorA = false;
}
ImGui::EndMenu();
}
ImGui::Separator();
ImGui::MenuItem( "Metrics", "M", &context->showMetrics );
ImGui::MenuItem( "Profile", "I", &context->showProfile, context->sample->HasProfile() );
ImGui::PushItemWidth( 8.0f * fontSize );
ImGui::SliderFloat( "Draw Distance", &context->drawDistance, 10.0f, Camera::kViewDistance, "%.0f m" );
ImGui::PopItemWidth();
ImGui::Separator();
if ( ImGui::BeginMenu( "Scale" ) )
{
ImGui::PushItemWidth( 6.0f * fontSize );
ImGui::InputFloat( "Joint", &gd->jointScale );
ImGui::InputFloat( "Force", &gd->forceScale, 0, 0, "%.6f", ImGuiInputTextFlags_CharsScientific );
ImGui::PopItemWidth();
ImGui::EndMenu();
}
ImGui::EndMenu();
}
if ( ImGui::BeginMenu( "Render" ) )
{
DrawRenderMenu( *context );
ImGui::EndMenu();
}
if ( ImGui::BeginMenu( "Samples" ) )
{
int i = 0;
while ( i < g_sampleCount )
{
const char* category = g_sampleEntries[i].Category;
if ( ImGui::BeginMenu( category ) )
{
while ( i < g_sampleCount && strcmp( category, g_sampleEntries[i].Category ) == 0 )
{
bool selected = ( i == context->sampleIndex );
if ( ImGui::MenuItem( g_sampleEntries[i].Name, nullptr, selected ) )
{
SelectSample( context, i, false );
}
++i;
}
ImGui::EndMenu();
}
else
{
while ( i < g_sampleCount && strcmp( category, g_sampleEntries[i].Category ) == 0 )
{
++i;
}
}
}
ImGui::EndMenu();
}
// Only present once the replay viewer is registered. Open pops a native picker, then hands
// the chosen file to the viewer through replayFile.
if ( g_replayIndex >= 0 && ImGui::BeginMenu( "Replay" ) )
{
if ( ImGui::MenuItem( "Open..." ) )
{
// Defer the native picker to the top of the next frame. Running it
// here would block on a nested run loop mid-frame (after the buffers
// were uploaded and the ImGui frame began), re-entering the render
// loop. See OpenReplayFileDialog and SampleContext::openReplayPicker.
context->openReplayPicker = true;
}
ImGui::EndMenu();
}
static bool showAbout = false;
if ( ImGui::BeginMenu( "Help" ) )
{
ImGui::MenuItem( "Controls", "?", &context->showControls );
ImGui::MenuItem( "About", nullptr, &showAbout );
ImGui::EndMenu();
}
ImGui::EndMainMenuBar();
if ( context->showControls )
{
ImGui::SetNextWindowPos( { context->camera.m_width * 0.5f, context->camera.m_height * 0.35f }, ImGuiCond_Appearing,
{ 0.5f, 0.5f } );
ImGui::SetNextWindowSize( { 26.0f * fontSize, 0.0f }, ImGuiCond_Appearing );
if ( ImGui::Begin( "Controls", &context->showControls,
ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize ) )
{
ImGui::SeparatorText( "Keyboard" );
if ( ImGui::BeginTable( "keys", 2, ImGuiTableFlags_SizingFixedFit ) )
{
DrawRow( "Tab", "Show / hide UI" );
DrawRow( "Shift+Tab", "Show / hide UI and text" );
DrawRow( "M", "Show / hide metrics" );
DrawRow( "I", "Show / hide profile" );
DrawRow( "P", "Pause / resume" );
DrawRow( ".", "Single step (Shift: 5)" );
DrawRow( ",", "Step back, replay only (Shift: 5)" );
DrawRow( "R", "Restart sample" );
DrawRow( "[ ]", "Previous / next sample" );
DrawRow( "Ctrl+O", "Open sample picker" );
DrawRow( "F", "Frame selection" );
DrawRow( "Home", "Reset camera" );
DrawRow( "?", "Show / hide controls" );
DrawRow( "Esc", "Cancel / close" );
DrawRow( "Ctrl+Q", "Quit" );
ImGui::EndTable();
}
ImGui::SeparatorText( "Mouse" );
if ( ImGui::BeginTable( "mouse", 2, ImGuiTableFlags_SizingFixedFit ) )
{
DrawRow( "Left click", "Select body/shape" );
DrawRow( "Ctrl + left drag", "Move bodies (mouse joint)" );
DrawRow( "Alt + left drag", "Orbit camera" );
DrawRow( "Alt + middle drag", "Pan camera" );
DrawRow( "Alt + right drag", "Zoom (dolly)" );
DrawRow( "Right drag", "Fly look (WASD, Q / E to move)" );
DrawRow( "Scroll", "Zoom" );
DrawRow( "Shift + left", "Shoot (Ctrl spin, Alt ragdoll)" );
ImGui::EndTable();
}
}
ImGui::End();
}
if ( showAbout )
{
ImGui::SetNextWindowPos( { context->camera.m_width * 0.5f, context->camera.m_height * 0.5f }, ImGuiCond_Appearing,
{ 0.5f, 0.5f } );
ImGui::SetNextWindowSize( { 22.0f * fontSize, 0.0f }, ImGuiCond_Appearing );
if ( ImGui::Begin( "About", &showAbout, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_AlwaysAutoResize ) )
{
b3Version version = b3GetVersion();
ImGui::Text( "Box3D %d.%d.%d", version.major, version.minor, version.revision );
ImGui::Spacing();
ImGui::TextLinkOpenURL( "github.com/erincatto/box3d", "https://github.com/erincatto/box3d" );
}
ImGui::End();
}
}
}
static void DrawSamplePicker( SampleContext* context )
{
float fontSize = ImGui::GetFontSize();
// Opens a transient popup; type to filter by name or category, Up/Down to
// navigate, Enter to select, Esc / click-outside to dismiss.
static char query[64] = {};
static char prevQuery[64] = {};
static int highlight = 0;
static int prevHighlight = 0;
static int filtered[MAX_SAMPLES];
static int filteredCount = 0;
static bool justOpened = false;
static bool forceScroll = false;
if ( context->openSamplePicker )
{
ImGui::OpenPopup( "##sample_picker" );
context->openSamplePicker = false;
query[0] = '\0';
prevQuery[0] = '\0';
highlight = 0;
prevHighlight = 0;
RebuildPicker( query, filtered, &filteredCount );
justOpened = true;
forceScroll = true;
}
ImGui::SetNextWindowPos( { context->camera.m_width * 0.5f, context->camera.m_height * 0.35f }, ImGuiCond_Appearing,
{ 0.5f, 0.5f } );
ImGui::SetNextWindowSize( { 32.0f * fontSize, 0.0f }, ImGuiCond_Appearing );
if ( ImGui::BeginPopup( "##sample_picker",
ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoSavedSettings ) )
{
if ( justOpened )
{
ImGui::SetKeyboardFocusHere();
justOpened = false;
}
ImGui::PushItemWidth( -1.0f );
ImGui::InputTextWithHint( "##q", "Search by name or category...", query, sizeof( query ) );
ImGui::PopItemWidth();
if ( strcmp( query, prevQuery ) != 0 )
{
RebuildPicker( query, filtered, &filteredCount );
strncpy( prevQuery, query, sizeof( prevQuery ) );
prevQuery[sizeof( prevQuery ) - 1] = '\0';
highlight = 0;
forceScroll = true;
}
if ( filteredCount > 0 )
{
if ( ImGui::IsKeyPressed( ImGuiKey_DownArrow, true ) )
{
highlight = ( highlight + 1 ) % filteredCount;
}
if ( ImGui::IsKeyPressed( ImGuiKey_UpArrow, true ) )
{
highlight = ( highlight + filteredCount - 1 ) % filteredCount;
}
}
bool commit = ImGui::IsKeyPressed( ImGuiKey_Enter, false ) || ImGui::IsKeyPressed( ImGuiKey_KeypadEnter, false );
ImGui::BeginChild( "##results", { 0.0f, 14.0f * fontSize }, ImGuiChildFlags_Borders );
for ( int row = 0; row < filteredCount; ++row )
{
int i = filtered[row];
char label[160];
snprintf( label, sizeof( label ), "%s > %s", g_sampleEntries[i].Category, g_sampleEntries[i].Name );
bool sel = ( row == highlight );
if ( ImGui::Selectable( label, sel ) )
{
highlight = row;
commit = true;
}
if ( sel && ( forceScroll || highlight != prevHighlight ) )
{
ImGui::SetScrollHereY();
}
}
ImGui::EndChild();
prevHighlight = highlight;
forceScroll = false;
if ( commit && filteredCount > 0 )
{
SelectSample( context, filtered[highlight], false );
ImGui::CloseCurrentPopup();
}
// The active search field eats the first Esc, so dismiss here instead of
// relying on the popup's default nav close.
if ( ImGui::IsKeyPressed( ImGuiKey_Escape, false ) )
{
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
}
// A dot after the widget that reveals help on hover. Unlike a tooltip on the widget itself,
// it never covers the value being edited, and it is quieter than a "(?)" on every row.
static void HelpMarker( const char* text )
{
ImGui::SameLine( 0.0f, ImGui::GetStyle().ItemInnerSpacing.x );
float width = ImGui::GetFontSize();
float height = ImGui::GetFrameHeight();
ImVec2 pos = ImGui::GetCursorScreenPos();
ImGui::Dummy( { width, height } );
bool hovered = ImGui::IsItemHovered();
ImU32 color = ImGui::GetColorU32( ImGuiCol_CheckMark, hovered ? 1.0f : 0.6f );
ImVec2 center = { pos.x + 0.5f * width, pos.y + 0.5f * height };
ImGui::GetWindowDrawList()->AddCircleFilled( center, 0.2f * width, color );
ImGui::SetItemTooltip( "%s", text );
}
static void DrawInfoPanel( SampleContext* context )
{
const SampleEntry& entry = g_sampleEntries[context->sampleIndex];
float fontSize = ImGui::GetFontSize();
float menuWidth = context->sample->InfoPanelWidthEm() * fontSize;
float menuBarHeight = ImGui::GetFrameHeight();
// Full-height panel pinned under the menu bar at the right edge, matching Box2D.
ImGui::SetNextWindowPos( { context->camera.m_width - menuWidth - 0.5f * fontSize, menuBarHeight + 0.5f * fontSize } );
ImGui::SetNextWindowSize( { menuWidth, context->camera.m_height - menuBarHeight - fontSize } );
ImGui::Begin( "Info", nullptr,
ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse |
ImGuiWindowFlags_NoTitleBar );
ImGui::TextColored( HexColor( b3_colorGoldenRod ), "%s", entry.Name );
ImGui::TextColored( HexColor( b3_colorLightGray ), "%s", entry.Category );
ImGui::Separator();
if ( context->pause )
{
ImGui::TextColored( HexColor( b3_colorRed ), "PAUSED" );
ImGui::SameLine();
ImGui::TextDisabled( "(p)" );
ImGui::Separator();
}
const float frameMs = (float)( sapp_frame_duration() * 1000.0 );
ImGui::TextColored( HexColor( b3_colorSeaGreen ), "frame %.1f ms", frameMs );
ImGui::TextColored( HexColor( b3_colorSeaGreen ), "step %d", context->sample->m_stepCount );
ImGui::Separator();
// The camera lives in display space, so pivot, radius and speed are in meters
// regardless of the simulation's length units.
b3Pos p = context->camera.m_pivot;
ImGui::TextColored( HexColor( b3_colorSeaGreen ), "pivot m (%.1f, %.1f, %.1f)", p.x, p.y, p.z );
float yawDeg = B3_RAD_TO_DEG * context->camera.m_yaw;
float pitchDeg = B3_RAD_TO_DEG * context->camera.m_pitch;
ImGui::TextColored( HexColor( b3_colorSeaGreen ), "yaw/pitch (%.1f, %.1f)", yawDeg, pitchDeg );
ImGui::TextColored( HexColor( b3_colorSeaGreen ), "radius m %.1f, speed m/s %.1f", context->camera.m_radius,
context->camera.m_speed );
ImGui::Separator();
ImGui::PushItemWidth( 6.0f * fontSize );
if ( context->sample->DrawControls() )
{
ImGui::Separator();
}
ImGui::PopItemWidth();
if ( context->sample->HasSolverControls() && ImGui::CollapsingHeader( "Solver", ImGuiTreeNodeFlags_DefaultOpen ) )
{
ImGui::PushItemWidth( 6.0f * fontSize );
ImGui::SliderInt( "Sub-steps##Solver", &context->subStepCount, 1, 50 );
HelpMarker( "The solver breaks the full step into several sub-steps.\nMore sub-steps usually lead to more accurate results." );
ImGui::SliderInt( "Bounce Iters##Solver", &context->restitutionIterations, 0, 8 );
HelpMarker( "Iterations for the restitution solver." );
ImGui::SliderFloat( "Hertz##Solver", &context->hertz, 5.0f, 240.0f, "%.0f Hz" );
HelpMarker( "The number of world steps per second." );
if ( ImGui::SliderInt( "Workers##Solver", &context->workerCount, 1, B3_MAX_WORKERS ) )
{
context->workerCount = b3ClampInt( context->workerCount, 1, B3_MAX_WORKERS );
SelectSample( context, context->sampleIndex, true );
}
HelpMarker( "The number worker threads used by the world step." );
float recyclingCentimeters = 100.0f * context->recycleDistance;
if ( ImGui::SliderFloat( "Recycle##Solver", &recyclingCentimeters, 0.0f, 10.0f, "%.1f cm" ) )
{
context->recycleDistance = 0.01f * recyclingCentimeters;
b3World_SetContactRecycleDistance( context->sample->m_worldId, context->recycleDistance );
}
HelpMarker( "The contact recycling distance tolerance.\nSet to zero to disable recycling." );
ImGui::PopItemWidth();
ImGui::Checkbox( "Sleep##Solver", &context->enableSleep );
HelpMarker( "Allow bodies to sleep, reducing simulation CPU cost." );
ImGui::Checkbox( "Warm Starting##Solver", &context->enableWarmStarting );
HelpMarker( "Enable solver warm starting which usually improves stacking stability." );
ImGui::Checkbox( "Continuous##Solver", &context->enableContinuous );
HelpMarker( "Enable continuous collision detection." );
ImGui::Checkbox( "Bounce Propagation##Solver", &context->enableRestitutionPropagation );
HelpMarker( "Enable restitution solver propagation across all touching contacts points" );
static bool avx2Available = b3IsAVX2Available();
if ( avx2Available )
{
ImGui::Checkbox( "SSE2 Fallback##Solver", &context->enableSSE2Fallback );
HelpMarker( "Use the 4 wide SSE2 path instead of the 8 wide AVX2 path.\nThe simulation is bitwise identical either way." );
}
if ( ImGui::Shortcut( ImGuiKey_R ) || ImGui::Button( "Restart" ) )
{
SelectSample( context, context->sampleIndex, true );
}
}
if ( context->sample->HasSolverControls() && ImGui::CollapsingHeader( "Recording", ImGuiTreeNodeFlags_DefaultOpen ) )
{
ImGui::PushItemWidth( 9.0f * fontSize );
ImGui::InputText( "File##Recording", context->recordingFile, sizeof( context->recordingFile ) );
ImGui::PopItemWidth();
if ( context->sample->m_recording == nullptr )
{
// Restart to a clean world then snapshot it at step 0, a whole session capture.
if ( ImGui::Button( "Record (restart)##Recording" ) )
{
SelectSample( context, context->sampleIndex, true );
context->sample->StartRecording();
}
// Snapshot the running world and log from here, the mid simulation case.
if ( ImGui::Button( "Record Now##Recording" ) )
{
context->sample->StartRecording();
}
if ( g_replayIndex >= 0 && context->savedRecordingFile[0] != 0 )
{
if ( ImGui::Button( "Play##Recording" ) )
{
snprintf( context->replayFile, sizeof( context->replayFile ), "%s", context->savedRecordingFile );
SelectSample( context, g_replayIndex, false );
}
ImGui::SetItemTooltip( "Open %s in the replay viewer", context->savedRecordingFile );
}
}
else
{
if ( ImGui::Button( "Stop##Recording" ) )
{
context->sample->FinishRecording();
}
}
if ( context->sample->m_recording != nullptr )
{
float kilobytes = b3Recording_GetSize( context->sample->m_recording ) / 1024.0f;
int steps = context->sample->m_stepCount - context->sample->m_recordStartStep;
if ( kilobytes < 1024.0f )
{
ImGui::TextColored( HexColor( b3_colorRed ), "recording %d steps, %.0f KB", steps, kilobytes );
}
else
{
ImGui::TextColored( HexColor( b3_colorRed ), "recording %d steps, %.1f MB", steps, kilobytes / 1024.0f );
}
}
}
ImGui::End();
}
// Minimal in-world HUD shown only when the UI is hidden: sample identity at the
// top-left, frame time and step count at the bottom-left. Matches Box2D DrawHud.
static void DrawHud( SampleContext* context )
{
const SampleEntry& entry = g_sampleEntries[context->sampleIndex];
float fontSize = ImGui::GetFontSize();
DrawScreenStringFormat( 5, (int)( 0.5f * fontSize ), MakeColor( b3_colorYellow ), "%s : %s", entry.Category, entry.Name );
if ( context->pause )
{
DrawScreenString( 5, (int)( 3.0f * fontSize ), MakeColor( b3_colorRed ), "****PAUSED****" );
}
DrawScreenStringFormat( 5, context->camera.m_height - (int)( 1.5f * fontSize ), MakeColor( b3_colorSeaGreen ),
"%.1f ms step %d", 1000.0f * (float)sapp_frame_duration(), context->sample->m_stepCount );
}
void DrawUI( SampleContext* context )
{
// Hidden shows only the minimal in-world HUD.
if ( context->showUI == false )
{
if ( context->showText )
{
DrawHud( context );
}
return;
}
DrawMenuBar( context );
DrawSamplePicker( context );
DrawInfoPanel( context );
// Extra top-level windows (the Replay viewer adds the Outline panel).
context->sample->DrawSampleWindows();
// Sample controls live in the info panel.
context->sample->DrawProfile();
context->sample->DrawMetrics();
}
void Sample::ToggleThirdPerson()
{
if ( m_camera->m_thirdPerson )
{
sapp_lock_mouse( false );
m_camera->m_thirdPerson = false;
}
else
{
sapp_lock_mouse( true );
m_camera->m_thirdPerson = true;
ClearSelection();
}
}
MoverInput Sample::GetMoverInput() const
{
MoverInput input = {};
input.forward = -m_camera->GetForward();
input.right = m_camera->GetRight();
input.forward.y = 0.0f;
input.forward = b3Normalize( input.forward );
if ( m_camera->m_thirdPerson == false )
{
return input;
}
if ( IsKeyDown( KEY_W ) )
{
input.throttle.x += 1.0f;
}
if ( IsKeyDown( KEY_S ) )
{
input.throttle.x -= 1.0f;
}
if ( IsKeyDown( KEY_A ) )
{
input.throttle.y -= 1.0f;
}
if ( IsKeyDown( KEY_D ) )
{
input.throttle.y += 1.0f;
}
input.jump = IsKeyDown( KEY_SPACE );
input.sprint = IsKeyDown( KEY_LEFT_SHIFT ) || IsKeyDown( KEY_RIGHT_SHIFT );
input.walk = IsKeyDown( KEY_LEFT_CONTROL ) || IsKeyDown( KEY_RIGHT_CONTROL );
return input;
}
float CastClosestCallback( b3ShapeId shapeId, b3Pos point, b3Vec3 normal, float fraction, uint64_t materialId, int triangleIndex,
int childIndex, void* context )
{
CastClosestContext* rayContext = (CastClosestContext*)context;
rayContext->shapeId = shapeId;
rayContext->point = point;
rayContext->normal = normal;
rayContext->fraction = fraction;
rayContext->materialId = materialId;
rayContext->childIndex = childIndex;
rayContext->triangleIndex = triangleIndex;
rayContext->hit = true;
return fraction;
}
MechanicalEnergy MeasureEnergy( b3WorldId worldId, const b3BodyId* bodyIds, int count )
{
b3Vec3 gravity = b3World_GetGravity( worldId );
MechanicalEnergy energy = {};
for ( int i = 0; i < count; ++i )
{
b3MassData massData = b3Body_GetMassData( bodyIds[i] );
b3Vec3 v = b3Body_GetLinearVelocity( bodyIds[i] );
// The inertia tensor is in the body frame, so bring the angular velocity back to it
b3Vec3 w = b3InvRotateVector( b3Body_GetRotation( bodyIds[i] ), b3Body_GetAngularVelocity( bodyIds[i] ) );
energy.linear += 0.5f * massData.mass * b3Dot( v, v );
energy.angular += 0.5f * b3Dot( w, b3MulMV( massData.inertia, w ) );
energy.potential -= massData.mass * b3Dot( gravity, b3ToVec3( b3Body_GetWorldCenter( bodyIds[i] ) ) );
}
return energy;
}