diff options
Diffstat (limited to 'src/render/vulkan.zig')
| -rw-r--r-- | src/render/vulkan.zig | 1151 |
1 files changed, 0 insertions, 1151 deletions
diff --git a/src/render/vulkan.zig b/src/render/vulkan.zig deleted file mode 100644 index bd0ca29..0000000 --- a/src/render/vulkan.zig +++ /dev/null @@ -1,1151 +0,0 @@ -const std = @import("std"); -const c = @import("../c.zig"); -const window = @import("./window.zig"); -const mesh = @import("./mesh.zig"); -const math = @import("../math.zig"); -const Allocator = std.mem.Allocator; - -const builtin = @import("builtin"); -const debug = (builtin.mode == .Debug); - -const Uniform = struct { - proj: math.Matrix, - view: math.Matrix, - model: math.Matrix, -}; - -const validation_layers: []const [*c]const u8 = if (!debug) &[0][*c]const u8{} else &[_][*c]const u8{ - "VK_LAYER_KHRONOS_validation", -}; - -const device_extensions: []const [*c]const u8 = &[_][*c]const u8{ - c.VK_KHR_SWAPCHAIN_EXTENSION_NAME, -}; - -pub const Error = error{ - out_of_host_memory, - out_of_device_memory, - initialization_failed, - layer_not_present, - extension_not_present, - incompatible_driver, - unknown_error, -}; - -pub fn mapError(result: c_int) !void { - return switch (result) { - c.VK_SUCCESS => {}, - c.VK_ERROR_OUT_OF_HOST_MEMORY => Error.out_of_host_memory, - c.VK_ERROR_OUT_OF_DEVICE_MEMORY => Error.out_of_device_memory, - c.VK_ERROR_INITIALIZATION_FAILED => Error.initialization_failed, - c.VK_ERROR_LAYER_NOT_PRESENT => Error.layer_not_present, - c.VK_ERROR_EXTENSION_NOT_PRESENT => Error.extension_not_present, - c.VK_ERROR_INCOMPATIBLE_DRIVER => Error.incompatible_driver, - else => Error.unknown_error, - }; -} - -pub const BufferUsage = packed struct(u32) { - transfer_src: bool = false, - transfer_dst: bool = false, - uniform_texel_buffer: bool = false, - storage_texel_buffer: bool = false, - uniform_buffer: bool = false, - storage_buffer: bool = false, - index_buffer: bool = false, - vertex_buffer: bool = false, - indirect_buffer: bool = false, - _padding: enum(u23) { unset } = .unset, -}; - -pub const BufferFlags = packed struct(u32) { - device_local: bool = false, - host_visible: bool = false, - host_coherent: bool = false, - host_cached: bool = false, - lazily_allocated: bool = false, - _padding: enum(u27) { unset } = .unset, -}; - -pub const Instance = struct { - handle: c.VkInstance, - - pub fn create(allocator: Allocator) !Instance { - const extensions = window.getExtensions(); - - // Querry avaliable extensions size - var avaliableExtensionsCount: u32 = 0; - _ = c.vkEnumerateInstanceExtensionProperties(null, &avaliableExtensionsCount, null); - // Actually querry avaliable extensions - var avaliableExtensions = std.ArrayList(c.VkExtensionProperties).init(allocator); - try avaliableExtensions.resize(avaliableExtensionsCount); - defer avaliableExtensions.deinit(); - _ = c.vkEnumerateInstanceExtensionProperties(null, &avaliableExtensionsCount, avaliableExtensions.items.ptr); - // Check the extensions we want against the extensions the user has - for(extensions) |need_ext| { - var found = false; - for(avaliableExtensions.items) |useable_ext| { - const extensionName: [*c]const u8 = &useable_ext.extensionName; - if(std.mem.eql(u8, std.mem.sliceTo(need_ext, 0), std.mem.sliceTo(extensionName, 0))){ - found = true; - break; - } - } - if(!found){ - std.debug.panic("ERROR: Needed vulkan extension {s} not found\n", .{need_ext}); - } - } - - // Querry avaliable layers size - var avaliableLayersCount: u32 = 0; - _ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, null); - // Actually querry avaliable layers - var availableLayers = std.ArrayList(c.VkLayerProperties).init(allocator); - try availableLayers.resize(avaliableLayersCount); - defer availableLayers.deinit(); - _ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, availableLayers.items.ptr); - // Every layer we do have we add to this list, if we don't have it no worries just print a message and continue - var newLayers = std.ArrayList([*c]const u8).init(allocator); - // Loop over layers we want - for(validation_layers) |want_layer| { - var found = false; - for(availableLayers.items) |useable_validation| { - const layer_name: [*c]const u8 = &useable_validation.layerName; - if (std.mem.eql(u8, std.mem.sliceTo(want_layer, 0), std.mem.sliceTo(layer_name, 0))){ - found = true; - break; - } - } - if(!found){ - std.debug.print("WARNING: Compiled in debug mode, but wanted validation layer {s} not found.\n", .{want_layer}); - std.debug.print("NOTE: Validation layer will be removed from the wanted validation layers\n", .{}); - } else{ - try newLayers.append(want_layer); - } - } - - const app_info: c.VkApplicationInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_APPLICATION_INFO, - .pApplicationName = "sideros", - .applicationVersion = c.VK_MAKE_VERSION(1, 0, 0), - .engineVersion = c.VK_MAKE_VERSION(1, 0, 0), - .pEngineName = "sideros", - .apiVersion = c.VK_MAKE_VERSION(1, 3, 0), - }; - - const instance_info: c.VkInstanceCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, - .pApplicationInfo = &app_info, - .enabledExtensionCount = @intCast(extensions.len), - .ppEnabledExtensionNames = extensions.ptr, - .enabledLayerCount = @intCast(newLayers.capacity), - .ppEnabledLayerNames = newLayers.items.ptr, - }; - - var instance: c.VkInstance = undefined; - - try mapError(c.vkCreateInstance(&instance_info, null, &instance)); - - return Instance{ - .handle = instance, - }; - } - - pub fn destroy(self: Instance) void { - c.vkDestroyInstance(self.handle, null); - } -}; - -pub const Buffer = struct { - handle: c.VkBuffer, - memory: c.VkDeviceMemory, - size: usize, - - pub fn copyTo(self: Buffer, device: anytype, dest: Buffer) !void { - const command_buffer_info: c.VkCommandBufferAllocateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - .commandPool = device.command_pool, - .level = c.VK_COMMAND_BUFFER_LEVEL_PRIMARY, - .commandBufferCount = 1, - }; - - var command_buffer: c.VkCommandBuffer = undefined; - try mapError(c.vkAllocateCommandBuffers(device.handle, &command_buffer_info, @ptrCast(&command_buffer))); - - const begin_info: c.VkCommandBufferBeginInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - .flags = c.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - }; - - try mapError(c.vkBeginCommandBuffer(command_buffer, &begin_info)); - - const copy_region: c.VkBufferCopy = .{ - .srcOffset = 0, - .dstOffset = 0, - .size = self.size, - }; - - c.vkCmdCopyBuffer(command_buffer, self.handle, dest.handle, 1, ©_region); - try mapError(c.vkEndCommandBuffer(command_buffer)); - - const submit_info: c.VkSubmitInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_SUBMIT_INFO, - .commandBufferCount = 1, - .pCommandBuffers = &command_buffer, - }; - - try mapError(c.vkQueueSubmit(device.graphics_queue, 1, &submit_info, null)); - try mapError(c.vkQueueWaitIdle(device.graphics_queue)); - c.vkFreeCommandBuffers(device.handle, device.command_pool, 1, &command_buffer); - } - - pub fn destroy(self: Buffer, device_handle: c.VkDevice) void { - c.vkDestroyBuffer(device_handle, self.handle, null); - c.vkFreeMemory(device_handle, self.memory, null); - } -}; - -pub fn RenderPass(comptime n: usize) type { - return struct { - handle: c.VkRenderPass, - - const Self = @This(); - - pub fn create(allocator: Allocator, device: Device(n), surface: Surface, physical_device: PhysicalDevice) !Self { - const color_attachment: c.VkAttachmentDescription = .{ - .format = (try Swapchain(n).pickFormat(allocator, surface, physical_device)).format, - .samples = c.VK_SAMPLE_COUNT_1_BIT, - .loadOp = c.VK_ATTACHMENT_LOAD_OP_CLEAR, - .storeOp = c.VK_ATTACHMENT_STORE_OP_STORE, - .stencilLoadOp = c.VK_ATTACHMENT_LOAD_OP_DONT_CARE, - .stencilStoreOp = c.VK_ATTACHMENT_STORE_OP_DONT_CARE, - .initialLayout = c.VK_IMAGE_LAYOUT_UNDEFINED, - .finalLayout = c.VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, - }; - - const color_attachment_reference: c.VkAttachmentReference = .{ - .attachment = 0, - .layout = c.VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - }; - - const subpass: c.VkSubpassDescription = .{ - .pipelineBindPoint = c.VK_PIPELINE_BIND_POINT_GRAPHICS, - .colorAttachmentCount = 1, - .pColorAttachments = &color_attachment_reference, - }; - - const dependency: c.VkSubpassDependency = .{ - .srcSubpass = c.VK_SUBPASS_EXTERNAL, - .dstSubpass = 0, - .srcStageMask = c.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - .srcAccessMask = 0, - .dstStageMask = c.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, - .dstAccessMask = c.VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, - }; - - const render_pass_info: c.VkRenderPassCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO, - .attachmentCount = 1, - .pAttachments = &color_attachment, - .subpassCount = 1, - .pSubpasses = &subpass, - .dependencyCount = 1, - .pDependencies = &dependency, - }; - - var render_pass: c.VkRenderPass = undefined; - - try mapError(c.vkCreateRenderPass(device.handle, &render_pass_info, null, &render_pass)); - - return Self{ - .handle = render_pass, - }; - } - - pub fn begin(self: Self, swapchain: Swapchain(n), device: Device(n), image: usize, frame: usize) void { - std.debug.assert(frame < n); - const clear_color: c.VkClearValue = .{ .color = .{ .float32 = .{ 0.0, 0.0, 0.0, 1.0 } } }; - - const begin_info: c.VkRenderPassBeginInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, - .renderPass = self.handle, - .framebuffer = swapchain.framebuffers[image], - .renderArea = .{ - .offset = .{ .x = 0, .y = 0 }, - .extent = swapchain.extent, - }, - .clearValueCount = 1, - .pClearValues = &clear_color, - }; - - c.vkCmdBeginRenderPass(device.command_buffers[frame], &begin_info, c.VK_SUBPASS_CONTENTS_INLINE); - } - - pub fn end(self: Self, device: Device(n), frame: usize) void { - _ = self; - std.debug.assert(frame < n); - c.vkCmdEndRenderPass(device.command_buffers[frame]); - } - - pub fn destroy(self: Self, device: Device(n)) void { - c.vkDestroyRenderPass(device.handle, self.handle, null); - } - }; -} - -pub fn GraphicsPipeline(comptime n: usize) type { - return struct { - layout: c.VkPipelineLayout, - handle: c.VkPipeline, - descriptor_pool: c.VkDescriptorPool, - descriptor_set: c.VkDescriptorSet, - descriptor_set_layout: c.VkDescriptorSetLayout, - uniform_buffer: Buffer, - - const Self = @This(); - - pub fn create(device: Device(n), swapchain: Swapchain(n), render_pass: RenderPass(n), vertex_shader: c.VkShaderModule, fragment_shader: c.VkShaderModule) !Self { - const vertex_shader_stage_info: c.VkPipelineShaderStageCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = c.VK_SHADER_STAGE_VERTEX_BIT, - .module = vertex_shader, - .pName = "main", - }; - - const fragment_shader_stage_info: c.VkPipelineShaderStageCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, - .stage = c.VK_SHADER_STAGE_FRAGMENT_BIT, - .module = fragment_shader, - .pName = "main", - }; - - // TODO: shouldn't this be closer to usage? - const shader_stage_infos: []const c.VkPipelineShaderStageCreateInfo = &.{ vertex_shader_stage_info, fragment_shader_stage_info }; - - const vertex_attributes: []const c.VkVertexInputAttributeDescription = &.{mesh.Vertex.attributeDescription()}; - const vertex_bindings: []const c.VkVertexInputBindingDescription = &.{mesh.Vertex.bindingDescription()}; - - const vertex_input_info: c.VkPipelineVertexInputStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - .vertexBindingDescriptionCount = 1, - .pVertexBindingDescriptions = vertex_bindings.ptr, - .vertexAttributeDescriptionCount = 1, - .pVertexAttributeDescriptions = vertex_attributes.ptr, - }; - - const input_assembly_info: c.VkPipelineInputAssemblyStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - .topology = c.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - .primitiveRestartEnable = c.VK_FALSE, - }; - - const viewport: c.VkViewport = .{ - .x = 0.0, - .y = 0.0, - .width = @floatFromInt(swapchain.extent.width), - .height = @floatFromInt(swapchain.extent.height), - .minDepth = 0.0, - .maxDepth = 1.0, - }; - - const scissor: c.VkRect2D = .{ - .offset = .{ - .x = 0.0, - .y = 0.0, - }, - .extent = swapchain.extent, - }; - - const viewport_state_info: c.VkPipelineViewportStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, - .viewportCount = 1, - .pViewports = &viewport, - .scissorCount = 1, - .pScissors = &scissor, - }; - - const rasterizer_info: c.VkPipelineRasterizationStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, - .depthClampEnable = c.VK_FALSE, - .rasterizerDiscardEnable = c.VK_FALSE, - .polygonMode = c.VK_POLYGON_MODE_FILL, - .lineWidth = 1.0, - .cullMode = c.VK_CULL_MODE_BACK_BIT, - .frontFace = c.VK_FRONT_FACE_CLOCKWISE, - .depthBiasEnable = c.VK_FALSE, - }; - - const multisampling_info: c.VkPipelineMultisampleStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, - .sampleShadingEnable = c.VK_FALSE, - .rasterizationSamples = c.VK_SAMPLE_COUNT_1_BIT, - }; - - const color_blend_attachment: c.VkPipelineColorBlendAttachmentState = .{ - .colorWriteMask = c.VK_COLOR_COMPONENT_R_BIT | c.VK_COLOR_COMPONENT_G_BIT | c.VK_COLOR_COMPONENT_B_BIT | c.VK_COLOR_COMPONENT_A_BIT, - .blendEnable = c.VK_TRUE, - .srcColorBlendFactor = c.VK_BLEND_FACTOR_SRC_ALPHA, - .dstColorBlendFactor = c.VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA, - .colorBlendOp = c.VK_BLEND_OP_ADD, - .srcAlphaBlendFactor = c.VK_BLEND_FACTOR_ONE, - .dstAlphaBlendFactor = c.VK_BLEND_FACTOR_ZERO, - .alphaBlendOp = c.VK_BLEND_OP_ADD, - }; - - const color_blend_info: c.VkPipelineColorBlendStateCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, - .logicOpEnable = c.VK_FALSE, - .logicOp = c.VK_LOGIC_OP_COPY, - .attachmentCount = 1, - .pAttachments = &color_blend_attachment, - .blendConstants = .{ 0.0, 0.0, 0.0, 0.0 }, - }; - - const set_binding = c.VkDescriptorSetLayoutBinding{ - .binding = 0, - .descriptorType = c.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - .descriptorCount = 1, - .stageFlags = c.VK_SHADER_STAGE_VERTEX_BIT, - }; - - const bindings = [_]c.VkDescriptorSetLayoutBinding{set_binding}; - - var descriptor_set_layout: c.VkDescriptorSetLayout = undefined; - - const descriptor_set_layout_info = c.VkDescriptorSetLayoutCreateInfo{ - .sType = c.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, - .bindingCount = 1, - .pBindings = bindings[0..].ptr, - }; - - try mapError(c.vkCreateDescriptorSetLayout(device.handle, &descriptor_set_layout_info, null, &descriptor_set_layout)); - - const set_layouts = [_]c.VkDescriptorSetLayout{descriptor_set_layout}; - - const layout_info: c.VkPipelineLayoutCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, - .setLayoutCount = 1, - .pSetLayouts = set_layouts[0..].ptr, - .pushConstantRangeCount = 0, - .pPushConstantRanges = null, - }; - - var layout: c.VkPipelineLayout = undefined; - - try mapError(c.vkCreatePipelineLayout(device.handle, &layout_info, null, @ptrCast(&layout))); - - const pipeline_info: c.VkGraphicsPipelineCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, - .stageCount = 2, - .pStages = shader_stage_infos.ptr, - .pVertexInputState = &vertex_input_info, - .pInputAssemblyState = &input_assembly_info, - .pViewportState = &viewport_state_info, - .pRasterizationState = &rasterizer_info, - .pMultisampleState = &multisampling_info, - .pDepthStencilState = null, - .pColorBlendState = &color_blend_info, - .pDynamicState = null, - .layout = layout, - .renderPass = render_pass.handle, - .subpass = 0, - .basePipelineHandle = null, - .basePipelineIndex = -1, - }; - - var pipeline: c.VkPipeline = undefined; - - try mapError(c.vkCreateGraphicsPipelines(device.handle, null, 1, &pipeline_info, null, @ptrCast(&pipeline))); - - var size = c.VkDescriptorPoolSize{ - .type = c.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - .descriptorCount = 1, - }; - - const descriptor_pool_info = c.VkDescriptorPoolCreateInfo{ - .sType = c.VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, - .maxSets = 1, - .poolSizeCount = 1, - .pPoolSizes = &size, - }; - - var descriptor_pool: c.VkDescriptorPool = undefined; - - try mapError(c.vkCreateDescriptorPool(device.handle, &descriptor_pool_info, null, &descriptor_pool)); - - const descriptor_allocate_info = c.VkDescriptorSetAllocateInfo{ - .sType = c.VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, - .descriptorPool = descriptor_pool, - .descriptorSetCount = 1, - .pSetLayouts = set_layouts[0..].ptr, - }; - - var descriptor_set: c.VkDescriptorSet = undefined; - - try mapError(c.vkAllocateDescriptorSets(device.handle, &descriptor_allocate_info, &descriptor_set)); - - const proj = math.Matrix.perspective(math.rad(45.0), (@as(f32, @floatFromInt(swapchain.extent.width)) / @as(f32, @floatFromInt(swapchain.extent.height))), 0.1, 10.0); - - const view = math.Matrix.lookAt(@Vector(3, f32){ 0.0, 0.0, 10.0 }, @Vector(3, f32){ 0.0, 0.0, 0.0 }, @Vector(3, f32){ 0.0, 1.0, 0.0 }); - const model = math.Matrix.identity(); - - const uniform = Uniform{ - .proj = proj, - .view = view, - .model = model, - }; - - const uniform_buffer = try device.createBuffer(BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, BufferFlags{ .device_local = true }, @sizeOf(Uniform)); - - var data: [*c]u8 = undefined; - - try mapError(c.vkMapMemory( - device.handle, - uniform_buffer.memory, - 0, - uniform_buffer.size, - 0, - @ptrCast(&data), - )); - - @memcpy(data[0..(@sizeOf(math.Matrix) * 3)], std.mem.asBytes(&uniform)); - - const descriptor_buffer_info = c.VkDescriptorBufferInfo{ - .buffer = uniform_buffer.handle, - .offset = 0, - .range = uniform_buffer.size, - }; - - const write_descriptor_set = c.VkWriteDescriptorSet{ - .sType = c.VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, - .dstSet = descriptor_set, - .dstBinding = 0, - .dstArrayElement = 0, - .descriptorCount = 1, - .descriptorType = c.VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, - .pBufferInfo = &descriptor_buffer_info, - }; - - c.vkUpdateDescriptorSets(device.handle, 1, &write_descriptor_set, 0, null); - - return Self{ - .layout = layout, - .handle = pipeline, - .descriptor_pool = descriptor_pool, - .descriptor_set = descriptor_set, - .descriptor_set_layout = descriptor_set_layout, - .uniform_buffer = uniform_buffer, - }; - } - - pub fn bind(self: Self, device: Device(n), frame: usize) void { - std.debug.assert(frame < n); - c.vkCmdBindPipeline(device.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, self.handle); - } - - pub fn destroy(self: Self, device: Device(n)) void { - self.uniform_buffer.destroy(device.handle); - c.vkDestroyDescriptorSetLayout(device.handle, self.descriptor_set_layout, null); - c.vkDestroyDescriptorPool(device.handle, self.descriptor_pool, null); - c.vkDestroyPipeline(device.handle, self.handle, null); - c.vkDestroyPipelineLayout(device.handle, self.layout, null); - } - }; -} - -//pub const Shader = struct { -// handle: c.VkShaderModule, -// -// pub fn create(comptime name: []const u8, device: Device) !Shader { -// const code = @embedFile(name); -// -// const create_info: c.VkShaderModuleCreateInfo = .{ -// .sType = c.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, -// .codeSize = code.len, -// .pCode = @ptrCast(@alignCast(code)), -// }; -// -// var shader_module: c.VkShaderModule = undefined; -// -// try mapError(c.vkCreateShaderModule(device.handle, &create_info, null, @ptrCast(&shader_module))); -// -// return Shader{ -// .handle = shader_module, -// }; -// } -// -// pub fn destroy(self: Shader, device: Device) void { -// c.vkDestroyShaderModule(device.handle, self.handle, null); -// } -//}; - -pub fn Swapchain(comptime n: usize) type { - return struct { - handle: c.VkSwapchainKHR, - images: []c.VkImage, - image_views: []c.VkImageView, - format: c.VkSurfaceFormatKHR, - extent: c.VkExtent2D, - framebuffers: []c.VkFramebuffer, - - allocator: Allocator, - - const Self = @This(); - - // TODO: This should not be part of the Swapchain? - pub fn pickFormat(allocator: Allocator, surface: Surface, physical_device: PhysicalDevice) !c.VkSurfaceFormatKHR { - const formats = try surface.formats(allocator, physical_device); - defer allocator.free(formats); - var format: ?c.VkSurfaceFormatKHR = null; - - for (formats) |fmt| { - if (fmt.format == c.VK_FORMAT_B8G8R8A8_SRGB and fmt.colorSpace == c.VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) { - format = fmt; - } - } - - if (format == null) { - format = formats[0]; - } - - return format.?; - } - - // TODO: Allow to recreate so Window can be resized - pub fn create(allocator: Allocator, surface: Surface, device: Device(n), physical_device: PhysicalDevice, w: window.Window, render_pass: RenderPass(n)) !Self { - const present_modes = try surface.presentModes(allocator, physical_device); - defer allocator.free(present_modes); - const capabilities = try surface.capabilities(physical_device); - var present_mode: ?c.VkPresentModeKHR = null; - var extent: c.VkExtent2D = undefined; - const format = try Self.pickFormat(allocator, surface, physical_device); - - for (present_modes) |mode| { - if (mode == c.VK_PRESENT_MODE_MAILBOX_KHR) { - present_mode = mode; - } - } - - if (present_mode == null) { - present_mode = c.VK_PRESENT_MODE_FIFO_KHR; - } - - if (capabilities.currentExtent.width != std.math.maxInt(u32)) { - extent = capabilities.currentExtent; - } else { - const width, const height = w.size(); - - extent = .{ - .width = @intCast(width), - .height = @intCast(height), - }; - - extent.width = std.math.clamp(extent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width); - extent.height = std.math.clamp(extent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height); - } - - var create_info: c.VkSwapchainCreateInfoKHR = .{ - .sType = c.VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR, - .surface = surface.handle, - .minImageCount = capabilities.minImageCount + 1, - .imageFormat = format.format, - .imageColorSpace = format.colorSpace, - .imageExtent = extent, - .imageArrayLayers = 1, - .imageUsage = c.VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, - .preTransform = capabilities.currentTransform, - .compositeAlpha = c.VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR, - .presentMode = present_mode.?, - .clipped = c.VK_TRUE, - .oldSwapchain = null, - }; - - const graphics_family = try physical_device.graphicsQueue(allocator); - const present_family = try physical_device.presentQueue(surface, allocator); - const family_indices: []const u32 = &.{ graphics_family, present_family }; - - if (graphics_family != present_family) { - create_info.imageSharingMode = c.VK_SHARING_MODE_CONCURRENT; - create_info.queueFamilyIndexCount = @intCast(family_indices.len); - create_info.pQueueFamilyIndices = family_indices.ptr; - } else { - create_info.imageSharingMode = c.VK_SHARING_MODE_EXCLUSIVE; - create_info.queueFamilyIndexCount = 0; - create_info.pQueueFamilyIndices = null; - } - - var swapchain: c.VkSwapchainKHR = undefined; - - try mapError(c.vkCreateSwapchainKHR(device.handle, &create_info, null, &swapchain)); - - var image_count: u32 = 0; - try mapError(c.vkGetSwapchainImagesKHR(device.handle, swapchain, &image_count, null)); - const images = try allocator.alloc(c.VkImage, image_count); - - try mapError(c.vkGetSwapchainImagesKHR(device.handle, swapchain, &image_count, @ptrCast(images))); - - const image_views = try allocator.alloc(c.VkImageView, image_count); - for (images, 0..) |image, index| { - const view_create_info: c.VkImageViewCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, - .image = image, - .viewType = c.VK_IMAGE_VIEW_TYPE_2D, - .format = format.format, - .components = .{ - .r = c.VK_COMPONENT_SWIZZLE_IDENTITY, - .g = c.VK_COMPONENT_SWIZZLE_IDENTITY, - .b = c.VK_COMPONENT_SWIZZLE_IDENTITY, - .a = c.VK_COMPONENT_SWIZZLE_IDENTITY, - }, - .subresourceRange = .{ - .aspectMask = c.VK_IMAGE_ASPECT_COLOR_BIT, - .baseMipLevel = 0, - .levelCount = 1, - .baseArrayLayer = 0, - .layerCount = 1, - }, - }; - - try mapError(c.vkCreateImageView(device.handle, &view_create_info, null, &(image_views[index]))); - } - - const framebuffers = try allocator.alloc(c.VkFramebuffer, image_count); - for (image_views, 0..) |view, index| { - const framebuffer_info: c.VkFramebufferCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO, - .renderPass = render_pass.handle, - .attachmentCount = 1, - .pAttachments = &view, - .width = extent.width, - .height = extent.height, - .layers = 1, - }; - - try mapError(c.vkCreateFramebuffer(device.handle, &framebuffer_info, null, &(framebuffers[index]))); - } - - return Self{ - .handle = swapchain, - .format = format, - .extent = extent, - .images = images[0..image_count], - .image_views = image_views[0..image_count], - .framebuffers = framebuffers, - .allocator = allocator, - }; - } - - pub fn nextImage(self: Self, device: Device(n), frame: usize) !usize { - std.debug.assert(frame < n); - var index: u32 = undefined; - try mapError(c.vkAcquireNextImageKHR(device.handle, self.handle, std.math.maxInt(u64), device.image_available[frame], null, &index)); - - return @intCast(index); - } - - pub fn destroy(self: Self, device: Device(n)) void { - for (self.image_views) |view| { - c.vkDestroyImageView(device.handle, view, null); - } - - for (self.framebuffers) |framebuffer| { - c.vkDestroyFramebuffer(device.handle, framebuffer, null); - } - - c.vkDestroySwapchainKHR(device.handle, self.handle, null); - - self.allocator.free(self.images); - self.allocator.free(self.image_views); - self.allocator.free(self.framebuffers); - } - }; -} - -pub const Surface = struct { - handle: c.VkSurfaceKHR, - - pub fn create(instance: Instance, w: window.Window) !Surface { - var handle: c.VkSurfaceKHR = undefined; - try mapError(c.glfwCreateWindowSurface(instance.handle, w.raw, null, &handle)); - return Surface{ - .handle = handle, - }; - } - - pub fn presentModes(self: Surface, allocator: Allocator, device: PhysicalDevice) ![]c.VkPresentModeKHR { - var mode_count: u32 = 0; - try mapError(c.vkGetPhysicalDeviceSurfacePresentModesKHR(device.handle, self.handle, &mode_count, null)); - const modes = try allocator.alloc(c.VkPresentModeKHR, mode_count); - try mapError(c.vkGetPhysicalDeviceSurfacePresentModesKHR(device.handle, self.handle, &mode_count, @ptrCast(modes))); - - return modes[0..mode_count]; - } - - pub fn formats(self: Surface, allocator: Allocator, device: PhysicalDevice) ![]c.VkSurfaceFormatKHR { - var format_count: u32 = 0; - try mapError(c.vkGetPhysicalDeviceSurfaceFormatsKHR(device.handle, self.handle, &format_count, null)); - const fmts = try allocator.alloc(c.VkSurfaceFormatKHR, format_count); - try mapError(c.vkGetPhysicalDeviceSurfaceFormatsKHR(device.handle, self.handle, &format_count, @ptrCast(fmts))); - - return fmts[0..format_count]; - } - - pub fn capabilities(self: Surface, device: PhysicalDevice) !c.VkSurfaceCapabilitiesKHR { - var caps: c.VkSurfaceCapabilitiesKHR = undefined; - try mapError(c.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device.handle, self.handle, &caps)); - return caps; - } - - pub fn destroy(self: Surface, instance: Instance) void { - c.vkDestroySurfaceKHR(instance.handle, self.handle, null); - } -}; - -pub fn Device(comptime n: usize) type { - return struct { - handle: c.VkDevice, - graphics_queue: c.VkQueue, - present_queue: c.VkQueue, - command_pool: c.VkCommandPool, - command_buffers: [n]c.VkCommandBuffer, - image_available: [n]c.VkSemaphore, - render_finished: [n]c.VkSemaphore, - in_flight_fence: [n]c.VkFence, - graphics_family: u32, - present_family: u32, - memory_properties: c.VkPhysicalDeviceMemoryProperties, - - const Self = @This(); - - pub fn resetCommand(self: Self, frame: usize) !void { - std.debug.assert(frame < n); - try mapError(c.vkResetCommandBuffer(self.command_buffers[frame], 0)); - } - - pub fn beginCommand(self: Self, frame: usize) !void { - std.debug.assert(frame < n); - const begin_info: c.VkCommandBufferBeginInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, - .flags = c.VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, - }; - try mapError(c.vkBeginCommandBuffer(self.command_buffers[frame], &begin_info)); - } - - pub fn endCommand(self: Self, frame: usize) !void { - std.debug.assert(frame < n); - try mapError(c.vkEndCommandBuffer(self.command_buffers[frame])); - } - - pub fn draw(self: Self, indices: u32, frame: usize) void { - std.debug.assert(frame < n); - c.vkCmdDrawIndexed(self.command_buffers[frame], indices, 1, 0, 0, 0); - } - - pub fn waitFence(self: Self, frame: usize) !void { - std.debug.assert(frame < n); - try mapError(c.vkWaitForFences(self.handle, 1, &self.in_flight_fence[frame], c.VK_TRUE, std.math.maxInt(u64))); - try mapError(c.vkResetFences(self.handle, 1, &self.in_flight_fence[frame])); - } - - pub fn waitIdle(self: Self) void { - const mapErrorRes = mapError(c.vkDeviceWaitIdle(self.handle)); - if(mapErrorRes) {} else |err| { - std.debug.panic("Vulkan wait idle error: {any}\n", .{err}); - } - } - - pub fn bindIndexBuffer(self: Self, buffer: Buffer, frame: usize) void { - std.debug.assert(frame < n); - c.vkCmdBindIndexBuffer(self.command_buffers[frame], buffer.handle, 0, c.VK_INDEX_TYPE_UINT16); - } - - pub fn bindVertexBuffer(self: Self, buffer: Buffer, frame: usize) void { - std.debug.assert(frame < n); - const offset: u64 = 0; - c.vkCmdBindVertexBuffers(self.command_buffers[frame], 0, 1, &buffer.handle, &offset); - } - - pub fn bindDescriptorSets(self: Self, pipeline: GraphicsPipeline(n), frame: usize) void { - c.vkCmdBindDescriptorSets(self.command_buffers[frame], c.VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 1, &pipeline.descriptor_set, 0, null); - } - - pub fn pick_memory_type(self: Self, type_bits: u32, flags: u32) u32 { - var memory_type_index: u32 = 0; - for (0..self.memory_properties.memoryTypeCount) |index| { - const memory_type = self.memory_properties.memoryTypes[index]; - - if (((type_bits & (@as(u64, 1) << @intCast(index))) != 0) and (memory_type.propertyFlags & flags) != 0 and (memory_type.propertyFlags & c.VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD) == 0) { - memory_type_index = @intCast(index); - } - } - - return memory_type_index; - } - - pub fn createBuffer(self: Self, usage: BufferUsage, flags: BufferFlags, size: usize) !Buffer { - const family_indices: []const u32 = &.{self.graphics_family}; - - const create_info: c.VkBufferCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - .size = size, - .sharingMode = c.VK_SHARING_MODE_EXCLUSIVE, - .usage = @bitCast(usage), - .queueFamilyIndexCount = 1, - .pQueueFamilyIndices = family_indices.ptr, - }; - - var buffer: c.VkBuffer = undefined; - try mapError(c.vkCreateBuffer(self.handle, &create_info, null, &buffer)); - - var memory_requirements: c.VkMemoryRequirements = undefined; - c.vkGetBufferMemoryRequirements(self.handle, buffer, &memory_requirements); - - const alloc_info: c.VkMemoryAllocateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, - .allocationSize = memory_requirements.size, - .memoryTypeIndex = self.pick_memory_type(memory_requirements.memoryTypeBits, @bitCast(flags)), - }; - - var device_memory: c.VkDeviceMemory = undefined; - - try mapError(c.vkAllocateMemory(self.handle, &alloc_info, null, &device_memory)); - - try mapError(c.vkBindBufferMemory(self.handle, buffer, device_memory, 0)); - - return Buffer{ - .handle = buffer, - .size = size, - .memory = device_memory, - }; - } - - pub fn submit(self: Self, swapchain: Swapchain(n), image: usize, frame: usize) !void { - std.debug.assert(frame < n); - //const wait_semaphores: [1]c.VkSemaphore = .{self.image_available[frame]}; - //const signal_semaphores: [1]c.VkSemaphore = .{self.render_finished[frame]}; - //const swapchains: [1]c.VkSwapchainKHR = .{swapchain.handle}; - const stages: []const u32 = &[_]u32{c.VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT}; - - const submit_info: c.VkSubmitInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_SUBMIT_INFO, - .waitSemaphoreCount = 1, - .pWaitSemaphores = &self.image_available[frame], - .pWaitDstStageMask = stages.ptr, - .commandBufferCount = 1, - .pCommandBuffers = &self.command_buffers[frame], - .signalSemaphoreCount = 1, - .pSignalSemaphores = &self.render_finished[frame], - }; - - try mapError(c.vkQueueSubmit(self.graphics_queue, 1, &submit_info, self.in_flight_fence[frame])); - - const present_info: c.VkPresentInfoKHR = .{ - .sType = c.VK_STRUCTURE_TYPE_PRESENT_INFO_KHR, - .waitSemaphoreCount = 1, - .pWaitSemaphores = &self.render_finished[frame], - .swapchainCount = 1, - .pSwapchains = &swapchain.handle, - .pImageIndices = @ptrCast(&image), - .pResults = null, - }; - - try mapError(c.vkQueuePresentKHR(self.present_queue, &present_info)); - } - - pub fn createShader(self: Self, comptime name: []const u8) !c.VkShaderModule { - const code = @embedFile(name); - - const create_info: c.VkShaderModuleCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO, - .codeSize = code.len, - .pCode = @ptrCast(@alignCast(code)), - }; - - var shader_module: c.VkShaderModule = undefined; - - try mapError(c.vkCreateShaderModule(self.handle, &create_info, null, @ptrCast(&shader_module))); - - return shader_module; - } - - pub fn destroyShader(self: Self, shader: c.VkShaderModule) void { - c.vkDestroyShaderModule(self.handle, shader, null); - } - - pub fn destroy(self: Self) void { - inline for (0..n) |index| { - c.vkDestroySemaphore(self.handle, self.image_available[index], null); - c.vkDestroySemaphore(self.handle, self.render_finished[index], null); - c.vkDestroyFence(self.handle, self.in_flight_fence[index], null); - } - - c.vkDestroyCommandPool(self.handle, self.command_pool, null); - c.vkDestroyDevice(self.handle, null); - } - }; -} - -pub const PhysicalDevice = struct { - handle: c.VkPhysicalDevice, - - pub fn pick(allocator: Allocator, instance: Instance) !PhysicalDevice { - var device_count: u32 = 0; - try mapError(c.vkEnumeratePhysicalDevices(instance.handle, &device_count, null)); - const devices = try allocator.alloc(c.VkPhysicalDevice, device_count); - defer allocator.free(devices); - try mapError(c.vkEnumeratePhysicalDevices(instance.handle, &device_count, @ptrCast(devices))); - - return PhysicalDevice{ .handle = devices[0] }; - } - - pub fn queueFamilyProperties(self: PhysicalDevice, allocator: Allocator) ![]const c.VkQueueFamilyProperties { - var count: u32 = 0; - c.vkGetPhysicalDeviceQueueFamilyProperties(self.handle, &count, null); - const family_properties = try allocator.alloc(c.VkQueueFamilyProperties, count); - c.vkGetPhysicalDeviceQueueFamilyProperties(self.handle, &count, @ptrCast(family_properties)); - - return family_properties; - } - - pub fn graphicsQueue(self: PhysicalDevice, allocator: Allocator) !u32 { - const queue_families = try self.queueFamilyProperties(allocator); - defer allocator.free(queue_families); - var graphics_queue: ?u32 = null; - - for (queue_families, 0..) |family, index| { - if (graphics_queue) |_| { - break; - } - - if ((family.queueFlags & c.VK_QUEUE_GRAPHICS_BIT) != 0x0) { - graphics_queue = @intCast(index); - } - } - - return graphics_queue.?; - } - - pub fn presentQueue(self: PhysicalDevice, surface: Surface, allocator: Allocator) !u32 { - const queue_families = try self.queueFamilyProperties(allocator); - defer allocator.free(queue_families); - var present_queue: ?u32 = null; - - for (queue_families, 0..) |_, index| { - if (present_queue) |_| { - break; - } - - var support: u32 = undefined; - try mapError(c.vkGetPhysicalDeviceSurfaceSupportKHR(self.handle, @intCast(index), surface.handle, &support)); - - if (support == c.VK_TRUE) { - present_queue = @intCast(index); - } - } - - return present_queue.?; - } - - pub fn create_device(self: *PhysicalDevice, surface: Surface, allocator: Allocator, comptime n: usize) !Device(n) { - const graphics_queue_index = try self.graphicsQueue(allocator); - const present_queue_index = try self.presentQueue(surface, allocator); - - const priorities: f32 = 1.0; - - const graphics_queue_info: c.VkDeviceQueueCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueFamilyIndex = graphics_queue_index, - .queueCount = 1, - .pQueuePriorities = &priorities, - }; - - const present_queue_info: c.VkDeviceQueueCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO, - .queueFamilyIndex = present_queue_index, - .queueCount = 1, - .pQueuePriorities = &priorities, - }; - - const queues: []const c.VkDeviceQueueCreateInfo = &.{ graphics_queue_info, present_queue_info }; - - var device_features: c.VkPhysicalDeviceFeatures2 = .{ - .sType = c.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - }; - - c.vkGetPhysicalDeviceFeatures2(self.handle, &device_features); - - const device_info: c.VkDeviceCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, - .pNext = &device_features, - .queueCreateInfoCount = 1, - .pQueueCreateInfos = queues.ptr, - .enabledLayerCount = 0, - .enabledExtensionCount = @intCast(device_extensions.len), - .ppEnabledExtensionNames = device_extensions.ptr, - }; - - var device: c.VkDevice = undefined; - try mapError(c.vkCreateDevice(self.handle, &device_info, null, &device)); - - var graphics_queue: c.VkQueue = undefined; - var present_queue: c.VkQueue = undefined; - - c.vkGetDeviceQueue(device, graphics_queue_index, 0, &graphics_queue); - c.vkGetDeviceQueue(device, present_queue_index, 0, &present_queue); - - const command_pool_info: c.VkCommandPoolCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, - .flags = c.VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, - .queueFamilyIndex = graphics_queue_index, - }; - - var command_pool: c.VkCommandPool = undefined; - try mapError(c.vkCreateCommandPool(device, &command_pool_info, null, &command_pool)); - - const command_buffer_info: c.VkCommandBufferAllocateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, - .commandPool = command_pool, - .level = c.VK_COMMAND_BUFFER_LEVEL_PRIMARY, - .commandBufferCount = n, - }; - - var command_buffers: [n]c.VkCommandBuffer = undefined; - try mapError(c.vkAllocateCommandBuffers(device, &command_buffer_info, command_buffers[0..n].ptr)); - - const semaphore_info: c.VkSemaphoreCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, - }; - - const fence_info: c.VkFenceCreateInfo = .{ - .sType = c.VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, - .flags = c.VK_FENCE_CREATE_SIGNALED_BIT, - }; - - var image_available: [n]c.VkSemaphore = undefined; - var render_finished: [n]c.VkSemaphore = undefined; - var in_flight_fence: [n]c.VkFence = undefined; - - inline for (0..n) |index| { - try mapError(c.vkCreateSemaphore(device, &semaphore_info, null, &image_available[index])); - try mapError(c.vkCreateSemaphore(device, &semaphore_info, null, &render_finished[index])); - try mapError(c.vkCreateFence(device, &fence_info, null, &in_flight_fence[index])); - } - - var memory_properties: c.VkPhysicalDeviceMemoryProperties = undefined; - c.vkGetPhysicalDeviceMemoryProperties(self.handle, &memory_properties); - - return Device(n){ - .handle = device, - .graphics_queue = graphics_queue, - .present_queue = present_queue, - .command_pool = command_pool, - .command_buffers = command_buffers, - .image_available = image_available, - .render_finished = render_finished, - .in_flight_fence = in_flight_fence, - .graphics_family = graphics_queue_index, - .present_family = present_queue_index, - .memory_properties = memory_properties, - }; - } -}; |