Split gfx context & swapchain

src/Context.zig

@@ -7,6 +7,7 @@ const img = @import("zstbi");
 
 const validation = @import("./validation_layers.zig");
 const Swapchain = @import("Swapchain.zig");
+const QueueUtils = @import("queue_utils.zig");
 
 const device_extensions = [_][*:0]const u8{vk.extensions.khr_swapchain.name};
 
@@ -23,15 +24,6 @@ pub const apis: []const vk.ApiInfo = &.{
 const enable_validation_layers = builtin.mode == .Debug;
 const validation_layers = [_][*:0]const u8{"VK_LAYER_KHRONOS_validation"};
 
-const QueueFamilyIndices = struct {
-    graphics_family: ?u32 = null,
-    presentation_family: ?u32 = null,
-
-    fn isValid(self: QueueFamilyIndices) bool {
-        return self.graphics_family != null and self.presentation_family != null;
-    }
-};
-
 const BaseDispatch = vk.BaseWrapper(apis);
 const InstanceDispatch = vk.InstanceWrapper(apis);
 const DeviceDispatch = vk.DeviceWrapper(apis);
@@ -171,7 +163,7 @@ fn getPhysicalDevice(self: *Self) !void {
 }
 
 fn createLogicalDevice(self: *Self) !void {
-    const indices = try self.getQueueFamilies(self.physical_device);
+    const indices = try QueueUtils.getQueueFamilies(self.*, self.physical_device);
     // 1 is the highest priority
     const priority = [_]f32{1};
 
@@ -214,7 +206,7 @@ fn createLogicalDevice(self: *Self) !void {
 
     self.device = Device.init(device_handle, vkd);
 
-    const queues = try self.getDeviceQueues();
+    const queues = try QueueUtils.getDeviceQueues(self.*);
 
     self.graphics_queue = Queue.init(queues[0], self.device.wrapper);
     self.presentation_queue = Queue.init(queues[1], self.device.wrapper);
@@ -237,43 +229,6 @@ fn getRequiredExtensions(self: Self) ![][*:0]const u8 {
     return extensions;
 }
 
-fn getQueueFamilies(self: Self, pdev: vk.PhysicalDevice) !QueueFamilyIndices {
-    var indices: QueueFamilyIndices = .{ .graphics_family = null };
-
-    var queue_family_count: u32 = 0;
-    self.instance.getPhysicalDeviceQueueFamilyProperties(pdev, &queue_family_count, null);
-
-    const queue_family_list = try self.allocator.alloc(vk.QueueFamilyProperties, queue_family_count);
-    defer self.allocator.free(queue_family_list);
-
-    self.instance.getPhysicalDeviceQueueFamilyProperties(pdev, &queue_family_count, queue_family_list.ptr);
-
-    for (queue_family_list, 0..) |queue_family, i| {
-        if (queue_family.queue_count > 0 and queue_family.queue_flags.graphics_bit) {
-            indices.graphics_family = @intCast(i);
-        }
-
-        const presentation_support = try self.instance.getPhysicalDeviceSurfaceSupportKHR(pdev, @intCast(i), self.surface);
-        if (queue_family.queue_count > 0 and presentation_support == vk.TRUE) {
-            indices.presentation_family = @intCast(i);
-        }
-
-        if (indices.isValid()) {
-            return indices;
-        }
-    }
-
-    unreachable;
-}
-
-fn getDeviceQueues(self: Self) ![2]vk.Queue {
-    const indices = try self.getQueueFamilies(self.physical_device);
-
-    const graphics_queue = self.device.getDeviceQueue(indices.graphics_family.?, 0);
-    const presentation_queue = self.device.getDeviceQueue(indices.presentation_family.?, 0);
-    return .{ graphics_queue, presentation_queue };
-}
-
 fn checkInstanceExtensions(self: Self, required_extensions: *const [][*:0]const u8) !bool {
     var prop_count: u32 = 0;
     _ = try self.vkb.enumerateInstanceExtensionProperties(null, &prop_count, null);
@@ -330,13 +285,13 @@ fn checkDeviceSuitable(self: Self, pdev: vk.PhysicalDevice) bool {
     }
 
     const pdev_features = self.instance.getPhysicalDeviceFeatures(pdev);
-    const queue_family_indices = self.getQueueFamilies(pdev) catch return false;
+    const queue_family_indices = QueueUtils.getQueueFamilies(self, pdev) catch return false;
     const extension_support = self.checkDeviceExtensions(pdev) catch return false;
 
     const swapchain_details = Swapchain.getSwapchainDetails(
         self.allocator,
         self.instance,
-        self.physical_device,
+        pdev,
         self.surface,
     ) catch return false;
     defer self.allocator.free(swapchain_details.formats);

src/MeshModel.zig

@@ -4,8 +4,8 @@ const zm = @import("zmath");
 const ai = @import("assimp.zig").c;
 
 const Mesh = @import("Mesh.zig");
-const Device = @import("vulkan_renderer.zig").Device;
+const Device = @import("Context.zig").Device;
-const Instance = @import("vulkan_renderer.zig").Instance;
+const Instance = @import("Context.zig").Instance;
 const Vertex = @import("utilities.zig").Vertex;
 
 const Self = @This();

src/Swapchain.zig

@@ -4,6 +4,8 @@ const sdl = @import("sdl");
 
 const Context = @import("Context.zig");
 const Instance = Context.Instance;
+const QueueUtils = @import("queue_utils.zig");
+const Utilities = @import("utilities.zig");
 
 pub const SwapchainDetails = struct {
     surface_capabilities: vk.SurfaceCapabilitiesKHR,
@@ -22,11 +24,14 @@ allocator: std.mem.Allocator,
 
 ctx: Context,
 
-swapchain: vk.SwapchainKHR,
+handle: vk.SwapchainKHR,
 
 swapchain_images: []SwapchainImage,
 swapchain_framebuffers: []vk.Framebuffer,
 
+swapchain_image_format: vk.Format,
+extent: vk.Extent2D,
+
 pub fn create(allocator: std.mem.Allocator, context: Context) !Self {
     var self: Self = undefined;
 
@@ -42,7 +47,7 @@ pub fn create(allocator: std.mem.Allocator, context: Context) !Self {
     // 2. Choose best presentation mode
     const present_mode = chooseBestPresentationMode(swapchain_details.presentation_modes);
     // 3. Choose swapchain image resolution
-    const extent = chooseSwapExtent(&context.window, swapchain_details.surface_capabilities);
+    const extent = chooseSwapExtent(&self.ctx.window, swapchain_details.surface_capabilities);
 
     // How many images are in the swapchain? Get 1 more than the minimum to allow triple buffering
     var image_count: u32 = swapchain_details.surface_capabilities.min_image_count + 1;
@@ -71,7 +76,7 @@ pub fn create(allocator: std.mem.Allocator, context: Context) !Self {
     };
 
     // Get queue family indices
-    const family_indices = try self.getQueueFamilies(self.physical_device);
+    const family_indices = try QueueUtils.getQueueFamilies(self.ctx, self.ctx.physical_device);
 
     // If graphic and presentation families are different, then swapchain must let images be shared between families
 
@@ -86,18 +91,18 @@ pub fn create(allocator: std.mem.Allocator, context: Context) !Self {
         swapchain_create_info.p_queue_family_indices = &qfi;
     }
 
-    self.swapchain = try self.device.createSwapchainKHR(&swapchain_create_info, null);
+    self.handle = try self.ctx.device.createSwapchainKHR(&swapchain_create_info, null);
     self.swapchain_image_format = surface_format.format;
     self.extent = extent;
 
     // Swapchain images
     var swapchain_image_count: u32 = 0;
-    _ = try self.device.getSwapchainImagesKHR(self.swapchain, &swapchain_image_count, null);
+    _ = try self.ctx.device.getSwapchainImagesKHR(self.handle, &swapchain_image_count, null);
 
     const images = try self.allocator.alloc(vk.Image, swapchain_image_count);
     defer self.allocator.free(images);
 
-    _ = try self.device.getSwapchainImagesKHR(self.swapchain, &swapchain_image_count, images.ptr);
+    _ = try self.ctx.device.getSwapchainImagesKHR(self.handle, &swapchain_image_count, images.ptr);
 
     self.swapchain_images = try self.allocator.alloc(SwapchainImage, swapchain_image_count);
 
@@ -111,6 +116,78 @@ pub fn create(allocator: std.mem.Allocator, context: Context) !Self {
     return self;
 }
 
+pub fn createImage(
+    self: *Self,
+    width: u32,
+    height: u32,
+    format: vk.Format,
+    tiling: vk.ImageTiling,
+    use_flags: vk.ImageUsageFlags,
+    prop_flags: vk.MemoryPropertyFlags,
+    image_memory: *vk.DeviceMemory,
+) !vk.Image {
+    // -- Create Image --
+    const image_create_info: vk.ImageCreateInfo = .{
+        .image_type = .@"2d", // Type of image (1D, 2D or 3D)
+        .extent = .{
+            .width = width, // Width of image extent
+            .height = height, // Height of image extent
+            .depth = 1, // Depth of image (just 1, no 3D aspecct)
+        },
+        .mip_levels = 1, // Number of mipmap levels
+        .array_layers = 1, // Number of level in image array
+        .format = format, // Format type of image
+        .tiling = tiling, // How image data should be tiled (arranged for optimal reading)
+        .initial_layout = .undefined, // Layout of image data on creation
+        .usage = use_flags, // Bit flags defining what image will be used for
+        .samples = .{ .@"1_bit" = true }, // Number of samples for multi-sampling
+        .sharing_mode = .exclusive, // Whether image can be shared between queues
+    };
+
+    const image = try self.ctx.device.createImage(&image_create_info, null);
+
+    // -- Create memory for image --
+    // Get memory requirements for a type of image
+    const memory_requirements = self.ctx.device.getImageMemoryRequirements(image);
+
+    // Allocate memory using image requirements and user-defined properties
+    const memory_alloc_info: vk.MemoryAllocateInfo = .{
+        .allocation_size = memory_requirements.size,
+        .memory_type_index = Utilities.findMemoryTypeIndex(self.ctx.physical_device, self.ctx.instance, memory_requirements.memory_type_bits, prop_flags),
+    };
+
+    image_memory.* = try self.ctx.device.allocateMemory(&memory_alloc_info, null);
+
+    // Connect memory to image
+    try self.ctx.device.bindImageMemory(image, image_memory.*, 0);
+
+    return image;
+}
+
+pub fn createImageView(self: Self, image: vk.Image, format: vk.Format, aspect_flags: vk.ImageAspectFlags) !vk.ImageView {
+    const image_view_create_info: vk.ImageViewCreateInfo = .{
+        .image = image,
+        .format = format,
+        .view_type = .@"2d",
+        .components = .{
+            // Used for remapping rgba values to other rgba values
+            .r = .identity,
+            .g = .identity,
+            .b = .identity,
+            .a = .identity,
+        },
+        .subresource_range = .{
+            .aspect_mask = aspect_flags, // Which aspect of image to view (e.g.: colour, depth, stencil, etc...)
+            .base_mip_level = 0, // Start mipmap level to view from
+            .level_count = 1, // Number of mipmap levels to view
+            .base_array_layer = 0, // Start array level to view from
+            .layer_count = 1, // Number of array levels to view
+        },
+    };
+
+    return try self.ctx.device.createImageView(&image_view_create_info, null);
+}
+
 pub fn getSwapchainDetails(allocator: std.mem.Allocator, instance: Instance, pdev: vk.PhysicalDevice, surface: vk.SurfaceKHR) !SwapchainDetails {
     // Capabilities
     const surface_capabilities = try instance.getPhysicalDeviceSurfaceCapabilitiesKHR(pdev, surface);

src/queue_utils.zig

@@ -0,0 +1,53 @@
+const std = @import("std");
+
+const vk = @import("vulkan");
+
+const Context = @import("Context.zig");
+const Instance = Context.Instance;
+const Device = Context.Device;
+
+pub const QueueFamilyIndices = struct {
+    graphics_family: ?u32 = null,
+    presentation_family: ?u32 = null,
+
+    pub fn isValid(self: QueueFamilyIndices) bool {
+        return self.graphics_family != null and self.presentation_family != null;
+    }
+};
+
+pub fn getQueueFamilies(ctx: Context, pdev: vk.PhysicalDevice) !QueueFamilyIndices {
+    var indices: QueueFamilyIndices = .{ .graphics_family = null };
+
+    var queue_family_count: u32 = 0;
+    ctx.instance.getPhysicalDeviceQueueFamilyProperties(pdev, &queue_family_count, null);
+
+    const queue_family_list = try ctx.allocator.alloc(vk.QueueFamilyProperties, queue_family_count);
+    defer ctx.allocator.free(queue_family_list);
+
+    ctx.instance.getPhysicalDeviceQueueFamilyProperties(pdev, &queue_family_count, queue_family_list.ptr);
+
+    for (queue_family_list, 0..) |queue_family, i| {
+        if (queue_family.queue_count > 0 and queue_family.queue_flags.graphics_bit) {
+            indices.graphics_family = @intCast(i);
+        }
+
+        const presentation_support = try ctx.instance.getPhysicalDeviceSurfaceSupportKHR(pdev, @intCast(i), ctx.surface);
+        if (queue_family.queue_count > 0 and presentation_support == vk.TRUE) {
+            indices.presentation_family = @intCast(i);
+        }
+
+        if (indices.isValid()) {
+            return indices;
+        }
+    }
+
+    unreachable;
+}
+
+pub fn getDeviceQueues(ctx: Context) ![2]vk.Queue {
+    const indices = try getQueueFamilies(ctx, ctx.physical_device);
+
+    const graphics_queue = ctx.device.getDeviceQueue(indices.graphics_family.?, 0);
+    const presentation_queue = ctx.device.getDeviceQueue(indices.presentation_family.?, 0);
+    return .{ graphics_queue, presentation_queue };
+}

src/utilities.zig

@@ -1,8 +1,8 @@
 const std = @import("std");
 const vk = @import("vulkan");
 
-const Instance = @import("vulkan_renderer.zig").Instance;
+const Instance = @import("Context.zig").Instance;
-const Device = @import("vulkan_renderer.zig").Device;
+const Device = @import("Context.zig").Device;
 const CommandBuffer = @import("vulkan_renderer.zig").CommandBuffer;
 
 pub const Vector3 = @Vector(3, f32);

src/vulkan_renderer.zig

@@ -7,6 +7,7 @@ const zm = @import("zmath");
 const img = @import("zstbi");
 const ai = @import("assimp.zig").c;
 
+const QueueUtils = @import("queue_utils.zig");
 const StringUtils = @import("string_utils.zig");
 const Utilities = @import("utilities.zig");
 const Vertex = Utilities.Vertex;
@@ -39,8 +40,7 @@ pub const VulkanRenderer = struct {
 
     current_frame: u32 = 0,
 
-    context: Context,
+    ctx: Context,
-
     swapchain: Swapchain,
 
     // Scene settings
@@ -98,9 +98,7 @@ pub const VulkanRenderer = struct {
     graphics_command_pool: vk.CommandPool,
 
     // Utilities
-    swapchain_image_format: vk.Format,
     depth_format: vk.Format,
-    extent: vk.Extent2D,
 
     // Synchronisation
     image_available: [MAX_FRAME_DRAWS]vk.Semaphore,
@@ -110,9 +108,10 @@ pub const VulkanRenderer = struct {
     pub fn init(allocator: std.mem.Allocator, window: sdl.Window) !Self {
         var self: Self = undefined;
 
-        self.context = try Context.init(allocator, window);
+        self.allocator = allocator;
+        self.ctx = try Context.init(allocator, window);
         self.current_frame = 0;
-        self.swapchain = try Swapchain.create(allocator, self.context);
+        self.swapchain = try Swapchain.create(allocator, self.ctx);
 
         try self.createColourBufferImage();
         try self.createDepthBufferImage();
@@ -123,7 +122,7 @@ pub const VulkanRenderer = struct {
         try self.createFramebuffers();
         try self.createCommandPool();
 
-        self.sampler_descriptor_sets = try std.ArrayList(vk.DescriptorSet).initCapacity(self.allocator, self.swapchain_images.len);
+        self.sampler_descriptor_sets = try std.ArrayList(vk.DescriptorSet).initCapacity(self.allocator, self.swapchain.swapchain_images.len);
 
         try self.createCommandBuffers();
         try self.createTextureSampler();
@@ -139,7 +138,7 @@ pub const VulkanRenderer = struct {
         self.texture_image_views = std.ArrayList(vk.ImageView).init(self.allocator);
         self.model_list = std.ArrayList(MeshModel).init(allocator);
 
-        const aspect: f32 = @as(f32, @floatFromInt(self.extent.width)) / @as(f32, @floatFromInt(self.extent.height));
+        const aspect: f32 = @as(f32, @floatFromInt(self.swapchain.extent.width)) / @as(f32, @floatFromInt(self.swapchain.extent.height));
         self.ubo_view_projection.projection = zm.perspectiveFovRh(
             std.math.degreesToRadians(45.0),
             aspect,
@@ -172,19 +171,19 @@ pub const VulkanRenderer = struct {
 
     pub fn draw(self: *Self) !void {
         // Wait for given fence to signal (open) from last draw before continuing
-        _ = try self.device.waitForFences(
+        _ = try self.ctx.device.waitForFences(
             1,
             @ptrCast(&self.draw_fences[self.current_frame]),
             vk.TRUE,
             std.math.maxInt(u64),
         );
         // Manually reset (close) fences
-        try self.device.resetFences(1, @ptrCast(&self.draw_fences[self.current_frame]));
+        try self.ctx.device.resetFences(1, @ptrCast(&self.draw_fences[self.current_frame]));
 
         // -- Get next image
         // Get index of next image to be drawn to, and signal semaphore when ready to be drawn to
-        const image_index_result = try self.device.acquireNextImageKHR(
+        const image_index_result = try self.ctx.device.acquireNextImageKHR(
-            self.swapchain,
+            self.swapchain.handle,
             std.math.maxInt(u64),
             self.image_available[self.current_frame],
             .null_handle,
@@ -208,26 +207,26 @@ pub const VulkanRenderer = struct {
         };
 
         // Submit command buffer to queue
-        try self.device.queueSubmit(self.graphics_queue.handle, 1, @ptrCast(&submit_info), self.draw_fences[self.current_frame]);
+        try self.ctx.device.queueSubmit(self.ctx.graphics_queue.handle, 1, @ptrCast(&submit_info), self.draw_fences[self.current_frame]);
 
         // -- Present rendered image to screen
         const present_info: vk.PresentInfoKHR = .{
             .wait_semaphore_count = 1, // Number of semaphores to wait on
             .p_wait_semaphores = @ptrCast(&self.render_finished[self.current_frame]), // Semaphores to wait on
             .swapchain_count = 1, // Number of swapchains to present to
-            .p_swapchains = @ptrCast(&self.swapchain), // Swapchains to present images to
+            .p_swapchains = @ptrCast(&self.swapchain.handle), // Swapchains to present images to
             .p_image_indices = @ptrCast(&image_index_result.image_index), // Index of images in swapchains to present
         };
 
         // Present image
-        _ = try self.device.queuePresentKHR(self.presentation_queue.handle, &present_info);
+        _ = try self.ctx.device.queuePresentKHR(self.ctx.presentation_queue.handle, &present_info);
 
         // Get next frame (use % to keep the current frame below MAX_FRAME_DRAWS)
         self.current_frame = (self.current_frame + 1) % MAX_FRAME_DRAWS;
     }
 
     pub fn deinit(self: *Self) void {
-        self.device.deviceWaitIdle() catch undefined;
+        self.ctx.device.deviceWaitIdle() catch undefined;
 
         for (0..self.model_list.items.len) |i| {
             self.model_list.items[i].destroy();
@@ -239,16 +238,16 @@ pub const VulkanRenderer = struct {
         }
         self.image_files.deinit();
 
-        self.device.destroySampler(self.texture_sampler, null);
+        self.ctx.device.destroySampler(self.texture_sampler, null);
 
         for (
             self.texture_images.items,
             self.texture_image_memory.items,
             self.texture_image_views.items,
         ) |tex_image, tex_image_memory, tex_image_view| {
-            self.device.destroyImage(tex_image, null);
+            self.ctx.device.destroyImage(tex_image, null);
-            self.device.freeMemory(tex_image_memory, null);
+            self.ctx.device.freeMemory(tex_image_memory, null);
-            self.device.destroyImageView(tex_image_view, null);
+            self.ctx.device.destroyImageView(tex_image_view, null);
         }
 
         self.texture_images.deinit();
@@ -256,9 +255,9 @@ pub const VulkanRenderer = struct {
         self.texture_image_views.deinit();
 
         for (0..self.depth_buffer_image.len) |i| {
-            self.device.destroyImageView(self.depth_buffer_image_view[i], null);
+            self.ctx.device.destroyImageView(self.depth_buffer_image_view[i], null);
-            self.device.destroyImage(self.depth_buffer_image[i], null);
+            self.ctx.device.destroyImage(self.depth_buffer_image[i], null);
-            self.device.freeMemory(self.depth_buffer_image_memory[i], null);
+            self.ctx.device.freeMemory(self.depth_buffer_image_memory[i], null);
         }
 
         self.allocator.free(self.depth_buffer_image);
@@ -266,61 +265,61 @@ pub const VulkanRenderer = struct {
         self.allocator.free(self.depth_buffer_image_view);
 
         for (0..self.colour_buffer_image.len) |i| {
-            self.device.destroyImageView(self.colour_buffer_image_view[i], null);
+            self.ctx.device.destroyImageView(self.colour_buffer_image_view[i], null);
-            self.device.destroyImage(self.colour_buffer_image[i], null);
+            self.ctx.device.destroyImage(self.colour_buffer_image[i], null);
-            self.device.freeMemory(self.colour_buffer_image_memory[i], null);
+            self.ctx.device.freeMemory(self.colour_buffer_image_memory[i], null);
         }
 
         self.allocator.free(self.colour_buffer_image);
         self.allocator.free(self.colour_buffer_image_memory);
         self.allocator.free(self.colour_buffer_image_view);
 
-        self.device.destroyDescriptorPool(self.input_descriptor_pool, null);
+        self.ctx.device.destroyDescriptorPool(self.input_descriptor_pool, null);
-        self.device.destroyDescriptorPool(self.descriptor_pool, null);
+        self.ctx.device.destroyDescriptorPool(self.descriptor_pool, null);
-        self.device.destroyDescriptorSetLayout(self.descriptor_set_layout, null);
+        self.ctx.device.destroyDescriptorSetLayout(self.descriptor_set_layout, null);
-        self.device.destroyDescriptorPool(self.sampler_descriptor_pool, null);
+        self.ctx.device.destroyDescriptorPool(self.sampler_descriptor_pool, null);
-        self.device.destroyDescriptorSetLayout(self.sampler_set_layout, null);
+        self.ctx.device.destroyDescriptorSetLayout(self.sampler_set_layout, null);
-        self.device.destroyDescriptorSetLayout(self.input_set_layout, null);
+        self.ctx.device.destroyDescriptorSetLayout(self.input_set_layout, null);
         self.sampler_descriptor_sets.deinit();
         self.allocator.free(self.input_descriptor_sets);
 
-        for (0..self.swapchain_images.len) |i| {
+        for (0..self.swapchain.swapchain_images.len) |i| {
-            self.device.destroyBuffer(self.vp_uniform_buffer[i], null);
+            self.ctx.device.destroyBuffer(self.vp_uniform_buffer[i], null);
-            self.device.freeMemory(self.vp_uniform_buffer_memory[i], null);
+            self.ctx.device.freeMemory(self.vp_uniform_buffer_memory[i], null);
         }
         self.allocator.free(self.vp_uniform_buffer);
         self.allocator.free(self.vp_uniform_buffer_memory);
         self.allocator.free(self.descriptor_sets);
 
         for (0..MAX_FRAME_DRAWS) |i| {
-            self.device.destroySemaphore(self.render_finished[i], null);
+            self.ctx.device.destroySemaphore(self.render_finished[i], null);
-            self.device.destroySemaphore(self.image_available[i], null);
+            self.ctx.device.destroySemaphore(self.image_available[i], null);
-            self.device.destroyFence(self.draw_fences[i], null);
+            self.ctx.device.destroyFence(self.draw_fences[i], null);
         }
 
         self.allocator.free(self.command_buffers);
-        self.device.destroyCommandPool(self.graphics_command_pool, null);
+        self.ctx.device.destroyCommandPool(self.graphics_command_pool, null);
 
-        for (self.swapchain_framebuffers) |framebuffer| {
+        for (self.swapchain.swapchain_framebuffers) |framebuffer| {
-            self.device.destroyFramebuffer(framebuffer, null);
+            self.ctx.device.destroyFramebuffer(framebuffer, null);
         }
 
-        self.allocator.free(self.swapchain_framebuffers);
+        self.allocator.free(self.swapchain.swapchain_framebuffers);
 
-        self.device.destroyPipeline(self.second_pipeline, null);
+        self.ctx.device.destroyPipeline(self.second_pipeline, null);
-        self.device.destroyPipelineLayout(self.second_pipeline_layout, null);
+        self.ctx.device.destroyPipelineLayout(self.second_pipeline_layout, null);
-        self.device.destroyPipeline(self.graphics_pipeline, null);
+        self.ctx.device.destroyPipeline(self.graphics_pipeline, null);
-        self.device.destroyPipelineLayout(self.pipeline_layout, null);
+        self.ctx.device.destroyPipelineLayout(self.pipeline_layout, null);
-        self.device.destroyRenderPass(self.render_pass, null);
+        self.ctx.device.destroyRenderPass(self.render_pass, null);
 
-        for (self.swapchain_images) |swapchain_image| {
+        for (self.swapchain.swapchain_images) |swapchain_image| {
-            self.device.destroyImageView(swapchain_image.image_view, null);
+            self.ctx.device.destroyImageView(swapchain_image.image_view, null);
         }
 
-        self.allocator.free(self.swapchain_images);
+        self.allocator.free(self.swapchain.swapchain_images);
-        self.device.destroySwapchainKHR(self.swapchain, null);
+        self.ctx.device.destroySwapchainKHR(self.swapchain.handle, null);
 
-        self.context.deinit();
+        self.ctx.deinit();
     }
 
     fn createRenderPass(self: *Self) !void {
@@ -332,8 +331,8 @@ pub const VulkanRenderer = struct {
 
         // Colour attachment (input)
         const colour_format = chooseSupportedFormat(
-            self.physical_device,
+            self.ctx.physical_device,
-            self.instance,
+            self.ctx.instance,
             &[_]vk.Format{.r8g8b8a8_srgb},
             .optimal,
             .{ .color_attachment_bit = true },
@@ -384,7 +383,7 @@ pub const VulkanRenderer = struct {
 
         // Colour attachment of the render pass
         const swapchain_colour_attachment: vk.AttachmentDescription = .{
-            .format = self.swapchain_image_format, // Format to use for attachment
+            .format = self.swapchain.swapchain_image_format, // Format to use for attachment
             .samples = .{ .@"1_bit" = true }, // Number of samples to write for multisampling
             .load_op = .clear, // Describes what to do with attachment before rendering
             .store_op = .store, // Describes what to do with attachment after rendering
@@ -471,7 +470,7 @@ pub const VulkanRenderer = struct {
             .p_dependencies = &subpass_dependencies,
         };
 
-        self.render_pass = try self.device.createRenderPass(&render_pass_create_info, null);
+        self.render_pass = try self.ctx.device.createRenderPass(&render_pass_create_info, null);
     }
 
     fn createDescriptorSetLayout(self: *Self) !void {
@@ -495,7 +494,7 @@ pub const VulkanRenderer = struct {
         };
 
         // Create descriptor set layout
-        self.descriptor_set_layout = try self.device.createDescriptorSetLayout(&layout_create_info, null);
+        self.descriptor_set_layout = try self.ctx.device.createDescriptorSetLayout(&layout_create_info, null);
 
         // -- Texture sampler descriptor set layout --
 
@@ -514,7 +513,7 @@ pub const VulkanRenderer = struct {
             .p_bindings = @ptrCast(&sampler_layout_binding),
         };
 
-        self.sampler_set_layout = try self.device.createDescriptorSetLayout(&texture_layout_info, null);
+        self.sampler_set_layout = try self.ctx.device.createDescriptorSetLayout(&texture_layout_info, null);
 
         // -- Create input attachment image descriptor set layout
         // Colour input binding
@@ -542,7 +541,7 @@ pub const VulkanRenderer = struct {
             .p_bindings = &input_bindings,
         };
 
-        self.input_set_layout = try self.device.createDescriptorSetLayout(&input_layout_create_info, null);
+        self.input_set_layout = try self.ctx.device.createDescriptorSetLayout(&input_layout_create_info, null);
     }
 
     fn createPushConstantRange(self: *Self) !void {
@@ -555,14 +554,14 @@ pub const VulkanRenderer = struct {
     }
 
     fn createColourBufferImage(self: *Self) !void {
-        self.colour_buffer_image = try self.allocator.alloc(vk.Image, self.swapchain_images.len);
+        self.colour_buffer_image = try self.allocator.alloc(vk.Image, self.swapchain.swapchain_images.len);
-        self.colour_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain_images.len);
+        self.colour_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain.swapchain_images.len);
-        self.colour_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain_images.len);
+        self.colour_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain.swapchain_images.len);
 
         // Get supported format for colour attachment
         const colour_format = chooseSupportedFormat(
-            self.physical_device,
+            self.ctx.physical_device,
-            self.instance,
+            self.ctx.instance,
             &[_]vk.Format{.r8g8b8a8_srgb},
             .optimal,
             .{ .color_attachment_bit = true },
@@ -570,9 +569,9 @@ pub const VulkanRenderer = struct {
 
         // Create colour buffers
         for (0..self.colour_buffer_image.len) |i| {
-            self.colour_buffer_image[i] = try self.createImage(
+            self.colour_buffer_image[i] = try self.swapchain.createImage(
-                self.extent.width,
+                self.swapchain.extent.width,
-                self.extent.height,
+                self.swapchain.extent.height,
                 colour_format,
                 .optimal,
                 .{ .color_attachment_bit = true, .input_attachment_bit = true },
@@ -580,7 +579,7 @@ pub const VulkanRenderer = struct {
                 &self.colour_buffer_image_memory[i],
             );
 
-            self.colour_buffer_image_view[i] = try self.createImageView(
+            self.colour_buffer_image_view[i] = try self.swapchain.createImageView(
                 self.colour_buffer_image[i],
                 colour_format,
                 .{ .color_bit = true },
@@ -589,15 +588,15 @@ pub const VulkanRenderer = struct {
     }
 
     fn createDepthBufferImage(self: *Self) !void {
-        self.depth_buffer_image = try self.allocator.alloc(vk.Image, self.swapchain_images.len);
+        self.depth_buffer_image = try self.allocator.alloc(vk.Image, self.swapchain.swapchain_images.len);
-        self.depth_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain_images.len);
+        self.depth_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain.swapchain_images.len);
-        self.depth_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain_images.len);
+        self.depth_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain.swapchain_images.len);
 
         // Get supported depth buffer format
         const formats = [_]vk.Format{ .d32_sfloat_s8_uint, .d32_sfloat, .d24_unorm_s8_uint };
         self.depth_format = chooseSupportedFormat(
-            self.physical_device,
+            self.ctx.physical_device,
-            self.instance,
+            self.ctx.instance,
             &formats,
             .optimal,
             .{ .depth_stencil_attachment_bit = true },
@@ -605,9 +604,9 @@ pub const VulkanRenderer = struct {
 
         for (0..self.depth_buffer_image.len) |i| {
             // Create depth buffer image
-            self.depth_buffer_image[i] = try self.createImage(
+            self.depth_buffer_image[i] = try self.swapchain.createImage(
-                self.extent.width,
+                self.swapchain.extent.width,
-                self.extent.height,
+                self.swapchain.extent.height,
                 self.depth_format,
                 .optimal,
                 .{ .depth_stencil_attachment_bit = true, .input_attachment_bit = true },
@@ -616,23 +615,23 @@ pub const VulkanRenderer = struct {
             );
 
             // Create depth buffer image view
-            self.depth_buffer_image_view[i] = try self.createImageView(self.depth_buffer_image[i], self.depth_format, .{ .depth_bit = true });
+            self.depth_buffer_image_view[i] = try self.swapchain.createImageView(self.depth_buffer_image[i], self.depth_format, .{ .depth_bit = true });
         }
     }
 
     fn createGraphicsPipeline(self: *Self) !void {
         // Create shader modules
-        const vert = try self.device.createShaderModule(&.{
+        const vert = try self.ctx.device.createShaderModule(&.{
             .code_size = shaders.shader_vert.len,
             .p_code = @ptrCast(&shaders.shader_vert),
         }, null);
-        defer self.device.destroyShaderModule(vert, null);
+        defer self.ctx.device.destroyShaderModule(vert, null);
 
-        const frag = try self.device.createShaderModule(&.{
+        const frag = try self.ctx.device.createShaderModule(&.{
             .code_size = shaders.shader_frag.len,
             .p_code = @ptrCast(&shaders.shader_frag),
         }, null);
-        defer self.device.destroyShaderModule(frag, null);
+        defer self.ctx.device.destroyShaderModule(frag, null);
 
         // -- Shader stage creation information --
 
@@ -707,15 +706,15 @@ pub const VulkanRenderer = struct {
         self.viewport = .{
             .x = 0.0,
             .y = 0.0,
-            .width = @floatFromInt(self.extent.width),
+            .width = @floatFromInt(self.swapchain.extent.width),
-            .height = @floatFromInt(self.extent.height),
+            .height = @floatFromInt(self.swapchain.extent.height),
             .min_depth = 0.0,
             .max_depth = 1.0,
         };
 
         self.scissor = .{
             .offset = .{ .x = 0, .y = 0 },
-            .extent = self.extent,
+            .extent = self.swapchain.extent,
         };
 
         const viewport_state_create_info: vk.PipelineViewportStateCreateInfo = .{
@@ -793,7 +792,7 @@ pub const VulkanRenderer = struct {
             .p_push_constant_ranges = @ptrCast(&self.push_constant_range),
         };
 
-        self.pipeline_layout = try self.device.createPipelineLayout(&pipeline_layout_create_info, null);
+        self.pipeline_layout = try self.ctx.device.createPipelineLayout(&pipeline_layout_create_info, null);
 
         // -- Depth stencil testing --
         var depth_stencil_create_info: vk.PipelineDepthStencilStateCreateInfo = .{
@@ -828,7 +827,7 @@ pub const VulkanRenderer = struct {
             .base_pipeline_index = -1, // Or index of pipeline being created to derive from (in case creating multiple at once)
         };
 
-        _ = try self.device.createGraphicsPipelines(
+        _ = try self.ctx.device.createGraphicsPipelines(
             .null_handle,
             1,
             @ptrCast(&pipeline_create_info),
@@ -838,17 +837,17 @@ pub const VulkanRenderer = struct {
 
         // -- Create second pass pipeline
         // Second pass shaders
-        const second_vert_shader_module = try self.device.createShaderModule(&.{
+        const second_vert_shader_module = try self.ctx.device.createShaderModule(&.{
             .code_size = shaders.second_vert.len,
             .p_code = @ptrCast(&shaders.second_vert),
         }, null);
-        defer self.device.destroyShaderModule(second_vert_shader_module, null);
+        defer self.ctx.device.destroyShaderModule(second_vert_shader_module, null);
 
-        const second_frag_shader_module = try self.device.createShaderModule(&.{
+        const second_frag_shader_module = try self.ctx.device.createShaderModule(&.{
             .code_size = shaders.second_frag.len,
             .p_code = @ptrCast(&shaders.second_frag),
         }, null);
-        defer self.device.destroyShaderModule(second_frag_shader_module, null);
+        defer self.ctx.device.destroyShaderModule(second_frag_shader_module, null);
 
         // Set new shaders
         vertex_shader_create_info.module = second_vert_shader_module;
@@ -871,7 +870,7 @@ pub const VulkanRenderer = struct {
             .p_set_layouts = @ptrCast(&self.input_set_layout),
         };
 
-        self.second_pipeline_layout = try self.device.createPipelineLayout(&second_pipeline_layout_create_info, null);
+        self.second_pipeline_layout = try self.ctx.device.createPipelineLayout(&second_pipeline_layout_create_info, null);
 
         pipeline_create_info.stage_count = @intCast(second_shader_stages.len);
         pipeline_create_info.p_stages = &second_shader_stages;
@@ -879,7 +878,7 @@ pub const VulkanRenderer = struct {
         pipeline_create_info.subpass = 1;
 
         // Create second pipeline
-        _ = try self.device.createGraphicsPipelines(
+        _ = try self.ctx.device.createGraphicsPipelines(
             .null_handle,
             1,
             @ptrCast(&pipeline_create_info),
@@ -889,10 +888,10 @@ pub const VulkanRenderer = struct {
     }
 
     fn createFramebuffers(self: *Self) !void {
-        self.swapchain_framebuffers = try self.allocator.alloc(vk.Framebuffer, self.swapchain_images.len);
+        self.swapchain.swapchain_framebuffers = try self.allocator.alloc(vk.Framebuffer, self.swapchain.swapchain_images.len);
 
         // Create a frammebuffer for each swapchain image
-        for (self.swapchain_images, 0..) |swapchain_image, i| {
+        for (self.swapchain.swapchain_images, 0..) |swapchain_image, i| {
             // Order matters
             const attachments = [_]vk.ImageView{
                 swapchain_image.image_view,
@@ -904,18 +903,18 @@ pub const VulkanRenderer = struct {
                 .render_pass = self.render_pass, // Render pass layout the frambuffer will be used with
                 .attachment_count = @intCast(attachments.len),
                 .p_attachments = &attachments, // List of attachments (1:1 with render pass)
-                .width = self.extent.width, // Framebuffer width
+                .width = self.swapchain.extent.width, // Framebuffer width
-                .height = self.extent.height, // Framebuffer height
+                .height = self.swapchain.extent.height, // Framebuffer height
                 .layers = 1, // Framebuffer layers
             };
 
-            self.swapchain_framebuffers[i] = try self.device.createFramebuffer(&framebuffer_create_info, null);
+            self.swapchain.swapchain_framebuffers[i] = try self.ctx.device.createFramebuffer(&framebuffer_create_info, null);
         }
     }
 
     fn createCommandPool(self: *Self) !void {
         // Get indices of queue families from device
-        const queue_family_indices = try self.getQueueFamilies(self.physical_device);
+        const queue_family_indices = try QueueUtils.getQueueFamilies(self.ctx, self.ctx.physical_device);
 
         const pool_create_info: vk.CommandPoolCreateInfo = .{
             // Queue family type that buffers from this command pool will use
@@ -924,12 +923,12 @@ pub const VulkanRenderer = struct {
         };
 
         // Create a graphics queue family command pool
-        self.graphics_command_pool = try self.device.createCommandPool(&pool_create_info, null);
+        self.graphics_command_pool = try self.ctx.device.createCommandPool(&pool_create_info, null);
     }
 
     fn createCommandBuffers(self: *Self) !void {
         // Allocate one command buffer for each framebuffer
-        const command_buffer_handles = try self.allocator.alloc(vk.CommandBuffer, self.swapchain_framebuffers.len);
+        const command_buffer_handles = try self.allocator.alloc(vk.CommandBuffer, self.swapchain.swapchain_framebuffers.len);
         defer self.allocator.free(command_buffer_handles);
         self.command_buffers = try self.allocator.alloc(CommandBuffer, command_buffer_handles.len);
 
@@ -940,9 +939,9 @@ pub const VulkanRenderer = struct {
         };
 
         // Allocate command buffers and place handles in array of buffers
-        try self.device.allocateCommandBuffers(&command_buffer_allocate_info, command_buffer_handles.ptr);
+        try self.ctx.device.allocateCommandBuffers(&command_buffer_allocate_info, command_buffer_handles.ptr);
         for (command_buffer_handles, 0..) |command_buffer_handle, i| {
-            self.command_buffers[i] = CommandBuffer.init(command_buffer_handle, self.device.wrapper);
+            self.command_buffers[i] = CommandBuffer.init(command_buffer_handle, self.ctx.device.wrapper);
         }
     }
 
@@ -952,9 +951,9 @@ pub const VulkanRenderer = struct {
 
         // Semaphore creation information
         for (0..MAX_FRAME_DRAWS) |i| {
-            self.image_available[i] = try self.device.createSemaphore(&.{}, null);
+            self.image_available[i] = try self.ctx.device.createSemaphore(&.{}, null);
-            self.render_finished[i] = try self.device.createSemaphore(&.{}, null);
+            self.render_finished[i] = try self.ctx.device.createSemaphore(&.{}, null);
-            self.draw_fences[i] = try self.device.createFence(&fence_create_info, null);
+            self.draw_fences[i] = try self.ctx.device.createFence(&fence_create_info, null);
         }
     }
 
@@ -978,7 +977,7 @@ pub const VulkanRenderer = struct {
             .compare_op = .never,
         };
 
-        self.texture_sampler = try self.device.createSampler(&sampler_create_info, null);
+        self.texture_sampler = try self.ctx.device.createSampler(&sampler_create_info, null);
     }
 
     fn createUniformBuffers(self: *Self) !void {
@@ -986,15 +985,15 @@ pub const VulkanRenderer = struct {
         const vp_buffer_size: vk.DeviceSize = @sizeOf(UboViewProjection);
 
         // One uniform buffer for each image (and by extension, command buffer)
-        self.vp_uniform_buffer = try self.allocator.alloc(vk.Buffer, self.swapchain_images.len);
+        self.vp_uniform_buffer = try self.allocator.alloc(vk.Buffer, self.swapchain.swapchain_images.len);
-        self.vp_uniform_buffer_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain_images.len);
+        self.vp_uniform_buffer_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain.swapchain_images.len);
 
         // Create the uniform buffers
         for (0..self.vp_uniform_buffer.len) |i| {
             try Utilities.createBuffer(
-                self.physical_device,
+                self.ctx.physical_device,
-                self.instance,
+                self.ctx.instance,
-                self.device,
+                self.ctx.device,
                 vp_buffer_size,
                 .{ .uniform_buffer_bit = true },
                 .{ .host_visible_bit = true, .host_coherent_bit = true },
@@ -1019,13 +1018,13 @@ pub const VulkanRenderer = struct {
 
         // Data to create descriptor pool
         const pool_create_info: vk.DescriptorPoolCreateInfo = .{
-            .max_sets = @intCast(self.swapchain_images.len), // Maximum number of descriptor sets that can be created from pool
+            .max_sets = @intCast(self.swapchain.swapchain_images.len), // Maximum number of descriptor sets that can be created from pool
             .pool_size_count = @intCast(descriptor_pool_sizes.len), // Amount of pool sizes being passed
             .p_pool_sizes = &descriptor_pool_sizes, // Pool sizes to create pool with
         };
 
         // Create descriptor pool
-        self.descriptor_pool = try self.device.createDescriptorPool(&pool_create_info, null);
+        self.descriptor_pool = try self.ctx.device.createDescriptorPool(&pool_create_info, null);
 
         // -- Create sampler descriptor pool --
 
@@ -1042,7 +1041,7 @@ pub const VulkanRenderer = struct {
             .p_pool_sizes = @ptrCast(&sampler_pool_size),
         };
 
-        self.sampler_descriptor_pool = try self.device.createDescriptorPool(&sampler_pool_create_info, null);
+        self.sampler_descriptor_pool = try self.ctx.device.createDescriptorPool(&sampler_pool_create_info, null);
 
         // -- Create input attachment descriptor pool
         // Colour attachment pool size
@@ -1061,19 +1060,19 @@ pub const VulkanRenderer = struct {
 
         // Create input attachment pool
         const input_pool_create_info: vk.DescriptorPoolCreateInfo = .{
-            .max_sets = @intCast(self.swapchain_images.len),
+            .max_sets = @intCast(self.swapchain.swapchain_images.len),
             .pool_size_count = @intCast(input_pool_sizes.len),
             .p_pool_sizes = &input_pool_sizes,
         };
 
-        self.input_descriptor_pool = try self.device.createDescriptorPool(&input_pool_create_info, null);
+        self.input_descriptor_pool = try self.ctx.device.createDescriptorPool(&input_pool_create_info, null);
     }
 
     fn createDescriptorSets(self: *Self) !void {
         // One descriptor set for every buffer
-        self.descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain_images.len);
+        self.descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain.swapchain_images.len);
 
-        var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain_images.len);
+        var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain.swapchain_images.len);
         defer self.allocator.free(set_layouts);
         for (0..set_layouts.len) |i| {
             set_layouts[i] = self.descriptor_set_layout;
@@ -1082,15 +1081,15 @@ pub const VulkanRenderer = struct {
         // Descriptor set allocation info
         const set_alloc_info: vk.DescriptorSetAllocateInfo = .{
             .descriptor_pool = self.descriptor_pool, // Pool to allocate descriptor set from
-            .descriptor_set_count = @intCast(self.swapchain_images.len), // Number of sets to allocate
+            .descriptor_set_count = @intCast(self.swapchain.swapchain_images.len), // Number of sets to allocate
             .p_set_layouts = set_layouts.ptr, // Layouts to use to allocate sets (1:1 relationship)
         };
 
         // Allocate descriptor sets (multiple)
-        try self.device.allocateDescriptorSets(&set_alloc_info, self.descriptor_sets.ptr);
+        try self.ctx.device.allocateDescriptorSets(&set_alloc_info, self.descriptor_sets.ptr);
 
         // Update all of descriptor set buffer bindings
-        for (0..self.swapchain_images.len) |i| {
+        for (0..self.swapchain.swapchain_images.len) |i| {
             // -- View projection descriptor
             // Buffer info and data offset info
             const vp_buffer_info: vk.DescriptorBufferInfo = .{
@@ -1115,15 +1114,15 @@ pub const VulkanRenderer = struct {
             const set_writes = [_]vk.WriteDescriptorSet{vp_set_write};
 
             // Update the descriptor sets with new buffer/binding info
-            self.device.updateDescriptorSets(@intCast(set_writes.len), &set_writes, 0, null);
+            self.ctx.device.updateDescriptorSets(@intCast(set_writes.len), &set_writes, 0, null);
         }
     }
 
     fn createInputDescriptorSets(self: *Self) !void {
-        self.input_descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain_images.len);
+        self.input_descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain.swapchain_images.len);
 
         // Fill array of layouts ready for set creation
-        var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain_images.len);
+        var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain.swapchain_images.len);
         defer self.allocator.free(set_layouts);
         for (0..set_layouts.len) |i| {
             set_layouts[i] = self.input_set_layout;
@@ -1132,15 +1131,15 @@ pub const VulkanRenderer = struct {
         // Input attachment descriptor set allocation info
         const set_alloc_info: vk.DescriptorSetAllocateInfo = .{
             .descriptor_pool = self.input_descriptor_pool,
-            .descriptor_set_count = @intCast(self.swapchain_images.len),
+            .descriptor_set_count = @intCast(self.swapchain.swapchain_images.len),
             .p_set_layouts = set_layouts.ptr,
         };
 
         // Allocate descriptor sets
-        try self.device.allocateDescriptorSets(&set_alloc_info, self.input_descriptor_sets.ptr);
+        try self.ctx.device.allocateDescriptorSets(&set_alloc_info, self.input_descriptor_sets.ptr);
 
         // Update each descriptor set with input attachment
-        for (0..self.swapchain_images.len) |i| {
+        for (0..self.swapchain.swapchain_images.len) |i| {
             // Colour attachment descriptor
             const colour_attachment_descriptor: vk.DescriptorImageInfo = .{
                 .image_layout = .shader_read_only_optimal,
@@ -1183,13 +1182,13 @@ pub const VulkanRenderer = struct {
             const set_writes = [_]vk.WriteDescriptorSet{ colour_write, depth_write };
 
             // Update descriptor sets
-            self.device.updateDescriptorSets(@intCast(set_writes.len), &set_writes, 0, null);
+            self.ctx.device.updateDescriptorSets(@intCast(set_writes.len), &set_writes, 0, null);
         }
     }
 
     fn updateUniformBuffers(self: *Self, image_index: u32) !void {
         // Copy VP data
-        const data = try self.device.mapMemory(
+        const data = try self.ctx.device.mapMemory(
             self.vp_uniform_buffer_memory[image_index],
             0,
             @sizeOf(UboViewProjection),
@@ -1198,7 +1197,7 @@ pub const VulkanRenderer = struct {
 
         const vp_data: *UboViewProjection = @ptrCast(@alignCast(data));
         vp_data.* = self.ubo_view_projection;
-        self.device.unmapMemory(self.vp_uniform_buffer_memory[image_index]);
+        self.ctx.device.unmapMemory(self.vp_uniform_buffer_memory[image_index]);
     }
 
     fn recordCommands(self: *Self, current_image: u32) !void {
@@ -1219,11 +1218,11 @@ pub const VulkanRenderer = struct {
             .render_pass = self.render_pass, // Render pass to begin
             .render_area = .{
                 .offset = .{ .x = 0, .y = 0 }, // Start point of render pass in pixels
-                .extent = self.extent, // Size of region to run render pass on (starting at offset)
+                .extent = self.swapchain.extent, // Size of region to run render pass on (starting at offset)
             },
             .p_clear_values = &clear_values, // List of clear values
             .clear_value_count = @intCast(clear_values.len),
-            .framebuffer = self.swapchain_framebuffers[current_image],
+            .framebuffer = self.swapchain.swapchain_framebuffers[current_image],
         };
 
         const command_buffer = self.command_buffers[current_image];
@@ -1307,78 +1306,6 @@ pub const VulkanRenderer = struct {
         try command_buffer.endCommandBuffer();
     }
 
-    fn createImage(
-        self: *Self,
-        width: u32,
-        height: u32,
-        format: vk.Format,
-        tiling: vk.ImageTiling,
-        use_flags: vk.ImageUsageFlags,
-        prop_flags: vk.MemoryPropertyFlags,
-        image_memory: *vk.DeviceMemory,
-    ) !vk.Image {
-        // -- Create Image --
-        const image_create_info: vk.ImageCreateInfo = .{
-            .image_type = .@"2d", // Type of image (1D, 2D or 3D)
-            .extent = .{
-                .width = width, // Width of image extent
-                .height = height, // Height of image extent
-                .depth = 1, // Depth of image (just 1, no 3D aspecct)
-            },
-            .mip_levels = 1, // Number of mipmap levels
-            .array_layers = 1, // Number of level in image array
-            .format = format, // Format type of image
-            .tiling = tiling, // How image data should be tiled (arranged for optimal reading)
-            .initial_layout = .undefined, // Layout of image data on creation
-            .usage = use_flags, // Bit flags defining what image will be used for
-            .samples = .{ .@"1_bit" = true }, // Number of samples for multi-sampling
-            .sharing_mode = .exclusive, // Whether image can be shared between queues
-        };
-
-        const image = try self.device.createImage(&image_create_info, null);
-
-        // -- Create memory for image --
-        // Get memory requirements for a type of image
-        const memory_requirements = self.device.getImageMemoryRequirements(image);
-
-        // Allocate memory using image requirements and user-defined properties
-        const memory_alloc_info: vk.MemoryAllocateInfo = .{
-            .allocation_size = memory_requirements.size,
-            .memory_type_index = Utilities.findMemoryTypeIndex(self.physical_device, self.instance, memory_requirements.memory_type_bits, prop_flags),
-        };
-
-        image_memory.* = try self.device.allocateMemory(&memory_alloc_info, null);
-
-        // Connect memory to image
-        try self.device.bindImageMemory(image, image_memory.*, 0);
-
-        return image;
-    }
-
-    fn createImageView(self: Self, image: vk.Image, format: vk.Format, aspect_flags: vk.ImageAspectFlags) !vk.ImageView {
-        const image_view_create_info: vk.ImageViewCreateInfo = .{
-            .image = image,
-            .format = format,
-            .view_type = .@"2d",
-            .components = .{
-                // Used for remapping rgba values to other rgba values
-                .r = .identity,
-                .g = .identity,
-                .b = .identity,
-                .a = .identity,
-            },
-            .subresource_range = .{
-                .aspect_mask = aspect_flags, // Which aspect of image to view (e.g.: colour, depth, stencil, etc...)
-                .base_mip_level = 0, // Start mipmap level to view from
-                .level_count = 1, // Number of mipmap levels to view
-                .base_array_layer = 0, // Start array level to view from
-                .layer_count = 1, // Number of array levels to view
-            },
-        };
-
-        return try self.device.createImageView(&image_view_create_info, null);
-    }
-
     fn createTextureImage(self: *Self, file_name: []const u8) !u32 {
         // Load image file
         var width: u32 = undefined;
@@ -1389,13 +1316,13 @@ pub const VulkanRenderer = struct {
         // Create staging buffer to hold loaded data, ready to copy to device
         var image_staging_buffer: vk.Buffer = undefined;
         var image_staging_buffer_memory: vk.DeviceMemory = undefined;
-        defer self.device.destroyBuffer(image_staging_buffer, null);
+        defer self.ctx.device.destroyBuffer(image_staging_buffer, null);
-        defer self.device.freeMemory(image_staging_buffer_memory, null);
+        defer self.ctx.device.freeMemory(image_staging_buffer_memory, null);
 
         try Utilities.createBuffer(
-            self.physical_device,
+            self.ctx.physical_device,
-            self.instance,
+            self.ctx.instance,
-            self.device,
+            self.ctx.device,
             image_size,
             .{ .transfer_src_bit = true },
             .{ .host_visible_bit = true, .host_coherent_bit = true },
@@ -1404,15 +1331,15 @@ pub const VulkanRenderer = struct {
         );
 
         // Copy data to staging buffer
-        const data = try self.device.mapMemory(image_staging_buffer_memory, 0, image_size, .{});
+        const data = try self.ctx.device.mapMemory(image_staging_buffer_memory, 0, image_size, .{});
         const image_data: [*]u8 = @ptrCast(@alignCast(data));
 
         @memcpy(image_data, image[0..]);
-        self.device.unmapMemory(image_staging_buffer_memory);
+        self.ctx.device.unmapMemory(image_staging_buffer_memory);
 
         // Create image to hold final texture
         var tex_image_memory: vk.DeviceMemory = undefined;
-        const tex_image: vk.Image = try self.createImage(
+        const tex_image: vk.Image = try self.swapchain.createImage(
             width,
             height,
             .r8g8b8a8_srgb,
@@ -1424,8 +1351,8 @@ pub const VulkanRenderer = struct {
 
         // Transition image to be DST for copy operation
         try Utilities.transitionImageLayout(
-            self.device,
+            self.ctx.device,
-            self.graphics_queue.handle,
+            self.ctx.graphics_queue.handle,
             self.graphics_command_pool,
             tex_image,
             .undefined,
@@ -1434,8 +1361,8 @@ pub const VulkanRenderer = struct {
 
         // Copy data to image
         try Utilities.copyImageBuffer(
-            self.device,
+            self.ctx.device,
-            self.graphics_queue.handle,
+            self.ctx.graphics_queue.handle,
             self.graphics_command_pool,
             image_staging_buffer,
             tex_image,
@@ -1445,8 +1372,8 @@ pub const VulkanRenderer = struct {
 
         // Transition image to be shader readable for shader usage
         try Utilities.transitionImageLayout(
-            self.device,
+            self.ctx.device,
-            self.graphics_queue.handle,
+            self.ctx.graphics_queue.handle,
             self.graphics_command_pool,
             tex_image,
             .transfer_dst_optimal,
@@ -1466,7 +1393,7 @@ pub const VulkanRenderer = struct {
         const texture_image_loc = try self.createTextureImage(file_name);
 
         // Create image view and add to list
-        const image_view = try self.createImageView(
+        const image_view = try self.swapchain.createImageView(
             self.texture_images.items[texture_image_loc],
             .r8g8b8a8_srgb,
             .{ .color_bit = true },
@@ -1522,10 +1449,10 @@ pub const VulkanRenderer = struct {
         // Load in all our meshes
         const model_meshes = try MeshModel.loadNode(
             self.allocator,
-            self.instance,
+            self.ctx.instance,
-            self.physical_device,
+            self.ctx.physical_device,
-            self.device,
+            self.ctx.device,
-            self.graphics_queue.handle,
+            self.ctx.graphics_queue.handle,
             self.graphics_command_pool,
             scene.*.mRootNode,
             scene,
@@ -1550,7 +1477,7 @@ pub const VulkanRenderer = struct {
         };
 
         // Allocate descriptor sets
-        try self.device.allocateDescriptorSets(&set_alloc_info, @ptrCast(&descriptor_set));
+        try self.ctx.device.allocateDescriptorSets(&set_alloc_info, @ptrCast(&descriptor_set));
 
         const image_info: vk.DescriptorImageInfo = .{
             .image_layout = .shader_read_only_optimal, // Image layout when in use
@@ -1571,7 +1498,7 @@ pub const VulkanRenderer = struct {
         };
 
         // Update the new descriptor set
-        self.device.updateDescriptorSets(1, @ptrCast(&descriptor_write), 0, null);
+        self.ctx.device.updateDescriptorSets(1, @ptrCast(&descriptor_write), 0, null);
 
         try self.sampler_descriptor_sets.append(descriptor_set);