ZZZURPShader流程 - StellaAstra Blog

TIP
下面视频是新版优化后的ZZZShader

WARNING
该文章只是从我的旧博客以及语雀笔记上迁移，目前已经迭代过一个版本，该文章版本已经过时，仅供参考，新版的文档可能后续会更新(待定)

1.开始前工作#

如果使用的是模之屋的mmd模型请在blender中处理模型，将模型中相同材质的部分合并为一个材质，并且将模型的面部有关形态键的部分单独拆成一个网格体，当然也可以拆的更细一些比如将眼睛单独拆出可以用来做透视，头发单独拆开，不会拆的请自行找教程！！

贴图准备#

找不到贴图怎么办？请到上海市徐汇区苍梧路519号光启园四期1号楼去要，记得声音要尖锐点不然可能要不到

关闭贴图压缩#

面部光照图去SRGB#

各类遮罩图也需要去SRGB#

2.Shader处理（BaseShader部分）#

添加KeywordEnum对各个部分进行区分，具体参数请看下面代码#

1
//添加KeywordEnum对各个部分进行区分，添加贴图参数和颜色混合参数
2
[KeywordEnum(None, Face, Eye, Body)] _Domain("Domain(区域)", Float) = 0
3

4
//基本贴图，并禁止缩放和偏移（防止蠢蛋美术瞎搞）
5
[Header(Main Maps)]
6
_Color("Color", Color) = (1, 1, 1, 1)
7
[NoScaleOffset] _MainTex("ColorTexture",2D) = "White"{}
8
[NoScaleOffset] _LightTex("LinghtTex", 2D) = "White"{}
9
[NoScaleOffset] _OtherDataTex1("Other Data Tex1",2D) = "White"{}
10
[NoScaleOffset] _OtherDataTex2("Other Data Tex2",2D) = "White"{}

定义Keyword 宏#

常量放常量缓冲区，采样贴图需要额外定义采样器

1
#pragma shader_feature_local _DOMAIN_FACE
2
#pragma shader_feature_local _DOMAIN_EYE
3
#pragma shader_feature_local _DOMAIN_BODY

定义参数变量#

1
// 定义纹理
2
TEXTURE2D (_MainTex);
3
// 定义纹理采样器
4
SAMPLER(sampler_MainTex);
5

6
TEXTURE2D (_LightTex);
7
SAMPLER(sampler_LightTex);
8

9
TEXTURE2D (_OtherDataTex1);
10
SAMPLER(sampler_OtherDataTex1);
11

12
TEXTURE2D (_OtherDataTex2);
13
SAMPLER(sampler_OtherDataTex2);

定义输入结构体#

1
// 定义输入结构体 appdata to Vertex
2
struct UniversalAttributes
3
{
4
    float4 positionOS   :POSITION;
5
    float3 normalOS     :NORMAL;
6
    float4 tangentOS    :TANGENT;
7
    float2 texcoord     :TEXCOORD0;
8

9
};

定义顶点输出结构体#

1
// 定义输出结构体 Vertex to frag
2
struct UniversalVaryings
3
{
4
    float4 positionCS               :SV_POSITION;
5
    float4 positionWSAndFogFactor   :TEXCOORD0;
6
    float2 uv                       :TEXCOORD1;
7
    float3 normalWS                 :TEXCOORD2;
8
    float4 tangentWS                :TEXCOORD3;
9
    float3 viewDirWS                :TEXCOORD4;
10

11
};

定义主顶点着色器函数#

1
UniversalVaryings MainVS(UniversalAttributes input)
2
{
3
    //获取世界空间下法线和位置等信息
4
    VertexPositionInputs positionInputs = GetVertexPositionInputs(input.positionOS.xyz);
5
    VertexNormalInputs normalInputs = GetVertexNormalInputs(input.normalOS, input.tangentOS);
6

7
    UniversalVaryings output;
8
    output.positionCS = positionInputs.positionCS;
9
    output.positionWSAndFogFactor = float4(positionInputs.positionWS, ComputeFogFactor(positionInputs.positionCS.z));
10
    output.normalWS = normalInputs.normalWS;
11

12
    output.tangentWS.xyz = normalInputs.tangentWS;
13
    output.tangentWS.w = input.tangentOS.w * GetOddNegativeScale();
14
    // unity_OrthoParams.w判断是透视还是正交
15
    output.viewDirWS = unity_OrthoParams.w == 0 ? GetCameraPositionWS() - positionInputs.positionWS : GetWorldToViewMatrix()[2].xyz;
16

17
    output.uv = input.texcoord;
18

19
    return output;
20

21
}

定义主片元着色器函数#

1
float4 MainPS(UniversalVaryings input, bool isFrontFace : SV_IsFrontFace):SV_TARGET
2
{
3
    float4 var_MainTex = SAMPLE_TEXTURE2D(_MainTex,sampler_MainTex,input.uv);
4
    var_MainTex *= _Color;
5

6
    float3 baseCol = var_MainTex.rgb;
7
    float baseAlpha = 1.0;
8

9
    #if _DOMAIN_BODY || _DOMAIN_EYE
10
    {
11
        baseAlpha = var_MainTex.a;
12
    }
13
    return float4(baseCol, baseAlpha);
14
    #endif
15
}

Pass部分#

1
{
2
    Name"Base Pass"
3
    //Name"UniversalForward"
4

5
    Tags{
6
        "LightMode" = "UniversalForward"
7
    }
8
    // HLSL程序段
9
    HLSLPROGRAM
10
    #pragma vertex MainVS
11
    #pragma fragment MainPS
12
    #pragma multi_compile_fog
13
    ENDHLSL
14

15
}

3.Shader处理（OutlineShader部分）#

参数增加#

1
[Header(Outline)]
2
[Toggle(_OUTLINE_PASS)] _Outline("Outline描边", int) = 0
3
_OutlineWidth("OutlineWidth", Range(0, 10)) = 1
4
_OutlineColor1("OutlineColor1",  Color) = (0, 0, 0, 1)
5
_OutlineColor2("OutlineColor2",  Color) = (0, 0, 0, 1)
6
_OutlineColor3("OutlineColor2",  Color) = (0, 0, 0, 1)
7
_OutlineColor4("OutlineColor2",  Color) = (0, 0, 0, 1)
8
_OutlineColor5("OutlineColor2",  Color) = (0, 0, 0, 1)
9
_OutlineZOffset("OutlineZOffset", Range(0, 1)) = 0.01
10
_NoseLineKDnDisp("NoseLineKDnDisp", Range(0, 1)) = 0.5
11
_NoseLineHoriDisp("NoseLineHoriDisp", Range(0, 1)) = 0.5

Pass内声明#

1
 {
2
    Name"Outline Pass"
3
    Tags{
4
        "LightMode" = "UniversalForwardOnly"
5
    }
6
    Cull Front
7
    //ZWrite On
8
    // HLSL程序段
9
    HLSLPROGRAM
10
    #pragma shader_feature_local _OUTLINE_PASS
11

12
    #pragma vertex vert
13
    #pragma fragment frag
14
    #pragma multi_compile_fog
15

16
    #include "OutLinePass.hlsl"
17
    ENDHLSL
18
}

这里获取了模型第二套UV,里面是平滑法线数据#

1
// 定义输入结构体 appdata to Vertex
2
struct Attributes
3
{
4
    float4 positionOS   :POSITION;
5
    float3 normalOS     :NORMAL;
6
    float4 tangentOS    :TANGENT;
7
    float2 texcoord0    :TEXCOORD0;
8
    float2 texcoord1    :TEXCOORD1;
9

10
};

float2 texcoord1 ;(平滑法线数据)

1
// 定义输出结构体 Vertex to frag
2
struct Varyings
3
{
4
    float4 positionCS :SV_POSITION;
5
    float FogFactor   :TEXCOORD0;
6
    float2 uv         :TEXCOORD1;
7
};

描边缩放函数（使用Colin的算法代码）#

1
//限制描边宽度
2
// If your project has a faster way to get camera fov in shader, you can replace this slow function to your method.
3
// For example, you write cmd.SetGlobalFloat("_CurrentCameraFOV",cameraFOV) using a new RendererFeature in C#.
4
// For this tutorial shader, we will keep things simple and use this slower but convenient method to get camera fov
5
float GetCameraFOV()
6
{
7
    //https://answers.unity.com/questions/770838/how-can-i-extract-the-fov-information-from-the-pro.html
8
    float t = unity_CameraProjection._m11;
9
    float Rad2Deg = 180 / 3.1415;
10
    float fov = atan(1.0f / t) * 2.0 * Rad2Deg;
11
    return fov;
12
}
13
float ApplyOutlineDistanceFadeOut(float inputMulFix)
14
{
15
    //make outline "fadeout" if character is too small in camera's view
16
    return saturate(inputMulFix);
17
}
18
float GetOutlineCameraFovAndDistanceFixMultiplier(float positionVS_Z)
19
{
20
    float cameraMulFix;
21
    if(unity_OrthoParams.w == 0)
22
    {
23
        ////////////////////////////////
24
        // Perspective camera case
25
        ////////////////////////////////
26

27
        // keep outline similar width on screen accoss all camera distance
28
        cameraMulFix = abs(positionVS_Z);
29

30
        // can replace to a tonemap function if a smooth stop is needed
31
        cameraMulFix = ApplyOutlineDistanceFadeOut(cameraMulFix);
32

33
        // keep outline similar width on screen accoss all camera fov
34
        cameraMulFix *= GetCameraFOV();
35
    }
36
    else
37
    {
38
        ////////////////////////////////
39
        // Orthographic camera case
40
        ////////////////////////////////
41
        float orthoSize = abs(unity_OrthoParams.y);
42
        orthoSize = ApplyOutlineDistanceFadeOut(orthoSize);
43
        cameraMulFix = orthoSize * 50; // 50 is a magic number to match perspective camera's outline width
44
    }
45

46
    return cameraMulFix * 0.00005; // mul a const to make return result = default normal expand amount WS
47
}
48
// Push an imaginary vertex towards camera in view space (linear, view space unit),
49
// then only overwrite original positionCS.z using imaginary vertex's result positionCS.z value
50
// Will only affect ZTest ZWrite's depth value of vertex shader
51

52
// Useful for:
53
// -Hide ugly outline on face/eye
54
// -Make eyebrow render on top of hair
55
// -Solve ZFighting issue without moving geometry

法线外扩#

法线外扩需要读取第二套UV的平滑法线信息

八面体映射读取函数#

1
//从UV读取平滑法线
2
//2维转3维
3
float3 OctTounitVector(float2 oct)
4
{
5
    //还原了未折叠时的 3D 坐标
6
    //N = float3(oct.x, oct.y, 1 - abs(oct.x) - abs(oct.y))
7
    float3 N = float3(oct, 1 - dot(1, abs(oct)));
8
    // 检测是否折叠（z为负数时
9
    float t = max(-N.z, 0);
10
    N.x += N.x >= 0? (-t) : t;
11
    N.y += N.y >= 0? (-t) : t;
12
    return normalize(N);
13
}

这里需要裁剪空间下描边顶点Z轴方向偏移，代码来自于Colin#

1
float4 NiloGetNewClipPosWithZOffset(float4 originalPositionCS, float viewSpaceZOffsetAmount)
2
{
3
    if(unity_OrthoParams.w == 0)
4
    {
5
        ////////////////////////////////
6
        //Perspective camera case
7
        ////////////////////////////////
8
        float2 ProjM_ZRow_ZW = UNITY_MATRIX_P[2].zw;
9
        float modifiedPositionVS_Z = -originalPositionCS.w + -viewSpaceZOffsetAmount; // push imaginary vertex
10
        float modifiedPositionCS_Z = modifiedPositionVS_Z * ProjM_ZRow_ZW[0] + ProjM_ZRow_ZW[1];
11
        originalPositionCS.z = modifiedPositionCS_Z * originalPositionCS.w / (-modifiedPositionVS_Z); // overwrite positionCS.z
12
        return originalPositionCS;
13
    }
14
    else
15
    {
16
        ////////////////////////////////
17
        //Orthographic camera case
18
        ////////////////////////////////
19
        originalPositionCS.z += -viewSpaceZOffsetAmount / _ProjectionParams.z; // push imaginary vertex and overwrite positionCS.z
20
        return originalPositionCS;
21
    }
22
}

描边顶点着色器函数#

1
// 顶点着色器函数
2
Varyings vert(Attributes input)
3
{
4
    #if !_OUTLINE_PASS
5
    return  (Varyings)0;
6
    #endif
7
    //获取世界空间下法线和位置等信息
8
    VertexPositionInputs positionInputs = GetVertexPositionInputs(input.positionOS.xyz);
9
    VertexNormalInputs normalInputs = GetVertexNormalInputs(input.normalOS, input.tangentOS);
10
    //描边宽度
11
    float outlineWidth = _OutlineWidth;
12
    //描边宽度随相机深度进行缩放
13
    outlineWidth *= GetOutlineCameraFovAndDistanceFixMultiplier(positionInputs.positionVS.z);
14

15
    //法线外扩
16
    float3 positionWS = positionInputs.positionWS.xyz;
17
    //获取平滑法线
18
    float3 smoothNormal = OctTounitVector(input.texcoord1);
19
    //构建TBN矩阵
20
    float3x3 TBN = float3x3(
21
        normalInputs.tangentWS,
22
        normalInputs.bitangentWS,
23
        normalInputs.normalWS
24
    );
25
    smoothNormal = mul(smoothNormal, TBN);
26
    positionWS += smoothNormal * outlineWidth;
27

28
    Varyings output = (Varyings)0;
29
    output.positionCS = NiloGetNewClipPosWithZOffset(TransformWorldToHClip(positionWS), _OutlineZOffset);
30
    output.FogFactor = ComputeFogFactor(positionInputs.positionCS.z);
31
    output.uv = input.texcoord0;
32

33
    return output;
34

35
}

这里需要读取R通道，里面是存的材质ID

R通道
添加ID选择通用的函数宏
这里定义了4个函数宏，两个“##”表示拼接
TYPE

TYPE##2

TYPE##3

TYPE##4
分别对应 1维到4维数据类型，同时在下面进行函数声明

1
#define DEFINE_SELECT(TYPE)\
2
TYPE select(int id, TYPE e0, TYPE e1, TYPE e2, TYPE e3, TYPE e4)    {return TYPE(id > 0 ? (id > 1 ? (id > 2 ? (id > 3 ? e4 : e3) : e2) : e1) : e0);}\
3
TYPE##2 select(int id, TYPE##2 e0, TYPE##2 e1, TYPE##2 e2, TYPE##2 e3, TYPE##2 e4)  {return TYPE##2(id > 0 ? (id > 1 ? (id > 2 ? (id > 3 ? e4 : e3) : e2) : e1) : e0);}\
4
TYPE##3 select(int id, TYPE##3 e0, TYPE##3 e1, TYPE##3 e2, TYPE##3 e3, TYPE##3 e4)  {return TYPE##3(id > 0 ? (id > 1 ? (id > 2 ? (id > 3 ? e4 : e3) : e2) : e1) : e0);}\
5
TYPE##4 select(int id, TYPE##4 e0, TYPE##4 e1, TYPE##4 e2, TYPE##4 e3, TYPE##4 e4)  {return TYPE##4(id > 0 ? (id > 1 ? (id > 2 ? (id > 3 ? e4 : e3) : e2) : e1) : e0);}
6

7
DEFINE_SELECT(bool)
8
DEFINE_SELECT(uint)
9
DEFINE_SELECT(int)
10
DEFINE_SELECT(float)
11
DEFINE_SELECT(half)

最后进行输出

描边颜色x0.2压暗，除了面部为FF8181,其余先调成555555

描边片元着色器函数#

这里进行描边的染色，需要针对不同区域进行不同染色

1
// 片元着色器函数
2
float4 frag(Varyings input):SV_Target
3
{
4
    #if !_OUTLINE_PASS
5
    clip(-1);
6
    #endif
7
    float3 outlineColor = 0;
8

9
    #if _DOMAIN_FACE
10
    {
11
        outlineColor = _OutlineColor1.rgb;
12
    }
13
    #elif _DOMAIN_BODY
14
    {
15
        outlineColor = _OutlineColor2.rgb;
16
        float4 var_OtherDataTex1 = SAMPLE_TEXTURE2D(_OtherDataTex1, sampler_OtherDataTex1, input.uv);
17
        int materialId = max(0, 4 - floor(var_OtherDataTex1.r * 5));
18
        outlineColor = select(materialId, _OutlineColor1, _OutlineColor2, _OutlineColor3, _OutlineColor4, _OutlineColor5);
19
    }
20
    #endif
21

22
    outlineColor *= 0.2;
23

24
    float4 color = float4(outlineColor, 1);
25
    color.rgb = MixFog(color.rgb, input.FogFactor);
26
    return color;
27
}

Shader构建#

着色阶段#

获取法线和顶点位置并进行归一化

1
float3 normalWS = normalize(input.normalWS);
2
float3 positionWS = input.positionWSAndFogFactor.xyz;

获取ShadowCoord和光线向量#

1
//获取shadowCoord和光向量
2
float4 shadowCoord = TransformWorldToShadowCoord(positionWS);
3
Light mainLight = GetMainLight(shadowCoord);
4
float3 lightDirectionWS = normalize(mainLight.direction);

计算光线衰减（兰伯特）#

1
//光线衰减
2
float baseAttenuation = 1.0;
3
{
4
    //兰伯特
5
    float NoL = dot(pixelNormalWS, lightDirectionWS);
6
    baseAttenuation = NoL + diffuseBias;
7
}

我们看一下效果
可以看到细节还有不够

下面我们来添加法线和漫反射偏移
法线贴图是这几张图，法线在RG通道，B通道是漫反射偏移，其实就是增亮暗部的颜色

R通道

G通道

B通道

法线解析和漫反射偏移#

TBN矩阵参数计算#

1
//计算TBN矩阵
2
float sign = input.tangentWS.w;
3
float3 tangentWS = normalize(input.tangentWS.xyz);
4
float3 bitangentWS = sign * cross(normalWS, tangentWS);

法线翻转值#

sign 是控制法线翻转的值，之前顶点着色器传入的值就存在tangent的w分量中

1
output.tangentWS.xyz = normalInputs.tangentWS;
2
output.tangentWS.w = input.tangentOS.w * GetOddNegativeScale();

初始化变量#

1
float3 pixelNormalWS = normalWS;
2
//漫反射偏移
3
float diffuseBias = 0;

身体部分，进行法线解析和漫反射偏移处理#

1
 #if _DOMAIN_BODY
2
{
3
    //RG是法线，B是漫反射偏移
4
    float4 var_lightTex = SAMPLE_TEXTURE2D(_LightTex, sampler_LightTex, input.uv);
5
    //映射到-1~1
6
    var_lightTex = var_lightTex * 2.0 - 1.0;
7
    //漫反射偏移
8
    diffuseBias = var_lightTex.z * 2.0;
9

10
    //解析法线
11
    float3 pixelNormalTS = float3(var_lightTex.xy, 0.0);
12
    pixelNormalTS.xy *= _BumpScale;
13
    pixelNormalTS.z = sqrt(1.0 - min(1, dot(pixelNormalTS.xy, pixelNormalTS.xy)));
14
    pixelNormalWS = TransformTangentToWorld(pixelNormalTS, float3x3(tangentWS, bitangentWS, normalWS));
15
    pixelNormalWS = normalize(pixelNormalWS);
16
}
17
 #endif

这里法线只有XY两个值，所以我们需要计算Z向量的值 _BumpScale新增参数控制法线强度对于法线，各个向量的平方相加应该等于1，由此可以求出Z方向数值
因为浮点计算误差问题X和Y的平方和可能超过1，所以使用Min进行防范最后使用TBN矩阵进行转换然后归一化

混合输出测试看效果#

当当！细节效果是不是有了

最后处理一下背面法线#

1
//处理背面法线
2
normalWS *= isFrontFace ? 1 : -1;
3
pixelNormalWS *= isFrontFace ? 1 : -1;

光照分级#

添加分级参数#

这里设置参数和初始化

1
//定义光滑度
2
float albedoSmoothness = max(1e-5, _AlbedoSmoothness);
3
float albedoShadowFade = 1.0;       //较深阴影
4
float albedoShadow = 1.0;           //较浅阴影
5
float albedoShallowFade = 1.0;      //中间过渡部分较深阴影
6
float albedoShallow = 1.0;          //中间过渡部分较浅阴影
7
float albedoSSS = 1.0;              //中间过渡部分较浅阴影向上偏移出的次表面部分
8
float albedoFront = 1.0;            //最亮区域，接近没有衰减的部分
9
float albedoForward = 1.0;          //最强反射部分

定义光滑系数和锐利系数#

锐利系数也可以叫做粗糙度，锐利系数 = 1 - 光滑系数

1
float attenuation = baseAttenuation * 1.5; //-1.5 ~ 1.5
2
//光滑度系数调整
3
float s0 = albedoSmoothness * 1.5; // 0 ~ 1.5
4
//锐利系数
5
float s1 = 1.0 - s0; // -0.5 ~ 1

分级操作#

1
//将明暗分为6个部分 每0.5一段 1.5 ~ -1
2
float aRamp[6] = {
3
    (attenuation + 1.5) / s1 + 0.0,     //aRamp[0] 强光衰减部分，表示最强的衰减和最深的阴影的负值
4
    (attenuation + 0.5) / s0 + 0.5,     //aRamp[1] 相对较弱的衰减，表征较浅的阴影。
5
    (attenuation + 0.0) / s1 + 0.5,     //aRamp[2] 中等衰减，逐渐过渡到正常的阴影
6
    (attenuation - 0.5) / s0 + 0.5,     //aRamp[3] 较弱衰减，较弱阴影区域
7
    (attenuation - 0.5) / s0 - 0.5,     //aRamp[4] 衰减较少，代表反射或光照强度较强次表面的区域
8
    (attenuation - 2.0) / s1 + 1.5,     //aRamp[5] 最亮区域，接近没有衰减的部分
9
};
10
albedoShadowFade = saturate(1 - aRamp[0]);                  //较深阴影
11
albedoShadow = saturate(min(1 - aRamp[1], aRamp[0]));       //较浅阴影
12
albedoShallowFade = saturate(min(1 - aRamp[2], aRamp[1]));  //中间过渡部分较深阴影
13
albedoShallow = saturate(min(1 - aRamp[3], aRamp[2]));      //中间过渡部分较浅阴影
14
albedoSSS = saturate(min(1 - aRamp[4], aRamp[3]));          //中间过渡部分较浅阴影偏移出的次表面部分
15
albedoFront = saturate(min(1 - aRamp[5], aRamp[4]));        //明亮区域，接近没有衰减的部分
16
albedoForward = saturate(aRamp[5]);

分区公式理解#

分区公式，不用管下标i

aRamp[i] = \frac{attenuation + offset_i} {s_i} + 0.5

Offset参数设计#

Attenuation的范围是-1.5~1.5,这个跨度是3，如果我分6层进行平均分配的话就是3/6=0.5，所以offset这里偏移值应当是0.5的倍数

attenuation的范围是-1.5~1.5#

缩放因子的选择#

然后是看S0和S1两个参数的使用，第一层是使用的S1,光滑度控制，而S0则是1-光滑度即锐利系数，这里我们先分析，这个光滑度的作用是什么这是attenuation / _AlbedoSmoothness 这里可以发现中间的分界线变硬了，这是因为除以一个小数，数值会变大，结果而言就是负数变得更小，正数变得更大，所以对比变得更强烈，也就是数值越小越硬（范围变小），数值越大越软（范围变大）还要一个重要的点是收缩方向，收缩的方向是双向的，只是小于0都是黑色所以看不出来这里使用的是 S0 =_AlbedoSmoothness，若是换成S1则相反，数值越大越软（范围变大），数值越小越硬（范围变小）

这里假设，0 ~ 2/6是第一层的部分，范围是0~1，因为需要满足能量守恒相加为一切保证两段连续，所以第二层在物体的2/6处必须为0，这样可以保证连续，而对于软硬控制，如果使用同一参数，就会导致中间链接的地方向两侧拉开，就会导致不连续，所以两层之间需要使用不同的混合，一个进行外扩的时候另一个同步进行压缩，这也是为什么需要使用S0和S1

各个分量预览#

albedoShadowFade最深阴影#

最深的阴影部分就是光照衰减最大的部分，也就是1 - aRamp[0]

1
albedoShadowFade = saturate(1 - aRamp[0]);   //较深阴影

albedoShadow较浅阴影#

min(1 - aRamp[1], aRamp[0])这里进行处理与第一层重叠过渡的部分和排除重叠的部分，albedoShadow最终输出

1
albedoShadow = saturate(min(1 - aRamp[1], aRamp[0]));       //较浅阴影

albedoShallowFade中间过渡较深阴影#

这里是albedoShallowFade输出，这里使用的是S1，min(1 - aRamp[2], aRamp[1])对重叠部分和两层中间过渡部分进行处理

1
albedoShallowFade = saturate(min(1 - aRamp[2], aRamp[1]));  //中间过渡部分较深阴影

albedoShallow中间过渡较浅阴影#

这里是 albedoShallow输出，min(1 - aRamp[3], aRamp[2])对重叠部分和两层中间过渡部分进行处理

1
albedoShallow = saturate(min(1 - aRamp[3], aRamp[2]));      //中间过渡部分较浅阴影

albedoSSS次表面部分#

阴影层已经分完了，现在这里是次表面部分次表面部分应该是在光照部分和阴影部分之间，阴影越硬次表面就应该也越硬也就是越不明显，这里用S0和上一层相同的软硬控制相当于增强阴影层和光照层的
对应aRamp第五行：衰减程度未改变为attenuation - 0.5，然后受光滑系数影响，阴影范围偏移为-0.5

1
albedoSSS = saturate(min(1 - aRamp[4], aRamp[3]));//中间过渡部分较浅阴影偏移出的次表面部分albedoSSS = saturate(min(1 - aRamp[4], aRamp[3]));          //中间过渡部分较浅阴影偏移出的次表面部分

albedoSSS预览，因为使用的是和上一层相同的S0,当_AlbedoSmoothness为0时，是全黑的

稍微增大_AlbedoSmoothness，边缘变软就出现了区域

模型的_AlbedoSmoothness为0.1

SSS和albedoShallow一起输出#

albedoFront 明亮区域，接近没有衰减#

对应aRamp第六行：衰减程度改变为attenuation - 2.0相当于无衰减，然后受光滑系数影响

1
albedoFront = saturate(min(1 - aRamp[5], aRamp[4]));//明亮区域，接近没有衰减的部分

albedoFront预览，这里使用的S1，min(1 - aRamp[5], aRamp[4])处理和SSS重叠的部分

albedoForward 最强反射部分,没有衰减#

对应aRamp第六行：衰减程度改变为attenuation - 2.0相当于无衰减，然后受光滑系数影响，阴影范围偏移为+1.5，取这个值就是最强反射的部分

1
albedoForward = saturate(aRamp[5]);////最强反射部分

albedoForward预览，这里使用的S1因为和albedoFront同属一组是连续的

能量守恒#

分层之后，各个值加起来应该等于1，所以需要进行判断

1
//能量守恒 累加等于1 abs经验性将权重控制为1，没有经过半球积分验证
2
float a = abs(albedoShadowFade + albedoShadow + albedoShallowFade + albedoShallow + albedoSSS + albedoFront + albedoForward - 1.0) < 0.01;

分层着色#

材质ID初始化#

1
//材质索引
2
int materialId = 0;

读取贴图数据获得材质ID#

1
//材质索引
2
float4 var_OtherDataTex1 =  SAMPLE_TEXTURE2D(_OtherDataTex1, sampler_OtherDataTex1, input.uv);
3
materialId = max(0, 4 - floor(var_OtherDataTex1.r * 5));

初始化颜色变量#

1
//定义光滑度
2
float albedoSmoothness = max(1e-5, _AlbedoSmoothness);
3

4
float albedoShadowFade = 1.0;       //较深阴影
5
float albedoShadow = 1.0;           //较浅阴影
6
float albedoShallowFade = 1.0;      //中间过渡部分较深阴影
7
float albedoShallow = 1.0;          //中间过渡部分较浅阴影
8
float albedoSSS = 1.0;              //中间过渡部分较浅阴影向上偏移出的次表面部分
9
float albedoFront = 1.0;            //最亮区域，接近没有衰减的部分
10
float albedoForward = 1.0;          //最强反射部分

参数追加#

1
[Header(Diffuse)]
2
_AlbedoSmoothness("AlbedoSmoothness", Float) = 1.0
3
_ShallowColor1("ShallowColor1",  Color) = (1, 1, 1, 1)
4
_ShallowColor2("ShallowColor2",  Color) = (1, 1, 1, 1)
5
_ShallowColor3("ShallowColor3",  Color) = (1, 1, 1, 1)
6
_ShallowColor4("ShallowColor4",  Color) = (1, 1, 1, 1)
7
_ShallowColor5("ShallowColor5",  Color) = (1, 1, 1, 1)
8

9
_ShadowColor1("ShadowColor1",  Color) = (1, 1, 1, 1)
10
_ShadowColor2("ShadowColor2",  Color) = (1, 1, 1, 1)
11
_ShadowColor3("ShadowColor3",  Color) = (1, 1, 1, 1)
12
_ShadowColor4("ShadowColor4",  Color) = (1, 1, 1, 1)
13
_ShadowColor5("ShadowColor5",  Color) = (1, 1, 1, 1)
14

15
_PostShallowTint("PostShallowTint",  Color) = (1, 1, 1, 1)
16
_PostShallowFadeTint("PostShallowFadeTint",  Color) = (1, 1, 1, 1)
17

18
_PostShadowTint("PostShadowTint",  Color) = (1, 1, 1, 1)
19
_PostShadowFadeTint("PostShadowFadeTint",  Color) = (1, 1, 1, 1)
20
_PostSssTint("PostSssTint",  Color) = (1, 1, 1, 1)
21
_PosFrontTint("PosFrontTint",  Color) = (1, 1, 1, 1)

新增函数#

这里对颜色归一化其实是进行提亮操作，根据深度来判断是否提亮，当视角越近亮度就越高，越原就越解决原色

平均颜色亮度与归一化#

1
//平均颜色亮度
2
float AverageColor(float3 color)
3
{
4
return dot(color, float3(1.0, 1.0, 1.0)) / 3;
5
}
6
//颜色归一化，这里归一化会使颜色变亮
7
float3 NormalizeColorByAverageColor(float3 color)
8
{
9
float average = AverageColor(color);
10
return color / max(average, 1e-5);
11
}

限制灯光颜色亮度#

这里对灯光进行压暗操作，当灯光亮度不超过1的时候进行缩放，获得一个低亮度的灯光颜色用于阴影处理，而非阴影部分使用不处理的灯光颜色

1
//限制灯光颜色亮度
2
float3 ScaleColorByMax(float3 color)
3
{
4
float maxComponent = max3(color.r, color.g, color.b);
5
maxComponent = min(maxComponent, 1.0);
6
return float3(color * maxComponent);
7
}

三值比较函数宏模版#

1
#define DEFINE_MINMAX3(TYPE)\
2
TYPE min3(TYPE a, TYPE b, TYPE c) {return TYPE(min(min(a, b), c));}\
3
TYPE##2 min3(TYPE##2 a, TYPE##2 b, TYPE##2 c) {return TYPE##2(min(min(a, b), c));}\
4
TYPE##3 min3(TYPE##3 a, TYPE##3 b, TYPE##3 c) {return TYPE##3(min(min(a, b), c));}\
5
TYPE##4 min3(TYPE##4 a, TYPE##4 b, TYPE##4 c) {return TYPE##4(min(min(a, b), c));}\
6
TYPE max3(TYPE a, TYPE b, TYPE c){return TYPE(max(max(a, b), c));}\
7
TYPE##2 max3(TYPE##2 a, TYPE##2 b, TYPE##2 c) {return TYPE##2(max(max(a, b), c));}\
8
TYPE##3 max3(TYPE##3 a, TYPE##3 b, TYPE##3 c) {return TYPE##3(max(max(a, b), c));}\
9
TYPE##4 max3(TYPE##4 a, TYPE##4 b, TYPE##4 c) {return TYPE##4(max(max(a, b), c));}
10

11
DEFINE_MINMAX3(bool)
12
DEFINE_MINMAX3(uint)
13
DEFINE_MINMAX3(int)
14
DEFINE_MINMAX3(float)
15
DEFINE_MINMAX3(half)

各分段颜色设置#

深色阴影#

深色阴影颜色根据材质ID判断进行设置，同时使用深度进行控制远近阴影颜色的亮度，越近越亮，越远越暗，同时新增参数控制阴影底色

1
//ShadowColor
2
float zFade = saturate(input.positionCS.w * 0.43725);
3
shadowColor = select(materialId,
4
    _ShadowColor1,
5
    _ShadowColor2,
6
    _ShadowColor3,
7
    _ShadowColor4,
8
    _ShadowColor5
9
);
10

11
shadowColor = lerp(NormalizeColorByAverageColor(shadowColor), shadowColor, zFade);
12
shadowFadeColor = shadowColor * _PostShadowFadeTint;
13
shadowColor = shadowColor * _PostShadowTint;

浅色阴影#

浅色阴影相同处理

1
//shallowColor
2
shallowColor = select(materialId,
3
    _ShallowColor1,
4
    _ShallowColor2,
5
    _ShallowColor3,
6
    _ShallowColor4,
7
    _ShallowColor5
8
);
9

10
shallowColor = lerp(NormalizeColorByAverageColor(shallowColor), shallowColor, zFade);
11
shallowFadeColor = shallowColor * _PostShallowFadeTint;
12
shallowColor = shallowColor * _PostShallowTint;

过渡部分#

SSS颜色和光照亮色直接进行设置底色，反射颜色ForWardColor直接给1.0白色就行

1
sssColor = _PostSssTint;
2
frontColor = _PosFrontTint;
3
forwardColor = 1.0;

混合颜色#

1
float3 lightColorScaledByMax = ScaleColorByMax(lightColor);
2
float3 albedo = (albedoForward * forwardColor + albedoFront * frontColor + albedoSSS * sssColor) * lightColor;
3
albedo += (albedoShadowFade * shadowFadeColor + albedoShadow * shadowColor + albedoShallowFade * shallowFadeColor + albedoShallow * shallowColor) * lightColorScaledByMax;

查看混合效果#

效果出来了！！接下来我们给模型追加投影效果

投影追加#

当前处理了兰伯特的明暗关系，现在进行投影的处理，使用屏幕空间投影

开启深度缓冲，调整深度贴图渲染模式

使用FrameDebug查看是否正常启用#

如果没有上面的两个过程说明深度缓冲没有开启这时候我们就该在追加一个Pass了

追加DepthOnlyPass#

1
// DepthOnlyPass
2
Name"DepthOnly"
3
Tags
4
{
5
    "LightMode" = "DepthOnly"
6
}
7
ZWrite [_ZWrite]
8
ZTest LEqual
9
ColorMask 0
10
Cull [_Cull]
11
// HLSL程序段
12
HLSLPROGRAM
13

14
#pragma multi_compile_instancing
15
#pragma multi_compile _ DOTS_INSTANCING_ON
16

17
#pragma vertex vert
18
#pragma fragment frag
19

20

21
struct Attributes
22
{
23
    float4 positionOS : POSITION;
24

25
};
26
struct Varyings
27
{
28
    float4 positionCS : SV_POSITION;
29
};
30

31
Varyings vert(Attributes input)
32
{
33
    Varyings output = (Varyings)0;
34
    output.positionCS = TransformObjectToHClip(input.positionOS.xyz);
35
    return output;
36
}
37

38
float4 frag(Varyings input) : SV_TARGET
39
{
40
    clip(1.0 - _AlphaClip);
41

42
    return 0;
43
}
44
ENDHLSL

参数追加#

1
[Header(Screen Space Shadow)]
2
[Toggle(_SCREEN_SPACE_SHADOW)] _ScreenSpaceShadow("Screen Space Shadow", int) = 1
3
_ScreenSpaceShadowWidth("Screen Space Shadow Width", Range(0, 1)) = 0.2
4
_ScreenSpaceShadowThreshold("Screen Space Shadow Threshold", Range(0, 1)) = 0.015
5
_ScreenSpaceShadowFadeout("Screen Space Shadow Fadeout", Range(0, 10)) = 0.2

投影追加#

1
//投影追加
2
float shadowAttenuation = 1.0;
3
#if _SCREEN_SPACE_SHADOW
4
{
5
    //读取像素深度
6
    float linearEyeDepth = input.positionCS.w;
7
    //透视除法计算透视因子转换到NDC标准化空间
8
    float perspective = 1.0 / linearEyeDepth;
9
    //计算偏移方向乘量
10
    float offsetMul = _ScreenSpaceShadowWidth * 5.0 * perspective / 100.0;
11
    //将光向量转换到视图空间
12
    float3 lightDirectionVS = TransformWorldToViewDir(lightDirectionWS);
13
    //计算偏移值
14
    float2 offset = lightDirectionVS.xy * offsetMul;
15

16
    //屏幕采样
17
    int2 coord = input.positionCS.xy + offset * _ScaledScreenParams.xy;
18
    //钳制防止采样到边界
19
    coord = min(max(0, coord), _ScaledScreenParams.xy - 1);
20
    //读取深度图
21
    float offsetSceneDepth = LoadSceneDepth(coord);
22
    //深度图是经过透视变换过的所以是非线性，这里进行转线性_ZBufferParams里面有近裁面和远裁面信息
23
    float offsetSceneLinearEyeDepth = LinearEyeDepth(offsetSceneDepth, _ZBufferParams);
24

25
    //控制阴影衰减程度，进行钳制
26
    float fadeout = max(1e-5, _ScreenSpaceShadowFadeout);
27
    //偏移后的深度图减去原来的深度图
28
    shadowAttenuation = saturate((offsetSceneLinearEyeDepth - (linearEyeDepth - _ScreenSpaceShadowThreshold)) * 50 / fadeout);
29
    //shadowAttenuation = saturate((offsetSceneLinearEyeDepth-linearEyeDepth+0.015)*50);
30
}
31
#endif

分段解析#

对于深度信息，实际上就是裁剪空间下的w分量，如果要映射到屏幕上，还需要进行透视除法，也就是需要除以W分量这里先取得了W分量，然后计算了透视除法的因子，也就是 $1.0/linearEyeDepth$

1
//读取像素深度
2
float linearEyeDepth = input.positionCS.w;
3
//透视除法计算透视因子转换到NDC标准化空间
4
float perspective = 1.0 / linearEyeDepth;

然后接着计算偏移的乘量，_ScreenSpaceShadowWidth是我们自定义的参数，这里乘上5.0是经验值为了方便调整参数，然后乘上透视因子perspective，最后除以100应该是进行百分制的换算，就计算完成

1
//计算偏移方向乘量
2
float offsetMul = _ScreenSpaceShadowWidth * 5.0 * perspective / 100.0;

下面先对光向量进行处理，将光向量转换到视图空间，偏移值则是取X和Y分量，也就是仅在屏幕上上下或者左右偏移，最后乘上偏移的乘量，应该可以理解为灯光偏移百分之多少

1
//将光向量转换到视图空间
2
float3 lightDirectionVS = TransformWorldToViewDir(lightDirectionWS);
3
//计算偏移值
4
float2 offset = lightDirectionVS.xy * offsetMul;

计算屏幕UV采样坐标，原坐标就是裁剪空间的XY，Offset是NDC下的所以需要乘上屏幕的长宽，然后对坐标进行限制防止越界。然后就是采样，采样出来的是非线性的所以需要进行转换，最后就是进行线性转换

1
//屏幕采样
2
int2 coord = input.positionCS.xy + offset * _ScaledScreenParams.xy;
3
//钳制防止采样到边界
4
coord = min(max(0, coord), _ScaledScreenParams.xy - 1);
5
//读取深度图
6
float offsetSceneDepth = LoadSceneDepth(coord);
7
//深度图是经过透视变换过的所以是非线性，这里进行转线性_ZBufferParams里面有近裁面和远裁面信息
8
float offsetSceneLinearEyeDepth = LinearEyeDepth(offsetSceneDepth, _ZBufferParams);

为了有效地利用深度缓冲区的有限精度，深度值通常会经过非线性映射。例如，常用的深度映射公式是： $zndc = zclip/zclip + d$ 其中zclip是裁剪平面的位置 ,d是物体到摄像机的距离。这个公式导致了深度值在近处变化更快，而在远处变化较慢。这里进行最终投影计算，使用偏移过后的深度图减去原深度图，这里为了防止在距离非常近的情况下两个图相减效果不对所以需要对原深度图减去一个阈值这样可以保证两个图之间一定会有差值并且不会出现自阴影，最后进行x50这个经验值进行增强对比度在除以一个人为控制的衰减值，这里是除数所以必须大于0 !

1
//控制阴影衰减程度，进行钳制
2
float fadeout = max(1e-5, _ScreenSpaceShadowFadeout);
3
//偏移后的深度图减去原来的深度图
4
shadowAttenuation = saturate((offsetSceneLinearEyeDepth - (linearEyeDepth - _ScreenSpaceShadowThreshold)) * 50 / fadeout);
5
//shadowAttenuation = saturate((offsetSceneLinearEyeDepth-linearEyeDepth+0.015)*50);

投影效果#

将投影追加到光照层级中#

这里保证了能量守恒，将投影全部给了ShallowFade，Shadow部分保持不变。Shallowfade能量增加，Shallow能量减小了，这里计算特别复杂，需要画图分析，看看代码就行

1
//投影追加修改（*）
2
float sRamp[2] = {
3
    2.0 * shadowAttenuation,        // 范围[0, 2]   投影1
4
    2.0 * shadowAttenuation - 1     // 范围[-1, 1]  投影2 shadowAttenuationd大于0.5时才影响
5
};
6

7

8
albedoShallowFade *= saturate(sRamp[0]);
9
albedoShallowFade += (1 - albedoShadowFade - albedoShadow) * saturate(1 - sRamp[0]);
10
//albedoShallowFade =saturate(albedoShallowFade);
11

12
albedoShallow *= saturate(min(sRamp[0], 1 - sRamp[1])) + saturate(sRamp[1]);
13
albedoSSS *= saturate(min(sRamp[0], 1 - sRamp[1])) + saturate(sRamp[1]);
14
albedoSSS += (albedoFront + albedoForward) * saturate(min(sRamp[0], 1 - sRamp[1]));
15
albedoFront *= saturate(sRamp[1]);
16
albedoForward *= saturate(sRamp[1]);

面部阴影SDF重构#

添加空组件进行定位#

找到模型骨骼的头部，添加三个空组件用于定位

创建C#脚本#

开启编辑模式也可以调用

下面是完整的脚本代码

1
using System.Collections;
2
using System.Collections.Generic;
3
using UnityEngine;
4

5
[ExecuteInEditMode]
6
public class NewBehaviourScript : MonoBehaviour
7
{
8
    public Transform HeadBoneTransform;
9
    public Transform HeadForwardTransform;
10
    public Transform HeadRightTransform;
11

12
    private Renderer[] allRanderers;
13

14
    private int headCenterID = Shader.PropertyToID("_HeadCenter");
15
    private int headForwardID = Shader.PropertyToID("_HeadForward");
16
    private int headRightID = Shader.PropertyToID("_HeadRight");
17
    //脚本开启时也更新一次
18
    #if UNITY_EDITOR
19
    void OnValidate()
20
    {
21
        Update();
22
    }
23
    #endif
24

25
    // Update is called once per frame
26
    void Update()
27
    {
28
        if(allRanderers == null)
29
        {
30
            allRanderers = GetComponentsInChildren<Renderer>(true);
31
        }
32
        for(int i = 0; i < allRanderers.Length; i++)
33
        {
34
            Renderer r = allRanderers[i];
35
            foreach (Material mat in r.sharedMaterials)
36
            {
37
                if (mat.shader)
38
                {
39
                    if (mat.shader.name == "URP/Miyabi")
40
                    {
41
                        mat.SetVector(headCenterID, HeadBoneTransform.position);
42
                        mat.SetVector(headForwardID, HeadForwardTransform.position);
43
                        mat.SetVector(headRightID, HeadRightTransform.position);
44

45
                    }
46
                }
47
            }
48
        }
49
    }
50
}

追加参数#

1
[Header(SDF)]
2
[NoScaleOffset] _SDFTex("SDFTexture",2D) = "White"{}
3
_HeadCenter("HeadCenter", Vector) = (0,0,0,0)
4
_HeadForward("HeadForward", Vector) = (0,0,0,0)
5
_HeadRight("HeadRight", Vector) = (0,0,0,0)

采样SDF图#

通过脚本传入值计算角度阈值等，点乘判断光线方向进行UV的水平方向翻转计算阈值是为了混合光照强度，当正脸有光照的话就将混合强度降低，而背光时就需要将面部增亮了

注意这里不是常规的反正切而是actan2函数，对应上图的话就是左右分两半，从-Forward方向为起点也就是0，向下为末端π，左半为正右半为负。所以函数的输出范围就是-π到π，那么转为弧度就-1到1。如果大于0就1-去这个值，小于零就加1，这样就得到当光线在正面时为0，在背面为1

1
#if _DOMAIN_FACE
2
{
3
    float3 headForward = normalize(_HeadForward - _HeadCenter);
4
    float3 headRight = normalize(_HeadRight - _HeadCenter);
5
    float3 headUp = normalize(cross(headForward, headRight));
6

7
    float3 lightDirectionProjHeadWS = lightDirectionWS - dot(lightDirectionWS,headUp) * headUp;
8
    lightDirectionProjHeadWS = normalize(lightDirectionProjHeadWS);
9

10
    float sX = dot(lightDirectionProjHeadWS, headRight);
11
    float sZ = dot(lightDirectionProjHeadWS, -headForward);
12

13
    angleThreshold = atan2(sX, sZ) / 3.14159265359; //角度转弧度
14
    angleThreshold = angleThreshold > 0 ? (1 - angleThreshold) : ( 1 + angleThreshold);
15

16
    float2 angleUV = input.uv;
17
    //判断光线是否在右侧，如果在右侧需要翻转UV的水平方向
18
    if(dot(lightDirectionProjHeadWS, headRight) > 0)
19
    {
20
        angleUV.x = 1.0 - angleUV.x;
21
    }
22

23
    float4 angleData =  SAMPLE_TEXTURE2D(_SDFTex, sampler_SDFTex, angleUV);
24

25
    angleMapping = angleData.r;
26
    angleFunction = angleData.g;
27
    angleMapMask = angleData.a;
28
}
29
#endif

将SDF融入光照模型#

1
//SDF
2
#if _DOMAIN_FACE
3
{
4
    float s = lerp(_AlbedoSmoothness, 0.025, saturate(2.5 * (angleFunction - 0.5)));
5
    s = max(1e-5, s);
6

7
    float angleAttenuation = 0.6 + (angleMapping * 1.2 - 0.6) / (s * 4 + 1) - angleThreshold;
8

9
    float aRamp[3] =
10
    {
11
        angleAttenuation / s,
12
        angleAttenuation / s - 1,
13
        angleAttenuation / 0.125 - 16 * s
14
    };
15

16
    float angleShadowFade = saturate(1 - aRamp[0]);
17
    float angleShadow = 0;
18
    float angleShallowFade = 0;
19
    float angleShallow = 0;
20
    float angleSSS = min(saturate(1 - aRamp[1]), saturate(aRamp[0]));
21
    float angleFront = min(saturate(1 - aRamp[2]), saturate(aRamp[1]));
22
    float angleForward = saturate(aRamp[2]);
23

24
    float sRamp[1] = {
25
        2 * shadowAttenuation
26
    };
27

28
    angleShadowFade *= saturate(1 - sRamp[0]);
29
    angleShallowFade += (1 - angleForward - angleFront - angleSSS - angleShallow) * saturate(sRamp[0]);
30
    angleShallowFade += (angleSSS + angleFront + angleForward) * saturate(1 - sRamp[0]);
31
    angleSSS *= saturate(sRamp[0]);
32
    angleFront *= saturate(sRamp[0]);
33
    angleForward *= saturate(sRamp[0]);
34

35

36
    albedoShadowFade = lerp(albedoShadowFade, angleShadowFade, angleMapMask);
37
    albedoShadow = lerp(albedoShadow, angleShadow, angleMapMask);
38
    albedoShallowFade = lerp(albedoShallowFade, angleShallowFade, angleMapMask);
39
    albedoShallow = lerp(albedoShallow, angleShallow, angleMapMask);
40
    albedoSSS = lerp(albedoSSS, angleSSS, angleMapMask);
41
    albedoFront = lerp(albedoFront, angleFront, angleMapMask);
42
    albedoForward = lerp(albedoForward, angleForward, angleMapMask);
43
}
44
#endif

效果展示#

书接上回接着往下看吧#

鼻线添加#

转动灯光到正面这里看不见鼻子了，所以需要对鼻线进行添加

贴图信息#

鼻线的位置在面部贴图的Alpha通道中

之前代码中已经提取了，但没有使用

1
#if _DOMAIN_BODY || _DOMAIN_EYE
2
{
3
    baseAlpha = var_MainTex.a;
4
}
5
#endif

获取观察向量#

因为鼻线需要对视线方向做混合，偏转大的视角比如说侧脸，就直接看不见鼻线，所以需要获取观察向量

1
float3 viewDirWS = normalize(input.viewDirWS);

计算鼻线的DisplayValue#

这里直接在SDF代码下面写就行。先获取描边颜色，后面进行混合处理。根据点乘判断方向>0同向，小于0反向，计算ViewDir和HeadUP点积已及ViewDir和HeadRight点积。

我这里偷懒没有对鼻线的颜色进行修改，直接就使用面部描边颜色_OutLineColor1了，如果要修改再加一个变量控制即可

1
float3 outlineColor = _OutLineColor1,rgb * 0.2;
2
float viewDotHeadUp = dot(viewDirWS, headUp);
3
float viewDotHeadRight = dot(headForward, viewDirWS);

计算混合值，这里很多应该都是经验性的处理，对_NoseLineKDnDisp,_NoseLineHoriDisp进行插值，这里是进行了竖直方向的Alpha控制，混合水平控制直接使用了viewDotHeadForward - dispValue;然后钳制和混和贴图鼻线

1
 //视角从上往下到水平之间Alpha由水平值控制，从下往上则由_NoseLineKDnDispk控制
2
float dispValue = lerp(_NoseLineKDnDisp, _NoseLineHoriDisp, smoothstep(0, 0.75, saturate(viewDotHeadUp + 0.85)));
3
dispValue = viewDotHeadForward - dispValue;
4
dispValue = smoothstep(0, 0.02, dispValue);
5
dispValue -= var_MainTex.a;
6
baseCol = lerp(baseCol, outlineColor, saturate(dispValue));

反正最后效果就是上下左右的偏转都看不见鼻线，只在正脸的小范围有鼻线。理论上乘法混合，效果也差不多，但因为乘法原因是取到0时对应角度太大了，所以得对viewDotHeadForward范围钳制一次，有点多余。这块自己随意调整吧

鼻线效果#

接下来就到大家喜欢的丝袜制作环节了

添加MatCap#

贴图#

B通道是MatCap的Mask

这里有3张MatCap,分别对应是高光，金属，丝袜

先把贴图上上

读取MatCapMask#

初始化#

1
//MatCap
2
float matCapMask = 0;

采样#

1
//MatCap
2
float4 var_OtherDataTex2 = SAMPLE_TEXTURE2D(_OtherDataTex2, sampler_OtherDataTex2, input.uv);
3
matCapMask = var_OtherDataTex2.b;

我们来看一下matcapmask区域

可以明显看到在丝袜，金属部分有matcap遮罩不错！

添加参数#

MatCap宏开关和贴图#

1
[Header(MatCap)]
2
[Toggle(_MATCAP_ON)] _MatCap_On("MatCap_On", int) = 0
3
[NoScaleOffset] _MatCapTex1("_MatCapTex1", 2D) = "White"{}
4
[NoScaleOffset] _MatCapTex2("_MatCapTex2", 2D) = "White"{}
5
[NoScaleOffset] _MatCapTex3("_MatCapTex3", 2D) = "White"{}
6
[NoScaleOffset] _MatCapTex4("_MatCapTex4", 2D) = "White"{}
7
[NoScaleOffset] _MatCapTex5("_MatCapTex5", 2D) = "White"{}

MatCap的基础混色，混合颜色强度强度，混合Alpha程度#

1
_MatCapTintColor1("_MatCapTintColor1",  Color) = (1, 1, 1, 1)
2
_MatCapTintColor2("_MatCapTintColor2",  Color) = (1, 1, 1, 1)
3
_MatCapTintColor3("_MatCapTintColor3",  Color) = (1, 1, 1, 1)
4
_MatCapTintColor4("_MatCapTintColor4",  Color) = (1, 1, 1, 1)
5
_MatCapTintColor5("_MatCapTintColor5",  Color) = (1, 1, 1, 1)
6

7
_MatCapColorBurst1("MatCapColorBurst1", Range(0, 10)) = 1
8
_MatCapColorBurst2("MatCapColorBurst2", Range(0, 10)) = 1
9
_MatCapColorBurst3("MatCapColorBurst3", Range(0, 10)) = 1
10
_MatCapColorBurst4("MatCapColorBurst4", Range(0, 10)) = 1
11
_MatCapColorBurst5("MatCapColorBurst5", Range(0, 10)) = 1
12

13
_MatCapAlphaBurst1("MatCapAlphaBurst1", Range(0, 10)) = 1
14
_MatCapAlphaBurst2("MatCapAlphaBurst2", Range(0, 10)) = 1
15
_MatCapAlphaBurst3("MatCapAlphaBurst3", Range(0, 10)) = 1
16
_MatCapAlphaBurst4("MatCapAlphaBurst4", Range(0, 10)) = 1
17
_MatCapAlphaBurst5("MatCapAlphaBurst5", Range(0, 10)) = 1

反射开关#

这里没有设置宏，仅为开关，在后面声明之后当Float（Bool）用就行。还有深度值，用于计算折射!

1
[Toggle] _MatCapRefract1("MatCapRefract1", int) = 0
2
[Toggle] _MatCapRefract2("MatCapRefract2", int) = 0
3
[Toggle] _MatCapRefract3("MatCapRefract3", int) = 0
4
[Toggle] _MatCapRefract4("MatCapRefract4", int) = 0
5
[Toggle] _MatCapRefract5("MatCapRefract5", int) = 0
6

7
_MatCapDepth1("MatCapDepth1", Float) = 0.5
8
_MatCapDepth2("MatCapDepth2", Float) = 0.5
9
_MatCapDepth3("MatCapDepth3", Float) = 0.5
10
_MatCapDepth4("MatCapDepth4", Float) = 0.5
11
_MatCapDepth5("MatCapDepth5", Float) = 0.5

混合模式设置，UV偏移#

1
[Enum(AlphaBlend, 0, Add, 1, Overlay, 2)] _MatCapBlendMode1("MatCapBlendMode1", int) = 0
2
[Enum(AlphaBlend, 0, Add, 1, Overlay, 2)] _MatCapBlendMode2("MatCapBlendMode2", int) = 0
3
[Enum(AlphaBlend, 0, Add, 1, Overlay, 2)] _MatCapBlendMode3("MatCapBlendMode3", int) = 0
4
[Enum(AlphaBlend, 0, Add, 1, Overlay, 2)] _MatCapBlendMode4("MatCapBlendMode4", int) = 0
5
[Enum(AlphaBlend, 0, Add, 1, Overlay, 2)] _MatCapBlendMode5("MatCapBlendMode5", int) = 0
6

7
_MatCapParam1("_MatCapWrapOffset1", Vector) = (5,5,0,0)
8
_MatCapParam2("_MatCapWrapOffset2", Vector) = (5,5,0,0)
9
_MatCapParam3("_MatCapWrapOffset3", Vector) = (5,5,0,0)
10
_MatCapParam4("_MatCapWrapOffset4", Vector) = (5,5,0,0)
11
_MatCapParam5("_MatCapWrapOffset5", Vector) = (5,5,0,0)

声明参数#

1
//MatCap
2
float3 _MatCapTintColor1;
3
float3 _MatCapTintColor2;
4
float3 _MatCapTintColor3;
5
float3 _MatCapTintColor4;
6
float3 _MatCapTintColor5;
7

8
float _MatCapColorBurst1;
9
float _MatCapColorBurst2;
10
float _MatCapColorBurst3;
11
float _MatCapColorBurst4;
12
float _MatCapColorBurst5;
13

14
float _MatCapAlphaBurst1;
15
float _MatCapAlphaBurst2;
16
float _MatCapAlphaBurst3;
17
float _MatCapAlphaBurst4;
18
float _MatCapAlphaBurst5;
19

20
float _MatCapDepth1;
21
float _MatCapDepth2;
22
float _MatCapDepth3;
23
float _MatCapDepth4;
24
float _MatCapDepth5;
25

26
float4 _MatCapParam1;
27
float4 _MatCapParam2;
28
float4 _MatCapParam3;
29
float4 _MatCapParam4;
30
float4 _MatCapParam5;
31

32
int _MatCapRefract1;
33
int _MatCapRefract2;
34
int _MatCapRefract3;
35
int _MatCapRefract4;
36
int _MatCapRefract5;
37

38
int _MatCapBlendMode1;
39
int _MatCapBlendMode2;
40
int _MatCapBlendMode3;
41
int _MatCapBlendMode4;
42
int _MatCapBlendMode5;

计算MatCap#

获取MatCapMask#

采样获得MatCapMask，在贴图的B通道中

1
//MatCap
2
float4 var_OtherDataTex2 = SAMPLE_TEXTURE2D(_OtherDataTex2, sampler_OtherDataTex2, input.uv);
3
matCapMask = var_OtherDataTex2.b;

计算UV#

采样matCap的固定公式，将法线转换到观察空间，取XY作为UV进行采样，这里因为原本法线是-1_{1，这里需要重映射到0}1

1
float3 matCapColor = baseCol;
2
#if _MATCAP_ON && _DOMAIN_BODY
3
{
4
    float mask = matCapMask;
5
    float3 normalVS = TransformWorldToViewDir(pixelNormalWS);
6
    //-1~1 映射到 0~1
7
    float2 matCapUV = normalVS.xy * 0.5 + 0.5;
8
}
9
#endif

折射判断#

对需要折射的部分进行判断，这里其实是直接根据折射开关的值来的，因为只有0和1的bool值

1
//折射
2
float refract = select(materialId,
3
    _MatCapRefract1,
4
    _MatCapRefract2,
5
    _MatCapRefract3,
6
    _MatCapRefract4,
7
    _MatCapRefract5
8
);

折射系数及UV调整#

这里并非是真的计算折射，其实只是对MatCap采样进行缩放和平移调整。获取各个区域不同的UV和Depth参数进行混合，调整matCapUV param.xy * input.uv是表示物体UV方向的偏移(为了保证效果贴合物体本身UV)，但为了整体控制偏移也使用了 $+ param.zw$

1
if(refract > 0.5)
2
{
3
    float4 param = select(materialId,
4
        _MatCapParam1,
5
        _MatCapParam2,
6
        _MatCapParam3,
7
        _MatCapParam4,
8
        _MatCapParam5
9
    );
10
    float depth = select(materialId,
11
        _MatCapDepth1,
12
        _MatCapDepth2,
13
        _MatCapDepth3,
14
        _MatCapDepth4,
15
        _MatCapDepth5
16
    );
17
    matCapUV = matCapUV * depth + param.xy * input.uv + param.zw;
18
}

采样MatCap和混合参数#

1
matCapColor = select(materialId,
2
    SAMPLE_TEXTURE2D(_MatCapTex1, sampler_MatCapTex1, matCapUV).rgb,
3
    SAMPLE_TEXTURE2D(_MatCapTex2, sampler_MatCapTex2, matCapUV).rgb,
4
    SAMPLE_TEXTURE2D(_MatCapTex3, sampler_MatCapTex3, matCapUV).rgb,
5
    SAMPLE_TEXTURE2D(_MatCapTex4, sampler_MatCapTex4, matCapUV).rgb,
6
    SAMPLE_TEXTURE2D(_MatCapTex5, sampler_MatCapTex5, matCapUV).rgb
7
);
8

9
float3 tintColor = select(materialId,
10
    _MatCapTintColor1,
11
    _MatCapTintColor2,
12
    _MatCapTintColor3,
13
    _MatCapTintColor4,
14
    _MatCapTintColor5
15
);
16

17
float alphaBurst = select(materialId,
18
    _MatCapAlphaBurst1,
19
    _MatCapAlphaBurst2,
20
    _MatCapAlphaBurst3,
21
    _MatCapAlphaBurst4,
22
    _MatCapAlphaBurst5
23
);
24
float colorBurst = select(materialId,
25
    _MatCapColorBurst1,
26
    _MatCapColorBurst2,
27
    _MatCapColorBurst3,
28
    _MatCapColorBurst4,
29
    _MatCapColorBurst5
30
);
31

32
int blendMode = select(materialId,
33
    _MatCapBlendMode1,
34
    _MatCapBlendMode2,
35
    _MatCapBlendMode3,
36
    _MatCapBlendMode4,
37
    _MatCapBlendMode5
38
);

混合模式#

这里是三种混合方式

1
//乘法Alpha混合
2
if(blendMode == 0)
3
{
4
    float alpha = saturate(alphaBurst * mask);
5
    float3 blendColor = tintColor * matCapColor * colorBurst;
6
    matCapColor = lerp(baseCol, blendColor, alpha);
7
}
8
//加法混合
9
else if(blendMode == 1)
10
{
11
    float alpha = saturate(alphaBurst * mask);
12
    float3 blendColor = tintColor * matCapColor * colorBurst;
13
    matCapColor = baseCol + blendColor * alpha;
14
}
15
//叠加混合
16
else if(blendMode == 2)
17
{
18
    float alpha = saturate(alphaBurst * mask);
19
    float3 blendColor = saturate((matCapColor * tintColor - 0.5) * colorBurst + matCapColor *  tintColor);
20
    blendColor = lerp(0.5, blendColor, alpha);
21
    matCapColor = lerp(blendColor * baseCol * 2, 1 - 2 * (1 - baseCol) * (1 - blendColor), baseCol >= 0.5);
22
}

分段解释#

乘法混合（Multiply Alpha Blend）#

这里先计算Alpha的值，blendColor就是MatCap采样颜色乘上基础混合颜色和Matcap颜色总强度，最后是使用alpha进行插值

从效果来说，乘法会使颜色变暗，而使用alpha混合，输出部分就全部是Matcap颜色或全是基础颜色，两者是不会有重叠的

加法混合（Additive Blend）#

同样先计算Alpha，几个混合模式中Alpha是一样的。这里是先是使用乘法混合matcap颜色和相关系数，最后是加法混合，使用原本颜色加上matcap颜色

效果来说就，在最后一步加法混合时，原颜色并没有剔除掉Alpha中部分，所以在alpha区域两个颜色相加就会变亮

叠加混合（Overlay Blend）#

公式一：对比度调整#

$adjustedColor = (originalColor - 0.5) * contrast + 0.5$

公式二：叠加混合#

C_{out} = \left\{ \begin{matrix} 2 \cdot C_{base} \cdot C_{blend} & \text{if } C_{base} < 0.5 \\ 1 - 2 \cdot (1 - C_{base}) \cdot (1 - C_{blend}) & \text{if } C_{base} \geq 0.5 \end{matrix} \right.

先对matcap的blendColor进行处理，-0.5就是原本颜色范围变成-0.5~0.5以0.5为中心环绕，这时这个值作为一个基数在乘上颜色强度就得到了一个降低暗部增强亮部的系数，最后加上原本的matcapColor,相当于以matcapColor增强对比度

为了防止前面的颜色对比度过高失真所以使用一个中性灰色0.5进行平滑

以0.5为边界用来区分高亮区域和阴影区域，高于0.5就增强，低于0.5就削弱，效果来可以理解为增加对比度

matcap参数调整#

饰品手臂部分#

第2个槽位是金属手臂的材质
第3个槽位是饰品的材质
第5个槽位是丝袜的材质，所以进行染色和开启反射，这里取消他的偏移，使它不按照物体UV进行偏移反射！

说了你们看不出来直接看图吧！

衣服身体部分#

什么？你问第5个槽的Matcap不生效是什么原因，请看上面的matcapmask输出，第5个槽原本是对应的裙摆，可以看到裙摆上并没有mask。

matcap效果（你们最期待的丝袜来了）#

饰品和手臂部分#

衣服部分#

丝袜部分#

颜色锐化处理#

获取遮蔽信息#

1
//颜色调整
2
float3 gammaColor = matCapColor;
3
{
4
    float pixelNDotL = dot(pixelNormalWS, lightDirectionWS);
5
    float NDotL = dot(normalWS, lightDirectionWS);
6
}

pixelNDotL，含贴图法线发兰伯特拥有很多细节
NDotL，顶点法线的兰伯特非常光滑细节较少
NDotL - pixelNDotL，两者相减可以得到物体的凹凸信息，那么用1减去这个值就可以得到一个遮罩的遮蔽信息occlusion

遮蔽信息调整#

1
float occlusion = saturate(1 - 3 * (NDotL - pixelNDotL)) * 2;
2
occlusion *= sqrt(occlusion);
3
occlusion = min(1, occlusion);

颜色Gamma矫正衰减系数#

最后计算获得一个颜色衰减值，兰伯特的值是-1_{1，这里使用半兰伯特0}1和遮罩系数进行计算是为了保留教暗地方的依旧有颜色衰减值，我们默认使用的是兰伯特光照，所以这里进行混合，使用0.5也就是均匀混合。这样就得到了一个颜色的衰减值，注意这里说的衰减值是作用于Gamma矫正也就是颜色变化，而不是仅仅亮度变化，这里叫做颜色Gamma矫正衰减系数应该比较合适

1
//颜色Gamma矫正衰减系数
2
float attenuation = lerp((pixelNDotL * 0.5 + 0.5) * occlusion, saturate(pixelNDotL), 0.5);

Gamma矫正#

颜色钳制#

有了颜色Gamma矫正衰减系数，然后知道Gamma矫正的值后，就可以对颜色进行Gamma矫正了，但在这之前需要钳制颜色亮度，因为Gamma其实本质可以理解为Pow(Color，gamma)，对于大于1的进行Pow会导致变得非常亮

1
//钳制亮度
2
float3 matCapColorClamped = ClampColorMax(matCapColor);

这里函数内部对颜色各个分量取得最大值，如果大于1，就将整个颜色除以这个值进行压暗，保证颜色不变的情况下降低明度，钳制到1以下

1
//颜色钳制处理
2
float3 ClampColorMax(float3 color)
3
{
4
    float maxComponent = max3(color.r, color.g, color.b);
5
    if(maxComponent > 1.0)
6
    {
7
        return color / maxComponent;
8
    }
9
    return color;
10
}

计算颜色亮度和gamma值#

这里Luminance()函数是根据权重计算颜色的灰度（亮度）值。最终通过灰度值来控制Gmma值基数，使用颜色Gamma矫正衰减系数混合，这里这个乘 0.2875和加1.4375的操作也属于经验值，并不是固定的，以效果为准

1
//颜色转单一亮度
2
float luminance = Luminance(matCapColor);
3
//计算gamma值
4
float gamma = lerp(luminance * 0.2875 + 1.4375, 1, attenuation);

现在有了Gama值后，现在就进行颜色的Gamma矫正了。直接使用pow即可，钳制一下不要等于0了，根据效果来调整强度，使用兰伯特控制，亮的部分就使用Gamma，暗的地方就减小Gamma强使用GammaHalf

1
//颜色进行Gamma
2
float3 matCapColorGamma = pow(max(1e-5, matCapColorClamped), gamma);
3
//Gamma效果削弱
4
float3 matCapColorGammaHalf = lerp(matCapColor, matCapColorGamma, 0.5);
5
//均衡Gamma效果
6
gammaColor = lerp(matCapColorGammaHalf, matCapColorGamma, saturate(NDotL));

添加PBR高光#

追加高光参数#

1
[Header(Specular)]
2
//Metallic
3
_Metallic("Metallic", Range(0, 10)) = 0
4
_Glossiness("Glossiness", Range(0, 1)) = 0
5
[Toggle] _HighlightShape1("HighlightShape1", int) = 0
6
[Toggle] _HighlightShape2("HighlightShape2", int) = 0
7
[Toggle] _HighlightShape3("HighlightShape3", int) = 0
8
[Toggle] _HighlightShape4("HighlightShape4", int) = 0
9
[Toggle] _HighlightShape5("HighlightShape5", int) = 0
10

11
_HeadSphereRang("HeadSphereRang", Range(0, 1)) = 0
12

13
_ShapeSoftness1("ShapeSoftness1", Range(0, 1)) = 1
14
_ShapeSoftness2("ShapeSoftness2", Range(0, 1)) = 1
15
_ShapeSoftness3("ShapeSoftness3", Range(0, 1)) = 1
16
_ShapeSoftness4("ShapeSoftness4", Range(0, 1)) = 1
17
_ShapeSoftness5("ShapeSoftness5", Range(0, 1)) = 1
18

19
_SpecularRnge1("SpecularRnge1", Range(0, 2)) = 1
20
_SpecularRnge2("SpecularRnge2", Range(0, 2)) = 1
21
_SpecularRnge3("SpecularRnge3", Range(0, 2)) = 1
22
_SpecularRnge4("SpecularRnge4", Range(0, 2)) = 1
23
_SpecularRnge5("SpecularRnge5", Range(0, 2)) = 1
24

25

26
_ToonSpecular1("ToonSpecular1", Range(0, 1)) = 0.01
27
_ToonSpecular2("ToonSpecular2", Range(0, 1)) = 0.01
28
_ToonSpecular3("ToonSpecular3", Range(0, 1)) = 0.01
29
_ToonSpecular4("ToonSpecular4", Range(0, 1)) = 0.01
30
_ToonSpecular5("ToonSpecular5", Range(0, 1)) = 0.01
31

32
_ModelSize1("ModelSize1", Range(0, 100)) = 1
33
_ModelSize2("ModelSize2", Range(0, 100)) = 1
34
_ModelSize3("ModelSize3", Range(0, 100)) = 1
35
_ModelSize4("ModelSize4", Range(0, 100)) = 1
36
_ModelSize5("ModelSize5", Range(0, 100)) = 1
37

38

39
_SpecularIntensity("SpecularIntensity", Range(0, 1)) = 0.1
40

41
[HDR]_SpecularColor1("SpecularColor1",  Color) = (1, 1, 1, 1)
42
[HDR]_SpecularColor2("SpecularColor2",  Color) = (1, 1, 1, 1)
43
[HDR]_SpecularColor3("SpecularColor3",  Color) = (1, 1, 1, 1)
44
[HDR]_SpecularColor4("SpecularColor4",  Color) = (1, 1, 1, 1)
45
[HDR]_SpecularColor5("SpecularColor5",  Color) = (1, 1, 1, 1)

高光贴图信息#

金属Mask和高光遮罩在下方贴图中#

金属图，G通道#

注意这里的金属度图并非是非0和1，大概是64/255这个样子，应该是想表达带漆面的金属效果一类

高光Mask，B通道#

光滑度信息在下方的贴图的G通道中#

Smoothnesss，G通道#

PBR金属高光和漫反射划分#

获取对应的金属信息和高光遮罩

1
//Metallic
2
metallic = _Metallic * var_OtherDataTex1.g;
3
specularMask = var_OtherDataTex1.b;
4

5
smoothness = _Glossiness * var_OtherDataTex2.g;

pbrDiffuseColor进行金属与非金属的划分，非金属的最大漫反射比例是0.96，0.96 x GammColor就是非金属的漫反射，而金属部分是只有镜面反射的没有漫反射，所以漫反射为0。pbrSpecularColor镜面反射，非金属的镜面反射比例就是1-0.96，因为非金属的镜面反射颜色不受本身颜色影响仅受材料的反射率影响，所以这里给上0.04固定颜色。而金属部分，金属的镜面反射是受颜色影响的所以反射原本的颜色

金属部分颜色#

1
// 非金属有0.04去了高光反射，所以漫反射乘上0.96
2
float3 pbrDiffuseColor = lerp(0.96 * gammaColor, 0, metallic);
3
float3 pbrSpecularColor = lerp(0.04, gammaColor, metallic);

球状法线#

1
if(shape > 0.5)
2
{
3
    //判断使用球形法线的时候，_HeadSphereRang是否生效
4
    bool useSphere = _HeadSphereRang > 0;
5
    //球形法线计算
6
    float3 sphereNormalWS = positionWS - _HeadCenter;
7
    //法线长度
8
    float len = length(sphereNormalWS);
9
    sphereNormalWS = normalize(sphereNormalWS);
10
}

由于这样粗略计算会导致身上的一些部位也变成使用球形法线，所以得限制一下范围,超出范围的部分用回贴图法线

1
float sphereUsage = 1.0 - saturate((len - _HeadSphereRange) * 20);
2
float3 shapeNormalWS = lerp(pixelNormalWS, sphereNormalWS, sphereUsage)
3
return float4(sphereNormalWS, 1);

只要脑袋上的头发部分是球形法线就行

Blinn-Phong高光#

1
//高光项，法线决定高光形状
2
float shapeNoL = dot(lightDirectionWS, sphereNormalWS);
3
float shapeAttenuation = sqrt(saturate(shapeNoL * 0.5 + 0.5));
4

5
float NDotH = dot(sphereNormalWS, halfWS);
6
float NDotH01 = saturate(NDotH * 0.5 + 0.5);

获得过度，用高光除上过度，接着乘上几何项和菲涅尔项

1
float headSpecular = NDotH01 * shapeAttenuation + specularMask - 1;
2

3
float softness = select(materialId,
4
    _ShapeSoftness1,
5
    _ShapeSoftness2,
6
    _ShapeSoftness3,
7
    _ShapeSoftness4,
8
    _ShapeSoftness5
9
);
10

11
//软硬控制
12
headSpecular = saturate(headSpecular / softness);
13
headSpecular = headSpecular * min(1.0, 1.0 / (6.0 * rangeLoH2)) * rangeNoL;

几何项和菲涅尔项的计算#

1
float shape = select(materialId,
2
        _HighlightShape1,
3
        _HighlightShape2,
4
        _HighlightShape3,
5
        _HighlightShape4,
6
        _HighlightShape5
7

8
    );
9

10
    float range = select(materialId,
11
        _SpecularRnge1,
12
        _SpecularRnge2,
13
        _SpecularRnge3,
14
        _SpecularRnge4,
15
        _SpecularRnge5
16
    );
17

18
    //半角向量
19
    float3 halfWS = normalize(lightDirectionWS + viewDirWS);
20

21
    //计算高光项
22
    float LoH = dot(lightDirectionWS, halfWS); //0~1
23
    float rangeLoH = saturate(range * LoH * 0.75 + 0.25);//保证最低亮度为0.25但最大亮度还是为1

Smoothness控制#

这一种高光采用GGX（微表面分布函数GGX）
不多废话了直接贴代码

1
//GGX
2
float perceptualRoughness = 1 - smoothness;
3
float roughness = perceptualRoughness * perceptualRoughness;
4

5
float normalizationTerm = roughness * 4 + 2;
6
float roughness2 = roughness * roughness;
7

8
float roughness2MinusOne = roughness2 - 1;
9
float NoH = dot(pixelNormalWS, halfWS);
10
float rangeNoH = saturate(range * NoH * 0.75 + 0.25);//-0.5~1,0~1
11

12
float d = rangeNoH * rangeNoH * roughness2MinusOne + 1.0;
13
float ggx = roughness2 / ((d * d) * rangeLoH2 * normalizationTerm);
14

15
float otherSpecular = saturate((ggx - smoothness) * rangeNoL);
16
otherSpecular = otherSpecular / max(1e-5, roughness);
17

18
//高光强度控制
19
float toon = select(materialId,
20
    _ToonSpecular1,
21
    _ToonSpecular2,
22
    _ToonSpecular3,
23
    _ToonSpecular4,
24
    _ToonSpecular5
25
);
26
//根据模型大小控制高光强度
27
float size = select(materialId,
28
    _ModelSize1,
29
    _ModelSize2,
30
    _ModelSize3,
31
    _ModelSize4,
32
    _ModelSize5
33
);
34

35
otherSpecular *= toon * size * specularMask;
36
otherSpecular *= 10;
37
otherSpecular = saturate(otherSpecular);
38

39

40
specular = useSphere ? lerp(otherSpecular, headSpecular, sphereUsage) : otherSpecular;

上面是GGX方法的简化版，简单来说就是将F（菲涅尔项）与G（几何遮蔽项）变成了V点乘F $I_{spec} = \frac {D(N·H, roughness)·G(N·V, N·L, roughness)·F(L·H, specColor)} {4·(N·V)·(N·L)}·N·L$ 将包含G的这部分分子式替换成V了 $V = \frac{G(N·V, N·L, roughness)}{4·(N·V)·(N·L)}$

不需要纠结怎么简化的，反正最后优化成近似的结果，V乘F公式就变成了下面这个,L是光向量，H是半角向量 $V * F = \frac{1.0} { LoH^2 * (roughness + 0.5)}$

计算公式就变成了 $BRDFspec = \frac{D * V * F} {4.0}$

$Finalspec = \frac{D * V * F} {4.0} * NoL$

ggx除上高光系数，与toonspecular系数和模型大小系数相乘，再乘遮罩，放大一点后钳制一下

给specular乘上系数，乘上颜色，输出

1
//整体强度控制
2
specular *= 100;
3
specular *= _SpecularIntensity;
4

5
//染色
6
float3 tintColor = select(materialId,
7
    _SpecularColor1,
8
    _SpecularColor2,
9
    _SpecularColor3,
10
    _SpecularColor4,
11
    _SpecularColor5
12
);
13

14

15
specularColor = specular * tintColor;

最终效果#

我们来看一下最终效果

可以看到效果不错，nice！我们继续下一步

添加环境光#

球谐光照原理#

想要具体了解的可以去看这篇文章，这边我就不多讲解了
球谐函数介绍（Spherical Harmonics）

添加球谐光照#

新增参数#

增加环境光强度控制参数

1
[Header(Ambient)]
2
_AmbientColorIntensity("AmbientColorIntensity", Range(0, 1)) = 0.1

计算SH#

使用GammaColor进行混合颜色和_AmbientColorIntensity控制强度。

最终输出颜色直接加上环境光颜色即可，但这里做了额外的处理，提取出高光颜色大于1的部分在相加，因为SH环境光是加法混合，整体颜色变亮可能会让高光效果不明显，所以这里为增加高光做处理。

1
//Sh球谐光照
2
    float3 ambientColor = SampleSH(pixelNormalWS) * gammaColor * _AmbientColorIntensity;
3
    float3 color = ambientColor;
4
    color += pbrDiffuseColor * albedo + pbrSpecularColor * specularColor * albedo;
5
    color += max(0, pbrSpecularColor * specularColor * albedo - 1);
6
    color += rimGlowColor;

当前效果#

环境光其实就可以理解为是天空球的颜色。环境光强度也是会受天空球的强度影响的
调整强度也会影响模型SH的强度

对比一下下面效果（可能不是特别明显）
无环境光

有环境光

确实不明显哦，可以把天空球的强度拉高点

可以看到环境光的效果明显了很多

环境光也处理完了接下来就到边缘光效果了

添加边缘光#

新增边缘光参数#

对应的分别为屏幕空间高光开关，皮肤ID，光源颜色，边缘光染色，屏幕空间下边缘光宽度，阈值，衰减程度，强度

1
[Header(RimColor)]
2
[Toggle(_SCREEN_SPACE_RIM)] _ScreenSpaceRim("Screen Space Rim", int) = 1
3
[Enum(S0, 0, S1, 1, S2, 2, S3, 3, S4, 4, NoSkin, 5)] _SkinMatID("SkinMatID", int) = 0
4

5
[HDR]_UISunColor1("_UISunColor1",  Color) = (1, 1, 1, 1)
6
[HDR]_UISunColor2("_UISunColor2",  Color) = (1, 1, 1, 1)
7
[HDR]_UISunColor3("_UISunColor3",  Color) = (1, 1, 1, 1)
8
[HDR]_UISunColor4("_UISunColor4",  Color) = (1, 1, 1, 1)
9
[HDR]_UISunColor5("_UISunColor5",  Color) = (1, 1, 1, 1)
10

11
[HDR]_RimGlowLightColor1("RimGlowLightColor1",  Color) = (1, 1, 1, 1)
12
[HDR]_RimGlowLightColor2("RimGlowLightColor2",  Color) = (1, 1, 1, 1)
13
[HDR]_RimGlowLightColor3("RimGlowLightColor3",  Color) = (1, 1, 1, 1)
14
[HDR]_RimGlowLightColor4("RimGlowLightColor4",  Color) = (1, 1, 1, 1)
15
[HDR]_RimGlowLightColor5("RimGlowLightColor5",  Color) = (1, 1, 1, 1)
16

17
_ScreenSpaceRimWidth("Screen Space Rim Width", Range(0, 5)) = 1
18
_ScreenSpaceRimThreshold("Screen Space Rim Threshold", Range(0, 1)) = 0.01
19
_ScreenSpaceRimFadeout("Screen Space Rim Fadeout", Range(0, 10)) = 0.5
20
_ScreenSpaceRimBrightness("Screen Space Rim Brightness", Range(0, 10)) = 1

宏开关声明与参数申明我就不在单独贴出来了，相信你们也能自己补上

对皮肤部分进行区分#

因为这里处理为皮肤和服装的背光强度是不一样的，所以进行划分，这里直接指定材质ID是皮肤

计算相关衰减项#

背光衰减#

因为边缘光是根据视线方向和灯光方向来控制的，比如说背光的时候边缘光会很强，而面光面就比较弱。所以先计算LOV 这里对（-LOV）进行了重映射，映射到0~1，这里注意是（-LOV），因为LOV根据点乘特征同向为一反向为-1，所以面光面为1，背光面为-1，而边缘光应该以背光面为主，所以取（-LOV）计算，得到viewAttenuation

1
float3 rimGlowColor = 0;
2
{
3
    //获取对应ID设置为皮肤
4
    bool isSkin = materialId == _SkinMatID;
5

6
    //背光方向衰减
7
    float LoV = dot(lightDirectionWS, viewDirWS);
8
    float viewAttenuation = -LoV * 0.5 + 0.5;
9
}

这里得到viewAttenuation后还做了额外的处理，先进行平方后在乘0.5和加0.5，相当于平滑过渡，同时也是为了面光面也有边缘光为0.5，不为0，下面的函数图可以更好理解

1
//进行0.5~1的平滑映射
2
viewAttenuation = pow2(viewAttenuation);
3
viewAttenuation = viewAttenuation * 0.5 + 0.5;

函数图#

法线垂直方向衰减#

这里取法线的Y方向，也就是垂直的方向，重映射到0~1

1
//法线垂直方向衰减
2
float verticalAttenuation =  pixelNormalWS.y * 0.5 + 0.5;

这里对皮肤和服装部分进行区分，让服装的强度低一点直接进行平方，最后整体进行平滑处理

1
verticalAttenuation = isSkin ? verticalAttenuation : pow2(verticalAttenuation);
2
verticalAttenuation = smoothstep(0, 1, verticalAttenuation);

兰伯特方向衰减#

其实就光源对于模型的衰减，也适用于边缘光。这里因为之前计算过投影，所以也追加进去

1
//兰伯特衰减
2
float lightAttenuation = saturate(dot(pixelNormalWS,lightDirectionWS)) * shadowAttenuation;

菲涅尔衰减#

这一步是真正求边缘光的步骤，一般边缘光都是通过菲涅尔进行计算。因为这里需要对相机距离进行反馈，所以先计算相机距离

计算菲涅尔NOV

这是NOV的值，需要的边缘光是黑色部分，所以边缘光需要的值是1-NOV

1
//菲涅尔
2
float cameraDistance = length(input.viewDirWS);
3
float NoV = dot(pixelNormalWS, viewDirWS);
4
float fresnelDistanceFade = (isSkin ? 0.75 : 0.65) - 0.45 * min(1, cameraDistance / 12.0);
5
float fresnelAttenuation = 1 - NoV - fresnelDistanceFade;

对皮肤进行判断，皮肤的菲涅尔效果应该比衣服更弱，所以被(1-NOV)减去的值应该更多，然后衰减程度也和相机距离相关，min(1, cameraDistance / 12.0)最大值为1，当相机距离为12米时为最大，这里12.0就是相机距离，综合起来看就是随距离越远，菲涅尔强度略微增强（其实肉眼看不太出来）

最后根据皮肤划分进行平滑调整

1
float fresnelSoftness = isSkin ? 0.2 : 0.3;
2
fresnelAttenuation = smoothstep(0, fresnelSoftness, fresnelAttenuation);

相机距离衰减#

这里相当于5m之后开始逐渐衰减，5m之前不变，因为小于5的时候减去的部分是负数进行钳制就会变成0 !

1
//相机距离衰减
2
//5m后进行衰减
3
float distanceAttenuation = 1 - 0.7 * saturate(cameraDistance * 0.2 - 1);

函数如下

背光外围向中心方向衰减#

1
//背光中心外围方向衰减
2
float edgeAttenuation = 1 - pow4(pow5(viewAttenuation));

边缘光颜色控制#

阳光颜色混色#

皮肤只混合灰度，而非皮肤混合颜色

1
 //阳光染色
2
float3 sunColor = select(materialId,
3
    _UISunColor1,
4
    _UISunColor2,
5
    _UISunColor3,
6
    _UISunColor4,
7
    _UISunColor5
8
);
9
//皮肤部分只混和灰度，非皮肤混合阳光颜色
10
float sunLuminance = Luminance(sunColor);
11
sunColor = isSkin ? sunColor : sunLuminance.xxx;

这里对阳光强度控制，如果亮度为1，效果大概就是缩放大概1/2.1倍，这里是对暗处提亮而亮的地方进行压制防止过曝

1
//获取缩放系数，1~平滑增大
2
float3 sunColorScaled = pow2(pow4(sunColor));
3
sunColorScaled /= max(1e-5, dot(sunColorScaled, 0.7));
4
//缩放控制
5
sunColor = AverageColor(sunColor) * sunColorScaled;

边缘光混合漫反射#

不使用边缘光的地方衰减使用Albedo

1
//投影部分为阳光颜色
2
sunColor = lerp(albedo, sunColor, shadowAttenuation);
3
//背光方向中心保持Albedo颜色
4
sunColor = lerp(albedo, sunColor, edgeAttenuation);

边缘光使用提亮过后的漫反射颜色#

1
float3 rimDiffuse = pow(max(1e-5, pbrDiffuseColor), 0.2);
2
rimDiffuse = normalize(rimDiffuse);

平均边缘光的强度#

这里对边缘光的漫反射强度做处理，大概是平均边缘光的强度，漫反射强度越高，边缘光减弱

1
//平均漫反射和边缘光强度
2
float diffuseBrightness = AverageColor(pbrDiffuseColor);
3
diffuseBrightness = (1 - 0.2 * pow2(diffuseBrightness)) * 0.1;
4
rimDiffuse *= diffuseBrightness;

曲线大致如下

边缘光镜面反射混合#

边缘光的镜面反射直接使用PBR镜面反射，使用金属度划分插值边缘光漫反射和镜面反射程度

1
float3 rimSpecular = pbrSpecularColor;
2
float3 rimColor = lerp(rimDiffuse, rimSpecular, metallic);

整体控制强度，然后乘上上面计算的衰减参数和光源颜色就得到边缘光了

1
rimColor *= 48;
2
rimColor *= fresnelAttenuation * verticalAttenuation * viewAttenuation * lightAttenuation * distanceAttenuation * sunColor;

边缘光染色和强度控制#

对边缘光进行染色。最后对边缘光进行强度控制，效果也是平滑提亮

1
float3 glowColor = select(materialId,
2
    _RimGlowLightColor1,
3
    _RimGlowLightColor2,
4
    _RimGlowLightColor3,
5
    _RimGlowLightColor4,
6
    _RimGlowLightColor5
7
);
8

9
rimColor *= glowColor;
10

11

12
//1以上的亮度更平缓的增亮
13
float3 rimColorBrightness = AverageColor(rimColor);
14
rimColorBrightness = pow2(rimColorBrightness);
15
rimColorBrightness = 1 + 0.5 * rimColorBrightness;
16
rimColor *= rimColorBrightness;
17

18
rimGlowColor = rimColor;

曲线大概如下

屏幕空间边缘光#

这里添加了屏幕空间的边缘光，和计算投影是一个原理，采样偏移的深度图与原深度图进行相减。计算最后就是乘上一个强度系数控制

1
//屏幕空间边缘光
2
float screenSpaceRim = 1.0;
3
#if _SCREEN_SPACE_RIM
4
{
5
    float linearEyeDepth = input.positionCS.w;
6
    float3 normalVS = TransformWorldToViewDir(normalWS);
7
    float2 UVOffset = float2(normalize(normalVS.xy)) * _ScreenSpaceRimWidth / linearEyeDepth;
8
    int2 texPos = input.positionCS.xy + UVOffset;
9
    texPos = min(max(0, texPos), _ScaledScreenParams.xy - 1);
10
    float offsetSceneDepth = LoadSceneDepth(texPos);
11
    float offsetSceneLinearEyeDepth = LinearEyeDepth(offsetSceneDepth, _ZBufferParams);
12
    screenSpaceRim = saturate((offsetSceneLinearEyeDepth - (linearEyeDepth + _ScreenSpaceRimThreshold)) * 10 / _ScreenSpaceRimFadeout);
13

14
    screenSpaceRim *= _ScreenSpaceRimBrightness;
15
}
16
#endif

最后混合输出

边缘光效果#

边缘光效果出来啦！现在还有最后一步就是目透效果的实现啦

眼睛处理#

眼部参数追加#

眼睛需要进行半透明处理以及透过头发需要进行蒙版测试所以添加相关参数

1
[Enum(UnityEngine.Rendering.BlendMode)]_BlendSrc("SrcAlpha混合源乘子", int) = 1
2
[Enum(UnityEngine.Rendering.BlendMode)]_BlendDst("DstAlpha混合目标乘子", int) = 0
3
[Enum(UnityEngine.Rendering.BlendOp)]_BlendOp("Alpha混合算符", int) = 0
4

5
_StencilRef("蒙版值", int) = 0
6
[Enum(UnityEngine.Rendering.CompareFunction)]_StencilComp("蒙版判断条件", int) = 0
7
[Enum(UnityEngine.Rendering.StencilOp)]_StencilPassOp("蒙版测试通过", int) = 0
8
[Enum(UnityEngine.Rendering.StencilOp)]_StencilFailOp("蒙版测试失败", int) = 0
9
[Enum(UnityEngine.Rendering.StencilOp)]_StencilZFailOp("深度Z测试失败", int) = 0
10

11
//眼睛重绘
12
[Header(EyeReDrawPassOption)]
13
[Toggle(_SRP_DEFAULT_PASS)] _SRP_DEFAULT_PASS(" SRP Default Pass", int) = 0
14
[Enum(UnityEngine.Rendering.BlendMode)]_SRPBlendSrc("SRPSrcAlpha混合源乘子", int) = 1
15
[Enum(UnityEngine.Rendering.BlendMode)]_SRPBlendDst("SRPDstAlpha混合目标乘子", int) = 0
16
[Enum(UnityEngine.Rendering.BlendOp)]_SRPBlendOp("SRPAlpha混合算符", int) = 0
17
_SRPStencilRef("SRP蒙版值", int) = 0
18
[Enum(UnityEngine.Rendering.CompareFunction)]_SRPStencilComp("SRP蒙版判断条件", int) = 0
19
[Enum(UnityEngine.Rendering.StencilOp)]_SRPStencilPassOp("SRP蒙版测试通过", int) = 0
20
[Enum(UnityEngine.Rendering.StencilOp)]_SRPStencilFailOp("SRP蒙版测试失败", int) = 0
21
[Enum(UnityEngine.Rendering.StencilOp)]_SRPStencilZFailOp("SRP深度Z测试失败", int) = 0

参数申明跳过，相信你们自己能写，写不出来想想是不是是自己的问题

对应在基础Pass里面追加#

1
//蒙版测试
2
Stencil {
3
    Ref [_StencilRef]
4
    Comp [_StencilComp]
5
    Pass [_StencilPassOp]
6
    Fail [_StencilFailOp]
7
    ZFail [_StencilZFailOp]
8
}

透明度调整#

眼影的基础染色给个纯黑在给一些透明度
就是把alpha值线调到0.5左右

调整混合模式#

这里设置为SrcAlpha和 OneMinusSrcAlpha就好了，默认是One和Zero，同样的调整内高光
当当效果出来了

蒙版测试原理#

这里有些绕，既要考虑蒙版测试和深度测试还得考虑渲染顺序进行的优先级是先渲染顺序然后蒙版测试最后深度测试

渲染队列#

Unity使用渲染队列调整渲染顺序，数字越大渲染顺序越靠后

蒙版测试和深度测试#

举一个例子，其他情况可以自己去推。给出两个物体AB，分别设置一个蒙版值，渲染顺序为A->B，前后关系是A在B前方。这里注意默认蒙版值基数为0，判断条件都是以这个基数判断 A设置蒙版值为2，判断条件为大于等于，操作为“替换Replace”。 B物体蒙版值为3，判断条件为大于等于，操作为“替换Replace”。

首先考虑渲染顺序是A->B，所以A先计算 A首先进行模板测试，判断条件是大于等于2，蒙版值为2>基数0，模版测试通过，因为操作为“替换Replace”，所以在A渲染时蒙版值基数被替换为2。然后是深度测试，因为率先渲染，所以无遮挡，不需要剔除，深度测试通过

接下来是B进行渲染先模板测试，判断条件是大于等于3，蒙版值为3>基数2，模版测试通过，因为操作为“替换Replace”，所以在B渲染时蒙版值基数被替换为3，重叠部分也变成了3，所以重叠部分应该为B的颜色。然后是深度测试，因为A先渲染，所以有遮挡关系，那么重叠部分B的颜色就会被剔除，最终效果上就为黑色

最后值得一提的是如果遮挡物是半透明，那么深度剔除就不会生效的#

排序设置#

渲染队列设置#

基于上面说的原理，先对模型进行渲染排序，只需要对眼睛头发排序就行了先对眼睛部分排序

眼睛肯定是最先渲染所以给个2001

其次就是高光了，内高光和外高光都给个2002

最后就是眼影了，给2003

头发就在后一点，2004吧

蒙版设置#

需要眼睛在头发前面，那么先从整体来看，默认蒙版基数是0，头发是最后渲染。因为眼睛部分先渲染所以会替换蒙版值，那么只要保证头发的蒙版值比眼部的小就行了。这里直接让头发部分按照基数0来设置，而眼睛就大于这个值就行了头发，判断条件为大于等于，因为默认基数为0，这里蒙版值给的0，可以保证默认通过蒙版测试

眼睛部分虽然可以都设为同一的蒙版值，但最好还是区分一下，从里到外递增，判断条件都是大于等于眼睛 !

内高光和外高光

眼影

现在就有了透过头发的效果了，但是没有颜色，原因和上面说的一样，深度剔除给剔除了
当当效果出来了，但是想要变成下面的效果还有一个关键的一步那就是眼睛重绘，我们继续往下讲

重新绘制眼睛#

追加Pass#

为了解决穿过头发没有颜色的问题，这里需要进行重新绘制，就是在调一遍Pass 这里新增了一个无光照Pass

这里相当于在跑一遍之前的BasePass，而如果不开启就为空，什么也不做

1
{
2
    Name"EyeReDrawPass"
3

4
    Tags{
5
        "LightMode" = "SRPDefaultUnlit"
6
    }
7

8
    ZWrite [_ZWrite]
9
    Cull [_Cull]
10
    BlendOp [_SRPBlendOp]               //混合算符
11
    Blend [_SRPBlendSrc] [_SRPBlendDst]    //混合乘子
12

13
    //蒙版测试
14
    Stencil {
15
        Ref [_SRPStencilRef]
16
        Comp [_SRPStencilComp]
17
        Pass [_SRPStencilPassOp]
18
        Fail [_SRPStencilFailOp]
19
        ZFail [_SRPStencilZFailOp]
20
    }
21

22
    // HLSL程序段
23

24
    HLSLPROGRAM
25
    #pragma vertex MainVS2
26
    #pragma fragment MainPS2
27
    #pragma multi_compile_fog
28

29

30
    #if _SRP_DEFAULT_PASS
31
    UniversalVaryings MainVS2(UniversalAttributes input){return MainVS(input);}
32
    float4 MainPS2(UniversalVaryings input, bool isFrontFace : SV_IsFrontFace) : SV_Target{return MainPS(input, isFrontFace);}
33
    #else
34
    void MainVS2(){}
35
    void MainPS2(){}
36
    #endif
37

38
    ENDHLSL
39

40
}

参数调整#

头发贴图中有透明度信息的，这里可以处理眼睛透过头发的强度

这里进行透明度设置，以及蒙版值，之前设置的眼睛部分最小的蒙版值是眼睛的也就是2，所以这里设置为小于2的值就好了

最终成品效果#

最后#

感谢你能坚持看到这里，感谢你看我花了四天左右时间从效果实现到实现过程文档的完成，感谢你看完一整篇旷世之史，谢谢！！

1.开始前工作#

贴图准备#

关闭贴图压缩#

面部光照图去SRGB#

各类遮罩图也需要去SRGB#

2.Shader处理 （BaseShader部分）#

添加KeywordEnum对各个部分进行区分，具体参数请看下面代码#

定义Keyword 宏#

定义参数变量#

定义输入结构体#

定义顶点输出结构体#

定义主顶点着色器函数#

定义主片元着色器函数#

Pass部分#

3.Shader处理 （OutlineShader部分）#

参数增加#

Pass内声明#

这里获取了模型第二套UV,里面是平滑法线数据#

描边缩放函数（使用Colin的算法代码）#

法线外扩#

八面体映射读取函数#

这里需要裁剪空间下描边顶点Z轴方向偏移，代码来自于Colin#

描边顶点着色器函数#

描边片元着色器函数#

Shader构建#

着色阶段#

获取ShadowCoord和光线向量#

计算光线衰减（兰伯特）#

法线解析和漫反射偏移#

TBN矩阵参数计算#

法线翻转值#

初始化变量#

身体部分，进行法线解析和漫反射偏移处理#

混合输出测试看效果#

最后处理一下背面法线#

光照分级#

添加分级参数#

定义光滑系数和锐利系数#

分级操作#

分区公式理解#

Offset参数设计#

attenuation的范围是-1.5~1.5#

缩放因子的选择#

各个分量预览#

albedoShadowFade最深阴影#

albedoShadow较浅阴影#

albedoShallowFade中间过渡较深阴影#

albedoShallow中间过渡较浅阴影#

albedoSSS次表面部分#

SSS和albedoShallow一起输出#

albedoFront 明亮区域，接近没有衰减#

albedoForward 最强反射部分,没有衰减#

能量守恒#

分层着色#

材质ID初始化#

读取贴图数据获得材质ID#

初始化颜色变量#

参数追加#

新增函数#

平均颜色亮度与归一化#

限制灯光颜色亮度#

三值比较函数宏模版#

各分段颜色设置#

深色阴影#

浅色阴影#

过渡部分#

混合颜色#

查看混合效果#

投影追加#

使用FrameDebug查看是否正常启用#

追加DepthOnlyPass#

参数追加#

投影追加#

分段解析#

投影效果#

将投影追加到光照层级中#

面部阴影SDF重构#

添加空组件进行定位#

创建C#脚本#

追加参数#

2.Shader处理（BaseShader部分）#

3.Shader处理（OutlineShader部分）#