batch_main.c File Reference

#include "core/sbl_arena.h"
#include <math.h>
#include <sbgl.h>
#include <sbgl_camera.h>
#include <sbgl_math.h>
#include <stdio.h>
#include <time.h>
#include "batching_vert.h"
#include "batching_frag.h"

Include dependency graph for batch_main.c:

Go to the source code of this file.

Macros
#define	PACK_POS(x, y, z)
#define	PACK_COL(r, g, b, a)

Functions
int	main (void)

Macro Definition Documentation

PACK_COL

#define PACK_COL	(		r,
			g,
			b,
			a )

Value:

(uint32_t)(((uint32_t)((r)*255.0f) << 0) | ((uint32_t)((g)*255.0f) << 8) | ((uint32_t)((b)*255.0f) << 16) | ((uint32_t)((a)*255.0f) << 24))

Definition at line 12 of file batch_main.c.

PACK_POS

#define PACK_POS	(		x,
			y,
			z )

Value:

{ (int16_t)((x) * 32767.0f), (int16_t)((y) * 32767.0f), (int16_t)((z) * 32767.0f), 32767 }

Definition at line 11 of file batch_main.c.

Function Documentation

main()

int main

(

void

)

Definition at line 14 of file batch_main.c.

               {
    sbgl_InitResult res = sbgl_Init(800, 600, "SBgl Advanced 3D Batching");
    if (res.error != SBGL_SUCCESS)
        return 1;
    sbgl_Context* ctx = res.ctx;
 
    SblArena arena;
    sbl_arena_init(&arena, 10 * 1024 * 1024); // 10MB for render queues
 
    sbgl_Shader vert =
        sbgl_LoadShader(ctx, SBGL_SHADER_STAGE_VERTEX, (const uint32_t*)batching_vert_spv, batching_vert_spv_len);
    sbgl_Shader frag =
        sbgl_LoadShader(ctx, SBGL_SHADER_STAGE_FRAGMENT, (const uint32_t*)batching_frag_spv, batching_frag_spv_len);
 
    sbgl_Vertex vertices[] = { // Triangle (Mesh 0)
                               { PACK_POS(0.0f, 0.5f, 0.0f), PACK_COL(1, 0, 0, 1), 0 },
                               { PACK_POS(0.5f, -0.5f, 0.0f), PACK_COL(0, 1, 0, 1), 0 },
                               { PACK_POS(-0.5f, -0.5f, 0.0f), PACK_COL(0, 0, 1, 1), 0 },
 
                               // Cube (Mesh 1)
                               { PACK_POS(-0.5f, -0.5f, -0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(0.5f, -0.5f, -0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(0.5f, 0.5f, -0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(-0.5f, 0.5f, -0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(-0.5f, -0.5f, 0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(0.5f, -0.5f, 0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(0.5f, 0.5f, 0.5f), PACK_COL(1, 1, 1, 1), 0 },
                               { PACK_POS(-0.5f, 0.5f, 0.5f), PACK_COL(1, 1, 1, 1), 0 },
 
                               // Pyramid (Mesh 2)
                               { PACK_POS(0.0f, 0.5f, 0.0f), PACK_COL(1, 1, 0, 1), 0 },  // Top
                               { PACK_POS(-0.5f, -0.5f, -0.5f), PACK_COL(1, 0, 1, 1), 0 }, // base
                               { PACK_POS(0.5f, -0.5f, -0.5f), PACK_COL(1, 0, 1, 1), 0 },
                               { PACK_POS(0.5f, -0.5f, 0.5f), PACK_COL(1, 0, 1, 1), 0 },
                               { PACK_POS(-0.5f, -0.5f, 0.5f), PACK_COL(1, 0, 1, 1), 0 }
    };
 
    uint32_t indices[] = { // Triangle
                           0,
                           2,
                           1,
 
                           // Cube
                           0,
                           3,
                           2,
                           2,
                           1,
                           0,
                           4,
                           5,
                           6,
                           6,
                           7,
                           4,
                           0,
                           4,
                           7,
                           7,
                           3,
                           0,
                           1,
                           2,
                           6,
                           6,
                           5,
                           1,
                           2,
                           3,
                           7,
                           7,
                           6,
                           2,
                           0,
                           1,
                           5,
                           5,
                           4,
                           0,
 
                           // Pyramid
                           0,
                           2,
                           1,
                           0,
                           3,
                           2,
                           0,
                           4,
                           3,
                           0,
                           1,
                           4,
                           1,
                           2,
                           3,
                           3,
                           4,
                           1
    };
 
    sbgl_Buffer vbo = sbgl_CreateBuffer(ctx, SBGL_BUFFER_USAGE_VERTEX, sizeof(vertices), vertices);
    sbgl_Buffer ibo = sbgl_CreateBuffer(ctx, SBGL_BUFFER_USAGE_INDEX, sizeof(indices), indices);
 
    sbgl_VertexAttribute attributes[] = {
        { 0, offsetof(sbgl_Vertex, position), SBGL_FORMAT_R16G16B16A16_SNORM },
        { 1, offsetof(sbgl_Vertex, color), SBGL_FORMAT_R8G8B8A8_UNORM }
    };
 
    sbgl_PipelineConfig config = { .vertexShader = vert,
                                   .fragmentShader = frag,
                                   .vertexLayout = { sizeof(sbgl_Vertex), 2, attributes } };
 
    sbgl_Pipeline pipeline = sbgl_CreatePipeline(ctx, &config);
    sbgl_RenderQueue* queue = sbgl_CreateRenderQueue(ctx, &arena);
 
    int width, height;
    sbgl_GetWindowSize(ctx, &width, &height);
    sbgl_Camera camera =
        sbgl_CameraPerspective(SBGL_PI / 4.0f, (float)width / (float)height, 0.1f, 1000.0f);
    camera.position = sbgl_Vec3Set(0.0f, 50.0f, 200.0f);
    camera.target = sbgl_Vec3Set(0.0f, 0.0f, 0.0f);
    camera.up = sbgl_Vec3Set(0.0f, 1.0f, 0.0f);
 
    float pitch = -0.2f;
    float yaw = -SBGL_PI / 2.0f;
    bool mouse_locked = false;
    float move_speed = 100.0f;
    float mouse_sensitivity = 0.005f;
 
    double start_time = sbgl_GetTime(ctx);
    double last_time = start_time;
    float fps_timer = 0.0f;
    int frame_count = 0;
 
    printf("--- Batching Controls ---\n");
    printf("W/A/S/D: Move\n");
    printf("Q/E: Vertical Move\n");
    printf("TAB: Lock/Unlock Mouse\n");
    printf("ESC: Exit\n");
    printf("-------------------------\n");
 
    while (!sbgl_WindowShouldClose(ctx)) {
        sbgl_Clear(ctx, 0.02f, 0.02f, 0.02f, 1.0f);
        sbgl_BeginDrawing(ctx);
 
        const sbgl_InputState* input = sbgl_GetInputState(ctx);
        if (input->keysDown[SBGL_KEY_ESCAPE]) {
            sbgl_EndDrawing(ctx);
            break;
        }
 
        double current_time = sbgl_GetTime(ctx);
        float dt = (float)(current_time - last_time);
        last_time = current_time;
        float time = (float)(current_time - start_time);
 
        // Calculate and display FPS
        frame_count++;
        fps_timer += dt;
        if (fps_timer >= 1.0f) {
            printf(
                "FPS: %d | Frame Time: %.2f ms\n",
                frame_count,
                (fps_timer / (float)frame_count) * 1000.0f
            );
            fps_timer = 0.0f;
            frame_count = 0;
        }
 
        if (input->keysPressed[SBGL_KEY_TAB]) {
            mouse_locked = !mouse_locked;
            sbgl_SetMouseMode(
                ctx,
                mouse_locked ? SBGL_MOUSE_MODE_CAPTURED : SBGL_MOUSE_MODE_NORMAL
            );
        }
 
        if (mouse_locked) {
            yaw += (float)input->mouseDeltaX * mouse_sensitivity;
            pitch -= (float)input->mouseDeltaY * mouse_sensitivity;
 
            if (pitch > 1.5f)
                pitch = 1.5f;
            if (pitch < -1.5f)
                pitch = -1.5f;
        }
 
        sbgl_Vec3 front;
        front.x = cosf(yaw) * cosf(pitch);
        front.y = sinf(pitch);
        front.z = sinf(yaw) * cosf(pitch);
        front = sbgl_Vec3Normalize(front);
 
        sbgl_Vec3 right = sbgl_Vec3Normalize(sbgl_Vec3Cross(front, sbgl_Vec3Set(0.0f, 1.0f, 0.0f)));
        sbgl_Vec3 up = sbgl_Vec3Normalize(sbgl_Vec3Cross(right, front));
 
        float velocity = move_speed * dt;
 
        if (input->keysDown[SBGL_KEY_W])
            camera.position = sbgl_Vec3Add(camera.position, sbgl_Vec3Mul(front, velocity));
        if (input->keysDown[SBGL_KEY_S])
            camera.position = sbgl_Vec3Sub(camera.position, sbgl_Vec3Mul(front, velocity));
        if (input->keysDown[SBGL_KEY_A])
            camera.position = sbgl_Vec3Sub(camera.position, sbgl_Vec3Mul(right, velocity));
        if (input->keysDown[SBGL_KEY_D])
            camera.position = sbgl_Vec3Add(camera.position, sbgl_Vec3Mul(right, velocity));
        if (input->keysDown[SBGL_KEY_E])
            camera.position = sbgl_Vec3Add(
                camera.position,
                sbgl_Vec3Mul(sbgl_Vec3Set(0.0f, 1.0f, 0.0f), velocity)
            );
        if (input->keysDown[SBGL_KEY_Q])
            camera.position = sbgl_Vec3Sub(
                camera.position,
                sbgl_Vec3Mul(sbgl_Vec3Set(0.0f, 1.0f, 0.0f), velocity)
            );
 
        camera.target = sbgl_Vec3Add(camera.position, front);
        camera.up = up;
 
        sbgl_Mat4 vp = sbgl_Mat4Mul(sbgl_CameraGetProjection(&camera), sbgl_CameraGetView(&camera));
 
        // Submit 10,000 instances
        for (int i = 0; i < 10000; i++) {
            uint32_t meshId = i % 3;
 
            float angle = time + (float)i;
            sbgl_Vec3 pos = sbgl_Vec3Set(
                ((float)(i % 100) - 50.0f) * 10.0f,
                ((float)(i / 100 % 100) - 50.0f) * 10.0f,
                ((float)(i / 10000) - 0.5f) * 10.0f
            );
 
            sbgl_InstanceData data;
            data.transform = sbgl_Mat4Mul(
                sbgl_Mat4Translate(pos),
                sbgl_Mat4Rotate(angle, sbgl_Vec3Set(0.4f, 1.0f, 0.2f))
            );
 
            float r = (float)(i % 255) / 255.0f;
            float g = (float)((i * 7) % 255) / 255.0f;
            float b = (float)((i * 13) % 255) / 255.0f;
            data.color = sbgl_Vec4Set(r, g, b, 1.0f);
 
            // Use meshId as the sort key for maximum batching
            sbgl_SubmitDraw(queue, meshId, 0, 0, 0, 0, (sbgl_SortKey)meshId, &data);
        }
 
        sbgl_BindPipeline(ctx, pipeline);
        sbgl_BindBuffer(ctx, vbo, SBGL_BUFFER_USAGE_VERTEX);
        sbgl_BindBuffer(ctx, ibo, SBGL_BUFFER_USAGE_INDEX);
 
        sbgl_RenderQueues(ctx, &queue, 1, &vp);
 
        sbgl_EndDrawing(ctx);
    }
 
    sbgl_DeviceWaitIdle(ctx);
 
    sbgl_DestroyPipeline(ctx, pipeline);
    sbgl_DestroyShader(ctx, vert);
    sbgl_DestroyShader(ctx, frag);
    sbgl_DestroyBuffer(ctx, vbo);
    sbgl_DestroyBuffer(ctx, ibo);
 
    sbl_arena_free(&arena);
    sbgl_Shutdown(ctx);
 
    return 0;
}