early-access version 1365

src/video_core/CMakeLists.txt

@@ -284,10 +284,10 @@ target_link_libraries(video_core PRIVATE sirit)
 
 if (ENABLE_NSIGHT_AFTERMATH)
     if (NOT DEFINED ENV{NSIGHT_AFTERMATH_SDK})
-        message(ERROR "Environment variable NSIGHT_AFTERMATH_SDK has to be provided")
+        message(FATAL_ERROR "Environment variable NSIGHT_AFTERMATH_SDK has to be provided")
     endif()
     if (NOT WIN32)
-        message(ERROR "Nsight Aftermath doesn't support non-Windows platforms")
+        message(FATAL_ERROR "Nsight Aftermath doesn't support non-Windows platforms")
     endif()
     target_compile_definitions(video_core PRIVATE HAS_NSIGHT_AFTERMATH)
     target_include_directories(video_core PRIVATE "$ENV{NSIGHT_AFTERMATH_SDK}/include")

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -140,6 +140,7 @@ void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat
                                          u32 offset, [[maybe_unused]] u32 size) {
     VkIndexType vk_index_type = MaxwellToVK::IndexFormat(index_format);
     VkDeviceSize vk_offset = offset;
+    VkBuffer vk_buffer = buffer;
     if (topology == PrimitiveTopology::Quads) {
         vk_index_type = VK_INDEX_TYPE_UINT32;
         std::tie(buffer, vk_offset) =
@@ -148,8 +149,13 @@ void BufferCacheRuntime::BindIndexBuffer(PrimitiveTopology topology, IndexFormat
         vk_index_type = VK_INDEX_TYPE_UINT16;
         std::tie(buffer, vk_offset) = uint8_pass.Assemble(num_indices, buffer, offset);
     }
-    scheduler.Record([buffer, vk_offset, vk_index_type](vk::CommandBuffer cmdbuf) {
-        cmdbuf.BindIndexBuffer(buffer, vk_offset, vk_index_type);
+    if (vk_buffer == VK_NULL_HANDLE) {
+        // Vulkan doesn't support null index buffers. Replace it with our own null buffer.
+        ReserveNullIndexBuffer();
+        vk_buffer = *null_index_buffer;
+    }
+    scheduler.Record([vk_buffer, vk_offset, vk_index_type](vk::CommandBuffer cmdbuf) {
+        cmdbuf.BindIndexBuffer(vk_buffer, vk_offset, vk_index_type);
     });
 }
 
@@ -276,4 +282,29 @@ void BufferCacheRuntime::ReserveQuadArrayLUT(u32 num_indices, bool wait_for_idle
     });
 }
 
+void BufferCacheRuntime::ReserveNullIndexBuffer() {
+    if (null_index_buffer) {
+        return;
+    }
+    null_index_buffer = device.GetLogical().CreateBuffer(VkBufferCreateInfo{
+        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+        .pNext = nullptr,
+        .flags = 0,
+        .size = 4,
+        .usage = VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+        .queueFamilyIndexCount = 0,
+        .pQueueFamilyIndices = nullptr,
+    });
+    if (device.HasDebuggingToolAttached()) {
+        null_index_buffer.SetObjectNameEXT("Null index buffer");
+    }
+    null_index_buffer_commit = memory_allocator.Commit(null_index_buffer, MemoryUsage::DeviceLocal);
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([buffer = *null_index_buffer](vk::CommandBuffer cmdbuf) {
+        cmdbuf.FillBuffer(buffer, 0, VK_WHOLE_SIZE, 0);
+    });
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -90,6 +90,8 @@ private:
 
     void ReserveQuadArrayLUT(u32 num_indices, bool wait_for_idle);
 
+    void ReserveNullIndexBuffer();
+
     const Device& device;
     MemoryAllocator& memory_allocator;
     VKScheduler& scheduler;
@@ -101,6 +103,9 @@ private:
     VkIndexType quad_array_lut_index_type{};
     u32 current_num_indices = 0;
 
+    vk::Buffer null_index_buffer;
+    MemoryCommit null_index_buffer_commit;
+
     Uint8Pass uint8_pass;
     QuadIndexedPass quad_index_pass;
 };

src/video_core/shader/shader_ir.cpp

@@ -392,7 +392,7 @@ void ShaderIR::SetInternalFlagsFromInteger(NodeBlock& bb, Node value, bool sets_
     case 0: // Operation Node
         SearchOperands(bb, value);
         break;
-    case 2: // Genral Purpose Node
+    case 2: // General Purpose Node
         if (const auto* gpr = std::get_if<GprNode>(value.get())) {
             LOG_DEBUG(HW_GPU, "GprNode: index={}", gpr->GetIndex());
             Node zerop = Operation(OperationCode::LogicalIEqual, std::move(value),

src/video_core/vulkan_common/nsight_aftermath_tracker.cpp

@@ -12,21 +12,12 @@
 
 #include <fmt/format.h>
 
-#define VK_NO_PROTOTYPES
-#include <vulkan/vulkan.h>
-
-#include <GFSDK_Aftermath.h>
-#include <GFSDK_Aftermath_Defines.h>
-#include <GFSDK_Aftermath_GpuCrashDump.h>
-#include <GFSDK_Aftermath_GpuCrashDumpDecoding.h>
-
 #include "common/common_paths.h"
 #include "common/common_types.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
-
-#include "video_core/renderer_vulkan/nsight_aftermath_tracker.h"
+#include "video_core/vulkan_common/nsight_aftermath_tracker.h"
 
 namespace Vulkan {
 
@@ -53,7 +44,7 @@ NsightAftermathTracker::NsightAftermathTracker() {
         !dl.GetSymbol("GFSDK_Aftermath_GpuCrashDump_GetJSON",
                       &GFSDK_Aftermath_GpuCrashDump_GetJSON)) {
         LOG_ERROR(Render_Vulkan, "Failed to load Nsight Aftermath function pointers");
-        return false;
+        return;
     }
     dump_dir = Common::FS::GetUserPath(Common::FS::UserPath::LogDir) + "gpucrash";
 

src/video_core/vulkan_common/nsight_aftermath_tracker.h

@@ -8,16 +8,16 @@
 #include <string>
 #include <vector>
 
+#include "common/common_types.h"
+#include "common/dynamic_library.h"
+#include "video_core/vulkan_common/vulkan_wrapper.h"
+
 #ifdef HAS_NSIGHT_AFTERMATH
 #include <GFSDK_Aftermath_Defines.h>
 #include <GFSDK_Aftermath_GpuCrashDump.h>
 #include <GFSDK_Aftermath_GpuCrashDumpDecoding.h>
 #endif
 
-#include "common/common_types.h"
-#include "common/dynamic_library.h"
-#include "video_core/vulkan_common/vulkan_wrapper.h"
-
 namespace Vulkan {
 
 class NsightAftermathTracker {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -444,6 +444,11 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             "Blacklisting AMD proprietary on RDNA devices from VK_EXT_extended_dynamic_state");
         ext_extended_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.
+        LOG_WARNING(Render_Vulkan, "Blacklisting Intel proprietary from float16 math");
+        is_float16_supported = false;
+    }
 
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);