pub const Impl = struct {
    allocator: std.mem.Allocator,
    device: *gpu.GPUDevice = undefined,

    drawData: [*c]ig.DrawData = undefined,
    rendererDebug: bool = true,

    dtAverage: f64 = 0.0,

    pub var NeonObjectTable: core.EngineObjectVTable = core.EngineObjectVTable.from(@This());

    pub const Settings = struct {
        x: u32 = 0,
    };

    // renderer plugin
    pub fn create(allocator: std.mem.Allocator) !*@This() {
        const self = try allocator.create(@This());

        self.* = .{
            .allocator = allocator,
        };

        return self;
    }

    pub fn setup(self: *@This()) !void {
        core.graphics_log("imgui startup", .{});
        self.device = rend.context().device;
        try rend.registerRendererObject(@This(), self);

        c.Imgui_SDL3_Init(@ptrCast(platform.getInstance().window), @ptrCast(self.device));
        try platform.getInstance().addSDLProcessFunction(processSDLEvents);
    }

    pub fn processSDLEvents(event: *sdl3.Event) void {
        if (platform.getInstance().enableImguiEvents) {
            c.Imgui_SDL3_ProcessEvent(@ptrCast(event));
        }
    }

    pub fn onPreDraw(p: *anyopaque, cmd: *gpu.GPUCommandBuffer) void {
        const self: *@This() = @ptrCast(@alignCast(p));
        ig.render();

        if (platform.getInstance().imguiVisible) {
            self.drawData = ig.getDrawData();

            c.Imgui_SDL3_PrepareRender(@ptrCast(self.drawData), @ptrCast(cmd));
        }
    }

    pub fn postRender(p: *anyopaque, cmd: *gpu.GPUCommandBuffer) void {
        const self: *@This() = @ptrCast(@alignCast(p));
        if (platform.getInstance().imguiVisible) {

            //const renderpass = cmd.beginGPURenderPass(color_target_infos: [*c]const GPUColorTargetInfo, num_color_targets: u32, depth_stencil_target_info: [*c]const GPUDepthStencilTargetInfo);

            var targetInfo: gpu.GPUColorTargetInfo = std.mem.zeroes(gpu.GPUColorTargetInfo);
            targetInfo.texture = rend.context().state.swapchainTexture.?;
            targetInfo.clear_color = .{ .r = 0.0, .g = 0.0, .b = 0.0, .a = 0.0 };
            targetInfo.load_op = .loadopLoad;
            targetInfo.store_op = .storeopStore;
            const renderpass = cmd.beginGPURenderPass(&targetInfo, 1, null);

            c.ImGui_SDLGPU3_RenderDrawData(
                @ptrCast(self.drawData),
                @ptrCast(cmd),
                @ptrCast(renderpass),
            );

            renderpass.endGPURenderPass();
        }
    }

    pub fn preTick(self: *@This(), dt: f64) core.EngineDataEventError!void {
        c.Imgui_SDL3_NewFrame();
        c.igNewFrame();

        core.rollingAverage(&self.dtAverage, dt, 50);

        if (ig.begin("renderer debug", &self.rendererDebug, .{})) {
            _ = ig.sliderFloat("directional light yaw", &rend.context().directionalLightYaw, 0, 360, null, .{});
            _ = ig.sliderFloat("ortho near", &rend.context().shadowOrthoNear, 0, 200, null, .{});
            _ = ig.sliderFloat("ortho far", &rend.context().shadowOrthoFar, 0, 6000, null, .{});
            if (self.dtAverage > 0.000001) {
                ig.textFmt("frameTime: {d:.2}ms ({d:.2}fps)", .{ self.dtAverage * 1000, @as(u32, @intFromFloat(1 / self.dtAverage)) }) catch return error.UnknownStatePanic;
            }
            ig.end();
        }
    }

    // renderer plugin
    pub fn destroy(self: *@This()) void {
        self.allocator.destroy(self);
    }
};
const c = @import("cimgui").c;
const ig = @import("cimgui");
const sdl3 = @import("sdl3");
const gpu = sdl3.gpu;
const rend = @import("rend");
const platform = @import("platform");
const std = @import("std");
const core = @import("core");