lcy
2025-01-02 c867ea92cce28ea0ceb312ef8e2f8e7e0888b1d6
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
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
Shader "Character/Basic"
{
    
    
    Subshader
    {
        Tags { "Queue" = "Geometry" "IgnoreProjector" = "True" "LightMode" = "ForwardBase" }
        
        //渲染X光效果的Pass
        Pass
        {
            
            Name "XRAYPASSBASE"
            
            Blend SrcAlpha One
            ZWrite Off
            ZTest Greater
            
            CGPROGRAM
            
            #include "Lighting.cginc"
            #pragma vertex vert
            #pragma fragment frag
            
            struct v2f
            {
                float4 pos: SV_POSITION;
            };
            
            v2f vert(appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                return float4(0, 0, 0, 0);
            }
            
            ENDCG
            
        }
        
        //渲染X光效果的Pass
        Pass
        {
            Name "XRAYPASSHERO"
            
            Blend SrcAlpha One
            ZWrite Off
            ZTest Greater
            
            CGPROGRAM
            
            #include "Lighting.cginc"
            #pragma vertex vert
            #pragma fragment frag
            
            fixed4 _XRayColor;
            
            struct v2f
            {
                float4 pos: SV_POSITION;
                float3 normal: normal;
                float3 viewDir: TEXCOORD0;
            };
            
            v2f vert(appdata_base v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.viewDir = ObjSpaceViewDir(v.vertex);
                o.normal = v.normal;
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                half3 normal = normalize(i.normal);
                half3 viewDir = normalize(i.viewDir);
                half rim = 1 - dot(normal, viewDir);
                return  float4(_XRayColor.rgb, _XRayColor.a * 3) * rim;
            }
            
            ENDCG
            
        }
        
        Pass
        {
            Name "EMISSION_FLOW_ALPHA"
            
            Cull Back
            Fog
            {
                Mode Off
            }
            
            Blend SrcAlpha OneMinusSrcAlpha
            CGPROGRAM
            
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag
            
            #pragma multi_compile_fwdbase
            #pragma exclude_renderers flash
            
            #include "UnityCG.cginc"
            #include "SnxxzCG.cginc"
            
            struct vertexInput
            {
                half4 vertex: POSITION;
                half3 normal: NORMAL;
                half4 tangent: TANGENT;
                half2 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                // basics
                half4 pos: SV_POSITION;
                half2 uv1: TEXCOORD0;
            };
            // assets
            uniform sampler2D _MainTex;
            uniform sampler2D _ChanTex;
            
            v2f vert(vertexInput v)
            {
                v2f o;
                
                // pos and uv tex coord
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv1 = v.texcoord;
                return o;
            }
            
            fixed4 _FlowColor;
            fixed _FlowSpeed;
            fixed _FlowDirectionH;
            fixed _FlowDirectionV;
            fixed _FlowIntensity;
            
            fixed4    _SelfLuminousColor;
            fixed  _SelfLuminousSpeed;
            fixed  _SelfLuminousIntensity;
            fixed  _SelfLuminousMin;
            fixed  _SelfLuminousMax;
            
            fixed4 frag(v2f i): SV_Target
            {
                
                // textures
                fixed4 outcolor = tex2D(_MainTex, i.uv1);
                fixed3 channels = tex2D(_ChanTex, i.uv1);
                
                outcolor.rgb *= 1.2;
                fixed timeadd = _Time.y * 5 * _FlowSpeed;
                
                fixed uvshiftH = (timeadd - floor(timeadd)) * _FlowDirectionH;
                fixed uvshiftV = (timeadd - floor(timeadd)) * _FlowDirectionV;
                
                fixed channelsB = tex2D(_ChanTex, i.uv1 + fixed2(uvshiftH, uvshiftV)).b;
                outcolor.rgb += _FlowColor * channels.r * _FlowIntensity * channelsB;
                
                fixed delta = _SelfLuminousMax - _SelfLuminousMin;
                outcolor.rgb += _SelfLuminousColor * channels.g * ((delta * 0.5 * sin(_Time.y * 10 * _SelfLuminousSpeed)) + (2 - _SelfLuminousMin) * 0.5) * _SelfLuminousIntensity;
                
                return outcolor;
            }
            
            ENDCG
            
        }
        
        Pass
        {
            Name "EMISSION_FLOW"
            
            Cull Back
            Fog
            {
                Mode Off
            }
            
            CGPROGRAM
            
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag
            
            #pragma multi_compile_fwdbase
            #pragma multi_compile QUALITY_LOW QUALITY_MED QUALITY_HGH
            
            #pragma exclude_renderers flash
            
            #include "UnityCG.cginc"
            #include "SnxxzCG.cginc"
            
            struct vertexInput
            {
                half4 vertex: POSITION;
                half3 normal: NORMAL;
                half4 tangent: TANGENT;
                half2 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                // basics
                half4 pos: SV_POSITION;
                half2 uv1: TEXCOORD0;
                half3 lgt: TEXCOORD5;
            };
            // assets
            uniform sampler2D _MainTex;
            uniform sampler2D _ChanTex;
            
            // properties
            uniform half _Hit;
            
            v2f vert(vertexInput v)
            {
                v2f o;
                
                // pos and uv tex coord
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv1 = v.texcoord;
                
                o.lgt = 0.6 + _Hit;
                return o;
            }
            
            fixed4 _FlowColor;
            fixed _FlowSpeed;
            fixed _FlowDirectionH;
            fixed _FlowDirectionV;
            fixed _FlowIntensity;
            
            fixed4    _SelfLuminousColor;
            fixed  _SelfLuminousSpeed;
            fixed  _SelfLuminousIntensity;
            fixed  _SelfLuminousMin;
            fixed  _SelfLuminousMax;
            
            fixed4 frag(v2f i): SV_Target
            {
                
                // textures
                fixed3 outcolor = tex2D(_MainTex, i.uv1);
                fixed3 channels = tex2D(_ChanTex, i.uv1);
                
                outcolor *= 2;
                outcolor *= i.lgt;
                
                #ifndef QUALITY_LOW
                    fixed timeadd = _Time.y * 5 * _FlowSpeed;
                    
                    fixed uvshiftH = (timeadd - floor(timeadd)) * _FlowDirectionH;
                    fixed uvshiftV = (timeadd - floor(timeadd)) * _FlowDirectionV;
                    
                    fixed channelsB = tex2D(_ChanTex, i.uv1 + fixed2(uvshiftH, uvshiftV)).b;
                    outcolor += _FlowColor * channels.r * _FlowIntensity * channelsB;
                    
                    fixed delta = _SelfLuminousMax - _SelfLuminousMin;
                    outcolor += _SelfLuminousColor * channels.g * ((delta * 0.5 * sin(_Time.y * 10 * _SelfLuminousSpeed)) + (2 - _SelfLuminousMin) * 0.5) * _SelfLuminousIntensity;
                #endif
                
                return fixed4(outcolor.rgb, 1);
            }
            
            ENDCG
            
        }
        
        Pass
        {
            Name "EMISSION_FLOW_NEW"
            
            Cull Back
            Fog
            {
                Mode Off
            }
            
            CGPROGRAM
            
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag
            
            #pragma multi_compile_fwdbase
            #pragma multi_compile QUALITY_LOW QUALITY_MED QUALITY_HGH
            
            #pragma exclude_renderers flash
            
            #include "UnityCG.cginc"
            #include "SnxxzCG.cginc"
            
            struct vertexInput
            {
                half4 vertex: POSITION;
                half3 normal: NORMAL;
                half4 tangent: TANGENT;
                half2 texcoord0: TEXCOORD0;
                half2 texcoord1: TEXCOORD1;
            };
            
            struct v2f
            {
                // basics
                half4 pos: SV_POSITION;
                half2 uv0: TEXCOORD0;
                half2 uv1: TEXCOORD1;
                half3 lgt: TEXCOORD5;
            };
            
            // assets
            uniform sampler2D _MainTex;
            
            uniform sampler2D _EmissiveTex;
            fixed4    _EmissiveColor;
            fixed  _EmissiveSpeed;
            fixed  _EmissiveIntensity;
            fixed  _EmissiveMin;
            fixed  _EmissiveMax;
            
            uniform sampler2D _FlowTex; uniform float4 _FlowTex_ST;
            uniform float4 _FlowColor;
            uniform float _FlowSpeed;
            uniform float _PannerX;
            uniform float _PannerY;
            
            uniform half _Hit;
            
            v2f vert(vertexInput v)
            {
                v2f o = (v2f)0;
                
                // pos and uv tex coord
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv0 = v.texcoord0;
                o.uv1 = v.texcoord1;
                
                o.lgt = 0.6 + _Hit;
                return o;
            }
            
            fixed4 frag(v2f i): SV_TARGET
            {
                // textures
                fixed3 outcolor = tex2D(_MainTex, i.uv0);
                fixed3 channels = tex2D(_EmissiveTex, i.uv0);
                
                outcolor *= 2;
                outcolor *= i.lgt;
                
                fixed delta = _EmissiveMax - _EmissiveMin;
                outcolor += _EmissiveColor * channels.g * ((delta * 0.5 * sin(_Time.y * 10 * _EmissiveSpeed)) + (2 - _EmissiveMin) * 0.5) * _EmissiveIntensity;
                
                float2 uvTimeShift = (float2(0.0, (-1 * (_Time.g * _FlowSpeed))) + i.uv1);
                float flowR = tex2D(_FlowTex, TRANSFORM_TEX(uvTimeShift, _FlowTex)).r;
                float2 pannerUV = (i.uv1 + (float2(_PannerX, _PannerY) * _Time.g));
                float flowG = tex2D(_FlowTex, TRANSFORM_TEX(pannerUV, _FlowTex)).g;
                
                float clip = tex2D(_FlowTex, TRANSFORM_TEX(i.uv1, _FlowTex)).b;
                
                float3 flowColor = (flowR * flowG * _FlowColor.rgb * _FlowColor.a) * 5 * clip;
                return fixed4(outcolor.rgb + flowColor, 1);
            }
            
            ENDCG
            
        }
        
        Pass
        {
            Name "MONSTERNORMAL"
            
            Cull Back
            Lighting Off
            Fog
            {
                Mode Off
            }
            
            CGPROGRAM
            
            #pragma target 3.0
            #pragma vertex vert
            #pragma fragment frag
            
            #pragma multi_compile_fwdbase
            #pragma exclude_renderers flash
            
            #include "UnityCG.cginc"
            #include "SnxxzCG.cginc"
            
            struct vertexInput
            {
                half4 vertex: POSITION;
                half3 normal: NORMAL;
                half4 tangent: TANGENT;
                half2 texcoord: TEXCOORD0;
            };
            
            struct v2f
            {
                // basics
                half4 pos: SV_POSITION;
                half2 uv1: TEXCOORD0;
                half3 lgt: TEXCOORD1;
            };
            
            // assets
            uniform sampler2D _MainTex;
            // properties
            uniform half _Hit;
            uniform half _BaTi;
            uniform half _Rate;
            
            v2f vert(vertexInput v)
            {
                v2f o;
                
                // pos and uv tex coord
                o.pos = UnityObjectToClipPos(v.vertex);
                o.uv1 = v.texcoord;
                
                half hit = _Hit;
                half3 bati = half3(_BaTi, 0, 0) * sin(_Time * _Rate);
                o.lgt = 1 + hit + bati * bati;
                
                return o;
            }
            
            fixed4 frag(v2f i): SV_Target
            {
                
                // textures
                fixed3 outcolor = tex2D(_MainTex, i.uv1);
                outcolor *= i.lgt;
                
                return fixed4(outcolor.rgb, 1);
            }
            
            ENDCG
            
        }
    }
    
    FallBack "Diffuse"
}