From b2c22307c5e14978c007b33869e51eaa127547cc Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Tue, 8 Oct 2019 10:02:17 -0600 Subject: vulkaninfo: Present Surfaces now wont show duplicates If a machine has multiple surface types that work with the same gpu and have the same properties, vulkainfo will now list them in a short array instead of duplicating the entire surfaces information. To do this required being able to compare vulkan objects, necesitating the autogeneration of comparators for vulkan structs. This patch also refactors some of the device creation code to better reflect the actual data dependencies of the various vulkan objects. files modified - vulkaninfo/vulkaninfo.cpp - vulkaninfo/vulkaninfo.h - scripts/vulkaninfo_generator.py - vulkaninfo/generated/vulkaninfo.hpp Change-Id: Ifda51eacc3883982a6e2f7f60439827eb355c204 --- scripts/vulkaninfo_generator.py | 67 ++++++++- vulkaninfo/generated/vulkaninfo.hpp | 45 ++++++ vulkaninfo/vulkaninfo.cpp | 82 +++++++---- vulkaninfo/vulkaninfo.h | 272 ++++++++++++++++++------------------ 4 files changed, 298 insertions(+), 168 deletions(-) diff --git a/scripts/vulkaninfo_generator.py b/scripts/vulkaninfo_generator.py index 318ecd51..3846e345 100644 --- a/scripts/vulkaninfo_generator.py +++ b/scripts/vulkaninfo_generator.py @@ -92,6 +92,9 @@ flags_to_gen = ['VkSurfaceTransformFlagsKHR', 'VkCompositeAlphaFlagsKHR', 'VkDeviceGroupPresentModeFlagsKHR', 'VkFormatFeatureFlags', 'VkMemoryPropertyFlags', 'VkMemoryHeapFlags'] flags_strings_to_gen = ['VkQueueFlags'] +struct_comparisons_to_gen = ['VkSurfaceFormatKHR', 'VkSurfaceFormat2KHR', 'VkSurfaceCapabilitiesKHR', + 'VkSurfaceCapabilities2KHR', 'VkSurfaceCapabilities2EXT'] + # iostream or custom outputter handles these types predefined_types = ['char', 'VkBool32', 'uint32_t', 'uint8_t', 'int32_t', 'float', 'uint64_t', 'size_t', 'VkDeviceSize', 'VkConformanceVersionKHR'] @@ -177,6 +180,7 @@ class VulkanInfoGenerator(OutputGenerator): self.flags = set() self.bitmasks = set() self.structures = set() + self.structs_to_comp = set() self.all_structures = set() self.types_to_gen = set() @@ -216,6 +220,12 @@ class VulkanInfoGenerator(OutputGenerator): types_to_gen = types_to_gen.union( GatherTypesToGen(self.extension_sets[key])) + structs_to_comp = set() + for s in struct_comparisons_to_gen: + structs_to_comp.add(s) + structs_to_comp = structs_to_comp.union( + GatherTypesToGen(self.structs_to_comp)) + self.enums = sorted(self.enums, key=operator.attrgetter('name')) self.flags = sorted(self.flags, key=operator.attrgetter('name')) self.bitmasks = sorted(self.bitmasks, key=operator.attrgetter('name')) @@ -275,6 +285,14 @@ class VulkanInfoGenerator(OutputGenerator): out += PrintChainIterator(key, self.extension_sets[key], value.get('type')) + for s in self.all_structures: + if s.name in structs_to_comp: + out += PrintStructComparisonForwardDef(s) + + for s in self.all_structures: + if s.name in structs_to_comp: + out += PrintStructComparison(s) + gen.write(out, file=self.outFile) gen.OutputGenerator.endFile(self) @@ -311,6 +329,10 @@ class VulkanInfoGenerator(OutputGenerator): self.structures.add(VulkanStructure( name, typeinfo.elem, self.constants, self.extTypes)) + if typeinfo.elem.get('category') == 'struct' and name in struct_comparisons_to_gen: + self.structs_to_comp.add(VulkanStructure( + name, typeinfo.elem, self.constants, self.extTypes)) + if typeinfo.elem.get('category') == 'struct': self.all_structures.add(VulkanStructure( name, typeinfo.elem, self.constants, self.extTypes)) @@ -328,13 +350,19 @@ class VulkanInfoGenerator(OutputGenerator): def GatherTypesToGen(structures): - types_to_gen = set() - for s in structures: - types_to_gen.add(s.name) - for m in s.members: - if m.typeID not in predefined_types and m.name not in ['sType', 'pNext']: - types_to_gen.add(m.typeID) - return types_to_gen + types = set() + added_stuff = True # repeat until no new types are added + while added_stuff == True: + added_stuff = False + for s in structures: + size = len(types) + types.add(s.name) + if len(types) != size: + added_stuff = True + for m in s.members: + if m.typeID not in predefined_types and m.name not in ['sType', 'pNext']: + types.add(m.typeID) + return types def GetExtension(name, generator): @@ -608,6 +636,31 @@ def PrintChainIterator(listName, structures, checkExtLoc): return out +def PrintStructComparisonForwardDef(structure): + out = '' + out += "bool operator==(const " + structure.name + \ + " & a, const " + structure.name + " b);\n" + return out + + +def PrintStructComparison(structure): + out = '' + out += "bool operator==(const " + structure.name + \ + " & a, const " + structure.name + " b) {\n" + out += " return " + is_first = True + for m in structure.members: + if m.name not in ['sType', 'pNext']: + if not is_first: + out += "\n && " + else: + is_first = False + out += "a." + m.name + " == b." + m.name + out += ";\n" + out += "}\n" + return out + + def isPow2(num): return num != 0 and ((num & (num - 1)) == 0) diff --git a/vulkaninfo/generated/vulkaninfo.hpp b/vulkaninfo/generated/vulkaninfo.hpp index 261a05dd..12060fb3 100644 --- a/vulkaninfo/generated/vulkaninfo.hpp +++ b/vulkaninfo/generated/vulkaninfo.hpp @@ -2120,4 +2120,49 @@ void chain_iterator_format_properties2(Printer &p, AppGpu &gpu, void * place) { place = structure->pNext; } } +bool operator==(const VkExtent2D & a, const VkExtent2D b); +bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b); +bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b); +bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b); +bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b); +bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b); +bool operator==(const VkExtent2D & a, const VkExtent2D b) { + return a.width == b.width + && a.height == b.height; +} +bool operator==(const VkSurfaceCapabilities2EXT & a, const VkSurfaceCapabilities2EXT b) { + return a.minImageCount == b.minImageCount + && a.maxImageCount == b.maxImageCount + && a.currentExtent == b.currentExtent + && a.minImageExtent == b.minImageExtent + && a.maxImageExtent == b.maxImageExtent + && a.maxImageArrayLayers == b.maxImageArrayLayers + && a.supportedTransforms == b.supportedTransforms + && a.currentTransform == b.currentTransform + && a.supportedCompositeAlpha == b.supportedCompositeAlpha + && a.supportedUsageFlags == b.supportedUsageFlags + && a.supportedSurfaceCounters == b.supportedSurfaceCounters; +} +bool operator==(const VkSurfaceCapabilities2KHR & a, const VkSurfaceCapabilities2KHR b) { + return a.surfaceCapabilities == b.surfaceCapabilities; +} +bool operator==(const VkSurfaceCapabilitiesKHR & a, const VkSurfaceCapabilitiesKHR b) { + return a.minImageCount == b.minImageCount + && a.maxImageCount == b.maxImageCount + && a.currentExtent == b.currentExtent + && a.minImageExtent == b.minImageExtent + && a.maxImageExtent == b.maxImageExtent + && a.maxImageArrayLayers == b.maxImageArrayLayers + && a.supportedTransforms == b.supportedTransforms + && a.currentTransform == b.currentTransform + && a.supportedCompositeAlpha == b.supportedCompositeAlpha + && a.supportedUsageFlags == b.supportedUsageFlags; +} +bool operator==(const VkSurfaceFormat2KHR & a, const VkSurfaceFormat2KHR b) { + return a.surfaceFormat == b.surfaceFormat; +} +bool operator==(const VkSurfaceFormatKHR & a, const VkSurfaceFormatKHR b) { + return a.format == b.format + && a.colorSpace == b.colorSpace; +} diff --git a/vulkaninfo/vulkaninfo.cpp b/vulkaninfo/vulkaninfo.cpp index fbfda81a..75a653d8 100644 --- a/vulkaninfo/vulkaninfo.cpp +++ b/vulkaninfo/vulkaninfo.cpp @@ -53,7 +53,7 @@ void DumpExtensions(Printer &p, std::string layer_name, std::vector layers, std::vector gpus) { +void DumpLayers(Printer &p, std::vector layers, const std::vector> &gpus) { std::sort(layers.begin(), layers.end(), [](LayerExtensionList &left, LayerExtensionList &right) -> int { const char *a = left.layer_properties.layerName; const char *b = right.layer_properties.layerName; @@ -146,7 +146,7 @@ void DumpSurfaceCapabilities(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurf chain_iterator_surface_capabilities2(p, inst, gpu, surface.surface_capabilities2_khr.pNext); } -void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface) { +void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface, std::vector surface_types) { std::string header; if (p.Type() == OutputType::text) header = std::string("GPU id : ") + std::to_string(gpu.id) + " (" + gpu.props.deviceName + ")"; @@ -154,7 +154,15 @@ void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface header = std::string("GPU id : ") + std::to_string(gpu.id) + " (" + gpu.props.deviceName + ")"; p.ObjectStart(header); - p.SetAsType().PrintKeyValue("Surface type", surface.surface_extension.name); + if (surface_types.size() == 0) { + p.SetAsType().PrintKeyValue("Surface type", surface.surface_extension.name); + } else { + p.ArrayStart("Surface types", surface_types.size()); + for (auto &name : surface_types) { + p.PrintElement(name); + } + p.ArrayEnd(); + } DumpSurfaceFormats(p, inst, surface); @@ -166,14 +174,43 @@ void DumpSurface(Printer &p, AppInstance &inst, AppGpu &gpu, AppSurface &surface p.AddNewline(); } -void DumpPresentableSurfaces(Printer &p, AppInstance &inst, std::vector &gpus, std::vector &surfaces) { +struct SurfaceTypeGroup { + AppSurface *surface; + std::vector surface_types; + AppGpu *gpu; +}; + +bool operator==(AppSurface const &a, AppSurface const &b) { + return a.surf_present_modes == b.surf_present_modes && a.surf_formats == b.surf_formats && a.surf_formats2 == b.surf_formats2 && + a.surface_capabilities == b.surface_capabilities && a.surface_capabilities2_khr == b.surface_capabilities2_khr && + a.surface_capabilities2_ext == b.surface_capabilities2_ext; +} + +void DumpPresentableSurfaces(Printer &p, AppInstance &inst, const std::vector> &gpus, + const std::vector> &surfaces) { p.SetHeader().ObjectStart("Presentable Surfaces"); p.IndentDecrease(); + std::vector surface_list; + for (auto &surface : surfaces) { for (auto &gpu : gpus) { - DumpSurface(p, inst, *gpu, *surface); + auto exists = surface_list.end(); + for (auto it = surface_list.begin(); it != surface_list.end(); it++) { + // use custom comparator to check if the surface has the same values + if (it->gpu == gpu.get() && *it->surface == *surface.get()) { + exists = it; + } + } + if (exists != surface_list.end()) { + exists->surface_types.push_back(surface.get()->surface_extension.name); + } else { + surface_list.push_back({surface.get(), {surface.get()->surface_extension.name}, gpu.get()}); + } } } + for (auto &group : surface_list) { + DumpSurface(p, inst, *group.gpu, *group.surface, group.surface_types); + } p.IndentIncrease(); p.ObjectEnd(); p.AddNewline(); @@ -671,34 +708,31 @@ int main(int argc, char **argv) { auto pNext_chains = get_chain_infos(); - auto gpu_holder = FindGpus(instance, pNext_chains); + auto phys_devices = instance.FindPhysicalDevices(); - std::vector gpus; - for (auto &gpu : gpu_holder) { - gpus.push_back(gpu.get()); - } - - if (selected_gpu >= gpus.size()) { - selected_gpu = 0; - } - - std::vector> surfaces_holder; + std::vector> surfaces; #if defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_WIN32_KHR) || \ defined(VK_USE_PLATFORM_MACOS_MVK) || defined(VK_USE_PLATFORM_WAYLAND_KHR) for (auto &surface_extension : instance.surface_extensions) { surface_extension.create_window(instance); surface_extension.surface = surface_extension.create_surface(instance); - for (auto &gpu : gpus) { - surfaces_holder.push_back( - std::unique_ptr(new AppSurface(instance, gpu, surface_extension, pNext_chains.surface_capabilities2))); + for (auto &phys_device : phys_devices) { + surfaces.push_back(std::unique_ptr( + new AppSurface(instance, phys_device, surface_extension, pNext_chains.surface_capabilities2))); } } +#endif - std::vector surfaces; - for (auto &surface : surfaces_holder) { - surfaces.push_back(surface.get()); + std::vector> gpus; + + uint32_t gpu_counter = 0; + for (auto &phys_device : phys_devices) { + gpus.push_back(std::unique_ptr(new AppGpu(instance, gpu_counter++, phys_device, pNext_chains))); + } + + if (selected_gpu >= gpus.size()) { + selected_gpu = 0; } -#endif std::vector> printers; @@ -738,7 +772,7 @@ int main(int argc, char **argv) { for (auto &gpu : gpus) { if ((p->Type() == OutputType::json && gpu->id == selected_gpu) || p->Type() == OutputType::text || p->Type() == OutputType::html) { - DumpGpu(*p.get(), *gpu, show_formats, pNext_chains); + DumpGpu(*p.get(), *gpu.get(), show_formats, pNext_chains); } } if (p->Type() != OutputType::json) { diff --git a/vulkaninfo/vulkaninfo.h b/vulkaninfo/vulkaninfo.h index ea8ddd54..3a10370a 100644 --- a/vulkaninfo/vulkaninfo.h +++ b/vulkaninfo/vulkaninfo.h @@ -146,6 +146,33 @@ struct pNextChainBuildingBlockInfo { uint32_t mem_size; }; +void buildpNextChain(VkStructureHeader *first, const std::vector &chain_info) { + VkStructureHeader *place = first; + + for (uint32_t i = 0; i < chain_info.size(); i++) { + place->pNext = static_cast(malloc(chain_info[i].mem_size)); + if (!place->pNext) { + ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY); + } + std::memset(place->pNext, 0, chain_info[i].mem_size); + place = place->pNext; + place->sType = chain_info[i].sType; + } + + place->pNext = nullptr; +} + +void freepNextChain(VkStructureHeader *first) { + VkStructureHeader *place = first; + VkStructureHeader *next = nullptr; + + while (place) { + next = place->pNext; + free(place); + place = next; + } +} + struct LayerExtensionList { VkLayerProperties layer_properties; std::vector extension_properties; @@ -353,6 +380,26 @@ struct AppInstance { if (err) ERR_EXIT(err); return ext_props; } + + std::vector FindPhysicalDevices() { + std::vector phys_devices; + + VkResult err; + uint32_t gpu_count = 0; + + /* repeat get until VK_INCOMPLETE goes away */ + do { + err = vkEnumeratePhysicalDevices(instance, &gpu_count, nullptr); + if (err) ERR_EXIT(err); + + phys_devices.resize(gpu_count); + err = vkEnumeratePhysicalDevices(instance, &gpu_count, phys_devices.data()); + if (err) ERR_EXIT(err); + phys_devices.resize(gpu_count); + } while (err == VK_INCOMPLETE); + + return phys_devices; + } }; // --------- Platform Specific Presentation Calls --------- // @@ -725,6 +772,94 @@ void SetupWindowExtensions(AppInstance &inst) { #endif } +// ---------- Surfaces -------------- // + +class AppSurface { + public: + AppInstance &inst; + SurfaceExtension surface_extension; + + std::vector surf_present_modes; + + std::vector surf_formats; + std::vector surf_formats2; + + VkSurfaceCapabilitiesKHR surface_capabilities; + VkSurfaceCapabilities2KHR surface_capabilities2_khr; + VkSurfaceCapabilities2EXT surface_capabilities2_ext; + + AppSurface(AppInstance &inst, VkPhysicalDevice phys_device, SurfaceExtension surface_extension, + std::vector &sur_extension_pNextChain) + : inst(inst), surface_extension(surface_extension) { + uint32_t present_mode_count = 0; + VkResult err = + inst.vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface_extension.surface, &present_mode_count, nullptr); + if (err) ERR_EXIT(err); + + surf_present_modes.resize(present_mode_count); + err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(phys_device, surface_extension.surface, &present_mode_count, + surf_present_modes.data()); + if (err) ERR_EXIT(err); + + const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr, + surface_extension.surface}; + + uint32_t format_count = 0; + if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { + VkResult err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(phys_device, &surface_info2, &format_count, nullptr); + if (err) ERR_EXIT(err); + surf_formats2.resize(format_count); + for (uint32_t i = 0; i < format_count; ++i) { + surf_formats2[i].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; + surf_formats2[i].pNext = nullptr; + } + err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(phys_device, &surface_info2, &format_count, surf_formats2.data()); + if (err) ERR_EXIT(err); + } else { + VkResult err = + inst.vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface_extension.surface, &format_count, nullptr); + if (err) ERR_EXIT(err); + surf_formats.resize(format_count); + err = inst.vkGetPhysicalDeviceSurfaceFormatsKHR(phys_device, surface_extension.surface, &format_count, + surf_formats.data()); + if (err) ERR_EXIT(err); + } + + if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) { + VkResult err = + inst.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface_extension.surface, &surface_capabilities); + if (err) ERR_EXIT(err); + } + + if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { + surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; + buildpNextChain((VkStructureHeader *)&surface_capabilities2_khr, sur_extension_pNextChain); + + VkPhysicalDeviceSurfaceInfo2KHR surface_info; + surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; + surface_info.pNext = nullptr; + surface_info.surface = surface_extension.surface; + + VkResult err = inst.vkGetPhysicalDeviceSurfaceCapabilities2KHR(phys_device, &surface_info, &surface_capabilities2_khr); + if (err) ERR_EXIT(err); + } + + if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) { + surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; + surface_capabilities2_ext.pNext = nullptr; + VkResult err = + inst.vkGetPhysicalDeviceSurfaceCapabilities2EXT(phys_device, surface_extension.surface, &surface_capabilities2_ext); + if (err) ERR_EXIT(err); + } + } + + ~AppSurface() { + if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { + freepNextChain(static_cast(surface_capabilities2_khr.pNext)); + } + } +}; + // -------------------- Device Groups ------------------------// std::vector GetGroups(AppInstance &inst) { @@ -798,33 +933,6 @@ std::pair GetGroupCapabilities(AppIns // -------------------- Device Setup ------------------- // -void buildpNextChain(VkStructureHeader *first, const std::vector &chain_info) { - VkStructureHeader *place = first; - - for (uint32_t i = 0; i < chain_info.size(); i++) { - place->pNext = static_cast(malloc(chain_info[i].mem_size)); - if (!place->pNext) { - ERR_EXIT(VK_ERROR_OUT_OF_HOST_MEMORY); - } - std::memset(place->pNext, 0, chain_info[i].mem_size); - place = place->pNext; - place->sType = chain_info[i].sType; - } - - place->pNext = nullptr; -} - -void freepNextChain(VkStructureHeader *first) { - VkStructureHeader *place = first; - VkStructureHeader *next = nullptr; - - while (place) { - next = place->pNext; - free(place); - place = next; - } -} - struct MemImageSupport { bool regular_supported, sparse_supported, transient_supported; VkFormat format; @@ -1164,26 +1272,6 @@ struct AppGpu { } } }; - -std::vector> FindGpus(AppInstance &instance, pNextChainInfos chainInfos) { - uint32_t gpu_count; - VkResult err = vkEnumeratePhysicalDevices(instance.instance, &gpu_count, nullptr); - if (err) ERR_EXIT(err); - - std::vector phys_devices(gpu_count); - - err = vkEnumeratePhysicalDevices(instance.instance, &gpu_count, phys_devices.data()); - if (err) ERR_EXIT(err); - - std::vector> gpus; - - uint32_t i = 0; - for (auto &phys_device : phys_devices) { - gpus.push_back(std::unique_ptr(new AppGpu(instance, i++, phys_device, chainInfos))); - } - return gpus; -} - struct AppQueueFamilyProperties { VkQueueFamilyProperties props; uint32_t queue_index; @@ -1212,96 +1300,6 @@ struct AppQueueFamilyProperties { } }; -// ---------- Surfaces -------------- // - -class AppSurface { - public: - AppInstance &inst; - SurfaceExtension surface_extension; - - uint32_t present_mode_count = 0; - std::vector surf_present_modes; - - uint32_t format_count = 0; - std::vector surf_formats; - std::vector surf_formats2; - - VkSurfaceCapabilitiesKHR surface_capabilities; - VkSurfaceCapabilities2KHR surface_capabilities2_khr; - VkSurfaceCapabilities2EXT surface_capabilities2_ext; - - AppSurface(AppInstance &inst, AppGpu *gpu, SurfaceExtension surface_extension, - std::vector &sur_extension_pNextChain) - : inst(inst), surface_extension(surface_extension) { - uint32_t present_mode_count = 0; - VkResult err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(gpu->phys_device, surface_extension.surface, - &present_mode_count, nullptr); - if (err) ERR_EXIT(err); - - surf_present_modes.resize(present_mode_count); - err = inst.vkGetPhysicalDeviceSurfacePresentModesKHR(gpu->phys_device, surface_extension.surface, &present_mode_count, - surf_present_modes.data()); - if (err) ERR_EXIT(err); - - const VkPhysicalDeviceSurfaceInfo2KHR surface_info2 = {VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR, nullptr, - surface_extension.surface}; - - if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { - VkResult err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(gpu->phys_device, &surface_info2, &format_count, nullptr); - if (err) ERR_EXIT(err); - surf_formats2.resize(format_count); - for (uint32_t i = 0; i < format_count; ++i) { - surf_formats2[i].sType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR; - surf_formats2[i].pNext = nullptr; - } - err = inst.vkGetPhysicalDeviceSurfaceFormats2KHR(gpu->phys_device, &surface_info2, &format_count, surf_formats2.data()); - if (err) ERR_EXIT(err); - } else { - VkResult err = - inst.vkGetPhysicalDeviceSurfaceFormatsKHR(gpu->phys_device, surface_extension.surface, &format_count, nullptr); - if (err) ERR_EXIT(err); - surf_formats.resize(format_count); - err = inst.vkGetPhysicalDeviceSurfaceFormatsKHR(gpu->phys_device, surface_extension.surface, &format_count, - surf_formats.data()); - if (err) ERR_EXIT(err); - } - - if (inst.CheckExtensionEnabled(VK_KHR_SURFACE_EXTENSION_NAME)) { - VkResult err = - inst.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(gpu->phys_device, surface_extension.surface, &surface_capabilities); - if (err) ERR_EXIT(err); - } - - if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { - surface_capabilities2_khr.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR; - buildpNextChain((VkStructureHeader *)&surface_capabilities2_khr, sur_extension_pNextChain); - - VkPhysicalDeviceSurfaceInfo2KHR surface_info; - surface_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR; - surface_info.pNext = nullptr; - surface_info.surface = surface_extension.surface; - - VkResult err = - inst.vkGetPhysicalDeviceSurfaceCapabilities2KHR(gpu->phys_device, &surface_info, &surface_capabilities2_khr); - if (err) ERR_EXIT(err); - } - - if (inst.CheckExtensionEnabled(VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) { - surface_capabilities2_ext.sType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT; - surface_capabilities2_ext.pNext = nullptr; - VkResult err = inst.vkGetPhysicalDeviceSurfaceCapabilities2EXT(gpu->phys_device, surface_extension.surface, - &surface_capabilities2_ext); - if (err) ERR_EXIT(err); - } - } - - ~AppSurface() { - if (inst.CheckExtensionEnabled(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME)) { - freepNextChain(static_cast(surface_capabilities2_khr.pNext)); - } - } -}; - // --------- Format Properties ----------// struct PropFlags { -- cgit v1.2.3