lightling/DX11Starter
Archived
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

cleanup shader code and add comments

Browse source
This commit is contained in:
lightling 2022-04-20 01:38:19 -04:00
parent 62256f1e96
commit 503bf34dc7
Signed by: lightling
GPG key ID: 016F11E0AA296B67
3 changed files with 59 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
SimplePixelPBR.hlsl
View file

@ -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);
}

36
SimplePixelShader.hlsl
View file

@ -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;
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;
// calculate lighting
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);
}

44
ToonShader.hlsl
View file

@ -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(outlineValue * outlineTint, alphaValue);
}
return float4(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);
}