const std = @import("std");
const builtin = @import("builtin");
const vk = @import("vulkan");
const sysgpu = @import("sysgpu/main.zig");
const limits = @import("limits.zig");
const shader = @import("shader.zig");
const utils = @import("utils.zig");
const conv = @import("vulkan/conv.zig");
const proc = @import("vulkan/proc.zig");

const log = std.log.scoped(.vulkan);
const api_version = vk.makeApiVersion(0, 1, 1, 0);
const upload_page_size = 64 * 1024 * 1024; // TODO - split writes and/or support large uploads
const use_semaphore_wait = false;

var allocator: std.mem.Allocator = undefined;
var libvulkan: ?std.DynLib = null;
var vkb: proc.BaseFunctions = undefined;
var vki: proc.InstanceFunctions = undefined;
var vkd: proc.DeviceFunctions = undefined;

pub const InitOptions = struct {
    baseLoader: ?proc.BaseLoader = null,
};

pub fn init(alloc: std.mem.Allocator, options: InitOptions) !void {
    allocator = alloc;
    if (options.baseLoader) |baseLoader| {
        vkb = try proc.loadBase(baseLoader);
    } else {
        libvulkan = try std.DynLib.openZ(switch (builtin.target.os.tag) {
            .windows => "vulkan-1.dll",
            .linux => "libvulkan.so.1",
            .macos => "libvulkan.1.dylib",
            else => @compileError("Unknown OS!"),
        });
        vkb = try proc.loadBase(libVulkanBaseLoader);
    }
}

pub fn libVulkanBaseLoader(_: vk.Instance, name_ptr: [*:0]const u8) vk.PfnVoidFunction {
    const name = std.mem.span(name_ptr);
    return libvulkan.?.lookup(vk.PfnVoidFunction, name) orelse null;
}

const MapCallback = struct {
    buffer: *Buffer,
    callback: sysgpu.Buffer.MapCallback,
    userdata: ?*anyopaque,
};

pub const Instance = struct {
    manager: utils.Manager(Instance) = .{},
    vk_instance: vk.Instance,

    pub fn init(desc: *const sysgpu.Instance.Descriptor) !*Instance {
        _ = desc;

        // Query layers
        var count: u32 = 0;
        _ = try vkb.enumerateInstanceLayerProperties(&count, null);

        const available_layers = try allocator.alloc(vk.LayerProperties, count);
        defer allocator.free(available_layers);
        _ = try vkb.enumerateInstanceLayerProperties(&count, available_layers.ptr);

        var layers = std.BoundedArray([*:0]const u8, instance_layers.len){};
        for (instance_layers) |optional| {
            for (available_layers) |available| {
                if (std.mem.eql(
                    u8,
                    std.mem.sliceTo(optional, 0),
                    std.mem.sliceTo(&available.layer_name, 0),
                )) {
                    layers.appendAssumeCapacity(optional);
                    break;
                }
            }
        }

        // Query extensions
        _ = try vkb.enumerateInstanceExtensionProperties(null, &count, null);

        const available_extensions = try allocator.alloc(vk.ExtensionProperties, count);
        defer allocator.free(available_extensions);
        _ = try vkb.enumerateInstanceExtensionProperties(null, &count, available_extensions.ptr);

        var extensions = std.BoundedArray([*:0]const u8, instance_extensions.len){};

        for (instance_extensions) |required| {
            for (available_extensions) |available| {
                if (std.mem.eql(
                    u8,
                    std.mem.sliceTo(required, 0),
                    std.mem.sliceTo(&available.extension_name, 0),
                )) {
                    extensions.appendAssumeCapacity(required);
                    break;
                }
            } else {
                log.warn("unable to find required instance extension: {s}", .{required});
            }
        }

        // Create instace
        const application_info = vk.ApplicationInfo{
            .p_engine_name = "Banana",
            .application_version = 0,
            .engine_version = vk.makeApiVersion(0, 0, 1, 0), // TODO: get this from build.zig.zon
            .api_version = api_version,
        };
        const instance_info = vk.InstanceCreateInfo{
            .p_application_info = &application_info,
            .enabled_layer_count = layers.len,
            .pp_enabled_layer_names = layers.slice().ptr,
            .enabled_extension_count = extensions.len,
            .pp_enabled_extension_names = extensions.slice().ptr,
        };
        const vk_instance = try vkb.createInstance(&instance_info, null);

        // Load instance functions
        vki = try proc.loadInstance(vk_instance, vkb.dispatch.vkGetInstanceProcAddr);

        const instance = try allocator.create(Instance);
        instance.* = .{ .vk_instance = vk_instance };
        return instance;
    }

    const instance_layers = if (builtin.mode == .Debug)
        &[_][*:0]const u8{"VK_LAYER_KHRONOS_validation"}
    else
        &.{};
    const instance_extensions: []const [*:0]const u8 = switch (builtin.target.os.tag) {
        .linux => &.{
            vk.extension_info.khr_surface.name,
            vk.extension_info.khr_xlib_surface.name,
            vk.extension_info.khr_xcb_surface.name,
            // TODO: renderdoc will not work with this extension
            // vk.extension_info.khr_wayland_surface.name,
        },
        .windows => &.{
            vk.extension_info.khr_surface.name,
            vk.extension_info.khr_win_32_surface.name,
        },
        .macos, .ios => &.{
            vk.extension_info.khr_surface.name,
            vk.extension_info.ext_metal_surface.name,
        },
        else => |tag| if (builtin.target.abi == .android)
            &.{
                vk.extension_info.khr_surface.name,
                vk.extension_info.khr_android_surface.name,
            }
        else
            @compileError(std.fmt.comptimePrint("unsupported platform ({s})", .{@tagName(tag)})),
    };

    pub fn deinit(instance: *Instance) void {
        const vk_instance = instance.vk_instance;

        vki.destroyInstance(vk_instance, null);
        allocator.destroy(instance);
        if (libvulkan) |*lib| lib.close();
    }

    pub fn requestAdapter(
        instance: *Instance,
        options: ?*const sysgpu.RequestAdapterOptions,
        callback: sysgpu.RequestAdapterCallback,
        userdata: ?*anyopaque,
    ) !*Adapter {
        return Adapter.init(instance, options orelse &sysgpu.RequestAdapterOptions{}) catch |err| {
            callback(.err, undefined, @errorName(err), userdata);
            @panic("unimplemented"); // TODO - return dummy adapter
        };
    }

    pub fn createSurface(instance: *Instance, desc: *const sysgpu.Surface.Descriptor) !*Surface {
        return Surface.init(instance, desc);
    }
};

pub const Adapter = struct {
    manager: utils.Manager(Adapter) = .{},
    instance: *Instance,
    physical_device: vk.PhysicalDevice,
    props: vk.PhysicalDeviceProperties,
    queue_family: u32,
    extensions: []const vk.ExtensionProperties,
    driver_desc: [:0]const u8,
    vendor_id: VendorID,

    pub fn init(instance: *Instance, options: *const sysgpu.RequestAdapterOptions) !*Adapter {
        const vk_instance = instance.vk_instance;

        var count: u32 = 0;
        _ = try vki.enumeratePhysicalDevices(vk_instance, &count, null);

        var physical_devices = try allocator.alloc(vk.PhysicalDevice, count);
        defer allocator.free(physical_devices);
        _ = try vki.enumeratePhysicalDevices(vk_instance, &count, physical_devices.ptr);

        // Find best device based on power preference
        var physical_device_info: ?struct {
            physical_device: vk.PhysicalDevice,
            props: vk.PhysicalDeviceProperties,
            queue_family: u32,
            score: u32,
        } = null;
        for (physical_devices[0..count]) |physical_device| {
            const props = vki.getPhysicalDeviceProperties(physical_device);
            const features = vki.getPhysicalDeviceFeatures(physical_device);
            const queue_family = try findQueueFamily(physical_device) orelse continue;

            if (isDeviceSuitable(props, features)) {
                const score = rateDevice(props, features, options.power_preference);
                if (score == 0) continue;

                if (physical_device_info == null or score > physical_device_info.?.score) {
                    physical_device_info = .{
                        .physical_device = physical_device,
                        .props = props,
                        .queue_family = queue_family,
                        .score = score,
                    };
                }
            }
        }

        if (physical_device_info) |info| {
            _ = try vki.enumerateDeviceExtensionProperties(info.physical_device, null, &count, null);
            const extensions = try allocator.alloc(vk.ExtensionProperties, count);
            errdefer allocator.free(extensions);
            _ = try vki.enumerateDeviceExtensionProperties(info.physical_device, null, &count, extensions.ptr);

            const driver_desc = try std.fmt.allocPrintZ(
                allocator,
                "Vulkan driver version {}.{}.{}",
                .{
                    vk.apiVersionMajor(info.props.driver_version),
                    vk.apiVersionMinor(info.props.driver_version),
                    vk.apiVersionPatch(info.props.driver_version),
                },
            );

            const adapter = try allocator.create(Adapter);
            adapter.* = .{
                .instance = instance,
                .physical_device = info.physical_device,
                .props = info.props,
                .queue_family = info.queue_family,
                .extensions = extensions,
                .driver_desc = driver_desc,
                .vendor_id = @enumFromInt(info.props.vendor_id),
            };
            return adapter;
        }

        return error.NoAdapterFound;
    }

    pub fn deinit(adapter: *Adapter) void {
        allocator.free(adapter.extensions);
        allocator.free(adapter.driver_desc);
        allocator.destroy(adapter);
    }

    pub fn createDevice(adapter: *Adapter, desc: ?*const sysgpu.Device.Descriptor) !*Device {
        return Device.init(adapter, desc);
    }

    pub fn getProperties(adapter: *Adapter) sysgpu.Adapter.Properties {
        return .{
            .vendor_id = @intFromEnum(adapter.vendor_id),
            .vendor_name = adapter.vendor_id.name(),
            .architecture = "", // TODO
            .device_id = adapter.props.device_id,
            .name = @ptrCast(&adapter.props.device_name),
            .driver_description = adapter.driver_desc,
            .adapter_type = conv.sysgpuAdapterType(adapter.props.device_type),
            .backend_type = .vulkan,
            .compatibility_mode = .false, // TODO
        };
    }

    pub fn hasExtension(adapter: *Adapter, name: []const u8) bool {
        for (adapter.extensions) |ext| {
            if (std.mem.eql(u8, name, std.mem.sliceTo(&ext.extension_name, 0))) {
                return true;
            }
        }
        return false;
    }

    fn isDeviceSuitable(props: vk.PhysicalDeviceProperties, features: vk.PhysicalDeviceFeatures) bool {
        return props.api_version >= api_version and
            // WebGPU features
            features.depth_bias_clamp == vk.TRUE and
            features.fragment_stores_and_atomics == vk.TRUE and
            features.full_draw_index_uint_32 == vk.TRUE and
            features.image_cube_array == vk.TRUE and
            features.independent_blend == vk.TRUE and
            features.sample_rate_shading == vk.TRUE and
            // At least one of the following texture compression forms
            (features.texture_compression_bc == vk.TRUE or
            features.texture_compression_etc2 == vk.TRUE or
            features.texture_compression_astc_ldr == vk.TRUE);
    }

    fn rateDevice(
        props: vk.PhysicalDeviceProperties,
        features: vk.PhysicalDeviceFeatures,
        power_preference: sysgpu.PowerPreference,
    ) u32 {
        _ = features;

        var score: u32 = 0;
        switch (props.device_type) {
            .integrated_gpu => if (power_preference == .low_power) {
                score += 1000;
            },
            .discrete_gpu => if (power_preference == .high_performance) {
                score += 1000;
            },
            else => {},
        }

        score += props.limits.max_image_dimension_2d;

        return score;
    }

    fn findQueueFamily(device: vk.PhysicalDevice) !?u32 {
        var count: u32 = 0;
        _ = vki.getPhysicalDeviceQueueFamilyProperties(device, &count, null);

        const queue_families = try allocator.alloc(vk.QueueFamilyProperties, count);
        defer allocator.free(queue_families);
        _ = vki.getPhysicalDeviceQueueFamilyProperties(device, &count, queue_families.ptr);

        for (queue_families, 0..) |family, i| {
            if (family.queue_flags.graphics_bit and family.queue_flags.compute_bit) {
                return @intCast(i);
            }
        }

        return null;
    }

    const VendorID = enum(u32) {
        amd = 0x1002,
        apple = 0x106b,
        arm = 0x13B5,
        google = 0x1AE0,
        img_tec = 0x1010,
        intel = 0x8086,
        mesa = 0x10005,
        microsoft = 0x1414,
        nvidia = 0x10DE,
        qualcomm = 0x5143,
        samsung = 0x144d,
        _,

        pub fn name(vendor_id: VendorID) [:0]const u8 {
            return switch (vendor_id) {
                .amd => "AMD",
                .apple => "Apple",
                .arm => "ARM",
                .google => "Google",
                .img_tec => "Img Tec",
                .intel => "Intel",
                .mesa => "Mesa",
                .microsoft => "Microsoft",
                .nvidia => "Nvidia",
                .qualcomm => "Qualcomm",
                .samsung => "Samsung",
                _ => "Unknown",
            };
        }
    };
};

pub const Surface = struct {
    manager: utils.Manager(Surface) = .{},
    instance: *Instance,
    vk_surface: vk.SurfaceKHR,

    pub fn init(instance: *Instance, desc: *const sysgpu.Surface.Descriptor) !*Surface {
        const vk_instance = instance.vk_instance;

        const vk_surface = switch (builtin.target.os.tag) {
            .linux => blk: {
                if (utils.findChained(sysgpu.Surface.DescriptorFromXlibWindow, desc.next_in_chain.generic)) |x_desc| {
                    break :blk try vki.createXlibSurfaceKHR(
                        vk_instance,
                        &vk.XlibSurfaceCreateInfoKHR{
                            .dpy = @ptrCast(x_desc.display),
                            .window = x_desc.window,
                        },
                        null,
                    );
                } else if (utils.findChained(sysgpu.Surface.DescriptorFromWaylandSurface, desc.next_in_chain.generic)) |wayland_desc| {
                    _ = wayland_desc;
                    @panic("unimplemented");
                    // TODO: renderdoc will not work with wayland
                    // break :blk try vki.createWaylandSurfaceKHR(
                    //     vk_instance,
                    //     &vk.WaylandSurfaceCreateInfoKHR{
                    //         .display = @ptrCast(wayland_desc.display),
                    //         .surface = @ptrCast(wayland_desc.surface),
                    //     },
                    //     null,
                    // );
                }

                return error.InvalidDescriptor;
            },
            .windows => blk: {
                if (utils.findChained(sysgpu.Surface.DescriptorFromWindowsHWND, desc.next_in_chain.generic)) |win_desc| {
                    break :blk try vki.createWin32SurfaceKHR(
                        vk_instance,
                        &vk.Win32SurfaceCreateInfoKHR{
                            .hinstance = @ptrCast(win_desc.hinstance),
                            .hwnd = @ptrCast(win_desc.hwnd),
                        },
                        null,
                    );
                }

                return error.InvalidDescriptor;
            },
            else => @compileError("unsupported platform"),
        };

        const surface = try allocator.create(Surface);
        surface.* = .{
            .instance = instance,
            .vk_surface = vk_surface,
        };
        return surface;
    }

    pub fn deinit(surface: *Surface) void {
        const vk_instance = surface.instance.vk_instance;

        vki.destroySurfaceKHR(vk_instance, surface.vk_surface, null);
        allocator.destroy(surface);
    }
};

pub const Device = struct {
    manager: utils.Manager(Device) = .{},
    adapter: *Adapter,
    vk_device: vk.Device,
    render_passes: std.AutoHashMapUnmanaged(RenderPassKey, vk.RenderPass) = .{},
    cmd_pool: vk.CommandPool,
    memory_allocator: MemoryAllocator,
    queue: ?Queue = null,
    streaming_manager: StreamingManager = undefined,
    submit_objects: std.ArrayListUnmanaged(SubmitObject) = .{},
    map_callbacks: std.ArrayListUnmanaged(MapCallback) = .{},
    /// Supported Depth-Stencil formats
    supported_ds_formats: std.AutoHashMapUnmanaged(vk.Format, void),

    lost_cb: ?sysgpu.Device.LostCallback = null,
    lost_cb_userdata: ?*anyopaque = null,
    log_cb: ?sysgpu.LoggingCallback = null,
    log_cb_userdata: ?*anyopaque = null,
    err_cb: ?sysgpu.ErrorCallback = null,
    err_cb_userdata: ?*anyopaque = null,

    pub fn init(adapter: *Adapter, descriptor: ?*const sysgpu.Device.Descriptor) !*Device {
        const queue_infos = &[_]vk.DeviceQueueCreateInfo{.{
            .queue_family_index = adapter.queue_family,
            .queue_count = 1,
            .p_queue_priorities = &[_]f32{1.0},
        }};

        var features = vk.PhysicalDeviceFeatures2{ .features = .{} };
        if (descriptor) |desc| {
            if (desc.required_features) |required_features| {
                for (required_features[0..desc.required_features_count]) |req_feature| {
                    switch (req_feature) {
                        .undefined => break,
                        .depth_clip_control => features.features.depth_clamp = vk.TRUE,
                        .pipeline_statistics_query => features.features.pipeline_statistics_query = vk.TRUE,
                        .texture_compression_bc => features.features.texture_compression_bc = vk.TRUE,
                        .texture_compression_etc2 => features.features.texture_compression_etc2 = vk.TRUE,
                        .texture_compression_astc => features.features.texture_compression_astc_ldr = vk.TRUE,
                        .indirect_first_instance => features.features.draw_indirect_first_instance = vk.TRUE,
                        .shader_f16 => {
                            var feature = vk.PhysicalDeviceShaderFloat16Int8FeaturesKHR{
                                .s_type = .physical_device_shader_float16_int8_features_khr,
                                .shader_float_16 = vk.TRUE,
                            };
                            features.p_next = @ptrCast(&feature);
                        },
                        else => log.warn("unimplement feature: {s}", .{@tagName(req_feature)}),
                    }
                }
            }
        }

        // Query layers
        var count: u32 = 0;
        _ = try vki.enumerateDeviceLayerProperties(adapter.physical_device, &count, null);

        const available_layers = try allocator.alloc(vk.LayerProperties, count);
        defer allocator.free(available_layers);
        _ = try vki.enumerateDeviceLayerProperties(adapter.physical_device, &count, available_layers.ptr);

        var layers = std.BoundedArray([*:0]const u8, device_layers.len){};
        for (device_layers) |optional| {
            for (available_layers) |available| {
                if (std.mem.eql(
                    u8,
                    std.mem.sliceTo(optional, 0),
                    std.mem.sliceTo(&available.layer_name, 0),
                )) {
                    layers.appendAssumeCapacity(optional);
                    break;
                }
            }
        }

        // Query extensions
        _ = try vki.enumerateDeviceExtensionProperties(adapter.physical_device, null, &count, null);

        const available_extensions = try allocator.alloc(vk.ExtensionProperties, count);
        defer allocator.free(available_extensions);
        _ = try vki.enumerateDeviceExtensionProperties(adapter.physical_device, null, &count, available_extensions.ptr);

        var extensions = std.BoundedArray([*:0]const u8, device_extensions.len){};
        for (device_extensions) |required| {
            for (available_extensions) |available| {
                if (std.mem.eql(
                    u8,
                    std.mem.sliceTo(required, 0),
                    std.mem.sliceTo(&available.extension_name, 0),
                )) {
                    extensions.appendAssumeCapacity(required);
                    break;
                }
            } else {
                log.warn("unable to find required device extension: {s}", .{required});
            }
        }

        var create_info = vk.DeviceCreateInfo{
            .queue_create_info_count = @intCast(queue_infos.len),
            .p_queue_create_infos = queue_infos.ptr,
            .enabled_layer_count = @intCast(layers.len),
            .pp_enabled_layer_names = layers.slice().ptr,
            .enabled_extension_count = @intCast(extensions.len),
            .pp_enabled_extension_names = extensions.slice().ptr,
        };
        if (adapter.hasExtension("GetPhysicalDeviceProperties2")) {
            create_info.p_next = &features;
        } else {
            create_info.p_enabled_features = &features.features;
        }

        const vk_device = try vki.createDevice(adapter.physical_device, &create_info, null);
        vkd = try proc.loadDevice(vk_device, vki.dispatch.vkGetDeviceProcAddr);

        var supported_ds_formats = std.AutoHashMapUnmanaged(vk.Format, void){};
        for ([_]vk.Format{ .d24_unorm_s8_uint, .s8_uint }) |format| {
            const properties = vki.getPhysicalDeviceFormatProperties(adapter.physical_device, format);
            if (properties.optimal_tiling_features.depth_stencil_attachment_bit) {
                try supported_ds_formats.put(allocator, format, {});
            }
        }

        const cmd_pool = try vkd.createCommandPool(vk_device, &.{
            .queue_family_index = adapter.queue_family,
            .flags = .{ .reset_command_buffer_bit = true },
        }, null);

        const memory_allocator = MemoryAllocator.init(adapter.physical_device);

        var device = try allocator.create(Device);
        device.* = .{
            .adapter = adapter,
            .vk_device = vk_device,
            .cmd_pool = cmd_pool,
            .memory_allocator = memory_allocator,
            .supported_ds_formats = supported_ds_formats,
        };
        device.streaming_manager = try StreamingManager.init(device);
        errdefer device.streaming_manager.deinit();
        return device;
    }

    pub fn deinit(device: *Device) void {
        const vk_device = device.vk_device;

        if (device.lost_cb) |lost_cb| {
            lost_cb(.destroyed, "Device was destroyed.", device.lost_cb_userdata);
        }

        device.waitAll() catch {};
        device.processQueuedOperations();

        device.map_callbacks.deinit(allocator);
        device.submit_objects.deinit(allocator);
        device.streaming_manager.deinit();

        var rp_iter = device.render_passes.valueIterator();
        while (rp_iter.next()) |render_pass| {
            vkd.destroyRenderPass(vk_device, render_pass.*, null);
        }
        device.render_passes.deinit(allocator);
        device.supported_ds_formats.deinit(allocator);

        vkd.destroyCommandPool(vk_device, device.cmd_pool, null);
        if (device.queue) |*queue| queue.manager.release();
        vkd.destroyDevice(vk_device, null);
        allocator.destroy(device);
    }

    fn waitAll(device: *Device) !void {
        for (device.submit_objects.items) |*submit_object| try submit_object.wait();
    }

    pub fn createBindGroup(device: *Device, desc: *const sysgpu.BindGroup.Descriptor) !*BindGroup {
        return BindGroup.init(device, desc);
    }

    pub fn createBindGroupLayout(device: *Device, desc: *const sysgpu.BindGroupLayout.Descriptor) !*BindGroupLayout {
        return BindGroupLayout.init(device, desc);
    }

    pub fn createBuffer(device: *Device, desc: *const sysgpu.Buffer.Descriptor) !*Buffer {
        return Buffer.init(device, desc);
    }

    pub fn createCommandEncoder(device: *Device, desc: *const sysgpu.CommandEncoder.Descriptor) !*CommandEncoder {
        return CommandEncoder.init(device, desc);
    }

    pub fn createComputePipeline(device: *Device, desc: *const sysgpu.ComputePipeline.Descriptor) !*ComputePipeline {
        return ComputePipeline.init(device, desc);
    }

    pub fn createPipelineLayout(device: *Device, desc: *const sysgpu.PipelineLayout.Descriptor) !*PipelineLayout {
        return PipelineLayout.init(device, desc);
    }

    pub fn createRenderPipeline(device: *Device, desc: *const sysgpu.RenderPipeline.Descriptor) !*RenderPipeline {
        return RenderPipeline.init(device, desc);
    }

    pub fn createSampler(device: *Device, desc: *const sysgpu.Sampler.Descriptor) !*Sampler {
        return Sampler.init(device, desc);
    }

    pub fn createShaderModuleAir(device: *Device, air: *shader.Air, label: [*:0]const u8) !*ShaderModule {
        _ = label;
        return ShaderModule.initAir(device, air);
    }

    pub fn createShaderModuleSpirv(device: *Device, code: [*]const u32, code_size: u32) !*ShaderModule {
        const vk_shader_module = try vkd.createShaderModule(device.vk_device, &vk.ShaderModuleCreateInfo{
            .code_size = code_size,
            .p_code = code,
        }, null);

        const module = try allocator.create(ShaderModule);
        module.* = .{
            .device = device,
            .vk_shader_module = vk_shader_module,
        };
        return module;
    }

    pub fn createShaderModuleHLSL(device: *Device, code: []const u8) !*ShaderModule {
        _ = code;
        _ = device;
        return error.Unsupported;
    }

    pub fn createShaderModuleMSL(
        device: *Device,
        label: [*:0]const u8,
        code: []const u8,
        workgroup_size: sysgpu.ShaderModule.WorkgroupSize,
    ) !*ShaderModule {
        _ = label;
        _ = code;
        _ = device;
        _ = workgroup_size;
        return error.Unsupported;
    }

    pub fn createSwapChain(device: *Device, surface: *Surface, desc: *const sysgpu.SwapChain.Descriptor) !*SwapChain {
        return SwapChain.init(device, surface, desc);
    }

    pub fn createTexture(device: *Device, desc: *const sysgpu.Texture.Descriptor) !*Texture {
        return Texture.init(device, desc);
    }

    pub fn getQueue(device: *Device) !*Queue {
        if (device.queue == null) {
            device.queue = try Queue.init(device);
        }
        return &device.queue.?;
    }

    pub fn tick(device: *Device) !void {
        if (device.queue) |*queue| try queue.flush();
        device.processQueuedOperations();
    }

    const device_layers = if (builtin.mode == .Debug)
        &[_][*:0]const u8{"VK_LAYER_KHRONOS_validation"}
    else
        &.{};
    const device_extensions = &[_][*:0]const u8{vk.extension_info.khr_swapchain.name};

    pub const ResolveKey = struct {
        format: vk.Format,
        layout: vk.ImageLayout,
    };

    pub const ColorAttachmentKey = struct {
        format: vk.Format,
        samples: u32,
        load_op: sysgpu.LoadOp,
        store_op: sysgpu.StoreOp,
        layout: vk.ImageLayout,
        resolve: ?ResolveKey,
    };

    pub const DepthStencilAttachmentKey = struct {
        format: vk.Format,
        samples: u32,
        depth_load_op: sysgpu.LoadOp,
        depth_store_op: sysgpu.StoreOp,
        stencil_load_op: sysgpu.LoadOp,
        stencil_store_op: sysgpu.StoreOp,
        layout: vk.ImageLayout,
        read_only: bool,
    };

    pub const RenderPassKey = struct {
        colors: std.BoundedArray(ColorAttachmentKey, 8),
        depth_stencil: ?DepthStencilAttachmentKey,

        pub fn init() RenderPassKey {
            var colors = std.BoundedArray(ColorAttachmentKey, 8){};
            for (&colors.buffer) |*color| {
                color.* = .{
                    .format = .undefined,
                    .samples = 1,
                    .load_op = .load,
                    .store_op = .store,
                    .layout = .undefined,
                    .resolve = null,
                };
            }

            return .{
                .colors = .{},
                .depth_stencil = null,
            };
        }
    };

    fn createRenderPass(device: *Device, key: RenderPassKey) !vk.RenderPass {
        const vk_device = device.vk_device;

        if (device.render_passes.get(key)) |render_pass| return render_pass;

        var attachments = std.BoundedArray(vk.AttachmentDescription, 8){};
        var color_refs = std.BoundedArray(vk.AttachmentReference, 8){};
        var resolve_refs = std.BoundedArray(vk.AttachmentReference, 8){};
        for (key.colors.slice()) |attach| {
            attachments.appendAssumeCapacity(.{
                .format = attach.format,
                .samples = conv.vulkanSampleCount(attach.samples),
                .load_op = conv.vulkanLoadOp(attach.load_op),
                .store_op = conv.vulkanStoreOp(attach.store_op),
                .stencil_load_op = .dont_care,
                .stencil_store_op = .dont_care,
                .initial_layout = attach.layout,
                .final_layout = attach.layout,
            });
            color_refs.appendAssumeCapacity(.{
                .attachment = @intCast(attachments.len - 1),
                .layout = .color_attachment_optimal,
            });

            if (attach.resolve) |resolve| {
                attachments.appendAssumeCapacity(.{
                    .format = resolve.format,
                    .samples = conv.vulkanSampleCount(1),
                    .load_op = .dont_care,
                    .store_op = .store,
                    .stencil_load_op = .dont_care,
                    .stencil_store_op = .dont_care,
                    .initial_layout = resolve.layout,
                    .final_layout = resolve.layout,
                });
                resolve_refs.appendAssumeCapacity(.{
                    .attachment = @intCast(attachments.len - 1),
                    .layout = .color_attachment_optimal,
                });
            }
        }

        const depth_stencil_ref = if (key.depth_stencil) |depth_stencil| blk: {
            const layout: vk.ImageLayout = if (depth_stencil.read_only)
                .depth_stencil_read_only_optimal
            else
                .depth_stencil_attachment_optimal;

            attachments.appendAssumeCapacity(.{
                .format = depth_stencil.format,
                .samples = conv.vulkanSampleCount(depth_stencil.samples),
                .load_op = conv.vulkanLoadOp(depth_stencil.depth_load_op),
                .store_op = conv.vulkanStoreOp(depth_stencil.depth_store_op),
                .stencil_load_op = conv.vulkanLoadOp(depth_stencil.stencil_load_op),
                .stencil_store_op = conv.vulkanStoreOp(depth_stencil.stencil_store_op),
                .initial_layout = depth_stencil.layout,
                .final_layout = depth_stencil.layout,
            });

            break :blk &vk.AttachmentReference{
                .attachment = @intCast(attachments.len - 1),
                .layout = layout,
            };
        } else null;

        const render_pass = try vkd.createRenderPass(vk_device, &vk.RenderPassCreateInfo{
            .attachment_count = @intCast(attachments.len),
            .p_attachments = attachments.slice().ptr,
            .subpass_count = 1,
            .p_subpasses = &[_]vk.SubpassDescription{
                .{
                    .pipeline_bind_point = .graphics,
                    .color_attachment_count = @intCast(color_refs.len),
                    .p_color_attachments = color_refs.slice().ptr,
                    .p_resolve_attachments = if (resolve_refs.len != 0) resolve_refs.slice().ptr else null,
                    .p_depth_stencil_attachment = depth_stencil_ref,
                },
            },
        }, null);

        try device.render_passes.put(allocator, key, render_pass);

        return render_pass;
    }

    pub fn processQueuedOperations(device: *Device) void {
        const vk_device = device.vk_device;

        // Submit objects
        {
            var i: usize = 0;
            while (i < device.submit_objects.items.len) {
                var submit_object = device.submit_objects.items[i];

                const status = vkd.getFenceStatus(vk_device, submit_object.fence) catch unreachable;
                if (status == .success) {
                    submit_object.deinit();
                    _ = device.submit_objects.swapRemove(i);
                } else {
                    i += 1;
                }
            }
        }

        // MapAsync
        {
            var i: usize = 0;
            while (i < device.map_callbacks.items.len) {
                const map_callback = device.map_callbacks.items[i];

                if (map_callback.buffer.gpu_count == 0) {
                    map_callback.buffer.executeMapAsync(map_callback);

                    _ = device.map_callbacks.swapRemove(i);
                } else {
                    i += 1;
                }
            }
        }
    }
};

pub const SubmitObject = struct {
    device: *Device,
    fence: vk.Fence,
    reference_trackers: std.ArrayListUnmanaged(*ReferenceTracker) = .{},

    pub fn init(device: *Device) !SubmitObject {
        const vk_device = device.vk_device;

        const fence = try vkd.createFence(vk_device, &.{ .flags = .{ .signaled_bit = false } }, null);

        return .{
            .device = device,
            .fence = fence,
        };
    }

    pub fn deinit(object: *SubmitObject) void {
        const vk_device = object.device.vk_device;

        for (object.reference_trackers.items) |reference_tracker| reference_tracker.deinit();
        vkd.destroyFence(vk_device, object.fence, null);
        object.reference_trackers.deinit(allocator);
    }

    pub fn wait(object: *SubmitObject) !void {
        const vk_device = object.device.vk_device;

        _ = try vkd.waitForFences(vk_device, 1, &[_]vk.Fence{object.fence}, vk.TRUE, std.math.maxInt(u64));
    }
};

pub const StreamingManager = struct {
    device: *Device,
    free_buffers: std.ArrayListUnmanaged(*Buffer) = .{},

    pub fn init(device: *Device) !StreamingManager {
        return .{
            .device = device,
        };
    }

    pub fn deinit(manager: *StreamingManager) void {
        for (manager.free_buffers.items) |buffer| buffer.manager.release();
        manager.free_buffers.deinit(allocator);
    }

    pub fn acquire(manager: *StreamingManager) !*Buffer {
        const device = manager.device;

        // Recycle finished buffers
        if (manager.free_buffers.items.len == 0) {
            device.processQueuedOperations();
        }

        // Create new buffer
        if (manager.free_buffers.items.len == 0) {
            const buffer = try Buffer.init(device, &.{
                .label = "upload",
                .usage = .{
                    .copy_src = true,
                    .map_write = true,
                },
                .size = upload_page_size,
                .mapped_at_creation = .true,
            });
            errdefer _ = buffer.manager.release();

            try manager.free_buffers.append(allocator, buffer);
        }

        // Result
        return manager.free_buffers.pop();
    }

    pub fn release(manager: *StreamingManager, buffer: *Buffer) void {
        manager.free_buffers.append(allocator, buffer) catch {
            std.debug.panic("OutOfMemory", .{});
        };
    }
};

pub const SwapChain = struct {
    manager: utils.Manager(SwapChain) = .{},
    device: *Device,
    vk_swapchain: vk.SwapchainKHR,
    fence: vk.Fence,
    wait_semaphore: vk.Semaphore,
    signal_semaphore: vk.Semaphore,
    textures: []*Texture,
    texture_views: []*TextureView,
    texture_index: u32 = 0,
    current_texture_view: ?*TextureView = null,
    format: sysgpu.Texture.Format,

    pub fn init(device: *Device, surface: *Surface, desc: *const sysgpu.SwapChain.Descriptor) !*SwapChain {
        const vk_device = device.vk_device;

        const sc = try allocator.create(SwapChain);

        const capabilities = try vki.getPhysicalDeviceSurfaceCapabilitiesKHR(
            device.adapter.physical_device,
            surface.vk_surface,
        );

        // TODO: query surface formats
        // TODO: query surface present modes

        const composite_alpha = blk: {
            const composite_alpha_flags = [_]vk.CompositeAlphaFlagsKHR{
                .{ .opaque_bit_khr = true },
                .{ .pre_multiplied_bit_khr = true },
                .{ .post_multiplied_bit_khr = true },
                .{ .inherit_bit_khr = true },
            };
            for (composite_alpha_flags) |flag| {
                if (@as(vk.Flags, @bitCast(flag)) & @as(vk.Flags, @bitCast(capabilities.supported_composite_alpha)) != 0) {
                    break :blk flag;
                }
            }
            break :blk vk.CompositeAlphaFlagsKHR{};
        };
        const image_count = @max(capabilities.min_image_count + 1, capabilities.max_image_count);
        const format = conv.vulkanFormat(device, desc.format);
        const extent = vk.Extent2D{
            .width = std.math.clamp(
                desc.width,
                capabilities.min_image_extent.width,
                capabilities.max_image_extent.width,
            ),
            .height = std.math.clamp(
                desc.height,
                capabilities.min_image_extent.height,
                capabilities.max_image_extent.height,
            ),
        };
        const image_usage = conv.vulkanImageUsageFlags(desc.usage, desc.format);
        const present_mode = conv.vulkanPresentMode(desc.present_mode);

        const vk_swapchain = try vkd.createSwapchainKHR(vk_device, &.{
            .surface = surface.vk_surface,
            .min_image_count = image_count,
            .image_format = format,
            .image_color_space = .srgb_nonlinear_khr,
            .image_extent = extent,
            .image_array_layers = 1,
            .image_usage = image_usage,
            .image_sharing_mode = .exclusive,
            .pre_transform = .{ .identity_bit_khr = true },
            .composite_alpha = composite_alpha,
            .present_mode = present_mode,
            .clipped = vk.FALSE,
        }, null);

        const fence = try vkd.createFence(vk_device, &.{ .flags = .{ .signaled_bit = false } }, null);
        errdefer vkd.destroyFence(vk_device, fence, null);

        const wait_semaphore = try vkd.createSemaphore(vk_device, &.{}, null);
        errdefer vkd.destroySemaphore(vk_device, wait_semaphore, null);

        const signal_semaphore = try vkd.createSemaphore(vk_device, &.{}, null);
        errdefer vkd.destroySemaphore(vk_device, signal_semaphore, null);

        var images_len: u32 = 0;
        _ = try vkd.getSwapchainImagesKHR(vk_device, vk_swapchain, &images_len, null);
        const images = try allocator.alloc(vk.Image, images_len);
        defer allocator.free(images);
        _ = try vkd.getSwapchainImagesKHR(vk_device, vk_swapchain, &images_len, images.ptr);

        const textures = try allocator.alloc(*Texture, images_len);
        errdefer allocator.free(textures);
        const texture_views = try allocator.alloc(*TextureView, images_len);
        errdefer allocator.free(texture_views);

        for (0..images_len) |i| {
            const texture = try Texture.initForSwapChain(device, desc, images[i], sc);
            textures[i] = texture;
            texture_views[i] = try texture.createView(&.{
                .format = desc.format,
                .dimension = .dimension_2d,
            });
        }

        sc.* = .{
            .device = device,
            .vk_swapchain = vk_swapchain,
            .fence = fence,
            .wait_semaphore = wait_semaphore,
            .signal_semaphore = signal_semaphore,
            .textures = textures,
            .texture_views = texture_views,
            .format = desc.format,
        };

        return sc;
    }

    pub fn deinit(sc: *SwapChain) void {
        const vk_device = sc.device.vk_device;

        sc.device.waitAll() catch {};

        for (sc.texture_views) |view| view.manager.release();
        for (sc.textures) |texture| texture.manager.release();
        vkd.destroySemaphore(vk_device, sc.wait_semaphore, null);
        vkd.destroySemaphore(vk_device, sc.signal_semaphore, null);
        vkd.destroyFence(vk_device, sc.fence, null);
        vkd.destroySwapchainKHR(vk_device, sc.vk_swapchain, null);
        allocator.free(sc.textures);
        allocator.free(sc.texture_views);
        allocator.destroy(sc);
    }

    pub fn getCurrentTextureView(sc: *SwapChain) !*TextureView {
        const vk_device = sc.device.vk_device;

        if (sc.current_texture_view) |view| {
            view.manager.reference();
            return view;
        }

        const result = try vkd.acquireNextImageKHR(
            vk_device,
            sc.vk_swapchain,
            std.math.maxInt(u64),
            if (use_semaphore_wait) sc.wait_semaphore else .null_handle,
            if (!use_semaphore_wait) sc.fence else .null_handle,
        );

        // Wait on the CPU so that GPU does not stall later during present.
        // This should be similar to using DXGI Waitable Object.
        if (!use_semaphore_wait) {
            _ = try vkd.waitForFences(vk_device, 1, &[_]vk.Fence{sc.fence}, vk.TRUE, std.math.maxInt(u64));
            try vkd.resetFences(vk_device, 1, &[_]vk.Fence{sc.fence});
        }

        sc.texture_index = result.image_index;
        var view = sc.texture_views[sc.texture_index];
        view.manager.reference();
        sc.current_texture_view = view;

        return view;
    }

    pub fn present(sc: *SwapChain) !void {
        const queue = try sc.device.getQueue();
        const vk_queue = queue.vk_queue;

        const semaphore = sc.signal_semaphore;
        try queue.signal_semaphores.append(allocator, semaphore);
        try queue.flush();

        _ = try vkd.queuePresentKHR(vk_queue, &.{
            .wait_semaphore_count = 1,
            .p_wait_semaphores = &[_]vk.Semaphore{semaphore},
            .swapchain_count = 1,
            .p_swapchains = &[_]vk.SwapchainKHR{sc.vk_swapchain},
            .p_image_indices = &[_]u32{sc.texture_index},
        });

        sc.current_texture_view = null;
    }
};

pub const Buffer = struct {
    manager: utils.Manager(Buffer) = .{},
    device: *Device,
    vk_buffer: vk.Buffer,
    memory: vk.DeviceMemory,
    // NOTE - this is a naive sync solution as a placeholder until render graphs are implemented
    read_stage_mask: vk.PipelineStageFlags,
    read_access_mask: vk.AccessFlags,
    stage_buffer: ?*Buffer,
    gpu_count: u32 = 0,
    map: ?[*]u8,
    // TODO - packed buffer descriptor struct
    size: u64,
    usage: sysgpu.Buffer.UsageFlags,

    pub fn init(device: *Device, desc: *const sysgpu.Buffer.Descriptor) !*Buffer {
        const vk_device = device.vk_device;

        // Buffer
        const size = @max(4, desc.size);

        var usage = desc.usage;
        if (desc.mapped_at_creation == .true and !desc.usage.map_write)
            usage.copy_dst = true;

        const vk_buffer = try vkd.createBuffer(vk_device, &.{
            .size = size,
            .usage = conv.vulkanBufferUsageFlags(usage),
            .sharing_mode = .exclusive,
        }, null);

        // Memory
        const requirements = vkd.getBufferMemoryRequirements(vk_device, vk_buffer);

        const mem_type: MemoryAllocator.MemoryKind = blk: {
            if (desc.usage.map_read) break :blk .linear_read_mappable;
            if (desc.usage.map_write) break :blk .linear_write_mappable;
            break :blk .linear;
        };
        const mem_type_index = device.memory_allocator.findBestAllocator(requirements, mem_type) orelse @panic("unimplemented"); // TODO

        const memory = try vkd.allocateMemory(vk_device, &.{
            .allocation_size = requirements.size,
            .memory_type_index = mem_type_index,
        }, null);

        try vkd.bindBufferMemory(vk_device, vk_buffer, memory, 0);

        // Upload buffer
        var stage_buffer: ?*Buffer = null;
        var map: ?*anyopaque = null;
        if (desc.mapped_at_creation == .true) {
            if (!desc.usage.map_write) {
                stage_buffer = try Buffer.init(device, &.{
                    .usage = .{
                        .copy_src = true,
                        .map_write = true,
                    },
                    .size = size,
                });
                map = try vkd.mapMemory(vk_device, stage_buffer.?.memory, 0, size, .{});
            } else {
                map = try vkd.mapMemory(vk_device, memory, 0, size, .{});
            }
        }

        // Result
        const buffer = try allocator.create(Buffer);
        buffer.* = .{
            .device = device,
            .vk_buffer = vk_buffer,
            .memory = memory,
            .read_stage_mask = conv.vulkanPipelineStageFlagsForBufferRead(desc.usage),
            .read_access_mask = conv.vulkanAccessFlagsForBufferRead(desc.usage),
            .stage_buffer = stage_buffer,
            .map = @ptrCast(map),
            .size = desc.size,
            .usage = desc.usage,
        };

        return buffer;
    }

    pub fn deinit(buffer: *Buffer) void {
        const vk_device = buffer.device.vk_device;

        if (buffer.stage_buffer) |stage_buffer| stage_buffer.manager.release();
        vkd.freeMemory(vk_device, buffer.memory, null);
        vkd.destroyBuffer(vk_device, buffer.vk_buffer, null);
        allocator.destroy(buffer);
    }

    pub fn getMappedRange(buffer: *Buffer, offset: usize, size: usize) !?*anyopaque {
        return @ptrCast(buffer.map.?[offset .. offset + size]);
    }

    pub fn getSize(buffer: *Buffer) u64 {
        return buffer.size;
    }

    pub fn getUsage(buffer: *Buffer) sysgpu.Buffer.UsageFlags {
        return buffer.usage;
    }

    pub fn mapAsync(
        buffer: *Buffer,
        mode: sysgpu.MapModeFlags,
        offset: usize,
        size: usize,
        callback: sysgpu.Buffer.MapCallback,
        userdata: ?*anyopaque,
    ) !void {
        _ = size;
        _ = offset;
        _ = mode;

        const map_callback = MapCallback{ .buffer = buffer, .callback = callback, .userdata = userdata };
        if (buffer.gpu_count == 0) {
            buffer.executeMapAsync(map_callback);
        } else {
            try buffer.device.map_callbacks.append(allocator, map_callback);
        }
    }

    pub fn setLabel(buffer: *Buffer, label: [*:0]const u8) void {
        _ = label;
        _ = buffer;
        @panic("unimplemented");
    }

    pub fn unmap(buffer: *Buffer) !void {
        const vk_device = buffer.device.vk_device;
        const queue = try buffer.device.getQueue();

        var unmap_memory: vk.DeviceMemory = undefined;
        if (buffer.stage_buffer) |stage_buffer| {
            unmap_memory = stage_buffer.memory;
            const encoder = try queue.getCommandEncoder();
            try encoder.copyBufferToBuffer(stage_buffer, 0, buffer, 0, buffer.size);
            stage_buffer.manager.release();
            buffer.stage_buffer = null;
        } else {
            unmap_memory = buffer.memory;
        }
        vkd.unmapMemory(vk_device, unmap_memory);
    }

    // Internal
    pub fn executeMapAsync(buffer: *Buffer, map_callback: MapCallback) void {
        const vk_device = buffer.device.vk_device;

        const map = vkd.mapMemory(vk_device, buffer.memory, 0, buffer.size, .{}) catch {
            map_callback.callback(.unknown, map_callback.userdata);
            return;
        };

        buffer.map = @ptrCast(map);
        map_callback.callback(.success, map_callback.userdata);
    }
};

pub const Texture = struct {
    manager: utils.Manager(Texture) = .{},
    device: *Device,
    extent: vk.Extent2D,
    image: vk.Image,
    memory: vk.DeviceMemory,
    swapchain: ?*SwapChain = null,
    // NOTE - this is a naive sync solution as a placeholder until render graphs are implemented
    read_stage_mask: vk.PipelineStageFlags,
    read_access_mask: vk.AccessFlags,
    read_image_layout: vk.ImageLayout,
    // TODO - packed texture descriptor struct
    usage: sysgpu.Texture.UsageFlags,
    dimension: sysgpu.Texture.Dimension,
    size: sysgpu.Extent3D,
    format: sysgpu.Texture.Format,
    mip_level_count: u32,
    sample_count: u32,

    pub fn init(device: *Device, desc: *const sysgpu.Texture.Descriptor) !*Texture {
        const vk_device = device.vk_device;

        // Image
        const cube_compatible =
            desc.dimension == .dimension_2d and
            desc.size.width == desc.size.height and
            desc.size.depth_or_array_layers >= 6;
        const extent = utils.calcExtent(desc.dimension, desc.size);

        const vk_image = try vkd.createImage(vk_device, &.{
            .flags = conv.vulkanImageCreateFlags(cube_compatible, desc.view_format_count),
            .image_type = conv.vulkanImageType(desc.dimension),
            .format = conv.vulkanFormat(device, desc.format),
            .extent = .{ .width = extent.width, .height = extent.height, .depth = extent.depth },
            .mip_levels = desc.mip_level_count,
            .array_layers = extent.array_count,
            .samples = conv.vulkanSampleCount(desc.sample_count),
            .tiling = .optimal,
            .usage = conv.vulkanImageUsageFlags(desc.usage, desc.format),
            .sharing_mode = .exclusive,
            .initial_layout = .undefined,
        }, null);

        // Memory
        const requirements = vkd.getImageMemoryRequirements(vk_device, vk_image);

        const mem_type = .linear;
        const mem_type_index = device.memory_allocator.findBestAllocator(requirements, mem_type) orelse @panic("unimplemented"); // TODO

        const memory = try vkd.allocateMemory(vk_device, &.{
            .allocation_size = requirements.size,
            .memory_type_index = mem_type_index,
        }, null);

        try vkd.bindImageMemory(vk_device, vk_image, memory, 0);

        // Result
        var texture = try allocator.create(Texture);
        texture.* = .{
            .device = device,
            .extent = .{ .width = extent.width, .height = extent.height },
            .image = vk_image,
            .memory = memory,
            .swapchain = null,
            .read_stage_mask = conv.vulkanPipelineStageFlagsForImageRead(desc.usage, desc.format),
            .read_access_mask = conv.vulkanAccessFlagsForImageRead(desc.usage, desc.format),
            .read_image_layout = conv.vulkanImageLayoutForRead(desc.usage, desc.format),
            .usage = desc.usage,
            .dimension = desc.dimension,
            .size = desc.size,
            .format = desc.format,
            .mip_level_count = desc.mip_level_count,
            .sample_count = desc.sample_count,
        };
        errdefer texture.manager.release();

        // Transition to read-state
        const queue = try device.getQueue();
        const encoder = try queue.getCommandEncoder();
        try encoder.state_tracker.initTexture(texture);

        return texture;
    }

    pub fn initForSwapChain(
        device: *Device,
        desc: *const sysgpu.SwapChain.Descriptor,
        image: vk.Image,
        swapchain: *SwapChain,
    ) !*Texture {
        var texture = try allocator.create(Texture);
        texture.* = .{
            .device = device,
            .extent = .{ .width = desc.width, .height = desc.height },
            .image = image,
            .memory = .null_handle,
            .swapchain = swapchain,
            .read_stage_mask = conv.vulkanPipelineStageFlagsForImageRead(desc.usage, desc.format),
            .read_access_mask = conv.vulkanAccessFlagsForImageRead(desc.usage, desc.format),
            .read_image_layout = .present_src_khr,
            .usage = desc.usage,
            .dimension = .dimension_2d,
            .size = .{ .width = desc.width, .height = desc.height, .depth_or_array_layers = 1 },
            .format = desc.format,
            .mip_level_count = 1,
            .sample_count = 1,
        };
        errdefer texture.manager.release();

        // Transition to read-state
        const queue = try device.getQueue();
        const encoder = try queue.getCommandEncoder();
        try encoder.state_tracker.initTexture(texture);

        return texture;
    }

    pub fn deinit(texture: *Texture) void {
        const vk_device = texture.device.vk_device;

        if (texture.swapchain == null) {
            vkd.freeMemory(vk_device, texture.memory, null);
            vkd.destroyImage(vk_device, texture.image, null);
        }
        allocator.destroy(texture);
    }

    pub fn createView(texture: *Texture, desc: *const sysgpu.TextureView.Descriptor) !*TextureView {
        return TextureView.init(texture, desc, texture.extent);
    }
};

pub const TextureView = struct {
    manager: utils.Manager(TextureView) = .{},
    device: *Device,
    texture: *Texture,
    vk_view: vk.ImageView,
    vk_format: vk.Format,
    extent: vk.Extent2D,

    pub fn init(texture: *Texture, desc: *const sysgpu.TextureView.Descriptor, extent: vk.Extent2D) !*TextureView {
        const vk_device = texture.device.vk_device;

        texture.manager.reference();

        const texture_dimension: sysgpu.TextureView.Dimension = switch (texture.dimension) {
            .dimension_1d => .dimension_1d,
            .dimension_2d => .dimension_2d,
            .dimension_3d => .dimension_3d,
        };

        const format = if (desc.format != .undefined) desc.format else texture.format;
        const dimension = if (desc.dimension != .dimension_undefined) desc.dimension else texture_dimension;

        const vk_format = conv.vulkanFormat(texture.device, format);

        const vk_view = try vkd.createImageView(vk_device, &.{
            .image = texture.image,
            .view_type = conv.vulkanImageViewType(dimension),
            .format = vk_format,
            .components = .{
                .r = .identity,
                .g = .identity,
                .b = .identity,
                .a = .identity,
            },
            .subresource_range = .{
                .aspect_mask = conv.vulkanImageAspectFlags(desc.aspect, format),
                .base_mip_level = desc.base_mip_level,
                .level_count = desc.mip_level_count,
                .base_array_layer = desc.base_array_layer,
                .layer_count = desc.array_layer_count,
            },
        }, null);

        const view = try allocator.create(TextureView);
        view.* = .{
            .device = texture.device,
            .texture = texture,
            .vk_view = vk_view,
            .vk_format = vk_format,
            .extent = extent,
        };
        return view;
    }

    pub fn deinit(view: *TextureView) void {
        const vk_device = view.device.vk_device;

        vkd.destroyImageView(vk_device, view.vk_view, null);
        view.texture.manager.release();
        allocator.destroy(view);
    }
};

pub const Sampler = struct {
    manager: utils.Manager(Sampler) = .{},
    device: *Device,
    vk_sampler: vk.Sampler,

    pub fn init(device: *Device, desc: *const sysgpu.Sampler.Descriptor) !*Sampler {
        const vk_device = device.vk_device;

        const vk_sampler = try vkd.createSampler(vk_device, &.{
            .flags = .{},
            .mag_filter = conv.vulkanFilter(desc.mag_filter),
            .min_filter = conv.vulkanFilter(desc.min_filter),
            .mipmap_mode = conv.vulkanSamplerMipmapMode(desc.mipmap_filter),
            .address_mode_u = conv.vulkanSamplerAddressMode(desc.address_mode_u),
            .address_mode_v = conv.vulkanSamplerAddressMode(desc.address_mode_v),
            .address_mode_w = conv.vulkanSamplerAddressMode(desc.address_mode_w),
            .mip_lod_bias = 0,
            .anisotropy_enable = @intFromBool(desc.max_anisotropy > 1),
            .max_anisotropy = @floatFromInt(desc.max_anisotropy),
            .compare_enable = @intFromBool(desc.compare != .undefined),
            .compare_op = if (desc.compare != .undefined) conv.vulkanCompareOp(desc.compare) else .never,
            .min_lod = desc.lod_min_clamp,
            .max_lod = desc.lod_max_clamp,
            .border_color = .float_transparent_black,
            .unnormalized_coordinates = vk.FALSE,
        }, null);

        // Result
        const sampler = try allocator.create(Sampler);
        sampler.* = .{
            .device = device,
            .vk_sampler = vk_sampler,
        };
        return sampler;
    }

    pub fn deinit(sampler: *Sampler) void {
        const vk_device = sampler.device.vk_device;

        vkd.destroySampler(vk_device, sampler.vk_sampler, null);
        allocator.destroy(sampler);
    }
};

pub const BindGroupLayout = struct {
    const Entry = struct {
        binding: u32,
        descriptor_type: vk.DescriptorType,
        image_layout: vk.ImageLayout,
    };

    manager: utils.Manager(BindGroupLayout) = .{},
    device: *Device,
    vk_layout: vk.DescriptorSetLayout,
    desc_pool: vk.DescriptorPool,
    entries: std.ArrayListUnmanaged(Entry),

    const max_sets = 512;

    pub fn init(device: *Device, desc: *const sysgpu.BindGroupLayout.Descriptor) !*BindGroupLayout {
        const vk_device = device.vk_device;

        var bindings = try std.ArrayListUnmanaged(vk.DescriptorSetLayoutBinding).initCapacity(allocator, desc.entry_count);
        defer bindings.deinit(allocator);

        var desc_types = std.AutoArrayHashMap(vk.DescriptorType, u32).init(allocator);
        defer desc_types.deinit();

        var entries = try std.ArrayListUnmanaged(Entry).initCapacity(allocator, desc.entry_count);
        errdefer entries.deinit(allocator);

        for (0..desc.entry_count) |entry_index| {
            const entry = desc.entries.?[entry_index];
            const descriptor_type = conv.vulkanDescriptorType(entry);
            if (desc_types.getPtr(descriptor_type)) |count| {
                count.* += 1;
            } else {
                try desc_types.put(descriptor_type, 1);
            }

            bindings.appendAssumeCapacity(.{
                .binding = entry.binding,
                .descriptor_type = descriptor_type,
                .descriptor_count = 1,
                .stage_flags = conv.vulkanShaderStageFlags(entry.visibility),
            });

            entries.appendAssumeCapacity(.{
                .binding = entry.binding,
                .descriptor_type = descriptor_type,
                .image_layout = conv.vulkanImageLayoutForTextureBinding(entry.texture.sample_type),
            });
        }

        const vk_layout = try vkd.createDescriptorSetLayout(vk_device, &vk.DescriptorSetLayoutCreateInfo{
            .binding_count = @intCast(bindings.items.len),
            .p_bindings = bindings.items.ptr,
        }, null);

        // Descriptor Pool
        var pool_sizes = try std.ArrayList(vk.DescriptorPoolSize).initCapacity(allocator, desc_types.count());
        defer pool_sizes.deinit();

        var desc_types_iter = desc_types.iterator();
        while (desc_types_iter.next()) |entry| {
            pool_sizes.appendAssumeCapacity(.{
                .type = entry.key_ptr.*,
                .descriptor_count = max_sets * entry.value_ptr.*,
            });
        }

        const desc_pool = try vkd.createDescriptorPool(vk_device, &vk.DescriptorPoolCreateInfo{
            .flags = .{ .free_descriptor_set_bit = true },
            .max_sets = max_sets,
            .pool_size_count = @intCast(pool_sizes.items.len),
            .p_pool_sizes = pool_sizes.items.ptr,
        }, null);

        // Result
        const layout = try allocator.create(BindGroupLayout);
        layout.* = .{
            .device = device,
            .vk_layout = vk_layout,
            .desc_pool = desc_pool,
            .entries = entries,
        };
        return layout;
    }

    pub fn deinit(layout: *BindGroupLayout) void {
        const vk_device = layout.device.vk_device;

        vkd.destroyDescriptorSetLayout(vk_device, layout.vk_layout, null);
        vkd.destroyDescriptorPool(vk_device, layout.desc_pool, null);

        layout.entries.deinit(allocator);
        allocator.destroy(layout);
    }

    // Internal
    pub fn getEntry(layout: *BindGroupLayout, binding: u32) ?*const Entry {
        for (layout.entries.items) |*entry| {
            if (entry.binding == binding)
                return entry;
        }

        return null;
    }
};

pub const BindGroup = struct {
    const BufferAccess = struct {
        buffer: *Buffer,
        storage: bool,
    };
    const TextureViewAccess = struct {
        texture_view: *TextureView,
        storage: bool,
    };
    manager: utils.Manager(BindGroup) = .{},
    device: *Device,
    layout: *BindGroupLayout,
    desc_set: vk.DescriptorSet,
    buffers: std.ArrayListUnmanaged(BufferAccess),
    texture_views: std.ArrayListUnmanaged(TextureViewAccess),
    samplers: std.ArrayListUnmanaged(*Sampler),

    pub fn init(device: *Device, desc: *const sysgpu.BindGroup.Descriptor) !*BindGroup {
        const vk_device = device.vk_device;

        const layout: *BindGroupLayout = @ptrCast(@alignCast(desc.layout));
        layout.manager.reference();

        var desc_set: vk.DescriptorSet = undefined;
        try vkd.allocateDescriptorSets(vk_device, &vk.DescriptorSetAllocateInfo{
            .descriptor_pool = layout.desc_pool,
            .descriptor_set_count = 1,
            .p_set_layouts = @ptrCast(&layout.vk_layout),
        }, @ptrCast(&desc_set));

        var writes = try allocator.alloc(vk.WriteDescriptorSet, layout.entries.items.len);
        defer allocator.free(writes);
        var write_image_info = try allocator.alloc(vk.DescriptorImageInfo, layout.entries.items.len);
        defer allocator.free(write_image_info);
        var write_buffer_info = try allocator.alloc(vk.DescriptorBufferInfo, layout.entries.items.len);
        defer allocator.free(write_buffer_info);

        for (0..desc.entry_count) |i| {
            const entry = desc.entries.?[i];
            const layout_entry = layout.getEntry(entry.binding) orelse return error.UnknownBinding;

            writes[i] = .{
                .dst_set = desc_set,
                .dst_binding = layout_entry.binding,
                .dst_array_element = 0,
                .descriptor_count = 1,
                .descriptor_type = layout_entry.descriptor_type,
                .p_image_info = undefined,
                .p_buffer_info = undefined,
                .p_texel_buffer_view = undefined,
            };

            switch (layout_entry.descriptor_type) {
                .sampler => {
                    const sampler: *Sampler = @ptrCast(@alignCast(entry.sampler.?));

                    write_image_info[i] = .{
                        .sampler = sampler.vk_sampler,
                        .image_view = .null_handle,
                        .image_layout = .undefined,
                    };
                    writes[i].p_image_info = @ptrCast(&write_image_info[i]);
                },
                .sampled_image, .storage_image => {
                    const texture_view: *TextureView = @ptrCast(@alignCast(entry.texture_view.?));

                    write_image_info[i] = .{
                        .sampler = .null_handle,
                        .image_view = texture_view.vk_view,
                        .image_layout = layout_entry.image_layout,
                    };
                    writes[i].p_image_info = @ptrCast(&write_image_info[i]);
                },
                .uniform_buffer,
                .storage_buffer,
                .uniform_buffer_dynamic,
                .storage_buffer_dynamic,
                => {
                    const buffer: *Buffer = @ptrCast(@alignCast(entry.buffer.?));

                    write_buffer_info[i] = .{
                        .buffer = buffer.vk_buffer,
                        .offset = desc.entries.?[i].offset,
                        .range = desc.entries.?[i].size,
                    };
                    writes[i].p_buffer_info = @ptrCast(&write_buffer_info[i]);
                },
                else => unreachable,
            }
        }

        vkd.updateDescriptorSets(vk_device, @intCast(writes.len), writes.ptr, 0, undefined);

        // Resource tracking
        var buffers = std.ArrayListUnmanaged(BufferAccess){};
        errdefer buffers.deinit(allocator);

        var texture_views = std.ArrayListUnmanaged(TextureViewAccess){};
        errdefer texture_views.deinit(allocator);

        var samplers = std.ArrayListUnmanaged(*Sampler){};
        errdefer samplers.deinit(allocator);

        for (0..desc.entry_count) |i| {
            const entry = desc.entries.?[i];
            const layout_entry = layout.getEntry(entry.binding) orelse return error.UnknownBinding;

            switch (layout_entry.descriptor_type) {
                .sampler => {
                    const sampler: *Sampler = @ptrCast(@alignCast(entry.sampler.?));

                    try samplers.append(allocator, sampler);
                    sampler.manager.reference();
                },
                .sampled_image, .storage_image => {
                    const texture_view: *TextureView = @ptrCast(@alignCast(entry.texture_view.?));
                    const storage = layout_entry.descriptor_type == .storage_image;

                    try texture_views.append(allocator, .{ .texture_view = texture_view, .storage = storage });
                    texture_view.manager.reference();
                },

                .uniform_buffer,
                .uniform_buffer_dynamic,
                .storage_buffer,
                .storage_buffer_dynamic,
                => {
                    const buffer: *Buffer = @ptrCast(@alignCast(entry.buffer.?));
                    const storage = layout_entry.descriptor_type == .storage_buffer or layout_entry.descriptor_type == .storage_buffer_dynamic;

                    try buffers.append(allocator, .{ .buffer = buffer, .storage = storage });
                    buffer.manager.reference();
                },
                else => unreachable,
            }
        }

        // Result
        const bind_group = try allocator.create(BindGroup);
        bind_group.* = .{
            .device = device,
            .layout = layout,
            .desc_set = desc_set,
            .buffers = buffers,
            .texture_views = texture_views,
            .samplers = samplers,
        };
        return bind_group;
    }

    pub fn deinit(group: *BindGroup) void {
        const vk_device = group.device.vk_device;

        vkd.freeDescriptorSets(vk_device, group.layout.desc_pool, 1, @ptrCast(&group.desc_set)) catch unreachable;

        for (group.buffers.items) |access| access.buffer.manager.release();
        for (group.texture_views.items) |access| access.texture_view.manager.release();
        for (group.samplers.items) |sampler| sampler.manager.release();
        group.layout.manager.release();

        group.buffers.deinit(allocator);
        group.texture_views.deinit(allocator);
        group.samplers.deinit(allocator);
        allocator.destroy(group);
    }
};

pub const PipelineLayout = struct {
    manager: utils.Manager(PipelineLayout) = .{},
    device: *Device,
    vk_layout: vk.PipelineLayout,
    group_layouts: []*BindGroupLayout,

    pub fn init(device: *Device, desc: *const sysgpu.PipelineLayout.Descriptor) !*PipelineLayout {
        const vk_device = device.vk_device;

        var group_layouts = try allocator.alloc(*BindGroupLayout, desc.bind_group_layout_count);
        errdefer allocator.free(group_layouts);

        const set_layouts = try allocator.alloc(vk.DescriptorSetLayout, desc.bind_group_layout_count);
        defer allocator.free(set_layouts);
        for (0..desc.bind_group_layout_count) |i| {
            const layout: *BindGroupLayout = @ptrCast(@alignCast(desc.bind_group_layouts.?[i]));
            layout.manager.reference();
            group_layouts[i] = layout;
            set_layouts[i] = layout.vk_layout;
        }

        const vk_layout = try vkd.createPipelineLayout(vk_device, &.{
            .set_layout_count = @intCast(set_layouts.len),
            .p_set_layouts = set_layouts.ptr,
        }, null);

        const layout = try allocator.create(PipelineLayout);
        layout.* = .{
            .device = device,
            .vk_layout = vk_layout,
            .group_layouts = group_layouts,
        };
        return layout;
    }

    pub fn initDefault(device: *Device, default_pipeline_layout: utils.DefaultPipelineLayoutDescriptor) !*PipelineLayout {
        const groups = default_pipeline_layout.groups;
        var bind_group_layouts = std.BoundedArray(*sysgpu.BindGroupLayout, limits.max_bind_groups){};
        defer {
            for (bind_group_layouts.slice()) |bind_group_layout| bind_group_layout.release();
        }

        for (groups.slice()) |entries| {
            const bind_group_layout = try device.createBindGroupLayout(
                &sysgpu.BindGroupLayout.Descriptor.init(.{ .entries = entries.items }),
            );
            bind_group_layouts.appendAssumeCapacity(@ptrCast(bind_group_layout));
        }

        return device.createPipelineLayout(
            &sysgpu.PipelineLayout.Descriptor.init(.{ .bind_group_layouts = bind_group_layouts.slice() }),
        );
    }

    pub fn deinit(layout: *PipelineLayout) void {
        const vk_device = layout.device.vk_device;

        for (layout.group_layouts) |group_layout| group_layout.manager.release();
        vkd.destroyPipelineLayout(vk_device, layout.vk_layout, null);
        allocator.free(layout.group_layouts);
        allocator.destroy(layout);
    }
};

pub const ShaderModule = struct {
    manager: utils.Manager(ShaderModule) = .{},
    device: *Device,
    vk_shader_module: vk.ShaderModule,
    air: ?*shader.Air = null,

    pub fn initAir(device: *Device, air: *shader.Air) !*ShaderModule {
        const vk_device = device.vk_device;

        const code = try shader.CodeGen.generate(allocator, air, .spirv, true, .{ .emit_source_file = "" }, null, null, null);
        defer allocator.free(code);

        const vk_shader_module = try vkd.createShaderModule(vk_device, &vk.ShaderModuleCreateInfo{
            .code_size = code.len,
            .p_code = @ptrCast(@alignCast(code.ptr)),
        }, null);

        const module = try allocator.create(ShaderModule);
        module.* = .{
            .device = device,
            .vk_shader_module = vk_shader_module,
            .air = air,
        };

        return module;
    }

    pub fn deinit(module: *ShaderModule) void {
        const vk_device = module.device.vk_device;

        vkd.destroyShaderModule(vk_device, module.vk_shader_module, null);
        if (module.air) |air| {
            air.deinit(allocator);
            allocator.destroy(air);
        }
        allocator.destroy(module);
    }
};

pub const ComputePipeline = struct {
    manager: utils.Manager(ComputePipeline) = .{},
    device: *Device,
    layout: *PipelineLayout,
    vk_pipeline: vk.Pipeline,

    pub fn init(device: *Device, desc: *const sysgpu.ComputePipeline.Descriptor) !*ComputePipeline {
        const vk_device = device.vk_device;

        // Shaders
        const compute_module: *ShaderModule = @ptrCast(@alignCast(desc.compute.module));

        // Pipeline Layout
        var layout: *PipelineLayout = undefined;
        if (desc.layout) |layout_raw| {
            layout = @ptrCast(@alignCast(layout_raw));
            layout.manager.reference();
        } else if (compute_module.air) |air| {
            var layout_desc = utils.DefaultPipelineLayoutDescriptor.init(allocator);
            defer layout_desc.deinit();

            try layout_desc.addFunction(air, .{ .compute = true }, desc.compute.entry_point);
            layout = try PipelineLayout.initDefault(device, layout_desc);
        } else {
            @panic(
                \\Cannot create pipeline descriptor autoamtically.
                \\Please provide it yourself or write the shader in WGSL.
            );
        }
        errdefer layout.manager.release();

        // PSO
        const stage = vk.PipelineShaderStageCreateInfo{
            .stage = .{ .compute_bit = true },
            .module = compute_module.vk_shader_module,
            .p_name = desc.compute.entry_point,
        };

        var vk_pipeline: vk.Pipeline = undefined;
        _ = try vkd.createComputePipelines(vk_device, .null_handle, 1, &[_]vk.ComputePipelineCreateInfo{.{
            .base_pipeline_index = -1,
            .layout = layout.vk_layout,
            .stage = stage,
        }}, null, @ptrCast(&vk_pipeline));

        // Result
        const pipeline = try allocator.create(ComputePipeline);
        pipeline.* = .{
            .device = device,
            .vk_pipeline = vk_pipeline,
            .layout = layout,
        };
        return pipeline;
    }

    pub fn deinit(pipeline: *ComputePipeline) void {
        const vk_device = pipeline.device.vk_device;

        pipeline.layout.manager.release();
        vkd.destroyPipeline(vk_device, pipeline.vk_pipeline, null);
        allocator.destroy(pipeline);
    }

    pub fn getBindGroupLayout(pipeline: *ComputePipeline, group_index: u32) *BindGroupLayout {
        return @ptrCast(pipeline.layout.group_layouts[group_index]);
    }
};

pub const RenderPipeline = struct {
    manager: utils.Manager(RenderPipeline) = .{},
    device: *Device,
    vk_pipeline: vk.Pipeline,
    layout: *PipelineLayout,

    pub fn init(device: *Device, desc: *const sysgpu.RenderPipeline.Descriptor) !*RenderPipeline {
        const vk_device = device.vk_device;

        var stages = std.BoundedArray(vk.PipelineShaderStageCreateInfo, 2){};

        const vertex_module: *ShaderModule = @ptrCast(@alignCast(desc.vertex.module));
        stages.appendAssumeCapacity(.{
            .stage = .{ .vertex_bit = true },
            .module = vertex_module.vk_shader_module,
            .p_name = desc.vertex.entry_point,
            .p_specialization_info = null,
        });

        if (desc.fragment) |frag| {
            const frag_module: *ShaderModule = @ptrCast(@alignCast(frag.module));
            stages.appendAssumeCapacity(.{
                .stage = .{ .fragment_bit = true },
                .module = frag_module.vk_shader_module,
                .p_name = frag.entry_point,
                .p_specialization_info = null,
            });
        }

        var vertex_bindings = try std.ArrayList(vk.VertexInputBindingDescription).initCapacity(allocator, desc.vertex.buffer_count);
        var vertex_attrs = try std.ArrayList(vk.VertexInputAttributeDescription).initCapacity(allocator, desc.vertex.buffer_count);
        defer {
            vertex_bindings.deinit();
            vertex_attrs.deinit();
        }

        for (0..desc.vertex.buffer_count) |i| {
            const buf = desc.vertex.buffers.?[i];
            const input_rate = conv.vulkanVertexInputRate(buf.step_mode);

            vertex_bindings.appendAssumeCapacity(.{
                .binding = @intCast(i),
                .stride = @intCast(buf.array_stride),
                .input_rate = input_rate,
            });

            for (0..buf.attribute_count) |j| {
                const attr = buf.attributes.?[j];
                try vertex_attrs.append(.{
                    .location = attr.shader_location,
                    .binding = @intCast(i),
                    .format = conv.vulkanVertexFormat(attr.format),
                    .offset = @intCast(attr.offset),
                });
            }
        }

        const vertex_input = vk.PipelineVertexInputStateCreateInfo{
            .vertex_binding_description_count = @intCast(vertex_bindings.items.len),
            .p_vertex_binding_descriptions = vertex_bindings.items.ptr,
            .vertex_attribute_description_count = @intCast(vertex_attrs.items.len),
            .p_vertex_attribute_descriptions = vertex_attrs.items.ptr,
        };

        const input_assembly = vk.PipelineInputAssemblyStateCreateInfo{
            .topology = conv.vulkanPrimitiveTopology(desc.primitive.topology),
            .primitive_restart_enable = @intFromBool(desc.primitive.strip_index_format != .undefined),
        };

        const viewport = vk.PipelineViewportStateCreateInfo{
            .viewport_count = 1,
            .p_viewports = &[_]vk.Viewport{.{ .x = 0, .y = 0, .width = 1.0, .height = 1.0, .min_depth = 0.0, .max_depth = 1.0 }},
            .scissor_count = 1,
            .p_scissors = &[_]vk.Rect2D{.{ .offset = .{ .x = 0, .y = 0 }, .extent = .{ .width = 1, .height = 1 } }},
        };

        const rasterization = vk.PipelineRasterizationStateCreateInfo{
            .depth_clamp_enable = vk.FALSE,
            .rasterizer_discard_enable = vk.FALSE,
            .polygon_mode = .fill,
            .cull_mode = conv.vulkanCullMode(desc.primitive.cull_mode),
            .front_face = conv.vulkanFrontFace(desc.primitive.front_face),
            .depth_bias_enable = isDepthBiasEnabled(desc.depth_stencil),
            .depth_bias_constant_factor = conv.vulkanDepthBias(desc.depth_stencil),
            .depth_bias_clamp = conv.vulkanDepthBiasClamp(desc.depth_stencil),
            .depth_bias_slope_factor = conv.vulkanDepthBiasSlopeScale(desc.depth_stencil),
            .line_width = 1,
        };

        const sample_count = conv.vulkanSampleCount(desc.multisample.count);
        const multisample = vk.PipelineMultisampleStateCreateInfo{
            .rasterization_samples = sample_count,
            .sample_shading_enable = vk.FALSE,
            .min_sample_shading = 0,
            .p_sample_mask = &[_]u32{desc.multisample.mask},
            .alpha_to_coverage_enable = @intFromEnum(desc.multisample.alpha_to_coverage_enabled),
            .alpha_to_one_enable = vk.FALSE,
        };

        var layout: *PipelineLayout = undefined;
        if (desc.layout) |layout_raw| {
            layout = @ptrCast(@alignCast(layout_raw));
            layout.manager.reference();
        } else if (vertex_module.air) |vertex_air| {
            var layout_desc = utils.DefaultPipelineLayoutDescriptor.init(allocator);
            defer layout_desc.deinit();

            try layout_desc.addFunction(vertex_air, .{ .vertex = true }, desc.vertex.entry_point);
            if (desc.fragment) |frag| {
                const frag_module: *ShaderModule = @ptrCast(@alignCast(frag.module));
                if (frag_module.air) |frag_air| {
                    try layout_desc.addFunction(frag_air, .{ .fragment = true }, frag.entry_point);
                } else {
                    @panic(
                        \\Cannot create pipeline descriptor autoamtically.
                        \\Please provide it yourself or write the shader in WGSL.
                    );
                }
            }
            layout = try PipelineLayout.initDefault(device, layout_desc);
        } else {
            @panic(
                \\Cannot create pipeline descriptor autoamtically.
                \\Please provide it yourself or write the shader in WGSL.
            );
        }

        errdefer layout.manager.release();

        var blend_attachments: []vk.PipelineColorBlendAttachmentState = &.{};
        defer if (desc.fragment != null) allocator.free(blend_attachments);

        var rp_key = Device.RenderPassKey.init();

        if (desc.fragment) |frag| {
            blend_attachments = try allocator.alloc(vk.PipelineColorBlendAttachmentState, frag.target_count);

            for (0..frag.target_count) |i| {
                const target = frag.targets.?[i];
                const blend = target.blend orelse &sysgpu.BlendState{};
                blend_attachments[i] = .{
                    .blend_enable = if (target.blend != null) vk.TRUE else vk.FALSE,
                    .src_color_blend_factor = conv.vulkanBlendFactor(blend.color.src_factor, true),
                    .dst_color_blend_factor = conv.vulkanBlendFactor(blend.color.dst_factor, true),
                    .color_blend_op = conv.vulkanBlendOp(blend.color.operation),
                    .src_alpha_blend_factor = conv.vulkanBlendFactor(blend.alpha.src_factor, false),
                    .dst_alpha_blend_factor = conv.vulkanBlendFactor(blend.alpha.dst_factor, false),
                    .alpha_blend_op = conv.vulkanBlendOp(blend.alpha.operation),
                    .color_write_mask = .{
                        .r_bit = target.write_mask.red,
                        .g_bit = target.write_mask.green,
                        .b_bit = target.write_mask.blue,
                        .a_bit = target.write_mask.alpha,
                    },
                };
                rp_key.colors.appendAssumeCapacity(.{
                    .format = conv.vulkanFormat(device, target.format),
                    .samples = desc.multisample.count,
                    .load_op = .clear,
                    .store_op = .store,
                    .layout = .color_attachment_optimal,
                    .resolve = null,
                });
            }
        }

        var depth_stencil_state = vk.PipelineDepthStencilStateCreateInfo{
            .depth_test_enable = vk.FALSE,
            .depth_write_enable = vk.FALSE,
            .depth_compare_op = .never,
            .depth_bounds_test_enable = vk.FALSE,
            .stencil_test_enable = vk.FALSE,
            .front = .{
                .fail_op = .keep,
                .depth_fail_op = .keep,
                .pass_op = .keep,
                .compare_op = .never,
                .compare_mask = 0,
                .write_mask = 0,
                .reference = 0,
            },
            .back = .{
                .fail_op = .keep,
                .depth_fail_op = .keep,
                .pass_op = .keep,
                .compare_op = .never,
                .compare_mask = 0,
                .write_mask = 0,
                .reference = 0,
            },
            .min_depth_bounds = 0,
            .max_depth_bounds = 1,
        };

        if (desc.depth_stencil) |ds| {
            depth_stencil_state.depth_test_enable = @intFromBool(ds.depth_compare != .always or ds.depth_write_enabled == .true);
            depth_stencil_state.depth_write_enable = @intFromBool(ds.depth_write_enabled == .true);
            depth_stencil_state.depth_compare_op = conv.vulkanCompareOp(ds.depth_compare);
            depth_stencil_state.stencil_test_enable = @intFromBool(conv.stencilEnable(ds.stencil_front) or conv.stencilEnable(ds.stencil_back));
            depth_stencil_state.front = .{
                .fail_op = conv.vulkanStencilOp(ds.stencil_front.fail_op),
                .depth_fail_op = conv.vulkanStencilOp(ds.stencil_front.depth_fail_op),
                .pass_op = conv.vulkanStencilOp(ds.stencil_front.pass_op),
                .compare_op = conv.vulkanCompareOp(ds.stencil_front.compare),
                .compare_mask = ds.stencil_read_mask,
                .write_mask = ds.stencil_write_mask,
                .reference = 0,
            };
            depth_stencil_state.back = .{
                .fail_op = conv.vulkanStencilOp(ds.stencil_back.fail_op),
                .depth_fail_op = conv.vulkanStencilOp(ds.stencil_back.depth_fail_op),
                .pass_op = conv.vulkanStencilOp(ds.stencil_back.pass_op),
                .compare_op = conv.vulkanCompareOp(ds.stencil_back.compare),
                .compare_mask = ds.stencil_read_mask,
                .write_mask = ds.stencil_write_mask,
                .reference = 0,
            };

            rp_key.depth_stencil = .{
                .format = conv.vulkanFormat(device, ds.format),
                .samples = desc.multisample.count,
                .depth_load_op = .load,
                .depth_store_op = .store,
                .stencil_load_op = .load,
                .stencil_store_op = .store,
                .layout = .depth_stencil_attachment_optimal,
                .read_only = ds.depth_write_enabled == .false and ds.stencil_write_mask == 0,
            };
        }

        const color_blend = vk.PipelineColorBlendStateCreateInfo{
            .logic_op_enable = vk.FALSE,
            .logic_op = .clear,
            .attachment_count = @intCast(blend_attachments.len),
            .p_attachments = blend_attachments.ptr,
            .blend_constants = .{ 0, 0, 0, 0 },
        };

        const dynamic_states = [_]vk.DynamicState{
            .viewport,        .scissor,      .line_width,
            .blend_constants, .depth_bounds, .stencil_reference,
        };
        const dynamic = vk.PipelineDynamicStateCreateInfo{
            .dynamic_state_count = dynamic_states.len,
            .p_dynamic_states = &dynamic_states,
        };

        const render_pass = try device.createRenderPass(rp_key);

        var vk_pipeline: vk.Pipeline = undefined;
        _ = try vkd.createGraphicsPipelines(vk_device, .null_handle, 1, &[_]vk.GraphicsPipelineCreateInfo{.{
            .stage_count = stages.len,
            .p_stages = stages.slice().ptr,
            .p_vertex_input_state = &vertex_input,
            .p_input_assembly_state = &input_assembly,
            .p_viewport_state = &viewport,
            .p_rasterization_state = &rasterization,
            .p_multisample_state = &multisample,
            .p_depth_stencil_state = &depth_stencil_state,
            .p_color_blend_state = &color_blend,
            .p_dynamic_state = &dynamic,
            .layout = layout.vk_layout,
            .render_pass = render_pass,
            .subpass = 0,
            .base_pipeline_index = -1,
        }}, null, @ptrCast(&vk_pipeline));

        const pipeline = try allocator.create(RenderPipeline);
        pipeline.* = .{
            .device = device,
            .vk_pipeline = vk_pipeline,
            .layout = layout,
        };

        return pipeline;
    }

    pub fn deinit(pipeline: *RenderPipeline) void {
        const vk_device = pipeline.device.vk_device;

        pipeline.layout.manager.release();
        vkd.destroyPipeline(vk_device, pipeline.vk_pipeline, null);
        allocator.destroy(pipeline);
    }

    pub fn getBindGroupLayout(pipeline: *RenderPipeline, group_index: u32) *BindGroupLayout {
        return @ptrCast(pipeline.layout.group_layouts[group_index]);
    }

    fn isDepthBiasEnabled(ds: ?*const sysgpu.DepthStencilState) vk.Bool32 {
        if (ds == null) return vk.FALSE;
        return @intFromBool(ds.?.depth_bias != 0 or ds.?.depth_bias_slope_scale != 0);
    }
};

pub const CommandBuffer = struct {
    pub const StreamingResult = struct {
        buffer: *Buffer,
        map: [*]u8,
        offset: u32,
    };

    manager: utils.Manager(CommandBuffer) = .{},
    device: *Device,
    vk_command_buffer: vk.CommandBuffer,
    wait_semaphores: std.ArrayListUnmanaged(vk.Semaphore) = .{},
    wait_dst_stage_masks: std.ArrayListUnmanaged(vk.PipelineStageFlags) = .{},
    reference_tracker: *ReferenceTracker,
    upload_buffer: ?*Buffer = null,
    upload_map: ?[*]u8 = null,
    upload_next_offset: u32 = upload_page_size,

    pub fn init(device: *Device) !*CommandBuffer {
        const vk_device = device.vk_device;

        var vk_command_buffer: vk.CommandBuffer = undefined;
        try vkd.allocateCommandBuffers(vk_device, &.{
            .command_pool = device.cmd_pool,
            .level = .primary,
            .command_buffer_count = 1,
        }, @ptrCast(&vk_command_buffer));
        try vkd.beginCommandBuffer(vk_command_buffer, &.{ .flags = .{ .one_time_submit_bit = true } });

        const reference_tracker = try ReferenceTracker.init(device, vk_command_buffer);
        errdefer reference_tracker.deinit();

        const command_buffer = try allocator.create(CommandBuffer);
        command_buffer.* = .{
            .device = device,
            .vk_command_buffer = vk_command_buffer,
            .reference_tracker = reference_tracker,
        };
        return command_buffer;
    }

    pub fn deinit(command_buffer: *CommandBuffer) void {
        // reference_tracker lifetime is managed externally
        // vk_command_buffer lifetime is managed externally
        command_buffer.wait_dst_stage_masks.deinit(allocator);
        command_buffer.wait_semaphores.deinit(allocator);
        allocator.destroy(command_buffer);
    }

    // Internal
    pub fn upload(command_buffer: *CommandBuffer, size: u64) !StreamingResult {
        if (command_buffer.upload_next_offset + size > upload_page_size) {
            const streaming_manager = &command_buffer.device.streaming_manager;

            std.debug.assert(size <= upload_page_size); // TODO - support large uploads
            const buffer = try streaming_manager.acquire();

            try command_buffer.reference_tracker.referenceUploadPage(buffer);
            command_buffer.upload_buffer = buffer;
            command_buffer.upload_map = buffer.map;
            command_buffer.upload_next_offset = 0;
        }

        const offset = command_buffer.upload_next_offset;
        command_buffer.upload_next_offset = @intCast(utils.alignUp(offset + size, limits.min_uniform_buffer_offset_alignment));
        return StreamingResult{
            .buffer = command_buffer.upload_buffer.?,
            .map = command_buffer.upload_map.? + offset,
            .offset = offset,
        };
    }
};

pub const ReferenceTracker = struct {
    device: *Device,
    vk_command_buffer: vk.CommandBuffer,
    buffers: std.ArrayListUnmanaged(*Buffer) = .{},
    textures: std.ArrayListUnmanaged(*Texture) = .{},
    texture_views: std.ArrayListUnmanaged(*TextureView) = .{},
    bind_groups: std.ArrayListUnmanaged(*BindGroup) = .{},
    compute_pipelines: std.ArrayListUnmanaged(*ComputePipeline) = .{},
    render_pipelines: std.ArrayListUnmanaged(*RenderPipeline) = .{},
    upload_pages: std.ArrayListUnmanaged(*Buffer) = .{},
    framebuffers: std.ArrayListUnmanaged(vk.Framebuffer) = .{},

    pub fn init(device: *Device, vk_command_buffer: vk.CommandBuffer) !*ReferenceTracker {
        const tracker = try allocator.create(ReferenceTracker);
        tracker.* = .{
            .device = device,
            .vk_command_buffer = vk_command_buffer,
        };
        return tracker;
    }

    pub fn deinit(tracker: *ReferenceTracker) void {
        const device = tracker.device;
        const vk_device = tracker.device.vk_device;

        vkd.freeCommandBuffers(vk_device, device.cmd_pool, 1, @ptrCast(&tracker.vk_command_buffer));

        for (tracker.buffers.items) |buffer| {
            buffer.gpu_count -= 1;
            buffer.manager.release();
        }

        for (tracker.textures.items) |texture| {
            texture.manager.release();
        }

        for (tracker.texture_views.items) |texture_view| {
            texture_view.manager.release();
        }

        for (tracker.bind_groups.items) |group| {
            for (group.buffers.items) |access| access.buffer.gpu_count -= 1;
            group.manager.release();
        }

        for (tracker.compute_pipelines.items) |pipeline| {
            pipeline.manager.release();
        }

        for (tracker.render_pipelines.items) |pipeline| {
            pipeline.manager.release();
        }

        for (tracker.upload_pages.items) |buffer| {
            device.streaming_manager.release(buffer);
        }

        for (tracker.framebuffers.items) |fb| vkd.destroyFramebuffer(vk_device, fb, null);

        tracker.buffers.deinit(allocator);
        tracker.textures.deinit(allocator);
        tracker.texture_views.deinit(allocator);
        tracker.bind_groups.deinit(allocator);
        tracker.compute_pipelines.deinit(allocator);
        tracker.render_pipelines.deinit(allocator);
        tracker.upload_pages.deinit(allocator);
        tracker.framebuffers.deinit(allocator);
        allocator.destroy(tracker);
    }

    pub fn referenceBuffer(tracker: *ReferenceTracker, buffer: *Buffer) !void {
        buffer.manager.reference();
        try tracker.buffers.append(allocator, buffer);
    }

    pub fn referenceTexture(tracker: *ReferenceTracker, texture: *Texture) !void {
        texture.manager.reference();
        try tracker.textures.append(allocator, texture);
    }

    pub fn referenceTextureView(tracker: *ReferenceTracker, texture_view: *TextureView) !void {
        texture_view.manager.reference();
        try tracker.texture_views.append(allocator, texture_view);
    }

    pub fn referenceBindGroup(tracker: *ReferenceTracker, group: *BindGroup) !void {
        group.manager.reference();
        try tracker.bind_groups.append(allocator, group);
    }

    pub fn referenceComputePipeline(tracker: *ReferenceTracker, pipeline: *ComputePipeline) !void {
        pipeline.manager.reference();
        try tracker.compute_pipelines.append(allocator, pipeline);
    }

    pub fn referenceRenderPipeline(tracker: *ReferenceTracker, pipeline: *RenderPipeline) !void {
        pipeline.manager.reference();
        try tracker.render_pipelines.append(allocator, pipeline);
    }

    pub fn referenceUploadPage(tracker: *ReferenceTracker, upload_page: *Buffer) !void {
        try tracker.upload_pages.append(allocator, upload_page);
    }

    pub fn submit(tracker: *ReferenceTracker) !void {
        for (tracker.buffers.items) |buffer| {
            buffer.gpu_count += 1;
        }

        for (tracker.bind_groups.items) |group| {
            for (group.buffers.items) |access| access.buffer.gpu_count += 1;
        }
    }
};

pub const CommandEncoder = struct {
    manager: utils.Manager(CommandEncoder) = .{},
    device: *Device,
    command_buffer: *CommandBuffer,
    reference_tracker: *ReferenceTracker,
    state_tracker: StateTracker = .{},

    pub fn init(device: *Device, desc: ?*const sysgpu.CommandEncoder.Descriptor) !*CommandEncoder {
        _ = desc;

        const command_buffer = try CommandBuffer.init(device);

        const cmd_encoder = try allocator.create(CommandEncoder);
        cmd_encoder.* = .{
            .device = device,
            .command_buffer = command_buffer,
            .reference_tracker = command_buffer.reference_tracker,
        };
        return cmd_encoder;
    }

    pub fn deinit(cmd_encoder: *CommandEncoder) void {
        cmd_encoder.state_tracker.deinit();
        cmd_encoder.command_buffer.manager.release();
        allocator.destroy(cmd_encoder);
    }

    pub fn beginComputePass(encoder: *CommandEncoder, desc: *const sysgpu.ComputePassDescriptor) !*ComputePassEncoder {
        return ComputePassEncoder.init(encoder, desc);
    }

    pub fn beginRenderPass(encoder: *CommandEncoder, desc: *const sysgpu.RenderPassDescriptor) !*RenderPassEncoder {
        try encoder.state_tracker.endPass();
        return RenderPassEncoder.init(encoder, desc);
    }

    pub fn copyBufferToBuffer(
        encoder: *CommandEncoder,
        source: *Buffer,
        source_offset: u64,
        destination: *Buffer,
        destination_offset: u64,
        size: u64,
    ) !void {
        const vk_command_buffer = encoder.command_buffer.vk_command_buffer;

        try encoder.reference_tracker.referenceBuffer(source);
        try encoder.reference_tracker.referenceBuffer(destination);
        try encoder.state_tracker.copyFromBuffer(source);
        try encoder.state_tracker.writeToBuffer(destination, .{ .transfer_bit = true }, .{ .transfer_write_bit = true });
        encoder.state_tracker.flush(vk_command_buffer);

        const region = vk.BufferCopy{
            .src_offset = source_offset,
            .dst_offset = destination_offset,
            .size = size,
        };
        vkd.cmdCopyBuffer(vk_command_buffer, source.vk_buffer, destination.vk_buffer, 1, @ptrCast(&region));
    }

    pub fn copyBufferToTexture(
        encoder: *CommandEncoder,
        source: *const sysgpu.ImageCopyBuffer,
        destination: *const sysgpu.ImageCopyTexture,
        copy_size_raw: *const sysgpu.Extent3D,
    ) !void {
        const vk_command_buffer = encoder.command_buffer.vk_command_buffer;
        const source_buffer: *Buffer = @ptrCast(@alignCast(source.buffer));
        const destination_texture: *Texture = @ptrCast(@alignCast(destination.texture));

        try encoder.reference_tracker.referenceBuffer(source_buffer);
        try encoder.reference_tracker.referenceTexture(destination_texture);
        try encoder.state_tracker.copyFromBuffer(source_buffer);
        try encoder.state_tracker.writeToTexture(
            destination_texture,
            .{ .transfer_bit = true },
            .{ .transfer_write_bit = true },
            .transfer_dst_optimal,
        );
        encoder.state_tracker.flush(vk_command_buffer);

        const copy_size = utils.calcExtent(destination_texture.dimension, copy_size_raw.*);
        const destination_origin = utils.calcOrigin(destination_texture.dimension, destination.origin);

        const region = vk.BufferImageCopy{
            .buffer_offset = source.layout.offset,
            .buffer_row_length = source.layout.bytes_per_row / 4, // TODO
            .buffer_image_height = source.layout.rows_per_image,
            .image_subresource = .{
                .aspect_mask = conv.vulkanImageAspectFlags(destination.aspect, destination_texture.format),
                .mip_level = destination.mip_level,
                .base_array_layer = destination_origin.array_slice,
                .layer_count = copy_size.array_count,
            },
            .image_offset = .{
                .x = @intCast(destination_origin.x),
                .y = @intCast(destination_origin.y),
                .z = @intCast(destination_origin.z),
            },
            .image_extent = .{ .width = copy_size.width, .height = copy_size.height, .depth = copy_size.depth },
        };

        vkd.cmdCopyBufferToImage(
            vk_command_buffer,
            source_buffer.vk_buffer,
            destination_texture.image,
            .transfer_dst_optimal,
            1,
            @ptrCast(&region),
        );
    }

    pub fn copyTextureToTexture(
        encoder: *CommandEncoder,
        source: *const sysgpu.ImageCopyTexture,
        destination: *const sysgpu.ImageCopyTexture,
        copy_size_raw: *const sysgpu.Extent3D,
    ) !void {
        const vk_command_buffer = encoder.command_buffer.vk_command_buffer;
        const source_texture: *Texture = @ptrCast(@alignCast(source.texture));
        const destination_texture: *Texture = @ptrCast(@alignCast(destination.texture));

        try encoder.reference_tracker.referenceTexture(source_texture);
        try encoder.reference_tracker.referenceTexture(destination_texture);
        try encoder.state_tracker.copyFromTexture(source_texture);
        try encoder.state_tracker.writeToTexture(
            destination_texture,
            .{ .transfer_bit = true },
            .{ .transfer_write_bit = true },
            .transfer_dst_optimal,
        );
        encoder.state_tracker.flush(vk_command_buffer);

        const copy_size = utils.calcExtent(destination_texture.dimension, copy_size_raw.*);
        const source_origin = utils.calcOrigin(source_texture.dimension, source.origin);
        const destination_origin = utils.calcOrigin(destination_texture.dimension, destination.origin);

        const region = vk.ImageCopy{
            .src_subresource = .{
                .aspect_mask = conv.vulkanImageAspectFlags(source.aspect, source_texture.format),
                .mip_level = source.mip_level,
                .base_array_layer = source_origin.array_slice,
                .layer_count = copy_size.array_count,
            },
            .src_offset = .{
                .x = @intCast(source_origin.x),
                .y = @intCast(source_origin.y),
                .z = @intCast(source_origin.z),
            },
            .dst_subresource = .{
                .aspect_mask = conv.vulkanImageAspectFlags(destination.aspect, destination_texture.format),
                .mip_level = destination.mip_level,
                .base_array_layer = destination_origin.array_slice,
                .layer_count = copy_size.array_count,
            },
            .dst_offset = .{
                .x = @intCast(destination_origin.x),
                .y = @intCast(destination_origin.y),
                .z = @intCast(destination_origin.z),
            },
            .extent = .{ .width = copy_size.width, .height = copy_size.height, .depth = copy_size.depth },
        };

        vkd.cmdCopyImage(
            vk_command_buffer,
            source_texture.image,
            .transfer_src_optimal,
            destination_texture.image,
            .transfer_dst_optimal,
            1,
            @ptrCast(&region),
        );
    }

    pub fn finish(encoder: *CommandEncoder, desc: *const sysgpu.CommandBuffer.Descriptor) !*CommandBuffer {
        _ = desc;
        const vk_command_buffer = encoder.command_buffer.vk_command_buffer;

        try encoder.state_tracker.endPass();
        encoder.state_tracker.flush(vk_command_buffer);

        try vkd.endCommandBuffer(vk_command_buffer);
        return encoder.command_buffer;
    }

    pub fn writeBuffer(encoder: *CommandEncoder, buffer: *Buffer, offset: u64, data: [*]const u8, size: u64) !void {
        const stream = try encoder.command_buffer.upload(size);
        @memcpy(stream.map[0..size], data[0..size]);

        try encoder.copyBufferToBuffer(stream.buffer, stream.offset, buffer, offset, size);
    }

    pub fn writeTexture(
        encoder: *CommandEncoder,
        destination: *const sysgpu.ImageCopyTexture,
        data: [*]const u8,
        data_size: usize,
        data_layout: *const sysgpu.Texture.DataLayout,
        write_size: *const sysgpu.Extent3D,
    ) !void {
        const stream = try encoder.command_buffer.upload(data_size);
        @memcpy(stream.map[0..data_size], data[0..data_size]);

        try encoder.copyBufferToTexture(
            &.{
                .layout = .{
                    .offset = stream.offset,
                    .bytes_per_row = data_layout.bytes_per_row,
                    .rows_per_image = data_layout.rows_per_image,
                },
                .buffer = @ptrCast(stream.buffer),
            },
            destination,
            write_size,
        );
    }
};

pub const StateTracker = struct {
    const BufferState = struct {
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
    };
    const TextureState = struct {
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
        image_layout: vk.ImageLayout,
    };

    device: *Device = undefined,
    written_buffers: std.AutoHashMapUnmanaged(*Buffer, BufferState) = .{},
    copy_buffers: std.AutoHashMapUnmanaged(*Buffer, void) = .{},
    written_textures: std.AutoHashMapUnmanaged(*Texture, TextureState) = .{},
    copy_textures: std.AutoHashMapUnmanaged(*Texture, void) = .{},
    image_barriers: std.ArrayListUnmanaged(vk.ImageMemoryBarrier) = .{},
    src_stage_mask: vk.PipelineStageFlags = .{},
    dst_stage_mask: vk.PipelineStageFlags = .{},
    src_access_mask: vk.AccessFlags = .{},
    dst_access_mask: vk.AccessFlags = .{},

    pub fn init(tracker: *StateTracker, device: *Device) void {
        tracker.device = device;
    }

    pub fn deinit(tracker: *StateTracker) void {
        tracker.written_buffers.deinit(allocator);
        tracker.copy_buffers.deinit(allocator);
        tracker.written_textures.deinit(allocator);
        tracker.copy_textures.deinit(allocator);
        tracker.image_barriers.deinit(allocator);
    }

    pub fn accessBindGroup(
        tracker: *StateTracker,
        group: *BindGroup,
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
        image_layout: vk.ImageLayout,
    ) !void {
        for (group.buffers.items) |access| {
            const buffer = access.buffer;
            if (access.storage) {
                try tracker.writeToBuffer(buffer, stage_mask, access_mask);
            } else {
                try tracker.readFromBuffer(buffer);
            }
        }
        for (group.texture_views.items) |access| {
            const texture = access.texture_view.texture;
            if (access.storage) {
                try tracker.writeToTexture(texture, stage_mask, access_mask, image_layout);
            } else {
                try tracker.readFromTexture(texture);
            }
        }
    }

    pub fn writeToBuffer(
        tracker: *StateTracker,
        buffer: *Buffer,
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
    ) !void {
        if (tracker.written_buffers.fetchRemove(buffer)) |write| {
            // WAW hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(write.value.stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            tracker.src_access_mask = tracker.src_access_mask.merge(write.value.access_mask);
            tracker.dst_access_mask = tracker.dst_access_mask.merge(access_mask);
        } else if (tracker.copy_buffers.fetchRemove(buffer)) |_| {
            // WAR hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(.{ .transfer_bit = true });
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);
        } else {
            // WAR hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(buffer.read_stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);
        }

        try tracker.written_buffers.put(allocator, buffer, .{ .stage_mask = stage_mask, .access_mask = access_mask });
    }

    pub fn writeToTexture(
        tracker: *StateTracker,
        texture: *Texture,
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
        image_layout: vk.ImageLayout,
    ) !void {
        var src_access_mask: vk.AccessFlags = undefined;
        var old_layout: vk.ImageLayout = undefined;
        if (tracker.written_textures.fetchRemove(texture)) |write| {
            // WAW hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(write.value.stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = write.value.access_mask;
            old_layout = write.value.image_layout;
        } else if (tracker.copy_textures.fetchRemove(texture)) |_| {
            // WAR hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(.{ .transfer_bit = true });
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = .{};
            old_layout = .transfer_src_optimal;
        } else {
            // WAR hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(texture.read_stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = .{};
            old_layout = texture.read_image_layout;
        }

        if (old_layout != image_layout) {
            try tracker.addImageBarrier(texture, src_access_mask, access_mask, old_layout, image_layout);
        }

        try tracker.written_textures.put(
            allocator,
            texture,
            .{ .stage_mask = stage_mask, .access_mask = access_mask, .image_layout = image_layout },
        );
    }

    pub fn readFromBufferEx(
        tracker: *StateTracker,
        buffer: *Buffer,
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
    ) !void {
        if (tracker.written_buffers.fetchRemove(buffer)) |write| {
            // RAW hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(write.value.stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            tracker.src_access_mask = tracker.src_access_mask.merge(write.value.access_mask);
            tracker.dst_access_mask = tracker.dst_access_mask.merge(access_mask);
        } else if (tracker.copy_buffers.fetchRemove(buffer)) |_| {
            // RAR hazard - no hazard
        }
    }

    pub fn readFromBuffer(tracker: *StateTracker, buffer: *Buffer) !void {
        try tracker.readFromBufferEx(buffer, buffer.read_stage_mask, buffer.read_access_mask);
    }

    pub fn copyFromBuffer(tracker: *StateTracker, buffer: *Buffer) !void {
        try tracker.readFromBufferEx(buffer, .{ .transfer_bit = true }, .{ .transfer_read_bit = true });
        try tracker.copy_buffers.put(allocator, buffer, {});
    }

    pub fn readFromTextureEx(
        tracker: *StateTracker,
        texture: *Texture,
        stage_mask: vk.PipelineStageFlags,
        access_mask: vk.AccessFlags,
        image_layout: vk.ImageLayout,
    ) !void {
        var src_access_mask: vk.AccessFlags = undefined;
        var old_layout: vk.ImageLayout = undefined;
        if (tracker.written_textures.fetchRemove(texture)) |write| {
            // RAW hazard
            tracker.src_stage_mask = tracker.src_stage_mask.merge(write.value.stage_mask);
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = write.value.access_mask;
            old_layout = write.value.image_layout;
        } else if (tracker.copy_textures.fetchRemove(texture)) |_| {
            // RAR - no execution hazard but needed for layout transition
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = .{};
            old_layout = .transfer_src_optimal;
        } else {
            // RAR - no hazard
            tracker.dst_stage_mask = tracker.dst_stage_mask.merge(stage_mask);

            src_access_mask = .{};
            old_layout = texture.read_image_layout;
        }

        if (old_layout != image_layout) {
            try tracker.addImageBarrier(texture, src_access_mask, access_mask, old_layout, image_layout);
        }
    }

    pub fn readFromTexture(tracker: *StateTracker, texture: *Texture) !void {
        try tracker.readFromTextureEx(texture, texture.read_stage_mask, texture.read_access_mask, texture.read_image_layout);
    }

    pub fn copyFromTexture(tracker: *StateTracker, texture: *Texture) !void {
        try tracker.readFromTextureEx(texture, .{ .transfer_bit = true }, .{ .transfer_read_bit = true }, .transfer_src_optimal);
        try tracker.copy_textures.put(allocator, texture, {});
    }

    pub fn initTexture(tracker: *StateTracker, texture: *Texture) !void {
        const src_access_mask = .{};
        const old_layout = .undefined;
        const access_mask = texture.read_access_mask;
        const image_layout = texture.read_image_layout;
        tracker.dst_stage_mask = tracker.dst_stage_mask.merge(texture.read_stage_mask);

        try tracker.addImageBarrier(texture, src_access_mask, access_mask, old_layout, image_layout);
    }

    pub fn flush(tracker: *StateTracker, vk_command_buffer: vk.CommandBuffer) void {
        if (tracker.src_stage_mask.merge(tracker.dst_stage_mask).toInt() == 0 and
            tracker.image_barriers.items.len == 0)
            return;

        var memory_barriers = std.BoundedArray(vk.MemoryBarrier, 1){};
        if (tracker.src_access_mask.merge(tracker.dst_access_mask).toInt() != 0) {
            memory_barriers.appendAssumeCapacity(.{
                .src_access_mask = tracker.src_access_mask,
                .dst_access_mask = tracker.dst_access_mask,
            });
        }

        // If the synchronization2 feature is not enabled, srcStageMask must not be 0
        const src_stage_mask = if (tracker.src_stage_mask.toInt() != 0)
            tracker.src_stage_mask
        else
            vk.PipelineStageFlags{ .top_of_pipe_bit = true };

        vkd.cmdPipelineBarrier(
            vk_command_buffer,
            src_stage_mask,
            tracker.dst_stage_mask,
            .{},
            memory_barriers.len,
            &memory_barriers.buffer,
            0,
            undefined,
            @intCast(tracker.image_barriers.items.len),
            tracker.image_barriers.items.ptr,
        );

        tracker.src_stage_mask = .{};
        tracker.dst_stage_mask = .{};
        tracker.src_access_mask = .{};
        tracker.dst_access_mask = .{};
        tracker.image_barriers.clearRetainingCapacity();
    }

    pub fn endPass(tracker: *StateTracker) !void {
        {
            var it = tracker.written_buffers.iterator();
            while (it.next()) |entry| {
                const buffer = entry.key_ptr.*;
                const write = entry.value_ptr.*;

                tracker.src_stage_mask = tracker.src_stage_mask.merge(write.stage_mask);
                tracker.dst_stage_mask = tracker.dst_stage_mask.merge(buffer.read_stage_mask);

                tracker.src_access_mask = tracker.src_access_mask.merge(write.access_mask);
                tracker.dst_access_mask = tracker.dst_access_mask.merge(buffer.read_access_mask);
            }
            tracker.written_buffers.clearRetainingCapacity();
        }

        {
            // no hazard
            tracker.copy_buffers.clearRetainingCapacity();
        }

        {
            var it = tracker.written_textures.iterator();
            while (it.next()) |entry| {
                const texture = entry.key_ptr.*;
                const write = entry.value_ptr.*;

                tracker.src_stage_mask = tracker.src_stage_mask.merge(write.stage_mask);
                tracker.dst_stage_mask = tracker.dst_stage_mask.merge(texture.read_stage_mask);

                const src_access_mask = write.access_mask;
                const old_layout = write.image_layout;
                const access_mask = texture.read_access_mask;
                const image_layout = texture.read_image_layout;

                if (old_layout != image_layout) {
                    try tracker.addImageBarrier(texture, src_access_mask, access_mask, old_layout, image_layout);
                }
            }
            tracker.written_textures.clearRetainingCapacity();
        }

        {
            var it = tracker.copy_textures.iterator();
            while (it.next()) |entry| {
                const texture = entry.key_ptr.*;

                const src_access_mask: vk.AccessFlags = .{};
                const old_layout: vk.ImageLayout = .transfer_src_optimal;
                const access_mask = texture.read_access_mask;
                const image_layout = texture.read_image_layout;

                if (old_layout != image_layout) {
                    try tracker.addImageBarrier(texture, src_access_mask, access_mask, old_layout, image_layout);
                }
            }
            tracker.copy_textures.clearRetainingCapacity();
        }
    }

    fn addImageBarrier(
        tracker: *StateTracker,
        texture: *Texture,
        src_access_mask: vk.AccessFlags,
        dst_access_mask: vk.AccessFlags,
        old_layout: vk.ImageLayout,
        new_layout: vk.ImageLayout,
    ) !void {
        const size = utils.calcExtent(texture.dimension, texture.size);

        try tracker.image_barriers.append(allocator, .{
            .src_access_mask = src_access_mask,
            .dst_access_mask = dst_access_mask,
            .old_layout = old_layout,
            .new_layout = new_layout,
            .src_queue_family_index = vk.QUEUE_FAMILY_IGNORED,
            .dst_queue_family_index = vk.QUEUE_FAMILY_IGNORED,
            .image = texture.image,
            .subresource_range = .{
                .aspect_mask = conv.vulkanImageAspectFlags(.all, texture.format),
                .base_mip_level = 0,
                .level_count = texture.mip_level_count,
                .base_array_layer = 0,
                .layer_count = size.array_count,
            },
        });
    }
};

pub const ComputePassEncoder = struct {
    manager: utils.Manager(ComputePassEncoder) = .{},
    vk_command_buffer: vk.CommandBuffer,
    reference_tracker: *ReferenceTracker,
    state_tracker: *StateTracker,
    pipeline: ?*ComputePipeline = null,
    bind_groups: [limits.max_bind_groups]*BindGroup = undefined,

    pub fn init(cmd_encoder: *CommandEncoder, desc: *const sysgpu.ComputePassDescriptor) !*ComputePassEncoder {
        _ = desc;
        const vk_command_buffer = cmd_encoder.command_buffer.vk_command_buffer;

        const encoder = try allocator.create(ComputePassEncoder);
        encoder.* = .{
            .vk_command_buffer = vk_command_buffer,
            .reference_tracker = cmd_encoder.reference_tracker,
            .state_tracker = &cmd_encoder.state_tracker,
        };
        return encoder;
    }

    pub fn deinit(encoder: *ComputePassEncoder) void {
        allocator.destroy(encoder);
    }

    pub fn dispatchWorkgroups(
        encoder: *ComputePassEncoder,
        workgroup_count_x: u32,
        workgroup_count_y: u32,
        workgroup_count_z: u32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        const bind_group_count = encoder.pipeline.?.layout.group_layouts.len;
        for (encoder.bind_groups[0..bind_group_count]) |group| {
            try encoder.state_tracker.accessBindGroup(
                group,
                .{ .compute_shader_bit = true },
                .{ .shader_write_bit = true },
                .general,
            );
        }
        encoder.state_tracker.flush(vk_command_buffer);

        vkd.cmdDispatch(vk_command_buffer, workgroup_count_x, workgroup_count_y, workgroup_count_z);
    }

    pub fn end(encoder: *ComputePassEncoder) void {
        _ = encoder;
    }

    pub fn setBindGroup(
        encoder: *ComputePassEncoder,
        group_index: u32,
        group: *BindGroup,
        dynamic_offset_count: usize,
        dynamic_offsets: ?[*]const u32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceBindGroup(group);
        encoder.bind_groups[group_index] = group;

        vkd.cmdBindDescriptorSets(
            vk_command_buffer,
            .compute,
            encoder.pipeline.?.layout.vk_layout,
            group_index,
            1,
            @ptrCast(&group.desc_set),
            @intCast(dynamic_offset_count),
            if (dynamic_offsets) |offsets| offsets else &[_]u32{},
        );
    }

    pub fn setPipeline(encoder: *ComputePassEncoder, pipeline: *ComputePipeline) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceComputePipeline(pipeline);

        vkd.cmdBindPipeline(
            vk_command_buffer,
            .compute,
            pipeline.vk_pipeline,
        );

        encoder.pipeline = pipeline;
    }
};

pub const RenderPassEncoder = struct {
    manager: utils.Manager(RenderPassEncoder) = .{},
    device: *Device,
    encoder: *CommandEncoder,
    vk_command_buffer: vk.CommandBuffer,
    reference_tracker: *ReferenceTracker,
    render_pass: vk.RenderPass,
    framebuffer: vk.Framebuffer,
    extent: vk.Extent2D,
    pipeline: ?*RenderPipeline = null,

    pub fn init(cmd_encoder: *CommandEncoder, desc: *const sysgpu.RenderPassDescriptor) !*RenderPassEncoder {
        const device = cmd_encoder.device;
        const vk_device = device.vk_device;
        const vk_command_buffer = cmd_encoder.command_buffer.vk_command_buffer;

        const depth_stencil_attachment_count = @intFromBool(desc.depth_stencil_attachment != null);
        const max_attachment_count = 2 * (desc.color_attachment_count + depth_stencil_attachment_count);

        var image_views = try std.ArrayList(vk.ImageView).initCapacity(allocator, max_attachment_count);
        defer image_views.deinit();

        var clear_values = std.ArrayList(vk.ClearValue).init(allocator);
        defer clear_values.deinit();

        var rp_key = Device.RenderPassKey.init();
        var extent: vk.Extent2D = .{ .width = 0, .height = 0 };

        for (0..desc.color_attachment_count) |i| {
            const attach = desc.color_attachments.?[i];
            if (attach.view) |view_raw| {
                const view: *TextureView = @ptrCast(@alignCast(view_raw));
                const resolve_view: ?*TextureView = @ptrCast(@alignCast(attach.resolve_target));

                try cmd_encoder.reference_tracker.referenceTextureView(view);
                if (resolve_view) |v|
                    try cmd_encoder.reference_tracker.referenceTextureView(v);

                if (use_semaphore_wait) {
                    if (view.texture.swapchain) |sc| {
                        try cmd_encoder.command_buffer.wait_semaphores.append(allocator, sc.wait_semaphore);
                        try cmd_encoder.command_buffer.wait_dst_stage_masks.append(allocator, .{ .all_commands_bit = true });
                    }
                }

                image_views.appendAssumeCapacity(view.vk_view);
                if (resolve_view) |rv|
                    image_views.appendAssumeCapacity(rv.vk_view);

                rp_key.colors.appendAssumeCapacity(.{
                    .format = view.vk_format,
                    .samples = view.texture.sample_count,
                    .load_op = attach.load_op,
                    .store_op = attach.store_op,
                    .layout = view.texture.read_image_layout,
                    .resolve = if (resolve_view) |rv| .{
                        .format = rv.vk_format,
                        .layout = rv.texture.read_image_layout,
                    } else null,
                });

                if (attach.load_op == .clear) {
                    try clear_values.append(.{
                        .color = .{
                            .float_32 = [4]f32{
                                @floatCast(attach.clear_value.r),
                                @floatCast(attach.clear_value.g),
                                @floatCast(attach.clear_value.b),
                                @floatCast(attach.clear_value.a),
                            },
                        },
                    });
                }

                extent = view.extent;
            }
        }

        if (desc.depth_stencil_attachment) |attach| {
            const view: *TextureView = @ptrCast(@alignCast(attach.view));

            try cmd_encoder.reference_tracker.referenceTextureView(view);

            image_views.appendAssumeCapacity(view.vk_view);

            rp_key.depth_stencil = .{
                .format = view.vk_format,
                .samples = view.texture.sample_count,
                .depth_load_op = attach.depth_load_op,
                .depth_store_op = attach.depth_store_op,
                .stencil_load_op = attach.stencil_load_op,
                .stencil_store_op = attach.stencil_store_op,
                .layout = view.texture.read_image_layout,
                .read_only = attach.depth_read_only == .true or attach.stencil_read_only == .true,
            };

            if (attach.depth_load_op == .clear or attach.stencil_load_op == .clear) {
                try clear_values.append(.{
                    .depth_stencil = .{
                        .depth = attach.depth_clear_value,
                        .stencil = attach.stencil_clear_value,
                    },
                });
            }

            extent = view.extent;
        }

        const render_pass = try device.createRenderPass(rp_key);
        const framebuffer = try vkd.createFramebuffer(vk_device, &.{
            .render_pass = render_pass,
            .attachment_count = @as(u32, @intCast(image_views.items.len)),
            .p_attachments = image_views.items.ptr,
            .width = extent.width,
            .height = extent.height,
            .layers = 1,
        }, null);
        try cmd_encoder.reference_tracker.framebuffers.append(allocator, framebuffer);

        cmd_encoder.state_tracker.flush(vk_command_buffer);

        const rect = vk.Rect2D{
            .offset = .{ .x = 0, .y = 0 },
            .extent = extent,
        };

        vkd.cmdBeginRenderPass(vk_command_buffer, &vk.RenderPassBeginInfo{
            .render_pass = render_pass,
            .framebuffer = framebuffer,
            .render_area = rect,
            .clear_value_count = @as(u32, @intCast(clear_values.items.len)),
            .p_clear_values = clear_values.items.ptr,
        }, .@"inline");

        vkd.cmdSetViewport(vk_command_buffer, 0, 1, @as(*const [1]vk.Viewport, &vk.Viewport{
            .x = 0,
            .y = @as(f32, @floatFromInt(extent.height)),
            .width = @as(f32, @floatFromInt(extent.width)),
            .height = -@as(f32, @floatFromInt(extent.height)),
            .min_depth = 0,
            .max_depth = 1,
        }));

        vkd.cmdSetScissor(vk_command_buffer, 0, 1, @as(*const [1]vk.Rect2D, &rect));
        vkd.cmdSetStencilReference(vk_command_buffer, .{ .front_bit = true, .back_bit = true }, 0);

        // Result
        const rpe = try allocator.create(RenderPassEncoder);
        errdefer allocator.destroy(rpe);
        rpe.* = .{
            .device = device,
            .encoder = cmd_encoder,
            .vk_command_buffer = vk_command_buffer,
            .reference_tracker = cmd_encoder.reference_tracker,
            .render_pass = render_pass,
            .framebuffer = framebuffer,
            .extent = extent,
        };

        return rpe;
    }

    pub fn deinit(encoder: *RenderPassEncoder) void {
        allocator.destroy(encoder);
    }

    pub fn draw(
        encoder: *RenderPassEncoder,
        vertex_count: u32,
        instance_count: u32,
        first_vertex: u32,
        first_instance: u32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        vkd.cmdDraw(vk_command_buffer, vertex_count, instance_count, first_vertex, first_instance);
    }

    pub fn drawIndexed(
        encoder: *RenderPassEncoder,
        index_count: u32,
        instance_count: u32,
        first_index: u32,
        base_vertex: i32,
        first_instance: u32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        vkd.cmdDrawIndexed(vk_command_buffer, index_count, instance_count, first_index, base_vertex, first_instance);
    }

    pub fn setBindGroup(
        encoder: *RenderPassEncoder,
        group_index: u32,
        group: *BindGroup,
        dynamic_offset_count: usize,
        dynamic_offsets: ?[*]const u32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceBindGroup(group);

        vkd.cmdBindDescriptorSets(
            vk_command_buffer,
            .graphics,
            encoder.pipeline.?.layout.vk_layout,
            group_index,
            1,
            @ptrCast(&group.desc_set),
            @intCast(dynamic_offset_count),
            if (dynamic_offsets) |offsets| offsets else &[_]u32{},
        );
    }

    pub fn end(encoder: *RenderPassEncoder) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        vkd.cmdEndRenderPass(vk_command_buffer);
    }

    pub fn setIndexBuffer(
        encoder: *RenderPassEncoder,
        buffer: *Buffer,
        format: sysgpu.IndexFormat,
        offset: u64,
        size: u64,
    ) !void {
        _ = size;
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceBuffer(buffer);

        vkd.cmdBindIndexBuffer(vk_command_buffer, buffer.vk_buffer, offset, conv.vulkanIndexType(format));
    }

    pub fn setPipeline(encoder: *RenderPassEncoder, pipeline: *RenderPipeline) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceRenderPipeline(pipeline);

        vkd.cmdBindPipeline(vk_command_buffer, .graphics, pipeline.vk_pipeline);

        encoder.pipeline = pipeline;
    }

    pub fn setScissorRect(encoder: *RenderPassEncoder, x: u32, y: u32, width: u32, height: u32) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        const rect = vk.Rect2D{
            .offset = .{ .x = @intCast(x), .y = @intCast(y) },
            .extent = .{ .width = width, .height = height },
        };

        vkd.cmdSetScissor(vk_command_buffer, 0, 1, @as(*const [1]vk.Rect2D, &rect));
    }

    pub fn setVertexBuffer(encoder: *RenderPassEncoder, slot: u32, buffer: *Buffer, offset: u64, size: u64) !void {
        _ = size;
        const vk_command_buffer = encoder.vk_command_buffer;

        try encoder.reference_tracker.referenceBuffer(buffer);

        vkd.cmdBindVertexBuffers(vk_command_buffer, slot, 1, @ptrCast(&.{buffer.vk_buffer}), @ptrCast(&offset));
    }

    pub fn setViewport(
        encoder: *RenderPassEncoder,
        x: f32,
        y: f32,
        width: f32,
        height: f32,
        min_depth: f32,
        max_depth: f32,
    ) !void {
        const vk_command_buffer = encoder.vk_command_buffer;

        vkd.cmdSetViewport(vk_command_buffer, 0, 1, @as(*const [1]vk.Viewport, &vk.Viewport{
            .x = x,
            .y = @as(f32, @floatFromInt(encoder.extent.height)) - y,
            .width = width,
            .height = -height,
            .min_depth = min_depth,
            .max_depth = max_depth,
        }));
    }
};

pub const Queue = struct {
    manager: utils.Manager(Queue) = .{},
    device: *Device,
    vk_queue: vk.Queue,
    command_buffers: std.ArrayListUnmanaged(*CommandBuffer) = .{},
    wait_semaphores: std.ArrayListUnmanaged(vk.Semaphore) = .{},
    wait_dst_stage_masks: std.ArrayListUnmanaged(vk.PipelineStageFlags) = .{},
    signal_semaphores: std.ArrayListUnmanaged(vk.Semaphore) = .{},
    command_encoder: ?*CommandEncoder = null,

    pub fn init(device: *Device) !Queue {
        const vk_device = device.vk_device;

        const vk_queue = vkd.getDeviceQueue(vk_device, device.adapter.queue_family, 0);

        return .{
            .device = device,
            .vk_queue = vk_queue,
        };
    }

    pub fn deinit(queue: *Queue) void {
        if (queue.command_encoder) |command_encoder| command_encoder.manager.release();
        queue.wait_dst_stage_masks.deinit(allocator);
        queue.wait_semaphores.deinit(allocator);
        queue.signal_semaphores.deinit(allocator);
        queue.command_buffers.deinit(allocator);
    }

    pub fn submit(queue: *Queue, commands: []const *CommandBuffer) !void {
        if (queue.command_encoder) |command_encoder| {
            const command_buffer = try command_encoder.finish(&.{});
            command_buffer.manager.reference(); // handled in main.zig
            defer command_buffer.manager.release();

            command_buffer.manager.reference();
            try queue.command_buffers.append(allocator, command_buffer);
            try command_buffer.reference_tracker.submit();

            command_encoder.manager.release();
            queue.command_encoder = null;
        }

        for (commands) |command_buffer| {
            command_buffer.manager.reference();
            try queue.command_buffers.append(allocator, command_buffer);
            try command_buffer.reference_tracker.submit();

            try queue.wait_dst_stage_masks.appendSlice(allocator, command_buffer.wait_dst_stage_masks.items);
            try queue.wait_semaphores.appendSlice(allocator, command_buffer.wait_semaphores.items);
        }
    }

    pub fn flush(queue: *Queue) !void {
        if (queue.command_buffers.items.len == 0 and
            queue.signal_semaphores.items.len == 0)
            return;

        const vk_queue = queue.vk_queue;

        var submit_object = try SubmitObject.init(queue.device);
        var vk_command_buffers = try std.ArrayListUnmanaged(vk.CommandBuffer).initCapacity(
            allocator,
            queue.command_buffers.items.len,
        );
        defer vk_command_buffers.deinit(allocator);

        for (queue.command_buffers.items) |command_buffer| {
            vk_command_buffers.appendAssumeCapacity(command_buffer.vk_command_buffer);
            try submit_object.reference_trackers.append(allocator, command_buffer.reference_tracker);
            command_buffer.manager.release();
        }
        queue.command_buffers.clearRetainingCapacity();

        const submitInfo = vk.SubmitInfo{
            .command_buffer_count = @intCast(vk_command_buffers.items.len),
            .p_command_buffers = vk_command_buffers.items.ptr,
            .wait_semaphore_count = @intCast(queue.wait_semaphores.items.len),
            .p_wait_semaphores = queue.wait_semaphores.items.ptr,
            .p_wait_dst_stage_mask = queue.wait_dst_stage_masks.items.ptr,
            .signal_semaphore_count = @intCast(queue.signal_semaphores.items.len),
            .p_signal_semaphores = queue.signal_semaphores.items.ptr,
        };

        try vkd.queueSubmit(vk_queue, 1, @ptrCast(&submitInfo), submit_object.fence);

        queue.wait_semaphores.clearRetainingCapacity();
        queue.wait_dst_stage_masks.clearRetainingCapacity();
        queue.signal_semaphores.clearRetainingCapacity();

        try queue.device.submit_objects.append(allocator, submit_object);
    }

    pub fn writeBuffer(queue: *Queue, buffer: *Buffer, offset: u64, data: [*]const u8, size: u64) !void {
        const encoder = try queue.getCommandEncoder();
        try encoder.writeBuffer(buffer, offset, data, size);
    }

    pub fn writeTexture(
        queue: *Queue,
        destination: *const sysgpu.ImageCopyTexture,
        data: [*]const u8,
        data_size: usize,
        data_layout: *const sysgpu.Texture.DataLayout,
        write_size: *const sysgpu.Extent3D,
    ) !void {
        const encoder = try queue.getCommandEncoder();
        try encoder.writeTexture(destination, data, data_size, data_layout, write_size);
    }

    // Private
    fn getCommandEncoder(queue: *Queue) !*CommandEncoder {
        if (queue.command_encoder) |command_encoder| return command_encoder;

        const command_encoder = try CommandEncoder.init(queue.device, &.{});
        queue.command_encoder = command_encoder;
        return command_encoder;
    }
};

const MemoryAllocator = struct {
    info: vk.PhysicalDeviceMemoryProperties,

    const MemoryKind = enum {
        lazily_allocated,
        linear,
        linear_read_mappable,
        linear_write_mappable,
    };

    fn init(physical_device: vk.PhysicalDevice) MemoryAllocator {
        const mem_info = vki.getPhysicalDeviceMemoryProperties(physical_device);
        return .{ .info = mem_info };
    }

    fn findBestAllocator(
        mem_alloc: *MemoryAllocator,
        requirements: vk.MemoryRequirements,
        mem_kind: MemoryKind,
    ) ?u32 {
        const mem_types = mem_alloc.info.memory_types[0..mem_alloc.info.memory_type_count];
        const mem_heaps = mem_alloc.info.memory_heaps[0..mem_alloc.info.memory_heap_count];

        var best_type: ?u32 = null;
        for (mem_types, 0..) |mem_type, i| {
            if (requirements.memory_type_bits & (@as(u32, @intCast(1)) << @intCast(i)) == 0) continue;

            const flags = mem_type.property_flags;
            const heap_size = mem_heaps[mem_type.heap_index].size;
            const candidate = switch (mem_kind) {
                .lazily_allocated => flags.lazily_allocated_bit,
                .linear_write_mappable => flags.host_visible_bit and flags.host_coherent_bit and !flags.device_coherent_bit_amd,
                .linear_read_mappable => blk: {
                    if (flags.host_visible_bit and flags.host_coherent_bit and !flags.device_coherent_bit_amd) {
                        if (best_type) |best| {
                            if (mem_types[best].property_flags.host_cached_bit) {
                                if (flags.host_cached_bit) {
                                    const best_heap_size = mem_heaps[mem_types[best].heap_index].size;
                                    if (heap_size > best_heap_size) {
                                        break :blk true;
                                    }
                                }

                                break :blk false;
                            }
                        }

                        break :blk true;
                    }

                    break :blk false;
                },
                .linear => blk: {
                    if (best_type) |best| {
                        if (mem_types[best].property_flags.device_local_bit) {
                            if (flags.device_local_bit and !flags.device_coherent_bit_amd) {
                                const best_heap_size = mem_heaps[mem_types[best].heap_index].size;
                                if (heap_size > best_heap_size or flags.host_visible_bit) {
                                    break :blk true;
                                }
                            }

                            break :blk false;
                        }
                    }

                    break :blk true;
                },
            };

            if (candidate) best_type = @intCast(i);
        }

        return best_type;
    }
};

test "reference declarations" {
    std.testing.refAllDeclsRecursive(@This());
}