summaryrefslogtreecommitdiffstats
path: root/src/video_core/vulkan_common
diff options
context:
space:
mode:
Diffstat (limited to 'src/video_core/vulkan_common')
-rw-r--r--src/video_core/vulkan_common/nsight_aftermath_tracker.cpp7
-rw-r--r--src/video_core/vulkan_common/nsight_aftermath_tracker.h21
-rw-r--r--src/video_core/vulkan_common/vulkan_device.cpp391
-rw-r--r--src/video_core/vulkan_common/vulkan_device.h167
-rw-r--r--src/video_core/vulkan_common/vulkan_wrapper.cpp45
-rw-r--r--src/video_core/vulkan_common/vulkan_wrapper.h52
6 files changed, 579 insertions, 104 deletions
diff --git a/src/video_core/vulkan_common/nsight_aftermath_tracker.cpp b/src/video_core/vulkan_common/nsight_aftermath_tracker.cpp
index 758c038ba..fdd1a5081 100644
--- a/src/video_core/vulkan_common/nsight_aftermath_tracker.cpp
+++ b/src/video_core/vulkan_common/nsight_aftermath_tracker.cpp
@@ -73,12 +73,11 @@ NsightAftermathTracker::~NsightAftermathTracker() {
}
}
-void NsightAftermathTracker::SaveShader(const std::vector<u32>& spirv) const {
+void NsightAftermathTracker::SaveShader(std::span<const u32> spirv) const {
if (!initialized) {
return;
}
-
- std::vector<u32> spirv_copy = spirv;
+ std::vector<u32> spirv_copy(spirv.begin(), spirv.end());
GFSDK_Aftermath_SpirvCode shader;
shader.pData = spirv_copy.data();
shader.size = static_cast<u32>(spirv_copy.size() * 4);
@@ -100,7 +99,7 @@ void NsightAftermathTracker::SaveShader(const std::vector<u32>& spirv) const {
LOG_ERROR(Render_Vulkan, "Failed to dump SPIR-V module with hash={:016x}", hash.hash);
return;
}
- if (file.Write(spirv) != spirv.size()) {
+ if (file.WriteSpan(spirv) != spirv.size()) {
LOG_ERROR(Render_Vulkan, "Failed to write SPIR-V module with hash={:016x}", hash.hash);
return;
}
diff --git a/src/video_core/vulkan_common/nsight_aftermath_tracker.h b/src/video_core/vulkan_common/nsight_aftermath_tracker.h
index 4fe2b14d9..eae1891dd 100644
--- a/src/video_core/vulkan_common/nsight_aftermath_tracker.h
+++ b/src/video_core/vulkan_common/nsight_aftermath_tracker.h
@@ -6,6 +6,7 @@
#include <filesystem>
#include <mutex>
+#include <span>
#include <string>
#include <vector>
@@ -33,7 +34,7 @@ public:
NsightAftermathTracker(NsightAftermathTracker&&) = delete;
NsightAftermathTracker& operator=(NsightAftermathTracker&&) = delete;
- void SaveShader(const std::vector<u32>& spirv) const;
+ void SaveShader(std::span<const u32> spirv) const;
private:
#ifdef HAS_NSIGHT_AFTERMATH
@@ -61,21 +62,21 @@ private:
bool initialized = false;
Common::DynamicLibrary dl;
- PFN_GFSDK_Aftermath_DisableGpuCrashDumps GFSDK_Aftermath_DisableGpuCrashDumps;
- PFN_GFSDK_Aftermath_EnableGpuCrashDumps GFSDK_Aftermath_EnableGpuCrashDumps;
- PFN_GFSDK_Aftermath_GetShaderDebugInfoIdentifier GFSDK_Aftermath_GetShaderDebugInfoIdentifier;
- PFN_GFSDK_Aftermath_GetShaderHashSpirv GFSDK_Aftermath_GetShaderHashSpirv;
- PFN_GFSDK_Aftermath_GpuCrashDump_CreateDecoder GFSDK_Aftermath_GpuCrashDump_CreateDecoder;
- PFN_GFSDK_Aftermath_GpuCrashDump_DestroyDecoder GFSDK_Aftermath_GpuCrashDump_DestroyDecoder;
- PFN_GFSDK_Aftermath_GpuCrashDump_GenerateJSON GFSDK_Aftermath_GpuCrashDump_GenerateJSON;
- PFN_GFSDK_Aftermath_GpuCrashDump_GetJSON GFSDK_Aftermath_GpuCrashDump_GetJSON;
+ PFN_GFSDK_Aftermath_DisableGpuCrashDumps GFSDK_Aftermath_DisableGpuCrashDumps{};
+ PFN_GFSDK_Aftermath_EnableGpuCrashDumps GFSDK_Aftermath_EnableGpuCrashDumps{};
+ PFN_GFSDK_Aftermath_GetShaderDebugInfoIdentifier GFSDK_Aftermath_GetShaderDebugInfoIdentifier{};
+ PFN_GFSDK_Aftermath_GetShaderHashSpirv GFSDK_Aftermath_GetShaderHashSpirv{};
+ PFN_GFSDK_Aftermath_GpuCrashDump_CreateDecoder GFSDK_Aftermath_GpuCrashDump_CreateDecoder{};
+ PFN_GFSDK_Aftermath_GpuCrashDump_DestroyDecoder GFSDK_Aftermath_GpuCrashDump_DestroyDecoder{};
+ PFN_GFSDK_Aftermath_GpuCrashDump_GenerateJSON GFSDK_Aftermath_GpuCrashDump_GenerateJSON{};
+ PFN_GFSDK_Aftermath_GpuCrashDump_GetJSON GFSDK_Aftermath_GpuCrashDump_GetJSON{};
#endif
};
#ifndef HAS_NSIGHT_AFTERMATH
inline NsightAftermathTracker::NsightAftermathTracker() = default;
inline NsightAftermathTracker::~NsightAftermathTracker() = default;
-inline void NsightAftermathTracker::SaveShader(const std::vector<u32>&) const {}
+inline void NsightAftermathTracker::SaveShader(std::span<const u32>) const {}
#endif
} // namespace Vulkan
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index f214510da..8e56a89e1 100644
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/src/video_core/vulkan_common/vulkan_device.cpp
@@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
+#include <algorithm>
#include <bitset>
#include <chrono>
#include <optional>
@@ -33,6 +34,12 @@ constexpr std::array DEPTH16_UNORM_STENCIL8_UINT{
};
} // namespace Alternatives
+enum class NvidiaArchitecture {
+ AmpereOrNewer,
+ Turing,
+ VoltaOrOlder,
+};
+
constexpr std::array REQUIRED_EXTENSIONS{
VK_KHR_MAINTENANCE1_EXTENSION_NAME,
VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME,
@@ -43,11 +50,14 @@ constexpr std::array REQUIRED_EXTENSIONS{
VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME,
VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME,
VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME,
+ VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME,
+ VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME,
VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME,
VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME,
VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME,
VK_EXT_ROBUSTNESS_2_EXTENSION_NAME,
VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME,
+ VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME,
#ifdef _WIN32
VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME,
#endif
@@ -112,6 +122,7 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
VK_FORMAT_R16G16_SFLOAT,
VK_FORMAT_R16G16_SINT,
VK_FORMAT_R16_UNORM,
+ VK_FORMAT_R16_SNORM,
VK_FORMAT_R16_UINT,
VK_FORMAT_R8G8B8A8_SRGB,
VK_FORMAT_R8G8_UNORM,
@@ -191,15 +202,47 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
return format_properties;
}
+std::vector<std::string> GetSupportedExtensions(vk::PhysicalDevice physical) {
+ const std::vector extensions = physical.EnumerateDeviceExtensionProperties();
+ std::vector<std::string> supported_extensions;
+ supported_extensions.reserve(extensions.size());
+ for (const auto& extension : extensions) {
+ supported_extensions.emplace_back(extension.extensionName);
+ }
+ return supported_extensions;
+}
+
+NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
+ std::span<const std::string> exts) {
+ if (std::ranges::find(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME) != exts.end()) {
+ VkPhysicalDeviceFragmentShadingRatePropertiesKHR shading_rate_props{};
+ shading_rate_props.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
+ VkPhysicalDeviceProperties2KHR physical_properties{};
+ physical_properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ physical_properties.pNext = &shading_rate_props;
+ physical.GetProperties2KHR(physical_properties);
+ if (shading_rate_props.primitiveFragmentShadingRateWithMultipleViewports) {
+ // Only Ampere and newer support this feature
+ return NvidiaArchitecture::AmpereOrNewer;
+ }
+ }
+ if (std::ranges::find(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME) != exts.end()) {
+ return NvidiaArchitecture::Turing;
+ }
+ return NvidiaArchitecture::VoltaOrOlder;
+}
} // Anonymous namespace
Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR surface,
const vk::InstanceDispatch& dld_)
: instance{instance_}, dld{dld_}, physical{physical_}, properties{physical.GetProperties()},
- format_properties{GetFormatProperties(physical)} {
+ supported_extensions{GetSupportedExtensions(physical)},
+ format_properties(GetFormatProperties(physical)) {
CheckSuitability(surface != nullptr);
SetupFamilies(surface);
SetupFeatures();
+ SetupProperties();
const auto queue_cis = GetDeviceQueueCreateInfos();
const std::vector extensions = LoadExtensions(surface != nullptr);
@@ -214,16 +257,16 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
.independentBlend = true,
.geometryShader = true,
.tessellationShader = true,
- .sampleRateShading = false,
- .dualSrcBlend = false,
+ .sampleRateShading = true,
+ .dualSrcBlend = true,
.logicOp = false,
.multiDrawIndirect = false,
.drawIndirectFirstInstance = false,
.depthClamp = true,
.depthBiasClamp = true,
- .fillModeNonSolid = false,
- .depthBounds = false,
- .wideLines = false,
+ .fillModeNonSolid = true,
+ .depthBounds = is_depth_bounds_supported,
+ .wideLines = true,
.largePoints = true,
.alphaToOne = false,
.multiViewport = true,
@@ -245,11 +288,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
.shaderSampledImageArrayDynamicIndexing = false,
.shaderStorageBufferArrayDynamicIndexing = false,
.shaderStorageImageArrayDynamicIndexing = false,
- .shaderClipDistance = false,
- .shaderCullDistance = false,
- .shaderFloat64 = false,
- .shaderInt64 = false,
- .shaderInt16 = false,
+ .shaderClipDistance = true,
+ .shaderCullDistance = true,
+ .shaderFloat64 = is_shader_float64_supported,
+ .shaderInt64 = is_shader_int64_supported,
+ .shaderInt16 = is_shader_int16_supported,
.shaderResourceResidency = false,
.shaderResourceMinLod = false,
.sparseBinding = false,
@@ -278,7 +321,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
VkPhysicalDevice16BitStorageFeaturesKHR bit16_storage{
.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR,
.pNext = nullptr,
- .storageBuffer16BitAccess = false,
+ .storageBuffer16BitAccess = true,
.uniformAndStorageBuffer16BitAccess = true,
.storagePushConstant16 = false,
.storageInputOutput16 = false,
@@ -310,6 +353,21 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
};
SetNext(next, host_query_reset);
+ VkPhysicalDeviceVariablePointerFeaturesKHR variable_pointers{
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR,
+ .pNext = nullptr,
+ .variablePointersStorageBuffer = VK_TRUE,
+ .variablePointers = VK_TRUE,
+ };
+ SetNext(next, variable_pointers);
+
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT demote{
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT,
+ .pNext = nullptr,
+ .shaderDemoteToHelperInvocation = true,
+ };
+ SetNext(next, demote);
+
VkPhysicalDeviceFloat16Int8FeaturesKHR float16_int8;
if (is_float16_supported) {
float16_int8 = {
@@ -327,6 +385,14 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
LOG_INFO(Render_Vulkan, "Device doesn't support viewport swizzles");
}
+ if (!nv_viewport_array2) {
+ LOG_INFO(Render_Vulkan, "Device doesn't support viewport masks");
+ }
+
+ if (!nv_geometry_shader_passthrough) {
+ LOG_INFO(Render_Vulkan, "Device doesn't support passthrough geometry shaders");
+ }
+
VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR std430_layout;
if (khr_uniform_buffer_standard_layout) {
std430_layout = {
@@ -389,12 +455,94 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
LOG_INFO(Render_Vulkan, "Device doesn't support extended dynamic state");
}
+ VkPhysicalDeviceLineRasterizationFeaturesEXT line_raster;
+ if (ext_line_rasterization) {
+ line_raster = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT,
+ .pNext = nullptr,
+ .rectangularLines = VK_TRUE,
+ .bresenhamLines = VK_FALSE,
+ .smoothLines = VK_TRUE,
+ .stippledRectangularLines = VK_FALSE,
+ .stippledBresenhamLines = VK_FALSE,
+ .stippledSmoothLines = VK_FALSE,
+ };
+ SetNext(next, line_raster);
+ } else {
+ LOG_INFO(Render_Vulkan, "Device doesn't support smooth lines");
+ }
+
+ if (!ext_conservative_rasterization) {
+ LOG_INFO(Render_Vulkan, "Device doesn't support conservative rasterization");
+ }
+
+ VkPhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex;
+ if (ext_provoking_vertex) {
+ provoking_vertex = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT,
+ .pNext = nullptr,
+ .provokingVertexLast = VK_TRUE,
+ .transformFeedbackPreservesProvokingVertex = VK_TRUE,
+ };
+ SetNext(next, provoking_vertex);
+ } else {
+ LOG_INFO(Render_Vulkan, "Device doesn't support provoking vertex last");
+ }
+
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertex_input_dynamic;
+ if (ext_vertex_input_dynamic_state) {
+ vertex_input_dynamic = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT,
+ .pNext = nullptr,
+ .vertexInputDynamicState = VK_TRUE,
+ };
+ SetNext(next, vertex_input_dynamic);
+ } else {
+ LOG_INFO(Render_Vulkan, "Device doesn't support vertex input dynamic state");
+ }
+
+ VkPhysicalDeviceShaderAtomicInt64FeaturesKHR atomic_int64;
+ if (ext_shader_atomic_int64) {
+ atomic_int64 = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR,
+ .pNext = nullptr,
+ .shaderBufferInt64Atomics = VK_TRUE,
+ .shaderSharedInt64Atomics = VK_TRUE,
+ };
+ SetNext(next, atomic_int64);
+ }
+
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR workgroup_layout;
+ if (khr_workgroup_memory_explicit_layout) {
+ workgroup_layout = {
+ .sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR,
+ .pNext = nullptr,
+ .workgroupMemoryExplicitLayout = VK_TRUE,
+ .workgroupMemoryExplicitLayoutScalarBlockLayout = VK_TRUE,
+ .workgroupMemoryExplicitLayout8BitAccess = VK_TRUE,
+ .workgroupMemoryExplicitLayout16BitAccess = VK_TRUE,
+ };
+ SetNext(next, workgroup_layout);
+ }
+
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR executable_properties;
+ if (khr_pipeline_executable_properties) {
+ LOG_INFO(Render_Vulkan, "Enabling shader feedback, expect slower shader build times");
+ executable_properties = {
+ .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR,
+ .pNext = nullptr,
+ .pipelineExecutableInfo = VK_TRUE,
+ };
+ SetNext(next, executable_properties);
+ }
+
if (!ext_depth_range_unrestricted) {
LOG_INFO(Render_Vulkan, "Device doesn't support depth range unrestricted");
}
VkDeviceDiagnosticsConfigCreateInfoNV diagnostics_nv;
- if (nv_device_diagnostics_config) {
+ if (Settings::values.enable_nsight_aftermath && nv_device_diagnostics_config) {
nsight_aftermath_tracker = std::make_unique<NsightAftermathTracker>();
diagnostics_nv = {
@@ -412,11 +560,33 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
CollectTelemetryParameters();
CollectToolingInfo();
+ if (driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR) {
+ const auto arch = GetNvidiaArchitecture(physical, supported_extensions);
+ switch (arch) {
+ case NvidiaArchitecture::AmpereOrNewer:
+ LOG_WARNING(Render_Vulkan, "Blacklisting Ampere devices from float16 math");
+ is_float16_supported = false;
+ break;
+ case NvidiaArchitecture::Turing:
+ break;
+ case NvidiaArchitecture::VoltaOrOlder:
+ LOG_WARNING(Render_Vulkan, "Blacklisting Volta and older from VK_KHR_push_descriptor");
+ khr_push_descriptor = false;
+ break;
+ }
+ }
if (ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_MESA_RADV) {
- LOG_WARNING(
- Render_Vulkan,
- "Blacklisting RADV for VK_EXT_extended_dynamic state, likely due to a bug in yuzu");
- ext_extended_dynamic_state = false;
+ // Mask driver version variant
+ const u32 version = (properties.driverVersion << 3) >> 3;
+ if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
+ LOG_WARNING(Render_Vulkan,
+ "RADV versions older than 21.2 have broken VK_EXT_extended_dynamic_state");
+ ext_extended_dynamic_state = false;
+ }
+ }
+ if (ext_vertex_input_dynamic_state && driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
+ LOG_WARNING(Render_Vulkan, "Blacklisting Intel for VK_EXT_vertex_input_dynamic_state");
+ ext_vertex_input_dynamic_state = false;
}
if (is_float16_supported && driver_id == VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS) {
// Intel's compiler crashes when using fp16 on Astral Chain, disable it for the time being.
@@ -426,8 +596,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
graphics_queue = logical.GetQueue(graphics_family);
present_queue = logical.GetQueue(present_family);
-
- use_asynchronous_shaders = Settings::values.use_asynchronous_shaders.GetValue();
}
Device::~Device() = default;
@@ -471,7 +639,7 @@ void Device::ReportLoss() const {
std::this_thread::sleep_for(std::chrono::seconds{15});
}
-void Device::SaveShader(const std::vector<u32>& spirv) const {
+void Device::SaveShader(std::span<const u32> spirv) const {
if (nsight_aftermath_tracker) {
nsight_aftermath_tracker->SaveShader(spirv);
}
@@ -597,10 +765,20 @@ void Device::CheckSuitability(bool requires_swapchain) const {
throw vk::Exception(VK_ERROR_FEATURE_NOT_PRESENT);
}
}
+ VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT demote{};
+ demote.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT;
+ demote.pNext = nullptr;
+
+ VkPhysicalDeviceVariablePointerFeaturesKHR variable_pointers{};
+ variable_pointers.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
+ variable_pointers.pNext = &demote;
+
VkPhysicalDeviceRobustness2FeaturesEXT robustness2{};
robustness2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT;
+ robustness2.pNext = &variable_pointers;
- VkPhysicalDeviceFeatures2 features2{};
+ VkPhysicalDeviceFeatures2KHR features2{};
features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
features2.pNext = &robustness2;
@@ -610,7 +788,6 @@ void Device::CheckSuitability(bool requires_swapchain) const {
const std::array feature_report{
std::make_pair(features.robustBufferAccess, "robustBufferAccess"),
std::make_pair(features.vertexPipelineStoresAndAtomics, "vertexPipelineStoresAndAtomics"),
- std::make_pair(features.robustBufferAccess, "robustBufferAccess"),
std::make_pair(features.imageCubeArray, "imageCubeArray"),
std::make_pair(features.independentBlend, "independentBlend"),
std::make_pair(features.depthClamp, "depthClamp"),
@@ -618,13 +795,23 @@ void Device::CheckSuitability(bool requires_swapchain) const {
std::make_pair(features.largePoints, "largePoints"),
std::make_pair(features.multiViewport, "multiViewport"),
std::make_pair(features.depthBiasClamp, "depthBiasClamp"),
+ std::make_pair(features.fillModeNonSolid, "fillModeNonSolid"),
+ std::make_pair(features.wideLines, "wideLines"),
std::make_pair(features.geometryShader, "geometryShader"),
std::make_pair(features.tessellationShader, "tessellationShader"),
+ std::make_pair(features.sampleRateShading, "sampleRateShading"),
+ std::make_pair(features.dualSrcBlend, "dualSrcBlend"),
std::make_pair(features.occlusionQueryPrecise, "occlusionQueryPrecise"),
std::make_pair(features.fragmentStoresAndAtomics, "fragmentStoresAndAtomics"),
std::make_pair(features.shaderImageGatherExtended, "shaderImageGatherExtended"),
std::make_pair(features.shaderStorageImageWriteWithoutFormat,
"shaderStorageImageWriteWithoutFormat"),
+ std::make_pair(features.shaderClipDistance, "shaderClipDistance"),
+ std::make_pair(features.shaderCullDistance, "shaderCullDistance"),
+ std::make_pair(demote.shaderDemoteToHelperInvocation, "shaderDemoteToHelperInvocation"),
+ std::make_pair(variable_pointers.variablePointers, "variablePointers"),
+ std::make_pair(variable_pointers.variablePointersStorageBuffer,
+ "variablePointersStorageBuffer"),
std::make_pair(robustness2.robustBufferAccess2, "robustBufferAccess2"),
std::make_pair(robustness2.robustImageAccess2, "robustImageAccess2"),
std::make_pair(robustness2.nullDescriptor, "nullDescriptor"),
@@ -647,14 +834,20 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
}
bool has_khr_shader_float16_int8{};
+ bool has_khr_workgroup_memory_explicit_layout{};
+ bool has_khr_pipeline_executable_properties{};
bool has_ext_subgroup_size_control{};
bool has_ext_transform_feedback{};
bool has_ext_custom_border_color{};
bool has_ext_extended_dynamic_state{};
- for (const VkExtensionProperties& extension : physical.EnumerateDeviceExtensionProperties()) {
+ bool has_ext_shader_atomic_int64{};
+ bool has_ext_provoking_vertex{};
+ bool has_ext_vertex_input_dynamic_state{};
+ bool has_ext_line_rasterization{};
+ for (const std::string& extension : supported_extensions) {
const auto test = [&](std::optional<std::reference_wrapper<bool>> status, const char* name,
bool push) {
- if (extension.extensionName != std::string_view(name)) {
+ if (extension != name) {
return;
}
if (push) {
@@ -665,8 +858,13 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
}
};
test(nv_viewport_swizzle, VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME, true);
+ test(nv_viewport_array2, VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME, true);
+ test(nv_geometry_shader_passthrough, VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME,
+ true);
test(khr_uniform_buffer_standard_layout,
VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, true);
+ test(khr_spirv_1_4, VK_KHR_SPIRV_1_4_EXTENSION_NAME, true);
+ test(khr_push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME, true);
test(has_khr_shader_float16_int8, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, false);
test(ext_depth_range_unrestricted, VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME, true);
test(ext_index_type_uint8, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, true);
@@ -675,16 +873,29 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
true);
test(ext_tooling_info, VK_EXT_TOOLING_INFO_EXTENSION_NAME, true);
test(ext_shader_stencil_export, VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME, true);
+ test(ext_conservative_rasterization, VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME,
+ true);
test(has_ext_transform_feedback, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, false);
test(has_ext_custom_border_color, VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, false);
test(has_ext_extended_dynamic_state, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, false);
test(has_ext_subgroup_size_control, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, false);
- if (Settings::values.renderer_debug) {
+ test(has_ext_provoking_vertex, VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME, false);
+ test(has_ext_vertex_input_dynamic_state, VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME,
+ false);
+ test(has_ext_shader_atomic_int64, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, false);
+ test(has_khr_workgroup_memory_explicit_layout,
+ VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME, false);
+ test(has_ext_line_rasterization, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, false);
+ if (Settings::values.enable_nsight_aftermath) {
test(nv_device_diagnostics_config, VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME,
true);
}
+ if (Settings::values.renderer_shader_feedback) {
+ test(has_khr_pipeline_executable_properties,
+ VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, false);
+ }
}
- VkPhysicalDeviceFeatures2KHR features;
+ VkPhysicalDeviceFeatures2KHR features{};
features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
VkPhysicalDeviceProperties2KHR physical_properties;
@@ -722,10 +933,49 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
subgroup_properties.maxSubgroupSize >= GuestWarpSize) {
extensions.push_back(VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME);
guest_warp_stages = subgroup_properties.requiredSubgroupSizeStages;
+ ext_subgroup_size_control = true;
}
} else {
is_warp_potentially_bigger = true;
}
+ if (has_ext_provoking_vertex) {
+ VkPhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex;
+ provoking_vertex.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT;
+ provoking_vertex.pNext = nullptr;
+ features.pNext = &provoking_vertex;
+ physical.GetFeatures2KHR(features);
+
+ if (provoking_vertex.provokingVertexLast &&
+ provoking_vertex.transformFeedbackPreservesProvokingVertex) {
+ extensions.push_back(VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+ ext_provoking_vertex = true;
+ }
+ }
+ if (has_ext_vertex_input_dynamic_state) {
+ VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT vertex_input;
+ vertex_input.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT;
+ vertex_input.pNext = nullptr;
+ features.pNext = &vertex_input;
+ physical.GetFeatures2KHR(features);
+
+ if (vertex_input.vertexInputDynamicState) {
+ extensions.push_back(VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME);
+ ext_vertex_input_dynamic_state = true;
+ }
+ }
+ if (has_ext_shader_atomic_int64) {
+ VkPhysicalDeviceShaderAtomicInt64Features atomic_int64;
+ atomic_int64.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+ atomic_int64.pNext = nullptr;
+ features.pNext = &atomic_int64;
+ physical.GetFeatures2KHR(features);
+
+ if (atomic_int64.shaderBufferInt64Atomics && atomic_int64.shaderSharedInt64Atomics) {
+ extensions.push_back(VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
+ ext_shader_atomic_int64 = true;
+ }
+ }
if (has_ext_transform_feedback) {
VkPhysicalDeviceTransformFeedbackFeaturesEXT tfb_features;
tfb_features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT;
@@ -760,17 +1010,68 @@ std::vector<const char*> Device::LoadExtensions(bool requires_surface) {
}
}
if (has_ext_extended_dynamic_state) {
- VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
- dynamic_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
- dynamic_state.pNext = nullptr;
- features.pNext = &dynamic_state;
+ VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extended_dynamic_state;
+ extended_dynamic_state.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
+ extended_dynamic_state.pNext = nullptr;
+ features.pNext = &extended_dynamic_state;
physical.GetFeatures2KHR(features);
- if (dynamic_state.extendedDynamicState) {
+ if (extended_dynamic_state.extendedDynamicState) {
extensions.push_back(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
ext_extended_dynamic_state = true;
}
}
+ if (has_ext_line_rasterization) {
+ VkPhysicalDeviceLineRasterizationFeaturesEXT line_raster;
+ line_raster.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT;
+ line_raster.pNext = nullptr;
+ features.pNext = &line_raster;
+ physical.GetFeatures2KHR(features);
+ if (line_raster.rectangularLines && line_raster.smoothLines) {
+ extensions.push_back(VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME);
+ ext_line_rasterization = true;
+ }
+ }
+ if (has_khr_workgroup_memory_explicit_layout) {
+ VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR layout;
+ layout.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR;
+ layout.pNext = nullptr;
+ features.pNext = &layout;
+ physical.GetFeatures2KHR(features);
+
+ if (layout.workgroupMemoryExplicitLayout &&
+ layout.workgroupMemoryExplicitLayout8BitAccess &&
+ layout.workgroupMemoryExplicitLayout16BitAccess &&
+ layout.workgroupMemoryExplicitLayoutScalarBlockLayout) {
+ extensions.push_back(VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME);
+ khr_workgroup_memory_explicit_layout = true;
+ }
+ }
+ if (has_khr_pipeline_executable_properties) {
+ VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR executable_properties;
+ executable_properties.sType =
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR;
+ executable_properties.pNext = nullptr;
+ features.pNext = &executable_properties;
+ physical.GetFeatures2KHR(features);
+
+ if (executable_properties.pipelineExecutableInfo) {
+ extensions.push_back(VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME);
+ khr_pipeline_executable_properties = true;
+ }
+ }
+ if (khr_push_descriptor) {
+ VkPhysicalDevicePushDescriptorPropertiesKHR push_descriptor;
+ push_descriptor.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR;
+ push_descriptor.pNext = nullptr;
+
+ physical_properties.pNext = &push_descriptor;
+ physical.GetProperties2KHR(physical_properties);
+
+ max_push_descriptors = push_descriptor.maxPushDescriptors;
+ }
return extensions;
}
@@ -806,11 +1107,25 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
}
void Device::SetupFeatures() {
- const auto supported_features{physical.GetFeatures()};
- is_formatless_image_load_supported = supported_features.shaderStorageImageReadWithoutFormat;
- is_shader_storage_image_multisample = supported_features.shaderStorageImageMultisample;
+ const VkPhysicalDeviceFeatures features{physical.GetFeatures()};
+ is_depth_bounds_supported = features.depthBounds;
+ is_formatless_image_load_supported = features.shaderStorageImageReadWithoutFormat;
+ is_shader_float64_supported = features.shaderFloat64;
+ is_shader_int64_supported = features.shaderInt64;
+ is_shader_int16_supported = features.shaderInt16;
+ is_shader_storage_image_multisample = features.shaderStorageImageMultisample;
is_blit_depth_stencil_supported = TestDepthStencilBlits();
- is_optimal_astc_supported = IsOptimalAstcSupported(supported_features);
+ is_optimal_astc_supported = IsOptimalAstcSupported(features);
+}
+
+void Device::SetupProperties() {
+ float_controls.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR;
+
+ VkPhysicalDeviceProperties2KHR properties2{};
+ properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ properties2.pNext = &float_controls;
+
+ physical.GetProperties2KHR(properties2);
}
void Device::CollectTelemetryParameters() {
@@ -832,12 +1147,6 @@ void Device::CollectTelemetryParameters() {
driver_id = driver.driverID;
vendor_name = driver.driverName;
-
- const std::vector extensions = physical.EnumerateDeviceExtensionProperties();
- reported_extensions.reserve(std::size(extensions));
- for (const auto& extension : extensions) {
- reported_extensions.emplace_back(extension.extensionName);
- }
}
void Device::CollectPhysicalMemoryInfo() {
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index 96c0f8c60..c19f40746 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -4,6 +4,7 @@
#pragma once
+#include <span>
#include <string>
#include <string_view>
#include <unordered_map>
@@ -43,7 +44,7 @@ public:
void ReportLoss() const;
/// Reports a shader to Nsight Aftermath.
- void SaveShader(const std::vector<u32>& spirv) const;
+ void SaveShader(std::span<const u32> spirv) const;
/// Returns the name of the VkDriverId reported from Vulkan.
std::string GetDriverName() const;
@@ -128,6 +129,11 @@ public:
return properties.limits.maxComputeSharedMemorySize;
}
+ /// Returns float control properties of the device.
+ const VkPhysicalDeviceFloatControlsPropertiesKHR& FloatControlProperties() const {
+ return float_controls;
+ }
+
/// Returns true if ASTC is natively supported.
bool IsOptimalAstcSupported() const {
return is_optimal_astc_supported;
@@ -148,11 +154,31 @@ public:
return guest_warp_stages & stage;
}
+ /// Returns the maximum number of push descriptors.
+ u32 MaxPushDescriptors() const {
+ return max_push_descriptors;
+ }
+
/// Returns true if formatless image load is supported.
bool IsFormatlessImageLoadSupported() const {
return is_formatless_image_load_supported;
}
+ /// Returns true if shader int64 is supported.
+ bool IsShaderInt64Supported() const {
+ return is_shader_int64_supported;
+ }
+
+ /// Returns true if shader int16 is supported.
+ bool IsShaderInt16Supported() const {
+ return is_shader_int16_supported;
+ }
+
+ // Returns true if depth bounds is supported.
+ bool IsDepthBoundsSupported() const {
+ return is_depth_bounds_supported;
+ }
+
/// Returns true when blitting from and to depth stencil images is supported.
bool IsBlitDepthStencilSupported() const {
return is_blit_depth_stencil_supported;
@@ -163,11 +189,41 @@ public:
return nv_viewport_swizzle;
}
- /// Returns true if the device supports VK_EXT_scalar_block_layout.
+ /// Returns true if the device supports VK_NV_viewport_array2.
+ bool IsNvViewportArray2Supported() const {
+ return nv_viewport_array2;
+ }
+
+ /// Returns true if the device supports VK_NV_geometry_shader_passthrough.
+ bool IsNvGeometryShaderPassthroughSupported() const {
+ return nv_geometry_shader_passthrough;
+ }
+
+ /// Returns true if the device supports VK_KHR_uniform_buffer_standard_layout.
bool IsKhrUniformBufferStandardLayoutSupported() const {
return khr_uniform_buffer_standard_layout;
}
+ /// Returns true if the device supports VK_KHR_spirv_1_4.
+ bool IsKhrSpirv1_4Supported() const {
+ return khr_spirv_1_4;
+ }
+
+ /// Returns true if the device supports VK_KHR_push_descriptor.
+ bool IsKhrPushDescriptorSupported() const {
+ return khr_push_descriptor;
+ }
+
+ /// Returns true if VK_KHR_pipeline_executable_properties is enabled.
+ bool IsKhrPipelineEexecutablePropertiesEnabled() const {
+ return khr_pipeline_executable_properties;
+ }
+
+ /// Returns true if the device supports VK_KHR_workgroup_memory_explicit_layout.
+ bool IsKhrWorkgroupMemoryExplicitLayoutSupported() const {
+ return khr_workgroup_memory_explicit_layout;
+ }
+
/// Returns true if the device supports VK_EXT_index_type_uint8.
bool IsExtIndexTypeUint8Supported() const {
return ext_index_type_uint8;
@@ -188,6 +244,11 @@ public:
return ext_shader_viewport_index_layer;
}
+ /// Returns true if the device supports VK_EXT_subgroup_size_control.
+ bool IsExtSubgroupSizeControlSupported() const {
+ return ext_subgroup_size_control;
+ }
+
/// Returns true if the device supports VK_EXT_transform_feedback.
bool IsExtTransformFeedbackSupported() const {
return ext_transform_feedback;
@@ -203,11 +264,36 @@ public:
return ext_extended_dynamic_state;
}
+ /// Returns true if the device supports VK_EXT_line_rasterization.
+ bool IsExtLineRasterizationSupported() const {
+ return ext_line_rasterization;
+ }
+
+ /// Returns true if the device supports VK_EXT_vertex_input_dynamic_state.
+ bool IsExtVertexInputDynamicStateSupported() const {
+ return ext_vertex_input_dynamic_state;
+ }
+
/// Returns true if the device supports VK_EXT_shader_stencil_export.
bool IsExtShaderStencilExportSupported() const {
return ext_shader_stencil_export;
}
+ /// Returns true if the device supports VK_EXT_conservative_rasterization.
+ bool IsExtConservativeRasterizationSupported() const {
+ return ext_conservative_rasterization;
+ }
+
+ /// Returns true if the device supports VK_EXT_provoking_vertex.
+ bool IsExtProvokingVertexSupported() const {
+ return ext_provoking_vertex;
+ }
+
+ /// Returns true if the device supports VK_KHR_shader_atomic_int64.
+ bool IsExtShaderAtomicInt64Supported() const {
+ return ext_shader_atomic_int64;
+ }
+
/// Returns true when a known debugging tool is attached.
bool HasDebuggingToolAttached() const {
return has_renderdoc || has_nsight_graphics;
@@ -220,12 +306,7 @@ public:
/// Returns the list of available extensions.
const std::vector<std::string>& GetAvailableExtensions() const {
- return reported_extensions;
- }
-
- /// Returns true if the setting for async shader compilation is enabled.
- bool UseAsynchronousShaders() const {
- return use_asynchronous_shaders;
+ return supported_extensions;
}
u64 GetDeviceLocalMemory() const {
@@ -245,6 +326,9 @@ private:
/// Sets up device features.
void SetupFeatures();
+ /// Sets up device properties.
+ void SetupProperties();
+
/// Collects telemetry information from the device.
void CollectTelemetryParameters();
@@ -267,46 +351,61 @@ private:
bool IsFormatSupported(VkFormat wanted_format, VkFormatFeatureFlags wanted_usage,
FormatType format_type) const;
- VkInstance instance; ///< Vulkan instance.
- vk::DeviceDispatch dld; ///< Device function pointers.
- vk::PhysicalDevice physical; ///< Physical device.
- VkPhysicalDeviceProperties properties; ///< Device properties.
- vk::Device logical; ///< Logical device.
- vk::Queue graphics_queue; ///< Main graphics queue.
- vk::Queue present_queue; ///< Main present queue.
- u32 instance_version{}; ///< Vulkan onstance version.
+ VkInstance instance; ///< Vulkan instance.
+ vk::DeviceDispatch dld; ///< Device function pointers.
+ vk::PhysicalDevice physical; ///< Physical device.
+ VkPhysicalDeviceProperties properties; ///< Device properties.
+ VkPhysicalDeviceFloatControlsPropertiesKHR float_controls{}; ///< Float control properties.
+ vk::Device logical; ///< Logical device.
+ vk::Queue graphics_queue; ///< Main graphics queue.
+ vk::Queue present_queue; ///< Main present queue.
+ u32 instance_version{}; ///< Vulkan onstance version.
u32 graphics_family{}; ///< Main graphics queue family index.
u32 present_family{}; ///< Main present queue family index.
VkDriverIdKHR driver_id{}; ///< Driver ID.
VkShaderStageFlags guest_warp_stages{}; ///< Stages where the guest warp size can be forced.
u64 device_access_memory{}; ///< Total size of device local memory in bytes.
+ u32 max_push_descriptors{}; ///< Maximum number of push descriptors
bool is_optimal_astc_supported{}; ///< Support for native ASTC.
bool is_float16_supported{}; ///< Support for float16 arithmetics.
bool is_warp_potentially_bigger{}; ///< Host warp size can be bigger than guest.
bool is_formatless_image_load_supported{}; ///< Support for shader image read without format.
+ bool is_depth_bounds_supported{}; ///< Support for depth bounds.
+ bool is_shader_float64_supported{}; ///< Support for float64.
+ bool is_shader_int64_supported{}; ///< Support for int64.
+ bool is_shader_int16_supported{}; ///< Support for int16.
bool is_shader_storage_image_multisample{}; ///< Support for image operations on MSAA images.
bool is_blit_depth_stencil_supported{}; ///< Support for blitting from and to depth stencil.
bool nv_viewport_swizzle{}; ///< Support for VK_NV_viewport_swizzle.
- bool khr_uniform_buffer_standard_layout{}; ///< Support for std430 on UBOs.
- bool ext_index_type_uint8{}; ///< Support for VK_EXT_index_type_uint8.
- bool ext_sampler_filter_minmax{}; ///< Support for VK_EXT_sampler_filter_minmax.
- bool ext_depth_range_unrestricted{}; ///< Support for VK_EXT_depth_range_unrestricted.
- bool ext_shader_viewport_index_layer{}; ///< Support for VK_EXT_shader_viewport_index_layer.
- bool ext_tooling_info{}; ///< Support for VK_EXT_tooling_info.
- bool ext_transform_feedback{}; ///< Support for VK_EXT_transform_feedback.
- bool ext_custom_border_color{}; ///< Support for VK_EXT_custom_border_color.
- bool ext_extended_dynamic_state{}; ///< Support for VK_EXT_extended_dynamic_state.
- bool ext_shader_stencil_export{}; ///< Support for VK_EXT_shader_stencil_export.
- bool nv_device_diagnostics_config{}; ///< Support for VK_NV_device_diagnostics_config.
- bool has_renderdoc{}; ///< Has RenderDoc attached
- bool has_nsight_graphics{}; ///< Has Nsight Graphics attached
-
- // Asynchronous Graphics Pipeline setting
- bool use_asynchronous_shaders{}; ///< Setting to use asynchronous shaders/graphics pipeline
+ bool nv_viewport_array2{}; ///< Support for VK_NV_viewport_array2.
+ bool nv_geometry_shader_passthrough{}; ///< Support for VK_NV_geometry_shader_passthrough.
+ bool khr_uniform_buffer_standard_layout{}; ///< Support for scalar uniform buffer layouts.
+ bool khr_spirv_1_4{}; ///< Support for VK_KHR_spirv_1_4.
+ bool khr_workgroup_memory_explicit_layout{}; ///< Support for explicit workgroup layouts.
+ bool khr_push_descriptor{}; ///< Support for VK_KHR_push_descritor.
+ bool khr_pipeline_executable_properties{}; ///< Support for executable properties.
+ bool ext_index_type_uint8{}; ///< Support for VK_EXT_index_type_uint8.
+ bool ext_sampler_filter_minmax{}; ///< Support for VK_EXT_sampler_filter_minmax.
+ bool ext_depth_range_unrestricted{}; ///< Support for VK_EXT_depth_range_unrestricted.
+ bool ext_shader_viewport_index_layer{}; ///< Support for VK_EXT_shader_viewport_index_layer.
+ bool ext_tooling_info{}; ///< Support for VK_EXT_tooling_info.
+ bool ext_subgroup_size_control{}; ///< Support for VK_EXT_subgroup_size_control.
+ bool ext_transform_feedback{}; ///< Support for VK_EXT_transform_feedback.
+ bool ext_custom_border_color{}; ///< Support for VK_EXT_custom_border_color.
+ bool ext_extended_dynamic_state{}; ///< Support for VK_EXT_extended_dynamic_state.
+ bool ext_line_rasterization{}; ///< Support for VK_EXT_line_rasterization.
+ bool ext_vertex_input_dynamic_state{}; ///< Support for VK_EXT_vertex_input_dynamic_state.
+ bool ext_shader_stencil_export{}; ///< Support for VK_EXT_shader_stencil_export.
+ bool ext_shader_atomic_int64{}; ///< Support for VK_KHR_shader_atomic_int64.
+ bool ext_conservative_rasterization{}; ///< Support for VK_EXT_conservative_rasterization.
+ bool ext_provoking_vertex{}; ///< Support for VK_EXT_provoking_vertex.
+ bool nv_device_diagnostics_config{}; ///< Support for VK_NV_device_diagnostics_config.
+ bool has_renderdoc{}; ///< Has RenderDoc attached
+ bool has_nsight_graphics{}; ///< Has Nsight Graphics attached
// Telemetry parameters
- std::string vendor_name; ///< Device's driver name.
- std::vector<std::string> reported_extensions; ///< Reported Vulkan extensions.
+ std::string vendor_name; ///< Device's driver name.
+ std::vector<std::string> supported_extensions; ///< Reported Vulkan extensions.
/// Format properties dictionary.
std::unordered_map<VkFormat, VkFormatProperties> format_properties;
diff --git a/src/video_core/vulkan_common/vulkan_wrapper.cpp b/src/video_core/vulkan_common/vulkan_wrapper.cpp
index 2aa0ffbe6..a9faa4807 100644
--- a/src/video_core/vulkan_common/vulkan_wrapper.cpp
+++ b/src/video_core/vulkan_common/vulkan_wrapper.cpp
@@ -103,6 +103,7 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
X(vkCmdFillBuffer);
X(vkCmdPipelineBarrier);
X(vkCmdPushConstants);
+ X(vkCmdPushDescriptorSetWithTemplateKHR);
X(vkCmdSetBlendConstants);
X(vkCmdSetDepthBias);
X(vkCmdSetDepthBounds);
@@ -120,9 +121,11 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
X(vkCmdSetDepthTestEnableEXT);
X(vkCmdSetDepthWriteEnableEXT);
X(vkCmdSetFrontFaceEXT);
+ X(vkCmdSetLineWidth);
X(vkCmdSetPrimitiveTopologyEXT);
X(vkCmdSetStencilOpEXT);
X(vkCmdSetStencilTestEnableEXT);
+ X(vkCmdSetVertexInputEXT);
X(vkCmdResolveImage);
X(vkCreateBuffer);
X(vkCreateBufferView);
@@ -178,6 +181,8 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
X(vkGetMemoryWin32HandleKHR);
#endif
X(vkGetQueryPoolResults);
+ X(vkGetPipelineExecutablePropertiesKHR);
+ X(vkGetPipelineExecutableStatisticsKHR);
X(vkGetSemaphoreCounterValueKHR);
X(vkMapMemory);
X(vkQueueSubmit);
@@ -199,7 +204,7 @@ void SetObjectName(const DeviceDispatch* dld, VkDevice device, T handle, VkObjec
const VkDebugUtilsObjectNameInfoEXT name_info{
.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT,
.pNext = nullptr,
- .objectType = VK_OBJECT_TYPE_IMAGE,
+ .objectType = type,
.objectHandle = reinterpret_cast<u64>(handle),
.pObjectName = name,
};
@@ -311,8 +316,6 @@ const char* ToString(VkResult result) noexcept {
return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
case VkResult::VK_ERROR_UNKNOWN:
return "VK_ERROR_UNKNOWN";
- case VkResult::VK_ERROR_INCOMPATIBLE_VERSION_KHR:
- return "VK_ERROR_INCOMPATIBLE_VERSION_KHR";
case VkResult::VK_THREAD_IDLE_KHR:
return "VK_THREAD_IDLE_KHR";
case VkResult::VK_THREAD_DONE_KHR:
@@ -808,6 +811,42 @@ VkMemoryRequirements Device::GetImageMemoryRequirements(VkImage image) const noe
return requirements;
}
+std::vector<VkPipelineExecutablePropertiesKHR> Device::GetPipelineExecutablePropertiesKHR(
+ VkPipeline pipeline) const {
+ const VkPipelineInfoKHR info{
+ .sType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR,
+ .pNext = nullptr,
+ .pipeline = pipeline,
+ };
+ u32 num{};
+ dld->vkGetPipelineExecutablePropertiesKHR(handle, &info, &num, nullptr);
+ std::vector<VkPipelineExecutablePropertiesKHR> properties(num);
+ for (auto& property : properties) {
+ property.sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR;
+ }
+ Check(dld->vkGetPipelineExecutablePropertiesKHR(handle, &info, &num, properties.data()));
+ return properties;
+}
+
+std::vector<VkPipelineExecutableStatisticKHR> Device::GetPipelineExecutableStatisticsKHR(
+ VkPipeline pipeline, u32 executable_index) const {
+ const VkPipelineExecutableInfoKHR executable_info{
+ .sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR,
+ .pNext = nullptr,
+ .pipeline = pipeline,
+ .executableIndex = executable_index,
+ };
+ u32 num{};
+ dld->vkGetPipelineExecutableStatisticsKHR(handle, &executable_info, &num, nullptr);
+ std::vector<VkPipelineExecutableStatisticKHR> statistics(num);
+ for (auto& statistic : statistics) {
+ statistic.sType = VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR;
+ }
+ Check(dld->vkGetPipelineExecutableStatisticsKHR(handle, &executable_info, &num,
+ statistics.data()));
+ return statistics;
+}
+
void Device::UpdateDescriptorSets(Span<VkWriteDescriptorSet> writes,
Span<VkCopyDescriptorSet> copies) const noexcept {
dld->vkUpdateDescriptorSets(handle, writes.size(), writes.data(), copies.size(), copies.data());
diff --git a/src/video_core/vulkan_common/vulkan_wrapper.h b/src/video_core/vulkan_common/vulkan_wrapper.h
index 3e36d356a..b7ae01c6c 100644
--- a/src/video_core/vulkan_common/vulkan_wrapper.h
+++ b/src/video_core/vulkan_common/vulkan_wrapper.h
@@ -193,15 +193,16 @@ struct DeviceDispatch : InstanceDispatch {
PFN_vkBeginCommandBuffer vkBeginCommandBuffer{};
PFN_vkBindBufferMemory vkBindBufferMemory{};
PFN_vkBindImageMemory vkBindImageMemory{};
+ PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT{};
PFN_vkCmdBeginQuery vkCmdBeginQuery{};
PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass{};
PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT{};
- PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT{};
PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets{};
PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer{};
PFN_vkCmdBindPipeline vkCmdBindPipeline{};
PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT{};
PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers{};
+ PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT{};
PFN_vkCmdBlitImage vkCmdBlitImage{};
PFN_vkCmdClearAttachments vkCmdClearAttachments{};
PFN_vkCmdCopyBuffer vkCmdCopyBuffer{};
@@ -211,34 +212,36 @@ struct DeviceDispatch : InstanceDispatch {
PFN_vkCmdDispatch vkCmdDispatch{};
PFN_vkCmdDraw vkCmdDraw{};
PFN_vkCmdDrawIndexed vkCmdDrawIndexed{};
+ PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
PFN_vkCmdEndQuery vkCmdEndQuery{};
PFN_vkCmdEndRenderPass vkCmdEndRenderPass{};
PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT{};
- PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT{};
PFN_vkCmdFillBuffer vkCmdFillBuffer{};
PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier{};
PFN_vkCmdPushConstants vkCmdPushConstants{};
+ PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR{};
+ PFN_vkCmdResolveImage vkCmdResolveImage{};
PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants{};
+ PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT{};
PFN_vkCmdSetDepthBias vkCmdSetDepthBias{};
PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds{};
- PFN_vkCmdSetEvent vkCmdSetEvent{};
- PFN_vkCmdSetScissor vkCmdSetScissor{};
- PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask{};
- PFN_vkCmdSetStencilReference vkCmdSetStencilReference{};
- PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask{};
- PFN_vkCmdSetViewport vkCmdSetViewport{};
- PFN_vkCmdWaitEvents vkCmdWaitEvents{};
- PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT{};
- PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT{};
PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT{};
PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT{};
PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT{};
PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT{};
+ PFN_vkCmdSetEvent vkCmdSetEvent{};
PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT{};
+ PFN_vkCmdSetLineWidth vkCmdSetLineWidth{};
PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT{};
+ PFN_vkCmdSetScissor vkCmdSetScissor{};
+ PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask{};
PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT{};
+ PFN_vkCmdSetStencilReference vkCmdSetStencilReference{};
PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT{};
- PFN_vkCmdResolveImage vkCmdResolveImage{};
+ PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask{};
+ PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT{};
+ PFN_vkCmdSetViewport vkCmdSetViewport{};
+ PFN_vkCmdWaitEvents vkCmdWaitEvents{};
PFN_vkCreateBuffer vkCreateBuffer{};
PFN_vkCreateBufferView vkCreateBufferView{};
PFN_vkCreateCommandPool vkCreateCommandPool{};
@@ -292,6 +295,8 @@ struct DeviceDispatch : InstanceDispatch {
#ifdef _WIN32
PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
#endif
+ PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR{};
+ PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR{};
PFN_vkGetQueryPoolResults vkGetQueryPoolResults{};
PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR{};
PFN_vkMapMemory vkMapMemory{};
@@ -876,6 +881,12 @@ public:
VkMemoryRequirements GetImageMemoryRequirements(VkImage image) const noexcept;
+ std::vector<VkPipelineExecutablePropertiesKHR> GetPipelineExecutablePropertiesKHR(
+ VkPipeline pipeline) const;
+
+ std::vector<VkPipelineExecutableStatisticKHR> GetPipelineExecutableStatisticsKHR(
+ VkPipeline pipeline, u32 executable_index) const;
+
void UpdateDescriptorSets(Span<VkWriteDescriptorSet> writes,
Span<VkCopyDescriptorSet> copies) const noexcept;
@@ -989,6 +1000,12 @@ public:
dynamic_offsets.size(), dynamic_offsets.data());
}
+ void PushDescriptorSetWithTemplateKHR(VkDescriptorUpdateTemplateKHR update_template,
+ VkPipelineLayout layout, u32 set,
+ const void* data) const noexcept {
+ dld->vkCmdPushDescriptorSetWithTemplateKHR(handle, update_template, layout, set, data);
+ }
+
void BindPipeline(VkPipelineBindPoint bind_point, VkPipeline pipeline) const noexcept {
dld->vkCmdBindPipeline(handle, bind_point, pipeline);
}
@@ -1190,6 +1207,10 @@ public:
dld->vkCmdSetFrontFaceEXT(handle, front_face);
}
+ void SetLineWidth(float line_width) const noexcept {
+ dld->vkCmdSetLineWidth(handle, line_width);
+ }
+
void SetPrimitiveTopologyEXT(VkPrimitiveTopology primitive_topology) const noexcept {
dld->vkCmdSetPrimitiveTopologyEXT(handle, primitive_topology);
}
@@ -1203,6 +1224,13 @@ public:
dld->vkCmdSetStencilTestEnableEXT(handle, enable ? VK_TRUE : VK_FALSE);
}
+ void SetVertexInputEXT(
+ vk::Span<VkVertexInputBindingDescription2EXT> bindings,
+ vk::Span<VkVertexInputAttributeDescription2EXT> attributes) const noexcept {
+ dld->vkCmdSetVertexInputEXT(handle, bindings.size(), bindings.data(), attributes.size(),
+ attributes.data());
+ }
+
void BindTransformFeedbackBuffersEXT(u32 first, u32 count, const VkBuffer* buffers,
const VkDeviceSize* offsets,
const VkDeviceSize* sizes) const noexcept {
generated by cgit v1.2.3 (git 2.25.1) at 2024-08-10 18:27:22 +0200