sbgl_core.c

Go to the documentation of this file.

#include "sbgl.h"
#include "sbgl_types.h"
 
#define SBL_ARENA_IMPLEMENTATION
#include "core/sbl_arena.h"
 
#include "backend/sbgl_graphics_hal.h"
#include "core/sbgl_batcher.h"
#include "core/sbgl_context_internal.h"
#include "core/sbgl_internal_log.h"
#include "core/sbgl_platform.h"
#include "core/sbgl_sort.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
 
struct sbgl_RenderQueue {
    sbgl_DrawPacket* packets;     
    sbgl_InstanceData* instances; 
    uint32_t count;               
    uint32_t capacity;            
    struct SblArena* arena;       
};
 
typedef struct {
    SblArena arena;          
    SblArena transientArena; 
    sbgl_Window* window;     
    sbgl_GfxContext* gfx;    
    float clearColor[4];     
    struct {
        uint32_t isDrawing : 1;   
        uint32_t hasStartedFrame : 1; 
        uint32_t isIdle : 1;      
        uint32_t wasFocused : 1;  
        uint32_t mouseLocked : 1; 
    } state;
    sbgl_InputState input;    
    sbgl_MouseMode mouseMode; 
    sbgl_Telemetry lastFrame;
    sbgl_Telemetry currentFrame;
    uint64_t frameCount;
    uint64_t frameStartTicks;
    uint64_t sortStartTicks;
} sbgl_InternalContext;
 
SblArena* sbgl_GetContextArena(sbgl_Context* ctx) {
  if (!ctx || !ctx->inner)
    return NULL;
  sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
  return &inner->arena;
}
 
// --- Error Inspection API ---
 
sbgl_Result sbgl_GetResult(sbgl_Context* ctx) {
  if (!ctx) {
    return SBGL_ERROR_NULL_CONTEXT;
  }
  return ctx->result;
}
 
sbgl_ErrorDetail sbgl_GetErrorDetail(sbgl_Context* ctx) {
  sbgl_ErrorDetail detail = {
    .type = SBGL_BACKEND_VULKAN,
    .coreResult = SBGL_SUCCESS,
    .vkResult = 0,
    .extension = 0,
  };
 
  if (!ctx) {
    detail.coreResult = SBGL_ERROR_NULL_CONTEXT;
    return detail;
  }
 
  detail.coreResult = ctx->result;
 
  if (ctx->inner) {
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    if (inner->gfx) {
      detail.vkResult = sbgl_gfx_GetLastVkResult(inner->gfx);
    }
  }
 
  return detail;
}
 
void sbgl_ClearResult(sbgl_Context* ctx) {
  if (!ctx) {
    return;
  }
  ctx->result = SBGL_SUCCESS;
}
 
// --- Initialization ---
 
sbgl_InitResult sbgl_InitWithConfig(const sbgl_InitConfig* config) {
    sbgl_InitResult res = { .ctx = NULL, .error = SBGL_SUCCESS };
 
    if (!config) {
        res.error = SBGL_ERROR_INVALID_ARGUMENT;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_InitWithConfig: NULL config passed");
        return res;
    }
 
    SblArena main_arena;
    if (!sbl_arena_init(&main_arena, 4 * 1024 * 1024)) {
        res.error = SBGL_ERROR_OUT_OF_MEMORY;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_InitWithConfig: arena initialization failed");
        return res;
    }
 
    sbgl_Context* ctx = SBL_ARENA_PUSH_STRUCT_ZERO(&main_arena, sbgl_Context);
    if (!ctx) {
        sbl_arena_free(&main_arena);
        res.error = SBGL_ERROR_OUT_OF_MEMORY;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_InitWithConfig: context allocation failed");
        return res;
    }
 
    sbgl_InternalContext* inner = SBL_ARENA_PUSH_STRUCT_ZERO(&main_arena, sbgl_InternalContext);
    if (!inner) {
        sbl_arena_free(&main_arena);
        res.error = SBGL_ERROR_OUT_OF_MEMORY;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_InitWithConfig: inner context allocation failed");
        return res;
    }
 
    inner->arena = main_arena;
    sbl_arena_init(&inner->transientArena, 16 * 1024 * 1024);
    inner->clearColor[0] = 0.0f;
    inner->clearColor[1] = 0.0f;
    inner->clearColor[2] = 0.0f;
    inner->clearColor[3] = 0.0f;
    inner->state.isIdle = 1;
    inner->mouseMode = SBGL_MOUSE_MODE_NORMAL;
    inner->state.wasFocused = 0;
 
    ctx->inner = inner;
    ctx->result = SBGL_SUCCESS;
 
    const char* title = config->windowTitle ? config->windowTitle : "SBgl";
    sbgl_platform_Result platformRes = sbgl_os_CreateWindow(
      &inner->arena, &inner->input,
      config->windowWidth, config->windowHeight, title,
      &inner->window
    );
 
    if (platformRes != SBGL_PLATFORM_SUCCESS) {
        res.error = SBGL_ERROR_WINDOW_CREATION_FAILED;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_PLATFORM,
                      "sbgl_InitWithConfig: window creation failed");
        sbl_arena_free(&inner->arena);
        return res;
    }
 
    inner->gfx = sbgl_gfx_Init(inner->window, &inner->arena, &config->limits, config->enableValidation);
    if (!inner->gfx) {
        res.error = SBGL_ERROR_GRAPHICS_FAILED;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_GFX,
                      "sbgl_InitWithConfig: graphics initialization failed");
        sbgl_os_DestroyWindow(inner->window);
        sbl_arena_free(&inner->arena);
        return res;
    }
 
    sbgl_log_impl(SBGL_LOG_INFO, SBGL_LOG_CAT_CORE,
                  "sbgl_InitWithConfig: initialization successful");
 
    res.ctx = ctx;
    return res;
}
 
sbgl_InitResult sbgl_Init(int w, int h, const char* title) {
    sbgl_InitConfig config = {
        .windowWidth = w,
        .windowHeight = h,
        .windowTitle = title,
        .limits = { .maxBuffers = 1024, .maxShaders = 256, .maxPipelines = 256 },
        .enableValidation = true
    };
    return sbgl_InitWithConfig(&config);
}
 
void sbgl_Shutdown(sbgl_Context* ctx) {
    if (!ctx) {
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_Shutdown: NULL context");
        return;
    }
    if (!ctx->inner) {
        ctx->result = SBGL_ERROR_NULL_CONTEXT;
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_CORE,
                      "sbgl_Shutdown: uninitialized context");
        return;
    }
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    sbgl_log_impl(SBGL_LOG_INFO, SBGL_LOG_CAT_CORE, "Initiating shutdown...");
 
    if (!inner->state.isIdle) {
        sbgl_DeviceWaitIdle(ctx);
    }
 
    if (inner->gfx)
        sbgl_gfx_Shutdown(inner->gfx);
    if (inner->window)
        sbgl_os_DestroyWindow(inner->window);
 
    sbl_arena_free(&inner->transientArena);
 
    // The context itself is allocated within inner->arena, 
    // so we cannot access it after the arena is freed.
    ctx->result = SBGL_SUCCESS;
    
    sbl_arena_free(&inner->arena);
}
 
bool sbgl_WindowShouldClose(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return true;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    return sbgl_os_WindowShouldClose(inner->window);
}
 
double sbgl_GetTime(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return 0.0;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    return (double)sbgl_os_GetPerfCount(inner->window) / (double)sbgl_os_GetPerfFreq(inner->window);
}
 
void sbgl_GetWindowSize(sbgl_Context* ctx, int* w, int* h) {
    if (w)
        *w = 0;
    if (h)
        *h = 0;
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_os_GetWindowSize(inner->window, w, h);
}
void sbgl_BeginDrawing(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner) return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    // Reset compute handle to prevent cross-phase push constant delivery
    sbgl_gfx_BindComputePipeline(inner->gfx, SBGL_INVALID_HANDLE);
 
    if (!inner->state.hasStartedFrame) {
        sbgl_os_PollEvents(inner->window);
 
        // Detect focus transitions to re-apply mouse locking if necessary.
        bool currentlyFocused = sbgl_os_IsWindowFocused(inner->window);
        if (currentlyFocused && !inner->state.wasFocused) {
            if (inner->mouseMode == SBGL_MOUSE_MODE_CAPTURED) {
                sbgl_os_SetCursorVisible(inner->window, false);
                sbgl_os_SetCursorLocked(inner->window, true);
            }
        }
        inner->state.wasFocused = currentlyFocused;
 
        inner->frameStartTicks = sbgl_os_GetPerfCount(inner->window);
 
        // Performance counters are reset at the start of every frame
        inner->currentFrame.draw_calls = 0;
        inner->currentFrame.instance_count = 0;
        inner->currentFrame.cpu_sort_time = 0.0f;
 
        if (sbgl_gfx_BeginFrame(inner->gfx)) {
            inner->state.hasStartedFrame = 1;
            
            /* GPU performance data for the previous frame in this slot is now guaranteed 
               to be ready. Telemetry is skipped for the very first frames to allow 
               the pipeline to prime and avoid uninitialized query errors. */
            if (inner->frameCount > 2) {
                inner->currentFrame.gpu_render_time = sbgl_gfx_GetGpuTime(inner->gfx);
            }
        } else {
            ctx->result = SBGL_ERROR_GRAPHICS_FAILED;
            return;
        }
    }
 
    sbgl_gfx_BeginRenderPass(
        inner->gfx,
        inner->clearColor[0],
        inner->clearColor[1],
        inner->clearColor[2],
        inner->clearColor[3]
    );
    inner->state.isDrawing = 1;
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_EndDrawing(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    if (inner->state.isDrawing) {
        sbgl_gfx_EndRenderPass(inner->gfx);
        inner->state.isDrawing = 0;
    }
 
    if (inner->state.hasStartedFrame) {
        sbgl_gfx_EndFrame(inner->gfx);
        inner->state.hasStartedFrame = 0;
        inner->state.isIdle = 0;
        inner->frameCount++;
 
        uint64_t frameEndTicks = sbgl_os_GetPerfCount(inner->window);
        inner->currentFrame.cpu_frame_time =
            (float)((double)(frameEndTicks - inner->frameStartTicks) * 1000.0 / (double)sbgl_os_GetPerfFreq(inner->window));
 
        // The completed telemetry data is archived for user retrieval
        inner->lastFrame = inner->currentFrame;
    }
 
    // Reset pressed states for next frame
    memset(inner->input.keysPressed, 0, sizeof(inner->input.keysPressed));
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_BeginCompute(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    // Reset graphics handle to prevent cross-phase push constant delivery
    sbgl_gfx_BindPipeline(inner->gfx, SBGL_INVALID_HANDLE);
 
    /* If a frame has not yet been initiated, the system handles event polling,
       focus management, and starts the GPU command stream. */
    if (!inner->state.hasStartedFrame) {
        sbgl_os_PollEvents(inner->window);
 
        bool currentlyFocused = sbgl_os_IsWindowFocused(inner->window);
        if (currentlyFocused && !inner->state.wasFocused) {
            if (inner->mouseMode == SBGL_MOUSE_MODE_CAPTURED) {
                sbgl_os_SetCursorVisible(inner->window, false);
                sbgl_os_SetCursorLocked(inner->window, true);
            }
        }
        inner->state.wasFocused = currentlyFocused;
 
        inner->frameStartTicks = sbgl_os_GetPerfCount(inner->window);
 
        inner->currentFrame.draw_calls = 0;
        inner->currentFrame.instance_count = 0;
        inner->currentFrame.cpu_sort_time = 0.0f;
 
        if (sbgl_gfx_BeginFrame(inner->gfx)) {
            inner->state.hasStartedFrame = 1;
            if (inner->frameCount > 2) {
                inner->currentFrame.gpu_render_time = sbgl_gfx_GetGpuTime(inner->gfx);
            }
        } else {
            ctx->result = SBGL_ERROR_GRAPHICS_FAILED;
            return;
        }
    }
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_EndCompute(sbgl_Context* ctx) {
    /* The compute phase finalize is currently a no-op at the core level,
       as command buffer submission is deferred until the main frame end. */
    (void)ctx;
}
 
void sbgl_DeviceWaitIdle(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_DeviceWaitIdle(inner->gfx);
    inner->state.isIdle = 1;
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_SetClearColor(sbgl_Context* ctx, float r, float g, float b, float a) {
    if (!ctx || !ctx->inner)
        return;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    inner->clearColor[0] = r;
    inner->clearColor[1] = g;
    inner->clearColor[2] = b;
    inner->clearColor[3] = a;
    ctx->result = SBGL_SUCCESS;
}
 
const sbgl_InputState* sbgl_GetInputState(sbgl_Context* ctx) {
    static const sbgl_InputState dummy = { 0 };
    if (!ctx || !ctx->inner)
        return &dummy;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    return &inner->input;
}
 
void sbgl_SetMouseMode(sbgl_Context* ctx, sbgl_MouseMode mode) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    inner->mouseMode = mode;
 
    bool visible = (mode == SBGL_MOUSE_MODE_NORMAL);
    bool locked = (mode == SBGL_MOUSE_MODE_CAPTURED);
 
    sbgl_os_SetCursorVisible(inner->window, visible);
    sbgl_os_SetCursorLocked(inner->window, locked);
    ctx->result = SBGL_SUCCESS;
}
 
sbgl_Telemetry sbgl_GetTelemetry(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner) {
        return (sbgl_Telemetry){ 0 };
    }
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    return inner->lastFrame;
}
 
sbgl_Buffer
sbgl_CreateBuffer(sbgl_Context* ctx, sbgl_BufferUsage usage, size_t size, const void* data) {
    if (!ctx || !ctx->inner)
        return SBGL_INVALID_HANDLE;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_Buffer res = sbgl_gfx_CreateBuffer(inner->gfx, usage, size, data);
 
    ctx->result =
        (res != SBGL_INVALID_HANDLE) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return res;
}
 
void sbgl_DestroyBuffer(sbgl_Context* ctx, sbgl_Buffer buffer) {
    if (!ctx || !ctx->inner)
        return;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    if (!inner->state.isIdle) {
        sbgl_log_impl(
            SBGL_LOG_WARN,
            SBGL_LOG_CAT_GFX,
            "Buffer destroyed while GPU is busy! Missing sbgl_DeviceWaitIdle."
        );
 
        ctx->result = SBGL_ERROR_DEVICE_BUSY;
 
        // Force a wait to safely destroy it anyway and prevent driver crash
        sbgl_DeviceWaitIdle(ctx);
    }
 
    sbgl_gfx_DestroyBuffer(inner->gfx, buffer);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_FillBuffer(sbgl_Context* ctx, sbgl_Buffer buffer, size_t offset, size_t size, uint32_t value) {
    if (!ctx || !ctx->inner)
        return;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_FillBuffer(inner->gfx, buffer, offset, size, value);
    ctx->result = SBGL_SUCCESS;
}
 
uint32_t sbgl_GetFrameIndex(sbgl_Context* ctx) {
    if (!ctx || !ctx->inner)
        return 0;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    return sbgl_gfx_GetFrameIndex(inner->gfx);
}
 
void* sbgl_MapBuffer(sbgl_Context* ctx, sbgl_Buffer buffer) {
    /* The system maps the specified GPU buffer into the CPU's address space,
       allowing for direct memory access. This is essential for reading back
       results from compute shaders or updating dynamic vertex data. */
    if (!ctx || !ctx->inner)
        return NULL;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    void* ptr = sbgl_gfx_MapBuffer(inner->gfx, buffer);
 
    ctx->result = (ptr != NULL) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return ptr;
}
 
void sbgl_UnmapBuffer(sbgl_Context* ctx, sbgl_Buffer buffer) {
    /* The mapping between the CPU and GPU buffer is released, finalizing any
       pending memory writes and ensuring synchronization for subsequent GPU operations. */
    if (!ctx || !ctx->inner)
        return;
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_UnmapBuffer(inner->gfx, buffer);
    ctx->result = SBGL_SUCCESS;
}
 
sbgl_Shader
sbgl_LoadShader(sbgl_Context* ctx, sbgl_ShaderStage stage, const uint32_t* bytecode, size_t size) {
    if (!ctx || !ctx->inner)
        return SBGL_INVALID_HANDLE;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_Shader res = sbgl_gfx_LoadShader(inner->gfx, stage, bytecode, size);
    ctx->result =
        (res != SBGL_INVALID_HANDLE) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return res;
}
 
sbgl_Shader
sbgl_LoadShaderFromFile(sbgl_Context* ctx, sbgl_ShaderStage stage, const char* filename) {
    FILE* file = fopen(filename, "rb");
    if (!file) {
        sbgl_log_impl(SBGL_LOG_ERROR, SBGL_LOG_CAT_GFX, "Failed to open shader file.");
        return SBGL_INVALID_HANDLE;
    }
 
    fseek(file, 0, SEEK_END);
    size_t size = ftell(file);
    fseek(file, 0, SEEK_SET);
 
    uint32_t* buffer = malloc(size);
    if (!buffer) {
        fclose(file);
        return SBGL_INVALID_HANDLE;
    }
 
    size_t read = fread(buffer, 1, size, file);
    fclose(file);
 
    if (read != size) {
        free(buffer);
        return SBGL_INVALID_HANDLE;
    }
 
    sbgl_Shader shader = sbgl_LoadShader(ctx, stage, buffer, size);
    free(buffer);
 
    return shader;
}
 
void sbgl_DestroyShader(sbgl_Context* ctx, sbgl_Shader shader) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    if (!inner->state.isIdle) {
        sbgl_log_impl(
            SBGL_LOG_ERROR,
            SBGL_LOG_CAT_GFX,
            "Destroy Shader called while GPU is busy! Missing sbgl_DeviceWaitIdle."
        );
 
        ctx->result = SBGL_ERROR_DEVICE_BUSY;
 
        // Force a wait to safely destroy it anyway and prevent driver crash
        sbgl_DeviceWaitIdle(ctx);
    }
 
    sbgl_gfx_DestroyShader(inner->gfx, shader);
    ctx->result = SBGL_SUCCESS;
}
 
sbgl_Pipeline sbgl_CreatePipeline(sbgl_Context* ctx, const sbgl_PipelineConfig* config) {
    if (!ctx || !ctx->inner)
        return SBGL_INVALID_HANDLE;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_Pipeline res = sbgl_gfx_CreatePipeline(inner->gfx, config);
    ctx->result =
        (res != SBGL_INVALID_HANDLE) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return res;
}
 
void sbgl_DestroyPipeline(sbgl_Context* ctx, sbgl_Pipeline pipeline) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    if (!inner->state.isIdle) {
        sbgl_log_impl(
            SBGL_LOG_ERROR,
            SBGL_LOG_CAT_GFX,
            "Destroy Pipeline called while GPU is busy! Missing sbgl_DeviceWaitIdle."
        );
 
        ctx->result = SBGL_ERROR_DEVICE_BUSY;
 
        // Force a wait to safely destroy it anyway and prevent driver crash
        sbgl_DeviceWaitIdle(ctx);
    }
 
    sbgl_gfx_DestroyPipeline(inner->gfx, pipeline);
    ctx->result = SBGL_SUCCESS;
}
 
sbgl_ComputePipeline sbgl_CreateComputePipeline(sbgl_Context* ctx, sbgl_Shader shader) {
    if (!ctx || !ctx->inner)
        return SBGL_INVALID_HANDLE;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_ComputePipeline res = sbgl_gfx_CreateComputePipeline(inner->gfx, shader);
    ctx->result =
        (res != SBGL_INVALID_HANDLE) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return res;
}
 
void sbgl_DestroyComputePipeline(sbgl_Context* ctx, sbgl_ComputePipeline pipeline) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    if (!inner->state.isIdle) {
        sbgl_log_impl(
            SBGL_LOG_ERROR,
            SBGL_LOG_CAT_GFX,
            "Destroy Compute Pipeline called while GPU is busy! Missing sbgl_DeviceWaitIdle."
        );
 
        ctx->result = SBGL_ERROR_DEVICE_BUSY;
        sbgl_DeviceWaitIdle(ctx);
    }
 
    sbgl_gfx_DestroyComputePipeline(inner->gfx, pipeline);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_BindComputePipeline(sbgl_Context* ctx, sbgl_ComputePipeline pipeline) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_BindComputePipeline(inner->gfx, pipeline);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_DispatchCompute(sbgl_Context* ctx, uint32_t x, uint32_t y, uint32_t z) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_DispatchCompute(inner->gfx, x, y, z);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_MemoryBarrier(sbgl_Context* ctx, sbgl_BarrierType type) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_MemoryBarrier(inner->gfx, type);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_BindPipeline(sbgl_Context* ctx, sbgl_Pipeline pipeline) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_BindPipeline(inner->gfx, pipeline);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_BindBuffer(sbgl_Context* ctx, sbgl_Buffer buffer, sbgl_BufferUsage usage) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_BindBuffer(inner->gfx, buffer, usage);
    ctx->result = SBGL_SUCCESS;
}
 
uint64_t sbgl_GetBufferDeviceAddress(sbgl_Context* ctx, sbgl_Buffer buffer) {
    if (!ctx || !ctx->inner)
        return 0;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    uint64_t addr = sbgl_gfx_GetBufferDeviceAddress(inner->gfx, buffer);
    ctx->result = (addr != 0) ? SBGL_SUCCESS : SBGL_ERROR_GRAPHICS_FAILED;
    return addr;
}
 
void sbgl_Draw(sbgl_Context* ctx, uint32_t vertexCount, uint32_t firstVertex, uint32_t instanceCount) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_Draw(inner->gfx, vertexCount, firstVertex, instanceCount);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_DrawIndexed(
    sbgl_Context* ctx,
    uint32_t indexCount,
    uint32_t firstIndex,
    int32_t vertexOffset,
    uint32_t instanceCount
) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_DrawIndexed(inner->gfx, indexCount, firstIndex, vertexOffset, instanceCount);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_DrawIndirect(
    sbgl_Context* ctx,
    sbgl_Buffer buffer,
    size_t offset,
    uint32_t drawCount
) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_DrawIndirect(inner->gfx, buffer, offset, drawCount);
    ctx->result = SBGL_SUCCESS;
}
 
void sbgl_PushConstants(sbgl_Context* ctx, size_t size, const void* data) {
    if (!ctx || !ctx->inner)
        return;
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
    sbgl_gfx_PushConstants(inner->gfx, size, data);
    ctx->result = SBGL_SUCCESS;
}
 
// --- Automated Batching API ---
 
sbgl_RenderQueue* sbgl_CreateRenderQueue(sbgl_Context* ctx, SblArena* arena) {
    if (!ctx || !arena) {
        return NULL;
    }
 
    // Allocate the queue structure from the provided arena
    sbgl_RenderQueue* queue = SBL_ARENA_PUSH_STRUCT_ZERO(arena, sbgl_RenderQueue);
    if (!queue) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return NULL;
    }
 
    // Initialize the queue with a default capacity of 16,384 packets
    /* Initialize the queue with a high capacity to support massive batching (e.g., voxels). */
    queue->capacity = 131072;
    queue->count = 0;
    queue->arena = arena;
    queue->packets = SBL_ARENA_PUSH_ARRAY_ZERO(arena, sbgl_DrawPacket, queue->capacity);
    queue->instances = SBL_ARENA_PUSH_ARRAY_ZERO(arena, sbgl_InstanceData, queue->capacity);
 
    if (!queue->packets || !queue->instances) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return NULL;
    }
 
    ctx->result = SBGL_SUCCESS;
    return queue;
}
 
void sbgl_SubmitDraw(
    sbgl_RenderQueue* queue,
    uint32_t mesh,
    uint32_t material,
    uint32_t blendMode,
    uint32_t sidedness,
    uint32_t tags,
    sbgl_SortKey key,
    const sbgl_InstanceData* data
) {
    if (!queue) {
        return;
    }
 
    // Verify the queue has not reached maximum capacity
    if (queue->count >= queue->capacity) {
        return;
    }
 
    // The system appends the draw packet to the contiguous array
    uint32_t index = queue->count++;
    sbgl_DrawPacket* packet = &queue->packets[index];
    packet->key = key;
    packet->header = SBGL_PACK_HEADER(mesh, material, blendMode, sidedness, tags);
 
    // Per-instance data is copied into the parallel array
    if (data) {
        queue->instances[index] = *data;
    } else {
        // An identity transform and white color are used if no data is provided
        memset(&queue->instances[index], 0, sizeof(sbgl_InstanceData));
        queue->instances[index].transform = sbgl_Mat4Identity();
        queue->instances[index].color = sbgl_Vec4Set(1, 1, 1, 1);
    }
}
 
void sbgl_RenderQueues(
    sbgl_Context* ctx,
    sbgl_RenderQueue** queues,
    uint32_t queueCount,
    const sbgl_Mat4* viewProj
) {
    sbgl_RenderQueuesEx(ctx, queues, queueCount, viewProj, 0);
}
 
void sbgl_RenderQueuesEx(
    sbgl_Context* ctx,
    sbgl_RenderQueue** queues,
    uint32_t queueCount,
    const sbgl_Mat4* viewProj,
    uint64_t userAddress
) {
    if (!ctx || !ctx->inner || !queues || queueCount == 0) {
        return;
    }
 
    sbgl_InternalContext* inner = (sbgl_InternalContext*)ctx->inner;
 
    // Total packet count is calculated across all queues to determine buffer requirements
    uint32_t totalPackets = 0;
    for (uint32_t i = 0; i < queueCount; ++i) {
        if (queues[i]) {
            totalPackets += queues[i]->count;
        }
    }
 
    if (totalPackets == 0) {
        return;
    }
 
    // The transient arena is reset for this frame's batching work
    sbl_arena_reset(&inner->transientArena);
 
    inner->sortStartTicks = sbgl_os_GetPerfCount(inner->window);
 
    // Temporary host memory is allocated for merging and sorting from the transient arena
    sbgl_DrawPacket* mergedPackets =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_DrawPacket, totalPackets);
    sbgl_InstanceData* mergedInstances =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_InstanceData, totalPackets);
    sbgl_SortKey* keys = SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_SortKey, totalPackets);
    uint32_t* indices = SBL_ARENA_PUSH_ARRAY(&inner->transientArena, uint32_t, totalPackets);
 
    if (!mergedPackets || !mergedInstances || !keys || !indices) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return;
    }
 
    // Packets and instance data are merged from all queues
    uint32_t current = 0;
    for (uint32_t i = 0; i < queueCount; ++i) {
        if (!queues[i])
            continue;
        for (uint32_t j = 0; j < queues[i]->count; ++j) {
            mergedPackets[current] = queues[i]->packets[j];
            mergedInstances[current] = queues[i]->instances[j];
            keys[current] = mergedPackets[current].key;
            indices[current] = current;
            current++;
        }
        // The queue is cleared for the next frame
        queues[i]->count = 0;
    }
 
    // A stable radix sort is performed on the packets based on sort keys
    sbgl_SortKey* temp_keys =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_SortKey, totalPackets);
    uint32_t* temp_indices = SBL_ARENA_PUSH_ARRAY(&inner->transientArena, uint32_t, totalPackets);
    if (!temp_keys || !temp_indices) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return;
    }
 
    sbgl_radix_sort(keys, indices, totalPackets, temp_keys, temp_indices);
 
    // Packets and instances are reordered according to the sorted indices
    sbgl_DrawPacket* sortedPackets =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_DrawPacket, totalPackets);
    sbgl_InstanceData* sortedInstances =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_InstanceData, totalPackets);
    if (!sortedPackets || !sortedInstances) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return;
    }
 
    for (uint32_t i = 0; i < totalPackets; ++i) {
        sortedPackets[i] = mergedPackets[indices[i]];
        sortedInstances[i] = mergedInstances[indices[i]];
    }
 
    // Sorted packets are baked into optimized indirect draw commands
    sbgl_IndirectCommand* commands =
        SBL_ARENA_PUSH_ARRAY(&inner->transientArena, sbgl_IndirectCommand, totalPackets);
    if (!commands) {
        ctx->result = SBGL_ERROR_OUT_OF_MEMORY;
        return;
    }
 
    uint32_t commandCount = sbgl_bake_commands(sortedPackets, totalPackets, commands, totalPackets);
 
    uint64_t sortEndTicks = sbgl_os_GetPerfCount(inner->window);
    inner->currentFrame.cpu_sort_time +=
        (float)((double)(sortEndTicks - inner->sortStartTicks) * 1000.0 / (double)sbgl_os_GetPerfFreq(inner->window));
 
    inner->currentFrame.draw_calls += commandCount;
    inner->currentFrame.instance_count += totalPackets;
 
    if (commandCount > 0) {
        // Allocate transient GPU space for packed instance data
        sbgl_GfxTransientAllocation instanceAlloc = sbgl_gfx_AllocateTransient(
            inner->gfx,
            sizeof(sbgl_InstanceData) * totalPackets,
            256 // Storage buffer alignment
        );
 
        if (instanceAlloc.buffer != SBGL_INVALID_HANDLE) {
            memcpy(instanceAlloc.mapped, sortedInstances, sizeof(sbgl_InstanceData) * totalPackets);
 
            // Retrieve BDA address and update push constants
            uint64_t bdaAddress = instanceAlloc.deviceAddress;
 
            struct {
                sbgl_Mat4 viewProj;
                uint64_t instanceAddress;
                uint64_t userAddress;
            } pc;
            pc.viewProj = viewProj ? *viewProj : sbgl_Mat4Identity();
            pc.instanceAddress = bdaAddress;
            pc.userAddress = userAddress;
 
            sbgl_gfx_PushConstants(inner->gfx, sizeof(pc), &pc);
 
            // Allocate transient GPU space for baked commands and dispatch MDI
            sbgl_GfxTransientAllocation indirectAlloc = sbgl_gfx_AllocateTransient(
                inner->gfx,
                sizeof(sbgl_IndirectCommand) * commandCount,
                16 // Indirect buffer alignment
            );
 
            if (indirectAlloc.buffer != SBGL_INVALID_HANDLE) {
                memcpy(indirectAlloc.mapped, commands, sizeof(sbgl_IndirectCommand) * commandCount);
                sbgl_gfx_DrawIndirect(
                    inner->gfx,
                    indirectAlloc.buffer,
                    indirectAlloc.offset,
                    commandCount
                );
            }
        }
    }
 
    ctx->result = SBGL_SUCCESS;
}