1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
| Shader "Custom/ShadowReciver"
{
Properties
{
_BaseColor ("Base Color", Color) = (1.0, 1.0, 1.0, 1.0)
_BaseMap ("Main Texture", 2D) = "white"{}
_SpecColor ("Specular Color", Color) = (1.0, 1.0, 1.0, 1.0)
_Smoothness ("Gloss", range(8, 256)) = 20
_BumpMap ("Normal Map", 2D) = "bump" {}
_BumpScale ("Scale", Float) = 1.0
[Toggle(_MULTIPLE_LIGHTS)] _MultipleLights ("Received MultipleLights", Float) = 1.0
}
SubShader
{
Tags {
"RenderType"="Opaque"
"RenderPipeline"="UniversalRenderPipeline"
"LightMode" = "UniversalForward"
"ShaderModel"="4.5"
}
HLSLINCLUDE
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
CBUFFER_START(UnityPerMaterial)
half4 _BaseMap_ST;
half4 _BumpMap_ST;
half4 _BaseColor;
half4 _SpecColor;
half _Smoothness;
half _BumpScale;
CBUFFER_END
TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap);
TEXTURE2D(_BumpMap); SAMPLER(sampler_BumpMap);
struct Attributes
{
half4 positionOS : POSITION;
half3 normal : NORMAL;
half4 tangetOS : TANGENT;
half2 uv : TEXCOORD0;
};
struct Varyings
{
half4 positionCS : SV_POSITION;
half3 positionWS : POSITION_WS;
half4 positionSC : POSITION_SC;
half2 uv : TEXCOORD0;
half3 normalWS : NORMAL_WS;
half4 tangentWS : TANGENT_WS;
};
half4 LightingModelImplement (Light light, half3 normalWS, half3 viewDirWS, half2 uv, bool isMainLight)
{
half3 lightColor = light.color;
half3 lightDir = normalize(light.direction);
half lambert = saturate(dot(lightDir, normalWS));
half3 albedo = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv) * _BaseColor;
//half3 ambient = half3(unity_SHAr.w, unity_SHAg.w, unity_SHAb.w) * albedo;
half3 ambient = SampleSH(normalWS) * albedo;
half3 diffuse = lambert * lightColor * ambient;
half3 halfDir = normalize(viewDirWS + lightDir);
half3 specular = pow(saturate(dot(normalWS, halfDir)), _Smoothness) * lightColor * saturate(_SpecColor);
half4 finalColor = half4(ambient + diffuse + specular, 1.0) * light.shadowAttenuation * light.distanceAttenuation;
return finalColor;
}
ENDHLSL
Pass
{
Tags{
"LightMode"="UniversalForward"
}
HLSLPROGRAM
#pragma vertex vert
#pragma fragment frag
#pragma shader_feature _MULTIPLE_LIGHTS
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
#pragma multi_compile _ _SHADOWS_SOFT
#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
Varyings vert (Attributes IN)
{
const VertexPositionInputs vertex_position_inputs = GetVertexPositionInputs(IN.positionOS);
const VertexNormalInputs vertex_normal_inputs = GetVertexNormalInputs(IN.normal);
// get positive or negative normal signal (should be either 1 or -1)
half sign = IN.tangetOS.w * GetOddNegativeScale();
Varyings OUT;
OUT.positionWS = vertex_position_inputs.positionWS;
OUT.positionCS = vertex_position_inputs.positionCS;
OUT.normalWS = vertex_normal_inputs.normalWS;
OUT.positionSC = GetShadowCoord(vertex_position_inputs);
OUT.uv = TRANSFORM_TEX(IN.uv, _BaseMap);
OUT.tangentWS = half4(vertex_normal_inputs.tangentWS, sign);
return OUT;
}
half4 frag (Varyings IN) : SV_Target
{
half3 normalTS = UnpackNormalScale(SAMPLE_TEXTURE2D(_BumpMap, sampler_BumpMap, IN.uv), _BumpScale);
half3 biTangent = IN.tangentWS.w * cross(IN.normalWS, IN.tangentWS.xyz);
half3 normalWS = mul(normalTS, half3x3(IN.tangentWS.xyz, biTangent, IN.normalWS));
half3 viewDirWS = SafeNormalize((GetCameraPositionWS() - IN.positionWS));
Light mainLight = GetMainLight(IN.positionSC);
half4 finalColor = LightingModelImplement(mainLight, normalWS, viewDirWS, IN.uv, true);
#if _MULTIPLE_LIGHTS
int lightsCount = GetAdditionalLightsCount();
for (int i=0; i<lightsCount; i++)
{
Light light = GetAdditionalLight(i, IN.positionWS, half4(1, 1, 1, 1));
finalColor += LightingModelImplement(light, normalWS, viewDirWS, IN.uv, false);
half shadow = AdditionalLightRealtimeShadow(i, IN.positionWS, mainLight.direction);
finalColor *= shadow;
}
#endif
return finalColor;
}
ENDHLSL
}
Pass{
Tags{
"LightMode"="ShadowCaster"
}
ZWrite On // the only goal of this pass is to write depth!
ZTest LEqual // early exit at Early-Z stage if possible
ColorMask 0 // we don't care about color, we just want to write depth, ColorMask 0 will save some write bandwidth
Cull Back
HLSLPROGRAM
#pragma vertex vertShadow
#pragma fragment fragShadow
half3 _LightDirection;
Varyings vertShadow(Attributes IN)
{
const VertexPositionInputs vertex_position_inputs = GetVertexPositionInputs(IN.positionOS);
const VertexNormalInputs vertex_normal_inputs = GetVertexNormalInputs(IN.normal);
Varyings OUT;
OUT.positionWS = vertex_position_inputs.positionWS;
OUT.normalWS = vertex_normal_inputs.normalWS;
OUT.positionCS = TransformWorldToHClip(ApplyShadowBias(OUT.positionWS,OUT.normalWS, _LightDirection));
#if UNITY_REVERSED_Z
OUT.positionCS.z = min(OUT.positionCS.z, UNITY_NEAR_CLIP_VALUE);
#else
OUT.positionCS.z = max(OUT.positionCS.z, UNITY_NEAR_CLIP_VALUE);
#endif
OUT.uv = IN.uv;
return OUT;
}
half4 fragShadow(Varyings IN):SV_TARGET
{
return 0;
}
ENDHLSL
}
}
}
|
