Jayden/yuzu
Archived
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

VideoCore: Fix draw error when InstanceId is used in the vertex shader

Browse Source
This commit is contained in:
VonChenPlus
2022-06-16 16:38:13 +08:00
parent f86b770ff7
commit e9e29c1c07
10 changed files with 104 additions and 144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/video_core/engines/maxwell_3d.cpp
+67 -97
View File
@@ -117,10 +117,12 @@ void Maxwell3D::InitializeRegisterDefaults() {
shadow_state = regs;
mme_inline[MAXWELL3D_REG_INDEX(draw.vertex_end_gl)] = true;
mme_inline[MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)] = true;
mme_inline[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
mme_inline[MAXWELL3D_REG_INDEX(index_array.count)] = true;
inline_draw[MAXWELL3D_REG_INDEX(draw.vertex_end_gl)] = true;
inline_draw[MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)] = true;
inline_draw[MAXWELL3D_REG_INDEX(vertex_buffer.first)] = true;
inline_draw[MAXWELL3D_REG_INDEX(vertex_buffer.count)] = true;
inline_draw[MAXWELL3D_REG_INDEX(index_array.first)] = true;
inline_draw[MAXWELL3D_REG_INDEX(index_array.count)] = true;
}
void Maxwell3D::ProcessMacro(u32 method, const u32* base_start, u32 amount, bool is_last_call) {
@@ -208,18 +210,16 @@ void Maxwell3D::ProcessMethodCall(u32 method, u32 argument, u32 nonshadow_argume
return ProcessCBBind(3);
case MAXWELL3D_REG_INDEX(cb_bind[4]):
return ProcessCBBind(4);
case MAXWELL3D_REG_INDEX(draw.vertex_end_gl):
return DrawArrays();
case MAXWELL3D_REG_INDEX(small_index):
regs.index_array.count = regs.small_index.count;
regs.index_array.first = regs.small_index.first;
dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
return DrawArrays();
return FlushInlineDraw();
case MAXWELL3D_REG_INDEX(small_index_2):
regs.index_array.count = regs.small_index_2.count;
regs.index_array.first = regs.small_index_2.first;
dirty.flags[VideoCommon::Dirty::IndexBuffer] = true;
return DrawArrays();
return FlushInlineDraw();
case MAXWELL3D_REG_INDEX(topology_override):
use_topology_override = true;
return;
@@ -257,14 +257,14 @@ void Maxwell3D::CallMacroMethod(u32 method, const std::vector<u32>& parameters)
// Execute the current macro.
macro_engine->Execute(macro_positions[entry], parameters);
if (mme_draw.current_mode != MMEDrawMode::Undefined) {
FlushMMEInlineDraw();
if (draw_state.current_mode != DrawMode::Undefined) {
FlushInlineDraw();
}
}
void Maxwell3D::CallMethod(u32 method, u32 method_argument, bool is_last_call) {
// It is an error to write to a register other than the current macro's ARG register before it
// has finished execution.
// It is an error to write to a register other than the current macro's ARG register before
// it has finished execution.
if (executing_macro != 0) {
ASSERT(method == executing_macro + 1);
}
@@ -279,9 +279,38 @@ 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");
const u32 argument = ProcessShadowRam(method, method_argument);
ProcessDirtyRegisters(method, argument);
ProcessMethodCall(method, argument, method_argument, is_last_call);
if (inline_draw[method]) {
regs.reg_array[method] = method_argument;
switch (method) {
case MAXWELL3D_REG_INDEX(vertex_buffer.count):
case MAXWELL3D_REG_INDEX(index_array.count): {
const DrawMode expected_mode = method == MAXWELL3D_REG_INDEX(vertex_buffer.count)
? DrawMode::Array
: DrawMode::Indexed;
StepInstance(expected_mode, method_argument);
break;
}
case MAXWELL3D_REG_INDEX(draw.vertex_begin_gl):
draw_state.instance_mode =
(regs.draw.instance_next != 0) || (regs.draw.instance_cont != 0);
draw_state.gl_begin_consume = true;
break;
case MAXWELL3D_REG_INDEX(draw.vertex_end_gl):
draw_state.gl_end_count++;
break;
case MAXWELL3D_REG_INDEX(vertex_buffer.first):
case MAXWELL3D_REG_INDEX(index_array.first):
break;
}
} else {
if (draw_state.current_mode != DrawMode::Undefined) {
FlushInlineDraw();
}
const u32 argument = ProcessShadowRam(method, method_argument);
ProcessDirtyRegisters(method, argument);
ProcessMethodCall(method, argument, method_argument, is_last_call);
}
}
void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
@@ -319,54 +348,30 @@ void Maxwell3D::CallMultiMethod(u32 method, const u32* base_start, u32 amount,
}
}
void Maxwell3D::StepInstance(const MMEDrawMode expected_mode, const u32 count) {
if (mme_draw.current_mode == MMEDrawMode::Undefined) {
if (mme_draw.gl_begin_consume) {
mme_draw.current_mode = expected_mode;
mme_draw.current_count = count;
mme_draw.instance_count = 1;
mme_draw.gl_begin_consume = false;
mme_draw.gl_end_count = 0;
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 (mme_draw.current_mode == expected_mode && count == mme_draw.current_count &&
mme_draw.instance_mode && mme_draw.gl_begin_consume) {
mme_draw.instance_count++;
mme_draw.gl_begin_consume = false;
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 {
FlushMMEInlineDraw();
FlushInlineDraw();
}
}
// Tail call in case it needs to retry.
StepInstance(expected_mode, count);
}
void Maxwell3D::CallMethodFromMME(u32 method, u32 method_argument) {
if (mme_inline[method]) {
regs.reg_array[method] = method_argument;
if (method == MAXWELL3D_REG_INDEX(vertex_buffer.count) ||
method == MAXWELL3D_REG_INDEX(index_array.count)) {
const MMEDrawMode expected_mode = method == MAXWELL3D_REG_INDEX(vertex_buffer.count)
? MMEDrawMode::Array
: MMEDrawMode::Indexed;
StepInstance(expected_mode, method_argument);
} else if (method == MAXWELL3D_REG_INDEX(draw.vertex_begin_gl)) {
mme_draw.instance_mode =
(regs.draw.instance_next != 0) || (regs.draw.instance_cont != 0);
mme_draw.gl_begin_consume = true;
} else {
mme_draw.gl_end_count++;
}
} else {
if (mme_draw.current_mode != MMEDrawMode::Undefined) {
FlushMMEInlineDraw();
}
CallMethod(method, method_argument, true);
}
}
void Maxwell3D::ProcessTopologyOverride() {
using PrimitiveTopology = Maxwell3D::Regs::PrimitiveTopology;
using PrimitiveTopologyOverride = Maxwell3D::Regs::PrimitiveTopologyOverride;
@@ -396,11 +401,11 @@ void Maxwell3D::ProcessTopologyOverride() {
}
}
void Maxwell3D::FlushMMEInlineDraw() {
void Maxwell3D::FlushInlineDraw() {
LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
regs.vertex_buffer.count);
ASSERT_MSG(!(regs.index_array.count && regs.vertex_buffer.count), "Both indexed and direct?");
ASSERT(mme_draw.instance_count == mme_draw.gl_end_count);
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_next || !regs.draw.instance_cont,
@@ -408,9 +413,9 @@ void Maxwell3D::FlushMMEInlineDraw() {
ProcessTopologyOverride();
const bool is_indexed = mme_draw.current_mode == MMEDrawMode::Indexed;
const bool is_indexed = draw_state.current_mode == DrawMode::Indexed;
if (ShouldExecute()) {
rasterizer->Draw(is_indexed, true);
rasterizer->Draw(is_indexed);
}
// TODO(bunnei): Below, we reset vertex count so that we can use these registers to determine if
@@ -422,12 +427,12 @@ void Maxwell3D::FlushMMEInlineDraw() {
} else {
regs.vertex_buffer.count = 0;
}
mme_draw.current_mode = MMEDrawMode::Undefined;
mme_draw.current_count = 0;
mme_draw.instance_count = 0;
mme_draw.instance_mode = false;
mme_draw.gl_begin_consume = false;
mme_draw.gl_end_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) {
@@ -558,41 +563,6 @@ void Maxwell3D::ProcessSyncPoint() {
}
}
void Maxwell3D::DrawArrays() {
LOG_TRACE(HW_GPU, "called, topology={}, count={}", regs.draw.topology.Value(),
regs.vertex_buffer.count);
ASSERT_MSG(!(regs.index_array.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_next || !regs.draw.instance_cont,
"Illegal combination of instancing parameters");
ProcessTopologyOverride();
if (regs.draw.instance_next) {
// Increment the current instance *before* drawing.
state.current_instance += 1;
} else if (!regs.draw.instance_cont) {
// Reset the current instance to 0.
state.current_instance = 0;
}
const bool is_indexed{regs.index_array.count && !regs.vertex_buffer.count};
if (ShouldExecute()) {
rasterizer->Draw(is_indexed, false);
}
// 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_array.count = 0;
} else {
regs.vertex_buffer.count = 0;
}
}
std::optional<u64> Maxwell3D::GetQueryResult() {
switch (regs.query.query_get.select) {
case Regs::QuerySelect::Payload: