Added checking if our extensions are supported and make Renderer.destroy() not return an error

Signed-off-by: luccie-cmd <luccie@sideros.org>

.gitignore

@@ -1,2 +1,3 @@
 .zig-cache/
 zig-out/
+.zigversion

src/main.zig

@@ -24,19 +24,17 @@ pub fn main() !void {
 
         //var parameters = [_]usize{};
         //try runtime.callExternal(allocator, "fibonacci", &parameters);
-
         const w = try window.Window.create(800, 600, "sideros");
         defer w.destroy();
 
-        // TODO: Renderer.destroy should not return an error?
+        // TODO(luccie-cmd): Renderer.create shouldn't return an error
         var r = try Renderer.create(allocator, w);
-        defer r.destroy() catch {};
+        defer r.destroy();
 
         while (!w.shouldClose()) {
             c.glfwPollEvents();
             try r.tick();
         }
-        try r.device.waitIdle();
     }
 
     if (gpa.detectLeaks()) {

src/render/renderer_vulkan.zig

@@ -19,7 +19,7 @@ vertex_buffer: vk.Buffer,
 index_buffer: vk.Buffer,
 
 pub fn create(allocator: Allocator, w: window.Window) !Renderer {
-    const instance = try vk.Instance.create();
+    const instance = try vk.Instance.create(allocator);
 
     const surface = try vk.Surface.create(instance, w);
 
@@ -61,8 +61,8 @@ pub fn create(allocator: Allocator, w: window.Window) !Renderer {
     };
 }
 
-pub fn destroy(self: Renderer) !void {
-    try self.device.waitIdle();
+pub fn destroy(self: Renderer) void {
+    self.device.waitIdle();
     self.index_buffer.destroy(self.device.handle);
     self.vertex_buffer.destroy(self.device.handle);
     self.graphics_pipeline.destroy(self.device);

src/render/vulkan.zig

@@ -70,9 +70,53 @@ pub const BufferFlags = packed struct(u32) {
 pub const Instance = struct {
     handle: c.VkInstance,
 
-    pub fn create() !Instance {
+    pub fn create(allocator: Allocator) !Instance {
         const extensions = window.getExtensions();
 
+        var avaliableExtensionsCount: u32 = 0;
+        _ = c.vkEnumerateInstanceExtensionProperties(null, &avaliableExtensionsCount, null);
+        var availableExtensions = std.ArrayList(c.VkExtensionProperties).init(allocator);
+        try availableExtensions.resize(avaliableExtensionsCount);
+        _ = c.vkEnumerateInstanceExtensionProperties(null, &avaliableExtensionsCount, availableExtensions.items.ptr);
+        for(extensions) |need_ext| {
+            var found = false;
+            for(availableExtensions.items) |useable_ext| {
+                const extensionName: [*c]const u8 = &useable_ext.extensionName;
+                if(std.mem.eql(u8, std.mem.sliceTo(need_ext, 0), std.mem.sliceTo(extensionName, 0))){
+                    found = true;
+                    break;
+                }
+            }
+            if(!found){
+                std.debug.panic("ERROR: Needed vulkan extension {s} not found\n", .{need_ext});
+            }
+        }
+        availableExtensions.deinit();
+
+        var avaliableLayersCount: u32 = 0;
+        _ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, null);
+        var availableLayers = std.ArrayList(c.VkLayerProperties).init(allocator);
+        try availableLayers.resize(avaliableLayersCount);
+        _ = c.vkEnumerateInstanceLayerProperties(&avaliableLayersCount, availableLayers.items.ptr);
+        var newLayers = std.ArrayList([*c]const u8).init(allocator);
+        for(validation_layers) |want_layer| {
+            var found = false;
+            for(availableLayers.items) |useable_validation| {
+                const layer_name: [*c]const u8 = &useable_validation.layerName;
+                if (std.mem.eql(u8, std.mem.sliceTo(want_layer, 0), std.mem.sliceTo(layer_name, 0))){
+                    found = true;
+                    break;
+                }
+            }
+            if(!found){
+                std.debug.print("WARNING: Compiled in debug mode, but wanted validation layer {s} not found.\n", .{want_layer});
+                std.debug.print("NOTE: Validation layer will be removed from the wanted validation layers\n", .{});
+            } else{
+                try newLayers.append(want_layer);
+            }
+        }
+        availableLayers.deinit();
+
         const app_info: c.VkApplicationInfo = .{
             .sType = c.VK_STRUCTURE_TYPE_APPLICATION_INFO,
             .pApplicationName = "sideros",
@@ -87,8 +131,8 @@ pub const Instance = struct {
             .pApplicationInfo = &app_info,
             .enabledExtensionCount = @intCast(extensions.len),
             .ppEnabledExtensionNames = extensions.ptr,
-            .enabledLayerCount = @intCast(validation_layers.len),
-            .ppEnabledLayerNames = validation_layers.ptr,
+            .enabledLayerCount = @intCast(newLayers.capacity),
+            .ppEnabledLayerNames = newLayers.items.ptr,
         };
 
         var instance: c.VkInstance = undefined;
@@ -796,8 +840,12 @@ pub fn Device(comptime n: usize) type {
             try mapError(c.vkResetFences(self.handle, 1, &self.in_flight_fence[frame]));
         }
 
-        pub fn waitIdle(self: Self) !void {
-            try mapError(c.vkDeviceWaitIdle(self.handle));
+        pub fn waitIdle(self: Self) void {
+            const mapErrorRes = mapError(c.vkDeviceWaitIdle(self.handle));
+            if(mapErrorRes) {} else |err| {
+                std.debug.print("ERROR: VULKAN ERROR {any}\n", .{err});
+                std.process.exit(1);
+            }
         }
 
         pub fn bindIndexBuffer(self: Self, buffer: Buffer, frame: usize) void {