mirror of
https://git.eden-emu.dev/eden-emu/eden.git
synced 2026-06-11 03:43:46 -04:00
0d950195e9
This PR introduces an optional Legacy Rescale Compatibility Mode that restores the previous rescale‑pass behavior for titles that rely on its quirks. While the new rescale logic is generally more correct, some games exhibit visual issues that the legacy behavior incidentally avoids. Enabling this mode can mitigate line artifacts on AMD GPUs and reduce grey‑texture flickering on Nvidia GPUs in Luigi’s Mansion 3. This is a compatibility workaround rather than a full fix, and should only be used for titles affected by these rare edge‑case rendering problems. Original Logic from MaranBR Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3582 Co-authored-by: John <john@eden-emu.dev> Co-committed-by: John <john@eden-emu.dev>
366 lines
14 KiB
C++
366 lines
14 KiB
C++
// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#include "common/settings.h"
|
|
#include "shader_recompiler/environment.h"
|
|
#include "shader_recompiler/frontend/ir/ir_emitter.h"
|
|
#include "shader_recompiler/frontend/ir/modifiers.h"
|
|
#include "shader_recompiler/frontend/ir/program.h"
|
|
#include "shader_recompiler/frontend/ir/value.h"
|
|
#include "shader_recompiler/ir_opt/passes.h"
|
|
#include "shader_recompiler/shader_info.h"
|
|
|
|
namespace Shader::Optimization {
|
|
namespace {
|
|
[[nodiscard]] bool IsTextureTypeRescalable(TextureType type) {
|
|
switch (type) {
|
|
case TextureType::Color2D:
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::Color2DRect:
|
|
return true;
|
|
case TextureType::Color1D:
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
case TextureType::Buffer:
|
|
break;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void VisitMark(IR::Block& block, IR::Inst& inst) {
|
|
switch (inst.GetOpcode()) {
|
|
case IR::Opcode::ShuffleIndex:
|
|
case IR::Opcode::ShuffleUp:
|
|
case IR::Opcode::ShuffleDown:
|
|
case IR::Opcode::ShuffleButterfly: {
|
|
const IR::Value shfl_arg{inst.Arg(0)};
|
|
if (shfl_arg.IsImmediate()) {
|
|
break;
|
|
}
|
|
const IR::Inst* const arg_inst{shfl_arg.InstRecursive()};
|
|
if (arg_inst->GetOpcode() != IR::Opcode::BitCastU32F32) {
|
|
break;
|
|
}
|
|
const IR::Value bitcast_arg{arg_inst->Arg(0)};
|
|
if (bitcast_arg.IsImmediate()) {
|
|
break;
|
|
}
|
|
IR::Inst* const bitcast_inst{bitcast_arg.InstRecursive()};
|
|
bool must_patch_outside = false;
|
|
if (bitcast_inst->GetOpcode() == IR::Opcode::GetAttribute) {
|
|
const IR::Attribute attr{bitcast_inst->Arg(0).Attribute()};
|
|
switch (attr) {
|
|
case IR::Attribute::PositionX:
|
|
case IR::Attribute::PositionY:
|
|
bitcast_inst->SetFlags<u32>(0xDEADBEEF);
|
|
must_patch_outside = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (must_patch_outside) {
|
|
const auto it{IR::Block::InstructionList::s_iterator_to(inst)};
|
|
IR::IREmitter ir{block, it};
|
|
if (Settings::values.rescale_hack.GetValue()) {
|
|
const IR::F32 new_inst{&*block.PrependNewInst(it, inst)};
|
|
const IR::F32 up_factor{ir.FPRecip(ir.ResolutionDownFactor())};
|
|
const IR::Value converted{ir.FPMul(new_inst, up_factor)};
|
|
inst.ReplaceUsesWith(converted);
|
|
} else {
|
|
IR::Inst* const new_inst{&*block.PrependNewInst(it, inst)};
|
|
const IR::F32 new_bitcast{ir.ConvertUToF(32, 32, IR::Value{new_inst})};
|
|
const IR::F32 up_factor{ir.FPRecip(ir.ResolutionDownFactor())};
|
|
const IR::Value converted{ir.FPMul(new_bitcast, up_factor)};
|
|
inst.ReplaceUsesWith(converted);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void PatchFragCoord(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const IR::F32 down_factor{ir.ResolutionDownFactor()};
|
|
const IR::F32 frag_coord{ir.GetAttribute(inst.Arg(0).Attribute())};
|
|
const IR::F32 downscaled_frag_coord{ir.FPMul(frag_coord, down_factor)};
|
|
inst.ReplaceUsesWith(downscaled_frag_coord);
|
|
}
|
|
|
|
void PatchPointSize(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const IR::F32 point_value{inst.Arg(1)};
|
|
const IR::F32 up_factor{ir.FPRecip(ir.ResolutionDownFactor())};
|
|
const IR::F32 upscaled_point_value{ir.FPMul(point_value, up_factor)};
|
|
inst.SetArg(1, upscaled_point_value);
|
|
}
|
|
|
|
[[nodiscard]] IR::U32 Scale(IR::IREmitter& ir, const IR::U1& is_scaled, const IR::U32& value) {
|
|
IR::U32 scaled_value{value};
|
|
if (const u32 up_scale = Settings::values.resolution_info.up_scale; up_scale != 1) {
|
|
scaled_value = ir.IMul(scaled_value, ir.Imm32(up_scale));
|
|
}
|
|
if (const u32 down_shift = Settings::values.resolution_info.down_shift; down_shift != 0) {
|
|
scaled_value = ir.ShiftRightArithmetic(scaled_value, ir.Imm32(down_shift));
|
|
}
|
|
return IR::U32{ir.Select(is_scaled, scaled_value, value)};
|
|
}
|
|
|
|
[[nodiscard]] IR::U32 SubScale(IR::IREmitter& ir, const IR::U1& is_scaled, const IR::U32& value,
|
|
const IR::Attribute attrib) {
|
|
const IR::F32 up_factor{ir.Imm32(Settings::values.resolution_info.up_factor)};
|
|
const IR::F32 base{ir.FPMul(ir.ConvertUToF(32, 32, value), up_factor)};
|
|
const IR::F32 frag_coord{ir.GetAttribute(attrib)};
|
|
const IR::F32 down_factor{ir.Imm32(Settings::values.resolution_info.down_factor)};
|
|
const IR::F32 floor{ir.FPMul(up_factor, ir.FPFloor(ir.FPMul(frag_coord, down_factor)))};
|
|
const IR::F16F32F64 deviation{ir.FPAdd(base, ir.FPAdd(frag_coord, ir.FPNeg(floor)))};
|
|
return IR::U32{ir.Select(is_scaled, ir.ConvertFToU(32, deviation), value)};
|
|
}
|
|
|
|
[[nodiscard]] IR::U32 DownScale(IR::IREmitter& ir, const IR::U1& is_scaled, const IR::U32& value) {
|
|
IR::U32 scaled_value{value};
|
|
if (const u32 down_shift = Settings::values.resolution_info.down_shift; down_shift != 0) {
|
|
scaled_value = ir.ShiftLeftLogical(scaled_value, ir.Imm32(down_shift));
|
|
}
|
|
if (const u32 up_scale = Settings::values.resolution_info.up_scale; up_scale != 1) {
|
|
scaled_value = ir.IDiv(scaled_value, ir.Imm32(up_scale));
|
|
}
|
|
return IR::U32{ir.Select(is_scaled, scaled_value, value)};
|
|
}
|
|
|
|
void PatchImageQueryDimensions(IR::Block& block, IR::Inst& inst) {
|
|
const auto it{IR::Block::InstructionList::s_iterator_to(inst)};
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const IR::U1 is_scaled{ir.IsTextureScaled(ir.Imm32(info.descriptor_index))};
|
|
switch (info.type) {
|
|
case TextureType::Color2D:
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::Color2DRect: {
|
|
const IR::Value new_inst{&*block.PrependNewInst(it, inst)};
|
|
const IR::U32 width{DownScale(ir, is_scaled, IR::U32{ir.CompositeExtract(new_inst, 0)})};
|
|
const IR::U32 height{DownScale(ir, is_scaled, IR::U32{ir.CompositeExtract(new_inst, 1)})};
|
|
const IR::Value replacement{ir.CompositeConstruct(
|
|
width, height, ir.CompositeExtract(new_inst, 2), ir.CompositeExtract(new_inst, 3))};
|
|
inst.ReplaceUsesWith(replacement);
|
|
break;
|
|
}
|
|
case TextureType::Color1D:
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
case TextureType::Buffer:
|
|
// Nothing to patch here
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ScaleIntegerComposite(IR::IREmitter& ir, IR::Inst& inst, const IR::U1& is_scaled,
|
|
size_t index) {
|
|
const IR::Value composite{inst.Arg(index)};
|
|
if (composite.IsEmpty()) {
|
|
return;
|
|
}
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const IR::U32 x{Scale(ir, is_scaled, IR::U32{ir.CompositeExtract(composite, 0)})};
|
|
const IR::U32 y{Scale(ir, is_scaled, IR::U32{ir.CompositeExtract(composite, 1)})};
|
|
switch (info.type) {
|
|
case TextureType::Color2D:
|
|
case TextureType::Color2DRect:
|
|
inst.SetArg(index, ir.CompositeConstruct(x, y));
|
|
break;
|
|
case TextureType::ColorArray2D: {
|
|
const IR::U32 z{ir.CompositeExtract(composite, 2)};
|
|
inst.SetArg(index, ir.CompositeConstruct(x, y, z));
|
|
break;
|
|
}
|
|
case TextureType::Color1D:
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
case TextureType::Buffer:
|
|
// Nothing to patch here
|
|
break;
|
|
}
|
|
}
|
|
|
|
void ScaleIntegerOffsetComposite(IR::IREmitter& ir, IR::Inst& inst, const IR::U1& is_scaled,
|
|
size_t index) {
|
|
const IR::Value composite{inst.Arg(index)};
|
|
if (composite.IsEmpty()) {
|
|
return;
|
|
}
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const IR::U32 x{Scale(ir, is_scaled, IR::U32{ir.CompositeExtract(composite, 0)})};
|
|
const IR::U32 y{Scale(ir, is_scaled, IR::U32{ir.CompositeExtract(composite, 1)})};
|
|
switch (info.type) {
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::Color2D:
|
|
case TextureType::Color2DRect:
|
|
inst.SetArg(index, ir.CompositeConstruct(x, y));
|
|
break;
|
|
case TextureType::Color1D:
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
case TextureType::Buffer:
|
|
// Nothing to patch here
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SubScaleCoord(IR::IREmitter& ir, IR::Inst& inst, const IR::U1& is_scaled) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const IR::Value coord{inst.Arg(1)};
|
|
const IR::U32 coord_x{ir.CompositeExtract(coord, 0)};
|
|
const IR::U32 coord_y{ir.CompositeExtract(coord, 1)};
|
|
|
|
const IR::U32 scaled_x{SubScale(ir, is_scaled, coord_x, IR::Attribute::PositionX)};
|
|
const IR::U32 scaled_y{SubScale(ir, is_scaled, coord_y, IR::Attribute::PositionY)};
|
|
switch (info.type) {
|
|
case TextureType::Color2D:
|
|
case TextureType::Color2DRect:
|
|
inst.SetArg(1, ir.CompositeConstruct(scaled_x, scaled_y));
|
|
break;
|
|
case TextureType::ColorArray2D: {
|
|
const IR::U32 z{ir.CompositeExtract(coord, 2)};
|
|
inst.SetArg(1, ir.CompositeConstruct(scaled_x, scaled_y, z));
|
|
break;
|
|
}
|
|
case TextureType::Color1D:
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
case TextureType::Buffer:
|
|
// Nothing to patch here
|
|
break;
|
|
}
|
|
}
|
|
|
|
void SubScaleImageFetch(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (!IsTextureTypeRescalable(info.type)) {
|
|
return;
|
|
}
|
|
const IR::U1 is_scaled{ir.IsTextureScaled(ir.Imm32(info.descriptor_index))};
|
|
SubScaleCoord(ir, inst, is_scaled);
|
|
// Scale ImageFetch offset
|
|
ScaleIntegerOffsetComposite(ir, inst, is_scaled, 2);
|
|
}
|
|
|
|
void SubScaleImageRead(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (!IsTextureTypeRescalable(info.type)) {
|
|
return;
|
|
}
|
|
const IR::U1 is_scaled{ir.IsImageScaled(ir.Imm32(info.descriptor_index))};
|
|
SubScaleCoord(ir, inst, is_scaled);
|
|
}
|
|
|
|
void PatchImageFetch(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (!IsTextureTypeRescalable(info.type)) {
|
|
return;
|
|
}
|
|
const IR::U1 is_scaled{ir.IsTextureScaled(ir.Imm32(info.descriptor_index))};
|
|
ScaleIntegerComposite(ir, inst, is_scaled, 1);
|
|
// Scale ImageFetch offset
|
|
ScaleIntegerOffsetComposite(ir, inst, is_scaled, 2);
|
|
}
|
|
|
|
void PatchImageRead(IR::Block& block, IR::Inst& inst) {
|
|
IR::IREmitter ir{block, IR::Block::InstructionList::s_iterator_to(inst)};
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (!IsTextureTypeRescalable(info.type)) {
|
|
return;
|
|
}
|
|
const IR::U1 is_scaled{ir.IsImageScaled(ir.Imm32(info.descriptor_index))};
|
|
ScaleIntegerComposite(ir, inst, is_scaled, 1);
|
|
}
|
|
|
|
void Visit(const IR::Program& program, IR::Block& block, IR::Inst& inst) {
|
|
const bool is_fragment_shader{program.stage == Stage::Fragment};
|
|
switch (inst.GetOpcode()) {
|
|
case IR::Opcode::GetAttribute: {
|
|
const IR::Attribute attr{inst.Arg(0).Attribute()};
|
|
switch (attr) {
|
|
case IR::Attribute::PositionX:
|
|
case IR::Attribute::PositionY:
|
|
if (is_fragment_shader && inst.Flags<u32>() != 0xDEADBEEF) {
|
|
PatchFragCoord(block, inst);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case IR::Opcode::SetAttribute: {
|
|
const IR::Attribute attr{inst.Arg(0).Attribute()};
|
|
switch (attr) {
|
|
case IR::Attribute::PointSize:
|
|
if (inst.Flags<u32>() != 0xDEADBEEF) {
|
|
PatchPointSize(block, inst);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
case IR::Opcode::ImageQueryDimensions:
|
|
PatchImageQueryDimensions(block, inst);
|
|
break;
|
|
case IR::Opcode::ImageFetch:
|
|
if (is_fragment_shader) {
|
|
SubScaleImageFetch(block, inst);
|
|
} else {
|
|
PatchImageFetch(block, inst);
|
|
}
|
|
break;
|
|
case IR::Opcode::ImageRead:
|
|
if (is_fragment_shader) {
|
|
SubScaleImageRead(block, inst);
|
|
} else {
|
|
PatchImageRead(block, inst);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
} // Anonymous namespace
|
|
|
|
void RescalingPass(IR::Program& program) {
|
|
const bool is_fragment_shader{program.stage == Stage::Fragment};
|
|
if (is_fragment_shader) {
|
|
for (IR::Block* const block : program.post_order_blocks) {
|
|
for (IR::Inst& inst : block->Instructions()) {
|
|
VisitMark(*block, inst);
|
|
}
|
|
}
|
|
}
|
|
for (IR::Block* const block : program.post_order_blocks) {
|
|
for (IR::Inst& inst : block->Instructions()) {
|
|
Visit(program, *block, inst);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace Shader::Optimization
|