内置管线

 1 Shader "Unity Shaders Book/Chapter 7/Single Texture" {
 2     Properties {
 3         _MainTex("MainTex", 2D) = "white"{}
 4         _Color("Color Tint", Color) = (1, 1, 1, 1)
 5         _Specular("Specular", Color) = (1, 1, 1, 1)
 6         _Gloss("Gloss", Range(10, 256)) = 20
 7         // _MainTex_ST 它不是属性
 8     }
 9  
10     SubShader {
11         Pass {
12             Tags {
13                 "LightMode"="ForwardBase"
14             }
15  
16             CGPROGRAM
17             #pragma vertex vert
18             #pragma fragment frag
19  
20             #include "UnityCG.cginc"
21             #include "Lighting.cginc"
22  
23             sampler2D _MainTex;
24             float4 _MainTex_ST;
25             fixed4 _Color;
26             fixed4 _Specular;
27             float _Gloss;
28  
29             struct a2v {
30                 float4 vertex : POSITION;
31                 float3 normal : NORMAL;
32                 float4 texcoord : TEXCOORD0;    // unity会将第一组纹理坐标存储到改变量中
33             };
34  
35             struct v2f {
36                 float4 pos : SV_POSITION;
37                 float3 worldNor : TEXCOORD0;
38                 float3 worldPos : TEXCOORD1;
39                 float2 uv : TEXCOORD2; // 疑惑，是不是float2类型？ 
40             };
41  
42             v2f vert(appdata_full data) {
43                 v2f v;
44                 v.pos = UnityObjectToClipPos(data.vertex);
45                 v.worldPos = mul(unity_ObjectToWorld, data.vertex);
46  
47                 // v.worldNor = mul(data.normal, unity_WorldToObject);
48                 v.worldNor = UnityObjectToWorldNormal(data.normal);
49  
50                 /*
51                     个人理解：
52                     texcoord的值是0-1
53                     是按照未缩放和未平移情况下计算的纹理坐标，因此才是0-1
54                     uv是 *缩放+平移 的结果，结果不一定再0-1之间
55                     tex2D按照uv在纹理上采样
56                 */
57                 // 方法等同
58                 // v.uv = data.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;
59                 v.uv = TRANSFORM_TEX(data.texcoord, _MainTex);
60  
61                 return v;
62             }
63  
64             fixed4 frag(v2f v) : SV_Target {
65                 fixed3 worldVetNormal = normalize(v.worldNor);
66                 // fixed3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
67                 fixed3 worldLightDir = normalize(UnityWorldSpaceLightDir(v.worldPos));
68  
69                 fixed3 albedo = tex2D(_MainTex, v.uv).rgb * _Color.rgb;    // 疑惑，采样结果的类型
70  
71                 // 环境光
72                 fixed3 ambient = UNITY_LIGHTMODEL_AMBIENT.xyz * albedo;
73  
74                 // 漫反射
75                 fixed3 diffuse = _LightColor0.rgb * albedo * saturate(dot(worldVetNormal, worldLightDir));
76  
77                 // 高光
78                 // fixed3 viewDir = normalize(_WorldSpaceCameraPos.xyz);
79                 fixed3 viewDir = normalize(UnityWorldSpaceViewDir(v.worldPos));
80                 fixed3 halfDir = normalize(viewDir + worldLightDir);
81                 fixed3 specular = _LightColor0.rgb * _Specular.rgb * pow(saturate(dot(halfDir, worldVetNormal)), _Gloss);
82  
83                 return fixed4(ambient + diffuse + specular, 1);
84             }
85  
86             ENDCG
87         }
88     }
89  
90     FallBack "Specular"
91 }

urp管线

 1 Shader "Unity Shaders Book/Chapter 7/Single Texture" {
 2     Properties {
 3         _MainTex("MainTex", 2D) = "white"{}
 4         _Color("Color Tint", Color) = (1, 1, 1, 1)
 5         _Specular("Specular", Color) = (1, 1, 1, 1)
 6         _Gloss("Gloss", Range(10, 256)) = 20
 7     }
 8  
 9     SubShader {
10         Tags {
11             "RenderPipeline"="UniversalPipeline"
12         }
13         Pass {
14             Tags {
15                 "LightMode"="UniversalForward"
16             }
17  
18             HLSLPROGRAM
19             #pragma vertex vert
20             #pragma fragment frag
21  
22             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
23             #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
24  
25 CBUFFER_START(UnityPerMaterial)
26             float4 _MainTex_ST;
27             half4 _Color;
28             half4 _Specular;
29             float _Gloss;
30 CBUFFER_END
31  
32             TEXTURE2D(_MainTex);
33             SAMPLER(sampler_MainTex);
34  
35             struct a2v {
36                 float4 vertex : POSITION;
37                 half3 normal : NORMAL;
38                 float4 texcoord : TEXCOORD0;    // unity会将第一组纹理坐标存储到改变量中
39             };
40  
41             struct v2f {
42                 float4 pos : SV_POSITION;
43                 half3 worldNormal : TEXCOORD0;
44                 float3 worldPos : TEXCOORD1;
45                 float2 uv : TEXCOORD2; // 疑惑，是不是float2类型？ 
46             };
47  
48             v2f vert(a2v data) {
49                 v2f v;
50                 v.pos = TransformObjectToHClip(data.vertex.xyz);
51                 v.worldPos = mul(UNITY_MATRIX_M, data.vertex).xyz;
52  
53                 // v.worldNormal = mul(data.normal, unity_WorldToObject);
54                 v.worldNormal = TransformObjectToWorldNormal(data.normal);
55  
56                 /*
57                     个人理解：
58                     texcoord的值是0-1
59                     是按照未缩放和未平移情况下计算的纹理坐标，因此才是0-1
60                     uv是 *缩放+平移 的结果，结果不一定再0-1之间
61                     tex2D按照uv在纹理上采样
62                 */
63                 // 方法等同
64                 // v.uv = data.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;
65                 v.uv = TRANSFORM_TEX(data.texcoord, _MainTex);
66  
67                 return v;
68             }
69  
70             half4 frag(v2f v) : SV_Target {
71                 half3 worldNormal = normalize(v.worldNormal);
72                 // half3 worldLightDir = normalize(_WorldSpaceLightPos0.xyz);
73                 half3 worldLightDir = normalize(_MainLightPosition.xyz);
74  
75                 half3 albedo = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, v.uv).rgb * _Color.rgb;    // 疑惑，采样结果的类型
76  
77                 // 环境光
78                 half3 ambient = half3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) * albedo;
79  
80                 // 漫反射
81                 half3 diffuse = _MainLightColor.rgb * albedo * saturate(dot(worldNormal, worldLightDir));
82  
83                 // 高光
84                 // half3 viewDir = normalize(_WorldSpaceCameraPos.xyz);
85                 half3 viewDir = normalize(_WorldSpaceCameraPos.xyz - v.worldPos);
86                 half3 halfDir = normalize(viewDir + worldLightDir);
87                 half3 specular = _MainLightColor.rgb * _Specular.rgb * pow(saturate(dot(halfDir, worldNormal)), _Gloss);
88  
89                 return half4(ambient + diffuse + specular, 1);
90             }
91  
92             ENDHLSL
93         }
94     }
95  
96     FallBack "Universal Render Pipeline/Simple Lit"
97 }