rFactor2_vk_hud/src/lib.rs

pub mod enums;
pub mod structs;

#[macro_use]
mod instance_handles;

#[macro_use]
mod device_handles;

use std::{fs::OpenOptions, io::Write, mem, os::raw::c_char, ptr};

use device_handles::*;
use enums::*;
use instance_handles::*;
use structs::*;
use vulkan_sys::prelude::*;

#[no_mangle]
#[allow(non_snake_case)]
pub extern "C" fn vkNegotiateLoaderLayerInterfaceVersion(
    pVersionStruct: *mut VkNegotiateLayerInterface,
) -> VkResult {
    write_log("======================================================");
    write_log("================= New Negotiation ====================");
    write_log("======================================================");

    unsafe {
        *pVersionStruct = VkNegotiateLayerInterface {
            sType: enums::VkNegotiateLayerStructType::LAYER_NEGOTIATE_INTERFACE_STRUCT,
            pNext: ptr::null_mut(),
            loaderLayerInterfaceVersion: 2,
            pfnGetInstanceProcAddr: Some(get_instance_proc_addr),
            pfnGetDeviceProcAddr: Some(get_device_proc_addr),
            pfnGetPhysicalDeviceProcAddr: None,
        }
    };

    VK_SUCCESS
}

#[no_mangle]
extern "system" fn get_device_proc_addr(
    _device: VkDevice,
    function_name: *const c_char,
) -> PFN_vkVoidFunction {
    write_log("-> vulkan layer device proc addr");

    get_function(function_name)
}

#[no_mangle]
extern "system" fn get_instance_proc_addr(
    _instance: VkInstance,
    function_name: *const c_char,
) -> PFN_vkVoidFunction {
    write_log("-> vulkan layer instance proc addr");

    get_function(function_name)
}

fn get_function(function_name: *const c_char) -> PFN_vkVoidFunction {
    let func_string = match VkString::try_from(function_name) {
        Ok(func) => func,
        Err(_) => {
            write_log("Err: failed creating string");
            return Functions::Null.convert();
        }
    };

    let s = func_string.as_str();

    cmp_instance_fn!(s, {
            [debug_utils_messenger_functions, vkCreateDebugUtilsMessengerEXT],
            [debug_utils_messenger_functions, vkDestroyDebugUtilsMessengerEXT],
            [debug_report_callback_functions, vkCreateDebugReportCallbackEXT],
            [debug_report_callback_functions, vkDestroyDebugReportCallbackEXT],
            [instance_functions, vkEnumeratePhysicalDevices],
            [instance_functions, vkGetPhysicalDeviceFeatures],
            [instance_functions, vkGetPhysicalDeviceFormatProperties],
            [instance_functions, vkGetPhysicalDeviceImageFormatProperties],
            [instance_functions, vkGetPhysicalDeviceProperties],
            [instance_functions, vkGetPhysicalDeviceQueueFamilyProperties],
            [instance_functions, vkGetPhysicalDeviceMemoryProperties],
            [instance_functions, vkEnumerateDeviceExtensionProperties],
            // [instance_functions, vkEnumerateDeviceLayerProperties],
            [instance_functions, vkGetPhysicalDeviceSparseImageFormatProperties],
            // [instance_functions, vkEnumeratePhysicalDeviceGroups],
            [physical_device_properties2_functions, vkGetPhysicalDeviceFeatures2KHR],
            [physical_device_properties2_functions, vkGetPhysicalDeviceProperties2KHR],
            [physical_device_properties2_functions, vkGetPhysicalDeviceFormatProperties2KHR],
            [physical_device_properties2_functions, vkGetPhysicalDeviceFeatures2KHR],
            [physical_device_properties2_functions, vkGetPhysicalDeviceFeatures2KHR],
            [instance_wsi_functions, vkDestroySurfaceKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceSurfaceSupportKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceSurfaceCapabilitiesKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceSurfaceFormatsKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceSurfacePresentModesKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceDisplayPropertiesKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceDisplayPlanePropertiesKHR],
            [instance_wsi_functions, vkGetDisplayPlaneSupportedDisplaysKHR],
            [instance_wsi_functions, vkGetDisplayModePropertiesKHR],
            [instance_wsi_functions, vkCreateDisplayModeKHR],
            [instance_wsi_functions, vkGetDisplayPlaneCapabilitiesKHR],
            [instance_wsi_functions, vkCreateDisplayPlaneSurfaceKHR],
            [instance_wsi_functions, vkCreateXlibSurfaceKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceXlibPresentationSupportKHR],
            [instance_wsi_functions, vkCreateXcbSurfaceKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceXcbPresentationSupportKHR],
            [instance_wsi_functions, vkCreateWaylandSurfaceKHR],
            [instance_wsi_functions, vkGetPhysicalDeviceWaylandPresentationSupportKHR],
        }
    );

    cmp_device_fn!(s, {
        [device_functions, vkGetDeviceQueue],
        [device_functions, vkQueueSubmit],
        [device_functions, vkQueueWaitIdle],
        [device_functions, vkDeviceWaitIdle],
        [device_functions, vkAllocateMemory],
        [device_functions, vkFreeMemory],
        [device_functions, vkMapMemory],
        [device_functions, vkUnmapMemory],
        [device_functions, vkBindBufferMemory],
        [device_functions, vkBindImageMemory],
        [device_functions, vkGetBufferMemoryRequirements],
        [device_functions, vkGetImageMemoryRequirements],
        [device_functions, vkCreateFence],
        [device_functions, vkDestroyFence],
        [device_functions, vkResetFences],
        [device_functions, vkWaitForFences],
        [device_functions, vkCreateSemaphore],
        [device_functions, vkDestroySemaphore],
        [device_functions, vkCreateEvent],
        [device_functions, vkDestroyEvent],
        [device_functions, vkGetEventStatus],
        [device_functions, vkSetEvent],
        [device_functions, vkResetEvent],
        [device_functions, vkCreateBuffer],
        [device_functions, vkDestroyBuffer],
        [device_functions, vkCreateBufferView],
        [device_functions, vkDestroyBufferView],
        [device_functions, vkCreateImage],
        [device_functions, vkDestroyImage],
        [device_functions, vkGetImageSubresourceLayout],
        [device_functions, vkCreateImageView],
        [device_functions, vkDestroyImageView],
        [device_functions, vkCreateShaderModule],
        [device_functions, vkDestroyShaderModule],
        [device_functions, vkCreatePipelineCache],
        [device_functions, vkDestroyPipelineCache],
        [device_functions, vkGetPipelineCacheData],
        [device_functions, vkMergePipelineCaches],
        [device_functions, vkCreateGraphicsPipelines],
        [device_functions, vkCreateComputePipelines],
        [device_functions, vkDestroyPipeline],
        [device_functions, vkCreatePipelineLayout],
        [device_functions, vkDestroyPipelineLayout],
        [device_functions, vkCreateSampler],
        [device_functions, vkDestroySampler],
        [device_functions, vkCreateDescriptorSetLayout],
        [device_functions, vkDestroyDescriptorSetLayout],
        [device_functions, vkCreateDescriptorPool],
        [device_functions, vkDestroyDescriptorPool],
        [device_functions, vkResetDescriptorPool],
        [device_functions, vkAllocateDescriptorSets],
        [device_functions, vkFreeDescriptorSets],
        [device_functions, vkUpdateDescriptorSets],
        [device_functions, vkCreateFramebuffer],
        [device_functions, vkDestroyFramebuffer],
        [device_functions, vkCreateRenderPass],
        [device_functions, vkDestroyRenderPass],
        [device_functions, vkCreateCommandPool],
        [device_functions, vkDestroyCommandPool],
        [device_functions, vkResetCommandPool],
        [device_functions, vkAllocateCommandBuffers],
        [device_functions, vkFreeCommandBuffers],
        [device_functions, vkBeginCommandBuffer],
        [device_functions, vkEndCommandBuffer],
        [device_functions, vkResetCommandBuffer],
        [device_functions, vkCmdBindPipeline],
        [device_functions, vkCmdSetViewport],
        [device_functions, vkCmdSetScissor],
        [device_functions, vkCmdSetLineWidth],
        [device_functions, vkCmdSetDepthBias],
        [device_functions, vkCmdSetBlendConstants],
        [device_functions, vkCmdSetDepthBounds],
        [device_functions, vkCmdSetStencilCompareMask],
        [device_functions, vkCmdSetStencilWriteMask],
        [device_functions, vkCmdSetStencilReference],
        [device_functions, vkCmdBindDescriptorSets],
        [device_functions, vkCmdBindIndexBuffer],
        [device_functions, vkCmdBindVertexBuffers],
        [device_functions, vkCmdDraw],
        [device_functions, vkCmdDispatch],
        [device_functions, vkCmdCopyBuffer],
        [device_functions, vkCmdCopyImage],
        [device_functions, vkCmdBlitImage],
        [device_functions, vkCmdCopyBufferToImage],
        [device_functions, vkCmdCopyImageToBuffer],
        [device_functions, vkCmdUpdateBuffer],
        [device_functions, vkCmdFillBuffer],
        [device_functions, vkCmdClearColorImage],
        [device_functions, vkCmdClearDepthStencilImage],
        [device_functions, vkCmdClearAttachments],
        [device_functions, vkCmdResolveImage],
        [device_functions, vkCmdSetEvent],
        [device_functions, vkCmdResetEvent],
        [device_functions, vkCmdWaitEvents],
        [device_functions, vkCmdPipelineBarrier],
        [device_functions, vkCmdPushConstants],
        [device_functions, vkCmdBeginRenderPass],
        [device_functions, vkCmdNextSubpass],
        [device_functions, vkCmdEndRenderPass],
        [device_functions, vkCmdExecuteCommands],
        [device_functions, vkTrimCommandPool],
        [device_functions, vkGetBufferDeviceAddress],
        [device_functions, vkGetBufferMemoryRequirements2],
        [device_functions, vkGetImageMemoryRequirements2],
        [device_functions, vkBindBufferMemory2],
        [device_functions, vkBindImageMemory2],
        [device_wsi_functions, vkCreateSwapchainKHR],
        [device_wsi_functions, vkDestroySwapchainKHR],
        [device_wsi_functions, vkAcquireNextImageKHR],
        [device_wsi_functions, vkQueuePresentKHR],
        [device_wsi_functions, vkGetSwapchainImagesKHR],
        [acceleration_structure_functions, vkBuildAccelerationStructuresKHR],
        [acceleration_structure_functions, vkCmdBuildAccelerationStructuresIndirectKHR],
        [acceleration_structure_functions, vkCmdBuildAccelerationStructuresKHR],
        [acceleration_structure_functions, vkCmdCopyAccelerationStructureKHR],
        [acceleration_structure_functions, vkCmdCopyAccelerationStructureToMemoryKHR],
        [acceleration_structure_functions, vkCmdCopyMemoryToAccelerationStructureKHR],
        [acceleration_structure_functions, vkCmdWriteAccelerationStructuresPropertiesKHR],
        [acceleration_structure_functions, vkCopyAccelerationStructureKHR],
        [acceleration_structure_functions, vkCopyAccelerationStructureToMemoryKHR],
        [acceleration_structure_functions, vkCopyMemoryToAccelerationStructureKHR],
        [acceleration_structure_functions, vkCreateAccelerationStructureKHR],
        [acceleration_structure_functions, vkDestroyAccelerationStructureKHR],
        [acceleration_structure_functions, vkGetAccelerationStructureBuildSizesKHR],
        [acceleration_structure_functions, vkGetAccelerationStructureDeviceAddressKHR],
        [acceleration_structure_functions, vkGetDeviceAccelerationStructureCompatibilityKHR],
        [acceleration_structure_functions, vkWriteAccelerationStructuresPropertiesKHR],
        [ray_tracing_pipeline_functions, vkCmdSetRayTracingPipelineStackSizeKHR],
        [ray_tracing_pipeline_functions, vkCmdTraceRaysIndirectKHR],
        [ray_tracing_pipeline_functions, vkCmdTraceRaysKHR],
        [ray_tracing_pipeline_functions, vkCreateRayTracingPipelinesKHR],
        [ray_tracing_pipeline_functions, vkGetRayTracingCaptureReplayShaderGroupHandlesKHR],
        [ray_tracing_pipeline_functions, vkGetRayTracingShaderGroupHandlesKHR],
        [ray_tracing_pipeline_functions, vkGetRayTracingShaderGroupStackSizeKHR],
        [maintenance3_functions, vkGetDescriptorSetLayoutSupport],

    });

    match s {
        "vkCreateDevice" => Functions::CreateDevice(create_device),
        "vkDestroyDevice" => Functions::DestroyDevice(destroy_device),
        "vkCreateInstance" => Functions::CreateInstance(create_instance),
        "vkDestroyInstance" => Functions::DestroyInstance(destroy_instance),

        _ => {
            write_log(format!("\trequested fn: {}", s));
            write_log(format!("\t-> not found"));
            Functions::Null
        }
    }
    .convert()
}

extern "system" fn create_instance(
    create_info: *const VkInstanceCreateInfo,
    allocator: *const VkAllocationCallbacks,
    instance: *mut VkInstance,
) -> VkResult {
    write_log(" ================== vulkan layer create instance ==================");

    let chain_info = match VkLayerInstanceCreateInfo::get_chain_info(
        unsafe { &*create_info },
        VK_LAYER_LINK_INFO,
    ) {
        Some(info) => info,
        None => {
            write_log("instance chain info not found.");
            return VK_ERROR_LAYER_NOT_PRESENT;
        }
    };

    let proc_addr = chain_info.layer_info().next_instance_proc_addr;

    let static_functions = StaticFunctions {
        _lib: None,
        vkGetInstanceProcAddr: proc_addr,
    };
    let entry_functions = EntryFunctions::new(&static_functions);

    chain_info.advance_layer_info();
    let result = unsafe { entry_functions.vkCreateInstance(create_info, allocator, instance) };
    if result != VK_SUCCESS {
        return result;
    };

    set_instance_fns(VkInstanceHandles::load_instance(
        static_functions,
        entry_functions,
        unsafe { *instance },
    ));

    write_log("-> successfully created instance.");

    VK_SUCCESS
}

extern "system" fn destroy_instance(instance: VkInstance, allocator: *const VkAllocationCallbacks) {
    write_log(" ================== vulkan layer destroy instance ==================");

    unsafe {
        instance_fns()
            .instance_functions
            .vkDestroyInstance(instance, allocator)
    };
}

extern "system" fn create_device(
    physical_device: VkPhysicalDevice,
    create_info: *const VkDeviceCreateInfo<'_>,
    allocator: *const VkAllocationCallbacks,
    device: *mut VkDevice,
) -> VkResult {
    write_log(" ================== vulkan layer create device ==================");

    let chain_info =
        match VkLayerDeviceCreateInfo::get_chain_info(unsafe { &*create_info }, VK_LAYER_LINK_INFO)
        {
            Some(info) => info,
            None => {
                write_log("device chain info not found.");
                return VK_ERROR_LAYER_NOT_PRESENT;
            }
        };

    replace_device_proc_addr(chain_info.layer_info().next_device_proc_addr);
    let instance = instance_fns();

    chain_info.advance_layer_info();

    let result = unsafe {
        instance
            .instance_functions
            .vkCreateDevice(physical_device, create_info, allocator, device)
    };

    if result != VK_SUCCESS {
        return result;
    }

    set_device_fns(VkDeviceHandles::new(unsafe { *device }));

    VK_SUCCESS
}

extern "system" fn destroy_device(device: VkDevice, allocator: *const VkAllocationCallbacks) {
    write_log(" ================== vulkan layer destroy device ==================");

    unsafe {
        device_fns()
            .device_functions
            .vkDestroyDevice(device, allocator)
    }
}

fn write_log(msg: impl ToString) {
    let mut file = OpenOptions::new()
        .append(true)
        .create(true)
        .open("/home/michael/rf2_vk_hud.log")
        .unwrap();

    file.write_all(format!("{}\n", msg.to_string()).as_bytes())
        .unwrap();
}