From 822e007d0561b82d08a7134d2ec752cf8cce6a93 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 18:09:30 +0800 Subject: [PATCH 01/17] feat(render): Enhanced dynamic lights light the ground per pixel With Enhanced dynamic lights on, candles, fires and spells used to light the ground through the terrain light grid only, interpolated between vertices a terrain cell apart, so their light showed as square patches. The ground now gets the same smooth pools the models get. - Before the terrain is drawn, the scene pins the brightening lights the frame's point-light selection applies (WorldDynamicLights) and marks the frame's light list. - The terrain's faces, layers, grass and lit terrain decals take a copy of the terrain light without those lights and draw with the new world-lit pipeline set (world_lit.vert/.frag), which adds them back per pixel with the grid's own linear falloff. Lights outside the selection stay in the grid. - The uploaded point lights keep the pinned ones first (DynamicLightsUniform::worldLightCount) and fill the slots left from the lights added after the pin. - The world-lit set is one row of the world pipeline table, in the Enhanced lighting family. Classic and the dynamic-lights switch off draw as before. Fight bench (Noria, 24 monsters, AA 4, alternating runs): 3.65 ms against 3.58 ms on main, within the run-to-run spread. --- cmake/ValidateDxilReflection.cmake | 2 + cmake/ValidateShaderBlobs.cmake | 2 + cmake/ValidateShaderReflection.cmake | 2 + docs/enhanced-look.md | 2 +- src/shaders/compiled/world_lit.frag.dxil | Bin 0 -> 7076 bytes src/shaders/compiled/world_lit.frag.msl | 102 ++++++++++++++ src/shaders/compiled/world_lit.frag.spv | Bin 0 -> 5688 bytes src/shaders/compiled/world_lit.vert.dxil | Bin 0 -> 5176 bytes src/shaders/compiled/world_lit.vert.msl | 50 +++++++ src/shaders/compiled/world_lit.vert.spv | Bin 0 -> 2304 bytes src/shaders/world_lit.frag.hlsl | 93 +++++++++++++ src/shaders/world_lit.vert.hlsl | 30 +++++ .../Render/Lighting/DynamicLightList.cpp | 15 +++ src/source/Render/Lighting/DynamicLightList.h | 5 + .../Render/Lighting/DynamicLightSelection.cpp | 18 +++ .../Render/Lighting/DynamicLightSelection.h | 6 + .../Render/Lighting/WorldDynamicLights.cpp | 30 +++++ .../Render/Lighting/WorldDynamicLights.h | 39 ++++++ src/source/Render/Renderer/MuRenderer.h | 21 +++ .../Render/Renderer/MuRendererSDLGpu.cpp | 76 ++++++++--- src/source/Render/Renderer/SceneLighting.h | 4 +- src/source/Render/Terrain/ZzzLodTerrain.cpp | 125 ++++++++++++++---- src/source/Scenes/CharacterScene.cpp | 1 + src/source/Scenes/LoginScene.cpp | 8 +- src/source/Scenes/MainScene.cpp | 11 +- src/source/Scenes/SceneLightingSetup.cpp | 16 ++- src/source/Scenes/SceneLightingSetup.h | 4 + tests/render/CMakeLists.txt | 1 + tests/render/test_dynamic_lights.cpp | 72 ++++++++++ tests/render/test_pipeline_fail_fast.cmake | 5 +- 30 files changed, 687 insertions(+), 53 deletions(-) create mode 100644 src/shaders/compiled/world_lit.frag.dxil create mode 100644 src/shaders/compiled/world_lit.frag.msl create mode 100644 src/shaders/compiled/world_lit.frag.spv create mode 100644 src/shaders/compiled/world_lit.vert.dxil create mode 100644 src/shaders/compiled/world_lit.vert.msl create mode 100644 src/shaders/compiled/world_lit.vert.spv create mode 100644 src/shaders/world_lit.frag.hlsl create mode 100644 src/shaders/world_lit.vert.hlsl create mode 100644 src/source/Render/Lighting/WorldDynamicLights.cpp create mode 100644 src/source/Render/Lighting/WorldDynamicLights.h diff --git a/cmake/ValidateDxilReflection.cmake b/cmake/ValidateDxilReflection.cmake index 3d14e2918e..3f963cbf1e 100644 --- a/cmake/ValidateDxilReflection.cmake +++ b/cmake/ValidateDxilReflection.cmake @@ -26,6 +26,8 @@ set(shader_specs "skinned_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" "skinned_weighted_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" "skinned_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+t0,space2+t1,space2" + "world_lit.vert|cb0,space1" + "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+t0,space2" "post_fullscreen.vert|-" "post_bloom_down.frag|cb0,space3+s0,space2+t0,space2" "post_bloom_up.frag|cb0,space3+s0,space2+t0,space2" diff --git a/cmake/ValidateShaderBlobs.cmake b/cmake/ValidateShaderBlobs.cmake index dbda6ae3ec..66b55fff35 100644 --- a/cmake/ValidateShaderBlobs.cmake +++ b/cmake/ValidateShaderBlobs.cmake @@ -19,6 +19,8 @@ set(MU_SHADER_STAGE_NAMES skinned_shadow.vert skinned_weighted_shadow.vert skinned_lit.frag + world_lit.vert + world_lit.frag shadow_volume.vert post_fullscreen.vert post_bloom_down.frag diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index e3403bbc9d..68c6efa499 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -271,6 +271,8 @@ set(shader_specs "skinned_shadow.vert|vert|0,3,4|0|2|2" "skinned_weighted_shadow.vert|vert|0,3,4,6,7|0|2|2" "skinned_lit.frag|frag||2|0|3" + "world_lit.vert|vert|0,1,2|0|0|1" + "world_lit.frag|frag||1|0|3" "post_fullscreen.vert|vert||0|0|0" "post_bloom_down.frag|frag||1|0|1" "post_bloom_up.frag|frag||1|0|1" diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 7ed4646816..f44ddb67d3 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -12,7 +12,7 @@ options window, without editing those files (see "Tuning it yourself"). |---|---|---| | Texture filtering | mipmaps and anisotropic filtering for world textures | — | | Enhanced lighting | per-pixel model lighting with rim light and, on metal armour, specular highlights | — | -| Dynamic model lights | candles, fires and spells light characters, monsters and NPCs | — | +| Dynamic model lights | candles, fires and spells light characters, monsters, NPCs and world objects per pixel, and the ground as smooth pools instead of patches interpolated between terrain vertices | — | | Light mood | darker baked map light, so the light sources stand out | [light-mood.md](light-mood.md) | | Post-processing | bloom around light effects and per-map colour grading | [post-processing.md](post-processing.md) | | Anti-aliasing | multisampled edges (4 samples, or what `Antialiasing` asks for), alpha-to-coverage for cut-out foliage and fences | — | diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil new file mode 100644 index 0000000000000000000000000000000000000000..a8c6460741dd6c18888a6baeb085a16156cf5383 GIT binary patch literal 7076 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 literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl new file mode 100644 index 0000000000..1c0272b605 --- /dev/null +++ b/src/shaders/compiled/world_lit.frag.msl @@ -0,0 +1,102 @@ +#include +#include + +using namespace metal; + +struct SceneLighting +{ + float4 sceneLightDirection; + float4 sceneLightColor; + float4 diffuseCurve; + float4 rimParameters; + float4 specularParameters; + float4 sceneFogColor; + float4 sceneFogParameters; + float4 cameraPosition; +}; + +struct DynamicLights +{ + uint dynamicLightCount; + float dynamicLightWrap; + uint dynamicWorldLightCount; + uint dynamicLightPadding; + float4 dynamicLightPositionAndRadius[32]; + float4 dynamicLightColor[32]; +}; + +struct FogUniforms +{ + uint fogEnabled; + uint alphaDiscardEnabled; + float alphaThreshold; + uint alphaToCoverage; + float fogStart; + float fogEnd; + float4 fogColor; +}; + +struct main0_out +{ + float4 _entryPointOutput [[color(0)]]; +}; + +struct main0_in +{ + float2 input_uv [[user(locn0)]]; + float4 input_color [[user(locn1)]]; + float input_eyeDepth [[user(locn3)]]; + float3 input_worldPosition [[user(locn4)]]; +}; + +fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _169 [[buffer(2)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]]) +{ + main0_out out = {}; + uint _389 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); + float3 _472; + _472 = float3(0.0); + float3 _474; + for (uint _471 = 0u; _471 < _389; _472 = _474, _471++) + { + float4 _379 = _64.dynamicLightPositionAndRadius[_471]; + float _406 = length(_64.dynamicLightPositionAndRadius[_471].xy - in.input_worldPosition.xy); + if (_406 < _379.w) + { + _474 = _472 + (_64.dynamicLightColor[_471].xyz * ((_379.w - _406) / _379.w)); + } + else + { + _474 = _472; + } + } + float4 _296 = tex.sample(s, in.input_uv); + float4 _275 = _296; + float4 _276 = float4(_296.xyz * fast::clamp(in.input_color.xyz + _472, float3(0.0), float3(1.0)), _275.w * in.input_color.w); + if (_169.alphaToCoverage != 0u) + { + _276.w *= fast::clamp(((_276.w - _169.alphaThreshold) / fast::max(fwidth(_276.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + if (_276.w <= 0.0) + { + discard_fragment(); + } + } + else + { + if ((_169.alphaDiscardEnabled != 0u) && (_276.w <= _169.alphaThreshold)) + { + discard_fragment(); + } + } + if ((_169.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) + { + float4 _357 = _276; + float _439 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; + float3 _366 = mix(_357.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_439) * _439), 0.0, 1.0))); + _276.x = _366.x; + _276.y = _366.y; + _276.z = _366.z; + } + out._entryPointOutput = _276; + return out; +} + diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..6c179f09a621e2a92b899233052df448f37e5387 GIT binary patch literal 5688 zcmaKu>vNq|6^Gv>O=&86jDv$cdgMt%Phu9pV|@&ztnAl9^WhaIN0#=lOb9xozB+HCNHOVx{Vwf@@5+H!5K*S5s9ski=8 ze{{Li=q|TcO5cIbx(B-UZ2JUHwA5HX&zd>!NUzrMy1@szSznn)8E252JpdM^mNorU zCzdriFU{6kzc<}K5!m^4Y@zI7`@ne`*fmZz<{E3gW&JmoGd95Q^9k1*Nu9G-ZM1rw zlk@Fnt9Pj1;~Zii;EtUq>%WaCF;3Hc_O>gp zG3G%mYK$2WiyFnuNi1p<+gPJm)VLi!&W-n+1hWo%JSepiysQ|#Tym$Oeoq+fh6lg&kag?$oosaKvVCGkz=`xr}m_3l?C zeb`@vtWD^zEA^-LUW>JL?}YRT3cp=olh9?vb+)WkOxf8Ac_Mvh%+2%NC4ICr&%NyC zum|!Ul&etWBf<#&1(IcnASMd;!eUfOA`%I6@~US-dF1sZ~k z|7zmnyw{TKEO?%>bF00w_UDtV{}2jwo}*sbITlmDCGqy4dS&ODze4>ujJbQhdS&Na zEPD54WcxYjW?s_zeSep>{{-=UjbXoh1s{7RuLWosM5 z-nx{n@$!tD(t7h#KY!m@Y*;7VRJv2_&C*6 zz`qX9UvVX*zxvQUkmVV%lcTecmF87x;?zC z@2Kn@`JRu#i#gxg`!b9gXeKY|bZQ83^6$6&@%cRFD|f%pB@`HqpNd-R7rp^fjQy)|fSpIDRoDdJT) z<1D!dIhq-rN=n; zDfagxYa@Of%-*>gUfg-Mf1G=;ayhPZvhj34jbooC%o7cy#0JPyvu%8_Yr6w^6lm0Zaxa{d3oKtkj1sx zL5y4BJ%0v@ncWR09{s!rUO(}Oy%&CC>?)Y}OXTI9&cKWL8>qYwp1z&7S}8<=>!_3iLt#tOfW!-t>mq^w=& zKauI>X4Xq$a{~@b_3qKjo+&%y;$P(+oW&R6#lz-z@PWlQ`WzU4{QtTr)JLAbhj(t($87%rp1*Ro)yHhl zbDH1FRWNOW;#<`MZ~4sx8O yk2YfA(}mZ^dkmi*vOd10KH7*m2hm&Z(HAG+jiLTNc6-lV-;3DQ|A%UKLjMB^jUChg literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/world_lit.vert.dxil b/src/shaders/compiled/world_lit.vert.dxil new file mode 100644 index 0000000000000000000000000000000000000000..24afdec73dc2cca7cb7d31e49eb19186ec652a19 GIT binary patch literal 5176 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 +#include + +using namespace metal; + +struct Transform +{ + float4x4 mvp; + float fogStart; + float fogEnd; + float2 fogPad; +}; + +struct main0_out +{ + float2 _entryPointOutput_uv [[user(locn0)]]; + float4 _entryPointOutput_color [[user(locn1)]]; + float _entryPointOutput_fogFactor [[user(locn2)]]; + float _entryPointOutput_eyeDepth [[user(locn3)]]; + float3 _entryPointOutput_worldPosition [[user(locn4)]]; + float4 gl_Position [[position]]; + float gl_ClipDistance [[clip_distance]] [1]; + float gl_ClipDistance_0 [[user(clip0)]]; +}; + +struct main0_in +{ + float3 input_pos [[attribute(0)]]; + float2 input_uv [[attribute(1)]]; + float4 input_color [[attribute(2)]]; +}; + +vertex main0_out main0(main0_in in [[stage_in]], constant Transform& _32 [[buffer(0)]]) +{ + main0_out out = {}; + float4 _151 = _32.mvp * float4(in.input_pos, 1.0); + float4 _188 = _151; + float _165 = abs(_188.w); + float _170 = _32.fogEnd - _32.fogStart; + out.gl_Position = _151; + out._entryPointOutput_uv = in.input_uv; + out._entryPointOutput_color = in.input_color; + out._entryPointOutput_fogFactor = (_170 > 0.001000000047497451305389404296875) ? fast::clamp((_32.fogEnd - _165) / _170, 0.0, 1.0) : 1.0; + out._entryPointOutput_eyeDepth = _165; + out._entryPointOutput_worldPosition = in.input_pos; + out.gl_ClipDistance[0] = _188.w - 1.0; + out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; + return out; +} + diff --git a/src/shaders/compiled/world_lit.vert.spv b/src/shaders/compiled/world_lit.vert.spv new file mode 100644 index 0000000000000000000000000000000000000000..3c1ff72a90575551dcde765d171356e0f61ab1a6 GIT binary patch literal 2304 zcmZXU-D^~55QmS6yKanV{q~}@CzarZCD>1j;zuE07h)rNt7VgH>_W090tI$?0DpI{Fy|ev~deIxf=Q(*_Jh&(PocYbnJMYZAvknd%*pwt2lHsJ5{F|(Q z+mit-Nuo@V!%4N^Q>V_J8tdlsV_$xC*vPHPprY_?OSTpIM*dx@H(QbmU=}O@4IQuy zR=`!z18ZQAzY6j{F0CXR`Foe6f@MGaT&LdZE@Yi0^ePeB{FW}Y;njj$^Fns<$SE2b%V`5)@{p|P>VSGTDQ$*i&+O- zt?2V)qm_47X0m20|86-i=cyGl==aB*wPHT~{+NHLm|ef0PA2Pfc~QeqG28x_#!6$n z(awLc_RYoY`(rL=oyGZ?tlP|+S&O)#;(hw#<`$dn@n)APPcb{+!WmDO-o-bZCPRED zmMr<;J=+1eUySqpw4E&3%&Tp@Wb^H`O@k@!OpznNFY-^&%_sLgV;%C@z@y)Hj6LXg zSBHV0+`TQIcZcQiy!%`}?{3Sj)APN+or&C?H^2U!OwJxhU~=_6XjNni_7d;xSp;1#bS`@SVsMSl^+*ccJ^q&9$#!y%YQ3AEBGW^ZW5yyEfy5_oaA0MtZ0Iqk*Tv zrhg>po|TUxt=-(Qj)Umsx;}-Q)4D%Hrohj5`RBmC&G!W|&O&|+?pbS$eNCWeJ64bE z!ZTU2pGNod+8Ow-$0s6yZ6c0 zg6(U5)6U#o@iXp!EES}&qsYI3cOQc*zX#4&ZqIYTdCHy9Md19-ki|Og0MGbE+g)^R z)*Nj=1)KHEaFe<20nZz+-#!19yd%i_AO-#wyxTqf8EC&vjOTv==Fone?(9XIIo!Y3 zK%0AM4(ojYw678)e+V9cc(>>N0q>vtHQ2Xs%5%Q~`*XJXywe^39i+hDO1$$Cy7n0J z7(E3CL5z8Vu07WE2fF99|3&UeoU;&{I&p?>St1%=H3Yn>F7IegBEB-F#bk zX?uDJ?CB8D@9)sLJPAF&LbnFvv^#TuE6!ZKgLGfi{Y|(l>h8a1)vqG0L%oM|PweFi T@)lSFzPWz+L-2;Gz5#CmU9#XP literal 0 HcmV?d00001 diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl new file mode 100644 index 0000000000..1f17d8d33a --- /dev/null +++ b/src/shaders/world_lit.frag.hlsl @@ -0,0 +1,93 @@ +// world_lit.frag.hlsl — Enhanced per-pixel point lights for the ground: terrain tiles, their layers, +// grass and terrain decals that take the terrain light. Pairs with world_lit.vert.hlsl. +// The vertex colour is the terrain light without the frame's first dynamicWorldLightCount point +// lights; those are added back here per pixel with the terrain light's own falloff, so the ground +// gets the light it always did, smooth instead of interpolated between grid vertices. +// FogUniforms mirrors FogUniform, SceneLighting mu::SceneLightingUniform and DynamicLights +// mu::DynamicLightsUniform (std140). + +Texture2D tex : register(t0, space2); +SamplerState s : register(s0, space2); +cbuffer FogUniforms : register(b0, space3) +{ + uint fogEnabled; + uint alphaDiscardEnabled; + float alphaThreshold; + uint alphaToCoverage; // 1: the pipeline turns alpha into multisample coverage + float fogStart; + float fogEnd; + float4 fogColor; +}; +cbuffer SceneLighting : register(b1, space3) +{ + float4 sceneLightDirection; + float4 sceneLightColor; + float4 diffuseCurve; + float4 rimParameters; + float4 specularParameters; + float4 sceneFogColor; + float4 sceneFogParameters; + float4 cameraPosition; +}; +static const uint MaxDynamicLights = 32; // mu::kMaxDynamicLights +cbuffer DynamicLights : register(b2, space3) +{ + uint dynamicLightCount; // lights used + float dynamicLightWrap; // models only + uint dynamicWorldLightCount; // the first lights: the ones the ground's vertex colour leaves out + uint dynamicLightPadding; + float4 dynamicLightPositionAndRadius[MaxDynamicLights]; + float4 dynamicLightColor[MaxDynamicLights]; +}; +struct FSInput +{ + float4 pos : SV_Position; + float2 uv : TEXCOORD0; + float4 color : TEXCOORD1; + float fogFactor : TEXCOORD2; + float eyeDepth : TEXCOORD3; + float3 worldPosition : TEXCOORD4; +}; + +// Same curve as basic_textured_fog.frag.hlsl and mu::EnhancedFogAmount() (SceneLighting.cpp). +float EnhancedFogAmount(float eyeDepth) +{ + const float scaledDistance = max(eyeDepth - sceneFogParameters.x, 0.0) * sceneFogParameters.z; + return saturate(1.0 - exp(-scaledDistance * scaledDistance)); +} + +// The terrain light's linear falloff over the horizontal distance, as the grid adds it. +float3 WorldDynamicLighting(float3 worldPosition) +{ + float3 light = float3(0.0, 0.0, 0.0); + const uint count = min(min(dynamicWorldLightCount, dynamicLightCount), MaxDynamicLights); + [loop] + for (uint i = 0; i < count; ++i) + { + const float4 positionAndRadius = dynamicLightPositionAndRadius[i]; + const float radius = positionAndRadius.w; + const float horizontalDistance = length(positionAndRadius.xy - worldPosition.xy); + if (horizontalDistance < radius) + light += dynamicLightColor[i].rgb * ((radius - horizontalDistance) / radius); + } + return light; +} + +float4 main(FSInput input) : SV_Target +{ + const float3 light = saturate(input.color.rgb + WorldDynamicLighting(input.worldPosition)); + const float4 texel = tex.Sample(s, input.uv); + float4 color = float4(texel.rgb * light, texel.a * input.color.a); + if (alphaToCoverage) + { + // Anti-aliased cutout, as in basic_textured.frag: coverage keeps the + // texel's translucency; only the alpha test's step becomes a ramp. + const float edge = saturate((color.a - alphaThreshold) / max(fwidth(color.a), 0.0001) + 0.5); + color.a *= edge; + if (color.a <= 0.0) discard; + } + else if (alphaDiscardEnabled && color.a <= alphaThreshold) discard; + if (fogEnabled && sceneFogColor.w > 0.0) + color.rgb = lerp(color.rgb, sceneFogColor.rgb, EnhancedFogAmount(input.eyeDepth)); + return color; +} diff --git a/src/shaders/world_lit.vert.hlsl b/src/shaders/world_lit.vert.hlsl new file mode 100644 index 0000000000..b55bdad242 --- /dev/null +++ b/src/shaders/world_lit.vert.hlsl @@ -0,0 +1,30 @@ +// world_lit.vert.hlsl — basic_textured.vert for the ground lit per pixel (world_lit.frag.hlsl). +// The ground is submitted in world space, so its vertex position is also the fragment's world +// position for the point lights. +cbuffer Transform : register(b0, space1) { float4x4 mvp; float fogStart; float fogEnd; float2 fogPad; }; +struct VSInput { float3 pos : TEXCOORD0; float2 uv : TEXCOORD1; float4 color : TEXCOORD2; }; +struct VSOutput +{ + float4 pos : SV_Position; + float2 uv : TEXCOORD0; + float4 color : TEXCOORD1; + float fogFactor : TEXCOORD2; + float eyeDepth : TEXCOORD3; + float3 worldPosition : TEXCOORD4; + float clipDist : SV_ClipDistance0; +}; +VSOutput main(VSInput input) +{ + VSOutput o; + o.pos = mul(mvp, float4(input.pos, 1.0)); + o.uv = input.uv; + o.color = input.color; + // Near-plane user clip, as in basic_textured.vert. + o.clipDist = o.pos.w - 1.0; + const float dist = abs(o.pos.w); + const float range = fogEnd - fogStart; + o.fogFactor = (range > 0.001) ? saturate((fogEnd - dist) / range) : 1.0; + o.eyeDepth = dist; + o.worldPosition = input.pos; + return o; +} diff --git a/src/source/Render/Lighting/DynamicLightList.cpp b/src/source/Render/Lighting/DynamicLightList.cpp index 04259f1d99..296c4e3c4c 100644 --- a/src/source/Render/Lighting/DynamicLightList.cpp +++ b/src/source/Render/Lighting/DynamicLightList.cpp @@ -12,6 +12,12 @@ void DynamicLightList::Clear() m_displaceableBegin = kCapacity; m_displaceableEnd = kCapacity; m_marking = false; + m_mark = 0; +} + +void DynamicLightList::Mark() +{ + m_mark = m_count; } void DynamicLightList::MarkDisplaceable() @@ -41,6 +47,10 @@ void DynamicLightList::Add(const DynamicLight& light) std::move(m_lights.begin() + static_cast(m_displaceableEnd), m_lights.begin() + static_cast(m_count), m_lights.begin() + static_cast(m_displaceableEnd) - 1); + if (m_mark >= m_displaceableEnd) + { + --m_mark; + } --m_displaceableEnd; --m_count; m_marking = false; @@ -57,6 +67,11 @@ std::span DynamicLightList::Lights() const return {m_lights.data(), m_count}; } +std::span DynamicLightList::LightsSinceMark() const +{ + return Lights().subspan(m_mark); +} + DynamicLightList& FrameDynamicLights() { static DynamicLightList lights; diff --git a/src/source/Render/Lighting/DynamicLightList.h b/src/source/Render/Lighting/DynamicLightList.h index 21a09115ff..57b0376ec4 100644 --- a/src/source/Render/Lighting/DynamicLightList.h +++ b/src/source/Render/Lighting/DynamicLightList.h @@ -26,8 +26,12 @@ class DynamicLightList void MarkDisplaceable(); // Ends the lingering interval; later additions are called lights, never evictable. void EndDisplaceable(); + // Remembers where the lights added from now on start (WorldDynamicLights). + void Mark(); [[nodiscard]] std::span Lights() const; + // The lights added since Mark(), all of them without a mark. + [[nodiscard]] std::span LightsSinceMark() const; // Lights added this frame that did not fit. [[nodiscard]] std::size_t Overflow() const { @@ -42,6 +46,7 @@ class DynamicLightList std::size_t m_displaceableBegin = kCapacity; std::size_t m_displaceableEnd = kCapacity; bool m_marking = false; + std::size_t m_mark = 0; }; // The list the game's terrain light calls record into. diff --git a/src/source/Render/Lighting/DynamicLightSelection.cpp b/src/source/Render/Lighting/DynamicLightSelection.cpp index 3991f774d4..48549a6761 100644 --- a/src/source/Render/Lighting/DynamicLightSelection.cpp +++ b/src/source/Render/Lighting/DynamicLightSelection.cpp @@ -6,6 +6,7 @@ #include #include #include +#include namespace Render::Lighting { @@ -99,6 +100,23 @@ DynamicLightSelection SelectDynamicLights(std::span lights, return selection; } +DynamicLightSelection SelectDynamicLights(const DynamicLightSelection& pinned, + std::span laterLights, const float (&reference)[3]) +{ + const DynamicLightSelection later = SelectDynamicLights(laterLights, reference); + DynamicLightSelection selection = pinned; + const std::size_t pinnedCount = pinned.uniform.lightCount; + const std::size_t added = std::min(later.uniform.lightCount, mu::kMaxDynamicLights - pinnedCount); + std::memcpy(selection.uniform.positionAndRadius + pinnedCount, later.uniform.positionAndRadius, + added * sizeof(later.uniform.positionAndRadius[0])); + std::memcpy(selection.uniform.color + pinnedCount, later.uniform.color, added * sizeof(later.uniform.color[0])); + selection.uniform.lightCount = static_cast(pinnedCount + added); + selection.uniform.worldLightCount = static_cast(pinnedCount); + selection.brighteningLights += later.brighteningLights; + selection.dropped += later.brighteningLights - added; + return selection; +} + bool DroppedLightReportLimiter::ShouldReport(std::chrono::steady_clock::time_point now) { if (m_lastReport && now - *m_lastReport < kDroppedLightReportInterval) diff --git a/src/source/Render/Lighting/DynamicLightSelection.h b/src/source/Render/Lighting/DynamicLightSelection.h index 79562b681c..3491e1a0da 100644 --- a/src/source/Render/Lighting/DynamicLightSelection.h +++ b/src/source/Render/Lighting/DynamicLightSelection.h @@ -32,6 +32,12 @@ struct DynamicLightSelection [[nodiscard]] DynamicLightSelection SelectDynamicLights(std::span lights, const float (&reference)[3]); +// The pinned selection's lights first, as its worldLightCount lights, then the selection of the +// lights added after it in the slots left. +[[nodiscard]] DynamicLightSelection SelectDynamicLights(const DynamicLightSelection& pinned, + std::span laterLights, + const float (&reference)[3]); + // Shortest time between two log lines about dropped lights. inline constexpr std::chrono::minutes kDroppedLightReportInterval{1}; diff --git a/src/source/Render/Lighting/WorldDynamicLights.cpp b/src/source/Render/Lighting/WorldDynamicLights.cpp new file mode 100644 index 0000000000..55e1464db3 --- /dev/null +++ b/src/source/Render/Lighting/WorldDynamicLights.cpp @@ -0,0 +1,30 @@ +#include "Render/Lighting/WorldDynamicLights.h" + +#include "Render/Lighting/DynamicLightList.h" + +namespace Render::Lighting +{ + +void WorldDynamicLights::Clear() +{ + m_pinned = false; +} + +void WorldDynamicLights::Pin(DynamicLightList& lights, const float (&reference)[3]) +{ + if (m_pinned) + { + return; + } + m_selection = SelectDynamicLights(lights.Lights(), reference); + lights.Mark(); + m_pinned = true; +} + +WorldDynamicLights& FrameWorldDynamicLights() +{ + static WorldDynamicLights lights; + return lights; +} + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/WorldDynamicLights.h b/src/source/Render/Lighting/WorldDynamicLights.h new file mode 100644 index 0000000000..7d165ef5ea --- /dev/null +++ b/src/source/Render/Lighting/WorldDynamicLights.h @@ -0,0 +1,39 @@ +// WorldDynamicLights.h: the frame's point lights the ground applies per pixel. +#pragma once + +#include "Render/Lighting/DynamicLightSelection.h" + +namespace Render::Lighting +{ + +class DynamicLightList; + +// The ground's vertex light leaves out exactly the lights pinned here and the ground's shader adds +// exactly these back per pixel, so they are chosen once per frame, before the ground is drawn, and +// kept even when lights added later would rank higher. Cleared with the frame's light list. +class WorldDynamicLights +{ +public: + void Clear(); + // Pins the selection SelectDynamicLights makes of `lights` at `reference` and marks the list, + // so the lights added after it are told apart. A second call in the frame keeps the first pin. + void Pin(DynamicLightList& lights, const float (&reference)[3]); + + [[nodiscard]] bool IsPinned() const + { + return m_pinned; + } + [[nodiscard]] const DynamicLightSelection& Selection() const + { + return m_selection; + } + +private: + DynamicLightSelection m_selection{}; + bool m_pinned = false; +}; + +// The pin the game's ground and its point-light upload share. +[[nodiscard]] WorldDynamicLights& FrameWorldDynamicLights(); + +} // namespace Render::Lighting diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index 4ed8285b06..7baef0cd03 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -428,6 +428,13 @@ class IMuRenderer // does in Classic. Scopes nest; use ScopedBloomExclusion. virtual void BeginBloomExclusion() {} virtual void EndBloomExclusion() {} + + // 3D draws between BeginWorldLitGeometry and EndWorldLitGeometry are ground lit by the + // terrain light: with Enhanced lighting, the frame's first DynamicLightsUniform::worldLightCount + // point lights are added to their vertex colour per pixel. Scopes nest; use + // ScopedWorldLitGeometry. + virtual void BeginWorldLitGeometry() {} + virtual void EndWorldLitGeometry() {} // True while a bloom exclusion is open: what is queued now and drawn later // (a character's glow sprites) can be drawn inside one too. [[nodiscard]] virtual bool IsBloomExcluded() const @@ -862,6 +869,20 @@ class ScopedBloomExclusion ScopedBloomExclusion(const ScopedBloomExclusion&) = delete; ScopedBloomExclusion& operator=(const ScopedBloomExclusion&) = delete; }; +class ScopedWorldLitGeometry +{ +public: + ScopedWorldLitGeometry() + { + GetRenderer().BeginWorldLitGeometry(); + } + ~ScopedWorldLitGeometry() + { + GetRenderer().EndWorldLitGeometry(); + } + ScopedWorldLitGeometry(const ScopedWorldLitGeometry&) = delete; + ScopedWorldLitGeometry& operator=(const ScopedWorldLitGeometry&) = delete; +}; // The draws recorded in its lifetime may be reordered (BeginReorderableDraws). class ScopedReorderableDraws { diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 1e10877624..e12e1d0e24 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -604,6 +604,8 @@ static WorldPipelines s_pipelinesSkinnedLit; static WorldPipelines s_pipelinesSkinnedWeighted; static WorldPipelines s_pipelinesSkinnedWeightedEnhancedFog; static WorldPipelines s_pipelinesSkinnedWeightedLit; +// The ground lit per pixel by the frame's first point lights (BeginWorldLitGeometry). +static WorldPipelines s_pipelinesWorldLit; static bool s_enhancedLightingAvailable = false; static bool s_enhancedLightingEnabled = false; // The frame's scene lighting, pushed once per render pass to fragment uniform slot 1. @@ -619,6 +621,7 @@ static mu::PostProcessingLook s_postProcessingLook{}; static mu::PostProcessingView s_postProcessingView = mu::PostProcessingView::Scene; static Render::PostProcessing::SceneBoundary s_sceneBoundary; static int s_bloomExclusionDepth = 0; +static int s_worldLitGeometryDepth = 0; // Alpha-to-coverage variants of the depth-writing world pipelines (each world set's culled and // no-cull states), used while anti-aliasing is on by alpha-tested cutout draws (foliage, hair, @@ -1022,8 +1025,8 @@ static void PushReplayFragmentUniforms(const FogUniform& uniforms, Render::SdlGp ++s_dbgFragmentUniformPushesThisFrame; } -// Classic fragment shaders declare one uniform buffer and never read slots 1 and 2; only -// skinned_lit.frag reads slot 2. +// Classic fragment shaders declare one uniform buffer and never read slots 1 and 2; only the +// skinned_lit and world_lit fragment shaders read slot 2. static void PushSceneLightingUniforms() { SDL_PushGPUFragmentUniformData(s_cmdBuf, k_FragmentUniformSlotSceneLighting, &s_sceneLightingUniform, @@ -1183,6 +1186,8 @@ static SDL_GPUShader* s_vertShaderSkinnedShadow = nullptr; // skinned_shadow.ver static SDL_GPUShader* s_vertShaderSkinnedWeightedShadow = nullptr; // skinned_weighted_shadow.vert static SDL_GPUShader* s_fragShaderTexFog = nullptr; // basic_textured_fog.frag (Enhanced, optional) static SDL_GPUShader* s_fragShaderLit = nullptr; // skinned_lit.frag (Enhanced, optional) +static SDL_GPUShader* s_vertShaderWorldLit = nullptr; // world_lit.vert (Enhanced, optional) +static SDL_GPUShader* s_fragShaderWorldLit = nullptr; // world_lit.frag (Enhanced, optional) // Post-processing (optional): without them post-processing is unavailable. static SDL_GPUShader* s_vertShaderPostFullscreen = nullptr; // post_fullscreen.vert static SDL_GPUShader* s_fragShaderBloomDown = nullptr; // post_bloom_down.frag @@ -2183,6 +2188,7 @@ class MuRendererSDLGpu : public IMuRenderer s_bloomExclusionDepth); s_bloomExclusionDepth = 0; } + s_worldLitGeometryDepth = 0; s_replayedCmdCount = 0u; s_mainColorPassOpenedThisFrame = false; @@ -3641,6 +3647,19 @@ class MuRendererSDLGpu : public IMuRenderer } } + void BeginWorldLitGeometry() override + { + ++s_worldLitGeometryDepth; + } + + void EndWorldLitGeometry() override + { + if (s_worldLitGeometryDepth > 0) + { + --s_worldLitGeometryDepth; + } + } + [[nodiscard]] bool IsBloomExcluded() const override { return s_bloomExclusionDepth > 0; @@ -5345,7 +5364,9 @@ class MuRendererSDLGpu : public IMuRenderer [[nodiscard]] SDL_GPUGraphicsPipeline* GetActive3DPipeline() const { - const WorldPipelines& set = UsesEnhancedLighting() ? s_pipelines3DEnhancedFog : s_pipelines3D; + const WorldPipelines& set = !UsesEnhancedLighting() ? s_pipelines3D + : s_worldLitGeometryDepth > 0 ? s_pipelinesWorldLit + : s_pipelines3DEnhancedFog; return set.Select(static_cast(GetActivePipelineIndex()), m_depthTestEnabled, m_depthMaskEnabled, m_cullFaceEnabled && !s_disableD3D12Culling); } @@ -5633,6 +5654,10 @@ class MuRendererSDLGpu : public IMuRenderer // skinned_lit.frag also reads the frame's point lights, DynamicLights (b2). // skinned_lit.frag samples the texture and the normal map (k_FragmentSamplerSlotNormalMap). s_fragShaderLit = createShader("skinned_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 3, /*fatal=*/false); + // The ground lit per pixel: the Transform (b0) of basic_textured.vert, and the uniforms of skinned_lit.frag. + s_vertShaderWorldLit = createShader("world_lit", "vert", SDL_GPU_SHADERSTAGE_VERTEX, 0, 0, 1, /*fatal=*/false); + s_fragShaderWorldLit = + createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 3, /*fatal=*/false); // Post-processing — non-fatal: without them post-processing is unavailable. // Bloom passes: source texture (t0) and BloomUniforms (b0); composite: scene, bloom and @@ -5711,8 +5736,8 @@ class MuRendererSDLGpu : public IMuRenderer SDL_ReleaseGPUShader(s_device, s_fragShaderLit); s_fragShaderLit = nullptr; } - for (SDL_GPUShader** shader : - {&s_vertShaderPostFullscreen, &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite}) + for (SDL_GPUShader** shader : {&s_vertShaderWorldLit, &s_fragShaderWorldLit, &s_vertShaderPostFullscreen, + &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite}) { if (*shader) { @@ -5730,6 +5755,7 @@ class MuRendererSDLGpu : public IMuRenderer { TwoDimensional, ThreeDimensional, + ThreeDimensionalWorldLit, // the 3D layout, with world_lit.vert Skinned, SkinnedWeighted, // SkinnedWeightedVertex3D, with skinned_weighted.vert SkinnedShadow, // the skinned layout, with skinned_shadow.vert @@ -5741,6 +5767,7 @@ class MuRendererSDLGpu : public IMuRenderer Textured, TexturedEnhancedFog, SkinnedLit, + WorldLit, }; struct PipelineBuildDescription @@ -5795,6 +5822,8 @@ class MuRendererSDLGpu : public IMuRenderer FragmentShader::TexturedEnhancedFog, WorldSetFamily::EnhancedLighting}, {&s_pipelinesSkinnedWeightedLit, "skinned-weighted-lit", VertexLayout::SkinnedWeighted, FragmentShader::SkinnedLit, WorldSetFamily::EnhancedLighting}, + {&s_pipelinesWorldLit, "world-lit", VertexLayout::ThreeDimensionalWorldLit, FragmentShader::WorldLit, + WorldSetFamily::EnhancedLighting}, }; return sets; } @@ -5842,6 +5871,8 @@ class MuRendererSDLGpu : public IMuRenderer return s_fragShaderTexFog; case FragmentShader::SkinnedLit: return s_fragShaderLit; + case FragmentShader::WorldLit: + return s_fragShaderWorldLit; case FragmentShader::Textured: break; } @@ -5856,6 +5887,8 @@ class MuRendererSDLGpu : public IMuRenderer return "basic_textured_fog.frag"; case FragmentShader::SkinnedLit: return "skinned_lit.frag"; + case FragmentShader::WorldLit: + return "world_lit.frag"; case FragmentShader::Textured: break; } @@ -5930,7 +5963,8 @@ class MuRendererSDLGpu : public IMuRenderer vtxBufDesc.pitch = sizeof(Vertex2D); numAttribs = 3; } - else if (description.vertexLayout == VertexLayout::ThreeDimensional) + else if (description.vertexLayout == VertexLayout::ThreeDimensional || + description.vertexLayout == VertexLayout::ThreeDimensionalWorldLit) { // Vertex3D mapped to the 2D shader's input locations: // location 0 (TEXCOORD0 → pos): float3 pos — shader reads float2 (x,y), z dropped @@ -6055,11 +6089,12 @@ class MuRendererSDLGpu : public IMuRenderer SDL_GPUGraphicsPipelineCreateInfo pipelineInfo{}; pipelineInfo.vertex_shader = - description.vertexLayout == VertexLayout::Skinned ? s_vertShaderSkinned - : description.vertexLayout == VertexLayout::SkinnedWeighted ? s_vertShaderSkinnedWeighted - : description.vertexLayout == VertexLayout::SkinnedShadow ? s_vertShaderSkinnedShadow - : description.vertexLayout == VertexLayout::SkinnedWeightedShadow ? s_vertShaderSkinnedWeightedShadow - : s_vertShader2D; + description.vertexLayout == VertexLayout::Skinned ? s_vertShaderSkinned + : description.vertexLayout == VertexLayout::SkinnedWeighted ? s_vertShaderSkinnedWeighted + : description.vertexLayout == VertexLayout::SkinnedShadow ? s_vertShaderSkinnedShadow + : description.vertexLayout == VertexLayout::SkinnedWeightedShadow ? s_vertShaderSkinnedWeightedShadow + : description.vertexLayout == VertexLayout::ThreeDimensionalWorldLit ? s_vertShaderWorldLit + : s_vertShader2D; pipelineInfo.fragment_shader = GetFragmentShader(description.fragmentShader); pipelineInfo.vertex_input_state = vtxInputState; pipelineInfo.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; @@ -6087,15 +6122,18 @@ class MuRendererSDLGpu : public IMuRenderer static void LogPipelineFailure(const char* driverName, const PipelineBuildResult& result, bool required) { const PipelineBuildDescription& description = result.description; - const char* layoutName = description.vertexLayout == VertexLayout::TwoDimensional ? "2D" - : description.vertexLayout == VertexLayout::ThreeDimensional ? "3D" - : "skinned"; + const char* layoutName = description.vertexLayout == VertexLayout::TwoDimensional ? "2D" + : description.vertexLayout == VertexLayout::ThreeDimensional || + description.vertexLayout == VertexLayout::ThreeDimensionalWorldLit + ? "3D" + : "skinned"; const char* vertexShaderName = - description.vertexLayout == VertexLayout::Skinned ? "skinned_textured.vert" - : description.vertexLayout == VertexLayout::SkinnedWeighted ? "skinned_weighted.vert" - : description.vertexLayout == VertexLayout::SkinnedShadow ? "skinned_shadow.vert" - : description.vertexLayout == VertexLayout::SkinnedWeightedShadow ? "skinned_weighted_shadow.vert" - : "basic_textured.vert"; + description.vertexLayout == VertexLayout::Skinned ? "skinned_textured.vert" + : description.vertexLayout == VertexLayout::SkinnedWeighted ? "skinned_weighted.vert" + : description.vertexLayout == VertexLayout::SkinnedShadow ? "skinned_shadow.vert" + : description.vertexLayout == VertexLayout::SkinnedWeightedShadow ? "skinned_weighted_shadow.vert" + : description.vertexLayout == VertexLayout::ThreeDimensionalWorldLit ? "world_lit.vert" + : "basic_textured.vert"; const char* fragmentShaderName = GetFragmentShaderName(description.fragmentShader); const char* cullMode = description.cullFaceEnabled ? "back" : "none"; if (required) diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index 565557292d..6310649663 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -100,7 +100,9 @@ struct DynamicLightsUniform { std::uint32_t lightCount = 0; // lights used float wrap = kDefaultDynamicWrap; // see WrappedDiffuse() - std::uint32_t padding[2]{}; + // The first lights, which the ground's vertex colour leaves out (ScopedWorldLitGeometry). + std::uint32_t worldLightCount = 0; + std::uint32_t padding = 0; float positionAndRadius[kMaxDynamicLights][4]; // xyz world position, w radius in world units float color[kMaxDynamicLights][4]; // rgb, w unused }; diff --git a/src/source/Render/Terrain/ZzzLodTerrain.cpp b/src/source/Render/Terrain/ZzzLodTerrain.cpp index 5b5d72b8a9..12edf70456 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.cpp +++ b/src/source/Render/Terrain/ZzzLodTerrain.cpp @@ -32,6 +32,7 @@ #include "Render/Lighting/DynamicLightList.h" #include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Lighting/LightMoodSetting.h" +#include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" #include "Render/Terrain/TerrainLightGrid.h" #include "Scenes/SceneCore.h" @@ -40,6 +41,8 @@ #include #include +#include +#include #include "GameLogic/Events/CSChaosCastle.h" #include "GameLogic/Events/Cinematic/CMVP1stDirection.h" @@ -1394,6 +1397,61 @@ inline void Interpolation(int mx, int my) } } +// The terrain light without the brightening part of the frame's pinned point lights +// (WorldDynamicLights): the ground lit per pixel adds that part back in its shader. +static vec3_t GroundTerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; +static bool s_groundLightBuilt = false; +// The light the ground's faces take: GroundTerrainLight inside a lit GroundLightScope. +static vec3_t* s_faceLight = PrimaryTerrainLight; + +extern int FrustrumBoundMinX, FrustrumBoundMinY, FrustrumBoundMaxX, FrustrumBoundMaxY; + +static void BuildGroundLight() +{ + for (int yi = FrustrumBoundMinY; yi <= FrustrumBoundMaxY + 3; ++yi) + { + for (int xi = FrustrumBoundMinX; xi <= FrustrumBoundMaxX + 3; ++xi) + { + const int index = TERRAIN_INDEX_REPEAT(xi, yi); + VectorCopy(PrimaryTerrainLight[index], GroundTerrainLight[index]); + } + } + const mu::DynamicLightsUniform& lights = Render::Lighting::FrameWorldDynamicLights().Selection().uniform; + for (std::uint32_t i = 0; i < lights.lightCount; ++i) + { + const float removed[3] = {-lights.color[i][0], -lights.color[i][1], -lights.color[i][2]}; + const int range = static_cast(std::lround(lights.positionAndRadius[i][3] / TERRAIN_SCALE)); + Render::Terrain::LightGrid::AddLight(GroundTerrainLight, lights.positionAndRadius[i][0], + lights.positionAndRadius[i][1], removed, range); + } + s_groundLightBuilt = true; +} + +// While alive, the ground's faces take the ground light and draw lit per pixel, once the frame's +// ground light is built and `lit` holds; otherwise they keep the terrain light. +class GroundLightScope +{ +public: + explicit GroundLightScope(bool lit) : m_previous(s_faceLight) + { + if (lit && s_groundLightBuilt) + { + s_faceLight = GroundTerrainLight; + m_worldLit.emplace(); + } + } + ~GroundLightScope() + { + s_faceLight = m_previous; + } + GroundLightScope(const GroundLightScope&) = delete; + GroundLightScope& operator=(const GroundLightScope&) = delete; + +private: + vec3_t* m_previous; + std::optional m_worldLit; +}; + void RenderFace(int Texture, int mx, int my) { if (gMapManager.WorldActive == WD_39KANTURU_3RD) @@ -1459,10 +1517,10 @@ void RenderFace(int Texture, int mx, int my) return {pos[0], pos[1], pos[2], 0.f, 0.f, 1.f, tc[0], tc[1], mu::PackABGR(light[0], light[1], light[2], 1.f)}; }; - const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], PrimaryTerrainLight[TerrainIndex1]); - const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], PrimaryTerrainLight[TerrainIndex2]); - const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], PrimaryTerrainLight[TerrainIndex3]); - const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], PrimaryTerrainLight[TerrainIndex4]); + const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], s_faceLight[TerrainIndex1]); + const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], s_faceLight[TerrainIndex2]); + const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], s_faceLight[TerrainIndex3]); + const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], s_faceLight[TerrainIndex4]); const mu::Vertex3D vertices[4] = {v0, v1, v2, v3}; mu::GetRenderer().RenderQuad3D(vertices, 0u); } @@ -1483,10 +1541,10 @@ void RenderFace_After(int Texture, int mx, int my) return {pos[0], pos[1], pos[2], 0.f, 0.f, 1.f, tc[0], tc[1], mu::PackABGR(light[0], light[1], light[2], 1.f)}; }; - const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], PrimaryTerrainLight[TerrainIndex1]); - const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], PrimaryTerrainLight[TerrainIndex2]); - const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], PrimaryTerrainLight[TerrainIndex3]); - const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], PrimaryTerrainLight[TerrainIndex4]); + const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], s_faceLight[TerrainIndex1]); + const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], s_faceLight[TerrainIndex2]); + const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], s_faceLight[TerrainIndex3]); + const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], s_faceLight[TerrainIndex4]); const mu::Vertex3D vertices[4] = {v0, v1, v2, v3}; mu::GetRenderer().RenderQuad3D(vertices, 0u); } @@ -1498,6 +1556,7 @@ struct LayerFace int texture; bool blend; mu::Vertex3D vertices[4]; + bool groundLit = false; // coloured by the ground light (GroundLightScope) }; static std::vector s_layerFaces; @@ -1508,6 +1567,7 @@ static void RenderLayerFaces() EnableDepthTest(); for (const LayerFace& face : s_layerFaces) { + const GroundLightScope ground(face.groundLit); if (face.blend) EnableAlphaBlend(); else @@ -1525,11 +1585,15 @@ void RenderFaceAlpha(int Texture, int mx, int my) return {pos[0], pos[1], pos[2], 0.f, 0.f, 1.f, tc[0], tc[1], mu::PackABGR(light[0], light[1], light[2], alpha)}; }; - const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], PrimaryTerrainLight[TerrainIndex1], TerrainMappingAlpha[TerrainIndex1]); - const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], PrimaryTerrainLight[TerrainIndex2], TerrainMappingAlpha[TerrainIndex2]); - const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], PrimaryTerrainLight[TerrainIndex3], TerrainMappingAlpha[TerrainIndex3]); - const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], PrimaryTerrainLight[TerrainIndex4], TerrainMappingAlpha[TerrainIndex4]); - s_layerFaces.push_back({Texture, false, {v0, v1, v2, v3}}); + const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], s_faceLight[TerrainIndex1], + TerrainMappingAlpha[TerrainIndex1]); + const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], s_faceLight[TerrainIndex2], + TerrainMappingAlpha[TerrainIndex2]); + const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], s_faceLight[TerrainIndex3], + TerrainMappingAlpha[TerrainIndex3]); + const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], s_faceLight[TerrainIndex4], + TerrainMappingAlpha[TerrainIndex4]); + s_layerFaces.push_back({Texture, false, {v0, v1, v2, v3}, s_faceLight == GroundTerrainLight}); } void RenderFaceBlend(int Texture, int mx, int my) @@ -1730,14 +1794,10 @@ void RenderTerrainFace(float xf, float yf, int xi, int yi, float lodf) return {pos[0], pos[1], pos[2], 0.f, 0.f, 1.f, tc[0], tc[1], mu::PackABGR(light[0], light[1], light[2], 1.f)}; }; - const mu::Vertex3D v0 = - MakeVert(TerrainVertex[0], TerrainTextureCoord[0], PrimaryTerrainLight[TerrainIndex1]); - const mu::Vertex3D v1 = - MakeVert(TerrainVertex[1], TerrainTextureCoord[1], PrimaryTerrainLight[TerrainIndex2]); - const mu::Vertex3D v2 = - MakeVert(TerrainVertex[2], TerrainTextureCoord[2], PrimaryTerrainLight[TerrainIndex3]); - const mu::Vertex3D v3 = - MakeVert(TerrainVertex[3], TerrainTextureCoord[3], PrimaryTerrainLight[TerrainIndex4]); + const mu::Vertex3D v0 = MakeVert(TerrainVertex[0], TerrainTextureCoord[0], s_faceLight[TerrainIndex1]); + const mu::Vertex3D v1 = MakeVert(TerrainVertex[1], TerrainTextureCoord[1], s_faceLight[TerrainIndex2]); + const mu::Vertex3D v2 = MakeVert(TerrainVertex[2], TerrainTextureCoord[2], s_faceLight[TerrainIndex3]); + const mu::Vertex3D v3 = MakeVert(TerrainVertex[3], TerrainTextureCoord[3], s_faceLight[TerrainIndex4]); const mu::Vertex3D vertices[4] = {v0, v1, v2, v3}; mu::GetRenderer().RenderQuad3D(vertices, 0u); @@ -1947,13 +2007,14 @@ void RenderTerrainBitmapTile(int Texture, float xf, float yf, float lodf, int lo Vector(sx + TileScale, sy + TileScale, BackTerrainHeight[TerrainIndex3] + Height, TerrainVertex[2]); Vector(sx, sy + TileScale, BackTerrainHeight[TerrainIndex4] + Height, TerrainVertex[3]); + const GroundLightScope ground(LightEnable); vec3_t Light[4]; if (LightEnable) { - VectorCopy(PrimaryTerrainLight[TerrainIndex1], Light[0]); - VectorCopy(PrimaryTerrainLight[TerrainIndex2], Light[1]); - VectorCopy(PrimaryTerrainLight[TerrainIndex3], Light[2]); - VectorCopy(PrimaryTerrainLight[TerrainIndex4], Light[3]); + VectorCopy(s_faceLight[TerrainIndex1], Light[0]); + VectorCopy(s_faceLight[TerrainIndex2], Light[1]); + VectorCopy(s_faceLight[TerrainIndex3], Light[2]); + VectorCopy(s_faceLight[TerrainIndex4], Light[3]); } mu::Vertex3D verts[4]; @@ -2820,6 +2881,8 @@ extern int EnableEvent; void InitTerrainLight() { Render::Lighting::FrameDynamicLights().Clear(); + Render::Lighting::FrameWorldDynamicLights().Clear(); + s_groundLightBuilt = false; if (UseLightHistory()) { Render::Lighting::FrameLightHistory().BeginTick(); @@ -3325,8 +3388,16 @@ void RenderTerrain(bool EditFlag) InitCollisionDetectLineToFace(); } + if (!EditFlag && Render::Lighting::FrameWorldDynamicLights().IsPinned() && !s_groundLightBuilt) + { + BuildGroundLight(); + } + TerrainFlag = TERRAIN_MAP_NORMAL; - RenderTerrainFrustrum(EditFlag); + { + const GroundLightScope ground(!EditFlag); + RenderTerrainFrustrum(EditFlag); + } RenderLayerFaces(); // if (EditFlag && SelectFlag) @@ -3343,6 +3414,7 @@ void RenderTerrain(bool EditFlag) if (TerrainGrassEnable && gMapManager.WorldActive != WD_7ATLANSE && !IsDoppelGanger3()) { TerrainFlag = TERRAIN_MAP_GRASS; + const GroundLightScope ground(true); RenderTerrainFrustrum(EditFlag); } #ifdef _EDITOR @@ -3364,6 +3436,7 @@ void RenderTerrain_After(bool EditFlag) return; TerrainFlag = TERRAIN_MAP_NORMAL; + const GroundLightScope ground(!EditFlag); RenderTerrainFrustrum_After(EditFlag); } diff --git a/src/source/Scenes/CharacterScene.cpp b/src/source/Scenes/CharacterScene.cpp index 5f628010ab..22144cde71 100644 --- a/src/source/Scenes/CharacterScene.cpp +++ b/src/source/Scenes/CharacterScene.cpp @@ -339,6 +339,7 @@ void NewMoveCharacterScene() MoveCharacterSceneState(); PlaceCharactersForDraw(); CullWorld(); + Scenes::Lighting::PinWorldDynamicLights(); } /** diff --git a/src/source/Scenes/LoginScene.cpp b/src/source/Scenes/LoginScene.cpp index 219ccfae2c..cdf62e4412 100644 --- a/src/source/Scenes/LoginScene.cpp +++ b/src/source/Scenes/LoginScene.cpp @@ -326,7 +326,10 @@ static void UpdateLogInSceneView() ResetFrustrumBoundsFullTerrain(); // Behind the credits the world is not drawn. if (!g_CreditWin.IsVisible()) + { CullWorld(); + Scenes::Lighting::PinWorldDynamicLights(); + } } void NewMoveLogInScene() @@ -431,7 +434,10 @@ bool NewRenderLogInScene(HDC hDC) if (!g_CreditWin.IsVisible()) { - { FRAME_PROFILE(Terrain); RenderTerrain(false); } + { + FRAME_PROFILE(Terrain); + RenderTerrain(false); + } { FRAME_PROFILE(Characters); RenderCharactersClient(); } { FRAME_PROFILE(Objects); RenderMount(); } { diff --git a/src/source/Scenes/MainScene.cpp b/src/source/Scenes/MainScene.cpp index 9290e6ccd9..af66a44513 100644 --- a/src/source/Scenes/MainScene.cpp +++ b/src/source/Scenes/MainScene.cpp @@ -354,6 +354,7 @@ static void UpdateMainSceneView() CullWorld(); // The frame's lights, from every light the update added; the draw only shows them. AddFrameHistoryLights(); + Scenes::Lighting::PinWorldDynamicLights(); } /** @@ -579,7 +580,10 @@ static void RenderGameWorldPass(BYTE& byWaterMap, int width, int height) if (gMapManager.WorldActive == WD_39KANTURU_3RD) { if (!g_Direction.m_CKanturu.IsMayaScene()) - { FRAME_PROFILE(Terrain); RenderTerrain(false); } + { + FRAME_PROFILE(Terrain); + RenderTerrain(false); + } } else if (gMapManager.WorldActive != WD_10HEAVEN && gMapManager.WorldActive != -1) @@ -591,7 +595,10 @@ static void RenderGameWorldPass(BYTE& byWaterMap, int width, int height) Render::Drawing::ScopedReorderableDraws reorderable; RenderObjects(); } - { FRAME_PROFILE(Terrain); RenderTerrain(false); } + { + FRAME_PROFILE(Terrain); + RenderTerrain(false); + } } } diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index c363739a44..83b4005903 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -10,6 +10,7 @@ #include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Lighting/EnhancedLightingSetting.h" #include "Render/Lighting/LightMoodSetting.h" +#include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" #include "Render/Renderer/MuRenderer.h" #include "Render/Renderer/SceneLighting.h" @@ -56,6 +57,17 @@ void SubmitSceneLighting() mu::GetRenderer().SetSceneLighting(lighting); } +void PinWorldDynamicLights() +{ + if (!Render::Lighting::DynamicLightsActive()) + { + return; + } + float reference[3]; + SelectionReference(reference); + Render::Lighting::FrameWorldDynamicLights().Pin(Render::Lighting::FrameDynamicLights(), reference); +} + void SubmitDynamicLights() { if (!Render::Lighting::DynamicLightsActive()) @@ -65,10 +77,12 @@ void SubmitDynamicLights() } const Render::Lighting::DynamicLightList& lights = Render::Lighting::FrameDynamicLights(); + const Render::Lighting::WorldDynamicLights& world = Render::Lighting::FrameWorldDynamicLights(); float reference[3]; SelectionReference(reference); Render::Lighting::DynamicLightSelection selection = - Render::Lighting::SelectDynamicLights(lights.Lights(), reference); + world.IsPinned() ? Render::Lighting::SelectDynamicLights(world.Selection(), lights.LightsSinceMark(), reference) + : Render::Lighting::SelectDynamicLights(lights.Lights(), reference); selection.uniform.wrap = Render::Look::Value(Data::Maps::LookValue::DynamicWrap); mu::GetRenderer().SetDynamicLights(selection.uniform); diff --git a/src/source/Scenes/SceneLightingSetup.h b/src/source/Scenes/SceneLightingSetup.h index 3b3f3808e2..be124d86c5 100644 --- a/src/source/Scenes/SceneLightingSetup.h +++ b/src/source/Scenes/SceneLightingSetup.h @@ -12,4 +12,8 @@ void SubmitSceneLighting(); // count too; the renderer applies them when it replays the frame. void SubmitDynamicLights(); +// The point lights the ground applies per pixel (Enhanced dynamic lights), from the lights the update +// recorded. Call at the end of the update, after the view and the cull; the draw only reads them. +void PinWorldDynamicLights(); + } // namespace Scenes::Lighting diff --git a/tests/render/CMakeLists.txt b/tests/render/CMakeLists.txt index 164a105292..b9ecae5715 100644 --- a/tests/render/CMakeLists.txt +++ b/tests/render/CMakeLists.txt @@ -235,6 +235,7 @@ mu_add_test( ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/DynamicLightHistory.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/DynamicLightList.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/DynamicLightSelection.cpp + ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/WorldDynamicLights.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Terrain/TerrainLightGrid.cpp ) diff --git a/tests/render/test_dynamic_lights.cpp b/tests/render/test_dynamic_lights.cpp index c352452256..98079d9057 100644 --- a/tests/render/test_dynamic_lights.cpp +++ b/tests/render/test_dynamic_lights.cpp @@ -4,6 +4,7 @@ #include "Core/Globals/_define.h" #include "Render/Lighting/DynamicLightList.h" #include "Render/Lighting/DynamicLightSelection.h" +#include "Render/Lighting/WorldDynamicLights.h" #include "Render/Terrain/TerrainLightGrid.h" #include @@ -312,6 +313,77 @@ TEST_CASE("over the cap the lights contributing most at the hero win [render][dy } } +TEST_CASE("the lights added after a mark stay apart when a lingering light gives way [render][dynamic_lights]") +{ + DynamicLightList frameLights; + CHECK(frameLights.LightsSinceMark().empty()); + frameLights.MarkDisplaceable(); + for (std::size_t i = 0; i + 1 < DynamicLightList::kCapacity; ++i) + { + frameLights.Add(MakeLight(static_cast(i), 0.f, 1.f, 1.f, 1.f, 1)); + } + frameLights.EndDisplaceable(); + CHECK(frameLights.LightsSinceMark().size() == DynamicLightList::kCapacity - 1); + + frameLights.Mark(); + frameLights.Add(MakeLight(5000.f, 0.f, 1.f, 1.f, 1.f, 1)); + // The list is full: the last lingering light gives way to this one. + frameLights.Add(MakeLight(6000.f, 0.f, 1.f, 1.f, 1.f, 1)); + + REQUIRE(frameLights.LightsSinceMark().size() == 2); + CHECK(frameLights.LightsSinceMark()[0].position[0] == 5000.f); + CHECK(frameLights.LightsSinceMark()[1].position[0] == 6000.f); +} + +TEST_CASE("the ground's pinned lights come first and later lights fill the slots left [render][dynamic_lights]") +{ + const float hero[3] = {1000.f, 1000.f, 0.f}; + const std::vector early = {MakeLight(1100.f, 1000.f, 0.5f, 0.5f, 0.5f, 3), + MakeLight(1000.f, 1000.f, 1.f, 1.f, 1.f, 3)}; + const std::vector later = {MakeLight(1000.f, 1000.f, 2.f, 2.f, 2.f, 3)}; + + const Render::Lighting::DynamicLightSelection pinned = Render::Lighting::SelectDynamicLights(early, hero); + const Render::Lighting::DynamicLightSelection selection = + Render::Lighting::SelectDynamicLights(pinned, later, hero); + + REQUIRE(selection.uniform.lightCount == 3); + CHECK(selection.uniform.worldLightCount == 2); + CHECK(selection.uniform.positionAndRadius[0][0] == 1000.f); + CHECK(selection.uniform.positionAndRadius[1][0] == 1100.f); + CHECK(selection.uniform.color[2][0] == 2.f); // stronger, but added after the pin + CHECK(selection.brighteningLights == 3); + CHECK(selection.dropped == 0); + + SUBCASE("a full pin leaves later lights out") + { + const std::vector many(mu::kMaxDynamicLights, early.front()); + const Render::Lighting::DynamicLightSelection full = + Render::Lighting::SelectDynamicLights(Render::Lighting::SelectDynamicLights(many, hero), later, hero); + CHECK(full.uniform.lightCount == mu::kMaxDynamicLights); + CHECK(full.uniform.worldLightCount == mu::kMaxDynamicLights); + CHECK(full.dropped == 1); + } +} + +TEST_CASE("the ground's lights are pinned once per frame [render][dynamic_lights]") +{ + const float hero[3] = {1000.f, 1000.f, 0.f}; + DynamicLightList frameLights; + frameLights.Add(MakeLight(1000.f, 1000.f, 1.f, 1.f, 1.f, 3)); + Render::Lighting::WorldDynamicLights world; + CHECK_FALSE(world.IsPinned()); + + world.Pin(frameLights, hero); + frameLights.Add(MakeLight(1100.f, 1000.f, 1.f, 1.f, 1.f, 3)); + world.Pin(frameLights, hero); + + CHECK(world.IsPinned()); + CHECK(world.Selection().uniform.lightCount == 1); + CHECK(frameLights.LightsSinceMark().size() == 1); + world.Clear(); + CHECK_FALSE(world.IsPinned()); +} + TEST_CASE("the dropped-light report runs at most once per minute [render][dynamic_lights]") { using std::chrono::seconds; diff --git a/tests/render/test_pipeline_fail_fast.cmake b/tests/render/test_pipeline_fail_fast.cmake index 125bb52bf3..f2e96f7f0b 100644 --- a/tests/render/test_pipeline_fail_fast.cmake +++ b/tests/render/test_pipeline_fail_fast.cmake @@ -137,6 +137,7 @@ require_world_set(s_pipelinesSkinned "skinned" Skinned Textured Classic) require_world_set(s_pipelines3DEnhancedFog "3d-enhanced-fog" ThreeDimensional TexturedEnhancedFog EnhancedLighting) require_world_set(s_pipelinesSkinnedEnhancedFog "skinned-enhanced-fog" Skinned TexturedEnhancedFog EnhancedLighting) require_world_set(s_pipelinesSkinnedLit "skinned-lit" Skinned SkinnedLit EnhancedLighting) +require_world_set(s_pipelinesWorldLit "world-lit" ThreeDimensionalWorldLit WorldLit EnhancedLighting) # The four depth/cull states every world set is built in: suffix, depth test, depth write, culling. function(require_world_state member suffix depth_test depth_write cull) @@ -188,7 +189,7 @@ require_source("${renderer_source}" "depth_write=\\{\\}" "pipeline diagnostics m require_source("${renderer_source}" "cull=\\{\\}" "pipeline diagnostics must include cull state") require_source("${renderer_source}" "error=\\{\\}" "pipeline diagnostics must include the SDL error") require_source("${build_source}" - "pipelineInfo\\.vertex_shader[ \t\r\n]*=[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::Skinned[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinned[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeighted[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedWeighted[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedShadow[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedShadow[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeightedShadow[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedWeightedShadow[ \t\r\n]*:[ \t\r\n]*s_vertShader2D" + "pipelineInfo\\.vertex_shader[ \t\r\n]*=[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::Skinned[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinned[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeighted[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedWeighted[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedShadow[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedShadow[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeightedShadow[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderSkinnedWeightedShadow[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::ThreeDimensionalWorldLit[ \t\r\n]*\\?[ \t\r\n]*s_vertShaderWorldLit[ \t\r\n]*:[ \t\r\n]*s_vertShader2D" "pipeline vertex shader handles must remain selected from the pipeline layout") require_source("${build_source}" "pipelineInfo\\.fragment_shader[ \t\r\n]*=[ \t\r\n]*GetFragmentShader\\(description\\.fragmentShader\\)" @@ -210,7 +211,7 @@ require_source("${depth_state_source}" "\\.compare_op[ \t\r\n]*=[ \t\r\n]*SDL_GP reject_source("${renderer_source}" "SDL_GPU_COMPAREOP_LESS([^_]|$)" "no pipeline may compare depth with strict LESS") require_source("${log_source}" - "vertexShaderName[ \t\r\n]*=[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::Skinned[ \t\r\n]*\\?[ \t\r\n]*\"skinned_textured\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeighted[ \t\r\n]*\\?[ \t\r\n]*\"skinned_weighted\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedShadow[ \t\r\n]*\\?[ \t\r\n]*\"skinned_shadow\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeightedShadow[ \t\r\n]*\\?[ \t\r\n]*\"skinned_weighted_shadow\\.vert\"[ \t\r\n]*:[ \t\r\n]*\"basic_textured\\.vert\"" + "vertexShaderName[ \t\r\n]*=[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::Skinned[ \t\r\n]*\\?[ \t\r\n]*\"skinned_textured\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeighted[ \t\r\n]*\\?[ \t\r\n]*\"skinned_weighted\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedShadow[ \t\r\n]*\\?[ \t\r\n]*\"skinned_shadow\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::SkinnedWeightedShadow[ \t\r\n]*\\?[ \t\r\n]*\"skinned_weighted_shadow\\.vert\"[ \t\r\n]*:[ \t\r\n]*description\\.vertexLayout[ \t\r\n]*==[ \t\r\n]*VertexLayout::ThreeDimensionalWorldLit[ \t\r\n]*\\?[ \t\r\n]*\"world_lit\\.vert\"[ \t\r\n]*:[ \t\r\n]*\"basic_textured\\.vert\"" "pipeline diagnostics must map the built vertex layout to its exact shader identifier") require_source("${log_source}" "fragmentShaderName[ \t\r\n]*=[ \t\r\n]*GetFragmentShaderName\\(description\\.fragmentShader\\)" From 1736103eb43af0b2641b114214701aec1cdff14c Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 18:36:07 +0800 Subject: [PATCH 02/17] feat(render): see-through character shadows on the Enhanced lit ground Character shadows were opaque black, and overlapping shadow triangles would double-darken as soon as they were not. In a frame with world-lit ground (Enhanced dynamic lights) they now darken the ground through a coverage mask: - Body shadows (GPU, CPU fallback and cloth) are recorded inside a ScopedGroundShadow. Before the scene pass they are replayed into an R8 mask at the frame's size with MIN blending, so each pixel darkens once however many triangles or characters overlap, and nearby shadows merge. - The scene passes leave the tagged draws out; world_lit.frag samples the mask and dims only the ground's own light by dynamic.shadowOpacity, so candles, fires and spells still light shadowed ground. - dynamic.shadowOpacity (Look.json, per map, default 60 %) has a "Shadow darkness" slider under Dynamic lights and a `$dynlights shadow ` command. - Classic, Dynamic lights off, and passes without the mask draw the shadows as before. --- cmake/ValidateDxilReflection.cmake | 3 +- cmake/ValidateShaderBlobs.cmake | 1 + cmake/ValidateShaderReflection.cmake | 3 +- docs/enhanced-look.md | 6 +- src/Localization/Game.en.resx | 6 + src/bin/Data/Render/Look.json | 1 + src/shaders/compiled/shadow_mask.frag.dxil | Bin 0 -> 3084 bytes src/shaders/compiled/shadow_mask.frag.msl | 22 ++ src/shaders/compiled/shadow_mask.frag.spv | Bin 0 -> 520 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 7076 -> 7492 bytes src/shaders/compiled/world_lit.frag.msl | 55 ++-- src/shaders/compiled/world_lit.frag.spv | Bin 5688 -> 6412 bytes src/shaders/shadow_mask.frag.hlsl | 14 ++ src/shaders/world_lit.frag.hlsl | 16 +- .../Data/GameData/MapData/LookProfile.cpp | 1 + .../Data/GameData/MapData/LookProfile.h | 1 + src/source/Render/Look/LookTuningCommand.cpp | 1 + src/source/Render/Look/LookTuningCommand.h | 1 + src/source/Render/Look/TuningControls.cpp | 2 + src/source/Render/Look/TuningControls.h | 1 + src/source/Render/Models/ZzzBMD.cpp | 1 + src/source/Render/Renderer/MuRenderer.h | 21 ++ .../Render/Renderer/MuRendererSDLGpu.cpp | 235 ++++++++++++++++-- src/source/Render/Renderer/SceneLighting.h | 5 +- .../Render/Renderer/SdlGpuReplayState.h | 2 +- src/source/Scenes/SceneLightingSetup.cpp | 1 + src/source/UI/Options/TuningRows.cpp | 2 + tests/render/test_look_profile.cpp | 2 + .../render/test_projected_shadow_state.cmake | 8 + tests/render/test_tuning_controls.cpp | 6 +- 30 files changed, 366 insertions(+), 51 deletions(-) create mode 100644 src/shaders/compiled/shadow_mask.frag.dxil create mode 100644 src/shaders/compiled/shadow_mask.frag.msl create mode 100644 src/shaders/compiled/shadow_mask.frag.spv create mode 100644 src/shaders/shadow_mask.frag.hlsl diff --git a/cmake/ValidateDxilReflection.cmake b/cmake/ValidateDxilReflection.cmake index 3f963cbf1e..2ab40272b9 100644 --- a/cmake/ValidateDxilReflection.cmake +++ b/cmake/ValidateDxilReflection.cmake @@ -27,7 +27,8 @@ set(shader_specs "skinned_weighted_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" "skinned_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+t0,space2+t1,space2" "world_lit.vert|cb0,space1" - "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+t0,space2" + "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+t0,space2+t1,space2" + "shadow_mask.frag|-" "post_fullscreen.vert|-" "post_bloom_down.frag|cb0,space3+s0,space2+t0,space2" "post_bloom_up.frag|cb0,space3+s0,space2+t0,space2" diff --git a/cmake/ValidateShaderBlobs.cmake b/cmake/ValidateShaderBlobs.cmake index 66b55fff35..101f50fcd8 100644 --- a/cmake/ValidateShaderBlobs.cmake +++ b/cmake/ValidateShaderBlobs.cmake @@ -21,6 +21,7 @@ set(MU_SHADER_STAGE_NAMES skinned_lit.frag world_lit.vert world_lit.frag + shadow_mask.frag shadow_volume.vert post_fullscreen.vert post_bloom_down.frag diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index 68c6efa499..a8f898ad63 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -272,7 +272,8 @@ set(shader_specs "skinned_weighted_shadow.vert|vert|0,3,4,6,7|0|2|2" "skinned_lit.frag|frag||2|0|3" "world_lit.vert|vert|0,1,2|0|0|1" - "world_lit.frag|frag||1|0|3" + "world_lit.frag|frag||2|0|3" + "shadow_mask.frag|frag||0|0|0" "post_fullscreen.vert|vert||0|0|0" "post_bloom_down.frag|frag||1|0|1" "post_bloom_up.frag|frag||1|0|1" diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index f44ddb67d3..07f16fbbb8 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -12,7 +12,7 @@ options window, without editing those files (see "Tuning it yourself"). |---|---|---| | Texture filtering | mipmaps and anisotropic filtering for world textures | — | | Enhanced lighting | per-pixel model lighting with rim light and, on metal armour, specular highlights | — | -| Dynamic model lights | candles, fires and spells light characters, monsters, NPCs and world objects per pixel, and the ground as smooth pools instead of patches interpolated between terrain vertices | — | +| Dynamic model lights | candles, fires and spells light characters, monsters, NPCs and world objects per pixel, and the ground as smooth pools instead of patches interpolated between terrain vertices; characters' shadows on the ground are see-through and merge where they overlap | — | | Light mood | darker baked map light, so the light sources stand out | [light-mood.md](light-mood.md) | | Post-processing | bloom around light effects and per-map colour grading | [post-processing.md](post-processing.md) | | Anti-aliasing | multisampled edges (4 samples, or what `Antialiasing` asks for), alpha-to-coverage for cut-out foliage and fences | — | @@ -80,6 +80,7 @@ window. | Dynamic lights | Skill radius | `dynamic.effectRange` | 0.5–4× | 0.1× | 3× | common | | Dynamic lights | Skill fade | `dynamic.effectFade` | 0–2 s | 0.05 s | 0.5 s | common | | Dynamic lights | Overlapping-light cap | `dynamic.effectCap` | 0–8 | 0.1 | 2.5 | common | +| Dynamic lights | Shadow darkness | `dynamic.shadowOpacity` | 0–100 % | 5 % | 60 % | common | | Dynamic lights | Light wrap | `dynamic.wrap` | 0–0.5 | 0.05 | 0.3 | More settings | | Dynamic lights | Map-light smoothing | `dynamic.mapSmoothing` | 0–2 s | 0.05 s | 0.5 s | More settings | | Dynamic lights | Maximum skill radius | `dynamic.effectRangeMax` | 0–16 cells | 1 cell | 8 cells | More settings | @@ -202,6 +203,7 @@ for the whole file. | `dynamic.effectRangeMax` | 8 | 0 (none) | 0–16 | the most terrain cells the range factor may widen a light to | | `dynamic.effectFade` | 0.5 | 0 | 0–2 | seconds over which a spell's light fades out after it ends | | `dynamic.effectCap` | 2.5 | 0 (none) | 0–8 | the most light overlapping spell lights may add up to | +| `dynamic.shadowOpacity` | 0.6 | 0.6 | 0–1 | how much characters' shadows darken the ground's own light; overlapping shadows darken it once, and point lights still light shadowed ground | | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | @@ -233,7 +235,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$bloom falloff `, `$bloom `. +`$dynlights reach `, `$dynlights shadow `, `$bloom falloff `, `$bloom `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index d2c4f583b9..2ff0fae57b 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1150,6 +1150,12 @@ The most light several overlapping skills may add up to. No cap lets them add up freely; it does not switch skill lights off. + + Shadow darkness + + + How dark characters' shadows make the ground. Candle, fire and skill light still lights shadowed ground. + Light wrap diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 640f82e1cf..9b0fe4c6d1 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -16,6 +16,7 @@ "dynamic.effectRangeMax": 8, "dynamic.effectFade": 0.5, "dynamic.effectCap": 2.5, + "dynamic.shadowOpacity": 0.6, "bloom.strength": 1.0, "bloom.levelFalloff": 0.6, "grading.strength": 1 diff --git a/src/shaders/compiled/shadow_mask.frag.dxil b/src/shaders/compiled/shadow_mask.frag.dxil new file mode 100644 index 0000000000000000000000000000000000000000..623d6caf2248ab2482bbe84318e379940b426013 GIT binary patch literal 3084 zcmeHJeN0=|6~Fd-_!+RDAK*1M81xLqeQgPIOv8tO$zK=~j6z~BV_i_}@KKNq80;}1 zk!GF^c8FP>KpQF~6d*xu)(=A2)@a@21cxy`Qqs~0+OC6yku@SI+R`bTrfv5+kY!W1 zN&92_r$;{boOizNx%WK(Y<-1RXTJaYo0ZqDPUvKr{;VG@yv+ds2m}BSP!>QoL0*DP zLB|$i9`r+}*-)b7L;DVun2Yzg;R6PF$6mMXL^Y8ek?5g_tggp&hEb=~kEUZ;cbXW=3B5#8tS|3JQNm$`wFes%e>ga;1^Ca9xb%6 z+~MRo+s?ZVQUGX&cUTAW6ERcJz)jGs#z)4kUNjcmC- z0Z)Z7HRCqZf|YKtgo(VbeY++G18%vm9Knq7#^hG zU8n87eRS7!?Y9&;>CBzr+NJs7u2V1la_`Shy>ziGI=HX8Ez{NRsL?bwHo0sFeVk@? zj6@ZlU#W~=5m!noSNd09({mbfYH|W>z(Qx6xJ8;xuz}(VWqo z5WZ&d-LmkStX9k^^y_lHQvt1;Xm2B&1I>aBAi7JD_uXWcK$~*qa`LrdS*&No@r@jt1{WF`tgyoM<3Bq#XxC858e64Pu^tz6Gu*zGf$=j>E zKTzcFLgZRd^m)1HKD@7H8sZa_Pbh_FJ}>yoP2gEBSX$rplLqdGjz3yE_qsax089J74^1GA7Y$ge)iRZ~n~l~S yHwfYZei>X8^gPeTd2pansxv$zKd^>rj+zosb7z@!$sQx1a4f81E<`{4C;B&B-g#sI literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/shadow_mask.frag.msl b/src/shaders/compiled/shadow_mask.frag.msl new file mode 100644 index 0000000000..ec56649380 --- /dev/null +++ b/src/shaders/compiled/shadow_mask.frag.msl @@ -0,0 +1,22 @@ +#include +#include + +using namespace metal; + +struct main0_out +{ + float4 _entryPointOutput [[color(0)]]; +}; + +struct main0_in +{ + float4 input_color [[user(locn1)]]; +}; + +fragment main0_out main0(main0_in in [[stage_in]]) +{ + main0_out out = {}; + out._entryPointOutput = float4(1.0 - in.input_color.w); + return out; +} + diff --git a/src/shaders/compiled/shadow_mask.frag.spv b/src/shaders/compiled/shadow_mask.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..164de1f7efd8371d10727f63255813e7bac484fa GIT binary patch literal 520 zcmYk2Jxc>o5JkttWCg*fL9LV(8zB+|6A{FZXptshz+WJ0v7oyWH-(+xUru2oc+P4d z5AM#)ojY&t+j{LFiCBu&Sc%*CI~!4h3Aknzhok#Z_q}}T_WH*v)}mes)wCjsWuka} z$Z{Kp;0UavlV<^0JsQLrLk-wPeFMgsEPtDp-N)jkn7|~}9oNr!Ir$hDSzg{vOZw=B zOsn4mda!n%wWp2$8gakc8dbhc-h@lR4thOV>!ZWhyaggYuePW+$x=&>ed{*xlO4SKQngNrlp3&blS@&Et; literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index a8c6460741dd6c18888a6baeb085a16156cf5383..4559a3d1a982912cdd3143bdc5334b0f7435a2ca 100644 GIT binary patch literal 7492 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 CzApIy diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index 1c0272b605..824efeb94c 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -20,7 +20,7 @@ struct DynamicLights uint dynamicLightCount; float dynamicLightWrap; uint dynamicWorldLightCount; - uint dynamicLightPadding; + float groundShadowOpacity; float4 dynamicLightPositionAndRadius[32]; float4 dynamicLightColor[32]; }; @@ -49,54 +49,55 @@ struct main0_in float3 input_worldPosition [[user(locn4)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _169 [[buffer(2)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]]) +fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _208 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - uint _389 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); - float3 _472; - _472 = float3(0.0); - float3 _474; - for (uint _471 = 0u; _471 < _389; _472 = _474, _471++) + float4 _328 = tex.sample(s, in.input_uv); + float4 _310 = _328; + uint2 _311 = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); + uint _459 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); + float3 _543; + _543 = float3(0.0); + float3 _545; + for (uint _542 = 0u; _542 < _459; _543 = _545, _542++) { - float4 _379 = _64.dynamicLightPositionAndRadius[_471]; - float _406 = length(_64.dynamicLightPositionAndRadius[_471].xy - in.input_worldPosition.xy); - if (_406 < _379.w) + float4 _449 = _64.dynamicLightPositionAndRadius[_542]; + float _476 = length(_64.dynamicLightPositionAndRadius[_542].xy - in.input_worldPosition.xy); + if (_476 < _449.w) { - _474 = _472 + (_64.dynamicLightColor[_471].xyz * ((_379.w - _406) / _379.w)); + _545 = _543 + (_64.dynamicLightColor[_542].xyz * ((_449.w - _476) / _449.w)); } else { - _474 = _472; + _545 = _543; } } - float4 _296 = tex.sample(s, in.input_uv); - float4 _275 = _296; - float4 _276 = float4(_296.xyz * fast::clamp(in.input_color.xyz + _472, float3(0.0), float3(1.0)), _275.w * in.input_color.w); - if (_169.alphaToCoverage != 0u) + float4 _318 = float4(_328.xyz * fast::clamp((in.input_color.xyz * (1.0 - (_64.groundShadowOpacity * (1.0 - groundShadowMask.sample(groundShadowSampler, (gl_FragCoord.xy / float2(float(_311.x), float(_311.y)))).x)))) + _543, float3(0.0), float3(1.0)), _310.w * in.input_color.w); + if (_208.alphaToCoverage != 0u) { - _276.w *= fast::clamp(((_276.w - _169.alphaThreshold) / fast::max(fwidth(_276.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); - if (_276.w <= 0.0) + _318.w *= fast::clamp(((_318.w - _208.alphaThreshold) / fast::max(fwidth(_318.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + if (_318.w <= 0.0) { discard_fragment(); } } else { - if ((_169.alphaDiscardEnabled != 0u) && (_276.w <= _169.alphaThreshold)) + if ((_208.alphaDiscardEnabled != 0u) && (_318.w <= _208.alphaThreshold)) { discard_fragment(); } } - if ((_169.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) + if ((_208.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) { - float4 _357 = _276; - float _439 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; - float3 _366 = mix(_357.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_439) * _439), 0.0, 1.0))); - _276.x = _366.x; - _276.y = _366.y; - _276.z = _366.z; + float4 _427 = _318; + float _509 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; + float3 _436 = mix(_427.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_509) * _509), 0.0, 1.0))); + _318.x = _436.x; + _318.y = _436.y; + _318.z = _436.z; } - out._entryPointOutput = _276; + out._entryPointOutput = _318; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index 6c179f09a621e2a92b899233052df448f37e5387..0265e91bbad7d7d38e71a1c1e675e633de9fff8a 100644 GIT binary patch literal 6412 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 literal 5688 zcmaKu>vNq|6^Gv>O=&86jDv$cdgMt%Phu9pV|@&ztnAl9^WhaIN0#=lOb9xozB+HCNHOVx{Vwf@@5+H!5K*S5s9ski=8 ze{{Li=q|TcO5cIbx(B-UZ2JUHwA5HX&zd>!NUzrMy1@szSznn)8E252JpdM^mNorU zCzdriFU{6kzc<}K5!m^4Y@zI7`@ne`*fmZz<{E3gW&JmoGd95Q^9k1*Nu9G-ZM1rw zlk@Fnt9Pj1;~Zii;EtUq>%WaCF;3Hc_O>gp zG3G%mYK$2WiyFnuNi1p<+gPJm)VLi!&W-n+1hWo%JSepiysQ|#Tym$Oeoq+fh6lg&kag?$oosaKvVCGkz=`xr}m_3l?C zeb`@vtWD^zEA^-LUW>JL?}YRT3cp=olh9?vb+)WkOxf8Ac_Mvh%+2%NC4ICr&%NyC zum|!Ul&etWBf<#&1(IcnASMd;!eUfOA`%I6@~US-dF1sZ~k z|7zmnyw{TKEO?%>bF00w_UDtV{}2jwo}*sbITlmDCGqy4dS&ODze4>ujJbQhdS&Na zEPD54WcxYjW?s_zeSep>{{-=UjbXoh1s{7RuLWosM5 z-nx{n@$!tD(t7h#KY!m@Y*;7VRJv2_&C*6 zz`qX9UvVX*zxvQUkmVV%lcTecmF87x;?zC z@2Kn@`JRu#i#gxg`!b9gXeKY|bZQ83^6$6&@%cRFD|f%pB@`HqpNd-R7rp^fjQy)|fSpIDRoDdJT) z<1D!dIhq-rN=n; zDfagxYa@Of%-*>gUfg-Mf1G=;ayhPZvhj34jbooC%o7cy#0JPyvu%8_Yr6w^6lm0Zaxa{d3oKtkj1sx zL5y4BJ%0v@ncWR09{s!rUO(}Oy%&CC>?)Y}OXTI9&cKWL8>qYwp1z&7S}8<=>!_3iLt#tOfW!-t>mq^w=& zKauI>X4Xq$a{~@b_3qKjo+&%y;$P(+oW&R6#lz-z@PWlQ`WzU4{QtTr)JLAbhj(t($87%rp1*Ro)yHhl zbDH1FRWNOW;#<`MZ~4sx8O yk2YfA(}mZ^dkmi*vOd10KH7*m2hm&Z(HAG+jiLTNc6-lV-;3DQ|A%UKLjMB^jUChg diff --git a/src/shaders/shadow_mask.frag.hlsl b/src/shaders/shadow_mask.frag.hlsl new file mode 100644 index 0000000000..731ce7e359 --- /dev/null +++ b/src/shaders/shadow_mask.frag.hlsl @@ -0,0 +1,14 @@ +// shadow_mask.frag.hlsl — a ground shadow into the ground shadow mask (R8, MIN blend): 1 minus the +// shadow's alpha, so the darkest shadow at a pixel wins and overlapping shadows count once. +// world_lit.frag.hlsl reads the mask. Pairs with skinned_shadow.vert and basic_textured.vert. +struct FSInput +{ + float4 pos : SV_Position; + float2 uv : TEXCOORD0; + float4 color : TEXCOORD1; +}; + +float4 main(FSInput input) : SV_Target +{ + return (1.0 - input.color.a).xxxx; +} diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index 1f17d8d33a..a0aaf39b16 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -8,6 +8,9 @@ Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); +// Per pixel, 1 minus the darkest ground shadow there (white without shadows). +Texture2D groundShadowMask : register(t1, space2); +SamplerState groundShadowSampler : register(s1, space2); cbuffer FogUniforms : register(b0, space3) { uint fogEnabled; @@ -35,7 +38,7 @@ cbuffer DynamicLights : register(b2, space3) uint dynamicLightCount; // lights used float dynamicLightWrap; // models only uint dynamicWorldLightCount; // the first lights: the ones the ground's vertex colour leaves out - uint dynamicLightPadding; + float groundShadowOpacity; // how much a shadow darkens the vertex colour float4 dynamicLightPositionAndRadius[MaxDynamicLights]; float4 dynamicLightColor[MaxDynamicLights]; }; @@ -75,8 +78,17 @@ float3 WorldDynamicLighting(float3 worldPosition) float4 main(FSInput input) : SV_Target { - const float3 light = saturate(input.color.rgb + WorldDynamicLighting(input.worldPosition)); + // Sampled before the mask: spirv-cross numbers the MSL textures in the order the source uses them. const float4 texel = tex.Sample(s, input.uv); + // The mask covers the render target; a 1x1 white mask clamps to white everywhere. + uint maskWidth; + uint maskHeight; + groundShadowMask.GetDimensions(maskWidth, maskHeight); + const float visibility = + groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).r; + // Shadows dim the ground's own light; the point lights still light shadowed ground. + const float shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); + const float3 light = saturate(input.color.rgb * shadow + WorldDynamicLighting(input.worldPosition)); float4 color = float4(texel.rgb * light, texel.a * input.color.a); if (alphaToCoverage) { diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index b79b455cd3..9e648efb84 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -41,6 +41,7 @@ constexpr std::array Infos = {{ {LookValue::DynamicEffectRangeMax, "dynamic.effectRangeMax", 0.0, 0.0, 16.0}, {LookValue::DynamicEffectFade, "dynamic.effectFade", 0.0, 0.0, 2.0}, {LookValue::DynamicEffectCap, "dynamic.effectCap", 0.0, 0.0, 8.0}, + {LookValue::GroundShadowOpacity, "dynamic.shadowOpacity", 0.6, 0.0, 1.0}, {LookValue::BloomStrength, "bloom.strength", 0.6, 0.0, 2.0}, {LookValue::BloomLevelFalloff, "bloom.levelFalloff", 0.5, 0.25, 1.0}, {LookValue::GradingStrength, "grading.strength", 1.0, 0.0, 1.0}, diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index 60a5414d8a..f550df34b1 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -43,6 +43,7 @@ enum class LookValue : std::uint8_t DynamicEffectRangeMax, DynamicEffectFade, DynamicEffectCap, + GroundShadowOpacity, BloomStrength, BloomLevelFalloff, GradingStrength, diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 83c557a831..4df3fc5352 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -27,6 +27,7 @@ const CommandForm CommandForms[] = { {L"$dynlights spell ", {LookValue::DynamicEffectGain, LookValue::DynamicEffectRange, LookValue::DynamicEffectFade}}, {L"$dynlights cap ", {LookValue::DynamicEffectCap}}, {L"$dynlights reach ", {LookValue::DynamicEffectRangeMax}}, + {L"$dynlights shadow ", {LookValue::GroundShadowOpacity}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$bloom ", {LookValue::BloomStrength}}, }; diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index e78c3b7bce..c8cfa42d3d 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -28,6 +28,7 @@ // $dynlights spell dynamic.effectGain, .effectRange, .effectFade // $dynlights cap dynamic.effectCap // $dynlights reach dynamic.effectRangeMax +// $dynlights shadow dynamic.shadowOpacity // $bloom falloff bloom.levelFalloff // $bloom bloom.strength namespace Render::Look diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index c78a7eefb2..77d25f4e47 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -58,6 +58,8 @@ constexpr std::array Specs = {{ TuningUnit::Seconds, 1.0, TuningZero::Immediate}, {TuningControlId::EffectCap, TuningGroup::DynamicLights, false, LookValue::DynamicEffectCap, 0.1, TuningUnit::None, 1.0, TuningZero::NoCap}, + {TuningControlId::ShadowOpacity, TuningGroup::DynamicLights, false, LookValue::GroundShadowOpacity, 0.05, + TuningUnit::Percent, 100.0, TuningZero::Plain}, {TuningControlId::Wrap, TuningGroup::DynamicLights, true, LookValue::DynamicWrap, 0.05, TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::MapSmoothing, TuningGroup::DynamicLights, true, LookValue::DynamicMapSmoothing, 0.05, diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index 4e4896eee0..f5e6b71827 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -66,6 +66,7 @@ enum class TuningControlId : std::uint8_t EffectRange, EffectFade, EffectCap, + ShadowOpacity, Wrap, MapSmoothing, EffectRangeMax, diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index a1524276c4..ce53d7708f 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -3094,6 +3094,7 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const DisableTexture(); DisableDepthMask(); BeginRender(1.f); + const mu::ScopedGroundShadow groundShadow; const auto [startMesh, endMesh] = ResolveMeshRange(NumMeshs, draw.startMesh, draw.endMesh); diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index 7baef0cd03..bb81d4a708 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -435,6 +435,13 @@ class IMuRenderer // ScopedWorldLitGeometry. virtual void BeginWorldLitGeometry() {} virtual void EndWorldLitGeometry() {} + + // Draws between BeginGroundShadow and EndGroundShadow are shadows cast on the ground. In a frame + // with world-lit ground they darken it through a coverage mask instead (each pixel once, by + // DynamicLightsUniform::groundShadowOpacity); otherwise they draw as recorded. Scopes nest; use + // ScopedGroundShadow. + virtual void BeginGroundShadow() {} + virtual void EndGroundShadow() {} // True while a bloom exclusion is open: what is queued now and drawn later // (a character's glow sprites) can be drawn inside one too. [[nodiscard]] virtual bool IsBloomExcluded() const @@ -883,6 +890,20 @@ class ScopedWorldLitGeometry ScopedWorldLitGeometry(const ScopedWorldLitGeometry&) = delete; ScopedWorldLitGeometry& operator=(const ScopedWorldLitGeometry&) = delete; }; +class ScopedGroundShadow +{ +public: + ScopedGroundShadow() + { + GetRenderer().BeginGroundShadow(); + } + ~ScopedGroundShadow() + { + GetRenderer().EndGroundShadow(); + } + ScopedGroundShadow(const ScopedGroundShadow&) = delete; + ScopedGroundShadow& operator=(const ScopedGroundShadow&) = delete; +}; // The draws recorded in its lifetime may be reordered (BeginReorderableDraws). class ScopedReorderableDraws { diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index e12e1d0e24..f64a306e9e 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -128,7 +128,8 @@ static_assert(offsetof(SkinningVertexUniforms, eyePositionAndSpecular) == 192, static_assert(offsetof(SkinningVertexUniforms, vertexToWorldRows) == 208, "vertexToWorldRows must follow eyePositionAndSpecular (HLSL cbuffer Skinning)"); -// skinned_lit.frag's normal map (t1, s1 in space2): bound for every draw with that shader. +// Slot 1 (t1, s1 in space2): skinned_lit.frag's normal map, bound for every draw with that shader, or +// world_lit.frag's ground shadow mask. constexpr Uint32 k_FragmentSamplerSlotNormalMap = 1u; // The flat tangent-space normal (0, 0, 1) as RGBA8: the normal map of draws without one. constexpr Uint32 k_FlatNormalPixel = 0xFFFF8080u; // R = G = 128, B = A = 255 (little-endian RGBA) @@ -622,6 +623,18 @@ static mu::PostProcessingView s_postProcessingView = mu::PostProcessingView::Sce static Render::PostProcessing::SceneBoundary s_sceneBoundary; static int s_bloomExclusionDepth = 0; static int s_worldLitGeometryDepth = 0; +static int s_groundShadowDepth = 0; +// Ground shadows (BeginGroundShadow) are drawn into a coverage mask the world-lit ground samples, in +// a frame that recorded world-lit draws; until the mask holds the frame's shadows they draw as before. +static bool s_frameHasWorldLit = false; +static bool s_groundShadowMaskReady = false; +// Per pixel, 1 minus the darkest shadow alpha drawn there; single-sample, at the frame's size. +static SDL_GPUTexture* s_groundShadowMask = nullptr; +static Uint32 s_groundShadowMaskW = 0; +static Uint32 s_groundShadowMaskH = 0; +// The mask's pipelines: GPU-skinned shadows, and the CPU and cloth shadows in the 3D layout. +static SDL_GPUGraphicsPipeline* s_groundShadowMaskSkinnedPipeline = nullptr; +static SDL_GPUGraphicsPipeline* s_groundShadowMask3DPipeline = nullptr; // Alpha-to-coverage variants of the depth-writing world pipelines (each world set's culled and // no-cull states), used while anti-aliasing is on by alpha-tested cutout draws (foliage, hair, @@ -814,6 +827,8 @@ struct RenderCmd bool depthMaskEnabled{}; bool cullFaceEnabled{}; bool bloomExcluded{}; // recorded inside a ScopedBloomExclusion: never a bloom source + bool groundShadow{}; // recorded inside a ScopedGroundShadow + bool worldLit{}; // recorded inside BeginWorldLitGeometry: slot 1 is the ground shadow mask // Set once this command has been replayed into an offscreen capture (see // BeginOffscreenCapture/EndOffscreenCapture); the main frame's replay pass then // skips it instead of drawing it a second time into the frame. @@ -848,7 +863,7 @@ static Render::DrawCommandHistory s_previousDrawCommands; return Counter::BatchBreakTexture; } if (previous.blendEnabled != command.blendEnabled || previous.blendMode != command.blendMode || - previous.bloomExcluded != command.bloomExcluded) + previous.bloomExcluded != command.bloomExcluded || previous.groundShadow != command.groundShadow) { return Counter::BatchBreakBlend; } @@ -1036,8 +1051,22 @@ static void PushSceneLightingUniforms() s_dbgFragmentUniformPushesThisFrame += 2; } +// The world-lit ground's slot 1: this frame's shadow mask once it holds its shadows, otherwise white, +// which leaves the ground unshadowed. +static SDL_GPUTextureSamplerBinding GroundShadowMaskBinding(); + static void BindReplayFragmentSampler(const RenderCmd& command, Render::SdlGpuReplayState& state) { + // Slot 1 changes meaning with the shader (normal map or shadow mask), so it is bound per draw. + if (!command.normalTexture && command.worldLit) + { + const SDL_GPUTextureSamplerBinding maskBinding = GroundShadowMaskBinding(); + if (state.SelectNormalMapSampler(maskBinding.texture, maskBinding.sampler)) + { + SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotNormalMap, &maskBinding, 1); + ++s_dbgSamplerBindsThisFrame; + } + } if (command.normalTexture && state.SelectNormalMapSampler(command.normalTexture, command.normalSampler)) { const SDL_GPUTextureSamplerBinding normalBinding{command.normalTexture, command.normalSampler}; @@ -1171,6 +1200,11 @@ static std::vector s_textureUpdates; // Default white 1×1 texture used for textureId==0 and unknown IDs. static SDL_GPUTexture* s_whiteTexture = nullptr; + +static SDL_GPUTextureSamplerBinding GroundShadowMaskBinding() +{ + return {s_groundShadowMaskReady ? s_groundShadowMask : s_whiteTexture, s_defaultSampler}; +} // 1×1 flat normal map (k_FlatNormalPixel) bound to skinned_lit.frag for draws without a map. static SDL_GPUTexture* s_flatNormalTexture = nullptr; @@ -1186,8 +1220,9 @@ static SDL_GPUShader* s_vertShaderSkinnedShadow = nullptr; // skinned_shadow.ver static SDL_GPUShader* s_vertShaderSkinnedWeightedShadow = nullptr; // skinned_weighted_shadow.vert static SDL_GPUShader* s_fragShaderTexFog = nullptr; // basic_textured_fog.frag (Enhanced, optional) static SDL_GPUShader* s_fragShaderLit = nullptr; // skinned_lit.frag (Enhanced, optional) -static SDL_GPUShader* s_vertShaderWorldLit = nullptr; // world_lit.vert (Enhanced, optional) -static SDL_GPUShader* s_fragShaderWorldLit = nullptr; // world_lit.frag (Enhanced, optional) +static SDL_GPUShader* s_vertShaderWorldLit = nullptr; // world_lit.vert (Enhanced, optional) +static SDL_GPUShader* s_fragShaderWorldLit = nullptr; // world_lit.frag (Enhanced, optional) +static SDL_GPUShader* s_fragShaderShadowMask = nullptr; // shadow_mask.frag (optional) // Post-processing (optional): without them post-processing is unavailable. static SDL_GPUShader* s_vertShaderPostFullscreen = nullptr; // post_fullscreen.vert static SDL_GPUShader* s_fragShaderBloomDown = nullptr; // post_bloom_down.frag @@ -2112,6 +2147,7 @@ class MuRendererSDLGpu : public IMuRenderer DestroySkinnedMeshCache(); DestroyPipelines(); ReleaseShaders(); + ReleaseGroundShadowMask(); s_postProcessing.Release(); SDL_ReleaseWindowFromGPUDevice(s_device, s_window); @@ -2189,6 +2225,9 @@ class MuRendererSDLGpu : public IMuRenderer s_bloomExclusionDepth = 0; } s_worldLitGeometryDepth = 0; + s_groundShadowDepth = 0; + s_frameHasWorldLit = false; + s_groundShadowMaskReady = false; s_replayedCmdCount = 0u; s_mainColorPassOpenedThisFrame = false; @@ -2302,6 +2341,7 @@ class MuRendererSDLGpu : public IMuRenderer { AllCommands, BloomSources, + GroundShadows, // the ground shadows, into the ground shadow mask }; [[nodiscard]] static ReplayView FullFrameView() @@ -2346,6 +2386,27 @@ class MuRendererSDLGpu : public IMuRenderer return nullptr; } + [[nodiscard]] static SDL_GPUGraphicsPipeline* GetGroundShadowMaskPipeline(const RenderCmd& command) + { + return command.type == RenderCmdType::DrawSkinnedTriangles ? s_groundShadowMaskSkinnedPipeline + : s_groundShadowMask3DPipeline; + } + + // The pipeline `command` replays with in a pass of `selection`, or null when it is not drawn there. + // Once the mask holds the ground shadows, the other passes leave them out. + [[nodiscard]] static SDL_GPUGraphicsPipeline* GetReplayPipeline(const RenderCmd& command, ReplaySelection selection) + { + if (selection == ReplaySelection::GroundShadows) + { + return command.groundShadow ? GetGroundShadowMaskPipeline(command) : nullptr; + } + if (command.groundShadow && s_groundShadowMaskReady) + { + return nullptr; + } + return selection == ReplaySelection::BloomSources ? GetBloomSourcePipeline(command) : command.pipeline; + } + // Replays commands [begin, end) into s_renderPass, starting from `view`; // `view` ends as the last replayed command left it. static void ReplayCommands(std::size_t begin, std::size_t end, bool boneDataReady, ReplaySelection selection, @@ -2359,7 +2420,7 @@ class MuRendererSDLGpu : public IMuRenderer if (replayState.SelectScissor(view.scissor)) SDL_SetGPUScissor(s_renderPass, &view.scissor); - const bool bloomSourcesOnly = selection == ReplaySelection::BloomSources; + const bool allCommands = selection == ReplaySelection::AllCommands; for (std::size_t index = begin; index < end; ++index) { const RenderCmd& cmd = s_renderCmds[index]; @@ -2373,7 +2434,7 @@ class MuRendererSDLGpu : public IMuRenderer { continue; // already drawn into its own offscreen texture above } - if (!bloomSourcesOnly) + if (allCommands) { ++s_dbgRenderCmdsReplayedThisFrame; } @@ -2403,7 +2464,7 @@ class MuRendererSDLGpu : public IMuRenderer case RenderCmdType::DrawIndexedStrip: case RenderCmdType::DrawTriangles2D: { - SDL_GPUGraphicsPipeline* pipeline = bloomSourcesOnly ? GetBloomSourcePipeline(cmd) : cmd.pipeline; + SDL_GPUGraphicsPipeline* pipeline = GetReplayPipeline(cmd, selection); if (pipeline) { ReplayDrawCommand(cmd, pipeline, boneDataReady, view.scissor, replayState); @@ -2457,6 +2518,71 @@ class MuRendererSDLGpu : public IMuRenderer return true; } + // The ground shadow mask at the frame's size, recreated when that changed. Null when it fails. + [[nodiscard]] static SDL_GPUTexture* EnsureGroundShadowMask() + { + if (s_groundShadowMask && s_groundShadowMaskW == s_swapW && s_groundShadowMaskH == s_swapH) + { + return s_groundShadowMask; + } + ReleaseGroundShadowMask(); + SDL_GPUTextureCreateInfo maskInfo{}; + maskInfo.type = SDL_GPU_TEXTURETYPE_2D; + maskInfo.format = SDL_GPU_TEXTUREFORMAT_R8_UNORM; + maskInfo.width = s_swapW; + maskInfo.height = s_swapH; + maskInfo.layer_count_or_depth = 1; + maskInfo.num_levels = 1; + maskInfo.sample_count = SDL_GPU_SAMPLECOUNT_1; + maskInfo.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + s_groundShadowMask = SDL_CreateGPUTexture(s_device, &maskInfo); + if (!s_groundShadowMask) + { + mu::log::Get("render")->error("SDL_gpu -- ground shadow mask creation failed ({}x{}): {}", s_swapW, s_swapH, + SDL_GetError()); + return nullptr; + } + s_groundShadowMaskW = s_swapW; + s_groundShadowMaskH = s_swapH; + return s_groundShadowMask; + } + + static void ReleaseGroundShadowMask() + { + if (s_groundShadowMask) + { + SDL_ReleaseGPUTexture(s_device, s_groundShadowMask); + s_groundShadowMask = nullptr; + } + s_groundShadowMaskW = 0u; + s_groundShadowMaskH = 0u; + } + + // In a frame with world-lit ground, its shadows [0, end) into the ground shadow mask, after which + // the other passes leave them out. + static void RenderGroundShadowMask(std::size_t end, bool boneDataReady) + { + if (!s_frameHasWorldLit || !s_groundShadowMask3DPipeline || !EnsureGroundShadowMask()) + { + return; + } + SDL_GPUColorTargetInfo maskTarget{}; + maskTarget.texture = s_groundShadowMask; + maskTarget.clear_color = {1.0f, 1.0f, 1.0f, 1.0f}; + maskTarget.load_op = SDL_GPU_LOADOP_CLEAR; + maskTarget.store_op = SDL_GPU_STOREOP_STORE; + maskTarget.cycle = true; + s_renderPass = SDL_BeginGPURenderPass(s_cmdBuf, &maskTarget, 1, nullptr); + if (!s_renderPass) + { + return; + } + ReplayView view = FullFrameView(); + ReplayCommands(0u, end, boneDataReady, ReplaySelection::GroundShadows, view); + EndReplayPass(); + s_groundShadowMaskReady = true; + } + static void EndReplayPass() { SDL_EndGPURenderPass(s_renderPass); @@ -2472,6 +2598,7 @@ class MuRendererSDLGpu : public IMuRenderer // Nothing reads depth after the pass; skip storing every sample of it. const SDL_GPUDepthStencilTargetInfo depthTarget = MakeDepthTarget(SDL_GPU_LOADOP_CLEAR, IsMultisampled() ? SDL_GPU_STOREOP_DONT_CARE : SDL_GPU_STOREOP_STORE); + RenderGroundShadowMask(s_renderCmds.size(), boneDataReady); if (!BeginReplayPass(colorTarget, depthTarget)) { return false; @@ -2582,6 +2709,7 @@ class MuRendererSDLGpu : public IMuRenderer // the UI did when it shared the scene's pass. const SDL_GPUColorTargetInfo sceneTarget = CycledTarget( mu::GetSdlGpuFrameColorTarget({s_postProcessing.GetSceneTexture(), multisampled}, s_clearColor)); + RenderGroundShadowMask(sceneEnd, boneDataReady); if (!BeginReplayPass(sceneTarget, MakeDepthTarget(SDL_GPU_LOADOP_CLEAR, SDL_GPU_STOREOP_STORE))) { return false; @@ -3660,6 +3788,19 @@ class MuRendererSDLGpu : public IMuRenderer } } + void BeginGroundShadow() override + { + ++s_groundShadowDepth; + } + + void EndGroundShadow() override + { + if (s_groundShadowDepth > 0) + { + --s_groundShadowDepth; + } + } + [[nodiscard]] bool IsBloomExcluded() const override { return s_bloomExclusionDepth > 0; @@ -5343,6 +5484,12 @@ class MuRendererSDLGpu : public IMuRenderer command.depthMaskEnabled = m_depthMaskEnabled; command.cullFaceEnabled = m_cullFaceEnabled; command.bloomExcluded = s_bloomExclusionDepth > 0; + command.groundShadow = s_groundShadowDepth > 0; + command.worldLit = s_worldLitGeometryDepth > 0; + if (command.worldLit) + { + s_frameHasWorldLit = true; + } } // ----------------------------------------------------------------------- @@ -5656,8 +5803,11 @@ class MuRendererSDLGpu : public IMuRenderer s_fragShaderLit = createShader("skinned_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 3, /*fatal=*/false); // The ground lit per pixel: the Transform (b0) of basic_textured.vert, and the uniforms of skinned_lit.frag. s_vertShaderWorldLit = createShader("world_lit", "vert", SDL_GPU_SHADERSTAGE_VERTEX, 0, 0, 1, /*fatal=*/false); + // world_lit.frag also samples the ground shadow mask (s1). s_fragShaderWorldLit = - createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 3, /*fatal=*/false); + createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 3, /*fatal=*/false); + s_fragShaderShadowMask = + createShader("shadow_mask", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 0, 0, 0, /*fatal=*/false); // Post-processing — non-fatal: without them post-processing is unavailable. // Bloom passes: source texture (t0) and BloomUniforms (b0); composite: scene, bloom and @@ -5736,8 +5886,9 @@ class MuRendererSDLGpu : public IMuRenderer SDL_ReleaseGPUShader(s_device, s_fragShaderLit); s_fragShaderLit = nullptr; } - for (SDL_GPUShader** shader : {&s_vertShaderWorldLit, &s_fragShaderWorldLit, &s_vertShaderPostFullscreen, - &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite}) + for (SDL_GPUShader** shader : + {&s_vertShaderWorldLit, &s_fragShaderWorldLit, &s_fragShaderShadowMask, &s_vertShaderPostFullscreen, + &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite}) { if (*shader) { @@ -5768,6 +5919,7 @@ class MuRendererSDLGpu : public IMuRenderer TexturedEnhancedFog, SkinnedLit, WorldLit, + ShadowMask, }; struct PipelineBuildDescription @@ -5781,6 +5933,8 @@ class MuRendererSDLGpu : public IMuRenderer bool cullFaceEnabled; FragmentShader fragmentShader = FragmentShader::Textured; bool alphaToCoverage = false; + // Into the ground shadow mask: one sample, no depth, instead of the frame's targets. + bool groundShadowMaskTarget = false; }; // The world sets built together, and what a failed pipeline means for them. @@ -5873,6 +6027,8 @@ class MuRendererSDLGpu : public IMuRenderer return s_fragShaderLit; case FragmentShader::WorldLit: return s_fragShaderWorldLit; + case FragmentShader::ShadowMask: + return s_fragShaderShadowMask; case FragmentShader::Textured: break; } @@ -5889,6 +6045,8 @@ class MuRendererSDLGpu : public IMuRenderer return "skinned_lit.frag"; case FragmentShader::WorldLit: return "world_lit.frag"; + case FragmentShader::ShadowMask: + return "shadow_mask.frag"; case FragmentShader::Textured: break; } @@ -5927,7 +6085,7 @@ class MuRendererSDLGpu : public IMuRenderer const SDL_GPUTextureFormat swapchainFmt = SDL_GetGPUSwapchainTextureFormat(s_device, s_window); SDL_GPUColorTargetDescription colorTargetDesc{}; - colorTargetDesc.format = swapchainFmt; + colorTargetDesc.format = description.groundShadowMaskTarget ? SDL_GPU_TEXTUREFORMAT_R8_UNORM : swapchainFmt; colorTargetDesc.blend_state = blendState; SDL_GPUVertexAttribute vertexAttribs[9]; @@ -6077,7 +6235,7 @@ class MuRendererSDLGpu : public IMuRenderer targetInfo.num_color_targets = 1; // Enable depth-stencil target so pipelines match // the render pass that now includes a depth buffer. - targetInfo.has_depth_stencil_target = true; + targetInfo.has_depth_stencil_target = !description.groundShadowMaskTarget; targetInfo.depth_stencil_format = mu::SdlGpuDepthFormat; // Back-face culling as the descriptor asks: on for opaque 3D geometry (depth write ON), @@ -6104,7 +6262,9 @@ class MuRendererSDLGpu : public IMuRenderer pipelineInfo.props = 0; pipelineInfo.multisample_state.sample_count = - mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); + description.groundShadowMaskTarget + ? SDL_GPU_SAMPLECOUNT_1 + : mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); pipelineInfo.multisample_state.enable_alpha_to_coverage = description.alphaToCoverage; result.pipeline = SDL_CreateGPUGraphicsPipeline(s_device, &pipelineInfo); @@ -6366,6 +6526,14 @@ class MuRendererSDLGpu : public IMuRenderer } } } + for (SDL_GPUGraphicsPipeline** pipeline : {&s_groundShadowMask3DPipeline, &s_groundShadowMaskSkinnedPipeline}) + { + if (*pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, *pipeline); + *pipeline = nullptr; + } + } DestroyAlphaCoveragePipelines(); s_postProcessing.DestroyPipelines(); } @@ -6487,6 +6655,7 @@ class MuRendererSDLGpu : public IMuRenderer } } CreateAlphaCoveragePipelines(); + CreateGroundShadowMaskPipelines(); CreatePostProcessingPipelines(); if (!CreateSingleSamplePipelines()) { @@ -6501,6 +6670,7 @@ class MuRendererSDLGpu : public IMuRenderer { return false; } + CreateGroundShadowMaskPipelines(); CreatePostProcessingPipelines(); } s_pipelinesMultisampled = s_sampleCount != Render::Antialiasing::OffSampleCount; @@ -6619,6 +6789,43 @@ class MuRendererSDLGpu : public IMuRenderer s_sampleCount); } + // The ground shadow mask's pipelines (one sample, whatever s_sampleCount is). Optional: without them + // ground shadows draw as recorded. + static void CreateGroundShadowMaskPipelines() + { + if (!s_fragShaderShadowMask) + { + return; + } + // The darkest shadow wins: overlapping shadows darken a pixel once. + SDL_GPUColorTargetBlendState darkest{}; + darkest.src_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE; + darkest.dst_color_blendfactor = SDL_GPU_BLENDFACTOR_ONE; + darkest.color_blend_op = SDL_GPU_BLENDOP_MIN; + darkest.src_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE; + darkest.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE; + darkest.alpha_blend_op = SDL_GPU_BLENDOP_MIN; + darkest.enable_blend = true; + const char* deviceDriver = SDL_GetGPUDeviceDriver(s_device); + const auto build = [&](SDL_GPUGraphicsPipeline*& destination, const char* name, VertexLayout layout) + { + PipelineBuildDescription description{name, "darkest", k_PipelineDisabled, false, false, + layout, false, FragmentShader::ShadowMask}; + description.groundShadowMaskTarget = true; + const PipelineBuildResult result = BuildBlendPipeline(darkest, description); + destination = result.pipeline; + if (!destination) + { + LogPipelineFailure(deviceDriver ? deviceDriver : "unknown", result, false); + } + }; + build(s_groundShadowMask3DPipeline, "ground-shadow-mask-3d", VertexLayout::ThreeDimensional); + if (s_vertShaderSkinnedShadow) + { + build(s_groundShadowMaskSkinnedPipeline, "ground-shadow-mask-skinned", VertexLayout::SkinnedShadow); + } + } + // Alpha-to-coverage variants for s_sampleCount; none with one sample. // Optional: a variant that fails leaves its draws on the opaque pipeline. static void CreateAlphaCoveragePipelines() @@ -6920,7 +7127,7 @@ class MuRendererSDLGpu : public IMuRenderer const SDL_Rect scissor{0, 0, static_cast(capture.width), static_cast(capture.height)}; SDL_SetGPUScissor(s_renderPass, &scissor); PushSceneLightingUniforms(); - + s_singleSamplePass = true; Render::SdlGpuReplayState replayState; for (std::size_t i = capture.startCmd; i < capture.endCmd && i < s_renderCmds.size(); ++i) diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index 6310649663..7fc2dcb5a1 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -86,6 +86,8 @@ static_assert(sizeof(SceneLightingUniform) == 8 * kSceneLightingRegisterSize); // Point lights on models light a face with saturate(dot(n, l) * (1 - wrap) + wrap): 0 is Lambert, // 0.5 (the built-in value) half-Lambert. Up to 0.5 a face turned away from the light gets nothing. inline constexpr float kDefaultDynamicWrap = 0.5f; +// How much a character's shadow darkens the world-lit ground's own light (the built-in value). +inline constexpr float kDefaultGroundShadowOpacity = 0.6f; // CPU mirror of the wrapped diffuse in skinned_lit.frag.hlsl's DynamicLighting(); the shader is the // implementation. [[nodiscard]] float WrappedDiffuse(float normalDotLight, float wrap); @@ -102,7 +104,8 @@ struct DynamicLightsUniform float wrap = kDefaultDynamicWrap; // see WrappedDiffuse() // The first lights, which the ground's vertex colour leaves out (ScopedWorldLitGeometry). std::uint32_t worldLightCount = 0; - std::uint32_t padding = 0; + // How much a ground shadow darkens the ground's own light, 0 to 1 (ScopedGroundShadow). + float groundShadowOpacity = 0.f; float positionAndRadius[kMaxDynamicLights][4]; // xyz world position, w radius in world units float color[kMaxDynamicLights][4]; // rgb, w unused }; diff --git a/src/source/Render/Renderer/SdlGpuReplayState.h b/src/source/Render/Renderer/SdlGpuReplayState.h index b6f25b8e05..a7d87d4e52 100644 --- a/src/source/Render/Renderer/SdlGpuReplayState.h +++ b/src/source/Render/Renderer/SdlGpuReplayState.h @@ -13,7 +13,7 @@ class SdlGpuReplayState final public: bool SelectPipeline(SDL_GPUGraphicsPipeline* pipeline); bool SelectFragmentSampler(SDL_GPUTexture* texture, SDL_GPUSampler* sampler); - // The second fragment texture slot (skinned_lit.frag's normal map). + // The second fragment texture slot (skinned_lit.frag's normal map, world_lit.frag's ground shadow mask). bool SelectNormalMapSampler(SDL_GPUTexture* texture, SDL_GPUSampler* sampler); bool SelectVertexUniforms(Uint32 slot, std::span bytes); bool SelectFragmentUniforms(std::span bytes); diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index 83b4005903..7c3325312f 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -84,6 +84,7 @@ void SubmitDynamicLights() world.IsPinned() ? Render::Lighting::SelectDynamicLights(world.Selection(), lights.LightsSinceMark(), reference) : Render::Lighting::SelectDynamicLights(lights.Lights(), reference); selection.uniform.wrap = Render::Look::Value(Data::Maps::LookValue::DynamicWrap); + selection.uniform.groundShadowOpacity = Render::Look::Value(Data::Maps::LookValue::GroundShadowOpacity); mu::GetRenderer().SetDynamicLights(selection.uniform); if (selection.dropped > 0 || lights.Overflow() > 0) diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 8b94354bc2..4c36bd0e8d 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -54,6 +54,8 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningSkillFade, I18N::Game::TuningSkillFadeHelp}; case TuningControlId::EffectCap: return {I18N::Game::TuningOverlappingLightCap, I18N::Game::TuningOverlappingLightCapHelp}; + case TuningControlId::ShadowOpacity: + return {I18N::Game::TuningShadowOpacity, I18N::Game::TuningShadowOpacityHelp}; case TuningControlId::Wrap: return {I18N::Game::TuningLightWrap, I18N::Game::TuningLightWrapHelp}; case TuningControlId::MapSmoothing: diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index c7db2b0639..aa36b2a647 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -55,6 +55,7 @@ TEST_CASE("the look profile's built-in values are the renderer's values before i CHECK(BuiltInFloat(LookValue::DynamicEffectRangeMax) == classicHistory.effectRangeMax); CHECK(BuiltInFloat(LookValue::DynamicEffectFade) == classicHistory.effectFadeSeconds); CHECK(BuiltInFloat(LookValue::DynamicEffectCap) == classicHistory.effectCap); + CHECK(BuiltInFloat(LookValue::GroundShadowOpacity) == mu::kDefaultGroundShadowOpacity); // Post-processing: the former config.ini default bloom strength, the level weight, full grading. CHECK(BuiltIn(LookValue::BloomStrength) == Approx(0.6)); @@ -222,6 +223,7 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$dynlights wrap 0.3", LookValue::DynamicWrap, 0.3); single(L"$dynlights smooth 0.4", LookValue::DynamicMapSmoothing, 0.4); single(L"$dynlights cap 1", LookValue::DynamicEffectCap, 1.0); + single(L"$dynlights shadow 0.4", LookValue::GroundShadowOpacity, 0.4); single(L"$bloom falloff 0.6", LookValue::BloomLevelFalloff, 0.6); single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); diff --git a/tests/render/test_projected_shadow_state.cmake b/tests/render/test_projected_shadow_state.cmake index 8bebd40881..f8bd140066 100644 --- a/tests/render/test_projected_shadow_state.cmake +++ b/tests/render/test_projected_shadow_state.cmake @@ -18,6 +18,14 @@ endif() math(EXPR shadow_length "${shadow_end} - ${shadow_start}") string(SUBSTRING "${bmd_source}" ${shadow_start} ${shadow_length} projected_shadow_source) +# Every path (GPU, CPU fallback, cloth) records inside the ground-shadow scope, so a world-lit frame +# draws them into the ground shadow mask. +string(FIND "${projected_shadow_source}" "const mu::ScopedGroundShadow groundShadow;" scope_position) +string(FIND "${projected_shadow_source}" "RenderGpuMeshShadow(" first_draw_position) +if(scope_position EQUAL -1 OR first_draw_position LESS scope_position) + message(FATAL_ERROR "Projected body shadows must be recorded inside a ScopedGroundShadow") +endif() + foreach(required_call IN ITEMS AddMeshShadowTriangles AddClothesShadowTriangles) string(FIND "${projected_shadow_source}" "${required_call}(" call_position) if(call_position EQUAL -1) diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index 8504d076f1..38c7046864 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -63,6 +63,8 @@ const SpecRow Spec[] = { TuningUnit::Seconds, TuningZero::Immediate}, {TuningControlId::EffectCap, TuningGroup::DynamicLights, false, LookValue::DynamicEffectCap, 0, 8, 0.1, TuningUnit::None, TuningZero::NoCap}, + {TuningControlId::ShadowOpacity, TuningGroup::DynamicLights, false, LookValue::GroundShadowOpacity, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, {TuningControlId::Wrap, TuningGroup::DynamicLights, true, LookValue::DynamicWrap, 0, 0.5, 0.05, TuningUnit::None, TuningZero::Plain}, {TuningControlId::MapSmoothing, TuningGroup::DynamicLights, true, LookValue::DynamicMapSmoothing, 0, 2, 0.05, @@ -92,9 +94,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 19 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 20 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 19); + REQUIRE(Render::Look::TuningControlCount == 20); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From e78044d485c668556768237c08aa2923495bb43f Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 19:41:27 +0800 Subject: [PATCH 03/17] feat(render): Enhanced character shadows fall away from the map's sun Body shadows always fell towards world -x, while the sun that shades the terrain's slopes shines from +x/-y, so shadows and terrain shading never agreed. With Enhanced dynamic lights the shadow's shear now acts along a per-map direction: - dynamic.shadowAngle (Look.json, per map) is where shadows fall, in degrees counter-clockwise from world +x. The shipped default is 135, directly away from the terrain's sun; the built-in 180 is the Classic direction. - The CPU, cloth and GPU-skinned paths take one mu::ShadowProjection with the shear's axis angle; at angle 0 the shear is Classic's exactly. - A "Shadow direction" slider under Dynamic lights' More settings (new degrees unit) and `$dynlights shadowangle `. - Classic and Dynamic lights off keep the Classic direction. --- docs/enhanced-look.md | 4 +- src/Localization/Game.en.resx | 6 ++ src/bin/Data/Render/Look.json | 1 + src/shaders/skinned_shadow.hlsli | 7 +- .../Data/GameData/MapData/LookProfile.cpp | 1 + .../Data/GameData/MapData/LookProfile.h | 1 + src/source/Render/Look/LookTuningCommand.cpp | 1 + src/source/Render/Look/LookTuningCommand.h | 1 + src/source/Render/Look/TuningControls.cpp | 2 + src/source/Render/Look/TuningControls.h | 2 + src/source/Render/Models/ZzzBMD.cpp | 90 ++++++++++--------- src/source/Render/Models/ZzzBMD.h | 20 +++-- src/source/Render/Renderer/MuRenderer.h | 3 + .../Render/Renderer/MuRendererSDLGpu.cpp | 3 +- src/source/Render/Renderer/SceneLighting.h | 2 + src/source/UI/Options/TuningRows.cpp | 5 ++ tests/data/test_look_profile_json.cpp | 2 +- tests/render/test_look_profile.cpp | 2 + tests/render/test_tuning_controls.cpp | 6 +- 19 files changed, 103 insertions(+), 56 deletions(-) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 07f16fbbb8..3c69083cce 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -84,6 +84,7 @@ window. | Dynamic lights | Light wrap | `dynamic.wrap` | 0–0.5 | 0.05 | 0.3 | More settings | | Dynamic lights | Map-light smoothing | `dynamic.mapSmoothing` | 0–2 s | 0.05 s | 0.5 s | More settings | | Dynamic lights | Maximum skill radius | `dynamic.effectRangeMax` | 0–16 cells | 1 cell | 8 cells | More settings | +| Dynamic lights | Shadow direction | `dynamic.shadowAngle` | 0–360° | 5° | 135° | More settings | | Darker map light | Mood strength | `mood.strengthPercent` | 0–100 % | 1 % | 100 % | common | | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | @@ -204,6 +205,7 @@ for the whole file. | `dynamic.effectFade` | 0.5 | 0 | 0–2 | seconds over which a spell's light fades out after it ends | | `dynamic.effectCap` | 2.5 | 0 (none) | 0–8 | the most light overlapping spell lights may add up to | | `dynamic.shadowOpacity` | 0.6 | 0.6 | 0–1 | how much characters' shadows darken the ground's own light; overlapping shadows darken it once, and point lights still light shadowed ground | +| `dynamic.shadowAngle` | 135 | 180 | 0–360 | which way characters' shadows fall, in degrees counter-clockwise from world +x; 135 falls away from the sun that shades the terrain's slopes, 180 is the Classic direction | | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | @@ -235,7 +237,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$bloom falloff `, `$bloom `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$bloom falloff `, `$bloom `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index 2ff0fae57b..a0fefc6311 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1156,6 +1156,12 @@ How dark characters' shadows make the ground. Candle, fire and skill light still lights shadowed ground. + + Shadow direction + + + Which way characters' shadows fall, away from the map's sun: 0 degrees is east, 90 north, 180 west (as in the original look). + Light wrap diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 9b0fe4c6d1..6678a9e8ef 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -17,6 +17,7 @@ "dynamic.effectFade": 0.5, "dynamic.effectCap": 2.5, "dynamic.shadowOpacity": 0.6, + "dynamic.shadowAngle": 135, "bloom.strength": 1.0, "bloom.levelFalloff": 0.6, "grading.strength": 1 diff --git a/src/shaders/skinned_shadow.hlsli b/src/shaders/skinned_shadow.hlsli index 4f717d96f2..74a03abbb6 100644 --- a/src/shaders/skinned_shadow.hlsli +++ b/src/shaders/skinned_shadow.hlsli @@ -27,7 +27,7 @@ cbuffer Skinning : register(b0, space1) cbuffer Shadow : register(b1, space1) { float4 shadowOrigin; // xyz: BodyOrigin, w: height of TW_HEIGHT cells - float4 shadowProjection; // x, y: sx, sy; z: 0 where RequestTerrainHeight() returns 0 + float4 shadowProjection; // x, y: sx, sy; z: 0 where RequestTerrainHeight() returns 0; w: axis angle }; struct VSOutput @@ -53,7 +53,10 @@ float4 clipPosition(float3 position) float3 shearShadow(float3 position) { float3 relative = position - shadowOrigin.xyz; - relative.x += relative.z * (relative.x + shadowProjection.x) / (relative.z - shadowProjection.y); + // The shear acts along the axis at angle w (0: x, as in Classic). + const float2 axis = float2(cos(shadowProjection.w), sin(shadowProjection.w)); + const float along = dot(relative.xy, axis); + relative.xy += axis * (relative.z * (along + shadowProjection.x) / (relative.z - shadowProjection.y)); return relative + shadowOrigin.xyz; } diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index 9e648efb84..e31e14730f 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -42,6 +42,7 @@ constexpr std::array Infos = {{ {LookValue::DynamicEffectFade, "dynamic.effectFade", 0.0, 0.0, 2.0}, {LookValue::DynamicEffectCap, "dynamic.effectCap", 0.0, 0.0, 8.0}, {LookValue::GroundShadowOpacity, "dynamic.shadowOpacity", 0.6, 0.0, 1.0}, + {LookValue::GroundShadowAngle, "dynamic.shadowAngle", 180.0, 0.0, 360.0}, {LookValue::BloomStrength, "bloom.strength", 0.6, 0.0, 2.0}, {LookValue::BloomLevelFalloff, "bloom.levelFalloff", 0.5, 0.25, 1.0}, {LookValue::GradingStrength, "grading.strength", 1.0, 0.0, 1.0}, diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index f550df34b1..0ba0a78614 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -44,6 +44,7 @@ enum class LookValue : std::uint8_t DynamicEffectFade, DynamicEffectCap, GroundShadowOpacity, + GroundShadowAngle, BloomStrength, BloomLevelFalloff, GradingStrength, diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 4df3fc5352..48d8d62c93 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -28,6 +28,7 @@ const CommandForm CommandForms[] = { {L"$dynlights cap ", {LookValue::DynamicEffectCap}}, {L"$dynlights reach ", {LookValue::DynamicEffectRangeMax}}, {L"$dynlights shadow ", {LookValue::GroundShadowOpacity}}, + {L"$dynlights shadowangle ", {LookValue::GroundShadowAngle}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$bloom ", {LookValue::BloomStrength}}, }; diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index c8cfa42d3d..48de95fe53 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -29,6 +29,7 @@ // $dynlights cap dynamic.effectCap // $dynlights reach dynamic.effectRangeMax // $dynlights shadow dynamic.shadowOpacity +// $dynlights shadowangle dynamic.shadowAngle // $bloom falloff bloom.levelFalloff // $bloom bloom.strength namespace Render::Look diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index 77d25f4e47..8db9d972a3 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -66,6 +66,8 @@ constexpr std::array Specs = {{ TuningUnit::Seconds, 1.0, TuningZero::Immediate}, {TuningControlId::EffectRangeMax, TuningGroup::DynamicLights, true, LookValue::DynamicEffectRangeMax, 1.0, TuningUnit::Cells, 1.0, TuningZero::NoCap}, + {TuningControlId::ShadowAngle, TuningGroup::DynamicLights, true, LookValue::GroundShadowAngle, 5.0, + TuningUnit::Degrees, 1.0, TuningZero::Plain}, {TuningControlId::MoodStrength, TuningGroup::LightMood, false, std::nullopt, 1.0, TuningUnit::Percent, 1.0, TuningZero::Plain}, {TuningControlId::BloomStrength, TuningGroup::PostProcessing, false, LookValue::BloomStrength, 0.05, diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index f5e6b71827..ac571850ca 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -39,6 +39,7 @@ enum class TuningUnit : std::uint8_t // Terrain cells. Cells, Percent, + Degrees, }; // What a value of zero means for a control, where it is not simply none of it. @@ -70,6 +71,7 @@ enum class TuningControlId : std::uint8_t Wrap, MapSmoothing, EffectRangeMax, + ShadowAngle, MoodStrength, BloomStrength, BloomLevelFalloff, diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index ce53d7708f..d6ef4baf4d 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -50,6 +50,8 @@ #include "Core/Utilities/FrameProfiler.h" #include "Scenes/MainScene.h" #include "Render/Lighting/LightMoodSetting.h" +#include "Render/Lighting/DynamicLightsSetting.h" +#include "Render/Look/LookProfileSetting.h" using mu::PackABGR; @@ -2531,8 +2533,9 @@ void BMD::RenderScriptedMesh(int mesh, int renderFlag, float alpha, int blendMes } } -__forceinline void CalcShadowPosition(vec3_t* position, const vec3_t origin, const float sx, const float sy) +__forceinline void CalcShadowPosition(vec3_t* position, const mu::ShadowProjection& projection) { + const float* origin = projection.origin; vec3_t result; VectorCopy(*position, result); @@ -2540,8 +2543,12 @@ __forceinline void CalcShadowPosition(vec3_t* position, const vec3_t origin, con // The result is the relative coordinate of the vertex to the origin. VectorSubtract(result, origin, result) - // scale the shadow in the x direction - result[0] += result[2] * (result[0] + sx) / (result[2] - sy); + // shear the shadow along its axis (x in Classic, where axisAngle is 0) + const float axis[2] = {std::cos(projection.axisAngle), std::sin(projection.axisAngle)}; + const float along = result[0] * axis[0] + result[1] * axis[1]; + const float shift = result[2] * (along + projection.shearX) / (result[2] - projection.shearHeight); + result[0] += shift * axis[0]; + result[1] += shift * axis[1]; // Add the origin again, to get the absolute coordinate of the vertex again VectorAdd(result, origin, result); @@ -2554,14 +2561,14 @@ __forceinline void CalcShadowPosition(vec3_t* position, const vec3_t origin, con } __forceinline void GetClothShadowPosition(vec3_t* target, const Render::ModelDrawing::ClothShadow& cloth, - const int index, const vec3_t origin, const float sx, const float sy) + const int index, const mu::ShadowProjection& projection) { VectorCopy(cloth.points[index], *target); - CalcShadowPosition(target, origin, sx, sy); + CalcShadowPosition(target, projection); } -void BMD::AddClothesShadowTriangles(std::span clothes, const float* origin, - const float sx, const float sy, const std::uint32_t color) const +void BMD::AddClothesShadowTriangles(std::span clothes, + const mu::ShadowProjection& projection, const std::uint32_t color) const { auto vertices = RenderArrayVertices; int target_vertex_index = -1; @@ -2584,10 +2591,10 @@ void BMD::AddClothesShadowTriangles(std::span(position), *static_cast(context)); +} -void ProjectOntoGround(float position[3], const void* context) +// The body shadow's shear axis: Classic's, or with Enhanced dynamic lights the map's shadow direction +// (dynamic.shadowAngle, where shadows fall; the shear axis points the other way). +float BodyShadowAxisAngle() { - const auto* ground = static_cast(context); - CalcShadowPosition(reinterpret_cast(position), ground->origin, ground->sx, ground->sy); + if (!Render::Lighting::DynamicLightsActive()) + { + return 0.f; + } + constexpr float RadiansPerDegree = 3.14159265358979f / 180.f; + return (Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle) + 180.f) * RadiansPerDegree; } -// CalcShadowPosition's projection for skinned_shadow.vert. +// Where CalcShadowPosition and skinned_shadow.vert put a body shadow. mu::ShadowProjection BodyShadowProjection(const vec3_t origin, const float sx, const float sy) { return { .origin = {origin[0], origin[1], origin[2]}, .shearX = sx, .shearHeight = sy, + .axisAngle = BodyShadowAxisAngle(), .specialHeight = g_fSpecialHeight, .terrain = SceneFlag != SERVER_LIST_SCENE && SceneFlag != WEBZEN_SCENE && SceneFlag != LOADING_SCENE, }; @@ -2719,7 +2730,7 @@ void BMD::ProjectWeightedShadowMesh(const Render::ModelDrawing::ShadowDraw& draw } void BMD::AddWeightedMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, const int startMesh, - const int endMesh, const float sx, const float sy, + const int endMesh, const mu::ShadowProjection& projection, const std::uint32_t color) const { constexpr std::size_t indexReach = std::size_t{std::numeric_limits::max()} + 1; @@ -2741,7 +2752,6 @@ void BMD::AddWeightedMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& batchIndices.clear(); }; - const ShadowGround ground{draw.bodyOrigin, sx, sy}; for (int i = startMesh; i < endMesh; i++) { if (i == draw.hiddenMesh) @@ -2754,7 +2764,7 @@ void BMD::AddWeightedMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& continue; } - ProjectWeightedShadowMesh(draw, i, ProjectOntoGround, &ground, meshVertices, meshIndices); + ProjectWeightedShadowMesh(draw, i, ProjectOntoGround, &projection, meshVertices, meshIndices); if (meshIndices.empty()) { continue; @@ -2821,8 +2831,8 @@ const vec3_t* BMD::ShadowVertices(const Render::ModelDrawing::ShadowDraw& draw, } void BMD::AddMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, const int blendMesh, - const int hiddenMesh, const int startMesh, const int endMesh, const float* origin, - const float sx, const float sy, const std::uint32_t color) const + const int hiddenMesh, const int startMesh, const int endMesh, + const mu::ShadowProjection& projection, const std::uint32_t color) const { auto vertices = RenderArrayVertices; int target_vertex_index = -1; @@ -2851,7 +2861,7 @@ void BMD::AddMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, c VectorCopy(positions[source_vertex_index], vertices[target_vertex_index]); - CalcShadowPosition(&vertices[target_vertex_index], origin, sx, sy); + CalcShadowPosition(&vertices[target_vertex_index], projection); } } } @@ -2872,7 +2882,7 @@ void BMD::AddMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, c } bool BMD::RenderGpuMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, const int startMesh, const int endMesh, - const float sx, const float sy, const std::uint32_t color) const + const mu::ShadowProjection& projection, const std::uint32_t color) const { if (!draw.skin.bones || startMesh < 0 || endMesh > NumMeshs || endMesh > MAX_MESH) { @@ -2946,11 +2956,11 @@ bool BMD::RenderGpuMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, cons .restPoseScale = draw.skin.restPoseScale, .translate = draw.skin.translate, }; - return renderer.RenderCachedSkinnedShadow(key, color, skinning, BodyShadowProjection(draw.bodyOrigin, sx, sy)); + return renderer.RenderCachedSkinnedShadow(key, color, skinning, projection); } void BMD::RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, const int startMesh, const int endMesh, - const float sx, const float sy, const std::uint32_t color) const + const mu::ShadowProjection& projection, const std::uint32_t color) const { const auto* gltf = Render::Models::Gltf::SkinnedModelOf(*this); auto& renderer = mu::GetRenderer(); @@ -2958,7 +2968,7 @@ void BMD::RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, !renderer.SetTerrainHeights({BackTerrainHeight, Render::kTerrainCells}, {TerrainWall, Render::kTerrainCells}, TerrainHeightVersion())) { - AddWeightedMeshShadowTriangles(draw, startMesh, endMesh, sx, sy, color); + AddWeightedMeshShadowTriangles(draw, startMesh, endMesh, projection, color); return; } @@ -2973,7 +2983,6 @@ void BMD::RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, .restPoseScale = draw.skin.restPoseScale, .translate = draw.skin.translate, }; - const mu::ShadowProjection projection = BodyShadowProjection(draw.bodyOrigin, sx, sy); for (int i = startMesh; i < endMesh; i++) { if (i == draw.hiddenMesh || Meshs[i].NumTriangles <= 0 || Meshs[i].Texture == draw.blendMesh) @@ -2989,7 +2998,7 @@ void BMD::RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, // As RenderGpuMeshShadow: CPU vertices already skinned this frame draw their own shadow. if (!lodMesh && ShadowOwnsVertices(draw, i)) { - AddWeightedMeshShadowTriangles(draw, i, i + 1, sx, sy, color); + AddWeightedMeshShadowTriangles(draw, i, i + 1, projection, color); continue; } @@ -3000,7 +3009,7 @@ void BMD::RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, renderer.CacheWeightedSkinnedMesh(key, WeightedCorners(packed, 0.f, 0.f))); if (!cached || !renderer.RenderCachedSkinnedShadow(key, color, skinning, projection)) { - AddWeightedMeshShadowTriangles(draw, i, i + 1, sx, sy, color); + AddWeightedMeshShadowTriangles(draw, i, i + 1, projection, color); } } } @@ -3098,25 +3107,24 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const const auto [startMesh, endMesh] = ResolveMeshRange(NumMeshs, draw.startMesh, draw.endMesh); - const float sx = gMapManager.InBattleCastle() ? 2500.f : 2000.f; - const float sy = 4000.f; + const mu::ShadowProjection projection = + BodyShadowProjection(draw.bodyOrigin, gMapManager.InBattleCastle() ? 2500.f : 2000.f, 4000.f); const std::uint32_t shadowColor = PackABGR(0.f, 0.f, 0.f, std::clamp(draw.alpha, 0.f, 1.f)); if (draw.clothes.empty() && Render::Models::Gltf::SkinnedModelOf(*this)) { - RenderWeightedMeshShadow(draw, startMesh, endMesh, sx, sy, shadowColor); + RenderWeightedMeshShadow(draw, startMesh, endMesh, projection, shadowColor); } else if (draw.clothes.empty()) { - if (!RenderGpuMeshShadow(draw, startMesh, endMesh, sx, sy, shadowColor)) + if (!RenderGpuMeshShadow(draw, startMesh, endMesh, projection, shadowColor)) { - AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, draw.bodyOrigin, sx, sy, - shadowColor); + AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, projection, shadowColor); } } else { - AddClothesShadowTriangles(draw.clothes, draw.bodyOrigin, sx, sy, shadowColor); + AddClothesShadowTriangles(draw.clothes, projection, shadowColor); } EndRender(); diff --git a/src/source/Render/Models/ZzzBMD.h b/src/source/Render/Models/ZzzBMD.h index 2937ed1fb7..7953b3b786 100644 --- a/src/source/Render/Models/ZzzBMD.h +++ b/src/source/Render/Models/ZzzBMD.h @@ -18,6 +18,11 @@ struct ShadowDraw; struct ClothShadow; } // namespace Render::ModelDrawing +namespace mu +{ +struct ShadowProjection; +} + struct BITMAP_t; extern const float (*g_pActiveBoneTransform)[3][4]; @@ -495,8 +500,8 @@ class BMD // The shadow streams the renderer keeps for the meshes of this slot. void ReleaseShadowStreams(); - void AddClothesShadowTriangles(std::span clothes, const float* origin, - float sx, float sy, std::uint32_t color) const; + void AddClothesShadowTriangles(std::span clothes, const mu::ShadowProjection& projection, + std::uint32_t color) const; // Whether VertexTransform[mesh] holds this model's vertices now: skinned on the CPU, or written by the cloth. [[nodiscard]] bool OwnsCpuVertices(int mesh) const; // Whether a shadow casts a mesh's own CPU vertices instead of skinning it on the GPU. @@ -505,19 +510,18 @@ class BMD // mesh skinned from the draw's skin without writing the scratch (valid until the next call). [[nodiscard]] const vec3_t* ShadowVertices(const Render::ModelDrawing::ShadowDraw& draw, int mesh) const; void AddMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, int blendMesh, int hiddenMesh, - int startMesh, int endMesh, const float* origin, float sx, float sy, - std::uint32_t color) const; + int startMesh, int endMesh, const mu::ShadowProjection& projection, std::uint32_t color) const; // The same shadow from a cached rest-pose stream skinned on the GPU; false leaves it to the CPU. [[nodiscard]] bool RenderGpuMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, int startMesh, int endMesh, - float sx, float sy, std::uint32_t color) const; + const mu::ShadowProjection& projection, std::uint32_t color) const; // AddMeshShadowTriangles of a model file: the meshes' shadows // (ProjectWeightedShadowMesh) drawn indexed, in mesh and triangle order. void AddWeightedMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, int startMesh, int endMesh, - float sx, float sy, std::uint32_t color) const; + const mu::ShadowProjection& projection, std::uint32_t color) const; // A model file's shadow, each mesh from the mesh its body draw caches on the GPU; a mesh the GPU cannot // draw gets its CPU shadow (AddWeightedMeshShadowTriangles). - void RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, int startMesh, int endMesh, float sx, - float sy, std::uint32_t color) const; + void RenderWeightedMeshShadow(const Render::ModelDrawing::ShadowDraw& draw, int startMesh, int endMesh, + const mu::ShadowProjection& projection, std::uint32_t color) const; }; extern BMD* Models; diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index bb81d4a708..cb2915f947 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -189,6 +189,9 @@ struct ShadowProjection float origin[3]{}; float shearX = 0.0f; // sx float shearHeight = 0.0f; // sy + // Radians from world +x to the axis the shear acts along; shadows fall the opposite way. 0 is + // Classic (shadows towards -x). + float axisAngle = 0.0f; float specialHeight = 0.0f; // the height of TW_HEIGHT cells bool terrain = true; // false in the scenes where RequestTerrainHeight() returns 0 }; diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index f64a306e9e..2b28da6d00 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -151,7 +151,7 @@ using WorldPipelines = Render::WorldPipelineSetshearX; shadowVu.projection[1] = shadow->shearHeight; shadowVu.projection[2] = shadow->terrain ? 1.0f : 0.0f; + shadowVu.projection[3] = shadow->axisAngle; } cmd.fogUniform = m_fogUniform; cmd.fogUniform.alphaToCoverage = coverage.alphaToCoverage ? 1u : 0u; diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index 7fc2dcb5a1..8c7b9a7a86 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -88,6 +88,8 @@ static_assert(sizeof(SceneLightingUniform) == 8 * kSceneLightingRegisterSize); inline constexpr float kDefaultDynamicWrap = 0.5f; // How much a character's shadow darkens the world-lit ground's own light (the built-in value). inline constexpr float kDefaultGroundShadowOpacity = 0.6f; +// Where characters' shadows fall, in degrees counter-clockwise from world +x: towards -x, as in Classic. +inline constexpr float kClassicGroundShadowAngle = 180.0f; // CPU mirror of the wrapped diffuse in skinned_lit.frag.hlsl's DynamicLighting(); the shader is the // implementation. [[nodiscard]] float WrappedDiffuse(float normalDotLight, float wrap); diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 4c36bd0e8d..94e1ec1dc0 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -56,6 +56,8 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningOverlappingLightCap, I18N::Game::TuningOverlappingLightCapHelp}; case TuningControlId::ShadowOpacity: return {I18N::Game::TuningShadowOpacity, I18N::Game::TuningShadowOpacityHelp}; + case TuningControlId::ShadowAngle: + return {I18N::Game::TuningShadowDirection, I18N::Game::TuningShadowDirectionHelp}; case TuningControlId::Wrap: return {I18N::Game::TuningLightWrap, I18N::Game::TuningLightWrapHelp}; case TuningControlId::MapSmoothing: @@ -165,6 +167,9 @@ std::string FormatTuningText(const TuningControl& control, double value) case TuningUnit::Percent: // The spacing of the UI Scale row ("100 %"). return number + " %"; + case TuningUnit::Degrees: + // U+00B0 DEGREE SIGN in UTF-8, the text encoding of the rows. + return number + "\xC2\xB0"; case TuningUnit::None: break; } diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index 3e263ee4ad..587a980f27 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -264,7 +264,7 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::DynamicEffectGain, 2.5}, {LookValue::DynamicEffectRange, 3.0}, {LookValue::DynamicEffectRangeMax, 8}, {LookValue::DynamicEffectFade, 0.5}, {LookValue::DynamicEffectCap, 2.5}, {LookValue::BloomStrength, 1.0}, - {LookValue::BloomLevelFalloff, 0.6}, + {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index aa36b2a647..2a8fe1ecbe 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -56,6 +56,7 @@ TEST_CASE("the look profile's built-in values are the renderer's values before i CHECK(BuiltInFloat(LookValue::DynamicEffectFade) == classicHistory.effectFadeSeconds); CHECK(BuiltInFloat(LookValue::DynamicEffectCap) == classicHistory.effectCap); CHECK(BuiltInFloat(LookValue::GroundShadowOpacity) == mu::kDefaultGroundShadowOpacity); + CHECK(BuiltInFloat(LookValue::GroundShadowAngle) == mu::kClassicGroundShadowAngle); // Post-processing: the former config.ini default bloom strength, the level weight, full grading. CHECK(BuiltIn(LookValue::BloomStrength) == Approx(0.6)); @@ -224,6 +225,7 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$dynlights smooth 0.4", LookValue::DynamicMapSmoothing, 0.4); single(L"$dynlights cap 1", LookValue::DynamicEffectCap, 1.0); single(L"$dynlights shadow 0.4", LookValue::GroundShadowOpacity, 0.4); + single(L"$dynlights shadowangle 90", LookValue::GroundShadowAngle, 90.0); single(L"$bloom falloff 0.6", LookValue::BloomLevelFalloff, 0.6); single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index 38c7046864..473c3652e4 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -71,6 +71,8 @@ const SpecRow Spec[] = { TuningUnit::Seconds, TuningZero::Immediate}, {TuningControlId::EffectRangeMax, TuningGroup::DynamicLights, true, LookValue::DynamicEffectRangeMax, 0, 16, 1, TuningUnit::Cells, TuningZero::NoCap}, + {TuningControlId::ShadowAngle, TuningGroup::DynamicLights, true, LookValue::GroundShadowAngle, 0, 360, 5, + TuningUnit::Degrees, TuningZero::Plain}, {TuningControlId::MoodStrength, TuningGroup::LightMood, false, std::nullopt, 0, 100, 1, TuningUnit::Percent, TuningZero::Plain}, {TuningControlId::BloomStrength, TuningGroup::PostProcessing, false, LookValue::BloomStrength, 0, 2, 0.05, @@ -94,9 +96,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 20 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 21 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 20); + REQUIRE(Render::Look::TuningControlCount == 21); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From d0b21924517a53fb59be9e37dfc034f764964fdb Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 19:45:29 +0800 Subject: [PATCH 04/17] feat(render): HDR Enhanced scene with a tone-mapped composite With post-processing the scene and bloom-source passes drew into textures of the swapchain's 8-bit format, so stacked additive light (overlapping spells, glows) clipped to flat white. They now draw into RGBA16F when the device can render it at the frame's sample count: - Every pipeline those passes replay has a twin built for RGBA16F (s_hdrScenePipelines, built like the single-sample twins, alpha-to-coverage variants paired by slot); s_hdrScenePass makes the replay use them. With anti-aliasing the passes resolve from an RGBA16F multisampled target. - The scene texture's format makes the scene HDR (EnsureTargets); the UI, offscreen captures and readback keep the swapchain format. - post_composite.frag rolls scene channels above 0.9 off towards 1 (the highlight-knee curve), before the bloom and grading, and adds a one-step ordered dither for the 8-bit target. An 8-bit scene composites as before. - Light below 0.9 is unchanged; inverse-colour blending over light above 1 can go negative and composites as black. --- src/shaders/compiled/post_composite.frag.dxil | Bin 5232 -> 5812 bytes src/shaders/compiled/post_composite.frag.msl | 72 ++++--- src/shaders/compiled/post_composite.frag.spv | Bin 3240 -> 5920 bytes src/shaders/post_composite.frag.hlsl | 31 ++- .../Render/Renderer/MuRendererSDLGpu.cpp | 185 +++++++++++++++++- .../Render/Renderer/SdlGpuPostProcessing.cpp | 29 ++- .../Render/Renderer/SdlGpuPostProcessing.h | 20 +- tests/render/test_look_profile.cpp | 2 +- 8 files changed, 291 insertions(+), 48 deletions(-) diff --git a/src/shaders/compiled/post_composite.frag.dxil b/src/shaders/compiled/post_composite.frag.dxil index 9d470866ee0edc7416937be6683eafa226e4bc7f..1d9ca13fc8fc63342a25e2bda1b9dce2fece9a84 100644 GIT binary patch delta 3674 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 delta 3038 zcmd^>dr(tn7QnxogqxdiliWann*_*>U>Y4(FAt+qwMl@8Et!oK@lmJ=4+RB9Q2P*@ zn};-NEK#r^P#b)-?5yj84@6s?Bp@h*LUmi?V=X8myW>u&R*D^`vo~Nnj@{jv{cmUX z&fNQb=bU@aneY3~`Q3Z+ccV&4>T+$$oOE65!KQ*P@8u53kw3k&7Xkp3iuOn(u!9T0 zVQy=(gfW#w05H-9lmS5M@K`Szi5>C&T}LlLKUJ4|?`HiMOd&02_wY;vx(WkiDDI-+v_O=F~A z9yx4^zD_AxbpviS98)jtoW(Sp>b7s5|n=5ev^l@t*ln? zR11m$ylH@K9AKyStL|0`?SoUUn4%YI6}}ReZwJod-68wmsZL6(A)m&1<^>B|LrI~M zP-d_gpn5&)w)sN_Bd|Mxi<0*Ru{;w~`mutbA0qlrh_1uM!VH&_qgdF*N}2Myk>$pB zx?_9X>Yk<~?m@EW&|kQ7-B`17M}pEWq^2mb<7=t2V(`;yfHXqHMwseq#cc0J)3E~A zdpH2+=~2SWaOup9(9Vz04G;gJM`OFDcBgg0itZyYD@dX1)hV3LVMRd-mVqJpR&}h@ zZt)WsE2#YphtX7w^X+xSrs!Q~S`$tm=P+97msZ=!ElWl?JnsMB?nM;Vf0yH*j~B;xr^zeI$n&L`>J%*f+l_#i}YX%y5@a zCi_)wQjx|w3s9kdjew;Hx4+Y99o^=JabF%t{x6a8vqkq6$;Vj?aAz5-#iKz$(@l{X@JiEXFJv-J6C zTGPuL4mHpr!gilId19t2K~i3{W>xv7P?m3sc3I_*_s101+bkP{hRtC{d3e4l9ADWS z^j7os>BYrcN@f)07p&j3#OmgX5A4d>e>?kT!>t;sP+R#RH==9xGR5qv%D=k?&-6BJ z-?Q)1taE$zwdy&pg#34Blogb3*j$!ZP`-o_-<(?cKwHaR7CtmQri+-^quFVcEx9>` z4pW=8r8ZTS7NJ`QLtg%B#-KyJdQRyA`U#*&%$|8mG zel*wwT`PTh<=#v_>A0Mt|6t=S)kKi()wR8Soi`4YyM9# zn9HRxSXKQsPcQq=C=^ud`4Q&WolQspe72o?l{PI7DXomA^)TfTgOD|#Ffusa@gVRO znt}LK?w6GbN2mrpIizk$o78m$c38nA+-N3Mzkt%xgMoo^qCS{uF?Ms(IKdA#&!ts6{ zi$Huo&JGC3mI>j{lfu>s;WgX|oI;8~?tV-E>;Mo0bAZ)Y`ib}W4hwF0E;T_NpLoTY zF|c{UctmrJ7MDLa{=ve83k>jehlW8Bc=ozcyG7Crsd8O_K;Q_eI@b-ab?wGu0b=!j z4GZz3UPgLEU0l=Y0cs3Auw=Q-G&zmVH2yL@kZCTo zc{_=nRl7AJS&U7&APd%2^rFsjzZn0%)$6L_RaO*}LwW1S&ThZaQFY3TeY%2Sa_5qa z`2d~{$MiFelY%a^-85%P9dodu0C#vQlU;odOJLRWz9hMppv~Y@p^XVNq~m?Bh%t}M zbyQ8OAY{SM%wRzqWvz(Ag2wSj>_@E>)#vasX}_cg6t}{~_V%;4Vf;ZOciZ!wBkM_| ztA_S43?$}`22Mo(YP(hWOyhF;l#Ly8TYO4-pFD+D%&9=FyhRno>38!|LS$0qQ@`O- zH~hweF-lVrM-1c{@Xl`Q2aE;bJ7}34$h&}F>_!skB^MAf=~b{mbr_ scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(constant CompositeUniforms& _35 [[buffer(0)]], texture2d scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - float2 _210 = gl_FragCoord.xy * _31.inverseTargetSize; - float4 _215 = scene.sample(sceneSampler, _210); - float4 _354; - if (_31.bloomScale > 0.0) + float2 _319 = gl_FragCoord.xy * _35.inverseTargetSize; + float4 _305 = scene.sample(sceneSampler, _319); + if (_35.toneMapKnee < 1.0) { - float3 _241 = float3(1.0) - ((float3(1.0) - _215.xyz) * (float3(1.0) - fast::clamp(bloom.sample(bloomSampler, _210).xyz * _31.bloomScale, float3(0.0), float3(1.0)))); - float4 _337 = _215; - _337.x = _241.x; - _337.y = _241.y; - _337.z = _241.z; - _354 = _337; + float4 _329 = _305; + float3 _331 = fast::max(_329.xyz, float3(0.0)); + _305.x = _331.x; + _305.y = _331.y; + _305.z = _331.z; + float _437 = 1.0 - _35.toneMapKnee; + float _342 = _305.y; + float _463 = 1.0 - _35.toneMapKnee; + float _345 = _305.z; + float _489 = 1.0 - _35.toneMapKnee; + _305.x = (_305.x > _35.toneMapKnee) ? (_35.toneMapKnee + (_437 * (1.0 - exp((-(_305.x - _35.toneMapKnee)) / _437)))) : _305.x; + _305.y = (_342 > _35.toneMapKnee) ? (_35.toneMapKnee + (_463 * (1.0 - exp((-(_342 - _35.toneMapKnee)) / _463)))) : _342; + _305.z = (_345 > _35.toneMapKnee) ? (_35.toneMapKnee + (_489 * (1.0 - exp((-(_345 - _35.toneMapKnee)) / _489)))) : _345; } - else + if (_35.bloomScale > 0.0) { - _354 = _215; + float4 _371 = _305; + float3 _380 = float3(1.0) - ((float3(1.0) - _371.xyz) * (float3(1.0) - fast::clamp(bloom.sample(bloomSampler, _319).xyz * _35.bloomScale, float3(0.0), float3(1.0)))); + _305.x = _380.x; + _305.y = _380.y; + _305.z = _380.z; } - float4 _355; - if (_31.gradingStrength > 0.0) + if (_35.gradingStrength > 0.0) { - float _282 = _354.z * 31.0; - float _284 = floor(_282); - float _295 = ((_354.x * 31.0) + 0.5) * 0.0009765625; - float _300 = ((_354.y * 31.0) + 0.5) * 0.03125; - float3 _261 = mix(_354.xyz, mix(grading.sample(gradingSampler, float2(_295 + (_284 * 0.03125), _300)).xyz, grading.sample(gradingSampler, float2(_295 + (fast::min(_284 + 1.0, 31.0) * 0.03125), _300)).xyz, float3(_282 - _284)), float3(_31.gradingStrength)); - float4 _346 = _354; - _346.x = _261.x; - _346.y = _261.y; - _346.z = _261.z; - _355 = _346; + float4 _392 = _305; + float3 _310 = _392.xyz; + float _522 = _310.z * 31.0; + float _524 = floor(_522); + float _535 = ((_310.x * 31.0) + 0.5) * 0.0009765625; + float _540 = ((_310.y * 31.0) + 0.5) * 0.03125; + float3 _400 = mix(_392.xyz, mix(grading.sample(gradingSampler, float2(_535 + (_524 * 0.03125), _540)).xyz, grading.sample(gradingSampler, float2(_535 + (fast::min(_524 + 1.0, 31.0) * 0.03125), _540)).xyz, float3(_522 - _524)), float3(_35.gradingStrength)); + _305.x = _400.x; + _305.y = _400.y; + _305.z = _400.z; } - else + if (_35.ditherAmount > 0.0) { - _355 = _354; + float4 _420 = _305; + float3 _423 = _420.xyz + float3((fract(52.98291778564453125 * fract(dot(gl_FragCoord.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))) - 0.5) * _35.ditherAmount); + _305.x = _423.x; + _305.y = _423.y; + _305.z = _423.z; } - out._entryPointOutput = _355; + out._entryPointOutput = _305; return out; } diff --git a/src/shaders/compiled/post_composite.frag.spv b/src/shaders/compiled/post_composite.frag.spv index 21f25565be45cd580fe9e645fb6334bf4ad102cd..ec8e2284f1cb7fe2bfca20232ca14296498708c3 100644 GIT binary patch literal 5920 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 diff --git a/src/shaders/post_composite.frag.hlsl b/src/shaders/post_composite.frag.hlsl index a609db59b8..f5c037586f 100644 --- a/src/shaders/post_composite.frag.hlsl +++ b/src/shaders/post_composite.frag.hlsl @@ -1,6 +1,6 @@ -// post_composite.frag.hlsl — the processed 3D scene: the scene image with its bloom screen-blended -// on top, colour graded through the map's lookup table. Draws into the frame's destination before -// the UI. +// post_composite.frag.hlsl — the processed 3D scene: the scene image (an HDR scene tone mapped), +// with its bloom screen-blended on top, colour graded through the map's lookup table and dithered. +// Draws into the frame's destination before the UI. // CompositeUniforms mirrors mu::SdlGpuCompositeUniform. Texture2D scene : register(t0, space2); SamplerState sceneSampler : register(s0, space2); // point: one scene texel per pixel @@ -13,6 +13,9 @@ cbuffer CompositeUniforms : register(b0, space3) float2 inverseTargetSize; float bloomScale; // 0: no bloom float gradingStrength; // 0: ungraded; else blend of the graded colour with the ungraded one + float toneMapKnee; // channels above it roll off towards 1; 1: none + float ditherAmount; // 0: no dither + float2 compositePadding; }; struct FSInput { @@ -28,10 +31,30 @@ static const float kGradingSize = 32.0; // bloom, grading): spirv-cross numbers Metal textures in that order. float3 Grade(float3 color); +// The HDR scene's tone map: unchanged up to the knee, then an exponential shoulder towards 1, so +// stacked light rolls off instead of clipping. The same curve as skinned_lit.frag's highlight knee. +float ToneMapChannel(float value) +{ + const float range = 1.0 - toneMapKnee; + return value > toneMapKnee ? toneMapKnee + range * (1.0 - exp(-(value - toneMapKnee) / range)) : value; +} + +// Interleaved gradient noise in [0, 1): an ordered dither pattern without a texture. +float DitherNoise(float2 pixel) +{ + return frac(52.9829189 * frac(dot(pixel, float2(0.06711056, 0.00583715)))); +} + float4 main(FSInput input) : SV_Target { const float2 uv = input.pos.xy * inverseTargetSize; float4 color = scene.Sample(sceneSampler, uv); + if (toneMapKnee < 1.0) + { + // Blending over light above 1 (inverse colour) can leave negative values: black. + color.rgb = max(color.rgb, 0.0); + color.rgb = float3(ToneMapChannel(color.r), ToneMapChannel(color.g), ToneMapChannel(color.b)); + } if (bloomScale > 0.0) { // Screen blend: a dark pixel gains about the glow's light, a bright one little, so glows @@ -44,6 +67,8 @@ float4 main(FSInput input) : SV_Target // Render::PostProcessing::BlendGrading mirrors this blend. color.rgb = lerp(color.rgb, Grade(color.rgb), gradingStrength); } + if (ditherAmount > 0.0) + color.rgb += (DitherNoise(input.pos.xy) - 0.5) * ditherAmount; return color; } diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 2b28da6d00..14dd86a812 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -1099,6 +1099,15 @@ static void BindReplayIndexBuffer(SDL_GPUBuffer* buffer, Uint32 offset, SDL_GPUI // sample. s_singleSamplePass makes ReplayDrawCommand use the twins. static std::unordered_map s_singleSamplePipelines; static bool s_singleSamplePass = false; +// The HDR scene: with post-processing, the scene and bloom-source passes draw into float textures +// (kHdrSceneFormat), so additive light stacks above 1 and the composite rolls it off. Each pipeline +// those passes use maps to its twin built for that format; s_hdrScenePass makes ReplayDrawCommand +// use them. Empty when the device cannot render the format at the frame's sample count. +static constexpr SDL_GPUTextureFormat kHdrSceneFormat = SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT; +static std::unordered_map s_hdrScenePipelines; +static bool s_hdrScenePass = false; +// The colour format CreatePipelines builds for instead of the swapchain's (INVALID: the swapchain's). +static SDL_GPUTextureFormat s_pipelineFormatOverride = SDL_GPU_TEXTUREFORMAT_INVALID; // Whether the built pipelines are multisampled; set by CreatePipelinesForSampleCount. static bool s_pipelinesMultisampled = false; @@ -1114,6 +1123,11 @@ static void ReplayDrawCommand(const RenderCmd& command, SDL_GPUGraphicsPipeline* const auto twin = s_singleSamplePipelines.find(pipeline); pipeline = twin != s_singleSamplePipelines.end() ? twin->second : nullptr; } + else if (s_hdrScenePass) + { + const auto twin = s_hdrScenePipelines.find(pipeline); + pipeline = twin != s_hdrScenePipelines.end() ? twin->second : nullptr; + } const bool skinned = command.type == RenderCmdType::DrawSkinnedTriangles; const bool shadow = skinned && command.shadowIndex != ~0u; if (!command.texture || !command.sampler || (skinned && (!boneDataReady || !s_boneGpuBuf)) || @@ -1257,6 +1271,9 @@ static bool s_alphaCoverageDrawLogged = false; static Render::Antialiasing::SupportedSampleCounts s_supportedSampleCounts{}; static SDL_GPUTexture* s_multisampleColorTexture = nullptr; static SDL_GPUTextureCreateInfo s_multisampleColorInfo{}; +// The HDR scene's multisampled colour target (kHdrSceneFormat), while anti-aliasing is on. +static SDL_GPUTexture* s_hdrMultisampleColorTexture = nullptr; +static SDL_GPUTextureCreateInfo s_hdrMultisampleColorInfo{}; // The depth of a single-sample pass at the frame's size while the frame's own depth is multisampled. static SDL_GPUTexture* s_singleSampleDepthTexture = nullptr; static Uint32 s_singleSampleDepthW = 0u; @@ -2684,8 +2701,7 @@ class MuRendererSDLGpu : public IMuRenderer { constexpr SDL_FColor noLight{0.0f, 0.0f, 0.0f, 0.0f}; const SDL_GPUColorTargetInfo colorTarget = CycledTarget(mu::GetSdlGpuFrameColorTarget( - {s_postProcessing.GetBloomSourceTexture(), IsMultisampled() ? s_multisampleColorTexture : nullptr}, - noLight)); + {s_postProcessing.GetBloomSourceTexture(), SceneMultisampleTexture()}, noLight)); // The UI pass tests against the same depth, so it is kept. if (!BeginReplayPass(colorTarget, MakeDepthTarget(SDL_GPU_LOADOP_LOAD, SDL_GPU_STOREOP_STORE))) { @@ -2697,6 +2713,17 @@ class MuRendererSDLGpu : public IMuRenderer s_postProcessing.RenderBloom(s_cmdBuf, s_postProcessingLook.bloomLevelFalloff); } + // The multisampled colour target of the scene and bloom-source passes: the HDR one with the HDR + // scene; null with one sample. + [[nodiscard]] static SDL_GPUTexture* SceneMultisampleTexture() + { + if (!IsMultisampled()) + { + return nullptr; + } + return s_hdrScenePass ? s_hdrMultisampleColorTexture : s_multisampleColorTexture; + } + // The scene into the scene texture, its bloom, then the processed scene and // the UI on top of it into `destination`. [[nodiscard]] static bool ReplayPostProcessedFrame(SDL_GPUTexture* destination, std::size_t sceneEnd, @@ -2704,14 +2731,17 @@ class MuRendererSDLGpu : public IMuRenderer { SDL_GPUTexture* const multisampled = IsMultisampled() ? s_multisampleColorTexture : nullptr; ReplayView view = FullFrameView(); + RenderGroundShadowMask(sceneEnd, boneDataReady); + // The scene texture's format says whether this frame's scene is HDR (EnsureTargets). + s_hdrScenePass = s_postProcessing.IsHdrScene(); // Its depth stays for the bloom and UI passes, which test against it as // the UI did when it shared the scene's pass. - const SDL_GPUColorTargetInfo sceneTarget = CycledTarget( - mu::GetSdlGpuFrameColorTarget({s_postProcessing.GetSceneTexture(), multisampled}, s_clearColor)); - RenderGroundShadowMask(sceneEnd, boneDataReady); + const SDL_GPUColorTargetInfo sceneTarget = CycledTarget(mu::GetSdlGpuFrameColorTarget( + {s_postProcessing.GetSceneTexture(), SceneMultisampleTexture()}, s_clearColor)); if (!BeginReplayPass(sceneTarget, MakeDepthTarget(SDL_GPU_LOADOP_CLEAR, SDL_GPU_STOREOP_STORE))) { + s_hdrScenePass = false; return false; } ReplayCommands(0u, sceneEnd, boneDataReady, ReplaySelection::AllCommands, view); @@ -2721,6 +2751,7 @@ class MuRendererSDLGpu : public IMuRenderer { RenderBloomSources(sceneEnd, boneDataReady); } + s_hdrScenePass = false; // The composite covers every pixel: the target's old content is not loaded. // A diagnostic view without its image this frame leaves black instead. @@ -3121,7 +3152,9 @@ class MuRendererSDLGpu : public IMuRenderer // sample: the rest follows the same way, without multisampling or post-processing. renderPassCompleted = ContinueFlushedFrame(frameColorTexture, boneDataReady); } - else if (split.postProcessed && s_postProcessing.EnsureTargets({s_swapW, s_swapH})) + else if (split.postProcessed && + s_postProcessing.EnsureTargets({s_swapW, s_swapH}, + UsesHdrScene() ? kHdrSceneFormat : SDL_GPU_TEXTUREFORMAT_INVALID)) { renderPassCompleted = ReplayPostProcessedFrame(frameColorTexture, split.sceneEnd, boneDataReady); } @@ -6086,7 +6119,9 @@ class MuRendererSDLGpu : public IMuRenderer const SDL_GPUTextureFormat swapchainFmt = SDL_GetGPUSwapchainTextureFormat(s_device, s_window); SDL_GPUColorTargetDescription colorTargetDesc{}; - colorTargetDesc.format = description.groundShadowMaskTarget ? SDL_GPU_TEXTUREFORMAT_R8_UNORM : swapchainFmt; + colorTargetDesc.format = description.groundShadowMaskTarget ? SDL_GPU_TEXTUREFORMAT_R8_UNORM + : s_pipelineFormatOverride != SDL_GPU_TEXTUREFORMAT_INVALID ? s_pipelineFormatOverride + : swapchainFmt; colorTargetDesc.blend_state = blendState; SDL_GPUVertexAttribute vertexAttribs[9]; @@ -6510,6 +6545,7 @@ class MuRendererSDLGpu : public IMuRenderer static void DestroyPipelines() { + DestroyHdrScenePipelines(); DestroySingleSamplePipelines(); s_pipelinesMultisampled = false; DestroyEnhancedPipelines(); @@ -6675,9 +6711,143 @@ class MuRendererSDLGpu : public IMuRenderer CreatePostProcessingPipelines(); } s_pipelinesMultisampled = s_sampleCount != Render::Antialiasing::OffSampleCount; + CreateHdrScenePipelines(); + return true; + } + + // The HDR scene's twins of every pipeline the scene and bloom-source passes replay, built for + // kHdrSceneFormat at s_sampleCount (an alpha-to-coverage variant maps to the variant built for its + // twin). Optional: without a complete set the scene stays in the swapchain's format. + static void CreateHdrScenePipelines() + { + DestroyHdrScenePipelines(); + const SDL_GPUTextureUsageFlags usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + const SDL_GPUSampleCount sampleCount = mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); + if (!SDL_GPUTextureSupportsFormat(s_device, kHdrSceneFormat, SDL_GPU_TEXTURETYPE_2D, usage) || + !SDL_GPUTextureSupportsSampleCount(s_device, kHdrSceneFormat, sampleCount)) + { + mu::log::Get("render")->info("SDL_gpu -- HDR scene unavailable at {}x: format unsupported", s_sampleCount); + return; + } + + const std::vector slots = ReplayPipelineSlots(); + std::vector frameFormat; + frameFormat.reserve(slots.size()); + for (SDL_GPUGraphicsPipeline** slot : slots) + { + frameFormat.push_back(*slot); + *slot = nullptr; + } + const bool enhancedLightingAvailable = s_enhancedLightingAvailable; + std::vector frameFormatCoverage; + frameFormatCoverage.swap(s_alphaCoveragePipelines); + + s_pipelineFormatOverride = kHdrSceneFormat; + const bool created = CreatePipelines(); + CreateAlphaCoveragePipelines(); + s_pipelineFormatOverride = SDL_GPU_TEXTUREFORMAT_INVALID; + + for (std::size_t i = 0; i < slots.size(); ++i) + { + if (frameFormat[i] && *slots[i]) + { + s_hdrScenePipelines[frameFormat[i]] = *slots[i]; + } + else if (*slots[i]) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, *slots[i]); + } + *slots[i] = frameFormat[i]; + } + s_enhancedLightingAvailable = enhancedLightingAvailable; + // Both coverage lists were built for the same slots in the same order: pair them by slot. + for (const AlphaCoveragePipeline& hdr : s_alphaCoveragePipelines) + { + const auto original = std::ranges::find(frameFormatCoverage, hdr.opaque, &AlphaCoveragePipeline::opaque); + if (original != frameFormatCoverage.end()) + { + s_hdrScenePipelines[original->variant] = hdr.variant; + } + else + { + SDL_ReleaseGPUGraphicsPipeline(s_device, hdr.variant); + } + } + s_alphaCoveragePipelines.swap(frameFormatCoverage); + for (const AlphaCoveragePipeline& entry : s_alphaCoveragePipelines) + { + frameFormat.push_back(entry.variant); + } + + if (!created || !Render::SingleSampleTwinsComplete(frameFormat, s_hdrScenePipelines)) + { + mu::log::Get("render")->warn("SDL_gpu -- HDR scene pipelines incomplete at {}x; HDR scene off", + s_sampleCount); + DestroyHdrScenePipelines(); + return; + } + mu::log::Get("render")->info("SDL_gpu -- {} HDR scene pipelines at {}x", s_hdrScenePipelines.size(), + s_sampleCount); + } + + static void DestroyHdrScenePipelines() + { + std::unordered_set released; + for (const auto& [frameFormat, twin] : s_hdrScenePipelines) + { + if (twin && released.insert(twin).second) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, twin); + } + } + s_hdrScenePipelines.clear(); + } + + // The HDR scene this frame: its pipelines, and with anti-aliasing its multisampled target. + [[nodiscard]] static bool UsesHdrScene() + { + return !s_hdrScenePipelines.empty() && (!IsMultisampled() || EnsureHdrMultisampleColorTexture()); + } + + [[nodiscard]] static bool EnsureHdrMultisampleColorTexture() + { + const SDL_GPUSampleCount sampleCount = mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); + if (s_hdrMultisampleColorTexture && s_hdrMultisampleColorInfo.width == s_swapW && + s_hdrMultisampleColorInfo.height == s_swapH && s_hdrMultisampleColorInfo.sample_count == sampleCount) + { + return true; + } + ReleaseHdrMultisampleColorTexture(); + SDL_GPUTextureCreateInfo info{}; + info.type = SDL_GPU_TEXTURETYPE_2D; + info.format = kHdrSceneFormat; + info.usage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; + info.width = s_swapW; + info.height = s_swapH; + info.layer_count_or_depth = 1; + info.num_levels = 1; + info.sample_count = sampleCount; + s_hdrMultisampleColorTexture = SDL_CreateGPUTexture(s_device, &info); + if (!s_hdrMultisampleColorTexture) + { + mu::log::Get("render")->error("SDL_gpu -- HDR multisampled colour target creation failed ({}x{}): {}", + s_swapW, s_swapH, SDL_GetError()); + return false; + } + s_hdrMultisampleColorInfo = info; return true; } + static void ReleaseHdrMultisampleColorTexture() + { + if (s_hdrMultisampleColorTexture) + { + SDL_ReleaseGPUTexture(s_device, s_hdrMultisampleColorTexture); + s_hdrMultisampleColorTexture = nullptr; + } + s_hdrMultisampleColorInfo = {}; + } + // Every pipeline slot CreatePipelines() fills, in one fixed order. [[nodiscard]] static std::vector ReplayPipelineSlots() { @@ -6898,6 +7068,7 @@ class MuRendererSDLGpu : public IMuRenderer } s_multisampleColorInfo = {}; ReleaseSingleSampleDepthTexture(); + ReleaseHdrMultisampleColorTexture(); } // The multisampled colour target for this frame's swapchain format, size diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp index 71f67afd39..fc03b08c8e 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp @@ -209,20 +209,26 @@ bool SdlGpuPostProcessing::CreateGradingTexture() return m_gradingTexture != nullptr; } -bool SdlGpuPostProcessing::EnsureTargets(SdlGpuTargetSize size) +bool SdlGpuPostProcessing::EnsureTargets(SdlGpuTargetSize size, SDL_GPUTextureFormat sceneFormat) { if (!m_device || size.width == 0u || size.height == 0u) { return false; } - if (m_sceneTexture && m_targetSize.width == size.width && m_targetSize.height == size.height) + if (sceneFormat == SDL_GPU_TEXTUREFORMAT_INVALID) + { + sceneFormat = m_frameFormat; + } + if (m_sceneTexture && m_targetSize.width == size.width && m_targetSize.height == size.height && + m_sceneFormat == sceneFormat) { return true; } ReleaseTargets(); - m_sceneTexture = CreateTarget(m_device, m_frameFormat, size); - m_bloomSourceTexture = CreateTarget(m_device, m_frameFormat, size); + m_sceneFormat = sceneFormat; + m_sceneTexture = CreateTarget(m_device, m_sceneFormat, size); + m_bloomSourceTexture = CreateTarget(m_device, m_sceneFormat, size); SdlGpuTargetSize levelSize = HalfSize(size); bool created = m_sceneTexture && m_bloomSourceTexture; for (BloomLevel& level : m_bloomLevels) @@ -243,6 +249,11 @@ bool SdlGpuPostProcessing::EnsureTargets(SdlGpuTargetSize size) return true; } +bool SdlGpuPostProcessing::IsHdrScene() const +{ + return m_sceneTexture && m_sceneFormat != m_frameFormat; +} + SDL_GPUTexture* SdlGpuPostProcessing::GetSceneTexture() const { return m_sceneTexture; @@ -385,8 +396,16 @@ void SdlGpuPostProcessing::DrawComposite(SDL_GPUCommandBuffer* commandBuffer, SD SDL_SetGPUScissor(pass, &scissor); SDL_BindGPUGraphicsPipeline(pass, m_compositePipeline); SDL_BindGPUFragmentSamplers(pass, 0, bindings, static_cast(std::size(bindings))); + // One step of the 8-bit target: enough to break up banding in the smooth HDR gradients. + constexpr float DitherAmount = 1.0f / 255.0f; + const bool hdr = IsHdrScene() && view == PostProcessingView::Scene; const SdlGpuCompositeUniform uniform{ - {1.0f / static_cast(size.width), 1.0f / static_cast(size.height)}, bloomScale, gradingStrength}; + {1.0f / static_cast(size.width), 1.0f / static_cast(size.height)}, + bloomScale, + gradingStrength, + hdr ? HdrToneMapKnee : 1.0f, + hdr ? DitherAmount : 0.0f, + {}}; SDL_PushGPUFragmentUniformData(commandBuffer, 0, &uniform, sizeof(uniform)); SDL_DrawGPUPrimitives(pass, FullscreenVertexCount, 1, 0, 0); } diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.h b/src/source/Render/Renderer/SdlGpuPostProcessing.h index aa66300c63..dc2c4eb837 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.h +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.h @@ -41,10 +41,19 @@ struct SdlGpuCompositeUniform // 0: ungraded; otherwise the blend of the graded colour with the ungraded one // (Render::PostProcessing::CompositeGradingStrength). float gradingStrength; + // Scene channels above it roll off towards 1 (the HDR scene); 1 leaves the scene as it is. + float toneMapKnee; + // Amplitude of the ordered dither added before the 8-bit target; 0 for none. + float ditherAmount; + float padding[2]; }; static_assert(offsetof(SdlGpuCompositeUniform, bloomScale) == 8); static_assert(offsetof(SdlGpuCompositeUniform, gradingStrength) == 12); -static_assert(sizeof(SdlGpuCompositeUniform) == 16); +static_assert(offsetof(SdlGpuCompositeUniform, toneMapKnee) == 16); +static_assert(sizeof(SdlGpuCompositeUniform) == 32); + +// Where the HDR scene's tone map starts rolling channels off: below it the scene is unchanged. +inline constexpr float HdrToneMapKnee = 0.9f; // The textures and passes that turn the rendered 3D scene into the processed // image the UI is then drawn on: the scene texture the scene pass resolves into, @@ -69,9 +78,11 @@ class SdlGpuPostProcessing void DestroyPipelines(); [[nodiscard]] bool IsAvailable() const; - // The scene, bloom source and bloom chain textures for frames of `size`, - // recreated when the size changed. - [[nodiscard]] bool EnsureTargets(SdlGpuTargetSize size); + // The scene, bloom source and bloom chain textures for frames of `size`, the scene and bloom + // source in `sceneFormat` (INVALID: the frame's format; another one makes an HDR scene, which + // the composite tone maps and dithers), recreated when either changed. + [[nodiscard]] bool EnsureTargets(SdlGpuTargetSize size, SDL_GPUTextureFormat sceneFormat); + [[nodiscard]] bool IsHdrScene() const; [[nodiscard]] SDL_GPUTexture* GetSceneTexture() const; [[nodiscard]] SDL_GPUTexture* GetBloomSourceTexture() const; @@ -111,6 +122,7 @@ class SdlGpuPostProcessing SDL_GPUDevice* m_device = nullptr; SDL_GPUTextureFormat m_frameFormat = SDL_GPU_TEXTUREFORMAT_INVALID; SDL_GPUTextureFormat m_bloomFormat = SDL_GPU_TEXTUREFORMAT_INVALID; + SDL_GPUTextureFormat m_sceneFormat = SDL_GPU_TEXTUREFORMAT_INVALID; SDL_GPUGraphicsPipeline* m_bloomDownPipeline = nullptr; SDL_GPUGraphicsPipeline* m_bloomUpPipeline = nullptr; SDL_GPUGraphicsPipeline* m_compositePipeline = nullptr; diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index 2a8fe1ecbe..b3638a6241 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -203,7 +203,7 @@ TEST_CASE( // The strength replaces the former gradingEnabled flag in the last register lane. CHECK(offsetof(mu::SdlGpuCompositeUniform, bloomScale) == 8); CHECK(offsetof(mu::SdlGpuCompositeUniform, gradingStrength) == 12); - CHECK(sizeof(mu::SdlGpuCompositeUniform) == 16); + CHECK(sizeof(mu::SdlGpuCompositeUniform) == 32); } TEST_CASE("the developer tuning commands name their look values [render][look]") From d0050f3858335c41583db1cbec234248b29a0fce Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 20:01:15 +0800 Subject: [PATCH 05/17] feat(render): nearby point lights cast characters' shadows on the Enhanced ground Candles, fires and spells lit the ground and characters but cast no shadow. With Enhanced dynamic lights a character now casts one more shadow per strong nearby point light, away from it: - SelectLightShadowCasters picks up to dynamic.shadowLights (Look.json, per map, 0-4; shipped 2) of the ground's pinned lights reaching the character, strongest first. Each shadow's strength is the light's share of the point light at the character; a light at the character (its own glow) casts none. - The ground shadow mask is now RG8: sun shadows write red and dim the ground's own light as before, point-light shadows (GroundShadowSource:: PointLight) write green and dim the point lights in world_lit.frag. - Point-light shadows never draw as plain shadows: without the mask they are left out. The mask pipelines are built only when the device can render and sample RG8. - A "Light shadows" slider under Dynamic lights and `$dynlights shadowlights `. --- docs/enhanced-look.md | 4 +- src/Localization/Game.en.resx | 6 + src/bin/Data/Render/Look.json | 1 + src/shaders/compiled/world_lit.frag.dxil | Bin 7492 -> 7524 bytes src/shaders/compiled/world_lit.frag.msl | 55 ++++----- src/shaders/compiled/world_lit.frag.spv | Bin 6412 -> 6576 bytes src/shaders/world_lit.frag.hlsl | 14 ++- .../Data/GameData/MapData/LookProfile.cpp | 1 + .../Data/GameData/MapData/LookProfile.h | 1 + src/source/Render/Lighting/DynamicLight.h | 3 + .../Render/Lighting/DynamicLightSelection.cpp | 1 + .../Render/Lighting/LightShadowCasters.cpp | 62 ++++++++++ .../Render/Lighting/LightShadowCasters.h | 39 +++++++ .../Render/Lighting/WorldDynamicLights.cpp | 1 + .../Render/Lighting/WorldDynamicLights.h | 3 +- src/source/Render/Look/LookTuningCommand.cpp | 1 + src/source/Render/Look/LookTuningCommand.h | 1 + src/source/Render/Look/TuningControls.cpp | 2 + src/source/Render/Look/TuningControls.h | 1 + src/source/Render/Models/ZzzBMD.cpp | 44 +++++-- src/source/Render/Renderer/MuRenderer.h | 25 ++-- .../Render/Renderer/MuRendererSDLGpu.cpp | 110 +++++++++++++----- src/source/Render/Renderer/SceneLighting.h | 2 +- .../Render/Terrain/TerrainLightGrid.cpp | 9 +- src/source/Render/Terrain/TerrainLightGrid.h | 2 +- src/source/UI/Options/TuningRows.cpp | 2 + tests/data/test_look_profile_json.cpp | 1 + tests/render/CMakeLists.txt | 1 + tests/render/test_dynamic_lights.cpp | 42 +++++++ tests/render/test_look_profile.cpp | 2 + .../render/test_projected_shadow_state.cmake | 2 +- tests/render/test_tuning_controls.cpp | 6 +- 32 files changed, 353 insertions(+), 91 deletions(-) create mode 100644 src/source/Render/Lighting/LightShadowCasters.cpp create mode 100644 src/source/Render/Lighting/LightShadowCasters.h diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 3c69083cce..1e32969421 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -81,6 +81,7 @@ window. | Dynamic lights | Skill fade | `dynamic.effectFade` | 0–2 s | 0.05 s | 0.5 s | common | | Dynamic lights | Overlapping-light cap | `dynamic.effectCap` | 0–8 | 0.1 | 2.5 | common | | Dynamic lights | Shadow darkness | `dynamic.shadowOpacity` | 0–100 % | 5 % | 60 % | common | +| Dynamic lights | Light shadows | `dynamic.shadowLights` | 0–4 | 1 | 2 | common | | Dynamic lights | Light wrap | `dynamic.wrap` | 0–0.5 | 0.05 | 0.3 | More settings | | Dynamic lights | Map-light smoothing | `dynamic.mapSmoothing` | 0–2 s | 0.05 s | 0.5 s | More settings | | Dynamic lights | Maximum skill radius | `dynamic.effectRangeMax` | 0–16 cells | 1 cell | 8 cells | More settings | @@ -205,6 +206,7 @@ for the whole file. | `dynamic.effectFade` | 0.5 | 0 | 0–2 | seconds over which a spell's light fades out after it ends | | `dynamic.effectCap` | 2.5 | 0 (none) | 0–8 | the most light overlapping spell lights may add up to | | `dynamic.shadowOpacity` | 0.6 | 0.6 | 0–1 | how much characters' shadows darken the ground's own light; overlapping shadows darken it once, and point lights still light shadowed ground | +| `dynamic.shadowLights` | 2 | 0 | 0–4 | how many of the strongest point lights near a character cast its shadow away from them; each darkens the point light on the ground by its share of the character's point light, and a light at the character casts none | | `dynamic.shadowAngle` | 135 | 180 | 0–360 | which way characters' shadows fall, in degrees counter-clockwise from world +x; 135 falls away from the sun that shades the terrain's slopes, 180 is the Classic direction | | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | @@ -237,7 +239,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$bloom falloff `, `$bloom `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index a0fefc6311..11954ebf21 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1156,6 +1156,12 @@ How dark characters' shadows make the ground. Candle, fire and skill light still lights shadowed ground. + + Light shadows + + + How many of the nearest candle, fire and skill lights cast a character's shadow away from them. 0 leaves only the sun's shadow. + Shadow direction diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 6678a9e8ef..a2def5e09f 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -18,6 +18,7 @@ "dynamic.effectCap": 2.5, "dynamic.shadowOpacity": 0.6, "dynamic.shadowAngle": 135, + "dynamic.shadowLights": 2, "bloom.strength": 1.0, "bloom.levelFalloff": 0.6, "grading.strength": 1 diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index 4559a3d1a982912cdd3143bdc5334b0f7435a2ca..2e0e113785166b5389f349a753c5f0d9d5a6a149 100644 GIT binary patch delta 1524 zcmZ8h4NMbP9DjFLjw`g#&QY$k;8mqEL~IeUW20*eWBAcY*cS*}X!#H`f{h?y+N{?W zYV8mq1<^8H5pm35BEv=Mbi48~V4`acZeUOW84`mFl1*!}xLpO8Z7+Fw|L^;~`~C9z zlV_6oY1yjO%8cfwir&Pv(vcNw2%crJ{=B307%Q; zvK`Ph9NK5laaAgHM?{~`x(_4YB5&eIP@XfcBj!*-Of{EW6=Q@&?daU+5K)1WH~1iH z7brOaIV(|ef)7l)KupxS{nmScybskWi28c~e1Ze8&we=YEy!)Z87PAYdkD4?8nMS? zkx-_6J0^mW*X(;RS-4IyF#oV~X#MuubG4-=#k(sQy$&L#%>EtrJv7w)DU$)gP^7&& z=n2$g*9YU0>-nZkr`tjvBVOJuQO1nsn={`N@ZhLvWz?)O3f)gUa7S4)!!+!alr3B} z$7b&jmcju7`;*`-sKmaNm0)l&VI>-OV`6r0R*a?b>odyRTH2(|m5&F~la#~=`9t2V z@n3|I+)D|UH(cE8O5*L?T~<*pAeu`)g2h^uxLCz5IVCQgW|x`V%rilPmJeIDMdTb8 z+-@W~RF?bN55$|BAI~O56OQ^R*H}&0c+;?&X-h7wiZ3tG6c!clRqrV*Dt!k&&ElW@ zEN^@w_ryf@_(UVcifx#3d46>_1-M*SyfxnTE3Rv5?uaJxfqzbW)9vU6H63nJGjFwq z@K0_#E;x}FHJa-X+@5G8qc71#wO4MsyiLQ`)Jz@R{U~fTY$roG$xV%4UTnTT@Z--F zN$&W$-?RM8_pq0gQ1(A1IO+HcB@`j{I>gak$hi;*Wp?xNLCD}B7^~4hV9HjHc=5SytZ|F*JxNjE2Ne%EgQYzEnbEFh7WTTZGqP zA=52IxYZf4ljNEapp^LLHN0m8uEt0&Lxihw#>aKO>`Bj{O(B0DTkO)-A7Mx6OFfeX z1~d9a4y<)*C1?r+(|89y3M*_zn~`?TyV)}Z zeS)DuR7OwJft7+uAWxzoeL9N;7;dM7xes49PaXQlJj<-aOY;Msj!{92UB<8(LqTU| z@QWY%n|QW0yjYtk!Yu-m!~gLaES(iXPn*2TJOBb)=nFA6ntZi54lt84fcK|v*$m^! zxXWfV@2~o0a}zI_n=PSsEm0Hy_0T~@)I2sDCE+Y6<%*KDE8IkjR&udX`G-_`x1Yh)mU@^^U> zWY+Q?_cUq~tXZOza@B10n0L}mlrELx5b~tUw3MpMzA@?0V7<~HKgwF{Y7LnzNR6ZhEy?6h zaqf*CDIW5A;sV90U|En*_UjTP(mX|_BB3KzB~0TbzIhaWwl(5_v=(1O69Huj46PAo l8^U}4lip7=@~^ZvTth-q`e}ygoomUh%Je_yf%NvTzX3xh9=HGi delta 1461 zcmZ9Me@qi+7{~8=$Mv9BdZh|iDsc4&>9p##$Zyv4C~nM-yJ_=mfHp6B^K&-3Pe z-_LVzAj6X(&ne3`$XEY$w`kvm&yss_Tl$^uTOa@cIp4_@VT}?1xYV1z8CpkR0AS{2 z1maU=1w{Z~gYz-K>)8hPl#;jq_O(JkL2IvsjWWkishrsasA8g2c*$P-FLEGz51{%1 zBo86>M{-~Y>?b`dASyh@YY3XC3j#m*hMb-(p%>A^z~g0%StF)x zNRR&9Qh%^s1~XXxm4V5z$+Lx-|5UE&An|H_)uv|)U$nKMyX8~uzjy3Xe0yh0>YV}c z$-*t0xd=)s(_TiBXj$?LB!%h``Prpsw(hhW`-m298_yJhbgpKER*FL|w&2ppGVl*SC`TDt+)1!>v zKQ%Wv_i)NT+l9{dL>>yQ^KkU}sgW*T9_@mknVPZjtG?E4ni`l(o~YfRP}CXDnX4&}w^6SP=091T(@1klu?uVTd%Nfe{@Nmxk~6NqA()TOv-TM-_pV#oxUV9`Yo{2u6J zNhglw!NM0~S}eyTR=Zm`&`uJzm%)gmxGNEM*D$=nnB+X0x^Av2mrU3IzbVscUixgY}8Y0TE<%(p>vg{?~r(x-3+OW zTXr)YlKabUmPY0XgKS%|NC4)h=fjVnkGM9wF1kOYVZ3%JLS#eL_CV4q>22rBF)fu( zRhmQ4AC&u{h5}y{)fv8n^5csz;nPyaWv&;?-WoFAdTO#sEU(NFYAalB6YUHdjC>cg z(dkTUR;VqP`f2UbF!;+|Ihn5Enrr||g{wiN58EzVnhmZ!I#DXg)SSbyAt|jxpQxR$ z;5CS_0btC*-dy9vP&p6Je&2vEUsQi!W-W7!C?;VM&krB*3fPnH?!;OlbDYlME1}Tr zT>E=%ZWIr4U-3|?(-bx0bR&~Wft10v#FMt05)Z_nL diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index 824efeb94c..866699db80 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -49,55 +49,56 @@ struct main0_in float3 input_worldPosition [[user(locn4)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _208 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _214 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - float4 _328 = tex.sample(s, in.input_uv); - float4 _310 = _328; - uint2 _311 = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); - uint _459 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); - float3 _543; - _543 = float3(0.0); - float3 _545; - for (uint _542 = 0u; _542 < _459; _543 = _545, _542++) + float4 _334 = tex.sample(s, in.input_uv); + float4 _316 = _334; + uint2 _317 = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); + float2 _321 = float2(1.0) - ((float2(1.0) - groundShadowMask.sample(groundShadowSampler, (gl_FragCoord.xy / float2(float(_317.x), float(_317.y)))).xy) * _64.groundShadowOpacity); + uint _471 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); + float3 _555; + _555 = float3(0.0); + float3 _557; + for (uint _554 = 0u; _554 < _471; _555 = _557, _554++) { - float4 _449 = _64.dynamicLightPositionAndRadius[_542]; - float _476 = length(_64.dynamicLightPositionAndRadius[_542].xy - in.input_worldPosition.xy); - if (_476 < _449.w) + float4 _461 = _64.dynamicLightPositionAndRadius[_554]; + float _488 = length(_64.dynamicLightPositionAndRadius[_554].xy - in.input_worldPosition.xy); + if (_488 < _461.w) { - _545 = _543 + (_64.dynamicLightColor[_542].xyz * ((_449.w - _476) / _449.w)); + _557 = _555 + (_64.dynamicLightColor[_554].xyz * ((_461.w - _488) / _461.w)); } else { - _545 = _543; + _557 = _555; } } - float4 _318 = float4(_328.xyz * fast::clamp((in.input_color.xyz * (1.0 - (_64.groundShadowOpacity * (1.0 - groundShadowMask.sample(groundShadowSampler, (gl_FragCoord.xy / float2(float(_311.x), float(_311.y)))).x)))) + _543, float3(0.0), float3(1.0)), _310.w * in.input_color.w); - if (_208.alphaToCoverage != 0u) + float4 _324 = float4(_334.xyz * fast::clamp((in.input_color.xyz * _321.x) + (_555 * _321.y), float3(0.0), float3(1.0)), _316.w * in.input_color.w); + if (_214.alphaToCoverage != 0u) { - _318.w *= fast::clamp(((_318.w - _208.alphaThreshold) / fast::max(fwidth(_318.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); - if (_318.w <= 0.0) + _324.w *= fast::clamp(((_324.w - _214.alphaThreshold) / fast::max(fwidth(_324.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + if (_324.w <= 0.0) { discard_fragment(); } } else { - if ((_208.alphaDiscardEnabled != 0u) && (_318.w <= _208.alphaThreshold)) + if ((_214.alphaDiscardEnabled != 0u) && (_324.w <= _214.alphaThreshold)) { discard_fragment(); } } - if ((_208.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) + if ((_214.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) { - float4 _427 = _318; - float _509 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; - float3 _436 = mix(_427.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_509) * _509), 0.0, 1.0))); - _318.x = _436.x; - _318.y = _436.y; - _318.z = _436.z; + float4 _439 = _324; + float _521 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; + float3 _448 = mix(_439.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_521) * _521), 0.0, 1.0))); + _324.x = _448.x; + _324.y = _448.y; + _324.z = _448.z; } - out._entryPointOutput = _318; + out._entryPointOutput = _324; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index 0265e91bbad7d7d38e71a1c1e675e633de9fff8a..b4365b7c2fc1e2b81447962586347c7db97af781 100644 GIT binary patch literal 6576 zcmaKwdyL#w6~}+=zKX513Q82LJKIQYDYYooHT1FDZmo|>mu_i|A+-BO=XdWJ+p}?|UDw}y9G3<8&c;-uwIDOqO6}00*_rCj+1BBz zzQWF|TD9rXa;rRDZC6_}xvaCN@y#@=DV7^w5BTg2FXeIur?Dd99PCB%az8Fz0LA?tv!d2<+%^*Q`{pm8Ln6Ml`FN` zV!YO>s2lY%=OJVc>3P<6^$j_F0$LwEobf5vVl1yL&%7Qemz`cD8!JyYr>ZSvJ=s0T zIG!u(wL^{8^bE20=9spJ8WX$f}(w7XeX)*`&ldY8*7(a9us&cHtUkdk^AYy=G_5{5~10Z-KP=5 zob0t)y*b<7*lcv_)06jJ2b(<{diG)m8_)Z}J7sTnu&yFis9JBg=0+Q}dVB9|o4wg&H*wjU*5svVMxU-R07hWA&cs#~Fm1&83z+p2^Mez% z)=g}vfLSxK(E?`8#I7!2_Lx|cxtp(zy;WiwPw)fKU5VeqsvqN2zV*NOu7$oaw&+3q zI|7SbjXSW&by)#(Pi>Kx?AIv=MALDieZ`|%7Z%-|UUYU5`GVhB+xxFOMlJoYFeAwGR^2VpWZ(rD-Lw4p@ zLR)?5r$ZTIe?GhEvd$YRb{_WTEUmu$QxmU$`EwGluhrR;^4?SD|IL2vo`sG!_UdJc zH%_sq!9Sa|pGo-HMFrkil$TihnGWUh134$&ou8M!)K~7hHpxSO9lSarzc`m4+r9y9 z^B!bs6H~u0hPOuU7k(~-?q^#!S^x5WC-~*O_I@Yi)!&e4 z_f=os?*_k2`3n;5omVdJcZ6T2{6!GvZ+^<<{jP{@;6@n7Mv}9CoY6neD`4U;MAsU0 zGacGL4C0;AuXpsP`1QPk-%{W`%dG|8vmY+-+K(iDEB=gk4ZO9JH_o-t)+*%dp{(E2E`?t>Q(oiS*2yxXC(A3n!ZE?2_4Z{%_S z-n$>U9E4X#d@rYB{ay`iO`Q&xCjPA5RWQa8{A-}ybCkHXeJ!*);@2naYG{2bi+Yu% znaX0{YoNuQ4i|G>!#WN##A=_Ki?LL|#E++aCZN5e`Z<}fNoa9(L+^Fa>M67K!>nR^ z`F49BrlHrT37f}(dLE1SwvJ4j0qBUO0Wa>p`e;JyN8B8Cfc*@5h;^75=k;?i@zA*^ z>3Ai&455$Aq?1+QP%+wrsy{MXRh8_T2E$p40^t-8{~oS^T~Z=r`+ zeW$cBXZz`Q;L1E7zZde>$ol^tTFkdA>i-9L@wiKWgx1FCa0%I;U^b^2vbY<62G>@d z6~yR0djOhWeum2LOnLqVTA6$Qn>Zg~b(piVzcR(lSvqq58}tx*zO}`i{|>G!?%_Y6 z#heZoN|fJY3mgcS0S{OZ_|_ zbiE7a{@8|bOd%HVZwpEHDPSSH?=SCh3mkyS6{jQ?TZmsWyZDx{p+Fq8zjDw zCFmQ##Lu8(Z@vv$YyjFj`*~=GcUIZknYS`MU+JjLJD}aKnD>qF;_CQ~J_+sq!_4T* zcY=xAU)JUnw07d*`(4nBecuEoem8MxcQdq@-#PhrL-Wg?n`HO1Mi0CPf%~X4pZ0w( zw77qRd583I3p~I44k=#??cXpF*ZaU0$Mt?N@i^-bK#S=s>`p_6o#!O4UdTUKkVl<9 z1SbB?bWR_J7BeQ#>7&pN&q>)wm|~uj^kZZqEoT3DuJX6Cy07=+W6++DJ?g$C){ldU z$Nl&Ow3zoJ;{7Ci2O)fG&kSNuLDGk;o~ka z@$m5tXfdb5rQ@TMXBUh<`kCe*XW9*}EPAyE`Vx%Aqwjj5^=IEHw+6mz-hn>&@aw<3 z!|yV1WzjQdLF-5SD0Q$GmqUw(&Xb`7i+A{JF!w&6sXXFb32omhkKXqGu+;T^P#(QK z%5J`Y-$JNP%y?J64X)irre|R-)s0^G4z%YrfIPn0--XxCVZW;*7B=65*2Z@)Y`za4 zdugMNSlIjkS{v&aHa~>dhOqN})Dg1};%>Rdz4$S-K9v82)w}2FeuJ#aA1B*E=6?X` C?w61N literal 6412 zcmaKvd2C!)6^Ebg*eN8Uffg!g;>_5n1wu`UAOw{rcI=P>DR$$K6ey@udt#4j&x~fq zNzIm+G_(aZq-7~f*ve8MY!XXLDSz}I_9YRE5Fix=Bm@Ek63~TK@O|&S<323J)m+`* z`JHpmJ?Gqe-?e+X2UjOaSF$EKCmHNc()Q$}8zxB{H#4qD`ciq}=!5j<(1+-o>Fb!M9Sehcl3vEY!}r1#=l8PidUTUh z)p~VzZDzJptIr_!5v#ndy{sFnwW?E{TBDABb*jf@K|k78w|#Ym7Dyvb8hS<@Kx;>rHklEw>3ii_N;Eaio5-*gQLMQ6emRlG9G2 znUi;|R&OqJhMJA6KE3JP%eaMuVdq`UxT*9$c&5CY8CPAbj#ZnT*{p`%*Ni{pafq#C zwbki89>@7jrZu_3xLlYvm<`Juu2XIuW7s)IyHbI(esY%< zIO`@iT;Qyk+(d!1W^&gSIPaKTlfH|ujd!a|H=d9Oz&*MA5=Q+Pr~1qPOYT{|H|7v` zQ2(~zB3I)ME^e*#&3SFTqs>b+}4z4GJwp5;4Y{N5K^u|{#n2IyKC-p%HG|O`|~%^xyBQtbF|a{c1B~`Mz=1? z!}N&Lx{Tzq_B(Q{FXK_alWseoS$i0@+skO&#u9e>!0w~^s~KG*^!mGo?!Je;51nT` zjU%~2TXR!h%DHE-`cbfUH|CtOcFKMqY!?#IO^o{R{N2h} zrW?C+k29L5e5~QO!)Dyt-a+r8hwqbMTjX^LY~KCk<-K-}y|`y$Yvr0hW^{dR^{MQ= zmeZ%U56~~T`^?sm&mz;dJO4t0;g_G2O!hk_Kd4n_PfC^QU82^`J115WxpeGaW@7?&ifL53n#;TSJ7?SJ_O@=(TC^n zetft$A#W+j?%RtBvi93@`EuqP%LZiYqHHb7;8HHDe^a*<)Sj`O$lA#7hjWc9!1AuWjV#SUE_}WW?0K8P-ZS`eWVxMS?afhc z1ijyqSAgXP!1^dN?nagmn=8TEcy7bymB{k3?l{fGaT!pNS{5ZQ{{q};b zsomz#WWKfAhhQ8bUk!H63F3C{tHIjH-<)%=0qav;)a$ii*H(8GcKW^sEN?T%LB`i1 z4>NlA%t5=?!^t1b=Uof-ygC0^&Q-wLsSCU7z}l%B=bP)^SHYeSyUoG#dK^FMXCSn3 zt}*R^`xbbZafBXq|2CX_*nB6qaeu?+yKwSrsdE|rdtiRaMRez@58d|*I_-Qn9wxFM zfW1GC|GOAB3Gb&pn@B7cda=s_Aw?9XgkF)p- zuygD-htT~J!Mkg>Ik?xJ!(SmdSDUrO=(+hdm|wbw>hH<(d;qM@wI3wTKQr3QS>12w za^@_KoX>)XvGe^a=KNcDb#cai2bQzj94OK9x%@qZYa4@i##sLV4nEG}AK~<+ZV5a0 z{!d`{U!CV8;&hDj;hE6J{nFkXwDl~Qlj9NmmGS2pF&E$P;(2q=W6kTqGjx5f&F@hi znIG>O^#FJteG8%nO*p@YcAEq0^uC%$3ql+H#QA80x6q5{qk}B3jqle6oD8n8IhgbD zEjWbiJo)(6+yHh>TX2gxCmq}ya?V&MIJKVXH^Mnzd-eMFeETk`GqxSry$S4lAK$Jr z_|0(gr?Byky#*{c0QT(N3ATCm)E%b3m+n4^qc%stu2-zh60*EDemma^cKs20+^?f> z^6^c)5$rtq@O=!t()Zio+(I zEZ8$7_YP!!=^0XgG1%{Q#C0p&%D9fh$;V#56D+5%n0Epk^V}z8?LvQBK_7Lx9Zvqf ze4pM0mNO>z={;bZ`=svObUF7){3w}-<-A9C<~sM%bv++cikobosbeH30@ z+?mI~`jJ0O9lVSG2Fr&{7Xb$s?`bz2Cj9Tk2#z>=z}{Q+akp3Hw!RPQ<8Du|n&1B~ z<4Bw6@veLY-Zh5k?uE6~Htxb#!S2@p`uJvl4cU1%@4Gf~G3RcubNstG=G=oEYdJ?7 yxtQ~Huyd?q%()lYIfR|Aqm7*RAkLO!oQwOw`cVH(M$ew3>uqLK{}|bBrT+)8V2kqr diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index a0aaf39b16..463efe869e 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -8,7 +8,8 @@ Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); -// Per pixel, 1 minus the darkest ground shadow there (white without shadows). +// Per pixel, 1 minus the darkest ground shadow there: red the sun's, green the point lights' (white +// without shadows). Texture2D groundShadowMask : register(t1, space2); SamplerState groundShadowSampler : register(s1, space2); cbuffer FogUniforms : register(b0, space3) @@ -84,11 +85,12 @@ float4 main(FSInput input) : SV_Target uint maskWidth; uint maskHeight; groundShadowMask.GetDimensions(maskWidth, maskHeight); - const float visibility = - groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).r; - // Shadows dim the ground's own light; the point lights still light shadowed ground. - const float shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); - const float3 light = saturate(input.color.rgb * shadow + WorldDynamicLighting(input.worldPosition)); + const float2 visibility = + groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).rg; + // The sun's shadows dim the ground's own light, the point lights' shadows the point lights. + const float2 shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); + const float3 light = + saturate(input.color.rgb * shadow.x + WorldDynamicLighting(input.worldPosition) * shadow.y); float4 color = float4(texel.rgb * light, texel.a * input.color.a); if (alphaToCoverage) { diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index e31e14730f..fd21c1df18 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -43,6 +43,7 @@ constexpr std::array Infos = {{ {LookValue::DynamicEffectCap, "dynamic.effectCap", 0.0, 0.0, 8.0}, {LookValue::GroundShadowOpacity, "dynamic.shadowOpacity", 0.6, 0.0, 1.0}, {LookValue::GroundShadowAngle, "dynamic.shadowAngle", 180.0, 0.0, 360.0}, + {LookValue::GroundShadowLights, "dynamic.shadowLights", 0.0, 0.0, 4.0}, {LookValue::BloomStrength, "bloom.strength", 0.6, 0.0, 2.0}, {LookValue::BloomLevelFalloff, "bloom.levelFalloff", 0.5, 0.25, 1.0}, {LookValue::GradingStrength, "grading.strength", 1.0, 0.0, 1.0}, diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index 0ba0a78614..a45aff6edc 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -45,6 +45,7 @@ enum class LookValue : std::uint8_t DynamicEffectCap, GroundShadowOpacity, GroundShadowAngle, + GroundShadowLights, BloomStrength, BloomLevelFalloff, GradingStrength, diff --git a/src/source/Render/Lighting/DynamicLight.h b/src/source/Render/Lighting/DynamicLight.h index fef9fc4baf..645be89113 100644 --- a/src/source/Render/Lighting/DynamicLight.h +++ b/src/source/Render/Lighting/DynamicLight.h @@ -22,6 +22,9 @@ struct DynamicLight int range = 0; // range in world units. float radius = 0.0f; + // Whether characters cast a shadow away from it: not for skill lights, whose glow runs along a + // beam or burst rather than from one point. + bool castsShadows = true; }; } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/DynamicLightSelection.cpp b/src/source/Render/Lighting/DynamicLightSelection.cpp index 48549a6761..e9e2f0886e 100644 --- a/src/source/Render/Lighting/DynamicLightSelection.cpp +++ b/src/source/Render/Lighting/DynamicLightSelection.cpp @@ -52,6 +52,7 @@ void PackLight(const DynamicLight& light, std::size_t slot, mu::DynamicLightsUni uniform.color[slot][i] = std::max(light.color[i], 0.f); } uniform.positionAndRadius[slot][3] = light.radius; + uniform.color[slot][3] = light.castsShadows ? 1.f : 0.f; } } // namespace diff --git a/src/source/Render/Lighting/LightShadowCasters.cpp b/src/source/Render/Lighting/LightShadowCasters.cpp new file mode 100644 index 0000000000..bb59c667f6 --- /dev/null +++ b/src/source/Render/Lighting/LightShadowCasters.cpp @@ -0,0 +1,62 @@ +#include "Render/Lighting/LightShadowCasters.h" + +#include +#include + +namespace Render::Lighting +{ + +LightShadowCasters SelectLightShadowCasters(const mu::DynamicLightsUniform& lights, const float (&position)[3], + std::size_t maxCasters) +{ + struct Candidate + { + float contribution; + float fallAngle; + }; + std::array candidates{}; + std::size_t candidateCount = 0; + float total = 0.f; + + const std::size_t count = std::min(lights.worldLightCount, mu::kMaxDynamicLights); + for (std::size_t i = 0; i < count; ++i) + { + const float radius = lights.positionAndRadius[i][3]; + const float dx = position[0] - lights.positionAndRadius[i][0]; + const float dy = position[1] - lights.positionAndRadius[i][1]; + const float distance = std::sqrt(dx * dx + dy * dy); + if (radius <= 0.f || distance >= radius) + { + continue; + } + const float contribution = + (lights.color[i][0] + lights.color[i][1] + lights.color[i][2]) * (radius - distance) / radius; + total += contribution; + if (distance >= kOwnLightDistance && lights.color[i][3] > 0.f) + { + candidates[candidateCount++] = {contribution, std::atan2(dy, dx)}; + } + } + + LightShadowCasters result; + if (total <= 0.f) + { + return result; + } + const std::size_t wanted = std::min({maxCasters, kMaxLightShadowCasters, candidateCount}); + std::partial_sort(candidates.begin(), candidates.begin() + static_cast(wanted), + candidates.begin() + static_cast(candidateCount), + [](const Candidate& left, const Candidate& right) + { return left.contribution > right.contribution; }); + for (std::size_t i = 0; i < wanted; ++i) + { + const float strength = candidates[i].contribution / total; + if (strength >= kMinLightShadowStrength) + { + result.casters[result.count++] = {candidates[i].fallAngle, strength}; + } + } + return result; +} + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/LightShadowCasters.h b/src/source/Render/Lighting/LightShadowCasters.h new file mode 100644 index 0000000000..706dc0ae9f --- /dev/null +++ b/src/source/Render/Lighting/LightShadowCasters.h @@ -0,0 +1,39 @@ +// LightShadowCasters.h: which of the frame's point lights cast a character's shadow on the ground. +#pragma once + +#include "Render/Renderer/SceneLighting.h" + +#include +#include + +namespace Render::Lighting +{ + +inline constexpr std::size_t kMaxLightShadowCasters = 4; + +// A shadow a point light casts: where it falls, in radians counter-clockwise from world +x (away +// from the light), and how strong it is: the light's share of the point light at the character. +struct LightShadowCaster +{ + float fallAngle = 0.f; + float strength = 0.f; +}; + +struct LightShadowCasters +{ + std::array casters{}; + std::size_t count = 0; +}; + +// Lights nearer the character than this (horizontally, in world units) cast none: they are its own. +inline constexpr float kOwnLightDistance = 50.f; +// Weaker shares cast none. +inline constexpr float kMinLightShadowStrength = 0.05f; + +// Up to `maxCasters` (at most kMaxLightShadowCasters) of the ground's lights (the first +// worldLightCount of `lights`) reaching `position`, strongest first. Every light reaching the +// character counts towards the shares, its own and skill lights (color w 0, which cast none) too. +[[nodiscard]] LightShadowCasters SelectLightShadowCasters(const mu::DynamicLightsUniform& lights, + const float (&position)[3], std::size_t maxCasters); + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/WorldDynamicLights.cpp b/src/source/Render/Lighting/WorldDynamicLights.cpp index 55e1464db3..b0336194b8 100644 --- a/src/source/Render/Lighting/WorldDynamicLights.cpp +++ b/src/source/Render/Lighting/WorldDynamicLights.cpp @@ -17,6 +17,7 @@ void WorldDynamicLights::Pin(DynamicLightList& lights, const float (&reference)[ return; } m_selection = SelectDynamicLights(lights.Lights(), reference); + m_selection.uniform.worldLightCount = m_selection.uniform.lightCount; lights.Mark(); m_pinned = true; } diff --git a/src/source/Render/Lighting/WorldDynamicLights.h b/src/source/Render/Lighting/WorldDynamicLights.h index 7d165ef5ea..fb6d4c93aa 100644 --- a/src/source/Render/Lighting/WorldDynamicLights.h +++ b/src/source/Render/Lighting/WorldDynamicLights.h @@ -15,7 +15,8 @@ class WorldDynamicLights { public: void Clear(); - // Pins the selection SelectDynamicLights makes of `lights` at `reference` and marks the list, + // Pins the selection SelectDynamicLights makes of `lights` at `reference`, all of them world lights + // (worldLightCount), and marks the list, // so the lights added after it are told apart. A second call in the frame keeps the first pin. void Pin(DynamicLightList& lights, const float (&reference)[3]); diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 48d8d62c93..7a31ab0e7a 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -29,6 +29,7 @@ const CommandForm CommandForms[] = { {L"$dynlights reach ", {LookValue::DynamicEffectRangeMax}}, {L"$dynlights shadow ", {LookValue::GroundShadowOpacity}}, {L"$dynlights shadowangle ", {LookValue::GroundShadowAngle}}, + {L"$dynlights shadowlights ", {LookValue::GroundShadowLights}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$bloom ", {LookValue::BloomStrength}}, }; diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index 48de95fe53..ff0786a12a 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -30,6 +30,7 @@ // $dynlights reach dynamic.effectRangeMax // $dynlights shadow dynamic.shadowOpacity // $dynlights shadowangle dynamic.shadowAngle +// $dynlights shadowlights dynamic.shadowLights // $bloom falloff bloom.levelFalloff // $bloom bloom.strength namespace Render::Look diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index 8db9d972a3..77bc337d28 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -60,6 +60,8 @@ constexpr std::array Specs = {{ 1.0, TuningZero::NoCap}, {TuningControlId::ShadowOpacity, TuningGroup::DynamicLights, false, LookValue::GroundShadowOpacity, 0.05, TuningUnit::Percent, 100.0, TuningZero::Plain}, + {TuningControlId::ShadowLights, TuningGroup::DynamicLights, false, LookValue::GroundShadowLights, 1.0, + TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::Wrap, TuningGroup::DynamicLights, true, LookValue::DynamicWrap, 0.05, TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::MapSmoothing, TuningGroup::DynamicLights, true, LookValue::DynamicMapSmoothing, 0.05, diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index ac571850ca..65218b0946 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -68,6 +68,7 @@ enum class TuningControlId : std::uint8_t EffectFade, EffectCap, ShadowOpacity, + ShadowLights, Wrap, MapSmoothing, EffectRangeMax, diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index d6ef4baf4d..f5b0fd10bd 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -51,6 +51,8 @@ #include "Scenes/MainScene.h" #include "Render/Lighting/LightMoodSetting.h" #include "Render/Lighting/DynamicLightsSetting.h" +#include "Render/Lighting/LightShadowCasters.h" +#include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" using mu::PackABGR; @@ -3103,28 +3105,46 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const DisableTexture(); DisableDepthMask(); BeginRender(1.f); - const mu::ScopedGroundShadow groundShadow; const auto [startMesh, endMesh] = ResolveMeshRange(NumMeshs, draw.startMesh, draw.endMesh); - const mu::ShadowProjection projection = + mu::ShadowProjection projection = BodyShadowProjection(draw.bodyOrigin, gMapManager.InBattleCastle() ? 2500.f : 2000.f, 4000.f); - const std::uint32_t shadowColor = PackABGR(0.f, 0.f, 0.f, std::clamp(draw.alpha, 0.f, 1.f)); - - if (draw.clothes.empty() && Render::Models::Gltf::SkinnedModelOf(*this)) - { - RenderWeightedMeshShadow(draw, startMesh, endMesh, projection, shadowColor); - } - else if (draw.clothes.empty()) + const auto drawShadow = [&](float shadowAlpha) { - if (!RenderGpuMeshShadow(draw, startMesh, endMesh, projection, shadowColor)) + const std::uint32_t shadowColor = PackABGR(0.f, 0.f, 0.f, std::clamp(shadowAlpha, 0.f, 1.f)); + if (!draw.clothes.empty()) + { + AddClothesShadowTriangles(draw.clothes, projection, shadowColor); + } + else if (Render::Models::Gltf::SkinnedModelOf(*this)) + { + RenderWeightedMeshShadow(draw, startMesh, endMesh, projection, shadowColor); + } + else if (!RenderGpuMeshShadow(draw, startMesh, endMesh, projection, shadowColor)) { AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, projection, shadowColor); } + }; + { + const mu::ScopedGroundShadow groundShadow; + drawShadow(draw.alpha); } - else + // The ground's strongest point lights cast one more shadow each, away from the light. + const Render::Lighting::WorldDynamicLights& worldLights = Render::Lighting::FrameWorldDynamicLights(); + if (Render::Lighting::DynamicLightsActive() && worldLights.IsPinned()) { - AddClothesShadowTriangles(draw.clothes, projection, shadowColor); + const auto maxCasters = + static_cast(Render::Look::Value(Data::Maps::LookValue::GroundShadowLights)); + const Render::Lighting::LightShadowCasters casters = Render::Lighting::SelectLightShadowCasters( + worldLights.Selection().uniform, {draw.bodyOrigin[0], draw.bodyOrigin[1], draw.bodyOrigin[2]}, maxCasters); + const mu::ScopedGroundShadow lightShadow(mu::GroundShadowSource::PointLight); + for (std::size_t i = 0; i < casters.count; ++i) + { + constexpr float HalfTurn = 3.14159265358979f; + projection.axisAngle = casters.casters[i].fallAngle + HalfTurn; + drawShadow(draw.alpha * casters.casters[i].strength); + } } EndRender(); diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index cb2915f947..33c15a50fb 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -183,6 +183,13 @@ struct SkinningParameters float normalMapScale = 0.0f; }; +// What casts a ground shadow (ScopedGroundShadow). +enum class GroundShadowSource : std::uint8_t +{ + Sun, // the map's light: darkens the ground's own light + PointLight, // a candle, fire or spell light: darkens the point lights +}; + // Where a body shadow lands, as CalcShadowPosition() puts it there. struct ShadowProjection { @@ -441,10 +448,11 @@ class IMuRenderer // Draws between BeginGroundShadow and EndGroundShadow are shadows cast on the ground. In a frame // with world-lit ground they darken it through a coverage mask instead (each pixel once, by - // DynamicLightsUniform::groundShadowOpacity); otherwise they draw as recorded. Scopes nest; use - // ScopedGroundShadow. - virtual void BeginGroundShadow() {} - virtual void EndGroundShadow() {} + // DynamicLightsUniform::groundShadowOpacity): a sun shadow its own light, a point-light shadow + // its point light. Otherwise a sun shadow draws as recorded and a point-light shadow not at all. + // Scopes nest; use ScopedGroundShadow. + virtual void BeginGroundShadow(GroundShadowSource /*source*/) {} + virtual void EndGroundShadow(GroundShadowSource /*source*/) {} // True while a bloom exclusion is open: what is queued now and drawn later // (a character's glow sprites) can be drawn inside one too. [[nodiscard]] virtual bool IsBloomExcluded() const @@ -896,16 +904,19 @@ class ScopedWorldLitGeometry class ScopedGroundShadow { public: - ScopedGroundShadow() + explicit ScopedGroundShadow(GroundShadowSource source = GroundShadowSource::Sun) : m_source(source) { - GetRenderer().BeginGroundShadow(); + GetRenderer().BeginGroundShadow(source); } ~ScopedGroundShadow() { - GetRenderer().EndGroundShadow(); + GetRenderer().EndGroundShadow(m_source); } ScopedGroundShadow(const ScopedGroundShadow&) = delete; ScopedGroundShadow& operator=(const ScopedGroundShadow&) = delete; + +private: + GroundShadowSource m_source; }; // The draws recorded in its lifetime may be reordered (BeginReorderableDraws). class ScopedReorderableDraws diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 14dd86a812..bec46857d5 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -624,6 +624,7 @@ static Render::PostProcessing::SceneBoundary s_sceneBoundary; static int s_bloomExclusionDepth = 0; static int s_worldLitGeometryDepth = 0; static int s_groundShadowDepth = 0; +static int s_lightShadowDepth = 0; // Ground shadows (BeginGroundShadow) are drawn into a coverage mask the world-lit ground samples, in // a frame that recorded world-lit draws; until the mask holds the frame's shadows they draw as before. static bool s_frameHasWorldLit = false; @@ -632,9 +633,9 @@ static bool s_groundShadowMaskReady = false; static SDL_GPUTexture* s_groundShadowMask = nullptr; static Uint32 s_groundShadowMaskW = 0; static Uint32 s_groundShadowMaskH = 0; -// The mask's pipelines: GPU-skinned shadows, and the CPU and cloth shadows in the 3D layout. -static SDL_GPUGraphicsPipeline* s_groundShadowMaskSkinnedPipeline = nullptr; -static SDL_GPUGraphicsPipeline* s_groundShadowMask3DPipeline = nullptr; +// The mask's pipelines, [point light][skinned]: GPU-skinned shadows, and the CPU and cloth shadows +// in the 3D layout. Sun shadows write the red channel, point-light shadows the green one. +static SDL_GPUGraphicsPipeline* s_groundShadowMaskPipelines[2][3]{}; // Alpha-to-coverage variants of the depth-writing world pipelines (each world set's culled and // no-cull states), used while anti-aliasing is on by alpha-tested cutout draws (foliage, hair, @@ -829,6 +830,7 @@ struct RenderCmd bool bloomExcluded{}; // recorded inside a ScopedBloomExclusion: never a bloom source bool groundShadow{}; // recorded inside a ScopedGroundShadow bool worldLit{}; // recorded inside BeginWorldLitGeometry: slot 1 is the ground shadow mask + bool lightShadow{}; // a point light's (GroundShadowSource::PointLight) // Set once this command has been replayed into an offscreen capture (see // BeginOffscreenCapture/EndOffscreenCapture); the main frame's replay pass then // skips it instead of drawing it a second time into the frame. @@ -863,7 +865,8 @@ static Render::DrawCommandHistory s_previousDrawCommands; return Counter::BatchBreakTexture; } if (previous.blendEnabled != command.blendEnabled || previous.blendMode != command.blendMode || - previous.bloomExcluded != command.bloomExcluded || previous.groundShadow != command.groundShadow) + previous.bloomExcluded != command.bloomExcluded || previous.groundShadow != command.groundShadow || + previous.lightShadow != command.lightShadow) { return Counter::BatchBreakBlend; } @@ -2243,6 +2246,7 @@ class MuRendererSDLGpu : public IMuRenderer } s_worldLitGeometryDepth = 0; s_groundShadowDepth = 0; + s_lightShadowDepth = 0; s_frameHasWorldLit = false; s_groundShadowMaskReady = false; @@ -2405,8 +2409,11 @@ class MuRendererSDLGpu : public IMuRenderer [[nodiscard]] static SDL_GPUGraphicsPipeline* GetGroundShadowMaskPipeline(const RenderCmd& command) { - return command.type == RenderCmdType::DrawSkinnedTriangles ? s_groundShadowMaskSkinnedPipeline - : s_groundShadowMask3DPipeline; + // Layouts: 3D, skinned, weighted skinned (glTF). + const int layout = command.type != RenderCmdType::DrawSkinnedTriangles ? 0 + : command.vtxStride == sizeof(mu::SkinnedWeightedVertex3D) ? 2 + : 1; + return s_groundShadowMaskPipelines[command.lightShadow ? 1 : 0][layout]; } // The pipeline `command` replays with in a pass of `selection`, or null when it is not drawn there. @@ -2417,7 +2424,7 @@ class MuRendererSDLGpu : public IMuRenderer { return command.groundShadow ? GetGroundShadowMaskPipeline(command) : nullptr; } - if (command.groundShadow && s_groundShadowMaskReady) + if (command.lightShadow || (command.groundShadow && s_groundShadowMaskReady)) { return nullptr; } @@ -2545,7 +2552,7 @@ class MuRendererSDLGpu : public IMuRenderer ReleaseGroundShadowMask(); SDL_GPUTextureCreateInfo maskInfo{}; maskInfo.type = SDL_GPU_TEXTURETYPE_2D; - maskInfo.format = SDL_GPU_TEXTUREFORMAT_R8_UNORM; + maskInfo.format = SDL_GPU_TEXTUREFORMAT_R8G8_UNORM; maskInfo.width = s_swapW; maskInfo.height = s_swapH; maskInfo.layer_count_or_depth = 1; @@ -2579,7 +2586,7 @@ class MuRendererSDLGpu : public IMuRenderer // the other passes leave them out. static void RenderGroundShadowMask(std::size_t end, bool boneDataReady) { - if (!s_frameHasWorldLit || !s_groundShadowMask3DPipeline || !EnsureGroundShadowMask()) + if (!s_frameHasWorldLit || !s_groundShadowMaskPipelines[0][0] || !EnsureGroundShadowMask()) { return; } @@ -3821,16 +3828,17 @@ class MuRendererSDLGpu : public IMuRenderer } } - void BeginGroundShadow() override + void BeginGroundShadow(GroundShadowSource source) override { - ++s_groundShadowDepth; + ++(source == GroundShadowSource::PointLight ? s_lightShadowDepth : s_groundShadowDepth); } - void EndGroundShadow() override + void EndGroundShadow(GroundShadowSource source) override { - if (s_groundShadowDepth > 0) + int& depth = source == GroundShadowSource::PointLight ? s_lightShadowDepth : s_groundShadowDepth; + if (depth > 0) { - --s_groundShadowDepth; + --depth; } } @@ -5518,7 +5526,8 @@ class MuRendererSDLGpu : public IMuRenderer command.depthMaskEnabled = m_depthMaskEnabled; command.cullFaceEnabled = m_cullFaceEnabled; command.bloomExcluded = s_bloomExclusionDepth > 0; - command.groundShadow = s_groundShadowDepth > 0; + command.lightShadow = s_lightShadowDepth > 0; + command.groundShadow = s_groundShadowDepth > 0 || command.lightShadow; command.worldLit = s_worldLitGeometryDepth > 0; if (command.worldLit) { @@ -6119,7 +6128,7 @@ class MuRendererSDLGpu : public IMuRenderer const SDL_GPUTextureFormat swapchainFmt = SDL_GetGPUSwapchainTextureFormat(s_device, s_window); SDL_GPUColorTargetDescription colorTargetDesc{}; - colorTargetDesc.format = description.groundShadowMaskTarget ? SDL_GPU_TEXTUREFORMAT_R8_UNORM + colorTargetDesc.format = description.groundShadowMaskTarget ? SDL_GPU_TEXTUREFORMAT_R8G8_UNORM : s_pipelineFormatOverride != SDL_GPU_TEXTUREFORMAT_INVALID ? s_pipelineFormatOverride : swapchainFmt; colorTargetDesc.blend_state = blendState; @@ -6563,12 +6572,15 @@ class MuRendererSDLGpu : public IMuRenderer } } } - for (SDL_GPUGraphicsPipeline** pipeline : {&s_groundShadowMask3DPipeline, &s_groundShadowMaskSkinnedPipeline}) + for (auto& layouts : s_groundShadowMaskPipelines) { - if (*pipeline) + for (SDL_GPUGraphicsPipeline*& pipeline : layouts) { - SDL_ReleaseGPUGraphicsPipeline(s_device, *pipeline); - *pipeline = nullptr; + if (pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, pipeline); + pipeline = nullptr; + } } } DestroyAlphaCoveragePipelines(); @@ -6964,7 +6976,9 @@ class MuRendererSDLGpu : public IMuRenderer // ground shadows draw as recorded. static void CreateGroundShadowMaskPipelines() { - if (!s_fragShaderShadowMask) + const SDL_GPUTextureUsageFlags maskUsage = SDL_GPU_TEXTUREUSAGE_COLOR_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + if (!s_fragShaderShadowMask || !SDL_GPUTextureSupportsFormat(s_device, SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, + SDL_GPU_TEXTURETYPE_2D, maskUsage)) { return; } @@ -6977,23 +6991,61 @@ class MuRendererSDLGpu : public IMuRenderer darkest.dst_alpha_blendfactor = SDL_GPU_BLENDFACTOR_ONE; darkest.alpha_blend_op = SDL_GPU_BLENDOP_MIN; darkest.enable_blend = true; + darkest.enable_color_write_mask = true; const char* deviceDriver = SDL_GetGPUDeviceDriver(s_device); - const auto build = [&](SDL_GPUGraphicsPipeline*& destination, const char* name, VertexLayout layout) - { - PipelineBuildDescription description{name, "darkest", k_PipelineDisabled, false, false, - layout, false, FragmentShader::ShadowMask}; + const auto build = [&](int lightShadow, int layout, const char* name) + { + PipelineBuildDescription description{name, + "darkest", + k_PipelineDisabled, + false, + false, + layout == 2 ? VertexLayout::SkinnedWeightedShadow + : layout == 1 ? VertexLayout::SkinnedShadow + : VertexLayout::ThreeDimensional, + false, + FragmentShader::ShadowMask}; description.groundShadowMaskTarget = true; + darkest.color_write_mask = lightShadow ? SDL_GPU_COLORCOMPONENT_G : SDL_GPU_COLORCOMPONENT_R; const PipelineBuildResult result = BuildBlendPipeline(darkest, description); - destination = result.pipeline; - if (!destination) + s_groundShadowMaskPipelines[lightShadow][layout] = result.pipeline; + if (!result.pipeline) { LogPipelineFailure(deviceDriver ? deviceDriver : "unknown", result, false); } }; - build(s_groundShadowMask3DPipeline, "ground-shadow-mask-3d", VertexLayout::ThreeDimensional); + build(0, 0, "ground-shadow-mask-3d"); + build(1, 0, "ground-light-shadow-mask-3d"); if (s_vertShaderSkinnedShadow) { - build(s_groundShadowMaskSkinnedPipeline, "ground-shadow-mask-skinned", VertexLayout::SkinnedShadow); + build(0, 1, "ground-shadow-mask-skinned"); + build(1, 1, "ground-light-shadow-mask-skinned"); + } + if (s_vertShaderSkinnedWeightedShadow) + { + build(0, 2, "ground-shadow-mask-weighted"); + build(1, 2, "ground-light-shadow-mask-weighted"); + } + // All or none: once the mask is ready the scene leaves every ground shadow to it, so a shadow + // the mask cannot draw would vanish. Without them, ground shadows draw as recorded. + const bool skinnedComplete = + !s_vertShaderSkinnedShadow || (s_groundShadowMaskPipelines[0][1] && s_groundShadowMaskPipelines[1][1]); + const bool weightedComplete = !s_vertShaderSkinnedWeightedShadow || + (s_groundShadowMaskPipelines[0][2] && s_groundShadowMaskPipelines[1][2]); + if (!s_groundShadowMaskPipelines[0][0] || !s_groundShadowMaskPipelines[1][0] || !skinnedComplete || + !weightedComplete) + { + for (auto& layouts : s_groundShadowMaskPipelines) + { + for (SDL_GPUGraphicsPipeline*& pipeline : layouts) + { + if (pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, pipeline); + pipeline = nullptr; + } + } + } } } diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index 8c7b9a7a86..d54a6285e6 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -109,7 +109,7 @@ struct DynamicLightsUniform // How much a ground shadow darkens the ground's own light, 0 to 1 (ScopedGroundShadow). float groundShadowOpacity = 0.f; float positionAndRadius[kMaxDynamicLights][4]; // xyz world position, w radius in world units - float color[kMaxDynamicLights][4]; // rgb, w unused + float color[kMaxDynamicLights][4]; // rgb, w 1 when it casts character shadows }; static_assert(offsetof(DynamicLightsUniform, lightCount) == 0); diff --git a/src/source/Render/Terrain/TerrainLightGrid.cpp b/src/source/Render/Terrain/TerrainLightGrid.cpp index 17dfa19b0f..f237fc2af8 100644 --- a/src/source/Render/Terrain/TerrainLightGrid.cpp +++ b/src/source/Render/Terrain/TerrainLightGrid.cpp @@ -129,12 +129,14 @@ void AddLight(float (*grid)[3], float x, float y, const float* color, int range) } void AddDynamicLight(float (*grid)[3], Lighting::DynamicLightList& frameLights, float x, float y, const float* color, - int range, float terrainHeight) + int range, float terrainHeight, bool castsShadows) { AddLight(grid, x, y, color, range); if (range > 0) { - frameLights.Add(MakeDynamicLight(x, y, color, range, terrainHeight)); + Lighting::DynamicLight light = MakeDynamicLight(x, y, color, range, terrainHeight); + light.castsShadows = castsShadows; + frameLights.Add(light); } } @@ -145,7 +147,8 @@ void ApplyCall(const FrameLightTarget& target, const Lighting::LightCall& call) float color[kColorComponents]; for (int k = 0; k < kColorComponents; ++k) color[k] = call.color[k] > 0.f ? call.color[k] * target.dynamicGain : call.color[k]; - AddDynamicLight(target.grid, *target.frameLights, call.x, call.y, color, call.range, target.height(call.x, call.y)); + AddDynamicLight(target.grid, *target.frameLights, call.x, call.y, color, call.range, target.height(call.x, call.y), + call.source != Lighting::LightSource::Effect); } } // namespace diff --git a/src/source/Render/Terrain/TerrainLightGrid.h b/src/source/Render/Terrain/TerrainLightGrid.h index 8df3cfae74..f3a610d605 100644 --- a/src/source/Render/Terrain/TerrainLightGrid.h +++ b/src/source/Render/Terrain/TerrainLightGrid.h @@ -25,7 +25,7 @@ void AddLight(float (*grid)[3], float x, float y, const float* color, int range) // AddLight, and records the light in the frame's light list as a point light over terrain of the // given height. A light without range changes no vertex and is not recorded. void AddDynamicLight(float (*grid)[3], Lighting::DynamicLightList& frameLights, float x, float y, const float* color, - int range, float terrainHeight); + int range, float terrainHeight, bool castsShadows = true); using HeightSampler = float (*)(float, float); diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 94e1ec1dc0..335d2c1f68 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -56,6 +56,8 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningOverlappingLightCap, I18N::Game::TuningOverlappingLightCapHelp}; case TuningControlId::ShadowOpacity: return {I18N::Game::TuningShadowOpacity, I18N::Game::TuningShadowOpacityHelp}; + case TuningControlId::ShadowLights: + return {I18N::Game::TuningLightShadows, I18N::Game::TuningLightShadowsHelp}; case TuningControlId::ShadowAngle: return {I18N::Game::TuningShadowDirection, I18N::Game::TuningShadowDirectionHelp}; case TuningControlId::Wrap: diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index 587a980f27..1b2d5b7299 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -265,6 +265,7 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::DynamicEffectRangeMax, 8}, {LookValue::DynamicEffectFade, 0.5}, {LookValue::DynamicEffectCap, 2.5}, {LookValue::BloomStrength, 1.0}, {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, + {LookValue::GroundShadowLights, 2}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { diff --git a/tests/render/CMakeLists.txt b/tests/render/CMakeLists.txt index b9ecae5715..5b8c479c51 100644 --- a/tests/render/CMakeLists.txt +++ b/tests/render/CMakeLists.txt @@ -236,6 +236,7 @@ mu_add_test( ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/DynamicLightList.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/DynamicLightSelection.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/WorldDynamicLights.cpp + ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/LightShadowCasters.cpp ${CMAKE_SOURCE_DIR}/src/source/Render/Terrain/TerrainLightGrid.cpp ) diff --git a/tests/render/test_dynamic_lights.cpp b/tests/render/test_dynamic_lights.cpp index 98079d9057..2aa6b94e4d 100644 --- a/tests/render/test_dynamic_lights.cpp +++ b/tests/render/test_dynamic_lights.cpp @@ -4,6 +4,7 @@ #include "Core/Globals/_define.h" #include "Render/Lighting/DynamicLightList.h" #include "Render/Lighting/DynamicLightSelection.h" +#include "Render/Lighting/LightShadowCasters.h" #include "Render/Lighting/WorldDynamicLights.h" #include "Render/Terrain/TerrainLightGrid.h" @@ -379,11 +380,52 @@ TEST_CASE("the ground's lights are pinned once per frame [render][dynamic_lights CHECK(world.IsPinned()); CHECK(world.Selection().uniform.lightCount == 1); + CHECK(world.Selection().uniform.worldLightCount == 1); CHECK(frameLights.LightsSinceMark().size() == 1); world.Clear(); CHECK_FALSE(world.IsPinned()); } +TEST_CASE("point lights cast a character's shadow away from them by their share of its light [render][dynamic_lights]") +{ + const float hero[3] = {1000.f, 1000.f, 0.f}; + const std::vector lights = { + MakeLight(1000.f, 1000.f, 1.f, 1.f, 1.f, 3), // the character's own light: casts none, still counts + MakeLight(1200.f, 1000.f, 1.f, 1.f, 1.f, 3), // east of it + MakeLight(1000.f, 900.f, 0.45f, 0.45f, 0.45f, 3), // south of it, weaker + }; + mu::DynamicLightsUniform uniform = Render::Lighting::SelectDynamicLights(lights, hero).uniform; + uniform.worldLightCount = uniform.lightCount; + + const Render::Lighting::LightShadowCasters casters = Render::Lighting::SelectLightShadowCasters(uniform, hero, 4); + + REQUIRE(casters.count == 2); + // East light: the shadow falls west. Contributions 3, 3 * 1/3 = 1 and 1.35 * 2/3 = 0.9 of 4.9. + CHECK(casters.casters[0].fallAngle == doctest::Approx(3.14159265f)); + CHECK(casters.casters[0].strength == doctest::Approx(1.f / 4.9f)); + CHECK(casters.casters[1].fallAngle == doctest::Approx(3.14159265f / 2.f)); + CHECK(casters.casters[1].strength == doctest::Approx(0.9f / 4.9f)); + CHECK(Render::Lighting::SelectLightShadowCasters(uniform, hero, 1).count == 1); + CHECK(Render::Lighting::SelectLightShadowCasters(uniform, hero, 0).count == 0); +} + +TEST_CASE("skill lights light the ground but cast no character shadow [render][dynamic_lights]") +{ + const float hero[3] = {1000.f, 1000.f, 0.f}; + DynamicLight beam = MakeLight(1200.f, 1000.f, 1.f, 1.f, 1.f, 3); + beam.castsShadows = false; + const std::vector lights = {beam, MakeLight(1000.f, 1200.f, 1.f, 1.f, 1.f, 3)}; + mu::DynamicLightsUniform uniform = Render::Lighting::SelectDynamicLights(lights, hero).uniform; + uniform.worldLightCount = uniform.lightCount; + + const Render::Lighting::LightShadowCasters casters = Render::Lighting::SelectLightShadowCasters(uniform, hero, 4); + + REQUIRE(casters.count == 1); + // Only the north light casts, with its half of the light. + CHECK(casters.casters[0].fallAngle == doctest::Approx(-3.14159265f / 2.f)); + CHECK(casters.casters[0].strength == doctest::Approx(0.5f)); +} + TEST_CASE("the dropped-light report runs at most once per minute [render][dynamic_lights]") { using std::chrono::seconds; diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index b3638a6241..5ae22274e1 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -57,6 +57,7 @@ TEST_CASE("the look profile's built-in values are the renderer's values before i CHECK(BuiltInFloat(LookValue::DynamicEffectCap) == classicHistory.effectCap); CHECK(BuiltInFloat(LookValue::GroundShadowOpacity) == mu::kDefaultGroundShadowOpacity); CHECK(BuiltInFloat(LookValue::GroundShadowAngle) == mu::kClassicGroundShadowAngle); + CHECK(BuiltIn(LookValue::GroundShadowLights) == 0.0); // Post-processing: the former config.ini default bloom strength, the level weight, full grading. CHECK(BuiltIn(LookValue::BloomStrength) == Approx(0.6)); @@ -226,6 +227,7 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$dynlights cap 1", LookValue::DynamicEffectCap, 1.0); single(L"$dynlights shadow 0.4", LookValue::GroundShadowOpacity, 0.4); single(L"$dynlights shadowangle 90", LookValue::GroundShadowAngle, 90.0); + single(L"$dynlights shadowlights 3", LookValue::GroundShadowLights, 3.0); single(L"$bloom falloff 0.6", LookValue::BloomLevelFalloff, 0.6); single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); diff --git a/tests/render/test_projected_shadow_state.cmake b/tests/render/test_projected_shadow_state.cmake index f8bd140066..fc84e22cfd 100644 --- a/tests/render/test_projected_shadow_state.cmake +++ b/tests/render/test_projected_shadow_state.cmake @@ -21,7 +21,7 @@ string(SUBSTRING "${bmd_source}" ${shadow_start} ${shadow_length} projected_shad # Every path (GPU, CPU fallback, cloth) records inside the ground-shadow scope, so a world-lit frame # draws them into the ground shadow mask. string(FIND "${projected_shadow_source}" "const mu::ScopedGroundShadow groundShadow;" scope_position) -string(FIND "${projected_shadow_source}" "RenderGpuMeshShadow(" first_draw_position) +string(FIND "${projected_shadow_source}" "drawShadow(draw.alpha);" first_draw_position) if(scope_position EQUAL -1 OR first_draw_position LESS scope_position) message(FATAL_ERROR "Projected body shadows must be recorded inside a ScopedGroundShadow") endif() diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index 473c3652e4..25882e0624 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -65,6 +65,8 @@ const SpecRow Spec[] = { TuningUnit::None, TuningZero::NoCap}, {TuningControlId::ShadowOpacity, TuningGroup::DynamicLights, false, LookValue::GroundShadowOpacity, 0, 1, 0.05, TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::ShadowLights, TuningGroup::DynamicLights, false, LookValue::GroundShadowLights, 0, 4, 1, + TuningUnit::None, TuningZero::Plain}, {TuningControlId::Wrap, TuningGroup::DynamicLights, true, LookValue::DynamicWrap, 0, 0.5, 0.05, TuningUnit::None, TuningZero::Plain}, {TuningControlId::MapSmoothing, TuningGroup::DynamicLights, true, LookValue::DynamicMapSmoothing, 0, 2, 0.05, @@ -96,9 +98,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 21 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 22 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 21); + REQUIRE(Render::Look::TuningControlCount == 22); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From 9861ff8ebc4223922fac3e6602eecb5e3ce0f113 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 20:45:22 +0800 Subject: [PATCH 06/17] feat(render): screen-space ambient occlusion in the Enhanced composite Corners, wall bases and the ground under objects had no contact darkening. With post-processing and one sample per pixel the scene now gets screen-space ambient occlusion from its depth: - SdlGpuAmbientOcclusion renders it at half size: post_ao.frag samples a 12-point hemisphere around the surface (normals and view positions from the depth and the scene's inverse projection, captured with the scene lighting), rotated in a 4x4 pattern; post_ao_blur.frag averages 4x4 texels, leaving out other surfaces, which cancels the pattern without halos. The sky gets none. - post_composite.frag darkens the scene by it before the tone map, and fades it out where the bloom source holds additive light (effects, glows). - The single-sample depth is now sampleable. Anti-aliased frames get no occlusion yet (their depth is multisampled). - ao.strength (0-2, shipped 0.8) and ao.radius (world units, 10-300, 60) in Look.json, the "Contact shadows" sliders, `$ao ` and `$ao radius `. --- cmake/ValidateDxilReflection.cmake | 4 +- cmake/ValidateShaderBlobs.cmake | 2 + cmake/ValidateShaderReflection.cmake | 4 +- docs/enhanced-look.md | 6 +- src/Localization/Game.en.resx | 12 + src/bin/Data/Render/Look.json | 4 +- src/shaders/compiled/post_ao.frag.dxil | Bin 0 -> 14648 bytes src/shaders/compiled/post_ao.frag.msl | 244 ++++++++++++++++++ src/shaders/compiled/post_ao.frag.spv | Bin 0 -> 30924 bytes src/shaders/compiled/post_ao_blur.frag.dxil | Bin 0 -> 11184 bytes src/shaders/compiled/post_ao_blur.frag.msl | 159 ++++++++++++ src/shaders/compiled/post_ao_blur.frag.spv | Bin 0 -> 23880 bytes src/shaders/compiled/post_composite.frag.dxil | Bin 5812 -> 6472 bytes src/shaders/compiled/post_composite.frag.msl | 104 +++++--- src/shaders/compiled/post_composite.frag.spv | Bin 5920 -> 7300 bytes src/shaders/post_ao.frag.hlsl | 100 +++++++ src/shaders/post_ao_blur.frag.hlsl | 71 +++++ src/shaders/post_composite.frag.hlsl | 26 +- .../Core/Utilities/Log/muConsoleDebug.cpp | 3 +- .../Data/GameData/MapData/LookProfile.cpp | 2 + .../Data/GameData/MapData/LookProfile.h | 2 + src/source/Render/Look/LookTuningCommand.cpp | 2 + src/source/Render/Look/LookTuningCommand.h | 2 + src/source/Render/Look/TuningControls.cpp | 4 + src/source/Render/Look/TuningControls.h | 2 + .../PostProcessing/PostProcessingSetting.cpp | 7 +- src/source/Render/Renderer/MuRenderer.h | 3 + .../Render/Renderer/MuRendererSDLGpu.cpp | 34 ++- .../Renderer/SdlGpuAmbientOcclusion.cpp | 210 +++++++++++++++ .../Render/Renderer/SdlGpuAmbientOcclusion.h | 67 +++++ .../Render/Renderer/SdlGpuPixelFormat.cpp | 5 + .../Render/Renderer/SdlGpuPixelFormat.h | 2 +- .../Render/Renderer/SdlGpuPostProcessing.cpp | 8 +- .../Render/Renderer/SdlGpuPostProcessing.h | 9 +- src/source/UI/Options/TuningRows.cpp | 4 + tests/data/test_look_profile_json.cpp | 2 +- tests/render/test_frame_pixel_readback.cpp | 2 +- tests/render/test_look_profile.cpp | 5 + tests/render/test_tuning_controls.cpp | 8 +- 39 files changed, 1054 insertions(+), 65 deletions(-) create mode 100644 src/shaders/compiled/post_ao.frag.dxil create mode 100644 src/shaders/compiled/post_ao.frag.msl create mode 100644 src/shaders/compiled/post_ao.frag.spv create mode 100644 src/shaders/compiled/post_ao_blur.frag.dxil create mode 100644 src/shaders/compiled/post_ao_blur.frag.msl create mode 100644 src/shaders/compiled/post_ao_blur.frag.spv create mode 100644 src/shaders/post_ao.frag.hlsl create mode 100644 src/shaders/post_ao_blur.frag.hlsl create mode 100644 src/source/Render/Renderer/SdlGpuAmbientOcclusion.cpp create mode 100644 src/source/Render/Renderer/SdlGpuAmbientOcclusion.h diff --git a/cmake/ValidateDxilReflection.cmake b/cmake/ValidateDxilReflection.cmake index 2ab40272b9..30b0bcb16d 100644 --- a/cmake/ValidateDxilReflection.cmake +++ b/cmake/ValidateDxilReflection.cmake @@ -32,7 +32,9 @@ set(shader_specs "post_fullscreen.vert|-" "post_bloom_down.frag|cb0,space3+s0,space2+t0,space2" "post_bloom_up.frag|cb0,space3+s0,space2+t0,space2" - "post_composite.frag|cb0,space3+s0,space2+s1,space2+s2,space2+t0,space2+t1,space2+t2,space2" + "post_composite.frag|cb0,space3+s0,space2+s1,space2+s2,space2+s3,space2+s4,space2+t0,space2+t1,space2+t2,space2+t3,space2+t4,space2" + "post_ao.frag|cb0,space3+s0,space2+t0,space2" + "post_ao_blur.frag|cb0,space3+s0,space2+s1,space2+t0,space2+t1,space2" ) foreach(shader_spec IN LISTS shader_specs) diff --git a/cmake/ValidateShaderBlobs.cmake b/cmake/ValidateShaderBlobs.cmake index 101f50fcd8..501e67cfa0 100644 --- a/cmake/ValidateShaderBlobs.cmake +++ b/cmake/ValidateShaderBlobs.cmake @@ -27,6 +27,8 @@ set(MU_SHADER_STAGE_NAMES post_bloom_down.frag post_bloom_up.frag post_composite.frag + post_ao.frag + post_ao_blur.frag ) set(MU_SHADER_BLOB_FORMATS spv msl dxil) set(MU_SHADER_BLOB_NAMES) diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index a8f898ad63..0efe5470e1 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -277,7 +277,9 @@ set(shader_specs "post_fullscreen.vert|vert||0|0|0" "post_bloom_down.frag|frag||1|0|1" "post_bloom_up.frag|frag||1|0|1" - "post_composite.frag|frag||3|0|1" + "post_composite.frag|frag||5|0|1" + "post_ao.frag|frag||1|0|1" + "post_ao_blur.frag|frag||2|0|1" ) foreach(shader_spec IN LISTS shader_specs) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 1e32969421..b14d302841 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -90,6 +90,8 @@ window. | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | | Bloom and colour grading | Colour grading strength | `grading.strength` | 0–100 % | 1 % | 100 % | common | +| Bloom and colour grading | Contact shadows | `ao.strength` | 0–2 | 0.05 | 0.8 | common | +| Bloom and colour grading | Contact shadow reach | `ao.radius` | 10–300 | 5 | 60 | common | The defaults are the shipped look profile's (and each map's own, where it has one); they are defaults, not a promise that every combination of extremes looks @@ -211,6 +213,8 @@ for the whole file. | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | +| `ao.strength` | 0.8 | 0 | 0–2 | how much screen-space ambient occlusion darkens corners, wall bases and the ground under objects; additive effects are left alone; not drawn while anti-aliasing is on | +| `ao.radius` | 60 | 60 | 10–300 | how far, in world units, nearby geometry still darkens a surface | ## Developer commands @@ -239,7 +243,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index 11954ebf21..f9795ed24b 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1207,6 +1207,18 @@ Colour grading strength + + Contact shadows + + + Soft darkening where things meet: corners, wall bases, under objects (ambient occlusion). 0 turns it off. Not drawn while anti-aliasing is on. + + + Contact shadow reach + + + How far from a surface nearby geometry still darkens it, in world units (a terrain cell is 100). + How much of the map's colour grading applies. 0 % applies none, while bloom stays on. diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index a2def5e09f..790befd32d 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -21,7 +21,9 @@ "dynamic.shadowLights": 2, "bloom.strength": 1.0, "bloom.levelFalloff": 0.6, - "grading.strength": 1 + "grading.strength": 1, + "ao.strength": 0.8, + "ao.radius": 60 }, "maps": [ { diff --git a/src/shaders/compiled/post_ao.frag.dxil b/src/shaders/compiled/post_ao.frag.dxil new file mode 100644 index 0000000000000000000000000000000000000000..9e92b8484bbeaff8f0c5e33fe1312879c830e444 GIT binary patch literal 14648 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 literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/post_ao.frag.msl b/src/shaders/compiled/post_ao.frag.msl new file mode 100644 index 0000000000..e0c6b4d297 --- /dev/null +++ b/src/shaders/compiled/post_ao.frag.msl @@ -0,0 +1,244 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" +#pragma clang diagnostic ignored "-Wmissing-braces" + +#include +#include + +using namespace metal; + +template +struct spvUnsafeArray +{ + T elements[Num ? Num : 1]; + + thread T& operator [] (size_t pos) thread + { + return elements[pos]; + } + constexpr const thread T& operator [] (size_t pos) const thread + { + return elements[pos]; + } + + device T& operator [] (size_t pos) device + { + return elements[pos]; + } + constexpr const device T& operator [] (size_t pos) const device + { + return elements[pos]; + } + + constexpr const constant T& operator [] (size_t pos) const constant + { + return elements[pos]; + } + + threadgroup T& operator [] (size_t pos) threadgroup + { + return elements[pos]; + } + constexpr const threadgroup T& operator [] (size_t pos) const threadgroup + { + return elements[pos]; + } +}; + +struct AmbientOcclusion +{ + float4x4 projection; + float4x4 inverseProjection; + float2 depthTexelSize; + float radius; + float padding; +}; + +constant spvUnsafeArray _247 = spvUnsafeArray({ 0.0, 0.5, 0.125, 0.625, 0.75, 0.25, 0.875, 0.375, 0.1875, 0.6875, 0.0625, 0.5625, 0.9375, 0.4375, 0.8125, 0.3125 }); +constant spvUnsafeArray _337 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); + +struct main0_out +{ + float4 _entryPointOutput [[color(0)]]; +}; + +struct main0_in +{ + float2 input_uv [[user(locn0)]]; +}; + +fragment main0_out main0(main0_in in [[stage_in]], constant AmbientOcclusion& _73 [[buffer(0)]], texture2d depthTexture [[texture(0)]], sampler depthSampler [[sampler(0)]], float4 gl_FragCoord [[position]]) +{ + main0_out out = {}; + float4 _1039; + do + { + if (depthTexture.sample(depthSampler, in.input_uv, level(0.0)).x >= 1.0) + { + _1039 = float4(1.0); + break; + } + float2 _653 = (floor((in.input_uv / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _638 = _653; + float4 _681 = _73.inverseProjection * float4((_638.x * 2.0) - 1.0, 1.0 - (_638.y * 2.0), depthTexture.sample(depthSampler, _653, level(0.0)).x, 1.0); + float4 _666 = _681; + float3 _687 = _681.xyz / float3(_666.w); + float2 _785 = (floor(((in.input_uv + float2(_73.depthTexelSize.x, 0.0)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _770 = _785; + float4 _813 = _73.inverseProjection * float4((_770.x * 2.0) - 1.0, 1.0 - (_770.y * 2.0), depthTexture.sample(depthSampler, _785, level(0.0)).x, 1.0); + float4 _798 = _813; + float3 _708 = (_813.xyz / float3(_798.w)) - _687; + float3 _688 = _708; + float2 _837 = (floor(((in.input_uv - float2(_73.depthTexelSize.x, 0.0)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _822 = _837; + float4 _865 = _73.inverseProjection * float4((_822.x * 2.0) - 1.0, 1.0 - (_822.y * 2.0), depthTexture.sample(depthSampler, _837, level(0.0)).x, 1.0); + float4 _850 = _865; + float3 _716 = _687 - (_865.xyz / float3(_850.w)); + float3 _690 = _716; + float2 _889 = (floor(((in.input_uv + float2(0.0, _73.depthTexelSize.y)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _874 = _889; + float4 _917 = _73.inverseProjection * float4((_874.x * 2.0) - 1.0, 1.0 - (_874.y * 2.0), depthTexture.sample(depthSampler, _889, level(0.0)).x, 1.0); + float4 _902 = _917; + float3 _724 = (_917.xyz / float3(_902.w)) - _687; + float3 _692 = _724; + float2 _941 = (floor(((in.input_uv - float2(0.0, _73.depthTexelSize.y)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _926 = _941; + float4 _969 = _73.inverseProjection * float4((_926.x * 2.0) - 1.0, 1.0 - (_926.y * 2.0), depthTexture.sample(depthSampler, _941, level(0.0)).x, 1.0); + float4 _954 = _969; + float3 _732 = _687 - (_969.xyz / float3(_954.w)); + float3 _694 = _732; + float3 _758 = fast::normalize(cross(select(_716, _708, bool3(abs(_688.z) < abs(_690.z))), select(_732, _724, bool3(abs(_692.z) < abs(_694.z))))); + float3 _767 = select(_758, -_758, bool3(dot(_758, _687) > 0.0)); + uint2 _468 = uint2(gl_FragCoord.xy) & uint2(3u); + float _518 = 6.283185482025146484375 * _247[(_468.y * 4u) + _468.x]; + float3 _523 = float3(cos(_518), sin(_518), 0.0); + float3 _532 = fast::normalize((_523 - (_767 * dot(_523, _767))) + float3(9.9999997473787516355514526367188e-05, 0.0, 0.0)); + float3 _535 = cross(_767, _532); + spvUnsafeArray _477 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); + spvUnsafeArray _478 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); + spvUnsafeArray _479 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); + float4 _481 = _73.projection * float4(_687 + ((((_532 * _477[0u].x) + (_535 * _478[0u].y)) + (_767 * _479[0u].z)) * _73.radius), 1.0); + float2 _993 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 _978 = _993; + float4 _1021 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _993, level(0.0)).x, 1.0); + float4 _1006 = _1021; + float3 _590 = (_1021.xyz / float3(_1006.w)) - _687; + float _593 = dot(_590, _590); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[1u].x) + (_535 * _478[1u].y)) + (_767 * _479[1u].z)) * _73.radius), 1.0); + float2 _1096 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1096; + float4 _1113 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1096, level(0.0)).x, 1.0); + _1006 = _1113; + float3 _1119 = (_1113.xyz / float3(_1006.w)) - _687; + float _1120 = dot(_1119, _1119); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[2u].x) + (_535 * _478[2u].y)) + (_767 * _479[2u].z)) * _73.radius), 1.0); + float2 _1192 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1192; + float4 _1209 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1192, level(0.0)).x, 1.0); + _1006 = _1209; + float3 _1215 = (_1209.xyz / float3(_1006.w)) - _687; + float _1216 = dot(_1215, _1215); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[3u].x) + (_535 * _478[3u].y)) + (_767 * _479[3u].z)) * _73.radius), 1.0); + float2 _1288 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1288; + float4 _1305 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1288, level(0.0)).x, 1.0); + _1006 = _1305; + float3 _1311 = (_1305.xyz / float3(_1006.w)) - _687; + float _1312 = dot(_1311, _1311); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[4u].x) + (_535 * _478[4u].y)) + (_767 * _479[4u].z)) * _73.radius), 1.0); + float2 _1384 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1384; + float4 _1401 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1384, level(0.0)).x, 1.0); + _1006 = _1401; + float3 _1407 = (_1401.xyz / float3(_1006.w)) - _687; + float _1408 = dot(_1407, _1407); + float _1424 = ((((fast::clamp((dot(_590, _767) * rsqrt(fast::max(_593, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_593 / (_73.radius * _73.radius)), 0.0, 1.0)) + (fast::clamp((dot(_1119, _767) * rsqrt(fast::max(_1120, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1120 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1215, _767) * rsqrt(fast::max(_1216, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1216 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1311, _767) * rsqrt(fast::max(_1312, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1312 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1407, _767) * rsqrt(fast::max(_1408, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1408 / (_73.radius * _73.radius)), 0.0, 1.0)); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[5u].x) + (_535 * _478[5u].y)) + (_767 * _479[5u].z)) * _73.radius), 1.0); + float2 _1480 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1480; + float4 _1497 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1480, level(0.0)).x, 1.0); + _1006 = _1497; + float3 _1503 = (_1497.xyz / float3(_1006.w)) - _687; + float _1504 = dot(_1503, _1503); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[6u].x) + (_535 * _478[6u].y)) + (_767 * _479[6u].z)) * _73.radius), 1.0); + float2 _1576 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1576; + float4 _1593 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1576, level(0.0)).x, 1.0); + _1006 = _1593; + float3 _1599 = (_1593.xyz / float3(_1006.w)) - _687; + float _1600 = dot(_1599, _1599); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[7u].x) + (_535 * _478[7u].y)) + (_767 * _479[7u].z)) * _73.radius), 1.0); + float2 _1672 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1672; + float4 _1689 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1672, level(0.0)).x, 1.0); + _1006 = _1689; + float3 _1695 = (_1689.xyz / float3(_1006.w)) - _687; + float _1696 = dot(_1695, _1695); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[8u].x) + (_535 * _478[8u].y)) + (_767 * _479[8u].z)) * _73.radius), 1.0); + float2 _1768 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1768; + float4 _1785 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1768, level(0.0)).x, 1.0); + _1006 = _1785; + float3 _1791 = (_1785.xyz / float3(_1006.w)) - _687; + float _1792 = dot(_1791, _1791); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[9u].x) + (_535 * _478[9u].y)) + (_767 * _479[9u].z)) * _73.radius), 1.0); + float2 _1864 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1864; + float4 _1881 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1864, level(0.0)).x, 1.0); + _1006 = _1881; + float3 _1887 = (_1881.xyz / float3(_1006.w)) - _687; + float _1888 = dot(_1887, _1887); + float _1904 = ((((_1424 + (fast::clamp((dot(_1503, _767) * rsqrt(fast::max(_1504, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1504 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1599, _767) * rsqrt(fast::max(_1600, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1600 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1695, _767) * rsqrt(fast::max(_1696, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1696 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1791, _767) * rsqrt(fast::max(_1792, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1792 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1887, _767) * rsqrt(fast::max(_1888, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1888 / (_73.radius * _73.radius)), 0.0, 1.0)); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[10u].x) + (_535 * _478[10u].y)) + (_767 * _479[10u].z)) * _73.radius), 1.0); + float2 _1960 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _1960; + float4 _1977 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1960, level(0.0)).x, 1.0); + _1006 = _1977; + float3 _1983 = (_1977.xyz / float3(_1006.w)) - _687; + float _1984 = dot(_1983, _1983); + _477 = _337; + _478 = _337; + _479 = _337; + _481 = _73.projection * float4(_687 + ((((_532 * _477[11u].x) + (_535 * _478[11u].y)) + (_767 * _479[11u].z)) * _73.radius), 1.0); + float2 _2056 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + _978 = _2056; + float4 _2073 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _2056, level(0.0)).x, 1.0); + _1006 = _2073; + float3 _2079 = (_2073.xyz / float3(_1006.w)) - _687; + float _2080 = dot(_2079, _2079); + _1039 = float4(1.0 - (((_1904 + (fast::clamp((dot(_1983, _767) * rsqrt(fast::max(_1984, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1984 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_2079, _767) * rsqrt(fast::max(_2080, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_2080 / (_73.radius * _73.radius)), 0.0, 1.0))) * 0.083333335816860198974609375)); + break; + } while(false); + out._entryPointOutput = _1039; + return out; +} + diff --git a/src/shaders/compiled/post_ao.frag.spv b/src/shaders/compiled/post_ao.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..924f32fd6daf90f13d6db3c160edb6555916c877 GIT binary patch literal 30924 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 literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/post_ao_blur.frag.msl b/src/shaders/compiled/post_ao_blur.frag.msl new file mode 100644 index 0000000000..b7d8f4ecee --- /dev/null +++ b/src/shaders/compiled/post_ao_blur.frag.msl @@ -0,0 +1,159 @@ +#include +#include + +using namespace metal; + +struct AmbientOcclusion +{ + float4x4 projection; + float4x4 inverseProjection; + float2 depthTexelSize; + float radius; + float padding; +}; + +struct main0_out +{ + float4 _entryPointOutput [[color(0)]]; +}; + +struct main0_in +{ + float2 input_uv [[user(locn0)]]; +}; + +fragment main0_out main0(main0_in in [[stage_in]], constant AmbientOcclusion& _31 [[buffer(0)]], texture2d depthTexture [[texture(0)]], texture2d occlusionTexture [[texture(1)]], sampler depthSampler [[sampler(0)]], sampler occlusionSampler [[sampler(1)]]) +{ + main0_out out = {}; + float2 _385 = (floor((in.input_uv / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _281 = _385; + float4 _404 = _31.inverseProjection * float4((_281.x * 2.0) - 1.0, 1.0 - (_281.y * 2.0), depthTexture.sample(depthSampler, _385, level(0.0)).x, 1.0); + float4 _371 = _404; + float3 _410 = _404.xyz / float3(_371.w); + float2 _496 = (floor(((in.input_uv + float2(_31.depthTexelSize.x, 0.0)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _412 = _496; + float4 _515 = _31.inverseProjection * float4((_412.x * 2.0) - 1.0, 1.0 - (_412.y * 2.0), depthTexture.sample(depthSampler, _496, level(0.0)).x, 1.0); + float4 _482 = _515; + float3 _430 = (_515.xyz / float3(_482.w)) - _410; + float3 _411 = _430; + float2 _537 = (floor(((in.input_uv - float2(_31.depthTexelSize.x, 0.0)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _414 = _537; + float4 _556 = _31.inverseProjection * float4((_414.x * 2.0) - 1.0, 1.0 - (_414.y * 2.0), depthTexture.sample(depthSampler, _537, level(0.0)).x, 1.0); + float4 _523 = _556; + float3 _438 = _410 - (_556.xyz / float3(_523.w)); + float3 _413 = _438; + float2 _578 = (floor(((in.input_uv + float2(0.0, _31.depthTexelSize.y)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _416 = _578; + float4 _597 = _31.inverseProjection * float4((_416.x * 2.0) - 1.0, 1.0 - (_416.y * 2.0), depthTexture.sample(depthSampler, _578, level(0.0)).x, 1.0); + float4 _564 = _597; + float3 _446 = (_597.xyz / float3(_564.w)) - _410; + float3 _415 = _446; + float2 _619 = (floor(((in.input_uv - float2(0.0, _31.depthTexelSize.y)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _418 = _619; + float4 _638 = _31.inverseProjection * float4((_418.x * 2.0) - 1.0, 1.0 - (_418.y * 2.0), depthTexture.sample(depthSampler, _619, level(0.0)).x, 1.0); + float4 _605 = _638; + float3 _454 = _410 - (_638.xyz / float3(_605.w)); + float3 _417 = _454; + float3 _480 = fast::normalize(cross(select(_438, _430, bool3(abs(_411.z) < abs(_413.z))), select(_454, _446, bool3(abs(_415.z) < abs(_417.z))))); + float2 _307 = _31.depthTexelSize * 2.0; + float _310 = _31.radius * 0.25; + float2 _330 = in.input_uv + (float2(-2.0) * _307); + float2 _660 = (floor((_330 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float2 _293 = _660; + float4 _679 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _660, level(0.0)).x, 1.0); + float4 _646 = _679; + float _342 = fast::clamp(1.0 - (abs(dot((_679.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _718 = in.input_uv + (float2(-1.0, -2.0) * _307); + float2 _729 = (floor((_718 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _729; + float4 _746 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _729, level(0.0)).x, 1.0); + _646 = _746; + float _757 = fast::clamp(1.0 - (abs(dot((_746.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _780 = in.input_uv + (float2(0.0, -2.0) * _307); + float2 _791 = (floor((_780 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _791; + float4 _808 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _791, level(0.0)).x, 1.0); + _646 = _808; + float _819 = fast::clamp(1.0 - (abs(dot((_808.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _842 = in.input_uv + (float2(1.0, -2.0) * _307); + float2 _853 = (floor((_842 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _853; + float4 _870 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _853, level(0.0)).x, 1.0); + _646 = _870; + float _881 = fast::clamp(1.0 - (abs(dot((_870.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _908 = in.input_uv + (float2(-2.0, -1.0) * _307); + float2 _919 = (floor((_908 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _919; + float4 _936 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _919, level(0.0)).x, 1.0); + _646 = _936; + float _947 = fast::clamp(1.0 - (abs(dot((_936.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _967 = in.input_uv + (float2(-1.0) * _307); + float2 _978 = (floor((_967 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _978; + float4 _995 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _978, level(0.0)).x, 1.0); + _646 = _995; + float _1006 = fast::clamp(1.0 - (abs(dot((_995.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1026 = in.input_uv + (float2(0.0, -1.0) * _307); + float2 _1037 = (floor((_1026 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1037; + float4 _1054 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1037, level(0.0)).x, 1.0); + _646 = _1054; + float _1065 = fast::clamp(1.0 - (abs(dot((_1054.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1085 = in.input_uv + (float2(1.0, -1.0) * _307); + float2 _1096 = (floor((_1085 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1096; + float4 _1113 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1096, level(0.0)).x, 1.0); + _646 = _1113; + float _1124 = fast::clamp(1.0 - (abs(dot((_1113.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1154 = in.input_uv + (float2(-2.0, 0.0) * _307); + float2 _1165 = (floor((_1154 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1165; + float4 _1182 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1165, level(0.0)).x, 1.0); + _646 = _1182; + float _1193 = fast::clamp(1.0 - (abs(dot((_1182.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1213 = in.input_uv + (float2(-1.0, 0.0) * _307); + float2 _1224 = (floor((_1213 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1224; + float4 _1241 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1224, level(0.0)).x, 1.0); + _646 = _1241; + float _1252 = fast::clamp(1.0 - (abs(dot((_1241.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1283 = (floor((in.input_uv / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1283; + float4 _1300 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1283, level(0.0)).x, 1.0); + _646 = _1300; + float _1311 = fast::clamp(1.0 - (abs(dot((_1300.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float _1319 = ((((((((((occlusionTexture.sample(occlusionSampler, _330, level(0.0)).x * (_342 + 0.001000000047497451305389404296875)) + (occlusionTexture.sample(occlusionSampler, _718, level(0.0)).x * (_757 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _780, level(0.0)).x * (_819 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _842, level(0.0)).x * (_881 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _908, level(0.0)).x * (_947 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _967, level(0.0)).x * (_1006 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1026, level(0.0)).x * (_1065 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1085, level(0.0)).x * (_1124 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1154, level(0.0)).x * (_1193 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1213, level(0.0)).x * (_1252 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, in.input_uv, level(0.0)).x * (_1311 + 0.001000000047497451305389404296875)); + float2 _1331 = in.input_uv + (float2(1.0, 0.0) * _307); + float2 _1342 = (floor((_1331 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1342; + float4 _1359 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1342, level(0.0)).x, 1.0); + _646 = _1359; + float _1370 = fast::clamp(1.0 - (abs(dot((_1359.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1400 = in.input_uv + (float2(-2.0, 1.0) * _307); + float2 _1411 = (floor((_1400 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1411; + float4 _1428 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1411, level(0.0)).x, 1.0); + _646 = _1428; + float _1439 = fast::clamp(1.0 - (abs(dot((_1428.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1459 = in.input_uv + (float2(-1.0, 1.0) * _307); + float2 _1470 = (floor((_1459 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1470; + float4 _1487 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1470, level(0.0)).x, 1.0); + _646 = _1487; + float _1498 = fast::clamp(1.0 - (abs(dot((_1487.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1518 = in.input_uv + (float2(0.0, 1.0) * _307); + float2 _1529 = (floor((_1518 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1529; + float4 _1546 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1529, level(0.0)).x, 1.0); + _646 = _1546; + float _1557 = fast::clamp(1.0 - (abs(dot((_1546.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + float2 _1577 = in.input_uv + _307; + float2 _1588 = (floor((_1577 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + _293 = _1588; + float4 _1605 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1588, level(0.0)).x, 1.0); + _646 = _1605; + float _1616 = fast::clamp(1.0 - (abs(dot((_1605.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); + out._entryPointOutput = float4((((((_1319 + (occlusionTexture.sample(occlusionSampler, _1331, level(0.0)).x * (_1370 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1400, level(0.0)).x * (_1439 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1459, level(0.0)).x * (_1498 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1518, level(0.0)).x * (_1557 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1577, level(0.0)).x * (_1616 + 0.001000000047497451305389404296875))) / (0.01600000075995922088623046875 + (((((((((((((((_342 + _757) + _819) + _881) + _947) + _1006) + _1065) + _1124) + _1193) + _1252) + _1311) + _1370) + _1439) + _1498) + _1557) + _1616))); + return out; +} + diff --git a/src/shaders/compiled/post_ao_blur.frag.spv b/src/shaders/compiled/post_ao_blur.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..c3eeaba33b4896bc0294dee8c3a6afeeb9146c1b GIT binary patch literal 23880 zcmZ9U2fUYM-G~2(z%eI^djYN-;X=iM9M=&yiUU`Qf{Gy^LnU8J+ygi6ZH^q-uzYQ} z%a!Kd>uBblY39g!uj|kAeY?G%&w09k-|Kg;=N?~9r1hL*xjwB{kJj9+j@IeDTkWTB zYYs>Y*1KJ9x$Vep2ThqeX3*eu*092St)A_A)|tQ6r!^;~?;)edO)#+liGI8bP*2VP zL_J%*C_jVuf|m7rQDbRxn;f#=xUmza?y&#<=9$fj~w^Iu`P1F+HL)c$)m@Nn>OXY z%y~^3J!Z_f2?tWEXKPusPcK>xrc7T`r%k4(*?dU&$kB&P8b5aOY~H8!A;H9a4CDW| zO`q1sW$s(;dbQVY+=NNfrVg5RSo(53J6W8`(??7k#~MwWN}lAF%+Yo5JBPEXSu4L| zc=Mfv?LAnaV#}G}NjulFY^Qeb%62l_b@HZv$Ce#kFxOUgQo-z7Hj{TtMsjTj@cKj# zB(|;E^)B;j^NwfUbuaVkGVl7E@4;(*b(wb$%DlSFdybcZ`Pkk)h+c?UIFA9$*7+JQ zLgW?d&$}q~T|2e8{^$-$nXmb|D9zj6{Ct$=$OR%t*xhauYHze^){fikIZYR2_C<5 z7-fG2k9l>cg2%o$rF7n|Yua}a^K?cJZ_A^HrTx}uzeC-ha>qv7-%iA?p?i}0qlmM| zqno^Ill;jI>qpBoiQW5Il*YEpIKL~j?ce8}xZtrHWbHiPK3OBrvybzdp9%BR{#Ns9 z&$rC{LIjTGI+#~`-es%dBd*cyeAtSVzF~L3JO{qc(|O(H0#KyR-DsI_>g;31*3oyS z&c0}wb;8D=-OG|42y;J5c5u_q_GxA{tr zyV9?-w`s5MTwLf5^d*Hhe`%r3Ush=ImlxXn6@@l`WueVqRp?F8QwnW<@k+1I=%IYS z^X`lG{BFXk3`8GJoIg)e=LnemB~-ku#Fy_Z@B<1AHk~F$A!eQyq+idMKJp}zX^3m z!+uJf^U#S-pV!09ji9Y(>;__)9x$U}H=;eC=A7R^a&Ho+Kl`%nTQGUf_1na@m8Y+F ziRI|moVES}Ezeo}l2}%r#jnuvoHzUW8f{k5Who)Nl+?!9` zMTpIn=YCOiJ?>&KdCvXf#I}{Y7MIbvEa!d+;_}=ti7wCmQfTYQbMBWRmfH_M?e&SD zFAFg5lXKr6?YNz=tn~nxJZE(vv8+6+%c12tkDmMG(e_oI`xRjF^tB?ftn6zgwEdXN zxnG&sG0ZvdjN`dqMMhcr`KmB^&i!h{_91s|{k=t&b3drjG9UNVFzd29!Zzi(Ujr@A zxnGl5mN(~qEtvhA&$+*q0X*~OoR7Z;$#U**BhGm#*YCG*b2<0FBlgV8bN+r$?727R z{0EXB!Z_(K=YD;dJm-D`V%y5o*G9zh^4t$aQ>}gO&8O}#VsquW??l(*ZUU3%+;2*3 zTe)j-1)a-s?l&VY&;91;^4xEMwvIgKeoJDx{qXaxb3Ytl-pBRvtZs#N+)m=0`>kQ} zoYifJW#w7j7A?Z_EqlN_Aq(++JRVB_B8@+Kjw1ocOrI-cCN`gXV3jebbao3 zhRJj8cOkY9xobO^QkHYSTcc$@?yF(eWfa0T<+gpCT)%tZ=5p@uCHCCQ0DV~OSExjz6+wf4C;pSlMTn=8-#ICMSk!7zEw{SSz3D|c_MqH|f!{dnT?+#iB2 z&;10nb>unslZfT^!_T+Q{h{mJoo>DuFw5ZFnP}XkBIF|sy-^T!+d2`O^N@7{YyPw$KeNJW$*@p+v za{v2dZ}@}6{P0_Ft7R^2A0qb8kFxEb(eku?n3$h-TXVN@&d)?YLTtb0{jOQC$B5;5 zuZR1)+T$>D{(d(5&#Kwp`2^Z~T#o-FTAuNrBIc((zPZf(X=2x+Z2Jsap0>{t^V4o? zE^~j5*nZ7t?k^I{^JeZZ!OZD3uKPUPa=+T>(o^u{Zye7Q9 z+iSt(r#JqwHnGfeZoAQxgVDD0@7uD+>%io>AL|m!R;13CoXGWv{W}^<^^itesyA%3 zrFx@ATdIdP+EU%wXv_G}R>XI6E}ip?X8v0f_vJO0?>>b(^>?2NlgCSE65CduzD_5W z-_GmW>aS-IQ?2c#=2Q19VsoXJo{g@@JqISwH_Rfot=#+N-|NWYrRNftUV0w7^wRUu z){)0cFC>=R4?pzf@0hdyPU9kgc^}uuKld+2J8ma&_V*H)Jo|eov8?pJ%h2+8oPAx6 zwy)AluYk$Z*OkPwvahSq_G2zydNr|Qm~-A4M=!kw?b?>VJ6{Wv$4jpxwhy^$djh2_ zUV43_Wj^k!VbU-%#ZK=M$ z(U$558*Q2U^9b?2d{pTHe}U-%=G@DH%;8bu`Yt{Olg9%dC$_EJwer3{Nh~it;3+iS zw>`jo>OMnkuJnLs(e=2`!Q}ad=ZS4Aj|a%IH!l#E9`GW%^njPp){$p#UM7~?4?o}9 zn^yqleOw>!?W^e81G-`I?B8p|vM%c9{JoBr=Wg29U(vM(yaAJ^ufGw?%D&!2+mE?; zz+1$QVa|DH96jJ|bnOA}z~u3OcZuyo9uJVk1KuN6`}(-AhFO>Q5w!<=0F%c9J|vdq zjR$-Lvw!pPfRBmgr3ZY1mUlCFJmBwW=i={7=HmgM5}PYM;4`%AVlE!=4`SQv0p@ED z_#9@P(gXg9E< zD;7tWUa#_>G_KH!M4qSPyL-dCu7oV!8LGK4TaO-5Dm& zH|#=eTY0=f7O&Wqxb%wM(4|+5LR&|kJ>1=x*M90f+yiFb$Mx}k?}@IxVlS9H`@A=? ztc&{jz2f_5dG4@%?SrnpVqcg%eT^oTm3{4pwjXoxiv5Wl!<_TZIC{kxbnO*mVe)vz z0mSwpk5|az6$cWleSO?l*DLFC5WMz^aWHwj;$UJ~-gw0iVD@i5UNN3nUV6nLXn8k- z$15hFor_*!K3*}A*j(uqlhCe8)#J1Nf%-3Eq8D^c*E2f}Jub7H1yX{=)iWAxsXn&Rmg?ggZK*!K(U$5H8*Q0;dn&R23{UAjGhupQG;k9!_Wo^Lpx*tYU`k1XDE0deU) z7otn=xd?3?dCtVe#B%$o&%`A#^FFSResL+f_MXdN@|>H?iDg~XkM~@Gmd6w9>q>O( zJy*fx>FX!Nva+wM(e`65-g6DHW0-T^8AtEA7F~PKbuf9n=cmN>A&>XS;yu?Bt9^ak z*V21#fY;u0BTOFexrtboH{SCznEjiN_uNb@FTLmIXn8k-$9sN(b}o94`FPJSiOrSX z^DDILVlLiu3$g9>9`m*L{2FGR(tCb`F1_bgbm=|+i?)tD=j=9Ox%Z|%XTOD+_sPEh z4lQ?l?+sVC^?Ty!yyn8jlhA*hqj&#yO1;KXeP^RB)ps@8QhiUOEpyNABle%|E4|`= zm|kJdyP#J*KwRJ12VwGf#Y4oll{;s>;$dQW=@pNl-G`1QpSq92&6Qs97`h(!ahN>c z@C31KFTvS(ter*T?()9J=<3=V9{f^9#hX zF6zfCUPQ}thwbYnbnO){!{q7f6=GT0*Q;pzF&D4sCUy*S&O77i6|bRduXr6Mk5~Ma z*goX(3R%434Pv#gkNaAB#oyqySG)<6$1C0 zJ+yPtE6m3$-X}I!dc_B5*Tr1C;zMHF>lNl}ulNXNozg2lmQmkx=ih;Tf-b${?`mFo z&e^BLa_>!j&OU>g_sPEh11)!a?+sVC^*OPAVJ>VU3H`!3diTGe)GI92Up3lN{dJ=) z)!#JQGWV`N@SpL!1$gqino zeZ1cbp=+<`2a{)?7bcc2wI*yY+s9_Yp+-gCQo0B6U)lJmO$H&xp>8r#ExOk zd1oBGVkva(6-&e9@rq@L?L!`~ki{#OC06_TxUZ#G^oQ48F#slyR}3VU<&9S?2eW_k z@rvb%<)v4wfR=YNc)Vgov~!_onU7bjL~O3~itnOb7jyB7m5FVySD3H8VilNmO0QTI zU3$f8=+Y~`hqjJ9=WGzM+v(;hdeX{RspyiJ5z2WM%)+E+1%!N%RpY-OY>h6xVjHw|`rVS@_2PzWzIHVE)I9}muJoQ$ z(e=19Ve)*#X~edb$9rV)p3{j-?>Pfqde50?>&SB^&LWoEPkkoNhMD(qee{cS(6#r> zg2{7k&Lx(0Q9s^u9$Fqxu&?vcwf9^Alc%o>iDhM97oqLPT)gLEV#hG&yfcp8a|yck zo=ai!c+X|T_92h=$l^Vh6RUlF+}F~3u7KCxb0th3@41RtmN(w>6PW#*kM~?nEHAz1 z8nnEd!Q(yGqMZvx%Y3}&I%0FB_xu#?x|oaiTu*F!y~lj*JvYFtQ+m&h=+b*`LYLn2 zGqiQ&IcGN$%e^=CIr}-xyifN17ihWTdvCb9tzQz4=QS601PT4eIePbRq11aU)xT-9 zrTW%JTdHqsv}NwuABg>T5lgSQ9i~^9^DgKWcM#Wi_D+~QUU3((ZRO5cuegV}%~=Td zQFbrPeduWNsrx6mxza1{L)YWp50mE`9w4@@JYFG-S3F2udc{NN(kuRqwvIe|_%N~D ze(F7Z1ZLjH_3?iH1zmf^qcC~)`7vTy7xm*6kE7+e!}j$Ay7r1EVe<6#6tS%A>uI$8 zn2T3DL+lvloOj02E1pHyUhy1E9{fLUL}^7UeS$~cQbgr;x)8$p=gT#Imxl1<>|m zE*{XA*fGpG?~J1dEQqc>U?G@19?*~2KIHKLSv+82VzsZ2`&xRyBJkP+7KO><0gDmK z^2P%ehuOdRc)$|G^3nsAM9aGwJRYzV+PQF?TIS;cOB0(bJzyEM>tZe*uq?6d^#Jp= z2lR(or}TgU=+XlQqDv204s9KI&e`(Ba_>!j&Q^e%_sPDmh?YCP_l9fUT8UU6FchjiXp`E(ks?SyAK^rK6N*Qn=8FyBXm9PP?$X5uraZ1}^uKlL7N1~c#D`gp%LN7r7l1x%iO?jn|TQ9r*gY^mnW9k#FG=-Ml` zvJP+h+L~Ba_O*?5Xm2iFu`RJ$17y6Y_z3%T%#@3hcwz!J+aZ2>Pd~Z zR3F-COZAjSTjt&#PJ9e=EWPIlnBHT~yQTL`C$2ri7??cYa4fNH&%+B))_i4%$C_EVpU zlVIk3Tp#`7WOVI4r@-VnH>VQIx~L!TnTeLi6YT3WbnQK-!{q7f3}RW?*O_ShF&FPS zi`X&DIq!_4_neKcz2_X5Jl->l*goX(9$CESTw=AakNaAB&w23Ld(MZ+<2@G;%ksv1 zE`-^?`FPJo#PZU6E>`n)GkCn`60~#Cd(6jsE+sZsde3EO*Tr1C=W=4(>pkXc@3{hI zozi=*M3>%k6}t4EpP;QH&pErASnj>4&)GFF^FG=4YteGY_ug=ITh|fq$7?R^I1>7g zbM)?CPpS7b71d)-TM3ok&8zaE{*nHz@TAOZA(Lwp72>XiN1wjke4^`+(U0|FqI8K7{EN=DZ7f z#Ye>To&6Xlk5_y`Y+Jc=)+;_GmX}`f8QOj5X!5E1Iow?775_xn<9-2?=NrBxwyiu~ zA&XahMO=Et*XYtK{)M)VJbU;JvD|*@J^VM!ypQYS{r(TS_6j#ro_+3tmUU6YE9OAU zbBFD#C%X2EIbrhj)r(lxRrJ*xZ9nGX6@7>u!<_TZIC@0~toDkzVDfmycZlsn9`dosn6Mx zaPvOd_odKs$M@ctUYh^VFU*CVLabjnNALc!lzN4wdO)Ks)dL%Csb0R(mbsrR6YC3l zh38&hSOr$!&sAaa_`+($ww0%^LB#UX7gk5R<{iA|Q+G{bbEPk=g|5e48zzr03?{a% zJiZ`{FRVjc`og;C(ihf4TSuP#8bU0$pL)O6hne?reZ0#Xple^)5GK!_ZbU5WqJDf~ zC|aKTYF`_pYhM@!lc%pvVp&(w*CuHDF&AIhl-M!MIq!_4FKmXcePMH$Jif36v329GanhjuRd zg8BHu_Qd8&U)TZdx|oYEj3BnXzF@xgg&kqmDScrlbm48`()pDL(3iCdt-VO|DiXS3pt8N}*#De2!x~!6J_?nMq<0v?9URM5Pw}DC5l18EkFEcKXeC!eeH-x@N6e-(Pdq zI_sXZ_x|m(&p!KcyPp|Oem1*MmX-Il9)Gg+_7;adFkPAv>UP)-B{Vc?qqW*(T` zU`~VSpg<7G0yNfvXFrAe4t%o`W?F@CS-c+vco21d27<4DEYK0KMyyTnns~p&KTG=8 z{;@!xle`XVc)@O?Euoh1ZX8kU^!{K!|Rk6cfj+Iws~~ z+i49u+OSmH-fd27=Lu|w081wVG93-uxY*7*Y{vw(M%nN-4cn=tk~Zq|5cPR4^||tf zT3y4AnSh!sy=f~+t2~aJ`L}PCRQ$MNb_4Jy0avo z6Q7sKBu8c050E^BL0cZIw{Au5YhMXKB;bOxBP*Ik)A`-!AEpc*KIrdSV!f=_aE z8#jWJXKAD-yl@`LihW6m*tq*`OD@`Q#)+tx4ik*S62?&_<9NpYm9`MD&=eWEo`s048cs-Q_OaSQkC};ybty^f&8RK$4bLVvr>A>h(SXM*{l#=@eHb zH?Y2qsD~pQZM+pVD>?{#1kr26wCqp#{Fc3Z)TAjicMS}jsmehEicETbRCL)kRdL0Z zGG37U0Jl_0D>Fzk>fN_IS1yjxWD zZLSE*`?JE*)W@X2M zIH^>itP~v5{>CBh>P}Am^mv!B=hOb~)ZPUsEdVWZDyXm`NWE*<=8m1ew(?f|9lk+n zK`;Fbcba6ZVJFKgVT5p89igi)9y1irL`{NrT*0znWkNCWx{f(Q5-jYDO#m&Rb z6-GlJyy~pgOrRlWVCj^u)0kQwnKn_A5H5djYP)#V($}W8 z%Nu}KPO@o5*tNxeC>;K2YVYY|WM6#m>C<$Is!C$Xusxn&x1)i>mZM|#)(Zh=2Cnyy z<>ThfRKqlU9oy;^X(WlK@)JM0)b!_y%EphjBt0Cd+W+#$m$VNX1FH-YB@drmBv8~D zkLjszsH%!8O19L#qE=VFRa3Eb%c|1S5_N4&FcN!PM|4V>+&mFGs#5Z7`Uz@=kNP|< z;8h=qS1B052<(F@xwHbwUbb|3CD*h@v6t?Su(?dS(46kQNBgVaKmDCyXGiYg++8&t zM9AleeOfC||J1t~d-77Lih-n@zdSU`Y_XaqTCfOMt^?%IOO;QC2cR+=6Bf| zN+&(y&^sHs{!nPKoyao%A-N$;zAoYSkLBymi{m91EqD8eTSo?713Az-l25;33yL_z z+!(!Ky`|$eZzFf(t&ZE{A@-00d!S#>>o+$B-3$Tbn=QJ~KLKn@|Ja2ur2|L%#{k%E zXGR?Q%=hzO^1x~1Et16$^vP2CYEWB2{g6ZKgMZ1`qZ3K$L3QN0#T$P6^^8ms8o+4{ zBwOlXTHBlBJ@Gl`zFgV-U)c!B;d@z36?$3o^z#2Kx?KGIVAXAXiXUQ3`Fv0H?J&}> z?SJn3w@nf5A@IrX7%L1oNc@ISfRE8QfP*s^vciXj)z=Oj=u$f zkt1D`6Ee4i!hSHYAANgY-Zbf5`%Y5ta(^Fq4C=lT@Sg+n|J)bG0ezt_h^W?=neFiU z*~W0>Kcz8<{~wK^jRIM>AkEh6?AHbVZhx@m2J)BLbr+5M-xU~TTv%YB*fpqbI08y8 zgYHK$h2}rZbryfQulrHCZzJ$asEQOgM?jS*J*QjZLHH~YB^YtPPvD~{sP{`eZjr}} zkD7`L+e*2S_ikE5%&VfTtc+lUa?6s(yqY(=j=g0mU|uZ%YaT=Ju3)o4g5C!8PD~)@ z^E?)qN2xL>(Q&kXqRqsmDYevOOUHIE8cN|yh3#YsKL&tE># zOSzRqk}}u`YDX=PlH5knpnW|KQEJkfb#E%R)>PDj1PiV=v=brMO}aKB`j+{v_*j zE~d_>{e0GYY(L3v)=#qgG01`ch;%Obm+7n`AgCOKS}^izqW{;;Uw4i)L5kIs?2w=H zTl4!vbAQ#caaqgi^pHC&$%QdePM$p5xJ!+Yyzh6V%84uAuQ$24FwH>xm1)%k#b^cG zM$W{8UrgQMNRelaWYpoya+Xn#|Za>vl7vsyJm0GOZ=YV?!ueF2I? z97=}_O2_ALE4pA?NH3JwE+GQ zzJczrV5JN2m|~3ttJN&PztM+b+m%@P0z9U28-QCD*gwFj*q#Y&(*jyhTRVa6aV)U+ z8kS<(X{>UdZCZXG7U(F8buP1%q9eFk?ynt~9cNVG0DytZ=vv(otWL5WhYr(aN*O;U znDMlcn*q@b(ytli6H8=d{&5YXjBH9koaF|*F@fbSrwALlQ9uIzmQn5Pc9+Wt)(gl7 z(<8}9Hd!?7cge^zPN{s^g`NTTinA{9tnxuJilftOffOxkK`P0sKbSu9WW=3#$(1^1 z0@+T|;!q~AO!3ei!;;z1%}z9|PrqBvVnK+D_-^lWvlWG|KaJ`|}R)pi?G*et+J~*x=-m&?e<`Ee< zj{L4r$y_+@MEotj<8}XWOJkTG2)N}l$&izQL@p_}v1(bTB!&Bq&VIFKS&?A=YyTQNM(F%E1`$GKHMrM_%S(I!v|`$YHusY2?T7 z0-ySH!(|>PB*9s+A9@>9bIZ;TeGAK2$3%n63-50}N)3rwg9$Qw0_D3KwTl~P3RiL; zb-66fY}4*aa#H<>^bAd^%*`X`aB$yJTM^04C`6Z|MwhWDcYV|P1BG>4p~ zJ(f|k9tLJ+*QkQ^0pCL(a*R|+O4dDyT}rW#Mds#Z0)7m$fRfqcsNbEaq0ex)1%1_} z(~X*4+S%)A^}$5fA{QAHR~`O#b#R>UAF+478$c8jDRXh0UolhvVtuydNcKyQSH1Z- z`z7G5`7|)FU))`pb5ETW6vGod^(ih4p}Cpg>cG`PV)t@>#J2O&^`HdLj{gIH;J2Ru delta 3377 zcmdT_e^3)w9^WLJ%>oBIu!!ZLAa0Neq8v>KI*8DTSJYT-n-B#QLaAu$Rj%0$ z0V53(jM@majlVc*(Sd?L@YH4lNT8qrt%pJx^iql*ZPCuPv~}+81#Iu`pZoXb-preQ z@B8z8-}`<(>rQB2vLaobraZrPP>+o0UOpO?-S;W=V1ffdQ2PQ15`b?Cm|4C(nA2dY zxDbQ}K+xiV+7*{L>e|1pF-?XQKmYT$qw4S2D`>AbZNsTSYg32$utx8 zP!ZOr2+UxDrjALjF=1nhuouP}*zUq#N^1D96I3=klpkOy?YlVN z_(TrbzT$_!K=&O>^gmAdpH%rbrt~E_%zS^Q>R@zv8o`M+awD3N$$E~X1fjb^p+)&n zlO#ZD{%S79?+FO{+%^~#Z!m8)%A>_5W|+ib{>2VIZfg+{XtI-Kxz60;=KeE9MmZG> zAHPH51C=J#f=YsLX(O(E|NZUr5uqXGP^7YCPeX4-?WvCU^%=yfTssrdAnXjz4u+*9 zZ?*DueaY*k+jnhSU%Wl<^_}|CVAyq(#BU&`rsj7EN~5$IvT?TqbN5#t?l_!XagJ?0 z+^d(Ht951ua+_PPTsilvuyR0G$v~4&ll>~T3o#;(q=m{KDpN9V~)|0pg<^+`caYcHSHQ^$t2_8X!LsHq_=PM`lKfc?P}*J?vC%|`CP}-ewf&BI|RAl-LOHXAe)3J zSFllHSKMsignp8^qCKI*asI-Jq)UF>b$Yoq`QoG#tDC^k>MQ5iD+8wn4=XBaeU}F6 zM+g`X&nOtyd}r2S8<( zRdpkhFGgX;UC@8({XewU4%*kQ{JHJ~c#LO7ml7^7yQl9x!LPtk?(uEk#pb5Lt9d8*pn^l~tx)sq`dQ=$@ z8EY$iJ2F;RKabqzp5Ef^n;3iOz1BC;2c?|gU-ge2fnV3x5R%vpf9en3f@ue z^MyGRKNY{fs4CuawkQ+w-wk|0M(<ME< zJ|Zmo49JB47=`F@qnASQkfz?sMXeK3(Wb- zp}4G@nD9{%;mD{X%?dyVANX-OdO2G4k(uSn;6K9*)-FVAr9vt0M7Fx^c?7EA4Q&Np zaEsO>E9OZ#26d7mx?HcE&ce<< ze%>x0yrzcwzB%Y_oODh0HNvkgOh|bzA!$WNO49{FV$!9K7{$W>CBn2M1Vw-!WH9_< zoDVeNV4A8S)jDo^$mWQ{*{vaI$%isS55E!P>uWZE3{WKE2N^ZiUQQ08 z_aI|t1(zm?t)=);M&f3Za;*@FBB2X2@=3u?2zhG!IeQW*fdpD=PJMKts!%1^P5z?( zLeY)vRtXHcr~1$^^$v~TP5D#3hIYLrc*}_l&*dVHLC79ju+3UcNFdb6bPK+)3QqWO zs5%mk3VAF&X1!r%dEiiqrywM25sZ5U?@TM68l3Per|RTbBq9JsXpXu<6HiigIMgX( zR+SmrFji!l4a#=<7nW?Dvzl(_iY0f=EC+;4IqN}s@?I8wcn@{qS2rPAw0Ze`od)mf z;TlsHSeUZa7zV*CdAwo;8iyHY)U>;YD@bjFJLTOZ`Z6UMl)I8XlZP&mi(KtJy3 zG0MP!84%q-q+gvDFlQ8ac);Qx)ij%b#6dI>uu)if4_zA!()|UUx_e)@%a_iQx?uFz zbZPr?(B?o8&e_|;mC`rjSgA+q;rqtK2l-Khwgyh%i~rgZm|PqD zQwzAR*){`Rq*2Zb7ayD%ws!R(nW?gz$F1zan%`=`)1fm&2=b`aLD#Ix1zT)JEkzzn zjhI)b3mND)MX`j6uSvL3YGm76Tz?2 zt6rGqWp#DU_6m{y_Pt<+pBV9>h{uBzlzE05#|hWc3Js>pF zxr8^roGtMsqec_vFo^E3@C)eGuK+0c@Ju_dsh7}5L3_p1d~ scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(constant CompositeUniforms& _38 [[buffer(0)]], texture2d scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], texture2d ambientOcclusion [[texture(3)]], texture2d bloomSource [[texture(4)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], sampler ambientOcclusionSampler [[sampler(3)]], sampler bloomSourceSampler [[sampler(4)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - float2 _319 = gl_FragCoord.xy * _35.inverseTargetSize; - float4 _305 = scene.sample(sceneSampler, _319); - if (_35.toneMapKnee < 1.0) + float2 _385 = gl_FragCoord.xy * _38.inverseTargetSize; + float4 _370 = scene.sample(sceneSampler, _385); + if (_38.ambientOcclusionStrength > 0.0) { - float4 _329 = _305; - float3 _331 = fast::max(_329.xyz, float3(0.0)); - _305.x = _331.x; - _305.y = _331.y; - _305.z = _331.z; - float _437 = 1.0 - _35.toneMapKnee; - float _342 = _305.y; - float _463 = 1.0 - _35.toneMapKnee; - float _345 = _305.z; - float _489 = 1.0 - _35.toneMapKnee; - _305.x = (_305.x > _35.toneMapKnee) ? (_35.toneMapKnee + (_437 * (1.0 - exp((-(_305.x - _35.toneMapKnee)) / _437)))) : _305.x; - _305.y = (_342 > _35.toneMapKnee) ? (_35.toneMapKnee + (_463 * (1.0 - exp((-(_342 - _35.toneMapKnee)) / _463)))) : _342; - _305.z = (_345 > _35.toneMapKnee) ? (_35.toneMapKnee + (_489 * (1.0 - exp((-(_345 - _35.toneMapKnee)) / _489)))) : _345; + float4 _522 = ambientOcclusion.sample(ambientOcclusionSampler, _385); + float _523 = _522.x; + float _699; + if (_38.ambientOcclusionEffects > 0.0) + { + _699 = mix(_523, 1.0, fast::clamp(dot(bloomSource.sample(bloomSourceSampler, _385).xyz, float3(0.2125999927520751953125, 0.715200006961822509765625, 0.072200000286102294921875)) * 4.0, 0.0, 1.0)); + } + else + { + _699 = _523; + } + float4 _397 = _370; + float3 _399 = _397.xyz * fast::max(1.0 - ((1.0 - _699) * _38.ambientOcclusionStrength), 0.0); + _370.x = _399.x; + _370.y = _399.y; + _370.z = _399.z; } - if (_35.bloomScale > 0.0) + if (_38.toneMapKnee < 1.0) { - float4 _371 = _305; - float3 _380 = float3(1.0) - ((float3(1.0) - _371.xyz) * (float3(1.0) - fast::clamp(bloom.sample(bloomSampler, _319).xyz * _35.bloomScale, float3(0.0), float3(1.0)))); - _305.x = _380.x; - _305.y = _380.y; - _305.z = _380.z; + float4 _411 = _370; + float3 _413 = fast::max(_411.xyz, float3(0.0)); + _370.x = _413.x; + _370.y = _413.y; + _370.z = _413.z; + float _553 = 1.0 - _38.toneMapKnee; + float _424 = _370.y; + float _579 = 1.0 - _38.toneMapKnee; + float _427 = _370.z; + float _605 = 1.0 - _38.toneMapKnee; + _370.x = (_370.x > _38.toneMapKnee) ? (_38.toneMapKnee + (_553 * (1.0 - exp((-(_370.x - _38.toneMapKnee)) / _553)))) : _370.x; + _370.y = (_424 > _38.toneMapKnee) ? (_38.toneMapKnee + (_579 * (1.0 - exp((-(_424 - _38.toneMapKnee)) / _579)))) : _424; + _370.z = (_427 > _38.toneMapKnee) ? (_38.toneMapKnee + (_605 * (1.0 - exp((-(_427 - _38.toneMapKnee)) / _605)))) : _427; } - if (_35.gradingStrength > 0.0) + if (_38.bloomScale > 0.0) { - float4 _392 = _305; - float3 _310 = _392.xyz; - float _522 = _310.z * 31.0; - float _524 = floor(_522); - float _535 = ((_310.x * 31.0) + 0.5) * 0.0009765625; - float _540 = ((_310.y * 31.0) + 0.5) * 0.03125; - float3 _400 = mix(_392.xyz, mix(grading.sample(gradingSampler, float2(_535 + (_524 * 0.03125), _540)).xyz, grading.sample(gradingSampler, float2(_535 + (fast::min(_524 + 1.0, 31.0) * 0.03125), _540)).xyz, float3(_522 - _524)), float3(_35.gradingStrength)); - _305.x = _400.x; - _305.y = _400.y; - _305.z = _400.z; + float4 _453 = _370; + float3 _462 = float3(1.0) - ((float3(1.0) - _453.xyz) * (float3(1.0) - fast::clamp(bloom.sample(bloomSampler, _385).xyz * _38.bloomScale, float3(0.0), float3(1.0)))); + _370.x = _462.x; + _370.y = _462.y; + _370.z = _462.z; } - if (_35.ditherAmount > 0.0) + if (_38.gradingStrength > 0.0) { - float4 _420 = _305; - float3 _423 = _420.xyz + float3((fract(52.98291778564453125 * fract(dot(gl_FragCoord.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))) - 0.5) * _35.ditherAmount); - _305.x = _423.x; - _305.y = _423.y; - _305.z = _423.z; + float4 _474 = _370; + float3 _376 = _474.xyz; + float _638 = _376.z * 31.0; + float _640 = floor(_638); + float _651 = ((_376.x * 31.0) + 0.5) * 0.0009765625; + float _656 = ((_376.y * 31.0) + 0.5) * 0.03125; + float3 _482 = mix(_474.xyz, mix(grading.sample(gradingSampler, float2(_651 + (_640 * 0.03125), _656)).xyz, grading.sample(gradingSampler, float2(_651 + (fast::min(_640 + 1.0, 31.0) * 0.03125), _656)).xyz, float3(_638 - _640)), float3(_38.gradingStrength)); + _370.x = _482.x; + _370.y = _482.y; + _370.z = _482.z; } - out._entryPointOutput = _305; + if (_38.ditherAmount > 0.0) + { + float4 _502 = _370; + float3 _505 = _502.xyz + float3((fract(52.98291778564453125 * fract(dot(gl_FragCoord.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))) - 0.5) * _38.ditherAmount); + _370.x = _505.x; + _370.y = _505.y; + _370.z = _505.z; + } + out._entryPointOutput = _370; return out; } diff --git a/src/shaders/compiled/post_composite.frag.spv b/src/shaders/compiled/post_composite.frag.spv index ec8e2284f1cb7fe2bfca20232ca14296498708c3..d1e6122ad03caf26cb6443d4ccc5772f90361d8b 100644 GIT binary patch literal 7300 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 VM}Mh92iO?ecJNewg%OXX{}(#xxWNDb literal 5920 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 0.0 ? -normal : normal; // towards the camera +} + +float4 main(FSInput input) : SV_Target +{ + if (SceneDepth(input.uv) >= 1.0) + return float4(1.0, 1.0, 1.0, 1.0); // sky + const float3 position = ViewPositionAt(input.uv); + const float3 normal = SurfaceNormal(input.uv, position); + + const uint2 cell = uint2(input.pos.xy) & 3u; + const float angle = 6.2831853 * Rotations[cell.y * 4u + cell.x]; + const float3 turn = float3(cos(angle), sin(angle), 0.0); + const float3 tangent = normalize(turn - normal * dot(turn, normal) + float3(1e-4, 0.0, 0.0)); + const float3 bitangent = cross(normal, tangent); + + float occlusion = 0.0; + [unroll] + for (uint i = 0; i < SampleCount; ++i) + { + const float3 offset = tangent * Kernel[i].x + bitangent * Kernel[i].y + normal * Kernel[i].z; + const float3 samplePosition = position + offset * radius; + const float4 clip = mul(projection, float4(samplePosition, 1.0)); + const float2 sampleUv = float2(clip.x / clip.w * 0.5 + 0.5, 0.5 - clip.y / clip.w * 0.5); + // The surface seen where the sample lands occludes by how far it rises above this surface's + // plane: the same flat ground, wherever its pixel rows put it, does not (no banding). + const float3 toOccluder = ViewPositionAt(sampleUv) - position; + const float distanceSquared = dot(toOccluder, toOccluder); + const float rise = dot(toOccluder, normal) * rsqrt(max(distanceSquared, 1e-6)); + // Only geometry within the radius counts: a far wall behind the sample does not. + const float inRange = saturate(1.0 - distanceSquared / (radius * radius)); + occlusion += saturate(rise - PlaneRise) * inRange; + } + const float visibility = 1.0 - occlusion / SampleCount; + return float4(visibility, visibility, visibility, visibility); +} diff --git a/src/shaders/post_ao_blur.frag.hlsl b/src/shaders/post_ao_blur.frag.hlsl new file mode 100644 index 0000000000..e5046e73d8 --- /dev/null +++ b/src/shaders/post_ao_blur.frag.hlsl @@ -0,0 +1,71 @@ +// post_ao_blur.frag.hlsl — post_ao.frag's occlusion averaged over 4x4 texels, the size of its +// rotation pattern, leaving out texels off the centre's surface (an edge) so edges keep no halo. +// Texels are weighed by their distance from the centre's plane, not by depth: ground far away, whose +// depth changes fast down the screen, still blends fully and the pattern cancels there too. +// AmbientOcclusion mirrors mu::SdlGpuAmbientOcclusionUniform (only some of it is read here). +Texture2D depthTexture : register(t0, space2); +SamplerState depthSampler : register(s0, space2); // point +Texture2D occlusionTexture : register(t1, space2); +SamplerState occlusionSampler : register(s1, space2); // point +cbuffer AmbientOcclusion : register(b0, space3) +{ + float4x4 projection; + float4x4 inverseProjection; + float2 depthTexelSize; + float radius; + float padding; +}; +struct FSInput +{ + float4 pos : SV_Position; + float2 uv : TEXCOORD0; +}; + +// At a depth texel's centre, as post_ao.frag's ViewPositionAt. +float3 ViewPosition(float2 uv) +{ + uv = (floor(uv / depthTexelSize + 0.25) + 0.5) * depthTexelSize; + const float depth = depthTexture.SampleLevel(depthSampler, uv, 0).r; + const float4 view = mul(inverseProjection, float4(uv.x * 2.0 - 1.0, 1.0 - uv.y * 2.0, depth, 1.0)); + return view.xyz / view.w; +} + +// As post_ao.frag's SurfaceNormal: from the nearer neighbour on each axis. +float3 SurfaceNormal(float2 uv, float3 position) +{ + const float3 right = ViewPosition(uv + float2(depthTexelSize.x, 0.0)) - position; + const float3 left = position - ViewPosition(uv - float2(depthTexelSize.x, 0.0)); + const float3 down = ViewPosition(uv + float2(0.0, depthTexelSize.y)) - position; + const float3 up = position - ViewPosition(uv - float2(0.0, depthTexelSize.y)); + const float3 alongX = abs(right.z) < abs(left.z) ? right : left; + const float3 alongY = abs(down.z) < abs(up.z) ? down : up; + return normalize(cross(alongX, alongY)); +} + +float4 main(FSInput input) : SV_Target +{ + const float3 centre = ViewPosition(input.uv); + const float3 normal = SurfaceNormal(input.uv, centre); + // The occlusion is at half the depth's resolution. + const float2 occlusionTexelSize = depthTexelSize * 2.0; + // Texels further than this from the centre's plane are another surface. + const float planeTolerance = radius * 0.25; + float sum = 0.0; + float weightSum = 0.0; + [unroll] + for (int y = -2; y < 2; ++y) + { + [unroll] + for (int x = -2; x < 2; ++x) + { + // Whole texels from the centre: four in a row cover all four of the pattern's columns. + const float2 uv = input.uv + float2(x, y) * occlusionTexelSize; + const float offPlane = abs(dot(ViewPosition(uv) - centre, normal)); + const float weight = saturate(1.0 - offPlane / planeTolerance) + 1e-3; + sum += occlusionTexture.SampleLevel(occlusionSampler, uv, 0).r * weight; + weightSum += weight; + } + } + const float visibility = sum / weightSum; + return float4(visibility, visibility, visibility, visibility); +} diff --git a/src/shaders/post_composite.frag.hlsl b/src/shaders/post_composite.frag.hlsl index f5c037586f..ee8a2de423 100644 --- a/src/shaders/post_composite.frag.hlsl +++ b/src/shaders/post_composite.frag.hlsl @@ -1,4 +1,5 @@ -// post_composite.frag.hlsl — the processed 3D scene: the scene image (an HDR scene tone mapped), +// post_composite.frag.hlsl — the processed 3D scene: the scene image darkened by its ambient +// occlusion (an HDR scene then tone mapped), // with its bloom screen-blended on top, colour graded through the map's lookup table and dithered. // Draws into the frame's destination before the UI. // CompositeUniforms mirrors mu::SdlGpuCompositeUniform. @@ -8,6 +9,10 @@ Texture2D bloom : register(t1, space2); SamplerState bloomSampler : register(s1, space2); // linear: the bloom is half resolution Texture2D grading : register(t2, space2); SamplerState gradingSampler : register(s2, space2); // linear: interpolates between table entries +Texture2D ambientOcclusion : register(t3, space2); +SamplerState ambientOcclusionSampler : register(s3, space2); // linear: half resolution +Texture2D bloomSource : register(t4, space2); +SamplerState bloomSourceSampler : register(s4, space2); // point cbuffer CompositeUniforms : register(b0, space3) { float2 inverseTargetSize; @@ -15,7 +20,8 @@ cbuffer CompositeUniforms : register(b0, space3) float gradingStrength; // 0: ungraded; else blend of the graded colour with the ungraded one float toneMapKnee; // channels above it roll off towards 1; 1: none float ditherAmount; // 0: no dither - float2 compositePadding; + float ambientOcclusionStrength; // 0: no ambient occlusion + float ambientOcclusionEffects; // 1: the bloom source holds this frame's additive light }; struct FSInput { @@ -30,6 +36,7 @@ static const float kGradingSize = 32.0; // Defined after main so the compiled shader declares its textures in binding order (scene, // bloom, grading): spirv-cross numbers Metal textures in that order. float3 Grade(float3 color); +float AmbientOcclusion(float2 uv); // The HDR scene's tone map: unchanged up to the knee, then an exponential shoulder towards 1, so // stacked light rolls off instead of clipping. The same curve as skinned_lit.frag's highlight knee. @@ -49,6 +56,8 @@ float4 main(FSInput input) : SV_Target { const float2 uv = input.pos.xy * inverseTargetSize; float4 color = scene.Sample(sceneSampler, uv); + if (ambientOcclusionStrength > 0.0) + color.rgb *= AmbientOcclusion(uv); if (toneMapKnee < 1.0) { // Blending over light above 1 (inverse colour) can leave negative values: black. @@ -88,3 +97,16 @@ float3 Grade(float3 color) const float3 upper = grading.Sample(gradingSampler, float2(x + upperSlice * sliceWidth, y)).rgb; return lerp(lower, upper, sliceBlend); } + +// The share of the scene's light its ambient occlusion leaves. Additive light (effects, glows) is +// light, not surface: where the bloom source holds it, the occlusion fades out. +float AmbientOcclusion(float2 uv) +{ + float visibility = ambientOcclusion.Sample(ambientOcclusionSampler, uv).r; + if (ambientOcclusionEffects > 0.0) + { + const float effectLight = dot(bloomSource.Sample(bloomSourceSampler, uv).rgb, float3(0.2126, 0.7152, 0.0722)); + visibility = lerp(visibility, 1.0, saturate(effectLight * 4.0)); + } + return max(1.0 - (1.0 - visibility) * ambientOcclusionStrength, 0.0); +} diff --git a/src/source/Core/Utilities/Log/muConsoleDebug.cpp b/src/source/Core/Utilities/Log/muConsoleDebug.cpp index d0e0e72a36..e1b1c7fe81 100644 --- a/src/source/Core/Utilities/Log/muConsoleDebug.cpp +++ b/src/source/Core/Utilities/Log/muConsoleDebug.cpp @@ -126,7 +126,8 @@ bool CheckDeveloperLookCommand(const std::wstring& command) return true; } if (command.starts_with(L"$lightmood ") || command.starts_with(L"$texfilter ") || - command.starts_with(L"$lighting ") || command.starts_with(L"$dynlights ") || command.starts_with(L"$post ")) + command.starts_with(L"$lighting ") || command.starts_with(L"$dynlights ") || command.starts_with(L"$post ") || + command.starts_with(L"$ao ")) { mu::log::Get("render")->warn("{}: not understood (on or off; $lightmood also takes 0 to 100)", Core::Text::ToUtf8(command.c_str())); diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index fd21c1df18..577f251d3f 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -47,6 +47,8 @@ constexpr std::array Infos = {{ {LookValue::BloomStrength, "bloom.strength", 0.6, 0.0, 2.0}, {LookValue::BloomLevelFalloff, "bloom.levelFalloff", 0.5, 0.25, 1.0}, {LookValue::GradingStrength, "grading.strength", 1.0, 0.0, 1.0}, + {LookValue::AmbientOcclusionStrength, "ao.strength", 0.0, 0.0, 2.0}, + {LookValue::AmbientOcclusionRadius, "ao.radius", 60.0, 10.0, 300.0}, }}; constexpr bool InfosFollowLookValueOrder() diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index a45aff6edc..43f13de919 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -49,6 +49,8 @@ enum class LookValue : std::uint8_t BloomStrength, BloomLevelFalloff, GradingStrength, + AmbientOcclusionStrength, + AmbientOcclusionRadius, Count, }; diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 7a31ab0e7a..1be7efb892 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -31,6 +31,8 @@ const CommandForm CommandForms[] = { {L"$dynlights shadowangle ", {LookValue::GroundShadowAngle}}, {L"$dynlights shadowlights ", {LookValue::GroundShadowLights}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, + {L"$ao radius ", {LookValue::AmbientOcclusionRadius}}, + {L"$ao ", {LookValue::AmbientOcclusionStrength}}, {L"$bloom ", {LookValue::BloomStrength}}, }; diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index ff0786a12a..e8ba1a8493 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -33,6 +33,8 @@ // $dynlights shadowlights dynamic.shadowLights // $bloom falloff bloom.levelFalloff // $bloom bloom.strength +// $ao radius ao.radius +// $ao ao.strength namespace Render::Look { diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index 77bc337d28..8754ce5a69 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -78,6 +78,10 @@ constexpr std::array Specs = {{ TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::GradingStrength, TuningGroup::PostProcessing, false, LookValue::GradingStrength, 0.01, TuningUnit::Percent, 100.0, TuningZero::Plain}, + {TuningControlId::AmbientOcclusionStrength, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionStrength, + 0.05, TuningUnit::None, 1.0, TuningZero::Plain}, + {TuningControlId::AmbientOcclusionRadius, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionRadius, + 5.0, TuningUnit::None, 1.0, TuningZero::Plain}, }}; constexpr bool SpecsFollowIdOrder() diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index 65218b0946..1983b42a99 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -77,6 +77,8 @@ enum class TuningControlId : std::uint8_t BloomStrength, BloomLevelFalloff, GradingStrength, + AmbientOcclusionStrength, + AmbientOcclusionRadius, Count, }; inline constexpr std::size_t TuningControlCount = static_cast(TuningControlId::Count); diff --git a/src/source/Render/PostProcessing/PostProcessingSetting.cpp b/src/source/Render/PostProcessing/PostProcessingSetting.cpp index fd4c92f15a..03da2d0dde 100644 --- a/src/source/Render/PostProcessing/PostProcessingSetting.cpp +++ b/src/source/Render/PostProcessing/PostProcessingSetting.cpp @@ -65,9 +65,10 @@ bool SetPostProcessingView(std::wstring_view name) void SubmitPostProcessingLook() { using Data::Maps::LookValue; - mu::GetRenderer().SetPostProcessingLook({Render::Look::Value(LookValue::BloomStrength), - Render::Look::Value(LookValue::BloomLevelFalloff), - Render::Look::Value(LookValue::GradingStrength)}); + mu::GetRenderer().SetPostProcessingLook( + {Render::Look::Value(LookValue::BloomStrength), Render::Look::Value(LookValue::BloomLevelFalloff), + Render::Look::Value(LookValue::GradingStrength), Render::Look::Value(LookValue::AmbientOcclusionStrength), + Render::Look::Value(LookValue::AmbientOcclusionRadius)}); } } // namespace Render::PostProcessing diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index 33c15a50fb..39274195a1 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -70,6 +70,9 @@ struct PostProcessingLook float bloomStrength = 0.0f; float bloomLevelFalloff = 0.5f; float gradingStrength = 1.0f; + // Ambient occlusion: how much it darkens (0: none) and how far it looks, in world units. + float ambientOcclusionStrength = 0.0f; + float ambientOcclusionRadius = 60.0f; }; // --------------------------------------------------------------------------- diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index bec46857d5..4a8c567f5a 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -38,6 +38,7 @@ #include "QuadTopology.h" #include "RangeAllocator.h" #include "SdlGpuPixelFormat.h" +#include "SdlGpuAmbientOcclusion.h" #include "SdlGpuPostProcessing.h" #include "SdlGpuReplayState.h" #include "SdlGpuValidation.h" @@ -1245,6 +1246,11 @@ static SDL_GPUShader* s_vertShaderPostFullscreen = nullptr; // post_fullscreen.v static SDL_GPUShader* s_fragShaderBloomDown = nullptr; // post_bloom_down.frag static SDL_GPUShader* s_fragShaderBloomUp = nullptr; // post_bloom_up.frag static SDL_GPUShader* s_fragShaderComposite = nullptr; // post_composite.frag +static SDL_GPUShader* s_fragShaderAmbientOcclusion = nullptr; // post_ao.frag +static SDL_GPUShader* s_fragShaderAmbientOcclusionBlur = nullptr; // post_ao_blur.frag +// The scene's ambient occlusion (one sample only), and the scene's projection it reconstructs from. +static mu::SdlGpuAmbientOcclusion s_ambientOcclusion; +static float s_sceneProjection[16]{}; // Depth buffer texture for correct 3D depth testing. // Created in Init() at swapchain dimensions, recreated on window resize. @@ -2168,6 +2174,7 @@ class MuRendererSDLGpu : public IMuRenderer DestroyPipelines(); ReleaseShaders(); ReleaseGroundShadowMask(); + s_ambientOcclusion.Release(); s_postProcessing.Release(); SDL_ReleaseWindowFromGPUDevice(s_device, s_window); @@ -2760,6 +2767,14 @@ class MuRendererSDLGpu : public IMuRenderer } s_hdrScenePass = false; + // Read from the scene's depth, which the scene pass stored; anti-aliased frames have none to read. + SDL_GPUTexture* const ambientOcclusion = + s_postProcessingLook.ambientOcclusionStrength > 0.0f && !IsMultisampled() && + s_postProcessingView == mu::PostProcessingView::Scene + ? s_ambientOcclusion.Render(s_cmdBuf, s_depthTexture, {s_swapW, s_swapH}, s_sceneProjection, + s_postProcessingLook.ambientOcclusionRadius) + : nullptr; + // The composite covers every pixel: the target's old content is not loaded. // A diagnostic view without its image this frame leaves black instead. constexpr SDL_FColor black{0.0f, 0.0f, 0.0f, 1.0f}; @@ -2773,7 +2788,7 @@ class MuRendererSDLGpu : public IMuRenderer return false; } s_postProcessing.DrawComposite(s_cmdBuf, s_renderPass, {s_swapW, s_swapH}, s_postProcessingLook, - s_postProcessingView); + s_postProcessingView, ambientOcclusion); ReplayCommands(sceneEnd, s_renderCmds.size(), boneDataReady, ReplaySelection::AllCommands, view); EndReplayPass(); return true; @@ -5179,8 +5194,10 @@ class MuRendererSDLGpu : public IMuRenderer fog.color[1] = m_fogUniform.fogColor[1]; fog.color[2] = m_fogUniform.fogColor[2]; s_sceneLightingUniform = PackSceneLightingUniform(lighting, fog); - // The scene sets its lighting right after its camera, so the model-view is the view. + // The scene sets its lighting right after its camera, so the model-view is the view and the + // projection the scene's. m_worldFromViewMatrix = glm::inverse(m_modelViewMatrix); + std::memcpy(s_sceneProjection, glm::value_ptr(m_projMatrix), sizeof(s_sceneProjection)); } void SetDynamicLights(const DynamicLightsUniform& lights) override @@ -5861,8 +5878,14 @@ class MuRendererSDLGpu : public IMuRenderer createShader("post_bloom_down", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 1, /*fatal=*/false); s_fragShaderBloomUp = createShader("post_bloom_up", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 1, /*fatal=*/false); + // The composite also reads the ambient occlusion and the bloom source (t3, t4). s_fragShaderComposite = - createShader("post_composite", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 3, 0, 1, /*fatal=*/false); + createShader("post_composite", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 5, 0, 1, /*fatal=*/false); + // Ambient occlusion: the depth (t0), and for the blur the occlusion (t1); AmbientOcclusion (b0). + s_fragShaderAmbientOcclusion = + createShader("post_ao", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 1, /*fatal=*/false); + s_fragShaderAmbientOcclusionBlur = + createShader("post_ao_blur", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 1, /*fatal=*/false); mu::log::Get("render")->info("SDL_gpu -- shaders loaded for driver: {}", driverName ? driverName : "unknown"); return true; @@ -5931,7 +5954,8 @@ class MuRendererSDLGpu : public IMuRenderer } for (SDL_GPUShader** shader : {&s_vertShaderWorldLit, &s_fragShaderWorldLit, &s_fragShaderShadowMask, &s_vertShaderPostFullscreen, - &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite}) + &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite, &s_fragShaderAmbientOcclusion, + &s_fragShaderAmbientOcclusionBlur}) { if (*shader) { @@ -6970,6 +6994,8 @@ class MuRendererSDLGpu : public IMuRenderer mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1)); mu::log::Get("render")->info("SDL_gpu -- post-processing {} at {}x", created ? "available" : "unavailable", s_sampleCount); + (void)s_ambientOcclusion.CreatePipelines( + s_device, {s_vertShaderPostFullscreen, s_fragShaderAmbientOcclusion, s_fragShaderAmbientOcclusionBlur}); } // The ground shadow mask's pipelines (one sample, whatever s_sampleCount is). Optional: without them diff --git a/src/source/Render/Renderer/SdlGpuAmbientOcclusion.cpp b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.cpp new file mode 100644 index 0000000000..aaf5fc22f8 --- /dev/null +++ b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.cpp @@ -0,0 +1,210 @@ +#include "SdlGpuAmbientOcclusion.h" + +#include "Core/Utilities/Log/MuLogger.h" + +#include +#include + +#include +#include + +namespace mu +{ +namespace +{ +// Three vertices cover the target with one triangle (post_fullscreen.vert.hlsl). +constexpr Uint32 FullscreenVertexCount = 3u; +constexpr SDL_GPUTextureFormat OcclusionFormat = SDL_GPU_TEXTUREFORMAT_R8_UNORM; + +SDL_GPUGraphicsPipeline* BuildPipeline(SDL_GPUDevice* device, SDL_GPUShader* vertexShader, + SDL_GPUShader* fragmentShader) +{ + SDL_GPUColorTargetDescription colorTarget{}; + colorTarget.format = OcclusionFormat; + + SDL_GPUGraphicsPipelineCreateInfo info{}; + info.vertex_shader = vertexShader; + info.fragment_shader = fragmentShader; + info.primitive_type = SDL_GPU_PRIMITIVETYPE_TRIANGLELIST; + info.rasterizer_state.fill_mode = SDL_GPU_FILLMODE_FILL; + info.rasterizer_state.cull_mode = SDL_GPU_CULLMODE_NONE; + info.rasterizer_state.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE; + info.multisample_state.sample_count = SDL_GPU_SAMPLECOUNT_1; + info.target_info.color_target_descriptions = &colorTarget; + info.target_info.num_color_targets = 1; + return SDL_CreateGPUGraphicsPipeline(device, &info); +} + +SDL_GPUTexture* CreateTarget(SDL_GPUDevice* device, SdlGpuTargetSize size) +{ + SDL_GPUTextureCreateInfo info{}; + info.type = SDL_GPU_TEXTURETYPE_2D; + info.format = OcclusionFormat; + info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER | SDL_GPU_TEXTUREUSAGE_COLOR_TARGET; + info.width = size.width; + info.height = size.height; + info.layer_count_or_depth = 1u; + info.num_levels = 1u; + info.sample_count = SDL_GPU_SAMPLECOUNT_1; + return SDL_CreateGPUTexture(device, &info); +} + +void ReleaseTexture(SDL_GPUDevice* device, SDL_GPUTexture*& texture) +{ + if (texture) + { + SDL_ReleaseGPUTexture(device, texture); + texture = nullptr; + } +} + +void ReleasePipeline(SDL_GPUDevice* device, SDL_GPUGraphicsPipeline*& pipeline) +{ + if (pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(device, pipeline); + pipeline = nullptr; + } +} +} // namespace + +bool SdlGpuAmbientOcclusion::CreatePipelines(SDL_GPUDevice* device, const SdlGpuAmbientOcclusionShaders& shaders) +{ + if (m_device && m_device != device) + { + // Handles of an earlier device, destroyed with it: forget them. + *this = SdlGpuAmbientOcclusion{}; + } + DestroyPipelines(); + if (!device || !shaders.fullscreenVertex || !shaders.occlusion || !shaders.blur) + { + return false; + } + m_device = device; + m_occlusionPipeline = BuildPipeline(device, shaders.fullscreenVertex, shaders.occlusion); + m_blurPipeline = BuildPipeline(device, shaders.fullscreenVertex, shaders.blur); + if (!m_pointSampler) + { + SDL_GPUSamplerCreateInfo info{}; + info.min_filter = SDL_GPU_FILTER_NEAREST; + info.mag_filter = SDL_GPU_FILTER_NEAREST; + info.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST; + info.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + info.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + info.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + m_pointSampler = SDL_CreateGPUSampler(device, &info); + } + if (!IsAvailable()) + { + log::Get("render")->warn("SDL_gpu -- ambient occlusion unavailable: {}", SDL_GetError()); + DestroyPipelines(); + return false; + } + return true; +} + +void SdlGpuAmbientOcclusion::DestroyPipelines() +{ + ReleasePipeline(m_device, m_occlusionPipeline); + ReleasePipeline(m_device, m_blurPipeline); +} + +bool SdlGpuAmbientOcclusion::IsAvailable() const +{ + return m_occlusionPipeline && m_blurPipeline && m_pointSampler; +} + +SDL_GPUTexture* SdlGpuAmbientOcclusion::Render(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUTexture* depth, + SdlGpuTargetSize size, const float (&projection)[16], float radius) +{ + if (!IsAvailable() || !depth || !EnsureTargets(size)) + { + return nullptr; + } + + SdlGpuAmbientOcclusionUniform uniform{}; + const glm::mat4 projectionMatrix = glm::make_mat4(projection); + std::memcpy(uniform.projection, projection, sizeof(uniform.projection)); + std::memcpy(uniform.inverseProjection, glm::value_ptr(glm::inverse(projectionMatrix)), + sizeof(uniform.inverseProjection)); + uniform.depthTexelSize[0] = 1.0f / static_cast(size.width); + uniform.depthTexelSize[1] = 1.0f / static_cast(size.height); + uniform.radius = radius; + + const SDL_GPUTextureSamplerBinding occlusionInputs[] = {{depth, m_pointSampler}}; + if (!RunPass(commandBuffer, m_occlusionPipeline, m_occlusion, occlusionInputs, 1u, uniform)) + { + return nullptr; + } + const SDL_GPUTextureSamplerBinding blurInputs[] = {{depth, m_pointSampler}, {m_occlusion, m_pointSampler}}; + return RunPass(commandBuffer, m_blurPipeline, m_blurred, blurInputs, 2u, uniform) ? m_blurred : nullptr; +} + +void SdlGpuAmbientOcclusion::Release() +{ + DestroyPipelines(); + ReleaseTargets(); + if (m_pointSampler) + { + SDL_ReleaseGPUSampler(m_device, m_pointSampler); + m_pointSampler = nullptr; + } + m_device = nullptr; +} + +bool SdlGpuAmbientOcclusion::EnsureTargets(SdlGpuTargetSize size) +{ + const SdlGpuTargetSize half{std::max(size.width / 2u, 1u), std::max(size.height / 2u, 1u)}; + if (m_occlusion && m_size.width == half.width && m_size.height == half.height) + { + return true; + } + ReleaseTargets(); + m_occlusion = CreateTarget(m_device, half); + m_blurred = CreateTarget(m_device, half); + if (!m_occlusion || !m_blurred) + { + log::Get("render")->error("SDL_gpu -- ambient occlusion targets failed ({}x{}): {}", half.width, half.height, + SDL_GetError()); + ReleaseTargets(); + return false; + } + m_size = half; + return true; +} + +void SdlGpuAmbientOcclusion::ReleaseTargets() +{ + ReleaseTexture(m_device, m_occlusion); + ReleaseTexture(m_device, m_blurred); + m_size = {}; +} + +bool SdlGpuAmbientOcclusion::RunPass(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUGraphicsPipeline* pipeline, + SDL_GPUTexture* target, const SDL_GPUTextureSamplerBinding* inputs, + Uint32 inputCount, const SdlGpuAmbientOcclusionUniform& uniform) +{ + SDL_GPUColorTargetInfo colorTarget{}; + colorTarget.texture = target; + colorTarget.load_op = SDL_GPU_LOADOP_DONT_CARE; + colorTarget.store_op = SDL_GPU_STOREOP_STORE; + colorTarget.cycle = true; + SDL_GPURenderPass* pass = SDL_BeginGPURenderPass(commandBuffer, &colorTarget, 1, nullptr); + if (!pass) + { + return false; + } + const SDL_GPUViewport viewport{0.0f, 0.0f, static_cast(m_size.width), static_cast(m_size.height), + 0.0f, 1.0f}; + const SDL_Rect scissor{0, 0, static_cast(m_size.width), static_cast(m_size.height)}; + SDL_SetGPUViewport(pass, &viewport); + SDL_SetGPUScissor(pass, &scissor); + SDL_BindGPUGraphicsPipeline(pass, pipeline); + SDL_BindGPUFragmentSamplers(pass, 0, inputs, inputCount); + SDL_PushGPUFragmentUniformData(commandBuffer, 0, &uniform, sizeof(uniform)); + SDL_DrawGPUPrimitives(pass, FullscreenVertexCount, 1, 0, 0); + SDL_EndGPURenderPass(pass); + return true; +} + +} // namespace mu diff --git a/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h new file mode 100644 index 0000000000..bfe240163b --- /dev/null +++ b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h @@ -0,0 +1,67 @@ +// SdlGpuAmbientOcclusion.h: screen-space ambient occlusion of the Enhanced scene, from its depth. +#pragma once + +#include "SdlGpuPixelFormat.h" + +#include + +#include + +namespace mu +{ + +struct SdlGpuAmbientOcclusionShaders +{ + SDL_GPUShader* fullscreenVertex = nullptr; + SDL_GPUShader* occlusion = nullptr; + SDL_GPUShader* blur = nullptr; +}; + +// Mirrors AmbientOcclusion in post_ao.frag.hlsl and post_ao_blur.frag.hlsl. Matrices column-major, +// as glm keeps them. +struct SdlGpuAmbientOcclusionUniform +{ + float projection[16]; + float inverseProjection[16]; + float depthTexelSize[2]; + float radius; + float padding; +}; +static_assert(offsetof(SdlGpuAmbientOcclusionUniform, depthTexelSize) == 128); +static_assert(sizeof(SdlGpuAmbientOcclusionUniform) == 144); + +// The occlusion pass at half the frame's size and its blur, into R8 textures the composite reads +// (1: open, 0: hidden). Needs a single-sample, sampleable scene depth. +class SdlGpuAmbientOcclusion +{ +public: + [[nodiscard]] bool CreatePipelines(SDL_GPUDevice* device, const SdlGpuAmbientOcclusionShaders& shaders); + void DestroyPipelines(); + [[nodiscard]] bool IsAvailable() const; + + // The blurred occlusion of `depth` (of `size`) seen through `projection` (column-major), or null + // when it cannot be rendered. `radius` is in view-space units. + [[nodiscard]] SDL_GPUTexture* Render(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUTexture* depth, + SdlGpuTargetSize size, const float (&projection)[16], float radius); + + // Everything, at shutdown. + void Release(); + +private: + [[nodiscard]] bool EnsureTargets(SdlGpuTargetSize size); + void ReleaseTargets(); + // False when the pass could not be opened. + [[nodiscard]] bool RunPass(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUGraphicsPipeline* pipeline, + SDL_GPUTexture* target, const SDL_GPUTextureSamplerBinding* inputs, Uint32 inputCount, + const SdlGpuAmbientOcclusionUniform& uniform); + + SDL_GPUDevice* m_device = nullptr; + SDL_GPUGraphicsPipeline* m_occlusionPipeline = nullptr; + SDL_GPUGraphicsPipeline* m_blurPipeline = nullptr; + SDL_GPUSampler* m_pointSampler = nullptr; + SdlGpuTargetSize m_size{}; + SDL_GPUTexture* m_occlusion = nullptr; + SDL_GPUTexture* m_blurred = nullptr; +}; + +} // namespace mu diff --git a/src/source/Render/Renderer/SdlGpuPixelFormat.cpp b/src/source/Render/Renderer/SdlGpuPixelFormat.cpp index 2f1ab6578f..f27531fbe1 100644 --- a/src/source/Render/Renderer/SdlGpuPixelFormat.cpp +++ b/src/source/Render/Renderer/SdlGpuPixelFormat.cpp @@ -87,6 +87,11 @@ std::optional GetSdlGpuDepthTextureInfo(SdlGpuTargetSi info.type = SDL_GPU_TEXTURETYPE_2D; info.format = SdlGpuDepthFormat; info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; + // A single-sample depth is also read: the ambient occlusion. + if (sampleCount == SDL_GPU_SAMPLECOUNT_1) + { + info.usage |= SDL_GPU_TEXTUREUSAGE_SAMPLER; + } info.width = size.width; info.height = size.height; info.layer_count_or_depth = 1u; diff --git a/src/source/Render/Renderer/SdlGpuPixelFormat.h b/src/source/Render/Renderer/SdlGpuPixelFormat.h index 4d98238997..a0e82aa409 100644 --- a/src/source/Render/Renderer/SdlGpuPixelFormat.h +++ b/src/source/Render/Renderer/SdlGpuPixelFormat.h @@ -33,7 +33,7 @@ struct SdlGpuTargetSize GetSdlGpuMultisampleColorTextureInfo(SDL_GPUTextureFormat format, SdlGpuTargetSize size, SDL_GPUSampleCount sampleCount); -// The frame's depth buffer, with the frame's sample count. +// The frame's depth buffer, with the frame's sample count; with one sample also sampleable. [[nodiscard]] std::optional GetSdlGpuDepthTextureInfo(SdlGpuTargetSize size, SDL_GPUSampleCount sampleCount); diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp index fc03b08c8e..46ae15155f 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp @@ -338,7 +338,8 @@ void SdlGpuPostProcessing::RenderBloom(SDL_GPUCommandBuffer* commandBuffer, floa } void SdlGpuPostProcessing::DrawComposite(SDL_GPUCommandBuffer* commandBuffer, SDL_GPURenderPass* pass, - SdlGpuTargetSize size, const PostProcessingLook& look, PostProcessingView view) + SdlGpuTargetSize size, const PostProcessingLook& look, PostProcessingView view, + SDL_GPUTexture* ambientOcclusion) { if (!IsAvailable() || !m_sceneTexture || size.width == 0u || size.height == 0u) { @@ -387,6 +388,8 @@ void SdlGpuPostProcessing::DrawComposite(SDL_GPUCommandBuffer* commandBuffer, SD {shown, shownSampler}, {bloom ? m_bloomLevels[0].texture : m_sceneTexture, m_linearSampler}, {grading ? m_gradingTexture : m_sceneTexture, m_linearSampler}, + {ambientOcclusion ? ambientOcclusion : m_sceneTexture, m_linearSampler}, + {bloomRendered ? m_bloomSourceTexture : m_sceneTexture, m_pointSampler}, }; const SDL_GPUViewport viewport{0.0f, 0.0f, static_cast(size.width), static_cast(size.height), @@ -405,7 +408,8 @@ void SdlGpuPostProcessing::DrawComposite(SDL_GPUCommandBuffer* commandBuffer, SD gradingStrength, hdr ? HdrToneMapKnee : 1.0f, hdr ? DitherAmount : 0.0f, - {}}; + ambientOcclusion && view == PostProcessingView::Scene ? look.ambientOcclusionStrength : 0.0f, + bloomRendered ? 1.0f : 0.0f}; SDL_PushGPUFragmentUniformData(commandBuffer, 0, &uniform, sizeof(uniform)); SDL_DrawGPUPrimitives(pass, FullscreenVertexCount, 1, 0, 0); } diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.h b/src/source/Render/Renderer/SdlGpuPostProcessing.h index dc2c4eb837..56683fbe5d 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.h +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.h @@ -45,7 +45,10 @@ struct SdlGpuCompositeUniform float toneMapKnee; // Amplitude of the ordered dither added before the 8-bit target; 0 for none. float ditherAmount; - float padding[2]; + // How much the ambient occlusion darkens the scene; 0 for none. + float ambientOcclusionStrength; + // 1 when the bloom source holds this frame's additive light, which the occlusion leaves alone. + float ambientOcclusionEffects; }; static_assert(offsetof(SdlGpuCompositeUniform, bloomScale) == 8); static_assert(offsetof(SdlGpuCompositeUniform, gradingStrength) == 12); @@ -95,8 +98,10 @@ class SdlGpuPostProcessing // RenderBloom ran (with the same level falloff), graded through the grading // table at the look's grading strength when one is set. The diagnostic // views show the bloom source or the bloom instead, ungraded. + // `ambientOcclusion` (SdlGpuAmbientOcclusion, or null for none) darkens the scene at the look's + // strength. void DrawComposite(SDL_GPUCommandBuffer* commandBuffer, SDL_GPURenderPass* pass, SdlGpuTargetSize size, - const PostProcessingLook& look, PostProcessingView view); + const PostProcessingLook& look, PostProcessingView view, SDL_GPUTexture* ambientOcclusion); // Replaces the grading table (Render::PostProcessing::LoadGradingTable's // RGBA8 texels), or empty for none. False (and no table) when it cannot be uploaded. diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 335d2c1f68..19e7edbf07 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -74,6 +74,10 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningBloomSpread, I18N::Game::TuningBloomSpreadHelp}; case TuningControlId::GradingStrength: return {I18N::Game::TuningColourGradingStrength, I18N::Game::TuningColourGradingStrengthHelp}; + case TuningControlId::AmbientOcclusionStrength: + return {I18N::Game::TuningContactShadows, I18N::Game::TuningContactShadowsHelp}; + case TuningControlId::AmbientOcclusionRadius: + return {I18N::Game::TuningContactShadowReach, I18N::Game::TuningContactShadowReachHelp}; case TuningControlId::Count: break; } diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index 1b2d5b7299..eb130432d2 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -265,7 +265,7 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::DynamicEffectRangeMax, 8}, {LookValue::DynamicEffectFade, 0.5}, {LookValue::DynamicEffectCap, 2.5}, {LookValue::BloomStrength, 1.0}, {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, - {LookValue::GroundShadowLights, 2}, + {LookValue::GroundShadowLights, 2}, {LookValue::AmbientOcclusionStrength, 0.8}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { diff --git a/tests/render/test_frame_pixel_readback.cpp b/tests/render/test_frame_pixel_readback.cpp index cdcb2c33fb..fb51090537 100644 --- a/tests/render/test_frame_pixel_readback.cpp +++ b/tests/render/test_frame_pixel_readback.cpp @@ -271,7 +271,7 @@ TEST_CASE("depth buffer carries the frame's sample count [frame readback][antial const auto single = mu::GetSdlGpuDepthTextureInfo({1920u, 1080u}, SDL_GPU_SAMPLECOUNT_1); REQUIRE(single.has_value()); CHECK(single->format == mu::SdlGpuDepthFormat); - CHECK(single->usage == SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET); + CHECK(single->usage == (SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER)); CHECK(single->sample_count == SDL_GPU_SAMPLECOUNT_1); const auto multisampled = mu::GetSdlGpuDepthTextureInfo({1920u, 1080u}, SDL_GPU_SAMPLECOUNT_8); diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index 5ae22274e1..b3642bf01d 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -64,6 +64,9 @@ TEST_CASE("the look profile's built-in values are the renderer's values before i CHECK(BuiltInFloat(LookValue::BloomLevelFalloff) == mu::SdlGpuPostProcessing::BloomLevelWeight); CHECK(BuiltInFloat(LookValue::BloomLevelFalloff) == mu::PostProcessingLook{}.bloomLevelFalloff); CHECK(BuiltIn(LookValue::GradingStrength) == 1.0); + // Ambient occlusion: off, at the renderer's default reach. + CHECK(BuiltIn(LookValue::AmbientOcclusionStrength) == 0.0); + CHECK(BuiltInFloat(LookValue::AmbientOcclusionRadius) == mu::PostProcessingLook{}.ambientOcclusionRadius); } TEST_CASE("dynamic.wrap: the point-light diffuse from Lambert to half-Lambert [render][look]") @@ -230,6 +233,8 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$dynlights shadowlights 3", LookValue::GroundShadowLights, 3.0); single(L"$bloom falloff 0.6", LookValue::BloomLevelFalloff, 0.6); single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); + single(L"$ao radius 80", LookValue::AmbientOcclusionRadius, 80.0); + single(L"$ao 0.5", LookValue::AmbientOcclusionStrength, 0.5); const std::optional diffuse = ParseLookTuningCommand(L"$lighting diffuse 1.0 0.3 0.15"); diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index 25882e0624..cef42fdd79 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -83,6 +83,10 @@ const SpecRow Spec[] = { 0.05, TuningUnit::None, TuningZero::Plain}, {TuningControlId::GradingStrength, TuningGroup::PostProcessing, false, LookValue::GradingStrength, 0, 1, 0.01, TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::AmbientOcclusionStrength, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionStrength, + 0, 2, 0.05, TuningUnit::None, TuningZero::Plain}, + {TuningControlId::AmbientOcclusionRadius, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionRadius, 10, + 300, 5, TuningUnit::None, TuningZero::Plain}, }; Data::Maps::LookProfileData ShippedLikeProfile() @@ -98,9 +102,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 22 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 24 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 22); + REQUIRE(Render::Look::TuningControlCount == 24); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From 2548cb3309ecc1b5ffc7f4423316bd03045edf4e Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 20 Oct 2026 23:48:00 +0800 Subject: [PATCH 07/17] tune(render): calmer skill lights and metal shine in the shipped Enhanced look Skill and spell lights washed out the ground around a fight, and metal armour read too glossy. The shipped Enhanced look now uses the values settled on in play: - dynamic.effectGain 2.5 -> 0.5: effect lights half as bright as their calls ask for. - dynamic.effectRange 3 -> 2: effect lights reach twice their calls' range, less far than before. - lighting.specular.scale 1 -> 0.8. --- docs/enhanced-look.md | 12 ++++++------ src/bin/Data/Render/Look.json | 6 +++--- tests/data/test_look_profile_json.cpp | 3 ++- 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index b14d302841..b90e153c16 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -70,14 +70,14 @@ window. |---|---|---|---|---|---|---| | Enhanced lighting | Directional light | `lighting.diffuse.scale` | 0–2 | 0.05 | 1 | common | | Enhanced lighting | Rim intensity | `lighting.rim.strength` | 0–1 | 0.05 | 0.4 | common | -| Enhanced lighting | Metallic shine | `lighting.specular.scale` | 0–2 | 0.05 | 1 | common | +| Enhanced lighting | Metallic shine | `lighting.specular.scale` | 0–2 | 0.05 | 0.8 | common | | Enhanced lighting | Ambient fill | `lighting.diffuse.ambient` | 0–1 | 0.05 | 0.3 | More settings | | Enhanced lighting | Minimum light | `lighting.diffuse.floor` | 0–1 | 0.05 | 0.15 | More settings | | Enhanced lighting | Highlight knee | `lighting.highlightKnee` | 0.5–0.9 | 0.01 | 0.8 | More settings | | Enhanced lighting | Rim concentration | `lighting.rim.power` | 1–8 | 0.1 | 3 | More settings | | Enhanced lighting | Shine concentration | `lighting.specular.power` | 4–128 | 1 | 32 | More settings | -| Dynamic lights | Skill intensity | `dynamic.effectGain` | 0–4× | 0.1× | 2.5× | common | -| Dynamic lights | Skill radius | `dynamic.effectRange` | 0.5–4× | 0.1× | 3× | common | +| Dynamic lights | Skill intensity | `dynamic.effectGain` | 0–4× | 0.1× | 0.5× | common | +| Dynamic lights | Skill radius | `dynamic.effectRange` | 0.5–4× | 0.1× | 2× | common | | Dynamic lights | Skill fade | `dynamic.effectFade` | 0–2 s | 0.05 s | 0.5 s | common | | Dynamic lights | Overlapping-light cap | `dynamic.effectCap` | 0–8 | 0.1 | 2.5 | common | | Dynamic lights | Shadow darkness | `dynamic.shadowOpacity` | 0–100 % | 5 % | 60 % | common | @@ -198,12 +198,12 @@ for the whole file. | `lighting.highlightKnee` | 0.8 | 0.8 | 0.5–0.9 | lit colours above it approach white without reaching it | | `lighting.rim.strength` | 0.4 | 0.35 | 0–1 | light along a model's silhouette | | `lighting.rim.power` | 3 | 3 | 1–8 | how narrow the rim is | -| `lighting.specular.scale` | 1 | 1 | 0–2 | highlights on item models that declare specular (`material.specular` in the item-model JSON; the metal armour sets) | +| `lighting.specular.scale` | 0.8 | 1 | 0–2 | highlights on item models that declare specular (`material.specular` in the item-model JSON; the metal armour sets) | | `lighting.specular.power` | 32 | 32 | 4–128 | how small the highlight is | | `dynamic.wrap` | 0.3 | 0.5 | 0–0.5 | how far a point light reaches round a model | | `dynamic.mapSmoothing` | 0.5 | 0 | 0–2 | seconds over which flickering map and character lights (candles, fires) ease to their new brightness | -| `dynamic.effectGain` | 2.5 | 1 | 0–4 | brightness factor of spell and effect lights | -| `dynamic.effectRange` | 3 | 1 | 0.5–4 | range factor of spell and effect lights | +| `dynamic.effectGain` | 0.5 | 1 | 0–4 | brightness factor of spell and effect lights | +| `dynamic.effectRange` | 2 | 1 | 0.5–4 | range factor of spell and effect lights | | `dynamic.effectRangeMax` | 8 | 0 (none) | 0–16 | the most terrain cells the range factor may widen a light to | | `dynamic.effectFade` | 0.5 | 0 | 0–2 | seconds over which a spell's light fades out after it ends | | `dynamic.effectCap` | 2.5 | 0 (none) | 0–8 | the most light overlapping spell lights may add up to | diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 790befd32d..067c2a52ef 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -7,12 +7,12 @@ "lighting.highlightKnee": 0.8, "lighting.rim.strength": 0.4, "lighting.rim.power": 3, - "lighting.specular.scale": 1.0, + "lighting.specular.scale": 0.8, "lighting.specular.power": 32, "dynamic.wrap": 0.3, "dynamic.mapSmoothing": 0.5, - "dynamic.effectGain": 2.5, - "dynamic.effectRange": 3, + "dynamic.effectGain": 0.5, + "dynamic.effectRange": 2, "dynamic.effectRangeMax": 8, "dynamic.effectFade": 0.5, "dynamic.effectCap": 2.5, diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index eb130432d2..13d63620b4 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -261,11 +261,12 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::DiffuseScale, 1.0}, {LookValue::DiffuseAmbient, 0.3}, {LookValue::DiffuseFloor, 0.15}, {LookValue::RimStrength, 0.4}, {LookValue::DynamicWrap, 0.3}, {LookValue::DynamicMapSmoothing, 0.5}, - {LookValue::DynamicEffectGain, 2.5}, {LookValue::DynamicEffectRange, 3.0}, + {LookValue::DynamicEffectGain, 0.5}, {LookValue::DynamicEffectRange, 2.0}, {LookValue::DynamicEffectRangeMax, 8}, {LookValue::DynamicEffectFade, 0.5}, {LookValue::DynamicEffectCap, 2.5}, {LookValue::BloomStrength, 1.0}, {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, {LookValue::GroundShadowLights, 2}, {LookValue::AmbientOcclusionStrength, 0.8}, + {LookValue::SpecularScale, 0.8}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { From 358b342a127ec843a2b8bf19df97448e1376ec63 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 21 Oct 2026 03:55:21 +0800 Subject: [PATCH 08/17] fix(render): Metal shaders take their uniform buffers in the declared order SDL pushes uniform slot N into MSL buffer N, but spirv-cross numbered the MSL buffers in the order the compiled code first uses them. Three fragment shaders read the wrong data on Metal: world_lit and skinned_lit took fog as scene lighting (and so on), basic_textured_fog swapped fog and scene light. - MSL is generated with --msl-decoration-binding, which keeps the declared bindings, for every shader without storage buffers (in mu_add_shader and in the reflection check's own MSL). Storage buffers share the MSL buffer indices and follow the uniform buffers, so the two skinned vertex shaders keep spirv-cross's numbering, which the check already pins. - The reflection check verifies each MSL uniform buffer's index against its binding, as it does for textures and samplers. It reported all three shaders before this change. --- CMakeLists.txt | 17 +- cmake/ValidateShaderReflection.cmake | 32 +- .../compiled/basic_textured_fog.frag.dxil | Bin 6060 -> 6060 bytes .../compiled/basic_textured_fog.frag.msl | 72 +++-- .../compiled/basic_textured_fog.frag.spv | Bin 3668 -> 5068 bytes src/shaders/compiled/post_ao.frag.dxil | Bin 14648 -> 14640 bytes src/shaders/compiled/post_ao.frag.msl | 257 ++++++---------- src/shaders/compiled/post_ao.frag.spv | Bin 30924 -> 10504 bytes src/shaders/compiled/post_ao_blur.frag.dxil | Bin 11184 -> 11176 bytes src/shaders/compiled/post_ao_blur.frag.msl | 203 +++++-------- src/shaders/compiled/post_ao_blur.frag.spv | Bin 23880 -> 6936 bytes src/shaders/compiled/post_composite.frag.dxil | Bin 6472 -> 6468 bytes src/shaders/compiled/post_composite.frag.msl | 157 ++++++---- src/shaders/compiled/post_composite.frag.spv | Bin 7300 -> 9180 bytes src/shaders/compiled/shadow_mask.frag.dxil | Bin 3084 -> 3092 bytes src/shaders/compiled/shadow_mask.frag.msl | 25 +- src/shaders/compiled/shadow_mask.frag.spv | Bin 520 -> 1252 bytes src/shaders/compiled/skinned_lit.frag.dxil | Bin 10680 -> 10676 bytes src/shaders/compiled/skinned_lit.frag.msl | 274 +++++++++++------- src/shaders/compiled/skinned_lit.frag.spv | Bin 10936 -> 17240 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 7524 -> 7520 bytes src/shaders/compiled/world_lit.frag.msl | 101 +++++-- src/shaders/compiled/world_lit.frag.spv | Bin 6576 -> 8812 bytes src/shaders/compiled/world_lit.vert.dxil | Bin 5176 -> 5176 bytes src/shaders/compiled/world_lit.vert.msl | 60 +++- src/shaders/compiled/world_lit.vert.spv | Bin 2304 -> 3908 bytes 26 files changed, 674 insertions(+), 524 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 538aacbb22..32438ea415 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -100,6 +100,21 @@ if(MU_ENABLE_SHADER_COMPILATION) set(spv "${MU_SHADER_OUTPUT_DIR}/${shader_name}.${stage}.spv") set(msl "${MU_SHADER_OUTPUT_DIR}/${shader_name}.${stage}.msl") set(dxil "${MU_SHADER_OUTPUT_DIR}/${shader_name}.${stage}.dxil") + # SDL binds uniform buffer, texture and sampler slot N to MSL index N: keep the declared + # bindings (spirv-cross otherwise numbers them in order of use). Not with storage buffers, + # which share the MSL buffer indices and follow the uniform buffers. + file(READ "${src}" shader_source) + # Storage buffers may be declared in an included .hlsli. + string(REGEX MATCHALL "#include \"[^\"]+\"" shader_includes "${shader_source}") + foreach(shader_include IN LISTS shader_includes) + string(REGEX REPLACE "#include \"([^\"]+)\"" "\\1" shader_include "${shader_include}") + file(READ "${MU_SHADER_SOURCE_DIR}/${shader_include}" include_source) + string(APPEND shader_source "${include_source}") + endforeach() + set(msl_flags) + if(NOT shader_source MATCHES "StructuredBuffer|ByteAddressBuffer") + set(msl_flags --msl-decoration-binding) + endif() add_custom_command( OUTPUT "${spv}" @@ -110,7 +125,7 @@ if(MU_ENABLE_SHADER_COMPILATION) ) add_custom_command( OUTPUT "${msl}" - COMMAND "${SPIRV_CROSS_EXE}" --msl "${spv}" --output "${msl}" + COMMAND "${SPIRV_CROSS_EXE}" --msl ${msl_flags} "${spv}" --output "${msl}" DEPENDS "${spv}" "${MU_SHADER_COMPILATION_STAMP}" "${SPIRV_CROSS_EXE}" COMMENT "SPIR-V to MSL: ${shader_name}.${stage}.spv" VERBATIM diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index 0efe5470e1..dbe131eb94 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -223,6 +223,24 @@ function(mu_expect_msl_binding_order shader_name json member resource_kind msl) endforeach() endfunction() +# Likewise for uniform buffers: SDL pushes uniform slot N into MSL buffer N, so each block must sit +# at its binding (uniform buffers come first, before any storage buffer). +function(mu_expect_msl_uniform_order shader_name json msl) + mu_json_array_length(uniform_count "${json}" ubos) + if(uniform_count LESS 2) + return() + endif() + math(EXPR last_uniform "${uniform_count} - 1") + foreach(uniform_index RANGE 0 ${last_uniform}) + string(JSON uniform_name GET "${json}" ubos ${uniform_index} name) + string(JSON uniform_binding GET "${json}" ubos ${uniform_index} binding) + if(NOT msl MATCHES "constant[ \t]+${uniform_name}&[ \t]+[A-Za-z0-9_]+[ \t]+\\[\\[buffer\\(${uniform_binding}\\)\\]\\]") + mu_add_shader_validation_error( + "${shader_name}: MSL uniform buffer ${uniform_name} is not at index ${uniform_binding}") + endif() + endforeach() +endfunction() + function(mu_expect_msl_layout shader_name stage msl input_locations sampler_count storage_count uniform_count) # A vertex shader without vertex inputs (generated geometry) has no [[stage_in]]. if(stage STREQUAL "vert" AND NOT input_locations STREQUAL "" AND NOT msl MATCHES "\\[\\[stage_in\\]\\]") @@ -300,6 +318,17 @@ foreach(shader_spec IN LISTS shader_specs) set(json_path "${MU_SHADER_REFLECTION_OUTPUT_DIR}/${shader_name}.json") set(msl_path "${MU_SHADER_REFLECTION_OUTPUT_DIR}/${shader_name}.msl") file(READ "${source_path}" hlsl) + # As mu_add_shader: declared bindings, except beside storage buffers (also those of an included .hlsli). + string(REGEX MATCHALL "#include \"[^\"]+\"" shader_includes "${hlsl}") + foreach(shader_include IN LISTS shader_includes) + string(REGEX REPLACE "#include \"([^\"]+)\"" "\\1" shader_include "${shader_include}") + file(READ "${MU_SHADER_SOURCE_DIR}/${shader_include}" include_source) + string(APPEND hlsl "${include_source}") + endforeach() + set(msl_flags) + if(NOT hlsl MATCHES "StructuredBuffer|ByteAddressBuffer") + set(msl_flags --msl-decoration-binding) + endif() execute_process( COMMAND "${GLSLANG_EXE}" -V -D -S "${stage}" -e main -o "${spv_path}" "${source_path}" @@ -327,7 +356,7 @@ foreach(shader_spec IN LISTS shader_specs) file(WRITE "${json_path}" "${reflection_json}") execute_process( - COMMAND "${SPIRV_CROSS_EXE}" "${spv_path}" --msl --output "${msl_path}" + COMMAND "${SPIRV_CROSS_EXE}" "${spv_path}" --msl ${msl_flags} --output "${msl_path}" RESULT_VARIABLE msl_result ERROR_VARIABLE msl_error ) @@ -361,6 +390,7 @@ foreach(shader_spec IN LISTS shader_specs) mu_expect_msl_layout("${shader_name}" "${stage}" "${msl}" "${input_locations}" "${sampler_count}" "${storage_count}" "${uniform_count}") mu_expect_msl_binding_order("${shader_name}" "${reflection_json}" separate_images texture "${msl}") mu_expect_msl_binding_order("${shader_name}" "${reflection_json}" separate_samplers sampler "${msl}") + mu_expect_msl_uniform_order("${shader_name}" "${reflection_json}" "${msl}") endforeach() get_property(validation_errors GLOBAL PROPERTY MU_SHADER_VALIDATION_ERRORS) diff --git a/src/shaders/compiled/basic_textured_fog.frag.dxil b/src/shaders/compiled/basic_textured_fog.frag.dxil index 66ca7e6f9bd099843929acbaae3f522a3c332c64..32a30bccd7fbe256384d4b78ee71d24b698cf4ad 100644 GIT binary patch delta 130 zcmZ3ZzeZogCBn(MJmBNs359muQqLkEM>Gdd-zd`0ChOAAlmF(eFOSMG)#I+m*xZh( zK4W8XRcrHMJO0LP^M1Afmc;_xOahT=sS10`PF=H}d17s!&93L06?nHZ6VUuwU=QQw I4MKld0L|bwF#rGn delta 129 zcmZ3ZzeZogCBn)1*z&`vqFdWvvKsY9={VaYZxrcglR47IlmF(eFOSMG)#I+m*wl_M zWn*Dgb35av*3+~309yddW`1r)CV|i;ZWt<_%(kK*u%Ja Iz0hA40Ji=zk^lez diff --git a/src/shaders/compiled/basic_textured_fog.frag.msl b/src/shaders/compiled/basic_textured_fog.frag.msl index 0861043e80..6e77c1b38c 100644 --- a/src/shaders/compiled/basic_textured_fog.frag.msl +++ b/src/shaders/compiled/basic_textured_fog.frag.msl @@ -1,8 +1,19 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" + #include #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float eyeDepth; +}; + struct SceneLighting { float4 sceneLightDirection; @@ -35,50 +46,61 @@ struct main0_in { float2 input_uv [[user(locn0)]]; float4 input_color [[user(locn1)]]; + float input_fogFactor [[user(locn2)]]; float input_eyeDepth [[user(locn3)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _24 [[buffer(0)]], constant FogUniforms& _72 [[buffer(1)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]]) +static inline __attribute__((always_inline)) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _24) { - main0_out out = {}; - float4 _190 = tex.sample(s, in.input_uv); - float4 _193 = _190 * in.input_color; - float4 _310; + float scaledDistance = fast::max(eyeDepth - _24.sceneFogParameters.x, 0.0) * _24.sceneFogParameters.z; + return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, constant SceneLighting& _24, texture2d tex, sampler s, constant FogUniforms& _72) +{ + float4 color = tex.sample(s, _input.uv) * _input.color; if (_72.alphaToCoverage != 0u) { - float _213 = _193.w * fast::clamp(((_193.w - _72.alphaThreshold) / fast::max(fwidth(_193.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); - float4 _301 = _193; - _301.w = _213; - if (_213 <= 0.0) + float edge = fast::clamp(((color.w - _72.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + color.w *= edge; + if (color.w <= 0.0) { discard_fragment(); } - _310 = _301; } else { - if ((_72.alphaDiscardEnabled != 0u) && (_193.w <= _72.alphaThreshold)) + if ((_72.alphaDiscardEnabled != 0u) && (color.w <= _72.alphaThreshold)) { discard_fragment(); } - _310 = _193; } - float4 _311; if ((_72.fogEnabled != 0u) && (_24.sceneFogColor.w > 0.0)) { - float _270 = fast::max(in.input_eyeDepth - _24.sceneFogParameters.x, 0.0) * _24.sceneFogParameters.z; - float3 _250 = mix(_310.xyz, _24.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_270) * _270), 0.0, 1.0))); - float4 _305 = _310; - _305.x = _250.x; - _305.y = _250.y; - _305.z = _250.z; - _311 = _305; + float4 _133 = color; + float param = _input.eyeDepth; + float3 _145 = mix(_133.xyz, _24.sceneFogColor.xyz, float3(EnhancedFogAmount(param, _24))); + color.x = _145.x; + color.y = _145.y; + color.z = _145.z; } - else - { - _311 = _310; - } - out._entryPointOutput = _311; + return color; +} + +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _72 [[buffer(0)]], constant SceneLighting& _24 [[buffer(1)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]], float4 gl_FragCoord [[position]]) +{ + main0_out out = {}; + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + _input.color = in.input_color; + _input.fogFactor = in.input_fogFactor; + _input.eyeDepth = in.input_eyeDepth; + FSInput param = _input; + float4 _179 = _main(param, _24, tex, s, _72); + out._entryPointOutput = _179; return out; } diff --git a/src/shaders/compiled/basic_textured_fog.frag.spv b/src/shaders/compiled/basic_textured_fog.frag.spv index b0e8321d4444d618d2f415d04e9d9748a0f2d8c7..dc1af83a8a20f5d92c44a1edef88b4e0f39cebde 100644 GIT binary patch literal 5068 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 diff --git a/src/shaders/compiled/post_ao.frag.dxil b/src/shaders/compiled/post_ao.frag.dxil index 9e92b8484bbeaff8f0c5e33fe1312879c830e444..c129c352f819f4faca5400a2e09eb22ef3a40ff0 100644 GIT binary patch delta 1602 zcmZvcc~BEq9LL`-%My|W!Xf5Bv*DH^O}I;Gnt%kWK~Oy6L5D-Il|uw%qy`fbj4)ye z1S)E!Xr+qa6eeDv%mlTf`y6{X9}aV8;t#{@1OmAe&2oHncaEwZe%rP z(btH>!u_AKr}ge0-v!Ai33U;Z@elxj(?p*#cW~23=un}~Z5%}++?66!KP4R3(9sd( zvzv0k@o2e_{;qw)t&zMt@-^bGM7R$C@xeOcHNU zKoG|yT2-VOjGIKpmPT73T9bk8IB+J|cV(3W-BzS3v2>5rA>n%?fx)xDR#xt*boNxh z%RFsD)}6!12}lizT&SaikUhZj41^!>?!c=pK=o016Almob&*d++H4R(j1eXYpuQ(y zngEp%Itj>J_y zGMbq$9=4@0Ksq<)8sRSpZnWx(M@MLdZFFo8rv##>QSSn)Dxz=Wk+K-~?aS z(>_Lvs=eCQR9S$vVwW3aF_z}$>7QYKix(pm>%S(z5OjR{(_&_;z>{k9ynt^Gmi_>Y=DgM^%y4b6v>kbLi!=^)`u z@65uXBqSvD{%DY}=T!CvA|YgQN$#7HPfKj)^1Gf5&>)f=U!=HzBm^gjR$?o|NzX=> z#tZkrlD4w|a6v7BJiezEcA6M`2D4a<4)4=MEfvO5pUN2RcW|ogx1kL(bwPW*Te6 zs|`@Oh31&UadXSLpNmSTBW+pF)ojM{)wuf(_~b5gzjMp5n~Kp5k6dd2&2i$WM2KMk zX_GbCJ6W2r*?xsOnc-~Cwd>FqsY@7MYamQ1s**J13q`zZJXiI5cLQ8i ztP7XMSZ@)GJ-N;2ZB3ET4EnnbntC4vyh7}&DxKW99-ZY%vOD=aUA8CPpg-v2W;RcI zP^VeX-30qk9`Jd&hn^AhjD4YI^Wy0jDLCu&7em-sQq%R*1(JrvZa-D&dcwrL?; z)8*$2!{W#4e*)IyhZzR_Fz4^z_`Khh&_yB_V_yfTO7A3s`T~i!qe8Pca2pJ@soR5{ zH-i>|=_HV+(Jbc0jGC6VA=GpjJg+bf=`}3{uTUuy`EVX;dNT0q#NZOMD1#c$$BY;5 OPV_I*%*Sh!c>W97JUs6J delta 1424 zcmZvcdrVVj7{@iqpUa8Y6uDuPpqRoc>3 zaAmC?mFs4K4VB;p59&mtrLeXV5L9p|AmRuEhYq@!4YRnF%b)xH`hL&*Jx}r`Prhpf zKNYa!Q)A;~(%FhW_G#?jb49~gb1ahv0Elj3Pdj=zS`r!&i8(L`ffI6qf)j%pB@&8_ zjKVSdl^nm!Yr=uFd+g*t0^J|Rr>>WVL;#Rs_nveCV4i_J2(vS0*JI<1FZ@sdloZe9 z5`-$+iG>+4?gvOStcv%yzvHj0WU*bPdaZL%q8X0cn+U8SN>_y{M8gd!fg%0y<4=I{UC*4XDOzX;EV02WJ&8Ped=PDpf)PcmVcewlV1kcuXE<)PNyT zyyENztlv0<<+`i6_#@AA6XxAruU%f}MU+Rp>B&>&Z*^C9JjXD1^{>^q_aKs4EeP*) zLNakAo6yq4$Zk=wx{1DTa%%m_J*xa&oO5HSQGs>>CbEWQHJ}1|jvkRVHs8Bw8h_X| z8ALxJ5EB=frhbIunZ-0Jn4Jn#!^5pcrU2f5EpwAYG!S@vx5CNGXwtq}t^Kw)y(Zmj zn6tBr<6~u|ReCpEY86D^Ay>dr35!s-kLX0g~uiapPGM)WCthTAonAI-e{NPrgU zoeppMy1eH~Phfd-ceyMH+v?X**s_YONj_Rw@PFW)0e#a3%Nc<&CoDTv?KSVBVX&>P|AZrrxDtRgGKjS9X8b@Z`A7zJiI6E1m5DXLiP%Nq^?Cf|dIapA-2-=idb zminRN+3?5AtM{WM25Q3F4wqwo8()ChMYy{-`Cwv+M{k8+DR))i^jG%@h>!pkPFJBV&<+&V3EQtg%K*{!o$Si~tE zFO%!L#S|~pl$Oc6S>%`(kM-feCJqYe^Vly4Y?c$oEtoU_q2REC4<_mohTu1LLZ;CvBcYkB`E z)e*^uAo?%lUu%=`V_sIv3u5MpNcdFKe%?M$MR%;#>weCfX;R9=Jsqel!50usNw!6E zx6a%WFI9o@1}WfNlo{HTBgj%4LRvZ2JiG83InIF>3t{M!;kWEU6Gtt>GDIk3FIzhD MC*3yxTP>ac0R7}6p8x;= diff --git a/src/shaders/compiled/post_ao.frag.msl b/src/shaders/compiled/post_ao.frag.msl index e0c6b4d297..7855f674c5 100644 --- a/src/shaders/compiled/post_ao.frag.msl +++ b/src/shaders/compiled/post_ao.frag.msl @@ -44,6 +44,12 @@ struct spvUnsafeArray } }; +struct FSInput +{ + float4 pos; + float2 uv; +}; + struct AmbientOcclusion { float4x4 projection; @@ -66,179 +72,90 @@ struct main0_in float2 input_uv [[user(locn0)]]; }; +static inline __attribute__((always_inline)) +float SceneDepth(thread const float2& uv, texture2d depthTexture, sampler depthSampler) +{ + return depthTexture.sample(depthSampler, uv, level(0.0)).x; +} + +static inline __attribute__((always_inline)) +float3 ViewPosition(thread const float2& uv, thread const float& depth, constant AmbientOcclusion& _73) +{ + float4 view = _73.inverseProjection * float4((uv.x * 2.0) - 1.0, 1.0 - (uv.y * 2.0), depth, 1.0); + return view.xyz / float3(view.w); +} + +static inline __attribute__((always_inline)) +float3 ViewPositionAt(thread const float2& uv, texture2d depthTexture, sampler depthSampler, constant AmbientOcclusion& _73) +{ + float2 centre = (floor((uv / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; + float2 param = centre; + float2 param_1 = centre; + float param_2 = SceneDepth(param, depthTexture, depthSampler); + return ViewPosition(param_1, param_2, _73); +} + +static inline __attribute__((always_inline)) +float3 SurfaceNormal(thread const float2& uv, thread const float3& position, texture2d depthTexture, sampler depthSampler, constant AmbientOcclusion& _73) +{ + float2 param = uv + float2(_73.depthTexelSize.x, 0.0); + float3 right = ViewPositionAt(param, depthTexture, depthSampler, _73) - position; + float2 param_1 = uv - float2(_73.depthTexelSize.x, 0.0); + float3 left = position - ViewPositionAt(param_1, depthTexture, depthSampler, _73); + float2 param_2 = uv + float2(0.0, _73.depthTexelSize.y); + float3 down = ViewPositionAt(param_2, depthTexture, depthSampler, _73) - position; + float2 param_3 = uv - float2(0.0, _73.depthTexelSize.y); + float3 up = position - ViewPositionAt(param_3, depthTexture, depthSampler, _73); + float3 alongX = select(left, right, bool3(abs(right.z) < abs(left.z))); + float3 alongY = select(up, down, bool3(abs(down.z) < abs(up.z))); + float3 normal = fast::normalize(cross(alongX, alongY)); + return select(normal, -normal, bool3(dot(normal, position) > 0.0)); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, texture2d depthTexture, sampler depthSampler, constant AmbientOcclusion& _73) +{ + float2 param = _input.uv; + if (SceneDepth(param, depthTexture, depthSampler) >= 1.0) + { + return float4(1.0); + } + float2 param_1 = _input.uv; + float3 position = ViewPositionAt(param_1, depthTexture, depthSampler, _73); + float2 param_2 = _input.uv; + float3 param_3 = position; + float3 normal = SurfaceNormal(param_2, param_3, depthTexture, depthSampler, _73); + uint2 cell = uint2(_input.pos.xy) & uint2(3u); + float angle = 6.283185482025146484375 * _247[(cell.y * 4u) + cell.x]; + float3 turn = float3(cos(angle), sin(angle), 0.0); + float3 tangent = fast::normalize((turn - (normal * dot(turn, normal))) + float3(9.9999997473787516355514526367188e-05, 0.0, 0.0)); + float3 bitangent = cross(normal, tangent); + float occlusion = 0.0; + for (uint i = 0u; i < 12u; i++) + { + float3 offset = ((tangent * _337[i].x) + (bitangent * _337[i].y)) + (normal * _337[i].z); + float3 samplePosition = position + (offset * _73.radius); + float4 clip = _73.projection * float4(samplePosition, 1.0); + float2 sampleUv = float2(((clip.x / clip.w) * 0.5) + 0.5, 0.5 - ((clip.y / clip.w) * 0.5)); + float2 param_4 = sampleUv; + float3 toOccluder = ViewPositionAt(param_4, depthTexture, depthSampler, _73) - position; + float distanceSquared = dot(toOccluder, toOccluder); + float rise = dot(toOccluder, normal) * rsqrt(fast::max(distanceSquared, 9.9999999747524270787835121154785e-07)); + float inRange = fast::clamp(1.0 - (distanceSquared / (_73.radius * _73.radius)), 0.0, 1.0); + occlusion += (fast::clamp(rise - 0.1500000059604644775390625, 0.0, 1.0) * inRange); + } + float visibility = 1.0 - (occlusion / 12.0); + return float4(visibility); +} + fragment main0_out main0(main0_in in [[stage_in]], constant AmbientOcclusion& _73 [[buffer(0)]], texture2d depthTexture [[texture(0)]], sampler depthSampler [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - float4 _1039; - do - { - if (depthTexture.sample(depthSampler, in.input_uv, level(0.0)).x >= 1.0) - { - _1039 = float4(1.0); - break; - } - float2 _653 = (floor((in.input_uv / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _638 = _653; - float4 _681 = _73.inverseProjection * float4((_638.x * 2.0) - 1.0, 1.0 - (_638.y * 2.0), depthTexture.sample(depthSampler, _653, level(0.0)).x, 1.0); - float4 _666 = _681; - float3 _687 = _681.xyz / float3(_666.w); - float2 _785 = (floor(((in.input_uv + float2(_73.depthTexelSize.x, 0.0)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _770 = _785; - float4 _813 = _73.inverseProjection * float4((_770.x * 2.0) - 1.0, 1.0 - (_770.y * 2.0), depthTexture.sample(depthSampler, _785, level(0.0)).x, 1.0); - float4 _798 = _813; - float3 _708 = (_813.xyz / float3(_798.w)) - _687; - float3 _688 = _708; - float2 _837 = (floor(((in.input_uv - float2(_73.depthTexelSize.x, 0.0)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _822 = _837; - float4 _865 = _73.inverseProjection * float4((_822.x * 2.0) - 1.0, 1.0 - (_822.y * 2.0), depthTexture.sample(depthSampler, _837, level(0.0)).x, 1.0); - float4 _850 = _865; - float3 _716 = _687 - (_865.xyz / float3(_850.w)); - float3 _690 = _716; - float2 _889 = (floor(((in.input_uv + float2(0.0, _73.depthTexelSize.y)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _874 = _889; - float4 _917 = _73.inverseProjection * float4((_874.x * 2.0) - 1.0, 1.0 - (_874.y * 2.0), depthTexture.sample(depthSampler, _889, level(0.0)).x, 1.0); - float4 _902 = _917; - float3 _724 = (_917.xyz / float3(_902.w)) - _687; - float3 _692 = _724; - float2 _941 = (floor(((in.input_uv - float2(0.0, _73.depthTexelSize.y)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _926 = _941; - float4 _969 = _73.inverseProjection * float4((_926.x * 2.0) - 1.0, 1.0 - (_926.y * 2.0), depthTexture.sample(depthSampler, _941, level(0.0)).x, 1.0); - float4 _954 = _969; - float3 _732 = _687 - (_969.xyz / float3(_954.w)); - float3 _694 = _732; - float3 _758 = fast::normalize(cross(select(_716, _708, bool3(abs(_688.z) < abs(_690.z))), select(_732, _724, bool3(abs(_692.z) < abs(_694.z))))); - float3 _767 = select(_758, -_758, bool3(dot(_758, _687) > 0.0)); - uint2 _468 = uint2(gl_FragCoord.xy) & uint2(3u); - float _518 = 6.283185482025146484375 * _247[(_468.y * 4u) + _468.x]; - float3 _523 = float3(cos(_518), sin(_518), 0.0); - float3 _532 = fast::normalize((_523 - (_767 * dot(_523, _767))) + float3(9.9999997473787516355514526367188e-05, 0.0, 0.0)); - float3 _535 = cross(_767, _532); - spvUnsafeArray _477 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); - spvUnsafeArray _478 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); - spvUnsafeArray _479 = spvUnsafeArray({ float3(0.20999999344348907470703125, 0.0500000007450580596923828125, 0.100000001490116119384765625), float3(-0.100000001490116119384765625, 0.25, 0.1500000059604644775390625), float3(-0.2800000011920928955078125, -0.119999997317790985107421875, 0.07999999821186065673828125), float3(0.14000000059604644775390625, -0.300000011920928955078125, 0.20000000298023223876953125), float3(0.4199999868869781494140625, 0.2199999988079071044921875, 0.25), float3(-0.3499999940395355224609375, 0.4000000059604644775390625, 0.119999997317790985107421875), float3(-0.300000011920928955078125, -0.449999988079071044921875, 0.3499999940395355224609375), float3(0.37999999523162841796875, -0.36000001430511474609375, 0.4199999868869781494140625), float3(0.699999988079071044921875, 0.100000001490116119384765625, 0.300000011920928955078125), float3(-0.1500000059604644775390625, 0.7200000286102294921875, 0.449999988079071044921875), float3(-0.660000026226043701171875, -0.20000000298023223876953125, 0.550000011920928955078125), float3(0.20000000298023223876953125, -0.62000000476837158203125, 0.699999988079071044921875) }); - float4 _481 = _73.projection * float4(_687 + ((((_532 * _477[0u].x) + (_535 * _478[0u].y)) + (_767 * _479[0u].z)) * _73.radius), 1.0); - float2 _993 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - float2 _978 = _993; - float4 _1021 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _993, level(0.0)).x, 1.0); - float4 _1006 = _1021; - float3 _590 = (_1021.xyz / float3(_1006.w)) - _687; - float _593 = dot(_590, _590); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[1u].x) + (_535 * _478[1u].y)) + (_767 * _479[1u].z)) * _73.radius), 1.0); - float2 _1096 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1096; - float4 _1113 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1096, level(0.0)).x, 1.0); - _1006 = _1113; - float3 _1119 = (_1113.xyz / float3(_1006.w)) - _687; - float _1120 = dot(_1119, _1119); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[2u].x) + (_535 * _478[2u].y)) + (_767 * _479[2u].z)) * _73.radius), 1.0); - float2 _1192 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1192; - float4 _1209 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1192, level(0.0)).x, 1.0); - _1006 = _1209; - float3 _1215 = (_1209.xyz / float3(_1006.w)) - _687; - float _1216 = dot(_1215, _1215); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[3u].x) + (_535 * _478[3u].y)) + (_767 * _479[3u].z)) * _73.radius), 1.0); - float2 _1288 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1288; - float4 _1305 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1288, level(0.0)).x, 1.0); - _1006 = _1305; - float3 _1311 = (_1305.xyz / float3(_1006.w)) - _687; - float _1312 = dot(_1311, _1311); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[4u].x) + (_535 * _478[4u].y)) + (_767 * _479[4u].z)) * _73.radius), 1.0); - float2 _1384 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1384; - float4 _1401 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1384, level(0.0)).x, 1.0); - _1006 = _1401; - float3 _1407 = (_1401.xyz / float3(_1006.w)) - _687; - float _1408 = dot(_1407, _1407); - float _1424 = ((((fast::clamp((dot(_590, _767) * rsqrt(fast::max(_593, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_593 / (_73.radius * _73.radius)), 0.0, 1.0)) + (fast::clamp((dot(_1119, _767) * rsqrt(fast::max(_1120, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1120 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1215, _767) * rsqrt(fast::max(_1216, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1216 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1311, _767) * rsqrt(fast::max(_1312, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1312 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1407, _767) * rsqrt(fast::max(_1408, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1408 / (_73.radius * _73.radius)), 0.0, 1.0)); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[5u].x) + (_535 * _478[5u].y)) + (_767 * _479[5u].z)) * _73.radius), 1.0); - float2 _1480 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1480; - float4 _1497 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1480, level(0.0)).x, 1.0); - _1006 = _1497; - float3 _1503 = (_1497.xyz / float3(_1006.w)) - _687; - float _1504 = dot(_1503, _1503); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[6u].x) + (_535 * _478[6u].y)) + (_767 * _479[6u].z)) * _73.radius), 1.0); - float2 _1576 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1576; - float4 _1593 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1576, level(0.0)).x, 1.0); - _1006 = _1593; - float3 _1599 = (_1593.xyz / float3(_1006.w)) - _687; - float _1600 = dot(_1599, _1599); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[7u].x) + (_535 * _478[7u].y)) + (_767 * _479[7u].z)) * _73.radius), 1.0); - float2 _1672 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1672; - float4 _1689 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1672, level(0.0)).x, 1.0); - _1006 = _1689; - float3 _1695 = (_1689.xyz / float3(_1006.w)) - _687; - float _1696 = dot(_1695, _1695); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[8u].x) + (_535 * _478[8u].y)) + (_767 * _479[8u].z)) * _73.radius), 1.0); - float2 _1768 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1768; - float4 _1785 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1768, level(0.0)).x, 1.0); - _1006 = _1785; - float3 _1791 = (_1785.xyz / float3(_1006.w)) - _687; - float _1792 = dot(_1791, _1791); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[9u].x) + (_535 * _478[9u].y)) + (_767 * _479[9u].z)) * _73.radius), 1.0); - float2 _1864 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1864; - float4 _1881 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1864, level(0.0)).x, 1.0); - _1006 = _1881; - float3 _1887 = (_1881.xyz / float3(_1006.w)) - _687; - float _1888 = dot(_1887, _1887); - float _1904 = ((((_1424 + (fast::clamp((dot(_1503, _767) * rsqrt(fast::max(_1504, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1504 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1599, _767) * rsqrt(fast::max(_1600, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1600 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1695, _767) * rsqrt(fast::max(_1696, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1696 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1791, _767) * rsqrt(fast::max(_1792, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1792 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_1887, _767) * rsqrt(fast::max(_1888, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1888 / (_73.radius * _73.radius)), 0.0, 1.0)); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[10u].x) + (_535 * _478[10u].y)) + (_767 * _479[10u].z)) * _73.radius), 1.0); - float2 _1960 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _1960; - float4 _1977 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _1960, level(0.0)).x, 1.0); - _1006 = _1977; - float3 _1983 = (_1977.xyz / float3(_1006.w)) - _687; - float _1984 = dot(_1983, _1983); - _477 = _337; - _478 = _337; - _479 = _337; - _481 = _73.projection * float4(_687 + ((((_532 * _477[11u].x) + (_535 * _478[11u].y)) + (_767 * _479[11u].z)) * _73.radius), 1.0); - float2 _2056 = (floor((float2(((_481.x / _481.w) * 0.5) + 0.5, 0.5 - ((_481.y / _481.w) * 0.5)) / _73.depthTexelSize) + float2(0.25)) + float2(0.5)) * _73.depthTexelSize; - _978 = _2056; - float4 _2073 = _73.inverseProjection * float4((_978.x * 2.0) - 1.0, 1.0 - (_978.y * 2.0), depthTexture.sample(depthSampler, _2056, level(0.0)).x, 1.0); - _1006 = _2073; - float3 _2079 = (_2073.xyz / float3(_1006.w)) - _687; - float _2080 = dot(_2079, _2079); - _1039 = float4(1.0 - (((_1904 + (fast::clamp((dot(_1983, _767) * rsqrt(fast::max(_1984, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_1984 / (_73.radius * _73.radius)), 0.0, 1.0))) + (fast::clamp((dot(_2079, _767) * rsqrt(fast::max(_2080, 9.9999999747524270787835121154785e-07))) - 0.1500000059604644775390625, 0.0, 1.0) * fast::clamp(1.0 - (_2080 / (_73.radius * _73.radius)), 0.0, 1.0))) * 0.083333335816860198974609375)); - break; - } while(false); - out._entryPointOutput = _1039; + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + FSInput param = _input; + out._entryPointOutput = _main(param, depthTexture, depthSampler, _73); return out; } diff --git a/src/shaders/compiled/post_ao.frag.spv b/src/shaders/compiled/post_ao.frag.spv index 924f32fd6daf90f13d6db3c160edb6555916c877..532c3f16507421aff2448596b43a6e78ab2934af 100644 GIT binary patch literal 10504 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 A7ytkO delta 4925 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 gC0t&@qHgWOyti`|o08($(8vp #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; +}; + struct AmbientOcclusion { float4x4 projection; @@ -22,138 +30,73 @@ struct main0_in float2 input_uv [[user(locn0)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant AmbientOcclusion& _31 [[buffer(0)]], texture2d depthTexture [[texture(0)]], texture2d occlusionTexture [[texture(1)]], sampler depthSampler [[sampler(0)]], sampler occlusionSampler [[sampler(1)]]) +static inline __attribute__((always_inline)) +float3 ViewPosition(thread float2& uv, constant AmbientOcclusion& _31, texture2d depthTexture, sampler depthSampler) +{ + uv = (floor((uv / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; + float depth = depthTexture.sample(depthSampler, uv, level(0.0)).x; + float4 view = _31.inverseProjection * float4((uv.x * 2.0) - 1.0, 1.0 - (uv.y * 2.0), depth, 1.0); + return view.xyz / float3(view.w); +} + +static inline __attribute__((always_inline)) +float3 SurfaceNormal(thread const float2& uv, thread const float3& position, constant AmbientOcclusion& _31, texture2d depthTexture, sampler depthSampler) +{ + float2 param = uv + float2(_31.depthTexelSize.x, 0.0); + float3 _103 = ViewPosition(param, _31, depthTexture, depthSampler); + float3 right = _103 - position; + float2 param_1 = uv - float2(_31.depthTexelSize.x, 0.0); + float3 _114 = ViewPosition(param_1, _31, depthTexture, depthSampler); + float3 left = position - _114; + float2 param_2 = uv + float2(0.0, _31.depthTexelSize.y); + float3 _123 = ViewPosition(param_2, _31, depthTexture, depthSampler); + float3 down = _123 - position; + float2 param_3 = uv - float2(0.0, _31.depthTexelSize.y); + float3 _134 = ViewPosition(param_3, _31, depthTexture, depthSampler); + float3 up = position - _134; + float3 alongX = select(left, right, bool3(abs(right.z) < abs(left.z))); + float3 alongY = select(up, down, bool3(abs(down.z) < abs(up.z))); + return fast::normalize(cross(alongX, alongY)); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, constant AmbientOcclusion& _31, texture2d depthTexture, sampler depthSampler, texture2d occlusionTexture, sampler occlusionSampler) +{ + float2 param = _input.uv; + float3 _173 = ViewPosition(param, _31, depthTexture, depthSampler); + float3 centre = _173; + float2 param_1 = _input.uv; + float3 param_2 = centre; + float3 normal = SurfaceNormal(param_1, param_2, _31, depthTexture, depthSampler); + float2 occlusionTexelSize = _31.depthTexelSize * 2.0; + float planeTolerance = _31.radius * 0.25; + float sum = 0.0; + float weightSum = 0.0; + for (int y = -2; y < 2; y++) + { + for (int x = -2; x < 2; x++) + { + float2 uv = _input.uv + (float2(float(x), float(y)) * occlusionTexelSize); + float2 param_3 = uv; + float3 _224 = ViewPosition(param_3, _31, depthTexture, depthSampler); + float offPlane = abs(dot(_224 - centre, normal)); + float weight = fast::clamp(1.0 - (offPlane / planeTolerance), 0.0, 1.0) + 0.001000000047497451305389404296875; + sum += (occlusionTexture.sample(occlusionSampler, uv, level(0.0)).x * weight); + weightSum += weight; + } + } + float visibility = sum / weightSum; + return float4(visibility); +} + +fragment main0_out main0(main0_in in [[stage_in]], constant AmbientOcclusion& _31 [[buffer(0)]], texture2d depthTexture [[texture(0)]], texture2d occlusionTexture [[texture(1)]], sampler depthSampler [[sampler(0)]], sampler occlusionSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - float2 _385 = (floor((in.input_uv / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _281 = _385; - float4 _404 = _31.inverseProjection * float4((_281.x * 2.0) - 1.0, 1.0 - (_281.y * 2.0), depthTexture.sample(depthSampler, _385, level(0.0)).x, 1.0); - float4 _371 = _404; - float3 _410 = _404.xyz / float3(_371.w); - float2 _496 = (floor(((in.input_uv + float2(_31.depthTexelSize.x, 0.0)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _412 = _496; - float4 _515 = _31.inverseProjection * float4((_412.x * 2.0) - 1.0, 1.0 - (_412.y * 2.0), depthTexture.sample(depthSampler, _496, level(0.0)).x, 1.0); - float4 _482 = _515; - float3 _430 = (_515.xyz / float3(_482.w)) - _410; - float3 _411 = _430; - float2 _537 = (floor(((in.input_uv - float2(_31.depthTexelSize.x, 0.0)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _414 = _537; - float4 _556 = _31.inverseProjection * float4((_414.x * 2.0) - 1.0, 1.0 - (_414.y * 2.0), depthTexture.sample(depthSampler, _537, level(0.0)).x, 1.0); - float4 _523 = _556; - float3 _438 = _410 - (_556.xyz / float3(_523.w)); - float3 _413 = _438; - float2 _578 = (floor(((in.input_uv + float2(0.0, _31.depthTexelSize.y)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _416 = _578; - float4 _597 = _31.inverseProjection * float4((_416.x * 2.0) - 1.0, 1.0 - (_416.y * 2.0), depthTexture.sample(depthSampler, _578, level(0.0)).x, 1.0); - float4 _564 = _597; - float3 _446 = (_597.xyz / float3(_564.w)) - _410; - float3 _415 = _446; - float2 _619 = (floor(((in.input_uv - float2(0.0, _31.depthTexelSize.y)) / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _418 = _619; - float4 _638 = _31.inverseProjection * float4((_418.x * 2.0) - 1.0, 1.0 - (_418.y * 2.0), depthTexture.sample(depthSampler, _619, level(0.0)).x, 1.0); - float4 _605 = _638; - float3 _454 = _410 - (_638.xyz / float3(_605.w)); - float3 _417 = _454; - float3 _480 = fast::normalize(cross(select(_438, _430, bool3(abs(_411.z) < abs(_413.z))), select(_454, _446, bool3(abs(_415.z) < abs(_417.z))))); - float2 _307 = _31.depthTexelSize * 2.0; - float _310 = _31.radius * 0.25; - float2 _330 = in.input_uv + (float2(-2.0) * _307); - float2 _660 = (floor((_330 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - float2 _293 = _660; - float4 _679 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _660, level(0.0)).x, 1.0); - float4 _646 = _679; - float _342 = fast::clamp(1.0 - (abs(dot((_679.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _718 = in.input_uv + (float2(-1.0, -2.0) * _307); - float2 _729 = (floor((_718 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _729; - float4 _746 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _729, level(0.0)).x, 1.0); - _646 = _746; - float _757 = fast::clamp(1.0 - (abs(dot((_746.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _780 = in.input_uv + (float2(0.0, -2.0) * _307); - float2 _791 = (floor((_780 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _791; - float4 _808 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _791, level(0.0)).x, 1.0); - _646 = _808; - float _819 = fast::clamp(1.0 - (abs(dot((_808.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _842 = in.input_uv + (float2(1.0, -2.0) * _307); - float2 _853 = (floor((_842 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _853; - float4 _870 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _853, level(0.0)).x, 1.0); - _646 = _870; - float _881 = fast::clamp(1.0 - (abs(dot((_870.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _908 = in.input_uv + (float2(-2.0, -1.0) * _307); - float2 _919 = (floor((_908 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _919; - float4 _936 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _919, level(0.0)).x, 1.0); - _646 = _936; - float _947 = fast::clamp(1.0 - (abs(dot((_936.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _967 = in.input_uv + (float2(-1.0) * _307); - float2 _978 = (floor((_967 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _978; - float4 _995 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _978, level(0.0)).x, 1.0); - _646 = _995; - float _1006 = fast::clamp(1.0 - (abs(dot((_995.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1026 = in.input_uv + (float2(0.0, -1.0) * _307); - float2 _1037 = (floor((_1026 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1037; - float4 _1054 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1037, level(0.0)).x, 1.0); - _646 = _1054; - float _1065 = fast::clamp(1.0 - (abs(dot((_1054.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1085 = in.input_uv + (float2(1.0, -1.0) * _307); - float2 _1096 = (floor((_1085 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1096; - float4 _1113 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1096, level(0.0)).x, 1.0); - _646 = _1113; - float _1124 = fast::clamp(1.0 - (abs(dot((_1113.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1154 = in.input_uv + (float2(-2.0, 0.0) * _307); - float2 _1165 = (floor((_1154 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1165; - float4 _1182 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1165, level(0.0)).x, 1.0); - _646 = _1182; - float _1193 = fast::clamp(1.0 - (abs(dot((_1182.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1213 = in.input_uv + (float2(-1.0, 0.0) * _307); - float2 _1224 = (floor((_1213 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1224; - float4 _1241 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1224, level(0.0)).x, 1.0); - _646 = _1241; - float _1252 = fast::clamp(1.0 - (abs(dot((_1241.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1283 = (floor((in.input_uv / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1283; - float4 _1300 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1283, level(0.0)).x, 1.0); - _646 = _1300; - float _1311 = fast::clamp(1.0 - (abs(dot((_1300.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float _1319 = ((((((((((occlusionTexture.sample(occlusionSampler, _330, level(0.0)).x * (_342 + 0.001000000047497451305389404296875)) + (occlusionTexture.sample(occlusionSampler, _718, level(0.0)).x * (_757 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _780, level(0.0)).x * (_819 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _842, level(0.0)).x * (_881 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _908, level(0.0)).x * (_947 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _967, level(0.0)).x * (_1006 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1026, level(0.0)).x * (_1065 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1085, level(0.0)).x * (_1124 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1154, level(0.0)).x * (_1193 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1213, level(0.0)).x * (_1252 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, in.input_uv, level(0.0)).x * (_1311 + 0.001000000047497451305389404296875)); - float2 _1331 = in.input_uv + (float2(1.0, 0.0) * _307); - float2 _1342 = (floor((_1331 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1342; - float4 _1359 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1342, level(0.0)).x, 1.0); - _646 = _1359; - float _1370 = fast::clamp(1.0 - (abs(dot((_1359.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1400 = in.input_uv + (float2(-2.0, 1.0) * _307); - float2 _1411 = (floor((_1400 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1411; - float4 _1428 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1411, level(0.0)).x, 1.0); - _646 = _1428; - float _1439 = fast::clamp(1.0 - (abs(dot((_1428.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1459 = in.input_uv + (float2(-1.0, 1.0) * _307); - float2 _1470 = (floor((_1459 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1470; - float4 _1487 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1470, level(0.0)).x, 1.0); - _646 = _1487; - float _1498 = fast::clamp(1.0 - (abs(dot((_1487.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1518 = in.input_uv + (float2(0.0, 1.0) * _307); - float2 _1529 = (floor((_1518 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1529; - float4 _1546 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1529, level(0.0)).x, 1.0); - _646 = _1546; - float _1557 = fast::clamp(1.0 - (abs(dot((_1546.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - float2 _1577 = in.input_uv + _307; - float2 _1588 = (floor((_1577 / _31.depthTexelSize) + float2(0.25)) + float2(0.5)) * _31.depthTexelSize; - _293 = _1588; - float4 _1605 = _31.inverseProjection * float4((_293.x * 2.0) - 1.0, 1.0 - (_293.y * 2.0), depthTexture.sample(depthSampler, _1588, level(0.0)).x, 1.0); - _646 = _1605; - float _1616 = fast::clamp(1.0 - (abs(dot((_1605.xyz / float3(_646.w)) - _410, _480)) / _310), 0.0, 1.0); - out._entryPointOutput = float4((((((_1319 + (occlusionTexture.sample(occlusionSampler, _1331, level(0.0)).x * (_1370 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1400, level(0.0)).x * (_1439 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1459, level(0.0)).x * (_1498 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1518, level(0.0)).x * (_1557 + 0.001000000047497451305389404296875))) + (occlusionTexture.sample(occlusionSampler, _1577, level(0.0)).x * (_1616 + 0.001000000047497451305389404296875))) / (0.01600000075995922088623046875 + (((((((((((((((_342 + _757) + _819) + _881) + _947) + _1006) + _1065) + _1124) + _1193) + _1252) + _1311) + _1370) + _1439) + _1498) + _1557) + _1616))); + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + FSInput param = _input; + out._entryPointOutput = _main(param, _31, depthTexture, depthSampler, occlusionTexture, occlusionSampler); return out; } diff --git a/src/shaders/compiled/post_ao_blur.frag.spv b/src/shaders/compiled/post_ao_blur.frag.spv index c3eeaba33b4896bc0294dee8c3a6afeeb9146c1b..838ce0e40b35f20b353b75e8ce0dea3e055d656a 100644 GIT binary patch literal 6936 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 delta 1242 zcmZuxe@q)y9Dmmy?@E8jv6gbs3I}YZAd+iW%TP4E0^OKhoRN{mNGt?L*+7b`V;Dnw zEd$&@&)tZKx~(`T!6n`Vw~1qg`3(;O0N8dm%>q>k-;1>Q$fO&$~Bly-TrOM+(p9m+h{wugC##2->H`0IcOexCj^WtHQap zH26!Fu$#o(716*5u3$w5@^C=1eNZk9crW@7AJzM<1fute0xsyCOasPxa6>CIbYEX{ z13()Az(H;%N%g;;xcf;t9+OCkhTkXgX~?+D8zW&;B!*9S*6r@!L!|$93 z**D8k9%{)aU5qqZ^51S4_AtP#`sf}*6OCk{L+MWpr@1vEV?QYYZ=K^! zMTIX^y}Yw|e}lWB`Bi0yZ-7)?>h$)Ls>^8Lf>|;|>7yu%?LR9y8+b|qhq z&2p+4G!Qfwh_$C^%^6xNZ=psJo<1lpb{Jo|Q=X!0t+Ex-`Y#eixrQcO_tZR(yIJ@; z51S|+nSrf*R?x5bTDyes0m{EQ<~IOtI5D>(I8@qs-PonJRq1|Qu~ki&H*LGf{yH|< z7ahMe)!P@{kr+AoNZRou)h{koZ&*-O6V(gHyz<`#%CWJTscZE3Cu1`LX$6eX(whj^ zul(HeGtvi}mtiec%K}mYH5rwAajb=cIWQ6U9Q-xrOX#*>br0bWGG1zAv9_IY_!e>* zwz1frxH_}WWx?F8IDCguV+S0VGp^2Td`(cZad;Ie@?hxHJC-qW6j(^@h4>k(VTh&v-0=OPg?kj|pbIec?3uAT@x4j}xs9YgVRGdcTJ# z0TLg5Tk2fgXr*?1>XOz|y*f1L^x-`^dDvMXGV~Byfr8wXw!}umPAe(jihj5pHKJuy z?ef}4qK^k@Ti(>U@i5ntqIn`(7-QZmj^2xg3%(B(trw#PC`k^K2_AOd3TMi#C*i&z zR9|4;w8`ZF4UvCyp_Dv?=5D4Gr$1LRYGtr>$IFxc$5d@pt!u5$H1~{JkLbC2wHfK< zjtlD$cS*fD@0&=;SH5R^bZFRBwkQi1eHS!^x #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; +}; + struct CompositeUniforms { float2 inverseTargetSize; @@ -19,76 +27,117 @@ struct main0_out float4 _entryPointOutput [[color(0)]]; }; -fragment main0_out main0(constant CompositeUniforms& _38 [[buffer(0)]], texture2d scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], texture2d ambientOcclusion [[texture(3)]], texture2d bloomSource [[texture(4)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], sampler ambientOcclusionSampler [[sampler(3)]], sampler bloomSourceSampler [[sampler(4)]], float4 gl_FragCoord [[position]]) +struct main0_in { - main0_out out = {}; - float2 _385 = gl_FragCoord.xy * _38.inverseTargetSize; - float4 _370 = scene.sample(sceneSampler, _385); + float2 input_uv [[user(locn0)]]; +}; + +static inline __attribute__((always_inline)) +float AmbientOcclusion(thread const float2& uv, constant CompositeUniforms& _38, texture2d ambientOcclusion, sampler ambientOcclusionSampler, texture2d bloomSource, sampler bloomSourceSampler) +{ + float visibility = ambientOcclusion.sample(ambientOcclusionSampler, uv).x; + if (_38.ambientOcclusionEffects > 0.0) + { + float effectLight = dot(bloomSource.sample(bloomSourceSampler, uv).xyz, float3(0.2125999927520751953125, 0.715200006961822509765625, 0.072200000286102294921875)); + visibility = mix(visibility, 1.0, fast::clamp(effectLight * 4.0, 0.0, 1.0)); + } + return fast::max(1.0 - ((1.0 - visibility) * _38.ambientOcclusionStrength), 0.0); +} + +static inline __attribute__((always_inline)) +float ToneMapChannel(thread const float& value, constant CompositeUniforms& _38) +{ + float range = 1.0 - _38.toneMapKnee; + return (value > _38.toneMapKnee) ? (_38.toneMapKnee + (range * (1.0 - exp((-(value - _38.toneMapKnee)) / range)))) : value; +} + +static inline __attribute__((always_inline)) +float3 Grade(thread const float3& color, texture2d grading, sampler gradingSampler) +{ + float blue = color.z * 31.0; + float lowerSlice = floor(blue); + float upperSlice = fast::min(lowerSlice + 1.0, 31.0); + float sliceBlend = blue - lowerSlice; + float x = ((color.x * 31.0) + 0.5) / 1024.0; + float y = ((color.y * 31.0) + 0.5) / 32.0; + float3 lower = grading.sample(gradingSampler, float2(x + (lowerSlice * 0.03125), y)).xyz; + float3 upper = grading.sample(gradingSampler, float2(x + (upperSlice * 0.03125), y)).xyz; + return mix(lower, upper, float3(sliceBlend)); +} + +static inline __attribute__((always_inline)) +float DitherNoise(thread const float2& pixel) +{ + return fract(52.98291778564453125 * fract(dot(pixel, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, constant CompositeUniforms& _38, texture2d scene, sampler sceneSampler, texture2d bloom, sampler bloomSampler, texture2d grading, sampler gradingSampler, texture2d ambientOcclusion, sampler ambientOcclusionSampler, texture2d bloomSource, sampler bloomSourceSampler) +{ + float2 uv = _input.pos.xy * _38.inverseTargetSize; + float4 color = scene.sample(sceneSampler, uv); if (_38.ambientOcclusionStrength > 0.0) { - float4 _522 = ambientOcclusion.sample(ambientOcclusionSampler, _385); - float _523 = _522.x; - float _699; - if (_38.ambientOcclusionEffects > 0.0) - { - _699 = mix(_523, 1.0, fast::clamp(dot(bloomSource.sample(bloomSourceSampler, _385).xyz, float3(0.2125999927520751953125, 0.715200006961822509765625, 0.072200000286102294921875)) * 4.0, 0.0, 1.0)); - } - else - { - _699 = _523; - } - float4 _397 = _370; - float3 _399 = _397.xyz * fast::max(1.0 - ((1.0 - _699) * _38.ambientOcclusionStrength), 0.0); - _370.x = _399.x; - _370.y = _399.y; - _370.z = _399.z; + float2 param = uv; + float4 _112 = color; + float3 _114 = _112.xyz * AmbientOcclusion(param, _38, ambientOcclusion, ambientOcclusionSampler, bloomSource, bloomSourceSampler); + color.x = _114.x; + color.y = _114.y; + color.z = _114.z; } if (_38.toneMapKnee < 1.0) { - float4 _411 = _370; - float3 _413 = fast::max(_411.xyz, float3(0.0)); - _370.x = _413.x; - _370.y = _413.y; - _370.z = _413.z; - float _553 = 1.0 - _38.toneMapKnee; - float _424 = _370.y; - float _579 = 1.0 - _38.toneMapKnee; - float _427 = _370.z; - float _605 = 1.0 - _38.toneMapKnee; - _370.x = (_370.x > _38.toneMapKnee) ? (_38.toneMapKnee + (_553 * (1.0 - exp((-(_370.x - _38.toneMapKnee)) / _553)))) : _370.x; - _370.y = (_424 > _38.toneMapKnee) ? (_38.toneMapKnee + (_579 * (1.0 - exp((-(_424 - _38.toneMapKnee)) / _579)))) : _424; - _370.z = (_427 > _38.toneMapKnee) ? (_38.toneMapKnee + (_605 * (1.0 - exp((-(_427 - _38.toneMapKnee)) / _605)))) : _427; + float4 _130 = color; + float3 _133 = fast::max(_130.xyz, float3(0.0)); + color.x = _133.x; + color.y = _133.y; + color.z = _133.z; + float param_1 = color.x; + float param_2 = color.y; + float param_3 = color.z; + float3 _152 = float3(ToneMapChannel(param_1, _38), ToneMapChannel(param_2, _38), ToneMapChannel(param_3, _38)); + color.x = _152.x; + color.y = _152.y; + color.z = _152.z; } if (_38.bloomScale > 0.0) { - float4 _453 = _370; - float3 _462 = float3(1.0) - ((float3(1.0) - _453.xyz) * (float3(1.0) - fast::clamp(bloom.sample(bloomSampler, _385).xyz * _38.bloomScale, float3(0.0), float3(1.0)))); - _370.x = _462.x; - _370.y = _462.y; - _370.z = _462.z; + float3 glow = fast::clamp(bloom.sample(bloomSampler, uv).xyz * _38.bloomScale, float3(0.0), float3(1.0)); + float4 _180 = color; + float3 _189 = float3(1.0) - ((float3(1.0) - _180.xyz) * (float3(1.0) - glow)); + color.x = _189.x; + color.y = _189.y; + color.z = _189.z; } if (_38.gradingStrength > 0.0) { - float4 _474 = _370; - float3 _376 = _474.xyz; - float _638 = _376.z * 31.0; - float _640 = floor(_638); - float _651 = ((_376.x * 31.0) + 0.5) * 0.0009765625; - float _656 = ((_376.y * 31.0) + 0.5) * 0.03125; - float3 _482 = mix(_474.xyz, mix(grading.sample(gradingSampler, float2(_651 + (_640 * 0.03125), _656)).xyz, grading.sample(gradingSampler, float2(_651 + (fast::min(_640 + 1.0, 31.0) * 0.03125), _656)).xyz, float3(_638 - _640)), float3(_38.gradingStrength)); - _370.x = _482.x; - _370.y = _482.y; - _370.z = _482.z; + float4 _202 = color; + float3 param_4 = color.xyz; + float3 _211 = mix(_202.xyz, Grade(param_4, grading, gradingSampler), float3(_38.gradingStrength)); + color.x = _211.x; + color.y = _211.y; + color.z = _211.z; } if (_38.ditherAmount > 0.0) { - float4 _502 = _370; - float3 _505 = _502.xyz + float3((fract(52.98291778564453125 * fract(dot(gl_FragCoord.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))) - 0.5) * _38.ditherAmount); - _370.x = _505.x; - _370.y = _505.y; - _370.z = _505.z; + float2 param_5 = _input.pos.xy; + float4 _234 = color; + float3 _237 = _234.xyz + float3((DitherNoise(param_5) - 0.5) * _38.ditherAmount); + color.x = _237.x; + color.y = _237.y; + color.z = _237.z; } - out._entryPointOutput = _370; + return color; +} + +fragment main0_out main0(main0_in in [[stage_in]], constant CompositeUniforms& _38 [[buffer(0)]], texture2d scene [[texture(0)]], texture2d bloom [[texture(1)]], texture2d grading [[texture(2)]], texture2d ambientOcclusion [[texture(3)]], texture2d bloomSource [[texture(4)]], sampler sceneSampler [[sampler(0)]], sampler bloomSampler [[sampler(1)]], sampler gradingSampler [[sampler(2)]], sampler ambientOcclusionSampler [[sampler(3)]], sampler bloomSourceSampler [[sampler(4)]], float4 gl_FragCoord [[position]]) +{ + main0_out out = {}; + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + FSInput param = _input; + out._entryPointOutput = _main(param, _38, scene, sceneSampler, bloom, bloomSampler, grading, gradingSampler, ambientOcclusion, ambientOcclusionSampler, bloomSource, bloomSourceSampler); return out; } diff --git a/src/shaders/compiled/post_composite.frag.spv b/src/shaders/compiled/post_composite.frag.spv index d1e6122ad03caf26cb6443d4ccc5772f90361d8b..ed0673d2769ba490d65e74396e413401405ae165 100644 GIT binary patch literal 9180 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 literal 7300 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 VM}Mh92iO?ecJNewg%OXX{}(#xxWNDb diff --git a/src/shaders/compiled/shadow_mask.frag.dxil b/src/shaders/compiled/shadow_mask.frag.dxil index 623d6caf2248ab2482bbe84318e379940b426013..d4a06b9af2c6297d57a03092a65c1731cc98d3db 100644 GIT binary patch delta 511 zcmeB?m?9zR65-?=@W`P!>$dXao|(Vx-r0PYW@KPs5ZNesgIPrNxa%=Cw_~c$*jQZE z+I-lKzj1rEnU&=`ljQ`jj~@d#)Vbz=#!#H^&hx+6>%o2f}Ng7Q?8Xcb&XmuKCv*hp7IgLrn5|uO>I6?)lUAR118NUWL`H&4cVT!!l3`;l&j*QGwwu6-ep0dHwFi&pJ##ZRS2bYXY{)f_(KdqFM7N34vBr%@h=JuG!_J;nQB8u)EDVkY4tk4M^(7op fU~~}RnQ(fAma2rI2ZI0$^An?0t2jY%!oUCkHZ!e_ delta 485 zcmbOt(IX-065-?={N?kb*mFlWIm_sE7;inhnUR5kfoG%S4Q3J6WWLv9Y+O zsj0iGEpv0*%*yheNn~ZL+eN;d8eR9+pu3q*j>)=2c=~Mq!q~_-c_N28Bk$z7%;M}F zNg7Q?8vK*@F-z)JN-!|^1I?9U_L<h5! zrFH4f!kL?XHC4^_UhG|6JX=BJ6wAU0GnOMP3lr2hTsJ2w%4tkmmZ+rBz!55V?ZV~B zA{SW}7MSTYvj$!=jbUc>5$H&EHt-SPNNL_6DLw5>lg3-AWj&9~cto!m0?l2-HQ8Ew zG0@cWER7y!9MKXv5gq(Y%=Mj8YE44Tyay$6By5Zr%tU&F*%$&^d(W;rtJ=HfOmCi- zK#1bu;*HvqXM-FiB;b4EL(H2)H{P6jvW&$|*2reMvFs{TmkCVEM7eMbaRz=@#5LDg{FYQ9TZMJK-ze7Cu=g} #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; + float4 color; +}; + struct main0_out { float4 _entryPointOutput [[color(0)]]; @@ -10,13 +19,25 @@ struct main0_out struct main0_in { + float2 input_uv [[user(locn0)]]; float4 input_color [[user(locn1)]]; }; -fragment main0_out main0(main0_in in [[stage_in]]) +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input) +{ + return float4(1.0 - _input.color.w); +} + +fragment main0_out main0(main0_in in [[stage_in]], float4 gl_FragCoord [[position]]) { main0_out out = {}; - out._entryPointOutput = float4(1.0 - in.input_color.w); + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + _input.color = in.input_color; + FSInput param = _input; + out._entryPointOutput = _main(param); return out; } diff --git a/src/shaders/compiled/shadow_mask.frag.spv b/src/shaders/compiled/shadow_mask.frag.spv index 164de1f7efd8371d10727f63255813e7bac484fa..9187440a23870acd37e06841abb2cb9c1df90b3d 100644 GIT binary patch literal 1252 zcmY+CTWeE66otpcQ(JqtwiVQR(rO#6i5KdPqP8y~^--Uah^@i~M{VIHkT@I|#xO^Fy!}tws4qV3NE5P4mzMI%oXF7iepUe1Ntaq!~ zuXvh?@w|!|PvhaXXf8ZXXX9@`CH=Jd%%7UIhA7@z%$O^9XHC=sJF%k!1~o&`wmcV&+6rB()|zF z+fTax5qtH%k$Slr^}cx<7&m6E@;BtN)+b;d=r`^h^!;XI45 v1{nj{An|6P8j!&zKnyY*Bp$%P4ulL0ra%l5N5*yx%nUkExxYZ$Er1vRcWD!C diff --git a/src/shaders/compiled/skinned_lit.frag.dxil b/src/shaders/compiled/skinned_lit.frag.dxil index 1a12c61da0c8ba7cf71557a3abb4ae3fd25d931b..d27302d795522266efb2d44aaa7218805aac770e 100644 GIT binary patch delta 3131 zcmai0ZB!Fy7M>)NA%O`@K*OX|Gl75~n`)v+sJkbdgcxx_3rg2uwH*?^Y!$H5YJ1Y1 zWP)k5)C8;)P}^ASu08dv1l&EIE$f*`AgR)7ZOU%nCBj@O@in%=Jo?RRWf-d-_&kC0qJ!tFf zH=9w#cwuP6IAR(v{2YNd6uByq(5z|rZJ`1gzMl0P?)s{s#jUeqIa_%D=dPzD7rEdrCHGiW z9?a=E_Gn&yR>K1-UR6uO_BDmuO>b^JJM7B4&86Bp@C%NZXrrwqVk?B#U&V?8ZU@Is z;N|hbw0BeH_e|Q=lzFczeZl;JOn=X<=Y#)N{lKK}$I`a!Pdjiu^BXeV(U!*Bmv%ta zk3j=MgQ{O8D7ojb?TPUcld-h8e>y8--H|07tv!KKTFm1?dX;zPvJB3^61{C8+cNDi9MX-E_~+GV4eD|% z9b=uZtMOG4a9eJhUMmsA{5!+^L@&lP1sO<(p=T}~Jj~EWZIL4Gmv>!r2e<$_5xH!Q!hXk5eI>NtJmHXji3efTi(?P={_;^d zpLq399kL$T%9&`W1Fsx4P?imW+xy&1}Sr_$h1-ho2Hi zdJowuRT+s%QUb7Xvv3&tngBM$@#k2_($|!VCnq499g566G-U}!ST-l& zW}f>Bj7+*U*;I{M9XGAbiCtTy18XF2i(r^iJvd&s+uEkFiU& zuEXgj6a}rSd!s9cDFr+L90KTtg3NTH8gx8Zaswn**;2qdu;zw4z{*N{N%ztV@`3>& zM`dY)2ugtLIC_0!m26a`f7u>T^0xDb;eY7Hu+08jHN3@TrOmc&VE?o)v3XsU9_@ed zQOT?THldl|VhFVvwa*ven+5g{U^%`S@Av?=sOXXzE4()t65MoqL{7jrKpv3Ud?Vdb z7(sVIbs+qT45fI+N;wQ5Yd*+&aK>nS1+LDnFU{}Gnm*CM43VkkSuYj`Xp^=G^!@3s zYf60ykec3~b^_8m0@v2D&d)njQuEcjN4x>t9UuU=(g3v}Q2BTIZAuE6rxH=qimDoL^ zy^t*LCIlqlrfv+%?CAoviICEdQ;udtzXTLN*5wbU3hi4C*HR)sLa!W6nSbxTZ(e$16d7%WzuKC7$)n|w7WIuQZ1s!oeX1tX(5`#(<>dXna_d^ zZ{K5C^zFc2*(!p+tJ9{3Kas-C6FNuNp;-u$`OEZQW*O>M~YMCsfiJE z7_Mi>jn$qp1?b+%S=9!%s*#J#%PHAe^S7DohXUD!`s@O=g@gzJl6|$KQZ;WedfB&%+Wt?$>Pr1Mnmm2@kW9&eq!= zm^fK+?&L(X0W!yy#id6D?HlG?1Q1!RO2e3 zpAdt3tu1vfkbZDqZh)=}(eLEURr6d| zS(4K3bsB{;_ds24kVrvaud(E$%y!Mn9J4OGFzQC6eGL5wsMUP`J#%c$_iHq)-1HOh zfY3>f{W;9G;j^(LHs$gtW!-ch`0P-966CdfH)&zvBzD`AE56%jsV9Bce-&3(eYrS+ zFTZ!hb}kc)@Fif*tj8nPGOjEydv4OpgvK}QimqiPO@QpWW8Zw`%=^s-6{>;X<{`uA z-a#a=0MVUJ(bYlllIRr&o2Yq>QA}+*VNJ=+)V@QLe(E^I(416S_OCK; z!u8gTI$6dQWPuirtUIto$AZq75{=S`9blbQJ@b_>T7GWqfig`wZ;%(|lS@>+4R)Re z0Fnt&tc?DlspX*SfGLMtS9&@9mDV0k<}G4=W;r*!FxS}LD2$N4hPFwjmZv$$)3ot4 z&CdBz@n!gn76!3_t>9ox1`h6ZmL?Bo&z;!V8ZH9o(siZzWFDY_*ZJ`MmpA^@`o7CX zfvwEWqWgmJ-G>^^RA&)J^J$w>5VbmP-v{<5;VCA@{?n2CJWXuV2AXMJXVGs0&0NJ~ z47ux{7R^{k^MawHdaVnM`|H6te+KB~*O0d4BMy*<&q<$E6@`}0KubYFNweV>cG3(I z?Dq^N8IoaK`9Gy5G@G3?b@HD$a?B#D`{nD?KMMcnHT}AZvEy9u&Hfm&?zuMb{l4(~ EFVQ({v;Y7A delta 3117 zcmaJ@dsGuw8lSu-37OD@N1PBmneYgx*_r@_6x(besSYOIgiEoV*C?b5Av6Nn@zEzpOiEv4Z>0VIquK=hRB+U9sNDt;o$^}u zW>LWd2lC`J!?QacFDrgrf3D&DWtZp<)#A2MtQcDNgOwR2!<6sma0bg5CZDF|8N=;P zVZ@f=uJ+jSl~1y5AC%EI$hR9P7z=KEG%%1Kv3)cVUV25ls&}AyLZbn(M@kR1+Ib!+ zV(0F|#G?CZRpot~xows<8;3GdK}n7!VH(Vj?Nm}Te^Sq$7wK#{cD{oFY2<;L8o`hn z8NiVUhPVpt^}K6Ma5GDfAP_yQUe0df$>g-TUK~yb!$`7xog8UIT#2l(`Z~^%^N9q@ z4!grt(4293kh6b`X-+Wrg_whU$_myU8LggP2*Z%wf@AMQ9%KoecJq1`V=m6iNFOaO zg_pw)=#^&wb~!7E5()N7*j}rul%*9Cw^!I29wA z$HYIjYE%NB&Fo<(O@}bC7M?Ti0aa#llcueCv1kuPCCE=HTvjiGW$v>qOPDm&Q)JJd z4Tuj(N?o|JU@vp>_zrm|9tlBe9&)xn#SBw*Drr9G);B5(D+~(M^@ki%?(wI0qsZmwN9Of4GVcVgwx-p4fKoMtcCy_jn zL={Hj0M0|ZsYO49#p)^X{bpr>fep$x^pNEj-HNfp_AZ~7T__QY^fju>^qT;u(nk&> z768;#;V_ZmhmC<))Kv@0o>83X^5*&gBvU4Lk$4lhW?m$UZu5B+?_pw-S))3C&t^tu z00Cy0>EJW@Nt5W|SoH1PK5sG2EK?>-85A*xHydvVMeTG|A?$ssw_WN-1Cc-f(R!Sgs=4J#-k%?jqP9yL&6JDPiK zowi2k`6d*+!g8Ul0+(>%F5XhDA1q~^!2oODC0P44n`G^c2R`D->Hu>J#GiChPfD*G_v^*1wnYS5%=Sz>;J92_E;q=mwV4GES!i ztiI7!D!-Q(+8Id@bPEVR?eL?Wu~$AP%0I}_BLX10ki9FFs{Y{H{z=M1P-QYX+hiv~I~fL;{AjtbCN_vdv)67Hzj-cGRYM8{d?GqG4}4dg-d zAq&fH>nXg)|2W#NH5B6Vo1x8Nne8Ei!s$3)^@;jAFEj5>BP~~}Y~8wU4m{v>E*IHlpl+-G%7uk4xZ*FOj=PW>Z-Jk z%50Seh1Id+DOxT~Y1EU+Aa|F62`(|v6qZq{#uV=QB7M#!?(dPOa=Q2j+GtB1!rB&{ z7qnt23GlyAogjIu8JZ^#$IhKpwx!^0OZ+>jqLaDY`L z3J0q4B~JFt5#C*yb~SA4VDnE+y3Y}O`GMn6OqDNy9q*5PsC z3#Yq7w~E|e3*(?!)}AO|mjd@_e*^xaUB_Spdq$lad`k}SMFQv0#DT}`Rf<*YDHBB} z=A?B%(ZIWL?30_P=q)8+bAQsLfq`)4z?T^I*4Kjqu<%z{=jMx6S)?Xr6 z4*n3oYofdfs*<#&DTszU;YPtRx-OYy_4* zFD_hO{&m)hlJa9bNO1q4*;Pp0%D*cl=OPCx+ zAhZQBT^WB(!-6GfC+k)%5YrgOU381j^iR?`2pHY5D6F-BS@5(R+*@nncRS}-XxqYy zf%RB`L0;nf+~LIat#O8eMMD2+M|@#| zC+tSb3bzhm#^8!HA;YCt3&flZ%bf8;kcYrfwdH~S*5>u1M1OU8{`pm(cL5cmrS}e* zk(`%mRdB|81>(0H6x9|c&D@s>&&GW~k91XKQ7ZUc{gSx_AT_tE@$RxW0Sd?{EKbC;bu)zYcE3azI zZF?QF@f180H2J&|hgl{}nzTy+KGjw)_XP;p!^7xZ6nWVCveL>_E`*zZ5if*_I$}gR v4}8aTs$=_Hd #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float eyeDepth; + float3 normal; + float3 viewVector; + float4 lightDirectionAndSpecular; + float4 worldPositionAndDynamicLights; + float3 worldNormal; + float4 tangent; + float4 worldTangentAndNormalMapScale; +}; + struct SceneLighting { float4 sceneLightDirection; @@ -44,6 +62,7 @@ struct main0_in { float2 input_uv [[user(locn0)]]; float4 input_color [[user(locn1)]]; + float input_fogFactor [[user(locn2)]]; float input_eyeDepth [[user(locn3)]]; float3 input_normal [[user(locn4)]]; float3 input_viewVector [[user(locn5)]]; @@ -54,133 +73,188 @@ struct main0_in float4 input_worldTangentAndNormalMapScale [[user(locn10)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _117 [[buffer(0)]], constant DynamicLights& _163 [[buffer(1)]], constant FogUniforms& _527 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]]) +static inline __attribute__((always_inline)) +float3 SafeNormalize(thread const float3& value) { - main0_out out = {}; - float4 _696 = tex.sample(s, in.input_uv); - float2 _699 = dfdx(in.input_uv); - float2 _702 = dfdy(in.input_uv); - float3 _1457; - float3 _1458; - if ((in.input_worldTangentAndNormalMapScale.w > 0.0) && (in.input_tangent.w != 0.0)) - { - float3 _727 = (normalMap.sample(normalSampler, in.input_uv, gradient2d(_699, _702)).xyz * 2.0) - float3(1.0); - float2 _731 = _727.xy * in.input_worldTangentAndNormalMapScale.w; - float _733 = _731.x; - float _735 = _731.y; - float _739 = (in.input_tangent.w > 0.0) ? 1.0 : (-1.0); - float _985 = dot(in.input_normal, in.input_normal); - float3 _993 = select(float3(0.0), in.input_normal * rsqrt(_985), bool3(_985 > 9.9999999600419720025001879548654e-13)); - float _999 = dot(in.input_tangent.xyz, in.input_tangent.xyz); - float3 _1007 = select(float3(0.0), in.input_tangent.xyz * rsqrt(_999), bool3(_999 > 9.9999999600419720025001879548654e-13)); - float3 _978 = ((_1007 * _733) + ((cross(_993, _1007) * _739) * _735)) + (_993 * _727.z); - float _1013 = dot(_978, _978); - float _1059 = dot(in.input_worldNormal, in.input_worldNormal); - float3 _1067 = select(float3(0.0), in.input_worldNormal * rsqrt(_1059), bool3(_1059 > 9.9999999600419720025001879548654e-13)); - float _1073 = dot(in.input_worldTangentAndNormalMapScale.xyz, in.input_worldTangentAndNormalMapScale.xyz); - float3 _1081 = select(float3(0.0), in.input_worldTangentAndNormalMapScale.xyz * rsqrt(_1073), bool3(_1073 > 9.9999999600419720025001879548654e-13)); - float3 _1052 = ((_1081 * _733) + ((cross(_1067, _1081) * _739) * _735)) + (_1067 * _727.z); - float _1087 = dot(_1052, _1052); - _1458 = select(float3(0.0), _1052 * rsqrt(_1087), bool3(_1087 > 9.9999999600419720025001879548654e-13)); - _1457 = select(float3(0.0), _978 * rsqrt(_1013), bool3(_1013 > 9.9999999600419720025001879548654e-13)) * length(in.input_normal); - } - else - { - _1458 = in.input_worldNormal; - _1457 = in.input_normal; - } - float _1101 = dot(_1457, _1457); - float3 _1109 = select(float3(0.0), _1457 * rsqrt(_1101), bool3(_1101 > 9.9999999600419720025001879548654e-13)); - float _1115 = dot(in.input_viewVector, in.input_viewVector); - float3 _1123 = select(float3(0.0), in.input_viewVector * rsqrt(_1115), bool3(_1115 > 9.9999999600419720025001879548654e-13)); - float _774 = dot(_1457, in.input_lightDirectionAndSpecular.xyz); - float _784 = fast::max((_774 * _117.diffuseCurve.x) + _117.diffuseCurve.y, _117.diffuseCurve.z); - float _1129 = dot(_1458, _1458); - float3 _1137 = select(float3(0.0), _1458 * rsqrt(_1129), bool3(_1129 > 9.9999999600419720025001879548654e-13)); - uint _1152 = min(_163.dynamicLightCount, 32u); - float3 _1460; - _1460 = float3(0.0); - float3 _1467; - for (uint _1459 = 0u; _1459 < _1152; _1460 = _1467, _1459++) + float lengthSquared = dot(value, value); + return select(float3(0.0), value * rsqrt(lengthSquared), bool3(lengthSquared > 9.9999999600419720025001879548654e-13)); +} + +static inline __attribute__((always_inline)) +float3 PerturbNormal(thread const float3& normal, thread const float3& tangent, thread const float& handedness, thread const float3& mapped) +{ + float3 param = normal; + float3 n = SafeNormalize(param); + float3 param_1 = tangent; + float3 t = SafeNormalize(param_1); + float3 b = cross(n, t) * handedness; + float3 param_2 = ((t * mapped.x) + (b * mapped.y)) + (n * mapped.z); + return SafeNormalize(param_2); +} + +static inline __attribute__((always_inline)) +float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _163) +{ + float3 light = float3(0.0); + uint count = min(_163.dynamicLightCount, 32u); + for (uint i = 0u; i < count; i++) { - float3 _1165 = _163.dynamicLightPositionAndRadius[_1459].xyz - in.input_worldPositionAndDynamicLights.xyz; - float _1170 = length(_1165.xy); - if (_1170 >= _163.dynamicLightPositionAndRadius[_1459].w) + float4 positionAndRadius = _163.dynamicLightPositionAndRadius[i]; + float3 toLight = positionAndRadius.xyz - worldPosition; + float radius = positionAndRadius.w; + float horizontalDistance = length(toLight.xy); + if (horizontalDistance >= radius) { - _1467 = _1460; continue; } - float _1213 = dot(_1165, _1165); - _1467 = _1460 + (_163.dynamicLightColor[_1459].xyz * (((_163.dynamicLightPositionAndRadius[_1459].w - _1170) / _163.dynamicLightPositionAndRadius[_1459].w) * fast::clamp((dot(_1137, select(float3(0.0), _1165 * rsqrt(_1213), bool3(_1213 > 9.9999999600419720025001879548654e-13))) * (1.0 - _163.dynamicLightWrap)) + _163.dynamicLightWrap, 0.0, 1.0))); + float falloff = (radius - horizontalDistance) / radius; + float3 param = toLight; + float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param)) * (1.0 - _163.dynamicLightWrap)) + _163.dynamicLightWrap, 0.0, 1.0); + light += (_163.dynamicLightColor[i].xyz * (falloff * wrapped)); } - float3 _795 = select(float3(0.0), _1460, bool3(in.input_worldPositionAndDynamicLights.w > 0.5)); - float3 _1462; - if ((_117.diffuseCurve.w > 0.0) && (_117.diffuseCurve.w < 1.0)) - { - float3 _812 = (in.input_color.xyz * _784) + _795; - float _1239 = _812.x; - float _1258 = 1.0 - _117.diffuseCurve.w; - float _1243 = _812.y; - float _1281 = 1.0 - _117.diffuseCurve.w; - float _1247 = _812.z; - float _1304 = 1.0 - _117.diffuseCurve.w; - _1462 = fast::clamp(float3((_1239 > _117.diffuseCurve.w) ? (_117.diffuseCurve.w + (_1258 * (1.0 - exp((-fast::max(_1239 - _117.diffuseCurve.w, 0.0)) / _1258)))) : _1239, (_1243 > _117.diffuseCurve.w) ? (_117.diffuseCurve.w + (_1281 * (1.0 - exp((-fast::max(_1243 - _117.diffuseCurve.w, 0.0)) / _1281)))) : _1243, (_1247 > _117.diffuseCurve.w) ? (_117.diffuseCurve.w + (_1304 * (1.0 - exp((-fast::max(_1247 - _117.diffuseCurve.w, 0.0)) / _1304)))) : _1247), float3(0.0), float3(1.0)); - } - else + return light; +} + +static inline __attribute__((always_inline)) +bool RollsOffHighlight(thread const float& knee) +{ + return (knee > 0.0) && (knee < 1.0); +} + +static inline __attribute__((always_inline)) +float RollOffChannel(thread const float& value, thread const float& knee) +{ + float range = 1.0 - knee; + return (value > knee) ? (knee + (range * (1.0 - exp((-fast::max(value - knee, 0.0)) / range)))) : value; +} + +static inline __attribute__((always_inline)) +float3 RollOffHighlight(thread const float3& color, thread const float& knee) +{ + float param = color.x; + float param_1 = knee; + float param_2 = color.y; + float param_3 = knee; + float param_4 = color.z; + float param_5 = knee; + return fast::clamp(float3(RollOffChannel(param, param_1), RollOffChannel(param_2, param_3), RollOffChannel(param_4, param_5)), float3(0.0), float3(1.0)); +} + +static inline __attribute__((always_inline)) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _117) +{ + float scaledDistance = fast::max(eyeDepth - _117.sceneFogParameters.x, 0.0) * _117.sceneFogParameters.z; + return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, constant SceneLighting& _117, constant DynamicLights& _163, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _527) +{ + float4 texel = tex.sample(s, _input.uv); + float2 uvDx = dfdx(_input.uv); + float2 uvDy = dfdy(_input.uv); + float3 shadingNormal = _input.normal; + float3 worldNormal = _input.worldNormal; + float normalMapScale = _input.worldTangentAndNormalMapScale.w; + if ((normalMapScale > 0.0) && (_input.tangent.w != 0.0)) { - _1462 = fast::clamp((in.input_color.xyz * _784) + _795, float3(0.0), float3(1.0)); + float3 mapped = (normalMap.sample(normalSampler, _input.uv, gradient2d(uvDx, uvDy)).xyz * 2.0) - float3(1.0); + float3 _334 = mapped; + float2 _336 = _334.xy * normalMapScale; + mapped.x = _336.x; + mapped.y = _336.y; + float handedness = (_input.tangent.w > 0.0) ? 1.0 : (-1.0); + float3 param = _input.normal; + float3 param_1 = _input.tangent.xyz; + float param_2 = handedness; + float3 param_3 = mapped; + shadingNormal = PerturbNormal(param, param_1, param_2, param_3) * length(_input.normal); + float3 param_4 = _input.worldNormal; + float3 param_5 = _input.worldTangentAndNormalMapScale.xyz; + float param_6 = handedness; + float3 param_7 = mapped; + worldNormal = PerturbNormal(param_4, param_5, param_6, param_7); } - float _836 = in.input_lightDirectionAndSpecular.w * _117.specularParameters.x; - float3 _1463; - if ((_836 > 0.0) && (_774 > 0.0)) + float3 objectLight = _input.color.xyz; + float3 param_8 = shadingNormal; + float3 normal = SafeNormalize(param_8); + float3 param_9 = _input.viewVector; + float3 view = SafeNormalize(param_9); + float3 light = _input.lightDirectionAndSpecular.xyz; + float lightDot = dot(shadingNormal, light); + float luminosity = fast::max((lightDot * _117.diffuseCurve.x) + _117.diffuseCurve.y, _117.diffuseCurve.z); + float3 param_10 = worldNormal; + float3 param_11 = _input.worldPositionAndDynamicLights.xyz; + float3 param_12 = SafeNormalize(param_10); + float3 dynamicLight = select(float3(0.0), DynamicLighting(param_11, param_12, _163), bool3(_input.worldPositionAndDynamicLights.w > 0.5)); + float3 diffuse = fast::clamp((objectLight * luminosity) + dynamicLight, float3(0.0), float3(1.0)); + float param_13 = _117.diffuseCurve.w; + if (RollsOffHighlight(param_13)) { - float _1328 = dot(in.input_lightDirectionAndSpecular.xyz, in.input_lightDirectionAndSpecular.xyz); - float3 _846 = select(float3(0.0), in.input_lightDirectionAndSpecular.xyz * rsqrt(_1328), bool3(_1328 > 9.9999999600419720025001879548654e-13)) + _1123; - float _1342 = dot(_846, _846); - _1463 = (_117.sceneLightColor.xyz * (_836 * powr(fast::clamp(dot(_1109, select(float3(0.0), _846 * rsqrt(_1342), bool3(_1342 > 9.9999999600419720025001879548654e-13))), 0.0, 1.0), _117.specularParameters.y))) * in.input_color.xyz; + float3 param_14 = (objectLight * luminosity) + dynamicLight; + float param_15 = _117.diffuseCurve.w; + diffuse = RollOffHighlight(param_14, param_15); } - else + float facing = fast::clamp(abs(dot(normal, view)), 0.0, 1.0); + float3 rim = objectLight * (_117.rimParameters.x * powr(1.0 - facing, _117.rimParameters.y)); + float specularStrength = _input.lightDirectionAndSpecular.w * _117.specularParameters.x; + float3 specular = float3(0.0); + if ((specularStrength > 0.0) && (lightDot > 0.0)) { - _1463 = float3(0.0); + float3 param_16 = light; + float3 param_17 = SafeNormalize(param_16) + view; + float3 halfVector = SafeNormalize(param_17); + float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _117.specularParameters.y); + specular = (_117.sceneLightColor.xyz * (specularStrength * highlight)) * objectLight; } - float _877 = _696.w * in.input_color.w; - float4 _881 = float4(((_696.xyz * _1462) + (in.input_color.xyz * (_117.rimParameters.x * powr(1.0 - fast::clamp(abs(dot(_1109, _1123)), 0.0, 1.0), _117.rimParameters.y)))) + _1463, _877); - float4 _1464; + float4 color = float4(((texel.xyz * diffuse) + rim) + specular, texel.w * _input.color.w); if (_527.alphaToCoverage != 0u) { - float _901 = _877 * fast::clamp(((_877 - _527.alphaThreshold) / fast::max(fwidth(_877), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); - float4 _1447 = _881; - _1447.w = _901; - if (_901 <= 0.0) + float edge = fast::clamp(((color.w - _527.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + color.w *= edge; + if (color.w <= 0.0) { discard_fragment(); } - _1464 = _1447; } else { - if ((_527.alphaDiscardEnabled != 0u) && (_877 <= _527.alphaThreshold)) + if ((_527.alphaDiscardEnabled != 0u) && (color.w <= _527.alphaThreshold)) { discard_fragment(); } - _1464 = _881; } - float4 _1465; if ((_527.fogEnabled != 0u) && (_117.sceneFogColor.w > 0.0)) { - float _1361 = fast::max(in.input_eyeDepth - _117.sceneFogParameters.x, 0.0) * _117.sceneFogParameters.z; - float3 _938 = mix(_1464.xyz, _117.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_1361) * _1361), 0.0, 1.0))); - float4 _1451 = _1464; - _1451.x = _938.x; - _1451.y = _938.y; - _1451.z = _938.z; - _1465 = _1451; - } - else - { - _1465 = _1464; + float4 _580 = color; + float param_18 = _input.eyeDepth; + float3 _590 = mix(_580.xyz, _117.sceneFogColor.xyz, float3(EnhancedFogAmount(param_18, _117))); + color.x = _590.x; + color.y = _590.y; + color.z = _590.z; } - out._entryPointOutput = _1465; + return color; +} + +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _527 [[buffer(0)]], constant SceneLighting& _117 [[buffer(1)]], constant DynamicLights& _163 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +{ + main0_out out = {}; + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + _input.color = in.input_color; + _input.fogFactor = in.input_fogFactor; + _input.eyeDepth = in.input_eyeDepth; + _input.normal = in.input_normal; + _input.viewVector = in.input_viewVector; + _input.lightDirectionAndSpecular = in.input_lightDirectionAndSpecular; + _input.worldPositionAndDynamicLights = in.input_worldPositionAndDynamicLights; + _input.worldNormal = in.input_worldNormal; + _input.tangent = in.input_tangent; + _input.worldTangentAndNormalMapScale = in.input_worldTangentAndNormalMapScale; + FSInput param = _input; + float4 _645 = _main(param, _117, _163, tex, s, normalMap, normalSampler, _527); + out._entryPointOutput = _645; return out; } diff --git a/src/shaders/compiled/skinned_lit.frag.spv b/src/shaders/compiled/skinned_lit.frag.spv index c30122e9eab2a060591e85a78bf0ab729b45a336..b8bbc3eedcebea04eb959e2019dde8d75ffb4f97 100644 GIT binary patch literal 17240 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 Y7^CJsinXzfc|8hjyZ)_4?B8ns7tFR81^@s6 literal 10936 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 Wu`o;g;7Y`Mn}3_jKK+x3UjG2j-5lls diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index 866699db80..6f1fd90fdc 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -1,8 +1,20 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" + #include #include using namespace metal; +struct FSInput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float eyeDepth; + float3 worldPosition; +}; + struct SceneLighting { float4 sceneLightDirection; @@ -45,60 +57,89 @@ struct main0_in { float2 input_uv [[user(locn0)]]; float4 input_color [[user(locn1)]]; + float input_fogFactor [[user(locn2)]]; float input_eyeDepth [[user(locn3)]]; float3 input_worldPosition [[user(locn4)]]; }; -fragment main0_out main0(main0_in in [[stage_in]], constant SceneLighting& _30 [[buffer(0)]], constant DynamicLights& _64 [[buffer(1)]], constant FogUniforms& _214 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +static inline __attribute__((always_inline)) +float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _64) { - main0_out out = {}; - float4 _334 = tex.sample(s, in.input_uv); - float4 _316 = _334; - uint2 _317 = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); - float2 _321 = float2(1.0) - ((float2(1.0) - groundShadowMask.sample(groundShadowSampler, (gl_FragCoord.xy / float2(float(_317.x), float(_317.y)))).xy) * _64.groundShadowOpacity); - uint _471 = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); - float3 _555; - _555 = float3(0.0); - float3 _557; - for (uint _554 = 0u; _554 < _471; _555 = _557, _554++) + float3 light = float3(0.0); + uint count = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); + for (uint i = 0u; i < count; i++) { - float4 _461 = _64.dynamicLightPositionAndRadius[_554]; - float _488 = length(_64.dynamicLightPositionAndRadius[_554].xy - in.input_worldPosition.xy); - if (_488 < _461.w) + float4 positionAndRadius = _64.dynamicLightPositionAndRadius[i]; + float radius = positionAndRadius.w; + float horizontalDistance = length(positionAndRadius.xy - worldPosition.xy); + if (horizontalDistance < radius) { - _557 = _555 + (_64.dynamicLightColor[_554].xyz * ((_461.w - _488) / _461.w)); - } - else - { - _557 = _555; + light += (_64.dynamicLightColor[i].xyz * ((radius - horizontalDistance) / radius)); } } - float4 _324 = float4(_334.xyz * fast::clamp((in.input_color.xyz * _321.x) + (_555 * _321.y), float3(0.0), float3(1.0)), _316.w * in.input_color.w); + return light; +} + +static inline __attribute__((always_inline)) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _30) +{ + float scaledDistance = fast::max(eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; + return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); +} + +static inline __attribute__((always_inline)) +float4 _main(thread const FSInput& _input, constant SceneLighting& _30, constant DynamicLights& _64, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _214) +{ + float4 texel = tex.sample(s, _input.uv); + uint2 sizeQueryTemp = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); + uint maskWidth = sizeQueryTemp.x; + uint maskHeight = sizeQueryTemp.y; + float2 visibility = groundShadowMask.sample(groundShadowSampler, (_input.pos.xy / float2(float(maskWidth), float(maskHeight)))).xy; + float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _64.groundShadowOpacity); + float3 param = _input.worldPosition; + float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param, _64) * shadow.y), float3(0.0), float3(1.0)); + float4 color = float4(texel.xyz * light, texel.w * _input.color.w); if (_214.alphaToCoverage != 0u) { - _324.w *= fast::clamp(((_324.w - _214.alphaThreshold) / fast::max(fwidth(_324.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); - if (_324.w <= 0.0) + float edge = fast::clamp(((color.w - _214.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + color.w *= edge; + if (color.w <= 0.0) { discard_fragment(); } } else { - if ((_214.alphaDiscardEnabled != 0u) && (_324.w <= _214.alphaThreshold)) + if ((_214.alphaDiscardEnabled != 0u) && (color.w <= _214.alphaThreshold)) { discard_fragment(); } } if ((_214.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) { - float4 _439 = _324; - float _521 = fast::max(in.input_eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; - float3 _448 = mix(_439.xyz, _30.sceneFogColor.xyz, float3(fast::clamp(1.0 - exp((-_521) * _521), 0.0, 1.0))); - _324.x = _448.x; - _324.y = _448.y; - _324.z = _448.z; + float4 _268 = color; + float param_1 = _input.eyeDepth; + float3 _278 = mix(_268.xyz, _30.sceneFogColor.xyz, float3(EnhancedFogAmount(param_1, _30))); + color.x = _278.x; + color.y = _278.y; + color.z = _278.z; } - out._entryPointOutput = _324; + return color; +} + +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _214 [[buffer(0)]], constant SceneLighting& _30 [[buffer(1)]], constant DynamicLights& _64 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +{ + main0_out out = {}; + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + _input.color = in.input_color; + _input.fogFactor = in.input_fogFactor; + _input.eyeDepth = in.input_eyeDepth; + _input.worldPosition = in.input_worldPosition; + FSInput param = _input; + float4 _315 = _main(param, _30, _64, tex, s, groundShadowMask, groundShadowSampler, _214); + out._entryPointOutput = _315; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index b4365b7c2fc1e2b81447962586347c7db97af781..5a2f1c9f6fcc79cfe7d8025260955eae64173bf8 100644 GIT binary patch literal 8812 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 C?w61N diff --git a/src/shaders/compiled/world_lit.vert.dxil b/src/shaders/compiled/world_lit.vert.dxil index 24afdec73dc2cca7cb7d31e49eb19186ec652a19..a266b6faed5175ca817c97709ca2cfabdf969df3 100644 GIT binary patch delta 108 zcmdm?u|q?|CBn&hBTrzf=6dlX9E_*8#jJd(yivrEO+@v$>oGRBW2(>CSX|ZGeAte^ vaeKBol5IMRz%0Hg2jmpE)=uq6y<_^J=k6x%6edQY$*H^n*fpKx&1VAux&SGj delta 108 zcmdm?u|q?|CBn(MKSa0P{LEM9;@6u+9+bkCc=8$bs3x6F;z7-7S}X2b$7L8 uZf=_+*`~7yI7!*O*tOR8Zn3bO$|Ifh`2~nr}741*L0FMpA7&jVkD^m diff --git a/src/shaders/compiled/world_lit.vert.msl b/src/shaders/compiled/world_lit.vert.msl index 7b0155f01e..ba77e07fea 100644 --- a/src/shaders/compiled/world_lit.vert.msl +++ b/src/shaders/compiled/world_lit.vert.msl @@ -1,8 +1,28 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" + #include #include using namespace metal; +struct VSInput +{ + float3 pos; + float2 uv; + float4 color; +}; + +struct VSOutput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float eyeDepth; + float3 worldPosition; + float clipDist; +}; + struct Transform { float4x4 mvp; @@ -30,20 +50,38 @@ struct main0_in float4 input_color [[attribute(2)]]; }; +static inline __attribute__((always_inline)) +VSOutput _main(thread const VSInput& _input, constant Transform& _32) +{ + VSOutput o; + o.pos = _32.mvp * float4(_input.pos, 1.0); + o.uv = _input.uv; + o.color = _input.color; + o.clipDist = o.pos.w - 1.0; + float dist = abs(o.pos.w); + float range = _32.fogEnd - _32.fogStart; + o.fogFactor = (range > 0.001000000047497451305389404296875) ? fast::clamp((_32.fogEnd - dist) / range, 0.0, 1.0) : 1.0; + o.eyeDepth = dist; + o.worldPosition = _input.pos; + return o; +} + vertex main0_out main0(main0_in in [[stage_in]], constant Transform& _32 [[buffer(0)]]) { main0_out out = {}; - float4 _151 = _32.mvp * float4(in.input_pos, 1.0); - float4 _188 = _151; - float _165 = abs(_188.w); - float _170 = _32.fogEnd - _32.fogStart; - out.gl_Position = _151; - out._entryPointOutput_uv = in.input_uv; - out._entryPointOutput_color = in.input_color; - out._entryPointOutput_fogFactor = (_170 > 0.001000000047497451305389404296875) ? fast::clamp((_32.fogEnd - _165) / _170, 0.0, 1.0) : 1.0; - out._entryPointOutput_eyeDepth = _165; - out._entryPointOutput_worldPosition = in.input_pos; - out.gl_ClipDistance[0] = _188.w - 1.0; + VSInput _input; + _input.pos = in.input_pos; + _input.uv = in.input_uv; + _input.color = in.input_color; + VSInput param = _input; + VSOutput flattenTemp = _main(param, _32); + out.gl_Position = flattenTemp.pos; + out._entryPointOutput_uv = flattenTemp.uv; + out._entryPointOutput_color = flattenTemp.color; + out._entryPointOutput_fogFactor = flattenTemp.fogFactor; + out._entryPointOutput_eyeDepth = flattenTemp.eyeDepth; + out._entryPointOutput_worldPosition = flattenTemp.worldPosition; + out.gl_ClipDistance[0] = flattenTemp.clipDist; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; return out; } diff --git a/src/shaders/compiled/world_lit.vert.spv b/src/shaders/compiled/world_lit.vert.spv index 3c1ff72a90575551dcde765d171356e0f61ab1a6..53a599369055e87ef1ed3a64e97bd8e597162b5a 100644 GIT binary patch literal 3908 zcmZvd+jdk%5QcY1CI^X}Pb%O9M50KP^I3uf5;Q^}fV!5VLo$KUWM-U9Kom8KB6{U( z_zFIk7vAXd`}TAtBVlL#>H4ewuI{d`y{B{4?w%~`$W~{)*>73vS)Z-KlVy%Y#?@JO z&PT^5$A{*d(?f@kyrptY*6EPP)@EySyNmyGrAk$D3)}`XKt}^CfCu0qSOkwjCw~RT zzgV=8b@8{HL;f86=H#VneWA%tS{zqaugx!U_q%W}gBNoBD)>}ww&t1z{`whjPF`7P znuNzZ`g|gfygiS+Jx@2Y^m*!;+MSD~sb-!({O-H_pgdBpH}7Ji?#cC@?S8E>J3UdG zuQV$)YY}t0v8QG$^^wYazOMq+wvxjZad5ubSeR<=Plw-sZ{`p<2o4`O)vDDRw3WOv z^3H4nyaqh;PR8qvQgwc&)|kWg%=&!h?$z@>$UQUXnQWFCsWz>-o*n;%>a=rPzI679 z5wk`~UTTy)Yk_{Y&co$uv+-b}R;e~ym%p@DZ{Ck9*6!_`TveFm+#8TT+7`v%6)jB-rHE)UE7yqR3z@6 z7d~6}ly5iOCv^6NzTq~XdG(F7`RoUMV_=jui;M%nC-^RG^T}^9#y;e?6OXue9cM7^ z9j*pGa^L6n`F>C2G2d@X`+UDMa`)-{#l)?N+?tx-_(m${83$l;?JZc{j76{&y|t4Y zm-i;FR^FGm`FB!tzg^BzXRL_E_4FCriPvw6vCx=b#99N)c^g8t`%_Wa~ z=dsnx^iOaO19@TF2CIt z_Z#Va>ttL$lYGwio93P)F8AGtbAOra$S?O@F>XHfzAK^sD%qajxZHOq^m5;w(0`xo zIG=nm`K*Wc@CbN@?eL!%&8^S<|IBDE{jMi}oP0;AqIYC%eboJpr@*Mzp7*yS)?SZY zY2(KI_8UKg-tkjl{m+rb-v11k!*}9sR*%*sy}hemu13A@`4_;rG50Dz!Cc?pS>SKJe&e1^U*z`pT%UW7_3POB)!PU1*t@@_ z>fL*s&mVUE>g@}8w{PU?eZRg2>dyo9-t#v=zk2&f9{O*w)%*U0 z{yS{_>K`)7)q7Vz0QEP3`X0s~fqwOiiAVll;OhNOME)n(`qkLWzXJO$?q9CvA3F9p zum`;h@4?6K?J?G}x7GmraUG-mX#Z^h?n`b>jz7guCmv_o0yj_Gp>wwa{a0Dr8orQx z3`@Qjlh5}mbT1{J@5}_d=wsXtoUh*aHsIO=jJrS)#M(QscLV*uqjCN#z#RIWXHUNh zJZIEQuFm)%<7>b(?FH7om+^I=KQ#NW&7sD-ldFj}_G6o)z4wOT`a|<3wmH<8L$2l= zRkQYoLG1G&cJ#oJ6nn&et?yBwFKXl5W5Bugj=AOPBKHaGXXQSL-&jAH&3y`ZM_s^} zx$Fu3p5sjJYu!Vf)p=)=KQzPeB8Zx*IR}P8oZ}sA=jnGHdre=QdjwnGpR9Y4aTMsg z0Aign>>_C2%O$w}$n!3?XNYy*!&aj|G~?K=^(58!eQb65`{@Yxe+6^^@80-j;2r#t zYBz!H9@Vwq%~iOy_dDY`anKUarQt-<6xdUbCOg(Zl!w&>xx) ZvCZMP#~gAs>iZc#0>=O4d!X&N<3D{8L;U~% delta 718 zcmZ9K%_~Gv7{=eZW6WTN8k7yLuo^2i7AWOo%fi-YQ5F-*g48G*OXe81rhJW%jFs$+ ze?s{uWUKt1ac@ngem&25=DhEF&goXV_S31T*BdvBSd%5}{Ww){ACV2W>y1PcmUTp6L>jb(2%fY$< zU4vDawV2hT$DkVh!Yq$h7OBZxka_3~ljxPR6BcTq0&VDkaT@oa1@NH_bhu9R6qFya zM~68B^-w-$(duQCsmBod2D;!NsD}=G4$2QK_jiM05Qf85Sb_hA7eSt+jT&8oZdeEU zPeVu1EAT<@9S*(5D-ZYF;C)v}wd6`Ttq!PG*IUqT Date: Tue, 3 Nov 2026 23:31:53 +0800 Subject: [PATCH 09/17] feat(render): the sun casts real shadows Enhanced sun shadows: the scene's solid draws are drawn once more from the sun into a depth map, and the world-lit ground and lit models sample it with a 3x3 comparison filter. Shadows now fall onto slopes, walls and other characters instead of being flattened copies on a plane. On models the shadow takes away only the direct sunlight, not the ambient light. Each draw keeps its recorded matrix: the sun pass multiplies in sun view-projection times the inverse scene view-projection, so nothing is recorded twice. The map covers the ground the camera sees, snapped to whole texels so shadows stay still while walking. The sun stands opposite dynamic.shadowAngle, as high as the flat character shadows were long. BMD, skinned and glTF draws each replay with their own vertex layout. Characters' see-through parts (wings, capes, auras) cast a partial shadow: each texel covers the map with the chance of its alpha, or for glowing parts its brightness, and the filter turns the dither into a lighter shadow. Skill effects cast none. The characters are drawn inside a ScopedCharacterDraws, which marks their draws apart from the world's objects. The lit shaders' sampler slots: 1 per draw (the normal map, or the ground's shadow mask), 2 the sun shadow map, bound once per pass. With sun shadows on, characters cast no flat sun shadow; point-light shadows stay flat. Works with anti-aliasing. Look.json: sun.shadow (1), sun.softness (1), sun.resolution (2048). Console: $sun. --- cmake/ValidateDxilReflection.cmake | 5 +- cmake/ValidateShaderBlobs.cmake | 1 + cmake/ValidateShaderReflection.cmake | 5 +- docs/enhanced-look.md | 8 +- src/Localization/Game.en.resx | 18 + src/bin/Data/Render/Look.json | 5 +- src/shaders/compiled/skinned_lit.frag.dxil | Bin 10676 -> 11936 bytes src/shaders/compiled/skinned_lit.frag.msl | 115 ++++-- src/shaders/compiled/skinned_lit.frag.spv | Bin 17240 -> 20744 bytes src/shaders/compiled/skinned_shadow.vert.dxil | Bin 7056 -> 7188 bytes src/shaders/compiled/skinned_shadow.vert.msl | 240 +++++++---- src/shaders/compiled/skinned_shadow.vert.spv | Bin 7568 -> 12480 bytes .../skinned_weighted_shadow.vert.dxil | Bin 8728 -> 8860 bytes .../compiled/skinned_weighted_shadow.vert.msl | 331 +++++++++------ .../compiled/skinned_weighted_shadow.vert.spv | Bin 11324 -> 15104 bytes src/shaders/compiled/sun_depth.frag.dxil | Bin 0 -> 4896 bytes src/shaders/compiled/sun_depth.frag.msl | 67 +++ src/shaders/compiled/sun_depth.frag.spv | Bin 0 -> 3312 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 7520 -> 8756 bytes src/shaders/compiled/world_lit.frag.msl | 77 +++- src/shaders/compiled/world_lit.frag.spv | Bin 8812 -> 12112 bytes src/shaders/skinned_lit.frag.hlsl | 47 ++- src/shaders/sun_depth.frag.hlsl | 44 ++ src/shaders/world_lit.frag.hlsl | 35 +- src/source/Core/Utilities/FrameProfiler.h | 4 +- .../Core/Utilities/Log/muConsoleDebug.cpp | 2 +- .../Data/GameData/MapData/LookProfile.cpp | 3 + .../Data/GameData/MapData/LookProfile.h | 3 + .../Render/Lighting/DynamicLightsSetting.cpp | 10 + .../Render/Lighting/DynamicLightsSetting.h | 4 + src/source/Render/Lighting/SunShadow.cpp | 84 ++++ src/source/Render/Lighting/SunShadow.h | 49 +++ src/source/Render/Look/LookTuningCommand.cpp | 3 + src/source/Render/Look/LookTuningCommand.h | 3 + src/source/Render/Look/TuningControls.cpp | 6 + src/source/Render/Look/TuningControls.h | 3 + src/source/Render/Models/ZzzBMD.cpp | 2 + src/source/Render/Renderer/MuRenderer.h | 23 ++ .../Render/Renderer/MuRendererSDLGpu.cpp | 391 +++++++++++++++++- src/source/Render/Renderer/SceneLighting.h | 15 +- src/source/Scenes/MainScene.cpp | 6 +- src/source/Scenes/SceneLightingSetup.cpp | 24 ++ src/source/UI/Options/TuningRows.cpp | 6 + tests/data/test_look_profile_json.cpp | 2 +- tests/render/CMakeLists.txt | 9 + tests/render/test_look_profile.cpp | 5 + tests/render/test_scene_lighting.cpp | 2 +- tests/render/test_sun_shadow.cpp | 107 +++++ tests/render/test_tuning_controls.cpp | 10 +- 49 files changed, 1467 insertions(+), 307 deletions(-) create mode 100644 src/shaders/compiled/sun_depth.frag.dxil create mode 100644 src/shaders/compiled/sun_depth.frag.msl create mode 100644 src/shaders/compiled/sun_depth.frag.spv create mode 100644 src/shaders/sun_depth.frag.hlsl create mode 100644 src/source/Render/Lighting/SunShadow.cpp create mode 100644 src/source/Render/Lighting/SunShadow.h create mode 100644 tests/render/test_sun_shadow.cpp diff --git a/cmake/ValidateDxilReflection.cmake b/cmake/ValidateDxilReflection.cmake index 30b0bcb16d..7353012743 100644 --- a/cmake/ValidateDxilReflection.cmake +++ b/cmake/ValidateDxilReflection.cmake @@ -25,9 +25,9 @@ set(shader_specs "skinned_weighted.vert|cb0,space1+t0,space0" "skinned_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" "skinned_weighted_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" - "skinned_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+t0,space2+t1,space2" + "skinned_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+s2,space2+t0,space2+t1,space2+t2,space2" "world_lit.vert|cb0,space1" - "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+t0,space2+t1,space2" + "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+s2,space2+t0,space2+t1,space2+t2,space2" "shadow_mask.frag|-" "post_fullscreen.vert|-" "post_bloom_down.frag|cb0,space3+s0,space2+t0,space2" @@ -35,6 +35,7 @@ set(shader_specs "post_composite.frag|cb0,space3+s0,space2+s1,space2+s2,space2+s3,space2+s4,space2+t0,space2+t1,space2+t2,space2+t3,space2+t4,space2" "post_ao.frag|cb0,space3+s0,space2+t0,space2" "post_ao_blur.frag|cb0,space3+s0,space2+s1,space2+t0,space2+t1,space2" + "sun_depth.frag|cb0,space3+s0,space2+t0,space2" ) foreach(shader_spec IN LISTS shader_specs) diff --git a/cmake/ValidateShaderBlobs.cmake b/cmake/ValidateShaderBlobs.cmake index 501e67cfa0..cdd8f299f8 100644 --- a/cmake/ValidateShaderBlobs.cmake +++ b/cmake/ValidateShaderBlobs.cmake @@ -29,6 +29,7 @@ set(MU_SHADER_STAGE_NAMES post_composite.frag post_ao.frag post_ao_blur.frag + sun_depth.frag ) set(MU_SHADER_BLOB_FORMATS spv msl dxil) set(MU_SHADER_BLOB_NAMES) diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index dbe131eb94..51bc89fbb7 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -288,9 +288,9 @@ set(shader_specs "skinned_weighted.vert|vert|0,1,2,3,4,5,6,7,8|0|1|1" "skinned_shadow.vert|vert|0,3,4|0|2|2" "skinned_weighted_shadow.vert|vert|0,3,4,6,7|0|2|2" - "skinned_lit.frag|frag||2|0|3" + "skinned_lit.frag|frag||3|0|3" "world_lit.vert|vert|0,1,2|0|0|1" - "world_lit.frag|frag||2|0|3" + "world_lit.frag|frag||3|0|3" "shadow_mask.frag|frag||0|0|0" "post_fullscreen.vert|vert||0|0|0" "post_bloom_down.frag|frag||1|0|1" @@ -298,6 +298,7 @@ set(shader_specs "post_composite.frag|frag||5|0|1" "post_ao.frag|frag||1|0|1" "post_ao_blur.frag|frag||2|0|1" + "sun_depth.frag|frag||1|0|1" ) foreach(shader_spec IN LISTS shader_specs) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index b90e153c16..d9510d8d1d 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -86,6 +86,9 @@ window. | Dynamic lights | Map-light smoothing | `dynamic.mapSmoothing` | 0–2 s | 0.05 s | 0.5 s | More settings | | Dynamic lights | Maximum skill radius | `dynamic.effectRangeMax` | 0–16 cells | 1 cell | 8 cells | More settings | | Dynamic lights | Shadow direction | `dynamic.shadowAngle` | 0–360° | 5° | 135° | More settings | +| Dynamic lights | Sun shadows | `sun.shadow` | 0–100 % | 5 % | 100 % | common | +| Dynamic lights | Sun shadow softness | `sun.softness` | 0–2 | 0.1 | 1 | More settings | +| Dynamic lights | Sun shadow resolution | `sun.resolution` | 1024–4096 | 1024 | 2048 | More settings | | Darker map light | Mood strength | `mood.strengthPercent` | 0–100 % | 1 % | 100 % | common | | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | @@ -215,6 +218,9 @@ for the whole file. | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | | `ao.strength` | 0.8 | 0 | 0–2 | how much screen-space ambient occlusion darkens corners, wall bases and the ground under objects; additive effects are left alone; not drawn while anti-aliasing is on | | `ao.radius` | 60 | 60 | 10–300 | how far, in world units, nearby geometry still darkens a surface | +| `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | +| `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | +| `sun.resolution` | 2048 | 2048 | 1024–4096 | the sun shadow map's size in texels (1024, 2048 or 4096): sharper shadows for more graphics memory and time | ## Developer commands @@ -243,7 +249,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `, `$sun `, `$sun softness `, `$sun resolution `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index f9795ed24b..9f4845de5d 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1219,6 +1219,24 @@ How far from a surface nearby geometry still darkens it, in world units (a terrain cell is 100). + + Sun shadows + + + How dark the sun's shadows are. Everything solid casts them onto the ground, walls and characters, in the shadow direction. 0 turns them off and draws the flat character shadows instead. + + + Sun shadow softness + + + How soft the edges of the sun's shadows are. + + + Sun shadow resolution + + + How sharp the sun's shadows are: 1024, 2048 or 4096. Higher costs more graphics memory and time. + How much of the map's colour grading applies. 0 % applies none, while bloom stays on. diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 067c2a52ef..d4aaa6dbfc 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -23,7 +23,10 @@ "bloom.levelFalloff": 0.6, "grading.strength": 1, "ao.strength": 0.8, - "ao.radius": 60 + "ao.radius": 60, + "sun.shadow": 1, + "sun.softness": 1, + "sun.resolution": 2048 }, "maps": [ { diff --git a/src/shaders/compiled/skinned_lit.frag.dxil b/src/shaders/compiled/skinned_lit.frag.dxil index d27302d795522266efb2d44aaa7218805aac770e..3f88d3c866d2673a9e5767ad2a35e1c50510d2b0 100644 GIT binary patch literal 11936 zcmeHtdsI`$_wUI&7fqe(6-eJMxbAG~ZkPrm1CLss|w(51vuL zl#mgmlm>VL1Stg1Vr8C$31mddTRbn>3iLRDLGVow3?!IQd=!H4{W;7U{c=b{xlfN! z^vglBzC_5W{xZy9eL|g(Gl|Cia-s<+hgkeS7y#=Ncu)=>2JE;$K{@EMFF_g9{j;1t zF80-hx_`ze;9z~I`)4^}uCHw%|1*97;K2mtQ1{RESx^WPltW!YzIf@2s&yOJRIXXK z7Fja4F#GAJ7v(^`r@=g>fgFwt(RLgZfFuJC#DR$zCV;b~Xv6B2m4K&Oyi}416kz?o zO8*22@;M}gMT|S4R|*JdpAbB79*A}TiE!ZyB!Um?!spL?D2EThhdQuKB%Yrj_yo?M z`2-HZhqn9?hoA{Qf%9iRfkW`iVf#-8`~MwLQM6_)Y>EwEAQAnA_Cgii zO%f&BS55*nY@b9OFQ)?<+CriMJOC^MG_;FEAIHxFG_;Y#7}s9}XlO5qIWB(=&_0_2 z#>=4SOTc~<+VSTE{g&`uUpt@-=Lgyd+krgd0pt@J@?aul|DF85qrZ5Ge2E)4EDn?_ zfx$V2dHHaF;ar>nd_}hXrWkCRF9R7{hxu%UW6sbo=5CUKGnvK=okZPH ztP##7D|WLLE;J=LgDG6VN+~wwT7t1`rRf+FnxYuYnkfXs&#aQVsERG_J zJK3MM;&;Ow!{CR8lRZ_rXnHWo8r4=9H)dsSzaqN6=AI?RgNBwm@y8#QS?l!YcTrsPNohsDb%iP z)uul6Bf-z;?#mTR+I($B0SwlIK)xKGN-q}DgLXVXY4W%n9+eY~I`b{MPACQadqphb(<`VED57(bDi4CkRp^> z!xYIdCFWqravkVE1;xHiYg#Risv^gdY1AuU=Pk|& zc;hm;_XHYvN5V(NyT7mrB!O{Q_unSK^&tq}V6Ush>!f9M)nybwb3at^D%`v+;EnLN zNEjQejExwh!opim5Ss~NJ!NRy-$I5G;YgzFiK1jstMMHzP=a?ylSsr~XSdXm z$v9+#q!HKCs4^c3UfGj4Obt;m&PGw6^Fs!wI&FL|TwO9U@t`&^14VA{||eD4+)ja)^;Z*2;E$i}-#SyS@cKKtlpZ ztHF9d4eSl0%Ff9{bn4t#V?Mp>o^mL5Wj30RnpW#% zGLb>+!B8sgOnU%1utLZ)G+{0B2(>lAc>qJNQngJ|X3hz*xUp7DH>#V?oV)OGZQG1m zM@253R&3OY!&5fCvUYJ8q3W2m?Vz>k0?5)2|FvFWZM^(urZ-zerEQO1sgL#i(k=8-KSm_X5cyr<5jyc z?(($OX%*(F_c=S)uGPs_h|tbolU5-V+-Z5GNFr~cWZ{z2Byp#PBP_-c>DqN0DvHV% z7geasS8fnlia5QRP&&B@>z7BO``_DmK*5fF_0t2am-QtHZ(P?%$}DtFD#vbY=3J6- zrD!lle_0|gq-0u)f38|O7!upLR4J8Xwg7TN0UA8Zqrujy1J@ypf^apfM4!!$o_|2Z zej_?z16xp%5DkpKMyKx6@8I1;c>6P~f=+r}h_W_znY8ZbPKa}g%PeMm9dTCvg^TpI zM4E9@^6u&8^iNaTZ6`hoAUi5#mf2@UyUS?`K_ZIhD+qnw`sA-)}rg6}zfweCO-?WNpz+8NTim}uim1F1HY3&VpwGGF< zyjY<^m!0{=%iSN#%hmFPf7B&xmw2q0O?|#YlvWUKAxD%;?AU~*%@babhr}}1Y8VHH zI(zzinyy}Q-!)ww?CHFF^=7{m%bm8uB}zLgW7Pbo*m%=(b5I)BJ#EEn!}J0H14v7| zulDwSKh$IVe(+w8G%h!3#SubOK6v$-wPUd3TF>2{!68sBX@$pcf@;4$LG)e;`wczo z4fe|kM-tvR04BKDCYNs+7y%={KLex9!c)_i4lP|ZS|uIr{5dvVj&y`mBfFHXRG-!*E+8DpUGeT8Zp5I=yqun7QEIb z#$uW0MfoTz!(&5#vGE_f`M*oXC=d8Z;JZ<+&3~UV^>Bb9kRdYs$2A*A+{XW>n;(^I zat-sN+r+|HCN-=aO?ty)lR%LwC@Oi3@)Lhbn;4H})`piCeqiy`y`CG;AY4+61^`1U z&<~273I=Qf~$4{qkML(Cg0$Z-9-okP@d(3@Wa=L!w{B<1Y%)9LNfkXP2Mt=uSTIU%H-%w>OE$Ue1M ze@aL@ZPlMH^A?+S$dhhbS)v2aA6O8!e4pq>Bi5oY-YH%doBrm{L(<9Ee#=0+r?%~z zJr@cBw$CcvoU{?_{VO*VtSenvzLRJi&5Vsr>p4RR|2_!mG`v)f zVp4}A;!<yTE<8( ztJ?tHnmV0|+9Uw240q^M3I19@=^LB$VRr=J3Jh z@Lu1$zbL#%9PZLa^c2y*vSiQf&Ys!id!KP;G-hX*D4C7U>7dcay39UGrp?K5i5WF& z%9gmgDotHzkCS%~=im3z?+x>QMEI#urto10w_6^5$-%uR4jDwr zvd(BT0KUOF3li|2upS%#Mr1^|Z~i!Yt0qlmcyzwv06A^NXFrXRt|Ea$(Wfgo*VT_M zeaj|26P&YTmR%J@$MCJ|ub;BPDxaaMx$>N26wc%#gbbB=SAEKXr2HIanp5GCr9vo5 zRDdkaqxI4H)El6Bhy+&u{T8D4%h7}heKP4Jo>_0VG?Yx~?Kb-`E-SD3p zbLJ+d2F?VvR>^#gQYDuann1}IFjY1K;$I!iq0TSh&j7|hr}r5z2rOWtMWD*kVGd|0 z>r2oV&+#^=`M35)6~H^5Of-JybAwydAMbo| zfKS}{x`6Co_Re?r-*>)$U{S(E4a@Mg(B~+M(!RWVKs>}Wbm_`w^|d8G6yqwUicfo!TAY_?~MBl zwEKT>k88rvEA%2soc&?}%3R~r#JH$(Zm-7fyTlpV#Nv?SVxv(ljd6CQIo;?bQ-%l(nT2|8u7IBZ1&3lQ8neqdQZ&fD(*a^h z51y?8ASCQc$ljsOl|A3HzpqHz3By{QszzWSbEH%kwVA08P>4Y|7sc(vxgIOmD8>2_ zO!16i#^`9w+%$O{h_q!3MSDrSK0DWg@r)V5ei=_nbyBrCX9%xZ z*Hbb*Xqv#F<46;O!&|f>uRNSnEpd?~a_l26>0`Oo$o+hhT^n|W6zOtU7|yU!2UY8q zQeOoMr?}(^EYaSlG?W=?ipr!f;>M+;wOmJJd0`N20;|mseueY@vkuZ-Jo z4<5nG^iQcNnP5cwjaaZWu?1ngHC3g)v#PBI(nqwMvPliC4#l}%f%pLvEdXIQ^5u6D7C zwsbRXIi9le;oJ$ao0clm<#9c@Q{mQy^^rwq9B#TnHQR2y#c?AOyAiCj zbJf>F9Y6m}zq9C0?EmcS98&C+P6YSfQ(|}R1oHHIiV0Hbr_wjmK1xadWU5?M%ej0W zTw>sC&6lN#og3TOB`3huC`kB9_wb4#cSm>6;QpK4J)Yy#ywH@{6Wc#(KRv6x?W6Xo z4q+cuUy$(Wf~W(B*+&u%1U1SdQf9xIl0K__cFXCs^iSHSlE4RN_#NZlG2Xvpy#Jdq zUJ-^MFMvN92&h|7HpnBv{(7{}&O`zyFOkun5#C<5d2X00iMIGSsWwbPQB~bunlgEr zj&%MRK>;nZCx*&ece~U;>>{>z{Dj= z1bnjoXNQmkK3zZF8E6|i@a>nr!tWOmGiVt>qUiyM4wumnW9{QmDCO z6!2Ijl41*jG3li;R&cmU7iV#pLDmnph9KRx;+NcX901kFM!#Jj5 zttJ38EKj((BhLB+AilIx!)mcS0eIK?B`Myj3mXT}YS~sB;~h2QAL9)Q+fi1Hl~slK z_3^v9xKT&ESMIl1+r~cPWwhEE#r_8A(=FtUS$*}z{L2!ISLInmV-d5{1Yu&~-N_Err6VA98TcO+^QgvH6c_cW}N80#eh zV5UtG-=~OcB>--_S?}WPBX$CyNuSW#G3}s2dD!o{RuE zqo3B-G5w?>!VmC(cN%AV?W`&SV79konn9n?PXIiyu-h@7O+x^5>ytFj43}b(A0V0k zDaso}*josIIm6)Njy~}o0r1ex{ubw*vJ(Iv{dB8yW}hOG7z6(Qu<-86*jpvV!_e_m za~eBBEn2kI5q30t)?-JQIhJZK)1l^APDdFznKRGi5HbIub}<;2mMN?!IC6nmC6sIt^^4`Y#{98#9lOs*-%Xk#7;V-Nfpx4r3FT355Qj2BFYeBfsFH=` z0xB$cawNqzH~=99k9Cowq{uOO3IUR{cSa28H@P>Nsj+%VttrBH)WCHf633YX$d0EGEN0P;+`s713 z=0}4i9AS4?*0Yv+S}7J;LVnZ~)!k*0XMOdSwx%_k@~H4l`bgVKO+AfKV-|Z$NaVqHQRFh0vKwP6)ua@7{R`+4lM{!!pKr9az6Y0jzJF?6>}cv_@gWV+Kn) za)ARhSS}|zQotm!nqt5tHJkE$g?%w0i6d=AppWvJ-m<|GT1=!sHztg_&=s7Q6-#}P zYy=(4pWfXie9=-r^))Oq`>`x*)nhREBE}<+k~h-!e)wR?1tgNq8*5V7yU5h6Q^CV+ znD(;C0XN&ip9UtLM}xCLN6*%Rj!Fvr9liS6<64{)6)E67^5EU8_gX{m3SCr5-TCk) z?JjvfvazsN`$v{`2~xRSxXN0BO^`hwVg#aG8vbT&k$)t9;eRP%b;OwlO!#!*u#RfN zVU?vbsO+FeO%^Z)Iaw#Dm%-#^{Bjjeo^$#|Sor;_e`0E*P9%pE2Zof0LyD5a11&~i zuWX^;-k=?BBd%QzCguc~m{nphF=b#bu)WoAVm9ns4GT@xesi`5-n1vNlWulQGe!?~ z%rLC;ds^s&ou9v(^j_F5<_peDgbW-GedJMx z4Yv)Xc}tvYfUkQIu)6KC{Go59rKM?NL@6-fX+@|~U@G#-OH-7)YnL`l+G46nEDRhII-*9}LIQ53h9|c$A8_X}6BIR*shOW^ zmOIpj2T>jA;S24i;XUX*wJR#xxlC(2!SPHm$Btp4zpvytd%z6$2tn-VC>oyUVUp=e?8@R+%$TOjj&qg9C zdKQ=!K6D|+jzdSc?OWp5-~R)(zeAbHwC%6bZSfe z?K~8$nR06}D%rAM$>D+h3*n3%d*;^B7XWlonjA4VF&-6S-K*1@nfY)O)X*I~7tYMb zdsE7a)%uO7%Wy8 zzSwL2UamXP_BNtKnT4*WC~1R>PaVSS2l*O+wRz)G1u zjmhDhA?(?kr52cWzEc3~k^WNXmJ;>^Y#oZVodocXDUs}M1e`Z(Kw!iy!`R?5F@C`R z_W06_adP)>nx|98$*aE^E=v|z>EL8;pr671w>+B81|y2!=6~nzs_E|9(lT!g5i36R zBM~5=EhpAxG32EF3W`%qu@UsEtZ^DRy_hjzn#u*wt5io{yM4VbK`nc%8 z#|sY(n6OvC`K#q#!~Cv4)wp4v&07J&kn7+GJ`J`9xd=EOUF7Kx^W|QDez!l&qlp@B zBhB@eP_{n_&cdVKmNV%vID2Ux@QZ#gmpIzDwA4`9oJUP~cNaYy4D~t~gRb>fRrqpb z(|C@7e7}w6AHkgszmDbB4>OaQe$U(&$N@5+zrNM*8#M$argG{|&lDSf8VKt!zxN>e zl#e2B1RjAqd;zMvVvySum4hWDab%`)URFr(NSgr^wIDPgX8`wUOt;UO0dh;a+n1Zu zy>n*RR9M8L!Z^#Wn#ADTd0DF%l$u^1SU3@!;Wn|ho*Ph8p6e}nSC9$J$N-0k{)75w znOld;(!@feh&+d^Uv8Xf0wX_un0xE-vaLS@A==Bl<#(k;@!zHbQL#i_REB7OV-LcY<0a zai?T#@Vd03KCQ^D6@mMmZx^pTnWLOC3aXL-t_$K0I{p*)RHZV(0E7+@?(|teT;`Qe zdeUh7QDsuv0(inb6uA6xjzm4{2v(;QFdbxhRtR;Z4ciGk+qVLPX1%`@pSI^tyeR;c;>k;GVky9UopqUg6Y5m;inA0__swu WT*evyAI<0J2dk?{zRw-L*Z%_OHZy1d literal 10676 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 sunShadowMap, sampler sunShadowSampler) +{ + if (_123.sunShadowParameters.x <= 0.0) + { + return 1.0; + } + float3 lifted = worldPosition + (worldNormal * (1.5 * _123.sunShadowParameters.w)); + float4 clip = _123.sunViewProjection * float4(lifted, 1.0); + float3 ndc = clip.xyz / float3(clip.w); + float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); + if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) + { + return 1.0; + } + float2 _step = _123.sunShadowParameters.zz * _123.sunShadowParameters.y; + float visible = 0.0; + for (int y = -1; y <= 1; y++) + { + for (int x = -1; x <= 1; x++) + { + float3 _276 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _276.xy, _276.z, level(0.0)); + } + } + return visible / 9.0; +} + +static inline __attribute__((always_inline)) +float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _299) { float3 light = float3(0.0); - uint count = min(_163.dynamicLightCount, 32u); + uint count = min(_299.dynamicLightCount, 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _163.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _299.dynamicLightPositionAndRadius[i]; float3 toLight = positionAndRadius.xyz - worldPosition; float radius = positionAndRadius.w; float horizontalDistance = length(toLight.xy); @@ -109,8 +139,8 @@ float3 DynamicLighting(thread const float3& worldPosition, thread const float3& } float falloff = (radius - horizontalDistance) / radius; float3 param = toLight; - float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param)) * (1.0 - _163.dynamicLightWrap)) + _163.dynamicLightWrap, 0.0, 1.0); - light += (_163.dynamicLightColor[i].xyz * (falloff * wrapped)); + float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param)) * (1.0 - _299.dynamicLightWrap)) + _299.dynamicLightWrap, 0.0, 1.0); + light += (_299.dynamicLightColor[i].xyz * (falloff * wrapped)); } return light; } @@ -141,14 +171,14 @@ float3 RollOffHighlight(thread const float3& color, thread const float& knee) } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _117) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _123) { - float scaledDistance = fast::max(eyeDepth - _117.sceneFogParameters.x, 0.0) * _117.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _123.sceneFogParameters.x, 0.0) * _123.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _117, constant DynamicLights& _163, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _527) +float4 _main(thread const FSInput& _input, constant SceneLighting& _123, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _299, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _677) { float4 texel = tex.sample(s, _input.uv); float2 uvDx = dfdx(_input.uv); @@ -159,10 +189,10 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _117, constan if ((normalMapScale > 0.0) && (_input.tangent.w != 0.0)) { float3 mapped = (normalMap.sample(normalSampler, _input.uv, gradient2d(uvDx, uvDy)).xyz * 2.0) - float3(1.0); - float3 _334 = mapped; - float2 _336 = _334.xy * normalMapScale; - mapped.x = _336.x; - mapped.y = _336.y; + float3 _462 = mapped; + float2 _464 = _462.xy * normalMapScale; + mapped.x = _464.x; + mapped.y = _464.y; float handedness = (_input.tangent.w > 0.0) ? 1.0 : (-1.0); float3 param = _input.normal; float3 param_1 = _input.tangent.xyz; @@ -182,35 +212,40 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _117, constan float3 view = SafeNormalize(param_9); float3 light = _input.lightDirectionAndSpecular.xyz; float lightDot = dot(shadingNormal, light); - float luminosity = fast::max((lightDot * _117.diffuseCurve.x) + _117.diffuseCurve.y, _117.diffuseCurve.z); + bool inWorld = _input.worldPositionAndDynamicLights.w > 0.5; float3 param_10 = worldNormal; + float3 litNormal = SafeNormalize(param_10); float3 param_11 = _input.worldPositionAndDynamicLights.xyz; - float3 param_12 = SafeNormalize(param_10); - float3 dynamicLight = select(float3(0.0), DynamicLighting(param_11, param_12, _163), bool3(_input.worldPositionAndDynamicLights.w > 0.5)); + float3 param_12 = litNormal; + float sunLight = inWorld ? (1.0 - (_123.sunShadowParameters.x * (1.0 - SunVisibility(param_11, param_12, _123, sunShadowMap, sunShadowSampler)))) : 1.0; + float luminosity = fast::max(((lightDot * _123.diffuseCurve.x) * sunLight) + _123.diffuseCurve.y, _123.diffuseCurve.z); + float3 param_13 = _input.worldPositionAndDynamicLights.xyz; + float3 param_14 = litNormal; + float3 dynamicLight = select(float3(0.0), DynamicLighting(param_13, param_14, _299), bool3(inWorld)); float3 diffuse = fast::clamp((objectLight * luminosity) + dynamicLight, float3(0.0), float3(1.0)); - float param_13 = _117.diffuseCurve.w; - if (RollsOffHighlight(param_13)) + float param_15 = _123.diffuseCurve.w; + if (RollsOffHighlight(param_15)) { - float3 param_14 = (objectLight * luminosity) + dynamicLight; - float param_15 = _117.diffuseCurve.w; - diffuse = RollOffHighlight(param_14, param_15); + float3 param_16 = (objectLight * luminosity) + dynamicLight; + float param_17 = _123.diffuseCurve.w; + diffuse = RollOffHighlight(param_16, param_17); } float facing = fast::clamp(abs(dot(normal, view)), 0.0, 1.0); - float3 rim = objectLight * (_117.rimParameters.x * powr(1.0 - facing, _117.rimParameters.y)); - float specularStrength = _input.lightDirectionAndSpecular.w * _117.specularParameters.x; + float3 rim = objectLight * (_123.rimParameters.x * powr(1.0 - facing, _123.rimParameters.y)); + float specularStrength = _input.lightDirectionAndSpecular.w * _123.specularParameters.x; float3 specular = float3(0.0); if ((specularStrength > 0.0) && (lightDot > 0.0)) { - float3 param_16 = light; - float3 param_17 = SafeNormalize(param_16) + view; - float3 halfVector = SafeNormalize(param_17); - float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _117.specularParameters.y); - specular = (_117.sceneLightColor.xyz * (specularStrength * highlight)) * objectLight; + float3 param_18 = light; + float3 param_19 = SafeNormalize(param_18) + view; + float3 halfVector = SafeNormalize(param_19); + float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _123.specularParameters.y); + specular = (_123.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; } float4 color = float4(((texel.xyz * diffuse) + rim) + specular, texel.w * _input.color.w); - if (_527.alphaToCoverage != 0u) + if (_677.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _527.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _677.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -219,24 +254,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _117, constan } else { - if ((_527.alphaDiscardEnabled != 0u) && (color.w <= _527.alphaThreshold)) + if ((_677.alphaDiscardEnabled != 0u) && (color.w <= _677.alphaThreshold)) { discard_fragment(); } } - if ((_527.fogEnabled != 0u) && (_117.sceneFogColor.w > 0.0)) + if ((_677.fogEnabled != 0u) && (_123.sceneFogColor.w > 0.0)) { - float4 _580 = color; - float param_18 = _input.eyeDepth; - float3 _590 = mix(_580.xyz, _117.sceneFogColor.xyz, float3(EnhancedFogAmount(param_18, _117))); - color.x = _590.x; - color.y = _590.y; - color.z = _590.z; + float4 _730 = color; + float param_20 = _input.eyeDepth; + float3 _740 = mix(_730.xyz, _123.sceneFogColor.xyz, float3(EnhancedFogAmount(param_20, _123))); + color.x = _740.x; + color.y = _740.y; + color.z = _740.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _527 [[buffer(0)]], constant SceneLighting& _117 [[buffer(1)]], constant DynamicLights& _163 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _677 [[buffer(0)]], constant SceneLighting& _123 [[buffer(1)]], constant DynamicLights& _299 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -253,8 +288,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _527 [[ _input.tangent = in.input_tangent; _input.worldTangentAndNormalMapScale = in.input_worldTangentAndNormalMapScale; FSInput param = _input; - float4 _645 = _main(param, _117, _163, tex, s, normalMap, normalSampler, _527); - out._entryPointOutput = _645; + float4 _795 = _main(param, _123, sunShadowMap, sunShadowSampler, _299, tex, s, normalMap, normalSampler, _677); + out._entryPointOutput = _795; return out; } diff --git a/src/shaders/compiled/skinned_lit.frag.spv b/src/shaders/compiled/skinned_lit.frag.spv index b8bbc3eedcebea04eb959e2019dde8d75ffb4f97..16f2908e52e6de405e0994d6a1bb78b8b3d8f992 100644 GIT binary patch literal 20744 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 XA2rue%#C@B>+@h^`2TWZ|6lGuA%5PS literal 17240 zcmaKy2b@*awZ@MyGoV;s6f+E;aVpI^sE+`6C^fGgY86ED7cV;M7Q1L}$Ow;7W z-i?}K)YxLwXqtH@mYBqtW=S!oyr;3Zy#N24vzX0&<{enS{e9nBd+mDmIrq*TJZS8Y zEL$xbmJQ9$AC%?Sy4fI<46P+E_djIzArpK1+9vM0+l~gToej?8j9DjJFKeRI7FIfI zI*ujJJgkCMu@0;Y>&EI>Kehxr9Xks<2m2T~%|T~CgR^GJ*J+>`HO<{jKZoHvqPwfB zcV>J00i6pvy0E@+?K|y>Zu}aQr_`!d3iwcR7x9Eo>!{Rf)h>ev;@8H%sM6JM1?#Uv zIZ%J~Y~(=wf#w#q?^347>x>|#wY#gkUgp?fl^jE}P2l_0XuY-CHlusN)P>#swShi2 zXB*?MF0D?l_VjfC$vGt3oN{)hy?R)8ePN}m^R((X8!h@c3g1AVSI@SDPhVQAEbMGO z#Odg)Ey$yb8rEsawjgG4cfG4^R(Ee_UuUdI`) zTbb0k+J?AV-oK(>@;Zb7wVAYspT9_d33|>7BhyN-GV!mz~Git<_pJc00U<*;n`KUFlo7VEBjR ze)rOVe_DRmhR=P~*4f_P-&>v5Uti=fSJrcX)jJo?a=6vLYQ0#?qD}W$Z@C@PfXLgd z-#&5k7cCC-*F6`$kE-k5Yo*D0W#GnbX1DjFdpRE$P9J1u^SMmw&#JVwaW3H> zme+Sa)A}(w_Vy8#w$A>TU)yqi)7Y3p=iz#MUgBFQJ99iFyOWYLBtPoXobKEE@bz`) znXy$$fKCp)e zXRpGGv$iRFt-<#OJl5vT2H!jI`ItG^VzLKvHf8I=`>IQ-UAcd7HoV}(4$d|NJ9pL_ z4ennweF-$@TNZq2!CSI%#&$69+Jf>FGOjt>9z8#AO4U8KBU&v#>jw@U+t>?z;5={6 z_DrDu4~{oHSk-_Q=Dt$ZOZO!@ITnVA8O!_!rLpY-oDfyoIM8T zECdh9o&m?%H@mN%pF%OF=MrCNFQRo+y4vFzYkyusOULu_D!e&+#X9k>m(N#I_8!{6 zJ6ChI76%T;>ru7Nc6O=n4lTK6ySx|dSF6nDIZ~WY#!@}2boF#pxV>8|^|lD`%+}BU z!hd8(z1rK+-IdoZe4br--6OlFbuZ#*=7|{Xc~;Th?7m7pUt6E+=JOel_ao0!^v$y$ zEsnE%Zr8D4F6U(gxZ0LKZgYMhJe{Yb;RDa-=KS3|=M#N&mBpffBRNtem|c~;f1!obXIp~ zt#4+3pKq$>Y0A#U7wfS<_l0wglpTOq>@~J1R%-4$H9wa`oORSjCz^Xq%@17>=iXAA zl4$NLwONVgzEV3W(R`0k^C7)IefRxg3}%0VZvh@$@~bJ$V?Xs@vkD)aKf`0J*W&Xs zznA@0Gq;-k4lTy&yK-o@X`F3^7GwPw6>R@{d}A={2j2p0UAfOd{a(TKN4(F))Gtr{ zKDYE!*2JRj%K1pNSo`6L z7HdBm&3W)V83XnTZoh3q?&ozsU#wGdKfC++(o4T*h1|Z&JtyQ8Irn^!M?TL5x&1ZX z&;4@y>OJCj0Dk7yC)Q`5<=*#l_p01`TkhP*{mww{XD7MeAISa8B==sGd#z6op^V*c z6pH?C0J5#oxi#hO*p}LGqHSjkdCV`?H^%j(G)AtCBxb!*Gxuot`lV0ZI>M*@p>~=5wy)6HD&6M={HOCN)MqVvV;AO-)O&W7!eS zcC2qdccL^-eLUP8lQ6H~lXJFgpAq=yfJf)N@XO~m@OkjnFzf5DVnx5#$j{E`+rKOA zr{}PBda*rA?zyIBKNeAr#-bg$FKPDQ`o0(&E01wp41WB9i^gw{>bzWnO-jspz7+2M zh_$~Q?0h*6{a2RQ+%dkZz@xEE@q4y9E;acz2_HqKYvJayU*PT9JBoT zQnM|`cmw8T{Ed{xn@@fRrG2&ih`$RQW4Rk_eE6;RQ0b5OXW^@1!CwHo2RGu*Sr3Q( z)}LO%?Zf&dG1f82J-@v+ru7ZL#*HjBxp8vOZLdw}@y1|t7`rK@<8rS@zqUndPWS}4 z_jdSqf_wG_p9J?Ti9Y!Z@QSvll-zj7cwoV&1V1L{%N~k+OW@9B@blsJG5BS0_fgcp zGOwTQGm2jN9B}S6+lo@`+BoL5i7~&i_EGM6uNFB+K}O#5)E>qk1GWk48!z|#SJQt& ziJe3Ja-RqKBi`ph#J82$KIxbHe293t&xeRVrNrJ>#>;(PM7-SRMR5D)Ga}_aBZ3?6 zGa|V0J|j}@GeYk8mV@2rF@Cwv47Ew@6d+N>rS>+8`^Ua|_W8c;`UUs>Pres^a~=nG zKBrR4`|NnIb-W+p2^0`jWOQ&>;=32#yg*VVB@`yjF%e|@r%IjkBDCkHs1Tpc)2mrpQYd> zSoG&Ku<@P~#>Z{$^y_nP z$tN>*=VAqT7fN;g?pw7F*xh?z?qAOm&oeL2x!s9#-96LX%f3(AmV0BjQop~fw|l8g zN@DgXW9}_uJ`Pv&S$}h>`F9uV>idv30e{X7t3sk3pIe&_b=a{dnj>yP{ggKh7V7A^+01t+X1+}@{V^Yh zft?TiE6Vya!Hz-S@=}`xcAWa6-NV6->z1;OBf!p&vHDz7wOCW{`;nN}aLhIJ-XBq7 z*KGsLHQkUh*7PW_zTp0?Am#q8AmxMmi z)MsDhlgl|c9_+rgj=pH)M6hkl!y?Z~V0H6226_1AgQE?{Bab#(!M0%?ebGic*fy$I z>2m2d)8|sEY5+A!S0hyDPv!p3U)nXe08vKQ|bE>%B5I8wirv- z`n1v)_r&RN>#E27cm~-1j>Ggj*2sG%IP#`*e-^sFxUbFzn@8RCu)k{2-(}!JE6&;F zaJBHCQ~D#{xo~6D<32wRY(Jed{V}E$VAnvuYv8<|j~VM4=yy!UxCZ)S4P39yF|W+U4zk-u?81_V-2i#A!eLokbkP=mz3wqMQ~%(ofGS;#h5=0R*UoZGhnrgvB>#Z zaJ1pLK8IN+=H&BW$2l6)cQI|-moH$})$e}2l=6$1ZG?HY8T+NuXB|J+IY(;g9Bm2r z8iU0gZIR%yVCQQqO6SY7?=sB!l3z}FMFYPj;dg-VOt|&$OSpL+Y~YVH@W&hY(+M}< zGbMK|?3-ite7TYGChU6b2F$siLwPf%?tLQv3g%pIjp@4zGneDiCw5HUfA26Cw^BMM zmT!{ttCU~E24VWYPO0BA+WZFC9Kmk~oBwwDIh697m@(?_l2d*gW^QwdqwcrB=JH;? zoAMsaG2VsgGj0Oqy_i1x?;6O%cRyHdW_h-K8?2^zIUkP4c=yr+nES$eQ~n*yI_l`&Yq-!J*Tl*XCw5lZ!F z>jz-9;6DW0=7Z&Y{|Ic1`difhF{PJtukSHT&AAu5uCB3MJ@WnpY~J8M1>0_%VNZaK zQID7>!Pbd)pQpgasXG?;yPEON_0O=e3I93RxiZ$hFZaFK*k53td+Kps{Ss^reXfts zm0w}kW6xsIujfiV`u=P9WK2EI@85vUr!R8-7TlQYcWCO%Y0tI)J!W0?ILn_0yRPFg z{gW`;b6ihTK9AYAIg~GA>7IWHZksQZKI7c;f57y`zW!sWse9SpAS}lGC$RG!{Lf(9 zj`6+>HbyxeJ+a!2giHA^bo9Nqt-S68|#@YWW*tp=YHSjkY z_?r#c5kcew=Zf@_bsqv(Pz8zsQWh9y6XDvr&`o~ z7i_-Z?}3f+8R2@qkGXfIW5((?*1i1!=DfxJ_z-Nox@|dTwaEQ1u(`c|9J`5~>$zCu zT+PO?$Tl7;Nsy(*!rqJS_4wqp3%p7O?fyW3LVYn_pk#9tw6oBKPWWb61nx zYoMt|?qOi-sYmWL!RFWJT)5t9u`X+aT^Dutt~~ax_wz28*G`ywcSp*dG56)Jl`T8}8r{IRO!)f5`&*ERm-`!#;FkXWBe;Hl_YvIE-*N=k@9#KLJ}=?w^Am1- zTLbrZ9BF-j#}VAp-*E)DzQ5y0xxeE`xxe8^xxe8^`LYJSyn(Msxb-e<;QoFi&F617 zQtodyQhr?nzo~)WnsDp+n~k*og9%snHyh!%d^F+C&tnPK@9#DuUcbN9NcoEm{G|r& zZ!{v_@|A?U|NMPM>L0;FCguK?L7v}V#E!uH8-U#J`!~Y;u73_^g5UFRf*GUkJ?Ng^ z40G?tGkYRBF7kTV~#D*)SsX)<{S%Fv%dF{JnC-+ZmhpG zn);Jv{cXT%*7v@XTiaxW&or?8O!vri zG;2;EJ4#eU+m4m^) z+l9sFh(pkg*YDbR&Z@=Q913=A@;RaYVPY&kC(Hz^X%y2iw~7JwVa)q$oSpZ_|+{LjD7 z)))KkWU%@5+plqyYLUAOZ0__dS%{`?{3(?3n6qxM@t!3yXFXu`n6p#CYMPft%vlYh zKjy3#9CKC&%VW;^#hCr*qm;*-Edo1d_RpNwHOAQODfRogAkGlW7{gMqV^~5NV>k`0 z9%DEitfqNc#26Ms^hZC>0z0p^eI}(m-sR2)`!1)h{|rjCnE!LY_GK{^`OZaCH-0&# zJo23fHlMowWt3_$w*LT|?|jM_+b6;5F}4f9YMPftjBN!(fAr;3V8<5xBCs*>Ir`IJ zW7O@>g_LT>dyaettmYZ81pZlYKc#b@zT1Bet}i}gejaRH^{D#=aMVrT=PyCmx4b;N zE(Kd(J?efD9Cg$8^)I38i|>d36U_hoGn0ArJFbf<^~G6sIoNr=j52-pT>;k@XW3O? zwJWih!)w6qQS)9+DUbEN7VP?}$C_Rbj<(Fk?VWEE$J)WVK@wbUP(D|RA6XvtNvG(~^O8v1v?gGdD zNZ0dQ==!X4C#BrA^1bG6@Gwes-(l{h^zt1>-#wU`?=a#R>wVyKe(r~-^Yd-EG3rt0 z0dP7$-+>#aZr>iHREzOE4F0I`d>37xbsnOW$6j~@Jd*yKOJB^Bx@T#O#WMQ!J@6R` z|2}vb7U#ncz{aS@v+9Rn{xeH_-YnSyxX!Mp{dg3vKgRcCu;aT6OV5%2 zLf2>iJbxYsTQ|PH`w7^b>XGZG;K-GpD^H;7i?iWLF#q$vMVUu`oL5hQZQGcbo2S99 zbL{({fz^z4Opj5j*$>~teh&6NKc6z)gTH|5i~jx+Y=2+C(y>2_t}puZE3kFdZSNUM zHSu$l-oG(VzlQ6NbL%%?HP;|wehc?3kC@+q)r^Vv`rpH?tIvDl1xhdP34PCFYTgs# zn5#d4S77$-B}#dmiGKupCaOpLpTNtoI4}MTHcs6fFH@>Tj=zA-p|1Z$O0~%MS8%$I z{{}ZE_VM4r#;C`4wf_L~KR;je$9|1<`fs#Yr*vQa54yhCSFeKkpYJPk>bH-tQ0j~M ze+}#!1^*}5m{{-E!N#cj?6{kpZ-DJXeD?9#@g|yjJUiY3t7%>qK09LHzKvjv`D4D` z0WZdE+w=NeuyN}4-TkHJxe@DaX?^?fK6qU$`tSi*P4lv_57FL-2)AO<-oL=sQI8la zcu&QiSPgERdc+I@+qZ}r3^z{QIrBbj0^7Ir9&AQak9)NR?7h0AA#Mn|zF3o?VC$;K z=cLuaw(Awz8l`4;LmO6VhR&jA&fA(0>l?4%{Lc4#RMh7fZY0j%%=Ivnify{d10Y$E2pDvtTt0Bn2d{ES3XH^%q84Z*hW{Mf!{@kVg< zIEyz1TTeZ5Zvt-2y(yadQ)Qmbz-n>-Yz}tb{GMCiC@lVtG#YF>#w@3A_G1iK{YvMI znNZsTZVsP4`r}@9ZvEa$e~e=+SS|XzCAhKATcN4PKG+(pX5FZ_4LIuAj@-ELk4yZ~ z_O@v150q=T9azo&x`x|>y<9_m<1sbYQ2ail6svh}y5@4%*>>GKJAhrgI5XTkJHpjt z@9YFtbMHidcZSD!qQASKsTE$@|?Te{74zd06zMl?uZsWY%53Z(pxp#$*?QY5$kmzIN*dI+j zavT6w)4b9go`VOWd&a$h#d;o$rtW?{kW%h5)_dp>@FtY%@os)7SUoJ>%@0Gfz5Kg3 zuzfK$_R>tS<8|KSJe-AQJullgMlI?b4z^DEozxL%(Ux_LQHwgW%Q}80jCPJJ>rmwF Y7^CJsinXzfc|8hjyZ)_4?B8ns7tFR81^@s6 diff --git a/src/shaders/compiled/skinned_shadow.vert.dxil b/src/shaders/compiled/skinned_shadow.vert.dxil index 268c5198cab20e1117cce80a98b16faba00f85c0..65360cd601000fb18bcb2a169945694034360c93 100644 GIT binary patch delta 4335 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 delta 4173 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 yw%vj38>_P1>fP}gpe|Y@if(-ku #include using namespace metal; +struct VSInput +{ + float3 pos; + float4 color; + int positionBoneIndex; +}; + +struct VSOutput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float clipDist; +}; + struct Skinning { float4x4 mvp; @@ -49,82 +67,158 @@ struct main0_in int input_positionBoneIndex [[attribute(4)]]; }; -vertex main0_out main0(main0_in in [[stage_in]], constant Skinning& _68 [[buffer(0)]], constant Shadow& _80 [[buffer(1)]], const device boneRows& boneRows_1 [[buffer(2)]], const device terrainWords& terrainWords_1 [[buffer(3)]]) +static inline __attribute__((always_inline)) +float4 loadBoneRow(thread const uint& row, const device boneRows& boneRows_1) { - main0_out out = {}; - float3 _947; - do + return boneRows_1._data[row]; +} + +static inline __attribute__((always_inline)) +float3 transformPosition(thread const float3& position, thread const int& boneIndex, constant Skinning& _68, const device boneRows& boneRows_1) +{ + if ((boneIndex < 0) || (boneIndex >= int(_68.palette.y))) + { + return position; + } + uint row = _68.palette.x + (uint(boneIndex) * 3u); + uint param = row; + float4 row0 = loadBoneRow(param, boneRows_1); + uint param_1 = row + 1u; + float4 row1 = loadBoneRow(param_1, boneRows_1); + uint param_2 = row + 2u; + float4 row2 = loadBoneRow(param_2, boneRows_1); + float3 transformed; + if (_68.boneScaleAndRestPoseScale.x == 1.0) + { + float restScale = (_68.boneScaleAndRestPoseScale.y != 0.0) ? _68.boneScaleAndRestPoseScale.y : 1.0; + float4 restPosition = float4(position * restScale, 1.0); + transformed = float3(dot(row0, restPosition), dot(row1, restPosition), dot(row2, restPosition)); + } + else + { + transformed = float3(dot(row0.xyz, position), dot(row1.xyz, position), dot(row2.xyz, position)); + transformed = (transformed * _68.boneScaleAndRestPoseScale.x) + float3(row0.w, row1.w, row2.w); + } + if (_68.palette.z != 0u) + { + transformed = _68.bodyOriginAndScale.xyz + (transformed * _68.bodyOriginAndScale.w); + } + return transformed; +} + +static inline __attribute__((always_inline)) +float3 skinnedPosition(thread const VSInput& _input, constant Skinning& _68, const device boneRows& boneRows_1) +{ + float3 param = _input.pos; + int param_1 = _input.positionBoneIndex; + return transformPosition(param, param_1, _68, boneRows_1); +} + +static inline __attribute__((always_inline)) +float3 shearShadow(thread const float3& position, constant Shadow& _80) +{ + float3 relative = position - _80.shadowOrigin.xyz; + float2 axis = float2(cos(_80.shadowProjection.w), sin(_80.shadowProjection.w)); + float along = dot(relative.xy, axis); + float _106 = relative.z; + float _114 = relative.z; + float3 _121 = relative; + float2 _123 = _121.xy + (axis * ((_106 * (along + _80.shadowProjection.x)) / (_114 - _80.shadowProjection.y))); + relative.x = _123.x; + relative.y = _123.y; + return relative + _80.shadowOrigin.xyz; +} + +static inline __attribute__((always_inline)) +uint loadTerrainWord(thread const uint& word, const device terrainWords& terrainWords_1) +{ + return terrainWords_1._data[word]; +} + +static inline __attribute__((always_inline)) +float terrainCornerHeight(thread const int& x, thread const int& y, const device terrainWords& terrainWords_1) +{ + uint param = (uint(y & 255) * 256u) + uint(x & 255); + return as_type(loadTerrainWord(param, terrainWords_1)); +} + +static inline __attribute__((always_inline)) +float terrainHeight(thread float& x, thread float& y, constant Shadow& _80, const device terrainWords& terrainWords_1) +{ + if (((_80.shadowProjection.z == 0.0) || (x < 0.0)) || (y < 0.0)) { - if ((in.input_positionBoneIndex < 0) || (in.input_positionBoneIndex >= int(_68.palette.y))) - { - _947 = in.input_pos; - break; - } - uint _582 = _68.palette.x + (uint(in.input_positionBoneIndex) * 3u); - float4 _554 = boneRows_1._data[_582]; - uint _586 = _582 + 1u; - float4 _556 = boneRows_1._data[_586]; - uint _589 = _582 + 2u; - float4 _558 = boneRows_1._data[_589]; - float3 _945; - if (_68.boneScaleAndRestPoseScale.x == 1.0) - { - float4 _607 = float4(in.input_pos * ((_68.boneScaleAndRestPoseScale.y != 0.0) ? _68.boneScaleAndRestPoseScale.y : 1.0), 1.0); - _945 = float3(dot(boneRows_1._data[_582], _607), dot(boneRows_1._data[_586], _607), dot(boneRows_1._data[_589], _607)); - } - else - { - _945 = (float3(dot(boneRows_1._data[_582].xyz, in.input_pos), dot(boneRows_1._data[_586].xyz, in.input_pos), dot(boneRows_1._data[_589].xyz, in.input_pos)) * _68.boneScaleAndRestPoseScale.x) + float3(_554.w, _556.w, _558.w); - } - float3 _946; - if (_68.palette.z != 0u) - { - _946 = _68.bodyOriginAndScale.xyz + (_945 * _68.bodyOriginAndScale.w); - } - else - { - _946 = _945; - } - _947 = _946; - break; - } while(false); - float3 _676 = _947 - _80.shadowOrigin.xyz; - _676.x += ((_676.z * (_676.x + _80.shadowProjection.x)) / (_676.z - _80.shadowProjection.y)); - float3 _492 = _676 + _80.shadowOrigin.xyz; - float _948; - do + return 0.0; + } + x /= 100.0; + y /= 100.0; + int xi = int(x); + int yi = int(y); + uint index = uint((yi * 256) + xi); + uint param = 65536u + (index >> uint(5)); + if ((index >= 65536u) || (((loadTerrainWord(param, terrainWords_1) >> (index & 31u)) & 1u) != 0u)) { - if (((_80.shadowProjection.z == 0.0) || (_492.x < 0.0)) || (_492.y < 0.0)) - { - _948 = 0.0; - break; - } - float _744 = _492.x * 0.00999999977648258209228515625; - float _746 = _492.y * 0.00999999977648258209228515625; - int _748 = int(_744); - int _750 = int(_746); - uint _755 = uint((_750 * 256) + _748); - if ((_755 >= 65536u) || (((terrainWords_1._data[65536u + (_755 >> uint(5))] >> (_755 & 31u)) & 1u) != 0u)) - { - _948 = _80.shadowOrigin.w; - break; - } - float _779 = _746 - float(_750); - float _836 = as_type(terrainWords_1._data[(uint(_750 & 255) * 256u) + uint(_748 & 255)]); - float _872 = as_type(terrainWords_1._data[(uint(_750 & 255) * 256u) + uint((_748 + 1) & 255)]); - float _802 = _836 + ((as_type(terrainWords_1._data[(uint((_750 + 1) & 255) * 256u) + uint(_748 & 255)]) - _836) * _779); - _948 = _802 + (((_872 + ((as_type(terrainWords_1._data[(uint((_750 + 1) & 255) * 256u) + uint((_748 + 1) & 255)]) - _872) * _779)) - _802) * (_744 - float(_748))); - break; - } while(false); - _492.z = _948 + 5.0; - float4 _905 = _68.mvp * float4(_492, 1.0); - float4 _911 = _905; - float _527 = _68.fogParameters.y - _68.fogParameters.x; - out.gl_Position = _905; - out._entryPointOutput_uv = float2(0.0); - out._entryPointOutput_color = in.input_color; - out._entryPointOutput_fogFactor = (_527 > 0.001000000047497451305389404296875) ? fast::clamp((_68.fogParameters.y - abs(_911.w)) / _527, 0.0, 1.0) : 1.0; - out.gl_ClipDistance[0] = _911.w - 1.0; + return _80.shadowOrigin.w; + } + float xd = x - float(xi); + float yd = y - float(yi); + int param_1 = xi; + int param_2 = yi; + float h1 = terrainCornerHeight(param_1, param_2, terrainWords_1); + int param_3 = xi; + int param_4 = yi + 1; + float h2 = terrainCornerHeight(param_3, param_4, terrainWords_1); + int param_5 = xi + 1; + int param_6 = yi; + float h3 = terrainCornerHeight(param_5, param_6, terrainWords_1); + int param_7 = xi + 1; + int param_8 = yi + 1; + float h4 = terrainCornerHeight(param_7, param_8, terrainWords_1); + float left = h1 + ((h2 - h1) * yd); + float right = h3 + ((h4 - h3) * yd); + return left + ((right - left) * xd); +} + +static inline __attribute__((always_inline)) +float4 clipPosition(thread const float3& position, constant Skinning& _68) +{ + return _68.mvp * float4(position, 1.0); +} + +static inline __attribute__((always_inline)) +VSOutput _main(thread const VSInput& _input, constant Skinning& _68, constant Shadow& _80, const device boneRows& boneRows_1, const device terrainWords& terrainWords_1) +{ + VSInput param = _input; + float3 param_1 = skinnedPosition(param, _68, boneRows_1); + float3 position = shearShadow(param_1, _80); + float param_2 = position.x; + float param_3 = position.y; + float _415 = terrainHeight(param_2, param_3, _80, terrainWords_1); + position.z = _415 + 5.0; + float3 param_4 = position; + VSOutput _output; + _output.pos = clipPosition(param_4, _68); + _output.uv = float2(0.0); + _output.color = _input.color; + _output.clipDist = _output.pos.w - 1.0; + float range = _68.fogParameters.y - _68.fogParameters.x; + _output.fogFactor = (range > 0.001000000047497451305389404296875) ? fast::clamp((_68.fogParameters.y - abs(_output.pos.w)) / range, 0.0, 1.0) : 1.0; + return _output; +} + +vertex main0_out main0(main0_in in [[stage_in]], constant Skinning& _68 [[buffer(0)]], constant Shadow& _80 [[buffer(1)]], const device boneRows& boneRows_1 [[buffer(2)]], const device terrainWords& terrainWords_1 [[buffer(3)]]) +{ + main0_out out = {}; + VSInput _input; + _input.pos = in.input_pos; + _input.color = in.input_color; + _input.positionBoneIndex = in.input_positionBoneIndex; + VSInput param = _input; + VSOutput flattenTemp = _main(param, _68, _80, boneRows_1, terrainWords_1); + out.gl_Position = flattenTemp.pos; + out._entryPointOutput_uv = flattenTemp.uv; + out._entryPointOutput_color = flattenTemp.color; + out._entryPointOutput_fogFactor = flattenTemp.fogFactor; + out.gl_ClipDistance[0] = flattenTemp.clipDist; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; return out; } diff --git a/src/shaders/compiled/skinned_shadow.vert.spv b/src/shaders/compiled/skinned_shadow.vert.spv index bdb8748f26ca78fb27228a199d1ca9bd7caaadc8..2438d9667f37cc6c71d75a723bf4e665b5585d82 100644 GIT binary patch literal 12480 zcmaKx37lM2mBwGv)mb1wB*-xotClY&e$$)<#I|LJqStF%@|;Jdm{sL^on>88tM{h3Qg$T1EeJHkj?bpiHtIdq zq4l-;#u1aQkhwYU7txNKcYD@>ww5_8ulAO==5eKLI_>I}%d3N%8dSf@k?ad^&;67w zTUQ&X)oI7DfA$&OjLGZex`uNekR69_XhWr1E%)x3-B6>xXP9Ubaj<)PX@HVWS`OO{fn|iIE zvw%Oy_}elMRrH$!ZuV=>=7CqQT(PNPF?g(pnoqMHO>R9lZPwrHV=ad3GbZojiCtgo zThgjyguk#HuzUlM5qYm9Y^`4DoHgpI+hBIugF<7I#wXvyQUR>jRSE@aY z@&&bCriE`@9>b-Pt?RGXHkL=Ez~7wrxP9d)gu35d#Q69=pHEva5A-xDn;j;v>4mh- zSGhTFxzAAkdN(U3cTW1OWz*MPuU#1{Zl0}f19{x5OK5wxR$Ow<*UATK`9?XH8{yWR zJ0Xv;#%eyDy*-T{TI1e8Ta0UGCjW$%-Vg7JJ^j^vhWn4ncEDR>t;@aW&HJa6J=ny) z8jM)V9-$?wDenLzusoQHTFyR za&SMZw>GaB(WjL4jNolqud!6Z*uD|IQdSwk+p-PDp4yD9j_{ST+6dm3)r~!^8M|eK zuas?V;a9;2%Inh|Q_8M|^Xm62SmPbWkNB>YvYT6S+}gt5*1~UZ;djAn>GpK(cenT- zhV$9#^TpHuX?XE2^E;mN+1|FzdHP*%YRwzg``z#Sp177TkZb!I{`I`#jdFEWdE;O{ z*4NR7&(FC0cS2{m+Nf{qu2rgy=B2-9+;RDDh`s&Z`p#=y{`+EYf6Q@w{@Y`3|L_;V z@3_BB_Kq3;IxOYvdQXnVmQgRUPYGMbEP{JSPHfTqM*Bn@L*?J?&VpuM7t#6`2;^2?3}HEcdm1Fj&V2J z-zT(K-$XQXbkmx%nWM>vbC$9j@HyXRd|Q6+w!y7)+`&iWeE3d|F`bilvVO-BJC;vy z$MTWiMC(}A(Z1f%F_zdT#tL2>%lkXV5*ODcFOKCqG!@Oqv3-B!jwkoskvHd3%HIQj z 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 literal 7568 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 diff --git a/src/shaders/compiled/skinned_weighted_shadow.vert.dxil b/src/shaders/compiled/skinned_weighted_shadow.vert.dxil index f4e422c42efdb660cc25646813a2e5ed97e70542..43ceefa722bb88edbd04473229860482f39ae6ea 100644 GIT binary patch delta 4864 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 Yg#V0KMLVFlWD2i=iddqit_A?`KWz`jN&o-= diff --git a/src/shaders/compiled/skinned_weighted_shadow.vert.msl b/src/shaders/compiled/skinned_weighted_shadow.vert.msl index 48d28f1077..7ccf3d7a17 100644 --- a/src/shaders/compiled/skinned_weighted_shadow.vert.msl +++ b/src/shaders/compiled/skinned_weighted_shadow.vert.msl @@ -1,8 +1,28 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" + #include #include using namespace metal; +struct VSInput +{ + float3 pos; + float4 color; + int positionBoneIndex; + uint4 joints; + float4 weights; +}; + +struct VSOutput +{ + float4 pos; + float2 uv; + float4 color; + float fogFactor; + float clipDist; +}; + struct Skinning { float4x4 mvp; @@ -51,143 +71,190 @@ struct main0_in float4 input_weights [[attribute(7)]]; }; -vertex main0_out main0(main0_in in [[stage_in]], constant Skinning& _76 [[buffer(0)]], constant Shadow& _88 [[buffer(1)]], const device boneRows& boneRows_1 [[buffer(2)]], const device terrainWords& terrainWords_1 [[buffer(3)]]) +static inline __attribute__((always_inline)) +float4 loadBoneRow(thread const uint& row, const device boneRows& boneRows_1) { - main0_out out = {}; - float3 _1189; - do + return boneRows_1._data[row]; +} + +static inline __attribute__((always_inline)) +float3 skinWeightedPosition(thread const float3& position, thread const uint4& joints, thread const float4& weights, constant Skinning& _76, const device boneRows& boneRows_1) +{ + float4 bindPosition = float4(position, 1.0); + float3 transformed = float3(0.0); + for (uint k = 0u; k < 4u; k++) { - if (in.input_weights.x > 0.0) + if ((weights[k] > 0.0) && (joints[k] < _76.palette.y)) { - float4 _699 = float4(in.input_pos, 1.0); - float3 _1192; - if ((in.input_weights.x > 0.0) && (in.input_joints.x < _76.palette.y)) - { - uint _723 = _76.palette.x + (in.input_joints.x * 3u); - _1192 = float3(dot(boneRows_1._data[_723], _699), dot(boneRows_1._data[_723 + 1u], _699), dot(boneRows_1._data[_723 + 2u], _699)) * in.input_weights.x; - } - else - { - _1192 = float3(0.0); - } - float3 _1233; - if ((in.input_weights.y > 0.0) && (in.input_joints.y < _76.palette.y)) - { - uint _1215 = _76.palette.x + (in.input_joints.y * 3u); - _1233 = _1192 + (float3(dot(boneRows_1._data[_1215], _699), dot(boneRows_1._data[_1215 + 1u], _699), dot(boneRows_1._data[_1215 + 2u], _699)) * in.input_weights.y); - } - else - { - _1233 = _1192; - } - float3 _1275; - if ((in.input_weights.z > 0.0) && (in.input_joints.z < _76.palette.y)) - { - uint _1257 = _76.palette.x + (in.input_joints.z * 3u); - _1275 = _1233 + (float3(dot(boneRows_1._data[_1257], _699), dot(boneRows_1._data[_1257 + 1u], _699), dot(boneRows_1._data[_1257 + 2u], _699)) * in.input_weights.z); - } - else - { - _1275 = _1233; - } - float3 _1317; - if ((in.input_weights.w > 0.0) && (in.input_joints.w < _76.palette.y)) - { - uint _1299 = _76.palette.x + (in.input_joints.w * 3u); - _1317 = _1275 + (float3(dot(boneRows_1._data[_1299], _699), dot(boneRows_1._data[_1299 + 1u], _699), dot(boneRows_1._data[_1299 + 2u], _699)) * in.input_weights.w); - } - else - { - _1317 = _1275; - } - float3 _1188; - if (_76.palette.z != 0u) - { - _1188 = _76.bodyOriginAndScale.xyz + (_1317 * _76.bodyOriginAndScale.w); - } - else - { - _1188 = _1317; - } - _1189 = _1188; - break; + uint row = _76.palette.x + (joints[k] * 3u); + uint param = row; + uint param_1 = row + 1u; + uint param_2 = row + 2u; + transformed += (float3(dot(loadBoneRow(param, boneRows_1), bindPosition), dot(loadBoneRow(param_1, boneRows_1), bindPosition), dot(loadBoneRow(param_2, boneRows_1), bindPosition)) * weights[k]); } - float3 _1185; - do - { - if ((in.input_positionBoneIndex < 0) || (in.input_positionBoneIndex >= int(_76.palette.y))) - { - _1185 = in.input_pos; - break; - } - uint _810 = _76.palette.x + (uint(in.input_positionBoneIndex) * 3u); - float4 _782 = boneRows_1._data[_810]; - uint _814 = _810 + 1u; - float4 _784 = boneRows_1._data[_814]; - uint _817 = _810 + 2u; - float4 _786 = boneRows_1._data[_817]; - float3 _1183; - if (_76.boneScaleAndRestPoseScale.x == 1.0) - { - float4 _835 = float4(in.input_pos * ((_76.boneScaleAndRestPoseScale.y != 0.0) ? _76.boneScaleAndRestPoseScale.y : 1.0), 1.0); - _1183 = float3(dot(boneRows_1._data[_810], _835), dot(boneRows_1._data[_814], _835), dot(boneRows_1._data[_817], _835)); - } - else - { - _1183 = (float3(dot(boneRows_1._data[_810].xyz, in.input_pos), dot(boneRows_1._data[_814].xyz, in.input_pos), dot(boneRows_1._data[_817].xyz, in.input_pos)) * _76.boneScaleAndRestPoseScale.x) + float3(_782.w, _784.w, _786.w); - } - float3 _1184; - if (_76.palette.z != 0u) - { - _1184 = _76.bodyOriginAndScale.xyz + (_1183 * _76.bodyOriginAndScale.w); - } - else - { - _1184 = _1183; - } - _1185 = _1184; - break; - } while(false); - _1189 = _1185; - break; - } while(false); - float3 _904 = _1189 - _88.shadowOrigin.xyz; - _904.x += ((_904.z * (_904.x + _88.shadowProjection.x)) / (_904.z - _88.shadowProjection.y)); - float3 _607 = _904 + _88.shadowOrigin.xyz; - float _1190; - do + } + if (_76.palette.z != 0u) { - if (((_88.shadowProjection.z == 0.0) || (_607.x < 0.0)) || (_607.y < 0.0)) - { - _1190 = 0.0; - break; - } - float _972 = _607.x * 0.00999999977648258209228515625; - float _974 = _607.y * 0.00999999977648258209228515625; - int _976 = int(_972); - int _978 = int(_974); - uint _983 = uint((_978 * 256) + _976); - if ((_983 >= 65536u) || (((terrainWords_1._data[65536u + (_983 >> uint(5))] >> (_983 & 31u)) & 1u) != 0u)) - { - _1190 = _88.shadowOrigin.w; - break; - } - float _1007 = _974 - float(_978); - float _1064 = as_type(terrainWords_1._data[(uint(_978 & 255) * 256u) + uint(_976 & 255)]); - float _1100 = as_type(terrainWords_1._data[(uint(_978 & 255) * 256u) + uint((_976 + 1) & 255)]); - float _1030 = _1064 + ((as_type(terrainWords_1._data[(uint((_978 + 1) & 255) * 256u) + uint(_976 & 255)]) - _1064) * _1007); - _1190 = _1030 + (((_1100 + ((as_type(terrainWords_1._data[(uint((_978 + 1) & 255) * 256u) + uint((_976 + 1) & 255)]) - _1100) * _1007)) - _1030) * (_972 - float(_976))); - break; - } while(false); - _607.z = _1190 + 5.0; - float4 _1133 = _76.mvp * float4(_607, 1.0); - float4 _1144 = _1133; - float _642 = _76.fogParameters.y - _76.fogParameters.x; - out.gl_Position = _1133; - out._entryPointOutput_uv = float2(0.0); - out._entryPointOutput_color = in.input_color; - out._entryPointOutput_fogFactor = (_642 > 0.001000000047497451305389404296875) ? fast::clamp((_76.fogParameters.y - abs(_1144.w)) / _642, 0.0, 1.0) : 1.0; - out.gl_ClipDistance[0] = _1144.w - 1.0; + transformed = _76.bodyOriginAndScale.xyz + (transformed * _76.bodyOriginAndScale.w); + } + return transformed; +} + +static inline __attribute__((always_inline)) +float3 transformPosition(thread const float3& position, thread const int& boneIndex, constant Skinning& _76, const device boneRows& boneRows_1) +{ + if ((boneIndex < 0) || (boneIndex >= int(_76.palette.y))) + { + return position; + } + uint row = _76.palette.x + (uint(boneIndex) * 3u); + uint param = row; + float4 row0 = loadBoneRow(param, boneRows_1); + uint param_1 = row + 1u; + float4 row1 = loadBoneRow(param_1, boneRows_1); + uint param_2 = row + 2u; + float4 row2 = loadBoneRow(param_2, boneRows_1); + float3 transformed; + if (_76.boneScaleAndRestPoseScale.x == 1.0) + { + float restScale = (_76.boneScaleAndRestPoseScale.y != 0.0) ? _76.boneScaleAndRestPoseScale.y : 1.0; + float4 restPosition = float4(position * restScale, 1.0); + transformed = float3(dot(row0, restPosition), dot(row1, restPosition), dot(row2, restPosition)); + } + else + { + transformed = float3(dot(row0.xyz, position), dot(row1.xyz, position), dot(row2.xyz, position)); + transformed = (transformed * _76.boneScaleAndRestPoseScale.x) + float3(row0.w, row1.w, row2.w); + } + if (_76.palette.z != 0u) + { + transformed = _76.bodyOriginAndScale.xyz + (transformed * _76.bodyOriginAndScale.w); + } + return transformed; +} + +static inline __attribute__((always_inline)) +float3 skinnedPosition(thread const VSInput& _input, constant Skinning& _76, const device boneRows& boneRows_1) +{ + if (_input.weights.x > 0.0) + { + float3 param = _input.pos; + uint4 param_1 = _input.joints; + float4 param_2 = _input.weights; + return skinWeightedPosition(param, param_1, param_2, _76, boneRows_1); + } + float3 param_3 = _input.pos; + int param_4 = _input.positionBoneIndex; + return transformPosition(param_3, param_4, _76, boneRows_1); +} + +static inline __attribute__((always_inline)) +float3 shearShadow(thread const float3& position, constant Shadow& _88) +{ + float3 relative = position - _88.shadowOrigin.xyz; + float2 axis = float2(cos(_88.shadowProjection.w), sin(_88.shadowProjection.w)); + float along = dot(relative.xy, axis); + float _114 = relative.z; + float _122 = relative.z; + float3 _129 = relative; + float2 _131 = _129.xy + (axis * ((_114 * (along + _88.shadowProjection.x)) / (_122 - _88.shadowProjection.y))); + relative.x = _131.x; + relative.y = _131.y; + return relative + _88.shadowOrigin.xyz; +} + +static inline __attribute__((always_inline)) +uint loadTerrainWord(thread const uint& word, const device terrainWords& terrainWords_1) +{ + return terrainWords_1._data[word]; +} + +static inline __attribute__((always_inline)) +float terrainCornerHeight(thread const int& x, thread const int& y, const device terrainWords& terrainWords_1) +{ + uint param = (uint(y & 255) * 256u) + uint(x & 255); + return as_type(loadTerrainWord(param, terrainWords_1)); +} + +static inline __attribute__((always_inline)) +float terrainHeight(thread float& x, thread float& y, constant Shadow& _88, const device terrainWords& terrainWords_1) +{ + if (((_88.shadowProjection.z == 0.0) || (x < 0.0)) || (y < 0.0)) + { + return 0.0; + } + x /= 100.0; + y /= 100.0; + int xi = int(x); + int yi = int(y); + uint index = uint((yi * 256) + xi); + uint param = 65536u + (index >> uint(5)); + if ((index >= 65536u) || (((loadTerrainWord(param, terrainWords_1) >> (index & 31u)) & 1u) != 0u)) + { + return _88.shadowOrigin.w; + } + float xd = x - float(xi); + float yd = y - float(yi); + int param_1 = xi; + int param_2 = yi; + float h1 = terrainCornerHeight(param_1, param_2, terrainWords_1); + int param_3 = xi; + int param_4 = yi + 1; + float h2 = terrainCornerHeight(param_3, param_4, terrainWords_1); + int param_5 = xi + 1; + int param_6 = yi; + float h3 = terrainCornerHeight(param_5, param_6, terrainWords_1); + int param_7 = xi + 1; + int param_8 = yi + 1; + float h4 = terrainCornerHeight(param_7, param_8, terrainWords_1); + float left = h1 + ((h2 - h1) * yd); + float right = h3 + ((h4 - h3) * yd); + return left + ((right - left) * xd); +} + +static inline __attribute__((always_inline)) +float4 clipPosition(thread const float3& position, constant Skinning& _76) +{ + return _76.mvp * float4(position, 1.0); +} + +static inline __attribute__((always_inline)) +VSOutput _main(thread const VSInput& _input, constant Skinning& _76, constant Shadow& _88, const device boneRows& boneRows_1, const device terrainWords& terrainWords_1) +{ + VSInput param = _input; + float3 param_1 = skinnedPosition(param, _76, boneRows_1); + float3 position = shearShadow(param_1, _88); + float param_2 = position.x; + float param_3 = position.y; + float _519 = terrainHeight(param_2, param_3, _88, terrainWords_1); + position.z = _519 + 5.0; + float3 param_4 = position; + VSOutput _output; + _output.pos = clipPosition(param_4, _76); + _output.uv = float2(0.0); + _output.color = _input.color; + _output.clipDist = _output.pos.w - 1.0; + float range = _76.fogParameters.y - _76.fogParameters.x; + _output.fogFactor = (range > 0.001000000047497451305389404296875) ? fast::clamp((_76.fogParameters.y - abs(_output.pos.w)) / range, 0.0, 1.0) : 1.0; + return _output; +} + +vertex main0_out main0(main0_in in [[stage_in]], constant Skinning& _76 [[buffer(0)]], constant Shadow& _88 [[buffer(1)]], const device boneRows& boneRows_1 [[buffer(2)]], const device terrainWords& terrainWords_1 [[buffer(3)]]) +{ + main0_out out = {}; + VSInput _input; + _input.pos = in.input_pos; + _input.color = in.input_color; + _input.positionBoneIndex = in.input_positionBoneIndex; + _input.joints = in.input_joints; + _input.weights = in.input_weights; + VSInput param = _input; + VSOutput flattenTemp = _main(param, _76, _88, boneRows_1, terrainWords_1); + out.gl_Position = flattenTemp.pos; + out._entryPointOutput_uv = flattenTemp.uv; + out._entryPointOutput_color = flattenTemp.color; + out._entryPointOutput_fogFactor = flattenTemp.fogFactor; + out.gl_ClipDistance[0] = flattenTemp.clipDist; out.gl_ClipDistance_0 = out.gl_ClipDistance[0]; return out; } diff --git a/src/shaders/compiled/skinned_weighted_shadow.vert.spv b/src/shaders/compiled/skinned_weighted_shadow.vert.spv index 4e31b7b1b59f42b88130266f9e29f11634e8198a..85560cf8ddee4a89e68b153ea144c1f70a028799 100644 GIT binary patch literal 15104 zcma)?dw`WyxyC=3JzN9@?}~toprQhbpol0AiUNv)g7?dr4YPsKVfHw)0ZlVZ?Q}b3 zmgksed9+ZoOv}>D3^i|Qnps*}X;xNtFH_6g`Tf4VUgn#vf1J-&>v^8{UGG}!UF%!x zn;Du0jvt(51F~V+knD_sS^jL94MfQ@>v7b>vOzhYw{XeADZRD!Dbx4cN5?I)Cac^w zA{&w8692!t+|ebOM!Xr6S(HO4hfx)H{Kp z4z06VZa=izRXGm-HB)Ed+mvmK-cwzd#~hV>mR5RtnBIxip7!Kd%67!I4uJ~ap;-%c zt*6}8yQ12&y5FEXh+H4{&eZ+K(VXXc8Dm(`)m}L#_Zyb&N!@!E9acJ4uBuhq`-NM( zX8NqPE2c-x-QN+jlublCv)a*B>$Trfwg-G&9;-L!li(*TSYdve0*CwYSO=hJj z(8kY1&nG#NjOR&rJ*VMQ&uddQ9eggO znfaK%)HbzRF?AOIL&n~e&7_WY2ZHPEnzPy96P7GmQ!{xy=1`3?$ zbKlXm5}1!&&1d!6?tGo)j(u6R{oF-89VI*D6O>+Zh%NF6dh=tao-w&&(q=B}w#7ZwGh@c}J$90gJjVSG>hd`q zPC4gi$~&w1LOGU8;pUvPD)%wRYCf&)=eo%H5 zywTUZ+=5;|7fadgb?mE5kEQGm>TVY;@o!P%JC!Q8-%VY#Z-istmnyg4N8M*{&K}Xu zo=V#epF!D^NsF@(ir$<(OTFpbt+eO9BT4$Qj;>ATX83N0-ru(=+X3yYJXTXS1srpn z3GN$HDQj)uM>Oyi4ZNd)cQ){|8+fgOU)+y3Wmm$_>2S_X+1224b6m=<0W;Nfca*Z5 z8`|AvJ8mi4-DA6i9{{gng^nN%3tZ>pnWR5c;5Ogl=CUx4E1sPZB*Clw?TdvZPH=} zeYdN7-|wh;o48$#H7NhKs_SvX*84ad{}mitwMy60%IfZXY)7E=&6V>K-dgFZ^_;ud zFNOMrwrQM0^6#~G+P%^2V@Uoj_fC7vX=whP_fC7?ZRaAU&nv1h$UaLeYC zU$KvO$b3c-+;e|qgEk)S6Migxrq)`}jH|Y|pfx3}t)SVTe%%GlyGm_+LGzAMyR@J= zHnnRCn)i^}EtGl8#yh8l;uCxquwym{-XrxKH0Kzax3_kFanBfYB*hrsEyk?JsPn#< zrR?L_9B%9|w#T^uV z1uypHofLhEi}R8f`|_O|i{@kBzHf5-llyatygrsv{%*+~pLTy~==CGZ9_Gf#sF(y-M)5md7NnG7= z?MrQ*9FxU1GpKE&uFnApt6LoV!AWy%9K&pC`&75KZM{8v2dv#b_oA)(TuPR$KV%2^ z0+4OY!&r8K=T&IxF`q{4SdYT)7;G~uanA`g`!XL#Q+)J4hFY8P$HF}mjBC+;BDHpP zO!nWN8^*ZX9=LWFz z3VuJ>c5>(U7{zB2%p7gcB-EnBe0N57?ITWG13wS`cCtH;3*Z?g`ng=5J#=WazqVl4 z|AyQ?U{m~?;LYgK|E+L;=MeFRIEn0`t8R7CfwtKf zY?rn(r*h9*HSPN+>^f?fd;W&~z=Ykq+U1_dVV|9_?}c``-#*$Sp67G;F95qv(VyJ& zTFvnsov?GWz1;I#yIgn!ToR2Z3D={l~x$2J7$sH@;jS{l}xVf?Xf|C&1@`_1}>E<@&^U4g zF`l{Ld^{|u@#XsH@3}rN*|nJq`Aqt9&&~(Wp;p&!?&?~7u1CSu%uV#a5U#Gj`$X0i5?wQ4Kb^YBp@)-MZVExTa#9sne*Z){*x&GcQCxG=gH~PDePK2xL?>>`< z|Eb`7Jme<)PeW7J$Gv$v#r+oRFW2Wy-jD+*?m_p#aEg!L3Nz@-z2i5D`*Cw>&BP1?Mq(KX-FgY!P;gKe+B_PG?teGK&?ig#J8%>wY^q+goG zd@S4;>TfYldCbYNj->c(L5Vqy06V8GseQ+s=TeIPa@X14vjlft&P+UVa6H^Nj@3Ky z6pHs`jMaRen)F5VV64-UrtV{I%*92-(0)3_xca%)j!A6}SzboHoMInslrkmOyB(}; zIDW22g<@>ytS#EF0KZ%NmFU`{{VK5SU2|=V8K3*SgJNv$j?WyaMNZBFJLW~qM*mKV zn#ISM`f6KEvHhor?U=hL`l}n;e5-|j6|8^k`?JCJ)lG>!^nlfa`?IuhV*YEuG5=b@ zZ!K8cg=sA7z_wMtBx&b>jjt`na4xuU4DUfxk3P=_N1xsYF}C-DwYm1r{{o6_)jycD z_krzK+sDw%+j@$*&}J<6&4rX=-rt`zbszKY+-!dlMf-Y6%;RFP?afKNzn6gZ^>ID) zQHwSo0NchnMVtQw+s6KEqmNpQ^Mhd97{hnwLlkpUd}ltK^mu1J0#~#67~6No`8fBF zQjDvg@4r0Wf8W9FC_dXzeE;h|uhifF?a>^Y-$HvNouIYpa& ziK8!LjH3ALK#9I~1bf!(L>+y72CQyhS5tqMauvnCw1wa2z}oCf9DOgD3QAxz}n7Fv2O&ceI>>I zBG_2!8qaq3uf)HS;RAFY|db#oW72V(t3H7;go~7;E4d<5$7j zV*XzPkE1wd_tR|@wTl^_{Od_8Q?F0jH^9cx<~!#at3@B*1gmLtedT@|xtH&x_NvGPR{Um7v3ffPTHjp~L$({k*UVrT|F5h2mj>G-)Gm3jA_|L)m#GU>N zus-VH^BmZH5&U^@vCS{x`lyG`3*e0f{wr{?&9CA5s4pf%=HxdN`!}9;^ZG2c`oCCb z_kipDB6alhTd?zqyXSXcHH(jVGf(>4$L}ewOU(Brux->M<{!Y$H)8$~tY-0PjQJ~ zqpgXe=Kd2qmy@wKgN@%tiM1YtrXFiO7_4UTu`2G#Aqd4a8VZk?Wqc#oo1trqH5vxC zt$O5VIN1KQMSj%GPmJH%n7$92gYDaUP+a_8*%RGoH%ff3?4Ixh>WK;OO1%fg-0Vdi z-zxsC);{DzsQnvl@U7wgeYVK`8*P#MciJLvZQw^F9&_0ezB_T_JlzVe<`df1NmCAO zo20oWah`6AW_$g$$9d|Uw3%Dy&c(fBo_7SB3+q>y`%cuODf}UBIq~x<0^QXf&P}HFalYCnQPiBT zIQrZh9DT+aW)Am3*A`=)3NFrPU%2y851(mZ_4rta8?KWfp>9I*YUM?Z&xi~Sr1*H1nAnF}uVb2wbh^VNQQFV&)-d0_idkACKZ zi~THs>!%)fz>#3*=@_)fxpx#;n>jU}XT(CV?_->UM}yV$bxhjSd_QAPS<8Jl-DB1< z$78^*Y2k+Rd2!6ku$>H!m}R(e-MgotYm5A!3bw6!0tZz-Vqn?oqg!jX9~r8XEOEP6mu|@I_{Gdw2S*;0(wV*dna`k zxcAT51wIB|OWgVU-j?C^(?%WVit}Fv*A{2za1SpN;le?0YBXzKbqU%CFycQrW1AA6z;OeJSn>`%sONaV~_b72~`gp6m4G{d5uBSnB4$v8j1ZYQF?Lidx;VIOh+5 z)y;>vn2%Z5eGZ_Q5BKoQ0zMFIJ`SQbALi>yV#GTmzq-K9*EJ3N<^nhVT@C!62L3>S z8~?!u{&0aC@6iI+|M3R?M1kx7WP$7dR0Dsy!1aHo!1aHwfj?j1`oGY?UrIdA$Pd9! z!mo`I=eq0kVRUWr`-_i&)#Cd~pO3;_pF3FZ>!|+=uBK1?KI>y}+iG*K+3w?D*D~5& z3Rf$(`vly!+B}m!N$umAr0p__n)^ZQezLt>J^K1@uw#thXa5ge?Q)8HR-0P*UjcS( z;s0s4TKH>I3;(OY#^_>PzJH&As~Ow9DG%Szf^8qZpM$IE>%NuiYn=ZDtNG5#uLG-H zO9`LPgYCmRU7s(2^;3^`e*;+EK71GCw)g$K9;|kATE82?YBx~A=Zj!{?#0J8UjnP$ zM2T;SFN1BP&3=5x)Z!fY3V0N4)g$gLVB>n;8277SwOc9C*Vn+d)fRrYfz|y6jBk#w z!_~dxV&8oO?tHYlf9|06asOz$oucM`5y$)RO|b8ScUqa^c-^yiqHA-XiEU^5uzwru zK9IW>cf(zqYHI%-uv+}BWh2-&>gLRING;;s3wEzWy!+tphluxGuv)~sA8Z?S<9Uv$ zMf-=qjz^nkm^^IX0~=f0!_;!`G3WgV*n7%0+Vt^ERFC%G2irdO;bUO6w!-*-0FVA3 z2g{A+d8mK%_d~G#>7z}bN2%4LzaN2(75)7ftY&}uKLu6`|DS+keouqt(ce$O_GcSy zwttdZJ=#ADF822`xSIWi&(Gn-9Q*>VrjIe71KUpgJhk>1!!N;(K_6}UJVUK+eAnSu zVDldQ*I@G!{5Q!S`{6~nKI-A~Td?~g{+{?duzuzkrM5_$ypL^%%$B!1krhalAyW7BT(~c5K1_0oEt@%gG+& z_$OQ+_3(KG?0XmaconRldW_>WuzhLs-IvEV%WU#BhvIVx#cvkB?OQ3H4~J66xBct1 zi|-VD-Y9UtrQa@a@9hEnU=#jw|Gjr`|NV{s-aEMM{rBF%^&geEbDac#llZOF=F-09 zp3k;<3+&G*>e?NPTG*LN{%;u6wL2Fzzm4r{AXu&VGe#4dy8g~Z9{$Z>{p0s5?z=%~ z>iRoZdAuKk!G0SWM_a7TP_Q=ttysj~3~X$_WsD`)&pbHSEs|ZEIg>k2eWABQjOw$U>mu9+Rs4SD%snTUA|?q+kR_sD|H*iG1$*GXzJ0&wqX14XAAp~>k~i6 zZI|qgchdIg+G3CI09KnzoXE$HaAUWT6JyKui~DXTusQT!L|H^cR5&b(D2t#1Dmy5CU-$c=?4&qF{rA7OZr!?d>%H#jj9qW$ z`nB4a+6J`=wOx8@?Y2p6J(ya}aT?eW?Y*SFF9c;@`Sc*%*Qqd-*?DJV^L#x|KY*I77h&6wV%}1vlRN_dYeXl zXnk3$zqza7@t>2z&Ohb)Di(7q-k@~_`qsb1VGxqm17xfQ}3@oX) z>LbhAz9zQkjR&{tC$^T4)aN#vBZH0MfmZ$C<{)7)zY{kHP+Pcoq`9R2e=g8>;-0WB zABAZT`CEXE&HNqCc-Z2B!RCrijLNoUZLX6YW!G0{-a5Mek>+vPoxaA_j?|FmIh@RB z{tj)faEr|EaN^#_sGRl^bv~VLi#!8t%;vy)?&P4S zjS<`P9o=8*U7wTb`mo0J+40elU-CJwb`m<{?bwfP--EHp=Gi-8+lsFL$ojV#llMWr zYl+MFm0ioG{!B*KGLO#neq=4NEo((C*YfUUEpfRo<#H|W(^NQ{YkQZJT~FEPwsI$y zaqWAfY<%jyFUp>qvd{Jnz&2%{^XhHNy_K9i`}|kW(AN7daK7tr1}i@uNm;xl$hD`@ zUyeW5RaQR@*;rQ5)^`H;YkU`cdAqlJ%+m z97eIR?Sd@sqt|Mu?za{4e2{bXHoAz&E zRHy%`$kus$t3RUB%j-}1$cj_{_6j@4y_kn%DlYN>vQ63b2kB$z&aX4NzB!2f5Lo@T zoRD`&-&4Wf5oPC{!st9X<5Koc$T`pZU@XpC$*AnS4>4*Z=R9TWTTcC16?X3Cus&xJ z_jzDzCUK4yvitfTT|esG&sB8Wu1MBH51W!pkKYFT3-Iwfglqz$UtP$?^$BGRqW?5< z4@~A?fV^EL8^@Dv`wM$_#md@y0lADpo5=*;-1Lln%)xZ9Q;gXhDSPMT)X%E0=b~QO zXF&8jRd`CJSN53@{i`Z$9Xnsy&w1+O&u2vJ_X3;utf%ZVL(X{it+0D@zOv5{^~&1! zRm_1$t?%w0i;N-K%Yr%5v(RrTxFOaS6TaUTxnFVC{1rHBma*LouP*W50`89g zH*oSFBnIQW6)ZOjKDFY0i>xno$>Hz8-8sAsPTshDm%IS>Iqo}3AE{Bc*4CYmf9v8- zbaI|?*1Q|+9CH|d5fJ{nudYS)DbR zGjvS7|E99BPPO-ZwY`7o2?R{cf;a zS?_;9wq7#NdjBJwd}{9=aB8ot_dmg_OTFIbVUHttEELZybH?sc9dVd@_{?y0c6JT}m_as=Z ztoNsojoY=wRN*b*cBs;O_W0fs;?YZwi)kk9odt zhO94j$>HYU?i_9bC!c!X5}bO{N9yV2V0Eddt-x|+eZB(OIc2?XjU0dK<8K?Vy7-#{ zmMi^ji>$x0-lrnRpZfUQ4y-Qzrh(UJ>O@7t!H)CWX{kr z^**bzu}-!3e6`(y(erjx{s;A^?3nX^1f26PpT&>DtNSK#_?_c1u$(p0ex8DD)|a|} z(x0X4U+h`?8T4OZ{SVTUqkqH6AHrXY{5tFZneUHy!L6>e~05(dId*n?c{6 zZd_vbVcg2{iD?!%F_rgz2Y7YHWQ;q4jUjh@CuF%%bh+a@BRfx>{yq1Tz_}mlbM_~L z)xCjy`rTVOerAKUHAnGt8gl%okDt@Q>h$AxcIEha4OlLtu6K@w>jV zYg>1(1DhlN7L^=Xce}x>`+jvMyMyKW(0L|{!8XrC-5&I}&^-fj{O<{lfA?%m`riv) z-KCZPy}@#w_em$VeUR5R_x14VzK$n-?F)9kyz%9(?1${%0@UYwe=k_x7HMO*!XCWMj0iYtB*d+BheBI2zgY^`}1P|4wku zu&l3R;ML`<-UZf&yw6qt2L5jFM)Xl|>Sh30J~qdKy&I*?LS*^a41%ru(x#3qpZMPc z*0*!j<=MIjY;5YwbMbugY`tI{&q8GDUVG2X{rk6?2H5@kx0>?Za~!<7ynBuZ%b6qZ z*K)AU`=xG(E@w@M-J8##C1Cvz(sSR3;p9^TO|YEZmb%Fqy%#<{${dZrtIHWJ1G`uG zy z%h_OmckmsRyqp6kpS+w4mb2TEmovz%@9dAjyM}f?J6AEvxrX(*8Z4J{^;z^$Wck>9 ztg9x1szl7X(ooo8{Zn?xXge+I?WeKu;Y=$eFGIvcl zdGGHQ)Qv5lqke*a@2+Fc;A(Krpsb;v!mG=>_ZqOA@5am6gP&EeMK&h6d~W(VoVMy> zcOBTcO1tafv{h%UH!|9M)~LIIE@!-A@1OfomQU^71U3eL%LsQfoa@OA<8KOnZ-LV` z@~vR){Jf?9cVIbxxAOCi+-=D6&dukv+rjeRsd8`!SkB+Ku7UHj++7vtZ(RATba!Q= z&fNQ4-kSaRJD$%6_12s7w}Dr8UFGkd%AdcHWsN__3_YX4K%)Pq%=yK*-oLadboVp*yKKJzjcy;9&IlqZN@9)E4bC~=5H?U_RADc(O z=07%%f;}I3_vd*`W53$?+hfjSI-GnyH_rge`FmvMZIA5w<-A#N@;RR!z|NJ=`RoeL z`KZtNyb7$&7~J2EV7b)IF}w~=KC$lxmMdf51Gzi)J>ldN`(9w@ z$|v?WfD^m=#J(R`U1Hw{ESK1yCPvpAEMo6N-<|h2!pSH01Hp1-><1z1uiW!|IQhi> zCa`nm6MH{6v8zw)Zw0GM>pqLanIm7ubp)Jz_H!gyuH4U2$gWY& zI~qEQAHGYhzwwogy3Cyf z)}J}b+zr9<<=mH5HtI5W6R^B~Gj}tvymvS2ZeH1_EAPI~=_mL#)7aL4uVVBW?sMWk zy7PQK#Ls(qR%_>P{&}~J!1@03o#gvbSvzy*`*T^P&v&Io%$Ku;TU>FteUWQaoTmBB z^*A`^Yp=c!opJc@OpZtPb7?-q%?A&`$*;!7-)xtF^&xMpCo;-qFDHZLMzJ-1^YVTI zkWbD}LYC`8XWjU{_!MN<_B~R*<39keE_SCDb_3XFjnm-OWsTFp&Xv#KP(KKkpG=Rx zGr{XxcO|^K?CX?u>}wTz`3>2F`}{Dn`G=~hODt!B^`}0c>COhr8_$OP&C2=bfStb! zUA?trj`F?xTsZfjoxJ(q8*Ki?bHM)F5pgfre>WiRV|1>2naj9fz@1|-sL4ef|rLp1ns^cU?47{L=B0%2ndnI6(|vs+I#nj zx+JTCWYs*DpefDR1V>}QO1isj5fLIJHlh%PN{DgLP-+^TX4;;+E;i$I`lHjCW~TXO z&N<)feBXD^J?DJiQEZaQZ^!@j$vyl{zqa-79o@RdHU&cvLl89YoJjEwIeD)1kucw%N`^C0jd^YPB}=XDrc{|xwHl~a>b_HJVt@BwE^&Da>q3>4}t=L z%wI=%{4w9ip`#8+`;lA}OH4lq8+b83+~5dge+h+Wv1AARWo|4{l*YxM^h+#h%CU+F zd3Mt=C^%6zl_RhQM7fpH0@^aE|8gIakc}3A4`kLo)H1;=El0xY;2UNcluc+z6N4;* zd^@0ApvSCHkWM8d^0+8Kp}hnIZ2@CqWRovZYD9vfjv7FB!_a0G1?E{S{swm*W_NNW zzK~xzG|hFWUWS(RNic=fn(zeH0u$KU>X7(fx*}wAPs_IKJ-?zlbU`o4Ll%6;d;Mo> zq4>UdnCDNk-X;AO!@ z7*fF9U%@@|ve$NZ^U|V{x&33=ZjvV#C%z-jS(YsqAvBhXkroLr=|g8)r#x-2H?s?V zyoJ4HSiZVnp56~HnWa~^^rj8>X7sZc+1MFp&F~Z7$t3Mi_$<0#|Xt_f59{DYkN7oO*6E)vz$KWU(qzDN!C`AyAO0#$m2g znNupv4HayF^FL4uG{b^M&_lvTl2c>n)Dj$xRj_Lw**%Z!QgIlCVf5=CsMSk2jVeyv zFglHK>K|yT1i-=r&1oRAbAXO!LICV|EqFNcw;o;^5M;_kG0(nc_5`mXkbuD6_W(YZ zCV{{P_5e9WQx9jU`lDcY{>(V6W)_R^s!`&LK8V9hK=KGamzuv*OqpTW!$Vz4L(Ex7 zjIiOs0eM!7Z|oC&h&*zw3bEt+?9l^u$3UCNuZ{3)m-ro{*0yI3SoR%^)5~x;jwO4Z zatA{p+o7g6V4@bKJ~@Ff8@d7P@!x_mgq>&2W(6r;;q9EcozIKzi#eCohi3Q1OruCv ztSJvYH?-2qULTGIYS8-A- zZZV2clQspph|s)#YX8XC=GJEpUpZ1dHjdD{W4XvFSR7dyiTaIV8-kFeI5t`viv7`r zmk<~7?5EUK+6uLz zvUZ!grZlTsT~bw68ibTwrHB%;nf`92O0w9(7d&q9%YVO0aJ#v=N+(f~+ADvushD<->%TjAd>q^_GV@HLp z=gkG(2Y})ZJ>BKJi#{iJ&)lxM*?c>{S|?EjA(3Mgv5P!UUmkRVC_6|(pQO~MQ0!Hs zBvu@rhaoC60z5prEvv$dVJJoP!UX4oPFUfda*g*5 z4@_6sPV^W@hEC+v9%(-U7Cm%ta_X7%klM=aTdPVHHwR`v9=|qqb^^#+wR4!P;8MDxPzqS(uKvy1vtVk86B$?pEvp`JgSZ*CpR_dT^1%&lwCmPxCtch;$y zbXr?zST(F)#n`MYdm*>95U|S%S!)!-69zs~vgwdw5C)R^7Ic%Zax=g+I_fb&9D zF>}b6JzoIEBrX-^o(wA&!K<6(X@*{ljN&xx=G5AD@unf+ZA@^N5+w0t5iV!=Cv9Qn zq>o2UA3Deex8-UJd-dRMOP!YUBA3&UW7cXpjaqj7ZnKs!2M-1aW~_oqQdmt2Z_Em2 zm4YP99ezz5HY#Rr%W`sW##w#Fusr<~JM*kQ)4n^@A&|;FHq*KT=Op6Tw^mg*y!bVW(9X91m8LYGbFpDzb$O4Eo{)!kE_E5#9?ka zd_awUZUwixJl*E$yL!`FL+7X}Lz6QhptR`XJ6QCv$JzA4Q z?`z{SHHrRV5fb=l`Qf>Xp9Ay%gZjfpV1uZdjB^ZuJY3#OMY}<@9M1|uTvrIJ&t%wS zGvOhwD_CX_lIV!#x|5`YozD$O2u#Rxn5e^qO?ny@FMn5zvPQAuP%gKl)7KST5z5kl zXGio^*QeuMd7FPB?HM{Ya;&F2AM>l!Df2>EB|4=Nq~ohZ&Zj2h>>85GPQcw1&Q2s` z8x1S(-i^*mmc||DUr?dfaf36Mx1F@W!Bt$7FDpQUMXwy~OfH{omWI6HB+w!JxYN|e z8>aXvJPmk`_`P4N=XJRH$}dkJ%q{}?D~9_XNQI-V=ZBaGe4ApKgr}|od9;w#E(m_> zLf963^P%F;LN^DGwGc}{@{4>r<-4NAsYNNNF^*fz++(d@#2m;UF^;r?M9L)0vg*2; z2IbDm>N=1PQ-8{Z|3|q{O+Zi$IBP*j?sDcG!n{%pmmFMZL5xIkVh9q+&bK~$0BtEa zA&TH{Ln3?LF2gMWj;fh&zQCOwbBT9`ASep;g>)*%Ub=*a@k}q(>^x|c;u0@)0IuCj zJ-gJw^>(vsV-*_T1rU0)LA$hEwg8NDTg!}EuYBsQf}ISZXeF~QvIM9uTT|u zsX@3Et(@KHrG}-)(C4YmQK%3^HZcgFigP>29i8Z7Nry40-B(5)Cb{jtZj~ZxQB=r% ze5C(eQ}&uDlmoQ2lhVZ_&I%dCOGWA-^dt`su*CA56|967Y(^`$b5!I7itB80!W4m5 z?2({XA}q0pOKS*>yS|*Ah(w_%uws2f7u@As4kwOVzlZU`L_CWu(Lw|lwJx#IpIPuQ zh^vF^{I)|r3)AKf#gOPyv~9L2K#xFD(yoLBr;hUmRc;3)!FbUdm3oIR*?O^wW?beR acc4zKB7pH$Gw;pK3Y!4lbl~qn&_4j7(=0{+ literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/sun_depth.frag.msl b/src/shaders/compiled/sun_depth.frag.msl new file mode 100644 index 0000000000..71e55252a6 --- /dev/null +++ b/src/shaders/compiled/sun_depth.frag.msl @@ -0,0 +1,67 @@ +#pragma clang diagnostic ignored "-Wmissing-prototypes" + +#include +#include + +using namespace metal; + +struct FSInput +{ + float4 pos; + float2 uv; + float4 color; +}; + +struct FogUniforms +{ + uint coverageMode; + uint alphaDiscardEnabled; + float alphaThreshold; + uint alphaToCoverage; + float fogStart; + float fogEnd; + float4 fogColor; +}; + +struct main0_in +{ + float2 input_uv [[user(locn0)]]; + float4 input_color [[user(locn1)]]; +}; + +static inline __attribute__((always_inline)) +float Dither(thread const float2& position) +{ + return fract(52.98291778564453125 * fract(dot(position, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))); +} + +static inline __attribute__((always_inline)) +void _main(thread const FSInput& _input, texture2d tex, sampler s, constant FogUniforms& _55) +{ + float4 texel = tex.sample(s, _input.uv) * _input.color; + if (_55.coverageMode == 0u) + { + if (((_55.alphaDiscardEnabled != 0u) || (_55.alphaToCoverage != 0u)) && (texel.w <= _55.alphaThreshold)) + { + discard_fragment(); + } + return; + } + float coverage = (_55.coverageMode == 1u) ? texel.w : (fast::max(texel.x, fast::max(texel.y, texel.z)) * texel.w); + float2 param = _input.pos.xy; + if (coverage <= Dither(param)) + { + discard_fragment(); + } +} + +fragment void main0(main0_in in [[stage_in]], constant FogUniforms& _55 [[buffer(0)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]], float4 gl_FragCoord [[position]]) +{ + FSInput _input; + _input.pos = gl_FragCoord; + _input.uv = in.input_uv; + _input.color = in.input_color; + FSInput param = _input; + _main(param, tex, s, _55); +} + diff --git a/src/shaders/compiled/sun_depth.frag.spv b/src/shaders/compiled/sun_depth.frag.spv new file mode 100644 index 0000000000000000000000000000000000000000..66411cc65ffd316e2ba05cc30a876797bff13471 GIT binary patch literal 3312 zcmZ9N+j3M@5QcXM6Ht(YgtHZPLGKqKwEHAwC z!e`J@U%@Kh$SbR~EVcZ;y;sAOyXvp*{`;_c^;&DDbItyBS=Nzl$ku0HW#zXuTLY89 zbrtgbrHM;@%dP3Yfn(1Zu_@~;0*%>B-ddzssMZ&Ctb$L#=U@x5`d9?5GpitfC$R$C zo>PI@fN!kcnyWPruFmui!Bnz`;g%Z9^;W%6)HZJu+_{O1i%TmlIxKA{{jh|Z5~-+ zPy0)|&<~(57kniC;@V_zFtS!$q=BLdq>v}4suQ8g+_n^DY@x!I z{dpen8eVs6g&oh}sM*k(ZHoJ+kRBculikP*Ti#(WFrMMG?-RCKl zb-W`b=Sh{Ecc$dZ)AGFUz(wuz*v`8b_=WvAy0g*t4BGwL5B#0QJdC}NW`J7MR0iic zxQ=rR&K$Y*ZJaZg+t|jLBe$iEbIx+zZJcwK%Yl768{q6X#Lx)+zTDyQT@~*KD8EfvQ%U*2j zc7XOTY;&BWpRq&9cJ_XI=z)uy^gl|FiwU zbpOT=Aamf?L*Kr4Ibr`H)nlH=(aks3ezd(8aB)9z#M0Hnu^-S7;l|Vf&Cco z{r?OY@A(?9ZA{ev0^NS2{+H;+d;Z328)Lk0<1Wyz?@qD@(?0KE`~M{W4-+^EoPo3V z{rmYgPmpVG{zp0we}kg`?TP;`nmx zp8>|m$9Ww=cWuurX3~c)f0aD%#IwL$`8cwO_?HPyUC*y@u|Z`kc!I($Bf*dmYF*7xllnmFjZ774;GH*!NX*`)EIlx3J~o zEZ#ghN6ZcM98^KXOrgtf z;SuC)(24}3c@Yv0O3;;*oeb?A$UllQZ4Yy0N)`5Wkd8(;&FkNdKO?wb0%8%?C2 TcSGMTAm<%WkGmlkzoY*Fs`CWl literal 0 HcmV?d00001 diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index 0cfd652612627f44220f84a386598de46c795b4e..ccef158762a18ba246c15c9e17ef03a727179c0b 100644 GIT binary patch delta 5720 zcmd5=dsI``nm;EwoIFUv;b}s6oB*aEsDWajh?v3hGlK(O+NfEJZDPhzZ~ z!Jty8H4$-aYkR>bRPE#?AVrH7TPi69o6=lcJJ#A>+UdP(c6fB!wPvmPW7e#7_u{Ox z_x_&y_kG{acNovOAjyyvh{WH)yGobO3%|3!JZ;sxpN%xZ5Co;hKoAMMGr^PNTZ2s{ zc$$e2)Q>@s2W!e0g-PZx_$5LF!MqF3fGOrKxYCaRm2L%pV55J=@&1Vn1O#YUt`Ef8s-{VH+bi2C)z z@j4L`j@JgoW9wd4-(f-PN}$r?uw@sjcC#RD2^9YpY}t*fAF!ZveXmE|Plv{Lt79>; zC!GO7yO|Kw20RZZ=9sbw!IDF?%I_ZL(#$7Fk*X4{Ad{`vjNlmJ*WE)Qz~xMaz6C#} ziBMV+oozUF8_}5fWXX9Br@5Yk8kGHmcYAWJ^-b5lSW<5<&qn;Ez3KzEM>ihX)cSeb=217IY2lKQi!evE;M*9K z)`E9yB0Jv*PpnQf1g6oIGICkrGcR!abxoj8w zbDU70R%&dycAS2#>)MT6j9jS|)Uh#1$otRN>I@-X8Bu#f7&&f_ni9r0I}n)hy;>Ex z@vTh-o9;35?ykrft(@XEGu|E=zY-YMq;`8<3G#2a1qu+#mdX&HG zCvIO>Z}TogR@#&G-(+2eg#{BI=+e|WE+hT;jca#%nr2dEnZ3TTD zNYmFn^%px-jmaIyt+$2OZg$-6xYpy>)3mz2spIa=aw%5O{p&PmwuZr+VV>cgI~;Gs zf}c~~bg)x%BTR(IvUD3By51W45+|%wt{p;m+O}1k9ei&(Uk=9SzF*d`=;6(BqSozL zc~vN;*4RpXWYtVQc^e<*RuHuw$6Zq85Kv~~tbO|FciR%#@0iagj;ir1%0^)4lz>#` zxpU9r@Hp-bcn3U_d^~&c=84JHBQ&6B+Y?tzA}TYuEyVwOowRo#OVKGXmf-iG>% zM{d;5AqJwH0@Bc{>~K!|(J=YIefG}4_ZH9C@IbHk&X}7|s}Ya}5ly^~PCdt@gvC>$bd&R$GrFZNr$JXr%uBC-vD0sN z3r@D7GN)izysV7;o!rSAaxTlkzLN#;kzWKS7be|o{HXcvyy4N!;eWZ;Hi}rKI*OKE!ELgj-BNNf@39}!ft7y(=kn2-Ry#baiv$3Gq8>Nh|w{h{m1^=NI!+!mGEHY^kovRCxy;eb{?%+&FY( z;?b>p$?Q8c|x3$IeJC_an^sG(1vNopeqT^UUScv=4d`gwNIhCKk9v+kv&Vpk}}Gh4e!Bxo5yH+%AZI>_0MJQ>O~_ zzg#chL`dEI;g3`B9Vl=z_Hw!ZsPdOvU-`o?gh=u;Y|rlQYh&l z(&oz{f{&SQ4h~quC%b(jYoQ;LkiN|M&j)^#BRROmeTkCq{Cer3#ktQ)EW=NvX0Vf- z?b}%qcv}x_nactq%=-f984o{xCi+J1bKk#lJ@w!EMe~)uE+;#1rt4XU{JHDlf&ICz zXEie2_0&#xJ>&n{U617d-t`nx%@ILU|1T|17-)H-Mbqt0JGRCeaVCC$O1wT$9TTr1 zSZh%Ar!1)Ie{W%0A@f1fqPdO*TmwU>oEL8cWo9gOs^eS;hwf6_rrQ;L7l#venqx31 z`EgE1>dhhSmf_UKmaWWi$LG9EX{xY5mkbnqf@my!+~tzGq;N2jhU+MV=gS3#16Bh} z@Ij4=RVE-G+Gf;1T=GsO$~M8YmeVX$M!Zv-^E3_V zlutPXG(HwI)M!WSj3JrWrv=7uhaH{lEgpE_|Db$Pqpw=E(z0N^b`-;c^(Wi#kTFzq zlAk0AKVuK?6tZdMf^It-vo3Ii@7Z%WrWFtQ(ok$9E>RNsDw9sgK+|eQa&6 zo5Fd$TQ_ji=JOtyCVB=z-?`$*jV0Hbj&$Wx4yP2=E~+Z7uH0FrD6Y=aCZ7=l{$uNR z9h2}^&db`spC7Nw04zXr)oy9!wu&0Slz(19m;Z}hQ!JGn2OnMFn;{sHMApvH>tyd~qP%t=-A5iG9b=Ef(Q3O|cjdI|RR5L>E4>$G2!B=PWWWj+0I)se61D zrwxucqE8VPcr+~4jL(`K{uT@MZ8fQ6)@O8)Uc2CoBg!)CGqVS$zS~LNV*(lifXmPq zB35=la(-xHr#3vlodWY(aipE1lm+gx^TE+a3sy|+g8)T`%0R3(K zGIA2;Q9O%9Z`V)FMzlHXA11~mj(pq6DCC6UoJJ5(qn!va6>R?@;9E80&Jg3FAgqWJ zGz^e0;Mw{XAgblF`E>1i_Eq9iWL2h%_@bqLwG7}dlRzf|btG^owZ{?XnTR}kAj&IW z_-V}iOQ6l^D^7Y8$E|KX_sIIPTXk4K~quHrbgF!ekRJX&c z0q!vOMFAhD7jD~rm^qjdm&IFa0scN#iSQeO>w?9|VX*pHgzu*>=0vk)qUC&-zOGD7 zoEm{hkGfz6s9c$^-b0O@eY~0J3&sm`(<8?2KACt^f1lx!=@7k~6TRL4%I|o_o@2i@ z5#3I)^W2!442-9)<;`3kTlP<>vP$*+r6Rl~&{g8HK_Fk=2}?etn3*n^$7+(z?#^3% zsAzVVnb2g@!XP<(*PQY?xfbb`uM$N2R}jG-3ihOTvyDiY;4$kUxk~)YRu;}>Ci8p| zC|)(tzI-dia$6tItRTw}+Ex_{e`+>7f6a2o@(YVnIhY~#tN@5v0A*UtFK1Z10*Gmj z+U0Lvr$?nJ-4@n#Oo`8~^0f0`211a5t!2ZyjfMnj7L5V!it(?Se(k5vW95 zzVfKBRU4=yf^wRA4OvkeyULfQs+w5iY~pR+x-MF{2V8_&KW$wS8C(%{;P#rvWC8z~ zCY#&GIg=h0Cu8lUT4Dn?(_Tu58+nBO&^1B7uW+(meFufh4YbEyMIa74p=kC4XgPlv z24!$sbI@)Y=V(c#76mV^);JD_dzm!K=BSujbrvlMI1B|IS@O0yBiSr>;l9Gfp5JKB kcsn>H@K59fv+PggR0@%11pnb9fWBc9`tP*`U_Lkg3!m6BTmS$7 delta 4490 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 W1xJHQ2Oe_JX7lE<^`MH*eg6%7b5#@o diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index 6f1fd90fdc..08606d250f 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -25,6 +25,8 @@ struct SceneLighting float4 sceneFogColor; float4 sceneFogParameters; float4 cameraPosition; + float4x4 sunViewProjection; + float4 sunShadowParameters; }; struct DynamicLights @@ -63,45 +65,76 @@ struct main0_in }; static inline __attribute__((always_inline)) -float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _64) +float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _36, depth2d sunShadowMap, sampler sunShadowSampler) +{ + if (_36.sunShadowParameters.x <= 0.0) + { + return 1.0; + } + float3 lifted = worldPosition + (worldNormal * (1.5 * _36.sunShadowParameters.w)); + float4 clip = _36.sunViewProjection * float4(lifted, 1.0); + float3 ndc = clip.xyz / float3(clip.w); + float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); + if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) + { + return 1.0; + } + float2 _step = _36.sunShadowParameters.zz * _36.sunShadowParameters.y; + float visible = 0.0; + for (int y = -1; y <= 1; y++) + { + for (int x = -1; x <= 1; x++) + { + float3 _179 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _179.xy, _179.z, level(0.0)); + } + } + return visible / 9.0; +} + +static inline __attribute__((always_inline)) +float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _202) { float3 light = float3(0.0); - uint count = min(min(_64.dynamicWorldLightCount, _64.dynamicLightCount), 32u); + uint count = min(min(_202.dynamicWorldLightCount, _202.dynamicLightCount), 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _64.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _202.dynamicLightPositionAndRadius[i]; float radius = positionAndRadius.w; float horizontalDistance = length(positionAndRadius.xy - worldPosition.xy); if (horizontalDistance < radius) { - light += (_64.dynamicLightColor[i].xyz * ((radius - horizontalDistance) / radius)); + light += (_202.dynamicLightColor[i].xyz * ((radius - horizontalDistance) / radius)); } } return light; } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _30) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _36) { - float scaledDistance = fast::max(eyeDepth - _30.sceneFogParameters.x, 0.0) * _30.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _36.sceneFogParameters.x, 0.0) * _36.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _30, constant DynamicLights& _64, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _214) +float4 _main(thread const FSInput& _input, constant SceneLighting& _36, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _202, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _358) { float4 texel = tex.sample(s, _input.uv); uint2 sizeQueryTemp = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); uint maskWidth = sizeQueryTemp.x; uint maskHeight = sizeQueryTemp.y; float2 visibility = groundShadowMask.sample(groundShadowSampler, (_input.pos.xy / float2(float(maskWidth), float(maskHeight)))).xy; - float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _64.groundShadowOpacity); + float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _202.groundShadowOpacity); float3 param = _input.worldPosition; - float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param, _64) * shadow.y), float3(0.0), float3(1.0)); + float3 param_1 = float3(0.0, 0.0, 1.0); + shadow.x *= (1.0 - (_36.sunShadowParameters.x * (1.0 - SunVisibility(param, param_1, _36, sunShadowMap, sunShadowSampler)))); + float3 param_2 = _input.worldPosition; + float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param_2, _202) * shadow.y), float3(0.0), float3(1.0)); float4 color = float4(texel.xyz * light, texel.w * _input.color.w); - if (_214.alphaToCoverage != 0u) + if (_358.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _214.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _358.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -110,24 +143,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _30, constant } else { - if ((_214.alphaDiscardEnabled != 0u) && (color.w <= _214.alphaThreshold)) + if ((_358.alphaDiscardEnabled != 0u) && (color.w <= _358.alphaThreshold)) { discard_fragment(); } } - if ((_214.fogEnabled != 0u) && (_30.sceneFogColor.w > 0.0)) + if ((_358.fogEnabled != 0u) && (_36.sceneFogColor.w > 0.0)) { - float4 _268 = color; - float param_1 = _input.eyeDepth; - float3 _278 = mix(_268.xyz, _30.sceneFogColor.xyz, float3(EnhancedFogAmount(param_1, _30))); - color.x = _278.x; - color.y = _278.y; - color.z = _278.z; + float4 _411 = color; + float param_3 = _input.eyeDepth; + float3 _421 = mix(_411.xyz, _36.sceneFogColor.xyz, float3(EnhancedFogAmount(param_3, _36))); + color.x = _421.x; + color.y = _421.y; + color.z = _421.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _214 [[buffer(0)]], constant SceneLighting& _30 [[buffer(1)]], constant DynamicLights& _64 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _358 [[buffer(0)]], constant SceneLighting& _36 [[buffer(1)]], constant DynamicLights& _202 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -138,8 +171,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _214 [[ _input.eyeDepth = in.input_eyeDepth; _input.worldPosition = in.input_worldPosition; FSInput param = _input; - float4 _315 = _main(param, _30, _64, tex, s, groundShadowMask, groundShadowSampler, _214); - out._entryPointOutput = _315; + float4 _458 = _main(param, _36, sunShadowMap, sunShadowSampler, _202, tex, s, groundShadowMask, groundShadowSampler, _358); + out._entryPointOutput = _458; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index 5a2f1c9f6fcc79cfe7d8025260955eae64173bf8..2e26f686c774d0f8a2da7bcdfc782fe6bd0774a8 100644 GIT binary patch literal 12112 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 1e-12 ? value * rsqrt(lengthSquared) : float3(0.0, 0.0, 0.0); } +// How much sun reaches `worldPosition` (Enhanced sun shadows): 1 lit, 0 in the shadow of what stands +// between it and the sun, softened over sunShadowParameters.y texels. 1 without a shadow map or +// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself. +float SunVisibility(float3 worldPosition, float3 worldNormal) +{ + if (sunShadowParameters.x <= 0.0) + return 1.0; + const float3 lifted = worldPosition + worldNormal * (1.5 * sunShadowParameters.w); + const float4 clip = mul(sunViewProjection, float4(lifted, 1.0)); + const float3 ndc = clip.xyz / clip.w; + const float2 uv = float2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); + if (any(uv < 0.0) || any(uv > 1.0) || ndc.z >= 1.0) + return 1.0; + const float2 step = sunShadowParameters.zz * sunShadowParameters.y; + float visible = 0.0; + [unroll] + for (int y = -1; y <= 1; ++y) + { + [unroll] + for (int x = -1; x <= 1; ++x) + visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); + } + return visible / 9.0; +} + // Point lights reach as far as the terrain light they come from (linear falloff over the // horizontal distance); the wrapped diffuse keeps MU's soft shading and leaves the far side dark. float3 DynamicLighting(float3 worldPosition, float3 worldNormal) @@ -161,11 +191,16 @@ float4 main(FSInput input) : SV_Target const float3 light = input.lightDirectionAndSpecular.xyz; const float lightDot = dot(shadingNormal, light); - const float luminosity = max(lightDot * diffuseCurve.x + diffuseCurve.y, diffuseCurve.z); - const float3 dynamicLight = input.worldPositionAndDynamicLights.w > 0.5 - ? DynamicLighting(input.worldPositionAndDynamicLights.xyz, - SafeNormalize(worldNormal)) - : float3(0.0, 0.0, 0.0); + // In the scene's world (not a model drawn for the UI), the point lights and the sun's shadows apply. + const bool inWorld = input.worldPositionAndDynamicLights.w > 0.5; + const float3 litNormal = SafeNormalize(worldNormal); + // The sun's shadow takes away the direct sunlight only: the ambient part and the point lights stay. + const float sunLight = inWorld ? 1.0 - sunShadowParameters.x * + (1.0 - SunVisibility(input.worldPositionAndDynamicLights.xyz, litNormal)) + : 1.0; + const float luminosity = max(lightDot * diffuseCurve.x * sunLight + diffuseCurve.y, diffuseCurve.z); + const float3 dynamicLight = + inWorld ? DynamicLighting(input.worldPositionAndDynamicLights.xyz, litNormal) : float3(0.0, 0.0, 0.0); float3 diffuse = saturate(objectLight * luminosity + dynamicLight); if (RollsOffHighlight(diffuseCurve.w)) diffuse = RollOffHighlight(objectLight * luminosity + dynamicLight, diffuseCurve.w); @@ -180,7 +215,7 @@ float4 main(FSInput input) : SV_Target { const float3 halfVector = SafeNormalize(SafeNormalize(light) + view); const float highlight = pow(saturate(dot(normal, halfVector)), specularParameters.y); - specular = specularStrength * highlight * sceneLightColor.rgb * objectLight; + specular = specularStrength * highlight * sunLight * sceneLightColor.rgb * objectLight; } // Rim and specular are light added on top of the surface, so dark textures still get an diff --git a/src/shaders/sun_depth.frag.hlsl b/src/shaders/sun_depth.frag.hlsl new file mode 100644 index 0000000000..a6df7335b9 --- /dev/null +++ b/src/shaders/sun_depth.frag.hlsl @@ -0,0 +1,44 @@ +// sun_depth.frag.hlsl — a draw into the sun shadow map (depth only). Pairs with +// basic_textured.vert and skinned_textured.vert, whose matrix the sun pass replaces with the sun's. +// FogUniforms mirrors FogUniform, whose fogEnabled slot carries the coverage mode (SunCoverage - 1): +// solid draws let the sun through where the scene's alpha test drops their texels (leaves, fences, +// hair); a character's blended parts (wings, capes, auras) cover a texel with the chance of their +// alpha, or glowing, their brightness, which the shadow's blur turns into a partial shadow. +Texture2D tex : register(t0, space2); +SamplerState s : register(s0, space2); +cbuffer FogUniforms : register(b0, space3) +{ + uint coverageMode; // 0 solid, 1 by alpha, 2 by brightness + uint alphaDiscardEnabled; + float alphaThreshold; + uint alphaToCoverage; + float fogStart; + float fogEnd; + float4 fogColor; +}; +struct FSInput +{ + float4 pos : SV_Position; + float2 uv : TEXCOORD0; + float4 color : TEXCOORD1; +}; + +// Interleaved gradient noise: a threshold per texel, even over small areas. +float Dither(float2 position) +{ + return frac(52.9829189 * frac(dot(position, float2(0.06711056, 0.00583715)))); +} + +void main(FSInput input) +{ + const float4 texel = tex.Sample(s, input.uv) * input.color; + if (coverageMode == 0) + { + if ((alphaDiscardEnabled || alphaToCoverage) && texel.a <= alphaThreshold) + discard; + return; + } + const float coverage = coverageMode == 1 ? texel.a : max(texel.r, max(texel.g, texel.b)) * texel.a; + if (coverage <= Dither(input.pos.xy)) + discard; +} diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index 463efe869e..3ad849f0a0 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -8,6 +8,9 @@ Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); +// The sun shadow map's depth (Enhanced sun shadows; a far 1x1 map without them). +Texture2D sunShadowMap : register(t2, space2); +SamplerComparisonState sunShadowSampler : register(s2, space2); // Per pixel, 1 minus the darkest ground shadow there: red the sun's, green the point lights' (white // without shadows). Texture2D groundShadowMask : register(t1, space2); @@ -32,6 +35,8 @@ cbuffer SceneLighting : register(b1, space3) float4 sceneFogColor; float4 sceneFogParameters; float4 cameraPosition; + float4x4 sunViewProjection; // world to the sun shadow map's clip space + float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units }; static const uint MaxDynamicLights = 32; // mu::kMaxDynamicLights cbuffer DynamicLights : register(b2, space3) @@ -60,7 +65,32 @@ float EnhancedFogAmount(float eyeDepth) return saturate(1.0 - exp(-scaledDistance * scaledDistance)); } -// The terrain light's linear falloff over the horizontal distance, as the grid adds it. +// How much sun reaches `worldPosition` (Enhanced sun shadows): 1 lit, 0 in the shadow of what stands +// between it and the sun, softened over sunShadowParameters.y texels. 1 without a shadow map or +// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself. +float SunVisibility(float3 worldPosition, float3 worldNormal) +{ + if (sunShadowParameters.x <= 0.0) + return 1.0; + const float3 lifted = worldPosition + worldNormal * (1.5 * sunShadowParameters.w); + const float4 clip = mul(sunViewProjection, float4(lifted, 1.0)); + const float3 ndc = clip.xyz / clip.w; + const float2 uv = float2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); + if (any(uv < 0.0) || any(uv > 1.0) || ndc.z >= 1.0) + return 1.0; + const float2 step = sunShadowParameters.zz * sunShadowParameters.y; + float visible = 0.0; + [unroll] + for (int y = -1; y <= 1; ++y) + { + [unroll] + for (int x = -1; x <= 1; ++x) + visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); + } + return visible / 9.0; +} + +// The frame's first point lights, which the ground's vertex colour leaves out. float3 WorldDynamicLighting(float3 worldPosition) { float3 light = float3(0.0, 0.0, 0.0); @@ -88,7 +118,8 @@ float4 main(FSInput input) : SV_Target const float2 visibility = groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).rg; // The sun's shadows dim the ground's own light, the point lights' shadows the point lights. - const float2 shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); + float2 shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); + shadow.x *= 1.0 - sunShadowParameters.x * (1.0 - SunVisibility(input.worldPosition, float3(0.0, 0.0, 1.0))); const float3 light = saturate(input.color.rgb * shadow.x + WorldDynamicLighting(input.worldPosition) * shadow.y); float4 color = float4(texel.rgb * light, texel.a * input.color.a); diff --git a/src/source/Core/Utilities/FrameProfiler.h b/src/source/Core/Utilities/FrameProfiler.h index 2de998d990..330edf72f9 100644 --- a/src/source/Core/Utilities/FrameProfiler.h +++ b/src/source/Core/Utilities/FrameProfiler.h @@ -46,6 +46,8 @@ enum class Pass : int ObjectsDraw, // The update's effect spawns and poses for the drawn characters and map objects. UpdateEffects, + // Inside RendererReplay: the sun shadow map. + SunShadow, Count_ }; @@ -53,7 +55,7 @@ inline constexpr const char* kPassNames[static_cast(Pass::Count_)] = { "Terrain", "Objects", "Chars", "Items", "Effects", "Other", "CharWait", "MoveFx", "MovePart", "Skinning", "UI", "RenderBegin", "RenderEnd", "Submit", "UIUpdate", "RmlInput", "UILayout", "Flush", "Sprites", "Particles", "Joints", "Overlay", "RmlUpd", "RmlRend", - "EndOffscr", "EndStage", "EndReplay", "EndPostUI", "ObjAnim", "ObjDraw", "UpdateFx", + "EndOffscr", "EndStage", "EndReplay", "EndPostUI", "ObjAnim", "ObjDraw", "UpdateFx", "SunShadow", }; enum class Counter : int diff --git a/src/source/Core/Utilities/Log/muConsoleDebug.cpp b/src/source/Core/Utilities/Log/muConsoleDebug.cpp index e1b1c7fe81..7dde154b26 100644 --- a/src/source/Core/Utilities/Log/muConsoleDebug.cpp +++ b/src/source/Core/Utilities/Log/muConsoleDebug.cpp @@ -127,7 +127,7 @@ bool CheckDeveloperLookCommand(const std::wstring& command) } if (command.starts_with(L"$lightmood ") || command.starts_with(L"$texfilter ") || command.starts_with(L"$lighting ") || command.starts_with(L"$dynlights ") || command.starts_with(L"$post ") || - command.starts_with(L"$ao ")) + command.starts_with(L"$ao ") || command.starts_with(L"$sun ")) { mu::log::Get("render")->warn("{}: not understood (on or off; $lightmood also takes 0 to 100)", Core::Text::ToUtf8(command.c_str())); diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index 577f251d3f..ad5b62a351 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -49,6 +49,9 @@ constexpr std::array Infos = {{ {LookValue::GradingStrength, "grading.strength", 1.0, 0.0, 1.0}, {LookValue::AmbientOcclusionStrength, "ao.strength", 0.0, 0.0, 2.0}, {LookValue::AmbientOcclusionRadius, "ao.radius", 60.0, 10.0, 300.0}, + {LookValue::SunShadowStrength, "sun.shadow", 0.0, 0.0, 1.0}, + {LookValue::SunShadowSoftness, "sun.softness", 1.0, 0.0, 2.0}, + {LookValue::SunShadowResolution, "sun.resolution", 2048.0, 1024.0, 4096.0}, }}; constexpr bool InfosFollowLookValueOrder() diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index 43f13de919..62a3b5ddd2 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -51,6 +51,9 @@ enum class LookValue : std::uint8_t GradingStrength, AmbientOcclusionStrength, AmbientOcclusionRadius, + SunShadowStrength, + SunShadowSoftness, + SunShadowResolution, Count, }; diff --git a/src/source/Render/Lighting/DynamicLightsSetting.cpp b/src/source/Render/Lighting/DynamicLightsSetting.cpp index 5b3dfc348f..5143189039 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.cpp +++ b/src/source/Render/Lighting/DynamicLightsSetting.cpp @@ -4,6 +4,9 @@ #include "Core/Utilities/Log/MuLogger.h" #include "Render/Lighting/EnhancedLightingSetting.h" +#include "Render/Look/LookProfileSetting.h" +#include "Render/Renderer/MuRenderer.h" +#include "Scenes/SceneCore.h" namespace Render::Lighting { @@ -28,4 +31,11 @@ bool DynamicLightsActive() return s_dynamicLightsEnabled && EnhancedLightingActive(); } +bool SunShadowsActive() +{ + return SceneFlag == MAIN_SCENE && DynamicLightsActive() && + Render::Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0 && + mu::GetRenderer().SunShadowsAvailable(); +} + } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/DynamicLightsSetting.h b/src/source/Render/Lighting/DynamicLightsSetting.h index f4225d1e63..4d00021105 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.h +++ b/src/source/Render/Lighting/DynamicLightsSetting.h @@ -12,4 +12,8 @@ void SetDynamicLightsEnabled(bool enabled); // draws Enhanced lighting. [[nodiscard]] bool DynamicLightsActive(); +// True when the sun's shadows come from the shadow map: in the game, with dynamic lights active, +// sun.shadow above 0 and a renderer that can draw it. Characters then cast no flat sun shadow. +[[nodiscard]] bool SunShadowsActive(); + } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/SunShadow.cpp b/src/source/Render/Lighting/SunShadow.cpp new file mode 100644 index 0000000000..745553bf70 --- /dev/null +++ b/src/source/Render/Lighting/SunShadow.cpp @@ -0,0 +1,84 @@ +#include "Render/Lighting/SunShadow.h" + +#include + +#include +#include +#include +#include + +namespace Render::Lighting +{ +namespace +{ +// The box's size and depth move in these steps, so a walking camera keeps the same box (and the +// same texels) until it has gone far enough. +constexpr float kSizeStep = 256.0f; +constexpr float kDepthStep = 512.0f; + +// World to light space without translation: light-space x and y stay fixed in the world, so +// snapping them to texels keeps the shadows still while the camera moves. +glm::mat4 LightRotation(const glm::vec3& toSun) +{ + const glm::vec3 up = std::abs(toSun.z) > 0.99f ? glm::vec3(0.0f, 1.0f, 0.0f) : glm::vec3(0.0f, 0.0f, 1.0f); + return glm::lookAtRH(glm::vec3(0.0f), -toSun, up); +} +} // namespace + +glm::vec3 SunDirection(float fallAngleDegrees, float fallPerHeight) +{ + const float angle = glm::radians(fallAngleDegrees); + // Shadows fall away from the sun: it stands on the other side, fallPerHeight across per unit up. + return glm::normalize(glm::vec3(-std::cos(angle) * fallPerHeight, -std::sin(angle) * fallPerHeight, 1.0f)); +} + +SunShadowView BuildSunShadowView(const glm::vec3& toSun, const glm::mat4& sceneViewProjection, float groundLow, + float groundHigh, std::uint32_t resolution) +{ + const glm::dmat4 sceneFromClip = glm::inverse(glm::dmat4(sceneViewProjection)); + const auto unproject = [&](double x, double y, double z) + { + const glm::dvec4 point = sceneFromClip * glm::dvec4(x, y, z, 1.0); + return glm::dvec3(point) / point.w; + }; + + // Where the screen's corner rays cross the lowest and highest ground. + const glm::mat4 rotation = LightRotation(toSun); + glm::vec3 low(INFINITY); + glm::vec3 high(-INFINITY); + for (const double x : {-1.0, 1.0}) + { + for (const double y : {-1.0, 1.0}) + { + const glm::dvec3 nearPoint = unproject(x, y, 0.0); + const glm::dvec3 farPoint = unproject(x, y, 1.0); + const double rise = farPoint.z - nearPoint.z; + for (const float height : {groundLow, groundHigh}) + { + const double t = std::abs(rise) > 1e-6 ? std::clamp((height - nearPoint.z) / rise, 0.0, 1.0) : 1.0; + const glm::vec3 lightPoint = + glm::vec3(rotation * glm::vec4(glm::vec3(nearPoint + (farPoint - nearPoint) * t), 1.0f)); + low = glm::min(low, lightPoint); + high = glm::max(high, lightPoint); + } + } + } + + SunShadowView view; + SunShadowBox& box = view.box; + const float extent = (std::max)(high.x - low.x, high.y - low.y); + box.size = (std::floor(extent / kSizeStep) + 2.0f) * kSizeStep; + const float texel = box.size / static_cast((std::max)(resolution, 1u)); + box.origin = glm::floor(glm::vec2(low) / texel) * texel; + // The light looks down its -z: the nearest point to the sun has the largest z. + box.nearDistance = std::floor((-high.z - kSunShadowCasterHeight) / kDepthStep) * kDepthStep; + box.farDistance = std::ceil((-low.z + kDepthStep) / kDepthStep) * kDepthStep; + + const glm::mat4 projection = glm::orthoRH_ZO(box.origin.x, box.origin.x + box.size, box.origin.y, + box.origin.y + box.size, box.nearDistance, box.farDistance); + view.viewProjection = 2.0f * projection * rotation; + view.sunFromScene = glm::mat4(glm::dmat4(view.viewProjection) * sceneFromClip); + return view; +} + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/SunShadow.h b/src/source/Render/Lighting/SunShadow.h new file mode 100644 index 0000000000..672a6e8b4d --- /dev/null +++ b/src/source/Render/Lighting/SunShadow.h @@ -0,0 +1,49 @@ +// SunShadow.h: the sun's direction and the shadow map's view around what the camera sees. +#pragma once + +#include + +#include + +namespace Render::Lighting +{ + +// How far a character's sun shadow falls per unit of its height: the body shadow shear's +// shearX / shearHeight (ZzzBMD.cpp, RenderBodyShadow). +inline constexpr float kSunShadowFall = 0.5f; +inline constexpr float kSunShadowFallBattleCastle = 0.625f; +// How far above the ground the shadow map still catches casters (trees, buildings, flying pets). +inline constexpr float kSunShadowCasterHeight = 3000.0f; + +// Unit vector towards the sun whose shadows fall towards `fallAngleDegrees` (counter-clockwise from +// world +x, as dynamic.shadowAngle) and `fallPerHeight` units per unit of height. +[[nodiscard]] glm::vec3 SunDirection(float fallAngleDegrees, float fallPerHeight); + +// The square, texel-snapped area of the shadow map: light-space x and y from `origin`, `size` wide, +// depth from `nearDistance` to `farDistance` along the sun's rays. +struct SunShadowBox +{ + glm::vec2 origin{}; + float size = 0.0f; + float nearDistance = 0.0f; + float farDistance = 0.0f; + + friend bool operator==(const SunShadowBox&, const SunShadowBox&) = default; +}; + +struct SunShadowView +{ + SunShadowBox box; + glm::mat4 viewProjection{1.0f}; + // viewProjection * inverse(the scene's view-projection): turns a draw's recorded scene matrix + // into its matrix from the sun. + glm::mat4 sunFromScene{1.0f}; +}; + +// The shadow map's view from the sun at `toSun` over the ground the camera sees between +// `groundLow` and `groundHigh`, at `resolution` texels a side. Clip w is 2 everywhere, so the +// vertex shaders' near-plane clip (w - 1) keeps every vertex. +[[nodiscard]] SunShadowView BuildSunShadowView(const glm::vec3& toSun, const glm::mat4& sceneViewProjection, + float groundLow, float groundHigh, std::uint32_t resolution); + +} // namespace Render::Lighting diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 1be7efb892..1c9bf218a3 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -33,6 +33,9 @@ const CommandForm CommandForms[] = { {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$ao radius ", {LookValue::AmbientOcclusionRadius}}, {L"$ao ", {LookValue::AmbientOcclusionStrength}}, + {L"$sun softness ", {LookValue::SunShadowSoftness}}, + {L"$sun resolution ", {LookValue::SunShadowResolution}}, + {L"$sun ", {LookValue::SunShadowStrength}}, {L"$bloom ", {LookValue::BloomStrength}}, }; diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index e8ba1a8493..8f135388ca 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -35,6 +35,9 @@ // $bloom bloom.strength // $ao radius ao.radius // $ao ao.strength +// $sun softness sun.softness +// $sun resolution sun.resolution +// $sun sun.shadow namespace Render::Look { diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index 8754ce5a69..3b89060391 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -82,6 +82,12 @@ constexpr std::array Specs = {{ 0.05, TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::AmbientOcclusionRadius, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionRadius, 5.0, TuningUnit::None, 1.0, TuningZero::Plain}, + {TuningControlId::SunShadowStrength, TuningGroup::DynamicLights, false, LookValue::SunShadowStrength, 0.05, + TuningUnit::Percent, 100.0, TuningZero::Plain}, + {TuningControlId::SunShadowSoftness, TuningGroup::DynamicLights, true, LookValue::SunShadowSoftness, 0.1, + TuningUnit::None, 1.0, TuningZero::Plain}, + {TuningControlId::SunShadowResolution, TuningGroup::DynamicLights, true, LookValue::SunShadowResolution, 1024.0, + TuningUnit::None, 1.0, TuningZero::Plain}, }}; constexpr bool SpecsFollowIdOrder() diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index 1983b42a99..af4d46e937 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -79,6 +79,9 @@ enum class TuningControlId : std::uint8_t GradingStrength, AmbientOcclusionStrength, AmbientOcclusionRadius, + SunShadowStrength, + SunShadowSoftness, + SunShadowResolution, Count, }; inline constexpr std::size_t TuningControlCount = static_cast(TuningControlId::Count); diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index f5b0fd10bd..c1c7d9b03d 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -3126,6 +3126,8 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, projection, shadowColor); } }; + // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it. + if (!Render::Lighting::SunShadowsActive()) { const mu::ScopedGroundShadow groundShadow; drawShadow(draw.alpha); diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index 39274195a1..87fb905a96 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -456,6 +456,15 @@ class IMuRenderer // Scopes nest; use ScopedGroundShadow. virtual void BeginGroundShadow(GroundShadowSource /*source*/) {} virtual void EndGroundShadow(GroundShadowSource /*source*/) {} + // Draws between BeginCharacterDraws and EndCharacterDraws are the characters, apart from the world's + // objects. Scopes nest; use ScopedCharacterDraws. + virtual void BeginCharacterDraws() {} + virtual void EndCharacterDraws() {} + // Whether SetSceneLighting's sun shadow settings draw a shadow map. + [[nodiscard]] virtual bool SunShadowsAvailable() const + { + return false; + } // True while a bloom exclusion is open: what is queued now and drawn later // (a character's glow sprites) can be drawn inside one too. [[nodiscard]] virtual bool IsBloomExcluded() const @@ -904,6 +913,20 @@ class ScopedWorldLitGeometry ScopedWorldLitGeometry(const ScopedWorldLitGeometry&) = delete; ScopedWorldLitGeometry& operator=(const ScopedWorldLitGeometry&) = delete; }; +class ScopedCharacterDraws +{ +public: + ScopedCharacterDraws() + { + GetRenderer().BeginCharacterDraws(); + } + ~ScopedCharacterDraws() + { + GetRenderer().EndCharacterDraws(); + } + ScopedCharacterDraws(const ScopedCharacterDraws&) = delete; + ScopedCharacterDraws& operator=(const ScopedCharacterDraws&) = delete; +}; class ScopedGroundShadow { public: diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 4a8c567f5a..268e019689 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -48,6 +48,7 @@ #include "Core/Utilities/Log/MuLogger.h" #include "Render/PostProcessing/BloomSource.h" #include "Render/PostProcessing/SceneBoundary.h" +#include "Render/Lighting/SunShadow.h" #include "Render/Terrain/TerrainHeightGrid.h" #include "Render/Text/SdlTtfFontSet.h" #ifdef _EDITOR @@ -132,6 +133,8 @@ static_assert(offsetof(SkinningVertexUniforms, vertexToWorldRows) == 208, // Slot 1 (t1, s1 in space2): skinned_lit.frag's normal map, bound for every draw with that shader, or // world_lit.frag's ground shadow mask. constexpr Uint32 k_FragmentSamplerSlotNormalMap = 1u; +// Slot 2 (t2, s2 in space2): the sun shadow map of both lit shaders, bound once per pass (BindLitSamplers). +constexpr Uint32 k_FragmentSamplerSlotSunShadow = 2u; // The flat tangent-space normal (0, 0, 1) as RGBA8: the normal map of draws without one. constexpr Uint32 k_FlatNormalPixel = 0xFFFF8080u; // R = G = 128, B = A = 255 (little-endian RGBA) @@ -625,6 +628,8 @@ static Render::PostProcessing::SceneBoundary s_sceneBoundary; static int s_bloomExclusionDepth = 0; static int s_worldLitGeometryDepth = 0; static int s_groundShadowDepth = 0; +// Draws recorded inside a ScopedCharacterDraws: the characters, apart from the world's objects. +static int s_characterDrawDepth = 0; static int s_lightShadowDepth = 0; // Ground shadows (BeginGroundShadow) are drawn into a coverage mask the world-lit ground samples, in // a frame that recorded world-lit draws; until the mask holds the frame's shadows they draw as before. @@ -832,6 +837,7 @@ struct RenderCmd bool groundShadow{}; // recorded inside a ScopedGroundShadow bool worldLit{}; // recorded inside BeginWorldLitGeometry: slot 1 is the ground shadow mask bool lightShadow{}; // a point light's (GroundShadowSource::PointLight) + bool characterDraw{}; // recorded inside a ScopedCharacterDraws // Set once this command has been replayed into an offscreen capture (see // BeginOffscreenCapture/EndOffscreenCapture); the main frame's replay pass then // skips it instead of drawing it a second time into the frame. @@ -867,7 +873,7 @@ static Render::DrawCommandHistory s_previousDrawCommands; } if (previous.blendEnabled != command.blendEnabled || previous.blendMode != command.blendMode || previous.bloomExcluded != command.bloomExcluded || previous.groundShadow != command.groundShadow || - previous.lightShadow != command.lightShadow) + previous.lightShadow != command.lightShadow || previous.characterDraw != command.characterDraw) { return Counter::BatchBreakBlend; } @@ -1115,6 +1121,55 @@ static SDL_GPUTextureFormat s_pipelineFormatOverride = SDL_GPU_TEXTUREFORMAT_INV // Whether the built pipelines are multisampled; set by CreatePipelinesForSampleCount. static bool s_pipelinesMultisampled = false; +// Enhanced sun shadows: while s_sunShadowPass replays the scene into the shadow map, each draw's recorded +// scene matrix is turned into the sun's by s_sunFromScene. +static bool s_sunShadowPass = false; +static glm::mat4 s_sunFromScene{1.0f}; + +// How a draw covers the sun shadow map (sun_depth.frag's coverageMode): solid with its alpha test, +// or a blended character part (wings, capes, auras) dithered by its alpha or, glowing, by its +// brightness, so the shadow's blur turns it into a partial shadow. Darkening blends cast none. +enum class SunCoverage : std::uint32_t +{ + None, + Solid, + Alpha, + Brightness, +}; + +[[nodiscard]] static SunCoverage GetSunCoverage(const RenderCmd& command) +{ + if (!command.blendEnabled) + return SunCoverage::Solid; + switch (command.blendMode) + { + case BlendMode::Alpha: + case BlendMode::Mixed: + return SunCoverage::Alpha; + case BlendMode::Additive: + case BlendMode::Glow: + case BlendMode::Luminance: + return SunCoverage::Brightness; + default: + return SunCoverage::None; + } +} + +// A draw's vertex uniforms in the sun shadow pass: its own, with the sun's matrix. +static void PushSunShadowVertexUniforms(const RenderCmd& command, bool skinned, Render::SdlGpuReplayState& state) +{ + if (skinned) + { + SkinningVertexUniforms uniforms = s_skinningUniforms[command.skinningIndex]; + uniforms.mvp = s_sunFromScene * uniforms.mvp; + PushReplayVertexUniforms(0, &uniforms, sizeof(uniforms), state); + return; + } + VertexUniforms uniforms = command.vu; + uniforms.mvp = s_sunFromScene * uniforms.mvp; + PushReplayVertexUniforms(0, &uniforms, sizeof(uniforms), state); +} + // Replays a recorded draw with `pipeline`: its own, or a variant of it for another pass. static void ReplayDrawCommand(const RenderCmd& command, SDL_GPUGraphicsPipeline* pipeline, bool boneDataReady, const SDL_Rect& scissor, Render::SdlGpuReplayState& state) @@ -1140,7 +1195,9 @@ static void ReplayDrawCommand(const RenderCmd& command, SDL_GPUGraphicsPipeline* return; } - if (skinned) + if (s_sunShadowPass) + PushSunShadowVertexUniforms(command, skinned, state); + else if (skinned) PushReplayVertexUniforms(0, &s_skinningUniforms[command.skinningIndex], sizeof(SkinningVertexUniforms), state); else PushReplayVertexUniforms(0, &command.vu, sizeof(command.vu), state); @@ -1185,7 +1242,15 @@ static void ReplayDrawCommand(const RenderCmd& command, SDL_GPUGraphicsPipeline* } BindReplayFragmentSampler(command, state); - PushReplayFragmentUniforms(command.fogUniform, state); + if (s_sunShadowPass) + { + // sun_depth.frag reads fogEnabled's slot as its coverage mode. + FogUniform coverage = command.fogUniform; + coverage.fogEnabled = static_cast(GetSunCoverage(command)) - 1u; + PushReplayFragmentUniforms(coverage, state); + } + else + PushReplayFragmentUniforms(command.fogUniform, state); if (command.type == RenderCmdType::DrawIndexedQuads || command.type == RenderCmdType::DrawIndexedStrip || command.trianglesIndexed) @@ -1251,6 +1316,19 @@ static SDL_GPUShader* s_fragShaderAmbientOcclusionBlur = nullptr; // post_ao_blu // The scene's ambient occlusion (one sample only), and the scene's projection it reconstructs from. static mu::SdlGpuAmbientOcclusion s_ambientOcclusion; static float s_sceneProjection[16]{}; +// Enhanced sun shadows (one sample): the shadow map's pipelines for 3D, skinned and glTF draws, the map and +// its size, the far 1x1 map bound while there is none, the comparison sampler, whether this frame asks +// for the map (SetSceneLighting) and whether it holds this frame's. +static SDL_GPUGraphicsPipeline* s_sunShadowPipelines[3]{}; // [ShadowPassLayout] +static SDL_GPUShader* s_fragShaderSunDepth = nullptr; // sun_depth.frag +static SDL_GPUTexture* s_sunShadowMap = nullptr; +static Uint32 s_sunShadowMapSize = 0u; +static SDL_GPUTexture* s_sunShadowFallback = nullptr; +static bool s_sunShadowFallbackCleared = false; +static SDL_GPUSampler* s_sunShadowSampler = nullptr; +static bool s_sunShadowRequested = false; +static Uint32 s_sunShadowResolution = 0u; +static bool s_sunShadowMapReady = false; // Depth buffer texture for correct 3D depth testing. // Created in Init() at swapchain dimensions, recreated on window resize. @@ -2110,6 +2188,8 @@ class MuRendererSDLGpu : public IMuRenderer s_bitmapGpuResources.LastStage(), s_bitmapGpuResources.LastError()); } + ReleaseSunShadowResources(); + // Release the independently owned white fallback texture. if (s_whiteTexture) { @@ -2253,6 +2333,7 @@ class MuRendererSDLGpu : public IMuRenderer } s_worldLitGeometryDepth = 0; s_groundShadowDepth = 0; + s_characterDrawDepth = 0; s_lightShadowDepth = 0; s_frameHasWorldLit = false; s_groundShadowMaskReady = false; @@ -2369,7 +2450,8 @@ class MuRendererSDLGpu : public IMuRenderer { AllCommands, BloomSources, - GroundShadows, // the ground shadows, into the ground shadow mask + GroundShadows, // the ground shadows, into the ground shadow mask + SunShadowCasters, // solid world draws, into the sun shadow map }; [[nodiscard]] static ReplayView FullFrameView() @@ -2414,13 +2496,42 @@ class MuRendererSDLGpu : public IMuRenderer return nullptr; } + // The vertex layout a shadow pass replays `command` with: 0 3D, 1 skinned, 2 weighted skinned (glTF). + [[nodiscard]] static int ShadowPassLayout(const RenderCmd& command) + { + return command.type != RenderCmdType::DrawSkinnedTriangles ? 0 + : command.vtxStride == sizeof(mu::SkinnedWeightedVertex3D) ? 2 + : 1; + } + [[nodiscard]] static SDL_GPUGraphicsPipeline* GetGroundShadowMaskPipeline(const RenderCmd& command) { - // Layouts: 3D, skinned, weighted skinned (glTF). - const int layout = command.type != RenderCmdType::DrawSkinnedTriangles ? 0 - : command.vtxStride == sizeof(mu::SkinnedWeightedVertex3D) ? 2 - : 1; - return s_groundShadowMaskPipelines[command.lightShadow ? 1 : 0][layout]; + return s_groundShadowMaskPipelines[command.lightShadow ? 1 : 0][ShadowPassLayout(command)]; + } + + // A solid draw of the scene's world: depth-tested and depth-writing, not blended, not a ground shadow, + // not 2D; or a character's blended part (GetSunCoverage). Models drawn for the UI (their own view, + // Enhanced without the point lights) are left out. + [[nodiscard]] static bool IsSunShadowCaster(const RenderCmd& command) + { + if (command.groundShadow || !command.depthTestEnabled) + { + return false; + } + if (command.blendEnabled || !command.depthMaskEnabled) + { + const bool characterPart = command.characterDraw && command.type == RenderCmdType::DrawSkinnedTriangles && + command.blendEnabled && GetSunCoverage(command) != SunCoverage::None; + if (!characterPart) + { + return false; + } + } + if (command.type == RenderCmdType::DrawSkinnedTriangles) + { + return s_skinningUniforms[command.skinningIndex].palette[3] != k_SkinningLightingEnhanced; + } + return command.type != RenderCmdType::DrawTriangles2D && command.vtxStride == sizeof(Vertex3D); } // The pipeline `command` replays with in a pass of `selection`, or null when it is not drawn there. @@ -2431,6 +2542,10 @@ class MuRendererSDLGpu : public IMuRenderer { return command.groundShadow ? GetGroundShadowMaskPipeline(command) : nullptr; } + if (selection == ReplaySelection::SunShadowCasters) + { + return IsSunShadowCaster(command) ? s_sunShadowPipelines[ShadowPassLayout(command)] : nullptr; + } if (command.lightShadow || (command.groundShadow && s_groundShadowMaskReady)) { return nullptr; @@ -2452,6 +2567,8 @@ class MuRendererSDLGpu : public IMuRenderer SDL_SetGPUScissor(s_renderPass, &view.scissor); const bool allCommands = selection == ReplaySelection::AllCommands; + // The shadow map keeps its own viewport and scissor. + const bool ownView = selection == ReplaySelection::SunShadowCasters; for (std::size_t index = begin; index < end; ++index) { const RenderCmd& cmd = s_renderCmds[index]; @@ -2469,6 +2586,10 @@ class MuRendererSDLGpu : public IMuRenderer { ++s_dbgRenderCmdsReplayedThisFrame; } + if (ownView && !IsDrawCommand(cmd.type)) + { + continue; + } switch (cmd.type) { @@ -2546,9 +2667,22 @@ class MuRendererSDLGpu : public IMuRenderer return false; } PushSceneLightingUniforms(); + BindLitSamplers(); return true; } + // The Enhanced-lit shaders' slot 2, the sun shadow map: this frame's once drawn, otherwise the far + // 1x1 map. Slot 1 is bound per draw (BindReplayFragmentSampler). + static void BindLitSamplers() + { + SDL_GPUTexture* const sunShadow = s_sunShadowMapReady ? s_sunShadowMap : s_sunShadowFallback; + if (sunShadow && s_sunShadowSampler) + { + const SDL_GPUTextureSamplerBinding binding{sunShadow, s_sunShadowSampler}; + SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotSunShadow, &binding, 1); + } + } + // The ground shadow mask at the frame's size, recreated when that changed. Null when it fails. [[nodiscard]] static SDL_GPUTexture* EnsureGroundShadowMask() { @@ -2614,6 +2748,91 @@ class MuRendererSDLGpu : public IMuRenderer s_groundShadowMaskReady = true; } + // A depth-only pass into `depth`, cleared to the far plane. Null when it cannot begin. + [[nodiscard]] static SDL_GPURenderPass* BeginDepthOnlyPass(SDL_GPUTexture* depth) + { + SDL_GPUDepthStencilTargetInfo target{}; + target.texture = depth; + target.clear_depth = 1.0f; + target.load_op = SDL_GPU_LOADOP_CLEAR; + target.store_op = SDL_GPU_STOREOP_STORE; + target.stencil_load_op = SDL_GPU_LOADOP_DONT_CARE; + target.stencil_store_op = SDL_GPU_STOREOP_DONT_CARE; + target.cycle = true; + return SDL_BeginGPURenderPass(s_cmdBuf, nullptr, 0, &target); + } + + [[nodiscard]] static SDL_GPUTexture* CreateSunShadowDepth(Uint32 size) + { + SDL_GPUTextureCreateInfo info{}; + info.type = SDL_GPU_TEXTURETYPE_2D; + info.format = mu::SdlGpuDepthFormat; + info.width = size; + info.height = size; + info.layer_count_or_depth = 1; + info.num_levels = 1; + info.sample_count = SDL_GPU_SAMPLECOUNT_1; + info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + SDL_GPUTexture* const texture = SDL_CreateGPUTexture(s_device, &info); + if (!texture) + { + mu::log::Get("render")->error("SDL_gpu -- sun shadow map creation failed ({0}x{0}): {1}", size, + SDL_GetError()); + } + return texture; + } + + static void ReleaseSunShadowMap() + { + if (s_sunShadowMap) + { + SDL_ReleaseGPUTexture(s_device, s_sunShadowMap); + s_sunShadowMap = nullptr; + } + s_sunShadowMapSize = 0u; + } + + // The frame's sun shadow map: the scene's solid draws [0, end) seen from the sun. Without a request + // (SetSceneLighting) the map is released and the lit shaders read the far 1x1 one. + // shortcut: every solid draw is drawn again each frame, the map's still parts too; cache them + // apart from the characters if the pass shows up in the profile. + static void RenderSunShadowMap(std::size_t end, bool boneDataReady) + { + FRAME_PROFILE(SunShadow); + s_sunShadowMapReady = false; + if (s_sunShadowFallback && !s_sunShadowFallbackCleared) + { + if ((s_renderPass = BeginDepthOnlyPass(s_sunShadowFallback)) != nullptr) + { + EndReplayPass(); + s_sunShadowFallbackCleared = true; + } + } + if (!s_sunShadowRequested) + { + ReleaseSunShadowMap(); + return; + } + if (s_sunShadowMapSize != s_sunShadowResolution) + { + ReleaseSunShadowMap(); + s_sunShadowMap = CreateSunShadowDepth(s_sunShadowResolution); + s_sunShadowMapSize = s_sunShadowMap ? s_sunShadowResolution : 0u; + } + if (!s_sunShadowMap || (s_renderPass = BeginDepthOnlyPass(s_sunShadowMap)) == nullptr) + { + return; + } + const float size = static_cast(s_sunShadowMapSize); + ReplayView view{{0.0f, 0.0f, size, size, 0.0f, 1.0f}, + {0, 0, static_cast(s_sunShadowMapSize), static_cast(s_sunShadowMapSize)}}; + s_sunShadowPass = true; + ReplayCommands(0u, end, boneDataReady, ReplaySelection::SunShadowCasters, view); + s_sunShadowPass = false; + EndReplayPass(); + s_sunShadowMapReady = true; + } + static void EndReplayPass() { SDL_EndGPURenderPass(s_renderPass); @@ -2629,6 +2848,7 @@ class MuRendererSDLGpu : public IMuRenderer // Nothing reads depth after the pass; skip storing every sample of it. const SDL_GPUDepthStencilTargetInfo depthTarget = MakeDepthTarget(SDL_GPU_LOADOP_CLEAR, IsMultisampled() ? SDL_GPU_STOREOP_DONT_CARE : SDL_GPU_STOREOP_STORE); + RenderSunShadowMap(s_renderCmds.size(), boneDataReady); RenderGroundShadowMask(s_renderCmds.size(), boneDataReady); if (!BeginReplayPass(colorTarget, depthTarget)) { @@ -2745,6 +2965,7 @@ class MuRendererSDLGpu : public IMuRenderer { SDL_GPUTexture* const multisampled = IsMultisampled() ? s_multisampleColorTexture : nullptr; ReplayView view = FullFrameView(); + RenderSunShadowMap(sceneEnd, boneDataReady); RenderGroundShadowMask(sceneEnd, boneDataReady); // The scene texture's format says whether this frame's scene is HDR (EnsureTargets). s_hdrScenePass = s_postProcessing.IsHdrScene(); @@ -3010,6 +3231,7 @@ class MuRendererSDLGpu : public IMuRenderer { // These passes render into single-sample textures (see s_singleSamplePipelines). PushSceneLightingUniforms(); + BindLitSamplers(); s_singleSamplePass = true; ReplayView view = FullFrameView(); ReplayCommands(startIdx, endIdx, boneDataReady, ReplaySelection::AllCommands, view); @@ -3843,6 +4065,19 @@ class MuRendererSDLGpu : public IMuRenderer } } + void BeginCharacterDraws() override + { + ++s_characterDrawDepth; + } + + void EndCharacterDraws() override + { + if (s_characterDrawDepth > 0) + { + --s_characterDrawDepth; + } + } + void BeginGroundShadow(GroundShadowSource source) override { ++(source == GroundShadowSource::PointLight ? s_lightShadowDepth : s_groundShadowDepth); @@ -5198,6 +5433,33 @@ class MuRendererSDLGpu : public IMuRenderer // projection the scene's. m_worldFromViewMatrix = glm::inverse(m_modelViewMatrix); std::memcpy(s_sceneProjection, glm::value_ptr(m_projMatrix), sizeof(s_sceneProjection)); + const glm::mat4 viewProjection = m_projMatrix * m_modelViewMatrix; + + s_sunShadowRequested = lighting.sunShadowDarkness > 0.0f && SunShadowsAvailable(); + if (s_sunShadowRequested) + { + const Uint32 resolution = lighting.sunShadowResolution < 1536u ? 1024u + : lighting.sunShadowResolution < 3072u ? 2048u + : 4096u; + const glm::vec3 toSun(lighting.sunDirection[0], lighting.sunDirection[1], lighting.sunDirection[2]); + const Render::Lighting::SunShadowView sun = Render::Lighting::BuildSunShadowView( + toSun, viewProjection, lighting.groundLow, lighting.groundHigh, resolution); + s_sunShadowResolution = resolution; + s_sunFromScene = sun.sunFromScene; + std::memcpy(s_sceneLightingUniform.sunViewProjection, glm::value_ptr(sun.viewProjection), + sizeof(s_sceneLightingUniform.sunViewProjection)); + const float texel = 1.0f / static_cast(resolution); + s_sceneLightingUniform.sunShadowParameters[0] = lighting.sunShadowDarkness; + s_sceneLightingUniform.sunShadowParameters[1] = lighting.sunShadowSoftness; + s_sceneLightingUniform.sunShadowParameters[2] = texel; + s_sceneLightingUniform.sunShadowParameters[3] = sun.box.size * texel; + } + } + + [[nodiscard]] bool SunShadowsAvailable() const override + { + return s_enhancedLightingAvailable && s_sunShadowPipelines[0] && s_sunShadowPipelines[1] && + s_sunShadowSampler && s_sunShadowFallback; } void SetDynamicLights(const DynamicLightsUniform& lights) override @@ -5546,6 +5808,7 @@ class MuRendererSDLGpu : public IMuRenderer command.lightShadow = s_lightShadowDepth > 0; command.groundShadow = s_groundShadowDepth > 0 || command.lightShadow; command.worldLit = s_worldLitGeometryDepth > 0; + command.characterDraw = s_characterDrawDepth > 0; if (command.worldLit) { s_frameHasWorldLit = true; @@ -5859,15 +6122,19 @@ class MuRendererSDLGpu : public IMuRenderer s_fragShaderTexFog = createShader("basic_textured_fog", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 2, /*fatal=*/false); // skinned_lit.frag also reads the frame's point lights, DynamicLights (b2). - // skinned_lit.frag samples the texture and the normal map (k_FragmentSamplerSlotNormalMap). - s_fragShaderLit = createShader("skinned_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 3, /*fatal=*/false); + // skinned_lit.frag samples the texture, the normal map (k_FragmentSamplerSlotNormalMap) and the sun + // shadow map (k_FragmentSamplerSlotSunShadow). + s_fragShaderLit = createShader("skinned_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 3, 0, 3, /*fatal=*/false); // The ground lit per pixel: the Transform (b0) of basic_textured.vert, and the uniforms of skinned_lit.frag. s_vertShaderWorldLit = createShader("world_lit", "vert", SDL_GPU_SHADERSTAGE_VERTEX, 0, 0, 1, /*fatal=*/false); - // world_lit.frag also samples the ground shadow mask (s1). + // world_lit.frag also samples the sun shadow map (s1) and the ground shadow mask (s2). s_fragShaderWorldLit = - createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 2, 0, 3, /*fatal=*/false); + createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 3, 0, 3, /*fatal=*/false); s_fragShaderShadowMask = createShader("shadow_mask", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 0, 0, 0, /*fatal=*/false); + // Sun shadows: the draw's texture (t0) for its alpha test, FogUniforms (b0). + s_fragShaderSunDepth = + createShader("sun_depth", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 0, 1, /*fatal=*/false); // Post-processing — non-fatal: without them post-processing is unavailable. // Bloom passes: source texture (t0) and BloomUniforms (b0); composite: scene, bloom and @@ -5955,7 +6222,7 @@ class MuRendererSDLGpu : public IMuRenderer for (SDL_GPUShader** shader : {&s_vertShaderWorldLit, &s_fragShaderWorldLit, &s_fragShaderShadowMask, &s_vertShaderPostFullscreen, &s_fragShaderBloomDown, &s_fragShaderBloomUp, &s_fragShaderComposite, &s_fragShaderAmbientOcclusion, - &s_fragShaderAmbientOcclusionBlur}) + &s_fragShaderAmbientOcclusionBlur, &s_fragShaderSunDepth}) { if (*shader) { @@ -5987,6 +6254,7 @@ class MuRendererSDLGpu : public IMuRenderer SkinnedLit, WorldLit, ShadowMask, + SunDepth, }; struct PipelineBuildDescription @@ -6002,6 +6270,8 @@ class MuRendererSDLGpu : public IMuRenderer bool alphaToCoverage = false; // Into the ground shadow mask: one sample, no depth, instead of the frame's targets. bool groundShadowMaskTarget = false; + // Into the sun shadow map: depth only, one sample, biased against self-shadowing. + bool sunShadowTarget = false; }; // The world sets built together, and what a failed pipeline means for them. @@ -6096,6 +6366,8 @@ class MuRendererSDLGpu : public IMuRenderer return s_fragShaderWorldLit; case FragmentShader::ShadowMask: return s_fragShaderShadowMask; + case FragmentShader::SunDepth: + return s_fragShaderSunDepth; case FragmentShader::Textured: break; } @@ -6114,6 +6386,8 @@ class MuRendererSDLGpu : public IMuRenderer return "world_lit.frag"; case FragmentShader::ShadowMask: return "shadow_mask.frag"; + case FragmentShader::SunDepth: + return "sun_depth.frag"; case FragmentShader::Textured: break; } @@ -6300,8 +6574,8 @@ class MuRendererSDLGpu : public IMuRenderer vtxInputState.num_vertex_attributes = numAttribs; SDL_GPUGraphicsPipelineTargetInfo targetInfo{}; - targetInfo.color_target_descriptions = &colorTargetDesc; - targetInfo.num_color_targets = 1; + targetInfo.color_target_descriptions = description.sunShadowTarget ? nullptr : &colorTargetDesc; + targetInfo.num_color_targets = description.sunShadowTarget ? 0u : 1u; // Enable depth-stencil target so pipelines match // the render pass that now includes a depth buffer. targetInfo.has_depth_stencil_target = !description.groundShadowMaskTarget; @@ -6313,6 +6587,12 @@ class MuRendererSDLGpu : public IMuRenderer rasterState.fill_mode = SDL_GPU_FILLMODE_FILL; rasterState.cull_mode = description.cullFaceEnabled ? SDL_GPU_CULLMODE_BACK : SDL_GPU_CULLMODE_NONE; rasterState.front_face = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE; + if (description.sunShadowTarget) + { + rasterState.enable_depth_bias = true; + rasterState.depth_bias_constant_factor = 2.0f; + rasterState.depth_bias_slope_factor = 2.0f; + } SDL_GPUGraphicsPipelineCreateInfo pipelineInfo{}; pipelineInfo.vertex_shader = @@ -6331,7 +6611,7 @@ class MuRendererSDLGpu : public IMuRenderer pipelineInfo.props = 0; pipelineInfo.multisample_state.sample_count = - description.groundShadowMaskTarget + description.groundShadowMaskTarget || description.sunShadowTarget ? SDL_GPU_SAMPLECOUNT_1 : mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); pipelineInfo.multisample_state.enable_alpha_to_coverage = description.alphaToCoverage; @@ -6607,6 +6887,14 @@ class MuRendererSDLGpu : public IMuRenderer } } } + for (SDL_GPUGraphicsPipeline*& pipeline : s_sunShadowPipelines) + { + if (pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, pipeline); + pipeline = nullptr; + } + } DestroyAlphaCoveragePipelines(); s_postProcessing.DestroyPipelines(); } @@ -6729,6 +7017,7 @@ class MuRendererSDLGpu : public IMuRenderer } CreateAlphaCoveragePipelines(); CreateGroundShadowMaskPipelines(); + CreateSunShadowPipelines(); CreatePostProcessingPipelines(); if (!CreateSingleSamplePipelines()) { @@ -6744,6 +7033,7 @@ class MuRendererSDLGpu : public IMuRenderer return false; } CreateGroundShadowMaskPipelines(); + CreateSunShadowPipelines(); CreatePostProcessingPipelines(); } s_pipelinesMultisampled = s_sampleCount != Render::Antialiasing::OffSampleCount; @@ -6998,6 +7288,70 @@ class MuRendererSDLGpu : public IMuRenderer s_device, {s_vertShaderPostFullscreen, s_fragShaderAmbientOcclusion, s_fragShaderAmbientOcclusionBlur}); } + // The pipelines replaying solid draws into the sun shadow map, with its comparison sampler and far + // 1x1 map. Optional: without them there are no sun shadows. + static void CreateSunShadowPipelines() + { + if (!s_fragShaderSunDepth) + { + return; + } + // Indexed by ShadowPassLayout. + const VertexLayout layouts[] = {VertexLayout::ThreeDimensional, VertexLayout::Skinned, + VertexLayout::SkinnedWeighted}; + for (std::size_t layout = 0; layout < 3; ++layout) + { + if (layout == 2 && !s_vertShaderSkinnedWeighted) + { + continue; + } + PipelineBuildDescription description{"sun-shadow", "opaque", k_PipelineDisabled, true, true, + layouts[layout], false, FragmentShader::SunDepth}; + description.sunShadowTarget = true; + const PipelineBuildResult result = BuildBlendPipeline(SDL_GPUColorTargetBlendState{}, description); + s_sunShadowPipelines[layout] = result.pipeline; + if (!result.pipeline) + { + const char* driver = SDL_GetGPUDeviceDriver(s_device); + LogPipelineFailure(driver ? driver : "unknown", result, false); + } + } + if (!s_sunShadowSampler) + { + SDL_GPUSamplerCreateInfo samplerInfo{}; + samplerInfo.min_filter = SDL_GPU_FILTER_LINEAR; + samplerInfo.mag_filter = SDL_GPU_FILTER_LINEAR; + samplerInfo.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST; + samplerInfo.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.enable_compare = true; + // Lit where the surface is no further from the sun than what the map saw first. + samplerInfo.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; + s_sunShadowSampler = SDL_CreateGPUSampler(s_device, &samplerInfo); + } + if (!s_sunShadowFallback) + { + s_sunShadowFallback = CreateSunShadowDepth(1u); + s_sunShadowFallbackCleared = false; + } + } + + static void ReleaseSunShadowResources() + { + ReleaseSunShadowMap(); + if (s_sunShadowFallback) + { + SDL_ReleaseGPUTexture(s_device, s_sunShadowFallback); + s_sunShadowFallback = nullptr; + } + if (s_sunShadowSampler) + { + SDL_ReleaseGPUSampler(s_device, s_sunShadowSampler); + s_sunShadowSampler = nullptr; + } + } + // The ground shadow mask's pipelines (one sample, whatever s_sampleCount is). Optional: without them // ground shadows draw as recorded. static void CreateGroundShadowMaskPipelines() @@ -7377,7 +7731,8 @@ class MuRendererSDLGpu : public IMuRenderer const SDL_Rect scissor{0, 0, static_cast(capture.width), static_cast(capture.height)}; SDL_SetGPUScissor(s_renderPass, &scissor); PushSceneLightingUniforms(); - + BindLitSamplers(); + s_singleSamplePass = true; Render::SdlGpuReplayState replayState; for (std::size_t i = capture.startCmd; i < capture.endCmd && i < s_renderCmds.size(); ++i) diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index d54a6285e6..cd71fedf08 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -45,6 +45,15 @@ struct SceneLighting float specularPower = kDefaultSpecularPower; // World-space camera position. float cameraPosition[3]{}; + // Enhanced sun shadows: the direction towards the sun, how much a shadow darkens (0: no shadow + // map), how many texels its edges blur over, the map's size in texels, and the heights between + // which the camera's view meets the ground. + float sunDirection[3]{0.0f, 0.0f, 1.0f}; + float sunShadowDarkness = 0.0f; + float sunShadowSoftness = 1.0f; + std::uint32_t sunShadowResolution = 2048; + float groundLow = 0.0f; + float groundHigh = 0.0f; }; // The frame's fog as configured through IMuRenderer::SetFog() when the scene lighting was set. @@ -68,6 +77,8 @@ struct SceneLightingUniform float fogColor[4]; // rgb, w = 1 when the scene has fog float fogParameters[4]; // start, end, Enhanced density, unused float cameraPosition[4]; // xyz world space, w unused + float sunViewProjection[16]; // column-major, world to the sun shadow map's clip space + float sunShadowParameters[4]; // darkness (0: no shadow map), softness in texels, 1 / map size, texel size }; inline constexpr std::size_t kSceneLightingRegisterSize = 16; @@ -79,7 +90,9 @@ static_assert(offsetof(SceneLightingUniform, specularParameters) == 4 * kSceneLi static_assert(offsetof(SceneLightingUniform, fogColor) == 5 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, fogParameters) == 6 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, cameraPosition) == 7 * kSceneLightingRegisterSize); -static_assert(sizeof(SceneLightingUniform) == 8 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, sunViewProjection) == 8 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, sunShadowParameters) == 12 * kSceneLightingRegisterSize); +static_assert(sizeof(SceneLightingUniform) == 13 * kSceneLightingRegisterSize); [[nodiscard]] SceneLightingUniform PackSceneLightingUniform(const SceneLighting& lighting, const SceneFog& fog); diff --git a/src/source/Scenes/MainScene.cpp b/src/source/Scenes/MainScene.cpp index af66a44513..4bd8ae5e70 100644 --- a/src/source/Scenes/MainScene.cpp +++ b/src/source/Scenes/MainScene.cpp @@ -616,7 +616,11 @@ static void RenderGameWorldPass(BYTE& byWaterMap, int width, int height) RenderBoids(); } - { FRAME_PROFILE(Characters); RenderCharactersClient(); } + { + FRAME_PROFILE(Characters); + mu::ScopedCharacterDraws characterDraws; + RenderCharactersClient(); + } if (EditFlag != EDIT_NONE && renderTerrain) { diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index 7c3325312f..cf1f1b74a5 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -8,6 +8,7 @@ #include "Render/Lighting/DynamicLightList.h" #include "Render/Lighting/DynamicLightSelection.h" #include "Render/Lighting/DynamicLightsSetting.h" +#include "Render/Lighting/SunShadow.h" #include "Render/Lighting/EnhancedLightingSetting.h" #include "Render/Lighting/LightMoodSetting.h" #include "Render/Lighting/WorldDynamicLights.h" @@ -15,6 +16,7 @@ #include "Render/Renderer/MuRenderer.h" #include "Render/Renderer/SceneLighting.h" #include "Scenes/SceneCore.h" +#include "World/MapInfra/MapManager.h" #include #include @@ -54,6 +56,27 @@ void SubmitSceneLighting() lighting.cameraPosition[2] = g_Camera.Position[2]; Render::Lighting::ApplyTuning(lighting); lighting.highlightKnee = Render::Lighting::LightMood::Active().highlightKnee; + if (Render::Lighting::SunShadowsActive() && Hero) + { + using Data::Maps::LookValue; + // The sun stands where the flat character shadows said it did: they fall towards + // dynamic.shadowAngle, as long as before. + const glm::vec3 toSun = + Render::Lighting::SunDirection(Render::Look::Value(LookValue::GroundShadowAngle), + gMapManager.InBattleCastle() ? Render::Lighting::kSunShadowFallBattleCastle + : Render::Lighting::kSunShadowFall); + lighting.sunDirection[0] = toSun.x; + lighting.sunDirection[1] = toSun.y; + lighting.sunDirection[2] = toSun.z; + lighting.sunShadowDarkness = + Render::Look::Value(LookValue::SunShadowStrength) * Render::Look::Value(LookValue::GroundShadowOpacity); + lighting.sunShadowSoftness = Render::Look::Value(LookValue::SunShadowSoftness); + lighting.sunShadowResolution = static_cast(Render::Look::Value(LookValue::SunShadowResolution)); + // Around the hero: the ground the camera sees lies within these heights. + constexpr float GroundReach = 400.0f; + lighting.groundLow = Hero->Object.Position[2] - GroundReach; + lighting.groundHigh = Hero->Object.Position[2] + GroundReach; + } mu::GetRenderer().SetSceneLighting(lighting); } @@ -70,6 +93,7 @@ void PinWorldDynamicLights() void SubmitDynamicLights() { + if (!Render::Lighting::DynamicLightsActive()) { mu::GetRenderer().SetDynamicLights({}); diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 19e7edbf07..4577e6b0e7 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -60,6 +60,12 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningLightShadows, I18N::Game::TuningLightShadowsHelp}; case TuningControlId::ShadowAngle: return {I18N::Game::TuningShadowDirection, I18N::Game::TuningShadowDirectionHelp}; + case TuningControlId::SunShadowStrength: + return {I18N::Game::TuningSunShadows, I18N::Game::TuningSunShadowsHelp}; + case TuningControlId::SunShadowSoftness: + return {I18N::Game::TuningSunShadowSoftness, I18N::Game::TuningSunShadowSoftnessHelp}; + case TuningControlId::SunShadowResolution: + return {I18N::Game::TuningSunShadowResolution, I18N::Game::TuningSunShadowResolutionHelp}; case TuningControlId::Wrap: return {I18N::Game::TuningLightWrap, I18N::Game::TuningLightWrapHelp}; case TuningControlId::MapSmoothing: diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index 13d63620b4..eb946dfe59 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -266,7 +266,7 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::DynamicEffectCap, 2.5}, {LookValue::BloomStrength, 1.0}, {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, {LookValue::GroundShadowLights, 2}, {LookValue::AmbientOcclusionStrength, 0.8}, - {LookValue::SpecularScale, 0.8}, + {LookValue::SpecularScale, 0.8}, {LookValue::SunShadowStrength, 1.0}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { diff --git a/tests/render/CMakeLists.txt b/tests/render/CMakeLists.txt index 5b8c479c51..894f72012e 100644 --- a/tests/render/CMakeLists.txt +++ b/tests/render/CMakeLists.txt @@ -240,6 +240,15 @@ mu_add_test( ${CMAKE_SOURCE_DIR}/src/source/Render/Terrain/TerrainLightGrid.cpp ) +mu_add_test( + NAME sun_shadow_tests + SOURCES + test_sun_shadow.cpp + ${CMAKE_SOURCE_DIR}/src/source/Render/Lighting/SunShadow.cpp + LINK_LIBS glm::glm +) +target_compile_definitions(sun_shadow_tests PRIVATE GLM_FORCE_DEPTH_ZERO_TO_ONE) + mu_add_test( NAME single_sample_twins_tests SOURCES test_single_sample_twins.cpp diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index b3642bf01d..51e815bce5 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -67,6 +67,8 @@ TEST_CASE("the look profile's built-in values are the renderer's values before i // Ambient occlusion: off, at the renderer's default reach. CHECK(BuiltIn(LookValue::AmbientOcclusionStrength) == 0.0); CHECK(BuiltInFloat(LookValue::AmbientOcclusionRadius) == mu::PostProcessingLook{}.ambientOcclusionRadius); + // Sun shadows: off. + CHECK(BuiltIn(LookValue::SunShadowStrength) == 0.0); } TEST_CASE("dynamic.wrap: the point-light diffuse from Lambert to half-Lambert [render][look]") @@ -235,6 +237,9 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); single(L"$ao radius 80", LookValue::AmbientOcclusionRadius, 80.0); single(L"$ao 0.5", LookValue::AmbientOcclusionStrength, 0.5); + single(L"$sun softness 1.5", LookValue::SunShadowSoftness, 1.5); + single(L"$sun resolution 4096", LookValue::SunShadowResolution, 4096.0); + single(L"$sun 0.5", LookValue::SunShadowStrength, 0.5); const std::optional diffuse = ParseLookTuningCommand(L"$lighting diffuse 1.0 0.3 0.15"); diff --git a/tests/render/test_scene_lighting.cpp b/tests/render/test_scene_lighting.cpp index b988d4fd1b..c221d3e66f 100644 --- a/tests/render/test_scene_lighting.cpp +++ b/tests/render/test_scene_lighting.cpp @@ -6,7 +6,7 @@ TEST_CASE("scene lighting uniform matches the HLSL cbuffer registers [render][scene_lighting]") { - CHECK(sizeof(mu::SceneLightingUniform) == 128); + CHECK(sizeof(mu::SceneLightingUniform) == 208); CHECK(offsetof(mu::SceneLightingUniform, lightDirection) == 0); CHECK(offsetof(mu::SceneLightingUniform, lightColor) == 16); CHECK(offsetof(mu::SceneLightingUniform, diffuseCurve) == 32); diff --git a/tests/render/test_sun_shadow.cpp b/tests/render/test_sun_shadow.cpp new file mode 100644 index 0000000000..a60fc92b3c --- /dev/null +++ b/tests/render/test_sun_shadow.cpp @@ -0,0 +1,107 @@ +#include "Render/Lighting/SunShadow.h" + +#include +#include + +#include +#include + +namespace +{ +using Render::Lighting::BuildSunShadowView; +using Render::Lighting::SunDirection; + +// A camera like the game's: high above the ground, looking down at the hero at `target`. +glm::mat4 SceneViewProjection(const glm::vec3& target) +{ + const glm::mat4 projection = glm::perspectiveRH_ZO(glm::radians(35.0f), 16.0f / 9.0f, 20.0f, 5000.0f); + const glm::mat4 view = glm::lookAtRH(target + glm::vec3(0.0f, -900.0f, 1300.0f), target, glm::vec3(0, 0, 1)); + return projection * view; +} + +glm::vec3 Ndc(const glm::mat4& viewProjection, const glm::vec3& world) +{ + const glm::vec4 clip = viewProjection * glm::vec4(world, 1.0f); + return glm::vec3(clip) / clip.w; +} +} // namespace + +TEST_CASE("the sun stands opposite where the shadows fall, as high as their length says [render][sun]") +{ + // Shadows towards -x (Classic), half as long as the caster is tall. + const glm::vec3 toSun = SunDirection(180.0f, 0.5f); + CHECK(glm::length(toSun) == doctest::Approx(1.0f)); + CHECK(toSun.x > 0.0f); + CHECK(toSun.y == doctest::Approx(0.0f).epsilon(1e-6)); + CHECK(toSun.x / toSun.z == doctest::Approx(0.5f)); + + const glm::vec3 east = SunDirection(90.0f, 0.5f); + CHECK(east.y < 0.0f); + CHECK(east.x == doctest::Approx(0.0f).epsilon(1e-6)); +} + +TEST_CASE("the shadow map covers the ground the camera sees [render][sun]") +{ + const glm::vec3 hero(12800.0f, 12800.0f, 200.0f); + const glm::mat4 scene = SceneViewProjection(hero); + const auto view = BuildSunShadowView(SunDirection(180.0f, 0.5f), scene, 0.0f, 600.0f, 2048u); + + // Every ground point at the screen's corners and centre lands inside the map's depth and area. + const glm::mat4 sceneFromClip = glm::inverse(scene); + for (const float x : {-1.0f, 0.0f, 1.0f}) + { + for (const float y : {-1.0f, 0.0f, 1.0f}) + { + const glm::vec4 nearPoint = sceneFromClip * glm::vec4(x, y, 0.0f, 1.0f); + const glm::vec4 farPoint = sceneFromClip * glm::vec4(x, y, 1.0f, 1.0f); + const glm::vec3 a = glm::vec3(nearPoint) / nearPoint.w; + const glm::vec3 b = glm::vec3(farPoint) / farPoint.w; + const glm::vec3 ground = a + (b - a) * ((hero.z - a.z) / (b.z - a.z)); + const glm::vec3 shadow = Ndc(view.viewProjection, ground); + CHECK(std::abs(shadow.x) < 1.0f); + CHECK(std::abs(shadow.y) < 1.0f); + CHECK(shadow.z > 0.0f); + CHECK(shadow.z < 1.0f); + } + } + // A caster high above the ground still lies in front of the map's near plane. + CHECK(Ndc(view.viewProjection, hero + glm::vec3(0.0f, 0.0f, 2000.0f)).z > 0.0f); + // Clip w is 2, so the vertex shaders' near-plane clip (w - 1) keeps every vertex. + CHECK((view.viewProjection * glm::vec4(hero, 1.0f)).w == doctest::Approx(2.0f)); +} + +TEST_CASE("a recorded scene matrix turns into the sun's [render][sun]") +{ + const glm::mat4 scene = SceneViewProjection({12800.0f, 12800.0f, 200.0f}); + const auto view = BuildSunShadowView(SunDirection(135.0f, 0.5f), scene, 0.0f, 600.0f, 2048u); + // A model's draw records scene * model; the sun pass draws it with sunFromScene * that. + const glm::mat4 model = glm::rotate(glm::translate(glm::mat4(1.0f), glm::vec3(12900.0f, 12750.0f, 180.0f)), 0.7f, + glm::vec3(0.0f, 0.0f, 1.0f)); + for (const glm::vec3 vertex : {glm::vec3(0.0f), glm::vec3(40.0f, -30.0f, 150.0f), glm::vec3(-60.0f, 10.0f, 5.0f)}) + { + const glm::vec3 expected = Ndc(view.viewProjection * model, vertex); + const glm::vec3 converted = Ndc(view.sunFromScene * (scene * model), vertex); + CHECK(converted.x == doctest::Approx(expected.x).epsilon(1e-4)); + CHECK(converted.y == doctest::Approx(expected.y).epsilon(1e-4)); + CHECK(converted.z == doctest::Approx(expected.z).epsilon(1e-4)); + } +} + +TEST_CASE("a camera moving less than a texel keeps the shadow map where it is [render][sun]") +{ + const glm::vec3 toSun = SunDirection(180.0f, 0.5f); + const glm::vec3 hero(12800.0f, 12800.0f, 200.0f); + const auto view = BuildSunShadowView(toSun, SceneViewProjection(hero), 0.0f, 600.0f, 2048u); + const float texel = view.box.size / 2048.0f; + const auto nudged = BuildSunShadowView(toSun, SceneViewProjection(hero + glm::vec3(texel * 0.01f, 0.0f, 0.0f)), + 0.0f, 600.0f, 2048u); + CHECK(nudged.box == view.box); + + // Further away, the map follows, by whole texels. + const auto moved = + BuildSunShadowView(toSun, SceneViewProjection(hero + glm::vec3(300.0f, 200.0f, 0.0f)), 0.0f, 600.0f, 2048u); + CHECK_FALSE(moved.box == view.box); + const glm::vec2 steps = moved.box.origin / (moved.box.size / 2048.0f); + CHECK(steps.x == doctest::Approx(std::round(steps.x)).epsilon(1e-3)); + CHECK(steps.y == doctest::Approx(std::round(steps.y)).epsilon(1e-3)); +} diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index cef42fdd79..20974de133 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -87,6 +87,12 @@ const SpecRow Spec[] = { 0, 2, 0.05, TuningUnit::None, TuningZero::Plain}, {TuningControlId::AmbientOcclusionRadius, TuningGroup::PostProcessing, false, LookValue::AmbientOcclusionRadius, 10, 300, 5, TuningUnit::None, TuningZero::Plain}, + {TuningControlId::SunShadowStrength, TuningGroup::DynamicLights, false, LookValue::SunShadowStrength, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::SunShadowSoftness, TuningGroup::DynamicLights, true, LookValue::SunShadowSoftness, 0, 2, 0.1, + TuningUnit::None, TuningZero::Plain}, + {TuningControlId::SunShadowResolution, TuningGroup::DynamicLights, true, LookValue::SunShadowResolution, 1024, 4096, + 1024, TuningUnit::None, TuningZero::Plain}, }; Data::Maps::LookProfileData ShippedLikeProfile() @@ -102,9 +108,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 24 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 27 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 24); + REQUIRE(Render::Look::TuningControlCount == 27); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From e221d8dda01ea56d1c1877a3cb05f91e919fea6d Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Tue, 3 Nov 2026 23:59:13 +0800 Subject: [PATCH 10/17] feat(render): the terrain's slope shading and the models' light turn with the sun - One sun per frame (FrameSun): from dynamic.shadowAngle, with the sun the maps' baked light implies (shadow angle 135). The sun shadows, the terrain's slope shading and the models' light all take it. - The baked vectors follow the sun's turn and rise (FollowSun), each keeping its own offset, so at the baked angle every map looks as before. Classic keeps the fixed vectors. - The terrain light is built again when the sun moves (profiled as TerrainBake); CreateTerrainLight_Part now uses Battle Castle's vector too. - The models' light comes from ModelLightVector(), outside the BMD code, so models of any format can be lit alike. Battle Castle's turned light no longer stays on models after leaving it. --- docs/enhanced-look.md | 2 +- docs/light-mood.md | 2 +- .../Core/Utilities/Benchmark/BenchTypes.h | 2 +- src/source/Core/Utilities/FrameProfiler.h | 3 ++ .../Render/Lighting/DynamicLightsSetting.cpp | 31 ++++++++++++++ .../Render/Lighting/DynamicLightsSetting.h | 17 ++++++++ src/source/Render/Lighting/ModelLight.cpp | 41 +++++++++++++++++++ src/source/Render/Lighting/ModelLight.h | 16 ++++++++ src/source/Render/Lighting/SunShadow.cpp | 17 ++++++++ src/source/Render/Lighting/SunShadow.h | 10 +++++ src/source/Render/Models/ZzzBMD.cpp | 26 +++--------- src/source/Render/Models/ZzzBMD.h | 1 - src/source/Render/Terrain/ZzzLodTerrain.cpp | 32 ++++++++++----- src/source/Scenes/SceneLightingSetup.cpp | 9 ++-- tests/render/test_sun_shadow.cpp | 32 +++++++++++++++ 15 files changed, 199 insertions(+), 42 deletions(-) create mode 100644 src/source/Render/Lighting/ModelLight.cpp create mode 100644 src/source/Render/Lighting/ModelLight.h diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index d9510d8d1d..22ea8bc5ae 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -212,7 +212,7 @@ for the whole file. | `dynamic.effectCap` | 2.5 | 0 (none) | 0–8 | the most light overlapping spell lights may add up to | | `dynamic.shadowOpacity` | 0.6 | 0.6 | 0–1 | how much characters' shadows darken the ground's own light; overlapping shadows darken it once, and point lights still light shadowed ground | | `dynamic.shadowLights` | 2 | 0 | 0–4 | how many of the strongest point lights near a character cast its shadow away from them; each darkens the point light on the ground by its share of the character's point light, and a light at the character casts none | -| `dynamic.shadowAngle` | 135 | 180 | 0–360 | which way characters' shadows fall, in degrees counter-clockwise from world +x; 135 falls away from the sun that shades the terrain's slopes, 180 is the Classic direction | +| `dynamic.shadowAngle` | 135 | 180 | 0–360 | which way characters' shadows fall, in degrees counter-clockwise from world +x; 135 falls away from the sun the maps' baked light was made for, 180 is the Classic direction. The sun turns with it: its shadow map, the terrain's slope shading and the models' light all follow, each keeping the offset the map's baked light has from that sun, so at 135 every map looks as it always did | | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | diff --git a/docs/light-mood.md b/docs/light-mood.md index 8afdb88da2..cb8f32024e 100644 --- a/docs/light-mood.md +++ b/docs/light-mood.md @@ -52,7 +52,7 @@ for the reader. | `figures` | the baked light on characters, monsters and NPCs, and the fixed light of the player's own character | `base` to 1 | | `dynamicGain` | the light candles, fires, skills and effects add each frame | 0.5 to 2 | | `background` | the clear and fog colour behind the scene | 0 to 1 | -| `sun` | how much brighter a model face turned to the sun is than one turned away (1 is Classic, 0 leaves only the even fill light) | 0 to 1 | +| `sun` | how much brighter a model face turned to the sun is than one turned away (1 is Classic, 0 leaves only the even fill light); with Enhanced dynamic lights the direction follows `dynamic.shadowAngle` | 0 to 1 | | `shadowKeep` | optional: the baked light at which a place keeps its full brightness; `base` and `figures` then darken the shade only, fading out towards this light (sunlit ground stays day). 0 (the default) darkens everything evenly | 0 to 1.5 | | `brightScale` | optional, with a shadow keep: the scale places at the shadow keep get, never below `base` (figures: never below `figures`) | 0.3 to 1 (default) | | `shadeCool` | optional: how much bluer the darkened shade gets | 0 (default) to 0.5 | diff --git a/src/source/Core/Utilities/Benchmark/BenchTypes.h b/src/source/Core/Utilities/Benchmark/BenchTypes.h index 9ded8eb47d..437fef4009 100644 --- a/src/source/Core/Utilities/Benchmark/BenchTypes.h +++ b/src/source/Core/Utilities/Benchmark/BenchTypes.h @@ -15,7 +15,7 @@ namespace Core::Benchmark { // Upper bound on the pass/counter dimensions copied out of FrameProfiler. Static-asserted // against the real enum sizes in BenchRecorder.cpp, which is the only file that knows both. -inline constexpr int kMaxPasses = 32; +inline constexpr int kMaxPasses = 40; inline constexpr int kMaxCounters = 32; // Name of the segment every run starts and ends with, so drift across the run is measurable diff --git a/src/source/Core/Utilities/FrameProfiler.h b/src/source/Core/Utilities/FrameProfiler.h index 330edf72f9..0e293202c5 100644 --- a/src/source/Core/Utilities/FrameProfiler.h +++ b/src/source/Core/Utilities/FrameProfiler.h @@ -48,6 +48,8 @@ enum class Pass : int UpdateEffects, // Inside RendererReplay: the sun shadow map. SunShadow, + // Inside the terrain's frame start: the static terrain light built again for a moved sun. + TerrainBake, Count_ }; @@ -56,6 +58,7 @@ inline constexpr const char* kPassNames[static_cast(Pass::Count_)] = { "MovePart", "Skinning", "UI", "RenderBegin", "RenderEnd", "Submit", "UIUpdate", "RmlInput", "UILayout", "Flush", "Sprites", "Particles", "Joints", "Overlay", "RmlUpd", "RmlRend", "EndOffscr", "EndStage", "EndReplay", "EndPostUI", "ObjAnim", "ObjDraw", "UpdateFx", "SunShadow", + "TerrainBake", }; enum class Counter : int diff --git a/src/source/Render/Lighting/DynamicLightsSetting.cpp b/src/source/Render/Lighting/DynamicLightsSetting.cpp index 5143189039..0b7f279bc7 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.cpp +++ b/src/source/Render/Lighting/DynamicLightsSetting.cpp @@ -5,7 +5,9 @@ #include "Core/Utilities/Log/MuLogger.h" #include "Render/Lighting/EnhancedLightingSetting.h" #include "Render/Look/LookProfileSetting.h" +#include "Render/Lighting/SunShadow.h" #include "Render/Renderer/MuRenderer.h" +#include "World/MapInfra/MapManager.h" #include "Scenes/SceneCore.h" namespace Render::Lighting @@ -38,4 +40,33 @@ bool SunShadowsActive() mu::GetRenderer().SunShadowsAvailable(); } +std::optional FrameSun() +{ + if (!DynamicLightsActive()) + { + return std::nullopt; + } + const float fall = gMapManager.InBattleCastle() ? kSunShadowFallBattleCastle : kSunShadowFall; + return FrameSunDirections{SunDirection(Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle), fall), + SunDirection(kBakedSunShadowAngle, fall)}; +} + +glm::vec3 FollowFrameSun(const glm::vec3& baked) +{ + const std::optional sun = FrameSun(); + if (!sun) + { + return baked; + } + // Every model asks with the same vector each frame: the last answer is reused. + static glm::vec3 s_baked{0.0f}, s_sun{0.0f}, s_followed{0.0f}; + if (baked != s_baked || sun->sun != s_sun) + { + s_baked = baked; + s_sun = sun->sun; + s_followed = FollowSun(baked, sun->baked, sun->sun); + } + return s_followed; +} + } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/DynamicLightsSetting.h b/src/source/Render/Lighting/DynamicLightsSetting.h index 4d00021105..19aaa39c95 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.h +++ b/src/source/Render/Lighting/DynamicLightsSetting.h @@ -1,5 +1,9 @@ #pragma once +#include + +#include + namespace Render::Lighting { @@ -16,4 +20,17 @@ void SetDynamicLightsEnabled(bool enabled); // sun.shadow above 0 and a renderer that can draw it. Characters then cast no flat sun shadow. [[nodiscard]] bool SunShadowsActive(); +// This frame's sun (towards it): from dynamic.shadowAngle and the map's shadow length, and the sun the +// map's baked light implies (kBakedSunShadowAngle). None without Enhanced dynamic lights (Classic). +struct FrameSunDirections +{ + glm::vec3 sun{0.0f, 0.0f, 1.0f}; + glm::vec3 baked{0.0f, 0.0f, 1.0f}; +}; +[[nodiscard]] std::optional FrameSun(); + +// `baked` (a world-space light vector of the baked light) following this frame's sun (FollowSun); +// unchanged without one. +[[nodiscard]] glm::vec3 FollowFrameSun(const glm::vec3& baked); + } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/ModelLight.cpp b/src/source/Render/Lighting/ModelLight.cpp new file mode 100644 index 0000000000..077f280b0a --- /dev/null +++ b/src/source/Render/Lighting/ModelLight.cpp @@ -0,0 +1,41 @@ +#include "stdafx.h" + +#include "Render/Lighting/ModelLight.h" + +#include "Core/Math/ZzzMathLib.h" +#include "Render/Lighting/DynamicLightsSetting.h" +#include "Render/Lighting/LightMoodSetting.h" +#include "World/MapInfra/MapManager.h" + +namespace Render::Lighting +{ + +glm::vec3 ModelLightVector(bool highlight) +{ + vec3_t position; + vec3_t angle = {0.f, 0.f, 0.f}; + if (highlight) + { + Vector(1.3f, 0.f, 2.f, position); + } + else if (gMapManager.InBattleCastle()) + { + Vector(0.5f, -1.f, 1.f, position); + Vector(0.f, 0.f, -45.f, angle); + } + else + { + Vector(0.f, -1.5f, 0.f, position); + } + + // The light mood's sun scales the directional part of the model light. + LightMood::ScaleSunDirection(LightMood::Active(), position); + float matrix[3][4]; + AngleMatrix(angle, matrix); + vec3_t light; + VectorIRotate(position, matrix, light); + const glm::vec3 vector(light[0], light[1], light[2]); + return highlight ? vector : FollowFrameSun(vector); +} + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/ModelLight.h b/src/source/Render/Lighting/ModelLight.h new file mode 100644 index 0000000000..a90508428b --- /dev/null +++ b/src/source/Render/Lighting/ModelLight.h @@ -0,0 +1,16 @@ +// ModelLight.h: the directional light models are lit with, whatever format they come from. +#pragma once + +#include + +namespace Render::Lighting +{ + +// World-space vector towards the models' light; its length is the directional part's strength +// (Classic lights a face max(0.8 × dot(n, L) + 0.4, 0.2) with it), so the normals it meets must be +// world-oriented. `highlight`: the brighter fixed light of previews (BMD::HighLight). Otherwise the +// map's baked direction, scaled by the light mood's sun and, with Enhanced dynamic lights, following +// the frame's sun (FollowFrameSun). +[[nodiscard]] glm::vec3 ModelLightVector(bool highlight); + +} // namespace Render::Lighting diff --git a/src/source/Render/Lighting/SunShadow.cpp b/src/source/Render/Lighting/SunShadow.cpp index 745553bf70..a2c8e42cc8 100644 --- a/src/source/Render/Lighting/SunShadow.cpp +++ b/src/source/Render/Lighting/SunShadow.cpp @@ -32,6 +32,23 @@ glm::vec3 SunDirection(float fallAngleDegrees, float fallPerHeight) return glm::normalize(glm::vec3(-std::cos(angle) * fallPerHeight, -std::sin(angle) * fallPerHeight, 1.0f)); } +glm::vec3 FollowSun(const glm::vec3& baked, const glm::vec3& bakedSun, const glm::vec3& sun) +{ + const float length = glm::length(baked); + if (sun == bakedSun || length == 0.0f) + { + return baked; + } + const auto azimuth = [](const glm::vec3& v) { return std::atan2(v.y, v.x); }; + const auto elevation = [](const glm::vec3& v) { return std::atan2(v.z, std::hypot(v.x, v.y)); }; + const float maxElevation = glm::radians(89.0f); + const float turned = azimuth(baked) + azimuth(sun) - azimuth(bakedSun); + const float raised = + std::clamp(elevation(baked) + elevation(sun) - elevation(bakedSun), -maxElevation, maxElevation); + return length * + glm::vec3(std::cos(raised) * std::cos(turned), std::cos(raised) * std::sin(turned), std::sin(raised)); +} + SunShadowView BuildSunShadowView(const glm::vec3& toSun, const glm::mat4& sceneViewProjection, float groundLow, float groundHigh, std::uint32_t resolution) { diff --git a/src/source/Render/Lighting/SunShadow.h b/src/source/Render/Lighting/SunShadow.h index 672a6e8b4d..e70719cfc4 100644 --- a/src/source/Render/Lighting/SunShadow.h +++ b/src/source/Render/Lighting/SunShadow.h @@ -19,6 +19,16 @@ inline constexpr float kSunShadowCasterHeight = 3000.0f; // world +x, as dynamic.shadowAngle) and `fallPerHeight` units per unit of height. [[nodiscard]] glm::vec3 SunDirection(float fallAngleDegrees, float fallPerHeight); +// The dynamic.shadowAngle the maps' baked light implies: its terrain sun, (0.5, -0.5, 0.5), stands at +// azimuth 315°, so shadows fall towards 135°. +inline constexpr float kBakedSunShadowAngle = 135.0f; + +// A baked light vector (the terrain's slope shading, the models' light) moved as far as the sun has +// moved from `bakedSun`, the sun the bake implies: its azimuth and elevation each change by the +// sun's, its length stays, and its elevation stays within ±89°. Exactly `baked` while the sun is +// `bakedSun`, so the maps keep their look at the baked angle. +[[nodiscard]] glm::vec3 FollowSun(const glm::vec3& baked, const glm::vec3& bakedSun, const glm::vec3& sun); + // The square, texel-snapped area of the shadow map: light-space x and y from `origin`, `size` wide, // depth from `nearDistance` to `farDistance` along the sun's rays. struct SunShadowBox diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index c1c7d9b03d..664c95b26c 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -51,6 +51,7 @@ #include "Scenes/MainScene.h" #include "Render/Lighting/LightMoodSetting.h" #include "Render/Lighting/DynamicLightsSetting.h" +#include "Render/Lighting/ModelLight.h" #include "Render/Lighting/LightShadowCasters.h" #include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" @@ -615,27 +616,10 @@ void BMD::TransformCheap(float (*BoneMatrix)[3][4], const vec3_t BoundingBoxMin, if (LightEnable) { - vec3_t Position; - - float Matrix[3][4]; - if (HighLight) - { - Vector(1.3f, 0.f, 2.f, Position); - } - else if (gMapManager.InBattleCastle()) - { - Vector(0.5f, -1.f, 1.f, Position); - Vector(0.f, 0.f, -45.f, ShadowAngle); - } - else - { - Vector(0.f, -1.5f, 0.f, Position); - } - - // The light mood's sun scales the directional part of the model light. - Render::Lighting::LightMood::ScaleSunDirection(Render::Lighting::LightMood::Active(), Position); - AngleMatrix(ShadowAngle, Matrix); - VectorIRotate(Position, Matrix, m_LastLightPosition); // for RenderMesh's GPU-skinned in-shader lighting + // For RenderMesh's lighting, CPU and GPU-skinned: normals are world-oriented (the root bone + // carries the object's angle), so one world vector lights every model alike. + const glm::vec3 light = Render::Lighting::ModelLightVector(HighLight); + Vector(light.x, light.y, light.z, m_LastLightPosition); } // Release/gameplay OBB: from the caller-supplied bounding box args, not a vertex-loop-derived diff --git a/src/source/Render/Models/ZzzBMD.h b/src/source/Render/Models/ZzzBMD.h index 7953b3b786..d79d16f05e 100644 --- a/src/source/Render/Models/ZzzBMD.h +++ b/src/source/Render/Models/ZzzBMD.h @@ -223,7 +223,6 @@ class BMD vec3_t BodyAngle; float BodyHeight; char StreamMesh; - vec3_t ShadowAngle; char Skin; bool HideSkin; float Velocity; diff --git a/src/source/Render/Terrain/ZzzLodTerrain.cpp b/src/source/Render/Terrain/ZzzLodTerrain.cpp index 12edf70456..b650660fe9 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.cpp +++ b/src/source/Render/Terrain/ZzzLodTerrain.cpp @@ -28,6 +28,7 @@ #include "Render/Renderer/MuRenderer.h" #include "Render/Renderer/RenderUtils.h" #include "Render/Terrain/TerrainHeightGrid.h" +#include "Core/Utilities/FrameProfiler.h" #include "Render/Lighting/DynamicLightHistory.h" #include "Render/Lighting/DynamicLightList.h" #include "Render/Lighting/DynamicLightsSetting.h" @@ -593,17 +594,20 @@ float RequestStaticLightBrightWeight(float xf, float yf) return weight[0]; } +// The sun the slope shading leans towards: the map's baked one, following the frame's sun. +static glm::vec3 TerrainSunVector() +{ + const glm::vec3 baked = gMapManager.InBattleCastle() ? glm::vec3(0.5f, -1.f, 1.f) : glm::vec3(0.5f, -0.5f, 0.5f); + return Render::Lighting::FollowFrameSun(baked); +} + +// The vector BackTerrainLight was last built with. +static glm::vec3 s_terrainLightSun{0.f}; + void CreateTerrainLight() { - vec3_t Light; - if (gMapManager.InBattleCastle()) - { - Vector(0.5f, -1.f, 1.f, Light); - } - else - { - Vector(0.5f, -0.5f, 0.5f, Light); - } + s_terrainLightSun = TerrainSunVector(); + const vec3_t Light = {s_terrainLightSun.x, s_terrainLightSun.y, s_terrainLightSun.z}; const Render::Lighting::LightMood::Scales& scales = Render::Lighting::LightMood::Active(); for (int y = 0; y < TERRAIN_SIZE; y++) { @@ -622,8 +626,7 @@ void CreateTerrainLight_Part(int xi, int yi) if (yi > TERRAIN_SIZE - 4) yi = TERRAIN_SIZE - 4; else if (yi < 4) yi = 4; - vec3_t Light; - Vector(0.5f, -0.5f, 0.5f, Light); + const vec3_t Light = {s_terrainLightSun.x, s_terrainLightSun.y, s_terrainLightSun.z}; const Render::Lighting::LightMood::Scales& scales = Render::Lighting::LightMood::Active(); for (int y = yi - 4; y < yi + 4; y++) { @@ -2880,6 +2883,13 @@ extern int EnableEvent; void InitTerrainLight() { + // The sun moved (dynamic.shadowAngle): the slope shading follows it. + if (const glm::vec3 sun = TerrainSunVector(); + glm::any(glm::greaterThan(glm::abs(sun - s_terrainLightSun), glm::vec3(1e-4f)))) + { + FRAME_PROFILE(TerrainBake); + CreateTerrainLight(); + } Render::Lighting::FrameDynamicLights().Clear(); Render::Lighting::FrameWorldDynamicLights().Clear(); s_groundLightBuilt = false; diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index cf1f1b74a5..d77298b592 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -16,7 +16,6 @@ #include "Render/Renderer/MuRenderer.h" #include "Render/Renderer/SceneLighting.h" #include "Scenes/SceneCore.h" -#include "World/MapInfra/MapManager.h" #include #include @@ -56,15 +55,13 @@ void SubmitSceneLighting() lighting.cameraPosition[2] = g_Camera.Position[2]; Render::Lighting::ApplyTuning(lighting); lighting.highlightKnee = Render::Lighting::LightMood::Active().highlightKnee; - if (Render::Lighting::SunShadowsActive() && Hero) + const std::optional sun = Render::Lighting::FrameSun(); + if (Render::Lighting::SunShadowsActive() && Hero && sun) { using Data::Maps::LookValue; // The sun stands where the flat character shadows said it did: they fall towards // dynamic.shadowAngle, as long as before. - const glm::vec3 toSun = - Render::Lighting::SunDirection(Render::Look::Value(LookValue::GroundShadowAngle), - gMapManager.InBattleCastle() ? Render::Lighting::kSunShadowFallBattleCastle - : Render::Lighting::kSunShadowFall); + const glm::vec3 toSun = sun->sun; lighting.sunDirection[0] = toSun.x; lighting.sunDirection[1] = toSun.y; lighting.sunDirection[2] = toSun.z; diff --git a/tests/render/test_sun_shadow.cpp b/tests/render/test_sun_shadow.cpp index a60fc92b3c..4175963570 100644 --- a/tests/render/test_sun_shadow.cpp +++ b/tests/render/test_sun_shadow.cpp @@ -105,3 +105,35 @@ TEST_CASE("a camera moving less than a texel keeps the shadow map where it is [r CHECK(steps.x == doctest::Approx(std::round(steps.x)).epsilon(1e-3)); CHECK(steps.y == doctest::Approx(std::round(steps.y)).epsilon(1e-3)); } + +TEST_CASE("a baked light vector follows the sun's turn and rise, and is the same at the baked sun [render][sun]") +{ + using Render::Lighting::FollowSun; + const glm::vec3 bakedSun = SunDirection(Render::Lighting::kBakedSunShadowAngle, 0.5f); + const glm::vec3 terrain(0.5f, -0.5f, 0.5f); + const glm::vec3 model(0.0f, -1.5f, 0.0f); + + // At the baked sun: exactly the old vectors. + CHECK(FollowSun(terrain, bakedSun, bakedSun) == terrain); + CHECK(FollowSun(model, bakedSun, bakedSun) == model); + + // The sun a quarter turn round (shadows towards 225 degrees instead of 135): so is the vector, as long. + const glm::vec3 turned = FollowSun(terrain, bakedSun, SunDirection(225.0f, 0.5f)); + CHECK(glm::length(turned) == doctest::Approx(glm::length(terrain))); + CHECK(turned.x == doctest::Approx(0.5f)); + CHECK(turned.y == doctest::Approx(0.5f)); + CHECK(turned.z == doctest::Approx(0.5f)); + + // A higher sun (shorter shadows) raises a level vector by as much. + const glm::vec3 higherSun = SunDirection(Render::Lighting::kBakedSunShadowAngle, 0.25f); + const float rise = std::atan2(higherSun.z, std::hypot(higherSun.x, higherSun.y)) - + std::atan2(bakedSun.z, std::hypot(bakedSun.x, bakedSun.y)); + const glm::vec3 raised = FollowSun(model, bakedSun, higherSun); + CHECK(std::atan2(raised.z, std::hypot(raised.x, raised.y)) == doctest::Approx(rise)); + CHECK(glm::length(raised) == doctest::Approx(1.5f)); + + // Never past straight up. + const glm::vec3 steep = FollowSun(glm::vec3(0.0f, 0.0f, 1.0f) + glm::vec3(0.01f, 0.0f, 0.0f), bakedSun, + SunDirection(Render::Lighting::kBakedSunShadowAngle, 0.01f)); + CHECK(std::atan2(steep.z, std::hypot(steep.x, steep.y)) <= glm::radians(89.0f) + 1e-5f); +} From 53e205b4f480747015c792e5b9d13cad252bff06 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Thu, 22 Oct 2026 12:20:12 +0800 Subject: [PATCH 11/17] feat(render): indoor and underground maps get no sun - New look value dynamic.flatSunShadow (0 to 1, Enhanced only): how dark the flat shadow under characters is while sun shadows are off. Classic keeps it as before. - Dungeon, Lost Tower, Kanturu Relics and Refinery Tower set sun.shadow and dynamic.flatSunShadow to 0 in Look.json: no sun there, so only torches and spells cast character shadows. Every other map keeps its look. --- docs/enhanced-look.md | 4 ++- src/Localization/Game.en.resx | 6 +++++ src/bin/Data/Render/Look.json | 27 ++++++++++++++++++- .../Data/GameData/MapData/LookProfile.cpp | 1 + .../Data/GameData/MapData/LookProfile.h | 1 + src/source/Render/Look/LookTuningCommand.cpp | 1 + src/source/Render/Look/LookTuningCommand.h | 1 + src/source/Render/Look/TuningControls.cpp | 2 ++ src/source/Render/Look/TuningControls.h | 1 + src/source/Render/Models/ZzzBMD.cpp | 9 ++++--- src/source/UI/Options/TuningRows.cpp | 2 ++ tests/data/test_look_profile_json.cpp | 8 ++++++ tests/render/test_look_profile.cpp | 1 + .../render/test_projected_shadow_state.cmake | 2 +- tests/render/test_tuning_controls.cpp | 6 +++-- 15 files changed, 64 insertions(+), 8 deletions(-) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 22ea8bc5ae..6f888332c2 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -89,6 +89,7 @@ window. | Dynamic lights | Sun shadows | `sun.shadow` | 0–100 % | 5 % | 100 % | common | | Dynamic lights | Sun shadow softness | `sun.softness` | 0–2 | 0.1 | 1 | More settings | | Dynamic lights | Sun shadow resolution | `sun.resolution` | 1024–4096 | 1024 | 2048 | More settings | +| Dynamic lights | Flat sun shadow | `dynamic.flatSunShadow` | 0–100 % | 5 % | 100 % (0 indoors) | More settings | | Darker map light | Mood strength | `mood.strengthPercent` | 0–100 % | 1 % | 100 % | common | | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | @@ -220,6 +221,7 @@ for the whole file. | `ao.radius` | 60 | 60 | 10–300 | how far, in world units, nearby geometry still darkens a surface | | `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | | `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | +| `dynamic.flatSunShadow` | 1 (Dungeon, Lost Tower, Kanturu Relics, Refinery Tower: 0) | 1 | 0–1 | how dark the flat shadow under characters is while sun shadows are off (`sun.shadow` 0), on top of the shadow's own darkness. The indoor and underground maps set both to 0: no sun there, so only torches and spells cast character shadows. Classic always draws it | | `sun.resolution` | 2048 | 2048 | 1024–4096 | the sun shadow map's size in texels (1024, 2048 or 4096): sharper shadows for more graphics memory and time | ## Developer commands @@ -249,7 +251,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `, `$sun `, `$sun softness `, `$sun resolution `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `, `$sun `, `$sun softness `, `$sun resolution `, `$dynlights flatsun `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index 9f4845de5d..e41c8b1a37 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1219,6 +1219,12 @@ How far from a surface nearby geometry still darkens it, in world units (a terrain cell is 100). + + Flat sun shadow + + + How dark the flat shadow under characters is when sun shadows are off. Indoor and underground maps set it to 0, leaving only the shadows of torches and spells. + Sun shadows diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index d4aaa6dbfc..fc98e3cc1c 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -26,13 +26,38 @@ "ao.radius": 60, "sun.shadow": 1, "sun.softness": 1, - "sun.resolution": 2048 + "sun.resolution": 2048, + "dynamic.flatSunShadow": 1 }, "maps": [ + { + "world": 1, + "name": "Dungeon", + "sun.shadow": 0, + "dynamic.flatSunShadow": 0 + }, + { + "world": 4, + "name": "Lost Tower", + "sun.shadow": 0, + "dynamic.flatSunShadow": 0 + }, { "world": 10, "name": "Icarus", "bloom.strength": 0.3 + }, + { + "world": 38, + "name": "Kanturu Relics", + "sun.shadow": 0, + "dynamic.flatSunShadow": 0 + }, + { + "world": 39, + "name": "Refinery Tower", + "sun.shadow": 0, + "dynamic.flatSunShadow": 0 } ] } diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index ad5b62a351..5350123c1a 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -52,6 +52,7 @@ constexpr std::array Infos = {{ {LookValue::SunShadowStrength, "sun.shadow", 0.0, 0.0, 1.0}, {LookValue::SunShadowSoftness, "sun.softness", 1.0, 0.0, 2.0}, {LookValue::SunShadowResolution, "sun.resolution", 2048.0, 1024.0, 4096.0}, + {LookValue::FlatSunShadow, "dynamic.flatSunShadow", 1.0, 0.0, 1.0}, }}; constexpr bool InfosFollowLookValueOrder() diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index 62a3b5ddd2..134b231094 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -54,6 +54,7 @@ enum class LookValue : std::uint8_t SunShadowStrength, SunShadowSoftness, SunShadowResolution, + FlatSunShadow, Count, }; diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index 1c9bf218a3..d4758de66f 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -30,6 +30,7 @@ const CommandForm CommandForms[] = { {L"$dynlights shadow ", {LookValue::GroundShadowOpacity}}, {L"$dynlights shadowangle ", {LookValue::GroundShadowAngle}}, {L"$dynlights shadowlights ", {LookValue::GroundShadowLights}}, + {L"$dynlights flatsun ", {LookValue::FlatSunShadow}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$ao radius ", {LookValue::AmbientOcclusionRadius}}, {L"$ao ", {LookValue::AmbientOcclusionStrength}}, diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index 8f135388ca..fba2e1b5ff 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -38,6 +38,7 @@ // $sun softness sun.softness // $sun resolution sun.resolution // $sun sun.shadow +// $dynlights flatsun dynamic.flatSunShadow namespace Render::Look { diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index 3b89060391..c2bb15d643 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -88,6 +88,8 @@ constexpr std::array Specs = {{ TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::SunShadowResolution, TuningGroup::DynamicLights, true, LookValue::SunShadowResolution, 1024.0, TuningUnit::None, 1.0, TuningZero::Plain}, + {TuningControlId::FlatSunShadow, TuningGroup::DynamicLights, true, LookValue::FlatSunShadow, 0.05, + TuningUnit::Percent, 100.0, TuningZero::Plain}, }}; constexpr bool SpecsFollowIdOrder() diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index af4d46e937..ece6e389d9 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -82,6 +82,7 @@ enum class TuningControlId : std::uint8_t SunShadowStrength, SunShadowSoftness, SunShadowResolution, + FlatSunShadow, Count, }; inline constexpr std::size_t TuningControlCount = static_cast(TuningControlId::Count); diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index 664c95b26c..ad71e0d373 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -3110,11 +3110,14 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, projection, shadowColor); } }; - // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it. - if (!Render::Lighting::SunShadowsActive()) + // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it, as dark + // as the map lets it be (dynamic.flatSunShadow: none indoors). + const float flatSunShadow = + Render::Lighting::DynamicLightsActive() ? Render::Look::Value(Data::Maps::LookValue::FlatSunShadow) : 1.f; + if (!Render::Lighting::SunShadowsActive() && flatSunShadow > 0.f) { const mu::ScopedGroundShadow groundShadow; - drawShadow(draw.alpha); + drawShadow(draw.alpha * flatSunShadow); } // The ground's strongest point lights cast one more shadow each, away from the light. const Render::Lighting::WorldDynamicLights& worldLights = Render::Lighting::FrameWorldDynamicLights(); diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index 4577e6b0e7..b1a72f8cd9 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -62,6 +62,8 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningShadowDirection, I18N::Game::TuningShadowDirectionHelp}; case TuningControlId::SunShadowStrength: return {I18N::Game::TuningSunShadows, I18N::Game::TuningSunShadowsHelp}; + case TuningControlId::FlatSunShadow: + return {I18N::Game::TuningFlatSunShadow, I18N::Game::TuningFlatSunShadowHelp}; case TuningControlId::SunShadowSoftness: return {I18N::Game::TuningSunShadowSoftness, I18N::Game::TuningSunShadowSoftnessHelp}; case TuningControlId::SunShadowResolution: diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index eb946dfe59..dcd4523ea8 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -286,4 +286,12 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] // Icarus: less bloom, which widened its fog clouds. CHECK(loaded.data.ForWorld(Icarus)[LookValue::BloomStrength] == doctest::Approx(0.3)); CHECK(loaded.data.ForWorld(Lorencia)[LookValue::BloomStrength] == doctest::Approx(1.0)); + // Indoor and underground maps: no sun, and no flat sun shadow under characters. + for (const int world : {1, 4, 38, 39}) + { + CAPTURE(world); + CHECK(loaded.data.ForWorld(world)[LookValue::SunShadowStrength] == 0.0); + CHECK(loaded.data.ForWorld(world)[LookValue::FlatSunShadow] == 0.0); + } + CHECK(loaded.data.ForWorld(Lorencia)[LookValue::FlatSunShadow] == 1.0); } diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index 51e815bce5..892ed7ef47 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -240,6 +240,7 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$sun softness 1.5", LookValue::SunShadowSoftness, 1.5); single(L"$sun resolution 4096", LookValue::SunShadowResolution, 4096.0); single(L"$sun 0.5", LookValue::SunShadowStrength, 0.5); + single(L"$dynlights flatsun 0.5", LookValue::FlatSunShadow, 0.5); const std::optional diffuse = ParseLookTuningCommand(L"$lighting diffuse 1.0 0.3 0.15"); diff --git a/tests/render/test_projected_shadow_state.cmake b/tests/render/test_projected_shadow_state.cmake index fc84e22cfd..490a94f70f 100644 --- a/tests/render/test_projected_shadow_state.cmake +++ b/tests/render/test_projected_shadow_state.cmake @@ -21,7 +21,7 @@ string(SUBSTRING "${bmd_source}" ${shadow_start} ${shadow_length} projected_shad # Every path (GPU, CPU fallback, cloth) records inside the ground-shadow scope, so a world-lit frame # draws them into the ground shadow mask. string(FIND "${projected_shadow_source}" "const mu::ScopedGroundShadow groundShadow;" scope_position) -string(FIND "${projected_shadow_source}" "drawShadow(draw.alpha);" first_draw_position) +string(FIND "${projected_shadow_source}" "drawShadow(draw.alpha * flatSunShadow);" first_draw_position) if(scope_position EQUAL -1 OR first_draw_position LESS scope_position) message(FATAL_ERROR "Projected body shadows must be recorded inside a ScopedGroundShadow") endif() diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index 20974de133..eaf3bc3d99 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -93,6 +93,8 @@ const SpecRow Spec[] = { TuningUnit::None, TuningZero::Plain}, {TuningControlId::SunShadowResolution, TuningGroup::DynamicLights, true, LookValue::SunShadowResolution, 1024, 4096, 1024, TuningUnit::None, TuningZero::Plain}, + {TuningControlId::FlatSunShadow, TuningGroup::DynamicLights, true, LookValue::FlatSunShadow, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, }; Data::Maps::LookProfileData ShippedLikeProfile() @@ -108,9 +110,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 27 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 28 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 27); + REQUIRE(Render::Look::TuningControlCount == 28); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From 99cc4ac82cc9fa73ecefa46d8ece1d70ed9c65f4 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 00:27:09 +0800 Subject: [PATCH 12/17] refactor(render): the frame's sun is taken once per frame, lit shaders share their lighting code - UpdateFrameSun() at the start of each frame's update (InitTerrainLight) fills the sun that FrameSun() and FollowFrameSun() return; their static caches go, and every part of a frame sees the same sun. - scene_lighting.hlsli and dynamic_lighting.hlsli hold the uniforms, the Enhanced fog curve, the sun shadow lookup and the point lights' fade that world_lit, skinned_lit and basic_textured_fog each carried a copy of; shader blobs rebuild when an include changes. - SdlGpuSunShadowMap owns the sun shadow map's textures and sampler. - The terrain light arrays say what each holds. --- CMakeLists.txt | 1 + src/shaders/basic_textured_fog.frag.hlsl | 31 +---- .../compiled/basic_textured_fog.frag.dxil | Bin 6060 -> 6168 bytes .../compiled/basic_textured_fog.frag.msl | 32 ++--- .../compiled/basic_textured_fog.frag.spv | Bin 5068 -> 5232 bytes src/shaders/compiled/skinned_lit.frag.dxil | Bin 11936 -> 11976 bytes src/shaders/compiled/skinned_lit.frag.msl | 100 +++++++------- src/shaders/compiled/skinned_lit.frag.spv | Bin 20744 -> 21076 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 8756 -> 8736 bytes src/shaders/compiled/world_lit.frag.msl | 72 +++++----- src/shaders/compiled/world_lit.frag.spv | Bin 12112 -> 12316 bytes src/shaders/dynamic_lighting.hlsli | 49 +++++++ src/shaders/scene_lighting.hlsli | 35 +++++ src/shaders/skinned_lit.frag.hlsl | 76 +---------- src/shaders/world_lit.frag.hlsl | 75 +---------- .../Render/Lighting/DynamicLightsSetting.cpp | 35 +++-- .../Render/Lighting/DynamicLightsSetting.h | 4 + .../Render/Renderer/MuRendererSDLGpu.cpp | 125 ++++-------------- .../Render/Renderer/SdlGpuSunShadowMap.cpp | 124 +++++++++++++++++ .../Render/Renderer/SdlGpuSunShadowMap.h | 56 ++++++++ src/source/Render/Terrain/ZzzLodTerrain.cpp | 8 ++ 21 files changed, 439 insertions(+), 384 deletions(-) create mode 100644 src/shaders/dynamic_lighting.hlsli create mode 100644 src/shaders/scene_lighting.hlsli create mode 100644 src/source/Render/Renderer/SdlGpuSunShadowMap.cpp create mode 100644 src/source/Render/Renderer/SdlGpuSunShadowMap.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 32438ea415..a400c18c34 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -141,6 +141,7 @@ if(MU_ENABLE_SHADER_COMPILATION) set(MU_SHADER_BLOBS "${MU_SHADER_BLOBS}" "${spv}" "${msl}" "${dxil}" PARENT_SCOPE) endfunction() + file(GLOB MU_SHADER_INCLUDES CONFIGURE_DEPENDS "${MU_SHADER_SOURCE_DIR}/*.hlsli") set(MU_SHADER_BLOBS) foreach(shader_stage IN LISTS MU_SHADER_STAGE_NAMES) string(REGEX REPLACE "\\.[^.]+$" "" shader_name "${shader_stage}") diff --git a/src/shaders/basic_textured_fog.frag.hlsl b/src/shaders/basic_textured_fog.frag.hlsl index f0ace9236f..ab6b19e94a 100644 --- a/src/shaders/basic_textured_fog.frag.hlsl +++ b/src/shaders/basic_textured_fog.frag.hlsl @@ -1,30 +1,10 @@ // basic_textured_fog.frag.hlsl — basic_textured.frag with Enhanced per-pixel exponential fog. // Used by the 3D and GPU-skinned unlit pipelines while Enhanced lighting is on, so terrain, static // objects and model overlays fade into the fog together with skinned_lit.frag models. -// FogUniforms mirrors FogUniform and SceneLighting mirrors mu::SceneLightingUniform (std140). +// The shared uniforms and lighting functions: scene_lighting.hlsli. Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); -cbuffer FogUniforms : register(b0, space3) -{ - uint fogEnabled; - uint alphaDiscardEnabled; - float alphaThreshold; - uint alphaToCoverage; // 1: the pipeline turns alpha into multisample coverage - float fogStart; - float fogEnd; - float4 fogColor; -}; -cbuffer SceneLighting : register(b1, space3) -{ - float4 sceneLightDirection; - float4 sceneLightColor; - float4 diffuseCurve; - float4 rimParameters; - float4 specularParameters; - float4 sceneFogColor; - float4 sceneFogParameters; - float4 cameraPosition; -}; +#include "scene_lighting.hlsli" struct FSInput { float4 pos : SV_Position; @@ -34,13 +14,6 @@ struct FSInput float eyeDepth : TEXCOORD3; }; -// Same curve as skinned_lit.frag.hlsl and mu::EnhancedFogAmount() (SceneLighting.cpp). -float EnhancedFogAmount(float eyeDepth) -{ - const float scaledDistance = max(eyeDepth - sceneFogParameters.x, 0.0) * sceneFogParameters.z; - return saturate(1.0 - exp(-scaledDistance * scaledDistance)); -} - float4 main(FSInput input) : SV_Target { float4 color = tex.Sample(s, input.uv) * input.color; diff --git a/src/shaders/compiled/basic_textured_fog.frag.dxil b/src/shaders/compiled/basic_textured_fog.frag.dxil index 32a30bccd7fbe256384d4b78ee71d24b698cf4ad..728f5e48b952f61dfd4d300467a26903e30ef81f 100644 GIT binary patch delta 1117 zcmbW0YfM{Z7{}jpPU*enurXFHg;NH#k;uxewA*yO$u?FZ1H-l$v=tCYMj>m}Er!vH z92lT!DM-1D99Uh@EXyI?MHVG3M+tP?hYlCQ!i0_(S>iH4qcI*9KNvsy@qOO^|NlHs z^8BtJ^vdJ(XS6!Y8y&CPH;+CG+<#aE9{(^30RTiIcU)XVxc~s$u&NhMZQ}x9r0Z8< z0Q6^07yvCo>9>`xYjuGY2_JwS&+l+A^sawh@FtX%!5O85$9iIbWoWW8Vo;L*ty1dC za6PMkv{V1+^riBZl!B;K!)rYGtXBUE!@%IOwSF`r8iK^0RAy45l}N}RK)Hi*uCI_g zl+BeBYJ{sK0tmN|04z@_Gcg&nFl{rjAiokE7vD3n=}DhJpQ^FlslY`M0CLDPgXVZ< znNb)NUq_@-y%;*pu-7TrdcQ={(I{c!bqdBT!_HrBXNi$MD8YlV5|NLyn>`xVzWti` z!iU$v4^3J&{|l^W{A$IU1z;j8h+1VrBlEg zXI%o^L3&w|djsR$A_uSl7Wq67BW1%Rv?NDIT)cR=bV<(tisbEOM-;YKfpnn;az$wZC4_&P+;R)gv$h1LwwkOJ#g4ak!-~RrFLklDJ`3mN=BCayrPHFa+V{;?x_dF)?icc4Sk(&U2y;c3 zzX)Un_uVkw|7#a7*FU)V{)5|vf8o~q0=F_xCxStw|2C5K|DZEQDxoARafEAcX_q;* zB1q=gBSZI8g62Mmpb=Y$1x21a=w;a||1JlPs!`)DZafGp*o!%u<47%{EjQ@+3{oGddXJlYtSR+1BN{W?*mw`cHqvdQSRUIw{ zh6JE^HxmPcON6Hn15l9wkS_uhcXB>(Pmza#p=t6@rrC_~lczE(Fs|6VjoFw{{i9Tv zg480Ho@6H}X2tv8Yk?@_o{F!as*fGF!FeZ_H!MCZTpU)LWmrWR8Koy1vdJ?BOb%p| zn4HHZC%2%8t>KI$gHt+#hV1D?4hDvX=Zt+03IYt35)2Holh?Aj*EdQPEYLnYTS4F~ zOJji^WYiM+P9 zo`SvtT*fyPd@i@8GO)*fV6BhiXjhbBix+6;J!s&lu#fjp2%oeVn@q_;@e_(NZE*=T z2W8Ay&af=BXy!f5!nf-I_X`0&XDgnE3^^Rjcn_K6M4V#)DZU0&Tq04{C~GFN-+=G= z0=~BgQck_<*7A9`rYEl{U;)rQ73{GM>~SB!?lEZRb+pNmxZ_wa*TCzl^Wcz84TGTJ zPJ``+TQ*rrrRC%&mJ|!KF!4kz*?IQjSzmz;1BHpt+|1pR_1?be?(I1ibL-}H8Ck(y zMtk(PoA2Dl>u0O*t$_c>1pZ$JZ<{4P9G3iYIH0xn?7Fk6y=%_&=6MN(C>}1}s6BbM zcXjb>ApzeLA7b7dy7A`Jllo;WuChip(=E3cY%vG<$^~+n6 zljrpyROxW>!qd&#+(pIJi@6tr%$TjThe`Je$WU+X-QG&G7jZAvo-K6431pU$xz$da z728eBckR?XXj1}IBw4+>crnoS*+O5Kfw=*cFav?KF-ODZYVNO$mXT_y3VX{=U9+Bf zVr`$zuIHev(*n&(3(>Mt4pLT{0nSPZo2N2|5TA+8@LMp-2Q0ARYV4Y%(d;C_sL>>( zAt02_&@qQmp_r}Vf+U02WM#olje|V9IGF@<9oo7kwjE?L tex, sampler s, constant FogUniforms& _72) +float4 _main(thread const FSInput& _input, constant SceneLighting& _25, texture2d tex, sampler s, constant FogUniforms& _73) { float4 color = tex.sample(s, _input.uv) * _input.color; - if (_72.alphaToCoverage != 0u) + if (_73.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _72.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _73.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -72,24 +74,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _24, texture2 } else { - if ((_72.alphaDiscardEnabled != 0u) && (color.w <= _72.alphaThreshold)) + if ((_73.alphaDiscardEnabled != 0u) && (color.w <= _73.alphaThreshold)) { discard_fragment(); } } - if ((_72.fogEnabled != 0u) && (_24.sceneFogColor.w > 0.0)) + if ((_73.fogEnabled != 0u) && (_25.sceneFogColor.w > 0.0)) { - float4 _133 = color; + float4 _134 = color; float param = _input.eyeDepth; - float3 _145 = mix(_133.xyz, _24.sceneFogColor.xyz, float3(EnhancedFogAmount(param, _24))); - color.x = _145.x; - color.y = _145.y; - color.z = _145.z; + float3 _146 = mix(_134.xyz, _25.sceneFogColor.xyz, float3(EnhancedFogAmount(param, _25))); + color.x = _146.x; + color.y = _146.y; + color.z = _146.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _72 [[buffer(0)]], constant SceneLighting& _24 [[buffer(1)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _73 [[buffer(0)]], constant SceneLighting& _25 [[buffer(1)]], texture2d tex [[texture(0)]], sampler s [[sampler(0)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -99,8 +101,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _72 [[b _input.fogFactor = in.input_fogFactor; _input.eyeDepth = in.input_eyeDepth; FSInput param = _input; - float4 _179 = _main(param, _24, tex, s, _72); - out._entryPointOutput = _179; + float4 _180 = _main(param, _25, tex, s, _73); + out._entryPointOutput = _180; return out; } diff --git a/src/shaders/compiled/basic_textured_fog.frag.spv b/src/shaders/compiled/basic_textured_fog.frag.spv index dc1af83a8a20f5d92c44a1edef88b4e0f39cebde..318e0f26110279a40fc03fe37bff1742363d3d8c 100644 GIT binary patch literal 5232 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 G4E-CB?k!XR diff --git a/src/shaders/compiled/skinned_lit.frag.msl b/src/shaders/compiled/skinned_lit.frag.msl index 02d00cd9b2..c241fbac53 100644 --- a/src/shaders/compiled/skinned_lit.frag.msl +++ b/src/shaders/compiled/skinned_lit.frag.msl @@ -39,7 +39,8 @@ struct DynamicLights { uint dynamicLightCount; float dynamicLightWrap; - uint2 dynamicLightPadding; + uint dynamicWorldLightCount; + float groundShadowOpacity; float4 dynamicLightPositionAndRadius[32]; float4 dynamicLightColor[32]; }; @@ -95,52 +96,59 @@ float3 PerturbNormal(thread const float3& normal, thread const float3& tangent, } static inline __attribute__((always_inline)) -float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _123, depth2d sunShadowMap, sampler sunShadowSampler) +float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _68, depth2d sunShadowMap, sampler sunShadowSampler) { - if (_123.sunShadowParameters.x <= 0.0) + if (_68.sunShadowParameters.x <= 0.0) { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _123.sunShadowParameters.w)); - float4 clip = _123.sunViewProjection * float4(lifted, 1.0); + float3 lifted = worldPosition + (worldNormal * (1.5 * _68.sunShadowParameters.w)); + float4 clip = _68.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) { return 1.0; } - float2 _step = _123.sunShadowParameters.zz * _123.sunShadowParameters.y; + float2 _step = _68.sunShadowParameters.zz * _68.sunShadowParameters.y; float visible = 0.0; for (int y = -1; y <= 1; y++) { for (int x = -1; x <= 1; x++) { - float3 _276 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _276.xy, _276.z, level(0.0)); + float3 _210 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _210.xy, _210.z, level(0.0)); } } return visible / 9.0; } static inline __attribute__((always_inline)) -float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _299) +float PointLightFalloff(thread const float3& toLight, thread const float& radius) +{ + float horizontal = length(toLight.xy); + return (horizontal < radius) ? ((radius - horizontal) / radius) : 0.0; +} + +static inline __attribute__((always_inline)) +float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _318) { float3 light = float3(0.0); - uint count = min(_299.dynamicLightCount, 32u); + uint count = min(_318.dynamicLightCount, 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _299.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _318.dynamicLightPositionAndRadius[i]; float3 toLight = positionAndRadius.xyz - worldPosition; - float radius = positionAndRadius.w; - float horizontalDistance = length(toLight.xy); - if (horizontalDistance >= radius) + float3 param = toLight; + float param_1 = positionAndRadius.w; + float falloff = PointLightFalloff(param, param_1); + if (falloff <= 0.0) { continue; } - float falloff = (radius - horizontalDistance) / radius; - float3 param = toLight; - float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param)) * (1.0 - _299.dynamicLightWrap)) + _299.dynamicLightWrap, 0.0, 1.0); - light += (_299.dynamicLightColor[i].xyz * (falloff * wrapped)); + float3 param_2 = toLight; + float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param_2)) * (1.0 - _318.dynamicLightWrap)) + _318.dynamicLightWrap, 0.0, 1.0); + light += (_318.dynamicLightColor[i].xyz * (falloff * wrapped)); } return light; } @@ -171,14 +179,14 @@ float3 RollOffHighlight(thread const float3& color, thread const float& knee) } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _123) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _68) { - float scaledDistance = fast::max(eyeDepth - _123.sceneFogParameters.x, 0.0) * _123.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _68.sceneFogParameters.x, 0.0) * _68.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _123, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _299, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _677) +float4 _main(thread const FSInput& _input, constant SceneLighting& _68, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _318, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _689) { float4 texel = tex.sample(s, _input.uv); float2 uvDx = dfdx(_input.uv); @@ -189,10 +197,10 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _123, depth2d if ((normalMapScale > 0.0) && (_input.tangent.w != 0.0)) { float3 mapped = (normalMap.sample(normalSampler, _input.uv, gradient2d(uvDx, uvDy)).xyz * 2.0) - float3(1.0); - float3 _462 = mapped; - float2 _464 = _462.xy * normalMapScale; - mapped.x = _464.x; - mapped.y = _464.y; + float3 _473 = mapped; + float2 _475 = _473.xy * normalMapScale; + mapped.x = _475.x; + mapped.y = _475.y; float handedness = (_input.tangent.w > 0.0) ? 1.0 : (-1.0); float3 param = _input.normal; float3 param_1 = _input.tangent.xyz; @@ -217,35 +225,35 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _123, depth2d float3 litNormal = SafeNormalize(param_10); float3 param_11 = _input.worldPositionAndDynamicLights.xyz; float3 param_12 = litNormal; - float sunLight = inWorld ? (1.0 - (_123.sunShadowParameters.x * (1.0 - SunVisibility(param_11, param_12, _123, sunShadowMap, sunShadowSampler)))) : 1.0; - float luminosity = fast::max(((lightDot * _123.diffuseCurve.x) * sunLight) + _123.diffuseCurve.y, _123.diffuseCurve.z); + float sunLight = inWorld ? (1.0 - (_68.sunShadowParameters.x * (1.0 - SunVisibility(param_11, param_12, _68, sunShadowMap, sunShadowSampler)))) : 1.0; + float luminosity = fast::max(((lightDot * _68.diffuseCurve.x) * sunLight) + _68.diffuseCurve.y, _68.diffuseCurve.z); float3 param_13 = _input.worldPositionAndDynamicLights.xyz; float3 param_14 = litNormal; - float3 dynamicLight = select(float3(0.0), DynamicLighting(param_13, param_14, _299), bool3(inWorld)); + float3 dynamicLight = select(float3(0.0), DynamicLighting(param_13, param_14, _318), bool3(inWorld)); float3 diffuse = fast::clamp((objectLight * luminosity) + dynamicLight, float3(0.0), float3(1.0)); - float param_15 = _123.diffuseCurve.w; + float param_15 = _68.diffuseCurve.w; if (RollsOffHighlight(param_15)) { float3 param_16 = (objectLight * luminosity) + dynamicLight; - float param_17 = _123.diffuseCurve.w; + float param_17 = _68.diffuseCurve.w; diffuse = RollOffHighlight(param_16, param_17); } float facing = fast::clamp(abs(dot(normal, view)), 0.0, 1.0); - float3 rim = objectLight * (_123.rimParameters.x * powr(1.0 - facing, _123.rimParameters.y)); - float specularStrength = _input.lightDirectionAndSpecular.w * _123.specularParameters.x; + float3 rim = objectLight * (_68.rimParameters.x * powr(1.0 - facing, _68.rimParameters.y)); + float specularStrength = _input.lightDirectionAndSpecular.w * _68.specularParameters.x; float3 specular = float3(0.0); if ((specularStrength > 0.0) && (lightDot > 0.0)) { float3 param_18 = light; float3 param_19 = SafeNormalize(param_18) + view; float3 halfVector = SafeNormalize(param_19); - float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _123.specularParameters.y); - specular = (_123.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; + float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _68.specularParameters.y); + specular = (_68.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; } float4 color = float4(((texel.xyz * diffuse) + rim) + specular, texel.w * _input.color.w); - if (_677.alphaToCoverage != 0u) + if (_689.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _677.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _689.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -254,24 +262,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _123, depth2d } else { - if ((_677.alphaDiscardEnabled != 0u) && (color.w <= _677.alphaThreshold)) + if ((_689.alphaDiscardEnabled != 0u) && (color.w <= _689.alphaThreshold)) { discard_fragment(); } } - if ((_677.fogEnabled != 0u) && (_123.sceneFogColor.w > 0.0)) + if ((_689.fogEnabled != 0u) && (_68.sceneFogColor.w > 0.0)) { - float4 _730 = color; + float4 _742 = color; float param_20 = _input.eyeDepth; - float3 _740 = mix(_730.xyz, _123.sceneFogColor.xyz, float3(EnhancedFogAmount(param_20, _123))); - color.x = _740.x; - color.y = _740.y; - color.z = _740.z; + float3 _752 = mix(_742.xyz, _68.sceneFogColor.xyz, float3(EnhancedFogAmount(param_20, _68))); + color.x = _752.x; + color.y = _752.y; + color.z = _752.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _677 [[buffer(0)]], constant SceneLighting& _123 [[buffer(1)]], constant DynamicLights& _299 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _689 [[buffer(0)]], constant SceneLighting& _68 [[buffer(1)]], constant DynamicLights& _318 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -288,8 +296,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _677 [[ _input.tangent = in.input_tangent; _input.worldTangentAndNormalMapScale = in.input_worldTangentAndNormalMapScale; FSInput param = _input; - float4 _795 = _main(param, _123, sunShadowMap, sunShadowSampler, _299, tex, s, normalMap, normalSampler, _677); - out._entryPointOutput = _795; + float4 _807 = _main(param, _68, sunShadowMap, sunShadowSampler, _318, tex, s, normalMap, normalSampler, _689); + out._entryPointOutput = _807; return out; } diff --git a/src/shaders/compiled/skinned_lit.frag.spv b/src/shaders/compiled/skinned_lit.frag.spv index 16f2908e52e6de405e0994d6a1bb78b8b3d8f992..b3476f964515215a3faeefd0580c9b2cbf1f1608 100644 GIT binary patch literal 21076 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 literal 20744 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 XA2rue%#C@B>+@h^`2TWZ|6lGuA%5PS diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index ccef158762a18ba246c15c9e17ef03a727179c0b..d84eaff41b3ff69116092a992d02b872c6841297 100644 GIT binary patch delta 1439 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 Ay#N3J diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index 08606d250f..ccc1a0126e 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -65,76 +65,80 @@ struct main0_in }; static inline __attribute__((always_inline)) -float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _36, depth2d sunShadowMap, sampler sunShadowSampler) +float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _41, depth2d sunShadowMap, sampler sunShadowSampler) { - if (_36.sunShadowParameters.x <= 0.0) + if (_41.sunShadowParameters.x <= 0.0) { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _36.sunShadowParameters.w)); - float4 clip = _36.sunViewProjection * float4(lifted, 1.0); + float3 lifted = worldPosition + (worldNormal * (1.5 * _41.sunShadowParameters.w)); + float4 clip = _41.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) { return 1.0; } - float2 _step = _36.sunShadowParameters.zz * _36.sunShadowParameters.y; + float2 _step = _41.sunShadowParameters.zz * _41.sunShadowParameters.y; float visible = 0.0; for (int y = -1; y <= 1; y++) { for (int x = -1; x <= 1; x++) { - float3 _179 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _179.xy, _179.z, level(0.0)); + float3 _184 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _184.xy, _184.z, level(0.0)); } } return visible / 9.0; } static inline __attribute__((always_inline)) -float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _202) +float PointLightFalloff(thread const float3& toLight, thread const float& radius) +{ + float horizontal = length(toLight.xy); + return (horizontal < radius) ? ((radius - horizontal) / radius) : 0.0; +} + +static inline __attribute__((always_inline)) +float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _222) { float3 light = float3(0.0); - uint count = min(min(_202.dynamicWorldLightCount, _202.dynamicLightCount), 32u); + uint count = min(min(_222.dynamicWorldLightCount, _222.dynamicLightCount), 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _202.dynamicLightPositionAndRadius[i]; - float radius = positionAndRadius.w; - float horizontalDistance = length(positionAndRadius.xy - worldPosition.xy); - if (horizontalDistance < radius) - { - light += (_202.dynamicLightColor[i].xyz * ((radius - horizontalDistance) / radius)); - } + float4 positionAndRadius = _222.dynamicLightPositionAndRadius[i]; + float3 param = positionAndRadius.xyz - worldPosition; + float param_1 = positionAndRadius.w; + light += (_222.dynamicLightColor[i].xyz * PointLightFalloff(param, param_1)); } return light; } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _36) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _41) { - float scaledDistance = fast::max(eyeDepth - _36.sceneFogParameters.x, 0.0) * _36.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _41.sceneFogParameters.x, 0.0) * _41.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _36, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _202, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _358) +float4 _main(thread const FSInput& _input, constant SceneLighting& _41, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _222, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _367) { float4 texel = tex.sample(s, _input.uv); uint2 sizeQueryTemp = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); uint maskWidth = sizeQueryTemp.x; uint maskHeight = sizeQueryTemp.y; float2 visibility = groundShadowMask.sample(groundShadowSampler, (_input.pos.xy / float2(float(maskWidth), float(maskHeight)))).xy; - float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _202.groundShadowOpacity); + float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _222.groundShadowOpacity); float3 param = _input.worldPosition; float3 param_1 = float3(0.0, 0.0, 1.0); - shadow.x *= (1.0 - (_36.sunShadowParameters.x * (1.0 - SunVisibility(param, param_1, _36, sunShadowMap, sunShadowSampler)))); + shadow.x *= (1.0 - (_41.sunShadowParameters.x * (1.0 - SunVisibility(param, param_1, _41, sunShadowMap, sunShadowSampler)))); float3 param_2 = _input.worldPosition; - float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param_2, _202) * shadow.y), float3(0.0), float3(1.0)); + float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param_2, _222) * shadow.y), float3(0.0), float3(1.0)); float4 color = float4(texel.xyz * light, texel.w * _input.color.w); - if (_358.alphaToCoverage != 0u) + if (_367.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _358.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _367.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -143,24 +147,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _36, depth2d< } else { - if ((_358.alphaDiscardEnabled != 0u) && (color.w <= _358.alphaThreshold)) + if ((_367.alphaDiscardEnabled != 0u) && (color.w <= _367.alphaThreshold)) { discard_fragment(); } } - if ((_358.fogEnabled != 0u) && (_36.sceneFogColor.w > 0.0)) + if ((_367.fogEnabled != 0u) && (_41.sceneFogColor.w > 0.0)) { - float4 _411 = color; + float4 _420 = color; float param_3 = _input.eyeDepth; - float3 _421 = mix(_411.xyz, _36.sceneFogColor.xyz, float3(EnhancedFogAmount(param_3, _36))); - color.x = _421.x; - color.y = _421.y; - color.z = _421.z; + float3 _430 = mix(_420.xyz, _41.sceneFogColor.xyz, float3(EnhancedFogAmount(param_3, _41))); + color.x = _430.x; + color.y = _430.y; + color.z = _430.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _358 [[buffer(0)]], constant SceneLighting& _36 [[buffer(1)]], constant DynamicLights& _202 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _367 [[buffer(0)]], constant SceneLighting& _41 [[buffer(1)]], constant DynamicLights& _222 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -171,8 +175,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _358 [[ _input.eyeDepth = in.input_eyeDepth; _input.worldPosition = in.input_worldPosition; FSInput param = _input; - float4 _458 = _main(param, _36, sunShadowMap, sunShadowSampler, _202, tex, s, groundShadowMask, groundShadowSampler, _358); - out._entryPointOutput = _458; + float4 _467 = _main(param, _41, sunShadowMap, sunShadowSampler, _222, tex, s, groundShadowMask, groundShadowSampler, _367); + out._entryPointOutput = _467; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index 2e26f686c774d0f8a2da7bcdfc782fe6bd0774a8..4b9fa1bf87f4413f62b77f4a1f5dcc892624317b 100644 GIT binary patch literal 12316 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 literal 12112 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 1.0) || ndc.z >= 1.0) + return 1.0; + const float2 step = sunShadowParameters.zz * sunShadowParameters.y; + float visible = 0.0; + [unroll] + for (int y = -1; y <= 1; ++y) + { + [unroll] + for (int x = -1; x <= 1; ++x) + visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); + } + return visible / 9.0; +} + +// How much of a point light reaches a point `toLight` away from it: the terrain light's linear fade +// over the horizontal distance. +float PointLightFalloff(float3 toLight, float radius) +{ + const float horizontal = length(toLight.xy); + return horizontal < radius ? (radius - horizontal) / radius : 0.0; +} +#endif diff --git a/src/shaders/scene_lighting.hlsli b/src/shaders/scene_lighting.hlsli new file mode 100644 index 0000000000..1059b370db --- /dev/null +++ b/src/shaders/scene_lighting.hlsli @@ -0,0 +1,35 @@ +// scene_lighting.hlsli — the fog and scene lighting uniforms every Enhanced lit shader shares, and the +// Enhanced fog curve. FogUniforms mirrors FogUniform, SceneLighting mu::SceneLightingUniform (std140). +#ifndef MU_SCENE_LIGHTING_HLSLI +#define MU_SCENE_LIGHTING_HLSLI +cbuffer FogUniforms : register(b0, space3) +{ + uint fogEnabled; + uint alphaDiscardEnabled; + float alphaThreshold; + uint alphaToCoverage; // 1: the pipeline turns alpha into multisample coverage + float fogStart; + float fogEnd; + float4 fogColor; +}; +cbuffer SceneLighting : register(b1, space3) +{ + float4 sceneLightDirection; + float4 sceneLightColor; + float4 diffuseCurve; // scale, ambient, floor, highlight knee + float4 rimParameters; + float4 specularParameters; + float4 sceneFogColor; + float4 sceneFogParameters; + float4 cameraPosition; + float4x4 sunViewProjection; // world to the sun shadow map's clip space + float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units +}; + +// The Enhanced exponential fog: the same curve as mu::EnhancedFogAmount() (SceneLighting.cpp). +float EnhancedFogAmount(float eyeDepth) +{ + const float scaledDistance = max(eyeDepth - sceneFogParameters.x, 0.0) * sceneFogParameters.z; + return saturate(1.0 - exp(-scaledDistance * scaledDistance)); +} +#endif diff --git a/src/shaders/skinned_lit.frag.hlsl b/src/shaders/skinned_lit.frag.hlsl index 20d1b7133c..771fd58b6b 100644 --- a/src/shaders/skinned_lit.frag.hlsl +++ b/src/shaders/skinned_lit.frag.hlsl @@ -12,8 +12,7 @@ // of the skinned tangent T, bitangent cross(N, T) x handedness and N, for the diffuse, // rim, specular and point-light terms; without one (scale 0) the interpolated normal // as before, and the flat default map bound at t1 is not read -// FogUniforms mirrors FogUniform, SceneLighting mirrors mu::SceneLightingUniform and DynamicLights -// mirrors mu::DynamicLightsUniform (std140). +// The shared uniforms and lighting functions: scene_lighting.hlsli, dynamic_lighting.hlsli. Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); Texture2D normalMap : register(t1, space2); @@ -21,38 +20,9 @@ SamplerState normalSampler : register(s1, space2); // The sun shadow map's depth (Enhanced sun shadows; a far 1x1 map without them). Texture2D sunShadowMap : register(t2, space2); SamplerComparisonState sunShadowSampler : register(s2, space2); -cbuffer FogUniforms : register(b0, space3) -{ - uint fogEnabled; - uint alphaDiscardEnabled; - float alphaThreshold; - uint alphaToCoverage; // 1: the pipeline turns alpha into multisample coverage - float fogStart; - float fogEnd; - float4 fogColor; -}; -cbuffer SceneLighting : register(b1, space3) -{ - float4 sceneLightDirection; - float4 sceneLightColor; - float4 diffuseCurve; // scale, ambient, floor, highlight knee - float4 rimParameters; - float4 specularParameters; - float4 sceneFogColor; - float4 sceneFogParameters; - float4 cameraPosition; - float4x4 sunViewProjection; // world to the sun shadow map's clip space - float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units -}; -static const uint MaxDynamicLights = 32; // mu::kMaxDynamicLights -cbuffer DynamicLights : register(b2, space3) -{ - uint dynamicLightCount; // lights used - float dynamicLightWrap; // 0: Lambert, 0.5: half-Lambert (mu::WrappedDiffuse) - uint2 dynamicLightPadding; - float4 dynamicLightPositionAndRadius[MaxDynamicLights]; - float4 dynamicLightColor[MaxDynamicLights]; -}; + +#include "scene_lighting.hlsli" +#include "dynamic_lighting.hlsli" // The light mood's highlight shoulder (Render::Lighting::LightMood::RollOffHighlight): a lit // colour channel above the knee approaches 1 smoothly instead of being cut off there. Only a knee @@ -91,44 +61,12 @@ struct FSInput float4 worldTangentAndNormalMapScale : TEXCOORD10; // w: the map's scale, 0 without one }; -// Same curve as basic_textured_fog.frag.hlsl and mu::EnhancedFogAmount() (SceneLighting.cpp). -float EnhancedFogAmount(float eyeDepth) -{ - const float scaledDistance = max(eyeDepth - sceneFogParameters.x, 0.0) * sceneFogParameters.z; - return saturate(1.0 - exp(-scaledDistance * scaledDistance)); -} - float3 SafeNormalize(float3 value) { const float lengthSquared = dot(value, value); return lengthSquared > 1e-12 ? value * rsqrt(lengthSquared) : float3(0.0, 0.0, 0.0); } -// How much sun reaches `worldPosition` (Enhanced sun shadows): 1 lit, 0 in the shadow of what stands -// between it and the sun, softened over sunShadowParameters.y texels. 1 without a shadow map or -// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself. -float SunVisibility(float3 worldPosition, float3 worldNormal) -{ - if (sunShadowParameters.x <= 0.0) - return 1.0; - const float3 lifted = worldPosition + worldNormal * (1.5 * sunShadowParameters.w); - const float4 clip = mul(sunViewProjection, float4(lifted, 1.0)); - const float3 ndc = clip.xyz / clip.w; - const float2 uv = float2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); - if (any(uv < 0.0) || any(uv > 1.0) || ndc.z >= 1.0) - return 1.0; - const float2 step = sunShadowParameters.zz * sunShadowParameters.y; - float visible = 0.0; - [unroll] - for (int y = -1; y <= 1; ++y) - { - [unroll] - for (int x = -1; x <= 1; ++x) - visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); - } - return visible / 9.0; -} - // Point lights reach as far as the terrain light they come from (linear falloff over the // horizontal distance); the wrapped diffuse keeps MU's soft shading and leaves the far side dark. float3 DynamicLighting(float3 worldPosition, float3 worldNormal) @@ -140,11 +78,9 @@ float3 DynamicLighting(float3 worldPosition, float3 worldNormal) { const float4 positionAndRadius = dynamicLightPositionAndRadius[i]; const float3 toLight = positionAndRadius.xyz - worldPosition; - const float radius = positionAndRadius.w; - const float horizontalDistance = length(toLight.xy); - if (horizontalDistance >= radius) + const float falloff = PointLightFalloff(toLight, positionAndRadius.w); + if (falloff <= 0.0) continue; - const float falloff = (radius - horizontalDistance) / radius; const float wrapped = saturate(dot(worldNormal, SafeNormalize(toLight)) * (1.0 - dynamicLightWrap) + dynamicLightWrap); light += dynamicLightColor[i].rgb * (falloff * wrapped); diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index 3ad849f0a0..82c7033410 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -3,8 +3,7 @@ // The vertex colour is the terrain light without the frame's first dynamicWorldLightCount point // lights; those are added back here per pixel with the terrain light's own falloff, so the ground // gets the light it always did, smooth instead of interpolated between grid vertices. -// FogUniforms mirrors FogUniform, SceneLighting mu::SceneLightingUniform and DynamicLights -// mu::DynamicLightsUniform (std140). +// The shared uniforms and lighting functions: scene_lighting.hlsli, dynamic_lighting.hlsli. Texture2D tex : register(t0, space2); SamplerState s : register(s0, space2); @@ -15,39 +14,8 @@ SamplerComparisonState sunShadowSampler : register(s2, space2); // without shadows). Texture2D groundShadowMask : register(t1, space2); SamplerState groundShadowSampler : register(s1, space2); -cbuffer FogUniforms : register(b0, space3) -{ - uint fogEnabled; - uint alphaDiscardEnabled; - float alphaThreshold; - uint alphaToCoverage; // 1: the pipeline turns alpha into multisample coverage - float fogStart; - float fogEnd; - float4 fogColor; -}; -cbuffer SceneLighting : register(b1, space3) -{ - float4 sceneLightDirection; - float4 sceneLightColor; - float4 diffuseCurve; - float4 rimParameters; - float4 specularParameters; - float4 sceneFogColor; - float4 sceneFogParameters; - float4 cameraPosition; - float4x4 sunViewProjection; // world to the sun shadow map's clip space - float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units -}; -static const uint MaxDynamicLights = 32; // mu::kMaxDynamicLights -cbuffer DynamicLights : register(b2, space3) -{ - uint dynamicLightCount; // lights used - float dynamicLightWrap; // models only - uint dynamicWorldLightCount; // the first lights: the ones the ground's vertex colour leaves out - float groundShadowOpacity; // how much a shadow darkens the vertex colour - float4 dynamicLightPositionAndRadius[MaxDynamicLights]; - float4 dynamicLightColor[MaxDynamicLights]; -}; +#include "scene_lighting.hlsli" +#include "dynamic_lighting.hlsli" struct FSInput { float4 pos : SV_Position; @@ -58,38 +26,6 @@ struct FSInput float3 worldPosition : TEXCOORD4; }; -// Same curve as basic_textured_fog.frag.hlsl and mu::EnhancedFogAmount() (SceneLighting.cpp). -float EnhancedFogAmount(float eyeDepth) -{ - const float scaledDistance = max(eyeDepth - sceneFogParameters.x, 0.0) * sceneFogParameters.z; - return saturate(1.0 - exp(-scaledDistance * scaledDistance)); -} - -// How much sun reaches `worldPosition` (Enhanced sun shadows): 1 lit, 0 in the shadow of what stands -// between it and the sun, softened over sunShadowParameters.y texels. 1 without a shadow map or -// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself. -float SunVisibility(float3 worldPosition, float3 worldNormal) -{ - if (sunShadowParameters.x <= 0.0) - return 1.0; - const float3 lifted = worldPosition + worldNormal * (1.5 * sunShadowParameters.w); - const float4 clip = mul(sunViewProjection, float4(lifted, 1.0)); - const float3 ndc = clip.xyz / clip.w; - const float2 uv = float2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); - if (any(uv < 0.0) || any(uv > 1.0) || ndc.z >= 1.0) - return 1.0; - const float2 step = sunShadowParameters.zz * sunShadowParameters.y; - float visible = 0.0; - [unroll] - for (int y = -1; y <= 1; ++y) - { - [unroll] - for (int x = -1; x <= 1; ++x) - visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); - } - return visible / 9.0; -} - // The frame's first point lights, which the ground's vertex colour leaves out. float3 WorldDynamicLighting(float3 worldPosition) { @@ -99,10 +35,7 @@ float3 WorldDynamicLighting(float3 worldPosition) for (uint i = 0; i < count; ++i) { const float4 positionAndRadius = dynamicLightPositionAndRadius[i]; - const float radius = positionAndRadius.w; - const float horizontalDistance = length(positionAndRadius.xy - worldPosition.xy); - if (horizontalDistance < radius) - light += dynamicLightColor[i].rgb * ((radius - horizontalDistance) / radius); + light += dynamicLightColor[i].rgb * PointLightFalloff(positionAndRadius.xyz - worldPosition, positionAndRadius.w); } return light; } diff --git a/src/source/Render/Lighting/DynamicLightsSetting.cpp b/src/source/Render/Lighting/DynamicLightsSetting.cpp index 0b7f279bc7..93f5ca8df5 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.cpp +++ b/src/source/Render/Lighting/DynamicLightsSetting.cpp @@ -35,38 +35,37 @@ bool DynamicLightsActive() bool SunShadowsActive() { - return SceneFlag == MAIN_SCENE && DynamicLightsActive() && + const std::optional sun = FrameSun(); + return SceneFlag == MAIN_SCENE && DynamicLightsActive() && sun && Render::Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0 && mu::GetRenderer().SunShadowsAvailable(); } +namespace +{ +std::optional s_frameSun; +} // namespace + std::optional FrameSun() { + return s_frameSun; +} + +void UpdateFrameSun() +{ + s_frameSun.reset(); if (!DynamicLightsActive()) { - return std::nullopt; + return; } const float fall = gMapManager.InBattleCastle() ? kSunShadowFallBattleCastle : kSunShadowFall; - return FrameSunDirections{SunDirection(Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle), fall), - SunDirection(kBakedSunShadowAngle, fall)}; + s_frameSun = FrameSunDirections{SunDirection(Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle), fall), + SunDirection(kBakedSunShadowAngle, fall)}; } glm::vec3 FollowFrameSun(const glm::vec3& baked) { - const std::optional sun = FrameSun(); - if (!sun) - { - return baked; - } - // Every model asks with the same vector each frame: the last answer is reused. - static glm::vec3 s_baked{0.0f}, s_sun{0.0f}, s_followed{0.0f}; - if (baked != s_baked || sun->sun != s_sun) - { - s_baked = baked; - s_sun = sun->sun; - s_followed = FollowSun(baked, sun->baked, sun->sun); - } - return s_followed; + return s_frameSun ? FollowSun(baked, s_frameSun->baked, s_frameSun->sun) : baked; } } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/DynamicLightsSetting.h b/src/source/Render/Lighting/DynamicLightsSetting.h index 19aaa39c95..f4d4c21cad 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.h +++ b/src/source/Render/Lighting/DynamicLightsSetting.h @@ -22,6 +22,7 @@ void SetDynamicLightsEnabled(bool enabled); // This frame's sun (towards it): from dynamic.shadowAngle and the map's shadow length, and the sun the // map's baked light implies (kBakedSunShadowAngle). None without Enhanced dynamic lights (Classic). +// Taken once per frame (UpdateFrameSun), so every part of a frame sees the same sun. struct FrameSunDirections { glm::vec3 sun{0.0f, 0.0f, 1.0f}; @@ -29,6 +30,9 @@ struct FrameSunDirections }; [[nodiscard]] std::optional FrameSun(); +// Takes this frame's sun; called first thing each frame (InitTerrainLight). +void UpdateFrameSun(); + // `baked` (a world-space light vector of the baked light) following this frame's sun (FollowSun); // unchanged without one. [[nodiscard]] glm::vec3 FollowFrameSun(const glm::vec3& baked); diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 268e019689..368c288eac 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -39,6 +39,7 @@ #include "RangeAllocator.h" #include "SdlGpuPixelFormat.h" #include "SdlGpuAmbientOcclusion.h" +#include "SdlGpuSunShadowMap.h" #include "SdlGpuPostProcessing.h" #include "SdlGpuReplayState.h" #include "SdlGpuValidation.h" @@ -1316,19 +1317,11 @@ static SDL_GPUShader* s_fragShaderAmbientOcclusionBlur = nullptr; // post_ao_blu // The scene's ambient occlusion (one sample only), and the scene's projection it reconstructs from. static mu::SdlGpuAmbientOcclusion s_ambientOcclusion; static float s_sceneProjection[16]{}; -// Enhanced sun shadows (one sample): the shadow map's pipelines for 3D, skinned and glTF draws, the map and -// its size, the far 1x1 map bound while there is none, the comparison sampler, whether this frame asks -// for the map (SetSceneLighting) and whether it holds this frame's. +// Enhanced sun shadows (one sample): the shadow map's pipelines for 3D, skinned and glTF draws, and its +// textures. static SDL_GPUGraphicsPipeline* s_sunShadowPipelines[3]{}; // [ShadowPassLayout] static SDL_GPUShader* s_fragShaderSunDepth = nullptr; // sun_depth.frag -static SDL_GPUTexture* s_sunShadowMap = nullptr; -static Uint32 s_sunShadowMapSize = 0u; -static SDL_GPUTexture* s_sunShadowFallback = nullptr; -static bool s_sunShadowFallbackCleared = false; -static SDL_GPUSampler* s_sunShadowSampler = nullptr; -static bool s_sunShadowRequested = false; -static Uint32 s_sunShadowResolution = 0u; -static bool s_sunShadowMapReady = false; +static mu::SdlGpuSunShadowMap s_sunShadowMap; // Depth buffer texture for correct 3D depth testing. // Created in Init() at swapchain dimensions, recreated on window resize. @@ -2675,10 +2668,11 @@ class MuRendererSDLGpu : public IMuRenderer // 1x1 map. Slot 1 is bound per draw (BindReplayFragmentSampler). static void BindLitSamplers() { - SDL_GPUTexture* const sunShadow = s_sunShadowMapReady ? s_sunShadowMap : s_sunShadowFallback; - if (sunShadow && s_sunShadowSampler) + SDL_GPUTexture* const sunShadow = s_sunShadowMap.Bound(); + SDL_GPUSampler* const sunShadowSampler = s_sunShadowMap.Sampler(); + if (sunShadow && sunShadowSampler) { - const SDL_GPUTextureSamplerBinding binding{sunShadow, s_sunShadowSampler}; + const SDL_GPUTextureSamplerBinding binding{sunShadow, sunShadowSampler}; SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotSunShadow, &binding, 1); } } @@ -2762,36 +2756,6 @@ class MuRendererSDLGpu : public IMuRenderer return SDL_BeginGPURenderPass(s_cmdBuf, nullptr, 0, &target); } - [[nodiscard]] static SDL_GPUTexture* CreateSunShadowDepth(Uint32 size) - { - SDL_GPUTextureCreateInfo info{}; - info.type = SDL_GPU_TEXTURETYPE_2D; - info.format = mu::SdlGpuDepthFormat; - info.width = size; - info.height = size; - info.layer_count_or_depth = 1; - info.num_levels = 1; - info.sample_count = SDL_GPU_SAMPLECOUNT_1; - info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; - SDL_GPUTexture* const texture = SDL_CreateGPUTexture(s_device, &info); - if (!texture) - { - mu::log::Get("render")->error("SDL_gpu -- sun shadow map creation failed ({0}x{0}): {1}", size, - SDL_GetError()); - } - return texture; - } - - static void ReleaseSunShadowMap() - { - if (s_sunShadowMap) - { - SDL_ReleaseGPUTexture(s_device, s_sunShadowMap); - s_sunShadowMap = nullptr; - } - s_sunShadowMapSize = 0u; - } - // The frame's sun shadow map: the scene's solid draws [0, end) seen from the sun. Without a request // (SetSceneLighting) the map is released and the lit shaders read the far 1x1 one. // shortcut: every solid draw is drawn again each frame, the map's still parts too; cache them @@ -2799,38 +2763,27 @@ class MuRendererSDLGpu : public IMuRenderer static void RenderSunShadowMap(std::size_t end, bool boneDataReady) { FRAME_PROFILE(SunShadow); - s_sunShadowMapReady = false; - if (s_sunShadowFallback && !s_sunShadowFallbackCleared) + if (SDL_GPUTexture* const fallback = s_sunShadowMap.FallbackToClear()) { - if ((s_renderPass = BeginDepthOnlyPass(s_sunShadowFallback)) != nullptr) + if ((s_renderPass = BeginDepthOnlyPass(fallback)) != nullptr) { EndReplayPass(); - s_sunShadowFallbackCleared = true; + s_sunShadowMap.MarkFallbackCleared(); } } - if (!s_sunShadowRequested) - { - ReleaseSunShadowMap(); - return; - } - if (s_sunShadowMapSize != s_sunShadowResolution) - { - ReleaseSunShadowMap(); - s_sunShadowMap = CreateSunShadowDepth(s_sunShadowResolution); - s_sunShadowMapSize = s_sunShadowMap ? s_sunShadowResolution : 0u; - } - if (!s_sunShadowMap || (s_renderPass = BeginDepthOnlyPass(s_sunShadowMap)) == nullptr) + SDL_GPUTexture* const map = s_sunShadowMap.PrepareMap(); + if (!map || (s_renderPass = BeginDepthOnlyPass(map)) == nullptr) { return; } - const float size = static_cast(s_sunShadowMapSize); - ReplayView view{{0.0f, 0.0f, size, size, 0.0f, 1.0f}, - {0, 0, static_cast(s_sunShadowMapSize), static_cast(s_sunShadowMapSize)}}; + const int texels = static_cast(s_sunShadowMap.Resolution()); + const float size = static_cast(texels); + ReplayView view{{0.0f, 0.0f, size, size, 0.0f, 1.0f}, {0, 0, texels, texels}}; s_sunShadowPass = true; ReplayCommands(0u, end, boneDataReady, ReplaySelection::SunShadowCasters, view); s_sunShadowPass = false; EndReplayPass(); - s_sunShadowMapReady = true; + s_sunShadowMap.MarkReady(); } static void EndReplayPass() @@ -5435,16 +5388,14 @@ class MuRendererSDLGpu : public IMuRenderer std::memcpy(s_sceneProjection, glm::value_ptr(m_projMatrix), sizeof(s_sceneProjection)); const glm::mat4 viewProjection = m_projMatrix * m_modelViewMatrix; - s_sunShadowRequested = lighting.sunShadowDarkness > 0.0f && SunShadowsAvailable(); - if (s_sunShadowRequested) + s_sunShadowMap.Cancel(); + if (lighting.sunShadowDarkness > 0.0f && SunShadowsAvailable()) { - const Uint32 resolution = lighting.sunShadowResolution < 1536u ? 1024u - : lighting.sunShadowResolution < 3072u ? 2048u - : 4096u; + s_sunShadowMap.Request(lighting.sunShadowResolution); + const Uint32 resolution = s_sunShadowMap.Resolution(); const glm::vec3 toSun(lighting.sunDirection[0], lighting.sunDirection[1], lighting.sunDirection[2]); const Render::Lighting::SunShadowView sun = Render::Lighting::BuildSunShadowView( toSun, viewProjection, lighting.groundLow, lighting.groundHigh, resolution); - s_sunShadowResolution = resolution; s_sunFromScene = sun.sunFromScene; std::memcpy(s_sceneLightingUniform.sunViewProjection, glm::value_ptr(sun.viewProjection), sizeof(s_sceneLightingUniform.sunViewProjection)); @@ -5459,7 +5410,7 @@ class MuRendererSDLGpu : public IMuRenderer [[nodiscard]] bool SunShadowsAvailable() const override { return s_enhancedLightingAvailable && s_sunShadowPipelines[0] && s_sunShadowPipelines[1] && - s_sunShadowSampler && s_sunShadowFallback; + s_sunShadowMap.IsAvailable(); } void SetDynamicLights(const DynamicLightsUniform& lights) override @@ -7316,40 +7267,12 @@ class MuRendererSDLGpu : public IMuRenderer LogPipelineFailure(driver ? driver : "unknown", result, false); } } - if (!s_sunShadowSampler) - { - SDL_GPUSamplerCreateInfo samplerInfo{}; - samplerInfo.min_filter = SDL_GPU_FILTER_LINEAR; - samplerInfo.mag_filter = SDL_GPU_FILTER_LINEAR; - samplerInfo.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST; - samplerInfo.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; - samplerInfo.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; - samplerInfo.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; - samplerInfo.enable_compare = true; - // Lit where the surface is no further from the sun than what the map saw first. - samplerInfo.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; - s_sunShadowSampler = SDL_CreateGPUSampler(s_device, &samplerInfo); - } - if (!s_sunShadowFallback) - { - s_sunShadowFallback = CreateSunShadowDepth(1u); - s_sunShadowFallbackCleared = false; - } + (void)s_sunShadowMap.CreateResources(s_device); } static void ReleaseSunShadowResources() { - ReleaseSunShadowMap(); - if (s_sunShadowFallback) - { - SDL_ReleaseGPUTexture(s_device, s_sunShadowFallback); - s_sunShadowFallback = nullptr; - } - if (s_sunShadowSampler) - { - SDL_ReleaseGPUSampler(s_device, s_sunShadowSampler); - s_sunShadowSampler = nullptr; - } + s_sunShadowMap.Release(); } // The ground shadow mask's pipelines (one sample, whatever s_sampleCount is). Optional: without them diff --git a/src/source/Render/Renderer/SdlGpuSunShadowMap.cpp b/src/source/Render/Renderer/SdlGpuSunShadowMap.cpp new file mode 100644 index 0000000000..2c0571c94e --- /dev/null +++ b/src/source/Render/Renderer/SdlGpuSunShadowMap.cpp @@ -0,0 +1,124 @@ +#include "stdafx.h" + +#include "Render/Renderer/SdlGpuSunShadowMap.h" + +#include "Core/Utilities/Log/MuLogger.h" +#include "Render/Renderer/SdlGpuPixelFormat.h" + +namespace mu +{ + +Uint32 SdlGpuSunShadowMap::ResolutionFor(Uint32 requested) +{ + return requested < 1536u ? 1024u : requested < 3072u ? 2048u : 4096u; +} + +bool SdlGpuSunShadowMap::CreateResources(SDL_GPUDevice* device) +{ + m_device = device; + if (!m_sampler) + { + SDL_GPUSamplerCreateInfo samplerInfo{}; + samplerInfo.min_filter = SDL_GPU_FILTER_LINEAR; + samplerInfo.mag_filter = SDL_GPU_FILTER_LINEAR; + samplerInfo.mipmap_mode = SDL_GPU_SAMPLERMIPMAPMODE_NEAREST; + samplerInfo.address_mode_u = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.address_mode_v = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.address_mode_w = SDL_GPU_SAMPLERADDRESSMODE_CLAMP_TO_EDGE; + samplerInfo.enable_compare = true; + // Lit where the surface is no further from the sun than what the map saw first. + samplerInfo.compare_op = SDL_GPU_COMPAREOP_LESS_OR_EQUAL; + m_sampler = SDL_CreateGPUSampler(m_device, &samplerInfo); + } + if (!m_fallback) + { + m_fallback = CreateDepth(1u); + m_fallbackCleared = false; + } + return IsAvailable(); +} + +bool SdlGpuSunShadowMap::IsAvailable() const +{ + return m_sampler && m_fallback; +} + +void SdlGpuSunShadowMap::Release() +{ + ReleaseMap(); + if (m_fallback) + { + SDL_ReleaseGPUTexture(m_device, m_fallback); + m_fallback = nullptr; + } + if (m_sampler) + { + SDL_ReleaseGPUSampler(m_device, m_sampler); + m_sampler = nullptr; + } +} + +void SdlGpuSunShadowMap::Request(Uint32 requested) +{ + m_requested = true; + m_resolution = ResolutionFor(requested); +} + +void SdlGpuSunShadowMap::Cancel() +{ + m_requested = false; +} + +SDL_GPUTexture* SdlGpuSunShadowMap::FallbackToClear() const +{ + return m_fallbackCleared ? nullptr : m_fallback; +} + +SDL_GPUTexture* SdlGpuSunShadowMap::PrepareMap() +{ + m_ready = false; + if (!m_requested) + { + ReleaseMap(); + return nullptr; + } + if (m_mapSize != m_resolution) + { + ReleaseMap(); + m_map = CreateDepth(m_resolution); + m_mapSize = m_map ? m_resolution : 0u; + } + return m_map; +} + +SDL_GPUTexture* SdlGpuSunShadowMap::CreateDepth(Uint32 size) const +{ + SDL_GPUTextureCreateInfo info{}; + info.type = SDL_GPU_TEXTURETYPE_2D; + info.format = SdlGpuDepthFormat; + info.width = size; + info.height = size; + info.layer_count_or_depth = 1; + info.num_levels = 1; + info.sample_count = SDL_GPU_SAMPLECOUNT_1; + info.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; + SDL_GPUTexture* const texture = SDL_CreateGPUTexture(m_device, &info); + if (!texture) + { + mu::log::Get("render")->error("SDL_gpu -- sun shadow map creation failed ({0}x{0}): {1}", size, + SDL_GetError()); + } + return texture; +} + +void SdlGpuSunShadowMap::ReleaseMap() +{ + if (m_map) + { + SDL_ReleaseGPUTexture(m_device, m_map); + m_map = nullptr; + } + m_mapSize = 0u; +} + +} // namespace mu diff --git a/src/source/Render/Renderer/SdlGpuSunShadowMap.h b/src/source/Render/Renderer/SdlGpuSunShadowMap.h new file mode 100644 index 0000000000..c18d9ec51a --- /dev/null +++ b/src/source/Render/Renderer/SdlGpuSunShadowMap.h @@ -0,0 +1,56 @@ +// SdlGpuSunShadowMap.h: the Enhanced sun shadow map's textures and sampler. The renderer replays the +// scene into Map(); the lit shaders read Bound(). +#pragma once + +#include + +namespace mu +{ + +class SdlGpuSunShadowMap +{ +public: + // The map's size for a requested sun.resolution: 1024, 2048 or 4096 texels a side. + [[nodiscard]] static Uint32 ResolutionFor(Uint32 requested); + + // The comparison sampler and the far 1x1 map bound while there is no map. False when either failed. + bool CreateResources(SDL_GPUDevice* device); + [[nodiscard]] bool IsAvailable() const; + // Everything, at shutdown. + void Release(); + + // This frame asks for a map of ResolutionFor(`requested`) (SetSceneLighting), or for none. + void Request(Uint32 requested); + void Cancel(); + [[nodiscard]] Uint32 Resolution() const { return m_resolution; } + + // The far 1x1 map while it still needs its one clear, then null. + [[nodiscard]] SDL_GPUTexture* FallbackToClear() const; + void MarkFallbackCleared() { m_fallbackCleared = true; } + + // Starts the frame: the map to draw into at the requested size, or null without a request (the map + // is then released). + [[nodiscard]] SDL_GPUTexture* PrepareMap(); + // The map holds this frame's shadows. + void MarkReady() { m_ready = true; } + + // What the lit shaders sample: this frame's map once drawn, otherwise the far 1x1 one. + [[nodiscard]] SDL_GPUTexture* Bound() const { return m_ready ? m_map : m_fallback; } + [[nodiscard]] SDL_GPUSampler* Sampler() const { return m_sampler; } + +private: + [[nodiscard]] SDL_GPUTexture* CreateDepth(Uint32 size) const; + void ReleaseMap(); + + SDL_GPUDevice* m_device = nullptr; + SDL_GPUSampler* m_sampler = nullptr; + SDL_GPUTexture* m_fallback = nullptr; + bool m_fallbackCleared = false; + SDL_GPUTexture* m_map = nullptr; + Uint32 m_mapSize = 0u; + bool m_requested = false; + Uint32 m_resolution = 0u; + bool m_ready = false; +}; + +} // namespace mu diff --git a/src/source/Render/Terrain/ZzzLodTerrain.cpp b/src/source/Render/Terrain/ZzzLodTerrain.cpp index b650660fe9..2d08962b0c 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.cpp +++ b/src/source/Render/Terrain/ZzzLodTerrain.cpp @@ -81,6 +81,12 @@ bool DetailLowEnable = false; char LodBuffer[64 * 64]; vec3_t TerrainNormal[TERRAIN_SIZE * TERRAIN_SIZE]; +// The terrain light, one value per cell, from the map file to the frame: +// TerrainLight: the map's painted lightmap, as loaded. +// BackTerrainLight: the static light, the lightmap × the sun's slope shading × the light mood +// (CreateStaticLightCell); rebuilt when the sun or the mood changes. +// PrimaryTerrainLight: this frame's light, the static light plus the frame's dynamic lights (game +// code adds them through AddTerrainLight); what the ground and the models sample. vec3_t PrimaryTerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; vec3_t BackTerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; vec3_t TerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; @@ -546,6 +552,7 @@ void CreateTerrainNormal_Part(int xi, int yi) // How much of each cell keeps its Classic brightness under the light mood (its // bright weight, the same in all three channels so the grid sampler reads it). static vec3_t StaticLightBrightWeight[TERRAIN_SIZE * TERRAIN_SIZE]; +// The static light figures stand in: BackTerrainLight with the mood's figure scale instead of its base. static vec3_t FigureStaticTerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; // The static light of one cell: the baked light, shaded by the slope towards @@ -2883,6 +2890,7 @@ extern int EnableEvent; void InitTerrainLight() { + Render::Lighting::UpdateFrameSun(); // The sun moved (dynamic.shadowAngle): the slope shading follows it. if (const glm::vec3 sun = TerrainSunVector(); glm::any(glm::greaterThan(glm::abs(sun - s_terrainLightSun), glm::vec3(1e-4f)))) From b1be5d021f6dc988c834291f007e991bf6f64307 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 00:59:05 +0800 Subject: [PATCH 13/17] feat(render): cloud shadows, sky-blue shade and a rim light that follows the sun - clouds.hlsli: drifting procedural clouds whose shadows fall slanted by the sun; they dim the sun's light on the ground (world_lit) and the characters (skinned_lit) alike. - sky.fill: shade from shadows and clouds turns towards the sky's blue while sunlit places keep the sun's colour; it replaces the light mood's shadeCool while sun shadows are on. - lighting.rim.sunFollow: the characters' edge light comes from the sun, brighter and sun-coloured on its side, gone in its shadow. - All three only under a sun that casts shadows (none indoors). - clouds.strength/scale/speed/cover, sky.fill, lighting.rim.sunFollow: Look values (off by default) with their controls, $clouds / $sky / $rim sun commands, strings, docs and tests. --- docs/enhanced-look.md | 14 +- src/Localization/Game.en.resx | 36 ++++ src/bin/Data/Render/Look.json | 8 +- src/shaders/clouds.hlsli | 38 +++++ .../compiled/basic_textured_fog.frag.dxil | Bin 6168 -> 6332 bytes .../compiled/basic_textured_fog.frag.msl | 5 + .../compiled/basic_textured_fog.frag.spv | Bin 5232 -> 5472 bytes src/shaders/compiled/skinned_lit.frag.dxil | Bin 11976 -> 13732 bytes src/shaders/compiled/skinned_lit.frag.msl | 155 ++++++++++++------ src/shaders/compiled/skinned_lit.frag.spv | Bin 21076 -> 25972 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 8736 -> 10216 bytes src/shaders/compiled/world_lit.frag.msl | 112 +++++++++---- src/shaders/compiled/world_lit.frag.spv | Bin 12316 -> 16448 bytes src/shaders/scene_lighting.hlsli | 5 + src/shaders/skinned_lit.frag.hlsl | 25 ++- src/shaders/world_lit.frag.hlsl | 11 +- .../Data/GameData/MapData/LookProfile.cpp | 6 + .../Data/GameData/MapData/LookProfile.h | 6 + .../Render/Lighting/LightMoodSetting.cpp | 8 + src/source/Render/Look/LookTuningCommand.cpp | 6 + src/source/Render/Look/LookTuningCommand.h | 6 + src/source/Render/Look/TuningControls.cpp | 12 ++ src/source/Render/Look/TuningControls.h | 6 + src/source/Render/Renderer/SceneLighting.cpp | 12 ++ src/source/Render/Renderer/SceneLighting.h | 20 ++- src/source/Scenes/SceneLightingSetup.cpp | 39 +++++ src/source/UI/Options/TuningRows.cpp | 12 ++ tests/render/test_look_profile.cpp | 6 + tests/render/test_scene_lighting.cpp | 2 +- tests/render/test_tuning_controls.cpp | 16 +- 30 files changed, 471 insertions(+), 95 deletions(-) create mode 100644 src/shaders/clouds.hlsli diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 6f888332c2..e783ef5018 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -90,6 +90,12 @@ window. | Dynamic lights | Sun shadow softness | `sun.softness` | 0–2 | 0.1 | 1 | More settings | | Dynamic lights | Sun shadow resolution | `sun.resolution` | 1024–4096 | 1024 | 2048 | More settings | | Dynamic lights | Flat sun shadow | `dynamic.flatSunShadow` | 0–100 % | 5 % | 100 % (0 indoors) | More settings | +| Dynamic lights | Cloud shadows | `clouds.strength` | 0–100 % | 5 % | 0 | common | +| Dynamic lights | Cloud size | `clouds.scale` | 500–10000 | 250 | 3000 | More settings | +| Dynamic lights | Cloud speed | `clouds.speed` | 0–300 | 5 | 40 | More settings | +| Dynamic lights | Cloud cover | `clouds.cover` | 0–100 % | 5 % | 45 % | More settings | +| Dynamic lights | Sky-blue shade | `sky.fill` | 0–100 % | 5 % | 0 | common | +| Dynamic lights | Rim light follows the sun | `lighting.rim.sunFollow` | 0–100 % | 5 % | 0 | More settings | | Darker map light | Mood strength | `mood.strengthPercent` | 0–100 % | 1 % | 100 % | common | | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | @@ -222,6 +228,12 @@ for the whole file. | `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | | `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | | `dynamic.flatSunShadow` | 1 (Dungeon, Lost Tower, Kanturu Relics, Refinery Tower: 0) | 1 | 0–1 | how dark the flat shadow under characters is while sun shadows are off (`sun.shadow` 0), on top of the shadow's own darkness. The indoor and underground maps set both to 0: no sun there, so only torches and spells cast character shadows. Classic always draws it | +| `clouds.strength` | 0 | 0 | 0–1 | how much a passing cloud dims the sun's light on the ground and characters; drifting procedural clouds whose shadows fall slanted by the sun. Only with sun shadows | +| `clouds.scale` | 3000 | 3000 | 500–10000 | the cloud pattern's size in world units | +| `clouds.speed` | 40 | 40 | 0–300 | how fast the clouds drift along a fixed wind, in world units per second | +| `clouds.cover` | 0.45 | 0.45 | 0–1 | the share of the sky the clouds cover | +| `sky.fill` | 0 | 0 | 0–1 | how far shade (from shadows and clouds) turns towards the sky's blue while sunlit places keep the sun's colour; replaces the light mood's `shadeCool` while sun shadows are on. Only with sun shadows | +| `lighting.rim.sunFollow` | 0 | 0 | 0–1 | how much the characters' edge light comes from the sun: brighter and sun-coloured on its side, gone in its shadow; 0 the even Enhanced rim | | `sun.resolution` | 2048 | 2048 | 1024–4096 | the sun shadow map's size in texels (1024, 2048 or 4096): sharper shadows for more graphics memory and time | ## Developer commands @@ -251,7 +263,7 @@ Shorter forms of `$look set`: `$lighting rim `, `$lighting specular `, `$lighting diffuse `, `$lightmood knee `, `$dynlights wrap `, `$dynlights smooth `, `$dynlights spell `, `$dynlights cap `, -`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `, `$sun `, `$sun softness `, `$sun resolution `, `$dynlights flatsun `. +`$dynlights reach `, `$dynlights shadow `, `$dynlights shadowangle `, `$dynlights shadowlights `, `$bloom falloff `, `$bloom `, `$ao `, `$ao radius `, `$sun `, `$sun softness `, `$sun resolution `, `$dynlights flatsun `, `$clouds `, `$clouds scale `, `$clouds speed `, `$clouds cover `, `$sky `, `$rim sun `. The DevEditor has the same values in its Look panel. Feature overrides, to compare one feature on and off. They last for the diff --git a/src/Localization/Game.en.resx b/src/Localization/Game.en.resx index e41c8b1a37..d8f906f23c 100644 --- a/src/Localization/Game.en.resx +++ b/src/Localization/Game.en.resx @@ -1219,6 +1219,42 @@ How far from a surface nearby geometry still darkens it, in world units (a terrain cell is 100). + + Cloud shadows + + + How much a passing cloud dims the sunlight on the ground and characters. 0 for a clear sky. Needs sun shadows. + + + Cloud size + + + How large the clouds are, in world units (a terrain cell is 100). + + + Cloud speed + + + How fast the clouds drift, in world units per second. 0 holds them still. + + + Cloud cover + + + How much of the sky the clouds cover, from clear to overcast. + + + Sky-blue shade + + + How blue the shade turns, lit by the sky instead of the sun; sunlit places keep the sun's colour. Needs sun shadows. + + + Rim light follows the sun + + + How much the edge light on characters comes from the sun: brighter and sun-coloured on its side, gone in shade. 0 keeps the even edge light. + Flat sun shadow diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index fc98e3cc1c..2afcb0bf38 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -27,7 +27,13 @@ "sun.shadow": 1, "sun.softness": 1, "sun.resolution": 2048, - "dynamic.flatSunShadow": 1 + "dynamic.flatSunShadow": 1, + "clouds.strength": 0, + "clouds.scale": 3000, + "clouds.speed": 40, + "clouds.cover": 0.45, + "sky.fill": 0, + "lighting.rim.sunFollow": 0 }, "maps": [ { diff --git a/src/shaders/clouds.hlsli b/src/shaders/clouds.hlsli new file mode 100644 index 0000000000..5fb65c5a18 --- /dev/null +++ b/src/shaders/clouds.hlsli @@ -0,0 +1,38 @@ +// clouds.hlsli — the shadows of drifting clouds: how much of the sun's light reaches a point on the ground +// through a soft, procedural cloud cover. The same function lights the ground and the characters, +// so a cloud's shadow falls on all of them alike. +#ifndef MU_CLOUDS_HLSLI +#define MU_CLOUDS_HLSLI + +float CloudHash(float2 p) +{ + return frac(sin(dot(p, float2(127.1, 311.7))) * 43758.5453); +} + +// Smooth value noise in [0, 1]. +float CloudNoise(float2 p) +{ + const float2 cell = floor(p); + const float2 f = frac(p); + const float2 u = f * f * (3.0 - 2.0 * f); + const float a = CloudHash(cell); + const float b = CloudHash(cell + float2(1.0, 0.0)); + const float c = CloudHash(cell + float2(0.0, 1.0)); + const float d = CloudHash(cell + float2(1.0, 1.0)); + return lerp(lerp(a, b, u.x), lerp(c, d, u.x), u.y); +} + +// The share of the sun's light that reaches world point `xy`: 1 in clear sky, 1 - strength under a cloud. +// `parameters`: x strength (0: no clouds), y 1 / pattern size in world units, z sky cover (0 to 1). +// `offset`: the clouds' drift plus the sun's slant through the cloud layer, in world units. +float CloudLight(float2 xy, float4 parameters, float2 offset) +{ + if (parameters.x <= 0.0) + return 1.0; + const float2 p = (xy + offset) * parameters.y; + const float cover = 0.55 * CloudNoise(p) + 0.3 * CloudNoise(p * 2.03 + 17.1) + 0.15 * CloudNoise(p * 4.07 + 31.7); + const float threshold = 1.0 - parameters.z; + const float cloud = smoothstep(threshold - 0.12, threshold + 0.12, cover); + return 1.0 - parameters.x * cloud; +} +#endif diff --git a/src/shaders/compiled/basic_textured_fog.frag.dxil b/src/shaders/compiled/basic_textured_fog.frag.dxil index 728f5e48b952f61dfd4d300467a26903e30ef81f..677543f6862989c2c05ac68502eefcea2b8aa368 100644 GIT binary patch delta 1123 zcmbPXu*Xo+CBn(sMsxE)fA6f>PD_F>i%49mWn^Gr*fUX5nvI2zfkA<9qtz@XRUK{y zh6JGaX(k2+mk3WE2B0DVAYTM1?&N&no+1we!=cG5dG~DI%Iw9ceBpEL{qME+!|Q;g z{7iGtU>DBG=b6rI77(;%6mDc{x=^C9S&mhRkx^l?A)7qojLCs)vff-J3mVwDY8EhX za!pxau`$5D2&3A=*c24=QmX@R825=jaTypG!& z8yL>cR_JMz2{5d-)-K`}PS#ci+Hi@bafTWPm(1iQ_Wg_{o1HkU80(qsl5_G)Qvwo; z5_3~aQj3a(S(JFp6gqT$wkxomm7T*l-EiA>t4-?0n|B)R;$%`}lNL}BSBn*Be#UpM z;rN}Xd4W>Ww^ ztY8%W-0aJ-Z))a_3a1j7o9a6boA4!FxN}f4r@_GP19N~tYmh^0XaQ^F3f7n#tnnP| zMK=Nj5+<-$1@H;8Fy3Iuk>DtCXy}!8AAv5@844mf8xj@oG0Hu1lzWyqgS|SPxTWB8xa}zqNU@^IyTl*uigGSV&Vl?tFYqfE3i&Ks zvv0+rC+AMRP~$i%ofFYfKdFIzGSGJt&l(r7*WD19bEK_NC4lKhz?^35B}do=1SfMB zOFL`NUYvOBo0yw9Fx1X9xX!vQa~GHt9GHbN^Gb?Mo?SY(@5YIYGfU^zp1mlzQ2X%j zqUy=nw;!xwIV7a}P)MIqIM}D7(Pz#cw{(?cBM= ze7h#&#TK6PNA-HnuJg(B3b>+pxOk>Bx3c!+>?&pLH zyLj>J*+NTP#EopGZ`^KWzKb1byXHY3hRu20OiY%7F9WmJc4YF-xgUQxx%r|xC=XBJ vg5>F?XnDE@C=Schb0+^}n$4K9*_AJgQI&{Xy^LY=1%4Ao#u=Mg1%=rGhZ3j% delta 994 zcmdmEIKx2FCBn(M*nf&^<6HYr2QJ?VVt90IA0q<;gTzEhX|@zz28IUSjaIXmRC~A> z7!rWuij};4+|HE)8)p=Wdi+^H?lS}%1$li8}7#IvD?`3m$V3aOcpnZ6@g1}jp#sV`Am(7Zb zQ(6_-+6v5A&a*V~+-c~(csp`x^sJk+V{YGJX{=D=VA;Z`sFbP1#x+A>4x`Lu7j^}` z4raDuX@R825=jaTypG!&8yL>cR_Jk*4lt~?)-K`}PS#ci+Hi@bafTYlDXGbm*!MH$ zZw}(HVytiGlC=RZdj;rK!N|u0WmcWrVWfY3XjgHY%)sAlaprK_A(<-&Wgj)l&G3n=4QxF*cj`r70WQ-U8w9=y@O?MndulL& zIgsz|2E_yQ?Yz#mPnb6>JkT0{p`BkrNlpBjSzDNy`{ACqx;=S$O%5H5-6q>DckSe4 zGGtS^bmzshj5AB;)^415afY|`?^%nLox`UbTJd}4(Qc;^I&^*zC zd6LAc4I6K6-MM7q)SVZ7Ih(XnD)h=yi;6Sz^MaWcaZ1kXj;)uN9Xs>Rlm#oC+nyV> zi@AlVUH{@1cFauG;nakOJ5NkKyZ7qJ-l=DOIrn%0HJ4Ntq&nv1<(DLu0L>^4W{JMh zY6UVhGqv0^B^W528r&2IGArnroBDM2uhX8nnVYL#Xx9TOO3p9MD*@Ub%rps-{sMvN zaI*x@4@S#wMpHg>iO!V=j1P*gOSt?Gl#wPtGu9Hcj8%b@v1S7^)}GC*{9cTT1hUl( Srp+Y+CX9?Fn^y`7vjYI*mUO28 diff --git a/src/shaders/compiled/basic_textured_fog.frag.msl b/src/shaders/compiled/basic_textured_fog.frag.msl index d79dc49670..8c3ba4acbc 100644 --- a/src/shaders/compiled/basic_textured_fog.frag.msl +++ b/src/shaders/compiled/basic_textured_fog.frag.msl @@ -26,6 +26,11 @@ struct SceneLighting float4 cameraPosition; float4x4 sunViewProjection; float4 sunShadowParameters; + float4 cloudParameters; + float4 cloudOffset; + float4 skyFill; + float4 sunTowards; + float4 sunColor; }; struct FogUniforms diff --git a/src/shaders/compiled/basic_textured_fog.frag.spv b/src/shaders/compiled/basic_textured_fog.frag.spv index 318e0f26110279a40fc03fe37bff1742363d3d8c..386795b9028d879f947c81a6d6b635d977b6dd54 100644 GIT binary patch delta 298 zcmeyM@jz?C9j1CV26hH<1_lN$AWqK7FHH$ZEK1BxElDjZW?%zCkQ_Hm&Oa@!IJE>Q z$_f_e0g4xASGr~9OG(af*hd?#20`VCI+$`B=!JF3}i7#>;sY*$YPKf10zB&$WoA)08q@GfdynCgCax; noUa6Q#C}$8CT2kf@yQq20NMZGD)1<<+yb*y1IPlifCeT40}KEcld%XJlfVcFlgtPRv*-wT3>sJsYybcN diff --git a/src/shaders/compiled/skinned_lit.frag.dxil b/src/shaders/compiled/skinned_lit.frag.dxil index eb158667546e16d6d46ef12721b7d35fccd4f250..4f03abe9341207ea8230ea1d1d097d1abd3f59f1 100644 GIT binary patch literal 13732 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 literal 11976 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 E0N!#%#{d8T diff --git a/src/shaders/compiled/skinned_lit.frag.msl b/src/shaders/compiled/skinned_lit.frag.msl index c241fbac53..0c23be3275 100644 --- a/src/shaders/compiled/skinned_lit.frag.msl +++ b/src/shaders/compiled/skinned_lit.frag.msl @@ -33,6 +33,11 @@ struct SceneLighting float4 cameraPosition; float4x4 sunViewProjection; float4 sunShadowParameters; + float4 cloudParameters; + float4 cloudOffset; + float4 skyFill; + float4 sunTowards; + float4 sunColor; }; struct DynamicLights @@ -96,33 +101,73 @@ float3 PerturbNormal(thread const float3& normal, thread const float3& tangent, } static inline __attribute__((always_inline)) -float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _68, depth2d sunShadowMap, sampler sunShadowSampler) +float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _83, depth2d sunShadowMap, sampler sunShadowSampler) { - if (_68.sunShadowParameters.x <= 0.0) + if (_83.sunShadowParameters.x <= 0.0) { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _68.sunShadowParameters.w)); - float4 clip = _68.sunViewProjection * float4(lifted, 1.0); + float3 lifted = worldPosition + (worldNormal * (1.5 * _83.sunShadowParameters.w)); + float4 clip = _83.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) { return 1.0; } - float2 _step = _68.sunShadowParameters.zz * _68.sunShadowParameters.y; + float2 _step = _83.sunShadowParameters.zz * _83.sunShadowParameters.y; float visible = 0.0; for (int y = -1; y <= 1; y++) { for (int x = -1; x <= 1; x++) { - float3 _210 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _210.xy, _210.z, level(0.0)); + float3 _223 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _223.xy, _223.z, level(0.0)); } } return visible / 9.0; } +static inline __attribute__((always_inline)) +float CloudHash(thread const float2& p) +{ + return fract(sin(dot(p, float2(127.09999847412109375, 311.70001220703125))) * 43758.546875); +} + +static inline __attribute__((always_inline)) +float CloudNoise(thread const float2& p) +{ + float2 cell = floor(p); + float2 f = fract(p); + float2 u = (f * f) * (float2(3.0) - (f * 2.0)); + float2 param = cell; + float a = CloudHash(param); + float2 param_1 = cell + float2(1.0, 0.0); + float b = CloudHash(param_1); + float2 param_2 = cell + float2(0.0, 1.0); + float c = CloudHash(param_2); + float2 param_3 = cell + float2(1.0); + float d = CloudHash(param_3); + return mix(mix(a, b, u.x), mix(c, d, u.x), u.y); +} + +static inline __attribute__((always_inline)) +float CloudLight(thread const float2& xy, thread const float4& parameters, thread const float2& offset) +{ + if (parameters.x <= 0.0) + { + return 1.0; + } + float2 p = (xy + offset) * parameters.y; + float2 param = p; + float2 param_1 = (p * 2.0299999713897705078125) + float2(17.1000003814697265625); + float2 param_2 = (p * 4.070000171661376953125) + float2(31.700000762939453125); + float cover = ((0.550000011920928955078125 * CloudNoise(param)) + (0.300000011920928955078125 * CloudNoise(param_1))) + (0.1500000059604644775390625 * CloudNoise(param_2)); + float threshold = 1.0 - parameters.z; + float cloud = smoothstep(threshold - 0.119999997317790985107421875, threshold + 0.119999997317790985107421875, cover); + return 1.0 - (parameters.x * cloud); +} + static inline __attribute__((always_inline)) float PointLightFalloff(thread const float3& toLight, thread const float& radius) { @@ -131,13 +176,13 @@ float PointLightFalloff(thread const float3& toLight, thread const float& radius } static inline __attribute__((always_inline)) -float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _318) +float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _455) { float3 light = float3(0.0); - uint count = min(_318.dynamicLightCount, 32u); + uint count = min(_455.dynamicLightCount, 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _318.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _455.dynamicLightPositionAndRadius[i]; float3 toLight = positionAndRadius.xyz - worldPosition; float3 param = toLight; float param_1 = positionAndRadius.w; @@ -147,8 +192,8 @@ float3 DynamicLighting(thread const float3& worldPosition, thread const float3& continue; } float3 param_2 = toLight; - float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param_2)) * (1.0 - _318.dynamicLightWrap)) + _318.dynamicLightWrap, 0.0, 1.0); - light += (_318.dynamicLightColor[i].xyz * (falloff * wrapped)); + float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param_2)) * (1.0 - _455.dynamicLightWrap)) + _455.dynamicLightWrap, 0.0, 1.0); + light += (_455.dynamicLightColor[i].xyz * (falloff * wrapped)); } return light; } @@ -179,14 +224,14 @@ float3 RollOffHighlight(thread const float3& color, thread const float& knee) } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _68) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _83) { - float scaledDistance = fast::max(eyeDepth - _68.sceneFogParameters.x, 0.0) * _68.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _83.sceneFogParameters.x, 0.0) * _83.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _68, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _318, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _689) +float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _455, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _897) { float4 texel = tex.sample(s, _input.uv); float2 uvDx = dfdx(_input.uv); @@ -197,10 +242,10 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _68, depth2d< if ((normalMapScale > 0.0) && (_input.tangent.w != 0.0)) { float3 mapped = (normalMap.sample(normalSampler, _input.uv, gradient2d(uvDx, uvDy)).xyz * 2.0) - float3(1.0); - float3 _473 = mapped; - float2 _475 = _473.xy * normalMapScale; - mapped.x = _475.x; - mapped.y = _475.y; + float3 _609 = mapped; + float2 _611 = _609.xy * normalMapScale; + mapped.x = _611.x; + mapped.y = _611.y; float handedness = (_input.tangent.w > 0.0) ? 1.0 : (-1.0); float3 param = _input.normal; float3 param_1 = _input.tangent.xyz; @@ -225,35 +270,45 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _68, depth2d< float3 litNormal = SafeNormalize(param_10); float3 param_11 = _input.worldPositionAndDynamicLights.xyz; float3 param_12 = litNormal; - float sunLight = inWorld ? (1.0 - (_68.sunShadowParameters.x * (1.0 - SunVisibility(param_11, param_12, _68, sunShadowMap, sunShadowSampler)))) : 1.0; - float luminosity = fast::max(((lightDot * _68.diffuseCurve.x) * sunLight) + _68.diffuseCurve.y, _68.diffuseCurve.z); - float3 param_13 = _input.worldPositionAndDynamicLights.xyz; - float3 param_14 = litNormal; - float3 dynamicLight = select(float3(0.0), DynamicLighting(param_13, param_14, _318), bool3(inWorld)); - float3 diffuse = fast::clamp((objectLight * luminosity) + dynamicLight, float3(0.0), float3(1.0)); - float param_15 = _68.diffuseCurve.w; - if (RollsOffHighlight(param_15)) + float2 param_13 = _input.worldPositionAndDynamicLights.xy; + float4 param_14 = _83.cloudParameters; + float2 param_15 = _83.cloudOffset.xy; + float sunVisible = (inWorld && (_83.sunShadowParameters.x > 0.0)) ? (SunVisibility(param_11, param_12, _83, sunShadowMap, sunShadowSampler) * CloudLight(param_13, param_14, param_15)) : 1.0; + float sunLight = 1.0 - (_83.sunShadowParameters.x * (1.0 - sunVisible)); + float3 skyShade = mix(float3(1.0), _83.skyFill.xyz, float3(_83.skyFill.w * (1.0 - sunVisible))); + float luminosity = fast::max(((lightDot * _83.diffuseCurve.x) * sunLight) + _83.diffuseCurve.y, _83.diffuseCurve.z); + float3 param_16 = _input.worldPositionAndDynamicLights.xyz; + float3 param_17 = litNormal; + float3 dynamicLight = select(float3(0.0), DynamicLighting(param_16, param_17, _455), bool3(inWorld)); + float3 diffuse = fast::clamp(((objectLight * skyShade) * luminosity) + dynamicLight, float3(0.0), float3(1.0)); + float param_18 = _83.diffuseCurve.w; + if (RollsOffHighlight(param_18)) { - float3 param_16 = (objectLight * luminosity) + dynamicLight; - float param_17 = _68.diffuseCurve.w; - diffuse = RollOffHighlight(param_16, param_17); + float3 param_19 = ((objectLight * skyShade) * luminosity) + dynamicLight; + float param_20 = _83.diffuseCurve.w; + diffuse = RollOffHighlight(param_19, param_20); } float facing = fast::clamp(abs(dot(normal, view)), 0.0, 1.0); - float3 rim = objectLight * (_68.rimParameters.x * powr(1.0 - facing, _68.rimParameters.y)); - float specularStrength = _input.lightDirectionAndSpecular.w * _68.specularParameters.x; + float3 rim = objectLight * (_83.rimParameters.x * powr(1.0 - facing, _83.rimParameters.y)); + if (inWorld && (_83.sunTowards.w > 0.0)) + { + float towardsSun = fast::clamp((dot(worldNormal, fast::normalize(_83.sunTowards.xyz)) * 0.75) + 0.25, 0.0, 1.0) * sunVisible; + rim = mix(rim, (rim * _83.sunColor.xyz) * (2.0 * towardsSun), float3(_83.sunTowards.w)); + } + float specularStrength = _input.lightDirectionAndSpecular.w * _83.specularParameters.x; float3 specular = float3(0.0); if ((specularStrength > 0.0) && (lightDot > 0.0)) { - float3 param_18 = light; - float3 param_19 = SafeNormalize(param_18) + view; - float3 halfVector = SafeNormalize(param_19); - float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _68.specularParameters.y); - specular = (_68.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; + float3 param_21 = light; + float3 param_22 = SafeNormalize(param_21) + view; + float3 halfVector = SafeNormalize(param_22); + float highlight = powr(fast::clamp(dot(normal, halfVector), 0.0, 1.0), _83.specularParameters.y); + specular = (_83.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; } float4 color = float4(((texel.xyz * diffuse) + rim) + specular, texel.w * _input.color.w); - if (_689.alphaToCoverage != 0u) + if (_897.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _689.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _897.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -262,24 +317,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _68, depth2d< } else { - if ((_689.alphaDiscardEnabled != 0u) && (color.w <= _689.alphaThreshold)) + if ((_897.alphaDiscardEnabled != 0u) && (color.w <= _897.alphaThreshold)) { discard_fragment(); } } - if ((_689.fogEnabled != 0u) && (_68.sceneFogColor.w > 0.0)) + if ((_897.fogEnabled != 0u) && (_83.sceneFogColor.w > 0.0)) { - float4 _742 = color; - float param_20 = _input.eyeDepth; - float3 _752 = mix(_742.xyz, _68.sceneFogColor.xyz, float3(EnhancedFogAmount(param_20, _68))); - color.x = _752.x; - color.y = _752.y; - color.z = _752.z; + float4 _950 = color; + float param_23 = _input.eyeDepth; + float3 _960 = mix(_950.xyz, _83.sceneFogColor.xyz, float3(EnhancedFogAmount(param_23, _83))); + color.x = _960.x; + color.y = _960.y; + color.z = _960.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _689 [[buffer(0)]], constant SceneLighting& _68 [[buffer(1)]], constant DynamicLights& _318 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _897 [[buffer(0)]], constant SceneLighting& _83 [[buffer(1)]], constant DynamicLights& _455 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -296,8 +351,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _689 [[ _input.tangent = in.input_tangent; _input.worldTangentAndNormalMapScale = in.input_worldTangentAndNormalMapScale; FSInput param = _input; - float4 _807 = _main(param, _68, sunShadowMap, sunShadowSampler, _318, tex, s, normalMap, normalSampler, _689); - out._entryPointOutput = _807; + float4 _1015 = _main(param, _83, sunShadowMap, sunShadowSampler, _455, tex, s, normalMap, normalSampler, _897); + out._entryPointOutput = _1015; return out; } diff --git a/src/shaders/compiled/skinned_lit.frag.spv b/src/shaders/compiled/skinned_lit.frag.spv index b3476f964515215a3faeefd0580c9b2cbf1f1608..5ce11ceb8dcb8d3007162a8767687cb66abc9cf2 100644 GIT binary patch literal 25972 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 GO#CmkF$A6f literal 21076 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 diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index d84eaff41b3ff69116092a992d02b872c6841297..96d28af8e8438bd15dfc7cc92463ac0f2ad1e5a7 100644 GIT binary patch literal 10216 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 delta 5518 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 Qs9Q(ssm=rcq0U_Y4!JHGp#T5? diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index ccc1a0126e..a3b8e0be08 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -27,6 +27,11 @@ struct SceneLighting float4 cameraPosition; float4x4 sunViewProjection; float4 sunShadowParameters; + float4 cloudParameters; + float4 cloudOffset; + float4 skyFill; + float4 sunTowards; + float4 sunColor; }; struct DynamicLights @@ -65,33 +70,73 @@ struct main0_in }; static inline __attribute__((always_inline)) -float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _41, depth2d sunShadowMap, sampler sunShadowSampler) +float SunVisibility(thread const float3& worldPosition, thread const float3& worldNormal, constant SceneLighting& _56, depth2d sunShadowMap, sampler sunShadowSampler) { - if (_41.sunShadowParameters.x <= 0.0) + if (_56.sunShadowParameters.x <= 0.0) { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _41.sunShadowParameters.w)); - float4 clip = _41.sunViewProjection * float4(lifted, 1.0); + float3 lifted = worldPosition + (worldNormal * (1.5 * _56.sunShadowParameters.w)); + float4 clip = _56.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); if ((any(uv < float2(0.0)) || any(uv > float2(1.0))) || (ndc.z >= 1.0)) { return 1.0; } - float2 _step = _41.sunShadowParameters.zz * _41.sunShadowParameters.y; + float2 _step = _56.sunShadowParameters.zz * _56.sunShadowParameters.y; float visible = 0.0; for (int y = -1; y <= 1; y++) { for (int x = -1; x <= 1; x++) { - float3 _184 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _184.xy, _184.z, level(0.0)); + float3 _197 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); + visible += sunShadowMap.sample_compare(sunShadowSampler, _197.xy, _197.z, level(0.0)); } } return visible / 9.0; } +static inline __attribute__((always_inline)) +float CloudHash(thread const float2& p) +{ + return fract(sin(dot(p, float2(127.09999847412109375, 311.70001220703125))) * 43758.546875); +} + +static inline __attribute__((always_inline)) +float CloudNoise(thread const float2& p) +{ + float2 cell = floor(p); + float2 f = fract(p); + float2 u = (f * f) * (float2(3.0) - (f * 2.0)); + float2 param = cell; + float a = CloudHash(param); + float2 param_1 = cell + float2(1.0, 0.0); + float b = CloudHash(param_1); + float2 param_2 = cell + float2(0.0, 1.0); + float c = CloudHash(param_2); + float2 param_3 = cell + float2(1.0); + float d = CloudHash(param_3); + return mix(mix(a, b, u.x), mix(c, d, u.x), u.y); +} + +static inline __attribute__((always_inline)) +float CloudLight(thread const float2& xy, thread const float4& parameters, thread const float2& offset) +{ + if (parameters.x <= 0.0) + { + return 1.0; + } + float2 p = (xy + offset) * parameters.y; + float2 param = p; + float2 param_1 = (p * 2.0299999713897705078125) + float2(17.1000003814697265625); + float2 param_2 = (p * 4.070000171661376953125) + float2(31.700000762939453125); + float cover = ((0.550000011920928955078125 * CloudNoise(param)) + (0.300000011920928955078125 * CloudNoise(param_1))) + (0.1500000059604644775390625 * CloudNoise(param_2)); + float threshold = 1.0 - parameters.z; + float cloud = smoothstep(threshold - 0.119999997317790985107421875, threshold + 0.119999997317790985107421875, cover); + return 1.0 - (parameters.x * cloud); +} + static inline __attribute__((always_inline)) float PointLightFalloff(thread const float3& toLight, thread const float& radius) { @@ -100,45 +145,50 @@ float PointLightFalloff(thread const float3& toLight, thread const float& radius } static inline __attribute__((always_inline)) -float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _222) +float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _359) { float3 light = float3(0.0); - uint count = min(min(_222.dynamicWorldLightCount, _222.dynamicLightCount), 32u); + uint count = min(min(_359.dynamicWorldLightCount, _359.dynamicLightCount), 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _222.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _359.dynamicLightPositionAndRadius[i]; float3 param = positionAndRadius.xyz - worldPosition; float param_1 = positionAndRadius.w; - light += (_222.dynamicLightColor[i].xyz * PointLightFalloff(param, param_1)); + light += (_359.dynamicLightColor[i].xyz * PointLightFalloff(param, param_1)); } return light; } static inline __attribute__((always_inline)) -float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _41) +float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _56) { - float scaledDistance = fast::max(eyeDepth - _41.sceneFogParameters.x, 0.0) * _41.sceneFogParameters.z; + float scaledDistance = fast::max(eyeDepth - _56.sceneFogParameters.x, 0.0) * _56.sceneFogParameters.z; return fast::clamp(1.0 - exp((-scaledDistance) * scaledDistance), 0.0, 1.0); } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _41, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _222, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _367) +float4 _main(thread const FSInput& _input, constant SceneLighting& _56, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _359, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _540) { float4 texel = tex.sample(s, _input.uv); uint2 sizeQueryTemp = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); uint maskWidth = sizeQueryTemp.x; uint maskHeight = sizeQueryTemp.y; float2 visibility = groundShadowMask.sample(groundShadowSampler, (_input.pos.xy / float2(float(maskWidth), float(maskHeight)))).xy; - float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _222.groundShadowOpacity); + float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _359.groundShadowOpacity); float3 param = _input.worldPosition; float3 param_1 = float3(0.0, 0.0, 1.0); - shadow.x *= (1.0 - (_41.sunShadowParameters.x * (1.0 - SunVisibility(param, param_1, _41, sunShadowMap, sunShadowSampler)))); - float3 param_2 = _input.worldPosition; - float3 light = fast::clamp((_input.color.xyz * shadow.x) + (WorldDynamicLighting(param_2, _222) * shadow.y), float3(0.0), float3(1.0)); + float2 param_2 = _input.worldPosition.xy; + float4 param_3 = _56.cloudParameters; + float2 param_4 = _56.cloudOffset.xy; + float sunVisible = (_56.sunShadowParameters.x > 0.0) ? (SunVisibility(param, param_1, _56, sunShadowMap, sunShadowSampler) * CloudLight(param_2, param_3, param_4)) : 1.0; + shadow.x *= (1.0 - (_56.sunShadowParameters.x * (1.0 - sunVisible))); + float3 skyShade = mix(float3(1.0), _56.skyFill.xyz, float3(_56.skyFill.w * (1.0 - sunVisible))); + float3 param_5 = _input.worldPosition; + float3 light = fast::clamp(((_input.color.xyz * skyShade) * shadow.x) + (WorldDynamicLighting(param_5, _359) * shadow.y), float3(0.0), float3(1.0)); float4 color = float4(texel.xyz * light, texel.w * _input.color.w); - if (_367.alphaToCoverage != 0u) + if (_540.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _367.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _540.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -147,24 +197,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _41, depth2d< } else { - if ((_367.alphaDiscardEnabled != 0u) && (color.w <= _367.alphaThreshold)) + if ((_540.alphaDiscardEnabled != 0u) && (color.w <= _540.alphaThreshold)) { discard_fragment(); } } - if ((_367.fogEnabled != 0u) && (_41.sceneFogColor.w > 0.0)) + if ((_540.fogEnabled != 0u) && (_56.sceneFogColor.w > 0.0)) { - float4 _420 = color; - float param_3 = _input.eyeDepth; - float3 _430 = mix(_420.xyz, _41.sceneFogColor.xyz, float3(EnhancedFogAmount(param_3, _41))); - color.x = _430.x; - color.y = _430.y; - color.z = _430.z; + float4 _593 = color; + float param_6 = _input.eyeDepth; + float3 _603 = mix(_593.xyz, _56.sceneFogColor.xyz, float3(EnhancedFogAmount(param_6, _56))); + color.x = _603.x; + color.y = _603.y; + color.z = _603.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _367 [[buffer(0)]], constant SceneLighting& _41 [[buffer(1)]], constant DynamicLights& _222 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _540 [[buffer(0)]], constant SceneLighting& _56 [[buffer(1)]], constant DynamicLights& _359 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -175,8 +225,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _367 [[ _input.eyeDepth = in.input_eyeDepth; _input.worldPosition = in.input_worldPosition; FSInput param = _input; - float4 _467 = _main(param, _41, sunShadowMap, sunShadowSampler, _222, tex, s, groundShadowMask, groundShadowSampler, _367); - out._entryPointOutput = _467; + float4 _640 = _main(param, _56, sunShadowMap, sunShadowSampler, _359, tex, s, groundShadowMask, groundShadowSampler, _540); + out._entryPointOutput = _640; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index 4b9fa1bf87f4413f62b77f4a1f5dcc892624317b..bd7435bc065585a9636471137e6b15d3066b90fb 100644 GIT binary patch literal 16448 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 RGRE~Jurd5xF7|Wz{{iPUg;)Rp literal 12316 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 diff --git a/src/shaders/scene_lighting.hlsli b/src/shaders/scene_lighting.hlsli index 1059b370db..45d6225ea3 100644 --- a/src/shaders/scene_lighting.hlsli +++ b/src/shaders/scene_lighting.hlsli @@ -24,6 +24,11 @@ cbuffer SceneLighting : register(b1, space3) float4 cameraPosition; float4x4 sunViewProjection; // world to the sun shadow map's clip space float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units + float4 cloudParameters; // x: cloud strength (0: none), y: 1 / pattern size, z: sky cover + float4 cloudOffset; // xy: the clouds' drift plus the sun's slant + float4 skyFill; // rgb: the sky's tint of the shade, w: how far shade takes it + float4 sunTowards; // xyz: towards the sun, w: how far the rim follows it + float4 sunColor; // rgb: the sun's colour }; // The Enhanced exponential fog: the same curve as mu::EnhancedFogAmount() (SceneLighting.cpp). diff --git a/src/shaders/skinned_lit.frag.hlsl b/src/shaders/skinned_lit.frag.hlsl index 771fd58b6b..cc7a016718 100644 --- a/src/shaders/skinned_lit.frag.hlsl +++ b/src/shaders/skinned_lit.frag.hlsl @@ -23,6 +23,7 @@ SamplerComparisonState sunShadowSampler : register(s2, space2); #include "scene_lighting.hlsli" #include "dynamic_lighting.hlsli" +#include "clouds.hlsli" // The light mood's highlight shoulder (Render::Lighting::LightMood::RollOffHighlight): a lit // colour channel above the knee approaches 1 smoothly instead of being cut off there. Only a knee @@ -131,19 +132,31 @@ float4 main(FSInput input) : SV_Target const bool inWorld = input.worldPositionAndDynamicLights.w > 0.5; const float3 litNormal = SafeNormalize(worldNormal); // The sun's shadow takes away the direct sunlight only: the ambient part and the point lights stay. - const float sunLight = inWorld ? 1.0 - sunShadowParameters.x * - (1.0 - SunVisibility(input.worldPositionAndDynamicLights.xyz, litNormal)) - : 1.0; + // Clouds dim the sunlight as shadows do. + const float sunVisible = + inWorld && sunShadowParameters.x > 0.0 + ? SunVisibility(input.worldPositionAndDynamicLights.xyz, litNormal) * + CloudLight(input.worldPositionAndDynamicLights.xy, cloudParameters, cloudOffset.xy) + : 1.0; + const float sunLight = 1.0 - sunShadowParameters.x * (1.0 - sunVisible); + // Shade turns towards the sky's blue. + const float3 skyShade = lerp(float3(1.0, 1.0, 1.0), skyFill.rgb, skyFill.w * (1.0 - sunVisible)); const float luminosity = max(lightDot * diffuseCurve.x * sunLight + diffuseCurve.y, diffuseCurve.z); const float3 dynamicLight = inWorld ? DynamicLighting(input.worldPositionAndDynamicLights.xyz, litNormal) : float3(0.0, 0.0, 0.0); - float3 diffuse = saturate(objectLight * luminosity + dynamicLight); + float3 diffuse = saturate(objectLight * skyShade * luminosity + dynamicLight); if (RollsOffHighlight(diffuseCurve.w)) - diffuse = RollOffHighlight(objectLight * luminosity + dynamicLight, diffuseCurve.w); + diffuse = RollOffHighlight(objectLight * skyShade * luminosity + dynamicLight, diffuseCurve.w); // Two-sided meshes show back faces; |dot| keeps their interiors from rim-lighting. const float facing = saturate(abs(dot(normal, view))); - const float3 rim = rimParameters.x * pow(1.0 - facing, rimParameters.y) * objectLight; + float3 rim = rimParameters.x * pow(1.0 - facing, rimParameters.y) * objectLight; + if (inWorld && sunTowards.w > 0.0) + { + // The rim follows the sun: brighter and sun-coloured on the side facing it, gone in its shadow. + const float towardsSun = saturate(dot(worldNormal, normalize(sunTowards.xyz)) * 0.75 + 0.25) * sunVisible; + rim = lerp(rim, rim * sunColor.rgb * (2.0 * towardsSun), sunTowards.w); + } const float specularStrength = input.lightDirectionAndSpecular.w * specularParameters.x; float3 specular = float3(0.0, 0.0, 0.0); diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index 82c7033410..f87e7558e9 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -16,6 +16,7 @@ Texture2D groundShadowMask : register(t1, space2); SamplerState groundShadowSampler : register(s1, space2); #include "scene_lighting.hlsli" #include "dynamic_lighting.hlsli" +#include "clouds.hlsli" struct FSInput { float4 pos : SV_Position; @@ -52,9 +53,15 @@ float4 main(FSInput input) : SV_Target groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).rg; // The sun's shadows dim the ground's own light, the point lights' shadows the point lights. float2 shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); - shadow.x *= 1.0 - sunShadowParameters.x * (1.0 - SunVisibility(input.worldPosition, float3(0.0, 0.0, 1.0))); + // Clouds dim the sunlight as shadows do; shade, from either, turns towards the sky's blue. + const float sunVisible = sunShadowParameters.x > 0.0 + ? SunVisibility(input.worldPosition, float3(0.0, 0.0, 1.0)) * + CloudLight(input.worldPosition.xy, cloudParameters, cloudOffset.xy) + : 1.0; + shadow.x *= 1.0 - sunShadowParameters.x * (1.0 - sunVisible); + const float3 skyShade = lerp(float3(1.0, 1.0, 1.0), skyFill.rgb, skyFill.w * (1.0 - sunVisible)); const float3 light = - saturate(input.color.rgb * shadow.x + WorldDynamicLighting(input.worldPosition) * shadow.y); + saturate(input.color.rgb * skyShade * shadow.x + WorldDynamicLighting(input.worldPosition) * shadow.y); float4 color = float4(texel.rgb * light, texel.a * input.color.a); if (alphaToCoverage) { diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index 5350123c1a..397eb8f1ed 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -53,6 +53,12 @@ constexpr std::array Infos = {{ {LookValue::SunShadowSoftness, "sun.softness", 1.0, 0.0, 2.0}, {LookValue::SunShadowResolution, "sun.resolution", 2048.0, 1024.0, 4096.0}, {LookValue::FlatSunShadow, "dynamic.flatSunShadow", 1.0, 0.0, 1.0}, + {LookValue::CloudStrength, "clouds.strength", 0.0, 0.0, 1.0}, + {LookValue::CloudScale, "clouds.scale", 3000.0, 500.0, 10000.0}, + {LookValue::CloudSpeed, "clouds.speed", 40.0, 0.0, 300.0}, + {LookValue::CloudCover, "clouds.cover", 0.45, 0.0, 1.0}, + {LookValue::SkyFill, "sky.fill", 0.0, 0.0, 1.0}, + {LookValue::RimSunFollow, "lighting.rim.sunFollow", 0.0, 0.0, 1.0}, }}; constexpr bool InfosFollowLookValueOrder() diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index 134b231094..fd4102e09d 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -55,6 +55,12 @@ enum class LookValue : std::uint8_t SunShadowSoftness, SunShadowResolution, FlatSunShadow, + CloudStrength, + CloudScale, + CloudSpeed, + CloudCover, + SkyFill, + RimSunFollow, Count, }; diff --git a/src/source/Render/Lighting/LightMoodSetting.cpp b/src/source/Render/Lighting/LightMoodSetting.cpp index 8bb2567104..8d6cfd9c4c 100644 --- a/src/source/Render/Lighting/LightMoodSetting.cpp +++ b/src/source/Render/Lighting/LightMoodSetting.cpp @@ -3,6 +3,7 @@ #include "Render/Lighting/LightMoodSetting.h" #include "Core/Utilities/Log/MuLogger.h" +#include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Look/LookProfileSetting.h" #include "Render/Terrain/ZzzLodTerrain.h" #include "World/MapInfra/MapManager.h" @@ -57,6 +58,13 @@ void Recompute(int world) s_state.scales = s_state.enabled && IsWorldMap(world) ? Blend(s_state.data.ForWorld(world), s_state.strength, Look::Value(Data::Maps::LookValue::HighlightKnee)) : Scales{}; + // Under a sun that casts shadows the sky fill tints the shade (the lit shaders): no second blue here. + if (s_state.enabled && IsWorldMap(world) && DynamicLightsActive() && + Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0f && + Look::Value(Data::Maps::LookValue::SkyFill) > 0.0f) + { + s_state.scales.shadeCool = 0.f; + } } void RebuildStaticLight() diff --git a/src/source/Render/Look/LookTuningCommand.cpp b/src/source/Render/Look/LookTuningCommand.cpp index d4758de66f..8fd09df7ff 100644 --- a/src/source/Render/Look/LookTuningCommand.cpp +++ b/src/source/Render/Look/LookTuningCommand.cpp @@ -33,6 +33,12 @@ const CommandForm CommandForms[] = { {L"$dynlights flatsun ", {LookValue::FlatSunShadow}}, {L"$bloom falloff ", {LookValue::BloomLevelFalloff}}, {L"$ao radius ", {LookValue::AmbientOcclusionRadius}}, + {L"$clouds scale ", {LookValue::CloudScale}}, + {L"$clouds speed ", {LookValue::CloudSpeed}}, + {L"$clouds cover ", {LookValue::CloudCover}}, + {L"$clouds ", {LookValue::CloudStrength}}, + {L"$sky ", {LookValue::SkyFill}}, + {L"$rim sun ", {LookValue::RimSunFollow}}, {L"$ao ", {LookValue::AmbientOcclusionStrength}}, {L"$sun softness ", {LookValue::SunShadowSoftness}}, {L"$sun resolution ", {LookValue::SunShadowResolution}}, diff --git a/src/source/Render/Look/LookTuningCommand.h b/src/source/Render/Look/LookTuningCommand.h index fba2e1b5ff..4cad5588f9 100644 --- a/src/source/Render/Look/LookTuningCommand.h +++ b/src/source/Render/Look/LookTuningCommand.h @@ -34,6 +34,12 @@ // $bloom falloff bloom.levelFalloff // $bloom bloom.strength // $ao radius ao.radius +// $clouds scale clouds.scale +// $clouds speed clouds.speed +// $clouds cover clouds.cover +// $clouds clouds.strength +// $sky sky.fill +// $rim sun lighting.rim.sunFollow // $ao ao.strength // $sun softness sun.softness // $sun resolution sun.resolution diff --git a/src/source/Render/Look/TuningControls.cpp b/src/source/Render/Look/TuningControls.cpp index c2bb15d643..28cbb150fe 100644 --- a/src/source/Render/Look/TuningControls.cpp +++ b/src/source/Render/Look/TuningControls.cpp @@ -90,6 +90,18 @@ constexpr std::array Specs = {{ TuningUnit::None, 1.0, TuningZero::Plain}, {TuningControlId::FlatSunShadow, TuningGroup::DynamicLights, true, LookValue::FlatSunShadow, 0.05, TuningUnit::Percent, 100.0, TuningZero::Plain}, + {TuningControlId::CloudStrength, TuningGroup::DynamicLights, false, LookValue::CloudStrength, 0.05, + TuningUnit::Percent, 100.0, TuningZero::Plain}, + {TuningControlId::CloudScale, TuningGroup::DynamicLights, true, LookValue::CloudScale, 250.0, TuningUnit::None, + 1.0, TuningZero::Plain}, + {TuningControlId::CloudSpeed, TuningGroup::DynamicLights, true, LookValue::CloudSpeed, 5.0, TuningUnit::None, 1.0, + TuningZero::Plain}, + {TuningControlId::CloudCover, TuningGroup::DynamicLights, true, LookValue::CloudCover, 0.05, TuningUnit::Percent, + 100.0, TuningZero::Plain}, + {TuningControlId::SkyFill, TuningGroup::DynamicLights, false, LookValue::SkyFill, 0.05, TuningUnit::Percent, 100.0, + TuningZero::Plain}, + {TuningControlId::RimSunFollow, TuningGroup::DynamicLights, true, LookValue::RimSunFollow, 0.05, + TuningUnit::Percent, 100.0, TuningZero::Plain}, }}; constexpr bool SpecsFollowIdOrder() diff --git a/src/source/Render/Look/TuningControls.h b/src/source/Render/Look/TuningControls.h index ece6e389d9..9559bb30e7 100644 --- a/src/source/Render/Look/TuningControls.h +++ b/src/source/Render/Look/TuningControls.h @@ -83,6 +83,12 @@ enum class TuningControlId : std::uint8_t SunShadowSoftness, SunShadowResolution, FlatSunShadow, + CloudStrength, + CloudScale, + CloudSpeed, + CloudCover, + SkyFill, + RimSunFollow, Count, }; inline constexpr std::size_t TuningControlCount = static_cast(TuningControlId::Count); diff --git a/src/source/Render/Renderer/SceneLighting.cpp b/src/source/Render/Renderer/SceneLighting.cpp index 30eba330d8..4b49991b85 100644 --- a/src/source/Render/Renderer/SceneLighting.cpp +++ b/src/source/Render/Renderer/SceneLighting.cpp @@ -80,6 +80,18 @@ SceneLightingUniform PackSceneLightingUniform(const SceneLighting& lighting, con uniform.cameraPosition[0] = lighting.cameraPosition[0]; uniform.cameraPosition[1] = lighting.cameraPosition[1]; uniform.cameraPosition[2] = lighting.cameraPosition[2]; + uniform.cloudParameters[0] = lighting.cloudStrength; + uniform.cloudParameters[1] = 1.0f / std::max(lighting.cloudScale, 1.0f); + uniform.cloudParameters[2] = lighting.cloudCover; + uniform.cloudOffset[0] = lighting.cloudOffset[0]; + uniform.cloudOffset[1] = lighting.cloudOffset[1]; + // The clear sky's blue the shade turns towards. + constexpr float SkyTint[3] = {0.72f, 0.84f, 1.0f}; + CopyColor(SkyTint, uniform.skyFill); + uniform.skyFill[3] = lighting.skyFill; + NormalizeInto(lighting.sunDirection, uniform.sunTowards); + uniform.sunTowards[3] = lighting.rimSunFollow; + CopyColor(lighting.sunColor, uniform.sunColor); return uniform; } diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index cd71fedf08..e399be3fef 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -54,6 +54,17 @@ struct SceneLighting std::uint32_t sunShadowResolution = 2048; float groundLow = 0.0f; float groundHigh = 0.0f; + // Enhanced cloud shadows: how much a cloud dims the sun's light (0: none), the pattern's size in + // world units, the share of sky covered and the pattern's offset (drift and the sun's slant). + float cloudStrength = 0.0f; + float cloudScale = 3000.0f; + float cloudCover = 0.45f; + float cloudOffset[2]{}; + // How far the shade takes the sky's blue (0: not at all), and how far the rim light follows the sun. + float skyFill = 0.0f; + float rimSunFollow = 0.0f; + // The sun's colour. + float sunColor[3]{1.0f, 1.0f, 1.0f}; }; // The frame's fog as configured through IMuRenderer::SetFog() when the scene lighting was set. @@ -79,6 +90,11 @@ struct SceneLightingUniform float cameraPosition[4]; // xyz world space, w unused float sunViewProjection[16]; // column-major, world to the sun shadow map's clip space float sunShadowParameters[4]; // darkness (0: no shadow map), softness in texels, 1 / map size, texel size + float cloudParameters[4]; // strength (0: no clouds), 1 / pattern size, sky cover, unused + float cloudOffset[4]; // xy: drift plus the sun's slant through the clouds, zw unused + float skyFill[4]; // rgb: the sky's tint of the shade, w: how far shade takes it + float sunTowards[4]; // xyz: towards the sun, w: how far the rim follows it + float sunColor[4]; // rgb: the sun's colour, w unused }; inline constexpr std::size_t kSceneLightingRegisterSize = 16; @@ -92,7 +108,9 @@ static_assert(offsetof(SceneLightingUniform, fogParameters) == 6 * kSceneLightin static_assert(offsetof(SceneLightingUniform, cameraPosition) == 7 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, sunViewProjection) == 8 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, sunShadowParameters) == 12 * kSceneLightingRegisterSize); -static_assert(sizeof(SceneLightingUniform) == 13 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, cloudParameters) == 13 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, sunColor) == 17 * kSceneLightingRegisterSize); +static_assert(sizeof(SceneLightingUniform) == 18 * kSceneLightingRegisterSize); [[nodiscard]] SceneLightingUniform PackSceneLightingUniform(const SceneLighting& lighting, const SceneFog& fog); diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index d77298b592..7f0382df59 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -17,7 +17,9 @@ #include "Render/Renderer/SceneLighting.h" #include "Scenes/SceneCore.h" +#include #include +#include #include namespace Scenes::Lighting @@ -47,6 +49,18 @@ void SelectionReference(float (&reference)[3]) } } // namespace +// How far the clouds have drifted at `speed` world units per second, along one fixed wind. +// shortcut: wraps every 2^20 world units (a jump every few hours of play); fine while clouds stay subtle. +static glm::vec2 CloudDrift(float speed) +{ + constexpr float WindDegrees = 30.0f; + constexpr double Wrap = 1048576.0; + const double seconds = std::chrono::duration(std::chrono::steady_clock::now().time_since_epoch()).count(); + const float along = static_cast(std::fmod(seconds * speed, Wrap)); + const float wind = glm::radians(WindDegrees); + return glm::vec2(std::cos(wind), std::sin(wind)) * along; +} + void SubmitSceneLighting() { mu::SceneLighting lighting{}; @@ -74,6 +88,31 @@ void SubmitSceneLighting() lighting.groundLow = Hero->Object.Position[2] - GroundReach; lighting.groundHigh = Hero->Object.Position[2] + GroundReach; } + if (sun) + { + if (!Render::Lighting::SunShadowsActive()) + { + lighting.sunDirection[0] = sun->sun.x; + lighting.sunDirection[1] = sun->sun.y; + lighting.sunDirection[2] = sun->sun.z; + } + } + // Clouds, the sky's tint of the shade and the sun-following rim: only under a sun that casts shadows. + if (Render::Lighting::SunShadowsActive() && sun) + { + using Data::Maps::LookValue; + lighting.cloudStrength = Render::Look::Value(LookValue::CloudStrength); + lighting.cloudScale = Render::Look::Value(LookValue::CloudScale); + lighting.cloudCover = Render::Look::Value(LookValue::CloudCover); + const glm::vec2 drift = CloudDrift(Render::Look::Value(LookValue::CloudSpeed)); + // The cloud layer stands this high: its shadow falls slanted by the sun. + constexpr float CloudHeight = 2000.0f; + const glm::vec2 slant = glm::vec2(sun->sun.x, sun->sun.y) * (CloudHeight / std::max(sun->sun.z, 0.2f)); + lighting.cloudOffset[0] = drift.x + slant.x; + lighting.cloudOffset[1] = drift.y + slant.y; + lighting.skyFill = Render::Look::Value(LookValue::SkyFill); + lighting.rimSunFollow = Render::Look::Value(LookValue::RimSunFollow); + } mu::GetRenderer().SetSceneLighting(lighting); } diff --git a/src/source/UI/Options/TuningRows.cpp b/src/source/UI/Options/TuningRows.cpp index b1a72f8cd9..2ab26f4519 100644 --- a/src/source/UI/Options/TuningRows.cpp +++ b/src/source/UI/Options/TuningRows.cpp @@ -62,6 +62,18 @@ ControlTexts TextsOf(TuningControlId id) return {I18N::Game::TuningShadowDirection, I18N::Game::TuningShadowDirectionHelp}; case TuningControlId::SunShadowStrength: return {I18N::Game::TuningSunShadows, I18N::Game::TuningSunShadowsHelp}; + case TuningControlId::CloudStrength: + return {I18N::Game::TuningCloudStrength, I18N::Game::TuningCloudStrengthHelp}; + case TuningControlId::CloudScale: + return {I18N::Game::TuningCloudScale, I18N::Game::TuningCloudScaleHelp}; + case TuningControlId::CloudSpeed: + return {I18N::Game::TuningCloudSpeed, I18N::Game::TuningCloudSpeedHelp}; + case TuningControlId::CloudCover: + return {I18N::Game::TuningCloudCover, I18N::Game::TuningCloudCoverHelp}; + case TuningControlId::SkyFill: + return {I18N::Game::TuningSkyFill, I18N::Game::TuningSkyFillHelp}; + case TuningControlId::RimSunFollow: + return {I18N::Game::TuningRimSunFollow, I18N::Game::TuningRimSunFollowHelp}; case TuningControlId::FlatSunShadow: return {I18N::Game::TuningFlatSunShadow, I18N::Game::TuningFlatSunShadowHelp}; case TuningControlId::SunShadowSoftness: diff --git a/tests/render/test_look_profile.cpp b/tests/render/test_look_profile.cpp index 892ed7ef47..2a9845df2e 100644 --- a/tests/render/test_look_profile.cpp +++ b/tests/render/test_look_profile.cpp @@ -236,6 +236,12 @@ TEST_CASE("the developer tuning commands name their look values [render][look]") single(L"$bloom falloff 0.6", LookValue::BloomLevelFalloff, 0.6); single(L"$bloom 0.9", LookValue::BloomStrength, 0.9); single(L"$ao radius 80", LookValue::AmbientOcclusionRadius, 80.0); + single(L"$clouds scale 4000", LookValue::CloudScale, 4000.0); + single(L"$clouds speed 60", LookValue::CloudSpeed, 60.0); + single(L"$clouds cover 0.5", LookValue::CloudCover, 0.5); + single(L"$clouds 0.3", LookValue::CloudStrength, 0.3); + single(L"$sky 0.5", LookValue::SkyFill, 0.5); + single(L"$rim sun 1", LookValue::RimSunFollow, 1.0); single(L"$ao 0.5", LookValue::AmbientOcclusionStrength, 0.5); single(L"$sun softness 1.5", LookValue::SunShadowSoftness, 1.5); single(L"$sun resolution 4096", LookValue::SunShadowResolution, 4096.0); diff --git a/tests/render/test_scene_lighting.cpp b/tests/render/test_scene_lighting.cpp index c221d3e66f..3b995f7581 100644 --- a/tests/render/test_scene_lighting.cpp +++ b/tests/render/test_scene_lighting.cpp @@ -6,7 +6,7 @@ TEST_CASE("scene lighting uniform matches the HLSL cbuffer registers [render][scene_lighting]") { - CHECK(sizeof(mu::SceneLightingUniform) == 208); + CHECK(sizeof(mu::SceneLightingUniform) == 288); CHECK(offsetof(mu::SceneLightingUniform, lightDirection) == 0); CHECK(offsetof(mu::SceneLightingUniform, lightColor) == 16); CHECK(offsetof(mu::SceneLightingUniform, diffuseCurve) == 32); diff --git a/tests/render/test_tuning_controls.cpp b/tests/render/test_tuning_controls.cpp index eaf3bc3d99..620945530b 100644 --- a/tests/render/test_tuning_controls.cpp +++ b/tests/render/test_tuning_controls.cpp @@ -95,6 +95,18 @@ const SpecRow Spec[] = { 1024, TuningUnit::None, TuningZero::Plain}, {TuningControlId::FlatSunShadow, TuningGroup::DynamicLights, true, LookValue::FlatSunShadow, 0, 1, 0.05, TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::CloudStrength, TuningGroup::DynamicLights, false, LookValue::CloudStrength, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::CloudScale, TuningGroup::DynamicLights, true, LookValue::CloudScale, 500, 10000, 250, + TuningUnit::None, TuningZero::Plain}, + {TuningControlId::CloudSpeed, TuningGroup::DynamicLights, true, LookValue::CloudSpeed, 0, 300, 5, TuningUnit::None, + TuningZero::Plain}, + {TuningControlId::CloudCover, TuningGroup::DynamicLights, true, LookValue::CloudCover, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, + {TuningControlId::SkyFill, TuningGroup::DynamicLights, false, LookValue::SkyFill, 0, 1, 0.05, TuningUnit::Percent, + TuningZero::Plain}, + {TuningControlId::RimSunFollow, TuningGroup::DynamicLights, true, LookValue::RimSunFollow, 0, 1, 0.05, + TuningUnit::Percent, TuningZero::Plain}, }; Data::Maps::LookProfileData ShippedLikeProfile() @@ -110,9 +122,9 @@ Data::Maps::LookProfileData ShippedLikeProfile() } } // namespace -TEST_CASE("the 28 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") +TEST_CASE("the 34 tuning controls have the specified bounds, steps, units and placement [render][look][tuning]") { - REQUIRE(Render::Look::TuningControlCount == 28); + REQUIRE(Render::Look::TuningControlCount == 34); REQUIRE(std::size(Spec) == Render::Look::TuningControlCount); std::set covered; for (const SpecRow& row : Spec) From a3ef5af7a0564de5a9305b0c4b3dd891287075ee Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 01:11:57 +0800 Subject: [PATCH 14/17] feat(render): ambient occlusion with anti-aliasing on Ambient occlusion reads the scene's depth, which a multisampled frame cannot sample: with anti-aliasing on, the scene's solid draws are drawn once more, depth only, into the single-sample pass depth (profiled as SceneDepth). BMD, skinned and glTF draws each replay with their own vertex layout. --- docs/enhanced-look.md | 2 +- src/source/Core/Utilities/FrameProfiler.h | 6 +- .../Render/Renderer/MuRendererSDLGpu.cpp | 77 ++++++++++++++++--- 3 files changed, 70 insertions(+), 15 deletions(-) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index e783ef5018..b862724dd7 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -223,7 +223,7 @@ for the whole file. | `bloom.strength` | 1.0 (Icarus 0.3) | 0.6 | 0–2 | how strong the halo around light effects is | | `bloom.levelFalloff` | 0.6 | 0.5 | 0.25–1 | how wide the halo spreads | | `grading.strength` | 1 | 1 | 0–1 | how much of a map's grading table applies; 0 grades nothing while the bloom stays | -| `ao.strength` | 0.8 | 0 | 0–2 | how much screen-space ambient occlusion darkens corners, wall bases and the ground under objects; additive effects are left alone; not drawn while anti-aliasing is on | +| `ao.strength` | 0.8 | 0 | 0–2 | how much screen-space ambient occlusion darkens corners, wall bases and the ground under objects; additive effects are left alone. With anti-aliasing on, the scene's solid parts are drawn once more for the depth it reads | | `ao.radius` | 60 | 60 | 10–300 | how far, in world units, nearby geometry still darkens a surface | | `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | | `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | diff --git a/src/source/Core/Utilities/FrameProfiler.h b/src/source/Core/Utilities/FrameProfiler.h index 0e293202c5..486fd218b2 100644 --- a/src/source/Core/Utilities/FrameProfiler.h +++ b/src/source/Core/Utilities/FrameProfiler.h @@ -46,10 +46,12 @@ enum class Pass : int ObjectsDraw, // The update's effect spawns and poses for the drawn characters and map objects. UpdateEffects, - // Inside RendererReplay: the sun shadow map. + // Inside RendererReplay: the sun shadow map, and the scene's depth for ambient occlusion while + // anti-aliasing is on. SunShadow, // Inside the terrain's frame start: the static terrain light built again for a moved sun. TerrainBake, + SceneDepth, Count_ }; @@ -58,7 +60,7 @@ inline constexpr const char* kPassNames[static_cast(Pass::Count_)] = { "MovePart", "Skinning", "UI", "RenderBegin", "RenderEnd", "Submit", "UIUpdate", "RmlInput", "UILayout", "Flush", "Sprites", "Particles", "Joints", "Overlay", "RmlUpd", "RmlRend", "EndOffscr", "EndStage", "EndReplay", "EndPostUI", "ObjAnim", "ObjDraw", "UpdateFx", "SunShadow", - "TerrainBake", + "TerrainBake", "SceneDepth", }; enum class Counter : int diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 368c288eac..85566efea0 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -1125,6 +1125,8 @@ static bool s_pipelinesMultisampled = false; // Enhanced sun shadows: while s_sunShadowPass replays the scene into the shadow map, each draw's recorded // scene matrix is turned into the sun's by s_sunFromScene. static bool s_sunShadowPass = false; +// While the scene's solid draws are replayed depth-only into a single-sample depth (RenderSceneDepth). +static bool s_sceneDepthPass = false; static glm::mat4 s_sunFromScene{1.0f}; // How a draw covers the sun shadow map (sun_depth.frag's coverageMode): solid with its alpha test, @@ -1243,7 +1245,7 @@ static void ReplayDrawCommand(const RenderCmd& command, SDL_GPUGraphicsPipeline* } BindReplayFragmentSampler(command, state); - if (s_sunShadowPass) + if (s_sunShadowPass || s_sceneDepthPass) { // sun_depth.frag reads fogEnabled's slot as its coverage mode. FogUniform coverage = command.fogUniform; @@ -1320,6 +1322,8 @@ static float s_sceneProjection[16]{}; // Enhanced sun shadows (one sample): the shadow map's pipelines for 3D, skinned and glTF draws, and its // textures. static SDL_GPUGraphicsPipeline* s_sunShadowPipelines[3]{}; // [ShadowPassLayout] +// The same draws, unbiased, into the scene's single-sample depth (RenderSceneDepth). +static SDL_GPUGraphicsPipeline* s_sceneDepthPipelines[3]{}; // [ShadowPassLayout] static SDL_GPUShader* s_fragShaderSunDepth = nullptr; // sun_depth.frag static mu::SdlGpuSunShadowMap s_sunShadowMap; @@ -2445,6 +2449,7 @@ class MuRendererSDLGpu : public IMuRenderer BloomSources, GroundShadows, // the ground shadows, into the ground shadow mask SunShadowCasters, // solid world draws, into the sun shadow map + SceneDepth, // the scene's solid draws, into a single-sample depth }; [[nodiscard]] static ReplayView FullFrameView() @@ -2535,6 +2540,11 @@ class MuRendererSDLGpu : public IMuRenderer { return command.groundShadow ? GetGroundShadowMaskPipeline(command) : nullptr; } + if (selection == ReplaySelection::SceneDepth) + { + const bool solid = IsSunShadowCaster(command) && !command.blendEnabled && command.depthMaskEnabled; + return solid ? s_sceneDepthPipelines[ShadowPassLayout(command)] : nullptr; + } if (selection == ReplaySelection::SunShadowCasters) { return IsSunShadowCaster(command) ? s_sunShadowPipelines[ShadowPassLayout(command)] : nullptr; @@ -2786,6 +2796,29 @@ class MuRendererSDLGpu : public IMuRenderer s_sunShadowMap.MarkReady(); } + // The scene's depth for ambient occlusion: the frame's own with one sample; multisampled, which + // cannot be read, its solid draws [0, end) again into the single-sample pass depth. Null without. + [[nodiscard]] static SDL_GPUTexture* RenderSceneDepth(std::size_t end, bool boneDataReady) + { + if (!IsMultisampled()) + { + return s_depthTexture; + } + FRAME_PROFILE(SceneDepth); + SDL_GPUTexture* const depth = SingleSamplePassDepth(); + if (!depth || !s_sceneDepthPipelines[0] || !s_sceneDepthPipelines[1] || + (s_renderPass = BeginDepthOnlyPass(depth)) == nullptr) + { + return nullptr; + } + ReplayView view = FullFrameView(); + s_sceneDepthPass = true; + ReplayCommands(0u, end, boneDataReady, ReplaySelection::SceneDepth, view); + s_sceneDepthPass = false; + EndReplayPass(); + return depth; + } + static void EndReplayPass() { SDL_EndGPURenderPass(s_renderPass); @@ -2858,7 +2891,7 @@ class MuRendererSDLGpu : public IMuRenderer depthInfo.layer_count_or_depth = 1; depthInfo.num_levels = 1; depthInfo.sample_count = SDL_GPU_SAMPLECOUNT_1; - depthInfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET; + depthInfo.usage = SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET | SDL_GPU_TEXTUREUSAGE_SAMPLER; s_singleSampleDepthTexture = SDL_CreateGPUTexture(s_device, &depthInfo); if (!s_singleSampleDepthTexture) { @@ -2941,13 +2974,14 @@ class MuRendererSDLGpu : public IMuRenderer } s_hdrScenePass = false; - // Read from the scene's depth, which the scene pass stored; anti-aliased frames have none to read. + const bool sceneView = s_postProcessingView == mu::PostProcessingView::Scene; + SDL_GPUTexture* const sceneDepth = s_postProcessingLook.ambientOcclusionStrength > 0.0f && sceneView + ? RenderSceneDepth(sceneEnd, boneDataReady) + : nullptr; SDL_GPUTexture* const ambientOcclusion = - s_postProcessingLook.ambientOcclusionStrength > 0.0f && !IsMultisampled() && - s_postProcessingView == mu::PostProcessingView::Scene - ? s_ambientOcclusion.Render(s_cmdBuf, s_depthTexture, {s_swapW, s_swapH}, s_sceneProjection, - s_postProcessingLook.ambientOcclusionRadius) - : nullptr; + sceneDepth ? s_ambientOcclusion.Render(s_cmdBuf, sceneDepth, {s_swapW, s_swapH}, s_sceneProjection, + s_postProcessingLook.ambientOcclusionRadius) + : nullptr; // The composite covers every pixel: the target's old content is not loaded. // A diagnostic view without its image this frame leaves black instead. @@ -6223,6 +6257,8 @@ class MuRendererSDLGpu : public IMuRenderer bool groundShadowMaskTarget = false; // Into the sun shadow map: depth only, one sample, biased against self-shadowing. bool sunShadowTarget = false; + // Into the scene's single-sample depth: depth only, one sample, unbiased. + bool sceneDepthTarget = false; }; // The world sets built together, and what a failed pipeline means for them. @@ -6525,8 +6561,9 @@ class MuRendererSDLGpu : public IMuRenderer vtxInputState.num_vertex_attributes = numAttribs; SDL_GPUGraphicsPipelineTargetInfo targetInfo{}; - targetInfo.color_target_descriptions = description.sunShadowTarget ? nullptr : &colorTargetDesc; - targetInfo.num_color_targets = description.sunShadowTarget ? 0u : 1u; + const bool depthOnly = description.sunShadowTarget || description.sceneDepthTarget; + targetInfo.color_target_descriptions = depthOnly ? nullptr : &colorTargetDesc; + targetInfo.num_color_targets = depthOnly ? 0u : 1u; // Enable depth-stencil target so pipelines match // the render pass that now includes a depth buffer. targetInfo.has_depth_stencil_target = !description.groundShadowMaskTarget; @@ -6562,7 +6599,7 @@ class MuRendererSDLGpu : public IMuRenderer pipelineInfo.props = 0; pipelineInfo.multisample_state.sample_count = - description.groundShadowMaskTarget || description.sunShadowTarget + description.groundShadowMaskTarget || depthOnly ? SDL_GPU_SAMPLECOUNT_1 : mu::GetSdlGpuSampleCount(s_sampleCount).value_or(SDL_GPU_SAMPLECOUNT_1); pipelineInfo.multisample_state.enable_alpha_to_coverage = description.alphaToCoverage; @@ -6838,6 +6875,14 @@ class MuRendererSDLGpu : public IMuRenderer } } } + for (SDL_GPUGraphicsPipeline*& pipeline : s_sceneDepthPipelines) + { + if (pipeline) + { + SDL_ReleaseGPUGraphicsPipeline(s_device, pipeline); + pipeline = nullptr; + } + } for (SDL_GPUGraphicsPipeline*& pipeline : s_sunShadowPipelines) { if (pipeline) @@ -7259,8 +7304,16 @@ class MuRendererSDLGpu : public IMuRenderer PipelineBuildDescription description{"sun-shadow", "opaque", k_PipelineDisabled, true, true, layouts[layout], false, FragmentShader::SunDepth}; description.sunShadowTarget = true; - const PipelineBuildResult result = BuildBlendPipeline(SDL_GPUColorTargetBlendState{}, description); + PipelineBuildResult result = BuildBlendPipeline(SDL_GPUColorTargetBlendState{}, description); s_sunShadowPipelines[layout] = result.pipeline; + if (result.pipeline) + { + description.setName = "scene-depth"; + description.sunShadowTarget = false; + description.sceneDepthTarget = true; + result = BuildBlendPipeline(SDL_GPUColorTargetBlendState{}, description); + s_sceneDepthPipelines[layout] = result.pipeline; + } if (!result.pipeline) { const char* driver = SDL_GetGPUDeviceDriver(s_device); From 44323822137a965a93ab65178e5ae114215eb486 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 01:15:56 +0800 Subject: [PATCH 15/17] feat(render): the sunlight look ships on: cloud shadows, sky-blue shade and a sun rim clouds.strength 0.35, sky.fill 0.5, lighting.rim.sunFollow 1 in the shipped Enhanced look. --- docs/enhanced-look.md | 12 ++++++------ src/bin/Data/Render/Look.json | 6 +++--- tests/data/test_look_profile_json.cpp | 2 ++ 3 files changed, 11 insertions(+), 9 deletions(-) diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index b862724dd7..4d3c9287eb 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -90,12 +90,12 @@ window. | Dynamic lights | Sun shadow softness | `sun.softness` | 0–2 | 0.1 | 1 | More settings | | Dynamic lights | Sun shadow resolution | `sun.resolution` | 1024–4096 | 1024 | 2048 | More settings | | Dynamic lights | Flat sun shadow | `dynamic.flatSunShadow` | 0–100 % | 5 % | 100 % (0 indoors) | More settings | -| Dynamic lights | Cloud shadows | `clouds.strength` | 0–100 % | 5 % | 0 | common | +| Dynamic lights | Cloud shadows | `clouds.strength` | 0–100 % | 5 % | 35 % | common | | Dynamic lights | Cloud size | `clouds.scale` | 500–10000 | 250 | 3000 | More settings | | Dynamic lights | Cloud speed | `clouds.speed` | 0–300 | 5 | 40 | More settings | | Dynamic lights | Cloud cover | `clouds.cover` | 0–100 % | 5 % | 45 % | More settings | -| Dynamic lights | Sky-blue shade | `sky.fill` | 0–100 % | 5 % | 0 | common | -| Dynamic lights | Rim light follows the sun | `lighting.rim.sunFollow` | 0–100 % | 5 % | 0 | More settings | +| Dynamic lights | Sky-blue shade | `sky.fill` | 0–100 % | 5 % | 50 % | common | +| Dynamic lights | Rim light follows the sun | `lighting.rim.sunFollow` | 0–100 % | 5 % | 100 % | More settings | | Darker map light | Mood strength | `mood.strengthPercent` | 0–100 % | 1 % | 100 % | common | | Bloom and colour grading | Bloom intensity | `bloom.strength` | 0–2 | 0.05 | 1 (Icarus 0.3) | common | | Bloom and colour grading | Bloom spread | `bloom.levelFalloff` | 0.25–1 | 0.05 | 0.6 | common | @@ -228,12 +228,12 @@ for the whole file. | `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | | `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | | `dynamic.flatSunShadow` | 1 (Dungeon, Lost Tower, Kanturu Relics, Refinery Tower: 0) | 1 | 0–1 | how dark the flat shadow under characters is while sun shadows are off (`sun.shadow` 0), on top of the shadow's own darkness. The indoor and underground maps set both to 0: no sun there, so only torches and spells cast character shadows. Classic always draws it | -| `clouds.strength` | 0 | 0 | 0–1 | how much a passing cloud dims the sun's light on the ground and characters; drifting procedural clouds whose shadows fall slanted by the sun. Only with sun shadows | +| `clouds.strength` | 0.35 | 0 | 0–1 | how much a passing cloud dims the sun's light on the ground and characters; drifting procedural clouds whose shadows fall slanted by the sun. Only with sun shadows | | `clouds.scale` | 3000 | 3000 | 500–10000 | the cloud pattern's size in world units | | `clouds.speed` | 40 | 40 | 0–300 | how fast the clouds drift along a fixed wind, in world units per second | | `clouds.cover` | 0.45 | 0.45 | 0–1 | the share of the sky the clouds cover | -| `sky.fill` | 0 | 0 | 0–1 | how far shade (from shadows and clouds) turns towards the sky's blue while sunlit places keep the sun's colour; replaces the light mood's `shadeCool` while sun shadows are on. Only with sun shadows | -| `lighting.rim.sunFollow` | 0 | 0 | 0–1 | how much the characters' edge light comes from the sun: brighter and sun-coloured on its side, gone in its shadow; 0 the even Enhanced rim | +| `sky.fill` | 0.5 | 0 | 0–1 | how far shade (from shadows and clouds) turns towards the sky's blue while sunlit places keep the sun's colour; replaces the light mood's `shadeCool` while sun shadows are on. Only with sun shadows | +| `lighting.rim.sunFollow` | 1 | 0 | 0–1 | how much the characters' edge light comes from the sun: brighter and sun-coloured on its side, gone in its shadow; 0 the even Enhanced rim | | `sun.resolution` | 2048 | 2048 | 1024–4096 | the sun shadow map's size in texels (1024, 2048 or 4096): sharper shadows for more graphics memory and time | ## Developer commands diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 2afcb0bf38..8bf4d79a2b 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -28,12 +28,12 @@ "sun.softness": 1, "sun.resolution": 2048, "dynamic.flatSunShadow": 1, - "clouds.strength": 0, + "clouds.strength": 0.35, "clouds.scale": 3000, "clouds.speed": 40, "clouds.cover": 0.45, - "sky.fill": 0, - "lighting.rim.sunFollow": 0 + "sky.fill": 0.5, + "lighting.rim.sunFollow": 1 }, "maps": [ { diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index dcd4523ea8..20f080090c 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -267,6 +267,8 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] {LookValue::BloomLevelFalloff, 0.6}, {LookValue::GroundShadowAngle, 135}, {LookValue::GroundShadowLights, 2}, {LookValue::AmbientOcclusionStrength, 0.8}, {LookValue::SpecularScale, 0.8}, {LookValue::SunShadowStrength, 1.0}, + {LookValue::CloudStrength, 0.35}, {LookValue::SkyFill, 0.5}, + {LookValue::RimSunFollow, 1.0}, }; for (const Data::Maps::LookValueInfo& info : Data::Maps::LookValueInfos()) { From 53f96b0abb627bbe41c8e9e7ca748bef91f5b340 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 01:53:54 +0800 Subject: [PATCH 16/17] fix(render): models, flat shadows and clouds agree with the frame's sun; maps name their environment - World models follow the frame's sun: the game lights every model with the highlight vector, which skipped it; UI models keep their light. - Enhanced flat shadows fall away from the frame's sun, as long as its slant. - On the ground a cloud takes away direct sunlight only: the terrain bake uploads each cell's direct part (SetTerrainSunLight), which world_lit subtracts under clouds, leaving the painted ambient light and point lights. - A change of the light mood's scales (look values) rebuilds the static light; the sky fill takes over the mood's shadeCool only where the renderer can draw sun shadows. - Shadow dims only the light a model face receives, so shaded far sides no longer come out brighter than lit ones. - Sun shadows filter with a rotated 12-sample Poisson disc and Gaussian weights instead of a 3x3 box, and push further off faces turned from the sun. - AO targets are freed whenever its pass does not run; bloom targets exist only while bloom is on. - Every map names an environment in Look.json: outdoor, outdoorDense, sky, underwater, enclosed or fixed (docs/enhanced-look-map-environments.md); "environments" holds their values, applied between the default and the map's own. Enclosed maps get no sun shadows. - rendering-parity.md: Windows defaults to Vulkan. --- cmake/ValidateDxilReflection.cmake | 2 +- cmake/ValidateShaderReflection.cmake | 2 +- docs/build/rendering-parity.md | 2 +- docs/enhanced-look-map-environments.md | 57 +++++++++ docs/enhanced-look.md | 23 +++- src/bin/Data/Render/Look.json | 103 +++++++++++---- .../compiled/basic_textured_fog.frag.dxil | Bin 6332 -> 6368 bytes .../compiled/basic_textured_fog.frag.msl | 1 + .../compiled/basic_textured_fog.frag.spv | Bin 5472 -> 5528 bytes src/shaders/compiled/skinned_lit.frag.dxil | Bin 13732 -> 15356 bytes src/shaders/compiled/skinned_lit.frag.msl | 119 ++++++++++++------ src/shaders/compiled/skinned_lit.frag.spv | Bin 25972 -> 27852 bytes src/shaders/compiled/world_lit.frag.dxil | Bin 10216 -> 12264 bytes src/shaders/compiled/world_lit.frag.msl | 118 ++++++++++++----- src/shaders/compiled/world_lit.frag.spv | Bin 16448 -> 19580 bytes src/shaders/dynamic_lighting.hlsli | 31 +++-- src/shaders/scene_lighting.hlsli | 1 + src/shaders/skinned_lit.frag.hlsl | 11 +- src/shaders/world_lit.frag.hlsl | 28 +++-- .../Data/GameData/MapData/LookProfile.cpp | 68 +++++++++- .../Data/GameData/MapData/LookProfile.h | 30 +++-- .../Render/Lighting/LightMoodSetting.cpp | 19 ++- src/source/Render/Lighting/LightMoodSetting.h | 4 + src/source/Render/Lighting/ModelLight.cpp | 10 +- src/source/Render/Lighting/ModelLight.h | 6 +- src/source/Render/Lighting/SunShadow.cpp | 11 ++ src/source/Render/Lighting/SunShadow.h | 10 ++ src/source/Render/Models/ZzzBMD.cpp | 14 ++- src/source/Render/Renderer/MuRenderer.h | 5 + .../Render/Renderer/MuRendererSDLGpu.cpp | 73 ++++++++++- src/source/Render/Renderer/SceneLighting.h | 8 +- .../Render/Renderer/SdlGpuAmbientOcclusion.h | 3 +- .../Render/Renderer/SdlGpuPostProcessing.cpp | 53 +++++--- .../Render/Renderer/SdlGpuPostProcessing.h | 9 +- src/source/Render/Terrain/ZzzLodTerrain.cpp | 22 +++- src/source/Scenes/SceneLightingSetup.cpp | 1 + tests/data/test_look_profile_json.cpp | 21 ++++ tests/render/test_scene_lighting.cpp | 2 +- tests/render/test_sun_shadow.cpp | 14 +++ 39 files changed, 711 insertions(+), 170 deletions(-) create mode 100644 docs/enhanced-look-map-environments.md diff --git a/cmake/ValidateDxilReflection.cmake b/cmake/ValidateDxilReflection.cmake index 7353012743..29ebc234b0 100644 --- a/cmake/ValidateDxilReflection.cmake +++ b/cmake/ValidateDxilReflection.cmake @@ -27,7 +27,7 @@ set(shader_specs "skinned_weighted_shadow.vert|cb0,space1+cb1,space1+t0,space0+t1,space0" "skinned_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+s2,space2+t0,space2+t1,space2+t2,space2" "world_lit.vert|cb0,space1" - "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+s2,space2+t0,space2+t1,space2+t2,space2" + "world_lit.frag|cb0,space3+cb1,space3+cb2,space3+s0,space2+s1,space2+s2,space2+s3,space2+t0,space2+t1,space2+t2,space2+t3,space2" "shadow_mask.frag|-" "post_fullscreen.vert|-" "post_bloom_down.frag|cb0,space3+s0,space2+t0,space2" diff --git a/cmake/ValidateShaderReflection.cmake b/cmake/ValidateShaderReflection.cmake index 51bc89fbb7..ce925e6b03 100644 --- a/cmake/ValidateShaderReflection.cmake +++ b/cmake/ValidateShaderReflection.cmake @@ -290,7 +290,7 @@ set(shader_specs "skinned_weighted_shadow.vert|vert|0,3,4,6,7|0|2|2" "skinned_lit.frag|frag||3|0|3" "world_lit.vert|vert|0,1,2|0|0|1" - "world_lit.frag|frag||3|0|3" + "world_lit.frag|frag||4|0|3" "shadow_mask.frag|frag||0|0|0" "post_fullscreen.vert|vert||0|0|0" "post_bloom_down.frag|frag||1|0|1" diff --git a/docs/build/rendering-parity.md b/docs/build/rendering-parity.md index e22c92e33e..62226f29ac 100644 --- a/docs/build/rendering-parity.md +++ b/docs/build/rendering-parity.md @@ -8,7 +8,7 @@ change performance behavior by OS. |----|----------------|--------------------| | macOS | Metal | Identical | | Linux | Vulkan | Identical | -| Windows | D3D12 | Identical | +| Windows | Vulkan (D3D12 via `[Render] Backend`) | Identical | Native drivers, GPUs, and font rasterizers can still expose platform-specific driver defects. Runtime parity therefore requires measurements on each target; diff --git a/docs/enhanced-look-map-environments.md b/docs/enhanced-look-map-environments.md new file mode 100644 index 0000000000..e8acb3292e --- /dev/null +++ b/docs/enhanced-look-map-environments.md @@ -0,0 +1,57 @@ +# Enhanced look: map environments + +Which environment each map has in `Data/Render/Look.json` and why. The environments themselves (what they set) are in [enhanced-look.md](enhanced-look.md#environments). Classic uses none of this. + +**Physical** describes the scene: outdoor, indoor, underground, underwater, aerial or mixed. **Policy** is the lighting it calls for: + +- **day-night:** open air, meant for a day-night cycle (not built yet: these maps keep their fixed sun). +- **hybrid:** mostly open, but dark, dense or special. +- **fixed:** authored lighting, never a day-night cycle. +- **custom:** its own kind of light (sky, underwater). + +The classification is a rendering proposal, not Webzen's own. A map is lit as one region: a mixed map can't light its interior and its open ground differently. + +| World | Map | Physical | Theme | Policy | Environment | +|---:|---|---|---|---|---| +| 0 | Lorencia | outdoor | grassland, town | day-night | `outdoor` | +| 1 | Dungeon | underground | dungeon, catacombs | fixed | `enclosed` | +| 2 | Devias | outdoor | snow, tundra | day-night | `outdoor` | +| 3 | Noria | outdoor | forest | day-night | `outdoor` | +| 4 | Lost Tower | indoor | dark tower | fixed | `enclosed` | +| 6 | Arena | mixed | gladiatorial arena | fixed | `fixed` | +| 7 | Atlans | underwater | submerged ruins | custom | `underwater` | +| 8 | Tarkan | outdoor | desert | day-night | `outdoor` | +| 9, 32 | Devil Square | indoor | demonic arena | fixed | `enclosed` | +| 10 | Icarus | aerial | sky, floating ruins | custom | `sky` | +| 11–17, 52 | Blood Castle 1–8 | aerial, mixed | floating fortress | fixed | `fixed` | +| 18–23, 53 | Chaos Castle 1–7 | indoor | enclosed battleground | fixed | `enclosed` | +| 24–29, 36 | Kalima 1–6, Lost Kalima | mixed | dark realm | fixed | `fixed` | +| 30 | Valley of Loren | outdoor | castle battlefield | day-night | `outdoor` | +| 31 | Land of Trials | outdoor | rocky wilderness | day-night | `outdoor` | +| 33 | Aida | outdoor | dark forest | hybrid | `outdoorDense` | +| 34, 35 | Crywolf | outdoor | mountain fortress | day-night | `outdoor` | +| 37 | Kanturu Ruins | outdoor, mixed | ancient ruins | hybrid | `outdoorDense` | +| 38 | Kanturu Relics | indoor | mechanical ruins | fixed | `enclosed` | +| 39 | Refinery Tower | indoor | boss chamber | fixed | `enclosed` | +| 41 | Barracks of Balgass | outdoor, mixed | military canyon | fixed | `fixed` | +| 42 | Balgass Refuge | indoor | boss refuge | fixed | `enclosed` | +| 45–50 | Illusion Temple 1–6 | indoor | ritual arena | fixed | `enclosed` | +| 51 | Elbeland | outdoor | enchanted forest | day-night | `outdoor` | +| 56 | Swamp of Calmness | outdoor | swamp | hybrid | `outdoorDense` | +| 57 | Raklion | outdoor | glacier | hybrid | `outdoorDense` | +| 58 | Raklion boss cave | underground | ice cavern | fixed | `enclosed` | +| 62 | Santa Village | outdoor | snowy village | fixed | `fixed` | +| 63 | Vulcanus | outdoor | volcanic | hybrid | `outdoorDense` | +| 64 | Duel Arena | arena | combat area | fixed | `fixed` | +| 65–68 | Doppelganger 1–4 | indoor, mixed | dungeon corridors | fixed | `enclosed` | +| 69–72 | Imperial Guardian 1–4 | indoor, mixed | fortress corridors | fixed | `enclosed` | +| 79 | Loren Market | outdoor | trade town | day-night | `outdoor` | +| 80, 81 | Karutan 1–2 | outdoor | rocky desert | day-night | `outdoor` | + +Not listed, so they get only the default values: + +- world 5; +- the GM area (40); +- the login and character scenes (54, 55, 73, 74, 77, 78). + +The later-season maps (Acheron, Debenter, Deep Dungeon, and so on) aren't in this client. diff --git a/docs/enhanced-look.md b/docs/enhanced-look.md index 4d3c9287eb..dccffc4217 100644 --- a/docs/enhanced-look.md +++ b/docs/enhanced-look.md @@ -190,7 +190,8 @@ Classic uses neither file. { "formatVersion": 1, "default": { "bloom.strength": 1.0, "dynamic.effectCap": 2.5 }, - "maps": [ { "world": 10, "name": "Icarus", "bloom.strength": 0.3 } ] + "environments": { "enclosed": { "sun.shadow": 0 } }, + "maps": [ { "world": 10, "name": "Icarus", "environment": "sky", "bloom.strength": 0.3 } ] } ``` @@ -227,7 +228,7 @@ for the whole file. | `ao.radius` | 60 | 60 | 10–300 | how far, in world units, nearby geometry still darkens a surface | | `sun.shadow` | 1 | 0 | 0–1 | how dark the sun's shadows are, on top of `dynamic.shadowOpacity`. Everything solid (the terrain, buildings, trees, characters) is drawn from the sun into a shadow map, so shadows fall onto slopes, walls and other characters. The sun stands opposite `dynamic.shadowAngle`, as high as the flat character shadows were long. On models it takes away only the direct sunlight, not the ambient light. Characters' see-through parts (wings, capes, auras) cast a lighter shadow by their opacity, or glowing, their brightness. Above 0, characters cast no flat sun shadow; point-light shadows stay flat. Needs dynamic lights; drawn with anti-aliasing too | | `sun.softness` | 1 | 1 | 0–2 | how many shadow-map texels the sun shadows' edges blur over | -| `dynamic.flatSunShadow` | 1 (Dungeon, Lost Tower, Kanturu Relics, Refinery Tower: 0) | 1 | 0–1 | how dark the flat shadow under characters is while sun shadows are off (`sun.shadow` 0), on top of the shadow's own darkness. The indoor and underground maps set both to 0: no sun there, so only torches and spells cast character shadows. Classic always draws it | +| `dynamic.flatSunShadow` | 1 (Dungeon, Lost Tower, Kanturu Relics, Refinery Tower: 0) | 1 | 0–1 | how dark the flat shadow under characters is while sun shadows are off (`sun.shadow` 0); it falls away from the frame's sun, as long as the sun's slant (at most 3 units per unit of height), on top of the shadow's own darkness. The indoor and underground maps set both to 0: no sun there, so only torches and spells cast character shadows. Classic always draws it | | `clouds.strength` | 0.35 | 0 | 0–1 | how much a passing cloud dims the sun's light on the ground and characters; drifting procedural clouds whose shadows fall slanted by the sun. Only with sun shadows | | `clouds.scale` | 3000 | 3000 | 500–10000 | the cloud pattern's size in world units | | `clouds.speed` | 40 | 40 | 0–300 | how fast the clouds drift along a fixed wind, in world units per second | @@ -236,6 +237,24 @@ for the whole file. | `lighting.rim.sunFollow` | 1 | 0 | 0–1 | how much the characters' edge light comes from the sun: brighter and sun-coloured on its side, gone in its shadow; 0 the even Enhanced rim | | `sun.resolution` | 2048 | 2048 | 1024–4096 | the sun shadow map's size in texels (1024, 2048 or 4096): sharper shadows for more graphics memory and time | +## Environments + +`environments` names kinds of place; a map entry picks one +with `"environment"`. Their values apply between the default and the map's +own. The shipped ones: + +| Environment | What it sets | Maps | +|---|---|---| +| `outdoor` | nothing yet | Lorencia, Devias, Noria, Tarkan, Valley of Loren, Land of Trials, Crywolf, Elbeland, Loren Market, Karutan | +| `outdoorDense` | nothing yet | Aida, Kanturu Ruins, Swamp of Calmness, Raklion, Vulcanus | +| `sky` | nothing yet | Icarus | +| `underwater` | softer sun shadows | Atlans | +| `enclosed` | no sun shadows | Dungeon, Lost Tower, Devil Square, Chaos Castle, Kanturu Relics, Refinery Tower, Balgass Refuge, Illusion Temple, Raklion boss cave, Doppelganger, Imperial Guardian | +| `fixed` | nothing (open air) | Arena, Blood Castle, Kalima, Barracks of Balgass, Santa Village, Duel Arena | + +[enhanced-look-map-environments.md](enhanced-look-map-environments.md) lists +every map with its world number and why it has its environment. + ## Developer commands Builds with the control socket (`ENABLE_CONTROL_SOCKET=ON`, the `-mueditor` diff --git a/src/bin/Data/Render/Look.json b/src/bin/Data/Render/Look.json index 8bf4d79a2b..b3220708d9 100644 --- a/src/bin/Data/Render/Look.json +++ b/src/bin/Data/Render/Look.json @@ -35,35 +35,86 @@ "sky.fill": 0.5, "lighting.rim.sunFollow": 1 }, - "maps": [ - { - "world": 1, - "name": "Dungeon", - "sun.shadow": 0, - "dynamic.flatSunShadow": 0 + "environments": { + "outdoor": {}, + "outdoorDense": {}, + "sky": {}, + "underwater": { + "sun.softness": 2 }, - { - "world": 4, - "name": "Lost Tower", + "enclosed": { "sun.shadow": 0, "dynamic.flatSunShadow": 0 }, - { - "world": 10, - "name": "Icarus", - "bloom.strength": 0.3 - }, - { - "world": 38, - "name": "Kanturu Relics", - "sun.shadow": 0, - "dynamic.flatSunShadow": 0 - }, - { - "world": 39, - "name": "Refinery Tower", - "sun.shadow": 0, - "dynamic.flatSunShadow": 0 - } + "fixed": {} + }, + "maps": [ + {"world": 0, "name": "Lorencia", "environment": "outdoor"}, + {"world": 1, "name": "Dungeon", "environment": "enclosed"}, + {"world": 2, "name": "Devias", "environment": "outdoor"}, + {"world": 3, "name": "Noria", "environment": "outdoor"}, + {"world": 4, "name": "Lost Tower", "environment": "enclosed"}, + {"world": 6, "name": "Arena", "environment": "fixed"}, + {"world": 7, "name": "Atlans", "environment": "underwater"}, + {"world": 8, "name": "Tarkan", "environment": "outdoor"}, + {"world": 9, "name": "Devil Square", "environment": "enclosed"}, + {"world": 10, "name": "Icarus", "environment": "sky", "bloom.strength": 0.3}, + {"world": 11, "name": "Blood Castle 1", "environment": "fixed"}, + {"world": 12, "name": "Blood Castle 2", "environment": "fixed"}, + {"world": 13, "name": "Blood Castle 3", "environment": "fixed"}, + {"world": 14, "name": "Blood Castle 4", "environment": "fixed"}, + {"world": 15, "name": "Blood Castle 5", "environment": "fixed"}, + {"world": 16, "name": "Blood Castle 6", "environment": "fixed"}, + {"world": 17, "name": "Blood Castle 7", "environment": "fixed"}, + {"world": 18, "name": "Chaos Castle 1", "environment": "enclosed"}, + {"world": 19, "name": "Chaos Castle 2", "environment": "enclosed"}, + {"world": 20, "name": "Chaos Castle 3", "environment": "enclosed"}, + {"world": 21, "name": "Chaos Castle 4", "environment": "enclosed"}, + {"world": 22, "name": "Chaos Castle 5", "environment": "enclosed"}, + {"world": 23, "name": "Chaos Castle 6", "environment": "enclosed"}, + {"world": 24, "name": "Kalima 1", "environment": "fixed"}, + {"world": 25, "name": "Kalima 2", "environment": "fixed"}, + {"world": 26, "name": "Kalima 3", "environment": "fixed"}, + {"world": 27, "name": "Kalima 4", "environment": "fixed"}, + {"world": 28, "name": "Kalima 5", "environment": "fixed"}, + {"world": 29, "name": "Kalima 6", "environment": "fixed"}, + {"world": 30, "name": "Valley of Loren", "environment": "outdoor"}, + {"world": 31, "name": "Land of Trials", "environment": "outdoor"}, + {"world": 32, "name": "Devil Square", "environment": "enclosed"}, + {"world": 33, "name": "Aida", "environment": "outdoorDense"}, + {"world": 34, "name": "Crywolf", "environment": "outdoor"}, + {"world": 35, "name": "Crywolf", "environment": "outdoor"}, + {"world": 36, "name": "Lost Kalima", "environment": "fixed"}, + {"world": 37, "name": "Kanturu Ruins", "environment": "outdoorDense"}, + {"world": 38, "name": "Kanturu Relics", "environment": "enclosed"}, + {"world": 39, "name": "Refinery Tower", "environment": "enclosed"}, + {"world": 41, "name": "Barracks of Balgass", "environment": "fixed"}, + {"world": 42, "name": "Balgass Refuge", "environment": "enclosed"}, + {"world": 45, "name": "Illusion Temple 1", "environment": "enclosed"}, + {"world": 46, "name": "Illusion Temple 2", "environment": "enclosed"}, + {"world": 47, "name": "Illusion Temple 3", "environment": "enclosed"}, + {"world": 48, "name": "Illusion Temple 4", "environment": "enclosed"}, + {"world": 49, "name": "Illusion Temple 5", "environment": "enclosed"}, + {"world": 50, "name": "Illusion Temple 6", "environment": "enclosed"}, + {"world": 51, "name": "Elbeland", "environment": "outdoor"}, + {"world": 52, "name": "Blood Castle 8", "environment": "fixed"}, + {"world": 53, "name": "Chaos Castle 7", "environment": "enclosed"}, + {"world": 56, "name": "Swamp of Calmness", "environment": "outdoorDense"}, + {"world": 57, "name": "Raklion", "environment": "outdoorDense"}, + {"world": 58, "name": "Raklion boss cave", "environment": "enclosed"}, + {"world": 62, "name": "Santa Village", "environment": "fixed"}, + {"world": 63, "name": "Vulcanus", "environment": "outdoorDense"}, + {"world": 64, "name": "Duel Arena", "environment": "fixed"}, + {"world": 65, "name": "Doppelganger 1", "environment": "enclosed"}, + {"world": 66, "name": "Doppelganger 2", "environment": "enclosed"}, + {"world": 67, "name": "Doppelganger 3", "environment": "enclosed"}, + {"world": 68, "name": "Doppelganger 4", "environment": "enclosed"}, + {"world": 69, "name": "Imperial Guardian 1", "environment": "enclosed"}, + {"world": 70, "name": "Imperial Guardian 2", "environment": "enclosed"}, + {"world": 71, "name": "Imperial Guardian 3", "environment": "enclosed"}, + {"world": 72, "name": "Imperial Guardian 4", "environment": "enclosed"}, + {"world": 79, "name": "Loren Market", "environment": "outdoor"}, + {"world": 80, "name": "Karutan 1", "environment": "outdoor"}, + {"world": 81, "name": "Karutan 2", "environment": "outdoor"} ] } diff --git a/src/shaders/compiled/basic_textured_fog.frag.dxil b/src/shaders/compiled/basic_textured_fog.frag.dxil index 677543f6862989c2c05ac68502eefcea2b8aa368..94eddbb8f6ad4dee382aa430b24782999b5c16a8 100644 GIT binary patch delta 1089 zcma)5|4&+X6#YDWKA<8zwVNQaKAa$a7i*qttqzc(bF#2D(^@eBt)k8vr_Q#v&IeSa zT{S2gQP>8x-Q1TSG%PBnCL(UjB(`d8R)<>Kb=oZ5*33HFWJ~tkU$9?pa?d$A=O*{w zo8nC|M}AV4d-45}mm9fj_UC!0C&by(S_lBJ*~8%mi$^xo4ndzEzBG>$S9(Q8857bb~X|XUEV5Sl@utQ0au801I~P zsyA9CzL1sJ7!pyD_$nE&4C`$|T7k8PIs<*+K2FPm+6(Gxbk)r@^*WWdQG2Gcxw5e- z0*+zem^ry{0z(#f4(LgIvu&de_8p3DoNLafXmN6UM1E?!uHmbF?H)aSs zSU)PYeHQAsuyz_)yH1udhp{)x;u^FDiNlL%|LhD6vF=mu0~a@`7B=0gNw3^}<0awQB1NWD zw5jpQoO8#n%d^*f8rEF)-#(K>fHUI8!e>k}-b1}0hcMgJwgCIoYINw~@rkr4ay@z^ zX?bny@s^M#kFw-94cmvs11*1jt58&={PyI%?rvHcXJa5hUK8?tyTCF)T((&*58A3_ zjM|5cy7H0P@2Y;>>QxkNDKZ7LFD(x|_xgWWxH0Wf(#^ut=TcgRCk)q^oKO7G zr`RQf>O0&LPM{CO=bE--it)XoxXdCvQ}8sQ=YePO7jJ*C$1}auu|!%dD8m+AykGY{ zZ}hJVdXxzy-mj!@xJa|N2Du-rUs)*~;;ygt5rQdFb#?l#XNgQ#((5R0CWAsj<5ID# mN7T;`g{8#dvm2i4Zj6~q5&VzGHOIS~(F_Q3xW5RCp#BR{ptAb_ delta 1056 zcma)5?N1v87{6<~A;&z{r@Q<3KWz4jHYD^6coq$^OkeI>>3Ge!O74`QTCZ6E*ux39#>!XP04pd*JEPRgs108q`s_c#Ec zuRMkWEC*rz7#1(mO{`%80GOoD3K{oRZUdOK@K@XV)3)`K7g)Q$TYaotA5PD6?z<6D zJ}99$mIX6P_aL9sBVm1@gRX#IDJ(cXWaJK|T~wuYh{(h=ih~WnN1b5rIhdS@15{^# zE!Hu^}n?l+nREr zd598($WInmPF;Je=SQY$Wfh{%r}Cju5KF92gd-fNQ%mc3So$y*Hp!5hU!^rD8Kw15 zBoJWGOH{let2JNQ94V<)Cb0#UAj*--kD#ycCP1^hjGqs-7uFg-`0!l=(M+7JGuJhn zBv7It7qzG39uy8FIKk^#-+A&}2eRE>)mS(OgJno^Z0g&HH6)xPe^`C}XeyZ1N%|=xxf6sj~y_>4mqO;Xp zi@n{SBdl3i^~D*<%)%Y60qHE$bXGKlof-B{x21(C?kjFJF=$MErZ#Q4TBpI0k6&}3F~(s6 zTLb04XyqZo!L!JL#1n@rb?qf3WqL`+H&MC#2ctyXV^F@Om2VTbx+wV$q07V(es&PW zUknq(f1&-`tkx!fM(8GRBtjh=#&?0}CmYdEGym~7MNinOAELP5_M2djj3sXq&$=+V zzD8FX{d^%B%@X5-H|`8gZqCharSk8}jFt8;+DRVGPA3gfy}S!S#5rZ7k`0`o!D-F! zpW-1RI?^Q5DVaWEdiUicYIbXL9$Xld?FaOS=H17EfU7DZnx z{V$qZ>4ue!8_=XU{bz9oC@IJ76z=rlf{I}9@x!X6nc3B?K}h?Osvx#~T;=tSsyzyD zu|qI__u!?#O}z2AVHxwAx^LP6{g?E4bxC z)gJX&<`|p8t0+1&q)TA&@ln@!vP;3jE(MssmrG&lqwiT;icNhCBktG7stT@;c=FU^ zD%k5)_;A3j5^y+(=#SEdZ|(I_&h^v&TI=Egw_cdRN%hVgLXD diff --git a/src/shaders/compiled/skinned_lit.frag.dxil b/src/shaders/compiled/skinned_lit.frag.dxil index 4f03abe9341207ea8230ea1d1d097d1abd3f59f1..f778a5b4b15da9e1fe13f43e773b46316024f7e5 100644 GIT binary patch delta 8079 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 L?Kvngu>AZVJH5yg delta 6553 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 a)486(AThx=Ch*hM^5Uf*?;rrd`S(AAQB^Jg diff --git a/src/shaders/compiled/skinned_lit.frag.msl b/src/shaders/compiled/skinned_lit.frag.msl index 0c23be3275..43d7ba229b 100644 --- a/src/shaders/compiled/skinned_lit.frag.msl +++ b/src/shaders/compiled/skinned_lit.frag.msl @@ -1,10 +1,49 @@ #pragma clang diagnostic ignored "-Wmissing-prototypes" +#pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; +template +struct spvUnsafeArray +{ + T elements[Num ? Num : 1]; + + thread T& operator [] (size_t pos) thread + { + return elements[pos]; + } + constexpr const thread T& operator [] (size_t pos) const thread + { + return elements[pos]; + } + + device T& operator [] (size_t pos) device + { + return elements[pos]; + } + constexpr const device T& operator [] (size_t pos) const device + { + return elements[pos]; + } + + constexpr const constant T& operator [] (size_t pos) const constant + { + return elements[pos]; + } + + threadgroup T& operator [] (size_t pos) threadgroup + { + return elements[pos]; + } + constexpr const threadgroup T& operator [] (size_t pos) const threadgroup + { + return elements[pos]; + } +}; + struct FSInput { float4 pos; @@ -33,6 +72,7 @@ struct SceneLighting float4 cameraPosition; float4x4 sunViewProjection; float4 sunShadowParameters; + float4 lightingParameters; float4 cloudParameters; float4 cloudOffset; float4 skyFill; @@ -61,6 +101,8 @@ struct FogUniforms float4 fogColor; }; +constant spvUnsafeArray _276 = spvUnsafeArray({ float2(-0.3260000050067901611328125, -0.4059999883174896240234375), float2(-0.839999973773956298828125, -0.07400000095367431640625), float2(-0.69599997997283935546875, 0.4569999873638153076171875), float2(-0.20299999415874481201171875, 0.620999991893768310546875), float2(0.96200001239776611328125, -0.194999992847442626953125), float2(0.472999989986419677734375, -0.4799999892711639404296875), float2(0.518999993801116943359375, 0.767000019550323486328125), float2(0.185000002384185791015625, -0.89300000667572021484375), float2(0.507000029087066650390625, 0.064000003039836883544921875), float2(0.89600002765655517578125, 0.412000000476837158203125), float2(-0.3219999969005584716796875, -0.933000028133392333984375), float2(-0.791999995708465576171875, -0.597999989986419677734375) }); + struct main0_out { float4 _entryPointOutput [[color(0)]]; @@ -107,7 +149,8 @@ float SunVisibility(thread const float3& worldPosition, thread const float3& wor { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _83.sunShadowParameters.w)); + float slope = 1.0 - fast::clamp(dot(worldNormal, fast::normalize(_83.sunTowards.xyz)), 0.0, 1.0); + float3 lifted = worldPosition + (worldNormal * ((1.5 + (2.0 * slope)) * _83.sunShadowParameters.w)); float4 clip = _83.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); @@ -115,17 +158,20 @@ float SunVisibility(thread const float3& worldPosition, thread const float3& wor { return 1.0; } - float2 _step = _83.sunShadowParameters.zz * _83.sunShadowParameters.y; + float turn = 6.283185482025146484375 * fract(52.98291778564453125 * fract(dot(worldPosition.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))); + float2x2 rotation = float2x2(float2(cos(turn), -sin(turn)), float2(sin(turn), cos(turn))); + float radius = (_83.sunShadowParameters.z * fast::max(_83.sunShadowParameters.y, 0.25)) * 1.5; float visible = 0.0; - for (int y = -1; y <= 1; y++) + float total = 0.0; + for (int i = 0; i < 12; i++) { - for (int x = -1; x <= 1; x++) - { - float3 _223 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _223.xy, _223.z, level(0.0)); - } + float2 offset = _276[i] * rotation; + float weight = exp((-2.0) * dot(offset, offset)); + float3 _311 = float3(uv + (offset * radius), ndc.z); + visible += (weight * sunShadowMap.sample_compare(sunShadowSampler, _311.xy, _311.z, level(0.0))); + total += weight; } - return visible / 9.0; + return visible / total; } static inline __attribute__((always_inline)) @@ -176,13 +222,13 @@ float PointLightFalloff(thread const float3& toLight, thread const float& radius } static inline __attribute__((always_inline)) -float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _455) +float3 DynamicLighting(thread const float3& worldPosition, thread const float3& worldNormal, constant DynamicLights& _545) { float3 light = float3(0.0); - uint count = min(_455.dynamicLightCount, 32u); + uint count = min(_545.dynamicLightCount, 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _455.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _545.dynamicLightPositionAndRadius[i]; float3 toLight = positionAndRadius.xyz - worldPosition; float3 param = toLight; float param_1 = positionAndRadius.w; @@ -192,8 +238,8 @@ float3 DynamicLighting(thread const float3& worldPosition, thread const float3& continue; } float3 param_2 = toLight; - float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param_2)) * (1.0 - _455.dynamicLightWrap)) + _455.dynamicLightWrap, 0.0, 1.0); - light += (_455.dynamicLightColor[i].xyz * (falloff * wrapped)); + float wrapped = fast::clamp((dot(worldNormal, SafeNormalize(param_2)) * (1.0 - _545.dynamicLightWrap)) + _545.dynamicLightWrap, 0.0, 1.0); + light += (_545.dynamicLightColor[i].xyz * (falloff * wrapped)); } return light; } @@ -231,7 +277,7 @@ float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _8 } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _455, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _897) +float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _545, texture2d tex, sampler s, texture2d normalMap, sampler normalSampler, constant FogUniforms& _983) { float4 texel = tex.sample(s, _input.uv); float2 uvDx = dfdx(_input.uv); @@ -242,10 +288,10 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d< if ((normalMapScale > 0.0) && (_input.tangent.w != 0.0)) { float3 mapped = (normalMap.sample(normalSampler, _input.uv, gradient2d(uvDx, uvDy)).xyz * 2.0) - float3(1.0); - float3 _609 = mapped; - float2 _611 = _609.xy * normalMapScale; - mapped.x = _611.x; - mapped.y = _611.y; + float3 _698 = mapped; + float2 _700 = _698.xy * normalMapScale; + mapped.x = _700.x; + mapped.y = _700.y; float handedness = (_input.tangent.w > 0.0) ? 1.0 : (-1.0); float3 param = _input.normal; float3 param_1 = _input.tangent.xyz; @@ -276,15 +322,16 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d< float sunVisible = (inWorld && (_83.sunShadowParameters.x > 0.0)) ? (SunVisibility(param_11, param_12, _83, sunShadowMap, sunShadowSampler) * CloudLight(param_13, param_14, param_15)) : 1.0; float sunLight = 1.0 - (_83.sunShadowParameters.x * (1.0 - sunVisible)); float3 skyShade = mix(float3(1.0), _83.skyFill.xyz, float3(_83.skyFill.w * (1.0 - sunVisible))); - float luminosity = fast::max(((lightDot * _83.diffuseCurve.x) * sunLight) + _83.diffuseCurve.y, _83.diffuseCurve.z); + float luminosity = fast::max(((lightDot * _83.diffuseCurve.x) * ((lightDot > 0.0) ? sunLight : 1.0)) + _83.diffuseCurve.y, _83.diffuseCurve.z); float3 param_16 = _input.worldPositionAndDynamicLights.xyz; float3 param_17 = litNormal; - float3 dynamicLight = select(float3(0.0), DynamicLighting(param_16, param_17, _455), bool3(inWorld)); - float3 diffuse = fast::clamp(((objectLight * skyShade) * luminosity) + dynamicLight, float3(0.0), float3(1.0)); + float3 dynamicLight = select(float3(0.0), DynamicLighting(param_16, param_17, _545), bool3(inWorld)); + float3 lit = ((objectLight * skyShade) * luminosity) + dynamicLight; + float3 diffuse = fast::clamp(lit, float3(0.0), float3(1.0)); float param_18 = _83.diffuseCurve.w; if (RollsOffHighlight(param_18)) { - float3 param_19 = ((objectLight * skyShade) * luminosity) + dynamicLight; + float3 param_19 = lit; float param_20 = _83.diffuseCurve.w; diffuse = RollOffHighlight(param_19, param_20); } @@ -292,7 +339,7 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d< float3 rim = objectLight * (_83.rimParameters.x * powr(1.0 - facing, _83.rimParameters.y)); if (inWorld && (_83.sunTowards.w > 0.0)) { - float towardsSun = fast::clamp((dot(worldNormal, fast::normalize(_83.sunTowards.xyz)) * 0.75) + 0.25, 0.0, 1.0) * sunVisible; + float towardsSun = fast::clamp((dot(litNormal, fast::normalize(_83.sunTowards.xyz)) * 0.75) + 0.25, 0.0, 1.0) * sunVisible; rim = mix(rim, (rim * _83.sunColor.xyz) * (2.0 * towardsSun), float3(_83.sunTowards.w)); } float specularStrength = _input.lightDirectionAndSpecular.w * _83.specularParameters.x; @@ -306,9 +353,9 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d< specular = (_83.sceneLightColor.xyz * ((specularStrength * highlight) * sunLight)) * objectLight; } float4 color = float4(((texel.xyz * diffuse) + rim) + specular, texel.w * _input.color.w); - if (_897.alphaToCoverage != 0u) + if (_983.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _897.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _983.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -317,24 +364,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _83, depth2d< } else { - if ((_897.alphaDiscardEnabled != 0u) && (color.w <= _897.alphaThreshold)) + if ((_983.alphaDiscardEnabled != 0u) && (color.w <= _983.alphaThreshold)) { discard_fragment(); } } - if ((_897.fogEnabled != 0u) && (_83.sceneFogColor.w > 0.0)) + if ((_983.fogEnabled != 0u) && (_83.sceneFogColor.w > 0.0)) { - float4 _950 = color; + float4 _1036 = color; float param_23 = _input.eyeDepth; - float3 _960 = mix(_950.xyz, _83.sceneFogColor.xyz, float3(EnhancedFogAmount(param_23, _83))); - color.x = _960.x; - color.y = _960.y; - color.z = _960.z; + float3 _1046 = mix(_1036.xyz, _83.sceneFogColor.xyz, float3(EnhancedFogAmount(param_23, _83))); + color.x = _1046.x; + color.y = _1046.y; + color.z = _1046.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _897 [[buffer(0)]], constant SceneLighting& _83 [[buffer(1)]], constant DynamicLights& _455 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _983 [[buffer(0)]], constant SceneLighting& _83 [[buffer(1)]], constant DynamicLights& _545 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d normalMap [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler normalSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -351,8 +398,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _897 [[ _input.tangent = in.input_tangent; _input.worldTangentAndNormalMapScale = in.input_worldTangentAndNormalMapScale; FSInput param = _input; - float4 _1015 = _main(param, _83, sunShadowMap, sunShadowSampler, _455, tex, s, normalMap, normalSampler, _897); - out._entryPointOutput = _1015; + float4 _1101 = _main(param, _83, sunShadowMap, sunShadowSampler, _545, tex, s, normalMap, normalSampler, _983); + out._entryPointOutput = _1101; return out; } diff --git a/src/shaders/compiled/skinned_lit.frag.spv b/src/shaders/compiled/skinned_lit.frag.spv index 5ce11ceb8dcb8d3007162a8767687cb66abc9cf2..eedc75d07c894e412e832c9093cb3dae2e3fbb59 100644 GIT binary patch literal 27852 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

o&jst_ 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 GO#CmkF$A6f diff --git a/src/shaders/compiled/world_lit.frag.dxil b/src/shaders/compiled/world_lit.frag.dxil index 96d28af8e8438bd15dfc7cc92463ac0f2ad1e5a7..8e681ea7338b9adbd27d7bddc9afbbeaec585794 100644 GIT binary patch literal 12264 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 literal 10216 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 diff --git a/src/shaders/compiled/world_lit.frag.msl b/src/shaders/compiled/world_lit.frag.msl index a3b8e0be08..ed8a92a7f7 100644 --- a/src/shaders/compiled/world_lit.frag.msl +++ b/src/shaders/compiled/world_lit.frag.msl @@ -1,10 +1,49 @@ #pragma clang diagnostic ignored "-Wmissing-prototypes" +#pragma clang diagnostic ignored "-Wmissing-braces" #include #include using namespace metal; +template +struct spvUnsafeArray +{ + T elements[Num ? Num : 1]; + + thread T& operator [] (size_t pos) thread + { + return elements[pos]; + } + constexpr const thread T& operator [] (size_t pos) const thread + { + return elements[pos]; + } + + device T& operator [] (size_t pos) device + { + return elements[pos]; + } + constexpr const device T& operator [] (size_t pos) const device + { + return elements[pos]; + } + + constexpr const constant T& operator [] (size_t pos) const constant + { + return elements[pos]; + } + + threadgroup T& operator [] (size_t pos) threadgroup + { + return elements[pos]; + } + constexpr const threadgroup T& operator [] (size_t pos) const threadgroup + { + return elements[pos]; + } +}; + struct FSInput { float4 pos; @@ -27,6 +66,7 @@ struct SceneLighting float4 cameraPosition; float4x4 sunViewProjection; float4 sunShadowParameters; + float4 lightingParameters; float4 cloudParameters; float4 cloudOffset; float4 skyFill; @@ -55,6 +95,8 @@ struct FogUniforms float4 fogColor; }; +constant spvUnsafeArray _250 = spvUnsafeArray({ float2(-0.3260000050067901611328125, -0.4059999883174896240234375), float2(-0.839999973773956298828125, -0.07400000095367431640625), float2(-0.69599997997283935546875, 0.4569999873638153076171875), float2(-0.20299999415874481201171875, 0.620999991893768310546875), float2(0.96200001239776611328125, -0.194999992847442626953125), float2(0.472999989986419677734375, -0.4799999892711639404296875), float2(0.518999993801116943359375, 0.767000019550323486328125), float2(0.185000002384185791015625, -0.89300000667572021484375), float2(0.507000029087066650390625, 0.064000003039836883544921875), float2(0.89600002765655517578125, 0.412000000476837158203125), float2(-0.3219999969005584716796875, -0.933000028133392333984375), float2(-0.791999995708465576171875, -0.597999989986419677734375) }); + struct main0_out { float4 _entryPointOutput [[color(0)]]; @@ -76,7 +118,8 @@ float SunVisibility(thread const float3& worldPosition, thread const float3& wor { return 1.0; } - float3 lifted = worldPosition + (worldNormal * (1.5 * _56.sunShadowParameters.w)); + float slope = 1.0 - fast::clamp(dot(worldNormal, fast::normalize(_56.sunTowards.xyz)), 0.0, 1.0); + float3 lifted = worldPosition + (worldNormal * ((1.5 + (2.0 * slope)) * _56.sunShadowParameters.w)); float4 clip = _56.sunViewProjection * float4(lifted, 1.0); float3 ndc = clip.xyz / float3(clip.w); float2 uv = float2((ndc.x * 0.5) + 0.5, 0.5 - (ndc.y * 0.5)); @@ -84,17 +127,20 @@ float SunVisibility(thread const float3& worldPosition, thread const float3& wor { return 1.0; } - float2 _step = _56.sunShadowParameters.zz * _56.sunShadowParameters.y; + float turn = 6.283185482025146484375 * fract(52.98291778564453125 * fract(dot(worldPosition.xy, float2(0.067110560834407806396484375, 0.005837149918079376220703125)))); + float2x2 rotation = float2x2(float2(cos(turn), -sin(turn)), float2(sin(turn), cos(turn))); + float radius = (_56.sunShadowParameters.z * fast::max(_56.sunShadowParameters.y, 0.25)) * 1.5; float visible = 0.0; - for (int y = -1; y <= 1; y++) + float total = 0.0; + for (int i = 0; i < 12; i++) { - for (int x = -1; x <= 1; x++) - { - float3 _197 = float3(uv + (float2(float(x), float(y)) * _step), ndc.z); - visible += sunShadowMap.sample_compare(sunShadowSampler, _197.xy, _197.z, level(0.0)); - } + float2 offset = _250[i] * rotation; + float weight = exp((-2.0) * dot(offset, offset)); + float3 _285 = float3(uv + (offset * radius), ndc.z); + visible += (weight * sunShadowMap.sample_compare(sunShadowSampler, _285.xy, _285.z, level(0.0))); + total += weight; } - return visible / 9.0; + return visible / total; } static inline __attribute__((always_inline)) @@ -145,16 +191,16 @@ float PointLightFalloff(thread const float3& toLight, thread const float& radius } static inline __attribute__((always_inline)) -float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _359) +float3 WorldDynamicLighting(thread const float3& worldPosition, constant DynamicLights& _449) { float3 light = float3(0.0); - uint count = min(min(_359.dynamicWorldLightCount, _359.dynamicLightCount), 32u); + uint count = min(min(_449.dynamicWorldLightCount, _449.dynamicLightCount), 32u); for (uint i = 0u; i < count; i++) { - float4 positionAndRadius = _359.dynamicLightPositionAndRadius[i]; + float4 positionAndRadius = _449.dynamicLightPositionAndRadius[i]; float3 param = positionAndRadius.xyz - worldPosition; float param_1 = positionAndRadius.w; - light += (_359.dynamicLightColor[i].xyz * PointLightFalloff(param, param_1)); + light += (_449.dynamicLightColor[i].xyz * PointLightFalloff(param, param_1)); } return light; } @@ -167,28 +213,38 @@ float EnhancedFogAmount(thread const float& eyeDepth, constant SceneLighting& _5 } static inline __attribute__((always_inline)) -float4 _main(thread const FSInput& _input, constant SceneLighting& _56, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _359, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, constant FogUniforms& _540) +float4 _main(thread const FSInput& _input, constant SceneLighting& _56, depth2d sunShadowMap, sampler sunShadowSampler, constant DynamicLights& _449, texture2d tex, sampler s, texture2d groundShadowMask, sampler groundShadowSampler, texture2d terrainSunLight, sampler terrainSunSampler, constant FogUniforms& _678) { float4 texel = tex.sample(s, _input.uv); uint2 sizeQueryTemp = uint2(groundShadowMask.get_width(), groundShadowMask.get_height()); uint maskWidth = sizeQueryTemp.x; uint maskHeight = sizeQueryTemp.y; float2 visibility = groundShadowMask.sample(groundShadowSampler, (_input.pos.xy / float2(float(maskWidth), float(maskHeight)))).xy; - float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _359.groundShadowOpacity); + float2 shadow = float2(1.0) - ((float2(1.0) - visibility) * _449.groundShadowOpacity); + bool sunShadows = _56.sunShadowParameters.x > 0.0; float3 param = _input.worldPosition; float3 param_1 = float3(0.0, 0.0, 1.0); + float sunVisible = sunShadows ? SunVisibility(param, param_1, _56, sunShadowMap, sunShadowSampler) : 1.0; + shadow.x *= (1.0 - (_56.sunShadowParameters.x * (1.0 - sunVisible))); float2 param_2 = _input.worldPosition.xy; float4 param_3 = _56.cloudParameters; float2 param_4 = _56.cloudOffset.xy; - float sunVisible = (_56.sunShadowParameters.x > 0.0) ? (SunVisibility(param, param_1, _56, sunShadowMap, sunShadowSampler) * CloudLight(param_2, param_3, param_4)) : 1.0; - shadow.x *= (1.0 - (_56.sunShadowParameters.x * (1.0 - sunVisible))); - float3 skyShade = mix(float3(1.0), _56.skyFill.xyz, float3(_56.skyFill.w * (1.0 - sunVisible))); + float cloud = sunShadows ? CloudLight(param_2, param_3, param_4) : 1.0; + float3 ground = _input.color.xyz * shadow.x; + if ((cloud < 1.0) && (_56.lightingParameters.y > 0.0)) + { + float2 cellUv = ((_input.worldPosition.xy / float2(100.0)) + float2(0.5)) / float2(256.0); + float3 direct = terrainSunLight.sample(terrainSunSampler, cellUv).xyz; + ground = fast::max(ground - ((direct * sunVisible) * (1.0 - cloud)), float3(0.0)); + } + float3 skyShade = mix(float3(1.0), _56.skyFill.xyz, float3(_56.skyFill.w * (1.0 - (sunVisible * cloud)))); float3 param_5 = _input.worldPosition; - float3 light = fast::clamp(((_input.color.xyz * skyShade) * shadow.x) + (WorldDynamicLighting(param_5, _359) * shadow.y), float3(0.0), float3(1.0)); + float3 pointLight = WorldDynamicLighting(param_5, _449) * shadow.y; + float3 light = fast::clamp((ground * skyShade) + pointLight, float3(0.0), float3(1.0)); float4 color = float4(texel.xyz * light, texel.w * _input.color.w); - if (_540.alphaToCoverage != 0u) + if (_678.alphaToCoverage != 0u) { - float edge = fast::clamp(((color.w - _540.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); + float edge = fast::clamp(((color.w - _678.alphaThreshold) / fast::max(fwidth(color.w), 9.9999997473787516355514526367188e-05)) + 0.5, 0.0, 1.0); color.w *= edge; if (color.w <= 0.0) { @@ -197,24 +253,24 @@ float4 _main(thread const FSInput& _input, constant SceneLighting& _56, depth2d< } else { - if ((_540.alphaDiscardEnabled != 0u) && (color.w <= _540.alphaThreshold)) + if ((_678.alphaDiscardEnabled != 0u) && (color.w <= _678.alphaThreshold)) { discard_fragment(); } } - if ((_540.fogEnabled != 0u) && (_56.sceneFogColor.w > 0.0)) + if ((_678.fogEnabled != 0u) && (_56.sceneFogColor.w > 0.0)) { - float4 _593 = color; + float4 _731 = color; float param_6 = _input.eyeDepth; - float3 _603 = mix(_593.xyz, _56.sceneFogColor.xyz, float3(EnhancedFogAmount(param_6, _56))); - color.x = _603.x; - color.y = _603.y; - color.z = _603.z; + float3 _741 = mix(_731.xyz, _56.sceneFogColor.xyz, float3(EnhancedFogAmount(param_6, _56))); + color.x = _741.x; + color.y = _741.y; + color.z = _741.z; } return color; } -fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _540 [[buffer(0)]], constant SceneLighting& _56 [[buffer(1)]], constant DynamicLights& _359 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], float4 gl_FragCoord [[position]]) +fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _678 [[buffer(0)]], constant SceneLighting& _56 [[buffer(1)]], constant DynamicLights& _449 [[buffer(2)]], texture2d tex [[texture(0)]], texture2d groundShadowMask [[texture(1)]], depth2d sunShadowMap [[texture(2)]], texture2d terrainSunLight [[texture(3)]], sampler s [[sampler(0)]], sampler groundShadowSampler [[sampler(1)]], sampler sunShadowSampler [[sampler(2)]], sampler terrainSunSampler [[sampler(3)]], float4 gl_FragCoord [[position]]) { main0_out out = {}; FSInput _input; @@ -225,8 +281,8 @@ fragment main0_out main0(main0_in in [[stage_in]], constant FogUniforms& _540 [[ _input.eyeDepth = in.input_eyeDepth; _input.worldPosition = in.input_worldPosition; FSInput param = _input; - float4 _640 = _main(param, _56, sunShadowMap, sunShadowSampler, _359, tex, s, groundShadowMask, groundShadowSampler, _540); - out._entryPointOutput = _640; + float4 _778 = _main(param, _56, sunShadowMap, sunShadowSampler, _449, tex, s, groundShadowMask, groundShadowSampler, terrainSunLight, terrainSunSampler, _678); + out._entryPointOutput = _778; return out; } diff --git a/src/shaders/compiled/world_lit.frag.spv b/src/shaders/compiled/world_lit.frag.spv index bd7435bc065585a9636471137e6b15d3066b90fb..a322813d377f453f66f5bc6eb24333c383987898 100644 GIT binary patch literal 19580 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 K-AwH7X8#AI8YU0` literal 16448 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 RGRE~Jurd5xF7|Wz{{iPUg;)Rp diff --git a/src/shaders/dynamic_lighting.hlsli b/src/shaders/dynamic_lighting.hlsli index 701e600398..8626deb46f 100644 --- a/src/shaders/dynamic_lighting.hlsli +++ b/src/shaders/dynamic_lighting.hlsli @@ -14,29 +14,44 @@ cbuffer DynamicLights : register(b2, space3) float4 dynamicLightColor[MaxDynamicLights]; }; +// Twelve points spread evenly over the unit disc (a Poisson disc). +static const float2 SunShadowDisc[12] = { + float2(-0.326, -0.406), float2(-0.840, -0.074), float2(-0.696, 0.457), float2(-0.203, 0.621), + float2(0.962, -0.195), float2(0.473, -0.480), float2(0.519, 0.767), float2(0.185, -0.893), + float2(0.507, 0.064), float2(0.896, 0.412), float2(-0.322, -0.933), float2(-0.792, -0.598), +}; + // How much sun reaches `worldPosition` (Enhanced sun shadows): 1 lit, 0 in the shadow of what stands // between it and the sun, softened over sunShadowParameters.y texels. 1 without a shadow map or -// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself. +// outside it. `worldNormal` pushes the lookup off the surface so that it does not shadow itself, +// further on faces turned away from the sun, where a texel covers more of the surface. float SunVisibility(float3 worldPosition, float3 worldNormal) { if (sunShadowParameters.x <= 0.0) return 1.0; - const float3 lifted = worldPosition + worldNormal * (1.5 * sunShadowParameters.w); + const float slope = 1.0 - saturate(dot(worldNormal, normalize(sunTowards.xyz))); + const float3 lifted = worldPosition + worldNormal * ((1.5 + 2.0 * slope) * sunShadowParameters.w); const float4 clip = mul(sunViewProjection, float4(lifted, 1.0)); const float3 ndc = clip.xyz / clip.w; const float2 uv = float2(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5); if (any(uv < 0.0) || any(uv > 1.0) || ndc.z >= 1.0) return 1.0; - const float2 step = sunShadowParameters.zz * sunShadowParameters.y; + // The disc turned by a per-place angle, so the samples' pattern becomes fine noise instead of + // bands; nearer samples weigh more (Gaussian). + const float turn = 6.2831853 * frac(52.9829189 * frac(dot(worldPosition.xy, float2(0.06711056, 0.00583715)))); + const float2x2 rotation = float2x2(cos(turn), -sin(turn), sin(turn), cos(turn)); + const float radius = sunShadowParameters.z * max(sunShadowParameters.y, 0.25) * 1.5; float visible = 0.0; + float total = 0.0; [unroll] - for (int y = -1; y <= 1; ++y) + for (int i = 0; i < 12; ++i) { - [unroll] - for (int x = -1; x <= 1; ++x) - visible += sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + float2(x, y) * step, ndc.z); + const float2 offset = mul(rotation, SunShadowDisc[i]); + const float weight = exp(-2.0 * dot(offset, offset)); + visible += weight * sunShadowMap.SampleCmpLevelZero(sunShadowSampler, uv + offset * radius, ndc.z); + total += weight; } - return visible / 9.0; + return visible / total; } // How much of a point light reaches a point `toLight` away from it: the terrain light's linear fade diff --git a/src/shaders/scene_lighting.hlsli b/src/shaders/scene_lighting.hlsli index 45d6225ea3..efe437ff96 100644 --- a/src/shaders/scene_lighting.hlsli +++ b/src/shaders/scene_lighting.hlsli @@ -24,6 +24,7 @@ cbuffer SceneLighting : register(b1, space3) float4 cameraPosition; float4x4 sunViewProjection; // world to the sun shadow map's clip space float4 sunShadowParameters; // darkness (0: no shadow map), softness in texels, 1 / map size, texel in world units + float4 lightingParameters; // y: 1 when the terrain's direct-sunlight grid is bound; x, z, w unused float4 cloudParameters; // x: cloud strength (0: none), y: 1 / pattern size, z: sky cover float4 cloudOffset; // xy: the clouds' drift plus the sun's slant float4 skyFill; // rgb: the sky's tint of the shade, w: how far shade takes it diff --git a/src/shaders/skinned_lit.frag.hlsl b/src/shaders/skinned_lit.frag.hlsl index cc7a016718..ee51477b2d 100644 --- a/src/shaders/skinned_lit.frag.hlsl +++ b/src/shaders/skinned_lit.frag.hlsl @@ -141,12 +141,15 @@ float4 main(FSInput input) : SV_Target const float sunLight = 1.0 - sunShadowParameters.x * (1.0 - sunVisible); // Shade turns towards the sky's blue. const float3 skyShade = lerp(float3(1.0, 1.0, 1.0), skyFill.rgb, skyFill.w * (1.0 - sunVisible)); - const float luminosity = max(lightDot * diffuseCurve.x * sunLight + diffuseCurve.y, diffuseCurve.z); + // Shadow dims the light a face receives, never the darkening of faces turned away. + const float luminosity = + max(lightDot * diffuseCurve.x * (lightDot > 0.0 ? sunLight : 1.0) + diffuseCurve.y, diffuseCurve.z); const float3 dynamicLight = inWorld ? DynamicLighting(input.worldPositionAndDynamicLights.xyz, litNormal) : float3(0.0, 0.0, 0.0); - float3 diffuse = saturate(objectLight * skyShade * luminosity + dynamicLight); + const float3 lit = objectLight * skyShade * luminosity + dynamicLight; + float3 diffuse = saturate(lit); if (RollsOffHighlight(diffuseCurve.w)) - diffuse = RollOffHighlight(objectLight * skyShade * luminosity + dynamicLight, diffuseCurve.w); + diffuse = RollOffHighlight(lit, diffuseCurve.w); // Two-sided meshes show back faces; |dot| keeps their interiors from rim-lighting. const float facing = saturate(abs(dot(normal, view))); @@ -154,7 +157,7 @@ float4 main(FSInput input) : SV_Target if (inWorld && sunTowards.w > 0.0) { // The rim follows the sun: brighter and sun-coloured on the side facing it, gone in its shadow. - const float towardsSun = saturate(dot(worldNormal, normalize(sunTowards.xyz)) * 0.75 + 0.25) * sunVisible; + const float towardsSun = saturate(dot(litNormal, normalize(sunTowards.xyz)) * 0.75 + 0.25) * sunVisible; rim = lerp(rim, rim * sunColor.rgb * (2.0 * towardsSun), sunTowards.w); } diff --git a/src/shaders/world_lit.frag.hlsl b/src/shaders/world_lit.frag.hlsl index f87e7558e9..28843cd943 100644 --- a/src/shaders/world_lit.frag.hlsl +++ b/src/shaders/world_lit.frag.hlsl @@ -14,6 +14,10 @@ SamplerComparisonState sunShadowSampler : register(s2, space2); // without shadows). Texture2D groundShadowMask : register(t1, space2); SamplerState groundShadowSampler : register(s1, space2); +// Per terrain cell, the direct sunlight inside the vertex colour (the rest is the painted ambient light +// and point lights): what a cloud's shadow takes away. Used while lightingParameters.y is 1. +Texture2D terrainSunLight : register(t3, space2); +SamplerState terrainSunSampler : register(s3, space2); #include "scene_lighting.hlsli" #include "dynamic_lighting.hlsli" #include "clouds.hlsli" @@ -53,15 +57,23 @@ float4 main(FSInput input) : SV_Target groundShadowMask.Sample(groundShadowSampler, input.pos.xy / float2(maskWidth, maskHeight)).rg; // The sun's shadows dim the ground's own light, the point lights' shadows the point lights. float2 shadow = 1.0 - groundShadowOpacity * (1.0 - visibility); - // Clouds dim the sunlight as shadows do; shade, from either, turns towards the sky's blue. - const float sunVisible = sunShadowParameters.x > 0.0 - ? SunVisibility(input.worldPosition, float3(0.0, 0.0, 1.0)) * - CloudLight(input.worldPosition.xy, cloudParameters, cloudOffset.xy) - : 1.0; + const bool sunShadows = sunShadowParameters.x > 0.0; + const float sunVisible = sunShadows ? SunVisibility(input.worldPosition, float3(0.0, 0.0, 1.0)) : 1.0; shadow.x *= 1.0 - sunShadowParameters.x * (1.0 - sunVisible); - const float3 skyShade = lerp(float3(1.0, 1.0, 1.0), skyFill.rgb, skyFill.w * (1.0 - sunVisible)); - const float3 light = - saturate(input.color.rgb * skyShade * shadow.x + WorldDynamicLighting(input.worldPosition) * shadow.y); + // A cloud takes away direct sunlight only, where the sun reaches. + const float cloud = sunShadows ? CloudLight(input.worldPosition.xy, cloudParameters, cloudOffset.xy) : 1.0; + float3 ground = input.color.rgb * shadow.x; + if (cloud < 1.0 && lightingParameters.y > 0.0) + { + // Cell centres: the terrain's 256 cells of 100 world units (TERRAIN_SIZE, TERRAIN_SCALE). + const float2 cellUv = (input.worldPosition.xy / 100.0 + 0.5) / 256.0; + const float3 direct = terrainSunLight.Sample(terrainSunSampler, cellUv).rgb; + ground = max(ground - direct * sunVisible * (1.0 - cloud), 0.0); + } + // Shade, from shadows and clouds, turns towards the sky's blue. + const float3 skyShade = lerp(float3(1.0, 1.0, 1.0), skyFill.rgb, skyFill.w * (1.0 - sunVisible * cloud)); + const float3 pointLight = WorldDynamicLighting(input.worldPosition) * shadow.y; + const float3 light = saturate(ground * skyShade + pointLight); float4 color = float4(texel.rgb * light, texel.a * input.color.a); if (alphaToCoverage) { diff --git a/src/source/Data/GameData/MapData/LookProfile.cpp b/src/source/Data/GameData/MapData/LookProfile.cpp index 397eb8f1ed..a8858bf6d0 100644 --- a/src/source/Data/GameData/MapData/LookProfile.cpp +++ b/src/source/Data/GameData/MapData/LookProfile.cpp @@ -22,6 +22,8 @@ constexpr const char* DefaultKey = "default"; constexpr const char* MapsKey = "maps"; constexpr const char* WorldKey = "world"; constexpr const char* NameKey = "name"; +constexpr const char* EnvironmentsKey = "environments"; +constexpr const char* EnvironmentKey = "environment"; // The built-in values are the renderer's behaviour before the profile existed; a doctest checks // each against the constant it replaces. @@ -155,7 +157,7 @@ bool CheckRootKeys(const OrderedJson& root, IssueList& issues) bool valid = true; for (const auto& [key, value] : root.items()) { - if (key != Items::Json::Keys::FormatVersion && key != DefaultKey && key != MapsKey) + if (key != Items::Json::Keys::FormatVersion && key != DefaultKey && key != MapsKey && key != EnvironmentsKey) { issues.Fatal(key, "unknown field"); valid = false; @@ -179,6 +181,35 @@ bool ReadDefault(const OrderedJson& root, LookOverrides& overrides, IssueList& i return ReadOverrides(*json, DefaultKey, {}, overrides, issues); } +bool ReadEnvironments(const OrderedJson& root, LookProfileData& data, IssueList& issues) +{ + const auto json = root.find(EnvironmentsKey); + if (json == root.end()) + { + return true; + } + if (!json->is_object()) + { + issues.Fatal(EnvironmentsKey, "must be an object of named environments"); + return false; + } + bool valid = true; + for (const auto& [name, values] : json->items()) + { + const std::string object = Field(EnvironmentsKey, name); + if (!values.is_object()) + { + issues.Fatal(object, "must be an object of look values"); + valid = false; + continue; + } + EnvironmentLookOverrides environment{name, {}}; + valid = ReadOverrides(values, object, {}, environment.overrides, issues) && valid; + data.environments.push_back(std::move(environment)); + } + return valid; +} + bool ReadWorld(const OrderedJson& json, const std::string& object, int& world, IssueList& issues) { const auto field = json.find(WorldKey); @@ -219,7 +250,21 @@ bool ReadMap(const OrderedJson& json, size_t index, std::set& worlds, LookP issues.Fatal(Field(object, NameKey), "must be text"); return false; } - if (!ReadOverrides(json, object, {WorldKey, NameKey}, map.overrides, issues)) + if (const auto environment = json.find(EnvironmentKey); environment != json.end()) + { + const auto known = environment->is_string() + ? std::find_if(data.environments.begin(), data.environments.end(), + [&environment](const EnvironmentLookOverrides& entry) + { return entry.name == environment->get(); }) + : data.environments.end(); + if (known == data.environments.end()) + { + issues.Fatal(Field(object, EnvironmentKey), "must name one of \"environments\""); + return false; + } + map.environment = static_cast(known - data.environments.begin()); + } + if (!ReadOverrides(json, object, {WorldKey, NameKey, EnvironmentKey}, map.overrides, issues)) { return false; } @@ -291,14 +336,23 @@ LookValues BuiltInLookValues() return builtIn; } +const MapLookOverrides* LookProfileData::FindMap(int world) const +{ + const auto map = + std::find_if(maps.begin(), maps.end(), [world](const MapLookOverrides& entry) { return entry.world == world; }); + return map != maps.end() ? &*map : nullptr; +} + LookValues LookProfileData::ForWorld(int world) const { LookValues values = BuiltInLookValues(); defaultOverrides.ApplyTo(values); - const auto map = - std::find_if(maps.begin(), maps.end(), [world](const MapLookOverrides& entry) { return entry.world == world; }); - if (map != maps.end()) + if (const MapLookOverrides* map = FindMap(world)) { + if (map->environment && *map->environment < environments.size()) + { + environments[*map->environment].overrides.ApplyTo(values); + } map->overrides.ApplyTo(values); } return values; @@ -319,8 +373,10 @@ void ReadLookProfileJson(std::string_view text, const std::string& source, LookP // Non-short-circuit: every problem of the file is reported. const bool keys = CheckRootKeys(root, list); const bool defaults = ReadDefault(root, read.defaultOverrides, list); + // Before the maps, which name them. + const bool environments = ReadEnvironments(root, read, list); const bool maps = ReadMaps(root, read, list); - if (keys && defaults && maps) + if (keys && defaults && environments && maps) { data = std::move(read); } diff --git a/src/source/Data/GameData/MapData/LookProfile.h b/src/source/Data/GameData/MapData/LookProfile.h index fd4102e09d..c7b0bdfe78 100644 --- a/src/source/Data/GameData/MapData/LookProfile.h +++ b/src/source/Data/GameData/MapData/LookProfile.h @@ -15,15 +15,19 @@ // // { "formatVersion": 1, // "default": { "lighting.rim.strength": 0.35, "bloom.strength": 0.6 }, -// "maps": [ { "world": 1, "name": "Dungeon", "grading.strength": 0.8 } ] } +// "environments": { "enclosed": { "sun.shadow": 0 } }, +// "maps": [ { "world": 1, "name": "Dungeon", "environment": "enclosed", "grading.strength": 0.8 } ] } // // Every value has a built-in value (the renderer's behaviour without the file) // and a range. The values apply in the order built-in, "default", the map's -// entry; either may name any subset of them. "world" is the map number as in -// LightMood.json, "name" is for the reader only. A file with an unknown name, a -// value of the wrong type or out of range, a missing or unsupported -// formatVersion, a duplicate world or a world outside 0 to 255 is unusable as a -// whole: the built-in values apply everywhere. +// environment, the map's entry; each may name any subset of them. "world" is +// the map number as in LightMood.json, "name" is for the reader only. +// "environment" names one of "environments": the kind of place a map is. +// +// A file with an unknown name, a value of the wrong type or out of range, a +// missing or unsupported formatVersion, a duplicate world, a world outside 0 to +// 255 or an unknown environment is unusable as a whole: the built-in values +// apply everywhere. namespace Data::Maps { enum class LookValue : std::uint8_t @@ -120,9 +124,19 @@ struct LookOverrides bool operator==(const LookOverrides&) const = default; }; +struct EnvironmentLookOverrides +{ + std::string name; + LookOverrides overrides; + + bool operator==(const EnvironmentLookOverrides&) const = default; +}; + struct MapLookOverrides { int world = 0; + // Index into LookProfileData::environments. + std::optional environment; LookOverrides overrides; bool operator==(const MapLookOverrides&) const = default; @@ -131,10 +145,12 @@ struct MapLookOverrides struct LookProfileData { LookOverrides defaultOverrides; + std::vector environments; std::vector maps; - // Built-in, then the default, then the world's entry. + // Built-in, then the default, the world's environment and the world's entry. [[nodiscard]] LookValues ForWorld(int world) const; + [[nodiscard]] const MapLookOverrides* FindMap(int world) const; bool operator==(const LookProfileData&) const = default; }; diff --git a/src/source/Render/Lighting/LightMoodSetting.cpp b/src/source/Render/Lighting/LightMoodSetting.cpp index 8d6cfd9c4c..b01fabe3c3 100644 --- a/src/source/Render/Lighting/LightMoodSetting.cpp +++ b/src/source/Render/Lighting/LightMoodSetting.cpp @@ -5,6 +5,7 @@ #include "Core/Utilities/Log/MuLogger.h" #include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Look/LookProfileSetting.h" +#include "Render/Renderer/MuRenderer.h" #include "Render/Terrain/ZzzLodTerrain.h" #include "World/MapInfra/MapManager.h" @@ -29,6 +30,8 @@ struct State int world = NoWorld; std::uint32_t lookRevision = 0; Scales scales; + // Bumped whenever the scales change: the static light built with older ones is stale. + std::uint32_t revision = 0; }; State s_state; @@ -53,18 +56,24 @@ void LogScales(const char* event) void Recompute(int world) { + const Scales previous = s_state.scales; s_state.world = world; s_state.lookRevision = Look::Revision(); s_state.scales = s_state.enabled && IsWorldMap(world) ? Blend(s_state.data.ForWorld(world), s_state.strength, Look::Value(Data::Maps::LookValue::HighlightKnee)) : Scales{}; - // Under a sun that casts shadows the sky fill tints the shade (the lit shaders): no second blue here. + // Where the sky fill tints the shade (the lit shaders, under sun shadows the renderer can draw), no + // second blue here. if (s_state.enabled && IsWorldMap(world) && DynamicLightsActive() && - Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0f && + Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0f && mu::GetRenderer().SunShadowsAvailable() && Look::Value(Data::Maps::LookValue::SkyFill) > 0.0f) { s_state.scales.shadeCool = 0.f; } + if (!(s_state.scales == previous)) + { + ++s_state.revision; + } } void RebuildStaticLight() @@ -143,4 +152,10 @@ void ScaleOwnHeroLight(float x, float y, const float classicLight[3], float ligh scales.shadowKeep > 0.f ? RequestStaticLightBrightWeight(x, y) : 0.f); } +std::uint32_t Revision() +{ + (void)Active(); + return s_state.revision; +} + } // namespace Render::Lighting::LightMood diff --git a/src/source/Render/Lighting/LightMoodSetting.h b/src/source/Render/Lighting/LightMoodSetting.h index 68bb2222ef..2947f77112 100644 --- a/src/source/Render/Lighting/LightMoodSetting.h +++ b/src/source/Render/Lighting/LightMoodSetting.h @@ -24,6 +24,10 @@ void UseMood(Data::Maps::LightMoodData data, bool enabled, int strengthPercent); // outside the world maps (login and character selection). const Scales& Active(); +// Changes whenever the active scales do (look values, the tint source): the map's static light built with +// an older one is stale. +[[nodiscard]] std::uint32_t Revision(); + // Logs the scales a map's static light was built with (map load and reload). void LogMapLight(); diff --git a/src/source/Render/Lighting/ModelLight.cpp b/src/source/Render/Lighting/ModelLight.cpp index 077f280b0a..a95ecc943a 100644 --- a/src/source/Render/Lighting/ModelLight.cpp +++ b/src/source/Render/Lighting/ModelLight.cpp @@ -5,6 +5,8 @@ #include "Core/Math/ZzzMathLib.h" #include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Lighting/LightMoodSetting.h" +#include "Render/Renderer/MuRenderer.h" +#include "Scenes/SceneCore.h" #include "World/MapInfra/MapManager.h" namespace Render::Lighting @@ -35,7 +37,13 @@ glm::vec3 ModelLightVector(bool highlight) vec3_t light; VectorIRotate(position, matrix, light); const glm::vec3 vector(light[0], light[1], light[2]); - return highlight ? vector : FollowFrameSun(vector); + // Models shown in the UI keep their light; in the world it follows the frame's sun. (The game draws + // every model with the highlight light.) + if (!FrameSun() || SceneFlag != MAIN_SCENE || mu::GetRenderer().InScreenSpaceSampling()) + { + return vector; + } + return FollowFrameSun(vector); } } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/ModelLight.h b/src/source/Render/Lighting/ModelLight.h index a90508428b..38162d6f91 100644 --- a/src/source/Render/Lighting/ModelLight.h +++ b/src/source/Render/Lighting/ModelLight.h @@ -8,9 +8,9 @@ namespace Render::Lighting // World-space vector towards the models' light; its length is the directional part's strength // (Classic lights a face max(0.8 × dot(n, L) + 0.4, 0.2) with it), so the normals it meets must be -// world-oriented. `highlight`: the brighter fixed light of previews (BMD::HighLight). Otherwise the -// map's baked direction, scaled by the light mood's sun and, with Enhanced dynamic lights, following -// the frame's sun (FollowFrameSun). +// world-oriented. `highlight`: the brighter light (BMD::HighLight, which the game always sets), otherwise +// the map's baked direction; scaled by the light mood's sun. With Enhanced dynamic lights, models in the +// world follow the frame's sun (FollowFrameSun); models shown in the UI keep theirs. [[nodiscard]] glm::vec3 ModelLightVector(bool highlight); } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/SunShadow.cpp b/src/source/Render/Lighting/SunShadow.cpp index a2c8e42cc8..3ee996d20a 100644 --- a/src/source/Render/Lighting/SunShadow.cpp +++ b/src/source/Render/Lighting/SunShadow.cpp @@ -98,4 +98,15 @@ SunShadowView BuildSunShadowView(const glm::vec3& toSun, const glm::mat4& sceneV return view; } +FlatShadowCast FlatShadowFromSun(const glm::vec3& toSun, float maxFall) +{ + const float horizontal = std::hypot(toSun.x, toSun.y); + if (horizontal <= 0.0f) + { + return {0.0f, 0.0f}; + } + const float fall = toSun.z > 0.0f ? std::min(horizontal / toSun.z, maxFall) : maxFall; + return {std::atan2(toSun.y, toSun.x), fall}; +} + } // namespace Render::Lighting diff --git a/src/source/Render/Lighting/SunShadow.h b/src/source/Render/Lighting/SunShadow.h index e70719cfc4..453a678b4d 100644 --- a/src/source/Render/Lighting/SunShadow.h +++ b/src/source/Render/Lighting/SunShadow.h @@ -29,6 +29,16 @@ inline constexpr float kBakedSunShadowAngle = 135.0f; // `bakedSun`, so the maps keep their look at the baked angle. [[nodiscard]] glm::vec3 FollowSun(const glm::vec3& baked, const glm::vec3& bakedSun, const glm::vec3& sun); +// A flat (sheared) shadow cast by a light towards `toSun`: the projection's axis angle in radians +// (mu::ShadowProjection::axisAngle, the shadow's direction plus a half turn) and how far it falls per +// unit of height, at most `maxFall`. +struct FlatShadowCast +{ + float axisAngle = 0.0f; + float fallPerHeight = 0.0f; +}; +[[nodiscard]] FlatShadowCast FlatShadowFromSun(const glm::vec3& toSun, float maxFall); + // The square, texel-snapped area of the shadow map: light-space x and y from `origin`, `size` wide, // depth from `nearDistance` to `farDistance` along the sun's rays. struct SunShadowBox diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index ad71e0d373..69c60712fa 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -52,6 +52,7 @@ #include "Render/Lighting/LightMoodSetting.h" #include "Render/Lighting/DynamicLightsSetting.h" #include "Render/Lighting/ModelLight.h" +#include "Render/Lighting/SunShadow.h" #include "Render/Lighting/LightShadowCasters.h" #include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" @@ -3111,9 +3112,16 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const } }; // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it, as dark - // as the map lets it be (dynamic.flatSunShadow: none indoors). - const float flatSunShadow = - Render::Lighting::DynamicLightsActive() ? Render::Look::Value(Data::Maps::LookValue::FlatSunShadow) : 1.f; + // as the map lets it be (dynamic.flatSunShadow: none indoors), falling away from the sun. + const std::optional sun = Render::Lighting::FrameSun(); + if (sun) + { + constexpr float MaxFlatShadowFall = 3.0f; + const Render::Lighting::FlatShadowCast cast = Render::Lighting::FlatShadowFromSun(sun->sun, MaxFlatShadowFall); + projection.axisAngle = cast.axisAngle; + projection.shearX = projection.shearHeight * cast.fallPerHeight; + } + const float flatSunShadow = sun ? Render::Look::Value(Data::Maps::LookValue::FlatSunShadow) : 1.f; if (!Render::Lighting::SunShadowsActive() && flatSunShadow > 0.f) { const mu::ScopedGroundShadow groundShadow; diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index 87fb905a96..e4f152f8a0 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -403,6 +403,11 @@ class IMuRenderer // The frame's point lights for Enhanced-lit draws (Enhanced dynamic lights). The last set in a // frame is the one all of that frame's draws use; set an empty block to turn them off. virtual void SetDynamicLights(const DynamicLightsUniform& /*lights*/) {} + // The terrain's direct sunlight per cell, 256x256 RGBA8 (Enhanced clouds dim only that part of the + // ground's light). Kept until replaced. + virtual void SetTerrainSunLight(std::span /*rgba*/) {} + // True between BeginScreenSpaceSampling and EndScreenSpaceSampling (3D models shown in the UI). + [[nodiscard]] virtual bool InScreenSpaceSampling() const { return false; } // Select Enhanced (per-pixel lighting and fog) or Classic pipelines for the following frames. // Returns false when Enhanced lighting was requested but this backend could not build it; the diff --git a/src/source/Render/Renderer/MuRendererSDLGpu.cpp b/src/source/Render/Renderer/MuRendererSDLGpu.cpp index 85566efea0..db220fda21 100644 --- a/src/source/Render/Renderer/MuRendererSDLGpu.cpp +++ b/src/source/Render/Renderer/MuRendererSDLGpu.cpp @@ -638,6 +638,9 @@ static bool s_frameHasWorldLit = false; static bool s_groundShadowMaskReady = false; // Per pixel, 1 minus the darkest shadow alpha drawn there; single-sample, at the frame's size. static SDL_GPUTexture* s_groundShadowMask = nullptr; +// The terrain's direct sunlight per cell (SetTerrainSunLight), which clouds dim; null until the first one. +static SDL_GPUTexture* s_terrainSunLight = nullptr; +static constexpr Uint32 kTerrainSunLightSize = 256; static Uint32 s_groundShadowMaskW = 0; static Uint32 s_groundShadowMaskH = 0; // The mask's pipelines, [point light][skinned]: GPU-skinned shadows, and the CPU and cloth shadows @@ -2186,6 +2189,11 @@ class MuRendererSDLGpu : public IMuRenderer } ReleaseSunShadowResources(); + if (s_terrainSunLight) + { + SDL_ReleaseGPUTexture(s_device, s_terrainSunLight); + s_terrainSunLight = nullptr; + } // Release the independently owned white fallback texture. if (s_whiteTexture) @@ -2680,10 +2688,17 @@ class MuRendererSDLGpu : public IMuRenderer { SDL_GPUTexture* const sunShadow = s_sunShadowMap.Bound(); SDL_GPUSampler* const sunShadowSampler = s_sunShadowMap.Sampler(); + // Slot 3, the terrain's direct sunlight (world_lit reads it only while lightingParameters.y is 1). + SDL_GPUTexture* const terrainSun = s_terrainSunLight ? s_terrainSunLight : s_whiteTexture; + const SDL_GPUTextureSamplerBinding terrainSunBinding{terrainSun, s_defaultSampler}; if (sunShadow && sunShadowSampler) { - const SDL_GPUTextureSamplerBinding binding{sunShadow, sunShadowSampler}; - SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotSunShadow, &binding, 1); + const SDL_GPUTextureSamplerBinding bindings[] = {{sunShadow, sunShadowSampler}, terrainSunBinding}; + SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotSunShadow, bindings, 2); + } + else + { + SDL_BindGPUFragmentSamplers(s_renderPass, k_FragmentSamplerSlotSunShadow + 1, &terrainSunBinding, 1); } } @@ -2953,6 +2968,7 @@ class MuRendererSDLGpu : public IMuRenderer ReplayView view = FullFrameView(); RenderSunShadowMap(sceneEnd, boneDataReady); RenderGroundShadowMask(sceneEnd, boneDataReady); + const bool sceneView = s_postProcessingView == mu::PostProcessingView::Scene; // The scene texture's format says whether this frame's scene is HDR (EnsureTargets). s_hdrScenePass = s_postProcessing.IsHdrScene(); @@ -2968,13 +2984,12 @@ class MuRendererSDLGpu : public IMuRenderer ReplayCommands(0u, sceneEnd, boneDataReady, ReplaySelection::AllCommands, view); EndReplayPass(); - if (s_postProcessingLook.bloomStrength > 0.0f) + if (s_postProcessingLook.bloomStrength > 0.0f && s_postProcessing.EnsureBloomTargets()) { RenderBloomSources(sceneEnd, boneDataReady); } s_hdrScenePass = false; - const bool sceneView = s_postProcessingView == mu::PostProcessingView::Scene; SDL_GPUTexture* const sceneDepth = s_postProcessingLook.ambientOcclusionStrength > 0.0f && sceneView ? RenderSceneDepth(sceneEnd, boneDataReady) : nullptr; @@ -3377,6 +3392,15 @@ class MuRendererSDLGpu : public IMuRenderer std::optional replayScope(std::in_place, FrameProfiler::Pass::RendererReplay); const Render::PostProcessing::FrameSplit split = s_sceneBoundary.Split(s_renderCmds.size(), IsPostProcessingActive()); + // Passes that will not run this frame free their targets, whichever way the frame is drawn. + { + const bool scene = split.postProcessed && s_postProcessingView == mu::PostProcessingView::Scene; + if (!scene || s_postProcessingLook.ambientOcclusionStrength <= 0.0f) + s_ambientOcclusion.ReleaseTargets(); + // The bloom views show the bloom too. + if (!split.postProcessed || s_postProcessingLook.bloomStrength <= 0.0f) + s_postProcessing.ReleaseBloomTargets(); + } if (s_mainColorPassOpenedThisFrame && frameColorTexture == FrameColorTexture()) { // FlushRenderCommands already drew part of this frame into its target with one @@ -5416,6 +5440,7 @@ class MuRendererSDLGpu : public IMuRenderer fog.color[1] = m_fogUniform.fogColor[1]; fog.color[2] = m_fogUniform.fogColor[2]; s_sceneLightingUniform = PackSceneLightingUniform(lighting, fog); + s_sceneLightingUniform.lightingParameters[1] = s_terrainSunLight ? 1.0f : 0.0f; // The scene sets its lighting right after its camera, so the model-view is the view and the // projection the scene's. m_worldFromViewMatrix = glm::inverse(m_modelViewMatrix); @@ -5447,6 +5472,44 @@ class MuRendererSDLGpu : public IMuRenderer s_sunShadowMap.IsAvailable(); } + void SetTerrainSunLight(std::span rgba) override + { + if (rgba.size() != kTerrainSunLightSize * kTerrainSunLightSize * 4u || !s_device) + { + return; + } + if (!s_terrainSunLight) + { + SDL_GPUTextureCreateInfo info{}; + info.type = SDL_GPU_TEXTURETYPE_2D; + info.format = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM; + info.usage = SDL_GPU_TEXTUREUSAGE_SAMPLER; + info.width = kTerrainSunLightSize; + info.height = kTerrainSunLightSize; + info.layer_count_or_depth = 1; + info.num_levels = 1; + info.sample_count = SDL_GPU_SAMPLECOUNT_1; + s_terrainSunLight = SDL_CreateGPUTexture(s_device, &info); + if (!s_terrainSunLight) + { + return; + } + } + DiscardQueuedTextureUpdates(s_terrainSunLight); + TextureUpdateCmd cmd{}; + cmd.gpuTexture = s_terrainSunLight; + cmd.pixelsCopy.assign(rgba.begin(), rgba.end()); + cmd.width = kTerrainSunLightSize; + cmd.height = kTerrainSunLightSize; + cmd.bytesPerRow = kTerrainSunLightSize * 4u; + s_textureUpdates.push_back(std::move(cmd)); + } + + [[nodiscard]] bool InScreenSpaceSampling() const override + { + return s_screenSpaceSamplingDepth > 0; + } + void SetDynamicLights(const DynamicLightsUniform& lights) override { s_dynamicLightsUniform = lights; @@ -6114,7 +6177,7 @@ class MuRendererSDLGpu : public IMuRenderer s_vertShaderWorldLit = createShader("world_lit", "vert", SDL_GPU_SHADERSTAGE_VERTEX, 0, 0, 1, /*fatal=*/false); // world_lit.frag also samples the sun shadow map (s1) and the ground shadow mask (s2). s_fragShaderWorldLit = - createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 3, 0, 3, /*fatal=*/false); + createShader("world_lit", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 4, 0, 3, /*fatal=*/false); s_fragShaderShadowMask = createShader("shadow_mask", "frag", SDL_GPU_SHADERSTAGE_FRAGMENT, 0, 0, 0, /*fatal=*/false); // Sun shadows: the draw's texture (t0) for its alpha test, FogUniforms (b0). diff --git a/src/source/Render/Renderer/SceneLighting.h b/src/source/Render/Renderer/SceneLighting.h index e399be3fef..e74def5ab1 100644 --- a/src/source/Render/Renderer/SceneLighting.h +++ b/src/source/Render/Renderer/SceneLighting.h @@ -90,6 +90,7 @@ struct SceneLightingUniform float cameraPosition[4]; // xyz world space, w unused float sunViewProjection[16]; // column-major, world to the sun shadow map's clip space float sunShadowParameters[4]; // darkness (0: no shadow map), softness in texels, 1 / map size, texel size + float lightingParameters[4]; // unused, terrain sunlight grid bound, unused, unused float cloudParameters[4]; // strength (0: no clouds), 1 / pattern size, sky cover, unused float cloudOffset[4]; // xy: drift plus the sun's slant through the clouds, zw unused float skyFill[4]; // rgb: the sky's tint of the shade, w: how far shade takes it @@ -108,9 +109,10 @@ static_assert(offsetof(SceneLightingUniform, fogParameters) == 6 * kSceneLightin static_assert(offsetof(SceneLightingUniform, cameraPosition) == 7 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, sunViewProjection) == 8 * kSceneLightingRegisterSize); static_assert(offsetof(SceneLightingUniform, sunShadowParameters) == 12 * kSceneLightingRegisterSize); -static_assert(offsetof(SceneLightingUniform, cloudParameters) == 13 * kSceneLightingRegisterSize); -static_assert(offsetof(SceneLightingUniform, sunColor) == 17 * kSceneLightingRegisterSize); -static_assert(sizeof(SceneLightingUniform) == 18 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, lightingParameters) == 13 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, cloudParameters) == 14 * kSceneLightingRegisterSize); +static_assert(offsetof(SceneLightingUniform, sunColor) == 18 * kSceneLightingRegisterSize); +static_assert(sizeof(SceneLightingUniform) == 19 * kSceneLightingRegisterSize); [[nodiscard]] SceneLightingUniform PackSceneLightingUniform(const SceneLighting& lighting, const SceneFog& fog); diff --git a/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h index bfe240163b..62eb833777 100644 --- a/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h +++ b/src/source/Render/Renderer/SdlGpuAmbientOcclusion.h @@ -46,10 +46,11 @@ class SdlGpuAmbientOcclusion // Everything, at shutdown. void Release(); + // The targets, while the pass is off. + void ReleaseTargets(); private: [[nodiscard]] bool EnsureTargets(SdlGpuTargetSize size); - void ReleaseTargets(); // False when the pass could not be opened. [[nodiscard]] bool RunPass(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUGraphicsPipeline* pipeline, SDL_GPUTexture* target, const SDL_GPUTextureSamplerBinding* inputs, Uint32 inputCount, diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp index 46ae15155f..014d84f7ad 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.cpp +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.cpp @@ -228,9 +228,30 @@ bool SdlGpuPostProcessing::EnsureTargets(SdlGpuTargetSize size, SDL_GPUTextureFo ReleaseTargets(); m_sceneFormat = sceneFormat; m_sceneTexture = CreateTarget(m_device, m_sceneFormat, size); - m_bloomSourceTexture = CreateTarget(m_device, m_sceneFormat, size); - SdlGpuTargetSize levelSize = HalfSize(size); - bool created = m_sceneTexture && m_bloomSourceTexture; + if (!m_sceneTexture) + { + log::Get("render")->error("SDL_gpu -- post-processing targets failed ({}x{}): {}", size.width, size.height, + SDL_GetError()); + ReleaseTargets(); + return false; + } + m_targetSize = size; + return true; +} + +bool SdlGpuPostProcessing::EnsureBloomTargets() +{ + if (m_bloomSourceTexture) + { + return true; + } + if (!m_sceneTexture) + { + return false; + } + m_bloomSourceTexture = CreateTarget(m_device, m_sceneFormat, m_targetSize); + SdlGpuTargetSize levelSize = HalfSize(m_targetSize); + bool created = m_bloomSourceTexture != nullptr; for (BloomLevel& level : m_bloomLevels) { level.size = levelSize; @@ -240,15 +261,25 @@ bool SdlGpuPostProcessing::EnsureTargets(SdlGpuTargetSize size, SDL_GPUTextureFo } if (!created) { - log::Get("render")->error("SDL_gpu -- post-processing targets failed ({}x{}): {}", size.width, size.height, - SDL_GetError()); - ReleaseTargets(); + log::Get("render")->error("SDL_gpu -- bloom targets failed ({}x{}): {}", m_targetSize.width, + m_targetSize.height, SDL_GetError()); + ReleaseBloomTargets(); return false; } - m_targetSize = size; return true; } +void SdlGpuPostProcessing::ReleaseBloomTargets() +{ + ReleaseTexture(m_device, m_bloomSourceTexture); + for (BloomLevel& level : m_bloomLevels) + { + ReleaseTexture(m_device, level.texture); + level.size = {}; + } + m_bloomRendered = false; +} + bool SdlGpuPostProcessing::IsHdrScene() const { return m_sceneTexture && m_sceneFormat != m_frameFormat; @@ -267,14 +298,8 @@ SDL_GPUTexture* SdlGpuPostProcessing::GetBloomSourceTexture() const void SdlGpuPostProcessing::ReleaseTargets() { ReleaseTexture(m_device, m_sceneTexture); - ReleaseTexture(m_device, m_bloomSourceTexture); - for (BloomLevel& level : m_bloomLevels) - { - ReleaseTexture(m_device, level.texture); - level.size = {}; - } + ReleaseBloomTargets(); m_targetSize = {}; - m_bloomRendered = false; } void SdlGpuPostProcessing::RunBloomPass(SDL_GPUCommandBuffer* commandBuffer, SDL_GPUGraphicsPipeline* pipeline, diff --git a/src/source/Render/Renderer/SdlGpuPostProcessing.h b/src/source/Render/Renderer/SdlGpuPostProcessing.h index 56683fbe5d..ae68235f5a 100644 --- a/src/source/Render/Renderer/SdlGpuPostProcessing.h +++ b/src/source/Render/Renderer/SdlGpuPostProcessing.h @@ -81,10 +81,13 @@ class SdlGpuPostProcessing void DestroyPipelines(); [[nodiscard]] bool IsAvailable() const; - // The scene, bloom source and bloom chain textures for frames of `size`, the scene and bloom - // source in `sceneFormat` (INVALID: the frame's format; another one makes an HDR scene, which - // the composite tone maps and dithers), recreated when either changed. + // The scene texture for frames of `size` in `sceneFormat` (INVALID: the frame's format; another + // one makes an HDR scene, which the composite tone maps and dithers), recreated when either changed. [[nodiscard]] bool EnsureTargets(SdlGpuTargetSize size, SDL_GPUTextureFormat sceneFormat); + // The bloom source (in the scene's format) and the bloom chain, at the scene's size; only bloom + // uses them. False when they cannot be created. + [[nodiscard]] bool EnsureBloomTargets(); + void ReleaseBloomTargets(); [[nodiscard]] bool IsHdrScene() const; [[nodiscard]] SDL_GPUTexture* GetSceneTexture() const; [[nodiscard]] SDL_GPUTexture* GetBloomSourceTexture() const; diff --git a/src/source/Render/Terrain/ZzzLodTerrain.cpp b/src/source/Render/Terrain/ZzzLodTerrain.cpp index 2d08962b0c..b4e7c8cc0a 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.cpp +++ b/src/source/Render/Terrain/ZzzLodTerrain.cpp @@ -558,6 +558,9 @@ static vec3_t FigureStaticTerrainLight[TERRAIN_SIZE * TERRAIN_SIZE]; // The static light of one cell: the baked light, shaded by the slope towards // the sun and darkened by the map's light mood: by its base where the baked // light is dark, less towards its shadow keep. +// Per cell, the direct sunlight inside BackTerrainLight (RGBA8): what Enhanced clouds take away. +static std::vector s_terrainSunLight(TERRAIN_SIZE * TERRAIN_SIZE * 4, 0); + static void CreateStaticLightCell(int Index, const vec3_t Sun, const Render::Lighting::LightMood::Scales& scales) { float Luminosity = VectorDotProduct(TerrainNormal[Index], Sun) + 0.5f; @@ -565,6 +568,8 @@ static void CreateStaticLightCell(int Index, const vec3_t Sun, const Render::Lig Luminosity = 0.f; else if (Luminosity > 1.f) Luminosity = 1.f; + // The sun's share: the slope term above the half Classic gives every face. + const float direct = std::max(Luminosity - 0.5f, 0.f); vec3_t undarkened; for (int i = 0; i < 3; i++) { @@ -579,6 +584,11 @@ static void CreateStaticLightCell(int Index, const vec3_t Sun, const Render::Lig BackTerrainLight[Index][i] = undarkened[i] * factor[i]; } Vector(weight, weight, weight, StaticLightBrightWeight[Index]); + for (int i = 0; i < 3; i++) + { + const float value = TerrainLight[Index][i] * direct * factor[i]; + s_terrainSunLight[Index * 4 + i] = static_cast(std::clamp(value, 0.f, 1.f) * 255.f + 0.5f); + } VectorCopy(BackTerrainLight[Index], FigureStaticTerrainLight[Index]); Render::Lighting::LightMood::CorrectFigureLight(scales, undarkened, FigureStaticTerrainLight[Index], weight); } @@ -610,10 +620,13 @@ static glm::vec3 TerrainSunVector() // The vector BackTerrainLight was last built with. static glm::vec3 s_terrainLightSun{0.f}; +// The light mood revision the static light was last built with. +static std::uint32_t s_bakedMoodRevision = 0; void CreateTerrainLight() { s_terrainLightSun = TerrainSunVector(); + s_bakedMoodRevision = Render::Lighting::LightMood::Revision(); const vec3_t Light = {s_terrainLightSun.x, s_terrainLightSun.y, s_terrainLightSun.z}; const Render::Lighting::LightMood::Scales& scales = Render::Lighting::LightMood::Active(); for (int y = 0; y < TERRAIN_SIZE; y++) @@ -623,6 +636,7 @@ void CreateTerrainLight() CreateStaticLightCell(TERRAIN_INDEX(x, y), Light, scales); } } + mu::GetRenderer().SetTerrainSunLight(s_terrainSunLight); } void CreateTerrainLight_Part(int xi, int yi) @@ -2891,9 +2905,11 @@ extern int EnableEvent; void InitTerrainLight() { Render::Lighting::UpdateFrameSun(); - // The sun moved (dynamic.shadowAngle): the slope shading follows it. - if (const glm::vec3 sun = TerrainSunVector(); - glm::any(glm::greaterThan(glm::abs(sun - s_terrainLightSun), glm::vec3(1e-4f)))) + // The sun moved (dynamic.shadowAngle), or look values or the tint source changed the mood's scales since + // the last build: the static light follows. + const glm::vec3 sun = TerrainSunVector(); + if (glm::any(glm::greaterThan(glm::abs(sun - s_terrainLightSun), glm::vec3(1e-4f))) || + Render::Lighting::LightMood::Revision() != s_bakedMoodRevision) { FRAME_PROFILE(TerrainBake); CreateTerrainLight(); diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index 7f0382df59..7f6e926f64 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -14,6 +14,7 @@ #include "Render/Lighting/WorldDynamicLights.h" #include "Render/Look/LookProfileSetting.h" #include "Render/Renderer/MuRenderer.h" +#include "Render/Lighting/SunShadow.h" #include "Render/Renderer/SceneLighting.h" #include "Scenes/SceneCore.h" diff --git a/tests/data/test_look_profile_json.cpp b/tests/data/test_look_profile_json.cpp index 20f080090c..583ad24e9a 100644 --- a/tests/data/test_look_profile_json.cpp +++ b/tests/data/test_look_profile_json.cpp @@ -297,3 +297,24 @@ TEST_CASE("the shipped look profile holds the tuned Enhanced values [data][look] } CHECK(loaded.data.ForWorld(Lorencia)[LookValue::FlatSunShadow] == 1.0); } + +TEST_CASE("a map's environment applies between the default and the map's own values [data][look]") +{ + const ReadResult result = Read(R"({"formatVersion": 1, + "default": {"bloom.strength": 1.0, "sun.shadow": 1}, + "environments": {"enclosed": {"sun.shadow": 0, "bloom.strength": 0.8}}, + "maps": [{"world": 1, "environment": "enclosed", "bloom.strength": 0.5}, + {"world": 10, "environment": "enclosed"}]})"); + REQUIRE_MESSAGE(!HasFatal(result.issues), Messages(result.issues)); + CHECK(result.data.ForWorld(Lorencia)[LookValue::SunShadowStrength] == 1.0); + CHECK(result.data.ForWorld(Dungeon)[LookValue::SunShadowStrength] == 0.0); + // The map's own value wins over its environment's. + CHECK(result.data.ForWorld(Dungeon)[LookValue::BloomStrength] == doctest::Approx(0.5)); + CHECK(result.data.ForWorld(Icarus)[LookValue::BloomStrength] == doctest::Approx(0.8)); +} + +TEST_CASE("an unknown environment makes the file unusable [data][look]") +{ + CheckBuiltInEverywhere(Read(R"({"formatVersion": 1, "maps": [{"world": 1, "environment": "cave"}]})")); + CheckBuiltInEverywhere(Read(R"({"formatVersion": 1, "environments": {"cave": 1}})")); +} diff --git a/tests/render/test_scene_lighting.cpp b/tests/render/test_scene_lighting.cpp index 3b995f7581..2130783885 100644 --- a/tests/render/test_scene_lighting.cpp +++ b/tests/render/test_scene_lighting.cpp @@ -6,7 +6,7 @@ TEST_CASE("scene lighting uniform matches the HLSL cbuffer registers [render][scene_lighting]") { - CHECK(sizeof(mu::SceneLightingUniform) == 288); + CHECK(sizeof(mu::SceneLightingUniform) == 304); CHECK(offsetof(mu::SceneLightingUniform, lightDirection) == 0); CHECK(offsetof(mu::SceneLightingUniform, lightColor) == 16); CHECK(offsetof(mu::SceneLightingUniform, diffuseCurve) == 32); diff --git a/tests/render/test_sun_shadow.cpp b/tests/render/test_sun_shadow.cpp index 4175963570..ccddaa9d9e 100644 --- a/tests/render/test_sun_shadow.cpp +++ b/tests/render/test_sun_shadow.cpp @@ -137,3 +137,17 @@ TEST_CASE("a baked light vector follows the sun's turn and rise, and is the same SunDirection(Render::Lighting::kBakedSunShadowAngle, 0.01f)); CHECK(std::atan2(steep.z, std::hypot(steep.x, steep.y)) <= glm::radians(89.0f) + 1e-5f); } + +TEST_CASE("a flat shadow falls away from the sun, as long as its slant [render][sun]") +{ + using Render::Lighting::FlatShadowFromSun; + // The baked sun: shadows towards 135 degrees, half a unit per unit of height. + const Render::Lighting::FlatShadowCast baked = FlatShadowFromSun(Render::Lighting::SunDirection(135.0f, 0.5f), 3.0f); + CHECK(baked.fallPerHeight == doctest::Approx(0.5f)); + CHECK(std::cos(baked.axisAngle) == doctest::Approx(std::cos(glm::radians(315.0f))).epsilon(1e-4)); + CHECK(std::sin(baked.axisAngle) == doctest::Approx(std::sin(glm::radians(315.0f))).epsilon(1e-4)); + // A low sun: long, but bounded. + CHECK(FlatShadowFromSun(Render::Lighting::SunDirection(90.0f, 10.0f), 3.0f).fallPerHeight == doctest::Approx(3.0f)); + // Straight overhead: no slant. + CHECK(FlatShadowFromSun(glm::vec3(0.0f, 0.0f, 1.0f), 3.0f).fallPerHeight == 0.0f); +} From 45794f453dd07dc2ea6634564b3f7f5adf759d00 Mon Sep 17 00:00:00 2001 From: Benito Go III Date: Wed, 4 Nov 2026 16:44:46 +0800 Subject: [PATCH 17/17] fix(render): lighting follows the draw drawn later The character scope is a recorded legacy call, so characters drawn later keep it. A shadow takes its fall, its strength and its point-light casts when described, so the draw reads only what it carries. The ground light is built in the update, after the lights are pinned, and whether sun shadows are active is taken once per frame. The parity log records the ground shadow, world-lit and character scopes. --- src/source/Render/Drawing/DrawCallLog.h | 29 +++++++ src/source/Render/Drawing/LegacyCalls.cpp | 8 ++ src/source/Render/Drawing/LegacyCalls.h | 19 +++++ .../Render/Lighting/DynamicLightsSetting.cpp | 18 ++-- .../Render/Lighting/DynamicLightsSetting.h | 3 +- src/source/Render/Models/ModelDraw.h | 15 ++++ src/source/Render/Models/ZzzBMD.cpp | 83 ++++++++++++------- src/source/Render/Renderer/MuRenderer.h | 16 +--- src/source/Render/Terrain/ZzzLodTerrain.cpp | 7 +- src/source/Render/Terrain/ZzzLodTerrain.h | 2 + src/source/Scenes/MainScene.cpp | 2 +- src/source/Scenes/SceneLightingSetup.cpp | 2 + tests/data/test_draw_parity.cpp | 28 +++++++ tests/render/test_model_draw.cpp | 39 +++++++++ .../render/test_projected_shadow_state.cmake | 2 +- 15 files changed, 209 insertions(+), 64 deletions(-) diff --git a/src/source/Render/Drawing/DrawCallLog.h b/src/source/Render/Drawing/DrawCallLog.h index 76bc5d65fe..596f2201c4 100644 --- a/src/source/Render/Drawing/DrawCallLog.h +++ b/src/source/Render/Drawing/DrawCallLog.h @@ -206,6 +206,30 @@ class DrawCallLog final : public mu::IMuRenderer { return m_bloomExclusions > 0; } + void BeginWorldLitGeometry() override + { + ++m_worldLit; + } + void EndWorldLitGeometry() override + { + --m_worldLit; + } + void BeginGroundShadow(mu::GroundShadowSource source) override + { + ++m_groundShadows[static_cast(source)]; + } + void EndGroundShadow(mu::GroundShadowSource source) override + { + --m_groundShadows[static_cast(source)]; + } + void BeginCharacterDraws() override + { + ++m_characterDraws; + } + void EndCharacterDraws() override + { + --m_characterDraws; + } [[nodiscard]] std::size_t BeginReorderableDraws() override { return m_reorderable++; @@ -271,6 +295,9 @@ class DrawCallLog final : public mu::IMuRenderer int m_bound = -1; int m_textureMode = 0; int m_bloomExclusions = 0; + int m_worldLit = 0; + int m_groundShadows[2] = {}; + int m_characterDraws = 0; std::size_t m_reorderable = 0; // The scene's camera, which the sprite matrix replaces. std::vector m_matrices{std::string(" camera")}; @@ -283,6 +310,8 @@ class DrawCallLog final : public mu::IMuRenderer std::to_string(m_alphaTest) + " alphaRef " + std::to_string(m_alphaRef) + " texture " + std::to_string(m_texture2D) + " " + std::to_string(m_bound) + " mode " + std::to_string(m_textureMode) + " fog " + std::to_string(m_fog) + " bloomExcluded " + std::to_string(m_bloomExclusions > 0) + + " worldLit " + std::to_string(m_worldLit > 0) + " groundShadow " + std::to_string(m_groundShadows[0] > 0) + + std::to_string(m_groundShadows[1] > 0) + " characters " + std::to_string(m_characterDraws > 0) + " reorderable " + std::to_string(m_reorderable) + " matrix" + m_matrices.back(); } diff --git a/src/source/Render/Drawing/LegacyCalls.cpp b/src/source/Render/Drawing/LegacyCalls.cpp index b57ca27b3b..4c4023bc31 100644 --- a/src/source/Render/Drawing/LegacyCalls.cpp +++ b/src/source/Render/Drawing/LegacyCalls.cpp @@ -110,6 +110,14 @@ void MakeLegacyCall(LegacyCall call, int argument) s_reorderableMarks.pop_back(); } break; + case LegacyCall::BeginCharacterDraws: + if (!RecordsLegacyCall(call, argument)) + mu::GetRenderer().BeginCharacterDraws(); + break; + case LegacyCall::EndCharacterDraws: + if (!RecordsLegacyCall(call, argument)) + mu::GetRenderer().EndCharacterDraws(); + break; case LegacyCall::RenderTerrain: RenderTerrain(argument != 0); break; diff --git a/src/source/Render/Drawing/LegacyCalls.h b/src/source/Render/Drawing/LegacyCalls.h index 7de5dcf376..88b5933080 100644 --- a/src/source/Render/Drawing/LegacyCalls.h +++ b/src/source/Render/Drawing/LegacyCalls.h @@ -35,6 +35,8 @@ enum class LegacyCall : std::uint8_t EndSprite, BeginReorderableDraws, EndReorderableDraws, + BeginCharacterDraws, + EndCharacterDraws, // Argument: the edit flag. RenderTerrain, RenderWaterTerrain, @@ -70,4 +72,21 @@ class ScopedReorderableDraws ScopedReorderableDraws(const ScopedReorderableDraws&) = delete; ScopedReorderableDraws& operator=(const ScopedReorderableDraws&) = delete; }; + +// The draws in its lifetime are the characters (mu::IMuRenderer::BeginCharacterDraws), recorded with them when drawn +// later. +class ScopedCharacterDraws +{ +public: + ScopedCharacterDraws() + { + MakeLegacyCall(LegacyCall::BeginCharacterDraws, 0); + } + ~ScopedCharacterDraws() + { + MakeLegacyCall(LegacyCall::EndCharacterDraws, 0); + } + ScopedCharacterDraws(const ScopedCharacterDraws&) = delete; + ScopedCharacterDraws& operator=(const ScopedCharacterDraws&) = delete; +}; } // namespace Render::Drawing diff --git a/src/source/Render/Lighting/DynamicLightsSetting.cpp b/src/source/Render/Lighting/DynamicLightsSetting.cpp index 93f5ca8df5..c773d5785f 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.cpp +++ b/src/source/Render/Lighting/DynamicLightsSetting.cpp @@ -33,19 +33,17 @@ bool DynamicLightsActive() return s_dynamicLightsEnabled && EnhancedLightingActive(); } -bool SunShadowsActive() -{ - const std::optional sun = FrameSun(); - return SceneFlag == MAIN_SCENE && DynamicLightsActive() && sun && - Render::Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0 && - mu::GetRenderer().SunShadowsAvailable(); -} - namespace { std::optional s_frameSun; +bool s_frameSunShadows = false; } // namespace +bool SunShadowsActive() +{ + return s_frameSunShadows; +} + std::optional FrameSun() { return s_frameSun; @@ -54,6 +52,7 @@ std::optional FrameSun() void UpdateFrameSun() { s_frameSun.reset(); + s_frameSunShadows = false; if (!DynamicLightsActive()) { return; @@ -61,6 +60,9 @@ void UpdateFrameSun() const float fall = gMapManager.InBattleCastle() ? kSunShadowFallBattleCastle : kSunShadowFall; s_frameSun = FrameSunDirections{SunDirection(Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle), fall), SunDirection(kBakedSunShadowAngle, fall)}; + s_frameSunShadows = SceneFlag == MAIN_SCENE && + Render::Look::Value(Data::Maps::LookValue::SunShadowStrength) > 0.0 && + mu::GetRenderer().SunShadowsAvailable(); } glm::vec3 FollowFrameSun(const glm::vec3& baked) diff --git a/src/source/Render/Lighting/DynamicLightsSetting.h b/src/source/Render/Lighting/DynamicLightsSetting.h index f4d4c21cad..db09b81690 100644 --- a/src/source/Render/Lighting/DynamicLightsSetting.h +++ b/src/source/Render/Lighting/DynamicLightsSetting.h @@ -17,7 +17,8 @@ void SetDynamicLightsEnabled(bool enabled); [[nodiscard]] bool DynamicLightsActive(); // True when the sun's shadows come from the shadow map: in the game, with dynamic lights active, -// sun.shadow above 0 and a renderer that can draw it. Characters then cast no flat sun shadow. +// sun.shadow above 0 and a renderer that can draw it, taken once per frame (UpdateFrameSun). Characters then cast no +// flat sun shadow. [[nodiscard]] bool SunShadowsActive(); // This frame's sun (towards it): from dynamic.shadowAngle and the map's shadow length, and the sun the diff --git a/src/source/Render/Models/ModelDraw.h b/src/source/Render/Models/ModelDraw.h index a386ffab28..01b4f9ba1d 100644 --- a/src/source/Render/Models/ModelDraw.h +++ b/src/source/Render/Models/ModelDraw.h @@ -87,6 +87,14 @@ struct ClothShadow }; // One model's shadow projected on the ground: the call's arguments and the model state the draw reads. +// A shadow a point light casts, taken when the draw is described. +struct ShadowLightCast +{ + // Radians from world +x to the axis the shear acts along. + float axisAngle = 0.f; + float strength = 0.f; +}; + struct ShadowDraw { const BMD* model = nullptr; @@ -98,6 +106,13 @@ struct ShadowDraw // Set: the cloth casts the shadow instead of the meshes. std::span clothes; float alpha = 1.f; + // The shadow's fall and strength under the frame's sun, and what the frame's point lights cast. + float shearX = 2000.f; + float shearHeight = 4000.f; + float axisAngle = 0.f; + float flatStrength = 1.f; + ShadowLightCast lightCasts[4]; + int lightCastCount = 0; float bodyOrigin[3] = {}; float bodyScale = 1.f; diff --git a/src/source/Render/Models/ZzzBMD.cpp b/src/source/Render/Models/ZzzBMD.cpp index 69c60712fa..1f24c6d622 100644 --- a/src/source/Render/Models/ZzzBMD.cpp +++ b/src/source/Render/Models/ZzzBMD.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -2554,7 +2555,7 @@ __forceinline void GetClothShadowPosition(vec3_t* target, const Render::ModelDra CalcShadowPosition(target, projection); } -void BMD::AddClothesShadowTriangles(std::span clothes, +void BMD::AddClothesShadowTriangles(std::span clothes, const mu::ShadowProjection& projection, const std::uint32_t color) const { auto vertices = RenderArrayVertices; @@ -2636,14 +2637,50 @@ float BodyShadowAxisAngle() return (Render::Look::Value(Data::Maps::LookValue::GroundShadowAngle) + 180.f) * RadiansPerDegree; } +// The frame's light on a shadow: its fall under the sun, how dark the flat shadow is, what the point lights cast. +void TakeShadowLight(Render::ModelDrawing::ShadowDraw& draw) +{ + draw.shearX = gMapManager.InBattleCastle() ? 2500.f : 2000.f; + draw.axisAngle = BodyShadowAxisAngle(); + // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it, as dark + // as the map lets it be (dynamic.flatSunShadow: none indoors), falling away from the sun. + const std::optional sun = Render::Lighting::FrameSun(); + if (sun) + { + constexpr float MaxFlatShadowFall = 3.0f; + const Render::Lighting::FlatShadowCast cast = Render::Lighting::FlatShadowFromSun(sun->sun, MaxFlatShadowFall); + draw.axisAngle = cast.axisAngle; + draw.shearX = draw.shearHeight * cast.fallPerHeight; + } + const float flatSunShadow = sun ? Render::Look::Value(Data::Maps::LookValue::FlatSunShadow) : 1.f; + draw.flatStrength = Render::Lighting::SunShadowsActive() ? 0.f : flatSunShadow; + // The ground's strongest point lights cast one more shadow each, away from the light. + const Render::Lighting::WorldDynamicLights& worldLights = Render::Lighting::FrameWorldDynamicLights(); + if (Render::Lighting::DynamicLightsActive() && worldLights.IsPinned()) + { + static_assert(std::extent_v == Render::Lighting::kMaxLightShadowCasters); + const auto maxCasters = + static_cast(Render::Look::Value(Data::Maps::LookValue::GroundShadowLights)); + const Render::Lighting::LightShadowCasters casters = Render::Lighting::SelectLightShadowCasters( + worldLights.Selection().uniform, {draw.bodyOrigin[0], draw.bodyOrigin[1], draw.bodyOrigin[2]}, maxCasters); + constexpr float HalfTurn = 3.14159265358979f; + for (std::size_t i = 0; i < casters.count; ++i) + { + draw.lightCasts[i] = {casters.casters[i].fallAngle + HalfTurn, casters.casters[i].strength}; + } + draw.lightCastCount = static_cast(casters.count); + } +} + // Where CalcShadowPosition and skinned_shadow.vert put a body shadow. -mu::ShadowProjection BodyShadowProjection(const vec3_t origin, const float sx, const float sy) +mu::ShadowProjection BodyShadowProjection(const Render::ModelDrawing::ShadowDraw& draw) { + const float* origin = draw.bodyOrigin; return { .origin = {origin[0], origin[1], origin[2]}, - .shearX = sx, - .shearHeight = sy, - .axisAngle = BodyShadowAxisAngle(), + .shearX = draw.shearX, + .shearHeight = draw.shearHeight, + .axisAngle = draw.axisAngle, .specialHeight = g_fSpecialHeight, .terrain = SceneFlag != SERVER_LIST_SCENE && SceneFlag != WEBZEN_SCENE && SceneFlag != LOADING_SCENE, }; @@ -2818,7 +2855,7 @@ const vec3_t* BMD::ShadowVertices(const Render::ModelDrawing::ShadowDraw& draw, } void BMD::AddMeshShadowTriangles(const Render::ModelDrawing::ShadowDraw& draw, const int blendMesh, - const int hiddenMesh, const int startMesh, const int endMesh, + const int hiddenMesh, const int startMesh, const int endMesh, const mu::ShadowProjection& projection, const std::uint32_t color) const { auto vertices = RenderArrayVertices; @@ -3014,6 +3051,7 @@ void BMD::RenderBodyShadow(const int blendMesh, const int hiddenMesh, const int .lod = ActiveLod, .skin = CurrentSkin()}; VectorCopy(BodyOrigin, draw.bodyOrigin); + TakeShadowLight(draw); // The cloth's points as plain data: the draw reads no simulation, and a drawer that draws later copies them. static thread_local std::vector clothes; static thread_local std::vector> clothPoints; @@ -3093,8 +3131,7 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const const auto [startMesh, endMesh] = ResolveMeshRange(NumMeshs, draw.startMesh, draw.endMesh); - mu::ShadowProjection projection = - BodyShadowProjection(draw.bodyOrigin, gMapManager.InBattleCastle() ? 2500.f : 2000.f, 4000.f); + mu::ShadowProjection projection = BodyShadowProjection(draw); const auto drawShadow = [&](float shadowAlpha) { const std::uint32_t shadowColor = PackABGR(0.f, 0.f, 0.f, std::clamp(shadowAlpha, 0.f, 1.f)); @@ -3111,36 +3148,18 @@ void BMD::DrawShadow(const Render::ModelDrawing::ShadowDraw& draw) const AddMeshShadowTriangles(draw, draw.blendMesh, draw.hiddenMesh, startMesh, endMesh, projection, shadowColor); } }; - // The sun shadow map shadows the ground itself; only the flat shadow is drawn without it, as dark - // as the map lets it be (dynamic.flatSunShadow: none indoors), falling away from the sun. - const std::optional sun = Render::Lighting::FrameSun(); - if (sun) - { - constexpr float MaxFlatShadowFall = 3.0f; - const Render::Lighting::FlatShadowCast cast = Render::Lighting::FlatShadowFromSun(sun->sun, MaxFlatShadowFall); - projection.axisAngle = cast.axisAngle; - projection.shearX = projection.shearHeight * cast.fallPerHeight; - } - const float flatSunShadow = sun ? Render::Look::Value(Data::Maps::LookValue::FlatSunShadow) : 1.f; - if (!Render::Lighting::SunShadowsActive() && flatSunShadow > 0.f) + if (draw.flatStrength > 0.f) { const mu::ScopedGroundShadow groundShadow; - drawShadow(draw.alpha * flatSunShadow); + drawShadow(draw.alpha * draw.flatStrength); } - // The ground's strongest point lights cast one more shadow each, away from the light. - const Render::Lighting::WorldDynamicLights& worldLights = Render::Lighting::FrameWorldDynamicLights(); - if (Render::Lighting::DynamicLightsActive() && worldLights.IsPinned()) + if (draw.lightCastCount > 0) { - const auto maxCasters = - static_cast(Render::Look::Value(Data::Maps::LookValue::GroundShadowLights)); - const Render::Lighting::LightShadowCasters casters = Render::Lighting::SelectLightShadowCasters( - worldLights.Selection().uniform, {draw.bodyOrigin[0], draw.bodyOrigin[1], draw.bodyOrigin[2]}, maxCasters); const mu::ScopedGroundShadow lightShadow(mu::GroundShadowSource::PointLight); - for (std::size_t i = 0; i < casters.count; ++i) + for (int i = 0; i < draw.lightCastCount; ++i) { - constexpr float HalfTurn = 3.14159265358979f; - projection.axisAngle = casters.casters[i].fallAngle + HalfTurn; - drawShadow(draw.alpha * casters.casters[i].strength); + projection.axisAngle = draw.lightCasts[i].axisAngle; + drawShadow(draw.alpha * draw.lightCasts[i].strength); } } diff --git a/src/source/Render/Renderer/MuRenderer.h b/src/source/Render/Renderer/MuRenderer.h index e4f152f8a0..6e2e907d3e 100644 --- a/src/source/Render/Renderer/MuRenderer.h +++ b/src/source/Render/Renderer/MuRenderer.h @@ -462,7 +462,7 @@ class IMuRenderer virtual void BeginGroundShadow(GroundShadowSource /*source*/) {} virtual void EndGroundShadow(GroundShadowSource /*source*/) {} // Draws between BeginCharacterDraws and EndCharacterDraws are the characters, apart from the world's - // objects. Scopes nest; use ScopedCharacterDraws. + // objects. Scopes nest; use Render::Drawing::ScopedCharacterDraws. virtual void BeginCharacterDraws() {} virtual void EndCharacterDraws() {} // Whether SetSceneLighting's sun shadow settings draw a shadow map. @@ -918,20 +918,6 @@ class ScopedWorldLitGeometry ScopedWorldLitGeometry(const ScopedWorldLitGeometry&) = delete; ScopedWorldLitGeometry& operator=(const ScopedWorldLitGeometry&) = delete; }; -class ScopedCharacterDraws -{ -public: - ScopedCharacterDraws() - { - GetRenderer().BeginCharacterDraws(); - } - ~ScopedCharacterDraws() - { - GetRenderer().EndCharacterDraws(); - } - ScopedCharacterDraws(const ScopedCharacterDraws&) = delete; - ScopedCharacterDraws& operator=(const ScopedCharacterDraws&) = delete; -}; class ScopedGroundShadow { public: diff --git a/src/source/Render/Terrain/ZzzLodTerrain.cpp b/src/source/Render/Terrain/ZzzLodTerrain.cpp index b4e7c8cc0a..59f598774c 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.cpp +++ b/src/source/Render/Terrain/ZzzLodTerrain.cpp @@ -1430,7 +1430,7 @@ static vec3_t* s_faceLight = PrimaryTerrainLight; extern int FrustrumBoundMinX, FrustrumBoundMinY, FrustrumBoundMaxX, FrustrumBoundMaxY; -static void BuildGroundLight() +void BuildGroundLight() { for (int yi = FrustrumBoundMinY; yi <= FrustrumBoundMaxY + 3; ++yi) { @@ -3422,11 +3422,6 @@ void RenderTerrain(bool EditFlag) InitCollisionDetectLineToFace(); } - if (!EditFlag && Render::Lighting::FrameWorldDynamicLights().IsPinned() && !s_groundLightBuilt) - { - BuildGroundLight(); - } - TerrainFlag = TERRAIN_MAP_NORMAL; { const GroundLightScope ground(!EditFlag); diff --git a/src/source/Render/Terrain/ZzzLodTerrain.h b/src/source/Render/Terrain/ZzzLodTerrain.h index 9d106305e2..4c5759b488 100644 --- a/src/source/Render/Terrain/ZzzLodTerrain.h +++ b/src/source/Render/Terrain/ZzzLodTerrain.h @@ -58,6 +58,8 @@ void AddTerrainHeight(float xf, float yf, float Height, int Range, float* Buffer void InitTerrainRay(int HeroX, int HeroY); void InitTerrainLight(); +// The ground's light without the pinned lights, over the frame's culled terrain: built by the update, read by the draw. +void BuildGroundLight(); void InitTerrainShadow(); void SetTerrainLight(float xf, float yf, vec3_t Light, int Range, vec3_t* Buffer); void AddTerrainLight(float xf, float yf, vec3_t Light, int Range, vec3_t* Buffer); diff --git a/src/source/Scenes/MainScene.cpp b/src/source/Scenes/MainScene.cpp index 4bd8ae5e70..c789c81b6f 100644 --- a/src/source/Scenes/MainScene.cpp +++ b/src/source/Scenes/MainScene.cpp @@ -618,7 +618,7 @@ static void RenderGameWorldPass(BYTE& byWaterMap, int width, int height) { FRAME_PROFILE(Characters); - mu::ScopedCharacterDraws characterDraws; + Render::Drawing::ScopedCharacterDraws characterDraws; RenderCharactersClient(); } diff --git a/src/source/Scenes/SceneLightingSetup.cpp b/src/source/Scenes/SceneLightingSetup.cpp index 7f6e926f64..48b8a31abb 100644 --- a/src/source/Scenes/SceneLightingSetup.cpp +++ b/src/source/Scenes/SceneLightingSetup.cpp @@ -16,6 +16,7 @@ #include "Render/Renderer/MuRenderer.h" #include "Render/Lighting/SunShadow.h" #include "Render/Renderer/SceneLighting.h" +#include "Render/Terrain/ZzzLodTerrain.h" #include "Scenes/SceneCore.h" #include @@ -126,6 +127,7 @@ void PinWorldDynamicLights() float reference[3]; SelectionReference(reference); Render::Lighting::FrameWorldDynamicLights().Pin(Render::Lighting::FrameDynamicLights(), reference); + BuildGroundLight(); } void SubmitDynamicLights() diff --git a/tests/data/test_draw_parity.cpp b/tests/data/test_draw_parity.cpp index d7142a1bb4..23ba25860c 100644 --- a/tests/data/test_draw_parity.cpp +++ b/tests/data/test_draw_parity.cpp @@ -569,6 +569,34 @@ TEST_CASE("Draws asked for inside a bloom exclusion and drawn later are drawn in CheckDrawnLaterAsAtOnce(scene, "CachedSkinned"); } +TEST_CASE("Characters drawn later are drawn inside the character scope they were asked for in [draw-parity]") +{ + PlayerModels models; + static float firstBones[MAX_BONES][3][4]; + static float secondBones[MAX_BONES][3][4]; + OBJECT first; + OBJECT second; + Place(first, 100.f, 2.5f, firstBones); + Place(second, 400.f, 5.5f, secondBones); + AnimateCharacterBones(&first); + AnimateCharacterBones(&second); + BeginObjectDraws(); + Engine::Object::Attachments::BeginFrame(); + + const vec3_t light = {1.f, 1.f, 1.f}; + const auto scene = [&] + { + { + const Render::Drawing::ScopedCharacterDraws characters; + RenderPartObject(&first, MODEL_BODY_ARMOR, nullptr, light, 1.f, 0, 0, 0, false, false, true, 0, + RENDER_TEXTURE); + } + RenderPartObject(&second, MODEL_BODY_ARMOR, nullptr, light, 1.f, 0, 0, 0, false, false, true, 0, + RENDER_TEXTURE); + }; + CheckDrawnLaterAsAtOnce(scene, "CachedSkinned"); +} + TEST_CASE("A cloth's shadow drawn later falls where the cloth was when it was asked for [draw-parity]") { PlayerModels models; diff --git a/tests/render/test_model_draw.cpp b/tests/render/test_model_draw.cpp index 9698daec31..87ec6536ee 100644 --- a/tests/render/test_model_draw.cpp +++ b/tests/render/test_model_draw.cpp @@ -3,11 +3,15 @@ #include #include "Engine/Physics/PhysicsManager.h" +#include "Render/Drawing/DrawCallLog.h" +#include "Render/Renderer/MuRenderer.h" #include "Render/Models/ModelDraw.h" #include "Render/Models/ZzzBMD.h" #include "Render/Sprites/TextureScript.h" +#include #include +#include #include namespace @@ -171,6 +175,41 @@ TEST_CASE("RenderBodyShadow hands the active drawer the call and the model state CHECK(draw.lod == 2); } +TEST_CASE("A shadow draws the casts it carries, whatever the frame's light is by then [render][model_draw]") +{ + auto model = std::make_unique(); + GridCloth cloth(0.f); + RecordingDrawer drawer; + { + DrawerScope scope(drawer); + model->RenderBodyShadow(-1, -1, -1, -1, &cloth, 1, 1.f); + } + REQUIRE(drawer.shadows.size() == 1); + Render::ModelDrawing::ShadowDraw draw = drawer.shadows.front(); + + const auto countsOf = [&](const char* state) + { + Render::Drawing::DrawCallLog log; + mu::SetRendererOverride(&log); + model->DrawShadow(draw); + mu::SetRendererOverride(nullptr); + return std::count_if(log.calls.begin(), log.calls.end(), [&](const std::string& call) + { return call.starts_with("Triangles") && call.find(state) != std::string::npos; }); + }; + + draw.flatStrength = 1.f; + draw.lightCastCount = 0; + CHECK(countsOf("groundShadow 10") == 1); + CHECK(countsOf("groundShadow 01") == 0); + + draw.flatStrength = 0.f; + draw.lightCastCount = 2; + draw.lightCasts[0] = {0.f, 0.5f}; + draw.lightCasts[1] = {1.f, 0.25f}; + CHECK(countsOf("groundShadow 10") == 0); + CHECK(countsOf("groundShadow 01") == 2); +} + TEST_CASE("Both draws carry the skinning the model's last Transform set up [render][model_draw]") { extern float BoneScale; diff --git a/tests/render/test_projected_shadow_state.cmake b/tests/render/test_projected_shadow_state.cmake index 490a94f70f..508b9d161f 100644 --- a/tests/render/test_projected_shadow_state.cmake +++ b/tests/render/test_projected_shadow_state.cmake @@ -21,7 +21,7 @@ string(SUBSTRING "${bmd_source}" ${shadow_start} ${shadow_length} projected_shad # Every path (GPU, CPU fallback, cloth) records inside the ground-shadow scope, so a world-lit frame # draws them into the ground shadow mask. string(FIND "${projected_shadow_source}" "const mu::ScopedGroundShadow groundShadow;" scope_position) -string(FIND "${projected_shadow_source}" "drawShadow(draw.alpha * flatSunShadow);" first_draw_position) +string(FIND "${projected_shadow_source}" "drawShadow(draw.alpha * draw.flatStrength);" first_draw_position) if(scope_position EQUAL -1 OR first_draw_position LESS scope_position) message(FATAL_ERROR "Projected body shadows must be recorded inside a ScopedGroundShadow") endif()