// ───────────────────────────────────────────────────────────────────────────── // instance.rs — vkCreateInstance and vkDestroyInstance // ───────────────────────────────────────────────────────────────────────────── use crate::dispatch::NextInstanceFn; use crate::state::INSTANCE_STATE; use crate::{VkLayerInstanceCreateInfo, dispatch_key, find_layer_link, load_instance_fn}; use ash::vk::{self, Handle}; use std::os::raw::c_void; use std::sync::Arc; use crate::dispatch::PFN_vkCreateInstance; const VK_LAYER_LINK_INFO: u32 = 0; #[unsafe(no_mangle)] pub unsafe extern "system" fn vkCreateInstance( p_create_info: *const vk::InstanceCreateInfo, p_allocator: *const vk::AllocationCallbacks, p_instance: *mut vk::Instance, ) -> vk::Result { crate::init_logger(); // ── Walk the pNext chain to find the loader's layer link ───────────────── let layer_info: *mut VkLayerInstanceCreateInfo = match unsafe { find_layer_link((*p_create_info).p_next as *const c_void, VK_LAYER_LINK_INFO) } { Some(p) => p, None => return vk::Result::ERROR_INITIALIZATION_FAILED, }; let layer_link = unsafe { (*layer_info).u.pLayerInfo }; let next_gipa = match unsafe { (*layer_link).pfnNextGetInstanceProcAddr } { Some(f) => f, None => return vk::Result::ERROR_INITIALIZATION_FAILED, }; // Advance the chain before calling through so the next layer gets its link. unsafe { (*layer_info).u.pLayerInfo = (*layer_link).pNext }; // ── Call the next layer / loader's vkCreateInstance ────────────────────── let next_create: PFN_vkCreateInstance = unsafe { load_instance_fn(next_gipa, vk::Instance::null(), b"vkCreateInstance\0") }; // The encoders run on the game's device, so the game's instance has to be // new enough for them: 1.1 for pixelforge, 1.3 for nespyro. See // `raised_version`. let asked = unsafe { let app = (*p_create_info).p_application_info; if app.is_null() { vk::API_VERSION_1_0 } else { (*app).api_version } }; let mut raised_app; let mut raised_ci; let mut create_info = p_create_info; let mut api_version = asked; if let Some(raised) = raised_version(asked, unsafe { loader_version(next_gipa) }) { raised_app = unsafe { let app = (*p_create_info).p_application_info; if app.is_null() { vk::ApplicationInfo::default() } else { *app } }; raised_app.api_version = raised; raised_ci = unsafe { *p_create_info }; raised_ci.p_application_info = &raised_app; create_info = &raised_ci; api_version = raised; log::info!( "instance asked for Vulkan {}.{}; created as {}.{} so the encoders can share its devices", vk::api_version_major(asked), vk::api_version_minor(asked), vk::api_version_major(raised), vk::api_version_minor(raised), ); } let result = unsafe { next_create(create_info, p_allocator, p_instance) }; if result != vk::Result::SUCCESS { return result; } let instance = unsafe { *p_instance }; let key = unsafe { dispatch_key(instance.as_raw() as *const c_void) }; // ── Build and store per-instance dispatch table ─────────────────────────── let istate = Arc::new(NextInstanceFn { instance, api_version, get_instance_proc_addr: next_gipa, destroy_instance: unsafe { load_instance_fn(next_gipa, instance, b"vkDestroyInstance\0") }, get_physical_device_memory_properties: unsafe { load_instance_fn( next_gipa, instance, b"vkGetPhysicalDeviceMemoryProperties\0", ) }, get_physical_device_properties: unsafe { crate::try_load_instance_fn(next_gipa, instance, b"vkGetPhysicalDeviceProperties\0") }, get_physical_device_queue_family_properties: unsafe { crate::try_load_instance_fn( next_gipa, instance, b"vkGetPhysicalDeviceQueueFamilyProperties\0", ) }, create_device: unsafe { load_instance_fn(next_gipa, instance, b"vkCreateDevice\0") }, }); INSTANCE_STATE.insert(key, istate); log::debug!("vkCreateInstance OK (enabled={})", crate::enabled()); vk::Result::SUCCESS } /// The version to create the game's instance at instead of the one it asked /// for, or `None` to leave it alone. /// /// As high as 1.3, which nespyro needs, and as the loader allows. A newer /// version only adds to an older one: a game cannot depend on behaviour it /// never asked for, and the only side of a session that has to care about old /// Vulkan is the client, which this layer is not. A loader below 1.1 is left /// alone, since then neither encoder can share the device anyway. The patch is /// dropped, as the version names a major.minor and its patch level is the /// loader's business. fn raised_version(asked: u32, loader: u32) -> Option { let target = vk::API_VERSION_1_3.min(loader); let target = vk::make_api_version( 0, vk::api_version_major(target), vk::api_version_minor(target), 0, ); (target >= vk::API_VERSION_1_1 && asked < target).then_some(target) } /// The highest instance version the loader below supports; 1.0 when it cannot /// say, since vkEnumerateInstanceVersion is itself a 1.1 addition. unsafe fn loader_version(next_gipa: crate::dispatch::PFN_vkGetInstanceProcAddr) -> u32 { type Enumerate = unsafe extern "system" fn(*mut u32) -> vk::Result; let Some(f) = (unsafe { crate::try_load_instance_fn::( next_gipa, vk::Instance::null(), b"vkEnumerateInstanceVersion\0", ) }) else { return vk::API_VERSION_1_0; }; let mut version = vk::API_VERSION_1_0; if unsafe { f(&mut version) } != vk::Result::SUCCESS { return vk::API_VERSION_1_0; } version } #[unsafe(no_mangle)] pub unsafe extern "system" fn vkDestroyInstance( instance: vk::Instance, p_allocator: *const vk::AllocationCallbacks, ) { let key = unsafe { dispatch_key(instance.as_raw() as *const c_void) }; if let Some((_, state)) = INSTANCE_STATE.remove(&key) { unsafe { (state.destroy_instance)(instance, p_allocator) }; } } #[cfg(test)] mod tests { use super::raised_version; use ash::vk; const LOADER_1_4: u32 = vk::make_api_version(0, 1, 4, 321); #[test] fn an_old_instance_is_raised_to_1_3() { for asked in [ 0, vk::API_VERSION_1_0, vk::API_VERSION_1_1, vk::API_VERSION_1_2, ] { assert_eq!(raised_version(asked, LOADER_1_4), Some(vk::API_VERSION_1_3)); } } /// Raising is only ever upward: a game asking for more keeps it. #[test] fn a_new_enough_instance_is_left_alone() { assert_eq!(raised_version(vk::API_VERSION_1_3, LOADER_1_4), None); assert_eq!(raised_version(LOADER_1_4, LOADER_1_4), None); } #[test] fn an_older_loader_gets_what_it_has() { let loader = vk::make_api_version(0, 1, 2, 198); assert_eq!( raised_version(vk::API_VERSION_1_0, loader), Some(vk::API_VERSION_1_2) ); assert_eq!(raised_version(vk::API_VERSION_1_2, loader), None); assert_eq!( raised_version(vk::API_VERSION_1_0, vk::API_VERSION_1_0), None ); } }