[PATCH v2 1/5] winevulkan: Implement physical device core functions.
Roderick Colenbrander
thunderbird2k at gmail.com
Fri Mar 9 10:48:46 CST 2018
Signed-off-by: Roderick Colenbrander <thunderbird2k at gmail.com>
---
dlls/winevulkan/make_vulkan | 734 +++++++++++++++++++++++++++++++++++++++-
dlls/winevulkan/vulkan_thunks.c | 220 +++++++++++-
dlls/winevulkan/vulkan_thunks.h | 164 +++++++++
3 files changed, 1105 insertions(+), 13 deletions(-)
diff --git a/dlls/winevulkan/make_vulkan b/dlls/winevulkan/make_vulkan
index 7499cf7011..12ea0a3f62 100755
--- a/dlls/winevulkan/make_vulkan
+++ b/dlls/winevulkan/make_vulkan
@@ -68,7 +68,6 @@ WINE_VULKAN_DRIVER_H = "../../include/wine/vulkan_driver.h"
WINE_VULKAN_THUNKS_C = "vulkan_thunks.c"
WINE_VULKAN_THUNKS_H = "vulkan_thunks.h"
-
# Functions part of our winevulkan graphics driver interface.
# DRIVER_VERSION should be bumped on any change to driver interface
# in FUNCTION_OVERRIDES
@@ -95,6 +94,13 @@ FUNCTION_OVERRIDES = {
}
+class Direction(Enum):
+ """ Parameter direction: input, output, input_output. """
+ INPUT = 1
+ OUTPUT = 2
+ INPUT_OUTPUT = 3
+
+
class VkBaseType(object):
def __init__(self, name, _type, requires=None):
""" Vulkan base type class.
@@ -285,6 +291,21 @@ class VkFunction(object):
return VkFunction(_type=func_type, name=func_name, params=params)
+ def get_conversions(self):
+ """ Get a list of conversion functions required for this function if any.
+ Parameters which are structures may require conversion between win32
+ and the host platform. This function returns a list of conversions
+ required.
+ """
+
+ conversions = []
+ for param in self.params:
+ convs = param.get_conversions()
+ if convs is not None:
+ conversions.extend(convs)
+
+ return conversions
+
def is_device_func(self):
# If none of the other, it must be a device function
return not self.is_global_func() and not self.is_instance_func()
@@ -312,9 +333,32 @@ class VkFunction(object):
def is_required(self):
return self.required
+ def needs_conversion(self):
+ """ Check if the function needs any input/output type conversion.
+ Functions need input/output conversion if struct parameters have
+ alignment differences between Win32 and Linux 32-bit.
+ """
+
+ for p in self.params:
+ if p.needs_conversion():
+ LOGGER.debug("Parameter {0} to {1} requires conversion".format(p.name, self.name))
+ return True
+
+ return False
+
def needs_dispatch(self):
return self.dispatch
+ def needs_stub(self):
+ """ Temporary function to limit script hacks until more code is implemented. """
+ if self.name == "vkCreateDevice":
+ return True
+
+ if self.params[0].type != "VkPhysicalDevice":
+ return True
+
+ return False
+
def needs_thunk(self):
return self.thunk_needed
@@ -374,6 +418,77 @@ class VkFunction(object):
return proto
+ def body(self):
+ body = " {0}".format(self.trace())
+
+ params = ", ".join([p.variable(conv=False) for p in self.params])
+
+ # Call the native Vulkan function.
+ if self.type == "void":
+ body += " {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params)
+ else:
+ body += " return {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params)
+
+ return body
+
+ def body_conversion(self):
+ body = ""
+
+ # Declare a variable to hold the result for non-void functions.
+ if self.type != "void":
+ body += " {0} result;\n".format(self.type)
+
+ # Declare any tmp parameters for conversion.
+ for p in self.params:
+ if not p.needs_conversion():
+ continue
+
+ if p.is_dynamic_array():
+ body += " {0}_host *{1}_host;\n".format(p.type, p.name)
+ else:
+ body += " {0}_host {1}_host;\n".format(p.type, p.name)
+
+ body += " {0}\n".format(self.trace())
+
+ # Call any win_to_host conversion calls.
+ for p in self.params:
+ if not p.needs_input_conversion():
+ continue
+
+ body += p.copy(Direction.INPUT)
+
+ # 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=True) for p in self.params])
+
+ # Call the native Vulkan function.
+ if self.type == "void":
+ body += " {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params)
+ else:
+ body += " result = {0}.p_{1}({2});\n".format(self.params[0].dispatch_table(), self.name, params)
+
+ body += "\n"
+
+ # Call any host_to_win conversion calls.
+ for p in self.params:
+ if not p.needs_output_conversion():
+ continue
+
+ body += p.copy(Direction.OUTPUT)
+
+ # Perform any required cleanups. Most of these are for array functions.
+ for p in self.params:
+ if not p.needs_free():
+ continue
+
+ body += p.free()
+
+ # Finally return the result.
+ if self.type != "void":
+ body += " return result;\n"
+
+ return body
+
def stub(self, call_conv=None, prefix=None):
stub = self.prototype(call_conv=call_conv, prefix=prefix)
stub += "\n{\n"
@@ -387,6 +502,22 @@ class VkFunction(object):
stub += "}\n\n"
return stub
+ def thunk(self, call_conv=None, prefix=None):
+ thunk = self.prototype(call_conv=call_conv, prefix=prefix)
+ thunk += "\n{\n"
+
+ if self.needs_conversion():
+ thunk += "#if defined(USE_STRUCT_CONVERSION)\n"
+ thunk += self.body_conversion()
+ thunk += "#else\n"
+ thunk += self.body()
+ thunk += "#endif\n"
+ else:
+ thunk += self.body()
+
+ thunk += "}\n\n"
+ return thunk
+
def trace(self, message=None, trace_func=None):
""" Create a trace string including all parameters.
@@ -492,6 +623,23 @@ class VkHandle(object):
parent = handle.attrib.get("parent") # Most objects have a parent e.g. VkQueue has VkDevice.
return VkHandle(name, _type, parent)
+ def dispatch_table(self):
+ if not self.is_dispatchable():
+ return None
+
+ if self.parent is None:
+ # Should only happen for VkInstance
+ return "funcs"
+ elif self.name == "VkDevice":
+ # VkDevice has VkInstance as a parent, but has its own dispatch table.
+ return "funcs"
+ elif self.parent in ["VkInstance", "VkPhysicalDevice"]:
+ return "instance->funcs"
+ elif self.parent in ["VkDevice", "VkCommandPool"]:
+ return "device->funcs"
+ else:
+ LOGGER.error("Unhandled dispatchable parent: {0}".format(self.parent))
+
def definition(self):
""" Generates handle definition e.g. VK_DEFINE_HANDLE(vkInstance) """
return "{0}({1})\n".format(self.type, self.name)
@@ -502,6 +650,28 @@ class VkHandle(object):
"""
return self.type == "VK_DEFINE_HANDLE"
+ def native_handle(self):
+ """ Provide access to the native handle of a dispatchable object.
+
+ Dispatchable objects wrap an underlying 'native' object.
+ This method provides access to the native object.
+ """
+ if not self.is_dispatchable():
+ return None
+
+ if self.name == "VkCommandBuffer":
+ return "command_buffer"
+ elif self.name == "VkDevice":
+ return "device"
+ elif self.name == "VkInstance":
+ return "instance"
+ elif self.name == "VkPhysicalDevice":
+ return "phys_dev"
+ elif self.name == "VkQueue":
+ return "queue"
+ else:
+ LOGGER.error("Unhandled native handle for: {0}".format(self.name))
+
class VkMember(object):
def __init__(self, const=None, _type=None, pointer=None, name=None, array_len=None, dyn_array_len=None, optional=False,
@@ -582,6 +752,36 @@ class VkMember(object):
return VkMember(const=const, _type=member_type, pointer=pointer, name=name_elem.text, array_len=array_len,
dyn_array_len=dyn_array_len, optional=optional, extension_structs=extension_structs)
+ def copy(self, input, output, direction):
+ """ Helper method for use by conversion logic to generate a C-code statement to copy this member. """
+
+ if self.needs_conversion():
+ if self.is_dynamic_array():
+ if direction == Direction.OUTPUT:
+ LOGGER.warn("TODO: implement copying of returnedonly dynamic array for {0}.{1}".format(self.type, self.name))
+ else:
+ # Array length is either a variable name (string) or an int.
+ count = self.dyn_array_len if isinstance(self.dyn_array_len, int) else "{0}{1}".format(input, self.dyn_array_len)
+ return "{0}{1} = convert_{2}_array_win_to_host({3}{1}, {4});\n".format(output, self.name, self.type, input, count)
+ elif self.is_static_array():
+ count = self.array_len
+ if direction == Direction.OUTPUT:
+ # Needed by VkMemoryHeap.memoryHeaps
+ return "convert_{0}_static_array_host_to_win({2}{1}, {3}{1}, {4});\n".format(self.type, self.name, input, output, count)
+ else:
+ # Nothing needed this yet.
+ LOGGER.warn("TODO: implement copying of static array for {0}.{1}".format(self.type, self.name))
+ else:
+ if direction == Direction.OUTPUT:
+ return "convert_{0}_host_to_win(&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output)
+ else:
+ return "convert_{0}_win_to_host(&{2}{1}, &{3}{1});\n".format(self.type, self.name, input, output)
+ elif self.is_static_array():
+ bytes_count = "{0} * sizeof({1})".format(self.array_len, self.type)
+ return "memcpy({0}{1}, {2}{1}, {3});\n".format(output, self.name, input, bytes_count)
+ else:
+ return "{0}{1} = {2}{1};\n".format(output, self.name, input)
+
def definition(self, align=False, conv=False):
""" Generate prototype for given function.
@@ -612,6 +812,36 @@ class VkMember(object):
return text
+ def get_conversions(self):
+ """ Return any conversion description for this member and its children when conversion is needed. """
+
+ # Check if we need conversion either for this member itself or for any child members
+ # in case member represents a struct.
+ if not self.needs_conversion():
+ return None
+
+ conversions = []
+
+ # Collect any conversion for any member structs.
+ struct = self.type_info["data"]
+ for m in struct:
+ if m.needs_conversion():
+ conversions.extend(m.get_conversions())
+
+ struct = self.type_info["data"]
+ direction = Direction.OUTPUT if struct.returnedonly else Direction.INPUT
+ if self.is_dynamic_array():
+ conversions.append(ConversionFunction(False, True, direction, struct))
+ elif self.is_static_array():
+ conversions.append(ConversionFunction(True, False, direction, struct))
+ else:
+ conversions.append(ConversionFunction(False, False, direction, struct))
+
+ if self.needs_free():
+ conversions.append(FreeFunction(self.is_dynamic_array(), struct))
+
+ return conversions
+
def is_const(self):
return self.const is not None
@@ -663,6 +893,26 @@ class VkMember(object):
return False if handle.is_dispatchable() else True
return False
+ def needs_conversion(self):
+ """ Structures requiring alignment, need conversion between win32 and host. """
+
+ if not self.is_struct():
+ return False
+
+ struct = self.type_info["data"]
+ return struct.needs_conversion()
+
+ def needs_free(self):
+ if not self.needs_conversion():
+ return False
+
+ if self.is_dynamic_array():
+ return True
+
+ # TODO: some non-pointer structs and optional pointer structs may need freeing,
+ # though none of this type have been encountered yet.
+ return False
+
def set_type_info(self, type_info):
""" Helper function to set type information from the type registry.
This is needed, because not all type data is available at time of
@@ -685,7 +935,9 @@ class VkParam(object):
self.handle = type_info["data"] if type_info["category"] == "handle" else None
self.struct = type_info["data"] if type_info["category"] == "struct" else None
+ self._set_direction()
self._set_format_string()
+ self._set_conversions()
def __repr__(self):
return "{0} {1} {2} {3} {4}".format(self.const, self.type, self.pointer, self.name, self.array_len, self.dyn_array_len)
@@ -722,6 +974,59 @@ class VkParam(object):
return VkParam(type_info, const=const, pointer=pointer, name=name, array_len=array_len, dyn_array_len=dyn_array_len)
+ def _set_conversions(self):
+ """ Internal helper function to configure any needed conversion functions. """
+
+ self.free_func = None
+ self.input_conv = None
+ self.output_conv = None
+ if not self.needs_conversion():
+ return
+
+ # Input functions require win to host conversion.
+ if self._direction in [Direction.INPUT, Direction.INPUT_OUTPUT]:
+ self.input_conv = ConversionFunction(False, self.is_dynamic_array(), Direction.INPUT, self.struct)
+
+ # Output functions require host to win conversion.
+ if self._direction in [Direction.INPUT_OUTPUT, Direction.OUTPUT]:
+ self.output_conv = ConversionFunction(False, self.is_dynamic_array(), Direction.OUTPUT, self.struct)
+
+ # Dynamic arrays, but also some normal structs (e.g. VkCommandBufferBeginInfo) need memory
+ # allocation and thus some cleanup.
+ if self.is_dynamic_array() or self.struct.needs_free():
+ self.free_func = FreeFunction(self.is_dynamic_array(), self.struct)
+
+ def _set_direction(self):
+ """ Internal helper function to set parameter direction (input/output/input_output). """
+
+ # The parameter direction needs to be determined from hints in vk.xml like returnedonly,
+ # parameter constness and other heuristics.
+ # For now we need to get this right for structures as we need to convert these, we may have
+ # missed a few other edge cases (e.g. count variables).
+ # See also https://github.com/KhronosGroup/Vulkan-Docs/issues/610
+
+ if not self.is_pointer():
+ self._direction = Direction.INPUT
+ elif self.is_const() and self.is_pointer():
+ self._direction = Direction.INPUT
+ elif self.is_struct():
+ if not self.struct.returnedonly:
+ self._direction = Direction.INPUT
+ return
+
+ # Returnedonly hints towards output, however in some cases
+ # it is inputoutput. In particular if pNext / sType exist,
+ # which are used to link in other structures without having
+ # to introduce new APIs. E.g. vkGetPhysicalDeviceProperties2KHR.
+ if "pNext" in self.struct:
+ self._direction = Direction.INPUT_OUTPUT
+ return
+
+ self._direction = Direction.OUTPUT
+ else:
+ # This should mostly be right. Count variables can be inout, but we don't care about these yet.
+ self._direction = Direction.OUTPUT
+
def _set_format_string(self):
""" Internal helper function to be used by constructor to set format string. """
@@ -765,6 +1070,18 @@ class VkParam(object):
else:
LOGGER.warn("Unhandled type: {0}".format(self.type_info))
+ def copy(self, direction):
+ if direction == Direction.INPUT:
+ if self.is_dynamic_array():
+ return " {0}_host = convert_{1}_array_win_to_host({0}, {2});\n".format(self.name, self.type, self.dyn_array_len)
+ else:
+ return " convert_{0}_win_to_host({1}, &{1}_host);\n".format(self.type, self.name)
+ else:
+ if self.is_dynamic_array():
+ LOGGER.error("Unimplemented output conversion for: {0}".format(self.name))
+ else:
+ return " convert_{0}_host_to_win(&{1}_host, {1});\n".format(self.type, self.name)
+
def definition(self, postfix=None):
""" Return prototype for the parameter. E.g. 'const char *foo' """
@@ -800,6 +1117,68 @@ class VkParam(object):
def format_string(self):
return self.format_str
+ def dispatch_table(self):
+ """ Return functions dispatch table pointer for dispatchable objects. """
+
+ if not self.is_dispatchable():
+ return None
+
+ return "{0}->{1}".format(self.name, self.handle.dispatch_table())
+
+ def format_string(self):
+ return self.format_str
+
+ def free(self):
+ if self.is_dynamic_array():
+ if self.struct.returnedonly:
+ # For returnedonly, counts is stored in a pointer.
+ return " free_{0}_array({1}_host, *{2});\n".format(self.type, self.name, self.dyn_array_len)
+ else:
+ return " free_{0}_array({1}_host, {2});\n".format(self.type, self.name, self.dyn_array_len)
+ else:
+ # We are operating on a single structure. Some structs (very rare) contain dynamic members,
+ # which would need freeing.
+ if self.struct.needs_free():
+ return " free_{0}(&{1}_host);\n".format(self.type, self.name)
+ return ""
+
+ def get_conversions(self):
+ """ Get a list of conversions required for this parameter if any.
+ Parameters which are structures may require conversion between win32
+ and the host platform. This function returns a list of conversions
+ required.
+ """
+
+ if not self.is_struct():
+ return None
+
+ if not self.needs_conversion():
+ return None
+
+ conversions = []
+
+ # Collect any member conversions first, so we can guarantee
+ # those functions will be defined prior to usage by the
+ # 'parent' param requiring conversion.
+ for m in self.struct:
+ if not m.is_struct():
+ continue
+
+ if not m.needs_conversion():
+ continue
+
+ conversions.extend(m.get_conversions())
+
+ # Conversion requirements for the 'parent' parameter.
+ if self.input_conv is not None:
+ conversions.append(self.input_conv)
+ if self.output_conv is not None:
+ conversions.append(self.output_conv)
+ if self.free_func is not None:
+ conversions.append(self.free_func)
+
+ return conversions
+
def is_const(self):
return self.const is not None
@@ -824,6 +1203,62 @@ class VkParam(object):
def is_struct(self):
return self.struct is not None
+ def needs_conversion(self):
+ """ Returns if parameter needs conversion between win32 and host. """
+
+ if not self.is_struct():
+ return False
+
+ # VkSparseImageMemoryRequirements is used by vkGetImageSparseMemoryRequirements.
+ # This function is tricky to wrap, because how to wrap depends on whether
+ # pSparseMemoryRequirements is NULL or not. Luckily for VkSparseImageMemoryRequirements
+ # the alignment works out in such a way that no conversion is needed between win32 and Linux.
+ if self.type == "VkSparseImageMemoryRequirements":
+ return False
+
+ # If a structure needs alignment changes, it means we need to
+ # perform parameter conversion between win32 and host.
+ if self.struct.needs_conversion():
+ return True
+
+ return False
+
+ def needs_free(self):
+ return self.free_func is not None
+
+ def needs_input_conversion(self):
+ return self.input_conv is not None
+
+ def needs_output_conversion(self):
+ return self.output_conv is not None
+
+ def variable(self, conv=False):
+ """ 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.
+
+ Args:
+ conv (bool, optional): Enable conversion if the param needs it. This appends '_host' to the name.
+ """
+
+ # 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:
+ LOGGER.debug("TODO: setting NULL VkAllocationCallbacks for {0}".format(self.name))
+ return "NULL"
+
+ # Dispatchable objects wrap the native handle. For thunk generation we
+ # need to pass the native handle to the native vulkan calls.
+ if self.is_dispatchable():
+ return "{0}->{1}".format(self.name, self.handle.native_handle())
+ elif conv and self.needs_conversion():
+ if self.is_dynamic_array():
+ return "{0}_host".format(self.name)
+ else:
+ return "&{0}_host".format(self.name)
+ else:
+ return self.name
+
class VkStruct(Sequence):
""" Class which represents the type union and struct. """
@@ -953,6 +1388,31 @@ class VkStruct(Sequence):
return True
return False
+ def needs_conversion(self):
+ """ Returns if struct members needs conversion between win32 and host.
+ Structures need conversion if they contain members requiring alignment
+ or if they include other structures which need alignment.
+ """
+
+ if self.needs_alignment():
+ return True
+
+ for m in self.members:
+ if m.needs_conversion():
+ return True
+ return False
+
+ def needs_free(self):
+ """ Check if any struct member needs some memory freeing."""
+
+ for m in self.members:
+ if m.needs_free():
+ return True
+
+ continue
+
+ return False
+
def set_type_info(self, types):
""" Helper function to set type information from the type registry.
This is needed, because not all type data is available at time of
@@ -963,10 +1423,251 @@ class VkStruct(Sequence):
m.set_type_info(type_info)
+class ConversionFunction(object):
+ def __init__(self, array, dyn_array, direction, struct):
+ self.array = array
+ self.direction = direction
+ self.dyn_array = dyn_array
+ self.struct = struct
+ self.type = struct.name
+
+ self._set_name()
+
+ def __eq__(self, other):
+ if self.name != other.name:
+ return False
+
+ return True
+
+ def _generate_array_conversion_func(self):
+ """ Helper function for generating a conversion function for array structs. """
+
+ if self.direction == Direction.OUTPUT:
+ params = ["const {0}_host *in".format(self.type), "uint32_t count"]
+ return_type = self.type
+ else:
+ params = ["const {0} *in".format(self.type), "uint32_t count"]
+ return_type = "{0}_host".format(self.type)
+
+ # Generate function prototype.
+ body = "static inline {0} * {1}(".format(return_type, self.name)
+ body += ", ".join(p for p in params)
+ body += ")\n{\n"
+
+ body += " {0} *out;\n".format(return_type)
+ body += " unsigned int i;\n\n"
+ body += " if (!in) return NULL;\n\n"
+
+ body += " out = ({0} *)heap_alloc(count * sizeof(*out));\n".format(return_type)
+
+ body += " for (i = 0; i < count; i++)\n"
+ body += " {\n"
+
+ for m in self.struct:
+ # TODO: support copying of pNext extension structures!
+ # Luckily though no extension struct at this point needs conversion.
+ body += " " + m.copy("in[i].", "out[i].", self.direction)
+
+ body += " }\n\n"
+ body += " return out;\n"
+ body += "}\n\n"
+ return body
+
+ def _generate_conversion_func(self):
+ """ Helper function for generating a conversion function for non-array structs. """
+
+ if self.direction == Direction.OUTPUT:
+ params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type)]
+ else:
+ params = ["const {0} *in".format(self.type), "{0}_host *out".format(self.type)]
+
+ body = "static inline void {0}(".format(self.name)
+
+ # Generate parameter list
+ body += ", ".join(p for p in params)
+ body += ")\n{\n"
+
+ body += " if (!in) return;\n\n"
+
+ if self.direction == Direction.INPUT and "pNext" in self.struct and self.struct.returnedonly:
+ # We are dealing with an input_output parameter. For these we only need to copy
+ # pNext and sType as the other fields are filled in by the host. We do potentially
+ # have to iterate over pNext and perform conversions based on switch(sType)!
+ # Luckily though no extension structs at this point need conversion.
+ # TODO: support copying of pNext extension structures!
+ body += " out->pNext = in->pNext;\n"
+ body += " out->sType = in->sType;\n"
+ else:
+ for m in self.struct:
+ # TODO: support copying of pNext extension structures!
+ body += " " + m.copy("in->", "out->", self.direction)
+
+ body += "}\n\n"
+ return body
+
+ def _generate_static_array_conversion_func(self):
+ """ Helper function for generating a conversion function for array structs. """
+
+ if self.direction == Direction.OUTPUT:
+ params = ["const {0}_host *in".format(self.type), "{0} *out".format(self.type), "uint32_t count"]
+ return_type = self.type
+ else:
+ params = ["const {0} *in".format(self.type), "{0} *out_host".format(self.type), "uint32_t count"]
+ return_type = "{0}_host".format(self.type)
+
+ # Generate function prototype.
+ body = "static inline void {0}(".format(self.name)
+ body += ", ".join(p for p in params)
+ body += ")\n{\n"
+ body += " unsigned int i;\n\n"
+ body += " if (!in) return;\n\n"
+ body += " for (i = 0; i < count; i++)\n"
+ body += " {\n"
+
+ for m in self.struct:
+ # TODO: support copying of pNext extension structures!
+ body += " " + m.copy("in[i].", "out[i].", self.direction)
+
+ body += " }\n"
+ body += "}\n\n"
+ return body
+
+ def _set_name(self):
+ if self.direction == Direction.INPUT:
+ if self.array:
+ name = "convert_{0}_static_array_win_to_host".format(self.type)
+ elif self.dyn_array:
+ name = "convert_{0}_array_win_to_host".format(self.type)
+ else:
+ name = "convert_{0}_win_to_host".format(self.type)
+ else: # Direction.OUTPUT
+ if self.array:
+ name = "convert_{0}_static_array_host_to_win".format(self.type)
+ elif self.dyn_array:
+ name = "convert_{0}_array_host_to_win".format(self.type)
+ else:
+ name = "convert_{0}_host_to_win".format(self.type)
+
+ self.name = name
+
+ def definition(self):
+ if self.array:
+ return self._generate_static_array_conversion_func()
+ elif self.dyn_array:
+ return self._generate_array_conversion_func()
+ else:
+ return self._generate_conversion_func()
+
+
+class FreeFunction(object):
+ def __init__(self, dyn_array, struct):
+ self.dyn_array = dyn_array
+ self.struct = struct
+ self.type = struct.name
+
+ if dyn_array:
+ self.name = "free_{0}_array".format(self.type)
+ else:
+ self.name = "free_{0}".format(self.type)
+
+ def __eq__(self, other):
+ if self.name == other.name:
+ return True
+
+ return False
+
+ def _generate_array_free_func(self):
+ """ Helper function for cleaning up temporary buffers required for array conversions. """
+
+ # Generate function prototype.
+ body = "static inline void {0}({1}_host *in, uint32_t count)\n{{\n".format(self.name, self.type)
+
+ # E.g. VkGraphicsPipelineCreateInfo_host needs freeing for pStages.
+ if self.struct.needs_free():
+ body += " unsigned int i;\n\n"
+ body += " if (!in) return;\n\n"
+ body += " for (i = 0; i < count; i++)\n"
+ body += " {\n"
+
+ for m in self.struct:
+ if m.needs_conversion() and m.is_dynamic_array():
+ if m.is_const():
+ # Add a cast to ignore const on conversion structs we allocated ourselves.
+ body += " free_{0}_array(({0}_host *)in[i].{1}, in[i].{2});\n".format(m.type, m.name, m.dyn_array_len)
+ else:
+ body += " free_{0}_array(in[i].{1}, in[i].{2});\n".format(m.type, m.name, m.dyn_array_len)
+ elif m.needs_conversion():
+ LOGGER.error("Unhandled conversion for {0}".format(m.name))
+ body += " }\n"
+ else:
+ body += " if (!in) return;\n\n"
+
+ body += " heap_free(in);\n"
+
+ body += "}\n\n"
+ return body
+
+ def _generate_free_func(self):
+ # E.g. VkCommandBufferBeginInfo.pInheritanceInfo needs freeing.
+ if not self.struct.needs_free():
+ return ""
+
+ # Generate function prototype.
+ body = "static inline void {0}({1}_host *in)\n{{\n".format(self.name, self.type)
+
+ for m in self.struct:
+ if m.needs_conversion() and m.is_dynamic_array():
+ count = m.dyn_array_len if isinstance(m.dyn_array_len, int) else "in->{0}".format(m.dyn_array_len)
+ if m.is_const():
+ # Add a cast to ignore const on conversion structs we allocated ourselves.
+ body += " free_{0}_array(({0}_host *)in->{1}, {2});\n".format(m.type, m.name, count)
+ else:
+ body += " free_{0}_array(in->{1}, {2});\n".format(m.type, m.name, count)
+
+ body += "}\n\n"
+ return body
+
+ def definition(self):
+ if self.dyn_array:
+ return self._generate_array_free_func()
+ else:
+ # Some structures need freeing too if they contain dynamic arrays.
+ # E.g. VkCommandBufferBeginInfo
+ return self._generate_free_func()
+
+
class VkGenerator(object):
def __init__(self, registry):
self.registry = registry
+ # Build a list conversion functions for struct conversion.
+ self.conversions = []
+ self.host_structs = []
+ for func in self.registry.funcs.values():
+ if not func.is_required():
+ continue
+
+ # Temporary filter.
+ if func.needs_stub():
+ continue
+
+ if not func.needs_conversion():
+ continue
+
+ conversions = func.get_conversions()
+ for conv in conversions:
+ # Pull in any conversions for vulkan_thunks.c. Driver conversions we
+ # handle manually in vulkan.c if needed.
+ if not func.is_driver_func():
+ # Append if we don't already have this conversion.
+ if not any(c == conv for c in self.conversions):
+ self.conversions.append(conv)
+
+ # Structs can be used in different ways by different conversions
+ # e.g. array vs non-array. Just make sure we pull in each struct once.
+ if not any(s.name == conv.struct.name for s in self.host_structs):
+ self.host_structs.append(conv.struct)
+
def generate_thunks_c(self, f, prefix):
f.write("/* Automatically generated from Vulkan vk.xml; DO NOT EDIT! */\n\n")
@@ -974,12 +1675,19 @@ class VkGenerator(object):
f.write("#include \"wine/port.h\"\n\n")
f.write("#include \"wine/debug.h\"\n")
+ f.write("#include \"wine/heap.h\"\n")
f.write("#include \"wine/vulkan.h\"\n")
f.write("#include \"wine/vulkan_driver.h\"\n")
f.write("#include \"vulkan_private.h\"\n\n")
f.write("WINE_DEFAULT_DEBUG_CHANNEL(vulkan);\n\n")
+ # Generate any conversion helper functions.
+ f.write("#if defined(USE_STRUCT_CONVERSION)\n")
+ for conv in self.conversions:
+ f.write(conv.definition())
+ f.write("#endif /* USE_STRUCT_CONVERSION */\n\n")
+
# Create thunks for instance functions.
# Global functions don't go through the thunks.
for vk_func in self.registry.funcs.values():
@@ -997,7 +1705,11 @@ class VkGenerator(object):
if not vk_func.needs_thunk():
continue
- f.write("static " + vk_func.stub(prefix=prefix, call_conv="WINAPI"))
+ # Temporary filter.
+ if vk_func.needs_stub():
+ f.write("static " + vk_func.stub(prefix=prefix, call_conv="WINAPI"))
+ else:
+ f.write("static " + vk_func.thunk(prefix=prefix, call_conv="WINAPI"))
f.write("static const struct vulkan_func vk_instance_dispatch_table[] =\n{\n")
for vk_func in self.registry.instance_funcs:
@@ -1031,6 +1743,11 @@ class VkGenerator(object):
f.write("#ifndef __WINE_VULKAN_THUNKS_H\n")
f.write("#define __WINE_VULKAN_THUNKS_H\n\n")
+ f.write("/* Perform vulkan struct conversion on 32-bit x86 platforms. */\n")
+ f.write("#if (defined(__i386__))\n")
+ f.write(" #define USE_STRUCT_CONVERSION\n")
+ f.write("#endif\n\n")
+
f.write("/* For use by vk_icdGetInstanceProcAddr / vkGetInstanceProcAddr */\n")
f.write("void *wine_vk_get_instance_proc_addr(const char *name) DECLSPEC_HIDDEN;\n\n")
@@ -1043,6 +1760,10 @@ class VkGenerator(object):
f.write("{0};\n".format(vk_func.prototype("WINAPI", prefix="wine_", postfix="DECLSPEC_HIDDEN")))
f.write("\n")
+ for struct in self.host_structs:
+ f.write(struct.definition(align=False, conv=True, postfix="_host"))
+ f.write("\n")
+
f.write("/* For use by vkInstance and children */\n")
f.write("struct vulkan_instance_funcs\n{\n")
for vk_func in self.registry.instance_funcs:
@@ -1053,7 +1774,14 @@ class VkGenerator(object):
LOGGER.debug("skipping {0} in vulkan_instance_funcs".format(vk_func.name))
continue
- f.write(" {0};\n".format(vk_func.pfn(conv=False)))
+ if vk_func.needs_conversion():
+ f.write("#if defined(USE_STRUCT_CONVERSION)\n")
+ f.write(" {0};\n".format(vk_func.pfn(conv=True)))
+ f.write("#else\n")
+ f.write(" {0};\n".format(vk_func.pfn(conv=False)))
+ f.write("#endif\n")
+ else:
+ f.write(" {0};\n".format(vk_func.pfn(conv=False)))
f.write("};\n\n")
f.write("#define ALL_VK_INSTANCE_FUNCS() \\\n")
diff --git a/dlls/winevulkan/vulkan_thunks.c b/dlls/winevulkan/vulkan_thunks.c
index 2e1b62d23c..daab898522 100644
--- a/dlls/winevulkan/vulkan_thunks.c
+++ b/dlls/winevulkan/vulkan_thunks.c
@@ -4,12 +4,177 @@
#include "wine/port.h"
#include "wine/debug.h"
+#include "wine/heap.h"
#include "wine/vulkan.h"
#include "wine/vulkan_driver.h"
#include "vulkan_private.h"
WINE_DEFAULT_DEBUG_CHANNEL(vulkan);
+#if defined(USE_STRUCT_CONVERSION)
+static inline void convert_VkImageFormatProperties_host_to_win(const VkImageFormatProperties_host *in, VkImageFormatProperties *out)
+{
+ if (!in) return;
+
+ out->maxExtent = in->maxExtent;
+ out->maxMipLevels = in->maxMipLevels;
+ out->maxArrayLayers = in->maxArrayLayers;
+ out->sampleCounts = in->sampleCounts;
+ out->maxResourceSize = in->maxResourceSize;
+}
+
+static inline void convert_VkMemoryHeap_static_array_host_to_win(const VkMemoryHeap_host *in, VkMemoryHeap *out, uint32_t count)
+{
+ unsigned int i;
+
+ if (!in) return;
+
+ for (i = 0; i < count; i++)
+ {
+ out[i].size = in[i].size;
+ out[i].flags = in[i].flags;
+ }
+}
+
+static inline void convert_VkPhysicalDeviceMemoryProperties_host_to_win(const VkPhysicalDeviceMemoryProperties_host *in, VkPhysicalDeviceMemoryProperties *out)
+{
+ if (!in) return;
+
+ out->memoryTypeCount = in->memoryTypeCount;
+ memcpy(out->memoryTypes, in->memoryTypes, VK_MAX_MEMORY_TYPES * sizeof(VkMemoryType));
+ out->memoryHeapCount = in->memoryHeapCount;
+ convert_VkMemoryHeap_static_array_host_to_win(in->memoryHeaps, out->memoryHeaps, VK_MAX_MEMORY_HEAPS);
+}
+
+static inline void convert_VkPhysicalDeviceLimits_host_to_win(const VkPhysicalDeviceLimits_host *in, VkPhysicalDeviceLimits *out)
+{
+ if (!in) return;
+
+ out->maxImageDimension1D = in->maxImageDimension1D;
+ out->maxImageDimension2D = in->maxImageDimension2D;
+ out->maxImageDimension3D = in->maxImageDimension3D;
+ out->maxImageDimensionCube = in->maxImageDimensionCube;
+ out->maxImageArrayLayers = in->maxImageArrayLayers;
+ out->maxTexelBufferElements = in->maxTexelBufferElements;
+ out->maxUniformBufferRange = in->maxUniformBufferRange;
+ out->maxStorageBufferRange = in->maxStorageBufferRange;
+ out->maxPushConstantsSize = in->maxPushConstantsSize;
+ out->maxMemoryAllocationCount = in->maxMemoryAllocationCount;
+ out->maxSamplerAllocationCount = in->maxSamplerAllocationCount;
+ out->bufferImageGranularity = in->bufferImageGranularity;
+ out->sparseAddressSpaceSize = in->sparseAddressSpaceSize;
+ out->maxBoundDescriptorSets = in->maxBoundDescriptorSets;
+ out->maxPerStageDescriptorSamplers = in->maxPerStageDescriptorSamplers;
+ out->maxPerStageDescriptorUniformBuffers = in->maxPerStageDescriptorUniformBuffers;
+ out->maxPerStageDescriptorStorageBuffers = in->maxPerStageDescriptorStorageBuffers;
+ out->maxPerStageDescriptorSampledImages = in->maxPerStageDescriptorSampledImages;
+ out->maxPerStageDescriptorStorageImages = in->maxPerStageDescriptorStorageImages;
+ out->maxPerStageDescriptorInputAttachments = in->maxPerStageDescriptorInputAttachments;
+ out->maxPerStageResources = in->maxPerStageResources;
+ out->maxDescriptorSetSamplers = in->maxDescriptorSetSamplers;
+ out->maxDescriptorSetUniformBuffers = in->maxDescriptorSetUniformBuffers;
+ out->maxDescriptorSetUniformBuffersDynamic = in->maxDescriptorSetUniformBuffersDynamic;
+ out->maxDescriptorSetStorageBuffers = in->maxDescriptorSetStorageBuffers;
+ out->maxDescriptorSetStorageBuffersDynamic = in->maxDescriptorSetStorageBuffersDynamic;
+ out->maxDescriptorSetSampledImages = in->maxDescriptorSetSampledImages;
+ out->maxDescriptorSetStorageImages = in->maxDescriptorSetStorageImages;
+ out->maxDescriptorSetInputAttachments = in->maxDescriptorSetInputAttachments;
+ out->maxVertexInputAttributes = in->maxVertexInputAttributes;
+ out->maxVertexInputBindings = in->maxVertexInputBindings;
+ out->maxVertexInputAttributeOffset = in->maxVertexInputAttributeOffset;
+ out->maxVertexInputBindingStride = in->maxVertexInputBindingStride;
+ out->maxVertexOutputComponents = in->maxVertexOutputComponents;
+ out->maxTessellationGenerationLevel = in->maxTessellationGenerationLevel;
+ out->maxTessellationPatchSize = in->maxTessellationPatchSize;
+ out->maxTessellationControlPerVertexInputComponents = in->maxTessellationControlPerVertexInputComponents;
+ out->maxTessellationControlPerVertexOutputComponents = in->maxTessellationControlPerVertexOutputComponents;
+ out->maxTessellationControlPerPatchOutputComponents = in->maxTessellationControlPerPatchOutputComponents;
+ out->maxTessellationControlTotalOutputComponents = in->maxTessellationControlTotalOutputComponents;
+ out->maxTessellationEvaluationInputComponents = in->maxTessellationEvaluationInputComponents;
+ out->maxTessellationEvaluationOutputComponents = in->maxTessellationEvaluationOutputComponents;
+ out->maxGeometryShaderInvocations = in->maxGeometryShaderInvocations;
+ out->maxGeometryInputComponents = in->maxGeometryInputComponents;
+ out->maxGeometryOutputComponents = in->maxGeometryOutputComponents;
+ out->maxGeometryOutputVertices = in->maxGeometryOutputVertices;
+ out->maxGeometryTotalOutputComponents = in->maxGeometryTotalOutputComponents;
+ out->maxFragmentInputComponents = in->maxFragmentInputComponents;
+ out->maxFragmentOutputAttachments = in->maxFragmentOutputAttachments;
+ out->maxFragmentDualSrcAttachments = in->maxFragmentDualSrcAttachments;
+ out->maxFragmentCombinedOutputResources = in->maxFragmentCombinedOutputResources;
+ out->maxComputeSharedMemorySize = in->maxComputeSharedMemorySize;
+ memcpy(out->maxComputeWorkGroupCount, in->maxComputeWorkGroupCount, 3 * sizeof(uint32_t));
+ out->maxComputeWorkGroupInvocations = in->maxComputeWorkGroupInvocations;
+ memcpy(out->maxComputeWorkGroupSize, in->maxComputeWorkGroupSize, 3 * sizeof(uint32_t));
+ out->subPixelPrecisionBits = in->subPixelPrecisionBits;
+ out->subTexelPrecisionBits = in->subTexelPrecisionBits;
+ out->mipmapPrecisionBits = in->mipmapPrecisionBits;
+ out->maxDrawIndexedIndexValue = in->maxDrawIndexedIndexValue;
+ out->maxDrawIndirectCount = in->maxDrawIndirectCount;
+ out->maxSamplerLodBias = in->maxSamplerLodBias;
+ out->maxSamplerAnisotropy = in->maxSamplerAnisotropy;
+ out->maxViewports = in->maxViewports;
+ memcpy(out->maxViewportDimensions, in->maxViewportDimensions, 2 * sizeof(uint32_t));
+ memcpy(out->viewportBoundsRange, in->viewportBoundsRange, 2 * sizeof(float));
+ out->viewportSubPixelBits = in->viewportSubPixelBits;
+ out->minMemoryMapAlignment = in->minMemoryMapAlignment;
+ out->minTexelBufferOffsetAlignment = in->minTexelBufferOffsetAlignment;
+ out->minUniformBufferOffsetAlignment = in->minUniformBufferOffsetAlignment;
+ out->minStorageBufferOffsetAlignment = in->minStorageBufferOffsetAlignment;
+ out->minTexelOffset = in->minTexelOffset;
+ out->maxTexelOffset = in->maxTexelOffset;
+ out->minTexelGatherOffset = in->minTexelGatherOffset;
+ out->maxTexelGatherOffset = in->maxTexelGatherOffset;
+ out->minInterpolationOffset = in->minInterpolationOffset;
+ out->maxInterpolationOffset = in->maxInterpolationOffset;
+ out->subPixelInterpolationOffsetBits = in->subPixelInterpolationOffsetBits;
+ out->maxFramebufferWidth = in->maxFramebufferWidth;
+ out->maxFramebufferHeight = in->maxFramebufferHeight;
+ out->maxFramebufferLayers = in->maxFramebufferLayers;
+ out->framebufferColorSampleCounts = in->framebufferColorSampleCounts;
+ out->framebufferDepthSampleCounts = in->framebufferDepthSampleCounts;
+ out->framebufferStencilSampleCounts = in->framebufferStencilSampleCounts;
+ out->framebufferNoAttachmentsSampleCounts = in->framebufferNoAttachmentsSampleCounts;
+ out->maxColorAttachments = in->maxColorAttachments;
+ out->sampledImageColorSampleCounts = in->sampledImageColorSampleCounts;
+ out->sampledImageIntegerSampleCounts = in->sampledImageIntegerSampleCounts;
+ out->sampledImageDepthSampleCounts = in->sampledImageDepthSampleCounts;
+ out->sampledImageStencilSampleCounts = in->sampledImageStencilSampleCounts;
+ out->storageImageSampleCounts = in->storageImageSampleCounts;
+ out->maxSampleMaskWords = in->maxSampleMaskWords;
+ out->timestampComputeAndGraphics = in->timestampComputeAndGraphics;
+ out->timestampPeriod = in->timestampPeriod;
+ out->maxClipDistances = in->maxClipDistances;
+ out->maxCullDistances = in->maxCullDistances;
+ out->maxCombinedClipAndCullDistances = in->maxCombinedClipAndCullDistances;
+ out->discreteQueuePriorities = in->discreteQueuePriorities;
+ memcpy(out->pointSizeRange, in->pointSizeRange, 2 * sizeof(float));
+ memcpy(out->lineWidthRange, in->lineWidthRange, 2 * sizeof(float));
+ out->pointSizeGranularity = in->pointSizeGranularity;
+ out->lineWidthGranularity = in->lineWidthGranularity;
+ out->strictLines = in->strictLines;
+ out->standardSampleLocations = in->standardSampleLocations;
+ out->optimalBufferCopyOffsetAlignment = in->optimalBufferCopyOffsetAlignment;
+ out->optimalBufferCopyRowPitchAlignment = in->optimalBufferCopyRowPitchAlignment;
+ out->nonCoherentAtomSize = in->nonCoherentAtomSize;
+}
+
+static inline void convert_VkPhysicalDeviceProperties_host_to_win(const VkPhysicalDeviceProperties_host *in, VkPhysicalDeviceProperties *out)
+{
+ if (!in) return;
+
+ out->apiVersion = in->apiVersion;
+ out->driverVersion = in->driverVersion;
+ out->vendorID = in->vendorID;
+ out->deviceID = in->deviceID;
+ out->deviceType = in->deviceType;
+ memcpy(out->deviceName, in->deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE * sizeof(char));
+ memcpy(out->pipelineCacheUUID, in->pipelineCacheUUID, VK_UUID_SIZE * sizeof(uint8_t));
+ convert_VkPhysicalDeviceLimits_host_to_win(&in->limits, &out->limits);
+ out->sparseProperties = in->sparseProperties;
+}
+
+#endif /* USE_STRUCT_CONVERSION */
+
static VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo *pCreateInfo, const VkAllocationCallbacks *pAllocator, VkDevice *pDevice)
{
FIXME("stub: %p, %p, %p, %p\n", physicalDevice, pCreateInfo, pAllocator, pDevice);
@@ -18,44 +183,79 @@ static VkResult WINAPI wine_vkCreateDevice(VkPhysicalDevice physicalDevice, cons
static VkResult WINAPI wine_vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t *pPropertyCount, VkLayerProperties *pProperties)
{
- FIXME("stub: %p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
- return VK_ERROR_OUT_OF_HOST_MEMORY;
+ TRACE("%p, %p, %p\n", physicalDevice, pPropertyCount, pProperties);
+ return physicalDevice->instance->funcs.p_vkEnumerateDeviceLayerProperties(physicalDevice->phys_dev, pPropertyCount, pProperties);
}
static void WINAPI wine_vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures *pFeatures)
{
- FIXME("stub: %p, %p\n", physicalDevice, pFeatures);
+ TRACE("%p, %p\n", physicalDevice, pFeatures);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFeatures(physicalDevice->phys_dev, pFeatures);
}
static void WINAPI wine_vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties *pFormatProperties)
{
- FIXME("stub: %p, %d, %p\n", physicalDevice, format, pFormatProperties);
+ TRACE("%p, %d, %p\n", physicalDevice, format, pFormatProperties);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceFormatProperties(physicalDevice->phys_dev, format, pFormatProperties);
}
static VkResult WINAPI wine_vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties *pImageFormatProperties)
{
- FIXME("stub: %p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
- return VK_ERROR_OUT_OF_HOST_MEMORY;
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult result;
+ VkImageFormatProperties_host pImageFormatProperties_host;
+ TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+
+ result = physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, &pImageFormatProperties_host);
+
+ convert_VkImageFormatProperties_host_to_win(&pImageFormatProperties_host, pImageFormatProperties);
+ return result;
+#else
+ TRACE("%p, %d, %d, %d, %#x, %#x, %p\n", physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
+ return physicalDevice->instance->funcs.p_vkGetPhysicalDeviceImageFormatProperties(physicalDevice->phys_dev, format, type, tiling, usage, flags, pImageFormatProperties);
+#endif
}
static void WINAPI wine_vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties *pMemoryProperties)
{
- FIXME("stub: %p, %p\n", physicalDevice, pMemoryProperties);
+#if defined(USE_STRUCT_CONVERSION)
+ VkPhysicalDeviceMemoryProperties_host pMemoryProperties_host;
+ TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
+
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, &pMemoryProperties_host);
+
+ convert_VkPhysicalDeviceMemoryProperties_host_to_win(&pMemoryProperties_host, pMemoryProperties);
+#else
+ TRACE("%p, %p\n", physicalDevice, pMemoryProperties);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceMemoryProperties(physicalDevice->phys_dev, pMemoryProperties);
+#endif
}
static void WINAPI wine_vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties *pProperties)
{
- FIXME("stub: %p, %p\n", physicalDevice, pProperties);
+#if defined(USE_STRUCT_CONVERSION)
+ VkPhysicalDeviceProperties_host pProperties_host;
+ TRACE("%p, %p\n", physicalDevice, pProperties);
+
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, &pProperties_host);
+
+ convert_VkPhysicalDeviceProperties_host_to_win(&pProperties_host, pProperties);
+#else
+ TRACE("%p, %p\n", physicalDevice, pProperties);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceProperties(physicalDevice->phys_dev, pProperties);
+#endif
}
static void WINAPI wine_vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties *pQueueFamilyProperties)
{
- FIXME("stub: %p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+ TRACE("%p, %p, %p\n", physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice->phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties);
}
static void WINAPI wine_vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t *pPropertyCount, VkSparseImageFormatProperties *pProperties)
{
- FIXME("stub: %p, %d, %d, %d, %#x, %d, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+ TRACE("%p, %d, %d, %d, %#x, %d, %p, %p\n", physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
+ physicalDevice->instance->funcs.p_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice->phys_dev, format, type, samples, usage, tiling, pPropertyCount, pProperties);
}
static const struct vulkan_func vk_instance_dispatch_table[] =
diff --git a/dlls/winevulkan/vulkan_thunks.h b/dlls/winevulkan/vulkan_thunks.h
index b8d2bbdb0f..4ae102b83b 100644
--- a/dlls/winevulkan/vulkan_thunks.h
+++ b/dlls/winevulkan/vulkan_thunks.h
@@ -3,6 +3,11 @@
#ifndef __WINE_VULKAN_THUNKS_H
#define __WINE_VULKAN_THUNKS_H
+/* Perform vulkan struct conversion on 32-bit x86 platforms. */
+#if (defined(__i386__))
+ #define USE_STRUCT_CONVERSION
+#endif
+
/* For use by vk_icdGetInstanceProcAddr / vkGetInstanceProcAddr */
void *wine_vk_get_instance_proc_addr(const char *name) DECLSPEC_HIDDEN;
@@ -11,6 +16,153 @@ void WINAPI wine_vkDestroyInstance(VkInstance instance, const VkAllocationCallba
VkResult WINAPI wine_vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char *pLayerName, uint32_t *pPropertyCount, VkExtensionProperties *pProperties) DECLSPEC_HIDDEN;
VkResult WINAPI wine_vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, VkPhysicalDevice *pPhysicalDevices) DECLSPEC_HIDDEN;
+typedef struct VkImageFormatProperties_host
+{
+ VkExtent3D maxExtent;
+ uint32_t maxMipLevels;
+ uint32_t maxArrayLayers;
+ VkSampleCountFlags sampleCounts;
+ VkDeviceSize maxResourceSize;
+} VkImageFormatProperties_host;
+
+typedef struct VkMemoryHeap_host
+{
+ VkDeviceSize size;
+ VkMemoryHeapFlags flags;
+} VkMemoryHeap_host;
+
+typedef struct VkPhysicalDeviceMemoryProperties_host
+{
+ uint32_t memoryTypeCount;
+ VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
+ uint32_t memoryHeapCount;
+ VkMemoryHeap_host memoryHeaps[VK_MAX_MEMORY_HEAPS];
+} VkPhysicalDeviceMemoryProperties_host;
+
+typedef struct VkPhysicalDeviceLimits_host
+{
+ uint32_t maxImageDimension1D;
+ uint32_t maxImageDimension2D;
+ uint32_t maxImageDimension3D;
+ uint32_t maxImageDimensionCube;
+ uint32_t maxImageArrayLayers;
+ uint32_t maxTexelBufferElements;
+ uint32_t maxUniformBufferRange;
+ uint32_t maxStorageBufferRange;
+ uint32_t maxPushConstantsSize;
+ uint32_t maxMemoryAllocationCount;
+ uint32_t maxSamplerAllocationCount;
+ VkDeviceSize bufferImageGranularity;
+ VkDeviceSize sparseAddressSpaceSize;
+ uint32_t maxBoundDescriptorSets;
+ uint32_t maxPerStageDescriptorSamplers;
+ uint32_t maxPerStageDescriptorUniformBuffers;
+ uint32_t maxPerStageDescriptorStorageBuffers;
+ uint32_t maxPerStageDescriptorSampledImages;
+ uint32_t maxPerStageDescriptorStorageImages;
+ uint32_t maxPerStageDescriptorInputAttachments;
+ uint32_t maxPerStageResources;
+ uint32_t maxDescriptorSetSamplers;
+ uint32_t maxDescriptorSetUniformBuffers;
+ uint32_t maxDescriptorSetUniformBuffersDynamic;
+ uint32_t maxDescriptorSetStorageBuffers;
+ uint32_t maxDescriptorSetStorageBuffersDynamic;
+ uint32_t maxDescriptorSetSampledImages;
+ uint32_t maxDescriptorSetStorageImages;
+ uint32_t maxDescriptorSetInputAttachments;
+ uint32_t maxVertexInputAttributes;
+ uint32_t maxVertexInputBindings;
+ uint32_t maxVertexInputAttributeOffset;
+ uint32_t maxVertexInputBindingStride;
+ uint32_t maxVertexOutputComponents;
+ uint32_t maxTessellationGenerationLevel;
+ uint32_t maxTessellationPatchSize;
+ uint32_t maxTessellationControlPerVertexInputComponents;
+ uint32_t maxTessellationControlPerVertexOutputComponents;
+ uint32_t maxTessellationControlPerPatchOutputComponents;
+ uint32_t maxTessellationControlTotalOutputComponents;
+ uint32_t maxTessellationEvaluationInputComponents;
+ uint32_t maxTessellationEvaluationOutputComponents;
+ uint32_t maxGeometryShaderInvocations;
+ uint32_t maxGeometryInputComponents;
+ uint32_t maxGeometryOutputComponents;
+ uint32_t maxGeometryOutputVertices;
+ uint32_t maxGeometryTotalOutputComponents;
+ uint32_t maxFragmentInputComponents;
+ uint32_t maxFragmentOutputAttachments;
+ uint32_t maxFragmentDualSrcAttachments;
+ uint32_t maxFragmentCombinedOutputResources;
+ uint32_t maxComputeSharedMemorySize;
+ uint32_t maxComputeWorkGroupCount[3];
+ uint32_t maxComputeWorkGroupInvocations;
+ uint32_t maxComputeWorkGroupSize[3];
+ uint32_t subPixelPrecisionBits;
+ uint32_t subTexelPrecisionBits;
+ uint32_t mipmapPrecisionBits;
+ uint32_t maxDrawIndexedIndexValue;
+ uint32_t maxDrawIndirectCount;
+ float maxSamplerLodBias;
+ float maxSamplerAnisotropy;
+ uint32_t maxViewports;
+ uint32_t maxViewportDimensions[2];
+ float viewportBoundsRange[2];
+ uint32_t viewportSubPixelBits;
+ size_t minMemoryMapAlignment;
+ VkDeviceSize minTexelBufferOffsetAlignment;
+ VkDeviceSize minUniformBufferOffsetAlignment;
+ VkDeviceSize minStorageBufferOffsetAlignment;
+ int32_t minTexelOffset;
+ uint32_t maxTexelOffset;
+ int32_t minTexelGatherOffset;
+ uint32_t maxTexelGatherOffset;
+ float minInterpolationOffset;
+ float maxInterpolationOffset;
+ uint32_t subPixelInterpolationOffsetBits;
+ uint32_t maxFramebufferWidth;
+ uint32_t maxFramebufferHeight;
+ uint32_t maxFramebufferLayers;
+ VkSampleCountFlags framebufferColorSampleCounts;
+ VkSampleCountFlags framebufferDepthSampleCounts;
+ VkSampleCountFlags framebufferStencilSampleCounts;
+ VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
+ uint32_t maxColorAttachments;
+ VkSampleCountFlags sampledImageColorSampleCounts;
+ VkSampleCountFlags sampledImageIntegerSampleCounts;
+ VkSampleCountFlags sampledImageDepthSampleCounts;
+ VkSampleCountFlags sampledImageStencilSampleCounts;
+ VkSampleCountFlags storageImageSampleCounts;
+ uint32_t maxSampleMaskWords;
+ VkBool32 timestampComputeAndGraphics;
+ float timestampPeriod;
+ uint32_t maxClipDistances;
+ uint32_t maxCullDistances;
+ uint32_t maxCombinedClipAndCullDistances;
+ uint32_t discreteQueuePriorities;
+ float pointSizeRange[2];
+ float lineWidthRange[2];
+ float pointSizeGranularity;
+ float lineWidthGranularity;
+ VkBool32 strictLines;
+ VkBool32 standardSampleLocations;
+ VkDeviceSize optimalBufferCopyOffsetAlignment;
+ VkDeviceSize optimalBufferCopyRowPitchAlignment;
+ VkDeviceSize nonCoherentAtomSize;
+} VkPhysicalDeviceLimits_host;
+
+typedef struct VkPhysicalDeviceProperties_host
+{
+ uint32_t apiVersion;
+ uint32_t driverVersion;
+ uint32_t vendorID;
+ uint32_t deviceID;
+ VkPhysicalDeviceType deviceType;
+ char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
+ uint8_t pipelineCacheUUID[VK_UUID_SIZE];
+ VkPhysicalDeviceLimits_host limits;
+ VkPhysicalDeviceSparseProperties sparseProperties;
+} VkPhysicalDeviceProperties_host;
+
+
/* For use by vkInstance and children */
struct vulkan_instance_funcs
{
@@ -20,9 +172,21 @@ struct vulkan_instance_funcs
VkResult (*p_vkEnumeratePhysicalDevices)(VkInstance, uint32_t *, VkPhysicalDevice *);
void (*p_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice, VkPhysicalDeviceFeatures *);
void (*p_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice, VkFormat, VkFormatProperties *);
+#if defined(USE_STRUCT_CONVERSION)
+ VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties_host *);
+#else
VkResult (*p_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkImageTiling, VkImageUsageFlags, VkImageCreateFlags, VkImageFormatProperties *);
+#endif
+#if defined(USE_STRUCT_CONVERSION)
+ void (*p_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties_host *);
+#else
void (*p_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice, VkPhysicalDeviceMemoryProperties *);
+#endif
+#if defined(USE_STRUCT_CONVERSION)
+ void (*p_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties_host *);
+#else
void (*p_vkGetPhysicalDeviceProperties)(VkPhysicalDevice, VkPhysicalDeviceProperties *);
+#endif
void (*p_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice, uint32_t *, VkQueueFamilyProperties *);
void (*p_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice, VkFormat, VkImageType, VkSampleCountFlagBits, VkImageUsageFlags, VkImageTiling, uint32_t *, VkSparseImageFormatProperties *);
};
--
2.14.3
More information about the wine-devel
mailing list