diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt index 7af976b..f4a61fa 100644 --- a/benchmark/CMakeLists.txt +++ b/benchmark/CMakeLists.txt @@ -34,7 +34,7 @@ if (NOT BUILD_SHARED_LIBS) endif() target_include_directories(mesh_soak PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../src) - target_link_libraries(mesh_soak PRIVATE box3d) + target_link_libraries(mesh_soak PRIVATE box3d shared) endif() # Headless Ghost Collisions sample. Counts ghost manifolds per scene and body. diff --git a/benchmark/mesh_soak.c b/benchmark/mesh_soak.c index ca06128..78798d4 100644 --- a/benchmark/mesh_soak.c +++ b/benchmark/mesh_soak.c @@ -3,34 +3,30 @@ // Headless soak of the Continuous / Mesh Drop sample. Each generation drops 1024 small bodies on a // wave mesh and steps until every body sleeps. A generation fails if a body falls through the mesh -// or the pile is still awake at the step limit. Generations run in parallel, one single threaded -// world per thread. The printed seed reproduces a generation in the sample. +// or the pile is still awake at the step limit. Tunnels are rare, so the soak also counts bodies that +// sink into the wave past a few depth levels and can compare those counts against a baseline. +// Generations run in parallel, one single threaded world per thread. The printed seed reproduces a +// generation in the sample. + +#define _CRT_SECURE_NO_WARNINGS #include "core.h" +#include "mesh_drop.h" #include "box3d/box3d.h" #include "box3d/collision.h" #include "box3d/math_functions.h" +#include +#include #include #include #include -#define GRID_COUNT 32 -#define BODY_COUNT ( GRID_COUNT * GRID_COUNT ) #define MAX_REPORTED_FAILURES 32 #define MAX_THREADS 64 - -typedef enum ShapeType -{ - e_box, - e_capsule, - e_cylinder, - e_sphere, - e_shapeCount, -} ShapeType; - -static const char* s_shapeNames[e_shapeCount] = { "box", "capsule", "cylinder", "sphere" }; +#define MAX_BASELINE_ROWS 64 +#define BASELINE_ROW_SIZE 512 typedef enum FailureKind { @@ -41,96 +37,51 @@ typedef enum FailureKind typedef struct Failure { FailureKind kind; - ShapeType shapeType; + MeshDropShape shape; int generation; uint32_t seed; int step; - int index1; - int index2; + int index; b3Pos position; } Failure; +typedef struct ShapeStats +{ + int generationCount; + int tunnelCount; + int awakeCount; + int depthCounts[MESH_DROP_DEPTH_LEVEL_COUNT]; + + float maxDepth; + uint32_t maxSeed; + int maxGeneration; + int maxIndex; + int maxStep; +} ShapeStats; + typedef struct Soak { b3Mutex* mutex; b3MeshData* groundMesh; b3HullData* cylinder; + MeshDropSettings settings; uint32_t baseSeed; int generationCount; int nextGeneration; - int shapeType; + + // -1 rotates through the shapes + int shapeFilter; + bool fixedSeed; int completedCount; int failureCount; - int tunnelCount; - int awakeCount; long long totalSteps; int maxSteps; + ShapeStats stats[e_meshDropShapeCount]; Failure failures[MAX_REPORTED_FAILURES]; } Soak; -// Same XorShift32 and mapping as the samples, so a seed replays there -static float RandomFloatRange( uint32_t* seed, float lo, float hi ) -{ - uint32_t x = *seed; - x ^= x << 13; - x ^= x >> 17; - x ^= x << 5; - *seed = x; - - int i = (int)( x % 32768 ); - float r = (float)( i & 32767 ) / 32767.0f; - return ( hi - lo ) * r + lo; -} - -static b3Vec3 RandomVec3Uniform( uint32_t* seed, float lo, float hi ) -{ - b3Vec3 v; - v.x = RandomFloatRange( seed, lo, hi ); - v.y = RandomFloatRange( seed, lo, hi ); - v.z = RandomFloatRange( seed, lo, hi ); - return v; -} - -static uint32_t HashSeed( uint32_t x ) -{ - x ^= x >> 16; - x *= 0x7feb352du; - x ^= x >> 15; - x *= 0x846ca68bu; - x ^= x >> 16; - return x != 0 ? x : 1; -} - -static void CreateGround( b3WorldId worldId, const b3MeshData* mesh ) -{ - b3BodyDef bodyDef = b3DefaultBodyDef(); - b3BodyId groundId = b3CreateBody( worldId, &bodyDef ); - - b3ShapeDef shapeDef = b3DefaultShapeDef(); - shapeDef.filter.categoryBits = 1; - b3CreateMeshShape( groundId, &shapeDef, mesh, b3Vec3_one ); - - float extent = 20.0f; - float halfHeight = 1.0f; - - b3Transform transforms[4] = { - { { 0.0f, halfHeight, -extent }, b3Quat_identity }, - { { 0.0f, halfHeight, extent }, b3Quat_identity }, - { { -extent, halfHeight, 0.0f }, b3Quat_identity }, - { { extent, halfHeight, 0.0f }, b3Quat_identity }, - }; - - for ( int i = 0; i < 4; ++i ) - { - float hx = i < 2 ? extent : 0.1f; - float hz = i < 2 ? 0.1f : extent; - b3BoxHull wallBox = b3MakeTransformedBoxHull( hx, halfHeight, hz, transforms[i] ); - b3CreateHullShape( groundId, &shapeDef, &wallBox.base ); - } -} - static void RecordFailure( Soak* soak, const Failure* failure ) { b3LockMutex( soak->mutex ); @@ -139,24 +90,18 @@ static void RecordFailure( Soak* soak, const Failure* failure ) soak->failures[soak->failureCount] = *failure; } soak->failureCount += 1; - if ( failure->kind == e_tunnel ) - { - soak->tunnelCount += 1; - } - else - { - soak->awakeCount += 1; - } b3UnlockMutex( soak->mutex ); const char* kind = failure->kind == e_tunnel ? "TUNNEL" : "AWAKE"; printf( "%s: generation %d, %s, seed %u, step %d, body (%d, %d) at (%.2f, %.2f, %.2f)\n", kind, failure->generation, - s_shapeNames[failure->shapeType], failure->seed, failure->step, failure->index1, failure->index2, - (float)failure->position.x, (float)failure->position.y, (float)failure->position.z ); + g_meshDropShapeNames[failure->shape], failure->seed, failure->step, failure->index / MESH_DROP_GRID_COUNT, + failure->index % MESH_DROP_GRID_COUNT, (float)failure->position.x, (float)failure->position.y, + (float)failure->position.z ); } -// Mirrors MeshDrop::Generate and the auto generate step loop -static int RunGeneration( Soak* soak, int generation, uint32_t seed, ShapeType shapeType, b3BodyId* bodies ) +// Mirrors MeshDrop::Generate and the auto generate step loop. Returns the step count. +static int RunGeneration( Soak* soak, int generation, uint32_t seed, MeshDropShape shape, b3BodyId* bodies, + MeshDropDepth* depth, int* failureKind ) { b3WorldDef worldDef = b3DefaultWorldDef(); worldDef.workerCount = 1; @@ -166,74 +111,34 @@ static int RunGeneration( Soak* soak, int generation, uint32_t seed, ShapeType s b3WorldId worldId = b3CreateWorld( &worldDef ); b3UnlockMutex( soak->mutex ); - CreateGround( worldId, soak->groundMesh ); + CreateMeshDropGround( worldId, soak->groundMesh ); - b3BoxHull box = b3MakeBoxHull( 0.02f, 0.2f, 0.04f ); - b3Capsule capsule = { { 0.0f, -0.2f, 0.0f }, { 0.0f, 0.2f, 0.0f }, 0.05f }; - b3Sphere sphere = { b3Vec3_zero, 0.05f }; - - b3BodyDef bodyDef = b3DefaultBodyDef(); - bodyDef.type = b3_dynamicBody; - - b3ShapeDef shapeDef = b3DefaultShapeDef(); - shapeDef.baseMaterial.rollingResistance = shapeType == e_capsule || shapeType == e_sphere ? 0.4f : 0.1f; - - // Isolate mesh collision - shapeDef.filter.categoryBits = 2; - shapeDef.filter.maskBits = 1; - - uint32_t random = seed; - int bodyIndex = 0; - for ( int i = 0; i < GRID_COUNT; ++i ) - { - for ( int j = 0; j < GRID_COUNT; ++j ) - { - b3Vec3 linearVelocity = RandomVec3Uniform( &random, -1.0f, 1.0f ); - b3Vec3 angularVelocity = RandomVec3Uniform( &random, -5.0f, 5.0f ); - - bodyDef.position = (b3Pos){ 0.5f * ( i - 0.5f * GRID_COUNT ), 5.0f, 0.5f * ( j - 0.5f * GRID_COUNT ) }; - bodyDef.linearVelocity = linearVelocity; - bodyDef.angularVelocity = angularVelocity; - b3BodyId bodyId = b3CreateBody( worldId, &bodyDef ); - - switch ( shapeType ) - { - case e_box: - b3CreateHullShape( bodyId, &shapeDef, &box.base ); - break; - case e_capsule: - b3CreateCapsuleShape( bodyId, &shapeDef, &capsule ); - break; - case e_cylinder: - b3CreateHullShape( bodyId, &shapeDef, soak->cylinder ); - break; - default: - b3CreateSphereShape( bodyId, &shapeDef, &sphere ); - break; - } - - bodies[bodyIndex++] = bodyId; - } - } + MeshDropSettings settings = soak->settings; + settings.shape = shape; + CreateMeshDropBodies( worldId, settings, seed, soak->cylinder, bodies ); + ResetMeshDropDepth( depth, settings, soak->cylinder ); float timeStep = 1.0f / 60.0f; int subStepCount = 4; - int maxSteps = shapeType == e_capsule ? 3000 : 1000; + int maxSteps = GetMeshDropStepLimit( shape ); + float tunnelHeight = GetMeshDropTunnelHeight(); int step = 0; bool failed = false; while ( failed == false ) { b3World_Step( worldId, timeStep, subStepCount ); + UpdateMeshDropDepth( worldId, depth ); step += 1; - for ( int i = 0; i < BODY_COUNT; ++i ) + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) { b3Pos center = b3Body_GetWorldCenter( bodies[i] ); - if ( center.y < -2.0f ) + if ( center.y < tunnelHeight ) { - Failure failure = { e_tunnel, shapeType, generation, seed, step, i / GRID_COUNT, i % GRID_COUNT, center }; + Failure failure = { e_tunnel, shape, generation, seed, step, i, center }; RecordFailure( soak, &failure ); + *failureKind = e_tunnel; failed = true; break; } @@ -247,7 +152,7 @@ static int RunGeneration( Soak* soak, int generation, uint32_t seed, ShapeType s if ( failed == false && step > maxSteps ) { int awakeIndex = 0; - for ( int i = 0; i < BODY_COUNT; ++i ) + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) { if ( b3Body_IsAwake( bodies[i] ) ) { @@ -257,8 +162,9 @@ static int RunGeneration( Soak* soak, int generation, uint32_t seed, ShapeType s } b3Pos center = b3Body_GetWorldCenter( bodies[awakeIndex] ); - Failure failure = { e_awake, shapeType, generation, seed, step, awakeIndex / GRID_COUNT, awakeIndex % GRID_COUNT, center }; + Failure failure = { e_awake, shape, generation, seed, step, awakeIndex, center }; RecordFailure( soak, &failure ); + *failureKind = e_awake; failed = true; } } @@ -273,7 +179,8 @@ static int RunGeneration( Soak* soak, int generation, uint32_t seed, ShapeType s static void SoakWorker( void* context ) { Soak* soak = context; - b3BodyId* bodies = malloc( BODY_COUNT * sizeof( b3BodyId ) ); + b3BodyId* bodies = malloc( MESH_DROP_BODY_COUNT * sizeof( b3BodyId ) ); + MeshDropDepth* depth = malloc( sizeof( MeshDropDepth ) ); while ( true ) { @@ -287,28 +194,247 @@ static void SoakWorker( void* context ) break; } - uint32_t seed = soak->fixedSeed ? soak->baseSeed : HashSeed( soak->baseSeed + (uint32_t)generation ); - ShapeType shapeType = soak->shapeType >= 0 ? (ShapeType)soak->shapeType : (ShapeType)( generation % e_shapeCount ); + uint32_t seed = soak->fixedSeed ? soak->baseSeed : GetMeshDropSeed( soak->baseSeed, generation ); + MeshDropShape shape = + soak->shapeFilter >= 0 ? (MeshDropShape)soak->shapeFilter : (MeshDropShape)( generation % e_meshDropShapeCount ); - int steps = RunGeneration( soak, generation, seed, shapeType, bodies ); + int failureKind = -1; + int steps = RunGeneration( soak, generation, seed, shape, bodies, depth, &failureKind ); + + int depthCounts[MESH_DROP_DEPTH_LEVEL_COUNT]; + GetMeshDropDepthCounts( depth, depthCounts ); b3LockMutex( soak->mutex ); soak->completedCount += 1; soak->totalSteps += steps; soak->maxSteps = b3MaxInt( soak->maxSteps, steps ); + + ShapeStats* stats = soak->stats + shape; + stats->generationCount += 1; + stats->tunnelCount += failureKind == e_tunnel ? 1 : 0; + stats->awakeCount += failureKind == e_awake ? 1 : 0; + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + stats->depthCounts[i] += depthCounts[i]; + } + + // Ties go to the earlier generation so the report does not depend on thread timing + if ( depth->maxDepth > stats->maxDepth || + ( depth->maxDepth == stats->maxDepth && generation < stats->maxGeneration ) ) + { + stats->maxDepth = depth->maxDepth; + stats->maxSeed = seed; + stats->maxGeneration = generation; + stats->maxIndex = depth->maxIndex; + stats->maxStep = depth->maxStep; + } + int completed = soak->completedCount; b3UnlockMutex( soak->mutex ); - if ( completed % 100 == 0 ) + if ( completed % b3MaxInt( 100, soak->generationCount / 10 ) == 0 ) { - printf( "%d generations, %d bodies\n", completed, completed * BODY_COUNT ); + printf( "%d generations, %d bodies\n", completed, completed * MESH_DROP_BODY_COUNT ); fflush( stdout ); } } + free( depth ); free( bodies ); } +static const char* GetFilterName( int shapeFilter ) +{ + return shapeFilter >= 0 ? g_meshDropShapeNames[shapeFilter] : "all"; +} + +// A baseline row starts with the run that made it, so one file can hold several runs +static void GetBaselineKey( const Soak* soak, char* key, int size ) +{ + snprintf( key, size, "%s,%u,%d,", GetFilterName( soak->shapeFilter ), soak->baseSeed, soak->generationCount ); +} + +// Replaces the rows of this run and keeps the rest +static void WriteBaseline( const Soak* soak, const char* path ) +{ + char key[64]; + GetBaselineKey( soak, key, sizeof( key ) ); + size_t keyLength = strlen( key ); + + char* rows = malloc( MAX_BASELINE_ROWS * BASELINE_ROW_SIZE ); + int rowCount = 0; + + FILE* file = fopen( path, "r" ); + if ( file != NULL ) + { + char line[BASELINE_ROW_SIZE]; + bool header = true; + while ( fgets( line, sizeof( line ), file ) != NULL ) + { + if ( header == false && strncmp( line, key, keyLength ) != 0 && rowCount < MAX_BASELINE_ROWS ) + { + snprintf( rows + rowCount * BASELINE_ROW_SIZE, BASELINE_ROW_SIZE, "%s", line ); + rowCount += 1; + } + + header = false; + } + + fclose( file ); + } + + file = fopen( path, "w" ); + if ( file == NULL ) + { + printf( "cannot write %s\n", path ); + free( rows ); + return; + } + + fprintf( file, "filter,base,generations,shape,tunnels,awake" ); + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + fprintf( file, ",depth%g", g_meshDropDepthLevels[i] ); + } + fprintf( file, "\n" ); + + for ( int i = 0; i < rowCount; ++i ) + { + fputs( rows + i * BASELINE_ROW_SIZE, file ); + } + + free( rows ); + + for ( int shape = 0; shape < e_meshDropShapeCount; ++shape ) + { + const ShapeStats* stats = soak->stats + shape; + if ( stats->generationCount == 0 ) + { + continue; + } + + fprintf( file, "%s,%u,%d,%s,%d,%d", GetFilterName( soak->shapeFilter ), soak->baseSeed, soak->generationCount, + g_meshDropShapeNames[shape], stats->tunnelCount, stats->awakeCount ); + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + fprintf( file, ",%d", stats->depthCounts[i] ); + } + fprintf( file, "\n" ); + } + + fclose( file ); + printf( "wrote %s\n", path ); +} + +// Returns 0 when no count grew past its noise band, 1 when one did, 2 when the baseline has no rows for this run +static int CompareBaseline( const Soak* soak, const char* path ) +{ + FILE* file = fopen( path, "r" ); + if ( file == NULL ) + { + printf( "cannot read %s\n", path ); + return 2; + } + + char line[512]; + if ( fgets( line, sizeof( line ), file ) == NULL ) + { + fclose( file ); + printf( "empty baseline %s\n", path ); + return 2; + } + + int result = 0; + int changedCount = 0; + int matchedCount = 0; + + while ( fgets( line, sizeof( line ), file ) != NULL ) + { + char filter[32]; + char shapeName[32]; + unsigned int base; + int generations; + int counts[2 + MESH_DROP_DEPTH_LEVEL_COUNT]; + + _Static_assert( MESH_DROP_DEPTH_LEVEL_COUNT == 4, "update the baseline row format" ); + int fieldCount = sscanf( line, "%31[^,],%u,%d,%31[^,],%d,%d,%d,%d,%d,%d", filter, &base, &generations, shapeName, + counts + 0, counts + 1, counts + 2, counts + 3, counts + 4, counts + 5 ); + if ( fieldCount != 10 ) + { + continue; + } + + if ( strcmp( filter, GetFilterName( soak->shapeFilter ) ) != 0 || base != soak->baseSeed || + generations != soak->generationCount ) + { + continue; + } + + int shape = -1; + for ( int i = 0; i < e_meshDropShapeCount; ++i ) + { + if ( strcmp( shapeName, g_meshDropShapeNames[i] ) == 0 ) + { + shape = i; + } + } + + if ( shape < 0 ) + { + continue; + } + + matchedCount += 1; + + const ShapeStats* stats = soak->stats + shape; + int current[2 + MESH_DROP_DEPTH_LEVEL_COUNT] = { stats->tunnelCount, stats->awakeCount }; + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + current[2 + i] = stats->depthCounts[i]; + } + + for ( int i = 0; i < 2 + MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + if ( current[i] == counts[i] ) + { + continue; + } + + // Any collision change reshuffles the chaotic pile, so a count moves by about its square root + // even when nothing got worse. Flag growth past three of those. A count that was zero flags on any + // growth, since a good build never sinks that deep. + float band = 3.0f * sqrtf( (float)counts[i] ); + bool regressed = i < 2 ? current[i] > counts[i] : current[i] > counts[i] + band; + + char column[32]; + if ( i < 2 ) + { + snprintf( column, sizeof( column ), i == 0 ? "tunnels" : "awake" ); + } + else + { + snprintf( column, sizeof( column ), "> %g slop", g_meshDropDepthLevels[i - 2] ); + } + + printf( " %-9s %-11s %d>%d%s\n", shapeName, column, counts[i], current[i], regressed ? " GREW" : "" ); + changedCount += 1; + result = regressed ? 1 : result; + } + } + + fclose( file ); + + if ( matchedCount == 0 ) + { + printf( "%s has no rows for -s=%s -b=%u -g=%d\n", path, GetFilterName( soak->shapeFilter ), soak->baseSeed, + soak->generationCount ); + return 2; + } + + printf( "compared with %s: %d changed, %s\n", path, changedCount, result == 0 ? "none grew past noise" : "GREW" ); + return result; +} + static const char* MatchValue( const char* arg, const char* shortName, const char* longName ) { size_t shortLength = strlen( shortName ); @@ -330,10 +456,12 @@ int main( int argc, char** argv ) { int generationCount = 1000; int threadCount = 8; - int shapeType = e_box; + int shapeFilter = e_meshDropBox; uint32_t seed = (uint32_t)b3GetTicks(); bool fixedSeed = false; - float amplitude = 0.5f; + const char* writePath = NULL; + const char* comparePath = NULL; + MeshDropSettings settings = GetDefaultMeshDropSettings(); for ( int i = 1; i < argc; ++i ) { @@ -350,21 +478,21 @@ int main( int argc, char** argv ) } else if ( ( value = MatchValue( arg, "-s=", "--shape=" ) ) != NULL ) { - shapeType = -2; - for ( int k = 0; k < e_shapeCount; ++k ) + shapeFilter = -2; + for ( int k = 0; k < e_meshDropShapeCount; ++k ) { - if ( strcmp( value, s_shapeNames[k] ) == 0 ) + if ( strcmp( value, g_meshDropShapeNames[k] ) == 0 ) { - shapeType = k; + shapeFilter = k; } } if ( strcmp( value, "all" ) == 0 ) { - shapeType = -1; + shapeFilter = -1; } - if ( shapeType == -2 ) + if ( shapeFilter == -2 ) { printf( "unknown shape: %s\n", value ); return 2; @@ -381,37 +509,61 @@ int main( int argc, char** argv ) } else if ( ( value = MatchValue( arg, "-a=", "--amplitude=" ) ) != NULL ) { - amplitude = (float)atof( value ); + settings.amplitude = (float)atof( value ); + } + else if ( ( value = MatchValue( arg, "-w=", "--write=" ) ) != NULL ) + { + writePath = value; + } + else if ( ( value = MatchValue( arg, "-c=", "--compare=" ) ) != NULL ) + { + comparePath = value; } else { printf( "Usage: mesh_soak [options]\n" "Drops %d bodies per generation on the Mesh Drop wave mesh until they sleep.\n" "Fails on a body below y = -2 (tunnel) or a pile awake past the step limit.\n" + "Counts bodies that sink into the wave deeper than each depth level.\n" " -g, --generations= generation count (default 1000)\n" " -t, --threads= worker threads, one world each (default 8)\n" " -s, --shape= box, capsule, cylinder, sphere or all (default box)\n" - " -b, --base-seed= base seed, each generation hashes its own seed from it\n" + " -b, --base-seed= base seed, each generation hashes its own seed from it (default random)\n" " --seed= run every generation with this exact seed (replay)\n" " -a, --amplitude= wave amplitude (default 0.5)\n" - "Exit code is 0 when every generation passes, 1 otherwise.\n", - BODY_COUNT ); + " -w, --write= write the counts as a baseline, replacing only the rows of this run\n" + " -c, --compare= compare the counts with the baseline rows from the same -s, -b and -g\n" + "Exit code is 0 when every generation passes and no count grew past noise, 1 otherwise,\n" + "2 for bad arguments or a baseline from a different run.\n", + MESH_DROP_BODY_COUNT ); return 2; } } + if ( fixedSeed && ( writePath != NULL || comparePath != NULL ) ) + { + printf( "a baseline needs a base seed, not --seed\n" ); + return 2; + } + Soak soak = { 0 }; soak.mutex = b3CreateMutex(); - soak.groundMesh = b3CreateWaveMesh( 40, 40, 1.0f, amplitude, 0.1f, 0.2f ); - soak.cylinder = b3CreateCylinder( 0.4f, 0.05f, 0.0f, 6 ); + soak.settings = settings; + soak.groundMesh = CreateMeshDropMesh( settings.amplitude ); + soak.cylinder = CreateMeshDropCylinder(); soak.baseSeed = seed; soak.fixedSeed = fixedSeed; soak.generationCount = generationCount; - soak.shapeType = shapeType; + soak.shapeFilter = shapeFilter; - const char* shapeName = shapeType >= 0 ? s_shapeNames[shapeType] : "all"; - printf( "mesh soak: %d generations, %d threads, shape %s, %s seed %u\n", generationCount, threadCount, shapeName, - fixedSeed ? "fixed" : "base", seed ); + for ( int i = 0; i < e_meshDropShapeCount; ++i ) + { + soak.stats[i].maxDepth = -FLT_MAX; + soak.stats[i].maxGeneration = INT32_MAX; + } + + printf( "mesh soak: %d generations, %d threads, shape %s, %s seed %u\n", generationCount, threadCount, + GetFilterName( shapeFilter ), fixedSeed ? "fixed" : "base", seed ); fflush( stdout ); uint64_t ticks = b3GetTicks(); @@ -429,24 +581,71 @@ int main( int argc, char** argv ) float seconds = 0.001f * b3GetMilliseconds( ticks ); double averageSteps = soak.completedCount > 0 ? (double)soak.totalSteps / soak.completedCount : 0.0; + float slop = B3_LINEAR_SLOP; - printf( "generations: %d, bodies: %d, tunnels: %d, awake: %d\n", soak.completedCount, soak.completedCount * BODY_COUNT, - soak.tunnelCount, soak.awakeCount ); - printf( "steps to sleep: average %.0f, max %d, time %.1f s\n", averageSteps, soak.maxSteps, seconds ); + printf( "\n%-9s %8s %8s %6s", "shape", "bodies", "tunnels", "awake" ); + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + char label[32]; + snprintf( label, sizeof( label ), "> %g slop", g_meshDropDepthLevels[i] ); + printf( " %10s", label ); + } + printf( " deepest\n" ); + + for ( int shape = 0; shape < e_meshDropShapeCount; ++shape ) + { + const ShapeStats* stats = soak.stats + shape; + if ( stats->generationCount == 0 ) + { + continue; + } + + printf( "%-9s %8d %8d %6d", g_meshDropShapeNames[shape], stats->generationCount * MESH_DROP_BODY_COUNT, + stats->tunnelCount, stats->awakeCount ); + for ( int i = 0; i < MESH_DROP_DEPTH_LEVEL_COUNT; ++i ) + { + printf( " %10d", stats->depthCounts[i] ); + } + + if ( stats->maxIndex >= 0 ) + { + printf( " %.1f slop, seed %u body (%d, %d) step %d\n", stats->maxDepth / slop, stats->maxSeed, + stats->maxIndex / MESH_DROP_GRID_COUNT, stats->maxIndex % MESH_DROP_GRID_COUNT, stats->maxStep ); + } + else + { + printf( "\n" ); + } + } + + printf( "\nsteps to sleep: average %.0f, max %d, time %.1f s\n", averageSteps, soak.maxSteps, seconds ); int reported = b3MinInt( soak.failureCount, MAX_REPORTED_FAILURES ); for ( int i = 0; i < reported; ++i ) { Failure* f = soak.failures + i; - printf( " %s %s seed %u body (%d, %d)\n", f->kind == e_tunnel ? "tunnel" : "awake", s_shapeNames[f->shapeType], f->seed, - f->index1, f->index2 ); + printf( " %s %s seed %u body (%d, %d)\n", f->kind == e_tunnel ? "tunnel" : "awake", g_meshDropShapeNames[f->shape], + f->seed, f->index / MESH_DROP_GRID_COUNT, f->index % MESH_DROP_GRID_COUNT ); } - printf( soak.failureCount == 0 ? "PASS\n" : "FAIL\n" ); + int exitCode = soak.failureCount == 0 ? 0 : 1; + + if ( writePath != NULL ) + { + WriteBaseline( &soak, writePath ); + } + + if ( comparePath != NULL ) + { + int compareResult = CompareBaseline( &soak, comparePath ); + exitCode = b3MaxInt( exitCode, compareResult ); + } + + printf( exitCode == 0 ? "PASS\n" : "FAIL\n" ); b3DestroyHull( soak.cylinder ); b3DestroyMesh( soak.groundMesh ); b3DestroyMutex( soak.mutex ); - return soak.failureCount == 0 ? 0 : 1; + return exitCode; } diff --git a/benchmark/soak_baseline.csv b/benchmark/soak_baseline.csv new file mode 100644 index 0000000..f9601de --- /dev/null +++ b/benchmark/soak_baseline.csv @@ -0,0 +1,9 @@ +filter,base,generations,shape,tunnels,awake,depth4,depth8,depth16,depth32 +all,12345,1000,box,0,0,1386,213,2,0 +all,12345,1000,capsule,0,0,14474,3477,28,0 +all,12345,1000,cylinder,0,0,10741,2305,35,0 +all,12345,1000,sphere,0,0,56,0,0,0 +all,12345,16000,box,0,0,21423,3126,42,0 +all,12345,16000,capsule,0,0,231138,54408,513,0 +all,12345,16000,cylinder,0,0,172961,36766,453,0 +all,12345,16000,sphere,0,0,989,0,0,0 diff --git a/samples/sample_continuous.cpp b/samples/sample_continuous.cpp index 81de7aa..fc4d506 100644 --- a/samples/sample_continuous.cpp +++ b/samples/sample_continuous.cpp @@ -4,6 +4,7 @@ #include "gfx/debug_adapter.h" #include "gfx/draw.h" #include "imgui.h" +#include "mesh_drop.h" #include "sample.h" #include "utils.h" @@ -387,38 +388,9 @@ public: static int sampleNeedleMesh = RegisterSample( "Continuous", "Needle Mesh", NeedleMesh::Create ); -struct IndexPair -{ - int index1; - int index2; -}; - -static inline IndexPair ConvertToPair( void* userData ) -{ - static_assert( sizeof( intptr_t ) >= 8 && sizeof( int ) == 4 ); - intptr_t value = (intptr_t)userData; - int index1 = (int)value; - int index2 = (int)( value >> 32 ); - return { index1, index2 }; -} - -static inline void* ConvertToUserData( IndexPair pair ) -{ - intptr_t value = (intptr_t)pair.index2 << 32 | (intptr_t)pair.index1; - return (void*)value; -} - class MeshDrop : public Sample { public: - enum ShapeType - { - e_box, - e_capsule, - e_cylinder, - e_sphere, - }; - explicit MeshDrop( SampleContext* context ) : Sample( context ) { @@ -428,20 +400,21 @@ public: GetGuiDraw()->forceScale = 0.1f; } + m_settings = GetDefaultMeshDropSettings(); m_groundId = b3_nullBodyId; m_groundMesh = nullptr; - m_groundAmplitude = 0.5f; CreateGround(); - m_bodies = new b3BodyId[m_bodyCount]; - memset( m_bodies, 0, m_bodyCount * sizeof( b3BodyId ) ); + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) + { + m_bodies[i] = b3_nullBodyId; + } - m_cylinder = b3CreateCylinder( 0.4f, 0.05f, 0.0f, 6 ); - m_shapeType = e_box; + m_cylinder = CreateMeshDropCylinder(); + m_seed = 0; m_runCount = 0; m_failure = false; m_autoGenerate = false; - m_collide = false; m_stepWhilePaused = true; Generate(); @@ -449,7 +422,6 @@ public: ~MeshDrop() override { - delete[] m_bodies; b3DestroyHull( m_cylinder ); b3DestroyMesh( m_groundMesh ); } @@ -468,58 +440,13 @@ public: m_groundMesh = nullptr; } - b3BodyDef bodyDef = b3DefaultBodyDef(); - m_groundId = b3CreateBody( m_worldId, &bodyDef ); - - int gridCount = 40; - float cellWidth = 1.0f; - float rowHz = 0.1f; - float columnHz = 0.2f; - - m_groundMesh = b3CreateWaveMesh( gridCount, gridCount, cellWidth, m_groundAmplitude, rowHz, columnHz ); - b3ShapeDef shapeDef = b3DefaultShapeDef(); - shapeDef.filter.categoryBits = 1; - b3CreateMeshShape( m_groundId, &shapeDef, m_groundMesh, b3Vec3_one ); - - float extent = 0.5f * gridCount * cellWidth; - float halfHeight = 1.0f; - - { - b3Transform transform; - transform.p = { 0.0f, halfHeight, -extent }; - transform.q = b3Quat_identity; - b3BoxHull wallBox = b3MakeTransformedBoxHull( extent, halfHeight, 0.1f, transform ); - b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base ); - } - - { - b3Transform transform; - transform.p = { 0.0f, halfHeight, extent }; - transform.q = b3Quat_identity; - b3BoxHull wallBox = b3MakeTransformedBoxHull( extent, halfHeight, 0.1f, transform ); - b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base ); - } - - { - b3Transform transform; - transform.p = { -extent, halfHeight, 0.0f }; - transform.q = b3Quat_identity; - b3BoxHull wallBox = b3MakeTransformedBoxHull( 0.1f, halfHeight, extent, transform ); - b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base ); - } - - { - b3Transform transform; - transform.p = { extent, halfHeight, 0.0f }; - transform.q = b3Quat_identity; - b3BoxHull wallBox = b3MakeTransformedBoxHull( 0.1f, halfHeight, extent, transform ); - b3CreateHullShape( m_groundId, &shapeDef, &wallBox.base ); - } + m_groundMesh = CreateMeshDropMesh( m_settings.amplitude ); + m_groundId = CreateMeshDropGround( m_worldId, m_groundMesh ); } void Generate() { - for ( int i = 0; i < m_bodyCount; ++i ) + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) { if ( B3_IS_NULL( m_bodies[i] ) ) { @@ -530,117 +457,53 @@ public: m_bodies[i] = b3_nullBodyId; } - // The soft contact solver cannot always resolve this small shape at 4 sub-steps. - // Also this small shape has trouble moving advancing in the time of impact code - // because the size is very close to the tolerances used. - // b3BoxHull box = b3MakeBoxHull( 0.01f, 0.1f, 0.02f ); - b3BoxHull box = b3MakeBoxHull( 0.02f, 0.2f, 0.04f ); - b3Capsule capsule = { { 0.0f, -0.2f, 0.0f }, { 0.0f, 0.2f, 0.0f }, 0.05f }; - b3Sphere sphere = { b3Vec3_zero, 0.05f }; - - int bodyIndex = 0; - - b3BodyDef bodyDef = b3DefaultBodyDef(); - bodyDef.type = b3_dynamicBody; - - b3ShapeDef shapeDef = b3DefaultShapeDef(); - if (m_shapeType == e_capsule || m_shapeType == e_sphere) - { - shapeDef.baseMaterial.rollingResistance = 0.4f; - } - else - { - shapeDef.baseMaterial.rollingResistance = 0.1f; - } - - // Don't allow shapes to collide with each other. This - // makes isolating failures easier. - if ( m_collide == false ) - { - shapeDef.filter.categoryBits = 2; - shapeDef.filter.maskBits = 1; - } - // A non-zero seed replays a generation reported by the mesh_soak tool - g_randomSeed = m_replaySeed != 0 ? m_replaySeed : (uint32_t)b3GetTicks(); - - bool simulateAll = false; - g_randomSeed = 2256131175; + m_seed = m_replaySeed != 0 ? m_replaySeed : (uint32_t)b3GetTicks(); m_runCount += 1; m_stepCount = 0; - printf( "run %d seed %u\n", m_runCount, g_randomSeed ); + printf( "run %d seed %u\n", m_runCount, m_seed ); - for ( int i = 0; i < m_gridCount; ++i ) + MeshDropSettings settings = m_settings; + if ( m_solo[0] >= 0 && m_solo[1] >= 0 ) { - for ( int j = 0; j < m_gridCount; ++j ) - { - b3Vec3 linearVelocity = RandomVec3Uniform( -1.0f, 1.0f ); - b3Vec3 angularVelocity = RandomVec3Uniform( -5.0f, 5.0f ); - - if ( simulateAll || ( i == 31 && j == 20 ) ) - { - bodyDef.position = { 0.5f * ( i - 0.5f * m_gridCount ), 5.0f, 0.5f * ( j - 0.5f * m_gridCount ) }; - bodyDef.linearVelocity = linearVelocity; - bodyDef.angularVelocity = angularVelocity; - // bodyDef.angularDamping = 0.1f; - bodyDef.userData = ConvertToUserData( { i, j } ); - b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef ); - - if ( m_shapeType == e_box ) - { - b3CreateHullShape( bodyId, &shapeDef, &box.base ); - } - else if ( m_shapeType == e_capsule ) - { - b3CreateCapsuleShape( bodyId, &shapeDef, &capsule ); - } - else if ( m_shapeType == e_cylinder ) - { - b3CreateHullShape( bodyId, &shapeDef, m_cylinder ); - } - else - { - b3CreateSphereShape( bodyId, &shapeDef, &sphere ); - } - - m_bodies[bodyIndex] = bodyId; - } - else - { - m_bodies[bodyIndex] = b3_nullBodyId; - } - bodyIndex += 1; - } + settings.soloIndex = MESH_DROP_GRID_COUNT * m_solo[0] + m_solo[1]; } - assert( bodyIndex == m_bodyCount ); + CreateMeshDropBodies( m_worldId, settings, m_seed, m_cylinder, m_bodies ); + ResetMeshDropDepth( &m_depth, settings, m_cylinder ); } bool DrawControls() override { - const char* shapeTypes[] = { "box", "capsule", "cylinder", "sphere" }; - int shapeType = (int)m_shapeType; - if ( ImGui::Combo( "Type", &shapeType, shapeTypes, IM_ARRAYSIZE( shapeTypes ) ) ) + int shapeType = (int)m_settings.shape; + if ( ImGui::Combo( "Type", &shapeType, g_meshDropShapeNames, e_meshDropShapeCount ) ) { m_stepCount = 0; - m_shapeType = ShapeType( shapeType ); + m_settings.shape = MeshDropShape( shapeType ); Generate(); } - if ( ImGui::SliderFloat( "Amplitude", &m_groundAmplitude, 0.0f, 1.0f ) ) + if ( ImGui::SliderFloat( "Amplitude", &m_settings.amplitude, 0.0f, 1.0f ) ) { CreateGround(); Generate(); } - if ( ImGui::Checkbox( "Collide", &m_collide ) ) + if ( ImGui::Checkbox( "Collide", &m_settings.collide ) ) { Generate(); } ImGui::InputScalar( "Seed", ImGuiDataType_U32, &m_replaySeed ); + // Drop only the body at these indices, -1 for all + if ( ImGui::InputInt2( "Solo", m_solo ) ) + { + m_solo[0] = b3ClampInt( m_solo[0], -1, MESH_DROP_GRID_COUNT - 1 ); + m_solo[1] = b3ClampInt( m_solo[1], -1, MESH_DROP_GRID_COUNT - 1 ); + } + if ( ImGui::Button( "Generate" ) ) { Generate(); @@ -657,8 +520,14 @@ public: void Step() override { + int stepCount = m_stepCount; Sample::Step(); + if ( m_stepCount != stepCount ) + { + UpdateMeshDropDepth( m_worldId, &m_depth ); + } + { PickRay pickRay = m_camera->BuildPickRay( m_context->mouseX, m_context->mouseY ); @@ -667,13 +536,25 @@ public: if ( result.hit ) { b3BodyId bodyId = b3Shape_GetBody( result.shapeId ); - void* userData = b3Body_GetUserData( bodyId ); - IndexPair pair = ConvertToPair( userData ); - DrawTextLine( "indices: (%d, %d)\n", pair.index1, pair.index2 ); + int index = GetMeshDropBodyIndex( b3Body_GetUserData( bodyId ) ); + if ( index >= 0 ) + { + DrawTextLine( "indices: (%d, %d)", index / MESH_DROP_GRID_COUNT, index % MESH_DROP_GRID_COUNT ); + } } } - for ( int i = 0; i < m_bodyCount && m_failure == false; i += 1 ) + DrawTextLine( "seed %u", m_seed ); + + if ( m_depth.maxIndex >= 0 ) + { + int index = m_depth.maxIndex; + DrawTextLine( "deepest: (%d, %d) %.1f slop at step %d", index / MESH_DROP_GRID_COUNT, index % MESH_DROP_GRID_COUNT, + m_depth.maxDepth / B3_LINEAR_SLOP, m_depth.maxStep ); + } + + float tunnelHeight = GetMeshDropTunnelHeight(); + for ( int i = 0; i < MESH_DROP_BODY_COUNT && m_failure == false; i += 1 ) { b3BodyId bodyId = m_bodies[i]; if ( B3_IS_NULL( bodyId ) ) @@ -682,19 +563,14 @@ public: } b3Pos massCenter = b3Body_GetWorldCenter( bodyId ); - if ( massCenter.y < -2.0f ) + if ( massCenter.y < tunnelHeight ) { - IndexPair pair = ConvertToPair( b3Body_GetUserData( bodyId ) ); - printf( "index1: %d - index2: %d\n", pair.index1, pair.index2 ); + printf( "index1: %d - index2: %d\n", i / MESH_DROP_GRID_COUNT, i % MESH_DROP_GRID_COUNT ); printf( "(%6.2f, %6.2f, %6.2f)\n", massCenter.x, massCenter.y, massCenter.z ); m_context->pause = true; m_failure = true; m_autoGenerate = false; } - - // This is for debugging the fallback inner sphere - // b3Sphere sphere = {massCenter, 0.015f}; - // DrawSphere( m_scene, b3Transform_identity, sphere, b3_colorLightGray ); } if ( m_autoGenerate ) @@ -719,13 +595,13 @@ public: for ( int i = 0; i < n; ++i ) { b3World_Step( m_worldId, timeStep, m_context->subStepCount ); + UpdateMeshDropDepth( m_worldId, &m_depth ); } m_stepCount += n; } - int maxSteps = m_shapeType == e_capsule ? 3000 : 1000; - if ( m_stepCount > maxSteps ) + if ( m_stepCount > GetMeshDropStepLimit( m_settings.shape ) ) { m_context->pause = true; m_failure = true; @@ -739,21 +615,18 @@ public: return new MeshDrop( context ); } - static constexpr int m_gridCount = 32; - // static constexpr int m_gridCount = 3; - static constexpr int m_bodyCount = m_gridCount * m_gridCount; - + MeshDropSettings m_settings; + MeshDropDepth m_depth; b3MeshData* m_groundMesh; - float m_groundAmplitude; b3BodyId m_groundId; b3HullData* m_cylinder; - b3BodyId* m_bodies; - ShapeType m_shapeType; + b3BodyId m_bodies[MESH_DROP_BODY_COUNT]; + uint32_t m_seed; int m_runCount; bool m_failure; bool m_autoGenerate; - bool m_collide; uint32_t m_replaySeed = 0; + int m_solo[2] = { -1, -1 }; }; static int sampleMeshDrop = RegisterSample( "Continuous", "Mesh Drop", MeshDrop::Create ); diff --git a/shared/CMakeLists.txt b/shared/CMakeLists.txt index bc47308..f09c241 100644 --- a/shared/CMakeLists.txt +++ b/shared/CMakeLists.txt @@ -9,6 +9,8 @@ set(BOX3D_SHARED_FILES ghost_collisions.h human.c human.h + mesh_drop.c + mesh_drop.h overflow_color.c overflow_color.h stability.c diff --git a/shared/mesh_drop.c b/shared/mesh_drop.c new file mode 100644 index 0000000..bf5df6e --- /dev/null +++ b/shared/mesh_drop.c @@ -0,0 +1,355 @@ +// SPDX-FileCopyrightText: 2026 Erin Catto +// SPDX-License-Identifier: MIT + +#include "mesh_drop.h" + +#include "box3d/box3d.h" + +#include +#include + +#define WAVE_CELL_WIDTH 1.0f +#define WAVE_ROW_FREQUENCY 0.1f +#define WAVE_COLUMN_FREQUENCY 0.2f +#define DROP_SPACING 0.5f +#define DROP_HEIGHT 5.0f +#define BODY_RADIUS 0.05f +#define CAPSULE_HALF_LENGTH 0.2f + +const char* g_meshDropShapeNames[e_meshDropShapeCount] = { "box", "capsule", "cylinder", "sphere" }; + +const float g_meshDropDepthLevels[MESH_DROP_DEPTH_LEVEL_COUNT] = { 4.0f, 8.0f, 16.0f, 32.0f }; + +// Same XorShift32 and mapping as the samples, but with local state so worlds can run on many threads +static float RandomFloatRange( uint32_t* state, float lo, float hi ) +{ + uint32_t x = *state; + x ^= x << 13; + x ^= x >> 17; + x ^= x << 5; + *state = x; + + int i = (int)( x % 32768 ); + float r = (float)( i & 32767 ) / 32767.0f; + return ( hi - lo ) * r + lo; +} + +static b3Vec3 RandomVec3Uniform( uint32_t* state, float lo, float hi ) +{ + b3Vec3 v; + v.x = RandomFloatRange( state, lo, hi ); + v.y = RandomFloatRange( state, lo, hi ); + v.z = RandomFloatRange( state, lo, hi ); + return v; +} + +static uint32_t HashSeed( uint32_t x ) +{ + x ^= x >> 16; + x *= 0x7feb352du; + x ^= x >> 15; + x *= 0x846ca68bu; + x ^= x >> 16; + return x != 0 ? x : 1; +} + +static b3BoxHull MakeDropBox( void ) +{ + // The soft contact solver cannot always resolve a smaller box at 4 sub-steps, and its size gets + // close to the time of impact tolerances + return b3MakeBoxHull( 0.02f, 0.2f, 0.04f ); +} + +MeshDropSettings GetDefaultMeshDropSettings( void ) +{ + MeshDropSettings settings = { + .shape = e_meshDropBox, + .amplitude = 0.5f, + .collide = false, + .soloIndex = -1, + }; + return settings; +} + +uint32_t GetMeshDropSeed( uint32_t baseSeed, int generation ) +{ + return HashSeed( HashSeed( baseSeed ) + (uint32_t)generation ); +} + +int GetMeshDropStepLimit( MeshDropShape shape ) +{ + return shape == e_meshDropCapsule ? 3000 : 1000; +} + +float GetMeshDropTunnelHeight( void ) +{ + return -2.0f; +} + +b3MeshData* CreateMeshDropMesh( float amplitude ) +{ + return b3CreateWaveMesh( MESH_DROP_WAVE_COUNT, MESH_DROP_WAVE_COUNT, WAVE_CELL_WIDTH, amplitude, WAVE_ROW_FREQUENCY, + WAVE_COLUMN_FREQUENCY ); +} + +b3HullData* CreateMeshDropCylinder( void ) +{ + return b3CreateCylinder( 0.4f, BODY_RADIUS, 0.0f, 6 ); +} + +b3BodyId CreateMeshDropGround( b3WorldId worldId, const b3MeshData* mesh ) +{ + b3BodyDef bodyDef = b3DefaultBodyDef(); + b3BodyId groundId = b3CreateBody( worldId, &bodyDef ); + + b3ShapeDef shapeDef = b3DefaultShapeDef(); + shapeDef.filter.categoryBits = 1; + b3CreateMeshShape( groundId, &shapeDef, mesh, b3Vec3_one ); + + float extent = 0.5f * MESH_DROP_WAVE_COUNT * WAVE_CELL_WIDTH; + float halfHeight = 1.0f; + + b3Transform transforms[4] = { + { { 0.0f, halfHeight, -extent }, b3Quat_identity }, + { { 0.0f, halfHeight, extent }, b3Quat_identity }, + { { -extent, halfHeight, 0.0f }, b3Quat_identity }, + { { extent, halfHeight, 0.0f }, b3Quat_identity }, + }; + + for ( int i = 0; i < 4; ++i ) + { + float hx = i < 2 ? extent : 0.1f; + float hz = i < 2 ? 0.1f : extent; + b3BoxHull wallBox = b3MakeTransformedBoxHull( hx, halfHeight, hz, transforms[i] ); + b3CreateHullShape( groundId, &shapeDef, &wallBox.base ); + } + + return groundId; +} + +void CreateMeshDropBodies( b3WorldId worldId, MeshDropSettings settings, uint32_t seed, const b3HullData* cylinder, + b3BodyId* bodies ) +{ + b3BoxHull box = MakeDropBox(); + b3Capsule capsule = { { 0.0f, -CAPSULE_HALF_LENGTH, 0.0f }, { 0.0f, CAPSULE_HALF_LENGTH, 0.0f }, BODY_RADIUS }; + b3Sphere sphere = { b3Vec3_zero, BODY_RADIUS }; + + b3BodyDef bodyDef = b3DefaultBodyDef(); + bodyDef.type = b3_dynamicBody; + + b3ShapeDef shapeDef = b3DefaultShapeDef(); + bool round = settings.shape == e_meshDropCapsule || settings.shape == e_meshDropSphere; + shapeDef.baseMaterial.rollingResistance = round ? 0.4f : 0.1f; + + if ( settings.collide == false ) + { + shapeDef.filter.categoryBits = 2; + shapeDef.filter.maskBits = 1; + } + + uint32_t state = seed; + int index = 0; + for ( int i = 0; i < MESH_DROP_GRID_COUNT; ++i ) + { + for ( int j = 0; j < MESH_DROP_GRID_COUNT; ++j ) + { + // Draw for every body so a solo body gets the same velocity it has in the full drop + b3Vec3 linearVelocity = RandomVec3Uniform( &state, -1.0f, 1.0f ); + b3Vec3 angularVelocity = RandomVec3Uniform( &state, -5.0f, 5.0f ); + + if ( settings.soloIndex >= 0 && settings.soloIndex != index ) + { + bodies[index] = b3_nullBodyId; + index += 1; + continue; + } + + bodyDef.position = (b3Pos){ DROP_SPACING * ( i - 0.5f * MESH_DROP_GRID_COUNT ), DROP_HEIGHT, + DROP_SPACING * ( j - 0.5f * MESH_DROP_GRID_COUNT ) }; + bodyDef.linearVelocity = linearVelocity; + bodyDef.angularVelocity = angularVelocity; + bodyDef.userData = (void*)(intptr_t)( index + 1 ); + b3BodyId bodyId = b3CreateBody( worldId, &bodyDef ); + + switch ( settings.shape ) + { + case e_meshDropBox: + b3CreateHullShape( bodyId, &shapeDef, &box.base ); + break; + case e_meshDropCapsule: + b3CreateCapsuleShape( bodyId, &shapeDef, &capsule ); + break; + case e_meshDropCylinder: + b3CreateHullShape( bodyId, &shapeDef, cylinder ); + break; + default: + b3CreateSphereShape( bodyId, &shapeDef, &sphere ); + break; + } + + bodies[index] = bodyId; + index += 1; + } + } +} + +int GetMeshDropBodyIndex( void* userData ) +{ + intptr_t value = (intptr_t)userData; + return 1 <= value && value <= MESH_DROP_BODY_COUNT ? (int)value - 1 : -1; +} + +void ResetMeshDropDepth( MeshDropDepth* depth, MeshDropSettings settings, const b3HullData* cylinder ) +{ + // Same heights as b3CreateWaveMesh + float omegaZ = 2.0f * B3_PI * WAVE_ROW_FREQUENCY * WAVE_CELL_WIDTH; + float omegaX = 2.0f * B3_PI * WAVE_COLUMN_FREQUENCY * WAVE_CELL_WIDTH; + int index = 0; + for ( int ix = 0; ix <= MESH_DROP_WAVE_COUNT; ++ix ) + { + float rowHeight = b3ComputeCosSin( omegaX * ix ).sine; + for ( int iz = 0; iz <= MESH_DROP_WAVE_COUNT; ++iz ) + { + float columnHeight = b3ComputeCosSin( omegaZ * iz ).sine; + depth->heights[index++] = settings.amplitude * rowHeight * columnHeight; + } + } + + depth->amplitude = fabsf( settings.amplitude ); + depth->probeCount = 0; + depth->radius = 0.0f; + + switch ( settings.shape ) + { + case e_meshDropBox: + case e_meshDropCylinder: + { + b3BoxHull box = MakeDropBox(); + const b3HullData* hull = settings.shape == e_meshDropBox ? &box.base : cylinder; + const b3Vec3* points = b3GetHullPoints( hull ); + int count = hull->vertexCount < MESH_DROP_MAX_PROBES ? hull->vertexCount : MESH_DROP_MAX_PROBES; + for ( int i = 0; i < count; ++i ) + { + depth->probes[i] = points[i]; + } + depth->probeCount = count; + } + break; + + case e_meshDropCapsule: + depth->probes[0] = (b3Vec3){ 0.0f, -CAPSULE_HALF_LENGTH, 0.0f }; + depth->probes[1] = (b3Vec3){ 0.0f, CAPSULE_HALF_LENGTH, 0.0f }; + depth->probeCount = 2; + depth->radius = BODY_RADIUS; + break; + + default: + depth->probes[0] = b3Vec3_zero; + depth->probeCount = 1; + depth->radius = BODY_RADIUS; + break; + } + + float maxLength = 0.0f; + for ( int i = 0; i < depth->probeCount; ++i ) + { + maxLength = fmaxf( maxLength, b3Length( depth->probes[i] ) ); + } + depth->boundingRadius = maxLength + depth->radius; + + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) + { + depth->bodyDepths[i] = -FLT_MAX; + } + + depth->maxDepth = -FLT_MAX; + depth->maxIndex = -1; + depth->maxStep = 0; + depth->stepCount = 0; +} + +// Signed distance to the plane of the wave triangle under the point. Exact away from the folds, where +// it reads a little deep on a crest and shallow in a valley. +static float GetWaveDistance( const MeshDropDepth* depth, b3Vec3 p ) +{ + float origin = -0.5f * MESH_DROP_WAVE_COUNT * WAVE_CELL_WIDTH; + float u = ( p.x - origin ) / WAVE_CELL_WIDTH; + float v = ( p.z - origin ) / WAVE_CELL_WIDTH; + int ix = b3ClampInt( (int)floorf( u ), 0, MESH_DROP_WAVE_COUNT - 1 ); + int iz = b3ClampInt( (int)floorf( v ), 0, MESH_DROP_WAVE_COUNT - 1 ); + + int stride = MESH_DROP_WAVE_COUNT + 1; + float ha = depth->heights[ix * stride + iz]; + float hb = depth->heights[ix * stride + iz + 1]; + float hc = depth->heights[( ix + 1 ) * stride + iz + 1]; + float hd = depth->heights[( ix + 1 ) * stride + iz]; + + // The cell diagonal runs from a to c, matching b3CreateWaveMesh + float w = WAVE_CELL_WIDTH; + b3Vec3 a = { origin + ix * w, ha, origin + iz * w }; + b3Vec3 ac = { w, hc - ha, w }; + b3Vec3 side = v - iz >= u - ix ? (b3Vec3){ 0.0f, hb - ha, w } : (b3Vec3){ w, hd - ha, 0.0f }; + b3Vec3 normal = b3Normalize( b3Cross( side, ac ) ); + if ( normal.y < 0.0f ) + { + normal = b3Neg( normal ); + } + + return b3Dot( normal, b3Sub( p, a ) ); +} + +void UpdateMeshDropDepth( b3WorldId worldId, MeshDropDepth* depth ) +{ + depth->stepCount += 1; + + b3BodyEvents events = b3World_GetBodyEvents( worldId ); + for ( int i = 0; i < events.moveCount; ++i ) + { + const b3BodyMoveEvent* event = events.moveEvents + i; + int index = GetMeshDropBodyIndex( event->userData ); + if ( index < 0 ) + { + continue; + } + + b3WorldTransform transform = event->transform; + if ( (float)transform.p.y - depth->boundingRadius > depth->amplitude ) + { + continue; + } + + float sink = -FLT_MAX; + for ( int j = 0; j < depth->probeCount; ++j ) + { + b3Pos point = b3TransformWorldPoint( transform, depth->probes[j] ); + b3Vec3 p = { (float)point.x, (float)point.y, (float)point.z }; + sink = fmaxf( sink, depth->radius - GetWaveDistance( depth, p ) ); + } + + if ( sink > depth->bodyDepths[index] ) + { + depth->bodyDepths[index] = sink; + } + + if ( sink > depth->maxDepth ) + { + depth->maxDepth = sink; + depth->maxIndex = index; + depth->maxStep = depth->stepCount; + } + } +} + +void GetMeshDropDepthCounts( const MeshDropDepth* depth, int counts[MESH_DROP_DEPTH_LEVEL_COUNT] ) +{ + for ( int level = 0; level < MESH_DROP_DEPTH_LEVEL_COUNT; ++level ) + { + float threshold = g_meshDropDepthLevels[level] * B3_LINEAR_SLOP; + int count = 0; + for ( int i = 0; i < MESH_DROP_BODY_COUNT; ++i ) + { + count += depth->bodyDepths[i] > threshold ? 1 : 0; + } + counts[level] = count; + } +} diff --git a/shared/mesh_drop.h b/shared/mesh_drop.h new file mode 100644 index 0000000..9c19dc0 --- /dev/null +++ b/shared/mesh_drop.h @@ -0,0 +1,115 @@ +// SPDX-FileCopyrightText: 2026 Erin Catto +// SPDX-License-Identifier: MIT +#pragma once + +#include "box3d/collision.h" +#include "box3d/id.h" +#include "box3d/math_functions.h" + +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +// Mesh Drop scene, shared by the Continuous / Mesh Drop sample and the headless mesh soak. A generation +// drops a grid of small bodies with random velocities on a wave mesh and steps until they sleep. A body +// that falls out of the world tunneled. The depth tracker measures how far each body sinks into the +// wave, which flags contact trouble far more often than tunnels do. + +typedef enum MeshDropShape +{ + e_meshDropBox, + e_meshDropCapsule, + e_meshDropCylinder, + e_meshDropSphere, + e_meshDropShapeCount +} MeshDropShape; + +#define MESH_DROP_GRID_COUNT 32 +#define MESH_DROP_BODY_COUNT ( MESH_DROP_GRID_COUNT * MESH_DROP_GRID_COUNT ) +#define MESH_DROP_DEPTH_LEVEL_COUNT 4 + +// Wave mesh cells along x and z +#define MESH_DROP_WAVE_COUNT 40 + +// Enough for the cylinder hull +#define MESH_DROP_MAX_PROBES 16 + +extern const char* g_meshDropShapeNames[e_meshDropShapeCount]; + +// Sink depth thresholds in linear slop +extern const float g_meshDropDepthLevels[MESH_DROP_DEPTH_LEVEL_COUNT]; + +typedef struct MeshDropSettings +{ + MeshDropShape shape; + float amplitude; + + // Let the bodies collide with each other. Off isolates mesh collision. + bool collide; + + // Create only this grid index, or -1 for all. Without body collision a body moves the same alone. + int soloIndex; +} MeshDropSettings; + +MeshDropSettings GetDefaultMeshDropSettings( void ); + +// Hashes the base before adding the generation, so nearby base seeds share no generations +uint32_t GetMeshDropSeed( uint32_t baseSeed, int generation ); + +// Steps a generation may take to fall asleep +int GetMeshDropStepLimit( MeshDropShape shape ); + +// A body below this height tunneled +float GetMeshDropTunnelHeight( void ); + +b3MeshData* CreateMeshDropMesh( float amplitude ); +b3HullData* CreateMeshDropCylinder( void ); + +// Creates a static body with the wave mesh and four walls +b3BodyId CreateMeshDropGround( b3WorldId worldId, const b3MeshData* mesh ); + +// Creates the bodies of one generation in grid order. Bodies left out by the solo index are null. The +// body user data encodes the grid index, see GetMeshDropBodyIndex. +void CreateMeshDropBodies( b3WorldId worldId, MeshDropSettings settings, uint32_t seed, const b3HullData* cylinder, + b3BodyId* bodies ); + +// Grid index from body user data, or -1 if the body is not part of the drop +int GetMeshDropBodyIndex( void* userData ); + +typedef struct MeshDropDepth +{ + // Wave heights at the mesh vertices + float heights[( MESH_DROP_WAVE_COUNT + 1 ) * ( MESH_DROP_WAVE_COUNT + 1 )]; + + // Collision points in the body frame, rounded by the radius + b3Vec3 probes[MESH_DROP_MAX_PROBES]; + int probeCount; + float radius; + float boundingRadius; + float amplitude; + + // Deepest sink of each body so far, positive when inside the wave + float bodyDepths[MESH_DROP_BODY_COUNT]; + + float maxDepth; + int maxIndex; + int maxStep; + int stepCount; +} MeshDropDepth; + +// Starts tracking a new generation +void ResetMeshDropDepth( MeshDropDepth* depth, MeshDropSettings settings, const b3HullData* cylinder ); + +// Call after each world step +void UpdateMeshDropDepth( b3WorldId worldId, MeshDropDepth* depth ); + +// Number of bodies that sank deeper than each depth level +void GetMeshDropDepthCounts( const MeshDropDepth* depth, int counts[MESH_DROP_DEPTH_LEVEL_COUNT] ); + +#ifdef __cplusplus +} +#endif