Refactored create/destroy to init/deinit

src/rendering/Device.zig

@@ -225,7 +225,7 @@ pub fn pick_memory_type(self: Self, type_bits: u32, flags: u32) u32 {
     return memory_type_index;
 }
 
-pub fn createBuffer(self: Self, usage: vk.BufferUsage, flags: vk.BufferFlags, size: usize) !vk.Buffer {
+pub fn initBuffer(self: Self, usage: vk.BufferUsage, flags: vk.BufferFlags, size: usize) !vk.Buffer {
     const family_indices: []const u32 = &.{self.graphics_family};
 
     const create_info: c.VkBufferCreateInfo = .{
@@ -297,7 +297,7 @@ pub fn submit(self: Self, swapchain: vk.Swapchain, image: usize, frame: usize) !
     try vk.mapError(c.vkQueuePresentKHR(self.present_queue, &present_info));
 }
 
-pub fn createShader(self: Self, comptime name: []const u8) !c.VkShaderModule {
+pub fn initShader(self: Self, comptime name: []const u8) !c.VkShaderModule {
     const code = @embedFile(name);
 
     const create_info: c.VkShaderModuleCreateInfo = .{
@@ -313,11 +313,11 @@ pub fn createShader(self: Self, comptime name: []const u8) !c.VkShaderModule {
     return shader_module;
 }
 
-pub fn destroyShader(self: Self, shader: c.VkShaderModule) void {
+pub fn deinitShader(self: Self, shader: c.VkShaderModule) void {
     c.vkDestroyShaderModule(self.handle, shader, null);
 }
 
-pub fn destroy(self: Self) void {
+pub fn deinit(self: Self) void {
     inline for (0..frames_in_flight) |index| {
         c.vkDestroySemaphore(self.handle, self.image_available[index], null);
         c.vkDestroySemaphore(self.handle, self.render_finished[index], null);

src/rendering/GraphicsPipeline.zig

@@ -263,7 +263,7 @@ pub fn init(allocator: std.mem.Allocator, device: vk.Device, swapchain: vk.Swapc
 
     try vk.mapError(c.vkAllocateDescriptorSets(device.handle, &descriptor_allocate_info, &descriptor_set));
 
-    const projection_buffer = try device.createBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Matrix));
+    const projection_buffer = try device.initBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Matrix));
 
     var data: [*c]u8 = undefined;
 
@@ -296,7 +296,7 @@ pub fn init(allocator: std.mem.Allocator, device: vk.Device, swapchain: vk.Swapc
 
     c.vkUpdateDescriptorSets(device.handle, 1, &write_descriptor_set, 0, null);
 
-    const view_buffer = try device.createBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Matrix));
+    const view_buffer = try device.initBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Matrix));
 
     var view_data: [*c]u8 = undefined;
 
@@ -327,7 +327,7 @@ pub fn init(allocator: std.mem.Allocator, device: vk.Device, swapchain: vk.Swapc
 
     c.vkUpdateDescriptorSets(device.handle, 1, &write_view_descriptor_set, 0, null);
 
-    const transform_buffer = try device.createBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Transform) - @sizeOf(math.Quaternion));
+    const transform_buffer = try device.initBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(math.Transform) - @sizeOf(math.Quaternion));
 
     var transform_data: [*c]u8 = undefined;
 
@@ -358,7 +358,7 @@ pub fn init(allocator: std.mem.Allocator, device: vk.Device, swapchain: vk.Swapc
 
     c.vkUpdateDescriptorSets(device.handle, 1, &write_transform_descriptor_set, 0, null);
 
-    const light_buffer = try device.createBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf([3]f32));
+    const light_buffer = try device.initBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf([3]f32));
 
     var light_data: [*c]u8 = undefined;
 
@@ -391,7 +391,7 @@ pub fn init(allocator: std.mem.Allocator, device: vk.Device, swapchain: vk.Swapc
 
     c.vkUpdateDescriptorSets(device.handle, 1, &write_light_descriptor_set, 0, null);
 
-    const view_pos_buffer = try device.createBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf([3]f32));
+    const view_pos_buffer = try device.initBuffer(vk.BufferUsage{ .uniform_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf([3]f32));
 
     var view_pos_data: [*c]u8 = undefined;
 

src/rendering/Mesh.zig

@@ -11,7 +11,7 @@ pub const Vertex = struct {
     normal: [3]f32,
     uv: [2]f32,
 
-    pub fn create(x: f32, y: f32, z: f32, normal_x: f32, normal_y: f32, normal_z: f32, u: f32, v: f32) Vertex {
+    pub fn init(x: f32, y: f32, z: f32, normal_x: f32, normal_y: f32, normal_z: f32, u: f32, v: f32) Vertex {
         return Vertex{
             .position = .{ x, y, z },
             .normal = .{ normal_x, normal_y, normal_z },
@@ -87,7 +87,7 @@ pub fn createVertexBuffer(allocator: Allocator, device: anytype) !vk.Buffer {
 
     var data: [*c]?*anyopaque = null;
 
-    const buffer = try device.createBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, @sizeOf([8]f32) * vertices.len);
+    const buffer = try device.initBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, @sizeOf([8]f32) * vertices.len);
 
     try vk.mapError(vk.c.vkMapMemory(
         device.handle,
@@ -106,7 +106,7 @@ pub fn createVertexBuffer(allocator: Allocator, device: anytype) !vk.Buffer {
 
     vk.c.vkUnmapMemory(device.handle, buffer.memory);
 
-    const vertex_buffer = try device.createBuffer(vk.BufferUsage{ .vertex_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(Vertex) * vertices.len);
+    const vertex_buffer = try device.initBuffer(vk.BufferUsage{ .vertex_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(Vertex) * vertices.len);
 
     try buffer.copyTo(device, vertex_buffer);
     buffer.deinit(device.handle);
@@ -124,7 +124,7 @@ pub fn createIndexBuffer(allocator: Allocator, device: anytype) !vk.Buffer {
 
     var data: [*c]?*anyopaque = null;
 
-    const buffer = try device.createBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, @sizeOf(u16) * indices.len);
+    const buffer = try device.initBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, @sizeOf(u16) * indices.len);
 
     try vk.mapError(vk.c.vkMapMemory(
         device.handle,
@@ -143,7 +143,7 @@ pub fn createIndexBuffer(allocator: Allocator, device: anytype) !vk.Buffer {
 
     vk.c.vkUnmapMemory(device.handle, buffer.memory);
 
-    const index_buffer = try device.createBuffer(vk.BufferUsage{ .index_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(u16) * indices.len);
+    const index_buffer = try device.initBuffer(vk.BufferUsage{ .index_buffer = true, .transfer_dst = true }, vk.BufferFlags{ .device_local = true }, @sizeOf(u16) * indices.len);
 
     try buffer.copyTo(device, index_buffer);
     buffer.deinit(device.handle);
@@ -151,7 +151,7 @@ pub fn createIndexBuffer(allocator: Allocator, device: anytype) !vk.Buffer {
     return index_buffer;
 }
 
-pub fn create(allocator: Allocator, device: anytype) !Mesh {
+pub fn init(allocator: Allocator, device: anytype) !Mesh {
     const vertex_buffer = try Mesh.createVertexBuffer(allocator, device);
     const index_buffer = try Mesh.createIndexBuffer(allocator, device);
 

src/rendering/Renderer.zig

@@ -28,14 +28,14 @@ pub fn init(allocator: Allocator, instance_handle: vk.c.VkInstance, surface_hand
     var physical_device = try vk.PhysicalDevice.pick(allocator, instance);
     const device = try physical_device.create_device(surface, allocator, 2);
 
-    const vertex_shader = try device.createShader("shader_vert");
-    defer device.destroyShader(vertex_shader);
-    const fragment_shader = try device.createShader("shader_frag");
-    defer device.destroyShader(fragment_shader);
+    const vertex_shader = try device.initShader("shader_vert");
+    defer device.deinitShader(vertex_shader);
+    const fragment_shader = try device.initShader("shader_frag");
+    defer device.deinitShader(fragment_shader);
 
-    const render_pass = try vk.RenderPass.create(allocator, device, surface, physical_device);
+    const render_pass = try vk.RenderPass.init(allocator, device, surface, physical_device);
 
-    const swapchain = try vk.Swapchain.create(allocator, surface, device, physical_device, render_pass);
+    const swapchain = try vk.Swapchain.init(allocator, surface, device, physical_device, render_pass);
 
     var graphics_pipeline = try vk.GraphicsPipeline.init(allocator, device, swapchain, render_pass, vertex_shader, fragment_shader);
 
@@ -46,7 +46,7 @@ pub fn init(allocator: Allocator, instance_handle: vk.c.VkInstance, surface_hand
     //    renderer.render(some_other_thing);
     //    ...
     //    renderer.submit()
-    const triangle = try Mesh.create(allocator, device);
+    const triangle = try Mesh.init(allocator, device);
 
     const texture = try Texture.init("assets/textures/container.png", device);
     const diffuse = try Texture.init("assets/textures/container_specular.png", device);
@@ -79,9 +79,9 @@ pub fn deinit(self: Renderer) void {
     self.index_buffer.deinit(self.device.handle);
     self.vertex_buffer.deinit(self.device.handle);
     self.graphics_pipeline.deinit(self.device);
-    self.swapchain.destroy(self.device);
-    self.render_pass.destroy(self.device);
-    self.device.destroy();
+    self.swapchain.deinit(self.device);
+    self.render_pass.deinit(self.device);
+    self.device.deinit();
 }
 
 // TODO: render is maybe a bad name? something like present() or submit() is better?

src/rendering/Swapchain.zig

@@ -36,7 +36,7 @@ pub fn pickFormat(allocator: Allocator, surface: vk.Surface, physical_device: vk
 }
 
 // TODO: Allow to recreate so Window can be resized
-pub fn create(allocator: Allocator, surface: vk.Surface, device: vk.Device, physical_device: vk.PhysicalDevice, render_pass: vk.RenderPass) !Self {
+pub fn init(allocator: Allocator, surface: vk.Surface, device: vk.Device, physical_device: vk.PhysicalDevice, render_pass: vk.RenderPass) !Self {
     const present_modes = try surface.presentModes(allocator, physical_device);
     defer allocator.free(present_modes);
     const capabilities = try surface.capabilities(physical_device);
@@ -167,7 +167,7 @@ pub fn nextImage(self: Self, device: vk.Device, frame: usize) !usize {
     return @intCast(index);
 }
 
-pub fn destroy(self: Self, device: vk.Device) void {
+pub fn deinit(self: Self, device: vk.Device) void {
     for (self.image_views) |view| {
         c.vkDestroyImageView(device.handle, view, null);
     }

src/rendering/Texture.zig

@@ -18,7 +18,7 @@ pub fn init(path: [:0]const u8, device: anytype) !Texture {
     defer stb.stbi_image_free(pixels);
 
     const size: c.VkDeviceSize  = @as(u64, @intCast(width)) * @as(u64, @intCast(height)) * 4;
-    const image_buffer = try device.createBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, size);
+    const image_buffer = try device.initBuffer(vk.BufferUsage{ .transfer_src = true }, vk.BufferFlags{ .host_visible = true, .host_coherent = true }, size);
 
     const pixel_bytes: [*]u8 = @ptrCast(pixels);
     var image_data: [*c]u8 = undefined;

src/rendering/vulkan.zig

@@ -145,7 +145,7 @@ pub const RenderPass = struct {
 
     const Self = @This();
 
-    pub fn create(allocator: Allocator, device: Device, surface: Surface, physical_device: PhysicalDevice) !Self {
+    pub fn init(allocator: Allocator, device: Device, surface: Surface, physical_device: PhysicalDevice) !Self {
         const color_attachment: c.VkAttachmentDescription = .{
             .format = (try Swapchain.pickFormat(allocator, surface, physical_device)).format,
             .samples = c.VK_SAMPLE_COUNT_1_BIT,
@@ -221,7 +221,7 @@ pub const RenderPass = struct {
         c.vkCmdEndRenderPass(device.command_buffers[frame]);
     }
 
-    pub fn destroy(self: Self, device: Device) void {
+    pub fn deinit(self: Self, device: Device) void {
         c.vkDestroyRenderPass(device.handle, self.handle, null);
     }
 };