Continue refactor
This commit is contained in:
parent
34135fa83e
commit
525fe1cc25
7 changed files with 96 additions and 109 deletions
|
|
@ -5,7 +5,7 @@ const vk = @import("vulkan");
|
|||
const sdl = @import("sdl");
|
||||
const img = @import("zstbi");
|
||||
|
||||
const validation = @import("./validation_layers.zig");
|
||||
const validation = @import("validation_layers.zig");
|
||||
const Swapchain = @import("Swapchain.zig");
|
||||
const QueueUtils = @import("queue_utils.zig");
|
||||
|
||||
|
|
@ -46,9 +46,11 @@ instance: Instance,
|
|||
physical_device: vk.PhysicalDevice,
|
||||
device: Device,
|
||||
|
||||
command_pool: vk.CommandPool,
|
||||
graphics_queue: Queue,
|
||||
presentation_queue: Queue,
|
||||
surface: vk.SurfaceKHR,
|
||||
swapchain: Swapchain,
|
||||
|
||||
debug_utils: ?vk.DebugUtilsMessengerEXT,
|
||||
|
||||
|
|
@ -71,6 +73,7 @@ pub fn init(allocator: std.mem.Allocator, window: sdl.Window) !Self {
|
|||
|
||||
try self.getPhysicalDevice();
|
||||
try self.createLogicalDevice();
|
||||
self.swapchain = try Swapchain.create(allocator, self);
|
||||
|
||||
return self;
|
||||
}
|
||||
|
|
@ -212,6 +215,20 @@ fn createLogicalDevice(self: *Self) !void {
|
|||
self.presentation_queue = Queue.init(queues[1], self.device.wrapper);
|
||||
}
|
||||
|
||||
fn createCommandPool(self: *Self) !void {
|
||||
// Get indices of queue families from device
|
||||
const queue_family_indices = try QueueUtils.getQueueFamilies(self.*, self.physical_device);
|
||||
|
||||
const pool_create_info: vk.CommandPoolCreateInfo = .{
|
||||
// Queue family type that buffers from this command pool will use
|
||||
.queue_family_index = queue_family_indices.graphics_family.?,
|
||||
.flags = .{ .reset_command_buffer_bit = true },
|
||||
};
|
||||
|
||||
// Create a graphics queue family command pool
|
||||
self.graphics_command_pool = try self.device.createCommandPool(&pool_create_info, null);
|
||||
}
|
||||
|
||||
fn getRequiredExtensions(self: Self) ![][*:0]const u8 {
|
||||
var ext_count = sdl.vulkan.getInstanceExtensionsCount(self.window);
|
||||
|
||||
|
|
|
|||
61
src/Mesh.zig
61
src/Mesh.zig
|
|
@ -2,6 +2,7 @@ const std = @import("std");
|
|||
const vk = @import("vulkan");
|
||||
const zm = @import("zmath");
|
||||
|
||||
const Context = @import("Context.zig");
|
||||
const Utilities = @import("utilities.zig");
|
||||
const Vertex = Utilities.Vertex;
|
||||
const Device = @import("Context.zig").Device;
|
||||
|
|
@ -11,7 +12,6 @@ const Model = @import("vulkan_renderer.zig").Model;
|
|||
const Self = @This();
|
||||
|
||||
ubo_model: Model,
|
||||
tex_id: u32,
|
||||
|
||||
vertex_count: u32,
|
||||
vertex_buffer: vk.Buffer,
|
||||
|
|
@ -21,17 +21,13 @@ index_count: u32,
|
|||
index_buffer: vk.Buffer,
|
||||
index_buffer_memory: vk.DeviceMemory,
|
||||
|
||||
instance: Instance,
|
||||
physical_device: vk.PhysicalDevice,
|
||||
device: Device,
|
||||
ctx: Context,
|
||||
|
||||
allocator: std.mem.Allocator,
|
||||
|
||||
pub fn create(
|
||||
allocator: std.mem.Allocator,
|
||||
instance: Instance,
|
||||
pdev: vk.PhysicalDevice,
|
||||
device: Device,
|
||||
ctx: Context,
|
||||
transfer_queue: vk.Queue,
|
||||
transfer_command_pool: vk.CommandPool,
|
||||
vertices: []const Vertex,
|
||||
|
|
@ -40,13 +36,12 @@ pub fn create(
|
|||
) !Self {
|
||||
var self: Self = undefined;
|
||||
|
||||
self.allocator = allocator;
|
||||
|
||||
self.vertex_count = @intCast(vertices.len);
|
||||
self.index_count = @intCast(indices.len);
|
||||
|
||||
self.instance = instance;
|
||||
self.physical_device = pdev;
|
||||
self.device = device;
|
||||
self.allocator = allocator;
|
||||
self.ctx = ctx;
|
||||
|
||||
try self.createVertexBuffer(transfer_queue, transfer_command_pool, vertices);
|
||||
try self.createIndexBuffer(transfer_queue, transfer_command_pool, indices);
|
||||
|
|
@ -58,11 +53,11 @@ pub fn create(
|
|||
}
|
||||
|
||||
pub fn destroy(self: Self) void {
|
||||
self.device.destroyBuffer(self.vertex_buffer, null);
|
||||
self.device.freeMemory(self.vertex_buffer_memory, null);
|
||||
self.ctx.device.destroyBuffer(self.vertex_buffer, null);
|
||||
self.ctx.device.freeMemory(self.vertex_buffer_memory, null);
|
||||
|
||||
self.device.destroyBuffer(self.index_buffer, null);
|
||||
self.device.freeMemory(self.index_buffer_memory, null);
|
||||
self.ctx.device.destroyBuffer(self.index_buffer, null);
|
||||
self.ctx.device.freeMemory(self.index_buffer_memory, null);
|
||||
}
|
||||
|
||||
fn createVertexBuffer(
|
||||
|
|
@ -77,14 +72,12 @@ fn createVertexBuffer(
|
|||
// Temporary buffer to "stage" vertex data before transfering to GPU
|
||||
var staging_buffer: vk.Buffer = undefined;
|
||||
var staging_buffer_memory: vk.DeviceMemory = undefined;
|
||||
defer self.device.destroyBuffer(staging_buffer, null);
|
||||
defer self.device.freeMemory(staging_buffer_memory, null);
|
||||
defer self.ctx.device.destroyBuffer(staging_buffer, null);
|
||||
defer self.ctx.device.freeMemory(staging_buffer_memory, null);
|
||||
|
||||
// Create buffer and allocate memory to it
|
||||
try Utilities.createBuffer(
|
||||
self.physical_device,
|
||||
self.instance,
|
||||
self.device,
|
||||
self.ctx,
|
||||
buffer_size,
|
||||
.{ .transfer_src_bit = true },
|
||||
.{ .host_visible_bit = true, .host_coherent_bit = true },
|
||||
|
|
@ -95,21 +88,19 @@ fn createVertexBuffer(
|
|||
// Map memory to vertex
|
||||
// 1. Create pointer to a point in normal memory
|
||||
// 2. Map the vertex buffer memory to that point
|
||||
const data = try self.device.mapMemory(staging_buffer_memory, 0, buffer_size, .{});
|
||||
const data = try self.ctx.device.mapMemory(staging_buffer_memory, 0, buffer_size, .{});
|
||||
// 3. Copy memory from vertices vector to the point in memory
|
||||
const gpu_vertices: [*]Vertex = @ptrCast(@alignCast(data));
|
||||
@memcpy(gpu_vertices, vertices[0..]);
|
||||
// 4. Unmap the vertex buffer memory
|
||||
self.device.unmapMemory(staging_buffer_memory);
|
||||
self.ctx.device.unmapMemory(staging_buffer_memory);
|
||||
|
||||
// ---
|
||||
|
||||
// Create buffer with TRANSFER_DST_BIT to mark as recipient of transfer data (also VERTEX_BUFFER)
|
||||
// Buffer memory is to be DEVICE_LOCAL_BIT meaning memory is on the GPU and only accessible by it and not CPU (host)
|
||||
try Utilities.createBuffer(
|
||||
self.physical_device,
|
||||
self.instance,
|
||||
self.device,
|
||||
self.ctx,
|
||||
buffer_size,
|
||||
.{ .transfer_dst_bit = true, .vertex_buffer_bit = true },
|
||||
.{ .device_local_bit = true },
|
||||
|
|
@ -119,7 +110,7 @@ fn createVertexBuffer(
|
|||
|
||||
// Copy staging buffer to vertex buffer on GPU
|
||||
try Utilities.copyBuffer(
|
||||
self.device,
|
||||
self.ctx,
|
||||
transfer_queue,
|
||||
transfer_command_pool,
|
||||
staging_buffer,
|
||||
|
|
@ -140,13 +131,11 @@ fn createIndexBuffer(
|
|||
// Temporary buffer to "stage" vertex data before transfering to GPU
|
||||
var staging_buffer: vk.Buffer = undefined;
|
||||
var staging_buffer_memory: vk.DeviceMemory = undefined;
|
||||
defer self.device.destroyBuffer(staging_buffer, null);
|
||||
defer self.device.freeMemory(staging_buffer_memory, null);
|
||||
defer self.ctx.device.destroyBuffer(staging_buffer, null);
|
||||
defer self.ctx.device.freeMemory(staging_buffer_memory, null);
|
||||
|
||||
try Utilities.createBuffer(
|
||||
self.physical_device,
|
||||
self.instance,
|
||||
self.device,
|
||||
self.ctx,
|
||||
buffer_size,
|
||||
.{ .transfer_src_bit = true },
|
||||
.{ .host_visible_bit = true, .host_coherent_bit = true },
|
||||
|
|
@ -155,16 +144,14 @@ fn createIndexBuffer(
|
|||
);
|
||||
|
||||
// Map memory to index buffer
|
||||
const data = try self.device.mapMemory(staging_buffer_memory, 0, buffer_size, .{});
|
||||
const data = try self.ctx.device.mapMemory(staging_buffer_memory, 0, buffer_size, .{});
|
||||
const gpu_vertices: [*]u32 = @ptrCast(@alignCast(data));
|
||||
@memcpy(gpu_vertices, indices[0..]);
|
||||
self.device.unmapMemory(staging_buffer_memory);
|
||||
self.ctx.device.unmapMemory(staging_buffer_memory);
|
||||
|
||||
// Create buffer for index data on GPU access only
|
||||
try Utilities.createBuffer(
|
||||
self.physical_device,
|
||||
self.instance,
|
||||
self.device,
|
||||
self.ctx,
|
||||
buffer_size,
|
||||
.{ .transfer_dst_bit = true, .index_buffer_bit = true },
|
||||
.{ .device_local_bit = true },
|
||||
|
|
@ -174,7 +161,7 @@ fn createIndexBuffer(
|
|||
|
||||
// Copy from staging buffer to GPU access buffer
|
||||
try Utilities.copyBuffer(
|
||||
self.device,
|
||||
self.ctx,
|
||||
transfer_queue,
|
||||
transfer_command_pool,
|
||||
staging_buffer,
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ pub fn new(
|
|||
texture_sampler: vk.Sampler,
|
||||
model_file: []const u8,
|
||||
) Self {
|
||||
_ = texture_sampler;
|
||||
var new_mesh_model: Self = undefined;
|
||||
|
||||
new_mesh_model.allocator = allocator;
|
||||
|
|
|
|||
|
|
@ -41,6 +41,7 @@ pub fn getMesh(self: *Self, file_name: []const u8) !Mesh {
|
|||
}
|
||||
|
||||
// TODO Create mesh
|
||||
// load mesh
|
||||
|
||||
return undefined;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,7 +55,9 @@ pub fn create(
|
|||
return self;
|
||||
}
|
||||
|
||||
pub fn destroy(self: *Self) void {}
|
||||
pub fn destroy(self: *Self) void {
|
||||
_ = self;
|
||||
}
|
||||
|
||||
fn createTextureImage(
|
||||
self: *Self,
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
const std = @import("std");
|
||||
const vk = @import("vulkan");
|
||||
|
||||
const Context = @import("Context.zig");
|
||||
const Instance = @import("Context.zig").Instance;
|
||||
const Device = @import("Context.zig").Device;
|
||||
const CommandBuffer = @import("vulkan_renderer.zig").CommandBuffer;
|
||||
|
|
@ -15,9 +16,9 @@ pub const Vertex = struct {
|
|||
tex: Vector2, // Texture coords (u, v)
|
||||
};
|
||||
|
||||
pub fn findMemoryTypeIndex(pdev: vk.PhysicalDevice, instance: Instance, allowed_types: u32, properties: vk.MemoryPropertyFlags) u32 {
|
||||
pub fn findMemoryTypeIndex(ctx: Context, allowed_types: u32, properties: vk.MemoryPropertyFlags) u32 {
|
||||
// Get properties of physical device memory
|
||||
const memory_properties = instance.getPhysicalDeviceMemoryProperties(pdev);
|
||||
const memory_properties = ctx.instance.getPhysicalDeviceMemoryProperties(ctx.physical_device);
|
||||
const mem_type_count = memory_properties.memory_type_count;
|
||||
|
||||
for (memory_properties.memory_types[0..mem_type_count], 0..mem_type_count) |mem_type, i| {
|
||||
|
|
@ -32,9 +33,7 @@ pub fn findMemoryTypeIndex(pdev: vk.PhysicalDevice, instance: Instance, allowed_
|
|||
}
|
||||
|
||||
pub fn createBuffer(
|
||||
pdev: vk.PhysicalDevice,
|
||||
instance: Instance,
|
||||
device: Device,
|
||||
ctx: Context,
|
||||
buffer_size: vk.DeviceSize,
|
||||
buffer_usage: vk.BufferUsageFlags,
|
||||
buffer_properties: vk.MemoryPropertyFlags,
|
||||
|
|
@ -50,17 +49,16 @@ pub fn createBuffer(
|
|||
.sharing_mode = .exclusive, // Similar to swapchain images, can share vertex buffers
|
||||
};
|
||||
|
||||
buffer.* = try device.createBuffer(&buffer_create_info, null);
|
||||
buffer.* = try ctx.device.createBuffer(&buffer_create_info, null);
|
||||
|
||||
// Get buffer memory requirements
|
||||
const mem_requirements = device.getBufferMemoryRequirements(buffer.*);
|
||||
const mem_requirements = ctx.device.getBufferMemoryRequirements(buffer.*);
|
||||
|
||||
// Allocate memory to buffer
|
||||
const allocate_info: vk.MemoryAllocateInfo = .{
|
||||
.allocation_size = mem_requirements.size,
|
||||
.memory_type_index = findMemoryTypeIndex(
|
||||
pdev,
|
||||
instance,
|
||||
ctx,
|
||||
mem_requirements.memory_type_bits, // Index of memory type of physical device that has required bit flags
|
||||
// Host visible: CPU can interact with memory
|
||||
// Host coherent: Allows placement of data straight into buffer after mapping (otherwise would have to specify manually)
|
||||
|
|
@ -69,10 +67,10 @@ pub fn createBuffer(
|
|||
};
|
||||
|
||||
// Allocate memory to vkDeviceMemory
|
||||
buffer_memory.* = try device.allocateMemory(&allocate_info, null);
|
||||
buffer_memory.* = try ctx.device.allocateMemory(&allocate_info, null);
|
||||
|
||||
// Allocate memory to given vertex buffer
|
||||
try device.bindBufferMemory(buffer.*, buffer_memory.*, 0);
|
||||
try ctx.device.bindBufferMemory(buffer.*, buffer_memory.*, 0);
|
||||
}
|
||||
|
||||
fn beginCommandBuffer(device: Device, command_pool: vk.CommandPool) !CommandBuffer {
|
||||
|
|
|
|||
|
|
@ -43,7 +43,6 @@ pub const VulkanRenderer = struct {
|
|||
current_frame: u32 = 0,
|
||||
|
||||
ctx: Context,
|
||||
swapchain: Swapchain,
|
||||
|
||||
// Scene settings
|
||||
ubo_view_projection: UboViewProjection,
|
||||
|
|
@ -93,9 +92,6 @@ pub const VulkanRenderer = struct {
|
|||
|
||||
render_pass: vk.RenderPass,
|
||||
|
||||
// Pools
|
||||
graphics_command_pool: vk.CommandPool,
|
||||
|
||||
// Utilities
|
||||
depth_format: vk.Format,
|
||||
|
||||
|
|
@ -110,7 +106,6 @@ pub const VulkanRenderer = struct {
|
|||
self.allocator = allocator;
|
||||
self.ctx = try Context.init(allocator, window);
|
||||
self.current_frame = 0;
|
||||
self.swapchain = try Swapchain.create(allocator, self.ctx);
|
||||
|
||||
try self.createColourBufferImage();
|
||||
try self.createDepthBufferImage();
|
||||
|
|
@ -121,7 +116,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.swapchain_images.len);
|
||||
self.sampler_descriptor_sets = try std.ArrayList(vk.DescriptorSet).initCapacity(self.allocator, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
try self.createCommandBuffers();
|
||||
try self.createTextureSampler();
|
||||
|
|
@ -135,7 +130,7 @@ pub const VulkanRenderer = struct {
|
|||
self.textures = std.ArrayList(Texture).init(self.allocator);
|
||||
self.model_list = std.ArrayList(MeshModel).init(allocator);
|
||||
|
||||
const aspect: f32 = @as(f32, @floatFromInt(self.swapchain.extent.width)) / @as(f32, @floatFromInt(self.swapchain.extent.height));
|
||||
const aspect: f32 = @as(f32, @floatFromInt(self.ctx.swapchain.extent.width)) / @as(f32, @floatFromInt(self.ctx.swapchain.extent.height));
|
||||
self.ubo_view_projection.projection = zm.perspectiveFovRh(
|
||||
std.math.degreesToRadians(45.0),
|
||||
aspect,
|
||||
|
|
@ -180,7 +175,7 @@ pub const VulkanRenderer = struct {
|
|||
// -- 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.ctx.device.acquireNextImageKHR(
|
||||
self.swapchain.handle,
|
||||
self.ctx.swapchain.handle,
|
||||
std.math.maxInt(u64),
|
||||
self.image_available[self.current_frame],
|
||||
.null_handle,
|
||||
|
|
@ -211,7 +206,7 @@ pub const VulkanRenderer = struct {
|
|||
.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.handle), // Swapchains to present images to
|
||||
.p_swapchains = @ptrCast(&self.ctx.swapchain.handle), // Swapchains to present images to
|
||||
.p_image_indices = @ptrCast(&image_index_result.image_index), // Index of images in swapchains to present
|
||||
};
|
||||
|
||||
|
|
@ -280,7 +275,7 @@ pub const VulkanRenderer = struct {
|
|||
self.sampler_descriptor_sets.deinit();
|
||||
self.allocator.free(self.input_descriptor_sets);
|
||||
|
||||
for (0..self.swapchain.swapchain_images.len) |i| {
|
||||
for (0..self.ctx.swapchain.swapchain_images.len) |i| {
|
||||
self.ctx.device.destroyBuffer(self.vp_uniform_buffer[i], null);
|
||||
self.ctx.device.freeMemory(self.vp_uniform_buffer_memory[i], null);
|
||||
}
|
||||
|
|
@ -303,7 +298,7 @@ pub const VulkanRenderer = struct {
|
|||
self.ctx.device.destroyPipelineLayout(self.pipeline_layout, null);
|
||||
self.ctx.device.destroyRenderPass(self.render_pass, null);
|
||||
|
||||
self.swapchain.deinit();
|
||||
self.ctx.swapchain.deinit();
|
||||
|
||||
self.ctx.deinit();
|
||||
}
|
||||
|
|
@ -369,7 +364,7 @@ pub const VulkanRenderer = struct {
|
|||
|
||||
// Colour attachment of the render pass
|
||||
const swapchain_colour_attachment: vk.AttachmentDescription = .{
|
||||
.format = self.swapchain.swapchain_image_format, // Format to use for attachment
|
||||
.format = self.ctx.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
|
||||
|
|
@ -540,9 +535,9 @@ pub const VulkanRenderer = struct {
|
|||
}
|
||||
|
||||
fn createColourBufferImage(self: *Self) !void {
|
||||
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.swapchain_images.len);
|
||||
self.colour_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain.swapchain_images.len);
|
||||
self.colour_buffer_image = try self.allocator.alloc(vk.Image, self.ctx.swapchain.swapchain_images.len);
|
||||
self.colour_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.ctx.swapchain.swapchain_images.len);
|
||||
self.colour_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
// Get supported format for colour attachment
|
||||
const colour_format = chooseSupportedFormat(
|
||||
|
|
@ -557,8 +552,8 @@ pub const VulkanRenderer = struct {
|
|||
for (0..self.colour_buffer_image.len) |i| {
|
||||
self.colour_buffer_image[i] = try Image.createImage(
|
||||
self.ctx,
|
||||
self.swapchain.extent.width,
|
||||
self.swapchain.extent.height,
|
||||
self.ctx.swapchain.extent.width,
|
||||
self.ctx.swapchain.extent.height,
|
||||
colour_format,
|
||||
.optimal,
|
||||
.{ .color_attachment_bit = true, .input_attachment_bit = true },
|
||||
|
|
@ -576,9 +571,9 @@ pub const VulkanRenderer = struct {
|
|||
}
|
||||
|
||||
fn createDepthBufferImage(self: *Self) !void {
|
||||
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.swapchain_images.len);
|
||||
self.depth_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.swapchain.swapchain_images.len);
|
||||
self.depth_buffer_image = try self.allocator.alloc(vk.Image, self.ctx.swapchain.swapchain_images.len);
|
||||
self.depth_buffer_image_memory = try self.allocator.alloc(vk.DeviceMemory, self.ctx.swapchain.swapchain_images.len);
|
||||
self.depth_buffer_image_view = try self.allocator.alloc(vk.ImageView, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
// Get supported depth buffer format
|
||||
const formats = [_]vk.Format{ .d32_sfloat_s8_uint, .d32_sfloat, .d24_unorm_s8_uint };
|
||||
|
|
@ -594,8 +589,8 @@ pub const VulkanRenderer = struct {
|
|||
// Create depth buffer image
|
||||
self.depth_buffer_image[i] = try Image.createImage(
|
||||
self.ctx,
|
||||
self.swapchain.extent.width,
|
||||
self.swapchain.extent.height,
|
||||
self.ctx.swapchain.extent.width,
|
||||
self.ctx.swapchain.extent.height,
|
||||
self.depth_format,
|
||||
.optimal,
|
||||
.{ .depth_stencil_attachment_bit = true, .input_attachment_bit = true },
|
||||
|
|
@ -698,15 +693,15 @@ pub const VulkanRenderer = struct {
|
|||
self.viewport = .{
|
||||
.x = 0.0,
|
||||
.y = 0.0,
|
||||
.width = @floatFromInt(self.swapchain.extent.width),
|
||||
.height = @floatFromInt(self.swapchain.extent.height),
|
||||
.width = @floatFromInt(self.ctx.swapchain.extent.width),
|
||||
.height = @floatFromInt(self.ctx.swapchain.extent.height),
|
||||
.min_depth = 0.0,
|
||||
.max_depth = 1.0,
|
||||
};
|
||||
|
||||
self.scissor = .{
|
||||
.offset = .{ .x = 0, .y = 0 },
|
||||
.extent = self.swapchain.extent,
|
||||
.extent = self.ctx.swapchain.extent,
|
||||
};
|
||||
|
||||
const viewport_state_create_info: vk.PipelineViewportStateCreateInfo = .{
|
||||
|
|
@ -883,10 +878,10 @@ pub const VulkanRenderer = struct {
|
|||
}
|
||||
|
||||
fn createFramebuffers(self: *Self) !void {
|
||||
self.swapchain.swapchain_framebuffers = try self.allocator.alloc(vk.Framebuffer, self.swapchain.swapchain_images.len);
|
||||
self.ctx.swapchain.swapchain_framebuffers = try self.allocator.alloc(vk.Framebuffer, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
// Create a frammebuffer for each swapchain image
|
||||
for (self.swapchain.swapchain_images, 0..) |swapchain_image, i| {
|
||||
for (self.ctx.swapchain.swapchain_images, 0..) |swapchain_image, i| {
|
||||
// Order matters
|
||||
const attachments = [_]vk.ImageView{
|
||||
swapchain_image.image_view,
|
||||
|
|
@ -898,32 +893,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.swapchain.extent.width, // Framebuffer width
|
||||
.height = self.swapchain.extent.height, // Framebuffer height
|
||||
.width = self.ctx.swapchain.extent.width, // Framebuffer width
|
||||
.height = self.ctx.swapchain.extent.height, // Framebuffer height
|
||||
.layers = 1, // Framebuffer layers
|
||||
};
|
||||
|
||||
self.swapchain.swapchain_framebuffers[i] = try self.ctx.device.createFramebuffer(&framebuffer_create_info, null);
|
||||
self.ctx.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 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
|
||||
.queue_family_index = queue_family_indices.graphics_family.?,
|
||||
.flags = .{ .reset_command_buffer_bit = true },
|
||||
};
|
||||
|
||||
// Create a graphics queue family command pool
|
||||
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.swapchain_framebuffers.len);
|
||||
const command_buffer_handles = try self.allocator.alloc(vk.CommandBuffer, self.ctx.swapchain.swapchain_framebuffers.len);
|
||||
defer self.allocator.free(command_buffer_handles);
|
||||
self.command_buffers = try self.allocator.alloc(CommandBuffer, command_buffer_handles.len);
|
||||
|
||||
|
|
@ -980,8 +961,8 @@ 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.swapchain_images.len);
|
||||
self.vp_uniform_buffer_memory = try self.allocator.alloc(vk.DeviceMemory, self.swapchain.swapchain_images.len);
|
||||
self.vp_uniform_buffer = try self.allocator.alloc(vk.Buffer, self.ctx.swapchain.swapchain_images.len);
|
||||
self.vp_uniform_buffer_memory = try self.allocator.alloc(vk.DeviceMemory, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
// Create the uniform buffers
|
||||
for (0..self.vp_uniform_buffer.len) |i| {
|
||||
|
|
@ -1013,7 +994,7 @@ pub const VulkanRenderer = struct {
|
|||
|
||||
// Data to create descriptor pool
|
||||
const pool_create_info: vk.DescriptorPoolCreateInfo = .{
|
||||
.max_sets = @intCast(self.swapchain.swapchain_images.len), // Maximum number of descriptor sets that can be created from pool
|
||||
.max_sets = @intCast(self.ctx.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
|
||||
};
|
||||
|
|
@ -1055,7 +1036,7 @@ pub const VulkanRenderer = struct {
|
|||
|
||||
// Create input attachment pool
|
||||
const input_pool_create_info: vk.DescriptorPoolCreateInfo = .{
|
||||
.max_sets = @intCast(self.swapchain.swapchain_images.len),
|
||||
.max_sets = @intCast(self.ctx.swapchain.swapchain_images.len),
|
||||
.pool_size_count = @intCast(input_pool_sizes.len),
|
||||
.p_pool_sizes = &input_pool_sizes,
|
||||
};
|
||||
|
|
@ -1065,9 +1046,9 @@ pub const VulkanRenderer = struct {
|
|||
|
||||
fn createDescriptorSets(self: *Self) !void {
|
||||
// One descriptor set for every buffer
|
||||
self.descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain.swapchain_images.len);
|
||||
self.descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain.swapchain_images.len);
|
||||
var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.ctx.swapchain.swapchain_images.len);
|
||||
defer self.allocator.free(set_layouts);
|
||||
for (0..set_layouts.len) |i| {
|
||||
set_layouts[i] = self.descriptor_set_layout;
|
||||
|
|
@ -1076,7 +1057,7 @@ 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.swapchain_images.len), // Number of sets to allocate
|
||||
.descriptor_set_count = @intCast(self.ctx.swapchain.swapchain_images.len), // Number of sets to allocate
|
||||
.p_set_layouts = set_layouts.ptr, // Layouts to use to allocate sets (1:1 relationship)
|
||||
};
|
||||
|
||||
|
|
@ -1084,7 +1065,7 @@ pub const VulkanRenderer = struct {
|
|||
try self.ctx.device.allocateDescriptorSets(&set_alloc_info, self.descriptor_sets.ptr);
|
||||
|
||||
// Update all of descriptor set buffer bindings
|
||||
for (0..self.swapchain.swapchain_images.len) |i| {
|
||||
for (0..self.ctx.swapchain.swapchain_images.len) |i| {
|
||||
// -- View projection descriptor
|
||||
// Buffer info and data offset info
|
||||
const vp_buffer_info: vk.DescriptorBufferInfo = .{
|
||||
|
|
@ -1114,10 +1095,10 @@ pub const VulkanRenderer = struct {
|
|||
}
|
||||
|
||||
fn createInputDescriptorSets(self: *Self) !void {
|
||||
self.input_descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.swapchain.swapchain_images.len);
|
||||
self.input_descriptor_sets = try self.allocator.alloc(vk.DescriptorSet, self.ctx.swapchain.swapchain_images.len);
|
||||
|
||||
// Fill array of layouts ready for set creation
|
||||
var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.swapchain.swapchain_images.len);
|
||||
var set_layouts = try self.allocator.alloc(vk.DescriptorSetLayout, self.ctx.swapchain.swapchain_images.len);
|
||||
defer self.allocator.free(set_layouts);
|
||||
for (0..set_layouts.len) |i| {
|
||||
set_layouts[i] = self.input_set_layout;
|
||||
|
|
@ -1126,7 +1107,7 @@ 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.swapchain_images.len),
|
||||
.descriptor_set_count = @intCast(self.ctx.swapchain.swapchain_images.len),
|
||||
.p_set_layouts = set_layouts.ptr,
|
||||
};
|
||||
|
||||
|
|
@ -1134,7 +1115,7 @@ pub const VulkanRenderer = struct {
|
|||
try self.ctx.device.allocateDescriptorSets(&set_alloc_info, self.input_descriptor_sets.ptr);
|
||||
|
||||
// Update each descriptor set with input attachment
|
||||
for (0..self.swapchain.swapchain_images.len) |i| {
|
||||
for (0..self.ctx.swapchain.swapchain_images.len) |i| {
|
||||
// Colour attachment descriptor
|
||||
const colour_attachment_descriptor: vk.DescriptorImageInfo = .{
|
||||
.image_layout = .shader_read_only_optimal,
|
||||
|
|
@ -1213,11 +1194,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.swapchain.extent, // Size of region to run render pass on (starting at offset)
|
||||
.extent = self.ctx.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.swapchain_framebuffers[current_image],
|
||||
.framebuffer = self.ctx.swapchain.swapchain_framebuffers[current_image],
|
||||
};
|
||||
|
||||
const command_buffer = self.command_buffers[current_image];
|
||||
|
|
|
|||
Loading…
Reference in a new issue