diff --git a/runtime/vk_exec_draw.c b/runtime/vk_exec_draw.c index 4f7276d0..4323d05d 100644 --- a/runtime/vk_exec_draw.c +++ b/runtime/vk_exec_draw.c @@ -32,7 +32,7 @@ #define MAX_DESC 1024 #define CHUNK_BYTES (4u << 20) #define ZERO_BYTES 65536u -#define SUPPORT_BYTES 1424u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... +#define SUPPORT_BYTES 1440u // Ryujinx SupportBuffer (std140): alpha_test, is_bgra[8], viewport_inverse, viewport_size, ... #define NVN_STAGE_VS 0 #define NVN_STAGE_FS 1 #define NVN_STAGE_CS 5 @@ -1265,6 +1265,22 @@ static const float *pcss_params(void) { return p; } +// The shadow_spread field of the support buffer: the factor translator patch 0011 applies to the lighting shaders' sun +// shadow filter offset (element 56 .xy of their lighting block), 1 / TOTK_SHADOW_SCALE. The game spaces its four +// compares for its own shadow map texels; with maps TOTK_SHADOW_SCALE times larger, the same offset in UV spans that +// many more texels and the near cascade shows four separate copies of each edge. Dividing by the scale keeps the game's +// spacing in texels. The offset is in UV of the shadow map, so the output resolution plays no part. The scale is read +// once, as vk_texture.c shadow_scale reads it: the maps keep the size they were made with. +static const float *shadow_spread_params(void) { + static float p[4] = {0, 0, 0, 0}; + if (p[0] == 0) { + int scale = cfg_int("TOTK_SHADOW_SCALE"); + scale = scale < 1 ? 1 : scale > 4 ? 4 : scale; + p[0] = 1.0f / (float)scale; + } + return p; +} + static void support_fill(uint8_t *b, float w, float h, float point_size) { memset(b, 0, SUPPORT_BYTES); float inv[4] = {w > 0 ? 2.0f / w : 0, h > 0 ? 2.0f / h : 0, 0, 0}, size[4] = {w, h, 0, 0}; @@ -1273,6 +1289,7 @@ static void support_fill(uint8_t *b, float w, float h, float point_size) { const float one = 1.0f; memcpy(b + 1392, &point_size, 4); // point_size (translator patch 0008): vertex shaders that write none output it memcpy(b + 1408, pcss_params(), 16); // pcss (translator patch 0010): soft sun shadows in the cascade compares + memcpy(b + 1424, shadow_spread_params(), 16); // shadow_spread (translator patch 0011): sun shadow filter width for (int i = 0; i < 73; i++) memcpy(b + 192 + 16 * i, &one, 4); // render scale 1: the host renders at guest size } diff --git a/tools/build_xlate.py b/tools/build_xlate.py index ef0d08bc..d721a8ed 100644 --- a/tools/build_xlate.py +++ b/tools/build_xlate.py @@ -1,7 +1,7 @@ """Build the shader translator: build/xlate/totk_xlate.exe (Ryujinx 1.3.2 + patches, NativeAOT, SPIR-V for Vulkan). Copies tools/vendor/ryujinx to build/xlate/ryujinx, applies tools/xlate/patches/*.patch there (tools/vendor stays -byte-identical; 0001-0004 are MNG's, 0005-0010 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build +byte-identical; 0001-0004 are MNG's, 0005-0011 are ours), then runs `dotnet publish`. Needs the .NET 10 SDK, the MSVC build tools and vswhere.exe (docs/building.md). Run with .venv. Next to the exe it writes totk_xlate.id: the translator identity, a sha256 over everything the build reads (this script, @@ -96,8 +96,8 @@ def prepare_sources() -> Path: for junk in list(src.glob("src/*/obj")) + list(src.glob("src/*/bin")): shutil.rmtree(junk) patches = sorted((XLATE / "patches").glob("*.patch")) - if len(patches) != 10: - sys.exit(f"expected 10 patches, found {len(patches)}") + if len(patches) != 11: + sys.exit(f"expected 11 patches, found {len(patches)}") for patch in patches: # git apply works outside a repository when given a directory; --check first so a failure names the patch. for extra in (["--check"], []): diff --git a/tools/xlate/patches/0011-shadow-filter-spread.patch b/tools/xlate/patches/0011-shadow-filter-spread.patch new file mode 100644 index 00000000..cd952174 --- /dev/null +++ b/tools/xlate/patches/0011-shadow-filter-spread.patch @@ -0,0 +1,82 @@ +--- a/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs ++++ b/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs +@@ -853,7 +853,51 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv + + private static OperationResult GenerateLoad(CodeGenContext context, AstOperation operation) + { +- return GenerateLoadOrStore(context, operation, isStore: false); ++ OperationResult result = GenerateLoadOrStore(context, operation, isStore: false); ++ if (result.Type == AggregateType.FP32 && IsShadowSpread(context, operation)) ++ { ++ SpvInstruction f32 = context.TypeFP32(), v4 = context.TypeVector(f32, 4); ++ SpvInstruction prmPtr = context.AccessChain(context.TypePointer(StorageClass.Uniform, v4), context.ConstantBuffers[SupportBuffer.Binding], ++ context.Constant(context.TypeS32(), (int)SupportBufferField.ShadowSpread)); ++ SpvInstruction factor = context.CompositeExtract(f32, context.Load(v4, prmPtr), 0); ++ result = new OperationResult(AggregateType.FP32, context.FMul(f32, result.Value, factor)); ++ } ++ ++ return result; ++ } ++ ++ // TOTK: the spread of the sun shadow filter. The deferred lighting shaders take the sun shadow as four compares ++ // at the receiver ± h on the cascade map, h = 0.5 * c[56].xy (UV) of their lighting block (fp_c9, or fp_c5 in ++ // some), the same in every cascade. In the near cascade the map is sharp enough that the four copies of an edge ++ // show apart. In a fragment shader that has a 2D array shadow sampler, reads of element 56 .x and .y from any ++ // constant buffer but fp_c4 (which holds the cascade matrices, row 56 being cascade 3's depth row) are multiplied ++ // by the support buffer's shadow_spread.x (runtime/vk_exec_draw.c support_fill, TOTK_SHADOW_SPREAD; 1 keeps the ++ // game's spread). ++ private static bool IsShadowSpread(CodeGenContext context, AstOperation load) ++ { ++ if (context.Definitions.Stage != ShaderStage.Fragment || ++ load.StorageKind != StorageKind.ConstantBuffer || ++ load.SourcesCount != 4 || ++ load.GetSource(0) is not AstOperand { Type: OperandType.Constant } binding || ++ load.GetSource(1) is not AstOperand { Type: OperandType.Constant, Value: 0 } || ++ load.GetSource(2) is not AstOperand { Type: OperandType.Constant, Value: 56 } || ++ load.GetSource(3) is not AstOperand { Type: OperandType.Constant, Value: < 2 } || ++ !context.Properties.ConstantBuffers.TryGetValue(binding.Value, out BufferDefinition buffer) || ++ buffer.Name == "fp_c4") ++ { ++ return false; ++ } ++ ++ foreach (TextureDefinition texture in context.Properties.Textures.Values) ++ { ++ if ((texture.Type & (SamplerType.Mask | SamplerType.Array | SamplerType.Shadow)) == ++ (SamplerType.Texture2D | SamplerType.Array | SamplerType.Shadow)) ++ { ++ return true; ++ } ++ } ++ ++ return false; + } + + private static OperationResult GenerateLod(CodeGenContext context, AstOperation operation) +--- a/src/Ryujinx.Graphics.Shader/SupportBuffer.cs ++++ b/src/Ryujinx.Graphics.Shader/SupportBuffer.cs +@@ -26,6 +26,7 @@ namespace Ryujinx.Graphics.Shader + TfeVertexCount, + PointSize, + Pcss, ++ ShadowSpread, + } + + public struct SupportBuffer +@@ -84,7 +85,8 @@ namespace Ryujinx.Graphics.Shader + new StructureField(AggregateType.Vector4 | AggregateType.S32, "tfe_offset"), + new StructureField(AggregateType.S32, "tfe_vertex_count"), + new StructureField(AggregateType.FP32, "point_size"), +- new StructureField(AggregateType.Vector4 | AggregateType.FP32, "pcss") ++ new StructureField(AggregateType.Vector4 | AggregateType.FP32, "pcss"), ++ new StructureField(AggregateType.Vector4 | AggregateType.FP32, "shadow_spread") + ]); + } + +@@ -101,5 +103,6 @@ namespace Ryujinx.Graphics.Shader + public Vector4 TfeVertexCount; + public Vector4 PointSize; + public Vector4 Pcss; ++ public Vector4 ShadowSpread; + } + } diff --git a/totk.ini.example b/totk.ini.example index 352f19c3..5722f8d1 100644 --- a/totk.ini.example +++ b/totk.ini.example @@ -120,7 +120,9 @@ # game's setting. Read at start. # aniso = 16 # Shadow map resolution: the game's sun cascades are 960x960 (and its static shadow maps 1440 and 720) whatever the game -# resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. Read at start. +# resolution; 2 to 4 draws them that many times larger on each side, for sharper shadows. 1 = the game's. The game's +# shadow edge filter is narrowed by the same factor (translator patch 0011), so close shadow edges don't look doubled. +# Read at start. # shadow_scale = 1 # Sun shadow cascade range in percent of the game's (its cascades end at 20, 40, 80 and 160 m), 50 to 400: higher moves # the steps where shadows turn softer further away, and spreads the shadow map over more ground. Read at start.