cleanup shader code and add comments

SimplePixelPBR.hlsl

@@ -28,19 +28,26 @@ SamplerState Sampler : register(s0);
 
 float4 main(VertexToPixel input) : SV_TARGET
 {
+	// normalize inputs and set uv scaling
 	input.normal = normalize(input.normal);
 	input.tangent = normalize(input.tangent);
+	input.uv = input.uv * scale + offset;
 
-	float3 view = normalize(cameraPosition - input.worldPosition);
+	// gets albedo with gamma correction
-
 	float4 albedo = pow(Albedo.Sample(Sampler, input.uv), 2.2f);
 
+	// gets normal map
 	float3 normal = getNormal(Sampler, Normal, input.uv, input.normal, input.tangent, normalIntensity);
 
+	// get pbr values
 	float roughness = Roughness.Sample(Sampler, input.uv).r;
 	float metalness = Metalness.Sample(Sampler, input.uv).r;
 	float3 specular = lerp(F0_NON_METAL.rrr, albedo.rgb, metalness);
 
+	// pre-calculate view
+	float3 view = normalize(cameraPosition - input.worldPosition);
+
+	// calculate lighting
 	float3 light = float3(0, 0, 0);
 	for (int i = 0; i < lightCount; i++)
 	{
@@ -55,7 +62,9 @@ float4 main(VertexToPixel input) : SV_TARGET
 		}
 	}
 
+	// calculate the final color value with lighting
 	float3 final = light;
 
+	// gamma-correct the final value
 	return float4(pow(final, 1.0f / 2.2f), albedo.a);
 }

SimplePixelShader.hlsl

@@ -42,38 +42,42 @@ SamplerState BasicSampler : register(s0);
 // shader entry point
 float4 main(VertexToPixel input) : SV_TARGET
 {
-	// ensure input normals are normalized
+	// normalize inputs and set uv scaling
 	input.normal = normalize(input.normal);
 	input.tangent = normalize(input.tangent);
-	float3 normal = input.normal;
+	input.uv = input.uv * scale + offset;
 
+	// get surface from tint, multiply it by albedo if there is one
+	// get alpha from exposed alpha value, multiply it by albedo alpha if there is one
 	float3 surface = tint;
 	float alphaValue = alpha;
 	if (hasAlbedoMap)
 	{
 		float4 sampledAlbedo = Albedo.Sample(BasicSampler, input.uv);
+		// discard if the alpha of the texture is less than the cutoff point
 		if (sampledAlbedo.a < cutoff) discard;
+		// gamma-correct the RGB of the albedo
 		float3 albedo = pow(sampledAlbedo.rgb, 2.2f);
+		// multiply surface and alpha by the sampled texture
 		surface *= albedo.rgb;
 		alphaValue *= sampledAlbedo.a;
 	}
 
+	// gets normal map if there is one
+	float3 normal = input.normal;
 	if (hasNormalMap > 0)
-	{
 		normal = getNormal(BasicSampler, Normal, input.uv, input.normal, input.tangent, normalIntensity);
-	}
-	input.uv = input.uv * scale + offset;
 
-	// view only needs calculated once, so pre-calculate here and pass it to lights
+	// gets specular value; if there is a specular map, use that instead
+	float specular = 1;
+	if (hasSpecularMap > 0)
+		specular = Specular.Sample(BasicSampler, input.uv).r;
+
+	// pre-calculate view
 	float3 view = getView(cameraPosition, input.worldPosition);
 
-	float specular = 1;
+	// calculate lighting
-	if (hasSpecularMap > 0) specular = Specular.Sample(BasicSampler, input.uv).r;
-	float3 emit = float3(1, 1, 1);
-	if (hasEmissiveMap > 0) emit = Emissive.Sample(BasicSampler, input.uv).rgb;
 	float3 light = ambient * surface;
-
-	// loop through lights
 	for (int i = 0; i < lightCount; i++)
 	{
 		switch (lights[i].Type)
@@ -87,8 +91,15 @@ float4 main(VertexToPixel input) : SV_TARGET
 		}
 	}
 
+	// get emission; use emissive map if there is one
+	float3 emit = float3(1, 1, 1);
+	if (hasEmissiveMap > 0)
+		emit = Emissive.Sample(BasicSampler, input.uv).rgb;
+
+	// calculate the final color value with lighting and emission
 	float3 final = float3(light + (emit * emitAmount));
 
+	// utilize reflection map if there is one
 	if (hasReflectionMap > 0)
 	{
 		float3 reflVec = getReflection(view, normal);
@@ -96,5 +107,6 @@ float4 main(VertexToPixel input) : SV_TARGET
 		final = lerp(final, reflCol, getFresnel(normal, view, F0_NON_METAL));
 	}
 
+	// gamma-correct the final value
 	return float4(pow(final, 1.0f/2.2f), alphaValue);
 }

ToonShader.hlsl

@@ -66,33 +66,41 @@ float GetRampSpecular(float original)
 
 float4 main(VertexToPixel input) : SV_TARGET
 {
+	// normalize inputs and set uv scaling
 	input.normal = normalize(input.normal);
 	input.tangent = normalize(input.tangent);
 	input.uv = input.uv * scale + offset;
-	float3 view = getView(cameraPosition, input.worldPosition);
-	float3 normal = input.normal;
 
+	// get surface from tint, multiply it by albedo if there is one
+	// get alpha from exposed alpha value, multiply it by albedo alpha if there is one
 	float3 surface = tint;
 	float alphaValue = alpha;
 	if (hasAlbedoMap)
 	{
 		float4 sampledAlbedo = Albedo.Sample(BasicSampler, input.uv);
+		// discard if the alpha of the texture is less than the cutoff point
 		if (sampledAlbedo.a < cutoff) discard;
+		// gamma-correct the RGB of the albedo
 		float3 albedo = pow(sampledAlbedo.rgb, 2.2f);
+		// multiply surface and alpha by the sampled texture
 		surface *= albedo.rgb;
 		alphaValue *= sampledAlbedo.a;
 	}
 
+	// gets normal map if there is one
+	float3 normal = input.normal;
 	if (hasNormalMap > 0)
-	{
 		normal = getNormal(BasicSampler, Normal, input.uv, input.normal, input.tangent, normalIntensity);
-	}
 
+	// gets specular value; if there is a specular map, use that instead
 	float specularValue = 1;
 	if (hasSpecularMap > 0)
-	{
 		specularValue = Specular.Sample(BasicSampler, input.uv).r;
-	}
+
+	// pre-calculate view
+	float3 view = getView(cameraPosition, input.worldPosition);
+
+	// calculate lighting
 	float3 light = ambient * surface;
 	for (int i = 0; i < lightCount; i++)
 	{
@@ -109,46 +117,42 @@ float4 main(VertexToPixel input) : SV_TARGET
 			break;
 		}
 
+		// applies the step-like effect of toon shading to the diffuse/specular of the lighting
 		float diffuse = 0;
 		float specular = 0;
 		if (hasRampDiffuse > 0)
-		{
 			diffuse = RampDiffuse.Sample(ClampSampler, float2(getDiffuse(normal, toLight), 0)).r;
-		}
 		else
-		{
 			diffuse = GetRampDiffuse(getDiffuse(normal, toLight));
-		}
 		if (hasRampSpecular > 0)
-		{
 			specular = RampSpecular.Sample(ClampSampler, float2(calculateSpecular(normal, toLight, view, specularValue, diffuse) * roughness, 0));
-		}
 		else
-		{
 			specular = GetRampSpecular(calculateSpecular(normal, toLight, view, specularValue, diffuse) * roughness);
-		}
 
 		light += (diffuse * surface.rgb + specular) * attenuate * lights[i].Intensity * lights[i].Color;
 	}
 
+	// get emission; use emissive map if there is one
 	float3 emit = float3(1, 1, 1);
-	if (hasEmissiveMap > 0) emit = Emissive.Sample(BasicSampler, input.uv).rgb;
+	if (hasEmissiveMap > 0)
+		emit = Emissive.Sample(BasicSampler, input.uv).rgb;
 
+	// calculate rim/outline value (i.e. whether there is any at this pixel)
 	float vDotN = (1 - dot(view, input.normal));
 	float rimValue = GetRampSpecular(vDotN * pow(light, rimCutoff));
 	float outlineValue = GetRampSpecular(vDotN * outlineThickness);
 
+	// return rim lighting if there is any; takes priority over outline
 	if (rimValue > 0)
-	{
 		return float4(light + (emit * emitAmount) + rimTint, alphaValue);
-	}
 
+	// return outline if there is any
 	if (outlineValue > 0)
-	{
+		return float4(outlineTint, alphaValue);
-		return float4(outlineValue * outlineTint, alphaValue);
-	}
 
+	// calculate the final color value with lighting and emission
 	float3 final = float3(light + (emit * emitAmount));
 
+	// gamma-correct the final value
 	return float4(pow(final, 1.0f / 2.2f), alphaValue);
 }