video_core: Fine tuning the index drawing judgment logic

src/core/hle/service/nvdrv/core/syncpoint_manager.cpp

@@ -28,15 +28,13 @@ SyncpointManager::SyncpointManager(Tegra::Host1x::Host1x& host1x_) : host1x{host
 SyncpointManager::~SyncpointManager() = default;
 
 u32 SyncpointManager::ReserveSyncpoint(u32 id, bool client_managed) {
-    auto& syncpoint = syncpoints.at(id);
-
-    if (syncpoint.reserved) {
+    if (syncpoints.at(id).reserved) {
         ASSERT_MSG(false, "Requested syncpoint is in use");
         return 0;
     }
 
-    syncpoint.reserved = true;
-    syncpoint.interface_managed = client_managed;
+    syncpoints.at(id).reserved = true;
+    syncpoints.at(id).interface_managed = client_managed;
 
     return id;
 }
@@ -58,12 +56,11 @@ u32 SyncpointManager::AllocateSyncpoint(bool client_managed) {
 
 void SyncpointManager::FreeSyncpoint(u32 id) {
     std::lock_guard lock(reservation_lock);
-    auto& syncpoint = syncpoints.at(id);
-    ASSERT(syncpoint.reserved);
-    syncpoint.reserved = false;
+    ASSERT(syncpoints.at(id).reserved);
+    syncpoints.at(id).reserved = false;
 }
 
-bool SyncpointManager::IsSyncpointAllocated(u32 id) const {
+bool SyncpointManager::IsSyncpointAllocated(u32 id) {
     return (id <= SyncpointCount) && syncpoints[id].reserved;
 }
 
@@ -72,7 +69,7 @@ bool SyncpointManager::HasSyncpointExpired(u32 id, u32 threshold) const {
 
     if (!syncpoint.reserved) {
         ASSERT(false);
-        return false;
+        return 0;
     }
 
     // If the interface manages counters then we don't keep track of the maximum value as it handles
@@ -85,51 +82,40 @@ bool SyncpointManager::HasSyncpointExpired(u32 id, u32 threshold) const {
 }
 
 u32 SyncpointManager::IncrementSyncpointMaxExt(u32 id, u32 amount) {
-    auto& syncpoint = syncpoints.at(id);
-
-    if (!syncpoint.reserved) {
+    if (!syncpoints.at(id).reserved) {
         ASSERT(false);
         return 0;
     }
 
-    return syncpoint.counter_max += amount;
+    return syncpoints.at(id).counter_max += amount;
 }
 
 u32 SyncpointManager::ReadSyncpointMinValue(u32 id) {
-    auto& syncpoint = syncpoints.at(id);
-
-    if (!syncpoint.reserved) {
+    if (!syncpoints.at(id).reserved) {
         ASSERT(false);
         return 0;
     }
 
-    return syncpoint.counter_min;
+    return syncpoints.at(id).counter_min;
 }
 
 u32 SyncpointManager::UpdateMin(u32 id) {
-    auto& syncpoint = syncpoints.at(id);
-
-    if (!syncpoint.reserved) {
+    if (!syncpoints.at(id).reserved) {
         ASSERT(false);
         return 0;
     }
 
-    syncpoint.counter_min = host1x.GetSyncpointManager().GetHostSyncpointValue(id);
-    return syncpoint.counter_min;
+    syncpoints.at(id).counter_min = host1x.GetSyncpointManager().GetHostSyncpointValue(id);
+    return syncpoints.at(id).counter_min;
 }
 
 NvFence SyncpointManager::GetSyncpointFence(u32 id) {
-    auto& syncpoint = syncpoints.at(id);
-
-    if (!syncpoint.reserved) {
+    if (!syncpoints.at(id).reserved) {
         ASSERT(false);
         return NvFence{};
     }
 
-    return {
-        .id = static_cast<s32>(id),
-        .value = syncpoint.counter_max,
-    };
+    return {.id = static_cast<s32>(id), .value = syncpoints.at(id).counter_max};
 }
 
 } // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/core/syncpoint_manager.h

@@ -44,7 +44,7 @@ public:
     /**
      * @brief Checks if the given syncpoint is both allocated and below the number of HW syncpoints
      */
-    bool IsSyncpointAllocated(u32 id) const;
+    bool IsSyncpointAllocated(u32 id);
 
     /**
      * @brief Finds a free syncpoint and reserves it

src/video_core/engines/maxwell_3d.cpp

@@ -126,7 +126,6 @@ void Maxwell3D::InitializeRegisterDefaults() {
     draw_command[MAXWELL3D_REG_INDEX(draw_inline_index)] = true;
     draw_command[MAXWELL3D_REG_INDEX(inline_index_2x16.even)] = true;
     draw_command[MAXWELL3D_REG_INDEX(inline_index_4x8.index0)] = true;
-    draw_command[MAXWELL3D_REG_INDEX(draw.instance_id)] = true;
 }
 
 void Maxwell3D::ProcessMacro(u32 method, const u32* base_start, u32 amount, bool is_last_call) {
@@ -218,16 +217,19 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         regs.index_buffer.count = regs.index_buffer32_first.count;
         regs.index_buffer.first = regs.index_buffer32_first.first;
         dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        draw_indexed = true;
         return ProcessDraw();
     case MAXWELL3D_REG_INDEX(index_buffer16_first):
         regs.index_buffer.count = regs.index_buffer16_first.count;
         regs.index_buffer.first = regs.index_buffer16_first.first;
         dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        draw_indexed = true;
         return ProcessDraw();
     case MAXWELL3D_REG_INDEX(index_buffer8_first):
         regs.index_buffer.count = regs.index_buffer8_first.count;
         regs.index_buffer.first = regs.index_buffer8_first.first;
         dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        draw_indexed = true;
         return ProcessDraw();
     case MAXWELL3D_REG_INDEX(topology_override):
         use_topology_override = true;
@@ -300,21 +302,33 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
             draw_mode = DrawMode::InlineIndex;
         };
         switch (method) {
+        case MAXWELL3D_REG_INDEX(draw.begin): {
+            draw_mode =
+                (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent) ||
+                        (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Unchanged)
+                    ? DrawMode::Instance
+                    : DrawMode::General;
+            break;
+        }
         case MAXWELL3D_REG_INDEX(draw.end):
             switch (draw_mode) {
             case DrawMode::General:
-                ProcessDraw(1);
+                ProcessDraw();
                 break;
             case DrawMode::InlineIndex:
                 regs.index_buffer.count = static_cast<u32>(inline_index_draw_indexes.size() / 4);
                 regs.index_buffer.format = Regs::IndexFormat::UnsignedInt;
-                ProcessDraw(1);
+                draw_indexed = true;
+                ProcessDraw();
                 inline_index_draw_indexes.clear();
                 break;
             case DrawMode::Instance:
                 break;
             }
             break;
+        case MAXWELL3D_REG_INDEX(index_buffer.count):
+            draw_indexed = true;
+            break;
         case MAXWELL3D_REG_INDEX(draw_inline_index):
             update_inline_index(method_argument);
             break;
@@ -328,13 +342,6 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
             update_inline_index(regs.inline_index_4x8.index2);
             update_inline_index(regs.inline_index_4x8.index3);
             break;
-        case MAXWELL3D_REG_INDEX(draw.instance_id):
-            draw_mode =
-                (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent) ||
-                        (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Unchanged)
-                    ? DrawMode::Instance
-                    : DrawMode::General;
-            break;
         }
     } else {
         ProcessDeferredDraw();
@@ -624,27 +631,16 @@ void Maxwell3D::ProcessClearBuffers(u32 layer_count) {
 
 void Maxwell3D::ProcessDraw(u32 instance_count) {
     LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
-              regs.vertex_buffer.count);
-
-    ASSERT_MSG(!(regs.index_buffer.count && regs.vertex_buffer.count), "Both indexed and direct?");
-
-    // Both instance configuration registers can not be set at the same time.
-    ASSERT_MSG(regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::First ||
-                   regs.draw.instance_id != Maxwell3D::Regs::Draw::InstanceId::Unchanged,
-               "Illegal combination of instancing parameters");
+              draw_indexed ? regs.index_buffer.count : regs.vertex_buffer.count);
 
     ProcessTopologyOverride();
 
-    const bool is_indexed = regs.index_buffer.count && !regs.vertex_buffer.count;
     if (ShouldExecute()) {
-        rasterizer->Draw(is_indexed, instance_count);
+        rasterizer->Draw(draw_indexed, instance_count);
     }
 
-    if (is_indexed) {
-        regs.index_buffer.count = 0;
-    } else {
-        regs.vertex_buffer.count = 0;
-    }
+    draw_indexed = false;
+    deferred_draw_method.clear();
 }
 
 void Maxwell3D::ProcessDeferredDraw() {
@@ -667,8 +663,6 @@ void Maxwell3D::ProcessDeferredDraw() {
     ASSERT_MSG(!(vertex_buffer_count && index_buffer_count), "Instance both indexed and direct?");
 
     ProcessDraw(instance_count);
-
-    deferred_draw_method.clear();
 }
 
 } // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.h

@@ -3182,6 +3182,7 @@ private:
     std::vector<u32> deferred_draw_method;
     enum class DrawMode : u32 { General = 0, Instance, InlineIndex };
     DrawMode draw_mode{DrawMode::General};
+    bool draw_indexed{};
 };
 
 #define ASSERT_REG_POSITION(field_name, position)                                                  \

src/yuzu_cmd/config.cpp

@@ -90,11 +90,7 @@ static const std::array<std::array<int, 5>, Settings::NativeAnalog::NumAnalogs>
 
 template <>
 void Config::ReadSetting(const std::string& group, Settings::Setting<std::string>& setting) {
-    std::string setting_value = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault());
-    if (setting_value.empty()) {
-        setting_value = setting.GetDefault();
-    }
-    setting = std::move(setting_value);
+    setting = sdl2_config->Get(group, setting.GetLabel(), setting.GetDefault());
 }
 
 template <>