Patch glsl

.github/workflows/manual_generate_apk.yml

@@ -55,10 +55,10 @@ jobs:
       #  with:
       #    ndk-version: r21e
 
-      - name: Test androidGitVersion
-        run: |
-          echo "count=${{steps.valid-tags.outputs.count}}"
-          gradle --quiet androidGitVersion
+      #- name: Test androidGitVersion
+      #  run: |
+      #    echo "count=${{steps.valid-tags.outputs.count}}"
+      #    gradle --quiet androidGitVersion
 
       - name: Assemble APK
         run: ./gradlew assemble${{ github.event.inputs.buildVariant }} --stacktrace

GPU/Common/FragmentShaderGenerator.cpp

@@ -30,6 +30,7 @@
 #include "GPU/Common/ShaderId.h"
 #include "GPU/Common/ShaderUniforms.h"
 #include "GPU/Common/FragmentShaderGenerator.h"
+#include "GPU/Common/LegacyPBR.h"
 #include "GPU/Vulkan/DrawEngineVulkan.h"
 #include "GPU/ge_constants.h"
 #include "GPU/GPUState.h"
@@ -48,7 +49,7 @@ static const SamplerDef samplersStereo[3] = {
 	{ 2, "pal" },
 };
 
-bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLanguageDesc &compat, Draw::Bugs bugs, uint64_t *uniformMask, FragmentShaderFlags *fragmentShaderFlags, std::string *errorString) {
+bool GenerateFragmentShader(const FShaderID &id, const VShaderID *linkedVSID, char *buffer, const ShaderLanguageDesc &compat, Draw::Bugs bugs, uint64_t *uniformMask, FragmentShaderFlags *fragmentShaderFlags, std::string *errorString) {
 	*uniformMask = 0;
 	*fragmentShaderFlags = (FragmentShaderFlags)0;
 	errorString->clear();
@@ -69,7 +70,22 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 	}
 
 	bool texture3D = id.Bit(FS_BIT_3D_TEXTURE);
-	bool arrayTexture = id.Bit(FS_BIT_SAMPLE_ARRAY_TEXTURE);
+		bool arrayTexture = id.Bit(FS_BIT_SAMPLE_ARRAY_TEXTURE);
+
+	bool linkedLegacyPBRVertexMode1 = false;
+	bool linkedLegacyPBRVertexMode2 = false;
+	if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && linkedVSID) {
+		linkedLegacyPBRVertexMode1 = LegacyPBRVertexMode1(
+			linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_HAS_NORMAL),
+			linkedVSID->Bit(VS_BIT_HAS_TEXCOORD) || !linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_LIGHTING_ENABLE),
+			linkedVSID->Bit(VS_BIT_VERTEX_RANGE_CULLING));
+		linkedLegacyPBRVertexMode2 = LegacyPBRVertexMode2(
+			linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_HAS_TEXCOORD) || !linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_VERTEX_RANGE_CULLING));
+	}
 	bool forceDepthWritesOff = id.Bit(FS_BIT_DEPTH_TEST_NEVER);
 	bool useDiscardStencilBugWorkaround = id.Bit(FS_BIT_NO_DEPTH_CANNOT_DISCARD_STENCIL) && !forceDepthWritesOff;
 
@@ -102,12 +118,36 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 
 	ShaderWriter p(buffer, compat, ShaderStage::Fragment, extensions, flags);
 	p.C("// %").W(id.Description()).endl();
+	if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && linkedVSID) {
+		const bool linkedVSMode1 = LegacyPBRVertexMode1(
+			linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_HAS_NORMAL),
+			linkedVSID->Bit(VS_BIT_HAS_TEXCOORD) || !linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_LIGHTING_ENABLE),
+			linkedVSID->Bit(VS_BIT_VERTEX_RANGE_CULLING));
+		const bool linkedVSMode2 = LegacyPBRVertexMode2(
+			linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_HAS_TEXCOORD) || !linkedVSID->Bit(VS_BIT_USE_HW_TRANSFORM),
+			linkedVSID->Bit(VS_BIT_VERTEX_RANGE_CULLING));
+		p.F("// Used by vertex%016llx.glsl\n", (unsigned long long)linkedVSID->ToUint64());
+		p.F("// Linked vertex shader ID: %016llx\n", (unsigned long long)linkedVSID->ToUint64());
+		if (linkedVSMode1)
+			p.C("// Legacy PBR vertex mode: 1 (fragment flag 1 is valid)\n");
+		else if (linkedVSMode2)
+			p.C("// Legacy PBR vertex mode: 2 (fragment flag 2; PBR path inactive)\n");
+		else
+			p.C("// Legacy PBR vertex mode: none (fragment PBR must remain inactive)\n");
+	}
 
 	p.ApplySamplerMetadata(arrayTexture ? samplersStereo : samplersMono);
 
 	bool lmode = id.Bit(FS_BIT_LMODE);
 	bool doTexture = id.Bit(FS_BIT_DO_TEXTURE);
 	bool enableFog = id.Bit(FS_BIT_ENABLE_FOG);
+	const bool legacyPBRFragmentBase =
+		id.Bit(FS_BIT_LEGACY_PBR_ATLAS) &&
+		(linkedLegacyPBRVertexMode1 || linkedLegacyPBRVertexMode2) &&
+		LegacyPBRFragmentBase(enableFragmentTestCache, doTexture, enableFog);
 	bool enableAlphaTest = id.Bit(FS_BIT_ALPHA_TEST);
 
 	bool alphaTestAgainstZero = id.Bit(FS_BIT_ALPHA_AGAINST_ZERO);
@@ -436,6 +476,10 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 		if (fsMinmaxDiscard || fsDepthClamp) {
 			WRITE(p, "%s highp vec2 v_zw;\n", compat.varying_fs);
 		}
+		if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && legacyPBRFragmentBase) {
+			WRITE(p, "//****** my_varying_fs *********\n");
+			WriteLegacyPBRVaryingFS(p, shading, compat.varying_fs);
+		}
 
 		if (!enableFragmentTestCache) {
 			if (enableAlphaTest && !alphaTestAgainstZero) {
@@ -471,6 +515,10 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 				WRITE(p, "%s vec4 fragColor0;\n", qualifierColor0);
 			}
 		}
+		// Emit PBR functions after fragment output declarations, since PBR__2_0 writes fragColor0.
+		if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && legacyPBRFragmentBase) {
+			WriteLegacyPBRPrelude(p);
+		}
 	}
 
 	bool hasPackUnorm4x8 = false;
@@ -518,6 +566,14 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 		if (writeDepth) {
 			WRITE(p, "  float gl_FragDepth;\n");
 		}
+	if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && legacyPBRFragmentBase) {
+			// The original replacement shader derives a tint from the fog color.
+			// Emit its helper outside main(), as required by GLSL.
+			WRITE(p, "float lightness(float R, float G, float B) {\n");
+			WRITE(p, "  return pow(pow(R / 1.0, 2.2) + pow(B / 1.666666, 2.2) + pow(G / 0.666666, 2.2), 1.0 / 2.2) * 0.547373;\n");
+			WRITE(p, "}\n");
+	}
+
 	} else {
 		WRITE(p, "void main() {\n");
 	}
@@ -930,9 +986,47 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 			WRITE(p, "  vec4 v = v_color0%s;\n", secondary);
 		}
 
+		// Legacy PBR is generated before post-processing so alpha/color tests and blending use its result.
+		WRITE(p, "  bool legacyPBRActive = false;\n");
+		WRITE(p, "  vec4 legacyPBRColor = vec4(0.0);\n");
+
+		if (ShaderLanguageIsOpenGL(compat.shaderLanguage) && legacyPBRFragmentBase) {
+			// Match the legacy GLSL atlas layout and sampling math:
+			// base color (top-left), normal data (top-right), emissive/material
+			// selector (bottom-left), and four sphere maps (bottom-right).
+			WRITE(p, "  if (flag == 1) {\n");
+			WRITE(p, "    vec4 legacyBaseColor = %s(tex, v_texcoord.xy * 0.5);\n", compat.texture);
+			WRITE(p, "    vec3 legacyNormalColor = %s(tex, vec2(0.5, 0.0) + v_texcoord.xy * 0.5).rgb;\n", compat.texture);
+			WRITE(p, "    vec4 legacyEmissive = %s(tex, vec2(0.0, 0.5) + v_texcoord.xy * 0.5);\n", compat.texture);
+			WRITE(p, "    vec3 legacyN = v_1.xyz + legacyNormalColor * 0.5;\n");
+			WRITE(p, "    legacyN = normalize(legacyN);\n");
+			WRITE(p, "    vec3 legacyR = reflect(-v_2.xyz, legacyN);\n");
+			WRITE(p, "    float legacyM = 2.0 * sqrt(max(legacyR.x * legacyR.x + legacyR.y * legacyR.y + (legacyR.z + 1.0) * legacyR.z, 0.000001));\n");
+			// Keep reflection coordinates inside the selected 512x512 sphere-map quadrant.\n			// The half-texel inset avoids filtering across atlas quadrant boundaries.\n			WRITE(p, "    vec2 legacySphereBaseUV = clamp((vec2(legacyR.x, legacyR.y) / legacyM + 0.5) * 0.25, vec2(0.0001220703125), vec2(0.2498779296875));\n");
+			WRITE(p, "    float legacyFogLightness = lightness(u_fogcolor.r, u_fogcolor.g, u_fogcolor.b);\n");
+			WRITE(p, "    vec3 legacyFogColor = vec3(mix(vec3(dot(u_fogcolor, vec3(0.299, 0.587, 0.114))), u_fogcolor, 0.6));\n");
+			WRITE(p, "    legacyFogColor += legacyFogLightness < 0.15 ? 0.6 - legacyFogLightness : 0.6;\n");
+			WRITE(p, "    vec2 legacySphereOffset = vec2(0.75, 0.75);\n");
+			WRITE(p, "    if (legacyEmissive.a >= 0.001 && legacyEmissive.a < 0.1) legacySphereOffset = vec2(0.5, 0.5);\n");
+			WRITE(p, "    else if (legacyEmissive.a >= 0.0999 && legacyEmissive.a < 0.2) legacySphereOffset = vec2(0.75, 0.5);\n");
+			WRITE(p, "    else if (legacyEmissive.a >= 0.1999 && legacyEmissive.a < 0.3) legacySphereOffset = vec2(0.5, 0.75);\n");
+			WRITE(p, "    else if (legacyEmissive.a >= 0.2999 && legacyEmissive.a < 0.4) legacySphereOffset = vec2(0.75, 0.75);\n");
+			WRITE(p, "    vec3 legacySphere = %s(tex, legacySphereOffset + legacySphereBaseUV).rgb;\n", compat.texture);
+			WRITE(p, "    legacyPBRColor = vec4(legacyBaseColor.rgb * legacySphere * legacyFogColor + legacyEmissive.rgb, v.a);\n");
+			WRITE(p, "    legacyPBRActive = true;\n");
+			WRITE(p, "  } else if (flag == 2) {\n");
+			WRITE(p, "    legacyPBRColor = %s(tex, v_texcoord.xy * 0.5);\n", compat.texture);
+			WRITE(p, "    legacyPBRActive = true;\n");
+			WRITE(p, "  }\n");
+			// Use the selected legacy texture result for alpha/color tests and blending.
+			WRITE(p, "  if (legacyPBRActive) v = legacyPBRColor;\n");
+		}
+
 		if (enableFog) {
-			WRITE(p, "  float fogCoef = clamp(v_fogdepth, 0.0, 1.0);\n");
-			WRITE(p, "  v.rgb = mix(u_fogcolor, v.rgb, fogCoef);\n");
+			WRITE(p, "  if (!legacyPBRActive) {\n");
+			WRITE(p, "    float fogCoef = clamp(v_fogdepth, 0.0, 1.0);\n");
+			WRITE(p, "    v.rgb = mix(u_fogcolor, v.rgb, fogCoef);\n");
+			WRITE(p, "  }\n");
 		}
 
 		// Texture access is at half texels [0.5/256, 255.5/256], but colors are normalized [0, 255].
@@ -950,6 +1044,8 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 		const char *discardStatement = testForceToZero ? "v.a = 0.0;" : "DISCARD;";
 		if (enableAlphaTest) {
 			*fragmentShaderFlags |= FragmentShaderFlags::USES_DISCARD;
+			if (legacyPBRFragmentBase && id.Bit(FS_BIT_LEGACY_PBR_ALPHA))
+				WRITE(p, "  if (!(legacyPBRActive && flag == 1)) {\n");
 
 			if (alphaTestAgainstZero) {
 				// When testing against 0 (extremely common), we can avoid some math.
@@ -985,6 +1081,8 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 					WRITE(p, "  %s\n", discardStatement);
 				}
 			}
+			if (legacyPBRFragmentBase && id.Bit(FS_BIT_LEGACY_PBR_ALPHA))
+				WRITE(p, "  }\n");
 		}
 
 		if (enableColorTest) {
@@ -1318,7 +1416,14 @@ bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLangu
 	}
 
 	WRITE(p, "}\n");
+	std::string overrideSource;
+	if (ShaderLanguageIsOpenGL(compat.shaderLanguage)) {
+		if (LoadLegacyGLSLOverride("Fragment", id.ToUint64(), &overrideSource)) {
+			memcpy(buffer, overrideSource.c_str(), overrideSource.size() + 1);
+		} else {
+			SaveGeneratedLegacyGLSL("Fragment", id.ToUint64(), std::string(buffer));
+		}
+	}
 
 	return true;
 }
-

GPU/Common/FragmentShaderGenerator.h

@@ -22,6 +22,7 @@
 #include "Common/GPU/thin3d.h"
 
 struct FShaderID;
+struct VShaderID;
 
 // Can technically be deduced from the fragment shader ID, but this is safer.
 enum class FragmentShaderFlags : u32 {
@@ -30,4 +31,4 @@ enum class FragmentShaderFlags : u32 {
 };
 ENUM_CLASS_BITOPS(FragmentShaderFlags);
 
-bool GenerateFragmentShader(const FShaderID &id, char *buffer, const ShaderLanguageDesc &compat, Draw::Bugs bugs, uint64_t *uniformMask, FragmentShaderFlags *fragmentShaderFlags, std::string *errorString);
+bool GenerateFragmentShader(const FShaderID &id, const VShaderID *linkedVSID, char *buffer, const ShaderLanguageDesc &compat, Draw::Bugs bugs, uint64_t *uniformMask, FragmentShaderFlags *fragmentShaderFlags, std::string *errorString);