add a small amount of debug data to manifolds

refine edge contact rule
This commit is contained in:
Erin Catto 2026-11-03 17:40:11 -08:00
commit 590ab5a7d9
13 changed files with 1668 additions and 33 deletions

View file

@ -103,3 +103,13 @@ chamfer,0,0,box,0,2
chamfer,0,0,cylinder,0,2
chamfer,0,1,box,0,2
chamfer,0,1,cylinder,0,2
rail,0,0,box,36,5
rail,0,0,capsule,0,2
rail,0,0,upright,0,5
rail,0,0,sphere,0,4
rail,0,0,cylinder,8,3
rail,0,1,box,36,5
rail,0,1,capsule,0,2
rail,0,1,upright,0,5
rail,0,1,sphere,0,4
rail,0,1,cylinder,8,3

1 scene preset mirror body ghosts runs
103 chamfer 0 0 cylinder 0 2
104 chamfer 0 1 box 0 2
105 chamfer 0 1 cylinder 0 2
106 rail 0 0 box 36 5
107 rail 0 0 capsule 0 2
108 rail 0 0 upright 0 5
109 rail 0 0 sphere 0 4
110 rail 0 0 cylinder 8 3
111 rail 0 1 box 36 5
112 rail 0 1 capsule 0 2
113 rail 0 1 upright 0 5
114 rail 0 1 sphere 0 4
115 rail 0 1 cylinder 8 3

View file

@ -103,3 +103,13 @@ chamfer,0,0,box,0,2
chamfer,0,0,cylinder,0,2
chamfer,0,1,box,0,2
chamfer,0,1,cylinder,0,2
rail,0,0,box,0,5
rail,0,0,capsule,0,4
rail,0,0,upright,0,5
rail,0,0,sphere,0,5
rail,0,0,cylinder,0,4
rail,0,1,box,0,5
rail,0,1,capsule,0,4
rail,0,1,upright,0,5
rail,0,1,sphere,0,5
rail,0,1,cylinder,0,4

1 scene preset mirror body ghosts runs
103 chamfer 0 0 cylinder 0 2
104 chamfer 0 1 box 0 2
105 chamfer 0 1 cylinder 0 2
106 rail 0 0 box 0 5
107 rail 0 0 capsule 0 4
108 rail 0 0 upright 0 5
109 rail 0 0 sphere 0 5
110 rail 0 0 cylinder 0 4
111 rail 0 1 box 0 5
112 rail 0 1 capsule 0 4
113 rail 0 1 upright 0 5
114 rail 0 1 sphere 0 5
115 rail 0 1 cylinder 0 4

View file

@ -18,7 +18,7 @@
#include <string.h>
// Command line and result file keys
static const char* s_sceneKeys[e_ghostSceneCount] = { "flat", "ramp", "cliff", "crest", "bumps", "tjunction", "peel", "chamfer" };
static const char* s_sceneKeys[e_ghostSceneCount] = { "flat", "ramp", "cliff", "crest", "bumps", "tjunction", "peel", "chamfer", "rail" };
static const char* s_bodyKeys[e_ghostBodyCount] = { "box", "capsule", "upright", "sphere", "cylinder" };
#define MAX_CONFIGS 256

View file

@ -1628,7 +1628,6 @@ typedef struct b3SimplexCache
/// Value use to compare length, area, volume of two simplexes.
float metric;
// todo use an index of 0xFF as a sentinel and remove the count
/// The number of stored simplex points
uint16_t count;
@ -2813,6 +2812,12 @@ typedef struct b3ManifoldPoint
/// Did this contact point exist in the previous step?
bool persisted;
// b3TriangleFeature
uint8_t triangleFeature;
// b3MeshContactFlags
uint8_t meshFlags;
} b3ManifoldPoint;
/// A contact manifold describes the contact points between colliding shapes.
@ -2840,7 +2845,7 @@ typedef struct b3Manifold
} b3Manifold;
/// Cached separating axis feature.
typedef enum
typedef enum b3SeparatingFeature
{
b3_invalidAxis = 0,
b3_backsideAxis,
@ -2856,7 +2861,7 @@ typedef enum
} b3SeparatingFeature;
/// Cached triangle feature.
typedef enum
typedef enum b3TriangleFeature
{
b3_featureNone = 0,
b3_featureTriangleFace,
@ -2872,6 +2877,16 @@ typedef enum
b3_featureVertex3
} b3TriangleFeature;
/// This gives debug information about how a contact point was generated.
typedef enum b3MeshContactFlags
{
b3_meshContactHullFace = 0x01,
b3_meshContactSnapped = 0x02,
b3_meshContactUnverified = 0x04,
b3_meshContactDeep = 0x08,
b3_meshContactBlocked = 0x10,
} b3MeshContactFlags;
/// Separating axis test cache. Provides temporal acceleration of collision routines.
typedef struct
{
@ -2923,6 +2938,12 @@ typedef struct b3LocalManifoldPoint
/// The triangle index when collide with a mesh or height-field.
int triangleIndex;
// b3TriangleFeature
uint8_t triangleFeature;
// b3MeshContactFlags
uint8_t meshFlags;
} b3LocalManifoldPoint;
/// A local manifold with no dynamic information. Used by b3Collide functions.

View file

@ -2,6 +2,7 @@
// SPDX-License-Identifier: MIT
#include "gfx/draw.h"
#include "gfx/keycodes.h"
#include "imgui.h"
#include "mesh_loader.h"
#include "meshoptimizer.h"
@ -2267,3 +2268,317 @@ public:
};
static int sampleRollingDeck = RegisterSample( "Issues", "Rolling Deck", RollingDeck::Create );
// A car made of one dynamic box (the chassis) and four ray cast 'wheels'.
// There are no wheel bodies and no joints.
// W/S to drive, A/D to steer and Space to brake. T toggles a camera that follows the car.
// Each step every wheel casts a ray down the chassis' own down axis. Where a ray hits the ground
// the wheel applies two forces to the chassis at the contact point:
// - a spring and damper force along the contact normal, which holds the chassis up
// - a tyre force in the contact plane, which drives, brakes and stops the wheel sliding sideways
// The tyre force is limited by friction times the spring force, so a wheel that is lightly loaded
// grips less. Weight transfer, body roll and rollover come from where these forces are applied.
class RaycastVehicle : public Sample
{
public:
static constexpr int m_wheelCount = 4;
static constexpr uint64_t m_vehicleBit = 0x2;
struct Wheel
{
b3Vec3 localMount;
bool steered;
// Distance from the mount down to the wheel's center
float suspensionLength;
bool grounded;
// Rotation about the axle, for drawing only
float spinAngle;
float spinSpeed;
};
explicit RaycastVehicle( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 25.0f, 20.0f, 12.0f, { 0.0f, 1.0f, 0.0f } );
}
m_suspensionHertz = 1.5f;
m_suspensionDampingRatio = 0.45f;
m_friction = 1.0f;
m_wheelRadius = 0.35f;
m_suspensionTravel = 0.3f;
m_engineAcceleration = 5.0f;
m_brakeDeceleration = 8.0f;
m_maxSteeringAngle = 0.15f * B3_PI;
m_steeringAngle = 0.0f;
AddGroundBox( 100.0f );
// A ramp to show the suspension working
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.position = { 15.0f, -0.5f, 0.0f };
bodyDef.rotation = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 0.1f );
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
b3BoxHull box = b3MakeBoxHull( 6.0f, 0.5f, 4.0f );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
// The chassis is the only body. Its shape has its own category so the wheel rays can skip
// it.
float halfLength = 2.2f;
float halfHeight = 0.7f;
float halfWidth = 0.9f;
{
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = { 0.0f, 1.2f, 0.0f };
m_chassisId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 130.0f;
shapeDef.filter.categoryBits = m_vehicleBit;
b3BoxHull box = b3MakeBoxHull( halfLength, halfHeight, halfWidth );
b3CreateHullShape( m_chassisId, &shapeDef, &box.base );
// A car tips over when its lateral acceleration exceeds half the track width divided by
// the height of its center of mass. At the middle of this box the center of mass would
// be about as high as the half track, and the car would roll before its tyres slide.
// Lower it to near the floor, where the heavy parts of a car are.
b3MassData massData = b3Body_GetMassData( m_chassisId );
massData.center = { 0.0f, -0.45f, 0.0f };
b3Body_SetMassData( m_chassisId, massData );
}
// The mounts are the top of each wheel's travel, inside the chassis at the sides. +x is
// forward.
float axle = 0.75f * halfLength;
float mountHeight = -0.3f;
m_wheels[0] = { { axle, mountHeight, halfWidth }, true, m_suspensionTravel };
m_wheels[1] = { { axle, mountHeight, -halfWidth }, true, m_suspensionTravel };
m_wheels[2] = { { -axle, mountHeight, halfWidth }, false, m_suspensionTravel };
m_wheels[3] = { { -axle, mountHeight, -halfWidth }, false, m_suspensionTravel };
// A cylinder along its y axis, centered, for drawing the wheels
float wheelWidth = 0.25f;
m_wheelHull = b3CreateCylinder( wheelWidth, m_wheelRadius, -0.5f * wheelWidth, 12 );
}
~RaycastVehicle() override
{
b3DestroyHull( m_wheelHull );
if ( m_camera->m_thirdPerson )
{
ToggleThirdPerson();
}
}
void Keyboard( int key, int action, int mods ) override
{
if ( key == KEY_T && action == ACTION_PRESS )
{
ToggleThirdPerson();
}
}
bool DrawControls() override
{
ImGui::SliderFloat( "Suspension Hertz", &m_suspensionHertz, 0.5f, 5.0f, "%.1f" );
ImGui::SliderFloat( "Suspension Damping", &m_suspensionDampingRatio, 0.0f, 2.0f, "%.2f" );
ImGui::SliderFloat( "Tyre Friction", &m_friction, 0.0f, 2.0f, "%.2f" );
bool thirdPerson = m_camera->m_thirdPerson;
if ( ImGui::Checkbox( "Third Person (T)", &thirdPerson ) )
{
ToggleThirdPerson();
}
return true;
}
// Apply the forces of every wheel to the chassis for the coming step
void UpdateWheels( float timeStep, float throttle, float brake, float steer )
{
b3WorldTransform transform = b3Body_GetTransform( m_chassisId );
b3Vec3 forward = b3RotateVector( transform.q, b3Vec3_axisX );
// The acceleration the driver asks for along the chassis' nose. The brake opposes the
// chassis' motion and is capped at what stops it this step, so it never drives it
// backwards.
float speed = b3Dot( b3Body_GetLinearVelocity( m_chassisId ), forward );
float acceleration = m_engineAcceleration * throttle;
float stopping = b3MinFloat( m_brakeDeceleration * brake, b3AbsFloat( speed ) / timeStep );
acceleration -= speed > 0.0f ? stopping : -stopping;
for ( int i = 0; i < m_wheelCount; ++i )
{
UpdateWheel( m_wheels[i], transform, timeStep, acceleration, steer );
}
}
// Cast one wheel's ray and apply its suspension and tyre forces to the chassis
void UpdateWheel( Wheel& wheel, b3WorldTransform transform, float timeStep, float acceleration,
float steer )
{
b3Vec3 up = b3RotateVector( transform.q, b3Vec3_axisY );
b3Vec3 forward = b3RotateVector( transform.q, b3Vec3_axisX );
// The ray reaches from the mount down through the spring's travel and the wheel's radius
float reach = m_suspensionTravel + m_wheelRadius;
b3Vec3 translation = b3MulSV( -reach, up );
b3QueryFilter filter = b3DefaultQueryFilter();
filter.categoryBits = m_vehicleBit;
filter.maskBits = ~m_vehicleBit;
b3Pos mount = b3TransformWorldPoint( transform, wheel.localMount );
b3RayResult hit = b3World_CastRayClosest( m_worldId, mount, translation, filter );
wheel.grounded = hit.hit;
float fraction = hit.hit ? hit.fraction : 1.0f;
wheel.suspensionLength = fraction * reach - m_wheelRadius;
// A wheel turns at the speed of the ground under it, and keeps that speed in the air
wheel.spinAngle = b3UnwindAngle( wheel.spinAngle + wheel.spinSpeed * timeStep );
if ( hit.hit == false )
{
return;
}
// Each wheel carries an equal share of the mass. The spring rate gives that share the
// requested natural frequency.
float share = b3Body_GetMass( m_chassisId ) / m_wheelCount;
float omega = 2.0f * B3_PI * m_suspensionHertz;
float stiffness = share * omega * omega;
float damping = 2.0f * m_suspensionDampingRatio * share * omega;
// Suspension. A spring only pushes: a negative load would pull the chassis onto the
// ground and hold it there through a jump.
float compression = ( 1.0f - hit.fraction ) * reach;
float compressionSpeed = -b3Dot( b3Body_GetWorldPointVelocity( m_chassisId, mount ), up );
float load = b3MaxFloat( stiffness * compression + damping * compressionSpeed, 0.0f );
b3Body_ApplyForce( m_chassisId, b3MulSV( load, hit.normal ), hit.point, true );
// The wheel's rolling direction in the contact plane, and the direction across it
b3Vec3 heading = forward;
if ( wheel.steered )
{
heading = b3RotateVector( b3MakeQuatFromAxisAngle( up, steer ), forward );
}
b3Vec3 rolling =
b3Normalize( b3MulAdd( heading, -b3Dot( heading, hit.normal ), hit.normal ) );
b3Vec3 lateral = b3Cross( hit.normal, rolling );
// The lateral force cancels the contact point's sideways sliding in one step. The rolling
// force gives this wheel's share of the mass the requested acceleration, resolved onto the
// wheel, so a steered wheel puts less of it into the nose direction.
b3Vec3 contactVelocity = b3Body_GetWorldPointVelocity( m_chassisId, hit.point );
float lateralForce = -share * b3Dot( contactVelocity, lateral ) / timeStep;
float rollingForce = share * acceleration * b3Dot( forward, rolling );
// Rolling forward along +x turns the wheel backwards about its axle, the chassis' +z
wheel.spinSpeed = -b3Dot( contactVelocity, rolling ) / m_wheelRadius;
// Friction circle: the tyre cannot give more than friction times the load on it
float maxForce = m_friction * load;
float magnitude = sqrtf( lateralForce * lateralForce + rollingForce * rollingForce );
if ( magnitude > maxForce )
{
lateralForce *= maxForce / magnitude;
rollingForce *= maxForce / magnitude;
}
b3Vec3 tyreForce =
b3Add( b3MulSV( rollingForce, rolling ), b3MulSV( lateralForce, lateral ) );
b3Body_ApplyForce( m_chassisId, tyreForce, hit.point, true );
}
void Step() override
{
float throttle = 0.0f;
throttle += IsKeyDown( KEY_W ) ? 1.0f : 0.0f;
throttle -= IsKeyDown( KEY_S ) ? 1.0f : 0.0f;
float brake = IsKeyDown( KEY_SPACE ) ? 1.0f : 0.0f;
m_steeringAngle = 0.0f;
m_steeringAngle += IsKeyDown( KEY_A ) ? m_maxSteeringAngle : 0.0f;
m_steeringAngle -= IsKeyDown( KEY_D ) ? m_maxSteeringAngle : 0.0f;
// Forces accumulate until the world steps, so apply them only on a step that runs
bool stepping = m_context->pause == false || m_context->singleStep > 0;
if ( stepping && m_context->hertz > 0.0f )
{
UpdateWheels( 1.0f / m_context->hertz, throttle, brake, m_steeringAngle );
}
if ( m_camera->m_thirdPerson )
{
m_camera->m_pivot = b3Body_GetPosition( m_chassisId );
m_camera->UpdateTransform();
}
Sample::Step();
}
void Render() override
{
Sample::Render();
b3WorldTransform transform = b3Body_GetTransform( m_chassisId );
b3Vec3 down = b3RotateVector( transform.q, b3Neg( b3Vec3_axisY ) );
// The wheel cylinder is along y. This turns it onto the axle, the chassis' z.
b3Quat cylinderToAxle = b3MakeQuatFromAxisAngle( b3Vec3_axisX, 0.5f * B3_PI );
for ( int i = 0; i < m_wheelCount; ++i )
{
const Wheel& wheel = m_wheels[i];
b3Pos mount = b3TransformWorldPoint( transform, wheel.localMount );
b3Pos center = b3OffsetPos( mount, b3MulSV( wheel.suspensionLength, down ) );
float steer = wheel.steered ? m_steeringAngle : 0.0f;
b3Quat q = b3MulQuat( transform.q, b3MakeQuatFromAxisAngle( b3Vec3_axisY, steer ) );
q = b3MulQuat( q, b3MakeQuatFromAxisAngle( b3Vec3_axisZ, wheel.spinAngle ) );
q = b3MulQuat( q, cylinderToAxle );
b3HexColor color = wheel.grounded ? b3_colorGreen : b3_colorRed;
DrawLine( mount, center, MakeColor( color ) );
DrawHull( { center, q }, m_wheelHull, MakeColor( b3_colorGray ) );
}
b3Vec3 forward = b3RotateVector( b3Body_GetRotation( m_chassisId ), b3Vec3_axisX );
float speed = b3Dot( b3Body_GetLinearVelocity( m_chassisId ), forward );
DrawTextLine( "speed = %.1f m/s", speed );
}
static Sample* Create( SampleContext* context )
{
return new RaycastVehicle( context );
}
b3BodyId m_chassisId;
Wheel m_wheels[m_wheelCount];
b3HullData* m_wheelHull;
float m_suspensionHertz;
float m_suspensionDampingRatio;
float m_friction;
float m_wheelRadius;
float m_suspensionTravel;
float m_engineAcceleration;
float m_brakeDeceleration;
float m_maxSteeringAngle;
float m_steeringAngle;
};
static int sampleRaycastVehicle =
RegisterSample( "Vehicle", "Raycast Vehicle", RaycastVehicle::Create );

View file

@ -2320,6 +2320,8 @@ public:
m_upperSteeringDegrees = 45.0f;
m_maxSteeringTorque = 5.0f;
m_targetSteeringDegrees = 0.0f;
m_wheelType = WheelType::sphere;
m_cylinderSides = 16;
b3BodyId groundId;
{
@ -2371,15 +2373,10 @@ public:
b3CreateParallelJoint( m_worldId, &parallelJointDef );
}
shapeDef.density = 2.0f;
shapeDef.baseMaterial.friction = 3.0f;
bodyDef.type = b3_dynamicBody;
bodyDef.allowFastRotation = true;
bodyDef.rotation = b3ComputeQuatBetweenUnitVectors( b3Vec3_axisY, b3Vec3_axisZ );
// b3HullData* hull = b3CreateCylinder( 0.25f, 0.4f, 0.0f, 16 );
b3WheelJointDef jointDef = b3DefaultWheelJointDef();
jointDef.base.bodyIdA = m_chassisId;
jointDef.base.localFrameA.q = b3ComputeQuatBetweenUnitVectors( b3Vec3_axisX, b3Vec3_axisY );
@ -2401,15 +2398,11 @@ public:
jointDef.lowerSteeringLimit = B3_PI / 180.0f * m_lowerSteeringDegrees;
jointDef.upperSteeringLimit = B3_PI / 180.0f * m_upperSteeringDegrees;
b3Sphere sphere = { b3Vec3_zero, 0.4f };
{
bodyDef.position = { 1.5f, 2.0f, 0.8f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
// b3CreateHullShape( bodyId, &shapeDef, hull );
m_wheelIds[0] = b3CreateBody( m_worldId, &bodyDef );
jointDef.base.bodyIdB = bodyId;
jointDef.base.bodyIdB = m_wheelIds[0];
jointDef.base.localFrameA.p = { 1.5f, -0.5f, 0.8f };
jointDef.enableSteering = true;
jointDef.enableSpinMotor = false;
@ -2418,11 +2411,9 @@ public:
{
bodyDef.position = { 1.5f, 2.0f, -0.8f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
// b3CreateHullShape( bodyId, &shapeDef, hull );
m_wheelIds[1] = b3CreateBody( m_worldId, &bodyDef );
jointDef.base.bodyIdB = bodyId;
jointDef.base.bodyIdB = m_wheelIds[1];
jointDef.base.localFrameA.p = { 1.5f, -0.5f, -0.8f };
jointDef.enableSteering = true;
jointDef.enableSpinMotor = false;
@ -2431,11 +2422,9 @@ public:
{
bodyDef.position = { -1.5f, 2.0f, 0.8f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
// b3CreateHullShape( bodyId, &shapeDef, hull );
m_wheelIds[2] = b3CreateBody( m_worldId, &bodyDef );
jointDef.base.bodyIdB = bodyId;
jointDef.base.bodyIdB = m_wheelIds[2];
jointDef.base.localFrameA.p = { -1.5f, -0.5f, 0.8f };
jointDef.enableSteering = false;
jointDef.enableSpinMotor = true;
@ -2444,18 +2433,21 @@ public:
{
bodyDef.position = { -1.5f, 2.0f, -0.8f };
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
// b3CreateHullShape( bodyId, &shapeDef, hull );
m_wheelIds[3] = b3CreateBody( m_worldId, &bodyDef );
jointDef.base.bodyIdB = bodyId;
jointDef.base.bodyIdB = m_wheelIds[3];
jointDef.base.localFrameA.p = { -1.5f, -0.5f, -0.8f };
jointDef.enableSteering = false;
jointDef.enableSpinMotor = true;
m_rearRightId = b3CreateWheelJoint( m_worldId, &jointDef );
}
// b3DestroyHull( hull );
for ( int i = 0; i < 4; ++i )
{
m_wheelShapeIds[i] = b3_nullShapeId;
}
CreateWheelShapes();
m_camera->m_thirdPerson = false;
@ -2474,6 +2466,59 @@ public:
b3DestroyHeightField( m_heightField );
}
void CreateWheelShapes()
{
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.density = 2.0f;
shapeDef.baseMaterial.friction = 3.0f;
float radius = 0.4f;
float width = 0.25f;
b3HullData* cylinder = nullptr;
if ( m_wheelType == WheelType::cylinder )
{
float w = 1.5f * width;
cylinder = b3CreateCylinder( w, radius, -0.5f * w, m_cylinderSides );
}
for ( int i = 0; i < 4; ++i )
{
if ( B3_IS_NON_NULL( m_wheelShapeIds[i] ) )
{
b3DestroyShape( m_wheelShapeIds[i], false );
}
b3BodyId bodyId = m_wheelIds[i];
switch ( m_wheelType )
{
case WheelType::sphere:
{
b3Sphere sphere = { b3Vec3_zero, radius };
m_wheelShapeIds[i] = b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
break;
case WheelType::capsule:
{
b3Capsule capsule = { { 0.0f, -0.5f * width, 0.0f }, { 0.0f, 0.5f * width, 0.0f }, radius };
m_wheelShapeIds[i] = b3CreateCapsuleShape( bodyId, &shapeDef, &capsule );
}
break;
case WheelType::cylinder:
m_wheelShapeIds[i] = b3CreateHullShape( bodyId, &shapeDef, cylinder );
break;
}
}
if ( cylinder != nullptr )
{
b3DestroyHull( cylinder );
}
}
void Keyboard( int key, int action, int mods ) override
{
if ( key == KEY_T && action == ACTION_PRESS )
@ -2484,6 +2529,32 @@ public:
bool DrawControls() override
{
ImGui::Text( "Wheels" );
if ( ImGui::RadioButton( "Sphere", m_wheelType == WheelType::sphere ) )
{
m_wheelType = WheelType::sphere;
CreateWheelShapes();
}
if ( ImGui::RadioButton( "Capsule", m_wheelType == WheelType::capsule ) )
{
m_wheelType = WheelType::capsule;
CreateWheelShapes();
}
if ( ImGui::RadioButton( "Cylinder", m_wheelType == WheelType::cylinder ) )
{
m_wheelType = WheelType::cylinder;
CreateWheelShapes();
}
if ( ImGui::SliderInt( "Sides", &m_cylinderSides, 3, 32 ) && m_wheelType == WheelType::cylinder )
{
CreateWheelShapes();
}
ImGui::Separator();
ImGui::Text( "Suspension" );
if ( ImGui::SliderFloat( "Min##Suspension", &m_lowerTranslation, -10.0f, 10.0f, "%.1f" ) )
{
@ -2659,8 +2730,19 @@ public:
return new Driving( context );
}
enum class WheelType
{
sphere,
capsule,
cylinder,
};
b3HeightFieldData* m_heightField;
b3BodyId m_chassisId;
b3BodyId m_wheelIds[4];
b3ShapeId m_wheelShapeIds[4];
WheelType m_wheelType;
int m_cylinderSides;
b3JointId m_frontLeftId;
b3JointId m_frontRightId;
b3JointId m_rearLeftId;

View file

@ -2666,6 +2666,45 @@ static void BuildGhostChamferExtended( std::vector<GhostMesh>& meshes )
BuildChamferBeam( meshes, 6.0f );
}
// A conveyor side rail running along x, from the Conveyor Circuit sample. The upper half of the inner
// wall facing -z and the 8 cm rail top meet at a convex edge, two cells along x so the vertex at x = 0
// is interior. Quad diagonals alternate as in the conveyor mesh.
static void BuildGhostRail( std::vector<GhostMesh>& meshes )
{
GhostMesh mesh;
b3Vec2 section[3] = { { 0.0f, 0.175f }, { 0.0f, 0.35f }, { 0.08f, 0.35f } };
for ( int row = 0; row < 3; ++row )
{
for ( int column = 0; column < 3; ++column )
{
mesh.vertices.push_back( { -0.25f + 0.25f * column, section[row].y, section[row].x } );
}
}
b3Vec3 facings[2] = { { 0.0f, 0.0f, -1.0f }, b3Vec3_axisY };
for ( int row = 0; row < 2; ++row )
{
for ( int column = 0; column < 2; ++column )
{
int a = 3 * row + column;
int b = a + 1;
int c = a + 4;
int d = a + 3;
if ( ( row + column ) & 1 )
{
AddGhostTriangle( mesh, a, d, b, facings[row] );
AddGhostTriangle( mesh, d, c, b, facings[row] );
}
else
{
AddGhostTriangle( mesh, a, d, c, facings[row] );
AddGhostTriangle( mesh, c, b, a, facings[row] );
}
}
}
meshes.push_back( mesh );
}
static const float s_inch = 0.0254f;
static const GhostScene s_hullGhostScenes[] = {
@ -2759,6 +2798,19 @@ static const GhostScene s_hullGhostScenes[] = {
{ 0.0f, 0.0f, 0.0f },
false,
},
{
"Rail edge",
"box pitched 60 degrees across the rail, its face cuts the convex rail edge 7 cm past the x = 0 "
"vertex, the real contact is edge on edge and perpendicular to the rail",
"the edge pair is shallower than the hull face and the hull face normal crosses the rail edge, so "
"SAT takes the edge pair. Without that the hull face is admitted at a rail edge vertex and leans 60 "
"degrees along the rail.",
BuildGhostRail,
{ 0.4f, 0.2f, 0.4f },
{ 0.1f, 0.77f, -0.15f },
{ -15.0f, 0.0f, 60.0f },
true,
},
};
class HullGhostManifold : public GhostManifold

View file

@ -5,15 +5,20 @@
#include "human.h"
#include "mesh_loader.h"
#include "sample.h"
#include "utils.h"
#include "gfx/draw.h"
#include "gfx/debug_adapter.h"
#include "box3d/box3d.h"
#include <algorithm>
#include <float.h>
#include <imgui.h>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
enum class ShapeType
{
@ -1774,3 +1779,953 @@ public:
};
static int sampleGhostCollisions = RegisterSample( "Mesh", "Ghost Collisions", GhostCollisions::Create );
// A closed conveyor circuit swept from a channel profile and finely tessellated, so every body slides over
// thousands of internal edges. The loop runs over a washboard, up a helix, through a chicane and down a
// sharp ramp.
// A pushing manifold is counted as a ghost when its normal matches no nearby triangle and does not lie
// on the arc between two triangles that meet at a convex crease.
class ConveyorCircuit : public Sample
{
public:
enum BodyType
{
e_mixedBody,
e_boxBody,
e_capsuleBody,
e_sphereBody,
e_cylinderBody,
e_bodyTypeCount
};
static constexpr int m_maxBodies = 300;
static constexpr int m_markerCapacity = 256;
// Material 0 is the rails and skirts, the rest are belt directions
static constexpr int m_yawBinCount = 128;
static constexpr int m_materialCount = m_yawBinCount + 1;
static constexpr int m_segmentCount = 8;
static constexpr int m_profileCount = 8;
static constexpr float m_radius = 5.0f;
static constexpr float m_straightLength = 16.0f;
static constexpr float m_chicaneRadius = 3.0f;
static constexpr float m_chicaneAngle = 25.0f * B3_DEG_TO_RAD;
static constexpr float m_halfWidth = 1.0f;
static constexpr float m_railHeight = 0.35f;
static constexpr float m_railThickness = 0.08f;
static constexpr float m_skirtDepth = 0.4f;
static constexpr float m_baseHeight = 1.0f;
static constexpr float m_liftHeight = 1.5f;
static constexpr float m_bumpStart = 5.0f;
static constexpr float m_bumpEnd = 11.0f;
static constexpr float m_bumpLength = 1.0f;
static constexpr float m_bumpHeight = 0.06f;
static constexpr float m_rampLength = 6.0f;
static constexpr float m_spawnDistance = 1.0f;
struct Segment
{
float length;
float curvature;
};
enum GhostClass
{
e_faceGhost,
e_edgeGhost,
e_vertexGhost,
e_otherGhost,
e_ghostClassCount
};
struct Marker
{
b3Pos point;
b3Vec3 normal;
};
explicit ConveyorCircuit( SampleContext* context )
: Sample( context )
{
if ( context->restart == false )
{
m_camera->SetView( 35.0f, 40.0f, 38.0f, { 0.0f, 1.5f, 0.0f } );
}
AddGroundBox( 30.0f );
float chicaneArc = m_chicaneRadius * m_chicaneAngle;
float chicaneAdvance = 4.0f * m_chicaneRadius * sinf( m_chicaneAngle );
float lead = 2.0f;
// The chicane returns to the original heading and line, so the loop still closes
m_segments[0] = { m_straightLength, 0.0f };
m_segments[1] = { B3_PI * m_radius, 1.0f / m_radius };
m_segments[2] = { lead, 0.0f };
m_segments[3] = { chicaneArc, 1.0f / m_chicaneRadius };
m_segments[4] = { 2.0f * chicaneArc, -1.0f / m_chicaneRadius };
m_segments[5] = { chicaneArc, 1.0f / m_chicaneRadius };
m_segments[6] = { m_straightLength - lead - chicaneAdvance, 0.0f };
m_segments[7] = { B3_PI * m_radius, 1.0f / m_radius };
m_totalLength = 0.0f;
for ( int i = 0; i < m_segmentCount; ++i )
{
m_segmentStart[i] = m_totalLength;
m_totalLength += m_segments[i].length;
}
// Channel cross section in lateral and up coordinates, traversed with air on the left
m_profile[0] = { -m_halfWidth - m_railThickness, -m_skirtDepth };
m_profile[1] = { -m_halfWidth - m_railThickness, m_railHeight };
m_profile[2] = { -m_halfWidth, m_railHeight };
m_profile[3] = { -m_halfWidth, 0.0f };
m_profile[4] = { m_halfWidth, 0.0f };
m_profile[5] = { m_halfWidth, m_railHeight };
m_profile[6] = { m_halfWidth + m_railThickness, m_railHeight };
m_profile[7] = { m_halfWidth + m_railThickness, -m_skirtDepth };
m_cylinderHull = b3CreateCylinder( 0.4f, 0.25f, -0.2f, 16 );
m_cellSize = 0.25f;
m_beltSpeed = 2.5f;
m_targetCount = 80;
m_spawnInterval = 15;
m_bodyType = e_mixedBody;
m_toleranceDegrees = 10.0f;
m_contactRecycling = true;
m_drawFlow = true;
m_drawGhosts = true;
m_groundId = b3_nullBodyId;
m_bodyCount = 0;
m_spawnIndex = 0;
m_spawnTimer = 0;
ResetCounters();
CreateCircuit();
}
~ConveyorCircuit() override
{
DestroyCircuit();
b3DestroyHull( m_cylinderHull );
}
float EvaluateHeight( float s ) const
{
float helix0 = m_segmentStart[1];
float helix1 = m_segmentStart[2];
float ramp0 = m_segmentStart[6] + 1.0f;
float ramp1 = ramp0 + m_rampLength;
if ( s < helix0 )
{
if ( m_bumpStart <= s && s <= m_bumpEnd )
{
float phase = 2.0f * B3_PI * ( s - m_bumpStart ) / m_bumpLength;
return 0.5f * m_bumpHeight * ( 1.0f - cosf( phase ) );
}
return 0.0f;
}
if ( s < helix1 )
{
float u = ( s - helix0 ) / ( helix1 - helix0 );
return m_liftHeight * u * u * ( 3.0f - 2.0f * u );
}
if ( s < ramp0 )
{
return m_liftHeight;
}
// Linear with sharp creases at both ends
if ( s < ramp1 )
{
return m_liftHeight * ( ramp1 - s ) / m_rampLength;
}
return 0.0f;
}
b3Vec3 EvaluateCenter( float s ) const
{
float x = -0.5f * m_straightLength;
float z = -m_radius;
float yaw = 0.0f;
float remaining = s;
for ( int i = 0; i < m_segmentCount && remaining > 0.0f; ++i )
{
float ds = b3MinFloat( remaining, m_segments[i].length );
float k = m_segments[i].curvature;
if ( k == 0.0f )
{
x += ds * cosf( yaw );
z += ds * sinf( yaw );
}
else
{
float yaw1 = yaw + k * ds;
x += ( sinf( yaw1 ) - sinf( yaw ) ) / k;
z -= ( cosf( yaw1 ) - cosf( yaw ) ) / k;
yaw = yaw1;
}
remaining -= ds;
}
return { x, m_baseHeight + EvaluateHeight( s ), z };
}
void BuildStations()
{
int count = b3MaxInt( 32, (int)ceilf( m_totalLength / m_cellSize ) );
m_stations.resize( count );
m_tangents.resize( count );
m_laterals.resize( count );
m_ups.resize( count );
for ( int k = 0; k < count; ++k )
{
m_stations[k] = EvaluateCenter( m_totalLength * (float)k / (float)count );
}
// The chord across each station bisects a crease, so the rails stay square to the belt
for ( int k = 0; k < count; ++k )
{
b3Vec3 next = m_stations[( k + 1 ) % count];
b3Vec3 prev = m_stations[( k + count - 1 ) % count];
b3Vec3 t = b3Normalize( next - prev );
b3Vec3 l = b3Normalize( b3Cross( t, b3Vec3_axisY ) );
m_tangents[k] = t;
m_laterals[k] = l;
m_ups[k] = b3Cross( l, t );
}
}
b3SurfaceMaterial MakeMaterial( int index ) const
{
b3SurfaceMaterial material = b3DefaultSurfaceMaterial();
if ( index == 0 )
{
material.friction = 0.2f;
material.customColor = b3_colorGoldenRod;
return material;
}
// Horizontal is enough, the solver projects tangent velocity onto the contact plane
float yaw = -B3_PI + 2.0f * B3_PI * (float)( index - 1 ) / (float)m_yawBinCount;
material.friction = 0.8f;
material.tangentVelocity = { m_beltSpeed * cosf( yaw ), 0.0f, m_beltSpeed * sinf( yaw ) };
material.customColor = b3_colorSlateGray;
return material;
}
void CreateCircuit()
{
BuildStations();
// The last row repeats the first station and welds to it, closing the loop
int stationCount = (int)m_stations.size();
std::vector<b3Vec3> vertices;
std::vector<int32_t> indices;
std::vector<uint8_t> materialIndices;
for ( int j = 0; j + 1 < m_profileCount; ++j )
{
b3Vec2 pa = m_profile[j];
b3Vec2 delta = { m_profile[j + 1].x - pa.x, m_profile[j + 1].y - pa.y };
float length = sqrtf( delta.x * delta.x + delta.y * delta.y );
int columnCount = b3MaxInt( 1, (int)ceilf( length / m_cellSize - 0.01f ) );
bool floor = j == 3;
int base = (int)vertices.size();
int stride = columnCount + 1;
for ( int k = 0; k <= stationCount; ++k )
{
int station = k % stationCount;
for ( int i = 0; i <= columnCount; ++i )
{
float alpha = (float)i / (float)columnCount;
float u = pa.x + alpha * delta.x;
float v = pa.y + alpha * delta.y;
vertices.push_back( m_stations[station] + u * m_laterals[station] + v * m_ups[station] );
}
}
for ( int k = 0; k < stationCount; ++k )
{
int station = k;
b3Vec3 expected = -delta.y * m_laterals[station] + delta.x * m_ups[station];
int material = 0;
if ( floor )
{
b3Vec3 direction = m_stations[( k + 1 ) % stationCount] - m_stations[station];
float yaw = atan2f( direction.z, direction.x );
int bin = (int)floorf( ( yaw + B3_PI ) / ( 2.0f * B3_PI ) * m_yawBinCount + 0.5f );
material = 1 + bin % m_yawBinCount;
}
for ( int i = 0; i < columnCount; ++i )
{
int a = base + k * stride + i;
int b = a + 1;
int c = a + stride + 1;
int d = a + stride;
int corners[6] = { a, b, c, c, d, a };
if ( ( k + i ) & 1 )
{
int flipped[6] = { a, b, d, b, c, d };
memcpy( corners, flipped, sizeof( corners ) );
}
for ( int n = 0; n < 6; n += 3 )
{
b3Vec3 v1 = vertices[corners[n]];
b3Vec3 v2 = vertices[corners[n + 1]];
b3Vec3 v3 = vertices[corners[n + 2]];
bool reversed = b3Dot( b3Cross( v2 - v1, v3 - v1 ), expected ) < 0.0f;
indices.push_back( corners[n] );
indices.push_back( reversed ? corners[n + 2] : corners[n + 1] );
indices.push_back( reversed ? corners[n + 1] : corners[n + 2] );
materialIndices.push_back( (uint8_t)material );
}
}
}
}
b3MeshDef meshDef = {};
meshDef.vertices = vertices.data();
meshDef.indices = indices.data();
meshDef.materialIndices = materialIndices.data();
meshDef.vertexCount = (int)vertices.size();
meshDef.triangleCount = (int)( indices.size() / 3 );
meshDef.weldVertices = true;
meshDef.weldTolerance = 0.001f;
meshDef.identifyEdges = true;
m_mesh = b3CreateMesh( &meshDef, nullptr, 0 );
b3SurfaceMaterial materials[m_materialCount];
for ( int i = 0; i < m_materialCount; ++i )
{
materials[i] = MakeMaterial( i );
}
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.name = "circuit";
m_groundId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.materials = materials;
shapeDef.materialCount = m_materialCount;
m_shapeId = b3CreateMeshShape( m_groundId, &shapeDef, m_mesh, b3Vec3_one );
BuildAdjacency();
m_markerCount = 0;
m_markerIndex = 0;
}
// The body holding the mesh shapes must go before the mesh data
void DestroyCircuit()
{
if ( B3_IS_NON_NULL( m_groundId ) )
{
b3DestroyBody( m_groundId );
m_groundId = b3_nullBodyId;
}
if ( m_mesh != nullptr )
{
b3DestroyMesh( m_mesh );
m_mesh = nullptr;
}
}
void UpdateBeltSpeed()
{
for ( int i = 1; i < m_materialCount; ++i )
{
b3Shape_SetMeshMaterial( m_shapeId, MakeMaterial( i ), i );
}
}
b3Pos GetSpawnPosition() const
{
b3Vec3 center = EvaluateCenter( m_spawnDistance );
float lateral = RandomFloatRange( -0.6f, 0.6f );
return b3ToPos( { center.x, center.y + 1.2f, center.z + lateral } );
}
void SpawnBody()
{
int type = m_bodyType == e_mixedBody ? 1 + m_spawnIndex % ( e_bodyTypeCount - 1 ) : m_bodyType;
m_spawnIndex += 1;
b3BodyDef bodyDef = b3DefaultBodyDef();
bodyDef.type = b3_dynamicBody;
bodyDef.position = GetSpawnPosition();
bodyDef.rotation = RandomQuat();
// A jammed body would fall asleep on a moving belt
bodyDef.enableSleep = false;
bodyDef.enableContactRecycling = m_contactRecycling;
b3BodyId bodyId = b3CreateBody( m_worldId, &bodyDef );
b3ShapeDef shapeDef = b3DefaultShapeDef();
shapeDef.baseMaterial.friction = 0.6f;
// Round bodies would roll back down the helix without it
shapeDef.baseMaterial.rollingResistance = 0.3f;
switch ( type )
{
case e_boxBody:
{
float halfLength = ( m_spawnIndex & 1 ) ? 0.4f : 0.25f;
b3BoxHull box = b3MakeBoxHull( halfLength, 0.15f, 0.25f );
b3CreateHullShape( bodyId, &shapeDef, &box.base );
}
break;
case e_capsuleBody:
{
b3Capsule capsule = { { -0.3f, 0.0f, 0.0f }, { 0.3f, 0.0f, 0.0f }, 0.15f };
b3CreateCapsuleShape( bodyId, &shapeDef, &capsule );
}
break;
case e_sphereBody:
{
b3Sphere sphere = { b3Vec3_zero, 0.25f };
b3CreateSphereShape( bodyId, &shapeDef, &sphere );
}
break;
default:
b3CreateHullShape( bodyId, &shapeDef, m_cylinderHull );
break;
}
m_bodyIds[m_bodyCount++] = bodyId;
}
void DestroyBodies()
{
for ( int i = 0; i < m_bodyCount; ++i )
{
b3DestroyBody( m_bodyIds[i] );
}
m_bodyCount = 0;
m_spawnIndex = 0;
m_spawnTimer = 0;
}
void ResetCounters()
{
memset( m_classCounts, 0, sizeof( m_classCounts ) );
memset( m_flagCounts, 0, sizeof( m_flagCounts ) );
m_ghostCount = 0;
m_manifoldCount = 0;
m_stepGhostCount = 0;
m_recycleCount = 0;
m_markerCount = 0;
m_markerIndex = 0;
}
void BuildAdjacency()
{
int triangleCount = m_mesh->triangleCount;
int vertexCount = m_mesh->vertexCount;
const b3MeshTriangle* triangles = b3GetMeshTriangles( m_mesh );
const b3Vec3* vertices = b3GetMeshVertices( m_mesh );
m_triangleNormals.resize( triangleCount );
m_edgeNeighbors.assign( 3 * triangleCount, B3_NULL_INDEX );
m_vertexRings.assign( vertexCount, {} );
m_vertexTriangles.assign( vertexCount, {} );
// Sorting by vertex pair puts the two sides of a shared edge next to each other
std::vector<std::pair<uint64_t, int>> edges;
edges.reserve( 3 * triangleCount );
for ( int t = 0; t < triangleCount; ++t )
{
int v[3] = { triangles[t].index1, triangles[t].index2, triangles[t].index3 };
m_triangleNormals[t] = b3Normalize( b3Cross( vertices[v[1]] - vertices[v[0]], vertices[v[2]] - vertices[v[0]] ) );
for ( int e = 0; e < 3; ++e )
{
int a = v[e];
int b = v[e < 2 ? e + 1 : 0];
uint64_t key = ( (uint64_t)b3MinInt( a, b ) << 32 ) | (uint64_t)b3MaxInt( a, b );
edges.push_back( { key, 3 * t + e } );
m_vertexRings[a].push_back( b );
m_vertexRings[b].push_back( a );
m_vertexTriangles[a].push_back( t );
}
}
std::sort( edges.begin(), edges.end() );
for ( size_t i = 0; i + 1 < edges.size(); ++i )
{
// A non-manifold edge leaves every side without a neighbor
uint64_t key = edges[i].first;
bool pair = edges[i + 1].first == key;
bool single = ( i + 2 >= edges.size() || edges[i + 2].first != key ) && ( i == 0 || edges[i - 1].first != key );
if ( pair && single )
{
m_edgeNeighbors[edges[i].second] = edges[i + 1].second / 3;
m_edgeNeighbors[edges[i + 1].second] = edges[i].second / 3;
}
}
for ( std::vector<int>& ring : m_vertexRings )
{
std::sort( ring.begin(), ring.end() );
ring.erase( std::unique( ring.begin(), ring.end() ), ring.end() );
}
}
bool MatchesFace( b3Vec3 normal, int triangleIndex ) const
{
return b3Dot( normal, m_triangleNormals[triangleIndex] ) >= m_cosTolerance;
}
// Direction in the face plane pointing away from the edge into the face
static b3Vec3 GetInwardDirection( b3Vec3 edgeStart, b3Vec3 axis, b3Vec3 opposite )
{
b3Vec3 d = opposite - edgeStart;
return b3Normalize( d - b3Dot( d, axis ) * axis );
}
// The normal cone of a convex edge is the arc between its two face normals. Neither face may rise
// above the edge along the normal, so a concave edge only admits its face normals.
bool AdmitsEdge( b3Vec3 normal, int triangleIndex, int edgeIndex ) const
{
int neighbor = m_edgeNeighbors[3 * triangleIndex + edgeIndex];
if ( MatchesFace( normal, triangleIndex ) || ( neighbor != B3_NULL_INDEX && MatchesFace( normal, neighbor ) ) )
{
return true;
}
const b3MeshTriangle* triangles = b3GetMeshTriangles( m_mesh );
const b3Vec3* vertices = b3GetMeshVertices( m_mesh );
int v[3] = { triangles[triangleIndex].index1, triangles[triangleIndex].index2, triangles[triangleIndex].index3 };
int ia = v[edgeIndex];
int ib = v[edgeIndex < 2 ? edgeIndex + 1 : 0];
int ic = v[edgeIndex > 0 ? edgeIndex - 1 : 2];
b3Vec3 a = vertices[ia];
b3Vec3 axis = b3Normalize( vertices[ib] - a );
if ( b3AbsFloat( b3Dot( normal, axis ) ) > m_sinTolerance )
{
return false;
}
if ( b3Dot( normal, GetInwardDirection( a, axis, vertices[ic] ) ) > m_sinTolerance )
{
return false;
}
if ( neighbor != B3_NULL_INDEX )
{
int w[3] = { triangles[neighbor].index1, triangles[neighbor].index2, triangles[neighbor].index3 };
for ( int k = 0; k < 3; ++k )
{
if ( w[k] != ia && w[k] != ib && b3Dot( normal, GetInwardDirection( a, axis, vertices[w[k]] ) ) > m_sinTolerance )
{
return false;
}
}
}
return true;
}
// A vertex normal is valid when the vertex is a local support point in that direction
bool AdmitsVertex( b3Vec3 normal, int vertexIndex ) const
{
for ( int t : m_vertexTriangles[vertexIndex] )
{
if ( MatchesFace( normal, t ) )
{
return true;
}
}
const b3Vec3* vertices = b3GetMeshVertices( m_mesh );
b3Vec3 vertex = vertices[vertexIndex];
for ( int other : m_vertexRings[vertexIndex] )
{
if ( b3Dot( normal, b3Normalize( vertices[other] - vertex ) ) > m_sinTolerance )
{
return false;
}
}
return true;
}
bool AdmitsPoint( b3Vec3 normal, const b3ManifoldPoint& point ) const
{
const b3MeshTriangle& triangle = b3GetMeshTriangles( m_mesh )[point.triangleIndex];
int v[3] = { triangle.index1, triangle.index2, triangle.index3 };
// The normal was replaced by the face normal of a nearby triangle
if ( point.meshFlags & b3_meshContactBlocked )
{
for ( int k = 0; k < 3; ++k )
{
for ( int other : m_vertexTriangles[v[k]] )
{
if ( MatchesFace( normal, other ) )
{
return true;
}
}
}
return false;
}
switch ( point.triangleFeature )
{
case b3_featureTriangleFace:
return MatchesFace( normal, point.triangleIndex );
case b3_featureEdge1:
case b3_featureEdge2:
case b3_featureEdge3:
return AdmitsEdge( normal, point.triangleIndex, point.triangleFeature - b3_featureEdge1 );
case b3_featureVertex1:
case b3_featureVertex2:
case b3_featureVertex3:
return AdmitsVertex( normal, v[point.triangleFeature - b3_featureVertex1] );
default:
// No feature was resolved, so any feature of the triangle may own the normal
if ( MatchesFace( normal, point.triangleIndex ) )
{
return true;
}
for ( int k = 0; k < 3; ++k )
{
if ( AdmitsEdge( normal, point.triangleIndex, k ) || AdmitsVertex( normal, v[k] ) )
{
return true;
}
}
return false;
}
}
static GhostClass Classify( const b3ManifoldPoint& point )
{
switch ( point.triangleFeature )
{
case b3_featureTriangleFace:
return e_faceGhost;
case b3_featureEdge1:
case b3_featureEdge2:
case b3_featureEdge3:
return e_edgeGhost;
case b3_featureVertex1:
case b3_featureVertex2:
case b3_featureVertex3:
return e_vertexGhost;
default:
return e_otherGhost;
}
}
void CountGhosts( b3BodyId bodyId, b3Pos center )
{
// Clustering merges manifolds whose normals agree within its threshold and hands them one normal,
// so a point may carry a normal that far from its own feature
float angle = m_toleranceDegrees * B3_DEG_TO_RAD + acosf( 0.996f );
m_cosTolerance = cosf( angle );
m_sinTolerance = sinf( angle );
b3ContactData contacts[16];
int contactCount = b3Body_GetContactData( bodyId, contacts, 16 );
for ( int i = 0; i < contactCount; ++i )
{
bool bodyIsA = B3_ID_EQUALS( b3Shape_GetBody( contacts[i].shapeIdA ), bodyId );
b3ShapeId otherId = bodyIsA ? contacts[i].shapeIdB : contacts[i].shapeIdA;
if ( b3Shape_GetType( otherId ) != b3_meshShape )
{
continue;
}
for ( int j = 0; j < contacts[i].manifoldCount; ++j )
{
const b3Manifold* manifold = contacts[i].manifolds + j;
b3Vec3 normal = bodyIsA ? b3Neg( manifold->normal ) : manifold->normal;
// Speculative points that never pushed are harmless. Clustering hands every point the normal
// of one member, so the manifold is sound if any pushing point owns that normal.
int pushCount = 0;
int firstPush = 0;
bool admitted = false;
for ( int k = 0; k < manifold->pointCount && admitted == false; ++k )
{
const b3ManifoldPoint& point = manifold->points[k];
if ( point.totalNormalImpulse <= 0.0f )
{
continue;
}
firstPush = pushCount == 0 ? k : firstPush;
pushCount += 1;
admitted = AdmitsPoint( normal, point );
}
if ( pushCount == 0 )
{
continue;
}
m_manifoldCount += 1;
if ( admitted )
{
continue;
}
const b3ManifoldPoint& point = manifold->points[firstPush];
m_ghostCount += 1;
m_stepGhostCount += 1;
m_classCounts[Classify( point )] += 1;
for ( int bit = 0; bit < m_flagCount; ++bit )
{
m_flagCounts[bit] += ( point.meshFlags >> bit ) & 1;
}
b3Vec3 anchor = bodyIsA ? point.anchorA : point.anchorB;
m_markers[m_markerIndex] = { b3OffsetPos( center, anchor ), normal };
m_markerIndex = ( m_markerIndex + 1 ) % m_markerCapacity;
m_markerCount = b3MinInt( m_markerCount + 1, m_markerCapacity );
}
}
}
void Step() override
{
// Contacts are computed at the start of the step and anchors stay relative to that body position.
// A fast body moves past the margin within a step, so the end position would query the wrong triangles.
for ( int i = 0; i < m_bodyCount; ++i )
{
m_contactCenters[i] = b3Body_GetWorldCenter( m_bodyIds[i] );
}
Sample::Step();
if ( m_didStep )
{
m_stepGhostCount = 0;
for ( int i = 0; i < m_bodyCount; ++i )
{
b3BodyId bodyId = m_bodyIds[i];
b3Pos position = b3Body_GetPosition( bodyId );
// Off the belt and on the ground, so drop it back in at the start
if ( position.y < m_baseHeight - 0.5f )
{
b3Body_SetTransform( bodyId, GetSpawnPosition(), RandomQuat() );
b3Body_SetLinearVelocity( bodyId, b3Vec3_zero );
b3Body_SetAngularVelocity( bodyId, b3Vec3_zero );
m_recycleCount += 1;
continue;
}
CountGhosts( bodyId, m_contactCenters[i] );
}
m_spawnTimer += 1;
if ( m_bodyCount < m_targetCount && m_spawnTimer >= m_spawnInterval )
{
SpawnBody();
m_spawnTimer = 0;
}
}
float rate = m_manifoldCount > 0 ? 1.0e6f * (float)m_ghostCount / (float)m_manifoldCount : 0.0f;
DrawTextLine( "ghost manifolds: %d this step, %d of %d pushing (%.0f ppm)", m_stepGhostCount, m_ghostCount,
m_manifoldCount, rate );
DrawTextLine( "ghost feature: face %d, edge %d, vertex %d, unresolved %d", m_classCounts[e_faceGhost],
m_classCounts[e_edgeGhost], m_classCounts[e_vertexGhost], m_classCounts[e_otherGhost] );
DrawTextLine( "ghost origin: hull face %d, snapped %d, unverified %d, deep %d, blocked %d", m_flagCounts[0],
m_flagCounts[1], m_flagCounts[2], m_flagCounts[3], m_flagCounts[4] );
DrawTextLine( "bodies: %d, recycled: %d", m_bodyCount, m_recycleCount );
DrawTextLine( "triangles: %d, stations: %d", m_mesh->triangleCount, (int)m_stations.size() );
}
void Render() override
{
Sample::Render();
int stationCount = (int)m_stations.size();
if ( m_drawFlow )
{
int stride = b3MaxInt( 1, stationCount / 48 );
for ( int k = 0; k < stationCount; k += stride )
{
b3Vec3 p = m_stations[k] + 0.05f * m_ups[k];
b3Vec3 t = m_tangents[k];
DrawArrow( b3ToPos( p ), b3ToPos( p + 0.25f * m_beltSpeed * t ), MakeColor( b3_colorBlueViolet ) );
}
}
if ( m_drawGhosts )
{
for ( int i = 0; i < m_markerCount; ++i )
{
b3Pos p = m_markers[i].point;
DrawPoint( p, 8.0f, MakeColor( b3_colorRed ) );
DrawLine( p, p + 0.5f * m_markers[i].normal, MakeColor( b3_colorRed ) );
}
}
}
bool DrawControls() override
{
bool rebuild = false;
bool respawn = false;
ImGui::SliderFloat( "Cell Size", &m_cellSize, 0.1f, 0.5f, "%.2f m" );
rebuild |= ImGui::IsItemDeactivatedAfterEdit();
if ( ImGui::SliderFloat( "Belt Speed", &m_beltSpeed, 0.0f, 6.0f, "%.1f m/s" ) )
{
UpdateBeltSpeed();
}
ImGui::SliderInt( "Body Count", &m_targetCount, 1, m_maxBodies );
ImGui::SliderInt( "Spawn Interval", &m_spawnInterval, 1, 60 );
const char* bodyNames[e_bodyTypeCount] = { "Mixed", "Box", "Capsule", "Sphere", "Cylinder" };
int bodyType = m_bodyType;
if ( ImGui::Combo( "Bodies", &bodyType, bodyNames, e_bodyTypeCount ) )
{
m_bodyType = (BodyType)bodyType;
respawn = true;
}
if ( ImGui::Checkbox( "Contact Recycling", &m_contactRecycling ) )
{
for ( int i = 0; i < m_bodyCount; ++i )
{
b3Body_EnableContactRecycling( m_bodyIds[i], m_contactRecycling );
}
}
ImGui::SliderFloat( "Ghost Tolerance", &m_toleranceDegrees, 1.0f, 20.0f, "%.0f deg" );
ImGui::Checkbox( "Draw Flow", &m_drawFlow );
ImGui::Checkbox( "Draw Ghosts", &m_drawGhosts );
respawn |= ImGui::Button( "Respawn" );
if ( ImGui::Button( "Reset Counters" ) )
{
ResetCounters();
}
if ( rebuild )
{
DestroyCircuit();
CreateCircuit();
ResetCounters();
}
if ( respawn )
{
DestroyBodies();
ResetCounters();
}
// Shrinking the count drops the newest bodies
while ( m_bodyCount > m_targetCount )
{
m_bodyCount -= 1;
b3DestroyBody( m_bodyIds[m_bodyCount] );
}
return true;
}
static Sample* Create( SampleContext* context )
{
return new ConveyorCircuit( context );
}
Segment m_segments[m_segmentCount];
float m_segmentStart[m_segmentCount];
float m_totalLength;
b3Vec2 m_profile[m_profileCount];
std::vector<b3Vec3> m_stations;
std::vector<b3Vec3> m_tangents;
std::vector<b3Vec3> m_laterals;
std::vector<b3Vec3> m_ups;
std::vector<b3Vec3> m_triangleNormals;
std::vector<int> m_edgeNeighbors;
std::vector<std::vector<int>> m_vertexRings;
std::vector<std::vector<int>> m_vertexTriangles;
b3BodyId m_groundId;
b3MeshData* m_mesh = nullptr;
b3ShapeId m_shapeId = {};
b3HullData* m_cylinderHull;
b3BodyId m_bodyIds[m_maxBodies];
b3Pos m_contactCenters[m_maxBodies];
int m_bodyCount;
int m_spawnIndex;
int m_spawnTimer;
float m_cellSize;
float m_beltSpeed;
int m_targetCount;
int m_spawnInterval;
BodyType m_bodyType;
float m_toleranceDegrees;
float m_cosTolerance = 1.0f;
float m_sinTolerance = 0.0f;
bool m_contactRecycling;
bool m_drawFlow;
bool m_drawGhosts;
static constexpr int m_flagCount = 5;
int m_classCounts[e_ghostClassCount];
int m_flagCounts[m_flagCount];
int m_ghostCount;
int m_manifoldCount;
int m_stepGhostCount;
int m_recycleCount;
Marker m_markers[m_markerCapacity];
int m_markerCount;
int m_markerIndex;
};
static int sampleConveyorCircuit = RegisterSample( "Mesh", "Conveyor Circuit", ConveyorCircuit::Create );

View file

@ -18,6 +18,11 @@
#define GHOST_CHAMFER_WIDTH 0.05f
#define GHOST_CHAMFER_DROP ( GHOST_CHAMFER_WIDTH / 1.5f )
// A conveyor side rail along x, the floor is on the -z side
#define GHOST_RAIL_HEIGHT 0.35f
#define GHOST_RAIL_THICKNESS 0.08f
#define GHOST_RAIL_SKIRT 0.4f
typedef struct PeelPreset
{
int columnCount;
@ -33,7 +38,7 @@ static const PeelPreset s_peelPresets[GHOST_PEEL_PRESET_COUNT] = {
};
const char* g_ghostSceneNames[e_ghostSceneCount] = {
"Flat", "Concave", "Cliff", "Crest", "Bumps", "T-Junction", "Internal", "Chamfer",
"Flat", "Concave", "Cliff", "Crest", "Bumps", "T-Junction", "Internal", "Chamfer", "Rail",
};
const char* g_ghostBodyNames[e_ghostBodyCount] = { "Box", "H Capsule", "V Capsule", "Sphere", "Cylinder" };
@ -152,6 +157,92 @@ static void AddStrip( MeshBuilder* builder, const b3Vec2* profile, int count, fl
free( points );
}
// The rail cross section is a profile in zy extruded along x. Each quad side is its edge direction along
// the section crossed with x, which is the outward normal for a section traversed with air on the left.
static void AddRail( MeshBuilder* builder, const b3Vec2* section, int count, float cellSize, bool mirror )
{
float sign = mirror ? -1.0f : 1.0f;
int xCount = b3MaxInt( 1, (int)ceilf( 2.0f * GHOST_HALF_LENGTH / cellSize - 0.01f ) );
int stride = xCount + 1;
int pointCount = 1;
for ( int k = 0; k + 1 < count; ++k )
{
float dz = section[k + 1].x - section[k].x;
float dy = section[k + 1].y - section[k].y;
pointCount += b3MaxInt( 1, (int)ceilf( sqrtf( dz * dz + dy * dy ) / cellSize - 0.01f ) );
}
builder->vertices = realloc( builder->vertices, pointCount * stride * sizeof( b3Vec3 ) );
int index = 0;
for ( int k = 0; k < count; ++k )
{
int n = 1;
if ( k + 1 < count )
{
float dz = section[k + 1].x - section[k].x;
float dy = section[k + 1].y - section[k].y;
n = b3MaxInt( 1, (int)ceilf( sqrtf( dz * dz + dy * dy ) / cellSize - 0.01f ) );
}
// The last point only closes the final segment
int last = k + 1 < count ? n : 1;
for ( int s = 0; s < last; ++s )
{
float t = k + 1 < count ? (float)s / (float)n : 0.0f;
b3Vec2 a = section[k];
b3Vec2 b = k + 1 < count ? section[k + 1] : a;
float z = a.x + t * ( b.x - a.x );
float y = a.y + t * ( b.y - a.y );
for ( int j = 0; j <= xCount; ++j )
{
float x = -GHOST_HALF_LENGTH + 2.0f * GHOST_HALF_LENGTH * (float)j / (float)xCount;
builder->vertices[index++] = (b3Vec3){ sign * x, y, z };
}
}
}
builder->vertexCount = index;
int triangleCount = 2 * ( pointCount - 1 ) * xCount;
builder->indices = realloc( builder->indices, 3 * triangleCount * sizeof( int32_t ) );
builder->indexCount = 0;
for ( int i = 0; i + 1 < pointCount; ++i )
{
for ( int j = 0; j < xCount; ++j )
{
int a = i * stride + j;
int b = a + 1;
int c = a + stride + 1;
int d = a + stride;
int corners[6] = { a, d, c, c, b, a };
if ( ( i + j ) & 1 )
{
int flipped[6] = { a, d, b, d, c, b };
memcpy( corners, flipped, sizeof( corners ) );
}
for ( int k = 0; k < 6; k += 3 )
{
builder->indices[builder->indexCount++] = corners[k];
builder->indices[builder->indexCount++] = mirror ? corners[k + 2] : corners[k + 1];
builder->indices[builder->indexCount++] = mirror ? corners[k + 1] : corners[k + 2];
}
}
}
}
static float EvaluateRail( float z, float cellZ )
{
if ( z < -0.5f * cellZ )
{
return 0.0f;
}
return z < 0.5f * cellZ ? GHOST_RAIL_HEIGHT : -GHOST_RAIL_SKIRT;
}
static void AddMesh( GhostCollisionsData* data, MeshBuilder* builder, bool frictionless )
{
b3MeshDef meshDef = { 0 };
@ -247,13 +338,16 @@ static void AddHeightField( b3WorldId worldId, GhostCollisionsData* data, float
float cellX = ( x1 - x0 ) / (float)cellCountX;
float cellZ = 2.0f * halfWidth / (float)cellCountZ;
// The mirror turns the body half way around y, which also reverses z
bool rail = data->settings.scene == e_ghostRail;
float* heights = malloc( countX * countZ * sizeof( float ) );
for ( int row = 0; row < countZ; ++row )
{
float z = mirror ? halfWidth - cellZ * (float)row : -halfWidth + cellZ * (float)row;
for ( int column = 0; column < countX; ++column )
{
float x = mirror ? x1 - cellX * (float)column : x0 + cellX * (float)column;
heights[row * countX + column] = EvaluateProfile( data, x );
heights[row * countX + column] = rail ? EvaluateRail( z, cellZ ) : EvaluateProfile( data, x );
}
}
@ -374,6 +468,15 @@ void CreateGhostGround( b3WorldId worldId, GhostCollisionsData* data )
PushProfile( data, h, 0.0f );
break;
case e_ghostRail:
// Cross section in zy, from the floor up the inner wall, over the top and down the outer skirt
PushProfile( data, -GHOST_HALF_WIDTH, 0.0f );
PushProfile( data, 0.0f, 0.0f );
PushProfile( data, 0.0f, GHOST_RAIL_HEIGHT );
PushProfile( data, GHOST_RAIL_THICKNESS, GHOST_RAIL_HEIGHT );
PushProfile( data, GHOST_RAIL_THICKNESS, -GHOST_RAIL_SKIRT );
break;
default:
PushProfile( data, -h, 0.0f );
PushProfile( data, h, 0.0f );
@ -421,6 +524,11 @@ void CreateGhostGround( b3WorldId worldId, GhostCollisionsData* data )
AddHeightField( worldId, data, -h, h, GetCellCount( 2.0f * h, cellSize ), groundHalfWidth, cellCountZ, false );
}
}
else if ( settings->scene == e_ghostRail )
{
AddRail( &builder, data->profile, data->profileCount, cellSize, mirror );
AddMesh( data, &builder, false );
}
else if ( settings->scene == e_ghostTJunction )
{
// Fine and coarse strips share only every other vertex along x = 0
@ -478,6 +586,16 @@ void LaunchGhostBody( b3WorldId worldId, GhostCollisionsData* data )
bodyDef.position = (b3Pos){ s_peelPresets[settings->peelPreset].startZ, 80.0f, 0.0f };
bodyDef.rotation = yaw;
}
else if ( settings->scene == e_ghostRail )
{
// Dropped across the rail top, pitched so a box face sweeps into the rail edge at an angle. The real
// contact is edge on edge and perpendicular to the rail, a face normal there leans along the rail
// and catches the body. Found in the Conveyor Circuit sample.
b3Quat pitch = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, 60.0f * B3_PI / 180.0f );
bodyDef.position = (b3Pos){ GHOST_START_X, GHOST_RAIL_HEIGHT + 0.45f, -0.15f };
bodyDef.rotation = b3MulQuat( pitch, yaw );
bodyDef.linearVelocity = (b3Vec3){ settings->speed, 0.0f, 0.0f };
}
else
{
int segment = 0;
@ -714,7 +832,15 @@ int UpdateGhostCollisions( b3WorldId worldId, GhostCollisionsData* data, GhostRe
}
b3Vec3 normal = bodyIsA ? b3Neg( manifold->normal ) : manifold->normal;
if ( IsGhost( data, normal, xMin, xMax, zMin, zMax ) == false )
if ( data->settings.scene == e_ghostRail )
{
// The rail is the same all along x, so no valid normal leans along it
if ( b3AbsFloat( normal.x ) <= sinf( 5.0f * B3_PI / 180.0f ) )
{
continue;
}
}
else if ( IsGhost( data, normal, xMin, xMax, zMin, zMax ) == false )
{
continue;
}

View file

@ -29,6 +29,7 @@ typedef enum GhostScene
e_ghostTJunction,
e_ghostInternal,
e_ghostChamfer,
e_ghostRail,
e_ghostSceneCount
} GhostScene;

View file

@ -581,6 +581,8 @@ static bool b3ComputeConvexManifold( b3World* world, int workerIndex, b3Contact*
target->separation = source->separation;
target->featureId = b3MakeFeatureId( source->pair );
target->triangleIndex = B3_NULL_INDEX;
target->triangleFeature = b3_featureNone;
target->meshFlags = 0;
target->normalVelocity = 0.0f;
}

View file

@ -1075,10 +1075,11 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
bool blockSource = false;
b3TriangleFeature nearFeature = manifold->feature;
b3NeighborResult result = b3_neighborAdmit;
uint8_t meshFlags = manifold->feature == b3_featureHullFace ? b3_meshContactHullFace : 0;
if ( validateNeighbors && manifold->pointCount > 0 &&
manifold->feature != b3_featureTriangleFace )
{
b3NeighborResult result;
if ( manifold->feature == b3_featureHullFace )
{
result = b3TestHullFaceNeighbors( shapeA, triangleIndex, vertices,
@ -1115,6 +1116,15 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
result = shapeB->type == b3_sphereShape ? b3_neighborUnknown : b3_neighborSnap;
}
if ( result == b3_neighborUnknown )
{
meshFlags |= b3_meshContactUnverified;
}
else if ( result == b3_neighborSnap )
{
meshFlags = b3_meshContactSnapped;
}
b3LocalManifold deepManifold = { 0 };
b3LocalManifoldPoint deepPoints[B3_MAX_CLIP_POINTS];
bool keepDeep = deep && result == b3_neighborSnap && shapeB->type == b3_hullShape;
@ -1152,6 +1162,11 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
// The kept manifold failed the neighbor test, so it is unverified like a boundary contact.
blockSource = true;
meshFlags = b3_meshContactDeep | b3_meshContactUnverified;
if ( manifold->feature == b3_featureHullFace )
{
meshFlags |= b3_meshContactHullFace;
}
}
}
}
@ -1162,6 +1177,22 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
{
B3_ASSERT( manifold->feature != b3_featureNone );
b3TriangleFeature pointFeature = manifold->feature;
if ( pointFeature == b3_featureHullFace && nearFeature != b3_featureHullFace && nearFeature != b3_featureNone )
{
pointFeature = nearFeature;
}
else if ( pointFeature == b3_featureHullFace && nearFeature == b3_featureNone && result == b3_neighborAdmit )
{
pointFeature = b3_featureTriangleFace;
}
for ( int i = 0; i < manifoldPointCount; ++i )
{
manifold->points[i].triangleFeature = (uint8_t)pointFeature;
manifold->points[i].meshFlags = meshFlags;
}
manifold->triangleIndex = triangleIndex;
manifold->triangleNormal =
b3MakeNormalFromPoints( vertices[0], vertices[1], vertices[2] );
@ -1265,6 +1296,11 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
manifold->normal = blockerNormal;
manifold->triangleNormal = blockerNormal;
manifold->feature = b3_featureTriangleFace;
for ( int j = 0; j < manifold->pointCount; ++j )
{
manifold->points[j].triangleFeature = b3_featureTriangleFace;
manifold->points[j].meshFlags |= b3_meshContactBlocked;
}
}
}
}
@ -1426,6 +1462,8 @@ static int b3CollideMeshTriangles( b3Cluster** clustersOut, const b3Shape* shape
cp->point = ap->point;
cp->separation = ap->separation;
cp->pair = ap->pair;
cp->triangleFeature = ap->triangleFeature;
cp->meshFlags = ap->meshFlags;
cm->pointCount += 1;
}
}
@ -1563,6 +1601,8 @@ bool b3ComputeMeshManifolds( b3World* world, int workerIndex, b3Contact* contact
target->separation = source->separation - restOffset;
target->featureId = b3MakeFeatureId( source->pair );
target->triangleIndex = source->triangleIndex;
target->triangleFeature = source->triangleFeature;
target->meshFlags = source->meshFlags;
// Preserve normal impulse if possible
if ( matchedManifold != NULL )
@ -1762,6 +1802,8 @@ int b3CollideMeshAndHull( b3Manifold* manifolds, int capacity, const b3Mesh* mes
target->separation = source->separation - restOffset;
target->featureId = b3MakeFeatureId( source->pair );
target->triangleIndex = source->triangleIndex;
target->triangleFeature = source->triangleFeature;
target->meshFlags = source->meshFlags;
}
}

View file

@ -13,6 +13,10 @@
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
// cosine of hull normal versus edge axis tolerance.
#define B3_CROSSING_TOLERANCE 0.1f
typedef struct b3TriangleData
{
@ -1311,14 +1315,29 @@ void b3CollideTriangleAndHull( b3LocalManifold* manifold, int capacity, b3Vec3 v
// If a face axis has positive separation there may be no points.
float maxFaceSeparation = b3MaxFloat( faceQueryA.separation, faceQueryB.separation );
// The edge axis can win if the hull face axis is significantly aligned with the edge axis.
bool crossesEdge = false;
if ( manifold->pointCount >= 1 && manifold->feature == b3_featureHullFace && edgeQuery.separation > clipSeparation )
{
b3Vec3 edgeAxis = b3Normalize( triangleEdges[edgeQuery.indexA] );
// Is the angle less than ~84 degrees?
crossesEdge = b3AbsFloat( b3Dot( faceQueryB.normal, edgeAxis ) ) > B3_CROSSING_TOLERANCE;
}
if ( ( manifold->pointCount == 0 && edgeQuery.separation > maxFaceSeparation ) ||
( manifold->pointCount == 1 && edgeQuery.separation > clipSeparation + linearSlop ) )
( manifold->pointCount == 1 && edgeQuery.separation > clipSeparation + linearSlop ) || crossesEdge )
{
B3_ASSERT( 0 <= edgeQuery.indexA && edgeQuery.indexA < 3 );
b3Vec3 trianglePoint = trianglePoints[edgeQuery.indexA];
b3Vec3 triangleEdge = triangleEdges[edgeQuery.indexA];
manifold->pointCount = 0;
b3CollideTriangleAndHullEdges( manifold, capacity, trianglePoint, triangleEdge, hullB, edgeQuery, cache );
if ( crossesEdge && manifold->pointCount == 0 )
{
b3CollideHullFace( manifold, capacity, &triangle, hullB, faceQueryB, cache, enableSpeculative );
}
}
}