mirror of
https://github.com/muskit/H3VR-TNH-Quality-of-Life-Improvements.git
synced 2026-06-03 04:34:26 -07:00
msk
265 lines
8.8 KiB
HLSL
Vendored
265 lines
8.8 KiB
HLSL
Vendored
// Alloy Physical Shader Framework
|
|
// Copyright 2013-2017 RUST LLC.
|
|
// http://www.alloy.rustltd.com/
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
/// @file Skin.cginc
|
|
/// @brief Skin surface shader definition.
|
|
/////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef ALLOY_LEGACY_SHADERS_DEFINITION_SKIN_CGINC
|
|
#define ALLOY_LEGACY_SHADERS_DEFINITION_SKIN_CGINC
|
|
|
|
#define A_AMBIENT_OCCLUSION_ON
|
|
|
|
#define A_SURFACE_CUSTOM_FIELDS \
|
|
half scatteringMask; \
|
|
half scattering;
|
|
|
|
#include "Assets/Alloy/Shaders/Framework/Lighting.cginc"
|
|
#include "Assets/Alloy/Shaders/Type/Standard.cginc"
|
|
|
|
// Jon Moore recommended this value in his blog post.
|
|
#define A_SKIN_BUMP_BLUR_BIAS (3.0)
|
|
|
|
sampler2D _SssBrdfTex;
|
|
|
|
/// Biases the thickness value used to look up in the skin LUT.
|
|
/// Expects values in the range [0,1].
|
|
half _SssBias;
|
|
|
|
/// Scales the thickness value used to look up in the skin LUT.
|
|
/// Expects values in the range [0,1].
|
|
half _SssScale;
|
|
|
|
/// Amount to colorize and darken AO to simulate local scattering.
|
|
/// Expects values in the range [0,1].
|
|
half _SssAoSaturation;
|
|
|
|
/// Increases the bluriness of the normal map for diffuse lighting.
|
|
/// Expects values in the range [0,1].
|
|
half _SssBumpBlur;
|
|
|
|
/// Transmission tint color.
|
|
/// Expects a linear LDR color.
|
|
half3 _TransColor;
|
|
|
|
/// Weight of the transmission effect.
|
|
/// Expects linear space value in the range [0,1].
|
|
half _TransScale;
|
|
|
|
/// Falloff of the transmission effect.
|
|
/// Expects values in the range [1,n).
|
|
half _TransPower;
|
|
|
|
/// Amount that the transmission is distorted by surface normals.
|
|
/// Expects values in the range [0,1].
|
|
half _TransDistortion;
|
|
|
|
/// Calculates standard indirect diffuse plus specular illumination.
|
|
/// @param d Direct lighting data.
|
|
/// @param s Material surface data.
|
|
/// @param skinLut Pre-Integrated scattering LUT.
|
|
/// @return Direct diffuse illumination with scattering effect.
|
|
half3 aLegacySkin(
|
|
ADirect d,
|
|
ASurface s,
|
|
sampler2D skinLut)
|
|
{
|
|
// Scattering
|
|
// cf http://www.farfarer.com/blog/2013/02/11/pre-integrated-skin-shader-unity-3d/
|
|
float ndlBlur = dot(s.ambientNormalWorld, d.direction) * 0.5h + 0.5h;
|
|
float2 sssLookupUv = float2(ndlBlur, s.scattering * aLuminance(d.color));
|
|
half3 sss = s.scatteringMask * d.shadow * tex2D(skinLut, sssLookupUv).rgb;
|
|
|
|
//#if !defined(SHADOWS_SCREEN) && !defined(SHADOWS_DEPTH) && !defined(SHADOWS_CUBE)
|
|
// // If shadows are off, we need to reduce the brightness
|
|
// // of the scattering on polys facing away from the light.
|
|
// sss *= saturate(ndlBlur * 4.0h - 1.0h); // [-1,3], then clamp
|
|
//#else
|
|
// sss *= d.shadow;
|
|
//#endif
|
|
|
|
return d.color * s.albedo * sss;
|
|
}
|
|
|
|
/// Calculates direct light transmission effect using per-pixel thickness.
|
|
/// @param d Indirect light description.
|
|
/// @param s Material surface data.
|
|
/// @param weight Weight of the transmission effect.
|
|
/// @param distortion Distortion due to surface normals.
|
|
/// @param falloff Tightness of the transmitted light.
|
|
/// @param shadowWeight Amount that the transsmision is shadowed.
|
|
/// @return Transmission effect.
|
|
half3 aLegacyTransmission(
|
|
ADirect d,
|
|
ASurface s,
|
|
half weight,
|
|
half distortion,
|
|
half falloff,
|
|
half shadowWeight)
|
|
{
|
|
// Transmission
|
|
// cf http://www.farfarer.com/blog/2012/09/11/translucent-shader-unity3d/
|
|
half3 transLightDir = d.direction + s.normalWorld * distortion;
|
|
half transLight = pow(aDotClamp(s.viewDirWorld, -transLightDir), falloff);
|
|
|
|
transLight *= weight * aLerpOneTo(d.shadow, shadowWeight);
|
|
return d.color * s.subsurfaceColor * transLight;
|
|
}
|
|
|
|
/// Direct diffuse and specular BRDF.
|
|
/// @param d Direct lighting data.
|
|
/// @param s Material surface data.
|
|
/// @return Direct diffuse BRDF.
|
|
half3 aLegacyDirectBrdf(
|
|
ADirect d,
|
|
ASurface s,
|
|
half diffuseWeight)
|
|
{
|
|
// Cook-Torrance microfacet model.
|
|
// cf http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
|
|
half LdotH2 = d.LdotH * d.LdotH;
|
|
|
|
// Brent Burley diffuse BRDF.
|
|
// cf https://disney-animation.s3.amazonaws.com/library/s2012_pbs_disney_brdf_notes_v2.pdf pg14
|
|
half FL = aFresnel(d.NdotL);
|
|
half Fd90 = 0.5h + (2.0h * LdotH2 * s.roughness);
|
|
half Fd = aLerpOneTo(Fd90, FL) * aLerpOneTo(Fd90, s.FV);
|
|
|
|
// Schlick's Fresnel approximation.
|
|
half3 F = lerp(s.f0, A_WHITE, aFresnel(d.LdotH));
|
|
|
|
// John Hable's Visibility function.
|
|
// cf http://www.filmicworlds.com/2014/04/21/optimizing-ggx-shaders-with-dotlh/
|
|
half a2 = s.beckmannRoughness * s.beckmannRoughness;
|
|
half k2 = a2 * 0.25h; // k = a/2; k*k = (a*a)/(2*2) = (a^2)/4.
|
|
half V = lerp(k2, 1.0h, LdotH2);
|
|
|
|
// GGX (Trowbridge-Reitz) NDF.
|
|
// cf http://graphicrants.blogspot.com/2013/08/specular-brdf-reference.html
|
|
half denom = aLerpOneTo(a2, d.NdotH * d.NdotH);
|
|
half mDV = k2 / (V * denom * denom); // k2 is GGX a^2 and microfacet 1/4.
|
|
|
|
// Punctual lighting equation.
|
|
// cf http://seblagarde.wordpress.com/2012/01/08/pi-or-not-to-pi-in-game-lighting-equation/
|
|
return (d.shadow * d.NdotL) * (
|
|
(s.albedo * (Fd * diffuseWeight)) + (F * (mDV * s.specularOcclusion * d.specularIntensity)));
|
|
}
|
|
|
|
/// Indirect specular BRDF.
|
|
/// @param s Material surface data.
|
|
/// @return Environment BRDF.
|
|
half3 aLegacyEnvironmentBrdf(
|
|
ASurface s)
|
|
{
|
|
// Brian Karis' modification of Dimitar Lazarov's Environment BRDF.
|
|
// cf https://www.unrealengine.com/blog/physically-based-shading-on-mobile
|
|
const half4 c0 = half4(-1.0h, -0.0275h, -0.572h, 0.022h);
|
|
const half4 c1 = half4(1.0h, 0.0425h, 1.04h, -0.04h);
|
|
half4 r = s.roughness * c0 + c1;
|
|
half a004 = min(r.x * r.x, exp2(-9.28h * s.NdotV)) * r.x + r.y;
|
|
half2 AB = half2(-1.04h, 1.04h) * a004 + r.zw;
|
|
return s.f0 * AB.x + AB.yyy;
|
|
}
|
|
|
|
/// Calculates standard indirect diffuse plus specular illumination.
|
|
/// @param d Indirect light description.
|
|
/// @param s Material surface data.
|
|
/// @return Indirect illumination.
|
|
half3 aLegacyStandardIndirect(
|
|
AIndirect i,
|
|
ASurface s)
|
|
{
|
|
#ifdef A_REFLECTION_PROBES_ON
|
|
half3 specular = i.specular * aLegacyEnvironmentBrdf(s);
|
|
#endif
|
|
|
|
#ifndef A_AMBIENT_OCCLUSION_ON
|
|
half3 diffuse = s.albedo * i.diffuse;
|
|
|
|
#ifndef A_REFLECTION_PROBES_ON
|
|
return diffuse;
|
|
#else
|
|
return diffuse + specular;
|
|
#endif
|
|
#else
|
|
// Yoshiharu Gotanda's fake interreflection for specular occlusion.
|
|
// Modified to better account for surface f0.
|
|
// cf http://research.tri-ace.com/Data/cedec2011_RealtimePBR_Implementation_e.pptx pg65
|
|
half3 ambient = i.diffuse * s.ambientOcclusion;
|
|
|
|
#ifndef A_REFLECTION_PROBES_ON
|
|
// Diffuse and fake interreflection only.
|
|
return ambient * (s.albedo + s.f0 * (1.0h - s.specularOcclusion));
|
|
#else
|
|
// Full equation.
|
|
return ambient * s.albedo
|
|
+ lerp(ambient * s.f0, specular, s.specularOcclusion);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
void aPreLighting(
|
|
inout ASurface s)
|
|
{
|
|
aStandardPreLighting(s);
|
|
|
|
// Blurred normals for indirect diffuse and direct scattering.
|
|
s.blurredNormalTangent = normalize(lerp(s.normalTangent, s.blurredNormalTangent, s.scatteringMask * _SssBumpBlur));
|
|
s.ambientNormalWorld = aTangentToWorld(s, s.blurredNormalTangent);
|
|
s.subsurfaceColor = _TransScale * _TransColor * s.albedo * s.subsurface.rrr;
|
|
s.scattering = saturate(s.subsurface * _SssScale + _SssBias);
|
|
}
|
|
|
|
half3 aDirectLighting(
|
|
ADirect d,
|
|
ASurface s)
|
|
{
|
|
return (d.color * aLegacyDirectBrdf(d, s, 1.0h - s.scatteringMask))
|
|
+ aLegacySkin(d, s, _SssBrdfTex)
|
|
+ aLegacyTransmission(d, s, 1.0h, _TransDistortion, _TransPower, 0.0h);
|
|
}
|
|
|
|
half3 aIndirectLighting(
|
|
AIndirect i,
|
|
ASurface s)
|
|
{
|
|
// Saturated AO.
|
|
// cf http://www.iryoku.com/downloads/Next-Generation-Character-Rendering-v6.pptx pg110
|
|
half saturation = s.scatteringMask * _SssAoSaturation;
|
|
|
|
s.albedo = pow(s.albedo, (1.0h + saturation) - saturation * s.ambientOcclusion);
|
|
return aLegacyStandardIndirect(i, s);
|
|
}
|
|
|
|
void aSurfaceShader(
|
|
inout ASurface s)
|
|
{
|
|
aDissolve(s);
|
|
|
|
half4 base = aBase(s);
|
|
|
|
s.baseColor = base.rgb;
|
|
s.subsurface = A_SS(s, base.a);
|
|
|
|
half4 material = aSampleMaterial(s);
|
|
|
|
s.scatteringMask = material.A_METALLIC_CHANNEL;
|
|
s.metallic = 0.0h;
|
|
s.ambientOcclusion = aLerpOneTo(material.A_AO_CHANNEL, _Occlusion);
|
|
s.specularity = _Specularity * material.A_SPECULARITY_CHANNEL;
|
|
s.roughness = _Roughness * material.A_ROUGHNESS_CHANNEL;
|
|
|
|
s.normalTangent = A_NT(s, aSampleBump(s));
|
|
s.blurredNormalTangent = aSampleBumpBias(s, A_SKIN_BUMP_BLUR_BIAS);
|
|
|
|
aDetail(s);
|
|
aTeamColor(s);
|
|
aDecal(s);
|
|
aRim(s);
|
|
aEmission(s);
|
|
}
|
|
|
|
#endif // ALLOY_LEGACY_SHADERS_DEFINITION_SKIN_CGINC
|