unity-shader-example-cartoonCharacter

buildin效果图

urp效果图

CartoonCharacter.shader

CartoonCharacter.shader

Shader "HHF/Example/CartoonCharacter"
{
    Properties
    {
        [Header(Base)]
        _BaseColor("Base Color",color) = (1,1,1,1)
        _BaseMap("BaseMap", 2D) = "white" {}

        [Header(Outline)]
        _OutlineColor("OutlineColor",color) = (0,0,0,0)
        _OutlineWidth("OutlineWidth",range(0,10)) = 0.1
        _UnifomWidth("UniformWidth",range(0, 1)) = 0.5

        [Header(Color)]
        [IntRange]_Step("Step",range(1,5)) = 2
        [NoScaleOffset]_ShadowRampMap("ShadowRampMap",2D) = "white"{}
        [NoScaleOffset]_ShadowMap("ShadowMap",2D) = "black"{}

        [Header(Specular)]
        _Specular("Strength(X) Gloss(Y) Soft(Z) Alpha(W)",vector) = (1,1,0,0)
        _SpecualrMaskMap("SpecularMask(R)",2D) = "black"{}

        [Header(Fresnel)]
        _FresnelColor("FresnelColor",color) = (1,1,1,1)
        _Fresnel("Strength(X) Gloss(Y) Soft(Z)",vector) = (1,1,0,0)
    }
    
    SubShader
    {
        Tags { "Queue"="Geometry" "RenderType" = "Opaque" "IgnoreProjector" = "True" "RenderPipeline" = "UniversalPipeline" }

        Pass
        {
            Tags {"LightMode" = "UniversalForward"}
            HLSLPROGRAM
            // Required to compile gles 2.0 with standard srp library
            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS
            #pragma multi_compile _ _SHADOWS_SOFT
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal : NORMAL;
            };

            struct v2f
            {
                float4 positionCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normalWS : TEXCOORD1;
                half3 viewWS : TEXCOORD2;
                float4 shadowCoord : TEXCOORD3;
            };

            CBUFFER_START(UnityPerMaterial)
            half4 _BaseColor;
            float4 _BaseMap_ST;
            half _Step;
            half4 _Specular,_Fresnel,_FresnelColor;
            CBUFFER_END
            TEXTURE2D (_BaseMap);SAMPLER(sampler_BaseMap);
            TEXTURE2D (_ShadowRampMap);SAMPLER(sampler_ShadowRampMap);
            TEXTURE2D (_ShadowMap);
            TEXTURE2D (_SpecualrMaskMap);

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                o.positionCS = TransformObjectToHClip(v.vertex.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                o.normalWS = TransformObjectToWorldNormal(v.normal.xyz);
                float3 positionWS = TransformObjectToWorld(v.vertex.xyz);
                o.viewWS = normalize(_WorldSpaceCameraPos - positionWS);
                o.shadowCoord = TransformWorldToShadowCoord(positionWS);
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 c;
                half4 baseMap = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, i.uv);
                c = baseMap * _BaseColor;

                // 利用lambert光照求出模型表面0~1的明暗面
                // 然后再利用相应的算法做出硬边明暗面
                Light mainLight = GetMainLight(i.shadowCoord);
                // return mainLight.shadowAttenuation;
                half3 L = mainLight.direction;
                half3 N = normalize(i.normalWS);
                half3 V = normalize(i.viewWS);
                half NdotL = dot(N,L)*0.5+0.5;  // 从[-1,1]变换到[0,1]

                // 明暗色阶的漫反射
                // 利用公式实现多阶分色
                // half4 level = ceil(NdotL * _Step)/_Step; 
                // 利用采样渐变图实现更灵活的明暗上色方式
                half4 shadowRampMap = SAMPLE_TEXTURE2D(_ShadowRampMap, sampler_ShadowRampMap, NdotL);
                half4 level = shadowRampMap;
                half4 shadowMap = SAMPLE_TEXTURE2D(_ShadowMap, sampler_BaseMap, i.uv);
                level *= shadowMap.a * 0.5 + 0.5; // 将美术给的阴影图从(0~1)变换到(0.5~1)，这样阴影不会太暗
                level *= mainLight.shadowAttenuation;
                c = lerp(c * shadowMap,c,level);

                // 高光
                half3 H = normalize(L+V);
                half NdotH = saturate(dot(N,H));
                half4 specular = _Specular.x * pow(NdotH,_Specular.y);
                specular = smoothstep(0.5, 0.5 + _Specular.z, specular);
                half4 specularMaskMap = SAMPLE_TEXTURE2D(_SpecualrMaskMap, sampler_BaseMap, i.uv);
                specular *= specularMaskMap;
                specular *= _Specular.w;
                c += specular;

                // 外发光
                half NdotV = 1-saturate(dot(N,V));
                half4 fresnel = _Fresnel.x * pow(NdotV, _Fresnel.y);
                fresnel = smoothstep(0.5, 0.5+_Fresnel.z, fresnel);
                fresnel *= _FresnelColor;
                c += fresnel;
                // return fresnel;

                return c;
            }
            
            ENDHLSL
        }

        Pass
        {
            Tags {"LightMode" = "SRPDefaultUnlit"}
            Cull Front
            HLSLPROGRAM
            // Required to compile gles 2.0 with standard srp library
            #pragma prefer_hlslcc gles
            #pragma exclude_renderers d3d11_9x
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 tangent : TANGENT;      // 为了不影响法线，处理描边断裂，使用切线存储的是平均化后的法线(可以使用houdini之类的软件对模型进行处理将平均化后的法线存储到切线)
                half4 color : COLOR;
                float uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 positionCS : SV_POSITION;
                half4 color : TEXCOORD0;
                float2 uv : TEXCOORD1;
            };

            CBUFFER_START(UnityPerMaterial)
            half4 _OutlineColor;
            half _OutlineWidth;
            half _UnifomWidth;
            CBUFFER_END

            TEXTURE2D (_ShadowMap);SAMPLER(sampler_ShadowMap);

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                // 描边的宽度本身不会变化，只是由于我们离的远了，所以感觉是变细了
                // 因此只需要对描边宽度乘上一个越来越大的值做为弥补即可
                // 求出相机与顶点间的距离
                float3 positionWS = TransformObjectToWorld(v.vertex.xyz);
                float distance = length(_WorldSpaceCameraPos - positionWS);
                // distance = 1;正常近大远小的表现
                // distance = distance;远近一样大小的表现
                // distance = lerp(1,distance,_UnifomWidth);
                distance = pow(distance,_UnifomWidth);

                float3 positionOS = v.vertex.xyz;
                float3 width = normalize(v.tangent) * _OutlineWidth * 0.01;
                width *= distance;
                width *= v.color.a;
                positionOS += width;
                o.positionCS = TransformObjectToHClip(positionOS);
                o.color = v.color;
                o.uv = v.uv;
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 shadowMap = SAMPLE_TEXTURE2D(_ShadowMap, sampler_ShadowMap, i.uv);
                return shadowMap * _OutlineColor;
            }
            
            ENDHLSL
        }

        Pass
        {
            Name "ShadowCaster"
            Tags{"LightMode" = "ShadowCaster"}

            ZWrite On
            ZTest LEqual
            ColorMask 0
            Cull[_Cull]

            HLSLPROGRAM
            #pragma exclude_renderers gles gles3 glcore
            #pragma target 4.5

            // -------------------------------------
            // Material Keywords
            #pragma shader_feature_local_fragment _ALPHATEST_ON
            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA

            //--------------------------------------
            // GPU Instancing
            #pragma multi_compile_instancing
            #pragma multi_compile _ DOTS_INSTANCING_ON

            #pragma vertex ShadowPassVertex
            #pragma fragment ShadowPassFragment

            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
            #include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
            ENDHLSL
        }
    }
    
    SubShader
    {
        Tags { "Queue"="Geometry"  }
    
        Pass
        {
            Cull Front
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 tangent : TANGENT;      // 为了不影响法线，处理描边断裂，使用切线存储的是平均化后的法线(可以使用houdini之类的软件对模型进行处理将平均化后的法线存储到切线)
                half4 color : COLOR;
                float uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 positionCS : SV_POSITION;
                half4 color : TEXCOORD0;
                float2 uv : TEXCOORD1;
            };

            half4 _OutlineColor;
            half _OutlineWidth;
            half _UnifomWidth;
            sampler2D _ShadowMap;

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                // 描边的宽度本身不会变化，只是由于我们离的远了，所以感觉是变细了
                // 因此只需要对描边宽度乘上一个越来越大的值做为弥补即可
                // 求出相机与顶点间的距离
                float3 positionWS = mul(UNITY_MATRIX_M, v.vertex);
                float distance = length(_WorldSpaceCameraPos - positionWS);
                // distance = 1;正常近大远小的表现
                // distance = distance;远近一样大小的表现
                // distance = lerp(1,distance,_UnifomWidth);
                distance = pow(distance,_UnifomWidth);

                float3 positionOS = v.vertex.xyz;
                float3 width = normalize(v.tangent) * _OutlineWidth * 0.01;
                width *= distance;
                width *= v.color.a;
                positionOS += width;
                o.positionCS = UnityObjectToClipPos(positionOS);
                o.color = v.color;
                o.uv = v.uv;
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 shadowMap = tex2D(_ShadowMap, i.uv);
                return shadowMap * _OutlineColor;
            }

            ENDCG
        }
        
        Pass
        {
//            Tags { "LightMode"="ForwardBase" }
            
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_fwdbase
            #include "UnityCG.cginc"
            #include "Lighting.cginc"
            #include "AutoLight.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
                float3 normal : NORMAL;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float2 uv : TEXCOORD0;
                half3 normalWS : TEXCOORD1;
                half3 viewWS : TEXCOORD2;
                half3 positionWS : TEXCOORD3;

                UNITY_SHADOW_COORDS(4)
            };

            half4 _BaseColor;
            sampler2D _BaseMap;float4 _BaseMap_ST;
            sampler2D _ShadowRampMap;
            sampler2D _ShadowMap;
            sampler2D _SpecualrMaskMap;
            half _Step;
            half4 _Specular,_Fresnel,_FresnelColor;

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;

                o.pos = UnityObjectToClipPos(v.vertex.xyz);
                o.uv = TRANSFORM_TEX(v.uv, _BaseMap);
                o.normalWS = UnityObjectToWorldNormal(v.normal.xyz);
                o.positionWS = mul(UNITY_MATRIX_M, v.vertex);
                o.viewWS = normalize(_WorldSpaceCameraPos - o.positionWS);
                
                TRANSFER_SHADOW(o)
                return o;
            }

            half4 frag(v2f i) : SV_Target
            {
                half4 c;
                half4 baseMap = tex2D(_BaseMap, i.uv);
                c = baseMap * _BaseColor;

                UNITY_LIGHT_ATTENUATION(atten, i, i.positionWS)
                
                // 利用lambert光照求出模型表面0~1的明暗面
                // 然后再利用相应的算法做出硬边明暗面
                half3 L = _WorldSpaceLightPos0;
                half3 N = normalize(i.normalWS);
                half3 V = normalize(i.viewWS);
                half NdotL = dot(N,L)*0.5+0.5;  // 从[-1,1]变换到[0,1]

                // 明暗色阶的漫反射
                // 利用公式实现多阶分色
                // half4 level = ceil(NdotL * _Step)/_Step; 
                // 利用采样渐变图实现更灵活的明暗上色方式
                half4 shadowRampMap = tex2D(_ShadowRampMap, NdotL);
                half4 level = shadowRampMap;
                half4 shadowMap = tex2D(_ShadowMap, i.uv);
                level *= shadowMap.a * 0.5 + 0.5; // 将美术给的阴影图从(0~1)变换到(0.5~1)，这样阴影不会太暗
                level *= atten;
                c = lerp(c * shadowMap,c,level);

                // 高光
                half3 H = normalize(L+V);
                half NdotH = saturate(dot(N,H));
                half4 specular = _Specular.x * pow(NdotH,_Specular.y);
                specular = smoothstep(0.5, 0.5 + _Specular.z, specular);
                half4 specularMaskMap = tex2D(_SpecualrMaskMap, i.uv);
                specular *= specularMaskMap;
                specular *= _Specular.w;
                c += specular;

                // 外发光
                half NdotV = 1-saturate(dot(N,V));
                half4 fresnel = _Fresnel.x * pow(NdotV, _Fresnel.y);
                fresnel = smoothstep(0.5, 0.5+_Fresnel.z, fresnel);
                fresnel *= _FresnelColor;
                c += fresnel;
                // return fresnel;

                return c;
            }

            ENDCG
        }
        
        pass
        {
            Tags {"LightMode" = "ShadowCaster"}
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #pragma multi_compile_shadowcaster
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex:POSITION;
                half3 normal:NORMAL;
            };

            struct v2f
            {
                V2F_SHADOW_CASTER;
            };

            v2f vert(appdata v)
            {
                v2f o = (v2f)0;
                TRANSFER_SHADOW_CASTER_NORMALOFFSET(o)
                return o;
            }

            fixed4 frag(v2f i):SV_TARGET
            {
                SHADOW_CASTER_FRAGMENT(i)
            }
            ENDCG
        }
    }    
}