Some renaming

AnKi/Resource/ShaderProgramResource.cpp

@@ -387,7 +387,7 @@ void ShaderProgramResource::initVariant(const ShaderProgramResourceVariantInitIn
 			inf.m_constValues.setArray((constValueCount) ? constValues.getBegin() : nullptr, constValueCount);
 			ShaderPtr shader = getManager().getGrManager().newShader(inf);
 
-			if(true && (ANKI_OS_LINUX || ANKI_OS_WINDOWS))
+			if(false && (ANKI_OS_LINUX || ANKI_OS_WINDOWS))
 			{
 				MaliOfflineCompilerOut maliocOut;
 				const Error err =

AnKi/ShaderCompiler/ShaderProgramParser.cpp

@@ -254,6 +254,7 @@ layout(std140, row_major) uniform;
 layout(std140, row_major) buffer;
 
 #define ANKI_RP mediump
+#define ANKI_FP highp
 )";
 
 static const U64 SHADER_HEADER_HASH = computeHash(SHADER_HEADER, sizeof(SHADER_HEADER));

AnKi/Shaders/ApplyIrradianceToReflection.ankiprog

@@ -34,7 +34,9 @@ void main()
 
 	// Read the gbuffer
 	GbufferInfo gbuffer;
-	readGBuffer(u_gbufferTex[0u], u_gbufferTex[1u], u_gbufferTex[2u], u_nearestAnyClampSampler, sampleUv, gbuffer);
+	unpackGBufferNoVelocity(textureLod(u_gbufferTex[0u], u_nearestAnyClampSampler, sampleUv, 0.0),
+							textureLod(u_gbufferTex[1u], u_nearestAnyClampSampler, sampleUv, 0.0),
+							textureLod(u_gbufferTex[2u], u_nearestAnyClampSampler, sampleUv, 0.0), gbuffer);
 
 	// Sample
 	const Vec3 irradiance = sampleAmbientDice(u_irradianceDice[0u].xyz, u_irradianceDice[1u].xyz,

AnKi/Shaders/ForwardShadingCommonFrag.glsl

@@ -22,7 +22,7 @@ layout(set = 0, binding = 2) uniform texture3D u_lightVol;
 
 layout(location = 0) out Vec4 out_color;
 
-void writeGBuffer(Vec4 color)
+void packGBuffer(Vec4 color)
 {
 	out_color = Vec4(color.rgb, color.a);
 }
@@ -115,7 +115,7 @@ Vec3 computeLightColorLow(Vec3 diffCol, Vec3 worldPos)
 
 void particleAlpha(Vec4 color, Vec4 scaleColor, Vec4 biasColor)
 {
-	writeGBuffer(color * scaleColor + biasColor);
+	packGBuffer(color * scaleColor + biasColor);
 }
 
 void fog(Vec3 color, F32 fogAlphaScale, F32 fogDistanceOfMaxThikness, F32 zVSpace)
@@ -134,5 +134,5 @@ void fog(Vec3 color, F32 fogAlphaScale, F32 fogDistanceOfMaxThikness, F32 zVSpac
 
 	zFeatherFactor = min(1.0, diff / fogDistanceOfMaxThikness);
 
-	writeGBuffer(Vec4(color, zFeatherFactor * fogAlphaScale));
+	packGBuffer(Vec4(color, zFeatherFactor * fogAlphaScale));
 }

AnKi/Shaders/GBufferCommon.glsl

@@ -90,18 +90,18 @@ layout(location = 3) out Vec2 out_gbuffer3;
 
 // Write the data to RTs
 #if defined(ANKI_FRAGMENT_SHADER) && ANKI_PASS == PASS_GB
-void writeGBuffer(ANKI_RP Vec3 diffColor, ANKI_RP Vec3 normal, ANKI_RP Vec3 specularColor, ANKI_RP F32 roughness,
-				  ANKI_RP F32 subsurface, ANKI_RP Vec3 emission, ANKI_RP F32 metallic, Vec2 velocity)
+void packGBuffer(ANKI_RP Vec3 diffColor, ANKI_RP Vec3 normal, ANKI_RP Vec3 specularColor, ANKI_RP F32 roughness,
+				 ANKI_RP F32 subsurface, ANKI_RP Vec3 emission, ANKI_RP F32 metallic, Vec2 velocity)
 {
 	GbufferInfo g;
 	g.m_diffuse = diffColor;
 	g.m_normal = normal;
-	g.m_specular = specularColor;
+	g.m_f0 = specularColor;
 	g.m_roughness = roughness;
 	g.m_subsurface = subsurface;
 	g.m_emission = (emission.r + emission.g + emission.b) / 3.0;
 	g.m_metallic = metallic;
 	g.m_velocity = velocity;
-	writeGBuffer(g, out_gbuffer0, out_gbuffer1, out_gbuffer2, out_gbuffer3);
+	packGBuffer(g, out_gbuffer0, out_gbuffer1, out_gbuffer2, out_gbuffer3);
 }
 #endif

AnKi/Shaders/GBufferGeneric.ankiprog

@@ -402,7 +402,7 @@ void main()
 	const Vec2 velocity = Vec2(1.0);
 #	endif
 
-	writeGBuffer(diffColor, normal, specColor, roughness, u_ankiPerDraw.m_subsurface, emission, metallic, velocity);
+	packGBuffer(diffColor, normal, specColor, roughness, u_ankiPerDraw.m_subsurface, emission, metallic, velocity);
 #elif ANKI_PASS == PASS_EZ
 	out_gbuffer0 = Vec4(0.0);
 	out_gbuffer1 = Vec4(0.0);

AnKi/Shaders/GBufferGpuParticles.ankiprog

@@ -78,13 +78,13 @@ void main()
 	GbufferInfo g;
 	g.m_diffuse = u_ankiPerDraw.m_diffColor;
 	g.m_normal = u_minusCameraZ;
-	g.m_specular = u_ankiPerDraw.m_specColor;
+	g.m_f0 = u_ankiPerDraw.m_specColor;
 	g.m_roughness = u_ankiPerDraw.m_roughness;
 	g.m_subsurface = 0.0;
 	const Vec3 emission = mix(u_ankiPerDraw.m_initialEmission, u_ankiPerDraw.m_finalEmission, in_lifeFactor);
 	g.m_emission = (emission.r + emission.g + emission.b) / 3.0;
 	g.m_metallic = u_ankiPerDraw.m_metallic;
 	g.m_velocity = in_velocity;
-	writeGBuffer(g, out_gbuffer0, out_gbuffer1, out_gbuffer2, out_gbuffer3);
+	packGBuffer(g, out_gbuffer0, out_gbuffer1, out_gbuffer2, out_gbuffer3);
 }
 #pragma anki end

AnKi/Shaders/IndirectDiffuse.ankiprog

@@ -62,7 +62,7 @@ void main()
 	const Vec2 ndc = UV_TO_NDC(uv);
 
 	// Get normal
-	const Vec3 worldNormal = readNormalFromGBuffer(u_gbufferRt2, u_linearAnyClampSampler, uv);
+	const Vec3 worldNormal = unpackNormalFromGBuffer(textureLod(u_gbufferRt2, u_linearAnyClampSampler, uv, 0.0));
 	const Vec3 viewNormal = u_clusteredShading.m_matrices.m_viewRotation * worldNormal;
 
 	// Get origin

AnKi/Shaders/IndirectDiffuseDenoise.ankiprog

@@ -51,7 +51,8 @@ void main()
 	}
 
 	const Vec3 positionCenter = unproject(UV_TO_NDC(uv), depthCenter);
-	const ANKI_RP Vec3 normalCenter = readNormalFromGBuffer(u_gbuffer2Tex, u_linearAnyClampSampler, uv);
+	const ANKI_RP Vec3 normalCenter =
+		unpackNormalFromGBuffer(textureLod(u_gbuffer2Tex, u_linearAnyClampSampler, uv, 0.0));
 
 	// Sample
 	ANKI_RP F32 weight = EPSILON_RP;

AnKi/Shaders/IrradianceDice.ankiprog

@@ -144,7 +144,9 @@ void main()
 		gbufferUv.x *= 1.0 / 6.0;
 		gbufferUv.x += (1.0 / 6.0) * F32(f);
 		GbufferInfo gbuffer;
-		readGBuffer(u_gbufferTex[0u], u_gbufferTex[1u], u_gbufferTex[2u], u_nearestAnyClampSampler, gbufferUv, gbuffer);
+		unpackGBufferNoVelocity(textureLod(u_gbufferTex[0u], u_nearestAnyClampSampler, gbufferUv, 0.0),
+								textureLod(u_gbufferTex[1u], u_nearestAnyClampSampler, gbufferUv, 0.0),
+								textureLod(u_gbufferTex[2u], u_nearestAnyClampSampler, gbufferUv, 0.0), gbuffer);
 
 		// Sample irradiance
 		Vec3 firstBounceIrradiance =

AnKi/Shaders/LightFunctions.glsl

@@ -139,7 +139,7 @@ ANKI_RP Vec3 specularIsotropicLobe(GbufferInfo gbuffer, Vec3 viewDir, Vec3 frag2
 	const ANKI_RP F32 NoV = max(0.05, dot(gbuffer.m_normal, viewDir));
 
 	// F
-	const ANKI_RP Vec3 F = F_Schlick(gbuffer.m_specular, VoH);
+	const ANKI_RP Vec3 F = F_Schlick(gbuffer.m_f0, VoH);
 
 	// D
 	const ANKI_RP F32 D = D_GGX(gbuffer.m_roughness, NoH, H, gbuffer.m_normal);

AnKi/Shaders/LightShading.ankiprog

@@ -76,7 +76,9 @@ void main()
 
 	// Decode GBuffer
 	GbufferInfo gbuffer;
-	readGBuffer(u_msRt0, u_msRt1, u_msRt2, u_nearestAnyClampSampler, in_uv, gbuffer);
+	unpackGBufferNoVelocity(textureLod(u_msRt0, u_nearestAnyClampSampler, in_uv, 0.0),
+							textureLod(u_msRt1, u_nearestAnyClampSampler, in_uv, 0.0),
+							textureLod(u_msRt2, u_nearestAnyClampSampler, in_uv, 0.0), gbuffer);
 	gbuffer.m_subsurface = max(gbuffer.m_subsurface, SUBSURFACE_MIN);
 
 	// SM
@@ -223,8 +225,7 @@ void main()
 
 		// Compute env BRDF
 		const F32 NoV = max(EPSILON, dot(gbuffer.m_normal, viewDir));
-		const Vec3 env =
-			envBRDF(gbuffer.m_specular, gbuffer.m_roughness, u_integrationLut, u_trilinearClampSampler, NoV);
+		const Vec3 env = envBRDF(gbuffer.m_f0, gbuffer.m_roughness, u_integrationLut, u_trilinearClampSampler, NoV);
 
 		out_color += finalSpecIndirect * env;
 	}

AnKi/Shaders/LightShadingApplyIndirect.ankiprog

@@ -9,6 +9,7 @@
 
 #pragma anki start frag
 #include <AnKi/Shaders/BilateralFilter.glsl>
+#include <AnKi/Shaders/PackFunctions.glsl>
 
 layout(set = 0, binding = 0) uniform sampler u_nearestAnyClampSampler;
 layout(set = 0, binding = 1) uniform sampler u_linearAnyClampSampler;
@@ -53,7 +54,9 @@ void main()
 
 	// Modulate
 	out_color /= sumWeight;
-	const ANKI_RP Vec3 albedo = textureLod(u_gbuffer0Tex, u_linearAnyClampSampler, in_uv, 0.0).xyz;
+	const ANKI_RP F32 metallic = 0.0;
+	const ANKI_RP Vec3 albedo =
+		unpackDiffuseFromGBuffer(textureLod(u_gbuffer0Tex, u_linearAnyClampSampler, in_uv, 0.0), metallic);
 	out_color *= albedo;
 }
 #pragma anki end

AnKi/Shaders/PackFunctions.glsl

@@ -122,20 +122,21 @@ Vec2 unpackUnorm1ToUnorm2(F32 c)
 #endif
 }
 
-const F32 ABSOLUTE_MAX_EMISSION = 1024.0;
+const ANKI_RP F32 ABSOLUTE_MAX_EMISSION = 1024.0;
 #if !defined(MAX_EMISSION)
-const F32 MAX_EMISSION = 30.0; // Max emission. Keep as low as possible and less than ABSOLUTE_MAX_EMISSION
+const ANKI_RP F32 MAX_EMISSION = 30.0; // Max emission. Keep as low as possible and less than ABSOLUTE_MAX_EMISSION
 #endif
 // Round the MAX_EMISSION to fit a U8_UNORM
-const F32 FIXED_MAX_EMISSION = F32(U32(MAX_EMISSION / ABSOLUTE_MAX_EMISSION * 255.0)) / 255.0 * ABSOLUTE_MAX_EMISSION;
+const ANKI_RP F32 FIXED_MAX_EMISSION =
+	F32(U32(MAX_EMISSION / ABSOLUTE_MAX_EMISSION * 255.0)) / 255.0 * ABSOLUTE_MAX_EMISSION;
 
-const F32 MIN_ROUGHNESS = 0.05;
+const ANKI_RP F32 MIN_ROUGHNESS = 0.05;
 
 // G-Buffer structure
 struct GbufferInfo
 {
 	ANKI_RP Vec3 m_diffuse;
-	ANKI_RP Vec3 m_specular;
+	ANKI_RP Vec3 m_f0; ///< Freshnel at zero angles.
 	ANKI_RP Vec3 m_normal;
 	ANKI_RP F32 m_roughness;
 	ANKI_RP F32 m_metallic;
@@ -145,10 +146,10 @@ struct GbufferInfo
 };
 
 // Populate the G buffer
-void writeGBuffer(GbufferInfo g, out Vec4 rt0, out Vec4 rt1, out Vec4 rt2, out Vec2 rt3)
+void packGBuffer(GbufferInfo g, out Vec4 rt0, out Vec4 rt1, out Vec4 rt2, out Vec2 rt3)
 {
 	rt0 = Vec4(g.m_diffuse, g.m_subsurface);
-	rt1 = Vec4(g.m_roughness, g.m_metallic, g.m_specular.x, FIXED_MAX_EMISSION / ABSOLUTE_MAX_EMISSION);
+	rt1 = Vec4(g.m_roughness, g.m_metallic, g.m_f0.x, FIXED_MAX_EMISSION / ABSOLUTE_MAX_EMISSION);
 
 	const Vec3 encNorm = signedOctEncode(g.m_normal);
 	rt2 = Vec4(g.m_emission / FIXED_MAX_EMISSION, encNorm);
@@ -156,49 +157,41 @@ void writeGBuffer(GbufferInfo g, out Vec4 rt0, out Vec4 rt1, out Vec4 rt2, out V
 	rt3 = g.m_velocity;
 }
 
-ANKI_RP Vec3 unpackNormalFromGBuffer(Vec4 gbuffer)
+ANKI_RP Vec3 unpackDiffuseFromGBuffer(ANKI_RP Vec4 rt0, ANKI_RP F32 metallic)
 {
-	return signedOctDecode(gbuffer.gba);
+	return rt0.xyz *= 1.0 - metallic;
 }
 
-// Read from G-buffer
-ANKI_RP Vec3 readNormalFromGBuffer(texture2D rt2, sampler sampl, Vec2 uv)
+ANKI_RP Vec3 unpackNormalFromGBuffer(ANKI_RP Vec4 rt2)
 {
-	return unpackNormalFromGBuffer(textureLod(rt2, sampl, uv, 0.0));
+	return signedOctDecode(rt2.gba);
 }
 
-// Read the roughness from G-buffer
-ANKI_RP F32 readRoughnessFromGBuffer(texture2D rt1, sampler sampl, Vec2 uv)
+ANKI_RP F32 unpackRoughnessFromGBuffer(ANKI_RP Vec4 rt1)
 {
-	ANKI_RP F32 r = textureLod(rt1, sampl, uv, 0.0).r;
+	ANKI_RP F32 r = rt1.x;
 	r = r * (1.0 - MIN_ROUGHNESS) + MIN_ROUGHNESS;
 	return r;
 }
 
 // Read part of the G-buffer
-void readGBuffer(texture2D rt0, texture2D rt1, texture2D rt2, sampler sampl, Vec2 uv, out GbufferInfo g)
+void unpackGBufferNoVelocity(ANKI_RP Vec4 rt0, ANKI_RP Vec4 rt1, ANKI_RP Vec4 rt2, out GbufferInfo g)
 {
-	ANKI_RP Vec4 comp = textureLod(rt0, sampl, uv, 0.0);
-	g.m_diffuse = comp.xyz;
-	g.m_subsurface = comp.w;
+	g.m_diffuse = rt0.xyz;
+	g.m_subsurface = rt0.w;
 
-	comp = textureLod(rt1, sampl, uv, 0.0);
-	g.m_roughness = comp.x;
-	g.m_metallic = comp.y;
-	g.m_specular = Vec3(comp.z);
-	const F32 maxEmission = comp.w * ABSOLUTE_MAX_EMISSION;
+	g.m_roughness = unpackRoughnessFromGBuffer(rt1);
+	g.m_metallic = rt1.y;
+	g.m_f0 = Vec3(rt1.z);
+	const ANKI_RP F32 maxEmission = rt1.w * ABSOLUTE_MAX_EMISSION;
 
-	comp = textureLod(rt2, sampl, uv, 0.0);
-	g.m_normal = signedOctDecode(comp.yzw);
-	g.m_emission = comp.x * maxEmission;
+	g.m_normal = signedOctDecode(rt2.yzw);
+	g.m_emission = rt2.x * maxEmission;
 
 	g.m_velocity = Vec2(MAX_F32); // Put something random
 
-	// Fix roughness
-	g.m_roughness = g.m_roughness * (1.0 - MIN_ROUGHNESS) + MIN_ROUGHNESS;
-
 	// Compute reflectance
-	g.m_specular = mix(g.m_specular, g.m_diffuse, g.m_metallic);
+	g.m_f0 = mix(g.m_f0, g.m_diffuse, g.m_metallic);
 
 	// Compute diffuse
 	g.m_diffuse *= 1.0 - g.m_metallic;

AnKi/Shaders/RtShadowsDenoise.ankiprog

@@ -78,7 +78,7 @@ void main()
 	}
 
 	const Vec3 positionCenter = unproject(UV_TO_NDC(uv), depthCenter);
-	const Vec3 normalCenter = readNormalFromGBuffer(u_gbuffer2Tex, u_linearAnyClampSampler, uv);
+	const Vec3 normalCenter = unpackNormalFromGBuffer(textureLod(u_gbuffer2Tex, u_linearAnyClampSampler, uv, 0.0));
 
 	F32 shadowFactors[MAX_RT_SHADOW_LAYERS];
 	unpackRtShadows(textureLod(u_inTex, u_nearestAnyClampSampler, uv, 0.0), shadowFactors);

AnKi/Shaders/RtShadowsRayGen.ankiprog

@@ -84,7 +84,7 @@ void main()
 	}
 
 	// World normal
-	const Vec3 normal = readNormalFromGBuffer(u_normalRt, u_linearAnyClampSampler, uv);
+	const Vec3 normal = unpackNormalFromGBuffer(textureLod(u_normalRt, u_linearAnyClampSampler, uv, 0.0));
 
 	// Cluster
 	Cluster cluster = getClusterFragCoord(Vec3(uv * u_clusteredShading.m_renderingSize, depth));

AnKi/Shaders/Ssr.ankiprog

@@ -60,8 +60,8 @@ void main()
 	const Vec2 uv = (Vec2(fixedGlobalInvocationId.xy) + 0.5) / Vec2(u_unis.m_framebufferSize);
 
 	// Read part of the G-buffer
-	const F32 roughness = readRoughnessFromGBuffer(u_gbufferRt1, u_trilinearClampSampler, uv);
-	const Vec3 worldNormal = readNormalFromGBuffer(u_gbufferRt2, u_trilinearClampSampler, uv);
+	const F32 roughness = unpackRoughnessFromGBuffer(textureLod(u_gbufferRt1, u_trilinearClampSampler, uv, 0.0));
+	const Vec3 worldNormal = unpackNormalFromGBuffer(textureLod(u_gbufferRt2, u_trilinearClampSampler, uv, 0.0));
 
 	// Get depth
 	const F32 depth = textureLod(u_depthRt, u_trilinearClampSampler, uv, 0.0).r;
@@ -96,7 +96,8 @@ void main()
 	ANKI_BRANCH if(hitAttenuation > 0.0)
 	{
 		const Vec3 hitNormal =
-			u_unis.m_normalMat * readNormalFromGBuffer(u_gbufferRt2, u_trilinearClampSampler, hitPoint.xy);
+			u_unis.m_normalMat
+			* unpackNormalFromGBuffer(textureLod(u_gbufferRt2, u_trilinearClampSampler, hitPoint.xy, 0.0));
 		F32 backFaceAttenuation;
 		rejectBackFaces(reflVec, hitNormal, backFaceAttenuation);
 

AnKi/Shaders/TraditionalDeferredShading.ankiprog

@@ -93,7 +93,9 @@ void main()
 
 	// Decode and process gbuffer
 	GbufferInfo gbuffer;
-	readGBuffer(u_msRt0, u_msRt1, u_msRt2, u_msSampler, uvToRead, gbuffer);
+	unpackGBufferNoVelocity(textureLod(u_msRt0, u_msSampler, uvToRead, 0.0),
+							textureLod(u_msRt1, u_msSampler, uvToRead, 0.0),
+							textureLod(u_msRt2, u_msSampler, uvToRead, 0.0), gbuffer);
 	gbuffer.m_subsurface = max(gbuffer.m_subsurface, SUBSURFACE_MIN * 8.0);
 
 	const Vec4 worldPos4 = u_unis.m_invViewProjMat * Vec4(UV_TO_NDC(uvToWrite), depth, 1.0);