465 lines
14 KiB
Zig
465 lines
14 KiB
Zig
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
|
|
const vk = @import("vk");
|
|
const c = @import("c.zig");
|
|
|
|
pub const Bus = @import("au/Bus.zig");
|
|
pub const SwapChain = @import("au/SwapChain.zig");
|
|
pub const Flights = @import("au/flights.zig").Flights;
|
|
|
|
pub const use_debug_messenger = switch (builtin.mode) {
|
|
.Debug, .ReleaseSafe => true,
|
|
.ReleaseSmall, .ReleaseFast => false,
|
|
};
|
|
|
|
pub const apis: []const vk.ApiInfo = &.{
|
|
vk.features.version_1_0,
|
|
vk.features.version_1_1,
|
|
vk.features.version_1_2,
|
|
vk.features.version_1_3,
|
|
vk.extensions.khr_surface,
|
|
vk.extensions.khr_swapchain,
|
|
vk.extensions.khr_dynamic_rendering,
|
|
if (use_debug_messenger) vk.extensions.ext_debug_utils else .{},
|
|
};
|
|
|
|
pub const device_extensions: []const [*:0]const u8 = &.{
|
|
// todo somehow sync this with APIs above?
|
|
vk.extensions.khr_swapchain.name,
|
|
vk.extensions.khr_dynamic_rendering.name,
|
|
};
|
|
|
|
pub const app_info: vk.ApplicationInfo = .{
|
|
.p_application_name = "hey tildes!",
|
|
.application_version = vk.makeApiVersion(0, 0, 0, 0),
|
|
.p_engine_name = "zig-glfw-vulkan",
|
|
.engine_version = vk.makeApiVersion(0, 0, 0, 0),
|
|
.api_version = vk.API_VERSION_1_3,
|
|
};
|
|
|
|
pub const BaseWrapper = vk.BaseWrapper(apis);
|
|
pub const InstanceWrapper = vk.InstanceWrapper(apis);
|
|
pub const DeviceWrapper = vk.DeviceWrapper(apis);
|
|
|
|
pub const InstanceProxy = vk.InstanceProxy(apis);
|
|
pub const DeviceProxy = vk.DeviceProxy(apis);
|
|
pub const QueueProxy = vk.QueueProxy(apis);
|
|
pub const CommandBufferProxy = vk.CommandBufferProxy(apis);
|
|
|
|
pub const B: *const BaseWrapper = &_bw;
|
|
pub const I: *const InstanceProxy = &_ip;
|
|
pub const D: *const DeviceProxy = &_dp;
|
|
pub const W: *const Window = &_window;
|
|
pub const Q: *const QueueProxy = &_qp;
|
|
|
|
pub const device_config: *const CandidateDeviceInfo = &_dconfig;
|
|
|
|
var _bw: BaseWrapper = undefined;
|
|
var _iw: InstanceWrapper = undefined;
|
|
var _dw: DeviceWrapper = undefined;
|
|
|
|
var _ip: InstanceProxy = undefined;
|
|
var _dp: DeviceProxy = undefined;
|
|
var _qp: QueueProxy = undefined;
|
|
|
|
var _instance: vk.Instance = undefined;
|
|
var _window: Window = undefined;
|
|
var _bus: Bus = undefined;
|
|
var _device: vk.Device = undefined;
|
|
var _dconfig: CandidateDeviceInfo = undefined;
|
|
var _queue: vk.Queue = undefined;
|
|
|
|
pub fn init(alloc: std.mem.Allocator) !void {
|
|
try init_glfw();
|
|
errdefer deinit_glfw();
|
|
|
|
try init_base();
|
|
errdefer deinit_base();
|
|
|
|
try init_instance(alloc);
|
|
errdefer deinit_instance();
|
|
|
|
try init_window(alloc);
|
|
errdefer deinit_window();
|
|
|
|
try init_device(alloc);
|
|
errdefer deinit_device();
|
|
|
|
try init_event_bus(alloc);
|
|
errdefer deinit_event_bus();
|
|
}
|
|
|
|
pub fn deinit() void {
|
|
deinit_event_bus();
|
|
deinit_device();
|
|
deinit_window();
|
|
deinit_instance();
|
|
deinit_base();
|
|
deinit_glfw();
|
|
}
|
|
|
|
fn init_glfw() !void {
|
|
if (c.glfwInit() != c.GLFW_TRUE)
|
|
return error.glfwInitFailed;
|
|
errdefer c.glfwTerminate();
|
|
|
|
if (c.glfwVulkanSupported() != c.GLFW_TRUE)
|
|
return error.glfwNoVulkan;
|
|
}
|
|
|
|
fn deinit_glfw() void {
|
|
c.glfwTerminate();
|
|
}
|
|
|
|
fn init_base() !void {
|
|
if (use_debug_messenger) {
|
|
_bw = try BaseWrapper.load(c.glfwGetInstanceProcAddress);
|
|
} else {
|
|
_bw = BaseWrapper.loadNoFail(c.glfwGetInstanceProcAddress);
|
|
}
|
|
}
|
|
|
|
fn deinit_base() void {}
|
|
|
|
fn init_instance(alloc: std.mem.Allocator) !void {
|
|
var extensions = std.ArrayList([*:0]const u8).init(alloc);
|
|
defer extensions.deinit();
|
|
|
|
var layers = std.ArrayList([*:0]const u8).init(alloc);
|
|
defer layers.deinit();
|
|
|
|
if (use_debug_messenger) {
|
|
try extensions.appendSlice(&.{
|
|
vk.extensions.ext_debug_utils.name,
|
|
});
|
|
|
|
try layers.appendSlice(&.{
|
|
"VK_LAYER_KHRONOS_validation",
|
|
});
|
|
}
|
|
|
|
var glfw_exts_count: u32 = 0;
|
|
const glfw_exts: [*]const [*:0]const u8 =
|
|
@ptrCast(c.glfwGetRequiredInstanceExtensions(&glfw_exts_count));
|
|
try extensions.appendSlice(glfw_exts[0..glfw_exts_count]);
|
|
|
|
const mci: vk.DebugUtilsMessengerCreateInfoEXT = .{
|
|
.message_severity = .{
|
|
.error_bit_ext = true,
|
|
.info_bit_ext = true,
|
|
.verbose_bit_ext = true,
|
|
.warning_bit_ext = true,
|
|
},
|
|
.message_type = .{
|
|
.device_address_binding_bit_ext = true,
|
|
.general_bit_ext = false,
|
|
.performance_bit_ext = true,
|
|
.validation_bit_ext = true,
|
|
},
|
|
.pfn_user_callback = &debug_callback,
|
|
.p_user_data = null,
|
|
};
|
|
|
|
_instance = try B.createInstance(&.{
|
|
.p_application_info = &app_info,
|
|
.enabled_extension_count = @intCast(extensions.items.len),
|
|
.pp_enabled_extension_names = extensions.items.ptr,
|
|
.enabled_layer_count = @intCast(layers.items.len),
|
|
.pp_enabled_layer_names = layers.items.ptr,
|
|
.p_next = if (use_debug_messenger) &mci else null,
|
|
}, null);
|
|
|
|
if (use_debug_messenger) {
|
|
_iw = try InstanceWrapper.load(_instance, _bw.dispatch.vkGetInstanceProcAddr);
|
|
} else {
|
|
_iw = InstanceWrapper.loadNoFail(_instance, _bw.dispatch.vkGetInstanceProcAddr);
|
|
}
|
|
|
|
_ip = InstanceProxy.init(_instance, &_iw);
|
|
}
|
|
|
|
fn deinit_instance() void {
|
|
_ip.destroyInstance(null);
|
|
}
|
|
|
|
fn init_window(alloc: std.mem.Allocator) !void {
|
|
_window = try Window.init(
|
|
alloc,
|
|
app_info.p_application_name orelse "Au Window",
|
|
.{ .height = 720, .width = 1280 },
|
|
);
|
|
errdefer _window.deinit();
|
|
}
|
|
|
|
fn deinit_window() void {
|
|
_window.deinit();
|
|
}
|
|
|
|
const CandidateDeviceInfo = struct {
|
|
pdev: vk.PhysicalDevice,
|
|
format: vk.SurfaceFormatKHR,
|
|
mode: vk.PresentModeKHR,
|
|
family: u32, // must support graphics and present for now
|
|
|
|
fn init(alloc: std.mem.Allocator, pdev: vk.PhysicalDevice) !struct { i32, CandidateDeviceInfo } {
|
|
var score: i32 = 0;
|
|
var res: CandidateDeviceInfo = undefined;
|
|
|
|
res.pdev = pdev;
|
|
|
|
var format_count: u32 = undefined;
|
|
_ = try I.getPhysicalDeviceSurfaceFormatsKHR(pdev, W.surface, &format_count, null);
|
|
if (format_count == 0) return error.NoSurfaceFormats;
|
|
const formats = try alloc.alloc(vk.SurfaceFormatKHR, format_count);
|
|
defer alloc.free(formats);
|
|
_ = try I.getPhysicalDeviceSurfaceFormatsKHR(pdev, W.surface, &format_count, formats.ptr);
|
|
|
|
for (formats) |fmt| {
|
|
if (fmt.color_space == .srgb_nonlinear_khr) {
|
|
res.format = fmt;
|
|
break;
|
|
}
|
|
} else {
|
|
res.format = formats[0];
|
|
score -= 100;
|
|
}
|
|
|
|
var mode_count: u32 = undefined;
|
|
_ = try I.getPhysicalDeviceSurfacePresentModesKHR(pdev, W.surface, &mode_count, null);
|
|
if (mode_count == 0) return error.NoSurfacePresentModes;
|
|
const modes = try alloc.alloc(vk.PresentModeKHR, mode_count);
|
|
defer alloc.free(modes);
|
|
_ = try I.getPhysicalDeviceSurfacePresentModesKHR(pdev, W.surface, &mode_count, modes.ptr);
|
|
|
|
if (std.mem.indexOfAny(vk.PresentModeKHR, modes, &.{
|
|
vk.PresentModeKHR.mailbox_khr,
|
|
})) |idx| {
|
|
res.mode = modes[idx];
|
|
} else {
|
|
score -= 50;
|
|
res.mode = .fifo_khr; // this is guaranteed
|
|
}
|
|
|
|
var ext_count: u32 = undefined;
|
|
_ = try I.enumerateDeviceExtensionProperties(pdev, null, &ext_count, null);
|
|
const exts = try alloc.alloc(vk.ExtensionProperties, ext_count);
|
|
defer alloc.free(exts);
|
|
_ = try I.enumerateDeviceExtensionProperties(pdev, null, &ext_count, exts.ptr);
|
|
|
|
for (device_extensions) |needle| {
|
|
for (exts) |ext| {
|
|
if (std.mem.eql(
|
|
u8,
|
|
std.mem.span(needle),
|
|
std.mem.sliceTo(&ext.extension_name, 0),
|
|
))
|
|
break;
|
|
} else {
|
|
return error.MissingDeviceExtension;
|
|
}
|
|
}
|
|
|
|
var family_count: u32 = undefined;
|
|
I.getPhysicalDeviceQueueFamilyProperties(pdev, &family_count, null);
|
|
const families = try alloc.alloc(vk.QueueFamilyProperties, family_count);
|
|
defer alloc.free(families);
|
|
I.getPhysicalDeviceQueueFamilyProperties(pdev, &family_count, families.ptr);
|
|
|
|
for (families, 0..) |prop, idx| {
|
|
const graphics_support = prop.queue_flags.graphics_bit;
|
|
const present_support = try I.getPhysicalDeviceSurfaceSupportKHR(pdev, @intCast(idx), W.surface) == vk.TRUE;
|
|
|
|
if (graphics_support and present_support) {
|
|
res.family = @intCast(idx);
|
|
break;
|
|
}
|
|
} else {
|
|
return error.NoSuitableFamily;
|
|
}
|
|
|
|
return .{ score, res };
|
|
}
|
|
};
|
|
|
|
fn init_device(alloc: std.mem.Allocator) !void {
|
|
var pdev_count: u32 = undefined;
|
|
_ = try I.enumeratePhysicalDevices(&pdev_count, null);
|
|
if (pdev_count == 0) return error.NoDevice;
|
|
const pdevs = try alloc.alloc(vk.PhysicalDevice, pdev_count);
|
|
defer alloc.free(pdevs);
|
|
_ = try I.enumeratePhysicalDevices(&pdev_count, pdevs.ptr);
|
|
|
|
// const scores = std.ArrayList(i32).
|
|
var scores: std.MultiArrayList(struct { score: i32, ci: CandidateDeviceInfo }) = .{};
|
|
defer scores.deinit(alloc);
|
|
|
|
for (pdevs) |pdev| {
|
|
const score, const ci = CandidateDeviceInfo.init(alloc, pdev) catch continue;
|
|
try scores.append(alloc, .{ .score = score, .ci = ci });
|
|
}
|
|
|
|
const idx = std.sort.argMax(i32, scores.items(.score), {}, std.sort.asc(i32)) orelse
|
|
return error.NoSuitableDevice;
|
|
_dconfig = scores.get(idx).ci;
|
|
|
|
const qci: []const vk.DeviceQueueCreateInfo = &.{
|
|
vk.DeviceQueueCreateInfo{
|
|
.queue_family_index = _dconfig.family,
|
|
.queue_count = 1,
|
|
.p_queue_priorities = &[_]f32{1.0},
|
|
},
|
|
};
|
|
|
|
_device = try I.createDevice(_dconfig.pdev, &.{
|
|
.queue_create_info_count = @intCast(qci.len),
|
|
.p_queue_create_infos = qci.ptr,
|
|
.enabled_extension_count = @intCast(device_extensions.len),
|
|
.pp_enabled_extension_names = device_extensions.ptr,
|
|
.p_next = &vk.PhysicalDeviceDynamicRenderingFeaturesKHR{
|
|
.dynamic_rendering = vk.TRUE,
|
|
},
|
|
}, null);
|
|
|
|
if (use_debug_messenger) {
|
|
_dw = try DeviceWrapper.load(_device, _iw.dispatch.vkGetDeviceProcAddr);
|
|
} else {
|
|
_dw = DeviceWrapper.loadNoFail(_device, _iw.dispatch.vkGetDeviceProcAddr);
|
|
}
|
|
_dp = DeviceProxy.init(_device, &_dw);
|
|
errdefer D.destroyDevice(null);
|
|
|
|
_queue = D.getDeviceQueue(_dconfig.family, 0);
|
|
|
|
_qp = QueueProxy.init(_queue, &_dw);
|
|
|
|
// todo i'm thinking this needs to be a more complex pointer structure... i'm making assumptions here about how the
|
|
// command pools are meant to work. probably I am cooking too much.
|
|
}
|
|
|
|
fn deinit_device() void {
|
|
D.destroyDevice(null);
|
|
}
|
|
|
|
pub fn debug_callback(
|
|
msg_severity: vk.DebugUtilsMessageSeverityFlagsEXT,
|
|
msg_type: vk.DebugUtilsMessageTypeFlagsEXT,
|
|
p_data: ?*const vk.DebugUtilsMessengerCallbackDataEXT,
|
|
_: ?*anyopaque,
|
|
) callconv(vk.vulkan_call_conv) vk.Bool32 {
|
|
// ripped from std.log.defaultLog
|
|
|
|
const data = p_data orelse return vk.FALSE;
|
|
const message = data.p_message orelse return vk.FALSE;
|
|
|
|
const severity_prefix = if (msg_severity.verbose_bit_ext)
|
|
"verbose:"
|
|
else if (msg_severity.info_bit_ext)
|
|
"info:"
|
|
else if (msg_severity.warning_bit_ext)
|
|
"warning:"
|
|
else if (msg_severity.error_bit_ext)
|
|
"error:"
|
|
else
|
|
"?:";
|
|
|
|
const type_prefix = if (msg_type.general_bit_ext)
|
|
""
|
|
else if (msg_type.validation_bit_ext)
|
|
"validation:"
|
|
else if (msg_type.performance_bit_ext)
|
|
"performance:"
|
|
else if (msg_type.device_address_binding_bit_ext)
|
|
"device_address_binding:"
|
|
else
|
|
"?:";
|
|
|
|
const stderr = std.io.getStdErr().writer();
|
|
var bw = std.io.bufferedWriter(stderr);
|
|
const writer = bw.writer();
|
|
|
|
std.debug.lockStdErr();
|
|
defer std.debug.unlockStdErr();
|
|
nosuspend {
|
|
writer.print("vk-{s}{s} {s}\n", .{ severity_prefix, type_prefix, message }) catch return vk.FALSE;
|
|
bw.flush() catch return vk.FALSE;
|
|
}
|
|
|
|
return vk.FALSE;
|
|
}
|
|
|
|
pub const Window = struct {
|
|
const Self = @This();
|
|
|
|
alloc: std.mem.Allocator,
|
|
handle: *c.GLFWwindow,
|
|
surface: vk.SurfaceKHR,
|
|
|
|
pub fn init(alloc: std.mem.Allocator, title: [*:0]const u8, extent: vk.Extent2D) !Self {
|
|
var self: Self = undefined;
|
|
self.alloc = alloc;
|
|
|
|
c.glfwWindowHintString(c.GLFW_X11_CLASS_NAME, "floating_window");
|
|
c.glfwWindowHintString(c.GLFW_X11_INSTANCE_NAME, "floating_window");
|
|
c.glfwWindowHint(c.GLFW_CLIENT_API, c.GLFW_NO_API);
|
|
|
|
self.handle = c.glfwCreateWindow(
|
|
@intCast(extent.width),
|
|
@intCast(extent.height),
|
|
title,
|
|
null,
|
|
null,
|
|
) orelse return error.glfwWindowFailed;
|
|
errdefer c.glfwDestroyWindow(self.handle);
|
|
|
|
if (c.glfwCreateWindowSurface(_instance, self.handle, null, &self.surface) != .success) {
|
|
return error.glfwSurfaceFailed;
|
|
}
|
|
errdefer I.destroySurfaceKHR(self.surface, null);
|
|
|
|
return self;
|
|
}
|
|
|
|
pub fn deinit(self: Self) void {
|
|
I.destroySurfaceKHR(self.surface, null);
|
|
c.glfwDestroyWindow(self.handle);
|
|
}
|
|
|
|
pub fn should_close(self: Self) bool {
|
|
return c.glfwWindowShouldClose(self.handle) == c.GLFW_TRUE;
|
|
}
|
|
|
|
pub fn focused(self: Self) bool {
|
|
return c.glfwGetWindowAttrib(self.handle, c.GLFW_FOCUSED) == c.GLFW_TRUE;
|
|
}
|
|
};
|
|
|
|
pub fn wait_events() []const Bus.Event {
|
|
_bus.clear();
|
|
c.glfwWaitEvents();
|
|
return _bus.events.items;
|
|
}
|
|
|
|
pub fn poll_events() []const Bus.Event {
|
|
_bus.clear();
|
|
c.glfwPollEvents();
|
|
return _bus.events.items;
|
|
}
|
|
|
|
pub fn wait_events_timeout(seconds: f64) []const Bus.Event {
|
|
_bus.clear();
|
|
c.glfwWaitEventsTimeout(seconds);
|
|
return _bus.events.items;
|
|
}
|
|
|
|
fn init_event_bus(alloc: std.mem.Allocator) !void {
|
|
_bus = Bus.init(alloc);
|
|
errdefer _bus.deinit();
|
|
try _bus.connect(&_window);
|
|
}
|
|
|
|
fn deinit_event_bus() void {
|
|
try _bus.disconnect(&_window);
|
|
_bus.deinit();
|
|
}
|