《Unity Shader 入门精要》从Bulit-in 到URP （HLSL）Chapter14.1-卡通风格的衬着

lingli125

前言：

已经进入“高级篇”啦，但愿大师多多撑持，多多存眷，这将对我发生非常愉悦的正反馈~

“《Unity Shader 入门精要》从Bulit-in 到URP”是一个辅佐Unity Shader学习者以冯乐乐女神《Unity Shader 入门精要》为基础学习用HLSL语言编写URP着色器的案例教学系列。

作者自学能力有限，抛砖引玉，如有建议和问题请各位大佬和同仁交流斧正。

Bulit-in版：

1. // Upgrade NOTE: replaced '_Object2World' with 'unity_ObjectToWorld'
2. // Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
4. Shader ”Unity Shaders Book/Chapter 14/Toon Shading” {
5.         Properties {
6.                 _Color (”Color Tint”, Color) = (1, 1, 1, 1)
7.                 _MainTex (”Main Tex”, 2D) = ”white” {}
8.                 _Ramp (”Ramp Texture”, 2D) = ”white” {}
9.                 _Outline (”Outline”, Range(0, 1)) = 0.1
10.                 _OutlineColor (”Outline Color”, Color) = (0, 0, 0, 1)
11.                 _Specular (”Specular”, Color) = (1, 1, 1, 1)
12.                 _SpecularScale (”Specular Scale”, Range(0, 0.1)) = 0.01
13.         }
14.     SubShader {
15.                 Tags { ”RenderType”=”Opaque” ”Queue”=”Geometry”}
16.                
17.                 Pass {
18.                         NAME ”OUTLINE”
19.                        
20.                         Cull Front
21.                        
22.                         CGPROGRAM
23.                        
24.                         #pragma vertex vert
25.                         #pragma fragment frag
26.                        
27.                         #include ”UnityCG.cginc”
28.                        
29.                         float _Outline;
30.                         fixed4 _OutlineColor;
31.                        
32.                         struct a2v {
33.                                 float4 vertex : POSITION;
34.                                 float3 normal : NORMAL;
35.                         };
36.                        
37.                         struct v2f {
38.                             float4 pos : SV_POSITION;
39.                         };
40.                        
41.                         v2f vert (a2v v) {
42.                                 v2f o;
43.                                
44.                                 float4 pos = mul(UNITY_MATRIX_MV, v.vertex);
45.                                 float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
46.                                 normal.z = -0.5;
47.                                 pos = pos + float4(normalize(normal), 0) * _Outline;
48.                                 o.pos = mul(UNITY_MATRIX_P, pos);
49.                                
50.                                 return o;
51.                         }
52.                        
53.                         float4 frag(v2f i) : SV_Target {
54.                                 return float4(_OutlineColor.rgb, 1);               
55.                         }
56.                        
57.                         ENDCG
58.                 }
59.                
60.                 Pass {
61.                         Tags { ”LightMode”=”ForwardBase” }
62.                        
63.                         Cull Back
64.                
65.                         CGPROGRAM
66.                
67.                         #pragma vertex vert
68.                         #pragma fragment frag
69.                        
70.                         #pragma multi_compile_fwdbase
71.                
72.                         #include ”UnityCG.cginc”
73.                         #include ”Lighting.cginc”
74.                         #include ”AutoLight.cginc”
75.                         #include ”UnityShaderVariables.cginc”
76.                        
77.                         fixed4 _Color;
78.                         sampler2D _MainTex;
79.                         float4 _MainTex_ST;
80.                         sampler2D _Ramp;
81.                         fixed4 _Specular;
82.                         fixed _SpecularScale;
83.                
84.                         struct a2v {
85.                                 float4 vertex : POSITION;
86.                                 float3 normal : NORMAL;
87.                                 float4 texcoord : TEXCOORD0;
88.                                 float4 tangent : TANGENT;
89.                         };
90.                
91.                         struct v2f {
92.                                 float4 pos : POSITION;
93.                                 float2 uv : TEXCOORD0;
94.                                 float3 worldNormal : TEXCOORD1;
95.                                 float3 worldPos : TEXCOORD2;
96.                                 SHADOW_COORDS(3)
97.                         };
98.                        
99.                         v2f vert (a2v v) {
100.                                 v2f o;
101.                                
102.                                 o.pos = UnityObjectToClipPos( v.vertex);
103.                                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex);
104.                                 o.worldNormal  = UnityObjectToWorldNormal(v.normal);
105.                                 o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
106.                                
107.                                 TRANSFER_SHADOW(o);
108.                                
109.                                 return o;
110.                         }
111.                        
112.                         float4 frag(v2f i) : SV_Target {
113.                                 fixed3 worldNormal = normalize(i.worldNormal);
114.                                 fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
115.                                 fixed3 worldViewDir = normalize(UnityWorldSpaceViewDir(i.worldPos));
116.                                 fixed3 worldHalfDir = normalize(worldLightDir + worldViewDir);
117.                                
118.                                 fixed4 c = tex2D (_MainTex, i.uv);
119.                                 fixed3 albedo = c.rgb * _Color.rgb;
120.                                
121.                                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
122.                                
123.                                 UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
124.                                
125.                                 fixed diff =  dot(worldNormal, worldLightDir);
126.                                 diff = (diff * 0.5 + 0.5) * atten;
127.                                
128.                                 fixed3 diffuse = _LightColor0.rgb * albedo * tex2D(_Ramp, float2(diff, diff)).rgb;
129.                                
130.                                 fixed spec = dot(worldNormal, worldHalfDir);
131.                                 fixed w = fwidth(spec) * 2.0;
132.                                 fixed3 specular = _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
133.                                
134.                                 return fixed4(ambient + diffuse + specular, 1.0);
135.                         }
136.                
137.                         ENDCG
138.                 }
139.         }
140.         FallBack ”Diffuse”
141. }

复制代码

URP版：

Unity项目源码：

1. Shader ”Unlit/Chapter14-ToonShading”
2. {
3.     Properties {
4.                 _Color (”Color Tint”, Color) = (1, 1, 1, 1)
5.                 _MainTex (”Main Tex”, 2D) = ”white” {}
6.                 _Ramp (”Ramp Texture”, 2D) = ”white” {}
7.                 _Outline (”Outline”, Range(0, 1)) = 0.1
8.                 _OutlineColor (”Outline Color”, Color) = (0, 0, 0, 1)
9.                 _Specular (”Specular”, Color) = (1, 1, 1, 1)
10.                 _SpecularScale (”Specular Scale”, Range(0, 0.1)) = 0.01
11.         }
12.     SubShader
13.     {
14.         Tags {”RenderPipeline” = ”UniversalPipeline” ”RenderType”=”Opaque” ”Queue”=”Geometry”}
16.         HLSLINCLUDE
17.         #include ”Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl”
18.                 #include ”Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl”
20.         CBUFFER_START(UnityPerMaterial)
21.             float _Outline;
22.                         half4 _OutlineColor;
23.             half4 _Color;
24.                         float4 _MainTex_ST;
25.                         half4 _Specular;
26.                         half _SpecularScale;
27.         CBUFFER_END
29.         ENDHLSL
31.         UsePass ”Universal Render Pipeline/Lit/ShadowCaster”
32.                
33.                 Pass {
34.                         NAME ”OUTLINE”
35.                        
36.                         Cull Front
37.                        
38.                         HLSLPROGRAM
39.                        
40.                         #pragma vertex vert
41.                         #pragma fragment frag
42.                        
43.                         struct a2v {
44.                                 float4 vertex : POSITION;
45.                                 float3 normal : NORMAL;
46.                         };
47.                        
48.                         struct v2f {
49.                             float4 pos : SV_POSITION;
50.                         };
51.                        
52.                         v2f vert (a2v v) {
53.                                 v2f o;
54.                                
55.                                 float4 pos = mul(UNITY_MATRIX_MV, v.vertex);
56.                                 float3 normal = mul((float3x3)UNITY_MATRIX_IT_MV, v.normal);  
57.                 //把顶点法线转换到view空间
58.                                 normal.z = -0.5;
59.                                 pos = pos + float4(normalize(normal), 0) * _Outline;
60.                 //在view空间完成顶点扩张
61.                                 o.pos = mul(UNITY_MATRIX_P, pos);
62.                                
63.                                 return o;
64.                         }
65.                        
66.                         float4 frag(v2f i) : SV_Target {
67.                                 return float4(_OutlineColor.rgb, 1);               
68.                         }
69.                        
70.                         ENDHLSL
71.                 }
72.                
73.                 Pass {
74.                         Tags { ”LightMode”=”UniversalForward” }
75.                        
76.                         Cull Back
77.                
78.                         HLSLPROGRAM
79.                
80.                         #pragma vertex vert
81.                         #pragma fragment frag
83.             TEXTURE2D(_MainTex);       SAMPLER(sampler_MainTex);
84.             TEXTURE2D(_Ramp);       SAMPLER(sampler_Ramp);
85.                
86.                         struct a2v {
87.                                 float4 vertex : POSITION;
88.                                 float3 normal : NORMAL;
89.                                 float4 texcoord : TEXCOORD0;
90.                                 //float4 tangent : TANGENT;
91.                         };
92.                
93.                         struct v2f {
94.                                 float4 pos : POSITION;
95.                                 float2 uv : TEXCOORD0;
96.                                 float3 worldNormal : TEXCOORD1;
97.                                 float3 worldPos : TEXCOORD2;
98.                         };
99.                        
100.                         v2f vert (a2v v) {
101.                                 v2f o;
102.                                
103.                 VertexPositionInputs positionInputs = GetVertexPositionInputs(v.vertex.xyz);
104.                                 //o.pos = TransformObjectToHClip( v.vertex);
105.                 o.pos = positionInputs.positionCS;
106.                                 o.uv = TRANSFORM_TEX (v.texcoord, _MainTex);
107.                                 o.worldNormal  = TransformObjectToWorldNormal(v.normal);
108.                                 //o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
109.                                 o.worldPos = positionInputs.positionWS;
110.                                
111.                                 return o;
112.                         }
113.                        
114.                         float4 frag(v2f i) : SV_Target {
115.                                 Light mainLight = GetMainLight();
116.                                 //获取光源信息的函数
117.                 half3 worldLightDir = normalize(TransformObjectToWorldDir(mainLight.direction));
118.                 //half3 worldNormal = normalize(i.worldNormal);
119.                                 //half3 worldLightDir = normalize(UnityWorldSpaceLightDir(i.worldPos));
120.                                 half3 worldViewDir = normalize(_WorldSpaceCameraPos.xyz - i.worldPos);
121.                                 half3 worldHalfDir = normalize(worldLightDir + worldViewDir);
122.                                
123.                                 half4 c = SAMPLE_TEXTURE2D (_MainTex, sampler_MainTex, i.uv);
124.                                 half3 albedo = c.rgb * _Color.rgb;
125.                                
126.                                 half3 ambient = half3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) * albedo;
127.                 half atten = mainLight.distanceAttenuation;
128.                                
129.                                 //UNITY_LIGHT_ATTENUATION(atten, i, i.worldPos);
130.                                
131.                                 half diff =  dot(i.worldNormal, worldLightDir);
132.                                 diff = (diff * 0.5 + 0.5) * atten;
133.                                
134.                                 half3 diffuse = mainLight.color * albedo * SAMPLE_TEXTURE2D(_Ramp, sampler_Ramp, float2(diff, diff)).rgb;
135.                                
136.                                 half spec = dot(i.worldNormal, worldHalfDir);
137.                                 half w = fwidth(spec) * 2.0;
138.                 //此函数计算以下内容： abs (ddx (x) ) + abs (ddy (x) ),即相邻像素点该数值的变化度 。
139.                                 half3 specular = mainLight.color * _Specular.rgb * lerp(0, 1, smoothstep(-w, w, spec + _SpecularScale - 1)) * step(0.0001, _SpecularScale);
140.                                
141.                                 return half4(ambient + diffuse + specular, 1.0);
142.                         }
143.                
144.                         ENDHLSL
145.                 }
146.         }
147.         FallBack ”Packages/com.unity.render-pipelines.universal/FallbackError”
148. }

复制代码

效果图：




如有收获，请留下“存眷”和“附和”