Skip to content

W
wine-cw
Commit 9972ae6e authored by Jacek Caban's avatar Jacek Caban Committed by Alexandre Julliard
Browse files
Options

winevulkan: Don't pass params struct to private thunks.

parent 8d1bdb5f
Hide whitespace changes
Inline Side-by-side
Showing with 225 additions and 314 deletions
dlls/winevulkan/make_vulkan
View file @ 9972ae6e
......@@ -725,7 +725,7 @@ class VkFunction(object):
pfn += ")"
return pfn
def prototype(self, call_conv=None, prefix=None, postfix=None):
def prototype(self, call_conv=None, prefix=None, postfix=None, is_thunk=False):
""" Generate prototype for given function.
Args:
......@@ -747,6 +747,9 @@ class VkFunction(object):
# Add all the parameters.
proto += ", ".join([p.definition() for p in self.params])
if is_thunk and self.extra_param:
proto += ", void *" + self.extra_param
if postfix is not None:
proto += ") {0}".format(postfix)
else:
......@@ -794,7 +797,7 @@ class VkFunction(object):
else:
body += " {0} {1}_host;\n".format(p.type, p.name)
if not self.needs_private_thunk():
if self.thunk_type == ThunkType.PUBLIC:
body += " {0}\n".format(self.trace(params_prefix=params_prefix))
# Call any win_to_host conversion calls.
......@@ -804,21 +807,23 @@ class VkFunction(object):
# Build list of parameters containing converted and non-converted parameters.
# The param itself knows if conversion is needed and applies it when we set conv=True.
params = ", ".join([p.variable(conv=conv, params_prefix=params_prefix) for p in self.params])
params = ", ".join([p.variable(conv=conv, unwrap=unwrap, params_prefix=params_prefix) for p in self.params])
if self.extra_param:
params += ", {0}{1}".format(params_prefix, self.extra_param)
if unwrap or self.thunk_type == ThunkType.PUBLIC:
func_prefix = "{0}.p_".format(self.params[0].dispatch_table(params_prefix))
else:
func_prefix = "wine_"
# Call the native Vulkan function.
if self.type == "void":
body += " {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(params_prefix),
self.name, params)
body += " {0}{1}({2});\n".format(func_prefix, self.name, params)
else:
body += " {0}result = {1}.p_{2}({3});\n".format(result_prefix,
self.params[0].dispatch_table(params_prefix),
self.name, params)
body += "\n"
body += " {0}result = {1}{2}({3});\n".format(result_prefix, func_prefix, self.name, params)
# Call any host_to_win conversion calls.
if conv:
if conv and unwrap:
for p in self.params:
if not p.output_conv:
continue
......@@ -885,7 +890,7 @@ class VkFunction(object):
thunk = "NTSTATUS {0}{1}(void *args)\n".format(prefix, self.name)
thunk += "{\n"
thunk += " struct {0}_params *params = args;\n".format(self.name)
thunk += self.body(conv=conv, unwrap=not self.needs_private_thunk(), params_prefix="params->")
thunk += self.body(conv=conv, unwrap=self.thunk_type == ThunkType.PUBLIC, params_prefix="params->")
thunk += "}\n\n"
return thunk
......@@ -1810,7 +1815,7 @@ class VkParam(VkVariable):
LOGGER.error("Unhandled spec conversion for type: {0}".format(self.type))
def variable(self, conv=False, params_prefix=""):
def variable(self, conv, unwrap, params_prefix=""):
""" Returns 'glue' code during generation of a function call on how to access the variable.
This function handles various scenarios such as 'unwrapping' if dispatchable objects and
renaming of parameters in case of win32 -> host conversion.
......@@ -1821,16 +1826,16 @@ class VkParam(VkVariable):
# Hack until we enable allocation callbacks from ICD to application. These are a joy
# to enable one day, because of calling convention conversion.
if "VkAllocationCallbacks" in self.type:
if unwrap and "VkAllocationCallbacks" in self.type:
LOGGER.debug("TODO: setting NULL VkAllocationCallbacks for {0}".format(self.name))
return "NULL"
if self.needs_unwrapping() or (conv and self.needs_conversion()):
if (unwrap and self.needs_unwrapping()) or (conv and self.needs_conversion()):
if self.is_dynamic_array():
return "{0}_host".format(self.name)
else:
return "&{0}_host".format(self.name)
else:
elif unwrap:
if self.object_type != None and self.type == "uint64_t":
return "wine_vk_unwrap_handle({0}{1}, {0}{2})".format(params_prefix, self.object_type, self.name)
......@@ -1839,6 +1844,8 @@ class VkParam(VkVariable):
p = "{0}{1}".format(params_prefix, self.name)
driver_handle = self.handle.driver_handle(p) if self.is_handle() else None
return driver_handle if driver_handle else p
else:
return "{0}{1}".format(params_prefix, self.name)
class VkStruct(Sequence):
......@@ -2710,21 +2717,19 @@ class VkGenerator(object):
for vk_func in self.registry.funcs.values():
if not vk_func.needs_exposing():
continue
if vk_func.loader_thunk_type == ThunkType.NONE or vk_func.thunk_type == ThunkType.NONE:
if vk_func.loader_thunk_type == ThunkType.NONE:
continue
f.write("#if !defined(USE_STRUCT_CONVERSION)\n\n")
if vk_func.needs_private_thunk():
f.write(vk_func.thunk(prefix="thunk_"))
else:
f.write("static ")
f.write(vk_func.thunk(prefix="thunk64_"))
f.write("static ")
f.write(vk_func.thunk(prefix="thunk64_"))
f.write("#else /* USE_STRUCT_CONVERSION */\n\n")
if vk_func.needs_private_thunk():
f.write(vk_func.thunk(prefix="thunk_", conv=True))
else:
f.write("static ")
f.write(vk_func.thunk(prefix="thunk32_", conv=True))
f.write("static ")
f.write(vk_func.thunk(prefix="thunk32_", conv=vk_func.thunk_type == ThunkType.PUBLIC))
f.write("#endif /* USE_STRUCT_CONVERSION */\n\n")
# Create array of device extensions.
......@@ -2814,8 +2819,7 @@ class VkGenerator(object):
if vk_func.loader_thunk_type == ThunkType.NONE:
continue
prefix = "thunk64_" if vk_func.thunk_type == ThunkType.PUBLIC else "wine_"
f.write(" {1}{0},\n".format(vk_func.name, prefix))
f.write(" {1}{0},\n".format(vk_func.name, "thunk64_"))
f.write("};\n")
f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n\n")
......@@ -2832,8 +2836,7 @@ class VkGenerator(object):
if vk_func.loader_thunk_type == ThunkType.NONE:
continue
prefix = "thunk32_" if vk_func.thunk_type == ThunkType.PUBLIC else "wine_"
f.write(" {1}{0},\n".format(vk_func.name, prefix))
f.write(" {1}{0},\n".format(vk_func.name, "thunk32_"))
f.write("};\n")
f.write("C_ASSERT(ARRAYSIZE(__wine_unix_call_funcs) == unix_count);\n\n")
......@@ -2860,7 +2863,7 @@ class VkGenerator(object):
if vk_func.needs_thunk() and not vk_func.needs_private_thunk():
continue
f.write("NTSTATUS {0}{1}(void *args) DECLSPEC_HIDDEN;\n".format(prefix, vk_func.name))
f.write("{0};\n".format(vk_func.prototype(prefix=prefix, postfix="DECLSPEC_HIDDEN", is_thunk=True)))
f.write("\n")
f.write("/* Private thunks */\n")
......
dlls/winevulkan/vulkan.c
View file @ 9972ae6e
......@@ -645,12 +645,10 @@ static void wine_vk_instance_free(struct wine_instance *instance)
free(instance);
}
NTSTATUS wine_vkAllocateCommandBuffers(void *args)
VkResult wine_vkAllocateCommandBuffers(VkDevice handle, const VkCommandBufferAllocateInfo *allocate_info,
VkCommandBuffer *buffers )
{
struct vkAllocateCommandBuffers_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
const VkCommandBufferAllocateInfo *allocate_info = params->pAllocateInfo;
VkCommandBuffer *buffers = params->pCommandBuffers;
struct wine_device *device = wine_device_from_handle(handle);
struct wine_cmd_buffer *buffer;
struct wine_cmd_pool *pool;
VkResult res = VK_SUCCESS;
......@@ -701,14 +699,12 @@ NTSTATUS wine_vkAllocateCommandBuffers(void *args)
return res;
}
NTSTATUS wine_vkCreateDevice(void *args)
VkResult wine_vkCreateDevice(VkPhysicalDevice phys_dev_handle, const VkDeviceCreateInfo *create_info,
const VkAllocationCallbacks *allocator, VkDevice *ret_device,
void *client_ptr)
{
struct vkCreateDevice_params *params = args;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(params->physicalDevice);
const VkDeviceCreateInfo *create_info = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkDevice *ret_device = params->pDevice;
VkDevice device_handle = params->client_ptr;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
VkDevice device_handle = client_ptr;
VkDeviceCreateInfo create_info_host;
struct VkQueue_T *queue_handles;
struct wine_queue *next_queue;
......@@ -716,7 +712,7 @@ NTSTATUS wine_vkCreateDevice(void *args)
unsigned int i;
VkResult res;
TRACE("%p, %p, %p, %p\n", phys_dev, create_info, allocator, ret_device);
TRACE("%p, %p, %p, %p\n", phys_dev_handle, create_info, allocator, ret_device);
if (allocator)
FIXME("Support for allocation callbacks not implemented yet\n");
......@@ -801,13 +797,11 @@ fail:
return res;
}
NTSTATUS wine_vkCreateInstance(void *args)
VkResult wine_vkCreateInstance(const VkInstanceCreateInfo *create_info,
const VkAllocationCallbacks *allocator, VkInstance *instance,
void *client_ptr)
{
struct vkCreateInstance_params *params = args;
const VkInstanceCreateInfo *create_info = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkInstance *instance = params->pInstance;
VkInstance client_instance = params->client_ptr;
VkInstance client_instance = client_ptr;
VkInstanceCreateInfo create_info_host;
const VkApplicationInfo *app_info;
struct wine_instance *object;
......@@ -885,11 +879,9 @@ NTSTATUS wine_vkCreateInstance(void *args)
return VK_SUCCESS;
}
NTSTATUS wine_vkDestroyDevice(void *args)
void wine_vkDestroyDevice(VkDevice handle, const VkAllocationCallbacks *allocator)
{
struct vkDestroyDevice_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_device *device = wine_device_from_handle(handle);
TRACE("%p %p\n", device, allocator);
......@@ -897,14 +889,11 @@ NTSTATUS wine_vkDestroyDevice(void *args)
FIXME("Support for allocation callbacks not implemented yet\n");
wine_vk_device_free(device);
return STATUS_SUCCESS;
}
NTSTATUS wine_vkDestroyInstance(void *args)
void wine_vkDestroyInstance(VkInstance handle, const VkAllocationCallbacks *allocator)
{
struct vkDestroyInstance_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_instance *instance = wine_instance_from_handle(handle);
TRACE("%p, %p\n", instance, allocator);
......@@ -912,16 +901,12 @@ NTSTATUS wine_vkDestroyInstance(void *args)
FIXME("Support allocation allocators\n");
wine_vk_instance_free(instance);
return STATUS_SUCCESS;
}
NTSTATUS wine_vkEnumerateDeviceExtensionProperties(void *args)
VkResult wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice phys_dev_handle, const char *layer_name,
uint32_t *count, VkExtensionProperties *properties)
{
struct vkEnumerateDeviceExtensionProperties_params *params = args;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(params->physicalDevice);
const char *layer_name = params->pLayerName;
uint32_t *count = params->pPropertyCount;
VkExtensionProperties *properties = params->pProperties;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(phys_dev_handle);
TRACE("%p, %p, %p, %p\n", phys_dev, layer_name, count, properties);
......@@ -945,11 +930,9 @@ NTSTATUS wine_vkEnumerateDeviceExtensionProperties(void *args)
return *count < phys_dev->extension_count ? VK_INCOMPLETE : VK_SUCCESS;
}
NTSTATUS wine_vkEnumerateInstanceExtensionProperties(void *args)
VkResult wine_vkEnumerateInstanceExtensionProperties(const char *name, uint32_t *count,
VkExtensionProperties *properties)
{
struct vkEnumerateInstanceExtensionProperties_params *params = args;
uint32_t *count = params->pPropertyCount;
VkExtensionProperties *properties = params->pProperties;
uint32_t num_properties = 0, num_host_properties;
VkExtensionProperties *host_properties;
unsigned int i, j;
......@@ -1004,21 +987,17 @@ NTSTATUS wine_vkEnumerateInstanceExtensionProperties(void *args)
return *count < num_properties ? VK_INCOMPLETE : VK_SUCCESS;
}
NTSTATUS wine_vkEnumerateDeviceLayerProperties(void *args)
VkResult wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice phys_dev, uint32_t *count,
VkLayerProperties *properties)
{
struct vkEnumerateDeviceLayerProperties_params *params = args;
uint32_t *count = params->pPropertyCount;
TRACE("%p, %p, %p\n", params->physicalDevice, count, params->pProperties);
TRACE("%p, %p, %p\n", phys_dev, count, properties);
*count = 0;
return VK_SUCCESS;
}
NTSTATUS wine_vkEnumerateInstanceVersion(void *args)
VkResult wine_vkEnumerateInstanceVersion(uint32_t *version)
{
struct vkEnumerateInstanceVersion_params *params = args;
uint32_t *version = params->pApiVersion;
VkResult res;
static VkResult (*p_vkEnumerateInstanceVersion)(uint32_t *version);
......@@ -1041,12 +1020,9 @@ NTSTATUS wine_vkEnumerateInstanceVersion(void *args)
return res;
}
NTSTATUS wine_vkEnumeratePhysicalDevices(void *args)
VkResult wine_vkEnumeratePhysicalDevices(VkInstance handle, uint32_t *count, VkPhysicalDevice *devices)
{
struct vkEnumeratePhysicalDevices_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
uint32_t *count = params->pPhysicalDeviceCount;
VkPhysicalDevice *devices = params->pPhysicalDevices;
struct wine_instance *instance = wine_instance_from_handle(handle);
unsigned int i;
TRACE("%p %p %p\n", instance, count, devices);
......@@ -1067,18 +1043,15 @@ NTSTATUS wine_vkEnumeratePhysicalDevices(void *args)
return *count < instance->phys_dev_count ? VK_INCOMPLETE : VK_SUCCESS;
}
NTSTATUS wine_vkFreeCommandBuffers(void *args)
void wine_vkFreeCommandBuffers(VkDevice handle, VkCommandPool command_pool, uint32_t count,
const VkCommandBuffer *buffers)
{
struct vkFreeCommandBuffers_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(params->commandPool);
uint32_t count = params->commandBufferCount;
const VkCommandBuffer *buffers = params->pCommandBuffers;
struct wine_device *device = wine_device_from_handle(handle);
struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(command_pool);
TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(params->commandPool), count, buffers);
TRACE("%p, 0x%s, %u, %p\n", device, wine_dbgstr_longlong(command_pool), count, buffers);
wine_vk_free_command_buffers(device, pool, count, buffers);
return STATUS_SUCCESS;
}
static VkQueue wine_vk_device_find_queue(VkDevice handle, const VkDeviceQueueInfo2 *info)
......@@ -1101,13 +1074,8 @@ static VkQueue wine_vk_device_find_queue(VkDevice handle, const VkDeviceQueueInf
return VK_NULL_HANDLE;
}
NTSTATUS wine_vkGetDeviceQueue(void *args)
void wine_vkGetDeviceQueue(VkDevice device, uint32_t family_index, uint32_t queue_index, VkQueue *queue)
{
struct vkGetDeviceQueue_params *params = args;
VkDevice device = params->device;
uint32_t family_index = params->queueFamilyIndex;
uint32_t queue_index = params->queueIndex;
VkQueue *queue = params->pQueue;
VkDeviceQueueInfo2 queue_info;
TRACE("%p, %u, %u, %p\n", device, family_index, queue_index, queue);
......@@ -1119,15 +1087,10 @@ NTSTATUS wine_vkGetDeviceQueue(void *args)
queue_info.queueIndex = queue_index;
*queue = wine_vk_device_find_queue(device, &queue_info);
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetDeviceQueue2(void *args)
void wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *info, VkQueue *queue)
{
struct vkGetDeviceQueue2_params *params = args;
VkDevice device = params->device;
const VkDeviceQueueInfo2 *info = params->pQueueInfo;
VkQueue *queue = params->pQueue;
const VkBaseInStructure *chain;
TRACE("%p, %p, %p\n", device, info, queue);
......@@ -1136,17 +1099,14 @@ NTSTATUS wine_vkGetDeviceQueue2(void *args)
FIXME("Ignoring a linked structure of type %u.\n", chain->sType);
*queue = wine_vk_device_find_queue(device, info);
return STATUS_SUCCESS;
}
NTSTATUS wine_vkCreateCommandPool(void *args)
VkResult wine_vkCreateCommandPool(VkDevice device_handle, const VkCommandPoolCreateInfo *info,
const VkAllocationCallbacks *allocator, VkCommandPool *command_pool,
void *client_ptr)
{
struct vkCreateCommandPool_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
const VkCommandPoolCreateInfo *info = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkCommandPool *command_pool = params->pCommandPool;
struct vk_command_pool *handle = params->client_ptr;
struct wine_device *device = wine_device_from_handle(device_handle);
struct vk_command_pool *handle = client_ptr;
struct wine_cmd_pool *object;
VkResult res;
......@@ -1176,12 +1136,10 @@ NTSTATUS wine_vkCreateCommandPool(void *args)
return res;
}
NTSTATUS wine_vkDestroyCommandPool(void *args)
void wine_vkDestroyCommandPool(VkDevice device_handle, VkCommandPool handle,
const VkAllocationCallbacks *allocator)
{
struct vkDestroyCommandPool_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
VkCommandPool handle = params->commandPool;
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_device *device = wine_device_from_handle(device_handle);
struct wine_cmd_pool *pool = wine_cmd_pool_from_handle(handle);
TRACE("%p, 0x%s, %p\n", device, wine_dbgstr_longlong(handle), allocator);
......@@ -1193,7 +1151,6 @@ NTSTATUS wine_vkDestroyCommandPool(void *args)
device->funcs.p_vkDestroyCommandPool(device->device, pool->command_pool, NULL);
free(pool);
return STATUS_SUCCESS;
}
static VkResult wine_vk_enumerate_physical_device_groups(struct wine_instance *instance,
......@@ -1223,88 +1180,66 @@ static VkResult wine_vk_enumerate_physical_device_groups(struct wine_instance *i
return res;
}
NTSTATUS wine_vkEnumeratePhysicalDeviceGroups(void *args)
VkResult wine_vkEnumeratePhysicalDeviceGroups(VkInstance handle, uint32_t *count,
VkPhysicalDeviceGroupProperties *properties)
{
struct vkEnumeratePhysicalDeviceGroups_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
uint32_t *count = params->pPhysicalDeviceGroupCount;
VkPhysicalDeviceGroupProperties *properties = params->pPhysicalDeviceGroupProperties;
struct wine_instance *instance = wine_instance_from_handle(handle);
TRACE("%p, %p, %p\n", instance, count, properties);
return wine_vk_enumerate_physical_device_groups(instance,
instance->funcs.p_vkEnumeratePhysicalDeviceGroups, count, properties);
}
NTSTATUS wine_vkEnumeratePhysicalDeviceGroupsKHR(void *args)
VkResult wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance handle, uint32_t *count,
VkPhysicalDeviceGroupProperties *properties)
{
struct vkEnumeratePhysicalDeviceGroupsKHR_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
uint32_t *count = params->pPhysicalDeviceGroupCount;
VkPhysicalDeviceGroupProperties *properties = params->pPhysicalDeviceGroupProperties;
struct wine_instance *instance = wine_instance_from_handle(handle);
TRACE("%p, %p, %p\n", instance, count, properties);
return wine_vk_enumerate_physical_device_groups(instance,
instance->funcs.p_vkEnumeratePhysicalDeviceGroupsKHR, count, properties);
}
NTSTATUS wine_vkGetPhysicalDeviceExternalFenceProperties(void *args)
void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalFenceInfo *fence_info,
VkExternalFenceProperties *properties)
{
struct vkGetPhysicalDeviceExternalFenceProperties_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalFenceInfo *fence_info = params->pExternalFenceInfo;
VkExternalFenceProperties *properties = params->pExternalFenceProperties;
TRACE("%p, %p, %p\n", phys_dev, fence_info, properties);
properties->exportFromImportedHandleTypes = 0;
properties->compatibleHandleTypes = 0;
properties->externalFenceFeatures = 0;
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args)
void wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalFenceInfo *fence_info,
VkExternalFenceProperties *properties)
{
struct vkGetPhysicalDeviceExternalFencePropertiesKHR_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalFenceInfo *fence_info = params->pExternalFenceInfo;
VkExternalFenceProperties *properties = params->pExternalFenceProperties;
TRACE("%p, %p, %p\n", phys_dev, fence_info, properties);
properties->exportFromImportedHandleTypes = 0;
properties->compatibleHandleTypes = 0;
properties->externalFenceFeatures = 0;
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetPhysicalDeviceExternalBufferProperties(void *args)
void wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalBufferInfo *buffer_info,
VkExternalBufferProperties *properties)
{
struct vkGetPhysicalDeviceExternalBufferProperties_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalBufferInfo *buffer_info = params->pExternalBufferInfo;
VkExternalBufferProperties *properties = params->pExternalBufferProperties;
TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args)
void wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalBufferInfo *buffer_info,
VkExternalBufferProperties *properties)
{
struct vkGetPhysicalDeviceExternalBufferPropertiesKHR_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalBufferInfo *buffer_info = params->pExternalBufferInfo;
VkExternalBufferProperties *properties = params->pExternalBufferProperties;
TRACE("%p, %p, %p\n", phys_dev, buffer_info, properties);
memset(&properties->externalMemoryProperties, 0, sizeof(properties->externalMemoryProperties));
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetPhysicalDeviceImageFormatProperties2(void *args)
VkResult wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceImageFormatInfo2 *format_info,
VkImageFormatProperties2 *properties)
{
struct vkGetPhysicalDeviceImageFormatProperties2_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceImageFormatInfo2 *format_info = params->pImageFormatInfo;
VkImageFormatProperties2 *properties = params->pImageFormatProperties;
VkExternalImageFormatProperties *external_image_properties;
VkResult res;
......@@ -1323,12 +1258,10 @@ NTSTATUS wine_vkGetPhysicalDeviceImageFormatProperties2(void *args)
return res;
}
NTSTATUS wine_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args)
VkResult wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceImageFormatInfo2 *format_info,
VkImageFormatProperties2 *properties)
{
struct vkGetPhysicalDeviceImageFormatProperties2KHR_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceImageFormatInfo2 *format_info = params->pImageFormatInfo;
VkImageFormatProperties2 *properties = params->pImageFormatProperties;
VkExternalImageFormatProperties *external_image_properties;
VkResult res;
......@@ -1393,14 +1326,11 @@ static inline uint64_t convert_timestamp(VkTimeDomainEXT host_domain, VkTimeDoma
return value;
}
NTSTATUS wine_vkGetCalibratedTimestampsEXT(void *args)
VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice handle, uint32_t timestamp_count,
const VkCalibratedTimestampInfoEXT *timestamp_infos,
uint64_t *timestamps, uint64_t *max_deviation)
{
struct vkGetCalibratedTimestampsEXT_params *params = args;
struct wine_device *device = wine_device_from_handle(params->device);
uint32_t timestamp_count = params->timestampCount;
const VkCalibratedTimestampInfoEXT *timestamp_infos = params->pTimestampInfos;
uint64_t *timestamps = params->pTimestamps;
uint64_t *max_deviation = params->pMaxDeviation;
struct wine_device *device = wine_device_from_handle(handle);
VkCalibratedTimestampInfoEXT* host_timestamp_infos;
unsigned int i;
VkResult res;
......@@ -1428,12 +1358,11 @@ NTSTATUS wine_vkGetCalibratedTimestampsEXT(void *args)
return res;
}
NTSTATUS wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice handle,
uint32_t *time_domain_count,
VkTimeDomainEXT *time_domains)
{
struct vkGetPhysicalDeviceCalibrateableTimeDomainsEXT_params *params = args;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(params->physicalDevice);
uint32_t *time_domain_count = params->pTimeDomainCount;
VkTimeDomainEXT *time_domains = params->pTimeDomains;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
BOOL supports_device = FALSE, supports_monotonic = FALSE, supports_monotonic_raw = FALSE;
const VkTimeDomainEXT performance_counter_domain = get_performance_counter_time_domain();
VkTimeDomainEXT *host_time_domains;
......@@ -1503,41 +1432,30 @@ NTSTATUS wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args)
return res;
}
NTSTATUS wine_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args)
void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalSemaphoreInfo *info,
VkExternalSemaphoreProperties *properties)
{
struct vkGetPhysicalDeviceExternalSemaphoreProperties_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalSemaphoreInfo *semaphore_info = params->pExternalSemaphoreInfo;
VkExternalSemaphoreProperties *properties = params->pExternalSemaphoreProperties;
TRACE("%p, %p, %p\n", phys_dev, semaphore_info, properties);
TRACE("%p, %p, %p\n", phys_dev, info, properties);
properties->exportFromImportedHandleTypes = 0;
properties->compatibleHandleTypes = 0;
properties->externalSemaphoreFeatures = 0;
return STATUS_SUCCESS;
}
NTSTATUS wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args)
void wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice phys_dev,
const VkPhysicalDeviceExternalSemaphoreInfo *info,
VkExternalSemaphoreProperties *properties)
{
struct vkGetPhysicalDeviceExternalSemaphorePropertiesKHR_params *params = args;
VkPhysicalDevice phys_dev = params->physicalDevice;
const VkPhysicalDeviceExternalSemaphoreInfo *semaphore_info = params->pExternalSemaphoreInfo;
VkExternalSemaphoreProperties *properties = params->pExternalSemaphoreProperties;
TRACE("%p, %p, %p\n", phys_dev, semaphore_info, properties);
TRACE("%p, %p, %p\n", phys_dev, info, properties);
properties->exportFromImportedHandleTypes = 0;
properties->compatibleHandleTypes = 0;
properties->externalSemaphoreFeatures = 0;
return STATUS_SUCCESS;
}
NTSTATUS wine_vkCreateWin32SurfaceKHR(void *args)
VkResult wine_vkCreateWin32SurfaceKHR(VkInstance handle, const VkWin32SurfaceCreateInfoKHR *createInfo,
const VkAllocationCallbacks *allocator, VkSurfaceKHR *surface)
{
struct vkCreateWin32SurfaceKHR_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
const VkWin32SurfaceCreateInfoKHR *createInfo = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkSurfaceKHR *surface = params->pSurface;
struct wine_instance *instance = wine_instance_from_handle(handle);
struct wine_surface *object;
VkResult res;
......@@ -1568,24 +1486,21 @@ NTSTATUS wine_vkCreateWin32SurfaceKHR(void *args)
return VK_SUCCESS;
}
NTSTATUS wine_vkDestroySurfaceKHR(void *args)
void wine_vkDestroySurfaceKHR(VkInstance handle, VkSurfaceKHR surface,
const VkAllocationCallbacks *allocator)
{
struct vkDestroySurfaceKHR_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
VkSurfaceKHR surface = params->surface;
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_instance *instance = wine_instance_from_handle(handle);
struct wine_surface *object = wine_surface_from_handle(surface);
TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(surface), allocator);
if (!object)
return STATUS_SUCCESS;
return;
instance->funcs.p_vkDestroySurfaceKHR(instance->instance, object->driver_surface, NULL);
WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
free(object);
return STATUS_SUCCESS;
}
static inline void adjust_max_image_count(struct wine_phys_dev *phys_dev, VkSurfaceCapabilitiesKHR* capabilities)
......@@ -1603,12 +1518,10 @@ static inline void adjust_max_image_count(struct wine_phys_dev *phys_dev, VkSurf
}
}
NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
VkResult wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice handle, VkSurfaceKHR surface,
VkSurfaceCapabilitiesKHR *capabilities)
{
struct vkGetPhysicalDeviceSurfaceCapabilitiesKHR_params *params = args;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(params->physicalDevice);
VkSurfaceKHR surface = params->surface;
VkSurfaceCapabilitiesKHR *capabilities = params->pSurfaceCapabilities;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
VkResult res;
TRACE("%p, 0x%s, %p\n", phys_dev, wine_dbgstr_longlong(surface), capabilities);
......@@ -1621,12 +1534,11 @@ NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args)
return res;
}
NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
VkResult wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice handle,
const VkPhysicalDeviceSurfaceInfo2KHR *surface_info,
VkSurfaceCapabilities2KHR *capabilities)
{
struct vkGetPhysicalDeviceSurfaceCapabilities2KHR_params *params = args;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(params->physicalDevice);
const VkPhysicalDeviceSurfaceInfo2KHR *surface_info = params->pSurfaceInfo;
VkSurfaceCapabilities2KHR *capabilities = params->pSurfaceCapabilities;
struct wine_phys_dev *phys_dev = wine_phys_dev_from_handle(handle);
VkResult res;
TRACE("%p, %p, %p\n", phys_dev, surface_info, capabilities);
......@@ -1639,13 +1551,12 @@ NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args)
return res;
}
NTSTATUS wine_vkCreateDebugUtilsMessengerEXT(void *args)
VkResult wine_vkCreateDebugUtilsMessengerEXT(VkInstance handle,
const VkDebugUtilsMessengerCreateInfoEXT *create_info,
const VkAllocationCallbacks *allocator,
VkDebugUtilsMessengerEXT *messenger)
{
struct vkCreateDebugUtilsMessengerEXT_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
const VkDebugUtilsMessengerCreateInfoEXT *create_info = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkDebugUtilsMessengerEXT *messenger = params->pMessenger;
struct wine_instance *instance = wine_instance_from_handle(handle);
VkDebugUtilsMessengerCreateInfoEXT wine_create_info;
struct wine_debug_utils_messenger *object;
VkResult res;
......@@ -1681,12 +1592,10 @@ NTSTATUS wine_vkCreateDebugUtilsMessengerEXT(void *args)
return VK_SUCCESS;
}
NTSTATUS wine_vkDestroyDebugUtilsMessengerEXT(void *args)
void wine_vkDestroyDebugUtilsMessengerEXT(VkInstance handle, VkDebugUtilsMessengerEXT messenger,
const VkAllocationCallbacks *allocator)
{
struct vkDestroyDebugUtilsMessengerEXT_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
VkDebugUtilsMessengerEXT messenger = params->messenger;
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_instance *instance = wine_instance_from_handle(handle);
struct wine_debug_utils_messenger *object;
TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(messenger), allocator);
......@@ -1694,22 +1603,20 @@ NTSTATUS wine_vkDestroyDebugUtilsMessengerEXT(void *args)
object = wine_debug_utils_messenger_from_handle(messenger);
if (!object)
return STATUS_SUCCESS;
return;
instance->funcs.p_vkDestroyDebugUtilsMessengerEXT(instance->instance, object->debug_messenger, NULL);
WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
free(object);
return STATUS_SUCCESS;
}
NTSTATUS wine_vkCreateDebugReportCallbackEXT(void *args)
VkResult wine_vkCreateDebugReportCallbackEXT(VkInstance handle,
const VkDebugReportCallbackCreateInfoEXT *create_info,
const VkAllocationCallbacks *allocator,
VkDebugReportCallbackEXT *callback)
{
struct vkCreateDebugReportCallbackEXT_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
const VkDebugReportCallbackCreateInfoEXT *create_info = params->pCreateInfo;
const VkAllocationCallbacks *allocator = params->pAllocator;
VkDebugReportCallbackEXT *callback = params->pCallback;
struct wine_instance *instance = wine_instance_from_handle(handle);
VkDebugReportCallbackCreateInfoEXT wine_create_info;
struct wine_debug_report_callback *object;
VkResult res;
......@@ -1745,12 +1652,10 @@ NTSTATUS wine_vkCreateDebugReportCallbackEXT(void *args)
return VK_SUCCESS;
}
NTSTATUS wine_vkDestroyDebugReportCallbackEXT(void *args)
void wine_vkDestroyDebugReportCallbackEXT(VkInstance handle, VkDebugReportCallbackEXT callback,
const VkAllocationCallbacks *allocator)
{
struct vkDestroyDebugReportCallbackEXT_params *params = args;
struct wine_instance *instance = wine_instance_from_handle(params->instance);
VkDebugReportCallbackEXT callback = params->callback;
const VkAllocationCallbacks *allocator = params->pAllocator;
struct wine_instance *instance = wine_instance_from_handle(handle);
struct wine_debug_report_callback *object;
TRACE("%p, 0x%s, %p\n", instance, wine_dbgstr_longlong(callback), allocator);
......@@ -1758,14 +1663,13 @@ NTSTATUS wine_vkDestroyDebugReportCallbackEXT(void *args)
object = wine_debug_report_callback_from_handle(callback);
if (!object)
return STATUS_SUCCESS;
return;
instance->funcs.p_vkDestroyDebugReportCallbackEXT(instance->instance, object->debug_callback, NULL);
WINE_VK_REMOVE_HANDLE_MAPPING(instance, object);
free(object);
return STATUS_SUCCESS;
}
static void fixup_pipeline_feedback(VkPipelineCreationFeedback *feedback, uint32_t count)
......@@ -1802,75 +1706,79 @@ static void fixup_pipeline_feedback_info(const void *pipeline_info)
feedback->pipelineStageCreationFeedbackCount);
}
NTSTATUS wine_vkCreateComputePipelines(void *args)
VkResult wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipeline_cache,
uint32_t count, const VkComputePipelineCreateInfo *create_infos,
const VkAllocationCallbacks *allocator, VkPipeline *pipelines)
{
struct vkCreateComputePipelines_params *params = args;
VkResult res;
uint32_t i;
TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache),
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipeline_cache),
count, create_infos, allocator, pipelines);
res = thunk_vkCreateComputePipelines(params->device, params->pipelineCache,
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
res = thunk_vkCreateComputePipelines(device, pipeline_cache, count, create_infos,
allocator, pipelines);
for (i = 0; i < params->createInfoCount; i++)
fixup_pipeline_feedback_info(&params->pCreateInfos[i]);
for (i = 0; i < count; i++)
fixup_pipeline_feedback_info(&create_infos[i]);
return res;
}
NTSTATUS wine_vkCreateGraphicsPipelines(void *args)
VkResult wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipeline_cache,
uint32_t count, const VkGraphicsPipelineCreateInfo *create_infos,
const VkAllocationCallbacks *allocator, VkPipeline *pipelines)
{
struct vkCreateGraphicsPipelines_params *params = args;
VkResult res;
uint32_t i;
TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache),
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipeline_cache),
count, create_infos, allocator, pipelines);
res = thunk_vkCreateGraphicsPipelines(params->device, params->pipelineCache,
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
res = thunk_vkCreateGraphicsPipelines(device, pipeline_cache, count, create_infos,
allocator, pipelines);
for (i = 0; i < params->createInfoCount; i++)
fixup_pipeline_feedback_info(&params->pCreateInfos[i]);
for (i = 0; i < count; i++)
fixup_pipeline_feedback_info(&create_infos[i]);
return res;
}
NTSTATUS wine_vkCreateRayTracingPipelinesKHR(void *args)
VkResult wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferred_operation,
VkPipelineCache pipeline_cache, uint32_t count,
const VkRayTracingPipelineCreateInfoKHR *create_infos,
const VkAllocationCallbacks *allocator, VkPipeline *pipelines)
{
struct vkCreateRayTracingPipelinesKHR_params *params = args;
VkResult res;
uint32_t i;
TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", params->device,
wine_dbgstr_longlong(params->deferredOperation), wine_dbgstr_longlong(params->pipelineCache),
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
TRACE("%p, 0x%s, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(deferred_operation),
wine_dbgstr_longlong(pipeline_cache), count, create_infos, allocator, pipelines);
res = thunk_vkCreateRayTracingPipelinesKHR(params->device, params->deferredOperation, params->pipelineCache,
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
res = thunk_vkCreateRayTracingPipelinesKHR(device, deferred_operation, pipeline_cache,
count, create_infos, allocator, pipelines);
for (i = 0; i < params->createInfoCount; i++)
fixup_pipeline_feedback_info(&params->pCreateInfos[i]);
for (i = 0; i < count; i++)
fixup_pipeline_feedback_info(&create_infos[i]);
return res;
}
NTSTATUS wine_vkCreateRayTracingPipelinesNV(void *args)
VkResult wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipeline_cache, uint32_t count,
const VkRayTracingPipelineCreateInfoNV *create_infos,
const VkAllocationCallbacks *allocator, VkPipeline *pipelines)
{
struct vkCreateRayTracingPipelinesNV_params *params = args;
VkResult res;
uint32_t i;
TRACE("%p, 0x%s, %u, %p, %p, %p\n", params->device, wine_dbgstr_longlong(params->pipelineCache),
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
TRACE("%p, 0x%s, %u, %p, %p, %p\n", device, wine_dbgstr_longlong(pipeline_cache),
count, create_infos, allocator, pipelines);
res = thunk_vkCreateRayTracingPipelinesNV(params->device, params->pipelineCache,
params->createInfoCount, params->pCreateInfos, params->pAllocator, params->pPipelines);
res = thunk_vkCreateRayTracingPipelinesNV(device, pipeline_cache, count, create_infos,
allocator, pipelines);
for (i = 0; i < params->createInfoCount; i++)
fixup_pipeline_feedback_info(&params->pCreateInfos[i]);
for (i = 0; i < count; i++)
fixup_pipeline_feedback_info(&create_infos[i]);
return res;
}
......
dlls/winevulkan/vulkan_thunks.c
View file @ 9972ae6e
This source diff could not be displayed because it is too large. You can view the blob instead.
dlls/winevulkan/vulkan_thunks.h
View file @ 9972ae6e
......@@ -15,48 +15,48 @@
#define WINE_VK_VERSION VK_API_VERSION_1_3
/* Functions for which we have custom implementations outside of the thunks. */
NTSTATUS wine_vkAllocateCommandBuffers(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateCommandPool(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateComputePipelines(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateDebugReportCallbackEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateDebugUtilsMessengerEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateDevice(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateGraphicsPipelines(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateInstance(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateRayTracingPipelinesKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateRayTracingPipelinesNV(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkCreateWin32SurfaceKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroyCommandPool(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroyDebugReportCallbackEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroyDebugUtilsMessengerEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroyDevice(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroyInstance(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkDestroySurfaceKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumerateDeviceExtensionProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumerateDeviceLayerProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumerateInstanceExtensionProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumerateInstanceLayerProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumerateInstanceVersion(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumeratePhysicalDeviceGroups(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumeratePhysicalDeviceGroupsKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkEnumeratePhysicalDevices(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkFreeCommandBuffers(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetCalibratedTimestampsEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetDeviceProcAddr(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetDeviceQueue(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetDeviceQueue2(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetInstanceProcAddr(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalBufferProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalFenceProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalSemaphoreProperties(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceImageFormatProperties2(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceImageFormatProperties2KHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(void *args) DECLSPEC_HIDDEN;
NTSTATUS wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(void *args) DECLSPEC_HIDDEN;
VkResult wine_vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo *pAllocateInfo, VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
VkResult wine_vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkCommandPool *pCommandPool, void *client_ptr) DECLSPEC_HIDDEN;
VkResult wine_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) DECLSPEC_HIDDEN;
VkResult wine_vkCreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugReportCallbackEXT *pCallback) DECLSPEC_HIDDEN;
VkResult wine_vkCreateDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDebugUtilsMessengerEXT *pMessenger) DECLSPEC_HIDDEN;
VkResult wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice, void *client_ptr) DECLSPEC_HIDDEN;
VkResult wine_vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) DECLSPEC_HIDDEN;
VkResult wine_vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkInstance *pInstance, void *client_ptr) DECLSPEC_HIDDEN;
VkResult wine_vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) DECLSPEC_HIDDEN;
VkResult wine_vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) DECLSPEC_HIDDEN;
VkResult wine_vkCreateWin32SurfaceKHR(VkInstance instance, const VkWin32SurfaceCreateInfoKHR *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkSurfaceKHR *pSurface) DECLSPEC_HIDDEN;
void wine_vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
void wine_vkDestroyDebugReportCallbackEXT(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
void wine_vkDestroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
void wine_vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
void wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
void wine_vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks *pAllocator) DECLSPEC_HIDDEN;
VkResult wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumerateInstanceExtensionProperties(const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount, VkLayerProperties *pProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumerateInstanceVersion(uint32_t *pApiVersion) DECLSPEC_HIDDEN;
VkResult wine_vkEnumeratePhysicalDeviceGroups(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumeratePhysicalDeviceGroupsKHR(VkInstance instance, uint32_t *pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties *pPhysicalDeviceGroupProperties) DECLSPEC_HIDDEN;
VkResult wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) DECLSPEC_HIDDEN;
void wine_vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer *pCommandBuffers) DECLSPEC_HIDDEN;
VkResult wine_vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT *pTimestampInfos, uint64_t *pTimestamps, uint64_t *pMaxDeviation) DECLSPEC_HIDDEN;
PFN_vkVoidFunction wine_vkGetDeviceProcAddr(VkDevice device, const char *pName) DECLSPEC_HIDDEN;
void wine_vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue *pQueue) DECLSPEC_HIDDEN;
void wine_vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2 *pQueueInfo, VkQueue *pQueue) DECLSPEC_HIDDEN;
PFN_vkVoidFunction wine_vkGetInstanceProcAddr(VkInstance instance, const char *pName) DECLSPEC_HIDDEN;
VkResult wine_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t *pTimeDomainCount, VkTimeDomainEXT *pTimeDomains) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) DECLSPEC_HIDDEN;
void wine_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) DECLSPEC_HIDDEN;
VkResult wine_vkGetPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) DECLSPEC_HIDDEN;
VkResult wine_vkGetPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkImageFormatProperties2 *pImageFormatProperties) DECLSPEC_HIDDEN;
VkResult wine_vkGetPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR *pSurfaceInfo, VkSurfaceCapabilities2KHR *pSurfaceCapabilities) DECLSPEC_HIDDEN;
VkResult wine_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR *pSurfaceCapabilities) DECLSPEC_HIDDEN;
/* Private thunks */
VkResult thunk_vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo *pCreateInfos, const VkAllocationCallbacks *pAllocator, VkPipeline *pPipelines) DECLSPEC_HIDDEN;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment