early-access version 3045

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 3044.
+This is the source code for early-access 3045.
 
 ## Legal Notice
 

src/video_core/engines/maxwell_3d.cpp

@@ -117,12 +117,18 @@ void Maxwell3D::InitializeRegisterDefaults() {
 
     shadow_state = regs;
 
-    inline_draw[MAXWELL3D_REG_INDEX(draw.end)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(draw.end)] = true;
-    inline_draw[MAXWELL3D_REG_INDEX(draw.begin)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(draw.begin)] = true;
-    inline_draw[MAXWELL3D_REG_INDEX(vertex_buffer.first)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(vertex_buffer.first)] = true;
-    inline_draw[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
-    inline_draw[MAXWELL3D_REG_INDEX(index_buffer.first)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(index_buffer.first)] = true;
-    inline_draw[MAXWELL3D_REG_INDEX(index_buffer.count)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(index_buffer.count)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(index_buffer32_first)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(index_buffer16_first)] = true;
+    draw_command[MAXWELL3D_REG_INDEX(index_buffer8_first)] = true;
+    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;
 }
 
 void Maxwell3D::ProcessMacro(u32 method, const u32* base_start, u32 amount, bool is_last_call) {
@@ -210,27 +216,6 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
         return ProcessCBBind(3);
     case MAXWELL3D_REG_INDEX(bind_groups[4].raw_config):
         return ProcessCBBind(4);
-    case MAXWELL3D_REG_INDEX(index_buffer32_first):
-        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_state.current_mode = DrawMode::Indexed;
-        draw_state.gl_end_count = draw_state.instance_count = 1;
-        return FlushInlineDraw();
-    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_state.current_mode = DrawMode::Indexed;
-        draw_state.gl_end_count = draw_state.instance_count = 1;
-        return FlushInlineDraw();
-    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_state.current_mode = DrawMode::Indexed;
-        draw_state.gl_end_count = draw_state.instance_count = 1;
-        return FlushInlineDraw();
     case MAXWELL3D_REG_INDEX(topology_override):
         use_topology_override = true;
         return;
@@ -265,9 +250,8 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
 
     // Execute the current macro.
     macro_engine->Execute(macro_positions[entry], parameters);
-    if (draw_state.current_mode != DrawMode::Undefined) {
+
-        FlushInlineDraw();
+    ProcessDeferredDraw();
-    }
 }
 
 void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
@@ -287,34 +271,28 @@ void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
     ASSERT_MSG(method < Regs::NUM_REGS,
                "Invalid Maxwell3D register, increase the size of the Regs structure");
 
-    if (inline_draw[method]) {
+    if (draw_command[method]) {
         regs.reg_array[method] = method_argument;
-        switch (method) {
+        deferred_draw_method.push_back(method);
-        case MAXWELL3D_REG_INDEX(vertex_buffer.count):
+        auto u32_to_u8 = [&](const u32 argument) {
-        case MAXWELL3D_REG_INDEX(index_buffer.count): {
+            inline_index_draw_indexes.push_back(static_cast<u8>(argument & 0x000000ff));
-            const DrawMode expected_mode = method == MAXWELL3D_REG_INDEX(vertex_buffer.count)
+            inline_index_draw_indexes.push_back(static_cast<u8>((argument & 0x0000ff00) >> 8));
-                                               ? DrawMode::Array
+            inline_index_draw_indexes.push_back(static_cast<u8>((argument & 0x00ff0000) >> 16));
-                                               : DrawMode::Indexed;
+            inline_index_draw_indexes.push_back(static_cast<u8>((argument & 0xff000000) >> 24));
-            StepInstance(expected_mode, method_argument);
+        };
-            break;
+        if (MAXWELL3D_REG_INDEX(draw_inline_index) == method) {
-        }
+            u32_to_u8(method_argument);
-        case MAXWELL3D_REG_INDEX(draw.begin):
+        } else if (MAXWELL3D_REG_INDEX(inline_index_2x16.even) == method) {
-            draw_state.instance_mode =
+            u32_to_u8(regs.inline_index_2x16.even);
-                (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent) ||
+            u32_to_u8(regs.inline_index_2x16.odd);
-                (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Unchanged);
+        } else if (MAXWELL3D_REG_INDEX(inline_index_4x8.index0) == method) {
-            draw_state.gl_begin_consume = true;
+            u32_to_u8(regs.inline_index_4x8.index0);
-            break;
+            u32_to_u8(regs.inline_index_4x8.index1);
-        case MAXWELL3D_REG_INDEX(draw.end):
+            u32_to_u8(regs.inline_index_4x8.index2);
-            draw_state.gl_end_count++;
+            u32_to_u8(regs.inline_index_4x8.index3);
-            break;
-        case MAXWELL3D_REG_INDEX(vertex_buffer.first):
-        case MAXWELL3D_REG_INDEX(index_buffer.first):
-            break;
         }
     } else {
-        if (draw_state.current_mode != DrawMode::Undefined) {
+        ProcessDeferredDraw();
-            FlushInlineDraw();
-        }
 
         const u32 argument = ProcessShadowRam(method, method_argument);
         ProcessDirtyRegisters(method, argument);
@@ -360,30 +338,6 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
     }
 }
 
-void Maxwell3D::StepInstance(const DrawMode expected_mode, const u32 count) {
-    if (draw_state.current_mode == DrawMode::Undefined) {
-        if (draw_state.gl_begin_consume) {
-            draw_state.current_mode = expected_mode;
-            draw_state.current_count = count;
-            draw_state.instance_count = 1;
-            draw_state.gl_begin_consume = false;
-            draw_state.gl_end_count = 0;
-        }
-        return;
-    } else {
-        if (draw_state.current_mode == expected_mode && count == draw_state.current_count &&
-            draw_state.instance_mode && draw_state.gl_begin_consume) {
-            draw_state.instance_count++;
-            draw_state.gl_begin_consume = false;
-            return;
-        } else {
-            FlushInlineDraw();
-        }
-    }
-    // Tail call in case it needs to retry.
-    StepInstance(expected_mode, count);
-}
-
 void Maxwell3D::ProcessTopologyOverride() {
     using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
     using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride;
@@ -413,42 +367,6 @@ void Maxwell3D::ProcessTopologyOverride() {
     }
 }
 
-void Maxwell3D::FlushInlineDraw() {
-    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?");
-    ASSERT(draw_state.instance_count == draw_state.gl_end_count);
-
-    // 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");
-
-    ProcessTopologyOverride();
-
-    const bool is_indexed = draw_state.current_mode == DrawMode::Indexed;
-    if (ShouldExecute()) {
-        rasterizer->Draw(is_indexed);
-    }
-
-    // TODO(bunnei): Below, we reset vertex count so that we can use these registers to determine if
-    // the game is trying to draw indexed or direct mode. This needs to be verified on HW still -
-    // it's possible that it is incorrect and that there is some other register used to specify the
-    // drawing mode.
-    if (is_indexed) {
-        regs.index_buffer.count = 0;
-    } else {
-        regs.vertex_buffer.count = 0;
-    }
-    draw_state.current_mode = DrawMode::Undefined;
-    draw_state.current_count = 0;
-    draw_state.instance_count = 0;
-    draw_state.instance_mode = false;
-    draw_state.gl_begin_consume = false;
-    draw_state.gl_end_count = 0;
-}
-
 void Maxwell3D::ProcessMacroUpload(u32 data) {
     macro_engine->AddCode(regs.load_mme.instruction_ptr++, data);
 }
@@ -665,4 +583,95 @@ void Maxwell3D::ProcessClearBuffers() {
     rasterizer->Clear();
 }
 
+void Maxwell3D::ProcessDeferredDraw() {
+    if (deferred_draw_method.empty()) {
+        return;
+    }
+
+    enum class DrawMode {
+        Undefined,
+        General,
+        Instance,
+    };
+    DrawMode draw_mode{DrawMode::Undefined};
+    u32 instance_count = 1;
+
+    auto first_method = deferred_draw_method[0];
+    if (MAXWELL3D_REG_INDEX(draw.begin) == first_method) {
+        // The minimum number of methods for drawing must be greater than or equal to
+        // 3[draw.begin->vertex(index)count->draw.end] to avoid errors in index mode drawing
+        if (deferred_draw_method.size() < 3) {
+            return;
+        }
+        draw_mode = (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Subsequent) ||
+                            (regs.draw.instance_id == Maxwell3D::Regs::Draw::InstanceId::Unchanged)
+                        ? DrawMode::Instance
+                        : DrawMode::General;
+    } else if (MAXWELL3D_REG_INDEX(index_buffer32_first) == first_method ||
+               MAXWELL3D_REG_INDEX(index_buffer16_first) == first_method ||
+               MAXWELL3D_REG_INDEX(index_buffer8_first) == first_method) {
+        draw_mode = DrawMode::General;
+    }
+
+    // Drawing will only begin with draw.begin or index_buffer method, other methods directly
+    // clear
+    if (draw_mode == DrawMode::Undefined) {
+        deferred_draw_method.clear();
+        return;
+    }
+
+    if (draw_mode == DrawMode::Instance) {
+        ASSERT_MSG(deferred_draw_method.size() % 4 == 0, "Instance mode method size error");
+        instance_count = static_cast<u32>(deferred_draw_method.size()) / 4;
+    } else {
+        if (MAXWELL3D_REG_INDEX(index_buffer32_first) == first_method) {
+            regs.index_buffer.count = regs.index_buffer32_first.count;
+            regs.index_buffer.first = regs.index_buffer32_first.first;
+            dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        } else if (MAXWELL3D_REG_INDEX(index_buffer32_first) == first_method) {
+            regs.index_buffer.count = regs.index_buffer16_first.count;
+            regs.index_buffer.first = regs.index_buffer16_first.first;
+            dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        } else if (MAXWELL3D_REG_INDEX(index_buffer32_first) == first_method) {
+            regs.index_buffer.count = regs.index_buffer8_first.count;
+            regs.index_buffer.first = regs.index_buffer8_first.first;
+            dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
+        } else {
+            auto second_method = deferred_draw_method[1];
+            if (MAXWELL3D_REG_INDEX(draw_inline_index) == second_method ||
+                MAXWELL3D_REG_INDEX(inline_index_2x16.even) == second_method ||
+                MAXWELL3D_REG_INDEX(inline_index_4x8.index0) == second_method) {
+                regs.index_buffer.count = static_cast<u32>(inline_index_draw_indexes.size() / 4);
+                regs.index_buffer.format = Regs::IndexFormat::UnsignedInt;
+            }
+        }
+    }
+
+    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");
+
+    ProcessTopologyOverride();
+
+    const bool is_indexed = regs.index_buffer.count && !regs.vertex_buffer.count;
+    if (ShouldExecute()) {
+        rasterizer->Draw(is_indexed, instance_count);
+    }
+
+    if (is_indexed) {
+        regs.index_buffer.count = 0;
+    } else {
+        regs.vertex_buffer.count = 0;
+    }
+
+    deferred_draw_method.clear();
+    inline_index_draw_indexes.clear();
+}
+
 } // namespace Tegra::Engines

src/video_core/engines/maxwell_3d.h

@@ -1739,14 +1739,11 @@ public:
             Footprint_1x1_Virtual = 2,
         };
 
-        struct InlineIndex4x8Align {
+        struct InlineIndex4x8 {
             union {
                 BitField<0, 30, u32> count;
                 BitField<30, 2, u32> start;
             };
-        };
-
-        struct InlineIndex4x8Index {
             union {
                 BitField<0, 8, u32> index0;
                 BitField<8, 8, u32> index1;
@@ -2836,8 +2833,7 @@ public:
                 u32 depth_write_enabled;                                               ///< 0x12E8
                 u32 alpha_test_enabled;                                                ///< 0x12EC
                 INSERT_PADDING_BYTES_NOINIT(0x10);
-                InlineIndex4x8Align inline_index_4x8_align;                            ///< 0x1300
+                InlineIndex4x8 inline_index_4x8;                                       ///< 0x1300
-                InlineIndex4x8Index inline_index_4x8_index;                            ///< 0x1304
                 D3DCullMode d3d_cull_mode;                                             ///< 0x1308
                 ComparisonOp depth_test_func;                                          ///< 0x130C
                 f32 alpha_test_ref;                                                    ///< 0x1310
@@ -3062,8 +3058,6 @@ public:
     void CallMultiMethod(u32 method, const u32* base_start, u32 amount,
                          u32 methods_pending) override;
 
-    void FlushInlineDraw();
-
     bool ShouldExecute() const {
         return execute_on;
     }
@@ -3076,21 +3070,6 @@ public:
         return *rasterizer;
     }
 
-    enum class DrawMode : u32 {
-        Undefined,
-        Array,
-        Indexed,
-    };
-
-    struct DrawState {
-        DrawMode current_mode{DrawMode::Undefined};
-        u32 current_count{};
-        u32 instance_count{};
-        bool instance_mode{};
-        bool gl_begin_consume{};
-        u32 gl_end_count{};
-    } draw_state;
-
     struct DirtyState {
         using Flags = std::bitset<std::numeric_limits<u8>::max()>;
         using Table = std::array<u8, Regs::NUM_REGS>;
@@ -3100,6 +3079,8 @@ public:
         Tables tables{};
     } dirty;
 
+    std::vector<u8> inline_index_draw_indexes;
+
 private:
     void InitializeRegisterDefaults();
 
@@ -3162,8 +3143,7 @@ private:
     /// Handles use of topology overrides (e.g., to avoid using a topology assigned from a macro)
     void ProcessTopologyOverride();
 
-    // Handles a instance drawcall from MME
+    void ProcessDeferredDraw();
-    void StepInstance(DrawMode expected_mode, u32 count);
 
     /// Returns a query's value or an empty object if the value will be deferred through a cache.
     std::optional<u64> GetQueryResult();
@@ -3176,8 +3156,6 @@ private:
     /// Start offsets of each macro in macro_memory
     std::array<u32, 0x80> macro_positions{};
 
-    std::array<bool, Regs::NUM_REGS> inline_draw{};
-
     /// Macro method that is currently being executed / being fed parameters.
     u32 executing_macro = 0;
     /// Parameters that have been submitted to the macro call so far.
@@ -3190,6 +3168,9 @@ private:
 
     bool execute_on{true};
     bool use_topology_override{false};
+
+    std::array<bool, Regs::NUM_REGS> draw_command{};
+    std::vector<u32> deferred_draw_method;
 };
 
 #define ASSERT_REG_POSITION(field_name, position)                                                  \
@@ -3394,8 +3375,7 @@ ASSERT_REG_POSITION(alpha_to_coverage_dither, 0x12E0);
 ASSERT_REG_POSITION(blend_per_target_enabled, 0x12E4);
 ASSERT_REG_POSITION(depth_write_enabled, 0x12E8);
 ASSERT_REG_POSITION(alpha_test_enabled, 0x12EC);
-ASSERT_REG_POSITION(inline_index_4x8_align, 0x1300);
+ASSERT_REG_POSITION(inline_index_4x8, 0x1300);
-ASSERT_REG_POSITION(inline_index_4x8_index, 0x1304);
 ASSERT_REG_POSITION(d3d_cull_mode, 0x1308);
 ASSERT_REG_POSITION(depth_test_func, 0x130C);
 ASSERT_REG_POSITION(alpha_test_ref, 0x1310);

src/video_core/macro/macro_hle.cpp

@@ -22,35 +22,29 @@ void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     maxwell3d.regs.draw.topology.Assign(
         static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0x3ffffff));
     maxwell3d.regs.global_base_instance_index = parameters[5];
-    maxwell3d.draw_state.instance_count = instance_count;
     maxwell3d.regs.global_base_vertex_index = parameters[3];
     maxwell3d.regs.index_buffer.count = parameters[1];
     maxwell3d.regs.index_buffer.first = parameters[4];
 
     if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(true);
+        maxwell3d.Rasterizer().Draw(true, instance_count);
     }
     maxwell3d.regs.index_buffer.count = 0;
-    maxwell3d.draw_state.instance_count = 0;
-    maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
 }
 
 void HLE_0D61FC9FAAC9FCAD(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
-    const u32 count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
+    const u32 instance_count = (maxwell3d.GetRegisterValue(0xD1B) & parameters[2]);
 
     maxwell3d.regs.vertex_buffer.first = parameters[3];
     maxwell3d.regs.vertex_buffer.count = parameters[1];
     maxwell3d.regs.global_base_instance_index = parameters[4];
     maxwell3d.regs.draw.topology.Assign(
         static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
-    maxwell3d.draw_state.instance_count = count;
 
     if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(false);
+        maxwell3d.Rasterizer().Draw(false, instance_count);
     }
     maxwell3d.regs.vertex_buffer.count = 0;
-    maxwell3d.draw_state.instance_count = 0;
-    maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
 }
 
 void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
@@ -63,39 +57,34 @@ void HLE_0217920100488FF7(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
     maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
     maxwell3d.regs.global_base_vertex_index = element_base;
     maxwell3d.regs.global_base_instance_index = base_instance;
-    maxwell3d.draw_state.instance_count = instance_count;
     maxwell3d.CallMethod(0x8e3, 0x640, true);
     maxwell3d.CallMethod(0x8e4, element_base, true);
     maxwell3d.CallMethod(0x8e5, base_instance, true);
     maxwell3d.regs.draw.topology.Assign(
         static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
     if (maxwell3d.ShouldExecute()) {
-        maxwell3d.Rasterizer().Draw(true);
+        maxwell3d.Rasterizer().Draw(true, instance_count);
     }
-    maxwell3d.regs.vertex_id_base = 0x0; // vertex id base?
+    maxwell3d.regs.vertex_id_base = 0x0;
     maxwell3d.regs.index_buffer.count = 0;
     maxwell3d.regs.global_base_vertex_index = 0x0;
     maxwell3d.regs.global_base_instance_index = 0x0;
-    maxwell3d.draw_state.instance_count = 0;
     maxwell3d.CallMethod(0x8e3, 0x640, true);
     maxwell3d.CallMethod(0x8e4, 0x0, true);
     maxwell3d.CallMethod(0x8e5, 0x0, true);
-    maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
 }
 
 // Multidraw Indirect
 void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
     SCOPE_EXIT({
         // Clean everything.
-        maxwell3d.regs.vertex_id_base = 0x0; // vertex id base?
+        maxwell3d.regs.vertex_id_base = 0x0;
         maxwell3d.regs.index_buffer.count = 0;
         maxwell3d.regs.global_base_vertex_index = 0x0;
         maxwell3d.regs.global_base_instance_index = 0x0;
-        maxwell3d.draw_state.instance_count = 0;
         maxwell3d.CallMethod(0x8e3, 0x640, true);
         maxwell3d.CallMethod(0x8e4, 0x0, true);
         maxwell3d.CallMethod(0x8e5, 0x0, true);
-        maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
         maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
     });
     const u32 start_indirect = parameters[0];
@@ -127,15 +116,13 @@ void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
         maxwell3d.regs.index_buffer.count = num_vertices;
         maxwell3d.regs.global_base_vertex_index = base_vertex;
         maxwell3d.regs.global_base_instance_index = base_instance;
-        maxwell3d.draw_state.instance_count = instance_count;
         maxwell3d.CallMethod(0x8e3, 0x640, true);
         maxwell3d.CallMethod(0x8e4, base_vertex, true);
         maxwell3d.CallMethod(0x8e5, base_instance, true);
         maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
         if (maxwell3d.ShouldExecute()) {
-            maxwell3d.Rasterizer().Draw(true);
+            maxwell3d.Rasterizer().Draw(true, instance_count);
         }
-        maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
     }
 }
 

src/video_core/rasterizer_interface.h

@@ -40,7 +40,7 @@ public:
     virtual ~RasterizerInterface() = default;
 
     /// Dispatches a draw invocation
-    virtual void Draw(bool is_indexed) = 0;
+    virtual void Draw(bool is_indexed, u32 instance_count) = 0;
 
     /// Clear the current framebuffer
     virtual void Clear() = 0;

src/video_core/renderer_opengl/gl_rasterizer.cpp

@@ -205,7 +205,7 @@ void RasterizerOpenGL::Clear() {
     ++num_queued_commands;
 }
 
-void RasterizerOpenGL::Draw(bool is_indexed) {
+void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
     MICROPROFILE_SCOPE(OpenGL_Drawing);
 
     SCOPE_EXIT({ gpu.TickWork(); });
@@ -222,13 +222,15 @@ void RasterizerOpenGL::Draw(bool is_indexed) {
     pipeline->SetEngine(maxwell3d, gpu_memory);
     pipeline->Configure(is_indexed);
 
+    BindInlineIndexBuffer();
+
     SyncState();
 
     const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(maxwell3d->regs.draw.topology);
     BeginTransformFeedback(pipeline, primitive_mode);
 
     const GLuint base_instance = static_cast<GLuint>(maxwell3d->regs.global_base_instance_index);
-    const GLsizei num_instances = maxwell3d->draw_state.instance_count;
+    const GLsizei num_instances = static_cast<GLsizei>(instance_count);
     if (is_indexed) {
         const GLint base_vertex = static_cast<GLint>(maxwell3d->regs.global_base_vertex_index);
         const GLsizei num_vertices = static_cast<GLsizei>(maxwell3d->regs.index_buffer.count);
@@ -1128,6 +1130,16 @@ void RasterizerOpenGL::ReleaseChannel(s32 channel_id) {
     query_cache.EraseChannel(channel_id);
 }
 
+void RasterizerOpenGL::BindInlineIndexBuffer() {
+    if (maxwell3d->inline_index_draw_indexes.empty()) {
+        return;
+    }
+    const auto data_count = static_cast<u32>(maxwell3d->inline_index_draw_indexes.size());
+    auto buffer = Buffer(buffer_cache_runtime, *this, 0, data_count);
+    buffer.ImmediateUpload(0, maxwell3d->inline_index_draw_indexes);
+    buffer_cache_runtime.BindIndexBuffer(buffer, 0, data_count);
+}
+
 AccelerateDMA::AccelerateDMA(BufferCache& buffer_cache_) : buffer_cache{buffer_cache_} {}
 
 bool AccelerateDMA::BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) {

src/video_core/renderer_opengl/gl_rasterizer.h

@@ -68,7 +68,7 @@ public:
                               StateTracker& state_tracker_);
     ~RasterizerOpenGL() override;
 
-    void Draw(bool is_indexed) override;
+    void Draw(bool is_indexed, u32 instance_count) override;
     void Clear() override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
@@ -199,6 +199,8 @@ private:
     /// End a transform feedback
     void EndTransformFeedback();
 
+    void BindInlineIndexBuffer();
+
     Tegra::GPU& gpu;
 
     const Device& device;

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -174,7 +174,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
 
 RasterizerVulkan::~RasterizerVulkan() = default;
 
-void RasterizerVulkan::Draw(bool is_indexed) {
+void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     MICROPROFILE_SCOPE(Vulkan_Drawing);
 
     SCOPE_EXIT({ gpu.TickWork(); });
@@ -191,12 +191,14 @@ void RasterizerVulkan::Draw(bool is_indexed) {
     pipeline->SetEngine(maxwell3d, gpu_memory);
     pipeline->Configure(is_indexed);
 
+    BindInlineIndexBuffer();
+
     BeginTransformFeedback();
 
     UpdateDynamicStates();
 
     const auto& regs{maxwell3d->regs};
-    const u32 num_instances{maxwell3d->draw_state.instance_count};
+    const u32 num_instances{instance_count};
     const DrawParams draw_params{MakeDrawParams(regs, num_instances, is_indexed)};
     scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
         if (draw_params.is_indexed) {
@@ -1006,4 +1008,17 @@ void RasterizerVulkan::ReleaseChannel(s32 channel_id) {
     query_cache.EraseChannel(channel_id);
 }
 
+void RasterizerVulkan::BindInlineIndexBuffer() {
+    if (maxwell3d->inline_index_draw_indexes.empty()) {
+        return;
+    }
+    const auto data_count = static_cast<u32>(maxwell3d->inline_index_draw_indexes.size());
+    auto buffer = buffer_cache_runtime.UploadStagingBuffer(data_count);
+    std::memcpy(buffer.mapped_span.data(), maxwell3d->inline_index_draw_indexes.data(), data_count);
+    buffer_cache_runtime.BindIndexBuffer(
+        maxwell3d->regs.draw.topology, maxwell3d->regs.index_buffer.format,
+        maxwell3d->regs.index_buffer.first, maxwell3d->regs.index_buffer.count, buffer.buffer,
+        static_cast<u32>(buffer.offset), data_count);
+}
+
 } // namespace Vulkan

src/video_core/renderer_vulkan/vk_rasterizer.h

@@ -64,7 +64,7 @@ public:
                               StateTracker& state_tracker_, Scheduler& scheduler_);
     ~RasterizerVulkan() override;
 
-    void Draw(bool is_indexed) override;
+    void Draw(bool is_indexed, u32 instance_count) override;
     void Clear() override;
     void DispatchCompute() override;
     void ResetCounter(VideoCore::QueryType type) override;
@@ -141,6 +141,8 @@ private:
 
     void UpdateVertexInput(Tegra::Engines::Maxwell3D::Regs& regs);
 
+    void BindInlineIndexBuffer();
+
     Tegra::GPU& gpu;
 
     ScreenInfo& screen_info;