[Solved] Integrating Box3D into Raylib. How to use b3DebugDraw in Raylib?

[ivan-enzhaev]

(It is from Discord)

Hello. I try to use b3DebugDraw but drawSegment and drawTransform are not called:

Click to see a code

static inline b3DebugDraw CreateDebugDrawer(LineDrawer *drawer)
{
    b3DebugDraw dd = {0};
    dd.DrawSegmentFcn = drawSegment;
    dd.DrawTransformFcn = drawTransform;
    // Add others as needed: dd.DrawBoxFcn = drawBox;
    
    dd.context = drawer;
    
    // Enable features
    dd.drawShapes = true;
    dd.drawJoints = true;

    return dd;
}

But these functions are not called:

Click to see a code

static void drawSegment(b3Pos p1, b3Pos p2, b3HexColor color, void *context)
{
    printf("hello");
}

static void drawTransform(b3WorldTransform transform, void *context)
{
    printf("hello");
}

I call b3World_Draw in the render loop:

    uint64_t debugMask = 0xFFFFFFFFFFFFFFFF;
    b3World_Draw(app->worldId, &app->debugDrawer, debugMask);

I have created a ground body:

Click to see a code

    app->lineDrawer = LineDrawer_getInstance();
    mat4 dummyMatrix = GLM_MAT4_IDENTITY_INIT;
    LineDrawer_init(app->lineDrawer, app->shaderProgram, dummyMatrix);

    b3WorldDef worldDef = b3DefaultWorldDef();
    worldDef.gravity = (b3Vec3) { 0.f, -9.8f, 0.f };
    app->worldId = b3CreateWorld(&worldDef);

    app->debugDrawer = CreateDebugDrawer(app->lineDrawer);
    // b3World_SetDebugDraw(app->worldId, &app->debugDrawer);

    b3BodyDef groundBodyDef = b3DefaultBodyDef();
    groundBodyDef.position = (b3Vec3){ 0.f, -0.f, 0.f };

    b3BodyId groundId = b3CreateBody(app->worldId, &groundBodyDef);

    b3BoxHull groundBox = b3MakeBoxHull(5.f, 0.5f, 5.f);

    b3ShapeDef groundShapeDef = b3DefaultShapeDef();
    b3CreateHullShape(groundId, &groundShapeDef, &groundBox.base);

I call b3World_Step in the render loop:

Click to see a code

SDL_AppResult SDL_AppIterate(void *appState)
{
    App *app = (App *)appState;
    int winW, winH;
    SDL_GetWindowSizeInPixels(app->window, &winW, &winH);

    // Update projection every frame with the window's actual aspect ratio
    update_projection(app, winW, winH);

    // Fill the entire window
    glViewport(0, 0, winW, winH);

    b3World_Step(app->worldId, 1.0f / 60.0f, 5);

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Use 0xFFFFFFFFFFFFFFFF to enable all flags,
    // or specify a more granular mask if you only want to see specific things
    uint64_t debugMask = 0xFFFFFFFFFFFFFFFF;
    b3World_Draw(app->worldId, &app->debugDrawer, debugMask);

    // Update the screen
    SDL_GL_SwapWindow(app->window);
    return SDL_APP_CONTINUE;
}

[yudin-s]

There are two separate things mixed together here.

First, initialize the debug draw from b3DefaultDebugDraw(), not from {0}. The default initializer installs no-op callbacks and default drawing bounds. A zeroed b3DebugDraw leaves any callback you did not fill as NULL, and it also gives you an empty drawingBounds unless b3World_Draw expands around it internally.

Second, DrawSegmentFcn is not the callback used to draw normal solid shapes like your ground hull. In the current Box3D 3D sample renderer, shapes are handled through DrawShapeFcn, and the world is also created with debug-shape lifetime callbacks:

b3WorldDef worldDef = b3DefaultWorldDef();
// set worldDef.createDebugShape / destroyDebugShape here if your renderer uses cached shape objects
b3WorldId worldId = b3CreateWorld(&worldDef);

b3DebugDraw dd = b3DefaultDebugDraw();
dd.DrawShapeFcn = drawShape;        // needed for normal shape rendering
dd.DrawSegmentFcn = drawSegment;    // used for joints/contacts/extra lines
dd.DrawTransformFcn = drawTransform;
dd.DrawBoundsFcn = drawBounds;
dd.context = drawer;

dd.drawShapes = true;
dd.drawJoints = true;
dd.drawMass = true;     // this is the flag that can make transforms useful
// dd.drawBounds = true; // if you want AABBs

b3World_Draw(worldId, &dd, B3_DEFAULT_MASK_BITS);

With only a static ground body and no joints, drawJoints = true will not produce any segments. DrawSegmentFcn will mainly show up for things like joint debug geometry, contact normals/forces, or other line-style overlays when their specific flags are enabled. For actual hull/sphere/capsule/mesh shape visualization, implement DrawShapeFcn or follow the sample adapter pattern: register createDebugShape / destroyDebugShape on b3WorldDef before b3CreateWorld(), then have DrawShapeFcn render the cached user shape passed back by Box3D.

So the quickest test is:

1. Change b3DebugDraw dd = {0}; to b3DebugDraw dd = b3DefaultDebugDraw();.
2. Add a DrawShapeFcn that logs or renders the passed shape.
3. If you want to see DrawTransformFcn, enable drawMass, not only drawShapes.
4. If you want line callbacks, create a joint or enable contact/joint/force-style debug flags that actually emit line primitives.

If this fixes the missing callbacks, please mark it as the answer so future Box3D debug-draw integrations can find the callback split quickly.

[ivan-enzhaev]

I've decided to use Raylib instead of raw OpenGL for a while, to provide a complete, working example. I've used createDebugShape / destroyDebugShape and the drawShape was called in this case - I've written about it on Discord in this post. My question is: can I avoid createDebugShape to call the drawShape function? You wrote implement DrawShapeFcn or follow the sample adapter pattern: register createDebugShape / destroyDebugShape

First, initialize the debug draw from b3DefaultDebugDraw(), not from {0}. The default initializer installs no-op callbacks and default drawing bounds. A zeroed b3DebugDraw leaves any callback you did not fill as NULL, and it also gives you an empty drawingBounds unless b3World_Draw expands around it internally.

I fixed it. 1) I use now debugDraw = b3DefaultDebugDraw(); instead of {0} 2) I have added drawingBounds just in case:

debugDraw.drawingBounds = (b3AABB) {
    (b3Vec3) { -100.0f, -100.0f, -100.0f },
    (b3Vec3) { 100.0f, 100.0f, 100.0f }
};

3. If you want to see DrawTransformFcn, enable drawMass, not only drawShapes..

I've enabled dd.drawMass = true but the DrawTransformFcn was not called. The most important that the drawShape is not called without createDebugShape. The following example calls the drawBounds only:

main.c (full code)

#include <box3d/box3d.h>
#include <raylib.h>
#include <stdio.h>

// Global or persistent data
b3WorldId worldId;
b3DebugDraw dd;

Camera3D camera = { 0 };

bool drawShape(void *userShape, b3WorldTransform transform, b3HexColor color, void *context) {
    printf("draw shape\n");
    fflush(stdout);
    return true;
}

void drawSegment(b3Pos p1, b3Pos p2, b3HexColor color, void *context) {
    printf("draw segment\n");
    fflush(stdout);
}

void drawTransform(b3WorldTransform transform, void *context) {
    printf("draw transform\n");
    fflush(stdout);
}

void drawBounds(b3AABB aabb, b3HexColor color, void *context) {
    printf("draw bounds\n");
    fflush(stdout);
}

void drawBox(b3Vec3 extents, b3WorldTransform transform, b3HexColor color, void *context) {
    printf("draw box\n");
    fflush(stdout);
}

void drawString(b3Pos p, const char *s, b3HexColor color, void *context) {
    printf("draw string\n");
    fflush(stdout);
}

void InitGame()
{
    InitWindow(800, 450, "Raylib and Box3D");
    SetTargetFPS(60);

    // Camera
    camera.position = (Vector3) { 10.f, 10.f, 10.f };
    camera.target = (Vector3) { 0.f, 0.f, 0.f };
    camera.up = (Vector3) { 0.f, 1.f, 0.f };
    camera.fovy = 45.f;
    camera.projection = CAMERA_PERSPECTIVE;

    // Debug draw
    dd = b3DefaultDebugDraw();
    dd.DrawShapeFcn = drawShape;
    dd.DrawSegmentFcn = drawSegment;
    dd.DrawTransformFcn = drawTransform;
    dd.DrawBoundsFcn = drawBounds;
    dd.DrawBoxFcn = drawBox;
    dd.DrawStringFcn = drawString;
    // dd.context = drawer;

    dd.drawShapes = true;
    dd.drawJoints = true;
    dd.drawMass = true;
    dd.drawBounds = true;

    dd.drawingBounds = (b3AABB) {
        (b3Vec3) { -100.0f, -100.0f, -100.0f },
        (b3Vec3) { 100.0f, 100.0f, 100.0f }
    };

    // Box3D world
    b3WorldDef worldDef = b3DefaultWorldDef();
    worldDef.gravity = (b3Vec3) { 0.0f, -9.8f, 0.0f };
    worldId = b3CreateWorld(&worldDef);

    // Ground
    b3BodyDef groundBodyDef = b3DefaultBodyDef();
    groundBodyDef.position = (b3Vec3) { 0.f, -0.f, 0.f };
    b3BodyId groundId = b3CreateBody(worldId, &groundBodyDef);
    b3BoxHull groundBox = b3MakeBoxHull(5.f, 0.5f, 5.f);
    b3ShapeDef groundShapeDef = b3DefaultShapeDef();
    b3CreateHullShape(groundId, &groundShapeDef, &groundBox.base);
}

void UpdateGame()
{
    b3World_Step(worldId, 1.0f / 60.0f, 5);
}

void DrawGame()
{
    BeginDrawing();
    ClearBackground(RAYWHITE);

    BeginMode3D(camera);
    b3World_Draw(worldId, &dd, B3_DEFAULT_MASK_BITS);
    EndMode3D();

    b3Vec3 g = b3World_GetGravity(worldId);
    DrawText(TextFormat("Gravity is: (%0.1f, %0.1f, %0.1f)", g.x, g.y, g.z), 190, 200, 20, DARKGRAY);

    EndDrawing();
}

void ShutdownGame()
{
    b3DestroyWorld(worldId);
    CloseWindow();
}

int main()
{
    InitGame();

    while (!WindowShouldClose())
    {
        UpdateGame();
        DrawGame();
    }

    ShutdownGame();

    return 0;
}

[yudin-s]

Yes, your new result matches the intended API: for normal shape debug rendering, expect to use createDebugShape / destroyDebugShape.

DrawShapeFcn is not an immediate-mode "please describe this hull to me every frame" callback. It receives the userShape handle that your worldDef.createDebugShape callback created earlier. So if createDebugShape is not registered, there is no renderer-side shape object for Box3D to pass into DrawShapeFcn, and seeing only DrawBoundsFcn in your reduced example is expected.

For a Raylib renderer, the usual shape is:

void* createDebugShape(b3ShapeId shapeId, const b3ShapeData* data, void* context) {
    // build/cache your Raylib mesh/model or your own vertex/index buffers from data
    // return a pointer/handle to that renderer object
}

void destroyDebugShape(void* userShape, void* context) {
    // free/unload the renderer object
}

bool drawShape(void* userShape, b3WorldTransform transform, b3HexColor color, void* context) {
    // cast userShape back to your renderer object and draw it at transform
    return true;
}

So the answer to "can I avoid createDebugShape to call drawShape?" is: not for the normal shape path. You can avoid it only by building a separate renderer that walks your own application-side body/shape data and draws it yourself, outside b3World_Draw. If you want to use Box3D debug draw for shapes, create the debug shape handles and let Box3D call DrawShapeFcn with those handles.

For DrawTransformFcn: with only a static ground body, there is not much mass/contact/joint debug data to draw. The Discord maintainer answer you copied is the key bit there: no mass or contact points means those callbacks may simply have nothing to emit.

[ivan-enzhaev]

I need a few days to explain my progress.

[ivan-enzhaev]

A simple example using Raylib to show the solution:

View WebAssemlby-demo in the Browser

GitHub repositories for C and C++ projects for the demo above (Desktop and WebAssembly):

• C-project: https://github.com/ivan-enzhaev/debug-drawer-box3d-raylib-c
• C++-project: https://github.com/ivan-enzhaev/debug-drawer-box3d-raylib-cpp

main.c (full code)

#include <box3d/box3d.h>
#include <raylib.h>
#include <raymath.h> // Required for QuaternionToMatrix and MatrixToFloat
#include <rlgl.h>    // Required for rlPushMatrix, rlMultMatrixf, rlPopMatrix
#include <stdio.h>
#include <stdlib.h> // Required for malloc/free

// Global or persistent data
b3WorldId worldId;
b3DebugDraw dd;

Camera3D camera = { 0 };

typedef struct
{
    b3ShapeType type;
    b3Vec3 extents; // For boxes, we store half-extents
    float radius;   // For spheres
} MyDebugShape;

int b3InternalAssert(const char *condition, const char *fileName, int lineNumber)
{
    printf("Box3D Assertion Failed: %s, file %s, line %d\n", condition, fileName, lineNumber);
    fflush(stdout);

    // Returning 1 usually tells the engine to trigger a breakpoint (if supported)
    // Returning 0 just ignores the error.
    // Using abort() here ensures the program stops immediately so you can debug.
    abort();

    return 1;
}

void *createDebugShape(const b3DebugShape *debugShape, void *context)
{
    MyDebugShape *myShape = (MyDebugShape *)malloc(sizeof(MyDebugShape));
    myShape->type = debugShape->type;

    if (debugShape->type == b3_hullShape)
    {
        b3AABB aabb = debugShape->hull->aabb;

        // Calculate the full dimensions (width, height, depth)
        // size = upperBound - lowerBound
        myShape->extents.x = (aabb.upperBound.x - aabb.lowerBound.x) * 0.5f;
        myShape->extents.y = (aabb.upperBound.y - aabb.lowerBound.y) * 0.5f;
        myShape->extents.z = (aabb.upperBound.z - aabb.lowerBound.z) * 0.5f;
    }
    else if (debugShape->type == b3_sphereShape)
    {
        myShape->radius = debugShape->sphere->radius;
    }

    return (void *)myShape;
}

void destroyDebugShape(void *userShape, void *context)
{
    free(userShape); // Free the memory we allocated
}

bool drawShape(void *userShape, b3WorldTransform transform, b3HexColor color, void *context)
{
    MyDebugShape *myShape = (MyDebugShape *)userShape;
    b3Vec3 pos = b3ToVec3(transform.p); // Convert high-precision b3Pos to float Vector3
    Vector3 vPos = { pos.x, pos.y, pos.z };

    if (myShape->type == b3_hullShape)
    {
        // Map b3Quat (s, v) to Raylib Quaternion (x, y, z, w)
        // Raylib expects: x, y, z, w
        // Box3D provides: v.x, v.y, v.z, s
        Matrix mat = QuaternionToMatrix((Quaternion) {
            transform.q.v.x,
            transform.q.v.y,
            transform.q.v.z,
            transform.q.s });

        // Apply translation to the matrix
        mat.m12 = pos.x;
        mat.m13 = pos.y;
        mat.m14 = pos.z;

        // Draw with matrix
        rlPushMatrix();
        rlMultMatrixf(MatrixToFloat(mat));

        Vector3 size = { myShape->extents.x * 2.0f, myShape->extents.y * 2.0f, myShape->extents.z * 2.0f };
        DrawCubeWires((Vector3) { 0, 0, 0 }, size.x, size.y, size.z, DARKGRAY);

        rlPopMatrix();
    }
    else if (myShape->type == b3_sphereShape) // Add this
    {
        // Create the rotation matrix from the quaternion
        Matrix mat = QuaternionToMatrix((Quaternion) {
            transform.q.v.x,
            transform.q.v.y,
            transform.q.v.z,
            transform.q.s });

        // Apply the translation
        mat.m12 = pos.x;
        mat.m13 = pos.y;
        mat.m14 = pos.z;

        // Apply the matrix so the sphere's coordinate system is transformed
        rlPushMatrix();
        rlMultMatrixf(MatrixToFloat(mat));

        // Draw the sphere wires at origin (0,0,0) because the matrix handles position
        DrawSphereWires((Vector3) { 0, 0, 0 }, myShape->radius, 10, 10, DARKGRAY);

        rlPopMatrix();
    }

    return true;
}

void CreateBoxAtMouse()
{
    if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
    {
        // Get a ray from the camera to the mouse position
        Ray ray = GetMouseRay(GetMousePosition(), camera);

        // Find intersection with the Z = 0 plane.
        // The ray is: origin + t * direction
        // We want origin.z + t * direction.z = 0
        // So: t = -origin.z / direction.z
        float t = -ray.position.z / ray.direction.z;
        Vector3 worldPos = {
            ray.position.x + ray.direction.x * t,
            ray.position.y + ray.direction.y * t,
            0.0f // Fixed on the Z=0 plane
        };

        // Create the Box3D body
        b3BodyDef boxBodyDef = b3DefaultBodyDef();
        boxBodyDef.type = b3_dynamicBody;
        boxBodyDef.position = (b3Vec3) { worldPos.x, worldPos.y, worldPos.z };

        b3BodyId boxId = b3CreateBody(worldId, &boxBodyDef);

        b3BoxHull boxHull = b3MakeBoxHull(0.5f, 0.5f, 0.5f);
        b3ShapeDef boxShapeDef = b3DefaultShapeDef();
        boxShapeDef.density = 1.0f;

        b3CreateHullShape(boxId, &boxShapeDef, &boxHull.base);
    }
}

void CreateSphereAtMouse()
{
    if (IsMouseButtonPressed(MOUSE_BUTTON_RIGHT))
    {
        Ray ray = GetMouseRay(GetMousePosition(), camera);
        float t = -ray.position.z / ray.direction.z;
        Vector3 worldPos = {
            ray.position.x + ray.direction.x * t,
            ray.position.y + ray.direction.y * t,
            0.0f
        };

        b3BodyDef bodyDef = b3DefaultBodyDef();
        bodyDef.type = b3_dynamicBody;
        bodyDef.position = (b3Vec3) { worldPos.x, worldPos.y, worldPos.z };
        b3BodyId bodyId = b3CreateBody(worldId, &bodyDef);

        // Use the sphere primitive constructor
        b3Sphere sphere = { .center = { 0, 0, 0 }, .radius = 0.5f };
        b3ShapeDef shapeDef = b3DefaultShapeDef();
        shapeDef.density = 1.0f;

        b3CreateSphereShape(bodyId, &shapeDef, &sphere);
    }
}

void InitGame()
{
    InitWindow(800, 450, "Raylib and Box3D");
    SetTargetFPS(60);

    // Camera
    camera.position = (Vector3) { 0.f, 0.f, 10.f };
    camera.target = (Vector3) { 0.f, 0.f, 0.f };
    camera.up = (Vector3) { 0.f, 1.f, 0.f };
    camera.fovy = 50.f;
    camera.projection = CAMERA_PERSPECTIVE;

    // Debug draw
    dd = b3DefaultDebugDraw();
    dd.DrawShapeFcn = drawShape;
    dd.drawShapes = true;

    dd.drawingBounds = (b3AABB) {
        (b3Vec3) { -100.0f, -100.0f, -100.0f },
        (b3Vec3) { 100.0f, 100.0f, 100.0f }
    };

    // Box3D world
    b3WorldDef worldDef = b3DefaultWorldDef();
    worldDef.gravity = (b3Vec3) { 0.0f, -9.8f, 0.0f };
    worldDef.createDebugShape = createDebugShape;
    worldDef.destroyDebugShape = destroyDebugShape;
    worldId = b3CreateWorld(&worldDef);

    // Ground rotation
    // Convert 20 degrees to radians
    float angleInRadians = 10.0f * (PI / 180.0f);
    // Define the axis of rotation (Z-axis)
    b3Vec3 axis = { 0.f, 0.f, 1.f };
    // Create the quaternion
    b3Quat rotation = b3MakeQuatFromAxisAngle(axis, angleInRadians);

    // Create a ground
    b3BodyDef groundBodyDef = b3DefaultBodyDef();
    groundBodyDef.position = (b3Vec3) { 0.f, -2.f, 0.f };
    groundBodyDef.rotation = rotation;
    b3BodyId groundId = b3CreateBody(worldId, &groundBodyDef);
    b3BoxHull groundBox = b3MakeBoxHull(5.f, 0.2f, 1.f);
    b3ShapeDef groundShapeDef = b3DefaultShapeDef();
    b3CreateHullShape(groundId, &groundShapeDef, &groundBox.base);

    // Create a dynamic falling box
    b3BodyDef boxBodyDef = b3DefaultBodyDef();
    boxBodyDef.type = b3_dynamicBody;                 // This tells Box3D it should fall
    boxBodyDef.position = (b3Vec3) { 0.f, 5.f, 0.f }; // Start 5 units above
    b3BodyId boxId = b3CreateBody(worldId, &boxBodyDef);
    b3BoxHull boxHull = b3MakeBoxHull(0.5f, 0.5f, 0.5f);
    b3ShapeDef boxShapeDef = b3DefaultShapeDef();
    // Setting density makes the object have mass so gravity affects it
    boxShapeDef.density = 1.0f;
    b3CreateHullShape(boxId, &boxShapeDef, &boxHull.base);
}

void UpdateGame()
{
    CreateBoxAtMouse();
    CreateSphereAtMouse();
    b3World_Step(worldId, 1.0f / 60.0f, 5);
}

void DrawGame()
{
    BeginDrawing();
    ClearBackground(RAYWHITE);

    BeginMode3D(camera);
    b3World_Draw(worldId, &dd, B3_DEFAULT_MASK_BITS);
    EndMode3D();

    // Display game information
    b3Vec3 g = b3World_GetGravity(worldId);
    DrawText(TextFormat("Gravity is: (%0.1f, %0.1f, %0.1f)", g.x, g.y, g.z), 10, 10, 20, DARKGRAY);

    // Display controls
    DrawText("Controls: [Left Click] Spawn Box | [Right Click] Spawn Sphere", 10, 40, 20, MAROON);

    EndDrawing();
}

void ShutdownGame()
{
    b3DestroyWorld(worldId);
    CloseWindow();
}

int main()
{
    InitGame();

    while (!WindowShouldClose())
    {
        UpdateGame();
        DrawGame();
    }

    ShutdownGame();

    return 0;
}

Steps that solved the problem:

1. Create a structure that createDebugShape will return:

typedef struct
{
    b3ShapeType type;
    b3Vec3 extents; // For boxes, we store half-extents
    float radius;   // For spheres
} MyDebugShape;

2. Return a shape from the createDebugShape function:

void *createDebugShape(const b3DebugShape *debugShape, void *context)
{
    MyDebugShape *myShape = (MyDebugShape *)malloc(sizeof(MyDebugShape));
    myShape->type = debugShape->type;

    if (debugShape->type == b3_hullShape)
    {
        b3AABB aabb = debugShape->hull->aabb;

        // Calculate the full dimensions (width, height, depth)
        // size = upperBound - lowerBound
        myShape->extents.x = (aabb.upperBound.x - aabb.lowerBound.x) * 0.5f;
        myShape->extents.y = (aabb.upperBound.y - aabb.lowerBound.y) * 0.5f;
        myShape->extents.z = (aabb.upperBound.z - aabb.lowerBound.z) * 0.5f;
    }
    else if (debugShape->type == b3_sphereShape)
    {
        myShape->radius = debugShape->sphere->radius;
    }

    return (void *)myShape;
}

3. Do not forget to destroy your shape in the destroyDebugShape:

void destroyDebugShape(void *userShape, void *context)
{
    free(userShape); // Free the memory we allocated
}

4. Get a shape in drawShape, apply position and quaternion:

drawShape code

bool drawShape(void *userShape, b3WorldTransform transform, b3HexColor color, void *context)
{
    MyDebugShape *myShape = (MyDebugShape *)userShape;
    b3Vec3 pos = b3ToVec3(transform.p); // Convert high-precision b3Pos to float Vector3
    Vector3 vPos = { pos.x, pos.y, pos.z };

    if (myShape->type == b3_hullShape)
    {
        // Map b3Quat (s, v) to Raylib Quaternion (x, y, z, w)
        // Raylib expects: x, y, z, w
        // Box3D provides: v.x, v.y, v.z, s
        Matrix mat = QuaternionToMatrix((Quaternion) {
            transform.q.v.x,
            transform.q.v.y,
            transform.q.v.z,
            transform.q.s });

        // Apply translation to the matrix
        mat.m12 = pos.x;
        mat.m13 = pos.y;
        mat.m14 = pos.z;

        // Draw with matrix
        rlPushMatrix();
        rlMultMatrixf(MatrixToFloat(mat));

        Vector3 size = { myShape->extents.x * 2.0f, myShape->extents.y * 2.0f, myShape->extents.z * 2.0f };
        DrawCubeWires((Vector3) { 0, 0, 0 }, size.x, size.y, size.z, DARKGRAY);

        rlPopMatrix();
    }
    else if (myShape->type == b3_sphereShape) // Add this
    {
        // Create the rotation matrix from the quaternion
        Matrix mat = QuaternionToMatrix((Quaternion) {
            transform.q.v.x,
            transform.q.v.y,
            transform.q.v.z,
            transform.q.s });

        // Apply the translation
        mat.m12 = pos.x;
        mat.m13 = pos.y;
        mat.m14 = pos.z;

        // Apply the matrix so the sphere's coordinate system is transformed
        rlPushMatrix();
        rlMultMatrixf(MatrixToFloat(mat));

        // Draw the sphere wires at origin (0,0,0) because the matrix handles position
        DrawSphereWires((Vector3) { 0, 0, 0 }, myShape->radius, 10, 10, DARKGRAY);

        rlPopMatrix();
    }

    return true;
}

5. Enable drawing of shapes and set a callback:

    // Debug draw
    dd = b3DefaultDebugDraw();
    dd.DrawShapeFcn = drawShape;
    dd.drawShapes = true;

6. Set callbacks for functions:

    // Box3D world
    b3WorldDef worldDef = b3DefaultWorldDef();
    worldDef.gravity = (b3Vec3) { 0.0f, -9.8f, 0.0f };
    worldDef.createDebugShape = createDebugShape;
    worldDef.destroyDebugShape = destroyDebugShape;
    worldId = b3CreateWorld(&worldDef);

I've recorded every step on these videos to create Box3D and Raylib integration with b3DebugDraw from scratch:

Text version: C/C++ Environment Setup with CLion, CMake, and MinGW
Video version: https://www.youtube.com/live/uuJObyUUC_8

Text version: Building Box3D from Source (MinGW)
Video version: https://www.youtube.com/live/uzVXntxR4Q4

Text version: Setting Up Box3D and Raylib in CLion with CMake and MinGW
Video version: https://www.youtube.com/live/240PVEH-iwo

Text version: Using Debug Drawer b3DebugDraw with Box3D and Raylib in CLion
Video version: https://www.youtube.com/live/tA5NI_uh00Q

[ivan-enzhaev]

These are my CMake-project templates for Raylib and Box3D to build to Windows, Android, and WebAssembly:

• C: debug-drawer-box3d-raylib-c
• C++: debug-drawer-box3d-raylib-cpp

Demo video: https://www.youtube.com/watch?v=KYDzSve6DTQ

[ivan-enzhaev]

I should publish chaosed0's and Erin's answers here from Discord:

chaosed0's answer (discord link):

I've been searching for the answer to this myself; it looks like you need to use createDebugShape on World to init a debug handle, which you'll then receive through DrawShapeFcn.
I can't verify because I'm using a Rust binding which doesn't currently expose it 😅

Erin's answer (discord link):

Those are used when you draw contacts, body mass, etc.

Erin's answer (discord link):

No mass or contact points to be drawn. So it won't call those function because there is nothing to draw.

Erin's answer (discord link):

That's not how the interface works. It draws shapes. I leave it up to you on how you want to draw the shapes.

Erin's answer (discord link):

    // Used to create debug draw shapes. This is called when a shape is
    // first drawn using b3DebugDraw.
    b3CreateDebugShapeCallback* createDebugShape;

It is not practical to draw complex 3D scenes line by line. The expectation is you build a vertex buffer or similar from Box3D shape data and create some sort of render object on your side. Then you pass back a pointer to that object to Box3D. Then Box3D will handle the scene culling. I recommend to look at the samples app.