sbgl_batcher.h File Reference

The baking pipeline for compressing draw packets into indirect commands. More...

#include "backend/sbgl_graphics_hal.h"
#include "sbgl_types.h"

Include dependency graph for sbgl_batcher.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
uint32_t	sbgl_bake_commands (const sbgl_DrawPacket *packets, uint32_t packetCount, sbgl_IndirectCommand *outCommands, uint32_t maxCommands)

Detailed Description

The baking pipeline for compressing draw packets into indirect commands.

The batcher provides the logic for grouping multiple draw requests into consolidated indirect commands, maximizing GPU throughput.

Definition in file sbgl_batcher.h.

Function Documentation

sbgl_bake_commands()

uint32_t sbgl_bake_commands	(	const sbgl_DrawPacket *	packets,
		uint32_t	packetCount,
		sbgl_IndirectCommand *	outCommands,
		uint32_t	maxCommands )

Bakes an array of sorted draw packets into optimized indirect commands.

The system groups contiguous draw packets that share the same mesh, material, and sort key into single multi-instance draw calls. This reduction minimizes the overhead of submitting thousands of individual commands to the graphics hardware.

Parameters

packets	A contiguous array of draw packets, assumed to be sorted.
packetCount	Total number of packets provided in the input array.
outCommands	Destination array for generated indirect commands.
maxCommands	Maximum number of commands the output array can hold.

Returns

The total number of indirect commands generated.

Definition at line 3 of file sbgl_batcher.c.

  {
    if (packetCount == 0 || maxCommands == 0) {
        return 0;
    }
 
    // The system initializes the first command using the first packet in the stream.
    // Geometry parameters are derived from the mesh identifier.
    uint32_t commandCount = 1;
 
    switch (SBGL_GET_MESH_ID(packets[0].header)) {
    case 0: // Triangle
        outCommands[0].indexCount = 3;
        outCommands[0].firstIndex = 0;
        outCommands[0].vertexOffset = 0;
        break;
    case 1: // Cube
        outCommands[0].indexCount = 36;
        outCommands[0].firstIndex = 3;
        outCommands[0].vertexOffset = 3;
        break;
    case 2: // Pyramid
        outCommands[0].indexCount = 18;
        outCommands[0].firstIndex = 39;
        outCommands[0].vertexOffset = 11;
        break;
    case 3:                                // Voxel Chunk (Procedural 32x32 grid of cubes)
        outCommands[0].indexCount = 36864; // 32 * 32 * 36
        outCommands[0].firstIndex = 0;     // Generated in shader via gl_VertexIndex
        outCommands[0].vertexOffset = 0;
        break;
    default:
 
        outCommands[0].indexCount = 0;
        outCommands[0].firstIndex = 0;
        outCommands[0].vertexOffset = 0;
        break;
    }
 
    outCommands[0].instanceCount = 1;
    outCommands[0].firstInstance = 0;
 
    // The logic iterates through remaining packets, comparing each to its predecessor.
    // If the state matches, the instance count of the current command is incremented.
    // Otherwise, a new command is started if space permits in the output buffer.
    for (uint32_t i = 1; i < packetCount; ++i) {
        const sbgl_DrawPacket* packet = &packets[i];
        const sbgl_DrawPacket* previous = &packets[i - 1];
 
        bool canBatch = (packet->header == previous->header) && (packet->key == previous->key);
 
        if (canBatch) {
            outCommands[commandCount - 1].instanceCount++;
        } else {
            if (commandCount >= maxCommands) {
                break;
            }
 
            sbgl_IndirectCommand* command = &outCommands[commandCount];
 
            switch (SBGL_GET_MESH_ID(packet->header)) {
            case 0: // Triangle
                command->indexCount = 3;
                command->firstIndex = 0;
                command->vertexOffset = 0;
                break;
            case 1: // Cube
                command->indexCount = 36;
                command->firstIndex = 3;
                command->vertexOffset = 3;
                break;
            case 2: // Pyramid
                command->indexCount = 18;
                command->firstIndex = 39;
                command->vertexOffset = 11;
                break;
            case 3: // Voxel Chunk
                command->indexCount = 36864;
                command->firstIndex = 0;
                command->vertexOffset = 0;
                break;
            default:
                command->indexCount = 0;
                command->firstIndex = 0;
                command->vertexOffset = 0;
                break;
            }
 
            command->instanceCount = 1;
 
            // The starting instance index is set to the current packet index,
            // assuming instance data is packed contiguously in the order of sorted packets.
            command->firstInstance = i;
 
            commandCount++;
        }
    }
 
    return commandCount;
}