From 6ddf4b241f19ecec89b867fc8d5fa30d1645fd12 Mon Sep 17 00:00:00 2001 From: Steveice10 <1269164+Steveice10@users.noreply.github.com> Date: Thu, 17 Aug 2023 13:22:25 -0700 Subject: [PATCH] renderer/vulkan: Emulate custom border colors in shaders when unavailable. (#6878) --- CMakeModules/GenerateSCMRev.cmake | 8 + src/video_core/rasterizer_accelerated.cpp | 21 ++ src/video_core/rasterizer_accelerated.h | 3 + .../renderer_vulkan/vk_instance.cpp | 4 +- .../renderer_vulkan/vk_shader_gen.cpp | 162 ++++++---- .../renderer_vulkan/vk_shader_gen.h | 5 + .../renderer_vulkan/vk_shader_gen_spv.cpp | 292 ++++++++++-------- .../renderer_vulkan/vk_shader_gen_spv.h | 18 +- src/video_core/shader/shader_uniforms.cpp | 1 + src/video_core/shader/shader_uniforms.h | 3 +- 10 files changed, 322 insertions(+), 195 deletions(-) diff --git a/CMakeModules/GenerateSCMRev.cmake b/CMakeModules/GenerateSCMRev.cmake index f0c8e7da6..ee077cbbd 100644 --- a/CMakeModules/GenerateSCMRev.cmake +++ b/CMakeModules/GenerateSCMRev.cmake @@ -12,8 +12,16 @@ set(HASH_FILES "${VIDEO_CORE}/renderer_opengl/gl_shader_gen.h" "${VIDEO_CORE}/renderer_opengl/gl_shader_util.cpp" "${VIDEO_CORE}/renderer_opengl/gl_shader_util.h" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_gen.cpp" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_gen.h" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_gen_spv.cpp" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_gen_spv.h" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_util.cpp" + "${VIDEO_CORE}/renderer_vulkan/vk_shader_util.h" "${VIDEO_CORE}/shader/shader.cpp" "${VIDEO_CORE}/shader/shader.h" + "${VIDEO_CORE}/shader/shader_uniforms.cpp" + "${VIDEO_CORE}/shader/shader_uniforms.h" "${VIDEO_CORE}/pica.cpp" "${VIDEO_CORE}/pica.h" "${VIDEO_CORE}/regs_framebuffer.h" diff --git a/src/video_core/rasterizer_accelerated.cpp b/src/video_core/rasterizer_accelerated.cpp index 2dcae06f8..bcd40354d 100644 --- a/src/video_core/rasterizer_accelerated.cpp +++ b/src/video_core/rasterizer_accelerated.cpp @@ -599,6 +599,17 @@ void RasterizerAccelerated::NotifyPicaRegisterChanged(u32 id) { SyncTextureLodBias(2); break; + // Texture borders + case PICA_REG_INDEX(texturing.texture0.border_color): + SyncTextureBorderColor(0); + break; + case PICA_REG_INDEX(texturing.texture1.border_color): + SyncTextureBorderColor(1); + break; + case PICA_REG_INDEX(texturing.texture2.border_color): + SyncTextureBorderColor(2); + break; + // Clipping plane case PICA_REG_INDEX(rasterizer.clip_coef[0]): case PICA_REG_INDEX(rasterizer.clip_coef[1]): @@ -821,6 +832,16 @@ void RasterizerAccelerated::SyncTextureLodBias(int tex_index) { } } +void RasterizerAccelerated::SyncTextureBorderColor(int tex_index) { + const auto pica_textures = regs.texturing.GetTextures(); + const auto params = pica_textures[tex_index].config; + const Common::Vec4f border_color = ColorRGBA8(params.border_color.raw); + if (border_color != uniform_block_data.data.tex_border_color[tex_index]) { + uniform_block_data.data.tex_border_color[tex_index] = border_color; + uniform_block_data.dirty = true; + } +} + void RasterizerAccelerated::SyncClipCoef() { const auto raw_clip_coef = regs.rasterizer.GetClipCoef(); const Common::Vec4f new_clip_coef = {raw_clip_coef.x.ToFloat32(), raw_clip_coef.y.ToFloat32(), diff --git a/src/video_core/rasterizer_accelerated.h b/src/video_core/rasterizer_accelerated.h index d9191226b..2ad11ee32 100644 --- a/src/video_core/rasterizer_accelerated.h +++ b/src/video_core/rasterizer_accelerated.h @@ -97,6 +97,9 @@ protected: /// Syncs the texture LOD bias to match the PICA register void SyncTextureLodBias(int tex_index); + /// Syncs the texture border color to match the PICA registers + void SyncTextureBorderColor(int tex_index); + /// Syncs the clip coefficients to match the PICA register void SyncClipCoef(); diff --git a/src/video_core/renderer_vulkan/vk_instance.cpp b/src/video_core/renderer_vulkan/vk_instance.cpp index 2388032a8..9d1b1935e 100644 --- a/src/video_core/renderer_vulkan/vk_instance.cpp +++ b/src/video_core/renderer_vulkan/vk_instance.cpp @@ -409,7 +409,9 @@ bool Instance::CreateDevice() { const bool has_extended_dynamic_state = add_extension(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, is_arm || is_qualcomm, "it is broken on Qualcomm and ARM drivers"); - const bool has_custom_border_color = add_extension(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME); + const bool has_custom_border_color = + add_extension(VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME, is_qualcomm, + "it is broken on most Qualcomm driver versions"); const bool has_index_type_uint8 = add_extension(VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME); const bool has_pipeline_creation_cache_control = add_extension(VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME); diff --git a/src/video_core/renderer_vulkan/vk_shader_gen.cpp b/src/video_core/renderer_vulkan/vk_shader_gen.cpp index 8ad0eb4d8..bfd954b84 100644 --- a/src/video_core/renderer_vulkan/vk_shader_gen.cpp +++ b/src/video_core/renderer_vulkan/vk_shader_gen.cpp @@ -69,6 +69,17 @@ PicaFSConfig::PicaFSConfig(const Pica::Regs& regs, const Instance& instance) { state.texture2_use_coord1.Assign(regs.texturing.main_config.texture2_use_coord1 != 0); + const auto pica_textures = regs.texturing.GetTextures(); + for (u32 tex_index = 0; tex_index < 3; tex_index++) { + const auto config = pica_textures[tex_index].config; + state.texture_border_color[tex_index].enable_s.Assign( + !instance.IsCustomBorderColorSupported() && + config.wrap_s == TexturingRegs::TextureConfig::WrapMode::ClampToBorder); + state.texture_border_color[tex_index].enable_t.Assign( + !instance.IsCustomBorderColorSupported() && + config.wrap_t == TexturingRegs::TextureConfig::WrapMode::ClampToBorder); + } + // Emulate logic op in the shader if not supported. This is mostly for mobile GPUs const bool emulate_logic_op = instance.NeedsLogicOpEmulation() && !Pica::g_state.regs.framebuffer.output_merger.alphablend_enable; @@ -284,54 +295,6 @@ static bool IsPassThroughTevStage(const TevStageConfig& stage) { stage.GetColorMultiplier() == 1 && stage.GetAlphaMultiplier() == 1); } -static std::string SampleTexture(const PicaFSConfig& config, unsigned texture_unit) { - const auto& state = config.state; - switch (texture_unit) { - case 0: - // Only unit 0 respects the texturing type - switch (state.texture0_type) { - case TexturingRegs::TextureConfig::Texture2D: - return "textureLod(tex0, texcoord0, getLod(texcoord0 * " - "vec2(textureSize(tex0, 0))) + tex_lod_bias[0])"; - case TexturingRegs::TextureConfig::Projection2D: - // TODO (wwylele): find the exact LOD formula for projection texture - return "textureProj(tex0, vec3(texcoord0, texcoord0_w))"; - case TexturingRegs::TextureConfig::TextureCube: - return "texture(tex_cube, vec3(texcoord0, texcoord0_w))"; - case TexturingRegs::TextureConfig::Shadow2D: - return "shadowTexture(texcoord0, texcoord0_w)"; - case TexturingRegs::TextureConfig::ShadowCube: - return "shadowTextureCube(texcoord0, texcoord0_w)"; - case TexturingRegs::TextureConfig::Disabled: - return "vec4(0.0)"; - default: - LOG_CRITICAL(HW_GPU, "Unhandled texture type {:x}", state.texture0_type); - UNIMPLEMENTED(); - return "texture(tex0, texcoord0)"; - } - case 1: - return "textureLod(tex1, texcoord1, getLod(texcoord1 * " - "vec2(textureSize(tex1, 0))) + tex_lod_bias[1])"; - case 2: - if (state.texture2_use_coord1) - return "textureLod(tex2, texcoord1, getLod(texcoord1 * " - "vec2(textureSize(tex2, 0))) + tex_lod_bias[2])"; - else - return "textureLod(tex2, texcoord2, getLod(texcoord2 * " - "vec2(textureSize(tex2, 0))) + tex_lod_bias[2])"; - case 3: - if (state.proctex.enable) { - return "ProcTex()"; - } else { - LOG_DEBUG(Render_OpenGL, "Using Texture3 without enabling it"); - return "vec4(0.0)"; - } - default: - UNREACHABLE(); - return ""; - } -} - /// Writes the specified TEV stage source component(s) static void AppendSource(std::string& out, const PicaFSConfig& config, TevStageConfig::Source source, std::string_view index_name) { @@ -347,16 +310,16 @@ static void AppendSource(std::string& out, const PicaFSConfig& config, out += "secondary_fragment_color"; break; case Source::Texture0: - out += SampleTexture(config, 0); + out += "sampleTexUnit0()"; break; case Source::Texture1: - out += SampleTexture(config, 1); + out += "sampleTexUnit1()"; break; case Source::Texture2: - out += SampleTexture(config, 2); + out += "sampleTexUnit2()"; break; case Source::Texture3: - out += SampleTexture(config, 3); + out += "sampleTexUnit3()"; break; case Source::PreviousBuffer: out += "combiner_buffer"; @@ -656,7 +619,7 @@ static void WriteLighting(std::string& out, const PicaFSConfig& config) { // Compute fragment normals and tangents const auto perturbation = [&] { - return fmt::format("2.0 * ({}).rgb - 1.0", SampleTexture(config, lighting.bump_selector)); + return fmt::format("2.0 * (sampleTexUnit{}()).rgb - 1.0", lighting.bump_selector); }; switch (lighting.bump_mode) { @@ -700,7 +663,7 @@ static void WriteLighting(std::string& out, const PicaFSConfig& config) { "vec3 tangent = quaternion_rotate(normalized_normquat, surface_tangent);\n"; if (lighting.enable_shadow) { - std::string shadow_texture = SampleTexture(config, lighting.shadow_selector); + std::string shadow_texture = fmt::format("sampleTexUnit{}()", lighting.shadow_selector); if (lighting.shadow_invert) { out += fmt::format("vec4 shadow = vec4(1.0) - {};\n", shadow_texture); } else { @@ -1310,6 +1273,7 @@ float mix2(vec4 s, vec2 a) { vec4 shadowTexture(vec2 uv, float w) { )"; + if (!config.state.shadow_texture_orthographic) { out += "uv /= w;"; } @@ -1344,9 +1308,7 @@ vec4 shadowTextureCube(vec2 uv, float w) { uv = -c.xy; if (c.z > 0.0) uv.x = -uv.x; } -)"; - out += "uint z = uint(max(0, int(min(w, 1.0) * float(0xFFFFFF)) - shadow_texture_bias));"; - out += R"( + uint z = uint(max(0, int(min(w, 1.0) * float(0xFFFFFF)) - shadow_texture_bias)); vec2 coord = vec2(size) * (uv / w * vec2(0.5) + vec2(0.5)) - vec2(0.5); vec2 coord_floor = floor(coord); vec2 f = coord - coord_floor; @@ -1409,10 +1371,92 @@ vec4 shadowTextureCube(vec2 uv, float w) { CompareShadow(pixels.w, z)); return vec4(mix2(s, f)); } -)"; + )"; - if (config.state.proctex.enable) + if (config.state.proctex.enable) { AppendProcTexSampler(out, config); + } + + for (u32 texture_unit = 0; texture_unit < 4; texture_unit++) { + out += fmt::format("vec4 sampleTexUnit{}() {{", texture_unit); + if (texture_unit == 0 && state.texture0_type == TexturingRegs::TextureConfig::Disabled) { + out += "return vec4(0.0);}"; + continue; + } else if (texture_unit == 3) { + if (state.proctex.enable) { + out += "return ProcTex();}"; + } else { + out += "return vec4(0.0);}"; + } + continue; + } + + u32 texcoord_num = texture_unit == 2 && state.texture2_use_coord1 ? 1 : texture_unit; + if (config.state.texture_border_color[texture_unit].enable_s) { + out += fmt::format(R"( + if (texcoord{}.x < 0 || texcoord{}.x > 1) {{ + return tex_border_color[{}]; + }} + )", + texcoord_num, texcoord_num, texture_unit); + } + if (config.state.texture_border_color[texture_unit].enable_t) { + out += fmt::format(R"( + if (texcoord{}.y < 0 || texcoord{}.y > 1) {{ + return tex_border_color[{}]; + }} + )", + texcoord_num, texcoord_num, texture_unit); + } + // TODO: 3D border? + + switch (texture_unit) { + case 0: + // Only unit 0 respects the texturing type + switch (state.texture0_type) { + case TexturingRegs::TextureConfig::Texture2D: + out += "return textureLod(tex0, texcoord0, getLod(texcoord0 * " + "vec2(textureSize(tex0, 0))) + tex_lod_bias[0]);"; + break; + case TexturingRegs::TextureConfig::Projection2D: + // TODO (wwylele): find the exact LOD formula for projection texture + out += "return textureProj(tex0, vec3(texcoord0, texcoord0_w));"; + break; + case TexturingRegs::TextureConfig::TextureCube: + out += "return texture(tex_cube, vec3(texcoord0, texcoord0_w));"; + break; + case TexturingRegs::TextureConfig::Shadow2D: + out += "return shadowTexture(texcoord0, texcoord0_w);"; + break; + case TexturingRegs::TextureConfig::ShadowCube: + out += "return shadowTextureCube(texcoord0, texcoord0_w);"; + break; + default: + LOG_CRITICAL(HW_GPU, "Unhandled texture type {:x}", state.texture0_type); + UNIMPLEMENTED(); + out += "return texture(tex0, texcoord0);"; + break; + } + case 1: + out += "return textureLod(tex1, texcoord1, getLod(texcoord1 * vec2(textureSize(tex1, " + "0))) + tex_lod_bias[1]);"; + break; + case 2: + if (state.texture2_use_coord1) { + out += "return textureLod(tex2, texcoord1, getLod(texcoord1 * " + "vec2(textureSize(tex2, 0))) + tex_lod_bias[1]);"; + } else { + out += "return textureLod(tex2, texcoord2, getLod(texcoord2 * " + "vec2(textureSize(tex2, 0))) + tex_lod_bias[2]);"; + } + break; + default: + UNREACHABLE(); + break; + } + + out += "}"; + } // We round the interpolated primary color to the nearest 1/255th // This maintains the PICA's 8 bits of precision diff --git a/src/video_core/renderer_vulkan/vk_shader_gen.h b/src/video_core/renderer_vulkan/vk_shader_gen.h index bd901b006..52fa832ff 100644 --- a/src/video_core/renderer_vulkan/vk_shader_gen.h +++ b/src/video_core/renderer_vulkan/vk_shader_gen.h @@ -57,6 +57,11 @@ struct PicaFSConfigState { BitField<28, 1, u32> shadow_texture_orthographic; }; + union { + BitField<0, 1, u32> enable_s; + BitField<1, 1, u32> enable_t; + } texture_border_color[3]; + std::array tev_stages; struct { diff --git a/src/video_core/renderer_vulkan/vk_shader_gen_spv.cpp b/src/video_core/renderer_vulkan/vk_shader_gen_spv.cpp index cf26a927f..332021944 100644 --- a/src/video_core/renderer_vulkan/vk_shader_gen_spv.cpp +++ b/src/video_core/renderer_vulkan/vk_shader_gen_spv.cpp @@ -21,8 +21,8 @@ FragmentModule::FragmentModule(Core::TelemetrySession& telemetry_, const PicaFSC DefineArithmeticTypes(); DefineUniformStructs(); DefineInterface(); - if (config.state.proctex.enable) { - DefineProcTexSampler(); + for (u32 i = 0; i < NUM_TEX_UNITS; i++) { + DefineTexSampler(i); } DefineEntryPoint(); } @@ -225,7 +225,8 @@ void FragmentModule::WriteLighting() { // Compute fragment normals and tangents const auto perturbation = [&]() -> Id { - const Id texel{SampleTexture(lighting.bump_selector)}; + const Id texel{ + OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[lighting.bump_selector])}; const Id texel_rgb{OpVectorShuffle(vec_ids.Get(3), texel, texel, 0, 1, 2)}; const Id rgb_mul_two{OpVectorTimesScalar(vec_ids.Get(3), texel_rgb, ConstF32(2.f))}; return OpFSub(vec_ids.Get(3), rgb_mul_two, ConstF32(1.f, 1.f, 1.f)); @@ -284,7 +285,7 @@ void FragmentModule::WriteLighting() { Id shadow{ConstF32(1.f, 1.f, 1.f, 1.f)}; if (lighting.enable_shadow) { - shadow = SampleTexture(lighting.shadow_selector); + shadow = OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[lighting.shadow_selector]); if (lighting.shadow_invert) { shadow = OpFSub(vec_ids.Get(4), ConstF32(1.f, 1.f, 1.f, 1.f), shadow); } @@ -710,89 +711,6 @@ void FragmentModule::WriteAlphaTestCondition(FramebufferRegs::CompareFunc func) } } -Id FragmentModule::SampleTexture(u32 texture_unit) { - const PicaFSConfigState& state = config.state; - const Id zero_vec{ConstF32(0.f, 0.f, 0.f, 0.f)}; - - // PICA's LOD formula for 2D textures. - // This LOD formula is the same as the LOD lower limit defined in OpenGL. - // f(x, y) >= max{m_u, m_v, m_w} - // (See OpenGL 4.6 spec, 8.14.1 - Scale Factor and Level-of-Detail) - const auto sample_lod = [this, texture_unit](Id tex_id, Id texcoord_id) { - const Id sampled_image{OpLoad(TypeSampledImage(image2d_id), tex_id)}; - const Id tex_image{OpImage(image2d_id, sampled_image)}; - const Id tex_size{OpImageQuerySizeLod(ivec_ids.Get(2), tex_image, ConstS32(0))}; - const Id texcoord{OpLoad(vec_ids.Get(2), texcoord_id)}; - const Id coord{OpFMul(vec_ids.Get(2), texcoord, OpConvertSToF(vec_ids.Get(2), tex_size))}; - const Id abs_dfdx_coord{OpFAbs(vec_ids.Get(2), OpDPdx(vec_ids.Get(2), coord))}; - const Id abs_dfdy_coord{OpFAbs(vec_ids.Get(2), OpDPdy(vec_ids.Get(2), coord))}; - const Id d{OpFMax(vec_ids.Get(2), abs_dfdx_coord, abs_dfdy_coord)}; - const Id dx_dy_max{ - OpFMax(f32_id, OpCompositeExtract(f32_id, d, 0), OpCompositeExtract(f32_id, d, 1))}; - const Id lod{OpLog2(f32_id, dx_dy_max)}; - const Id lod_bias{GetShaderDataMember(f32_id, ConstS32(28), ConstU32(texture_unit))}; - const Id biased_lod{OpFAdd(f32_id, lod, lod_bias)}; - return OpImageSampleExplicitLod(vec_ids.Get(4), sampled_image, texcoord, - spv::ImageOperandsMask::Lod, biased_lod); - }; - - const auto sample = [this](Id tex_id, bool projection) { - const Id image_type = tex_id.value == tex_cube_id.value ? image_cube_id : image2d_id; - const Id sampled_image{OpLoad(TypeSampledImage(image_type), tex_id)}; - const Id texcoord0{OpLoad(vec_ids.Get(2), texcoord0_id)}; - const Id texcoord0_w{OpLoad(f32_id, texcoord0_w_id)}; - const Id coord{OpCompositeConstruct(vec_ids.Get(3), - OpCompositeExtract(f32_id, texcoord0, 0), - OpCompositeExtract(f32_id, texcoord0, 1), texcoord0_w)}; - if (projection) { - return OpImageSampleProjImplicitLod(vec_ids.Get(4), sampled_image, coord); - } else { - return OpImageSampleImplicitLod(vec_ids.Get(4), sampled_image, coord); - } - }; - - switch (texture_unit) { - case 0: - // Only unit 0 respects the texturing type - switch (state.texture0_type) { - case Pica::TexturingRegs::TextureConfig::Texture2D: - return sample_lod(tex0_id, texcoord0_id); - case Pica::TexturingRegs::TextureConfig::Projection2D: - return sample(tex0_id, true); - case Pica::TexturingRegs::TextureConfig::TextureCube: - return sample(tex_cube_id, false); - case Pica::TexturingRegs::TextureConfig::Shadow2D: - return SampleShadow(); - // case Pica::TexturingRegs::TextureConfig::ShadowCube: - // return "shadowTextureCube(texcoord0, texcoord0_w)"; - case Pica::TexturingRegs::TextureConfig::Disabled: - return zero_vec; - default: - LOG_CRITICAL(Render_Vulkan, "Unhandled texture type {:x}", state.texture0_type); - UNIMPLEMENTED(); - return zero_vec; - } - case 1: - return sample_lod(tex1_id, texcoord1_id); - case 2: - if (state.texture2_use_coord1) { - return sample_lod(tex2_id, texcoord1_id); - } else { - return sample_lod(tex2_id, texcoord2_id); - } - case 3: - if (state.proctex.enable) { - return OpFunctionCall(vec_ids.Get(4), proctex_func); - } else { - LOG_DEBUG(Render_Vulkan, "Using Texture3 without enabling it"); - return zero_vec; - } - default: - UNREACHABLE(); - return void_id; - } -} - Id FragmentModule::CompareShadow(Id pixel, Id z) { const Id pixel_d24{OpShiftRightLogical(u32_id, pixel, ConstS32(8))}; const Id pixel_s8{OpConvertUToF(f32_id, OpBitwiseAnd(u32_id, pixel, ConstU32(255u)))}; @@ -802,7 +720,7 @@ Id FragmentModule::CompareShadow(Id pixel, Id z) { } Id FragmentModule::SampleShadow() { - const Id texcoord0{OpLoad(vec_ids.Get(2), texcoord0_id)}; + const Id texcoord0{OpLoad(vec_ids.Get(2), texcoord_id[0])}; const Id texcoord0_w{OpLoad(f32_id, texcoord0_w_id)}; const Id abs_min_w{OpFMul(f32_id, OpFMin(f32_id, OpFAbs(f32_id, texcoord0_w), ConstF32(1.f)), ConstF32(16777215.f))}; @@ -941,11 +859,145 @@ Id FragmentModule::AppendProcTexCombineAndMap(ProcTexCombiner combiner, Id u, Id return ProcTexLookupLUT(offset, combined); } -void FragmentModule::DefineProcTexSampler() { +void FragmentModule::DefineTexSampler(u32 texture_unit) { + const PicaFSConfigState& state = config.state; + const Id func_type{TypeFunction(vec_ids.Get(4))}; - proctex_func = OpFunction(vec_ids.Get(4), spv::FunctionControlMask::MaskNone, func_type); + sample_tex_unit_func[texture_unit] = + OpFunction(vec_ids.Get(4), spv::FunctionControlMask::MaskNone, func_type); AddLabel(OpLabel()); + const Id zero_vec{ConstF32(0.f, 0.f, 0.f, 0.f)}; + + if (texture_unit == 0 && state.texture0_type == TexturingRegs::TextureConfig::Disabled) { + OpReturnValue(zero_vec); + OpFunctionEnd(); + return; + } + + if (texture_unit == 3) { + if (state.proctex.enable) { + OpReturnValue(ProcTexSampler()); + } else { + OpReturnValue(zero_vec); + } + OpFunctionEnd(); + return; + } + + const Id border_label{OpLabel()}; + const Id not_border_label{OpLabel()}; + + u32 texcoord_num = texture_unit == 2 && state.texture2_use_coord1 ? 1 : texture_unit; + const Id texcoord{OpLoad(vec_ids.Get(2), texcoord_id[texcoord_num])}; + + auto& texture_border_color = state.texture_border_color[texture_unit]; + if (texture_border_color.enable_s || texture_border_color.enable_t) { + const Id texcoord_s{OpCompositeExtract(f32_id, texcoord, 0)}; + const Id texcoord_t{OpCompositeExtract(f32_id, texcoord, 1)}; + + const Id s_lt_zero{OpFOrdLessThan(bool_id, texcoord_s, ConstF32(0.0f))}; + const Id s_gt_one{OpFOrdGreaterThan(bool_id, texcoord_s, ConstF32(1.0f))}; + const Id t_lt_zero{OpFOrdLessThan(bool_id, texcoord_t, ConstF32(0.0f))}; + const Id t_gt_one{OpFOrdGreaterThan(bool_id, texcoord_t, ConstF32(1.0f))}; + + Id cond{}; + if (texture_border_color.enable_s && texture_border_color.enable_t) { + cond = OpAny(bool_id, OpCompositeConstruct(bvec_ids.Get(4), s_lt_zero, s_gt_one, + t_lt_zero, t_gt_one)); + } else if (texture_border_color.enable_s) { + cond = OpAny(bool_id, OpCompositeConstruct(bvec_ids.Get(2), s_lt_zero, s_gt_one)); + } else if (texture_border_color.enable_t) { + cond = OpAny(bool_id, OpCompositeConstruct(bvec_ids.Get(2), t_lt_zero, t_gt_one)); + } + + OpSelectionMerge(not_border_label, spv::SelectionControlMask::MaskNone); + OpBranchConditional(cond, border_label, not_border_label); + + AddLabel(border_label); + const Id border_color{ + GetShaderDataMember(vec_ids.Get(4), ConstS32(29), ConstU32(texture_unit))}; + OpReturnValue(border_color); + + AddLabel(not_border_label); + } + + // PICA's LOD formula for 2D textures. + // This LOD formula is the same as the LOD lower limit defined in OpenGL. + // f(x, y) >= max{m_u, m_v, m_w} + // (See OpenGL 4.6 spec, 8.14.1 - Scale Factor and Level-of-Detail) + const auto sample_lod = [&](Id tex_id) { + const Id sampled_image{OpLoad(TypeSampledImage(image2d_id), tex_id)}; + const Id tex_image{OpImage(image2d_id, sampled_image)}; + const Id tex_size{OpImageQuerySizeLod(ivec_ids.Get(2), tex_image, ConstS32(0))}; + const Id coord{OpFMul(vec_ids.Get(2), texcoord, OpConvertSToF(vec_ids.Get(2), tex_size))}; + const Id abs_dfdx_coord{OpFAbs(vec_ids.Get(2), OpDPdx(vec_ids.Get(2), coord))}; + const Id abs_dfdy_coord{OpFAbs(vec_ids.Get(2), OpDPdy(vec_ids.Get(2), coord))}; + const Id d{OpFMax(vec_ids.Get(2), abs_dfdx_coord, abs_dfdy_coord)}; + const Id dx_dy_max{ + OpFMax(f32_id, OpCompositeExtract(f32_id, d, 0), OpCompositeExtract(f32_id, d, 1))}; + const Id lod{OpLog2(f32_id, dx_dy_max)}; + const Id lod_bias{GetShaderDataMember(f32_id, ConstS32(28), ConstU32(texture_unit))}; + const Id biased_lod{OpFAdd(f32_id, lod, lod_bias)}; + return OpImageSampleExplicitLod(vec_ids.Get(4), sampled_image, texcoord, + spv::ImageOperandsMask::Lod, biased_lod); + }; + + const auto sample_3d = [&](Id tex_id, bool projection) { + const Id image_type = tex_id.value == tex_cube_id.value ? image_cube_id : image2d_id; + const Id sampled_image{OpLoad(TypeSampledImage(image_type), tex_id)}; + const Id texcoord0_w{OpLoad(f32_id, texcoord0_w_id)}; + const Id coord{OpCompositeConstruct(vec_ids.Get(3), OpCompositeExtract(f32_id, texcoord, 0), + OpCompositeExtract(f32_id, texcoord, 1), texcoord0_w)}; + if (projection) { + return OpImageSampleProjImplicitLod(vec_ids.Get(4), sampled_image, coord); + } else { + return OpImageSampleImplicitLod(vec_ids.Get(4), sampled_image, coord); + } + }; + + Id ret_val{void_id}; + switch (texture_unit) { + case 0: + // Only unit 0 respects the texturing type + switch (state.texture0_type) { + case Pica::TexturingRegs::TextureConfig::Texture2D: + ret_val = sample_lod(tex0_id); + break; + case Pica::TexturingRegs::TextureConfig::Projection2D: + ret_val = sample_3d(tex0_id, true); + break; + case Pica::TexturingRegs::TextureConfig::TextureCube: + ret_val = sample_3d(tex_cube_id, false); + break; + case Pica::TexturingRegs::TextureConfig::Shadow2D: + ret_val = SampleShadow(); + // case Pica::TexturingRegs::TextureConfig::ShadowCube: + // return "shadowTextureCube(texcoord0, texcoord0_w)"; + break; + default: + LOG_CRITICAL(Render_Vulkan, "Unhandled texture type {:x}", state.texture0_type); + UNIMPLEMENTED(); + ret_val = zero_vec; + break; + } + break; + case 1: + ret_val = sample_lod(tex1_id); + break; + case 2: + ret_val = sample_lod(tex2_id); + break; + default: + UNREACHABLE(); + break; + } + + OpReturnValue(ret_val); + OpFunctionEnd(); +} + +Id FragmentModule::ProcTexSampler() { // Define noise tables at the beginning of the function if (config.state.proctex.noise_enable) { noise1d_table = @@ -957,24 +1009,11 @@ void FragmentModule::DefineProcTexSampler() { Id uv{}; if (config.state.proctex.coord < 3) { - Id texcoord_id{}; - switch (config.state.proctex.coord.Value()) { - case 0: - texcoord_id = texcoord0_id; - break; - case 1: - texcoord_id = texcoord1_id; - break; - case 2: - texcoord_id = texcoord2_id; - break; - } - - const Id texcoord{OpLoad(vec_ids.Get(2), texcoord_id)}; + const Id texcoord{OpLoad(vec_ids.Get(2), texcoord_id[config.state.proctex.coord.Value()])}; uv = OpFAbs(vec_ids.Get(2), texcoord); } else { LOG_CRITICAL(Render_Vulkan, "Unexpected proctex.coord >= 3"); - uv = OpFAbs(vec_ids.Get(2), OpLoad(vec_ids.Get(2), texcoord0_id)); + uv = OpFAbs(vec_ids.Get(2), OpLoad(vec_ids.Get(2), texcoord_id[0])); } // This LOD formula is the same as the LOD upper limit defined in OpenGL. @@ -1058,8 +1097,7 @@ void FragmentModule::DefineProcTexSampler() { final_color = OpCompositeInsert(vec_ids.Get(4), final_alpha, final_color, 3); } - OpReturnValue(final_color); - OpFunctionEnd(); + return final_color; } Id FragmentModule::Byteround(Id variable_id, u32 size) { @@ -1226,13 +1264,13 @@ Id FragmentModule::AppendSource(TevStageConfig::Source source, s32 index) { case Source::SecondaryFragmentColor: return secondary_fragment_color; case Source::Texture0: - return SampleTexture(0); + return OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[0]); case Source::Texture1: - return SampleTexture(1); + return OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[1]); case Source::Texture2: - return SampleTexture(2); + return OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[2]); case Source::Texture3: - return SampleTexture(3); + return OpFunctionCall(vec_ids.Get(4), sample_tex_unit_func[3]); case Source::PreviousBuffer: return combiner_buffer; case Source::Constant: @@ -1428,9 +1466,9 @@ void FragmentModule::DefineEntryPoint() { const Id main_type{TypeFunction(TypeVoid())}; const Id main_func{OpFunction(TypeVoid(), spv::FunctionControlMask::MaskNone, main_type)}; - AddEntryPoint(spv::ExecutionModel::Fragment, main_func, "main", primary_color_id, texcoord0_id, - texcoord1_id, texcoord2_id, texcoord0_w_id, normquat_id, view_id, color_id, - gl_frag_coord_id, gl_frag_depth_id); + AddEntryPoint(spv::ExecutionModel::Fragment, main_func, "main", primary_color_id, + texcoord_id[0], texcoord_id[1], texcoord_id[2], texcoord0_w_id, normquat_id, + view_id, color_id, gl_frag_coord_id, gl_frag_depth_id); AddExecutionMode(main_func, spv::ExecutionMode::OriginUpperLeft); AddExecutionMode(main_func, spv::ExecutionMode::DepthReplacing); } @@ -1443,21 +1481,25 @@ void FragmentModule::DefineUniformStructs() { const Id light_src_array_id{TypeArray(light_src_struct_id, ConstU32(NUM_LIGHTS))}; const Id lighting_lut_array_id{TypeArray(ivec_ids.Get(4), ConstU32(NUM_LIGHTING_SAMPLERS / 4))}; const Id const_color_array_id{TypeArray(vec_ids.Get(4), ConstU32(NUM_TEV_STAGES))}; + const Id border_color_array_id{TypeArray(vec_ids.Get(4), ConstU32(NUM_NON_PROC_TEX_UNITS))}; - const Id shader_data_struct_id{TypeStruct( - i32_id, i32_id, f32_id, f32_id, f32_id, f32_id, i32_id, i32_id, i32_id, i32_id, i32_id, - i32_id, i32_id, i32_id, i32_id, i32_id, f32_id, i32_id, u32_id, lighting_lut_array_id, - vec_ids.Get(3), vec_ids.Get(2), vec_ids.Get(2), vec_ids.Get(2), vec_ids.Get(3), - light_src_array_id, const_color_array_id, vec_ids.Get(4), vec_ids.Get(3), vec_ids.Get(4))}; + const Id shader_data_struct_id{ + TypeStruct(i32_id, i32_id, f32_id, f32_id, f32_id, f32_id, i32_id, i32_id, i32_id, i32_id, + i32_id, i32_id, i32_id, i32_id, i32_id, i32_id, f32_id, i32_id, u32_id, + lighting_lut_array_id, vec_ids.Get(3), vec_ids.Get(2), vec_ids.Get(2), + vec_ids.Get(2), vec_ids.Get(3), light_src_array_id, const_color_array_id, + vec_ids.Get(4), vec_ids.Get(3), border_color_array_id, vec_ids.Get(4))}; constexpr std::array light_src_offsets{0u, 16u, 32u, 48u, 64u, 80u, 92u, 96u}; - constexpr std::array shader_data_offsets{ - 0u, 4u, 8u, 12u, 16u, 20u, 24u, 28u, 32u, 36u, 40u, 44u, 48u, 52u, 56u, - 60u, 64u, 68u, 72u, 80u, 176u, 192u, 200u, 208u, 224u, 240u, 1136u, 1232u, 1248u, 1264u}; + constexpr std::array shader_data_offsets{0u, 4u, 8u, 12u, 16u, 20u, 24u, 28u, + 32u, 36u, 40u, 44u, 48u, 52u, 56u, 60u, + 64u, 68u, 72u, 80u, 176u, 192u, 200u, 208u, + 224u, 240u, 1136u, 1232u, 1248u, 1264u, 1312u}; Decorate(lighting_lut_array_id, spv::Decoration::ArrayStride, 16u); Decorate(light_src_array_id, spv::Decoration::ArrayStride, 112u); Decorate(const_color_array_id, spv::Decoration::ArrayStride, 16u); + Decorate(border_color_array_id, spv::Decoration::ArrayStride, 16u); for (u32 i = 0; i < static_cast(light_src_offsets.size()); i++) { MemberDecorate(light_src_struct_id, i, spv::Decoration::Offset, light_src_offsets[i]); } @@ -1475,9 +1517,9 @@ void FragmentModule::DefineUniformStructs() { void FragmentModule::DefineInterface() { // Define interface block primary_color_id = DefineInput(vec_ids.Get(4), 1); - texcoord0_id = DefineInput(vec_ids.Get(2), 2); - texcoord1_id = DefineInput(vec_ids.Get(2), 3); - texcoord2_id = DefineInput(vec_ids.Get(2), 4); + texcoord_id[0] = DefineInput(vec_ids.Get(2), 2); + texcoord_id[1] = DefineInput(vec_ids.Get(2), 3); + texcoord_id[2] = DefineInput(vec_ids.Get(2), 4); texcoord0_w_id = DefineInput(f32_id, 5); normquat_id = DefineInput(vec_ids.Get(4), 6); view_id = DefineInput(vec_ids.Get(3), 7); diff --git a/src/video_core/renderer_vulkan/vk_shader_gen_spv.h b/src/video_core/renderer_vulkan/vk_shader_gen_spv.h index 98631423f..32bac11c2 100644 --- a/src/video_core/renderer_vulkan/vk_shader_gen_spv.h +++ b/src/video_core/renderer_vulkan/vk_shader_gen_spv.h @@ -30,6 +30,8 @@ class FragmentModule : public Sirit::Module { static constexpr u32 NUM_TEV_STAGES = 6; static constexpr u32 NUM_LIGHTS = 8; static constexpr u32 NUM_LIGHTING_SAMPLERS = 24; + static constexpr u32 NUM_TEX_UNITS = 4; + static constexpr u32 NUM_NON_PROC_TEX_UNITS = 3; public: explicit FragmentModule(Core::TelemetrySession& telemetry, const PicaFSConfig& config); @@ -57,15 +59,15 @@ private: /// Writes the code to emulate the specified TEV stage void WriteTevStage(s32 index); - /// Defines the tex3 proctex sampling function - void DefineProcTexSampler(); + /// Defines the basic texture sampling functions for a unit + void DefineTexSampler(u32 texture_unit); + + /// Function for sampling the procedurally generated texture unit. + Id ProcTexSampler(); /// Writes the if-statement condition used to evaluate alpha testing. void WriteAlphaTestCondition(Pica::FramebufferRegs::CompareFunc func); - /// Samples the current fragment texel from the provided texture unit - [[nodiscard]] Id SampleTexture(u32 texture_unit); - /// Samples the current fragment texel from shadow plane [[nodiscard]] Id SampleShadow(); @@ -237,9 +239,7 @@ private: Id shader_data_id{}; Id primary_color_id{}; - Id texcoord0_id{}; - Id texcoord1_id{}; - Id texcoord2_id{}; + Id texcoord_id[NUM_NON_PROC_TEX_UNITS]{}; Id texcoord0_w_id{}; Id normquat_id{}; Id view_id{}; @@ -276,7 +276,7 @@ private: Id alpha_results_2{}; Id alpha_results_3{}; - Id proctex_func{}; + Id sample_tex_unit_func[NUM_TEX_UNITS]{}; Id noise1d_table{}; Id noise2d_table{}; Id lut_offsets{}; diff --git a/src/video_core/shader/shader_uniforms.cpp b/src/video_core/shader/shader_uniforms.cpp index 8247d697b..baa496474 100644 --- a/src/video_core/shader/shader_uniforms.cpp +++ b/src/video_core/shader/shader_uniforms.cpp @@ -67,6 +67,7 @@ layout ({}std140) uniform shader_data {{ vec4 const_color[NUM_TEV_STAGES]; vec4 tev_combiner_buffer_color; vec3 tex_lod_bias; + vec4 tex_border_color[3]; vec4 clip_coef; }}; )"; diff --git a/src/video_core/shader/shader_uniforms.h b/src/video_core/shader/shader_uniforms.h index 1cc8e574f..168f3f14c 100644 --- a/src/video_core/shader/shader_uniforms.h +++ b/src/video_core/shader/shader_uniforms.h @@ -64,10 +64,11 @@ struct UniformData { alignas(16) Common::Vec4f const_color[6]; // A vec4 color for each of the six tev stages alignas(16) Common::Vec4f tev_combiner_buffer_color; alignas(16) Common::Vec3f tex_lod_bias; + alignas(16) Common::Vec4f tex_border_color[3]; alignas(16) Common::Vec4f clip_coef; }; -static_assert(sizeof(UniformData) == 0x500, +static_assert(sizeof(UniformData) == 0x530, "The size of the UniformData does not match the structure in the shader"); static_assert(sizeof(UniformData) < 16384, "UniformData structure must be less than 16kb as per the OpenGL spec");