2026-05-10 13:36:52 -07:00
|
|
|
// SPDX-FileCopyrightText: 2026 Erin Catto
|
|
|
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
|
|
|
|
|
|
#include "test_macros.h"
|
|
|
|
|
|
|
|
|
|
// b3CollideMoverAndCompound, b3GetCompoundChild, b3QueryCompound are internal
|
|
|
|
|
#include "compound.h"
|
|
|
|
|
|
2026-09-25 14:56:44 -07:00
|
|
|
#include "box3d/box3d.h"
|
2026-05-10 13:36:52 -07:00
|
|
|
#include "box3d/collision.h"
|
|
|
|
|
#include "box3d/math_functions.h"
|
|
|
|
|
|
|
|
|
|
#include <float.h>
|
|
|
|
|
#include <stdint.h>
|
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
|
|
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 = {
|
2026-06-11 22:39:26 -07:00
|
|
|
.capsules = capsules,
|
|
|
|
|
.capsuleCount = 1,
|
|
|
|
|
.hulls = hulls,
|
|
|
|
|
.hullCount = 1,
|
|
|
|
|
.meshes = meshes,
|
|
|
|
|
.meshCount = 1,
|
|
|
|
|
.spheres = spheres,
|
|
|
|
|
.sphereCount = 2,
|
2026-05-10 13:36:52 -07:00
|
|
|
};
|
|
|
|
|
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* compound = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( compound != NULL );
|
|
|
|
|
ENSURE( compound->version == B3_COMPOUND_VERSION );
|
2026-06-20 23:35:04 -07:00
|
|
|
ENSURE( compound->byteCount > (int)sizeof( b3CompoundData ) );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
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 );
|
|
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
ENSURE( compound->nodeCount >= 2 );
|
|
|
|
|
ENSURE( compound->nodeOffset > 0 );
|
|
|
|
|
ENSURE( compound->bounds.lowerBound.x < compound->bounds.upperBound.x );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( c->materialCount == 3 );
|
|
|
|
|
|
|
|
|
|
const b3SurfaceMaterial* mats = b3GetCompoundMaterials( c );
|
|
|
|
|
ENSURE( mats != NULL );
|
|
|
|
|
|
|
|
|
|
for ( int i = 0; i < 3; ++i )
|
|
|
|
|
{
|
|
|
|
|
b3CompoundCapsule cc = b3GetCompoundCapsule( c, i );
|
2026-09-25 14:56:44 -07:00
|
|
|
ENSURE( cc.materialIndex < 3 );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( mats[cc.materialIndex].userMaterialId == (uint64_t)( i + 1 ) );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
b3DestroyCompound( c );
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int CompoundMaterialCrossShape( void )
|
|
|
|
|
{
|
2026-07-11 23:26:31 -07:00
|
|
|
// One material shared across capsule, hull, and sphere -> 1 material slot.
|
2026-05-10 13:36:52 -07:00
|
|
|
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 = {
|
2026-06-11 22:39:26 -07:00
|
|
|
.capsules = &cap,
|
|
|
|
|
.capsuleCount = 1,
|
|
|
|
|
.hulls = &hull,
|
|
|
|
|
.hullCount = 1,
|
|
|
|
|
.spheres = &sph,
|
|
|
|
|
.sphereCount = 1,
|
2026-05-10 13:36:52 -07:00
|
|
|
};
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 = {
|
2026-06-11 22:39:26 -07:00
|
|
|
.meshes = &mesh,
|
|
|
|
|
.meshCount = 1,
|
|
|
|
|
.spheres = &sph,
|
|
|
|
|
.sphereCount = 1,
|
2026-05-10 13:36:52 -07:00
|
|
|
};
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 = {
|
2026-06-11 22:39:26 -07:00
|
|
|
.capsules = caps,
|
|
|
|
|
.capsuleCount = 2,
|
|
|
|
|
.hulls = hulls,
|
|
|
|
|
.hullCount = 1,
|
|
|
|
|
.meshes = meshes,
|
|
|
|
|
.meshCount = 1,
|
|
|
|
|
.spheres = spheres,
|
|
|
|
|
.sphereCount = 1,
|
2026-05-10 13:36:52 -07:00
|
|
|
};
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
2026-07-11 23:26:31 -07:00
|
|
|
// Index ordering is capsules -> hulls -> meshes -> spheres.
|
2026-05-10 13:36:52 -07:00
|
|
|
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 );
|
|
|
|
|
|
2026-07-11 23:26:31 -07:00
|
|
|
// Capsule and sphere children always report identity transform. The position
|
2026-05-10 13:36:52 -07:00
|
|
|
// 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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
// 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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
b3RayCastInput input = { .origin = { 0, 0, 0 }, .translation = { 20, 0, 0 }, .maxFraction = 1.0f };
|
|
|
|
|
b3CastOutput out = b3RayCastCompound( c, &input );
|
|
|
|
|
ENSURE( out.hit == true );
|
|
|
|
|
|
2026-07-11 23:26:31 -07:00
|
|
|
// Front face of the nearer sphere is at x=4 -> fraction 4/20 = 0.2.
|
2026-05-10 13:36:52 -07:00
|
|
|
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 )
|
|
|
|
|
{
|
2026-07-11 23:26:31 -07:00
|
|
|
// A unit box rotated 90 degrees about Z, placed at compound +X. The ray hits the
|
2026-05-10 13:36:52 -07:00
|
|
|
// 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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
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 );
|
2026-07-11 23:26:31 -07:00
|
|
|
// Closest contact: caster radius 0.25 + sphere radius 1.0 -> first contact at x ~= 3.75.
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE_SMALL( out.fraction - 3.75f / 20.0f, 1e-3f );
|
|
|
|
|
ENSURE( out.childIndex == 0 );
|
|
|
|
|
|
|
|
|
|
b3DestroyCompound( c );
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2026-09-16 15:46:31 -07:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-09-25 14:56:44 -07:00
|
|
|
// 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();
|
2026-10-07 14:48:58 -07:00
|
|
|
b3ShapeId compoundShapeId = b3CreateBakedCompoundShape( groundBodyId, &groundShapeDef, compound );
|
|
|
|
|
ENSURE( b3Shape_GetCompound( compoundShapeId ) == compound );
|
2026-09-25 14:56:44 -07:00
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-09-16 15:46:31 -07:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-11 22:39:26 -07:00
|
|
|
struct QueryAccumulator
|
2026-05-10 13:36:52 -07:00
|
|
|
{
|
|
|
|
|
int childIndices[8];
|
|
|
|
|
int count;
|
|
|
|
|
int stopAfter; // -1 = never stop early
|
|
|
|
|
};
|
|
|
|
|
|
2026-06-20 23:35:04 -07:00
|
|
|
static bool QueryCallback( const b3CompoundData* compound, int childIndex, void* context )
|
2026-05-10 13:36:52 -07:00
|
|
|
{
|
|
|
|
|
(void)compound;
|
2026-06-11 22:39:26 -07:00
|
|
|
struct QueryAccumulator* acc = context;
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
2026-07-11 23:26:31 -07:00
|
|
|
// Tight box around the middle sphere. Only it should be reported.
|
2026-05-10 13:36:52 -07:00
|
|
|
b3AABB middle = { { -1, -1, -1 }, { 1, 1, 1 } };
|
2026-06-11 22:39:26 -07:00
|
|
|
struct QueryAccumulator acc = { .stopAfter = -1 };
|
2026-05-10 13:36:52 -07:00
|
|
|
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 } };
|
2026-06-11 22:39:26 -07:00
|
|
|
struct QueryAccumulator stop = { .stopAfter = 1 };
|
2026-05-10 13:36:52 -07:00
|
|
|
b3QueryCompound( c, wide, QueryCallback, &stop );
|
|
|
|
|
ENSURE( stop.count == 1 );
|
|
|
|
|
|
|
|
|
|
// Without early-exit, all three are visited.
|
2026-06-11 22:39:26 -07:00
|
|
|
struct QueryAccumulator all = { .stopAfter = -1 };
|
2026-05-10 13:36:52 -07:00
|
|
|
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 };
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* c = b3CreateCompound( &def );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
// 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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-09-16 15:46:31 -07:00
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2026-06-20 23:35:04 -07:00
|
|
|
static b3CompoundData* BuildSerializableCompound( b3MeshData* md )
|
2026-05-10 13:36:52 -07:00
|
|
|
{
|
|
|
|
|
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 = {
|
2026-06-11 22:39:26 -07:00
|
|
|
.capsules = &cap,
|
|
|
|
|
.capsuleCount = 1,
|
|
|
|
|
.hulls = &hull,
|
|
|
|
|
.hullCount = 1,
|
|
|
|
|
.meshes = &mesh,
|
|
|
|
|
.meshCount = 1,
|
|
|
|
|
.spheres = &sph,
|
|
|
|
|
.sphereCount = 1,
|
2026-05-10 13:36:52 -07:00
|
|
|
};
|
|
|
|
|
return b3CreateCompound( &def );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int CompoundSerializeRoundtrip( void )
|
|
|
|
|
{
|
|
|
|
|
b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false );
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* a = BuildSerializableCompound( md );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
// 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 );
|
|
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
uint8_t* reference = (uint8_t*)malloc( (size_t)byteCount );
|
|
|
|
|
ENSURE( reference != NULL );
|
|
|
|
|
|
|
|
|
|
memcpy( buffer, a, (size_t)byteCount );
|
|
|
|
|
memcpy( reference, a, (size_t)byteCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
b3DestroyCompound( a );
|
|
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
const b3CompoundData* b = b3ValidateCompound( buffer, byteCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( b != NULL );
|
2026-10-07 14:48:58 -07:00
|
|
|
ENSURE( (const uint8_t*)b == buffer );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( b->byteCount == byteCount );
|
|
|
|
|
ENSURE( b->capsuleCount == 1 );
|
|
|
|
|
ENSURE( b->hullCount == 1 );
|
|
|
|
|
ENSURE( b->meshCount == 1 );
|
|
|
|
|
ENSURE( b->sphereCount == 1 );
|
2026-10-07 14:48:58 -07:00
|
|
|
|
|
|
|
|
// Validation must not touch the bytes
|
|
|
|
|
ENSURE( memcmp( buffer, reference, (size_t)byteCount ) == 0 );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
// 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 );
|
|
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
free( reference );
|
2026-05-10 13:36:52 -07:00
|
|
|
free( buffer );
|
|
|
|
|
b3DestroyMesh( md );
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int CompoundSerializeBadVersion( void )
|
|
|
|
|
{
|
|
|
|
|
b3MeshData* md = b3CreateBoxMesh( b3Vec3_zero, (b3Vec3){ 0.5f, 0.5f, 0.5f }, false );
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* a = BuildSerializableCompound( md );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
int byteCount = a->byteCount;
|
|
|
|
|
uint8_t* buffer = (uint8_t*)malloc( (size_t)byteCount );
|
2026-10-07 14:48:58 -07:00
|
|
|
memcpy( buffer, a, (size_t)byteCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
b3DestroyCompound( a );
|
|
|
|
|
|
|
|
|
|
// Corrupt the version word (first 8 bytes of b3Compound).
|
2026-06-20 23:35:04 -07:00
|
|
|
( (b3CompoundData*)buffer )->version ^= 0x1ull;
|
2026-05-10 13:36:52 -07:00
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
const b3CompoundData* b = b3ValidateCompound( buffer, byteCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
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 );
|
2026-06-20 23:35:04 -07:00
|
|
|
b3CompoundData* a = BuildSerializableCompound( md );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
int byteCount = a->byteCount;
|
|
|
|
|
uint8_t* buffer = (uint8_t*)malloc( (size_t)byteCount );
|
2026-10-07 14:48:58 -07:00
|
|
|
memcpy( buffer, a, (size_t)byteCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
b3DestroyCompound( a );
|
|
|
|
|
|
|
|
|
|
// Off-by-one in the declared length is rejected.
|
2026-10-07 14:48:58 -07:00
|
|
|
const b3CompoundData* b = b3ValidateCompound( buffer, byteCount + 1 );
|
2026-05-10 13:36:52 -07:00
|
|
|
ENSURE( b == NULL );
|
|
|
|
|
|
|
|
|
|
free( buffer );
|
|
|
|
|
b3DestroyMesh( md );
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2026-10-07 14:48:58 -07:00
|
|
|
static int CompoundSerializeBadNodeCount( 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, a, (size_t)byteCount );
|
|
|
|
|
b3DestroyCompound( a );
|
|
|
|
|
|
|
|
|
|
b3CompoundData* header = (b3CompoundData*)buffer;
|
|
|
|
|
int nodeCount = header->nodeCount;
|
|
|
|
|
|
|
|
|
|
// Node array runs off the end of the buffer
|
|
|
|
|
header->nodeCount = byteCount;
|
|
|
|
|
ENSURE( b3ValidateCompound( buffer, byteCount ) == NULL );
|
|
|
|
|
|
|
|
|
|
// Overflow in 32 bit arithmetic must still be caught
|
|
|
|
|
header->nodeCount = INT32_MAX;
|
|
|
|
|
ENSURE( b3ValidateCompound( buffer, byteCount ) == NULL );
|
|
|
|
|
|
|
|
|
|
header->nodeCount = nodeCount;
|
|
|
|
|
ENSURE( b3ValidateCompound( buffer, byteCount ) != NULL );
|
|
|
|
|
|
|
|
|
|
free( buffer );
|
|
|
|
|
b3DestroyMesh( md );
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2026-05-10 13:36:52 -07:00
|
|
|
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 );
|
2026-09-16 15:46:31 -07:00
|
|
|
RUN_SUBTEST( CompoundShapeCastMiss );
|
|
|
|
|
RUN_SUBTEST( CompoundShapeCastHullNormalRotation );
|
|
|
|
|
RUN_SUBTEST( CompoundMeshMaterialRemap );
|
2026-09-25 14:56:44 -07:00
|
|
|
RUN_SUBTEST( CompoundMeshManyMaterials );
|
|
|
|
|
RUN_SUBTEST( CompoundMeshContactMaterial );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
RUN_SUBTEST( CompoundOverlap );
|
2026-09-16 15:46:31 -07:00
|
|
|
RUN_SUBTEST( CompoundOverlapTransformed );
|
|
|
|
|
RUN_SUBTEST( CompoundOverlapChildTypes );
|
|
|
|
|
RUN_SUBTEST( CompoundOverlapSegmentProxy );
|
2026-05-10 13:36:52 -07:00
|
|
|
RUN_SUBTEST( CompoundQuery );
|
|
|
|
|
|
|
|
|
|
RUN_SUBTEST( CompoundMover );
|
2026-09-16 15:46:31 -07:00
|
|
|
RUN_SUBTEST( CompoundMoverRotatedChild );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
RUN_SUBTEST( CompoundSerializeRoundtrip );
|
|
|
|
|
RUN_SUBTEST( CompoundSerializeBadVersion );
|
|
|
|
|
RUN_SUBTEST( CompoundSerializeWrongByteCount );
|
2026-10-07 14:48:58 -07:00
|
|
|
RUN_SUBTEST( CompoundSerializeBadNodeCount );
|
2026-05-10 13:36:52 -07:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|