Archives
/
MangoHud
mirror of https://github.com/flightlessmango/MangoHud
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

mangoapp: layer: remove unused functions

Browse Source
pull/710/head
FlightlessMango 2 years ago
parent 529afdddf8
commit 284ae0da2c
1 changed files with 1 additions and 173 deletions
Show Stats Download Patch File Download Diff File

174
src/app/layer.cpp
Unescape Escape View File

@ -11,20 +11,6 @@
using json = nlohmann::json;
VkPhysicalDeviceDriverProperties driverProps = {};
/* Mapped from VkCommandBuffer */
struct queue_data;
/* Mapped from VkQueue */
struct queue_data {
struct device_data *device;
VkQueue queue;
VkQueueFlags flags;
uint32_t family_index;
};
// single global lock, for simplicity
std::mutex global_lock;
typedef std::lock_guard<std::mutex> scoped_lock;
@ -87,12 +73,6 @@ static struct instance_data *new_instance_data(VkInstance instance)
return data;
}
static void destroy_instance_data(struct instance_data *data)
{
unmap_object(HKEY(data->instance));
delete data;
}
static void instance_data_map_physical_devices(struct instance_data *instance_data,
bool map)
{
@ -114,136 +94,15 @@ static void instance_data_map_physical_devices(struct instance_data *instance_da
}
}
/**/
static struct device_data *new_device_data(VkDevice device, struct instance_data *instance)
{
struct device_data *data = new device_data();
data->instance = instance;
data->device = device;
map_object(HKEY(data->device), data);
return data;
}
static void destroy_queue(struct queue_data *data)
{
unmap_object(HKEY(data->queue));
delete data;
}
static void device_unmap_queues(struct device_data *data)
{
for (auto q : data->queues)
destroy_queue(q);
}
static void destroy_device_data(struct device_data *data)
{
unmap_object(HKEY(data->device));
delete data;
}
static VkResult overlay_CreateDevice(
VkPhysicalDevice physicalDevice,
const VkDeviceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkDevice* pDevice)
{
struct instance_data *instance_data =
FIND(struct instance_data, physicalDevice);
VkLayerDeviceCreateInfo *chain_info =
get_device_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
assert(chain_info->u.pLayerInfo);
PFN_vkGetInstanceProcAddr fpGetInstanceProcAddr = chain_info->u.pLayerInfo->pfnNextGetInstanceProcAddr;
PFN_vkGetDeviceProcAddr fpGetDeviceProcAddr = chain_info->u.pLayerInfo->pfnNextGetDeviceProcAddr;
PFN_vkCreateDevice fpCreateDevice = (PFN_vkCreateDevice)fpGetInstanceProcAddr(NULL, "vkCreateDevice");
if (fpCreateDevice == NULL) {
return VK_ERROR_INITIALIZATION_FAILED;
}
// Advance the link info for the next element on the chain
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
VkPhysicalDeviceFeatures device_features = {};
VkDeviceCreateInfo device_info = *pCreateInfo;
std::vector<const char*> enabled_extensions(device_info.ppEnabledExtensionNames,
device_info.ppEnabledExtensionNames +
device_info.enabledExtensionCount);
uint32_t extension_count;
instance_data->vtable.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extension_count, nullptr);
std::vector<VkExtensionProperties> available_extensions(extension_count);
instance_data->vtable.EnumerateDeviceExtensionProperties(physicalDevice, nullptr, &extension_count, available_extensions.data());
bool can_get_driver_info = instance_data->api_version < VK_API_VERSION_1_1 ? false : true;
// VK_KHR_driver_properties became core in 1.2
if (instance_data->api_version < VK_API_VERSION_1_2 && can_get_driver_info) {
for (auto& extension : available_extensions) {
if (extension.extensionName == std::string(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME)) {
for (auto& enabled : enabled_extensions) {
if (enabled == std::string(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME))
goto DONT;
}
enabled_extensions.push_back(VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME);
DONT:
goto FOUND;
}
}
can_get_driver_info = false;
FOUND:;
}
device_info.enabledExtensionCount = enabled_extensions.size();
device_info.ppEnabledExtensionNames = enabled_extensions.data();
if (pCreateInfo->pEnabledFeatures)
device_features = *(pCreateInfo->pEnabledFeatures);
device_info.pEnabledFeatures = &device_features;
VkResult result = fpCreateDevice(physicalDevice, &device_info, pAllocator, pDevice);
if (result != VK_SUCCESS) return result;
struct device_data *device_data = new_device_data(*pDevice, instance_data);
device_data->physical_device = physicalDevice;
vk_load_device_commands(*pDevice, fpGetDeviceProcAddr, &device_data->vtable);
instance_data->vtable.GetPhysicalDeviceProperties(device_data->physical_device,
&device_data->properties);
VkLayerDeviceCreateInfo *load_data_info =
get_device_chain_info(pCreateInfo, VK_LOADER_DATA_CALLBACK);
device_data->set_device_loader_data = load_data_info->u.pfnSetDeviceLoaderData;
driverProps.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
driverProps.pNext = nullptr;
if (can_get_driver_info) {
VkPhysicalDeviceProperties2 deviceProps = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, &driverProps};
instance_data->vtable.GetPhysicalDeviceProperties2(device_data->physical_device, &deviceProps);
}
return result;
}
static void overlay_DestroyDevice(
VkDevice device,
const VkAllocationCallbacks* pAllocator)
{
struct device_data *device_data = FIND(struct device_data, device);
device_unmap_queues(device_data);
device_data->vtable.DestroyDevice(device, pAllocator);
destroy_device_data(device_data);
}
static VkResult overlay_CreateInstance(
const VkInstanceCreateInfo* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkInstance* pInstance)
{
printf("MANGOAPP LAYER!!!\n");
VkLayerInstanceCreateInfo *chain_info =
get_instance_chain_info(pCreateInfo, VK_LAYER_LINK_INFO);
std::string engineVersion,engineName;
@ -289,7 +148,6 @@ static VkResult overlay_CreateInstance(
// Advance the link info for the next element on the chain
chain_info->u.pLayerInfo = chain_info->u.pLayerInfo->pNext;
VkResult result = fpCreateInstance(pCreateInfo, pAllocator, pInstance);
if (result != VK_SUCCESS) return result;
@ -322,18 +180,6 @@ static VkResult overlay_CreateInstance(
return result;
}
static void overlay_DestroyInstance(
VkInstance instance,
const VkAllocationCallbacks* pAllocator)
{
struct instance_data *instance_data = FIND(struct instance_data, instance);
instance_data_map_physical_devices(instance_data, false);
instance_data->vtable.DestroyInstance(instance, pAllocator);
destroy_instance_data(instance_data);
}
extern "C" VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL overlay_GetDeviceProcAddr(VkDevice dev,
const char *funcName);
extern "C" VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL overlay_GetInstanceProcAddr(VkInstance instance,
const char *funcName);
@ -342,14 +188,9 @@ static const struct {
void *ptr;
} name_to_funcptr_map[] = {
{ "vkGetInstanceProcAddr", (void *) overlay_GetInstanceProcAddr },
{ "vkGetDeviceProcAddr", (void *) overlay_GetDeviceProcAddr },
#define ADD_HOOK(fn) { "vk" # fn, (void *) overlay_ ## fn }
#define ADD_ALIAS_HOOK(alias, fn) { "vk" # alias, (void *) overlay_ ## fn }
ADD_HOOK(CreateDevice),
ADD_HOOK(DestroyDevice),
ADD_HOOK(CreateInstance),
ADD_HOOK(DestroyInstance),
#undef ADD_HOOK
};
@ -363,19 +204,6 @@ static void *find_ptr(const char *name)
return NULL;
}
extern "C" VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL overlay_GetDeviceProcAddr(VkDevice dev,
const char *funcName)
{
void *ptr = find_ptr(funcName);
if (ptr) return reinterpret_cast<PFN_vkVoidFunction>(ptr);
if (dev == NULL) return NULL;
struct device_data *device_data = FIND(struct device_data, dev);
if (device_data->vtable.GetDeviceProcAddr == NULL) return NULL;
return device_data->vtable.GetDeviceProcAddr(dev, funcName);
}
extern "C" VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL overlay_GetInstanceProcAddr(VkInstance instance,
const char *funcName)
{

Write Preview
Loading…
Cancel
Save