// SPDX-FileCopyrightText: 2026 Erin Catto // SPDX-License-Identifier: MIT #include "test_macros.h" // b3CollideMoverAndCompound, b3GetCompoundChild, b3QueryCompound are internal #include "compound.h" #include "box3d/box3d.h" #include "box3d/collision.h" #include "box3d/math_functions.h" #include #include #include #include static b3SurfaceMaterial MakeMaterial( float friction, uint64_t userId ) { b3SurfaceMaterial m = b3DefaultSurfaceMaterial(); m.friction = friction; m.userMaterialId = userId; return m; } static int CompoundCreateMixed( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundCapsuleDef capsules[1] = { { .capsule = { { -1.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f }, 0.25f }, .material = mat }, }; b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); b3CompoundHullDef hulls[1] = { { .hull = &box.base, .transform = b3Transform_identity, .material = mat }, }; b3MeshData* meshData = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundMeshDef meshes[1] = { { .meshData = meshData, .transform = b3Transform_identity, .scale = { 1.0f, 1.0f, 1.0f }, .materials = &mat, .materialCount = 1, }, }; b3CompoundSphereDef spheres[2] = { { .sphere = { { 5.0f, 0.0f, 0.0f }, 0.5f }, .material = mat }, { .sphere = { { -5.0f, 0.0f, 0.0f }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .capsules = capsules, .capsuleCount = 1, .hulls = hulls, .hullCount = 1, .meshes = meshes, .meshCount = 1, .spheres = spheres, .sphereCount = 2, }; b3CompoundData* compound = b3CreateCompound( &def ); ENSURE( compound != NULL ); ENSURE( compound->version == B3_COMPOUND_VERSION ); ENSURE( compound->byteCount > (int)sizeof( b3CompoundData ) ); ENSURE( compound->capsuleCount == 1 ); ENSURE( compound->hullCount == 1 ); ENSURE( compound->meshCount == 1 ); ENSURE( compound->sphereCount == 2 ); ENSURE( compound->materialCount == 1 ); ENSURE( compound->sharedHullCount == 1 ); ENSURE( compound->sharedMeshCount == 1 ); ENSURE( compound->tree.nodeEnd >= 2 ); ENSURE( compound->tree.proxyCount > 0 ); ENSURE( compound->tree.nodes != NULL ); ENSURE( compound->tree.proxies != NULL ); b3DestroyCompound( compound ); b3DestroyMesh( meshData ); return 0; } static int CompoundCreateSingleType( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); // Capsule only { b3CompoundCapsuleDef cap = { .capsule = { { 0, 0, 0 }, { 1, 0, 0 }, 0.5f }, .material = mat }; b3CompoundDef def = { .capsules = &cap, .capsuleCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c != NULL && c->capsuleCount == 1 && c->hullCount == 0 && c->meshCount == 0 && c->sphereCount == 0 ); b3DestroyCompound( c ); } // Hull only { b3BoxHull box = b3MakeBoxHull( 1, 1, 1 ); b3CompoundHullDef h = { .hull = &box.base, .transform = b3Transform_identity, .material = mat }; b3CompoundDef def = { .hulls = &h, .hullCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c != NULL && c->hullCount == 1 && c->sharedHullCount == 1 && c->capsuleCount == 0 ); b3DestroyCompound( c ); } // Mesh only { b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); b3CompoundMeshDef m = { .meshData = md, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1, }; b3CompoundDef def = { .meshes = &m, .meshCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c != NULL && c->meshCount == 1 && c->sharedMeshCount == 1 ); b3DestroyCompound( c ); b3DestroyMesh( md ); } // Sphere only { b3CompoundSphereDef s = { .sphere = { { 0, 0, 0 }, 1.0f }, .material = mat }; b3CompoundDef def = { .spheres = &s, .sphereCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c != NULL && c->sphereCount == 1 ); b3DestroyCompound( c ); } return 0; } static int CompoundMaterialDedup( void ) { b3SurfaceMaterial mat = MakeMaterial( 0.4f, 7 ); b3CompoundCapsuleDef caps[3]; for ( int i = 0; i < 3; ++i ) { caps[i].capsule = (b3Capsule){ { (float)i, 0, 0 }, { (float)i + 1, 0, 0 }, 0.25f }; caps[i].material = mat; } b3CompoundDef def = { .capsules = caps, .capsuleCount = 3 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->materialCount == 1 ); for ( int i = 0; i < 3; ++i ) { b3CompoundCapsule cc = b3GetCompoundCapsule( c, i ); ENSURE( cc.materialIndex == 0 ); } b3DestroyCompound( c ); return 0; } static int CompoundMaterialDistinct( void ) { b3CompoundCapsuleDef caps[3]; for ( int i = 0; i < 3; ++i ) { caps[i].capsule = (b3Capsule){ { (float)i, 0, 0 }, { (float)i + 1, 0, 0 }, 0.25f }; caps[i].material = MakeMaterial( 0.1f * (float)( i + 1 ), (uint64_t)( i + 1 ) ); } b3CompoundDef def = { .capsules = caps, .capsuleCount = 3 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->materialCount == 3 ); const b3SurfaceMaterial* mats = b3GetCompoundMaterials( c ); ENSURE( mats != NULL ); for ( int i = 0; i < 3; ++i ) { b3CompoundCapsule cc = b3GetCompoundCapsule( c, i ); ENSURE( cc.materialIndex < 3 ); ENSURE( mats[cc.materialIndex].userMaterialId == (uint64_t)( i + 1 ) ); } b3DestroyCompound( c ); return 0; } static int CompoundMaterialCrossShape( void ) { // One material shared across capsule, hull, and sphere -> 1 material slot. b3SurfaceMaterial mat = MakeMaterial( 0.5f, 99 ); b3CompoundCapsuleDef cap = { .capsule = { { 0, 0, 0 }, { 1, 0, 0 }, 0.25f }, .material = mat }; b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); b3CompoundHullDef hull = { .hull = &box.base, .transform = b3Transform_identity, .material = mat }; b3CompoundSphereDef sph = { .sphere = { { 5, 0, 0 }, 0.5f }, .material = mat }; b3CompoundDef def = { .capsules = &cap, .capsuleCount = 1, .hulls = &hull, .hullCount = 1, .spheres = &sph, .sphereCount = 1, }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->materialCount == 1 ); ENSURE( b3GetCompoundCapsule( c, 0 ).materialIndex == 0 ); ENSURE( b3GetCompoundHull( c, 0 ).materialIndex == 0 ); ENSURE( b3GetCompoundSphere( c, 0 ).materialIndex == 0 ); b3DestroyCompound( c ); return 0; } static int CompoundMaterialMeshShared( void ) { // Mesh material entries are routed through the same material map as convex // materials, so an identical material is deduped across mesh and convex. // (The comment in compound.c about meshes "not being shared" refers to the // per-instance materialIndices arrays, not the b3SurfaceMaterial table.) b3SurfaceMaterial mat = MakeMaterial( 0.3f, 11 ); b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); ENSURE( md->materialCount == 1 ); b3CompoundSphereDef sph = { .sphere = { { 5, 0, 0 }, 0.5f }, .material = mat }; b3CompoundMeshDef mesh = { .meshData = md, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1, }; b3CompoundDef def = { .meshes = &mesh, .meshCount = 1, .spheres = &sph, .sphereCount = 1, }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->materialCount == 1 ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } // --------------------------------------------------------------------------- // Hull / mesh blob sharing // --------------------------------------------------------------------------- static int CompoundHullSharingPointer( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 1, 1, 1 ); b3CompoundHullDef hulls[3]; for ( int i = 0; i < 3; ++i ) { hulls[i].hull = &box.base; hulls[i].transform = b3Transform_identity; hulls[i].transform.p.x = (float)( 4 * i ); hulls[i].material = mat; } b3CompoundDef def = { .hulls = hulls, .hullCount = 3 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->hullCount == 3 ); ENSURE( c->sharedHullCount == 1 ); b3DestroyCompound( c ); return 0; } static int CompoundHullSharingContent( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); // Two box hulls built independently with identical args are byte-identical // (b3MakeBoxHull is deterministic and the hash is computed over the bytes). b3BoxHull boxA = b3MakeBoxHull( 1, 1, 1 ); b3BoxHull boxB = b3MakeBoxHull( 1, 1, 1 ); ENSURE( &boxA != &boxB ); b3CompoundHullDef hulls[2] = { { .hull = &boxA.base, .transform = b3Transform_identity, .material = mat }, { .hull = &boxB.base, .transform = b3Transform_identity, .material = mat }, }; hulls[1].transform.p.x = 5.0f; b3CompoundDef def = { .hulls = hulls, .hullCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->sharedHullCount == 1 ); b3DestroyCompound( c ); return 0; } static int CompoundHullDistinct( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull boxA = b3MakeBoxHull( 1, 1, 1 ); b3BoxHull boxB = b3MakeBoxHull( 2, 1, 1 ); b3CompoundHullDef hulls[2] = { { .hull = &boxA.base, .transform = b3Transform_identity, .material = mat }, { .hull = &boxB.base, .transform = b3Transform_identity, .material = mat }, }; hulls[1].transform.p.x = 5.0f; b3CompoundDef def = { .hulls = hulls, .hullCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->sharedHullCount == 2 ); b3DestroyCompound( c ); return 0; } static int CompoundMeshSharingPointer( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); b3CompoundMeshDef meshes[3]; for ( int i = 0; i < 3; ++i ) { meshes[i].meshData = md; meshes[i].transform = b3Transform_identity; meshes[i].transform.p.x = (float)( 4 * i ); meshes[i].scale = (b3Vec3){ 1, 1, 1 }; meshes[i].materials = &mat; meshes[i].materialCount = 1; } b3CompoundDef def = { .meshes = meshes, .meshCount = 3 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->meshCount == 3 ); ENSURE( c->sharedMeshCount == 1 ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } static int CompoundMeshSharingContent( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3MeshData* mdA = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); b3MeshData* mdB = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); ENSURE( mdA != mdB ); b3CompoundMeshDef meshes[2] = { { .meshData = mdA, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1 }, { .meshData = mdB, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1 }, }; meshes[1].transform.p.x = 5.0f; b3CompoundDef def = { .meshes = meshes, .meshCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->sharedMeshCount == 1 ); b3DestroyCompound( c ); b3DestroyMesh( mdA ); b3DestroyMesh( mdB ); return 0; } static int CompoundMeshDistinct( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3MeshData* mdA = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 1, 1, 1 }, false ); b3MeshData* mdB = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 2, 1, 1 }, false ); b3CompoundMeshDef meshes[2] = { { .meshData = mdA, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1 }, { .meshData = mdB, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1 }, }; meshes[1].transform.p.x = 5.0f; b3CompoundDef def = { .meshes = meshes, .meshCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c->sharedMeshCount == 2 ); b3DestroyCompound( c ); b3DestroyMesh( mdA ); b3DestroyMesh( mdB ); return 0; } static int CompoundChildDispatch( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundCapsuleDef caps[2] = { { .capsule = { { 0, 0, 0 }, { 1, 0, 0 }, 0.2f }, .material = mat }, { .capsule = { { 0, 2, 0 }, { 1, 2, 0 }, 0.2f }, .material = mat }, }; b3CompoundHullDef hulls[1] = { { .hull = &box.base, .transform = b3Transform_identity, .material = mat } }; hulls[0].transform.p = (b3Vec3){ 5, 0, 0 }; b3CompoundMeshDef meshes[1] = { { .meshData = md, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1, } }; meshes[0].transform.p = (b3Vec3){ 0, 0, 5 }; b3CompoundSphereDef spheres[1] = { { .sphere = { { -5, 0, 0 }, 0.5f }, .material = mat } }; b3CompoundDef def = { .capsules = caps, .capsuleCount = 2, .hulls = hulls, .hullCount = 1, .meshes = meshes, .meshCount = 1, .spheres = spheres, .sphereCount = 1, }; b3CompoundData* c = b3CreateCompound( &def ); // Index ordering is capsules -> hulls -> meshes -> spheres. ENSURE( b3GetCompoundChild( c, 0 ).type == b3_capsuleShape ); ENSURE( b3GetCompoundChild( c, 1 ).type == b3_capsuleShape ); ENSURE( b3GetCompoundChild( c, 2 ).type == b3_hullShape ); ENSURE( b3GetCompoundChild( c, 3 ).type == b3_meshShape ); ENSURE( b3GetCompoundChild( c, 4 ).type == b3_sphereShape ); // Capsule and sphere children always report identity transform. The position // is encoded in the shape itself (capsule->center{1,2}, sphere->center). b3ChildShape cap0 = b3GetCompoundChild( c, 0 ); ENSURE_SMALL( cap0.transform.p.x, FLT_EPSILON ); ENSURE_SMALL( cap0.transform.p.y, FLT_EPSILON ); ENSURE_SMALL( cap0.transform.p.z, FLT_EPSILON ); ENSURE_SMALL( cap0.capsule.center2.x - 1.0f, FLT_EPSILON ); b3ChildShape sph = b3GetCompoundChild( c, 4 ); ENSURE_SMALL( sph.transform.p.x, FLT_EPSILON ); ENSURE_SMALL( sph.sphere.center.x + 5.0f, FLT_EPSILON ); // Hull and mesh children carry their stored transform. b3ChildShape hull = b3GetCompoundChild( c, 2 ); ENSURE_SMALL( hull.transform.p.x - 5.0f, FLT_EPSILON ); b3ChildShape mesh = b3GetCompoundChild( c, 3 ); ENSURE_SMALL( mesh.transform.p.z - 5.0f, FLT_EPSILON ); ENSURE( mesh.mesh.data != NULL ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } static int CompoundAABBContainsChildren( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[2] = { { .sphere = { { -3, 0, 0 }, 1.0f }, .material = mat }, { .sphere = { { 4, 0, 0 }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); b3AABB local = b3ComputeCompoundAABB( c, b3Transform_identity ); ENSURE( local.lowerBound.x <= -4.0f + 1e-5f ); ENSURE( local.upperBound.x >= 4.5f - 1e-5f ); ENSURE( local.lowerBound.y <= -1.0f + 1e-5f ); ENSURE( local.upperBound.y >= 1.0f - 1e-5f ); // Translation commutes through the bounding-box transform. b3Transform xf = { .p = { 10, 20, 30 }, .q = b3Quat_identity }; b3AABB world = b3ComputeCompoundAABB( c, xf ); ENSURE_SMALL( world.lowerBound.x - ( local.lowerBound.x + 10.0f ), 1e-4f ); ENSURE_SMALL( world.upperBound.y - ( local.upperBound.y + 20.0f ), 1e-4f ); ENSURE_SMALL( world.lowerBound.z - ( local.lowerBound.z + 30.0f ), 1e-4f ); b3DestroyCompound( c ); return 0; } static int CompoundRayCastMiss( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef sph = { .sphere = { { 0, 0, 0 }, 0.5f }, .material = mat }; b3CompoundDef def = { .spheres = &sph, .sphereCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); // Ray well above the sphere on a parallel path. b3RayCastInput input = { .origin = { -5, 5, 0 }, .translation = { 10, 0, 0 }, .maxFraction = 1.0f }; b3CastOutput out = b3RayCastCompound( c, &input ); ENSURE( out.hit == false ); b3DestroyCompound( c ); return 0; } static int CompoundRayCastClosest( void ) { b3SurfaceMaterial matA = MakeMaterial( 0.4f, 100 ); b3SurfaceMaterial matB = MakeMaterial( 0.4f, 200 ); // Two unit spheres along +X. Ray from origin must hit the nearer one first. b3CompoundSphereDef spheres[2] = { { .sphere = { { 5, 0, 0 }, 1.0f }, .material = matA }, { .sphere = { { 10, 0, 0 }, 1.0f }, .material = matB }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); b3RayCastInput input = { .origin = { 0, 0, 0 }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f }; b3CastOutput out = b3RayCastCompound( c, &input ); ENSURE( out.hit == true ); // Front face of the nearer sphere is at x=4 -> fraction 4/20 = 0.2. ENSURE_SMALL( out.fraction - 0.2f, 1e-4f ); ENSURE_SMALL( out.normal.x + 1.0f, 1e-4f ); ENSURE( out.childIndex == 0 ); const b3SurfaceMaterial* mats = b3GetCompoundMaterials( c ); ENSURE( mats[out.materialIndex].userMaterialId == 100 ); b3DestroyCompound( c ); return 0; } static int CompoundRayCastHullNormalRotation( void ) { // A unit box rotated 90 degrees about Z, placed at compound +X. The ray hits the // face that, in compound space, points back toward -X. Verifies that the // normal returned by the cast has been rotated from hull-local space back // into compound space. b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 1, 1, 1 ); b3CompoundHullDef hull = { .hull = &box.base, .transform = { .p = { 5, 0, 0 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) }, .material = mat, }; b3CompoundDef def = { .hulls = &hull, .hullCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); b3RayCastInput input = { .origin = { 0, 0, 0 }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f }; b3CastOutput out = b3RayCastCompound( c, &input ); ENSURE( out.hit == true ); // Box has |hx|=1; with the rotation a face still intersects the +X ray at x=4. ENSURE_SMALL( out.fraction - 0.2f, 1e-4f ); ENSURE_SMALL( out.normal.x + 1.0f, 1e-3f ); ENSURE_SMALL( out.normal.y, 1e-3f ); ENSURE_SMALL( out.normal.z, 1e-3f ); b3DestroyCompound( c ); return 0; } static int CompoundShapeCastClosest( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[2] = { { .sphere = { { 5, 0, 0 }, 1.0f }, .material = mat }, { .sphere = { { 10, 0, 0 }, 1.0f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); b3Vec3 point = { 0, 0, 0 }; b3ShapeCastInput input = { .proxy = { .points = &point, .count = 1, .radius = 0.25f }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f, .canEncroach = false, }; b3CastOutput out = b3ShapeCastCompound( c, &input ); ENSURE( out.hit == true ); // Closest contact: caster radius 0.25 + sphere radius 1.0 -> first contact at x ~= 3.75. ENSURE_SMALL( out.fraction - 3.75f / 20.0f, 1e-3f ); ENSURE( out.childIndex == 0 ); b3DestroyCompound( c ); return 0; } static int CompoundShapeCastMiss( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef sph = { .sphere = { { 5, 0, 0 }, 1.0f }, .material = mat }; b3CompoundDef def = { .spheres = &sph, .sphereCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); b3Vec3 point = { 0, 5, 0 }; b3ShapeCastInput input = { .proxy = { .points = &point, .count = 1, .radius = 0.25f }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f, .canEncroach = false, }; ENSURE( b3ShapeCastCompound( c, &input ).hit == false ); // An empty proxy has nothing to sweep input.proxy.count = 0; ENSURE( b3ShapeCastCompound( c, &input ).hit == false ); b3DestroyCompound( c ); return 0; } static int CompoundShapeCastHullNormalRotation( void ) { // Same setup as the ray cast rotation test. The result comes back in compound space, so the // hull local face the sweep lands on says nothing about the reported normal and point. b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 1, 1, 1 ); b3CompoundHullDef hull = { .hull = &box.base, .transform = { .p = { 5, 0, 0 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) }, .material = mat, }; b3CompoundDef def = { .hulls = &hull, .hullCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); b3Vec3 point = { 0, 0, 0 }; b3ShapeCastInput input = { .proxy = { .points = &point, .count = 1, .radius = 0.25f }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f, .canEncroach = false, }; b3CastOutput out = b3ShapeCastCompound( c, &input ); ENSURE( out.hit == true ); // Near face at x=4, caster radius 0.25 so contact at x=3.75 ENSURE_SMALL( out.fraction - 3.75f / 20.0f, 1e-3f ); ENSURE_SMALL( out.normal.x + 1.0f, 1e-3f ); ENSURE_SMALL( out.normal.y, 1e-3f ); ENSURE_SMALL( out.normal.z, 1e-3f ); ENSURE_SMALL( out.point.x - 4.0f, 1e-3f ); ENSURE_SMALL( out.point.y, 1e-3f ); ENSURE_SMALL( out.point.z, 1e-3f ); ENSURE( out.childIndex == 0 ); b3DestroyCompound( c ); return 0; } // Two separated upward facing triangles on the y = 0 plane, one per material. The bake may // reorder triangles but always keeps a triangle paired with its material index. static b3MeshData* MakeTwoMaterialMesh( void ) { b3Vec3 vertices[6] = { { -3.0f, 0.0f, -1.0f }, { -2.0f, 0.0f, 1.0f }, { -1.0f, 0.0f, -1.0f }, { 1.0f, 0.0f, -1.0f }, { 2.0f, 0.0f, 1.0f }, { 3.0f, 0.0f, -1.0f }, }; int32_t indices[6] = { 0, 1, 2, 3, 4, 5 }; uint8_t materialIndices[2] = { 0, 1 }; b3MeshDef def = { 0 }; def.vertices = vertices; def.stride = sizeof( b3Vec3 ); def.indices = indices; def.materialIndices = materialIndices; def.vertexCount = 6; def.triangleCount = 2; return b3CreateMesh( &def, NULL, 0 ); } static int CompoundMeshMaterialRemap( void ) { // A mesh child carries its own small material table. Casts report the triangle material // after it has been remapped into the compound material array. b3SurfaceMaterial matA = MakeMaterial( 0.3f, 100 ); b3SurfaceMaterial matB = MakeMaterial( 0.7f, 200 ); b3SurfaceMaterial materials[2] = { matA, matB }; b3MeshData* md = MakeTwoMaterialMesh(); b3CompoundMeshDef mesh = { .meshData = md, .transform = b3Transform_identity, .scale = { 1, 1, 1 }, .materials = materials, .materialCount = 2, }; b3CompoundDef def = { .meshes = &mesh, .meshCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); const b3SurfaceMaterial* table = b3GetCompoundMaterials( c ); // Straight down onto the material 0 triangle b3RayCastInput rayA = { .origin = { -2, 5, 0 }, .translation = { 0, -10, 0 }, .maxFraction = 1.0f }; b3CastOutput outA = b3RayCastCompound( c, &rayA ); ENSURE( outA.hit == true ); ENSURE( table[outA.materialIndex].userMaterialId == 100 ); b3RayCastInput rayB = { .origin = { 2, 5, 0 }, .translation = { 0, -10, 0 }, .maxFraction = 1.0f }; b3CastOutput outB = b3RayCastCompound( c, &rayB ); ENSURE( outB.hit == true ); ENSURE( table[outB.materialIndex].userMaterialId == 200 ); // The shape cast path does the same remap b3Vec3 point = { 2, 5, 0 }; b3ShapeCastInput castInput = { .proxy = { .points = &point, .count = 1, .radius = 0.1f }, .translation = { 0, -10, 0 }, .maxFraction = 1.0f, .canEncroach = false, }; b3CastOutput outCast = b3ShapeCastCompound( c, &castInput ); ENSURE( outCast.hit == true ); ENSURE( table[outCast.materialIndex].userMaterialId == 200 ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } // Six separated upward facing triangles, one per material index 0 to 5 static b3MeshData* MakeSixMaterialMesh( void ) { b3Vec3 vertices[18]; int32_t indices[18]; uint8_t materialIndices[6]; for ( int i = 0; i < 6; ++i ) { float x = 3.0f * (float)i; vertices[3 * i + 0] = (b3Vec3){ x - 1.0f, 0.0f, -1.0f }; vertices[3 * i + 1] = (b3Vec3){ x, 0.0f, 1.0f }; vertices[3 * i + 2] = (b3Vec3){ x + 1.0f, 0.0f, -1.0f }; indices[3 * i + 0] = 3 * i + 0; indices[3 * i + 1] = 3 * i + 1; indices[3 * i + 2] = 3 * i + 2; materialIndices[i] = (uint8_t)i; } b3MeshDef def = { 0 }; def.vertices = vertices; def.stride = sizeof( b3Vec3 ); def.indices = indices; def.materialIndices = materialIndices; def.vertexCount = 18; def.triangleCount = 6; return b3CreateMesh( &def, NULL, 0 ); } static int CompoundMeshManyMaterials( void ) { // The capsule material bakes first so the mesh map is not the identity b3SurfaceMaterial capsuleMat = MakeMaterial( 0.4f, 1000 ); b3MeshData* md = MakeSixMaterialMesh(); ENSURE( md->materialCount == 6 ); b3SurfaceMaterial meshMats[6]; for ( int i = 0; i < 6; ++i ) { meshMats[i] = MakeMaterial( 0.2f + 0.1f * (float)i, (uint64_t)( i + 1 ) ); } b3CompoundCapsuleDef cap = { .capsule = { { -10.0f, 0.0f, 0.0f }, { -9.0f, 0.0f, 0.0f }, 0.25f }, .material = capsuleMat }; b3CompoundMeshDef mesh = { .meshData = md, .transform = b3Transform_identity, .scale = { 1.0f, 1.0f, 1.0f }, .materials = meshMats, .materialCount = 6, }; b3CompoundDef def = { .capsules = &cap, .capsuleCount = 1, .meshes = &mesh, .meshCount = 1, }; b3CompoundData* c = b3CreateCompound( &def ); ENSURE( c != NULL ); ENSURE( c->materialCount == 7 ); const b3SurfaceMaterial* table = b3GetCompoundMaterials( c ); b3ChildShape capChild = b3GetCompoundChild( c, 0 ); ENSURE( capChild.type == b3_capsuleShape ); ENSURE( capChild.materialCount == 1 ); ENSURE( table[capChild.materialIndices[0]].userMaterialId == 1000 ); b3ChildShape meshChild = b3GetCompoundChild( c, 1 ); ENSURE( meshChild.type == b3_meshShape ); ENSURE( meshChild.materialCount == 6 ); for ( int k = 0; k < 6; ++k ) { ENSURE( table[meshChild.materialIndices[k]].userMaterialId == (uint64_t)( k + 1 ) ); } // Sixth triangle, material index 5 const uint8_t* triangleMaterials = b3GetMeshMaterialIndices( md ); b3RayCastInput ray = { .origin = { 15.0f, 5.0f, 0.0f }, .translation = { 0.0f, -10.0f, 0.0f }, .maxFraction = 1.0f }; b3CastOutput out = b3RayCastCompound( c, &ray ); ENSURE( out.hit == true ); ENSURE( out.childIndex == 1 ); int rawIndex = triangleMaterials[out.triangleIndex]; ENSURE( rawIndex >= 4 ); ENSURE( table[out.materialIndex].userMaterialId == (uint64_t)( rawIndex + 1 ) ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } // Flat quad with every triangle on material index 5, so the mesh has six materials static b3MeshData* MakeFlatMaterial5Mesh( void ) { b3Vec3 vertices[4] = { { -5.0f, 0.0f, -5.0f }, { -5.0f, 0.0f, 5.0f }, { 5.0f, 0.0f, -5.0f }, { 5.0f, 0.0f, 5.0f }, }; int32_t indices[6] = { 0, 1, 3, 3, 2, 0 }; uint8_t materialIndices[2] = { 5, 5 }; b3MeshDef def = { 0 }; def.vertices = vertices; def.stride = sizeof( b3Vec3 ); def.indices = indices; def.materialIndices = materialIndices; def.vertexCount = 4; def.triangleCount = 2; return b3CreateMesh( &def, NULL, 0 ); } static uint64_t s_compoundContactMaterialId; static float CompoundContactFrictionCallback( float frictionA, uint64_t userMaterialIdA, float frictionB, uint64_t userMaterialIdB ) { if ( userMaterialIdA == 6 || userMaterialIdB == 6 ) { s_compoundContactMaterialId = 6; } return 0.5f * ( frictionA + frictionB ); } static int CompoundMeshContactMaterial( void ) { s_compoundContactMaterialId = 0; b3WorldDef worldDef = b3DefaultWorldDef(); b3WorldId worldId = b3CreateWorld( &worldDef ); b3World_SetFrictionCallback( worldId, CompoundContactFrictionCallback ); b3BodyDef groundBodyDef = b3DefaultBodyDef(); groundBodyDef.type = b3_staticBody; b3BodyId groundBodyId = b3CreateBody( worldId, &groundBodyDef ); b3MeshData* md = MakeFlatMaterial5Mesh(); ENSURE( md->materialCount == 6 ); b3SurfaceMaterial meshMats[6]; for ( int i = 0; i < 6; ++i ) { meshMats[i] = MakeMaterial( 0.5f, (uint64_t)( i + 1 ) ); } b3CompoundMeshDef meshChild = { .meshData = md, .transform = b3Transform_identity, .scale = { 1.0f, 1.0f, 1.0f }, .materials = meshMats, .materialCount = 6, }; b3CompoundDef compoundDef = { .meshes = &meshChild, .meshCount = 1 }; b3CompoundData* compound = b3CreateCompound( &compoundDef ); ENSURE( compound != NULL ); b3ShapeDef groundShapeDef = b3DefaultShapeDef(); b3CreateBakedCompoundShape( groundBodyId, &groundShapeDef, compound ); b3BodyDef sphereBodyDef = b3DefaultBodyDef(); sphereBodyDef.type = b3_dynamicBody; sphereBodyDef.position = (b3Pos){ 0.0f, 3.0f, 0.0f }; b3BodyId sphereBodyId = b3CreateBody( worldId, &sphereBodyDef ); b3ShapeDef sphereShapeDef = b3DefaultShapeDef(); sphereShapeDef.density = 1.0f; b3Sphere sphere = { { 0.0f, 0.0f, 0.0f }, 0.5f }; b3CreateSphereShape( sphereBodyId, &sphereShapeDef, &sphere ); for ( int i = 0; i < 120; ++i ) { b3World_Step( worldId, 1.0f / 60.0f, 4 ); } ENSURE( s_compoundContactMaterialId == 6 ); b3DestroyWorld( worldId ); b3DestroyCompound( compound ); b3DestroyMesh( md ); return 0; } static int CompoundOverlap( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[2] = { { .sphere = { { -3, 0, 0 }, 0.5f }, .material = mat }, { .sphere = { { 3, 0, 0 }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); // Proxy at the origin lies in the gap between the two spheres. b3Vec3 origin = { 0, 0, 0 }; b3ShapeProxy gap = { .points = &origin, .count = 1, .radius = 0.25f }; ENSURE( b3OverlapCompound( c, b3Transform_identity, &gap ) == false ); // Proxy at the center of the second sphere overlaps it. b3Vec3 onSecond = { 3, 0, 0 }; b3ShapeProxy hit = { .points = &onSecond, .count = 1, .radius = 0.1f }; ENSURE( b3OverlapCompound( c, b3Transform_identity, &hit ) == true ); b3DestroyCompound( c ); return 0; } static int CompoundOverlapTransformed( void ) { // The tree and the child geometry live in the compound frame while the proxy arrives in world // space, so a compound that is moved and turned has to pull the proxy back before querying. b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[2] = { { .sphere = { { -3, 0, 0 }, 0.5f }, .material = mat }, { .sphere = { { 3, 0, 0 }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); b3Transform transform = { .p = { 10, 20, 30 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) }; b3Vec3 gapPoint = b3TransformPoint( transform, (b3Vec3){ 0, 0, 0 } ); b3ShapeProxy gap = { .points = &gapPoint, .count = 1, .radius = 0.25f }; ENSURE( b3OverlapCompound( c, transform, &gap ) == false ); b3Vec3 hitPoint = b3TransformPoint( transform, (b3Vec3){ 3, 0, 0 } ); b3ShapeProxy hit = { .points = &hitPoint, .count = 1, .radius = 0.1f }; ENSURE( b3OverlapCompound( c, transform, &hit ) == true ); // A proxy left in the compound frame must not register against the moved compound b3Vec3 localPoint = { 3, 0, 0 }; b3ShapeProxy stale = { .points = &localPoint, .count = 1, .radius = 0.1f }; ENSURE( b3OverlapCompound( c, transform, &stale ) == false ); b3DestroyCompound( c ); return 0; } static int CompoundOverlapChildTypes( void ) { // One child of every type, spaced far enough apart that a hit names the type it came from. // Hull and mesh children add a child transform underneath the compound transform. b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundCapsuleDef capsule = { .capsule = { { -10, 0, 0 }, { -9, 0, 0 }, 0.25f }, .material = mat }; b3CompoundHullDef hull = { .hull = &box.base, .transform = { .p = { 0, 0, 0 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.25f * B3_PI ) }, .material = mat, }; b3CompoundMeshDef mesh = { .meshData = md, .transform = { .p = { 10, 0, 0 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.5f * B3_PI ) }, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1, }; b3CompoundSphereDef sphere = { .sphere = { { 20, 0, 0 }, 0.5f }, .material = mat }; b3CompoundDef def = { .capsules = &capsule, .capsuleCount = 1, .hulls = &hull, .hullCount = 1, .meshes = &mesh, .meshCount = 1, .spheres = &sphere, .sphereCount = 1, }; b3CompoundData* c = b3CreateCompound( &def ); b3Transform transform = { .p = { 100, 200, 300 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) }; // Points sitting on or inside each child, then carried out to world space b3Vec3 localPoints[4] = { { -9.5f, 0, 0 }, // capsule axis { 0, 0, 0 }, // hull center { 10, 0.45f, 0 }, // just under a mesh face { 20, 0, 0 }, // sphere center }; for ( int i = 0; i < 4; ++i ) { b3Vec3 worldPoint = b3TransformPoint( transform, localPoints[i] ); b3ShapeProxy proxy = { .points = &worldPoint, .count = 1, .radius = 0.1f }; ENSURE( b3OverlapCompound( c, transform, &proxy ) == true ); } // A gap between the hull and the mesh b3Vec3 gapPoint = b3TransformPoint( transform, (b3Vec3){ 5, 0, 0 } ); b3ShapeProxy gap = { .points = &gapPoint, .count = 1, .radius = 0.1f }; ENSURE( b3OverlapCompound( c, transform, &gap ) == false ); b3DestroyCompound( c ); b3DestroyMesh( md ); return 0; } static int CompoundOverlapSegmentProxy( void ) { // A multi point proxy has to be carried into the compound frame point by point b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[2] = { { .sphere = { { -3, 0, 0 }, 0.5f }, .material = mat }, { .sphere = { { 3, 0, 0 }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); b3Transform transform = { .p = { -40, 15, 7 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisY, 0.5f * B3_PI ) }; // Segment that stays inside the gap b3Vec3 inGap[2] = { b3TransformPoint( transform, (b3Vec3){ -1, 0, 0 } ), b3TransformPoint( transform, (b3Vec3){ 1, 0, 0 } ), }; b3ShapeProxy gap = { .points = inGap, .count = 2, .radius = 0.25f }; ENSURE( b3OverlapCompound( c, transform, &gap ) == false ); // Same segment stretched until one end reaches the second sphere b3Vec3 reaching[2] = { b3TransformPoint( transform, (b3Vec3){ -1, 0, 0 } ), b3TransformPoint( transform, (b3Vec3){ 2.9f, 0, 0 } ), }; b3ShapeProxy hit = { .points = reaching, .count = 2, .radius = 0.25f }; ENSURE( b3OverlapCompound( c, transform, &hit ) == true ); b3DestroyCompound( c ); return 0; } struct QueryAccumulator { int childIndices[8]; int count; int stopAfter; // -1 = never stop early }; static bool QueryCallback( const b3CompoundData* compound, int childIndex, void* context ) { (void)compound; struct QueryAccumulator* acc = context; if ( acc->count < (int)( sizeof( acc->childIndices ) / sizeof( acc->childIndices[0] ) ) ) { acc->childIndices[acc->count++] = childIndex; } if ( acc->stopAfter >= 0 && acc->count >= acc->stopAfter ) { return false; } return true; } static int CompoundQuery( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3CompoundSphereDef spheres[3] = { { .sphere = { { -10, 0, 0 }, 0.5f }, .material = mat }, { .sphere = { { 0, 0, 0 }, 0.5f }, .material = mat }, { .sphere = { { 10, 0, 0 }, 0.5f }, .material = mat }, }; b3CompoundDef def = { .spheres = spheres, .sphereCount = 3 }; b3CompoundData* c = b3CreateCompound( &def ); // Tight box around the middle sphere. Only it should be reported. b3AABB middle = { { -1, -1, -1 }, { 1, 1, 1 } }; struct QueryAccumulator acc = { .stopAfter = -1 }; b3QueryCompound( c, middle, QueryCallback, &acc ); ENSURE( acc.count == 1 ); ENSURE( acc.childIndices[0] == 1 ); // Wide box overlapping all three; early-exit after the first reported child. b3AABB wide = { { -20, -1, -1 }, { 20, 1, 1 } }; struct QueryAccumulator stop = { .stopAfter = 1 }; b3QueryCompound( c, wide, QueryCallback, &stop ); ENSURE( stop.count == 1 ); // Without early-exit, all three are visited. struct QueryAccumulator all = { .stopAfter = -1 }; b3QueryCompound( c, wide, QueryCallback, &all ); ENSURE( all.count == 3 ); b3DestroyCompound( c ); return 0; } static int CompoundMover( void ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); // Two boxes side-by-side along X, gap of 1 between them. b3CompoundHullDef hulls[2] = { { .hull = &box.base, .transform = { .p = { -1.0f, 0, 0 }, .q = b3Quat_identity }, .material = mat }, { .hull = &box.base, .transform = { .p = { 1.0f, 0, 0 }, .q = b3Quat_identity }, .material = mat }, }; b3CompoundDef def = { .hulls = hulls, .hullCount = 2 }; b3CompoundData* c = b3CreateCompound( &def ); // Small capsule mover sitting on top of the boxes, low enough to penetrate both. b3Capsule mover = { { -1.0f, 0.6f, 0 }, { 1.0f, 0.6f, 0 }, 0.2f }; b3PlaneResult planes[8] = { 0 }; int planeCount = b3CollideMoverAndCompound( planes, 8, c, &mover ); // Both boxes contribute at least one plane each; the +Y face of each box // should produce a plane whose normal points roughly +Y in compound space. ENSURE( planeCount >= 2 ); int upPlanes = 0; for ( int i = 0; i < planeCount; ++i ) { if ( planes[i].plane.normal.y > 0.9f ) { upPlanes += 1; } } ENSURE( upPlanes >= 2 ); // Capacity cap is honored: ask for 1 and the call must not exceed it. b3PlaneResult one[1] = { 0 }; int capped = b3CollideMoverAndCompound( one, 1, c, &mover ); ENSURE( capped <= 1 ); b3DestroyCompound( c ); return 0; } static int CompoundMoverRotatedChild( void ) { // The child solves the mover in its own frame, so the plane it returns has to be carried // back into the compound frame before the caller sees it. b3SurfaceMaterial mat = MakeMaterial( 0.25f, 77 ); b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); // Quarter turn about z, so the compound space top face is a side face of the hull b3CompoundHullDef hull = { .hull = &box.base, .transform = { .p = { 0, 0, 0 }, .q = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.5f * B3_PI ) }, .material = mat, }; b3CompoundDef def = { .hulls = &hull, .hullCount = 1 }; b3CompoundData* c = b3CreateCompound( &def ); b3Capsule mover = { { -0.1f, 0.6f, 0 }, { 0.1f, 0.6f, 0 }, 0.2f }; b3PlaneResult planes[8] = { 0 }; int planeCount = b3CollideMoverAndCompound( planes, 8, c, &mover ); ENSURE( planeCount >= 1 ); ENSURE_SMALL( planes[0].plane.normal.x, 1e-3f ); ENSURE_SMALL( planes[0].plane.normal.y - 1.0f, 1e-3f ); ENSURE_SMALL( planes[0].plane.normal.z, 1e-3f ); ENSURE_SMALL( planes[0].point.y - 0.5f, 1e-3f ); ENSURE( planes[0].childIndex == 0 ); const b3SurfaceMaterial* table = b3GetCompoundMaterials( c ); ENSURE( table[planes[0].materialIndex].userMaterialId == 77 ); b3DestroyCompound( c ); return 0; } static b3CompoundData* BuildSerializableCompound( b3MeshData* md ) { b3SurfaceMaterial mat = b3DefaultSurfaceMaterial(); b3BoxHull box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); b3CompoundCapsuleDef cap = { .capsule = { { -2, 0, 0 }, { -1, 0, 0 }, 0.2f }, .material = mat }; b3CompoundHullDef hull = { .hull = &box.base, .transform = { .p = { 5, 0, 0 }, .q = b3Quat_identity }, .material = mat }; b3CompoundMeshDef mesh = { .meshData = md, .transform = { .p = { 0, 0, 5 }, .q = b3Quat_identity }, .scale = { 1, 1, 1 }, .materials = &mat, .materialCount = 1, }; b3CompoundSphereDef sph = { .sphere = { { -5, 0, 0 }, 0.5f }, .material = mat }; b3CompoundDef def = { .capsules = &cap, .capsuleCount = 1, .hulls = &hull, .hullCount = 1, .meshes = &mesh, .meshCount = 1, .spheres = &sph, .sphereCount = 1, }; return b3CreateCompound( &def ); } static int CompoundSerializeRoundtrip( void ) { b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundData* a = BuildSerializableCompound( md ); // Snapshot a few queries on the original. b3AABB aabbA = b3ComputeCompoundAABB( a, b3Transform_identity ); b3RayCastInput rayInput = { .origin = { 0, 0, 0 }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f }; b3CastOutput rayA = b3RayCastCompound( a, &rayInput ); ENSURE( rayA.hit ); int byteCount = a->byteCount; uint8_t* buffer = (uint8_t*)malloc( (size_t)byteCount ); ENSURE( buffer != NULL ); uint8_t* serialized = b3ConvertCompoundToBytes( a ); memcpy( buffer, serialized, (size_t)byteCount ); b3DestroyCompound( a ); b3CompoundData* b = b3ConvertBytesToCompound( buffer, byteCount ); ENSURE( b != NULL ); ENSURE( b->byteCount == byteCount ); ENSURE( b->capsuleCount == 1 ); ENSURE( b->hullCount == 1 ); ENSURE( b->meshCount == 1 ); ENSURE( b->sphereCount == 1 ); ENSURE( b->tree.nodes != NULL ); // Bounds and ray cast on the deserialized compound match the original. b3AABB aabbB = b3ComputeCompoundAABB( b, b3Transform_identity ); ENSURE_SMALL( aabbA.lowerBound.x - aabbB.lowerBound.x, 1e-5f ); ENSURE_SMALL( aabbA.upperBound.z - aabbB.upperBound.z, 1e-5f ); b3CastOutput rayB = b3RayCastCompound( b, &rayInput ); ENSURE( rayB.hit == rayA.hit ); ENSURE_SMALL( rayB.fraction - rayA.fraction, 1e-5f ); ENSURE( rayB.childIndex == rayA.childIndex ); free( buffer ); b3DestroyMesh( md ); return 0; } static int CompoundSerializeBadVersion( void ) { b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundData* a = BuildSerializableCompound( md ); int byteCount = a->byteCount; uint8_t* buffer = (uint8_t*)malloc( (size_t)byteCount ); memcpy( buffer, b3ConvertCompoundToBytes( a ), (size_t)byteCount ); b3DestroyCompound( a ); // Corrupt the version word (first 8 bytes of b3Compound). ( (b3CompoundData*)buffer )->version ^= 0x1ull; b3CompoundData* b = b3ConvertBytesToCompound( buffer, byteCount ); ENSURE( b == NULL ); free( buffer ); b3DestroyMesh( md ); return 0; } static int CompoundSerializeWrongByteCount( void ) { b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false ); b3CompoundData* a = BuildSerializableCompound( md ); int byteCount = a->byteCount; uint8_t* buffer = (uint8_t*)malloc( (size_t)byteCount ); memcpy( buffer, b3ConvertCompoundToBytes( a ), (size_t)byteCount ); b3DestroyCompound( a ); // Off-by-one in the declared length is rejected. b3CompoundData* b = b3ConvertBytesToCompound( buffer, byteCount + 1 ); ENSURE( b == NULL ); free( buffer ); b3DestroyMesh( md ); return 0; } int CompoundTest( void ) { RUN_SUBTEST( CompoundCreateMixed ); RUN_SUBTEST( CompoundCreateSingleType ); RUN_SUBTEST( CompoundMaterialDedup ); RUN_SUBTEST( CompoundMaterialDistinct ); RUN_SUBTEST( CompoundMaterialCrossShape ); RUN_SUBTEST( CompoundMaterialMeshShared ); RUN_SUBTEST( CompoundHullSharingPointer ); RUN_SUBTEST( CompoundHullSharingContent ); RUN_SUBTEST( CompoundHullDistinct ); RUN_SUBTEST( CompoundMeshSharingPointer ); RUN_SUBTEST( CompoundMeshSharingContent ); RUN_SUBTEST( CompoundMeshDistinct ); RUN_SUBTEST( CompoundChildDispatch ); RUN_SUBTEST( CompoundAABBContainsChildren ); RUN_SUBTEST( CompoundRayCastMiss ); RUN_SUBTEST( CompoundRayCastClosest ); RUN_SUBTEST( CompoundRayCastHullNormalRotation ); RUN_SUBTEST( CompoundShapeCastClosest ); RUN_SUBTEST( CompoundShapeCastMiss ); RUN_SUBTEST( CompoundShapeCastHullNormalRotation ); RUN_SUBTEST( CompoundMeshMaterialRemap ); RUN_SUBTEST( CompoundMeshManyMaterials ); RUN_SUBTEST( CompoundMeshContactMaterial ); RUN_SUBTEST( CompoundOverlap ); RUN_SUBTEST( CompoundOverlapTransformed ); RUN_SUBTEST( CompoundOverlapChildTypes ); RUN_SUBTEST( CompoundOverlapSegmentProxy ); RUN_SUBTEST( CompoundQuery ); RUN_SUBTEST( CompoundMover ); RUN_SUBTEST( CompoundMoverRotatedChild ); RUN_SUBTEST( CompoundSerializeRoundtrip ); RUN_SUBTEST( CompoundSerializeBadVersion ); RUN_SUBTEST( CompoundSerializeWrongByteCount ); return 0; }