389 lines
16 KiB
HLSL
389 lines
16 KiB
HLSL
//修改说明
|
||
//1)加上StylizedLambert
|
||
//2)加上高光颜色和阴影颜色(HColor和SColor) + SGAME_HS_COLOR_STYLIZED（光照颜色主要影响亮面，不影响暗面)
|
||
//3）加上WrapNL对Skin的处理
|
||
//4)atten改为由BRDF处理,添加SGameShadowAtten(atten);
|
||
//5)添加SGAME_DIRECT_SPECULAR，背光面也有微弱的高光
|
||
//6)添加SGAME_INDIRECT_SPECULAR，间接高光gi.specular改用gi.diffuse计算,由于gi.specular依赖的反射探头/天空盒不会随着光照和天空盒改变而变化
|
||
#ifndef SGAME_STANDARD_BRDF_INCLUDED
|
||
#define SGAME_STANDARD_BRDF_INCLUDED
|
||
|
||
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
|
||
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
|
||
|
||
#include "SGameEnvMapBase.hlsl"
|
||
#include "SGameVLight.hlsl"
|
||
|
||
//一些自定义的函数，对BRDF进行拓展
|
||
//----------------------------------------------------------------------------------------
|
||
/////////////////////////////////////SHADOW ATTEN//////////////////////////////////////////
|
||
inline half3 BlendMode_Add( half3 s, half3 d)
|
||
{
|
||
return s + d;
|
||
}
|
||
inline half3 BlendMode_Screen( half3 s, half3 d)
|
||
{
|
||
return s + d - s*d;
|
||
}
|
||
inline half3 ACESToneMapping( half3 x )
|
||
{
|
||
half tA = 2.51f;
|
||
half tB = 0.03f;
|
||
half tC = 2.43f;
|
||
half tD = 0.59f;
|
||
half tE = 0.14f;
|
||
return saturate((x*(tA*x+tB))/(x*(tC*x+tD)+tE));
|
||
}
|
||
#if defined(SGAME_TONEMAPPING_LIGHT_BOOST)
|
||
inline half3 ApplyToneMappingLightBoost(half3 col, half3 lightColor)
|
||
{
|
||
return col * 1 * lightColor;
|
||
}
|
||
#endif
|
||
|
||
#if defined(SGAME_TONEMAPPING_GI_DIFFUSE_ATTEN)
|
||
inline half3 ApplyToneMappingGIDiffuseAtten(half3 col)
|
||
{
|
||
return col * 1;
|
||
}
|
||
#endif
|
||
|
||
inline half3 SGameOutputTonemapping(half3 col)
|
||
{
|
||
half3 output = col;
|
||
return output;
|
||
}
|
||
inline half SGameShadowAtten(half atten)
|
||
{
|
||
return max(atten, 0.2);
|
||
}
|
||
|
||
inline half SGameStylizedAtten(half atten)
|
||
{
|
||
half stylizedAtten = (atten + 1) * 0.5;
|
||
stylizedAtten = saturate(stylizedAtten);
|
||
return stylizedAtten;
|
||
}
|
||
///////////////////////////////////////////////////////////////////////////////////////////
|
||
inline half3 EnvBRDFApprox(half3 specularColor, half roughness, half NDotV)
|
||
{
|
||
half4 c0 = half4(-1, -0.0275, -0.572, 0.022);
|
||
half4 c1 = half4(1, 0.0425, 1.04, -0.04);
|
||
half4 r = roughness*c0 + c1;
|
||
half a004 = min(r.x * r.x, exp2(-9.28 * NDotV)) * r.x + r.y;
|
||
half2 AB = half2(-1.04,1.04) * a004 + r.zw;
|
||
return specularColor*AB.x + AB.y;
|
||
}
|
||
inline half3 SGameGISpecular(half roughness, half3 normal, half3 viewDir, UnityIndirect gi, half giIntensity = 1, half smoothness = 1)
|
||
{
|
||
return 1;
|
||
}
|
||
inline half3 SGameDiffuseColor( half3 diffColor, half3 specColor )
|
||
{
|
||
half3 diffuseColor = diffColor;
|
||
return diffuseColor;
|
||
}
|
||
|
||
inline half3 SGameSpecularColor( half3 specColor )
|
||
{
|
||
return specColor;
|
||
}
|
||
|
||
inline half3 SGameStylizedSpecularColor( half3 specularColor, half metallic )
|
||
{
|
||
half3 linearSpecularColor = specularColor * specularColor;
|
||
specularColor = lerp( linearSpecularColor, specularColor, metallic );
|
||
return specularColor;
|
||
}
|
||
inline half SGameDirectSpecular(half3 normal, half3 viewDir, half NDotL, half metallic, half nh, half lh)
|
||
{
|
||
half3 backfaceLightDir = viewDir;
|
||
half3 backfaceHalfDir = viewDir;
|
||
half backface_nh = saturate(dot(normal, backfaceHalfDir));
|
||
half backface_lh = saturate(dot(backfaceLightDir, backfaceHalfDir));
|
||
half notBackface = smoothstep(-1,0.5,NDotL); //0背光 -> 1受光
|
||
half isBackface = 1 - smoothstep(-1,0.5,NDotL);
|
||
half ratio = isBackface * lerp(0.3,1,metallic);
|
||
nh = lerp(nh, backface_nh, ratio);
|
||
lh = lerp(lh, backface_lh, ratio);
|
||
return isBackface;
|
||
}
|
||
inline half SGameRoughness(half smoothness, out half perceptualRoughness )
|
||
{
|
||
perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness (smoothness);
|
||
perceptualRoughness = max(0.001, perceptualRoughness);
|
||
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||
return roughness;
|
||
}
|
||
|
||
#if defined(_SKIN_CALCULATION)
|
||
inline float FresnelReflectance (float3 H, float3 V, float F0)
|
||
{
|
||
float base = 1.0 - dot(V, H);
|
||
float exponential = pow(base, 5.0);
|
||
return exponential + F0 * saturate(1.0 - exponential);
|
||
}
|
||
inline float SkinSpecular( float3 N, // Bumped surface normal
|
||
float3 L, // Points to light
|
||
float3 V, // Points to eye
|
||
float m, // Roughness
|
||
float rho_s // Specular brightness
|
||
)
|
||
{
|
||
float ndotl = max(dot(N, L), 0);
|
||
|
||
float3 h = L + V; // Unnormalized half-way vector
|
||
float3 H = normalize(h);
|
||
float ndoth = dot(N, H);
|
||
|
||
float4 PH = pow(1.85, 10);
|
||
|
||
float F = FresnelReflectance(H, V, 0.028);
|
||
float frSpec = max(PH.x * F / dot(h, h), 0.0);
|
||
|
||
return ndotl * rho_s * frSpec;
|
||
}
|
||
#endif
|
||
|
||
//-------------------------------------------------------------------------------------
|
||
// Note: BRDF entry points use smoothness and oneMinusReflectivity for optimization
|
||
// purposes, mostly for DX9 SM2.0 level. Most of the math is being done on these (1-x) values, and that saves
|
||
// a few precious ALU slots.
|
||
// Based on Minimalist CookTorrance BRDF
|
||
// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
|
||
//
|
||
// * NDF (depending on UNITY_BRDF_GGX):
|
||
// a) BlinnPhong
|
||
// b) [Modified] GGX
|
||
// * Modified Kelemen and Szirmay-Kalos for Visibility term
|
||
// * Fresnel approximated with 1/LdotH
|
||
half4 SGame_BRDF2_Unity_PBS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half smoothness,
|
||
half3 normal, half3 viewDir, UnityLight light, UnityIndirect gi, half atten, half metallic,
|
||
half3 worldTangent = half3(0, 0, 0), half isSkin = 0, half anisotrophic = 0)
|
||
{
|
||
half3 halfDir = normalize (light.dir + viewDir);
|
||
half NDotL = dot(normal,light.dir);
|
||
half nl = saturate((dot(normal, light.dir) + _DiffuseWrap) / ((1 + _DiffuseWrap) * (1 + _DiffuseWrap)));
|
||
half nh = saturate(dot(normal, halfDir));
|
||
half NDotV = dot(normal, viewDir);
|
||
half nv = saturate(NDotV);
|
||
half lh = saturate(dot(light.dir, halfDir));
|
||
|
||
#if defined(_ANISOGGX_ON) && defined(UNITY_PASS_FORWARDBASE)
|
||
smoothness = smoothness + (_AnisotrophicSmooth) * anisotrophic;
|
||
metallic = metallic + (_AnisotrophicMetallic) * anisotrophic;
|
||
#endif
|
||
|
||
half perceptualRoughness = 0;
|
||
half roughness = SGameRoughness(smoothness, /*out*/ perceptualRoughness);
|
||
half isBackface = SGameDirectSpecular(normal, viewDir, NDotL, metallic, /*inout*/ nh, /*inout*/ lh);
|
||
half a = roughness;
|
||
half a2 = a * a;
|
||
half d = nh * nh * (a2 - 1.h) + 1.00001h;
|
||
half specularTerm = a / (max(0.32h, lh) * (1.5h + roughness) * d);
|
||
#if defined(_ANISOGGX_ON) && defined(UNITY_PASS_FORWARDBASE)
|
||
half3 worldBiTangent = cross(normal, worldTangent);
|
||
worldTangent = cross(worldBiTangent, normal);
|
||
half roughnessT = SGameRoughness(smoothness, /*out*/ perceptualRoughness);;
|
||
half roughnessB = 1;
|
||
half anisoSpecularTerm = GGXSpecularTermAniso_SGame(worldTangent, worldBiTangent, roughnessT, roughnessB, halfDir, light.dir, viewDir, nl, nh, nv);
|
||
specularTerm = lerp(specularTerm, anisoSpecularTerm, anisotrophic);
|
||
#endif
|
||
#if defined (SHADER_API_MOBILE)
|
||
specularTerm = specularTerm - 1e-4h;
|
||
#endif
|
||
#if defined (SHADER_API_MOBILE)
|
||
specularTerm = clamp(specularTerm, 0.0, 100.0); // Prevent FP16 overflow on mobiles
|
||
#endif
|
||
#ifdef UNITY_COLORSPACE_GAMMA
|
||
half surfaceReduction = 0.28;
|
||
#else
|
||
half surfaceReduction = (0.6 - 0.08 * perceptualRoughness);
|
||
#endif
|
||
surfaceReduction = 1.0 - roughness * perceptualRoughness * surfaceReduction;
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//基础
|
||
//--------------------------------------------------------------------------------
|
||
half shadowAtten = SGameShadowAtten(atten);
|
||
half stylizedAtten = SGameStylizedAtten(atten);
|
||
half3 lightColor = light.color;
|
||
lightColor *= shadowAtten;
|
||
half3 lightDir = light.dir; //光照方向
|
||
//--------------------------------------------------------------------------------
|
||
//处理漫反射和高光颜色
|
||
//--------------------------------------------------------------------------------
|
||
half3 diffuseColor = SGameDiffuseColor(diffColor, specColor);
|
||
half3 specularColor = SGameSpecularColor(specColor);
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
half3 stylizedSpecularColor = SGameStylizedSpecularColor(specularColor, metallic);
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//直接光照漫反射
|
||
//--------------------------------------------------------------------------------
|
||
half3 diffuseTerm = nl;
|
||
#if defined(_SKIN_CALCULATION)
|
||
diffuseTerm = lerp(diffuseTerm, BeckmannTexCol(half2(nl * 0.5 + 0.5, 1)).rgb * 1.5, isSkin);
|
||
lightColor = lerp(lightColor, lerp(lightColor, 1, 0.5), isSkin);
|
||
#endif
|
||
|
||
//直接光照漫反射
|
||
half3 diffuseLighting = diffuseColor * diffuseTerm * lightColor;
|
||
#if defined(_SKIN_CALCULATION)
|
||
float specularWeight = SkinSpecular(normal, lightDir, viewDir, _SkinRoughness, _SkinSpecIntensity * isSkin);
|
||
#if defined(BACK_FACE_ADD)
|
||
specularColor += lerp(specularColor, specularWeight * lightColor * _Color.rgb, isSkin) * 0.5;
|
||
#else
|
||
specularColor = lerp(specularColor, specularWeight * lightColor * _Color.rgb, isSkin);
|
||
#endif
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//直接光照高光
|
||
//--------------------------------------------------------------------------------
|
||
half3 specDiffuseTerm = nl;
|
||
half3 specularLighting = specularTerm * specDiffuseTerm * lightColor;
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
specularLighting *= stylizedSpecularColor;
|
||
#else
|
||
specularLighting *= specularColor;
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//间接光照漫反射
|
||
//--------------------------------------------------------------------------------
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
half3 diffuseIndirect = gi.diffuse * diffColor;
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//间接光照高光
|
||
//--------------------------------------------------------------------------------
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
half giRoughness = perceptualRoughness;
|
||
half3 giSpec = SGameGISpecular(giRoughness, normal, viewDir, gi, _IBLInensity, smoothness);
|
||
#if defined(_SKIN_CALCULATION)
|
||
giSpec = lerp(giSpec, 1, isSkin);
|
||
#endif
|
||
half3 giSpecularColor = stylizedSpecularColor;
|
||
half3 specularIndirect = surfaceReduction * giSpec * giSpecularColor;
|
||
specularIndirect *= stylizedAtten;
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
//虚拟光
|
||
//--------------------------------------------------------------------------------
|
||
//VLight, 只有Base Pass计算
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
half3 vDiffuseTerm = SGameVLightDiffuse(normal) * stylizedAtten;
|
||
half3 diffuseVLight = vDiffuseTerm * diffuseColor;
|
||
half3 specularVLight = SGameVLightSpecular(perceptualRoughness, normal, viewDir, specularColor, vDiffuseTerm);
|
||
#if defined(_SKIN_CALCULATION)
|
||
#if defined(BACK_FACE_ADD)
|
||
diffuseVLight += diffuseVLight * isSkin;
|
||
specularVLight += specularVLight * 3 * isSkin;
|
||
#else
|
||
specularVLight += specularVLight * 5 * isSkin;
|
||
#endif
|
||
#endif
|
||
#endif
|
||
|
||
//计算结果颜色
|
||
half3 output = 0;
|
||
//--------------------------------------------------------------------------------
|
||
// Add Pass 直接返回直接光照
|
||
//--------------------------------------------------------------------------------
|
||
#if defined(UNITY_PASS_FORWARDADD)
|
||
output = diffuseLighting + specularLighting;
|
||
return half4(output, 1);
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// Base Pass 根据不同风格计算
|
||
//--------------------------------------------------------------------------------
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
diffuseIndirect = ApplyToneMappingGIDiffuseAtten(diffuseIndirect); //对漫反射进行ToneMapping
|
||
half3 outputDiffuse = BlendMode_Screen(saturate(diffuseVLight), saturate(diffuseIndirect)); //补光和环境光
|
||
diffuseLighting = ApplyToneMappingLightBoost(diffuseLighting, lightColor);//主光
|
||
outputDiffuse = outputDiffuse + diffuseLighting;
|
||
outputDiffuse = SGameOutputTonemapping(outputDiffuse); //ToneMaping
|
||
half3 outputSpecular = specularLighting + specularIndirect; //对高光直接相加
|
||
outputSpecular += specularVLight * (1 + _SpecularBloomAdd * metallic);
|
||
output = outputDiffuse + outputSpecular;
|
||
half3 overflow = saturate(outputSpecular - 1);
|
||
output += overflow;
|
||
return half4(output,1);
|
||
#endif
|
||
|
||
//--------------------------------------------------------------------------------
|
||
// 其他 Pass 根据不同风格计算
|
||
//--------------------------------------------------------------------------------
|
||
output = diffuseLighting + specularLighting;
|
||
#if defined(UNITY_PASS_FORWARDBASE)
|
||
output += ( diffuseIndirect + specularIndirect);
|
||
#endif
|
||
return half4(output, 1);
|
||
}
|
||
|
||
inline half3 GetSpecularColorGGX_Smoothness (half ndotH, half ndotL, half ldotH, half3 specularColor, half smoothness, half powFac = 64, half ggxClamp = 3)
|
||
{
|
||
half3 specular = 0;
|
||
#if defined(SGAME_QUALITY_PERFECT)
|
||
half perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness (smoothness);
|
||
perceptualRoughness = max(0.08, perceptualRoughness);
|
||
half roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
|
||
half a = roughness;
|
||
half a2 = a * a;
|
||
half d = ndotH * ndotH * (a2 - 1) + 1.0001;
|
||
half specularTerm = a2 / (max(0.2, ldotH * ldotH) * (roughness + 0.5) * (d * d) * powFac);
|
||
specularTerm = specularTerm - 1e-4h;
|
||
specularTerm = clamp(specularTerm, 0, ggxClamp);
|
||
specular = specularTerm * specularColor.rgb;
|
||
#endif
|
||
return specular;
|
||
}
|
||
|
||
inline half3x3 GetDiffuseColor(half smoothness, half3 specularColor, half3 mainColor,
|
||
half3 worldNormal, half lightAtten, half3 NDotL)
|
||
{
|
||
half3 lightColor = lerp(half3(0,0,0), GetMainLight().color.rgb, lightAtten * NDotL);
|
||
specularColor = lerp(half3(0,0,0), GetMainLight().color.rgb, lightAtten) * specularColor;
|
||
|
||
half3 diffuse = mainColor * lightColor;
|
||
#if defined(SGAME_WET)
|
||
mainColor = lerp(mainColor, mainColor * _SG_WetColor, _SG_WetFactor);
|
||
specularColor = lerp(specularColor, _SG_WetSpecularColor * _SG_WetSpecularStrength, _SG_WetFactor);
|
||
smoothness = lerp(lerp(smoothness, _SG_WetSmoothness, _SG_WetFactor), smoothness, smoothness > _SG_WetSmoothness);
|
||
half thunderNDotL = saturate(dot(worldNormal, _SG_ThunderDirection));
|
||
half3 thunderDiffuse = mainColor * lerp(half3(0, 0, 0), _SG_ThunderColor, max(lightAtten,0.1)) * thunderNDotL * _SG_ThunderStrength;
|
||
diffuse += thunderDiffuse;
|
||
#endif
|
||
|
||
half3x3 matrixColor;
|
||
matrixColor[0] = diffuse;
|
||
matrixColor[1] = specularColor;
|
||
matrixColor[2] = half3(smoothness, 0, 0);
|
||
return matrixColor;
|
||
}
|
||
|
||
inline half3 GetSumLightingColorSpecGGX_Smoothness(half3 mainColor, half3 specularColor, half3 shLight,
|
||
half3 worldNormal, half3 worldPos, half smoothness, half lightAtten, half powFac = 64, half ggxClamp = 3, half intensity = 1)
|
||
{
|
||
half3 worldViewDir = normalize(GetCameraPositionWS() - worldPos);
|
||
half3 worldLightDir = normalize(GetMainLight().direction);
|
||
half3 halfDir = normalize(worldLightDir + worldViewDir);
|
||
half ndotH = max(dot(worldNormal, halfDir), 0);
|
||
half NDotL = max(dot(worldNormal, worldLightDir), 0);
|
||
half ldotH = max(dot(worldLightDir, halfDir), 0);
|
||
|
||
half3x3 colorMatrix = GetDiffuseColor(smoothness, specularColor, mainColor, worldNormal, lightAtten, NDotL);
|
||
specularColor = colorMatrix[1];
|
||
smoothness = colorMatrix[2].x;
|
||
|
||
half3 ambient = mainColor * 0.5;
|
||
half3 diffuse = colorMatrix[0];
|
||
half3 specular = GetSpecularColorGGX_Smoothness(ndotH, NDotL, ldotH, specularColor, smoothness, powFac, ggxClamp);
|
||
return ambient + diffuse + specular * intensity;
|
||
}
|
||
#endif |