allemang.d/zig-experiments
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

MAJOR restructure

Browse Source
This commit is contained in:
David Allemang
2024-04-05 23:47:30 -04:00
parent d24d49b3a5
commit 7b01cfc330
8 changed files with 1136 additions and 563 deletions
Download Patch File Download Diff File Expand all files Collapse all files

370
src/main.zig
View File

@@ -50,113 +50,104 @@ const vertices = [_]Vertex{
const indices = [_]Index{ 4, 5, 6, 6, 5, 7 };
const ChainImage = struct {
image: vk.Image = .null_handle,
view: vk.ImageView = .null_handle,
cmdbuf: vk.CommandBuffer = .null_handle,
fence: vk.Fence = .null_handle,
image_available: vk.Semaphore = .null_handle,
render_finished: vk.Semaphore = .null_handle,
};
// pub fn create_swapchain(
// chain: *std.MultiArrayList(ChainImage),
// swapchain: *vk.SwapchainKHR,
// ally: std.mem.Allocator,
// pdev: vk.PhysicalDevice,
// vki: gfx.InstanceDispatch,
// window: *c.GLFWwindow,
// dev: vk.Device,
// vkd: Device.Wrapper,
// pool: vk.CommandPool,
// surface: vk.SurfaceKHR,
// swap_image_count: u32,
// format: vk.SurfaceFormatKHR,
// present_mode: vk.PresentModeKHR,
// ) !vk.Extent2D {
// const extent = try gfx.find_swap_extent(pdev, vki, surface, window);
//
// const prev_swapchain = swapchain.*;
// swapchain.* = try vkd.createSwapchainKHR(dev, &.{
// .surface = surface,
// .min_image_count = swap_image_count,
// .image_format = format.format,
// .image_color_space = format.color_space,
// .image_extent = extent,
// .image_array_layers = 1,
// .image_usage = .{ .color_attachment_bit = true },
// .image_sharing_mode = .exclusive,
// .pre_transform = .{ .identity_bit_khr = true },
// .composite_alpha = .{ .opaque_bit_khr = true },
// .present_mode = present_mode,
// .clipped = vk.TRUE,
// .old_swapchain = prev_swapchain,
// }, null);
// vkd.destroySwapchainKHR(dev, prev_swapchain, null);
//
// var image_count: u32 = undefined;
// _ = try vkd.getSwapchainImagesKHR(dev, swapchain.*, &image_count, null);
// try chain.resize(ally, image_count);
// _ = try vkd.getSwapchainImagesKHR(dev, swapchain.*, &image_count, chain.items(.image).ptr);
//
// // memset so that deinit_chain will succeed with .null_handle if error part-way through a loop.
// @memset(chain.items(.view), .null_handle);
// @memset(chain.items(.cmdbuf), .null_handle);
// @memset(chain.items(.fence), .null_handle);
// @memset(chain.items(.image_available), .null_handle);
// errdefer deinit_chain(chain.*, dev, vkd, pool);
//
// for (chain.items(.image), chain.items(.view)) |image, *view| {
// view.* = try vkd.createImageView(dev, &.{
// .image = image,
// .view_type = .@"2d",
// .format = format.format,
// .components = .{ .r = .identity, .g = .identity, .b = .identity, .a = .identity },
// .subresource_range = .{
// .aspect_mask = .{ .color_bit = true },
// .base_mip_level = 0,
// .level_count = 1,
// .base_array_layer = 0,
// .layer_count = 1,
// },
// }, null);
// }
//
// for (chain.items(.fence)) |*fence| {
// fence.* = try vkd.createFence(dev, &.{ .flags = .{ .signaled_bit = true } }, null);
// }
//
// for (chain.items(.image_available)) |*sem| {
// sem.* = try vkd.createSemaphore(dev, &.{}, null);
// }
//
// for (chain.items(.render_finished)) |*sem| {
// sem.* = try vkd.createSemaphore(dev, &.{}, null);
// }
//
// try vkd.allocateCommandBuffers(dev, &.{
// .command_buffer_count = @intCast(chain.len),
// .command_pool = pool,
// .level = .primary,
// }, chain.items(.cmdbuf).ptr);
//
// return extent;
// }
//
// pub fn deinit_chain(
// chain: std.MultiArrayList(ChainImage),
// dev: vk.Device,
// vkd: Device.Wrapper,
// pool: vk.CommandPool,
// ) void {
// vkd.freeCommandBuffers(dev, pool, @intCast(chain.len), chain.items(.cmdbuf).ptr);
// for (chain.items(.view)) |view| vkd.destroyImageView(dev, view, null);
// for (chain.items(.fence)) |fence| vkd.destroyFence(dev, fence, null);
// for (chain.items(.image_available)) |sem| vkd.destroySemaphore(dev, sem, null);
// for (chain.items(.render_finished)) |sem| vkd.destroySemaphore(dev, sem, null);
// }
pub fn create_swapchain(
chain: *std.MultiArrayList(ChainImage),
swapchain: *vk.SwapchainKHR,
ally: std.mem.Allocator,
pdev: vk.PhysicalDevice,
vki: gfx.InstanceDispatch,
window: *c.GLFWwindow,
dev: vk.Device,
vkd: gfx.DeviceDispatch,
pool: vk.CommandPool,
surface: vk.SurfaceKHR,
swap_image_count: u32,
format: vk.SurfaceFormatKHR,
present_mode: vk.PresentModeKHR,
) !vk.Extent2D {
const extent = try gfx.find_swap_extent(pdev, vki, surface, window);
const prev_swapchain = swapchain.*;
swapchain.* = try vkd.createSwapchainKHR(dev, &.{
.surface = surface,
.min_image_count = swap_image_count,
.image_format = format.format,
.image_color_space = format.color_space,
.image_extent = extent,
.image_array_layers = 1,
.image_usage = .{ .color_attachment_bit = true },
.image_sharing_mode = .exclusive,
.pre_transform = .{ .identity_bit_khr = true },
.composite_alpha = .{ .opaque_bit_khr = true },
.present_mode = present_mode,
.clipped = vk.TRUE,
.old_swapchain = prev_swapchain,
}, null);
vkd.destroySwapchainKHR(dev, prev_swapchain, null);
var image_count: u32 = undefined;
_ = try vkd.getSwapchainImagesKHR(dev, swapchain.*, &image_count, null);
try chain.resize(ally, image_count);
_ = try vkd.getSwapchainImagesKHR(dev, swapchain.*, &image_count, chain.items(.image).ptr);
// memset so that deinit_chain will succeed with .null_handle if error part-way through a loop.
@memset(chain.items(.view), .null_handle);
@memset(chain.items(.cmdbuf), .null_handle);
@memset(chain.items(.fence), .null_handle);
@memset(chain.items(.image_available), .null_handle);
errdefer deinit_chain(chain.*, dev, vkd, pool);
for (chain.items(.image), chain.items(.view)) |image, *view| {
view.* = try vkd.createImageView(dev, &.{
.image = image,
.view_type = .@"2d",
.format = format.format,
.components = .{ .r = .identity, .g = .identity, .b = .identity, .a = .identity },
.subresource_range = .{
.aspect_mask = .{ .color_bit = true },
.base_mip_level = 0,
.level_count = 1,
.base_array_layer = 0,
.layer_count = 1,
},
}, null);
}
for (chain.items(.fence)) |*fence| {
fence.* = try vkd.createFence(dev, &.{ .flags = .{ .signaled_bit = true } }, null);
}
for (chain.items(.image_available)) |*sem| {
sem.* = try vkd.createSemaphore(dev, &.{}, null);
}
for (chain.items(.render_finished)) |*sem| {
sem.* = try vkd.createSemaphore(dev, &.{}, null);
}
try vkd.allocateCommandBuffers(dev, &.{
.command_buffer_count = @intCast(chain.len),
.command_pool = pool,
.level = .primary,
}, chain.items(.cmdbuf).ptr);
return extent;
}
pub fn deinit_chain(
chain: std.MultiArrayList(ChainImage),
dev: vk.Device,
vkd: gfx.DeviceDispatch,
pool: vk.CommandPool,
) void {
vkd.freeCommandBuffers(dev, pool, @intCast(chain.len), chain.items(.cmdbuf).ptr);
for (chain.items(.view)) |view| vkd.destroyImageView(dev, view, null);
for (chain.items(.fence)) |fence| vkd.destroyFence(dev, fence, null);
for (chain.items(.image_available)) |sem| vkd.destroySemaphore(dev, sem, null);
for (chain.items(.render_finished)) |sem| vkd.destroySemaphore(dev, sem, null);
}
fn render(dev: vk.Device, vkd: gfx.DeviceDispatch, swapchain: vk.SwapchainKHR, frame: ChainImage, queue: vk.Queue) !void {
fn render(dev: vk.Device, vkd: Device.Wrapper, swapchain: vk.SwapchainKHR, frame: Swapchain.ChainImage, queue: vk.Queue) !void {
_ = try vkd.waitForFences(dev, 1, @ptrCast(&frame.fence), vk.TRUE, std.math.maxInt(u64));
const result = try vkd.acquireNextImageKHR(
@@ -189,130 +180,86 @@ fn render(dev: vk.Device, vkd: gfx.DeviceDispatch, swapchain: vk.SwapchainKHR, f
});
}
const Base = @import("gfx/Base.zig");
const Instance = @import("gfx/Instance.zig");
const Context = @import("gfx/Context.zig");
const Window = @import("gfx/Window.zig");
const Device = @import("gfx/Device.zig");
const Swapchain = @import("gfx/Swapchain.zig");
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
defer _ = gpa.deinit();
const ally = gpa.allocator();
if (c.glfwInit() != c.GLFW_TRUE) return error.GlfwInitFailed;
defer c.glfwTerminate();
const base = try Base.init();
defer base.deinit();
if (c.glfwVulkanSupported() != c.GLFW_TRUE) {
std.log.err("GLFW could not find libvulkan", .{});
return error.NoVulkan;
}
const inst = try Instance.init(&base);
defer inst.deinit();
var extent = vk.Extent2D{ .width = 800, .height = 600 };
const win = try Window.init(&inst, "zig-glfw-vulkan", .{ .width = 800, .height = 600 });
defer win.deinit();
const window = try gfx.create_window(extent, app_name);
defer c.glfwDestroyWindow(window);
const dev = try Device.init(ally, &inst, &win);
defer dev.deinit();
const vkb = try gfx.BaseDispatch.load(c.glfwGetInstanceProcAddress);
var sc = try Swapchain.create(ally, &dev);
defer sc.deinit();
const instance, const vki, const messenger = try gfx.create_instance(vkb, app_name);
defer vki.destroyInstance(instance, null);
defer if (gfx.use_debug_messenger)
vki.destroyDebugUtilsMessengerEXT(instance, messenger, null);
const device_local = gfx.VkAllocator.init(dev.pdev, inst.vki);
const surface = try gfx.create_surface(instance, window);
defer vki.destroySurfaceKHR(instance, surface, null);
const pdev: vk.PhysicalDevice, const dev: vk.Device, const vkd: gfx.DeviceDispatch, const family: u32 =
try gfx.create_device(ally, instance, surface, vki);
defer vkd.destroyDevice(dev, null);
const queue = vkd.getDeviceQueue(dev, family, 0);
const pool = try vkd.createCommandPool(dev, &.{
.queue_family_index = family,
}, null);
defer vkd.destroyCommandPool(dev, pool, null);
const preferred_format: vk.SurfaceFormatKHR = .{
.format = .b8g8r8a8_srgb,
.color_space = .srgb_nonlinear_khr,
};
const format = try gfx.find_surface_format(pdev, vki, surface, preferred_format);
const present_mode = try gfx.find_present_mode(pdev, vki, surface, .mailbox_khr);
const swap_image_count = try gfx.find_swap_image_count(pdev, vki, surface);
var swapchain: vk.SwapchainKHR = .null_handle;
defer vkd.destroySwapchainKHR(dev, swapchain, null);
var chain = std.MultiArrayList(ChainImage){};
defer chain.deinit(ally);
defer deinit_chain(chain, dev, vkd, pool);
const device_local = gfx.VkAllocator.init(pdev, vki);
const pipeline_layout = try vkd.createPipelineLayout(dev, &.{
const pipeline_layout = try dev.vkd.createPipelineLayout(dev.dev, &.{
.flags = .{},
.set_layout_count = 0,
.p_set_layouts = undefined,
.push_constant_range_count = 0,
.p_push_constant_ranges = undefined,
}, null);
defer vkd.destroyPipelineLayout(dev, pipeline_layout, null);
defer dev.vkd.destroyPipelineLayout(dev.dev, pipeline_layout, null);
const pipeline = try createPipeline(dev, pipeline_layout, format, vkd);
defer vkd.destroyPipeline(dev, pipeline, null);
const pipeline = try createPipeline(dev.dev, pipeline_layout, dev.format, dev.vkd);
defer dev.vkd.destroyPipeline(dev.dev, pipeline, null);
const vertex_buffer = try vkd.createBuffer(dev, &.{
const vertex_buffer = try dev.vkd.createBuffer(dev.dev, &.{
.size = @sizeOf(@TypeOf(vertices)),
.usage = .{ .transfer_dst_bit = true, .vertex_buffer_bit = true },
.sharing_mode = .exclusive,
}, null);
defer vkd.destroyBuffer(dev, vertex_buffer, null);
const vertex_mem_reqs = vkd.getBufferMemoryRequirements(dev, vertex_buffer);
// const vertex_memory = try gfx.allocate(pdev, vki, dev, vkd, vertex_mem_reqs, .{ .device_local_bit = true });
const vertex_memory = try device_local.alloc(dev, vkd, vertex_mem_reqs, .{ .device_local_bit = true });
defer vkd.freeMemory(dev, vertex_memory, null);
try vkd.bindBufferMemory(dev, vertex_buffer, vertex_memory, 0);
defer dev.vkd.destroyBuffer(dev.dev, vertex_buffer, null);
const vertex_mem_reqs = dev.vkd.getBufferMemoryRequirements(dev.dev, vertex_buffer);
// const vertex_memory = try gfx.allocate(pdev, vki, dev, dev.vkd, vertex_mem_reqs, .{ .device_local_bit = true });
const vertex_memory = try device_local.alloc(dev.dev, dev.vkd, vertex_mem_reqs, .{ .device_local_bit = true });
defer dev.vkd.freeMemory(dev.dev, vertex_memory, null);
try dev.vkd.bindBufferMemory(dev.dev, vertex_buffer, vertex_memory, 0);
try gfx.uploadData(Vertex, pdev, vki, dev, vkd, queue, pool, vertex_buffer, &vertices);
try gfx.uploadData(Vertex, dev.pdev, inst.vki, dev.dev, dev.vkd, dev.queue, dev.pool, vertex_buffer, &vertices);
const index_buffer = try vkd.createBuffer(dev, &.{
const index_buffer = try dev.vkd.createBuffer(dev.dev, &.{
.size = @sizeOf(@TypeOf(indices)),
.usage = .{ .transfer_dst_bit = true, .index_buffer_bit = true },
.sharing_mode = .exclusive,
}, null);
defer vkd.destroyBuffer(dev, index_buffer, null);
const index_mem_reqs = vkd.getBufferMemoryRequirements(dev, index_buffer);
// const index_memory = try gfx.allocate(pdev, vki, dev, vkd, index_mem_reqs, .{ .device_local_bit = true });
const index_memory = try device_local.alloc(dev, vkd, index_mem_reqs, .{ .device_local_bit = true });
defer vkd.freeMemory(dev, index_memory, null);
try vkd.bindBufferMemory(dev, index_buffer, index_memory, 0);
defer dev.vkd.destroyBuffer(dev.dev, index_buffer, null);
const index_mem_reqs = dev.vkd.getBufferMemoryRequirements(dev.dev, index_buffer);
// const index_memory = try gfx.allocate(pdev, vki, dev, dev.vkd, index_mem_reqs, .{ .device_local_bit = true });
const index_memory = try device_local.alloc(dev.dev, dev.vkd, index_mem_reqs, .{ .device_local_bit = true });
defer dev.vkd.freeMemory(dev.dev, index_memory, null);
try dev.vkd.bindBufferMemory(dev.dev, index_buffer, index_memory, 0);
try gfx.uploadData(Index, pdev, vki, dev, vkd, queue, pool, index_buffer, &indices);
try gfx.uploadData(Index, dev.pdev, inst.vki, dev.dev, dev.vkd, dev.queue, dev.pool, index_buffer, &indices);
extent = try create_swapchain(
&chain,
&swapchain,
ally,
pdev,
vki,
window,
dev,
vkd,
pool,
surface,
swap_image_count,
format,
present_mode,
);
for (chain.items(.image), chain.items(.view), chain.items(.cmdbuf)) |image, view, cmdbuf| {
try record_cmdbuf(cmdbuf, vkd, image, view, extent, pipeline, vertex_buffer, index_buffer);
try sc.init();
for (sc.chain.items(.image), sc.chain.items(.view), sc.chain.items(.cmdbuf)) |image, view, cmdbuf| {
try record_cmdbuf(cmdbuf, dev.vkd, image, view, sc.extent, pipeline, vertex_buffer, index_buffer);
}
var index: u32 = 0;
while (c.glfwWindowShouldClose(window) == c.GLFW_FALSE) {
while (c.glfwWindowShouldClose(win.ref) == c.GLFW_FALSE) {
var w: c_int = undefined;
var h: c_int = undefined;
c.glfwGetFramebufferSize(window, &w, &h);
c.glfwGetFramebufferSize(win.ref, &w, &h);
// Don't present or resize swapchain while the window is minimized
if (w == 0 or h == 0) {
@@ -320,32 +267,15 @@ pub fn main() !void {
continue;
}
const frame: ChainImage = chain.get(index);
const frame = sc.chain.get(index);
render(dev, vkd, swapchain, frame, queue) catch |err| switch (err) {
render(dev.dev, dev.vkd, sc.ref, frame, dev.queue) catch |err| switch (err) {
error.OutOfDateKHR => {
try vkd.deviceWaitIdle(dev);
try dev.vkd.deviceWaitIdle(dev.dev);
deinit_chain(chain, dev, vkd, pool);
extent = try create_swapchain(
&chain,
&swapchain,
ally,
pdev,
vki,
window,
dev,
vkd,
pool,
surface,
swap_image_count,
format,
present_mode,
);
for (chain.items(.image), chain.items(.view), chain.items(.cmdbuf)) |image, view, cmdbuf| {
try record_cmdbuf(cmdbuf, vkd, image, view, extent, pipeline, vertex_buffer, index_buffer);
try sc.init();
for (sc.chain.items(.image), sc.chain.items(.view), sc.chain.items(.cmdbuf)) |image, view, cmdbuf| {
try record_cmdbuf(cmdbuf, dev.vkd, image, view, sc.extent, pipeline, vertex_buffer, index_buffer);
}
index = 0;
@@ -357,15 +287,15 @@ pub fn main() !void {
c.glfwPollEvents();
index = @intCast((index + 1) % chain.len);
index = @intCast((index + 1) % sc.chain.len);
}
try vkd.deviceWaitIdle(dev);
try dev.vkd.deviceWaitIdle(dev.dev);
}
fn record_cmdbuf(
cmdbuf: vk.CommandBuffer,
vkd: gfx.DeviceDispatch,
vkd: Device.Wrapper,
image: vk.Image,
view: vk.ImageView,
extent: vk.Extent2D,
@@ -486,7 +416,7 @@ fn record_cmdbuf(
try vkd.endCommandBuffer(cmdbuf);
}
fn createPipeline(dev: vk.Device, layout: vk.PipelineLayout, format: vk.SurfaceFormatKHR, vkd: gfx.DeviceDispatch) !vk.Pipeline {
fn createPipeline(dev: vk.Device, layout: vk.PipelineLayout, format: vk.SurfaceFormatKHR, vkd: Device.Wrapper) !vk.Pipeline {
const vert = try vkd.createShaderModule(dev, &.{
.code_size = shaders.triangle_vert.len,
.p_code = @as([*]const u32, @ptrCast(&shaders.triangle_vert)),