early-access version 3045

This commit is contained in:
pineappleEA 2022-10-22 16:13:01 +02:00
parent d0429309af
commit 0af3e1b4e0
9 changed files with 179 additions and 172 deletions

View File

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

View File

@ -117,12 +117,18 @@ void Maxwell3D::InitializeRegisterDefaults() {
shadow_state = regs; 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) { 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); return ProcessCBBind(3);
case MAXWELL3D_REG_INDEX(bind_groups[4].raw_config): case MAXWELL3D_REG_INDEX(bind_groups[4].raw_config):
return ProcessCBBind(4); 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): case MAXWELL3D_REG_INDEX(topology_override):
use_topology_override = true; use_topology_override = true;
return; return;
@ -265,9 +250,8 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
// Execute the current macro. // Execute the current macro.
macro_engine->Execute(macro_positions[entry], parameters); 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) { 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, ASSERT_MSG(method < Regs::NUM_REGS,
"Invalid Maxwell3D register, increase the size of the Regs structure"); "Invalid Maxwell3D register, increase the size of the Regs structure");
if (inline_draw[method]) { if (draw_command[method]) {
regs.reg_array[method] = method_argument; 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 { } else {
if (draw_state.current_mode != DrawMode::Undefined) { ProcessDeferredDraw();
FlushInlineDraw();
}
const u32 argument = ProcessShadowRam(method, method_argument); const u32 argument = ProcessShadowRam(method, method_argument);
ProcessDirtyRegisters(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() { void Maxwell3D::ProcessTopologyOverride() {
using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology; using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride; 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) { void Maxwell3D::ProcessMacroUpload(u32 data) {
macro_engine->AddCode(regs.load_mme.instruction_ptr++, data); macro_engine->AddCode(regs.load_mme.instruction_ptr++, data);
} }
@ -665,4 +583,95 @@ void Maxwell3D::ProcessClearBuffers() {
rasterizer->Clear(); 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 } // namespace Tegra::Engines

View File

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

View File

@ -22,35 +22,29 @@ void HLE_771BB18C62444DA0(Engines::Maxwell3D& maxwell3d, const std::vector<u32>&
maxwell3d.regs.draw.topology.Assign( maxwell3d.regs.draw.topology.Assign(
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0x3ffffff)); static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0] & 0x3ffffff));
maxwell3d.regs.global_base_instance_index = parameters[5]; 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.global_base_vertex_index = parameters[3];
maxwell3d.regs.index_buffer.count = parameters[1]; maxwell3d.regs.index_buffer.count = parameters[1];
maxwell3d.regs.index_buffer.first = parameters[4]; maxwell3d.regs.index_buffer.first = parameters[4];
if (maxwell3d.ShouldExecute()) { if (maxwell3d.ShouldExecute()) {
maxwell3d.Rasterizer().Draw(true); maxwell3d.Rasterizer().Draw(true, instance_count);
} }
maxwell3d.regs.index_buffer.count = 0; 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) { 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.first = parameters[3];
maxwell3d.regs.vertex_buffer.count = parameters[1]; maxwell3d.regs.vertex_buffer.count = parameters[1];
maxwell3d.regs.global_base_instance_index = parameters[4]; maxwell3d.regs.global_base_instance_index = parameters[4];
maxwell3d.regs.draw.topology.Assign( maxwell3d.regs.draw.topology.Assign(
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0])); static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
maxwell3d.draw_state.instance_count = count;
if (maxwell3d.ShouldExecute()) { if (maxwell3d.ShouldExecute()) {
maxwell3d.Rasterizer().Draw(false); maxwell3d.Rasterizer().Draw(false, instance_count);
} }
maxwell3d.regs.vertex_buffer.count = 0; 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) { 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.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
maxwell3d.regs.global_base_vertex_index = element_base; maxwell3d.regs.global_base_vertex_index = element_base;
maxwell3d.regs.global_base_instance_index = base_instance; maxwell3d.regs.global_base_instance_index = base_instance;
maxwell3d.draw_state.instance_count = instance_count;
maxwell3d.CallMethod(0x8e3, 0x640, true); maxwell3d.CallMethod(0x8e3, 0x640, true);
maxwell3d.CallMethod(0x8e4, element_base, true); maxwell3d.CallMethod(0x8e4, element_base, true);
maxwell3d.CallMethod(0x8e5, base_instance, true); maxwell3d.CallMethod(0x8e5, base_instance, true);
maxwell3d.regs.draw.topology.Assign( maxwell3d.regs.draw.topology.Assign(
static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0])); static_cast<Tegra::Engines::Maxwell3D::Regs::PrimitiveTopology>(parameters[0]));
if (maxwell3d.ShouldExecute()) { 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.index_buffer.count = 0;
maxwell3d.regs.global_base_vertex_index = 0x0; maxwell3d.regs.global_base_vertex_index = 0x0;
maxwell3d.regs.global_base_instance_index = 0x0; maxwell3d.regs.global_base_instance_index = 0x0;
maxwell3d.draw_state.instance_count = 0;
maxwell3d.CallMethod(0x8e3, 0x640, true); maxwell3d.CallMethod(0x8e3, 0x640, true);
maxwell3d.CallMethod(0x8e4, 0x0, true); maxwell3d.CallMethod(0x8e4, 0x0, true);
maxwell3d.CallMethod(0x8e5, 0x0, true); maxwell3d.CallMethod(0x8e5, 0x0, true);
maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
} }
// Multidraw Indirect // Multidraw Indirect
void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) { void HLE_3F5E74B9C9A50164(Engines::Maxwell3D& maxwell3d, const std::vector<u32>& parameters) {
SCOPE_EXIT({ SCOPE_EXIT({
// Clean everything. // 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.index_buffer.count = 0;
maxwell3d.regs.global_base_vertex_index = 0x0; maxwell3d.regs.global_base_vertex_index = 0x0;
maxwell3d.regs.global_base_instance_index = 0x0; maxwell3d.regs.global_base_instance_index = 0x0;
maxwell3d.draw_state.instance_count = 0;
maxwell3d.CallMethod(0x8e3, 0x640, true); maxwell3d.CallMethod(0x8e3, 0x640, true);
maxwell3d.CallMethod(0x8e4, 0x0, true); maxwell3d.CallMethod(0x8e4, 0x0, true);
maxwell3d.CallMethod(0x8e5, 0x0, true); maxwell3d.CallMethod(0x8e5, 0x0, true);
maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true; maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
}); });
const u32 start_indirect = parameters[0]; 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.index_buffer.count = num_vertices;
maxwell3d.regs.global_base_vertex_index = base_vertex; maxwell3d.regs.global_base_vertex_index = base_vertex;
maxwell3d.regs.global_base_instance_index = base_instance; maxwell3d.regs.global_base_instance_index = base_instance;
maxwell3d.draw_state.instance_count = instance_count;
maxwell3d.CallMethod(0x8e3, 0x640, true); maxwell3d.CallMethod(0x8e3, 0x640, true);
maxwell3d.CallMethod(0x8e4, base_vertex, true); maxwell3d.CallMethod(0x8e4, base_vertex, true);
maxwell3d.CallMethod(0x8e5, base_instance, true); maxwell3d.CallMethod(0x8e5, base_instance, true);
maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true; maxwell3d.dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
if (maxwell3d.ShouldExecute()) { if (maxwell3d.ShouldExecute()) {
maxwell3d.Rasterizer().Draw(true); maxwell3d.Rasterizer().Draw(true, instance_count);
} }
maxwell3d.draw_state.current_mode = Engines::Maxwell3D::DrawMode::Undefined;
} }
} }

View File

@ -40,7 +40,7 @@ public:
virtual ~RasterizerInterface() = default; virtual ~RasterizerInterface() = default;
/// Dispatches a draw invocation /// 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 /// Clear the current framebuffer
virtual void Clear() = 0; virtual void Clear() = 0;

View File

@ -205,7 +205,7 @@ void RasterizerOpenGL::Clear() {
++num_queued_commands; ++num_queued_commands;
} }
void RasterizerOpenGL::Draw(bool is_indexed) { void RasterizerOpenGL::Draw(bool is_indexed, u32 instance_count) {
MICROPROFILE_SCOPE(OpenGL_Drawing); MICROPROFILE_SCOPE(OpenGL_Drawing);
SCOPE_EXIT({ gpu.TickWork(); }); SCOPE_EXIT({ gpu.TickWork(); });
@ -222,13 +222,15 @@ void RasterizerOpenGL::Draw(bool is_indexed) {
pipeline->SetEngine(maxwell3d, gpu_memory); pipeline->SetEngine(maxwell3d, gpu_memory);
pipeline->Configure(is_indexed); pipeline->Configure(is_indexed);
BindInlineIndexBuffer();
SyncState(); SyncState();
const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(maxwell3d->regs.draw.topology); const GLenum primitive_mode = MaxwellToGL::PrimitiveTopology(maxwell3d->regs.draw.topology);
BeginTransformFeedback(pipeline, primitive_mode); BeginTransformFeedback(pipeline, primitive_mode);
const GLuint base_instance = static_cast<GLuint>(maxwell3d->regs.global_base_instance_index); 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) { if (is_indexed) {
const GLint base_vertex = static_cast<GLint>(maxwell3d->regs.global_base_vertex_index); 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); 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); 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_} {} AccelerateDMA::AccelerateDMA(BufferCache& buffer_cache_) : buffer_cache{buffer_cache_} {}
bool AccelerateDMA::BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) { bool AccelerateDMA::BufferCopy(GPUVAddr src_address, GPUVAddr dest_address, u64 amount) {

View File

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

View File

@ -174,7 +174,7 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
RasterizerVulkan::~RasterizerVulkan() = default; RasterizerVulkan::~RasterizerVulkan() = default;
void RasterizerVulkan::Draw(bool is_indexed) { void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
MICROPROFILE_SCOPE(Vulkan_Drawing); MICROPROFILE_SCOPE(Vulkan_Drawing);
SCOPE_EXIT({ gpu.TickWork(); }); SCOPE_EXIT({ gpu.TickWork(); });
@ -191,12 +191,14 @@ void RasterizerVulkan::Draw(bool is_indexed) {
pipeline->SetEngine(maxwell3d, gpu_memory); pipeline->SetEngine(maxwell3d, gpu_memory);
pipeline->Configure(is_indexed); pipeline->Configure(is_indexed);
BindInlineIndexBuffer();
BeginTransformFeedback(); BeginTransformFeedback();
UpdateDynamicStates(); UpdateDynamicStates();
const auto& regs{maxwell3d->regs}; 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)}; const DrawParams draw_params{MakeDrawParams(regs, num_instances, is_indexed)};
scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) { scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
if (draw_params.is_indexed) { if (draw_params.is_indexed) {
@ -1006,4 +1008,17 @@ void RasterizerVulkan::ReleaseChannel(s32 channel_id) {
query_cache.EraseChannel(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 } // namespace Vulkan

View File

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