/
z-mia-rt-in.txt
439 lines (439 loc) · 19.3 KB
/
z-mia-rt-in.txt
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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
uniform float3 _WorldSpaceCameraPos ;
uniform fixed4 _WorldSpaceLightPos0 ;
float4 unity_SHAr ;
float4 unity_SHAg ;
float4 unity_SHAb ;
float4 unity_SHBr ;
float4 unity_SHBg ;
float4 unity_SHBb ;
float4 unity_SHC ;
float4x4 glstate_matrix_mvp ;
float4x4 glstate_matrix_modelview0 ;
uniform float4x4 _Object2World ;
uniform float4x4 _World2Object ;
uniform float4 unity_Scale ;
float4x4 glstate_matrix_projection ;
float4 glstate_lightmodel_ambient ;
struct appdata_full
{
float4 vertex : POSITION ;
float4 tangent : TANGENT ;
float3 normal : NORMAL ;
float4 texcoord : TEXCOORD0 ;
float4 texcoord1 : TEXCOORD1 ;
fixed4 color : COLOR ;
}
;
inline float3 WorldSpaceLightDir ( in float4 v )
{
float3 worldPos = mul ( _Object2World , v ) . xyz ;
return _WorldSpaceLightPos0 . xyz ;
}
inline float3 ObjSpaceLightDir ( in float4 v )
{
float3 objSpaceLightPos = mul ( _World2Object , _WorldSpaceLightPos0 ) . xyz ;
return objSpaceLightPos . xyz ;
}
inline float3 WorldSpaceViewDir ( in float4 v )
{
return _WorldSpaceCameraPos . xyz - mul ( _Object2World , v ) . xyz ;
}
inline float3 ObjSpaceViewDir ( in float4 v )
{
float3 objSpaceCameraPos = mul ( _World2Object , float4 ( _WorldSpaceCameraPos . xyz , 1 ) ) . xyz * unity_Scale . w ;
return objSpaceCameraPos - v . xyz ;
}
half3 ShadeSH9 ( half4 normal )
{
half3 x1 , x2 , x3 ;
x1 . r = dot ( unity_SHAr , normal ) ;
x1 . g = dot ( unity_SHAg , normal ) ;
x1 . b = dot ( unity_SHAb , normal ) ;
half4 vB = normal . xyzz * normal . yzzx ;
x2 . r = dot ( unity_SHBr , vB ) ;
x2 . g = dot ( unity_SHBg , vB ) ;
x2 . b = dot ( unity_SHBb , vB ) ;
float vC = normal . x * normal . x - normal . y * normal . y ;
x3 = unity_SHC . rgb * vC ;
return x1 + x2 + x3 ;
}
inline fixed Luminance ( fixed3 c )
{
return dot ( c , fixed3 ( 0.22 , 0.707 , 0.071 ) ) ;
}
inline fixed3 DecodeLightmap ( fixed4 color )
{
return ( 8.0 * color . a ) * color . rgb ;
}
inline fixed3 UnpackNormal ( fixed4 packednormal )
{
fixed3 normal ;
normal . xy = packednormal . wy * 2 - 1 ;
normal . z = sqrt ( 1 - normal . x * normal . x - normal . y * normal . y ) ;
return normal ;
}
struct SurfaceOutput
{
fixed3 Albedo ;
fixed3 Normal ;
fixed3 Emission ;
half Specular ;
fixed Gloss ;
fixed Alpha ;
}
;
fixed4 _LightColor0 ;
fixed4 _SpecColor ;
inline fixed3 unityApplyLightmap ( fixed3 albedo , fixed3 lighting , fixed3 colorTint , fixed atten )
{
return albedo * lighting ;
}
uniform sampler2D _LightTexture0 ;
uniform float4x4 _LightMatrix0 ;
struct Input
{
float2 uv_MainTex ;
float2 uv_BumpMap ;
float3 viewDir ;
float3 worldPos ;
float3 worldNormal ;
float3 worldRefl ;
half3 TtoW0 ;
half3 TtoW1 ;
half3 TtoW2 ;
}
;
struct MySurfaceOutput
{
float3 Albedo ;
float3 Normal ;
float3 Emission ;
float3 Specular ;
float Reflectivity ;
float Roughness ;
float Alpha ;
}
;
float _Rolloff ;
inline float LambertTermWithRolloff ( float3 normal , float3 lightDir )
{
return max ( 0.0f , dot ( normal , lightDir ) + _Rolloff ) / ( 1.0f + _Rolloff * 2.0f ) ;
}
inline float BlinnTermWithRolloff ( float3 normal , float3 halfDir )
{
return max ( 0.0f , dot ( normal , halfDir ) + _Rolloff * 2.0f ) / ( 1.0f + _Rolloff * 2.0f ) ;
}
float _Falloff ;
inline float FresnelTerm ( float refl0 , float refl90 , float cosA )
{
float t = pow ( abs ( 1.0f - cosA ) , _Falloff ) ;
return refl0 * ( 1 - t ) + refl90 * t ;
}
inline float CTGeometricTerm ( float NdotL , float NdotH , float NdotV , float VdotH )
{
return min ( 1.0 , min ( ( 2.0 * NdotH * NdotV ) / VdotH , ( 2.0 * NdotH * NdotL ) / VdotH ) ) ;
}
inline float CTRoughnessTerm ( float roughness , float NdotH )
{
float mSq = roughness * roughness ;
float a = 1.0 / ( 4.0 * mSq * pow ( NdotH , 4.0 ) ) ;
float b = NdotH * NdotH - 1.0f ;
float c = mSq * NdotH * NdotH ;
return a * exp ( b / c ) ;
}
inline float CookTorranceTerm ( float roughness , float refl0 , float refl90 , float3 normal , float3 lightDir , float3 viewDir )
{
float3 halfDir = normalize ( lightDir + viewDir ) ;
float nl = LambertTermWithRolloff ( normal , lightDir ) ;
float nh = BlinnTermWithRolloff ( normal , halfDir ) ;
float nv = max ( 0.0 , dot ( normal , viewDir ) ) ;
float vh = max ( 0.0 , dot ( viewDir , halfDir ) ) ;
float F = FresnelTerm ( refl0 , refl90 , vh ) ;
float G = CTGeometricTerm ( nl , nh , nv , vh ) ;
float R = CTRoughnessTerm ( roughness , nh ) ;
R = max ( 0 , R ) ;
return max ( 0 , ( F * G * R ) / ( nv * nl ) ) ;
}
inline float OrenNayarTerm ( float roughness , float3 normal , float3 lightDir , float3 viewDir )
{
const float PI = 3.14159f ;
const float INVERSE_PI = 1.0 / PI ;
const float INVERSE_PI_SQ = INVERSE_PI * INVERSE_PI ;
float rSq = roughness * roughness ;
float NdotL = LambertTermWithRolloff ( normal , lightDir ) ;
float NdotV = dot ( normal , viewDir ) ;
float a = max ( acos ( NdotV ) , acos ( NdotL ) ) ;
float b = min ( acos ( NdotV ) , acos ( NdotL ) ) ;
float y = dot ( viewDir - normal * NdotV , lightDir - normal * NdotL ) ;
float K1 = rSq / ( rSq + 0.33 ) ;
float K2 = rSq / ( rSq + 0.09 ) ;
float c1 = 1.0 - 0.5 * K1 ;
float c2 = 0.45 * K2 ;
c2 *= sin ( a ) - ( ( y >= 0.0 ) ? 0.0 : pow ( 2.0 * b * INVERSE_PI , 3.0 ) ) ;
float c3 = ( 1.0 / 8.0 ) * K2 * pow ( 4.0 * a * b * INVERSE_PI_SQ , 2.0 ) ;
float x = y * c2 * tan ( b ) ;
float e = ( 1 - abs ( y ) ) * c3 * tan ( ( a + b ) / 2.0 ) ;
return c1 + x + e ;
}
inline float OrenNayarSimpleTerm ( float roughness , float3 normal , float3 lightDir , float3 viewDir )
{
const float PI = 3.14159f ;
const float INVERSE_PI = 1.0 / PI ;
const float INVERSE_PI_SQ = INVERSE_PI * INVERSE_PI ;
float rSq = roughness * roughness ;
float NdotL = LambertTermWithRolloff ( normal , lightDir ) ;
float NdotV = dot ( normal , viewDir ) ;
float x = sqrt ( ( 1.0 - NdotV * NdotV ) * ( 1.0 - NdotL * NdotL ) ) / max ( NdotV , NdotL ) ;
float y = dot ( viewDir - normal * NdotV , lightDir - normal * NdotL ) ;
float K1 = rSq / ( rSq + 0.33 ) ;
float K2 = rSq / ( rSq + 0.09 ) ;
float c1 = 1.0 - 0.5 * K1 ;
float c2 = 0.45 * K2 ;
return c1 + c2 * max ( 0 , y ) * x ;
}
inline float EvalMipLevel ( float3 uvw , float texResolution )
{
float3 dxSize = ddx ( uvw ) ;
float3 dySize = ddy ( uvw ) ;
float fMipLevel ;
float fMinTexCoordDelta ;
float3 dTexCoords ;
dTexCoords = dxSize * dxSize + dySize * dySize ;
fMinTexCoordDelta = max ( dTexCoords . z , max ( dTexCoords . x , dTexCoords . y ) ) * texResolution ;
fMipLevel = max ( 0.5 * log2 ( fMinTexCoordDelta ) , 0 ) ;
return fMipLevel ;
}
inline float RemapToRange ( float v , float4 range )
{
v *= range . y ;
v += range . x ;
return v ;
}
inline float3 CombineNormals ( float3 n1 , float3 n2 )
{
float3 n = normalize ( n1 ) ;
float3x3 nBasis = float3x3 ( float3 ( n . z , n . x , - n . y ) , float3 ( n . x , n . z , - n . y ) , float3 ( n . x , n . y , n . z ) ) ;
return normalize ( n2 . x * nBasis [ 0 ] + n2 . y * nBasis [ 1 ] + n2 . z * nBasis [ 2 ] ) ;
}
float _Roughness ;
float _Roughness2 ;
float _Reflectivity ;
float _Refl0 , _Refl90 ;
float _Metalic ;
float _SpecOnlyIntensity ;
float _ReflOnlyIntensity ;
inline fixed4 LightingOrenNayar_CookTorrance ( MySurfaceOutput s , float3 lightDir , float3 viewDir , float atten )
{
float3 normal = normalize ( s . Normal ) ;
lightDir = normalize ( lightDir ) ;
viewDir = normalize ( viewDir ) ;
float nl = LambertTermWithRolloff ( normal , lightDir ) ;
float diffRoughness = _Roughness2 ;
float specRoughness = max ( 0.02f , _Roughness * s . Roughness ) ;
float refl0 = _Refl0 * _Reflectivity ;
float refl90 = _Refl90 * _Reflectivity ;
float spec = CookTorranceTerm ( specRoughness , refl0 , refl90 , normal , lightDir , viewDir ) * _SpecOnlyIntensity ;
float3 specColor = _LightColor0 . rgb * 2.0 * lerp ( s . Specular , s . Specular * s . Albedo , _Metalic ) ;
float3 diffColor = _LightColor0 . rgb * 2.0 ;
float diffScatter = OrenNayarTerm ( diffRoughness , normal , lightDir , viewDir ) ;
fixed4 c ;
c . rgb = ( lerp ( s . Albedo * diffColor * diffScatter , specColor * spec , s . Reflectivity ) ) * nl * atten ;
c . a = s . Alpha + length ( specColor ) * spec * s . Reflectivity * nl * atten ;
return c ;
}
struct ContinuousSamplerLOD
{
float mip0 ;
float mip1 ;
float mipFrac ;
}
;
inline float4 tex2Dclod ( sampler2D s , float2 uv , in ContinuousSamplerLOD level )
{
return lerp ( tex2Dlod ( s , float4 ( uv , 0 , level . mip0 ) ) , tex2Dlod ( s , float4 ( uv , 0 , level . mip1 ) ) , level . mipFrac ) ;
}
inline float4 texCUBEclod ( samplerCUBE s , float3 dir , in ContinuousSamplerLOD level )
{
return lerp ( texCUBElod ( s , float4 ( dir , level . mip0 ) ) , texCUBElod ( s , float4 ( dir , level . mip1 ) ) , level . mipFrac ) ;
}
struct PlanarMapping
{
float4 plane ;
float3 tangent ;
float3 bitangent ;
float2 uvOffset ;
}
;
float4x4 _WorldToMirrorProjMatrix ;
sampler2D _MirrorTex ;
inline float4 SampleMirrorReflection ( float3 worldPos , in ContinuousSamplerLOD level )
{
float4 ppos = mul ( _WorldToMirrorProjMatrix , float4 ( worldPos , 1.0f ) ) ;
return tex2Dclod ( _MirrorTex , ppos . xy / ppos . w , level ) ;
}
inline float4 SampleCubeReflection ( samplerCUBE s , float3 rayDir , in ContinuousSamplerLOD level )
{
return texCUBEclod ( s , rayDir , level ) ;
}
inline float4 SamplePlanarReflection ( sampler2D s , in PlanarMapping p , float3 rayStart , float3 rayDir , in ContinuousSamplerLOD level )
{
float Vd = - dot ( p . plane . xyz , rayDir ) ;
if ( Vd < 1e-4 ) return float4 ( 0 , 0 , 0 , 0 ) ;
float Vo = dot ( p . plane . xyz , rayStart ) + p . plane . w ;
float t = Vo / Vd ;
if ( t < 0.0 ) return float4 ( 0 , 0 , 0 , 0 ) ;
float3 Pi = rayStart + rayDir * t ;
float3 Po = p . plane . xyz * p . plane . w ;
float3 d = Pi - Po ;
float u = dot ( d , p . tangent ) * 0.5 + 0.5 - p . uvOffset . x * 0.5 ;
float v = dot ( d , - p . bitangent ) * 0.5 + 0.5 + p . uvOffset . y * 0.5 ;
if ( u < 0.0 || u > 1.0 || v < 0.0 || v > 1.0 ) return float4 ( 0 , 0 , 0 , 0 ) ;
return tex2Dclod ( s , float2 ( u , v ) , level ) ;
}
inline float4 GlossyReflectionTerm ( Input IN , samplerCUBE crefl , in PlanarMapping pm0 , sampler2D prefl0 , in PlanarMapping pm1 , sampler2D prefl1 , in PlanarMapping pm2 , sampler2D prefl2 , float3 normal , float Q , float lod )
{
float W = Q / pow ( 2.0 , 0.5 ) ;
float3 worldP = IN . worldPos ;
float4 o1 = 0 ;
float4 o2 = 0 ;
float3 worldRefl ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal ) ) , dot ( IN . TtoW1 , ( normal ) ) , dot ( IN . TtoW2 , ( normal ) ) ) ) ;
ContinuousSamplerLOD clod ;
clod . mip0 = floor ( lod ) ;
clod . mip1 = clod . mip0 + 1.0f ;
clod . mipFrac = frac ( lod ) ;
o1 = SampleMirrorReflection ( worldP , clod ) ;
o1 = lerp ( SamplePlanarReflection ( prefl0 , pm0 , worldP , worldRefl , clod ) , o1 , o1 . a ) ;
o1 = lerp ( SamplePlanarReflection ( prefl1 , pm1 , worldP , worldRefl , clod ) , o1 , o1 . a ) ;
o1 = lerp ( SamplePlanarReflection ( prefl2 , pm2 , worldP , worldRefl , clod ) , o1 , o1 . a ) ;
clod . mip0 = floor ( lod * 2 ) ;
clod . mip1 = clod . mip0 + 1.0f ;
clod . mipFrac = frac ( lod * 2 ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( Q , 0 , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( Q , 0 , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( Q , 0 , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( - Q , 0 , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( - Q , 0 , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( - Q , 0 , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( 0 , - Q , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( 0 , - Q , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( 0 , - Q , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( 0 , Q , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( 0 , Q , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( 0 , Q , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( W , W , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( W , W , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( W , W , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( - W , W , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( - W , W , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( - W , W , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( W , - W , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( W , - W , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( W , - W , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
worldRefl = reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , ( normal + float3 ( - W , - W , 0 ) ) ) , dot ( IN . TtoW1 , ( normal + float3 ( - W , - W , 0 ) ) ) , dot ( IN . TtoW2 , ( normal + float3 ( - W , - W , 0 ) ) ) ) ) ;
o2 += SampleCubeReflection ( crefl , worldRefl , clod ) ;
o2 /= 8.0 ;
return lerp ( o2 , o1 , o1 . a ) ;
}
float4 _PlanarReflection0 ;
float4 _PlanarReflectionTangent0 , _PlanarReflectionBiTangent0 ;
sampler2D _PlanarReflectionTex0 ;
float4 _PlanarReflection1 ;
float4 _PlanarReflectionTangent1 , _PlanarReflectionBiTangent1 ;
sampler2D _PlanarReflectionTex1 ;
float4 _PlanarReflection2 ;
float4 _PlanarReflectionTangent2 , _PlanarReflectionBiTangent2 ;
sampler2D _PlanarReflectionTex2 ;
samplerCUBE _Cube ;
inline float3 GlobalIllumination ( Input IN , MySurfaceOutput s , out float3 spec )
{
float3 normal = normalize ( s . Normal ) ;
float3 worldRefl = normalize ( reflect ( IN . worldRefl , half3 ( dot ( IN . TtoW0 , normal ) , dot ( IN . TtoW1 , normal ) , dot ( IN . TtoW2 , normal ) ) ) ) ;
fixed3 worldN = fixed3 ( dot ( IN . TtoW0 , normal ) , dot ( IN . TtoW1 , normal ) , dot ( IN . TtoW2 , normal ) ) ;
float roughness = _Roughness * s . Roughness ;
float Q = 0.25 * 0.33 * ( 1.0 - pow ( 1.0 - max ( 0 , roughness - 0.033 ) , 2.0 ) ) ;
float LOD = 1.25 * ( 1.0 - pow ( 1.0 - max ( 0 , roughness ) , 2.0 ) ) * 4.0 ;
PlanarMapping pm0 ;
pm0 . plane = _PlanarReflection0 ;
pm0 . tangent = _PlanarReflectionTangent0 . xyz ;
pm0 . bitangent = _PlanarReflectionBiTangent0 . xyz ;
pm0 . uvOffset = float2 ( _PlanarReflectionTangent0 . w , _PlanarReflectionBiTangent0 . w ) ;
PlanarMapping pm1 ;
pm1 . plane = _PlanarReflection1 ;
pm1 . tangent = _PlanarReflectionTangent1 . xyz ;
pm1 . bitangent = _PlanarReflectionBiTangent1 . xyz ;
pm1 . uvOffset = float2 ( _PlanarReflectionTangent1 . w , _PlanarReflectionBiTangent1 . w ) ;
PlanarMapping pm2 ;
pm2 . plane = _PlanarReflection2 ;
pm2 . tangent = _PlanarReflectionTangent2 . xyz ;
pm2 . bitangent = _PlanarReflectionBiTangent2 . xyz ;
pm2 . uvOffset = float2 ( _PlanarReflectionTangent2 . w , _PlanarReflectionBiTangent2 . w ) ;
LOD = max ( EvalMipLevel ( worldRefl , 256.0f ) , LOD ) ;
float3 refl = GlossyReflectionTerm ( IN , _Cube , pm0 , _PlanarReflectionTex0 , pm1 , _PlanarReflectionTex1 , pm2 , _PlanarReflectionTex2 , normal , Q , LOD ) . xyz * _ReflOnlyIntensity ;
refl *= lerp ( s . Specular , s . Specular * s . Albedo , _Metalic ) ;
spec = refl * saturate ( s . Reflectivity ) ;
float3 ambient = ShadeSH9 ( float4 ( worldN , 1.0 ) ) * s . Albedo ;
return lerp ( ambient , refl , saturate ( s . Reflectivity ) ) ;
}
sampler2D _MainTex ;
sampler2D _BumpMap , _BumpMap2 ;
sampler2D _MainReflectivityTex ;
sampler2D _MainRoughnessTex ;
float4 _BumpMap2_ST ;
fixed4 _Color , _ReflColor ;
float _BumpMapFactor , _BumpMapFactor2 ;
float4 _MainReflectivityTex_AddMul ;
float4 _MainRoughnessTex_AddMul ;
void surf ( Input IN , inout MySurfaceOutput o )
{
half4 c = tex2D ( _MainTex , IN . uv_MainTex ) ;
o . Albedo = c . rgb * _Color . rgb ;
o . Alpha = c . a ;
o . Specular = _ReflColor . rgb ;
float2 uv_BumpMap2 = ( IN . uv_MainTex . xy * _BumpMap2_ST . xy ) + _BumpMap2_ST . zw ;
float3 up = float3 ( 0 , 0 , 1 ) ;
float3 n1 = lerp ( up , max ( float3 ( - 1 , - 1 , 0.01 ) , UnpackNormal ( tex2D ( _BumpMap , IN . uv_BumpMap ) ) ) , _BumpMapFactor ) ;
float3 n2 = lerp ( up , max ( float3 ( - 1 , - 1 , 0.01 ) , UnpackNormal ( tex2D ( _BumpMap2 , uv_BumpMap2 ) ) ) , _BumpMapFactor2 ) ;
o . Normal = CombineNormals ( n1 , n2 ) ;
float NdotV = max ( 0.0 , dot ( o . Normal , normalize ( IN . viewDir ) ) ) ;
float F = FresnelTerm ( _Refl0 * _Reflectivity , _Refl90 * _Reflectivity , NdotV ) ;
o . Reflectivity = RemapToRange ( tex2D ( _MainReflectivityTex , IN . uv_MainTex ) . r , _MainReflectivityTex_AddMul ) * F ;
o . Roughness = RemapToRange ( tex2D ( _MainRoughnessTex , IN . uv_MainTex ) . r , _MainRoughnessTex_AddMul ) ;
float3 globalSpec ;
o . Emission = GlobalIllumination ( IN , o , globalSpec ) ;
}
struct v2f_surf
{
float4 pos : POSITION ;
float4 pack0 : TEXCOORD0 ;
float3 worldPos : TEXCOORD1 ;
float3 viewDir : TEXCOORD2 ;
fixed4 TtoW0 : TEXCOORD3 ;
fixed4 TtoW1 : TEXCOORD4 ;
fixed4 TtoW2 : TEXCOORD5 ;
fixed3 lightDir : TEXCOORD6 ;
fixed3 vlight : TEXCOORD7 ;
float2 _LightCoord : TEXCOORD8 ;
}
;
float4 _MainTex_ST ;
float4 _BumpMap_ST ;
v2f_surf main ( appdata_full v )
{
v2f_surf o ;
o . pos = mul ( glstate_matrix_mvp , v . vertex ) ;
o . pack0 . xy = ( v . texcoord . xy * _MainTex_ST . xy + _MainTex_ST . zw ) ;
o . pack0 . zw = ( v . texcoord . xy * _BumpMap_ST . xy + _BumpMap_ST . zw ) ;
v . normal = normalize ( v . normal ) ;
v . tangent . xyz = normalize ( v . tangent . xyz ) ;
o . worldPos = mul ( _Object2World , v . vertex ) . xyz ;
float3 viewDir = - ObjSpaceViewDir ( v . vertex ) ;
float3 worldRefl = mul ( ( float3x3 ) _Object2World , viewDir ) ;
float3 binormal = cross ( normalize ( v . normal ) , normalize ( v . tangent . xyz ) ) * v . tangent . w ;
float3x3 rotation = float3x3 ( v . tangent . xyz , binormal , v . normal ) ;
o . TtoW0 = float4 ( mul ( rotation , _Object2World [ 0 ] . xyz ) , worldRefl . x ) * unity_Scale . w ;
o . TtoW1 = float4 ( mul ( rotation , _Object2World [ 1 ] . xyz ) , worldRefl . y ) * unity_Scale . w ;
o . TtoW2 = float4 ( mul ( rotation , _Object2World [ 2 ] . xyz ) , worldRefl . z ) * unity_Scale . w ;
float3 worldN = mul ( ( float3x3 ) _Object2World , ( v . normal * unity_Scale . w ) ) ;
float3 lightDir = mul ( rotation , ObjSpaceLightDir ( v . vertex ) ) ;
o . lightDir = lightDir ;
float3 viewDirForLight = mul ( rotation , ObjSpaceViewDir ( v . vertex ) ) ;
o . viewDir = viewDirForLight ;
o . vlight = 0.0 ;
o . _LightCoord = mul ( _LightMatrix0 , mul ( _Object2World , v . vertex ) ) . xy ;
;
return o ;
}