diff --git a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp index cff6e7b6a6..56f8ec1b3b 100644 --- a/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp +++ b/Source/Core/VideoCommon/GraphicsModSystem/Runtime/CustomShaderCache.cpp @@ -346,8 +346,8 @@ std::unique_ptr CustomShaderCache::CompilePixelShader(const PixelShaderUid& uid, const CustomShaderInstance& custom_shaders) const { - const ShaderCode source_code = GeneratePixelShaderCode( - m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents); + const ShaderCode source_code = + GeneratePixelShaderCode(m_api_type, m_host_config, uid.GetUidData(), {}); return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(), "Custom Pixel Shader"); } @@ -356,8 +356,7 @@ std::unique_ptr CustomShaderCache::CompilePixelShader(const UberShader::PixelShaderUid& uid, const CustomShaderInstance& custom_shaders) const { - const ShaderCode source_code = - GenPixelShader(m_api_type, m_host_config, uid.GetUidData(), custom_shaders.pixel_contents); + const ShaderCode source_code = GenPixelShader(m_api_type, m_host_config, uid.GetUidData()); return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(), "Custom Uber Pixel Shader"); } diff --git a/Source/Core/VideoCommon/LightingShaderGen.cpp b/Source/Core/VideoCommon/LightingShaderGen.cpp index 130fb6f46d..be9d10c78a 100644 --- a/Source/Core/VideoCommon/LightingShaderGen.cpp +++ b/Source/Core/VideoCommon/LightingShaderGen.cpp @@ -179,47 +179,9 @@ void GetLightingShaderUid(LightingUidData& uid_data) } } -void GenerateCustomLightingHeaderDetails(ShaderCode* out, u32 enablelighting, u32 light_mask) -{ - u32 light_count = 0; - for (u32 j = 0; j < NUM_XF_COLOR_CHANNELS; j++) - { - if ((enablelighting & (1 << j)) != 0) // Color lights - { - for (int i = 0; i < 8; ++i) - { - if ((light_mask & (1 << (i + 8 * j))) != 0) - { - light_count++; - } - } - } - if ((enablelighting & (1 << (j + 2))) != 0) // Alpha lights - { - for (int i = 0; i < 8; ++i) - { - if ((light_mask & (1 << (i + 8 * (j + 2)))) != 0) - { - light_count++; - } - } - } - } - if (light_count > 0) - { - out->Write("\tCustomShaderLightData[{}] light;\n", light_count); - } - else - { - // Cheat so shaders compile - out->Write("\tCustomShaderLightData[1] light;\n", light_count); - } - out->Write("\tint light_count;\n"); -} - -static void GenerateLighting(ShaderCode* out, const LightingUidData& uid_data, int index, - int litchan_index, u32 channel_index, u32 custom_light_index, - bool alpha) +static void GenerateCustomLightingImpl(ShaderCode* out, const LightingUidData& uid_data, int index, + int litchan_index, u32 channel_index, u32 custom_light_index, + bool alpha) { const auto attnfunc = static_cast((uid_data.attnfunc >> (2 * litchan_index)) & 0x3); @@ -228,60 +190,59 @@ static void GenerateLighting(ShaderCode* out, const LightingUidData& uid_data, i const std::string name = fmt::format("lights_chan{}_{}", channel_index, light_type); out->Write("\t{{\n"); - out->Write("\t\tcustom_data.{}[{}].direction = " LIGHT_DIR ".xyz;\n", name, custom_light_index, + out->Write("\t\tfrag_input.{}[{}].direction = " LIGHT_DIR ".xyz;\n", name, custom_light_index, LIGHT_DIR_PARAMS(index)); - out->Write("\t\tcustom_data.{}[{}].position = " LIGHT_POS ".xyz;\n", name, custom_light_index, + out->Write("\t\tfrag_input.{}[{}].position = " LIGHT_POS ".xyz;\n", name, custom_light_index, LIGHT_POS_PARAMS(index)); - out->Write("\t\tcustom_data.{}[{}].cosatt = " LIGHT_COSATT ";\n", name, custom_light_index, + out->Write("\t\tfrag_input.{}[{}].cosatt = " LIGHT_COSATT ";\n", name, custom_light_index, LIGHT_COSATT_PARAMS(index)); - out->Write("\t\tcustom_data.{}[{}].distatt = " LIGHT_DISTATT ";\n", name, custom_light_index, + out->Write("\t\tfrag_input.{}[{}].distatt = " LIGHT_DISTATT ";\n", name, custom_light_index, LIGHT_DISTATT_PARAMS(index)); - out->Write("\t\tcustom_data.{}[{}].attenuation_type = {};\n", name, custom_light_index, + out->Write("\t\tfrag_input.{}[{}].attenuation_type = {};\n", name, custom_light_index, static_cast(attnfunc)); if (alpha) { - out->Write("\t\tcustom_data.{}[{}].color = float3(" LIGHT_COL + out->Write("\t\tfrag_input.{}[{}].color = float3(" LIGHT_COL ") / float3(255.0, 255.0, 255.0);\n", name, custom_light_index, LIGHT_COL_PARAMS(index, alpha ? "a" : "rgb")); } else { - out->Write("\t\tcustom_data.{}[{}].color = " LIGHT_COL " / float3(255.0, 255.0, 255.0);\n", - name, custom_light_index, LIGHT_COL_PARAMS(index, alpha ? "a" : "rgb")); + out->Write("\t\tfrag_input.{}[{}].color = " LIGHT_COL " / float3(255.0, 255.0, 255.0);\n", name, + custom_light_index, LIGHT_COL_PARAMS(index, alpha ? "a" : "rgb")); } out->Write("\t}}\n"); } -void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData& uid_data, - std::string_view in_color_name) +void GenerateCustomLighting(ShaderCode* out, const LightingUidData& uid_data) { for (u32 i = 0; i < 8; i++) { for (u32 channel_index = 0; channel_index < NUM_XF_COLOR_CHANNELS; channel_index++) { - out->Write("\tcustom_data.lights_chan{}_color[{}].direction = float3(0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_color[{}].direction = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_color[{}].position = float3(0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_color[{}].position = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_color[{}].color = float3(0, 0, 0);\n", channel_index, + out->Write("\tfrag_input.lights_chan{}_color[{}].color = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_color[{}].cosatt = float4(0, 0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_color[{}].cosatt = float4(0, 0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_color[{}].distatt = float4(0, 0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_color[{}].distatt = float4(0, 0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_color[{}].attenuation_type = 0;\n", channel_index, i); + out->Write("\tfrag_input.lights_chan{}_color[{}].attenuation_type = 0;\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].direction = float3(0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_alpha[{}].direction = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].position = float3(0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_alpha[{}].position = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].color = float3(0, 0, 0);\n", channel_index, + out->Write("\tfrag_input.lights_chan{}_alpha[{}].color = float3(0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].cosatt = float4(0, 0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_alpha[{}].cosatt = float4(0, 0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].distatt = float4(0, 0, 0, 0);\n", + out->Write("\tfrag_input.lights_chan{}_alpha[{}].distatt = float4(0, 0, 0, 0);\n", channel_index, i); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].attenuation_type = 0;\n", channel_index, i); + out->Write("\tfrag_input.lights_chan{}_alpha[{}].attenuation_type = 0;\n", channel_index, i); } } @@ -289,20 +250,20 @@ void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData { const bool colormatsource = !!(uid_data.matsource & (1 << j)); if (colormatsource) // from vertex - out->Write("custom_data.base_material[{}] = {}{};\n", j, in_color_name, j); + out->Write("frag_input.base_material[{}] = frag_input.color_{};\n", j, j); else // from color - out->Write("custom_data.base_material[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j + 2); + out->Write("frag_input.base_material[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j + 2); if ((uid_data.enablelighting & (1 << j)) != 0) { if ((uid_data.ambsource & (1 << j)) != 0) // from vertex - out->Write("custom_data.ambient_lighting[{}] = {}{};\n", j, in_color_name, j); + out->Write("frag_input.ambient_lighting[{}] = frag_input.color_{};\n", j, j); else // from color - out->Write("custom_data.ambient_lighting[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j); + out->Write("frag_input.ambient_lighting[{}] = {}[{}] / 255.0;\n", j, I_MATERIALS, j); } else { - out->Write("custom_data.ambient_lighting[{}] = float4(1, 1, 1, 1);\n", j); + out->Write("frag_input.ambient_lighting[{}] = float4(1, 1, 1, 1);\n", j); } // check if alpha is different @@ -310,21 +271,21 @@ void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData if (alphamatsource != colormatsource) { if (alphamatsource) // from vertex - out->Write("custom_data.base_material[{}].w = {}{}.w;\n", j, in_color_name, j); + out->Write("frag_input.base_material[{}].w = frag_input.color_{}.w;\n", j, j); else // from color - out->Write("custom_data.base_material[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j + 2); + out->Write("frag_input.base_material[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j + 2); } if ((uid_data.enablelighting & (1 << (j + 2))) != 0) { if ((uid_data.ambsource & (1 << (j + 2))) != 0) // from vertex - out->Write("custom_data.ambient_lighting[{}].w = {}{}.w;\n", j, in_color_name, j); + out->Write("frag_input.ambient_lighting[{}].w = frag_input.color_{}.w;\n", j, j); else // from color - out->Write("custom_data.ambient_lighting[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j); + out->Write("frag_input.ambient_lighting[{}].w = {}[{}].w / 255.0;\n", j, I_MATERIALS, j); } else { - out->Write("custom_data.ambient_lighting[{}].w = 1;\n", j); + out->Write("frag_input.ambient_lighting[{}].w = 1;\n", j); } u32 light_count = 0; @@ -334,12 +295,12 @@ void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData { if ((uid_data.light_mask & (1 << (i + 8 * j))) != 0) { - GenerateLighting(out, uid_data, i, j, j, light_count, false); + GenerateCustomLightingImpl(out, uid_data, i, j, j, light_count, false); light_count++; } } } - out->Write("\tcustom_data.light_chan{}_color_count = {};\n", j, light_count); + out->Write("\tfrag_input.light_chan{}_color_count = {};\n", j, light_count); light_count = 0; if ((uid_data.enablelighting & (1 << (j + 2))) != 0) // Alpha lights @@ -348,11 +309,11 @@ void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData { if ((uid_data.light_mask & (1 << (i + 8 * (j + 2)))) != 0) { - GenerateLighting(out, uid_data, i, j + 2, j, light_count, true); + GenerateCustomLightingImpl(out, uid_data, i, j + 2, j, light_count, true); light_count++; } } } - out->Write("\tcustom_data.light_chan{}_alpha_count = {};\n", j, light_count); + out->Write("\tfrag_input.light_chan{}_alpha_count = {};\n", j, light_count); } } diff --git a/Source/Core/VideoCommon/LightingShaderGen.h b/Source/Core/VideoCommon/LightingShaderGen.h index 3e146cc07f..e7d6f1ed13 100644 --- a/Source/Core/VideoCommon/LightingShaderGen.h +++ b/Source/Core/VideoCommon/LightingShaderGen.h @@ -46,7 +46,4 @@ constexpr char s_lighting_struct[] = "struct Light {\n" void GenerateLightingShaderHeader(ShaderCode& object, const LightingUidData& uid_data); void GetLightingShaderUid(LightingUidData& uid_data); - -void GenerateCustomLightingHeaderDetails(ShaderCode* out, u32 enablelighting, u32 light_mask); -void GenerateCustomLightingImplementation(ShaderCode* out, const LightingUidData& uid_data, - std::string_view in_color_name); +void GenerateCustomLighting(ShaderCode* out, const LightingUidData& uid_data); diff --git a/Source/Core/VideoCommon/PixelShaderGen.cpp b/Source/Core/VideoCommon/PixelShaderGen.cpp index 1b9e491a40..ce90ecd42b 100644 --- a/Source/Core/VideoCommon/PixelShaderGen.cpp +++ b/Source/Core/VideoCommon/PixelShaderGen.cpp @@ -345,8 +345,7 @@ void ClearUnusedPixelShaderUidBits(APIType api_type, const ShaderHostConfig& hos } void WritePixelShaderCommonHeader(ShaderCode& out, APIType api_type, - const ShaderHostConfig& host_config, bool bounding_box, - const CustomPixelShaderContents& custom_details) + const ShaderHostConfig& host_config, bool bounding_box) { // dot product for integer vectors out.Write("int idot(int3 x, int3 y)\n" @@ -427,14 +426,6 @@ void WritePixelShaderCommonHeader(ShaderCode& out, APIType api_type, out.Write("}};\n"); } - if (!custom_details.shaders.empty() && - !custom_details.shaders.back().material_uniform_block.empty()) - { - out.Write("UBO_BINDING(std140, 3) uniform CustomShaderBlock {{\n"); - out.Write("{}", custom_details.shaders.back().material_uniform_block); - out.Write("}} custom_uniforms;\n"); - } - if (bounding_box) { out.Write("SSBO_BINDING(0) coherent buffer BBox {{\n" @@ -761,132 +752,8 @@ uint WrapCoord(int coord, uint wrap, int size) {{ } } -void WriteCustomShaderStructImpl(ShaderCode* out, u32 num_stages, bool per_pixel_lighting, - const pixel_shader_uid_data* uid_data) -{ - out->Write("\tCustomShaderData custom_data;\n"); - - if (per_pixel_lighting) - { - out->Write("\tcustom_data.position = WorldPos;\n"); - out->Write("\tcustom_data.normal = Normal;\n"); - } - else - { - out->Write("\tcustom_data.position = float3(0, 0, 0);\n"); - out->Write("\tcustom_data.normal = float3(0, 0, 0);\n"); - } - - if (uid_data->genMode_numtexgens == 0) [[unlikely]] - { - out->Write("\tcustom_data.texcoord[0] = float3(0, 0, 0);\n"); - } - else - { - for (u32 i = 0; i < uid_data->genMode_numtexgens; ++i) - { - out->Write("\tif (tex{0}.z == 0.0)\n", i); - out->Write("\t{{\n"); - out->Write("\t\tcustom_data.texcoord[{0}] = tex{0};\n", i); - out->Write("\t}}\n"); - out->Write("\telse {{\n"); - out->Write("\t\tcustom_data.texcoord[{0}] = float3(tex{0}.xy / tex{0}.z, 0);\n", i); - out->Write("\t}}\n"); - } - } - - for (u32 i = 0; i < 8; i++) - { - // Shader compilation complains if every index isn't initialized - out->Write("\tcustom_data.texmap_to_texcoord_index[{0}] = 0;\n", i); - } - - for (u32 i = 0; i < uid_data->genMode_numindstages; ++i) - { - if ((uid_data->nIndirectStagesUsed & (1U << i)) != 0) - { - u32 texcoord = uid_data->GetTevindirefCoord(i); - const u32 texmap = uid_data->GetTevindirefMap(i); - - // Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord does - // not exist), then tex coord 0 is used (though sometimes glitchy effects happen on console). - // This affects the Mario portrait in Luigi's Mansion, where the developers forgot to set - // the number of tex gens to 2 (bug 11462). - if (texcoord >= uid_data->genMode_numtexgens) - texcoord = 0; - - out->Write("\tcustom_data.texmap_to_texcoord_index[{}] = {};\n", texmap, texcoord); - } - } - out->Write("\tcustom_data.texcoord_count = {};\n", uid_data->genMode_numtexgens); - - // Try and do a best guess on what the texcoord index is - // Note: one issue with this would be textures that are used - // multiple times in the same draw but with different texture coordinates. - // In that scenario, only the last texture coordinate would be defined. - // This issue can be seen in how Rogue Squadron 2 does bump mapping - for (u32 i = 0; i < num_stages; i++) - { - auto& tevstage = uid_data->stagehash[i]; - // Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord does - // not exist), then tex coord 0 is used (though sometimes glitchy effects happen on console). - u32 texcoord = tevstage.tevorders_texcoord; - const bool has_tex_coord = texcoord < uid_data->genMode_numtexgens; - if (!has_tex_coord) - texcoord = 0; - - out->Write("\tcustom_data.texmap_to_texcoord_index[{}] = {};\n", tevstage.tevorders_texmap, - texcoord); - } - - if (per_pixel_lighting) - GenerateCustomLightingImplementation(out, uid_data->lighting, "colors_"); - - for (u32 i = 0; i < 16; i++) - { - // Shader compilation complains if every struct isn't initialized - - // Color Input - for (u32 j = 0; j < 4; j++) - { - out->Write("\tcustom_data.tev_stages[{}].input_color[{}].input_type = " - "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n", - i, j); - out->Write("\tcustom_data.tev_stages[{}].input_color[{}].value = " - "float3(0, 0, 0);\n", - i, j); - } - - // Alpha Input - for (u32 j = 0; j < 4; j++) - { - out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].input_type = " - "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n", - i, j); - out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].value = " - "float(0);\n", - i, j); - } - - // Texmap - out->Write("\tcustom_data.tev_stages[{}].texmap = 0u;\n", i); - - // Output - out->Write("\tcustom_data.tev_stages[{}].output_color = " - "float4(0, 0, 0, 0);\n", - i); - } - - // Actual data will be filled out in the tev stage code, just set the - // stage count for now - out->Write("\tcustom_data.tev_stage_count = {};\n", num_stages); - - // Time - out->Write("\tcustom_data.time_ms = time_ms;\n"); -} - static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n, - APIType api_type, bool stereo, bool has_custom_shaders); + APIType api_type, bool stereo); static void WriteTevRegular(ShaderCode& out, std::string_view components, TevBias bias, TevOp op, bool clamp, TevScale scale); static void WriteAlphaTest(ShaderCode& out, const pixel_shader_uid_data* uid_data, APIType api_type, @@ -898,9 +765,14 @@ static void WriteColor(ShaderCode& out, APIType api_type, const pixel_shader_uid bool use_dual_source); static void WriteBlend(ShaderCode& out, const pixel_shader_uid_data* uid_data); +static void WriteEmulatedFragmentBodyHeader(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out); +static void WriteFragmentDefinitions(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out); + ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& host_config, const pixel_shader_uid_data* uid_data, - const CustomPixelShaderContents& custom_details) + CustomPixelContents custom_contents) { ShaderCode out; @@ -917,15 +789,7 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos // Stuff that is shared between ubershaders and pixelgen. WriteBitfieldExtractHeader(out, api_type, host_config); - WritePixelShaderCommonHeader(out, api_type, host_config, uid_data->bounding_box, custom_details); - - // Custom shader details - WriteCustomShaderStructDef(&out, uid_data->genMode_numtexgens); - for (std::size_t i = 0; i < custom_details.shaders.size(); i++) - { - const auto& shader_details = custom_details.shaders[i]; - out.Write(fmt::runtime(shader_details.custom_shader), i); - } + WritePixelShaderCommonHeader(out, api_type, host_config, uid_data->bounding_box); out.Write("\n#define sampleTextureWrapper(texmap, uv, layer) " "sampleTexture(texmap, samp[texmap], uv, layer)\n"); @@ -1057,22 +921,39 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos } } + if (!custom_contents.uniforms.empty()) + { + out.Write("UBO_BINDING(std140, 3) uniform CustomShaderBlock {{\n"); + out.Write("{}", custom_contents.uniforms); + out.Write("}} custom_uniforms;\n"); + } + if (per_pixel_lighting) { GenerateLightingShaderHeader(out, uid_data->lighting); } + WriteFragmentDefinitions(api_type, host_config, uid_data, out); + WriteEmulatedFragmentBodyHeader(api_type, host_config, uid_data, out); + + if (custom_contents.shader.empty()) + { + out.Write("void process_fragment(in DolphinFragmentInput frag_input, out DolphinFragmentOutput " + "frag_output)\n"); + out.Write("{{\n"); + + out.Write("\tdolphin_process_emulated_fragment(frag_input, frag_output);\n"); + + out.Write("}}\n"); + } + else + { + out.Write("{}\n", custom_contents.shader); + } + out.Write("void main()\n{{\n"); out.Write("\tfloat4 rawpos = gl_FragCoord;\n"); - bool has_custom_shaders = false; - if (std::any_of(custom_details.shaders.begin(), custom_details.shaders.end(), - [](const std::optional& ps) { return ps.has_value(); })) - { - WriteCustomShaderStructImpl(&out, numStages, per_pixel_lighting, uid_data); - has_custom_shaders = true; - } - if (use_framebuffer_fetch) { // Store off a copy of the initial framebuffer value. @@ -1107,112 +988,31 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos out.Write("\tint layer = 0;\n"); } - out.Write("\tint4 c0 = " I_COLORS "[1], c1 = " I_COLORS "[2], c2 = " I_COLORS - "[3], prev = " I_COLORS "[0];\n" - "\tint4 rastemp = int4(0, 0, 0, 0), rawtextemp = int4(0, 0, 0, 0), " - "textemp = int4(0, 0, 0, 0), konsttemp = int4(0, 0, 0, 0);\n" - "\tint3 comp16 = int3(1, 256, 0), comp24 = int3(1, 256, 256*256);\n" - "\tint alphabump=0;\n" - "\tint3 tevcoord=int3(0, 0, 0);\n" - "\tint2 wrappedcoord=int2(0,0), tempcoord=int2(0,0);\n" - "\tint4 " - "tevin_a=int4(0,0,0,0),tevin_b=int4(0,0,0,0),tevin_c=int4(0,0,0,0),tevin_d=int4(0,0,0," - "0);\n\n"); // tev combiner inputs - - // On GLSL, input variables must not be assigned to. - // This is why we declare these variables locally instead. - out.Write("\tfloat4 col0 = colors_0;\n" - "\tfloat4 col1 = colors_1;\n"); - + out.Write("\tDolphinFragmentInput frag_input;\n"); + out.Write("\tfrag_input.color_0 = colors_0;\n"); + out.Write("\tfrag_input.color_1 = colors_1;\n"); + out.Write("\tfrag_input.layer = layer;\n"); if (per_pixel_lighting) { - out.Write("\tfloat3 _normal = normalize(Normal.xyz);\n\n" - "\tfloat3 pos = WorldPos;\n"); - - // TODO: Our current constant usage code isn't able to handle more than one buffer. - // So we can't mark the VS constant as used here. But keep them here as reference. - // out.SetConstantsUsed(C_PLIGHT_COLORS, C_PLIGHT_COLORS+7); // TODO: Can be optimized further - // out.SetConstantsUsed(C_PLIGHTS, C_PLIGHTS+31); // TODO: Can be optimized further - // out.SetConstantsUsed(C_PMATERIALS, C_PMATERIALS+3); - for (u32 chan = 0; chan < uid_data->numColorChans; chan++) - { - out.Write("\tcol{0} = dolphin_calculate_lighting_chn{0}(colors_{0}, pos, _normal);\n", chan); - } - // The number of colors available to TEV is determined by numColorChans. - // Normally this is performed in the vertex shader after lighting, but with per-pixel lighting, - // we need to perform it here. (It needs to be done after lighting, as what was originally - // black might become a different color after lighting). - if (uid_data->numColorChans == 0) - out.Write("col0 = float4(0.0, 0.0, 0.0, 0.0);\n"); - if (uid_data->numColorChans <= 1) - out.Write("col1 = float4(0.0, 0.0, 0.0, 0.0);\n"); - } - - if (uid_data->genMode_numtexgens == 0) - { - // TODO: This is a hack to ensure that shaders still compile when setting out of bounds tex - // coord indices to 0. Ideally, it shouldn't exist at all, but the exact behavior hasn't been - // tested. - out.Write("\tint2 fixpoint_uv0 = int2(0, 0);\n\n"); + out.Write("\tfrag_input.normal = normalize(Normal);\n"); + out.Write("\tfrag_input.position = WorldPos;\n"); } else { - out.SetConstantsUsed(C_TEXDIMS, C_TEXDIMS + uid_data->genMode_numtexgens - 1); - for (u32 i = 0; i < uid_data->genMode_numtexgens; ++i) - { - out.Write("\tint2 fixpoint_uv{} = int2(", i); - out.Write("(tex{}.z == 0.0 ? tex{}.xy : tex{}.xy / tex{}.z)", i, i, i, i); - out.Write(" * float2(" I_TEXDIMS "[{}].zw * 128));\n", i); - // TODO: S24 overflows here? - } + out.Write("\tfrag_input.normal = vec3(0, 0, 0);\n"); + out.Write("\tfrag_input.position = vec3(0, 0, 0);\n"); } - - for (u32 i = 0; i < uid_data->genMode_numindstages; ++i) + for (u32 i = 0; i < uid_data->genMode_numtexgens; i++) { - if ((uid_data->nIndirectStagesUsed & (1U << i)) != 0) - { - u32 texcoord = uid_data->GetTevindirefCoord(i); - const u32 texmap = uid_data->GetTevindirefMap(i); - - // Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord does - // not exist), then tex coord 0 is used (though sometimes glitchy effects happen on console). - // This affects the Mario portrait in Luigi's Mansion, where the developers forgot to set - // the number of tex gens to 2 (bug 11462). - if (texcoord >= uid_data->genMode_numtexgens) - texcoord = 0; - - out.SetConstantsUsed(C_INDTEXSCALE + i / 2, C_INDTEXSCALE + i / 2); - out.Write("\ttempcoord = fixpoint_uv{} >> " I_INDTEXSCALE "[{}].{};\n", texcoord, i / 2, - (i & 1) ? "zw" : "xy"); - - out.Write("\tint3 iindtex{0} = sampleTextureWrapper({1}u, tempcoord, layer).abg;\n", i, - texmap); - } + out.Write("\tfrag_input.tex{0} = tex{0};\n", i); } - for (u32 i = 0; i < numStages; i++) - { - // Build the equation for this stage - WriteStage(out, uid_data, i, api_type, stereo, has_custom_shaders); - } + if (!custom_contents.shader.empty()) + GenerateCustomLighting(&out, uid_data->lighting); - { - // The results of the last texenv stage are put onto the screen, - // regardless of the used destination register - TevStageCombiner::ColorCombiner last_cc; - TevStageCombiner::AlphaCombiner last_ac; - last_cc.hex = uid_data->stagehash[uid_data->genMode_numtevstages].cc; - last_ac.hex = uid_data->stagehash[uid_data->genMode_numtevstages].ac; - if (last_cc.dest != TevOutput::Prev) - { - out.Write("\tprev.rgb = {};\n", tev_c_output_table[last_cc.dest]); - } - if (last_ac.dest != TevOutput::Prev) - { - out.Write("\tprev.a = {};\n", tev_a_output_table[last_ac.dest]); - } - } - out.Write("\tprev = prev & 255;\n"); + out.Write("\tDolphinFragmentOutput frag_output;\n"); + out.Write("\tprocess_fragment(frag_input, frag_output);\n"); + out.Write("\tivec4 prev = frag_output.main & 255;\n"); // NOTE: Fragment may not be discarded if alpha test always fails and early depth test is enabled // (in this case we need to write a depth value if depth test passes regardless of the alpha @@ -1292,10 +1092,11 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos // ztextures anyway if (uid_data->ztex_op != ZTexOp::Disabled && !skip_ztexture) { - // use the texture input of the last texture stage (textemp), hopefully this has been read and + // use the texture input of the last texture stage, hopefully this has been read and // is in correct format... out.SetConstantsUsed(C_ZBIAS, C_ZBIAS + 1); - out.Write("\tzCoord = idot(" I_ZBIAS "[0].xyzw, rawtextemp.xyzw) + " I_ZBIAS "[1].w {};\n", + out.Write("\tzCoord = idot(" I_ZBIAS "[0].xyzw, frag_output.last_texture.xyzw) + " I_ZBIAS + "[1].w {};\n", (uid_data->ztex_op == ZTexOp::Add) ? "+ zCoord" : ""); out.Write("\tzCoord = zCoord & 0xFFFFFF;\n"); } @@ -1319,23 +1120,6 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos WriteFog(out, uid_data); - for (std::size_t i = 0; i < custom_details.shaders.size(); i++) - { - const auto& shader_details = custom_details.shaders[i]; - - if (!shader_details.custom_shader.empty()) - { - out.Write("\t{{\n"); - out.Write("\t\tcustom_data.final_color = float4(prev.r / 255.0, prev.g / 255.0, prev.b " - "/ 255.0, prev.a / 255.0);\n"); - out.Write("\t\tCustomShaderOutput custom_output = {}_{}(custom_data);\n", - CUSTOM_PIXELSHADER_COLOR_FUNC, i); - out.Write("\t\tprev = int4(custom_output.main_rt.r * 255, custom_output.main_rt.g * 255, " - "custom_output.main_rt.b * 255, custom_output.main_rt.a * 255);\n"); - out.Write("\t}}\n\n"); - } - } - if (uid_data->logic_op_enable) WriteLogicOp(out, uid_data); else if (uid_data->emulate_logic_op_with_blend) @@ -1360,7 +1144,7 @@ ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& hos } static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, int n, - APIType api_type, bool stereo, bool has_custom_shaders) + APIType api_type, bool stereo) { using Common::EnumMap; @@ -1755,58 +1539,6 @@ static void WriteStage(ShaderCode& out, const pixel_shader_uid_data* uid_data, i out.Write(", -1024, 1023)"); out.Write(";\n"); - - if (has_custom_shaders) - { - // Color input - out.Write( - "\tcustom_data.tev_stages[{}].input_color[0].value = {} / float3(255.0, 255.0, 255.0);\n", - n, tev_c_input_table[cc.a]); - out.Write("\tcustom_data.tev_stages[{}].input_color[0].input_type = {};\n", n, - tev_c_input_type[cc.a]); - out.Write( - "\tcustom_data.tev_stages[{}].input_color[1].value = {} / float3(255.0, 255.0, 255.0);\n", - n, tev_c_input_table[cc.b]); - out.Write("\tcustom_data.tev_stages[{}].input_color[1].input_type = {};\n", n, - tev_c_input_type[cc.b]); - out.Write( - "\tcustom_data.tev_stages[{}].input_color[2].value = {} / float3(255.0, 255.0, 255.0);\n", - n, tev_c_input_table[cc.c]); - out.Write("\tcustom_data.tev_stages[{}].input_color[2].input_type = {};\n", n, - tev_c_input_type[cc.c]); - out.Write( - "\tcustom_data.tev_stages[{}].input_color[3].value = {} / float3(255.0, 255.0, 255.0);\n", - n, tev_c_input_table[cc.d]); - out.Write("\tcustom_data.tev_stages[{}].input_color[3].input_type = {};\n", n, - tev_c_input_type[cc.d]); - - // Alpha input - out.Write("\tcustom_data.tev_stages[{}].input_alpha[0].value = {} / float(255.0);\n", n, - tev_a_input_table[ac.a]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[0].input_type = {};\n", n, - tev_a_input_type[ac.a]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[1].value = {} / float(255.0);\n", n, - tev_a_input_table[ac.b]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[1].input_type = {};\n", n, - tev_a_input_type[ac.b]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[2].value = {} / float(255.0);\n", n, - tev_a_input_table[ac.c]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[2].input_type = {};\n", n, - tev_a_input_type[ac.c]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[3].value = {} / float(255.0);\n", n, - tev_a_input_table[ac.d]); - out.Write("\tcustom_data.tev_stages[{}].input_alpha[3].input_type = {};\n", n, - tev_a_input_type[ac.d]); - - // Texmap - out.Write("\tcustom_data.tev_stages[{}].texmap = {}u;\n", n, stage.tevorders_texmap); - - // Output - out.Write("\tcustom_data.tev_stages[{}].output_color.rgb = {} / float3(255.0, 255.0, 255.0);\n", - n, tev_c_output_table[cc.dest]); - out.Write("\tcustom_data.tev_stages[{}].output_color.a = {} / float(255.0);\n", n, - tev_a_output_table[ac.dest]); - } } static void WriteTevRegular(ShaderCode& out, std::string_view components, TevBias bias, TevOp op, @@ -2187,3 +1919,198 @@ static void WriteBlend(ShaderCode& out, const pixel_shader_uid_data* uid_data) out.Write("\treal_ocol0 = blend_result;\n"); } + +void WriteFragmentBody(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out) +{ + const bool per_pixel_lighting = host_config.per_pixel_lighting; + const bool stereo = host_config.stereo; + const u32 numStages = uid_data->genMode_numtevstages + 1; + + out.Write("\tvec4 col0 = frag_input.color_0;\n"); + out.Write("\tvec4 col1 = frag_input.color_1;\n"); + out.Write("\tint layer = frag_input.layer;\n"); + + out.Write("\tint4 c0 = " I_COLORS "[1], c1 = " I_COLORS "[2], c2 = " I_COLORS + "[3], prev = " I_COLORS "[0];\n" + "\tint4 rastemp = int4(0, 0, 0, 0), rawtextemp = int4(0, 0, 0, 0), " + "textemp = int4(0, 0, 0, 0), konsttemp = int4(0, 0, 0, 0);\n" + "\tint3 comp16 = int3(1, 256, 0), comp24 = int3(1, 256, 256*256);\n" + "\tint alphabump=0;\n" + "\tint3 tevcoord=int3(0, 0, 0);\n" + "\tint2 wrappedcoord=int2(0,0), tempcoord=int2(0,0);\n" + "\tint4 " + "tevin_a=int4(0,0,0,0),tevin_b=int4(0,0,0,0),tevin_c=int4(0,0,0,0),tevin_d=int4(0,0,0," + "0);\n\n"); // tev combiner inputs + + if (per_pixel_lighting) + { + if (uid_data->numColorChans > 0) + { + out.Write("\tcol0 = dolphin_calculate_lighting_chn0(col0, frag_input.position, " + "frag_input.normal);\n"); + } + else + { + // The number of colors available to TEV is determined by numColorChans. + // We have to provide the fields to match the interface, so set to zero if it's not enabled. + out.Write("\tcol0 = vec4(0.0, 0.0, 0.0, 0.0);\n"); + } + + if (uid_data->numColorChans == 2) + { + out.Write("\tcol1 = dolphin_calculate_lighting_chn1(col1, frag_input.position, " + "frag_input.normal);\n"); + } + else + { + // The number of colors available to TEV is determined by numColorChans. + // We have to provide the fields to match the interface, so set to zero if it's not enabled. + out.Write("\tcol1 = vec4(0.0, 0.0, 0.0, 0.0);\n"); + } + } + + if (uid_data->genMode_numtexgens == 0) + { + // TODO: This is a hack to ensure that shaders still compile when setting out of bounds tex + // coord indices to 0. Ideally, it shouldn't exist at all, but the exact behavior hasn't been + // tested. + out.Write("\tint2 fixpoint_uv0 = int2(0, 0);\n\n"); + } + else + { + out.SetConstantsUsed(C_TEXDIMS, C_TEXDIMS + uid_data->genMode_numtexgens - 1); + for (u32 i = 0; i < uid_data->genMode_numtexgens; ++i) + { + out.Write("\tint2 fixpoint_uv{} = int2(", i); + out.Write("(frag_input.tex{}.z == 0.0 ? frag_input.tex{}.xy : frag_input.tex{}.xy / " + "frag_input.tex{}.z)", + i, i, i, i); + out.Write(" * float2(" I_TEXDIMS "[{}].zw * 128));\n", i); + // TODO: S24 overflows here? + } + } + + for (u32 i = 0; i < uid_data->genMode_numindstages; ++i) + { + if ((uid_data->nIndirectStagesUsed & (1U << i)) != 0) + { + u32 texcoord = uid_data->GetTevindirefCoord(i); + const u32 texmap = uid_data->GetTevindirefMap(i); + + // Quirk: when the tex coord is not less than the number of tex gens (i.e. the tex coord + // does not exist), then tex coord 0 is used (though sometimes glitchy effects happen on + // console). This affects the Mario portrait in Luigi's Mansion, where the developers forgot + // to set the number of tex gens to 2 (bug 11462). + if (texcoord >= uid_data->genMode_numtexgens) + texcoord = 0; + + out.SetConstantsUsed(C_INDTEXSCALE + i / 2, C_INDTEXSCALE + i / 2); + out.Write("\ttempcoord = fixpoint_uv{} >> " I_INDTEXSCALE "[{}].{};\n", texcoord, i / 2, + (i & 1) ? "zw" : "xy"); + + out.Write("\tint3 iindtex{0} = sampleTextureWrapper({1}u, tempcoord, layer).abg;\n", i, + texmap); + } + } + + for (u32 i = 0; i < numStages; i++) + { + // Build the equation for this stage + WriteStage(out, uid_data, i, api_type, stereo); + } + + { + // The results of the last texenv stage are put onto the screen, + // regardless of the used destination register + TevStageCombiner::ColorCombiner last_cc; + TevStageCombiner::AlphaCombiner last_ac; + last_cc.hex = uid_data->stagehash[uid_data->genMode_numtevstages].cc; + last_ac.hex = uid_data->stagehash[uid_data->genMode_numtevstages].ac; + if (last_cc.dest != TevOutput::Prev) + { + out.Write("\tprev.rgb = {};\n", tev_c_output_table[last_cc.dest]); + } + if (last_ac.dest != TevOutput::Prev) + { + out.Write("\tprev.a = {};\n", tev_a_output_table[last_ac.dest]); + } + } + + out.Write("\tfrag_output.last_texture = rawtextemp;\n"); + out.Write("\tfrag_output.main = prev;\n"); +} + +static void WriteFragmentDefinitions(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out) +{ + out.Write("struct DolphinLightData\n"); + out.Write("{{\n"); + out.Write("\tfloat3 position;\n"); + out.Write("\tfloat3 direction;\n"); + out.Write("\tfloat3 color;\n"); + out.Write("\tuint attenuation_type;\n"); + out.Write("\tfloat4 cosatt;\n"); + out.Write("\tfloat4 distatt;\n"); + out.Write("}};\n\n"); + + out.Write("struct DolphinFragmentInput\n"); + out.Write("{{\n"); + out.Write("\tvec4 color_0;\n"); + out.Write("\tvec4 color_1;\n"); + out.Write("\tint layer;\n"); + out.Write("\tvec3 normal;\n"); + out.Write("\tvec3 position;\n"); + for (u32 i = 0; i < uid_data->genMode_numtexgens; i++) + { + out.Write("\tvec3 tex{};\n", i); + } + for (u32 i = uid_data->genMode_numtexgens; i < 8; i++) + { + out.Write("\tvec3 tex{};\n", i); + } + out.Write("\n"); + + out.Write("\tDolphinLightData[8] lights_chan0_color;\n"); + out.Write("\tDolphinLightData[8] lights_chan0_alpha;\n"); + out.Write("\tDolphinLightData[8] lights_chan1_color;\n"); + out.Write("\tDolphinLightData[8] lights_chan1_alpha;\n"); + out.Write("\tfloat4[2] ambient_lighting;\n"); + out.Write("\tfloat4[2] base_material;\n"); + out.Write("\tuint light_chan0_color_count;\n"); + out.Write("\tuint light_chan0_alpha_count;\n"); + out.Write("\tuint light_chan1_color_count;\n"); + out.Write("\tuint light_chan1_alpha_count;\n"); + + out.Write("}};\n\n"); + + out.Write("struct DolphinFragmentOutput\n"); + out.Write("{{\n"); + out.Write("\tivec4 main;\n"); + out.Write("\tivec4 last_texture;\n"); + out.Write("}};\n\n"); + + // CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE "enum" values + out.Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_NONE = {}u;\n", + static_cast(AttenuationFunc::None)); + out.Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_POINT = {}u;\n", + static_cast(AttenuationFunc::Spec)); + out.Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_DIR = {}u;\n", + static_cast(AttenuationFunc::Dir)); + out.Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_SPOT = {}u;\n", + static_cast(AttenuationFunc::Spot)); +} + +static void WriteEmulatedFragmentBodyHeader(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out) +{ + constexpr std::string_view emulated_fragment_definition = + "void dolphin_process_emulated_fragment(in DolphinFragmentInput frag_input, out " + "DolphinFragmentOutput frag_output)"; + out.Write("{}\n", emulated_fragment_definition); + out.Write("{{\n"); + + WriteFragmentBody(api_type, host_config, uid_data, out); + + out.Write("}}\n"); +} diff --git a/Source/Core/VideoCommon/PixelShaderGen.h b/Source/Core/VideoCommon/PixelShaderGen.h index e5dd43d754..f8c0fa96c5 100644 --- a/Source/Core/VideoCommon/PixelShaderGen.h +++ b/Source/Core/VideoCommon/PixelShaderGen.h @@ -158,15 +158,19 @@ struct pixel_shader_uid_data using PixelShaderUid = ShaderUid; -void WriteCustomShaderStructImpl(ShaderCode* out, u32 num_stages, bool per_pixel_lighting, - const pixel_shader_uid_data* uid_data); +struct CustomPixelContents +{ + std::string_view shader = ""; + std::string_view uniforms = ""; +}; ShaderCode GeneratePixelShaderCode(APIType api_type, const ShaderHostConfig& host_config, const pixel_shader_uid_data* uid_data, - const CustomPixelShaderContents& custom_details); + CustomPixelContents custom_contents); void WritePixelShaderCommonHeader(ShaderCode& out, APIType api_type, - const ShaderHostConfig& host_config, bool bounding_box, - const CustomPixelShaderContents& custom_details); + const ShaderHostConfig& host_config, bool bounding_box); +void WriteFragmentBody(APIType api_type, const ShaderHostConfig& host_config, + const pixel_shader_uid_data* uid_data, ShaderCode& out); void ClearUnusedPixelShaderUidBits(APIType api_type, const ShaderHostConfig& host_config, PixelShaderUid* uid); PixelShaderUid GetPixelShaderUid(); diff --git a/Source/Core/VideoCommon/ShaderCache.cpp b/Source/Core/VideoCommon/ShaderCache.cpp index 22939e9b90..96f3a67e18 100644 --- a/Source/Core/VideoCommon/ShaderCache.cpp +++ b/Source/Core/VideoCommon/ShaderCache.cpp @@ -457,7 +457,7 @@ std::unique_ptr ShaderCache::CompilePixelUberShader(const UberShader::PixelShaderUid& uid) const { const ShaderCode source_code = - UberShader::GenPixelShader(m_api_type, m_host_config, uid.GetUidData(), {}); + UberShader::GenPixelShader(m_api_type, m_host_config, uid.GetUidData()); return g_gfx->CreateShaderFromSource(ShaderStage::Pixel, source_code.GetBuffer(), fmt::to_string(*uid.GetUidData())); } diff --git a/Source/Core/VideoCommon/ShaderGenCommon.cpp b/Source/Core/VideoCommon/ShaderGenCommon.cpp index ec251c3cce..26463f4476 100644 --- a/Source/Core/VideoCommon/ShaderGenCommon.cpp +++ b/Source/Core/VideoCommon/ShaderGenCommon.cpp @@ -362,95 +362,3 @@ const char* GetInterpolationQualifier(bool msaa, bool ssaa, bool in_glsl_interfa return "sample"; } } - -void WriteCustomShaderStructDef(ShaderCode* out, u32 numtexgens) -{ - // Bump this when there are breaking changes to the API - out->Write("#define CUSTOM_SHADER_API_VERSION 1;\n"); - - // CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE "enum" values - out->Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_NONE = {}u;\n", - static_cast(AttenuationFunc::None)); - out->Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_POINT = {}u;\n", - static_cast(AttenuationFunc::Spec)); - out->Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_DIR = {}u;\n", - static_cast(AttenuationFunc::Dir)); - out->Write("const uint CUSTOM_SHADER_LIGHTING_ATTENUATION_TYPE_SPOT = {}u;\n", - static_cast(AttenuationFunc::Spot)); - - out->Write("struct CustomShaderOutput\n"); - out->Write("{{\n"); - out->Write("\tfloat4 main_rt;\n"); - out->Write("}};\n\n"); - - out->Write("struct CustomShaderLightData\n"); - out->Write("{{\n"); - out->Write("\tfloat3 position;\n"); - out->Write("\tfloat3 direction;\n"); - out->Write("\tfloat3 color;\n"); - out->Write("\tuint attenuation_type;\n"); - out->Write("\tfloat4 cosatt;\n"); - out->Write("\tfloat4 distatt;\n"); - out->Write("}};\n\n"); - - // CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE "enum" values - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV = 0u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR = 1u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX = 2u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS = 3u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_KONST = 4u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC = 5u;\n"); - out->Write("const uint CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED = 6u;\n"); - - out->Write("struct CustomShaderTevStageInputColor\n"); - out->Write("{{\n"); - out->Write("\tuint input_type;\n"); - out->Write("\tfloat3 value;\n"); - out->Write("}};\n\n"); - - out->Write("struct CustomShaderTevStageInputAlpha\n"); - out->Write("{{\n"); - out->Write("\tuint input_type;\n"); - out->Write("\tfloat value;\n"); - out->Write("}};\n\n"); - - out->Write("struct CustomShaderTevStage\n"); - out->Write("{{\n"); - out->Write("\tCustomShaderTevStageInputColor[4] input_color;\n"); - out->Write("\tCustomShaderTevStageInputAlpha[4] input_alpha;\n"); - out->Write("\tuint texmap;\n"); - out->Write("\tfloat4 output_color;\n"); - out->Write("}};\n\n"); - - // Custom structure for data we pass to custom shader hooks - out->Write("struct CustomShaderData\n"); - out->Write("{{\n"); - out->Write("\tfloat3 position;\n"); - out->Write("\tfloat3 normal;\n"); - if (numtexgens == 0) - { - // Cheat so shaders compile - out->Write("\tfloat3[1] texcoord;\n"); - } - else - { - out->Write("\tfloat3[{}] texcoord;\n", numtexgens); - } - out->Write("\tuint texcoord_count;\n"); - out->Write("\tuint[8] texmap_to_texcoord_index;\n"); - out->Write("\tCustomShaderLightData[8] lights_chan0_color;\n"); - out->Write("\tCustomShaderLightData[8] lights_chan0_alpha;\n"); - out->Write("\tCustomShaderLightData[8] lights_chan1_color;\n"); - out->Write("\tCustomShaderLightData[8] lights_chan1_alpha;\n"); - out->Write("\tfloat4[2] ambient_lighting;\n"); - out->Write("\tfloat4[2] base_material;\n"); - out->Write("\tuint light_chan0_color_count;\n"); - out->Write("\tuint light_chan0_alpha_count;\n"); - out->Write("\tuint light_chan1_color_count;\n"); - out->Write("\tuint light_chan1_alpha_count;\n"); - out->Write("\tCustomShaderTevStage[16] tev_stages;\n"); - out->Write("\tuint tev_stage_count;\n"); - out->Write("\tfloat4 final_color;\n"); - out->Write("\tuint time_ms;\n"); - out->Write("}};\n\n"); -} diff --git a/Source/Core/VideoCommon/ShaderGenCommon.h b/Source/Core/VideoCommon/ShaderGenCommon.h index 4723cbfc79..7d2c80f086 100644 --- a/Source/Core/VideoCommon/ShaderGenCommon.h +++ b/Source/Core/VideoCommon/ShaderGenCommon.h @@ -345,5 +345,3 @@ struct CustomPixelShaderContents bool operator==(const CustomPixelShaderContents& other) const = default; }; - -void WriteCustomShaderStructDef(ShaderCode* out, u32 numtexgens); diff --git a/Source/Core/VideoCommon/UberShaderPixel.cpp b/Source/Core/VideoCommon/UberShaderPixel.cpp index ef59414619..94ce2e2dbb 100644 --- a/Source/Core/VideoCommon/UberShaderPixel.cpp +++ b/Source/Core/VideoCommon/UberShaderPixel.cpp @@ -17,263 +17,6 @@ namespace UberShader { -namespace -{ -void WriteCustomShaderStructImpl(ShaderCode* out, u32 num_texgen, bool per_pixel_lighting) -{ - out->Write("\tCustomShaderData custom_data;\n"); - if (per_pixel_lighting) - { - out->Write("\tcustom_data.position = WorldPos;\n"); - out->Write("\tcustom_data.normal = Normal;\n"); - } - else - { - out->Write("\tcustom_data.position = float3(0, 0, 0);\n"); - out->Write("\tcustom_data.normal = float3(0, 0, 0);\n"); - } - - if (num_texgen == 0) [[unlikely]] - { - out->Write("\tcustom_data.texcoord[0] = float3(0, 0, 0);\n"); - } - else - { - for (u32 i = 0; i < num_texgen; ++i) - { - out->Write("\tif (tex{0}.z == 0.0)\n", i); - out->Write("\t{{\n"); - out->Write("\t\tcustom_data.texcoord[{0}] = tex{0};\n", i); - out->Write("\t}}\n"); - out->Write("\telse {{\n"); - out->Write("\t\tcustom_data.texcoord[{0}] = float3(tex{0}.xy / tex{0}.z, 0);\n", i); - out->Write("\t}}\n"); - } - } - - out->Write("\tcustom_data.texcoord_count = {};\n", num_texgen); - - for (u32 i = 0; i < 8; i++) - { - // Shader compilation complains if every index isn't initialized - out->Write("\tcustom_data.texmap_to_texcoord_index[{0}] = {0};\n", i); - } - - for (u32 i = 0; i < NUM_XF_COLOR_CHANNELS; i++) - { - out->Write("\tcustom_data.base_material[{}] = vec4(0, 0, 0, 1);\n", i); - out->Write("\tcustom_data.ambient_lighting[{}] = vec4(0, 0, 0, 1);\n", i); - - // Shader compilation errors can throw if not everything is initialized - for (u32 light_count_index = 0; light_count_index < 8; light_count_index++) - { - // Color - out->Write("\tcustom_data.lights_chan{}_color[{}].direction = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_color[{}].position = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_color[{}].color = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_color[{}].cosatt = float4(0, 0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_color[{}].distatt = float4(0, 0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_color[{}].attenuation_type = 0;\n", i, - light_count_index); - - // Alpha - out->Write("\tcustom_data.lights_chan{}_alpha[{}].direction = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].position = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].color = float3(0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].cosatt = float4(0, 0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].distatt = float4(0, 0, 0, 0);\n", i, - light_count_index); - out->Write("\tcustom_data.lights_chan{}_alpha[{}].attenuation_type = 0;\n", i, - light_count_index); - } - - out->Write("\tcustom_data.light_chan{}_color_count = 0;\n", i); - out->Write("\tcustom_data.light_chan{}_alpha_count = 0;\n", i); - } - - if (num_texgen > 0) [[likely]] - { - out->Write("\n"); - out->Write("\tfor(uint stage = 0u; stage <= num_stages; stage++)\n"); - out->Write("\t{{\n"); - out->Write("\t\tStageState ss;\n"); - out->Write("\t\tss.order = bpmem_tevorder(stage>>1);\n"); - out->Write("\t\tif ((stage & 1u) == 1u)\n"); - out->Write("\t\t\tss.order = ss.order >> {};\n\n", - int(TwoTevStageOrders().enable_tex_odd.StartBit() - - TwoTevStageOrders().enable_tex_even.StartBit())); - out->Write("\t\tuint texmap = {};\n", - BitfieldExtract<&TwoTevStageOrders::texcoord_even>("ss.order")); - // Shader compilation is weird, shader arrays can't use indexing by variable - // to set values unless the variable is an index in a for loop. - // So instead we have to do this if check nonsense - for (u32 i = 0; i < 8; i++) - { - out->Write("\t\tif (texmap == {})\n", i); - out->Write("\t\t{{\n"); - out->Write("\t\t\tcustom_data.texmap_to_texcoord_index[{}] = selectTexCoordIndex(texmap);\n", - i); - out->Write("\t\t}}\n"); - } - out->Write("\t}}\n"); - } - - if (per_pixel_lighting) - { - out->Write("\tuint light_count = 0;\n"); - out->Write("\tfor (uint chan = 0u; chan < {}u; chan++)\n", NUM_XF_COLOR_CHANNELS); - out->Write("\t{{\n"); - out->Write("\t\tuint colorreg = xfmem_color(chan);\n"); - out->Write("\t\tuint alphareg = xfmem_alpha(chan);\n"); - for (const auto& color_type : std::array{"colorreg", "alphareg"}) - { - if (color_type == "colorreg") - { - out->Write("\t\tcustom_data.base_material[0] = " I_MATERIALS "[2u] / 255.0; \n"); - out->Write("\t\tif ({} != 0u)\n", BitfieldExtract<&LitChannel::enablelighting>(color_type)); - out->Write("\t\t\tcustom_data.base_material[0] = colors_0; \n"); - } - else - { - out->Write("custom_data.base_material[1].w = " I_MATERIALS "[3u].w / 255.0; \n"); - out->Write("\t\tif ({} != 0u)\n", BitfieldExtract<&LitChannel::enablelighting>(color_type)); - out->Write("\t\t\tcustom_data.base_material[1].w = colors_1.w; \n"); - } - out->Write("\t\tif ({} != 0u)\n", BitfieldExtract<&LitChannel::enablelighting>(color_type)); - out->Write("\t\t{{\n"); - out->Write("\t\t\tuint light_mask = {} | ({} << 4u);\n", - BitfieldExtract<&LitChannel::lightMask0_3>(color_type), - BitfieldExtract<&LitChannel::lightMask4_7>(color_type)); - out->Write("\t\t\tuint attnfunc = {};\n", BitfieldExtract<&LitChannel::attnfunc>(color_type)); - out->Write("\t\t\tfor (uint light_index = 0u; light_index < 8u; light_index++)\n"); - out->Write("\t\t\t{{\n"); - out->Write("\t\t\t\tif ((light_mask & (1u << light_index)) != 0u)\n"); - out->Write("\t\t\t\t{{\n"); - // Shader compilation is weird, shader arrays can't use indexing by variable - // to set values unless the variable is an index in a for loop. - // So instead we have to do this if check nonsense - for (u32 light_count_index = 0; light_count_index < 8; light_count_index++) - { - out->Write("\t\t\t\t\tif (light_index == {})\n", light_count_index); - out->Write("\t\t\t\t\t{{\n"); - if (color_type == "colorreg") - { - for (u32 channel_index = 0; channel_index < NUM_XF_COLOR_CHANNELS; channel_index++) - { - out->Write("\t\t\t\t\t\tif (chan == {})\n", channel_index); - out->Write("\t\t\t\t\t\t{{\n"); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].direction = " I_LIGHTS - "[light_index].dir.xyz;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].position = " I_LIGHTS - "[light_index].pos.xyz;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].cosatt = " I_LIGHTS - "[light_index].cosatt;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].distatt = " I_LIGHTS - "[light_index].distatt;\n", - channel_index, light_count_index); - out->Write( - "\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].attenuation_type = attnfunc;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_color[{}].color = " I_LIGHTS - "[light_index].color.rgb / float3(255.0, 255.0, 255.0);\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.light_chan{}_color_count += 1;\n", channel_index); - out->Write("\t\t\t\t\t\t}}\n"); - } - } - else - { - for (u32 channel_index = 0; channel_index < NUM_XF_COLOR_CHANNELS; channel_index++) - { - out->Write("\t\t\t\t\t\tif (chan == {})\n", channel_index); - out->Write("\t\t\t\t\t\t{{\n"); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].direction = " I_LIGHTS - "[light_index].dir.xyz;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].position = " I_LIGHTS - "[light_index].pos.xyz;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].cosatt = " I_LIGHTS - "[light_index].cosatt;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].distatt = " I_LIGHTS - "[light_index].distatt;\n", - channel_index, light_count_index); - out->Write( - "\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].attenuation_type = attnfunc;\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.lights_chan{}_alpha[{}].color = float3(" I_LIGHTS - "[light_index].color.a) / float3(255.0, 255.0, 255.0);\n", - channel_index, light_count_index); - out->Write("\t\t\t\t\t\t\tcustom_data.light_chan{}_alpha_count += 1;\n", channel_index); - out->Write("\t\t\t\t\t\t}}\n"); - } - } - - out->Write("\t\t\t\t\t}}\n"); - } - out->Write("\t\t\t\t}}\n"); - out->Write("\t\t\t}}\n"); - out->Write("\t\t}}\n"); - } - out->Write("\t}}\n"); - } - - for (u32 i = 0; i < 16; i++) - { - // Shader compilation complains if every struct isn't initialized - - // Color Input - for (u32 j = 0; j < 4; j++) - { - out->Write("\tcustom_data.tev_stages[{}].input_color[{}].input_type = " - "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n", - i, j); - out->Write("\tcustom_data.tev_stages[{}].input_color[{}].value = " - "float3(0, 0, 0);\n", - i, j); - } - - // Alpha Input - for (u32 j = 0; j < 4; j++) - { - out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].input_type = " - "CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_UNUSED;\n", - i, j); - out->Write("\tcustom_data.tev_stages[{}].input_alpha[{}].value = " - "float(0);\n", - i, j); - } - - // Texmap - out->Write("\tcustom_data.tev_stages[{}].texmap = 0u;\n", i); - - // Output - out->Write("\tcustom_data.tev_stages[{}].output_color = " - "float4(0, 0, 0, 0);\n", - i); - } - - // Actual data will be filled out in the tev stage code, just set the - // stage count for now - out->Write("\tcustom_data.tev_stage_count = num_stages;\n"); - - // Time - out->Write("\tcustom_data.time_ms = time_ms;\n"); -} -} // namespace PixelShaderUid GetPixelShaderUid() { PixelShaderUid out; @@ -313,8 +56,7 @@ void ClearUnusedPixelShaderUidBits(APIType api_type, const ShaderHostConfig& hos } ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, - const pixel_ubershader_uid_data* uid_data, - const CustomPixelShaderContents& custom_details) + const pixel_ubershader_uid_data* uid_data) { const bool per_pixel_lighting = host_config.per_pixel_lighting; const bool msaa = host_config.msaa; @@ -333,13 +75,7 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, out.Write("// {}\n", *uid_data); WriteBitfieldExtractHeader(out, api_type, host_config); - WritePixelShaderCommonHeader(out, api_type, host_config, bounding_box, custom_details); - WriteCustomShaderStructDef(&out, numTexgen); - for (std::size_t i = 0; i < custom_details.shaders.size(); i++) - { - const auto& shader_details = custom_details.shaders[i]; - out.Write(fmt::runtime(shader_details.custom_shader), i); - } + WritePixelShaderCommonHeader(out, api_type, host_config, bounding_box); if (per_pixel_lighting) WriteLightingFunction(out); @@ -769,25 +505,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, "return int3(0, 0, 0);", // ZERO }; - static constexpr Common::EnumMap tev_c_input_type{ - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_KONST;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC;", - }; - static constexpr Common::EnumMap tev_a_input_table{ "return s.Reg[0].a;", // APREV, "return s.Reg[1].a;", // A0, @@ -799,17 +516,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, "return 0;", // ZERO }; - static constexpr Common::EnumMap tev_a_input_type{ - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_PREV;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_COLOR;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_TEX;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_RAS;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_KONST;", - "return CUSTOM_SHADER_TEV_STAGE_INPUT_TYPE_NUMERIC;", - }; - static constexpr Common::EnumMap tev_regs_lookup_table{ "return s.Reg[0];", "return s.Reg[1];", @@ -851,16 +557,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, out.Write("}}\n" "\n"); - out.Write("// Helper function for Custom Shader Input Type\n" - "uint getColorInputType(uint index) {{\n"); - WriteSwitch(out, api_type, "index", tev_c_input_type, 2, false); - out.Write("}}\n" - "\n" - "uint getAlphaInputType(uint index) {{\n"); - WriteSwitch(out, api_type, "index", tev_a_input_type, 2, false); - out.Write("}}\n" - "\n"); - // Since the fixed-point texture coodinate variables aren't global, we need to pass // them to the select function. This applies to all backends. if (numTexgen > 0) @@ -880,14 +576,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, out.Write(" uint num_stages = {};\n\n", BitfieldExtract<&GenMode::numtevstages>("bpmem_genmode")); - bool has_custom_shader_details = false; - if (std::any_of(custom_details.shaders.begin(), custom_details.shaders.end(), - [](const std::optional& ps) { return ps.has_value(); })) - { - WriteCustomShaderStructImpl(&out, numTexgen, per_pixel_lighting); - has_custom_shader_details = true; - } - if (use_framebuffer_fetch) { // Store off a copy of the initial framebuffer value. @@ -1239,78 +927,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, "\n" " // Write result to the correct input register of the next stage\n"); WriteSwitch(out, api_type, "alpha_dest", tev_a_set_table, 6, true); - if (has_custom_shader_details) - { - for (u32 stage_index = 0; stage_index < 16; stage_index++) - { - out.Write("\tif (stage == {}u) {{\n", stage_index); - // Color input - out.Write("\t\tcustom_data.tev_stages[{}].input_color[0].value = color_A / float3(255.0, " - "255.0, 255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[0].input_type = " - "getColorInputType(color_a);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[1].value = color_B / float3(255.0, " - "255.0, 255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[1].input_type = " - "getColorInputType(color_b);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[2].value = color_C / float3(255.0, " - "255.0, 255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[2].input_type = " - "getColorInputType(color_c);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[3].value = color_D / float3(255.0, " - "255.0, 255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_color[3].input_type = " - "getColorInputType(color_c);\n", - stage_index); - - // Alpha input - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[0].value = alpha_A / float(255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[0].input_type = " - "getAlphaInputType(alpha_a);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[1].value = alpha_B / float(255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[1].input_type = " - "getAlphaInputType(alpha_b);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[2].value = alpha_C / float(255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[2].input_type = " - "getAlphaInputType(alpha_c);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[3].value = alpha_D / float(255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].input_alpha[3].input_type = " - "getAlphaInputType(alpha_d);\n", - stage_index); - - if (numTexgen != 0) - { - // Texmap - out.Write("\t\tif (texture_enabled) {{\n"); - out.Write("\t\t\tuint sampler_num = {};\n", - BitfieldExtract<&TwoTevStageOrders::texmap_even>("ss.order")); - out.Write("\t\tcustom_data.tev_stages[{}].texmap = sampler_num;\n", stage_index); - out.Write("\t\t}}\n"); - } - - // Output - out.Write("\t\tcustom_data.tev_stages[{}].output_color.rgb = color / float3(255.0, 255.0, " - "255.0);\n", - stage_index); - out.Write("\t\tcustom_data.tev_stages[{}].output_color.a = alpha / float(255.0);\n", - stage_index); - out.Write("\t}}\n"); - } - } out.Write(" }}\n"); out.Write(" }} // Main TEV loop\n"); out.Write("\n"); @@ -1508,24 +1124,6 @@ ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, " }}\n" "\n"); - for (std::size_t i = 0; i < custom_details.shaders.size(); i++) - { - const auto& shader_details = custom_details.shaders[i]; - - if (!shader_details.custom_shader.empty()) - { - out.Write("\t{{\n"); - out.Write("\t\tcustom_data.final_color = float4(TevResult.r / 255.0, TevResult.g / 255.0, " - "TevResult.b / 255.0, TevResult.a / 255.0);\n"); - out.Write("\t\tCustomShaderOutput custom_output = {}_{}(custom_data);\n", - CUSTOM_PIXELSHADER_COLOR_FUNC, i); - out.Write( - "\t\tTevResult = int4(custom_output.main_rt.r * 255, custom_output.main_rt.g * 255, " - "custom_output.main_rt.b * 255, custom_output.main_rt.a * 255);\n"); - out.Write("\t}}\n\n"); - } - } - if (use_framebuffer_fetch) { static constexpr std::array logic_op_mode{ diff --git a/Source/Core/VideoCommon/UberShaderPixel.h b/Source/Core/VideoCommon/UberShaderPixel.h index 80560688ca..aa3d6c7625 100644 --- a/Source/Core/VideoCommon/UberShaderPixel.h +++ b/Source/Core/VideoCommon/UberShaderPixel.h @@ -29,8 +29,7 @@ using PixelShaderUid = ShaderUid; PixelShaderUid GetPixelShaderUid(); ShaderCode GenPixelShader(APIType api_type, const ShaderHostConfig& host_config, - const pixel_ubershader_uid_data* uid_data, - const CustomPixelShaderContents& custom_details); + const pixel_ubershader_uid_data* uid_data); void EnumeratePixelShaderUids(const std::function& callback); void ClearUnusedPixelShaderUidBits(APIType api_type, const ShaderHostConfig& host_config,