// SPDX-FileCopyrightText: 2025 Erin Catto // SPDX-License-Identifier: MIT #include "sample.h" #include "gfx/draw.h" #include "utils.h" #include "box3d/box3d.h" #include class BoxHull : public Sample { public: explicit BoxHull( SampleContext* context ) : Sample( context ) { if ( m_context->restart == false ) { m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero ); } m_hull = nullptr; m_halfWidths = { 1.0f, 0.5f, 0.25f }; m_postScale = { 1.0f, 1.0f, 1.0f }; m_rotation = { 0.0f, 0.0f, 0.0f }; m_transform = b3Transform_identity; UpdateRotation(); CreateHulls( m_halfWidths, m_transform, m_postScale ); } ~BoxHull() override { b3DestroyHull( m_hull ); } void UpdateRotation() { b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisX, B3_DEG_TO_RAD * m_rotation.x ); b3Quat qy = b3MakeQuatFromAxisAngle( b3Vec3_axisY, B3_DEG_TO_RAD * m_rotation.y ); b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, B3_DEG_TO_RAD * m_rotation.z ); m_transform.q = b3MulQuat( qz, b3MulQuat( qy, qx ) ); } void CreateHulls( b3Vec3 h, b3Transform transform, b3Vec3 postScale ) { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); m_hull = nullptr; } b3Vec3 scale = b3SafeScale( postScale ); b3Vec3 points[8]; points[0] = scale * b3TransformPoint( transform, { h.x, h.y, h.z } ); points[1] = scale * b3TransformPoint( transform, { h.x, h.y, -h.z } ); points[2] = scale * b3TransformPoint( transform, { h.x, -h.y, h.z } ); points[3] = scale * b3TransformPoint( transform, { h.x, -h.y, -h.z } ); points[4] = scale * b3TransformPoint( transform, { -h.x, h.y, h.z } ); points[5] = scale * b3TransformPoint( transform, { -h.x, h.y, -h.z } ); points[6] = scale * b3TransformPoint( transform, { -h.x, -h.y, h.z } ); points[7] = scale * b3TransformPoint( transform, { -h.x, -h.y, -h.z } ); m_hull = b3CreateHull( points, 8, 8 ); m_box = b3MakeScaledBoxHull( h, transform, postScale ); } bool HasSolverControls() const override { return false; } bool DrawControls() override { float fontSize = ImGui::GetFontSize(); ImGui::PushItemWidth( 10.0f * fontSize ); if ( ImGui::SliderFloat3( "h", &m_halfWidths.x, 0.1f, 2.0f, "%.1f" ) ) { CreateHulls( m_halfWidths, m_transform, m_postScale ); } if ( ImGui::SliderFloat3( "c", &m_transform.p.x, -2.0f, 2.0f, "%.1f" ) ) { CreateHulls( m_halfWidths, m_transform, m_postScale ); } if ( ImGui::SliderFloat3( "r", &m_rotation.x, -180.0f, 180.0f, "%.0f" ) ) { UpdateRotation(); CreateHulls( m_halfWidths, m_transform, m_postScale ); } if ( ImGui::SliderFloat3( "s", &m_postScale.x, -2.0f, 2.0f, "%.1f" ) ) { CreateHulls( m_halfWidths, m_transform, m_postScale ); } if ( ImGui::Button( "Refresh" ) ) { CreateHulls( m_halfWidths, m_transform, m_postScale ); } ImGui::PopItemWidth(); return true; } void Render() override { DrawHull( b3Transform_identity, m_hull, MakeColor( b3_colorYellow ) ); DrawHull( b3Transform_identity, &m_box.base, MakeColor( b3_colorCyan ) ); DrawAxes( b3Transform_identity, 1.0f ); Sample::Render(); } static Sample* Create( SampleContext* sampleContext ) { return new BoxHull( sampleContext ); } b3Vec3 m_halfWidths; b3Vec3 m_rotation; b3Transform m_transform; b3Vec3 m_postScale; b3BoxHull m_box; b3HullData* m_hull; }; static int sampleBoxHull = RegisterSample( "Geometry", "Box Hull", BoxHull::Create ); class Hull : public Sample { public: explicit Hull( SampleContext* context ) : Sample( context ) { if ( m_context->restart == false ) { m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero ); } m_hull = nullptr; // this fails because it generates too many edges b3Vec3 points[] = { { -3.9866004, 75.4595108, 28.3783073 }, { -13.1079493, 73.080368, 28.296587 }, { -18.6611958, 72.0040894, 16.9292431 }, { 4.82537603, 79.2908554, 22.2369995 }, { -12.7315464, 79.2187576, 2.94275379 }, { -21.806488, 78.7758865, 0.985544085 }, { -27.7619209, 73.3481522, 11.9647141 }, { -22.3994541, 72.2203826, 21.4116211 }, { -25.3797474, 76.7417755, 27.9124985 }, { -22.7552319, 77.0559006, 29.4733639 }, { -6.81736374, 78.3484726, 36.8649979 }, { 3.62397718, 85.5270843, 29.2077713 }, { 7.90363788, 84.121231, 18.2612896 }, { -12.3809223, 84.5280533, -0.43230924 }, { 5.83599472, 95.2908325, 4.4423275 }, { -22.5541401, 89.9094467, -4.87791252 }, { -43.9060402, 78.5287094, 1.32877088 }, { -42.6015129, 76.7829742, 7.67437983 }, { -25.735527, 78.1218796, 27.908411 }, { -23.5183544, 77.6326675, 29.1178799 }, { 2.0977366, 100.430191, 34.3929482 }, { 1.09743047, 103.952553, 35.5656395 }, { 8.50175952, 96.0529861, 8.73674774 }, { 2.52570295, 103.303696, 32.2314339 }, { -20.099781, 89.4923248, -4.15468454 }, { 2.8092947, 123.516098, -1.12693477 }, { -43.9318161, 79.1106186, 1.39006138 }, { -23.358511, 90.9599686, -4.25683546 }, { 2.10804915, 123.603645, -1.38435471 }, { -44.1329117, 78.7192383, 1.54941654 }, { -42.4365158, 77.725357, 8.14835929 }, { -43.204792, 77.5811691, 7.14319515 }, { -44.17416, 78.7810363, 2.50146222 }, { -32.8975143, 99.1221771, 7.55588436 }, { -0.624746263, 110.070351, 32.7381058 }, { 0.00431228895, 109.14341, 33.6411133 }, { -0.58865279, 122.980537, 16.6554794 }, { 2.18539238, 124.324593, -0.620266676 }, { -1.02177501, 123.881721, 16.8230057 }, { 1.9842999, 124.571777, -0.321986318 }, { 1.86570692, 124.365791, -0.599836588 }, { -43.591507, 78.1373291, 6.1135149 }, { -43.8235397, 79.2239074, 3.48619604 }, { -43.591507, 78.50811, 5.54555655 }, { 1.21086729, 124.49453, 1.07543683 }, { -1.86223853, 124.195847, 15.6257992 }, { -1.46520972, 124.355492, 16.9864483 }, { 1.654302, 124.612976, 0.621887207 }, }; static_assert( sizeof( points ) / sizeof( points[0] ) < m_capacity, "bad" ); m_count = sizeof( points ) / sizeof( points[0] ); for ( int i = 0; i < m_count; ++i ) { m_points[i] = 0.01f * points[i]; } // This shift shouldn't be necessary but I'm doing it so the hull // appears on the screen. // for ( int i = 0; i < m_count; ++i ) //{ // m_points[i] -= m_points[0]; // m_points[i] *= 0.01f; //} m_hull = b3CreateHull( m_points, m_count, 16 ); (void)m_hull; } ~Hull() override { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); } } void Render() override { if ( m_hull != nullptr ) { DrawHull( b3Transform_identity, m_hull, MakeColor( b3_colorYellow ) ); } DrawAxes( b3Transform_identity, 1.0f ); Sample::Render(); } static Sample* Create( SampleContext* sampleContext ) { return new Hull( sampleContext ); } static constexpr int m_capacity = 64; b3HullData* m_hull; b3Vec3 m_points[m_capacity]; int m_count; }; static int sampleHull = RegisterSample( "Geometry", "Hull", Hull::Create ); class HullReduction : public Sample { public: enum Type { e_box, e_sphere, }; explicit HullReduction( SampleContext* context ) : Sample( context ) { if ( m_context->restart == false ) { m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero ); } m_hull = nullptr; m_type = e_sphere; m_count = 16; GeneratePoints(); GenerateHull(); } void GeneratePoints() { g_randomSeed = 42; if ( m_type == e_box ) { b3Vec3 lower = { -2.0f, -2.0f, -2.0f }; b3Vec3 upper = { 2.0f, 2.0f, 2.0f }; b3AABB box = { { -1.0f, -1.0f, -1.0f }, { 1.0f, 1.0f, 1.0f } }; float a = 0.001f; b3AABB noise = { { -a, -a, -a }, { a, a, a } }; for ( int i = 0; i < m_capacity; ++i ) { b3Vec3 p = RandomVec3( lower, upper ); p = b3Clamp( p, box.lowerBound, box.upperBound ); b3Vec3 f = RandomVec3( noise.lowerBound, noise.upperBound ); m_points[i] = b3Add(p, f); } } else { for ( int i = 0; i < m_capacity; ++i ) { m_points[i] = RandomUnitVector(); } } } void GenerateHull() { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); } m_hull = b3CreateHull( m_points, m_capacity, m_count ); } ~HullReduction() override { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); } } bool HasSolverControls() const override { return false; } bool DrawControls() override { if ( ImGui::RadioButton( "Box", m_type == e_box ) ) { m_type = e_box; GeneratePoints(); GenerateHull(); } if ( ImGui::RadioButton( "Sphere", m_type == e_sphere ) ) { m_type = e_sphere; GeneratePoints(); GenerateHull(); } if ( ImGui::SliderInt( "count", &m_count, 4, m_capacity ) ) { GenerateHull(); } return true; } void Render() override { if ( m_hull != nullptr ) { DrawHull( b3Transform_identity, m_hull, MakeColor( b3_colorYellow ) ); DrawTextLine( "v/f/e = %d/%d/%d", m_hull->vertexCount, m_hull->faceCount, m_hull->edgeCount / 2 ); } DrawAxes( b3Transform_identity, 1.0f ); Sample::Render(); } static Sample* Create( SampleContext* sampleContext ) { return new HullReduction( sampleContext ); } static constexpr int m_capacity = 128; Type m_type; b3HullData* m_hull; b3Vec3 m_points[m_capacity]; int m_count; }; static int sampleHullReduction = RegisterSample( "Geometry", "Hull Reduction", HullReduction::Create ); class HullTransform : public Sample { public: explicit HullTransform( SampleContext* context ) : Sample( context ) { if ( m_context->restart == false ) { m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero ); } m_original = b3CreateCylinder( 1.0f, 0.5f, 0.0f, 9 ); m_box = b3MakeBoxHull( 0.5f, 0.5f, 0.5f ); // m_original = &m_box.base; m_scale = { 1.0f, 1.0f, 1.0f }; m_angles = b3Vec3_zero; m_offset = b3Vec3_zero; m_hull = b3CloneAndTransformHull( m_original, b3Transform_identity, m_scale ); } ~HullTransform() override { if ( m_original != &m_box.base ) { b3DestroyHull( m_original ); } b3DestroyHull( m_hull ); } void UpdateHull() { b3DestroyHull( m_hull ); b3Quat qx = b3MakeQuatFromAxisAngle( b3Vec3_axisX, m_angles.x * B3_PI / 180.0f ); b3Quat qy = b3MakeQuatFromAxisAngle( b3Vec3_axisY, m_angles.y * B3_PI / 180.0f ); b3Quat qz = b3MakeQuatFromAxisAngle( b3Vec3_axisZ, m_angles.z * B3_PI / 180.0f ); b3Quat q = b3MulQuat( qz, b3MulQuat( qy, qx ) ); m_hull = b3CloneAndTransformHull( m_original, { m_offset, q }, m_scale ); } void Render() override { b3Transform transform1 = { { -2.0f, 0.0f, 0.0f }, b3Quat_identity }; b3Transform transform2 = { { 2.0f, 0.0f, 0.0f }, b3Quat_identity }; DrawHull( transform1, m_original, MakeColor( b3_colorGreen ) ); DrawHull( transform2, m_hull, MakeColor( b3_colorYellow ) ); DrawAxes( b3Transform_identity, 1.0f ); DrawTextLine( "hull 1: area = %g, volume = %g, radius = %g", m_original->surfaceArea, m_original->volume, m_original->innerRadius ); DrawTextLine( "hull 2: area = %g, volume = %g, radius = %g", m_hull->surfaceArea, m_hull->volume, m_hull->innerRadius ); Sample::Render(); } bool HasSolverControls() const override { return false; } bool DrawControls() override { if ( ImGui::SliderFloat( "sx", &m_scale.x, -2.0f, 2.0f, "%.1f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "sy", &m_scale.y, -2.0f, 2.0f, "%.1f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "sz", &m_scale.z, -2.0f, 2.0f, "%.1f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "rx", &m_angles.x, -180.0f, 180.0f, "%.0f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "ry", &m_angles.y, -180.0f, 180.0f, "%.0f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "rz", &m_angles.z, -180.0f, 180.0f, "%.0f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "px", &m_offset.x, -1.0f, 1.0f, "%.1f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "py", &m_offset.y, -1.0f, 1.0f, "%.1f" ) ) { UpdateHull(); } if ( ImGui::SliderFloat( "pz", &m_offset.z, -1.0f, 1.0f, "%.1f" ) ) { UpdateHull(); } return true; } static Sample* Create( SampleContext* sampleContext ) { return new HullTransform( sampleContext ); } b3BoxHull m_box; b3HullData* m_original; b3HullData* m_hull; b3Vec3 m_angles; b3Vec3 m_scale; b3Vec3 m_offset; }; static int sampleHullTransform = RegisterSample( "Geometry", "Hull Transform", HullTransform::Create ); class CapsuleMass : public Sample { public: explicit CapsuleMass( SampleContext* context ) : Sample( context ) { if ( m_context->restart == false ) { m_camera->SetView( 0.0f, 15.0f, 5.0f, b3Vec3_zero ); } m_radius = 1.0f; m_length = 2.0f; m_sides = 6; m_capsule = { { -0.5f * m_length, 0.0f, 0.0f }, { 0.5f * m_length, 0.0f, 0.0f }, m_radius }; m_box = b3MakeBoxHull( m_radius + 0.5f * m_length, m_radius, m_radius ); m_hull = nullptr; CreateCapsuleHull( m_sides ); } ~CapsuleMass() override { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); } } void CreateCapsuleHull( int sides ) { if ( m_hull != nullptr ) { b3DestroyHull( m_hull ); m_hull = nullptr; } constexpr int N = m_maxSides; constexpr int M = 2 * N * N; b3Vec3 points[M]; if ( sides > N ) { return; } int count = 2 * sides * sides; float d = B3_PI / ( sides - 1.0f ); float angle1 = -0.5f * B3_PI; int index = 0; for ( int i = 0; i < sides; ++i ) { float s1 = sinf( angle1 ); float c1 = cosf( angle1 ); float angle2 = -0.5f * B3_PI; for ( int j = 0; j < sides; ++j ) { points[index].x = 1.0f + m_radius * c1; points[index].y = m_radius * s1 * cosf( angle2 ); points[index].z = m_radius * s1 * sinf( angle2 ); angle2 += d; index += 1; } angle1 += d; } angle1 = 0.5f * B3_PI; for ( int i = 0; i < sides; ++i ) { float s1 = sinf( angle1 ); float c1 = cosf( angle1 ); float angle2 = -0.5f * B3_PI; for ( int j = 0; j < sides; ++j ) { points[index].x = -1.0f + m_radius * c1; points[index].y = m_radius * s1 * cosf( angle2 ); points[index].z = m_radius * s1 * sinf( angle2 ); angle2 += d; index += 1; } angle1 += d; } assert( index == count ); m_hull = b3CreateHull( points, count, count ); } void Render() override { DrawSolidCapsule( b3Transform_identity, m_capsule, MakeColorAlpha( b3_colorAqua, 0.8f ) ); DrawHull( b3Transform_identity, &m_box.base, MakeColor( b3_colorBlueViolet ) ); if ( m_hull != nullptr ) { DrawHull( b3Transform_identity, m_hull, MakeColor( b3_colorYellow ) ); } DrawAxes( b3Transform_identity, 1.0f ); if ( m_hull != nullptr ) { b3MassData lowerMassData = b3ComputeHullMass( m_hull, 1.0f ); b3MassData massData = b3ComputeCapsuleMass( &m_capsule, 1.0f ); b3MassData upperMassData = b3ComputeHullMass( &m_box.base, 1.0f ); DrawTextLine( "mass hull: %g", lowerMassData.mass ); DrawTextLine( "mass capsule: %g", massData.mass ); DrawTextLine( "mass box: %g", upperMassData.mass ); m_textLine += m_textIncrement; DrawTextLine( "Ixx hull: %g", lowerMassData.inertia.cx.x ); DrawTextLine( "Ixx capsule: %g", massData.inertia.cx.x ); DrawTextLine( "Ixx box: %g", upperMassData.inertia.cx.x ); m_textLine += m_textIncrement; DrawTextLine( "Iyy hull: %g", lowerMassData.inertia.cy.y ); DrawTextLine( "Iyy capsule: %g", massData.inertia.cy.y ); DrawTextLine( "Iyy box: %g", upperMassData.inertia.cy.y ); m_textLine += m_textIncrement; DrawTextLine( "Izz hull: %g", lowerMassData.inertia.cz.z ); DrawTextLine( "Izz capsule: %g", massData.inertia.cz.z ); DrawTextLine( "Izz box: %g", upperMassData.inertia.cz.z ); } Sample::Render(); } bool HasSolverControls() const override { return false; } bool DrawControls() override { if ( ImGui::SliderInt( "sides", &m_sides, 3, m_maxSides ) ) { CreateCapsuleHull( m_sides ); } return true; } static Sample* Create( SampleContext* sampleContext ) { return new CapsuleMass( sampleContext ); } // Limited by edge count static constexpr int m_maxSides = 6; b3Capsule m_capsule; b3BoxHull m_box; b3HullData* m_hull; float m_radius; float m_length; int m_sides; }; static int sampleCapsuleMass = RegisterSample( "Geometry", "Capsule Mass", CapsuleMass::Create );