source: other-projects/playing-in-the-street/summer-2013/trunk/Playing-in-the-Street-WPF/Content/Web/mrdoob-three.js-4862f5f/src/renderers/shaders/ShaderLib.js@ 28897

Last change on this file since 28897 was 28897, checked in by davidb, 10 years ago

GUI front-end to server base plus web page content
File size: 30.8 KB
Line 
1/**
2 * Webgl Shader Library for three.js
3 *
4 * @author alteredq / http://alteredqualia.com/
5 * @author mrdoob / http://mrdoob.com/
6 * @author mikael emtinger / http://gomo.se/
7 */
8
9
10THREE.ShaderLib = {
11
12 'basic': {
13
14 uniforms: THREE.UniformsUtils.merge( [
15
16 THREE.UniformsLib[ "common" ],
17 THREE.UniformsLib[ "fog" ],
18 THREE.UniformsLib[ "shadowmap" ]
19
20 ] ),
21
22 vertexShader: [
23
24 THREE.ShaderChunk[ "map_pars_vertex" ],
25 THREE.ShaderChunk[ "lightmap_pars_vertex" ],
26 THREE.ShaderChunk[ "envmap_pars_vertex" ],
27 THREE.ShaderChunk[ "color_pars_vertex" ],
28 THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
29 THREE.ShaderChunk[ "skinning_pars_vertex" ],
30 THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
31
32 "void main() {",
33
34 THREE.ShaderChunk[ "map_vertex" ],
35 THREE.ShaderChunk[ "lightmap_vertex" ],
36 THREE.ShaderChunk[ "color_vertex" ],
37 THREE.ShaderChunk[ "skinbase_vertex" ],
38
39 "#ifdef USE_ENVMAP",
40
41 THREE.ShaderChunk[ "morphnormal_vertex" ],
42 THREE.ShaderChunk[ "skinnormal_vertex" ],
43 THREE.ShaderChunk[ "defaultnormal_vertex" ],
44
45 "#endif",
46
47 THREE.ShaderChunk[ "morphtarget_vertex" ],
48 THREE.ShaderChunk[ "skinning_vertex" ],
49 THREE.ShaderChunk[ "default_vertex" ],
50
51 THREE.ShaderChunk[ "worldpos_vertex" ],
52 THREE.ShaderChunk[ "envmap_vertex" ],
53 THREE.ShaderChunk[ "shadowmap_vertex" ],
54
55 "}"
56
57 ].join("\n"),
58
59 fragmentShader: [
60
61 "uniform vec3 diffuse;",
62 "uniform float opacity;",
63
64 THREE.ShaderChunk[ "color_pars_fragment" ],
65 THREE.ShaderChunk[ "map_pars_fragment" ],
66 THREE.ShaderChunk[ "lightmap_pars_fragment" ],
67 THREE.ShaderChunk[ "envmap_pars_fragment" ],
68 THREE.ShaderChunk[ "fog_pars_fragment" ],
69 THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
70 THREE.ShaderChunk[ "specularmap_pars_fragment" ],
71
72 "void main() {",
73
74 "gl_FragColor = vec4( diffuse, opacity );",
75
76 THREE.ShaderChunk[ "map_fragment" ],
77 THREE.ShaderChunk[ "alphatest_fragment" ],
78 THREE.ShaderChunk[ "specularmap_fragment" ],
79 THREE.ShaderChunk[ "lightmap_fragment" ],
80 THREE.ShaderChunk[ "color_fragment" ],
81 THREE.ShaderChunk[ "envmap_fragment" ],
82 THREE.ShaderChunk[ "shadowmap_fragment" ],
83
84 THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
85
86 THREE.ShaderChunk[ "fog_fragment" ],
87
88 "}"
89
90 ].join("\n")
91
92 },
93
94 'lambert': {
95
96 uniforms: THREE.UniformsUtils.merge( [
97
98 THREE.UniformsLib[ "common" ],
99 THREE.UniformsLib[ "fog" ],
100 THREE.UniformsLib[ "lights" ],
101 THREE.UniformsLib[ "shadowmap" ],
102
103 {
104 "ambient" : { type: "c", value: new THREE.Color( 0xffffff ) },
105 "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
106 "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
107 }
108
109 ] ),
110
111 vertexShader: [
112
113 "#define LAMBERT",
114
115 "varying vec3 vLightFront;",
116
117 "#ifdef DOUBLE_SIDED",
118
119 "varying vec3 vLightBack;",
120
121 "#endif",
122
123 THREE.ShaderChunk[ "map_pars_vertex" ],
124 THREE.ShaderChunk[ "lightmap_pars_vertex" ],
125 THREE.ShaderChunk[ "envmap_pars_vertex" ],
126 THREE.ShaderChunk[ "lights_lambert_pars_vertex" ],
127 THREE.ShaderChunk[ "color_pars_vertex" ],
128 THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
129 THREE.ShaderChunk[ "skinning_pars_vertex" ],
130 THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
131
132 "void main() {",
133
134 THREE.ShaderChunk[ "map_vertex" ],
135 THREE.ShaderChunk[ "lightmap_vertex" ],
136 THREE.ShaderChunk[ "color_vertex" ],
137
138 THREE.ShaderChunk[ "morphnormal_vertex" ],
139 THREE.ShaderChunk[ "skinbase_vertex" ],
140 THREE.ShaderChunk[ "skinnormal_vertex" ],
141 THREE.ShaderChunk[ "defaultnormal_vertex" ],
142
143 THREE.ShaderChunk[ "morphtarget_vertex" ],
144 THREE.ShaderChunk[ "skinning_vertex" ],
145 THREE.ShaderChunk[ "default_vertex" ],
146
147 THREE.ShaderChunk[ "worldpos_vertex" ],
148 THREE.ShaderChunk[ "envmap_vertex" ],
149 THREE.ShaderChunk[ "lights_lambert_vertex" ],
150 THREE.ShaderChunk[ "shadowmap_vertex" ],
151
152 "}"
153
154 ].join("\n"),
155
156 fragmentShader: [
157
158 "uniform float opacity;",
159
160 "varying vec3 vLightFront;",
161
162 "#ifdef DOUBLE_SIDED",
163
164 "varying vec3 vLightBack;",
165
166 "#endif",
167
168 THREE.ShaderChunk[ "color_pars_fragment" ],
169 THREE.ShaderChunk[ "map_pars_fragment" ],
170 THREE.ShaderChunk[ "lightmap_pars_fragment" ],
171 THREE.ShaderChunk[ "envmap_pars_fragment" ],
172 THREE.ShaderChunk[ "fog_pars_fragment" ],
173 THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
174 THREE.ShaderChunk[ "specularmap_pars_fragment" ],
175
176 "void main() {",
177
178 "gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
179
180 THREE.ShaderChunk[ "map_fragment" ],
181 THREE.ShaderChunk[ "alphatest_fragment" ],
182 THREE.ShaderChunk[ "specularmap_fragment" ],
183
184 "#ifdef DOUBLE_SIDED",
185
186 //"float isFront = float( gl_FrontFacing );",
187 //"gl_FragColor.xyz *= isFront * vLightFront + ( 1.0 - isFront ) * vLightBack;",
188
189 "if ( gl_FrontFacing )",
190 "gl_FragColor.xyz *= vLightFront;",
191 "else",
192 "gl_FragColor.xyz *= vLightBack;",
193
194 "#else",
195
196 "gl_FragColor.xyz *= vLightFront;",
197
198 "#endif",
199
200 THREE.ShaderChunk[ "lightmap_fragment" ],
201 THREE.ShaderChunk[ "color_fragment" ],
202 THREE.ShaderChunk[ "envmap_fragment" ],
203 THREE.ShaderChunk[ "shadowmap_fragment" ],
204
205 THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
206
207 THREE.ShaderChunk[ "fog_fragment" ],
208
209 "}"
210
211 ].join("\n")
212
213 },
214
215 'phong': {
216
217 uniforms: THREE.UniformsUtils.merge( [
218
219 THREE.UniformsLib[ "common" ],
220 THREE.UniformsLib[ "bump" ],
221 THREE.UniformsLib[ "normalmap" ],
222 THREE.UniformsLib[ "fog" ],
223 THREE.UniformsLib[ "lights" ],
224 THREE.UniformsLib[ "shadowmap" ],
225
226 {
227 "ambient" : { type: "c", value: new THREE.Color( 0xffffff ) },
228 "emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
229 "specular" : { type: "c", value: new THREE.Color( 0x111111 ) },
230 "shininess": { type: "f", value: 30 },
231 "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
232 }
233
234 ] ),
235
236 vertexShader: [
237
238 "#define PHONG",
239
240 "varying vec3 vViewPosition;",
241 "varying vec3 vNormal;",
242
243 THREE.ShaderChunk[ "map_pars_vertex" ],
244 THREE.ShaderChunk[ "lightmap_pars_vertex" ],
245 THREE.ShaderChunk[ "envmap_pars_vertex" ],
246 THREE.ShaderChunk[ "lights_phong_pars_vertex" ],
247 THREE.ShaderChunk[ "color_pars_vertex" ],
248 THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
249 THREE.ShaderChunk[ "skinning_pars_vertex" ],
250 THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
251
252 "void main() {",
253
254 THREE.ShaderChunk[ "map_vertex" ],
255 THREE.ShaderChunk[ "lightmap_vertex" ],
256 THREE.ShaderChunk[ "color_vertex" ],
257
258 THREE.ShaderChunk[ "morphnormal_vertex" ],
259 THREE.ShaderChunk[ "skinbase_vertex" ],
260 THREE.ShaderChunk[ "skinnormal_vertex" ],
261 THREE.ShaderChunk[ "defaultnormal_vertex" ],
262
263 "vNormal = normalize( transformedNormal );",
264
265 THREE.ShaderChunk[ "morphtarget_vertex" ],
266 THREE.ShaderChunk[ "skinning_vertex" ],
267 THREE.ShaderChunk[ "default_vertex" ],
268
269 "vViewPosition = -mvPosition.xyz;",
270
271 THREE.ShaderChunk[ "worldpos_vertex" ],
272 THREE.ShaderChunk[ "envmap_vertex" ],
273 THREE.ShaderChunk[ "lights_phong_vertex" ],
274 THREE.ShaderChunk[ "shadowmap_vertex" ],
275
276 "}"
277
278 ].join("\n"),
279
280 fragmentShader: [
281
282 "uniform vec3 diffuse;",
283 "uniform float opacity;",
284
285 "uniform vec3 ambient;",
286 "uniform vec3 emissive;",
287 "uniform vec3 specular;",
288 "uniform float shininess;",
289
290 THREE.ShaderChunk[ "color_pars_fragment" ],
291 THREE.ShaderChunk[ "map_pars_fragment" ],
292 THREE.ShaderChunk[ "lightmap_pars_fragment" ],
293 THREE.ShaderChunk[ "envmap_pars_fragment" ],
294 THREE.ShaderChunk[ "fog_pars_fragment" ],
295 THREE.ShaderChunk[ "lights_phong_pars_fragment" ],
296 THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
297 THREE.ShaderChunk[ "bumpmap_pars_fragment" ],
298 THREE.ShaderChunk[ "normalmap_pars_fragment" ],
299 THREE.ShaderChunk[ "specularmap_pars_fragment" ],
300
301 "void main() {",
302
303 "gl_FragColor = vec4( vec3 ( 1.0 ), opacity );",
304
305 THREE.ShaderChunk[ "map_fragment" ],
306 THREE.ShaderChunk[ "alphatest_fragment" ],
307 THREE.ShaderChunk[ "specularmap_fragment" ],
308
309 THREE.ShaderChunk[ "lights_phong_fragment" ],
310
311 THREE.ShaderChunk[ "lightmap_fragment" ],
312 THREE.ShaderChunk[ "color_fragment" ],
313 THREE.ShaderChunk[ "envmap_fragment" ],
314 THREE.ShaderChunk[ "shadowmap_fragment" ],
315
316 THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
317
318 THREE.ShaderChunk[ "fog_fragment" ],
319
320 "}"
321
322 ].join("\n")
323
324 },
325
326 'particle_basic': {
327
328 uniforms: THREE.UniformsUtils.merge( [
329
330 THREE.UniformsLib[ "particle" ],
331 THREE.UniformsLib[ "shadowmap" ]
332
333 ] ),
334
335 vertexShader: [
336
337 "uniform float size;",
338 "uniform float scale;",
339
340 THREE.ShaderChunk[ "color_pars_vertex" ],
341 THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
342
343 "void main() {",
344
345 THREE.ShaderChunk[ "color_vertex" ],
346
347 "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
348
349 "#ifdef USE_SIZEATTENUATION",
350 "gl_PointSize = size * ( scale / length( mvPosition.xyz ) );",
351 "#else",
352 "gl_PointSize = size;",
353 "#endif",
354
355 "gl_Position = projectionMatrix * mvPosition;",
356
357 THREE.ShaderChunk[ "worldpos_vertex" ],
358 THREE.ShaderChunk[ "shadowmap_vertex" ],
359
360 "}"
361
362 ].join("\n"),
363
364 fragmentShader: [
365
366 "uniform vec3 psColor;",
367 "uniform float opacity;",
368
369 THREE.ShaderChunk[ "color_pars_fragment" ],
370 THREE.ShaderChunk[ "map_particle_pars_fragment" ],
371 THREE.ShaderChunk[ "fog_pars_fragment" ],
372 THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
373
374 "void main() {",
375
376 "gl_FragColor = vec4( psColor, opacity );",
377
378 THREE.ShaderChunk[ "map_particle_fragment" ],
379 THREE.ShaderChunk[ "alphatest_fragment" ],
380 THREE.ShaderChunk[ "color_fragment" ],
381 THREE.ShaderChunk[ "shadowmap_fragment" ],
382 THREE.ShaderChunk[ "fog_fragment" ],
383
384 "}"
385
386 ].join("\n")
387
388 },
389
390 'dashed': {
391
392 uniforms: THREE.UniformsUtils.merge( [
393
394 THREE.UniformsLib[ "common" ],
395 THREE.UniformsLib[ "fog" ],
396
397 {
398 "scale": { type: "f", value: 1 },
399 "dashSize": { type: "f", value: 1 },
400 "totalSize": { type: "f", value: 2 }
401 }
402
403 ] ),
404
405 vertexShader: [
406
407 "uniform float scale;",
408 "attribute float lineDistance;",
409
410 "varying float vLineDistance;",
411
412 THREE.ShaderChunk[ "color_pars_vertex" ],
413
414 "void main() {",
415
416 THREE.ShaderChunk[ "color_vertex" ],
417
418 "vLineDistance = scale * lineDistance;",
419
420 "vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );",
421 "gl_Position = projectionMatrix * mvPosition;",
422
423 "}"
424
425 ].join("\n"),
426
427 fragmentShader: [
428
429 "uniform vec3 diffuse;",
430 "uniform float opacity;",
431
432 "uniform float dashSize;",
433 "uniform float totalSize;",
434
435 "varying float vLineDistance;",
436
437 THREE.ShaderChunk[ "color_pars_fragment" ],
438 THREE.ShaderChunk[ "fog_pars_fragment" ],
439
440 "void main() {",
441
442 "if ( mod( vLineDistance, totalSize ) > dashSize ) {",
443
444 "discard;",
445
446 "}",
447
448 "gl_FragColor = vec4( diffuse, opacity );",
449
450 THREE.ShaderChunk[ "color_fragment" ],
451 THREE.ShaderChunk[ "fog_fragment" ],
452
453 "}"
454
455 ].join("\n")
456
457 },
458
459 'depth': {
460
461 uniforms: {
462
463 "mNear": { type: "f", value: 1.0 },
464 "mFar" : { type: "f", value: 2000.0 },
465 "opacity" : { type: "f", value: 1.0 }
466
467 },
468
469 vertexShader: [
470
471 "void main() {",
472
473 "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
474
475 "}"
476
477 ].join("\n"),
478
479 fragmentShader: [
480
481 "uniform float mNear;",
482 "uniform float mFar;",
483 "uniform float opacity;",
484
485 "void main() {",
486
487 "float depth = gl_FragCoord.z / gl_FragCoord.w;",
488 "float color = 1.0 - smoothstep( mNear, mFar, depth );",
489 "gl_FragColor = vec4( vec3( color ), opacity );",
490
491 "}"
492
493 ].join("\n")
494
495 },
496
497 'normal': {
498
499 uniforms: {
500
501 "opacity" : { type: "f", value: 1.0 }
502
503 },
504
505 vertexShader: [
506
507 "varying vec3 vNormal;",
508
509 THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
510
511 "void main() {",
512
513 "vNormal = normalize( normalMatrix * normal );",
514
515 THREE.ShaderChunk[ "morphtarget_vertex" ],
516 THREE.ShaderChunk[ "default_vertex" ],
517
518 "}"
519
520 ].join("\n"),
521
522 fragmentShader: [
523
524 "uniform float opacity;",
525 "varying vec3 vNormal;",
526
527 "void main() {",
528
529 "gl_FragColor = vec4( 0.5 * normalize( vNormal ) + 0.5, opacity );",
530
531 "}"
532
533 ].join("\n")
534
535 },
536
537 /* -------------------------------------------------------------------------
538 // Normal map shader
539 // - Blinn-Phong
540 // - normal + diffuse + specular + AO + displacement + reflection + shadow maps
541 // - point and directional lights (use with "lights: true" material option)
542 ------------------------------------------------------------------------- */
543
544 'normalmap' : {
545
546 uniforms: THREE.UniformsUtils.merge( [
547
548 THREE.UniformsLib[ "fog" ],
549 THREE.UniformsLib[ "lights" ],
550 THREE.UniformsLib[ "shadowmap" ],
551
552 {
553
554 "enableAO" : { type: "i", value: 0 },
555 "enableDiffuse" : { type: "i", value: 0 },
556 "enableSpecular" : { type: "i", value: 0 },
557 "enableReflection": { type: "i", value: 0 },
558 "enableDisplacement": { type: "i", value: 0 },
559
560 "tDisplacement": { type: "t", value: null }, // must go first as this is vertex texture
561 "tDiffuse" : { type: "t", value: null },
562 "tCube" : { type: "t", value: null },
563 "tNormal" : { type: "t", value: null },
564 "tSpecular" : { type: "t", value: null },
565 "tAO" : { type: "t", value: null },
566
567 "uNormalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) },
568
569 "uDisplacementBias": { type: "f", value: 0.0 },
570 "uDisplacementScale": { type: "f", value: 1.0 },
571
572 "diffuse": { type: "c", value: new THREE.Color( 0xffffff ) },
573 "specular": { type: "c", value: new THREE.Color( 0x111111 ) },
574 "ambient": { type: "c", value: new THREE.Color( 0xffffff ) },
575 "shininess": { type: "f", value: 30 },
576 "opacity": { type: "f", value: 1 },
577
578 "useRefract": { type: "i", value: 0 },
579 "refractionRatio": { type: "f", value: 0.98 },
580 "reflectivity": { type: "f", value: 0.5 },
581
582 "uOffset" : { type: "v2", value: new THREE.Vector2( 0, 0 ) },
583 "uRepeat" : { type: "v2", value: new THREE.Vector2( 1, 1 ) },
584
585 "wrapRGB" : { type: "v3", value: new THREE.Vector3( 1, 1, 1 ) }
586
587 }
588
589 ] ),
590
591 fragmentShader: [
592
593 "uniform vec3 ambient;",
594 "uniform vec3 diffuse;",
595 "uniform vec3 specular;",
596 "uniform float shininess;",
597 "uniform float opacity;",
598
599 "uniform bool enableDiffuse;",
600 "uniform bool enableSpecular;",
601 "uniform bool enableAO;",
602 "uniform bool enableReflection;",
603
604 "uniform sampler2D tDiffuse;",
605 "uniform sampler2D tNormal;",
606 "uniform sampler2D tSpecular;",
607 "uniform sampler2D tAO;",
608
609 "uniform samplerCube tCube;",
610
611 "uniform vec2 uNormalScale;",
612
613 "uniform bool useRefract;",
614 "uniform float refractionRatio;",
615 "uniform float reflectivity;",
616
617 "varying vec3 vTangent;",
618 "varying vec3 vBinormal;",
619 "varying vec3 vNormal;",
620 "varying vec2 vUv;",
621
622 "uniform vec3 ambientLightColor;",
623
624 "#if MAX_DIR_LIGHTS > 0",
625
626 "uniform vec3 directionalLightColor[ MAX_DIR_LIGHTS ];",
627 "uniform vec3 directionalLightDirection[ MAX_DIR_LIGHTS ];",
628
629 "#endif",
630
631 "#if MAX_HEMI_LIGHTS > 0",
632
633 "uniform vec3 hemisphereLightSkyColor[ MAX_HEMI_LIGHTS ];",
634 "uniform vec3 hemisphereLightGroundColor[ MAX_HEMI_LIGHTS ];",
635 "uniform vec3 hemisphereLightDirection[ MAX_HEMI_LIGHTS ];",
636
637 "#endif",
638
639 "#if MAX_POINT_LIGHTS > 0",
640
641 "uniform vec3 pointLightColor[ MAX_POINT_LIGHTS ];",
642 "uniform vec3 pointLightPosition[ MAX_POINT_LIGHTS ];",
643 "uniform float pointLightDistance[ MAX_POINT_LIGHTS ];",
644
645 "#endif",
646
647 "#if MAX_SPOT_LIGHTS > 0",
648
649 "uniform vec3 spotLightColor[ MAX_SPOT_LIGHTS ];",
650 "uniform vec3 spotLightPosition[ MAX_SPOT_LIGHTS ];",
651 "uniform vec3 spotLightDirection[ MAX_SPOT_LIGHTS ];",
652 "uniform float spotLightAngleCos[ MAX_SPOT_LIGHTS ];",
653 "uniform float spotLightExponent[ MAX_SPOT_LIGHTS ];",
654 "uniform float spotLightDistance[ MAX_SPOT_LIGHTS ];",
655
656 "#endif",
657
658 "#ifdef WRAP_AROUND",
659
660 "uniform vec3 wrapRGB;",
661
662 "#endif",
663
664 "varying vec3 vWorldPosition;",
665 "varying vec3 vViewPosition;",
666
667 THREE.ShaderChunk[ "shadowmap_pars_fragment" ],
668 THREE.ShaderChunk[ "fog_pars_fragment" ],
669
670 "void main() {",
671
672 "gl_FragColor = vec4( vec3( 1.0 ), opacity );",
673
674 "vec3 specularTex = vec3( 1.0 );",
675
676 "vec3 normalTex = texture2D( tNormal, vUv ).xyz * 2.0 - 1.0;",
677 "normalTex.xy *= uNormalScale;",
678 "normalTex = normalize( normalTex );",
679
680 "if( enableDiffuse ) {",
681
682 "#ifdef GAMMA_INPUT",
683
684 "vec4 texelColor = texture2D( tDiffuse, vUv );",
685 "texelColor.xyz *= texelColor.xyz;",
686
687 "gl_FragColor = gl_FragColor * texelColor;",
688
689 "#else",
690
691 "gl_FragColor = gl_FragColor * texture2D( tDiffuse, vUv );",
692
693 "#endif",
694
695 "}",
696
697 "if( enableAO ) {",
698
699 "#ifdef GAMMA_INPUT",
700
701 "vec4 aoColor = texture2D( tAO, vUv );",
702 "aoColor.xyz *= aoColor.xyz;",
703
704 "gl_FragColor.xyz = gl_FragColor.xyz * aoColor.xyz;",
705
706 "#else",
707
708 "gl_FragColor.xyz = gl_FragColor.xyz * texture2D( tAO, vUv ).xyz;",
709
710 "#endif",
711
712 "}",
713
714 "if( enableSpecular )",
715 "specularTex = texture2D( tSpecular, vUv ).xyz;",
716
717 "mat3 tsb = mat3( normalize( vTangent ), normalize( vBinormal ), normalize( vNormal ) );",
718 "vec3 finalNormal = tsb * normalTex;",
719
720 "#ifdef FLIP_SIDED",
721
722 "finalNormal = -finalNormal;",
723
724 "#endif",
725
726 "vec3 normal = normalize( finalNormal );",
727 "vec3 viewPosition = normalize( vViewPosition );",
728
729 // point lights
730
731 "#if MAX_POINT_LIGHTS > 0",
732
733 "vec3 pointDiffuse = vec3( 0.0 );",
734 "vec3 pointSpecular = vec3( 0.0 );",
735
736 "for ( int i = 0; i < MAX_POINT_LIGHTS; i ++ ) {",
737
738 "vec4 lPosition = viewMatrix * vec4( pointLightPosition[ i ], 1.0 );",
739 "vec3 pointVector = lPosition.xyz + vViewPosition.xyz;",
740
741 "float pointDistance = 1.0;",
742 "if ( pointLightDistance[ i ] > 0.0 )",
743 "pointDistance = 1.0 - min( ( length( pointVector ) / pointLightDistance[ i ] ), 1.0 );",
744
745 "pointVector = normalize( pointVector );",
746
747 // diffuse
748
749 "#ifdef WRAP_AROUND",
750
751 "float pointDiffuseWeightFull = max( dot( normal, pointVector ), 0.0 );",
752 "float pointDiffuseWeightHalf = max( 0.5 * dot( normal, pointVector ) + 0.5, 0.0 );",
753
754 "vec3 pointDiffuseWeight = mix( vec3 ( pointDiffuseWeightFull ), vec3( pointDiffuseWeightHalf ), wrapRGB );",
755
756 "#else",
757
758 "float pointDiffuseWeight = max( dot( normal, pointVector ), 0.0 );",
759
760 "#endif",
761
762 "pointDiffuse += pointDistance * pointLightColor[ i ] * diffuse * pointDiffuseWeight;",
763
764 // specular
765
766 "vec3 pointHalfVector = normalize( pointVector + viewPosition );",
767 "float pointDotNormalHalf = max( dot( normal, pointHalfVector ), 0.0 );",
768 "float pointSpecularWeight = specularTex.r * max( pow( pointDotNormalHalf, shininess ), 0.0 );",
769
770 // 2.0 => 2.0001 is hack to work around ANGLE bug
771
772 "float specularNormalization = ( shininess + 2.0001 ) / 8.0;",
773
774 "vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( pointVector, pointHalfVector ), 5.0 );",
775 "pointSpecular += schlick * pointLightColor[ i ] * pointSpecularWeight * pointDiffuseWeight * pointDistance * specularNormalization;",
776
777 "}",
778
779 "#endif",
780
781 // spot lights
782
783 "#if MAX_SPOT_LIGHTS > 0",
784
785 "vec3 spotDiffuse = vec3( 0.0 );",
786 "vec3 spotSpecular = vec3( 0.0 );",
787
788 "for ( int i = 0; i < MAX_SPOT_LIGHTS; i ++ ) {",
789
790 "vec4 lPosition = viewMatrix * vec4( spotLightPosition[ i ], 1.0 );",
791 "vec3 spotVector = lPosition.xyz + vViewPosition.xyz;",
792
793 "float spotDistance = 1.0;",
794 "if ( spotLightDistance[ i ] > 0.0 )",
795 "spotDistance = 1.0 - min( ( length( spotVector ) / spotLightDistance[ i ] ), 1.0 );",
796
797 "spotVector = normalize( spotVector );",
798
799 "float spotEffect = dot( spotLightDirection[ i ], normalize( spotLightPosition[ i ] - vWorldPosition ) );",
800
801 "if ( spotEffect > spotLightAngleCos[ i ] ) {",
802
803 "spotEffect = max( pow( spotEffect, spotLightExponent[ i ] ), 0.0 );",
804
805 // diffuse
806
807 "#ifdef WRAP_AROUND",
808
809 "float spotDiffuseWeightFull = max( dot( normal, spotVector ), 0.0 );",
810 "float spotDiffuseWeightHalf = max( 0.5 * dot( normal, spotVector ) + 0.5, 0.0 );",
811
812 "vec3 spotDiffuseWeight = mix( vec3 ( spotDiffuseWeightFull ), vec3( spotDiffuseWeightHalf ), wrapRGB );",
813
814 "#else",
815
816 "float spotDiffuseWeight = max( dot( normal, spotVector ), 0.0 );",
817
818 "#endif",
819
820 "spotDiffuse += spotDistance * spotLightColor[ i ] * diffuse * spotDiffuseWeight * spotEffect;",
821
822 // specular
823
824 "vec3 spotHalfVector = normalize( spotVector + viewPosition );",
825 "float spotDotNormalHalf = max( dot( normal, spotHalfVector ), 0.0 );",
826 "float spotSpecularWeight = specularTex.r * max( pow( spotDotNormalHalf, shininess ), 0.0 );",
827
828 // 2.0 => 2.0001 is hack to work around ANGLE bug
829
830 "float specularNormalization = ( shininess + 2.0001 ) / 8.0;",
831
832 "vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( spotVector, spotHalfVector ), 5.0 );",
833 "spotSpecular += schlick * spotLightColor[ i ] * spotSpecularWeight * spotDiffuseWeight * spotDistance * specularNormalization * spotEffect;",
834
835 "}",
836
837 "}",
838
839 "#endif",
840
841 // directional lights
842
843 "#if MAX_DIR_LIGHTS > 0",
844
845 "vec3 dirDiffuse = vec3( 0.0 );",
846 "vec3 dirSpecular = vec3( 0.0 );",
847
848 "for( int i = 0; i < MAX_DIR_LIGHTS; i++ ) {",
849
850 "vec4 lDirection = viewMatrix * vec4( directionalLightDirection[ i ], 0.0 );",
851 "vec3 dirVector = normalize( lDirection.xyz );",
852
853 // diffuse
854
855 "#ifdef WRAP_AROUND",
856
857 "float directionalLightWeightingFull = max( dot( normal, dirVector ), 0.0 );",
858 "float directionalLightWeightingHalf = max( 0.5 * dot( normal, dirVector ) + 0.5, 0.0 );",
859
860 "vec3 dirDiffuseWeight = mix( vec3( directionalLightWeightingFull ), vec3( directionalLightWeightingHalf ), wrapRGB );",
861
862 "#else",
863
864 "float dirDiffuseWeight = max( dot( normal, dirVector ), 0.0 );",
865
866 "#endif",
867
868 "dirDiffuse += directionalLightColor[ i ] * diffuse * dirDiffuseWeight;",
869
870 // specular
871
872 "vec3 dirHalfVector = normalize( dirVector + viewPosition );",
873 "float dirDotNormalHalf = max( dot( normal, dirHalfVector ), 0.0 );",
874 "float dirSpecularWeight = specularTex.r * max( pow( dirDotNormalHalf, shininess ), 0.0 );",
875
876 // 2.0 => 2.0001 is hack to work around ANGLE bug
877
878 "float specularNormalization = ( shininess + 2.0001 ) / 8.0;",
879
880 "vec3 schlick = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( dirVector, dirHalfVector ), 5.0 );",
881 "dirSpecular += schlick * directionalLightColor[ i ] * dirSpecularWeight * dirDiffuseWeight * specularNormalization;",
882
883 "}",
884
885 "#endif",
886
887 // hemisphere lights
888
889 "#if MAX_HEMI_LIGHTS > 0",
890
891 "vec3 hemiDiffuse = vec3( 0.0 );",
892 "vec3 hemiSpecular = vec3( 0.0 );" ,
893
894 "for( int i = 0; i < MAX_HEMI_LIGHTS; i ++ ) {",
895
896 "vec4 lDirection = viewMatrix * vec4( hemisphereLightDirection[ i ], 0.0 );",
897 "vec3 lVector = normalize( lDirection.xyz );",
898
899 // diffuse
900
901 "float dotProduct = dot( normal, lVector );",
902 "float hemiDiffuseWeight = 0.5 * dotProduct + 0.5;",
903
904 "vec3 hemiColor = mix( hemisphereLightGroundColor[ i ], hemisphereLightSkyColor[ i ], hemiDiffuseWeight );",
905
906 "hemiDiffuse += diffuse * hemiColor;",
907
908 // specular (sky light)
909
910
911 "vec3 hemiHalfVectorSky = normalize( lVector + viewPosition );",
912 "float hemiDotNormalHalfSky = 0.5 * dot( normal, hemiHalfVectorSky ) + 0.5;",
913 "float hemiSpecularWeightSky = specularTex.r * max( pow( hemiDotNormalHalfSky, shininess ), 0.0 );",
914
915 // specular (ground light)
916
917 "vec3 lVectorGround = -lVector;",
918
919 "vec3 hemiHalfVectorGround = normalize( lVectorGround + viewPosition );",
920 "float hemiDotNormalHalfGround = 0.5 * dot( normal, hemiHalfVectorGround ) + 0.5;",
921 "float hemiSpecularWeightGround = specularTex.r * max( pow( hemiDotNormalHalfGround, shininess ), 0.0 );",
922
923 "float dotProductGround = dot( normal, lVectorGround );",
924
925 // 2.0 => 2.0001 is hack to work around ANGLE bug
926
927 "float specularNormalization = ( shininess + 2.0001 ) / 8.0;",
928
929 "vec3 schlickSky = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVector, hemiHalfVectorSky ), 5.0 );",
930 "vec3 schlickGround = specular + vec3( 1.0 - specular ) * pow( 1.0 - dot( lVectorGround, hemiHalfVectorGround ), 5.0 );",
931 "hemiSpecular += hemiColor * specularNormalization * ( schlickSky * hemiSpecularWeightSky * max( dotProduct, 0.0 ) + schlickGround * hemiSpecularWeightGround * max( dotProductGround, 0.0 ) );",
932
933 "}",
934
935 "#endif",
936
937 // all lights contribution summation
938
939 "vec3 totalDiffuse = vec3( 0.0 );",
940 "vec3 totalSpecular = vec3( 0.0 );",
941
942 "#if MAX_DIR_LIGHTS > 0",
943
944 "totalDiffuse += dirDiffuse;",
945 "totalSpecular += dirSpecular;",
946
947 "#endif",
948
949 "#if MAX_HEMI_LIGHTS > 0",
950
951 "totalDiffuse += hemiDiffuse;",
952 "totalSpecular += hemiSpecular;",
953
954 "#endif",
955
956 "#if MAX_POINT_LIGHTS > 0",
957
958 "totalDiffuse += pointDiffuse;",
959 "totalSpecular += pointSpecular;",
960
961 "#endif",
962
963 "#if MAX_SPOT_LIGHTS > 0",
964
965 "totalDiffuse += spotDiffuse;",
966 "totalSpecular += spotSpecular;",
967
968 "#endif",
969
970 "#ifdef METAL",
971
972 "gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * ambient + totalSpecular );",
973
974 "#else",
975
976 "gl_FragColor.xyz = gl_FragColor.xyz * ( totalDiffuse + ambientLightColor * ambient ) + totalSpecular;",
977
978 "#endif",
979
980 "if ( enableReflection ) {",
981
982 "vec3 vReflect;",
983 "vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );",
984
985 "if ( useRefract ) {",
986
987 "vReflect = refract( cameraToVertex, normal, refractionRatio );",
988
989 "} else {",
990
991 "vReflect = reflect( cameraToVertex, normal );",
992
993 "}",
994
995 "vec4 cubeColor = textureCube( tCube, vec3( -vReflect.x, vReflect.yz ) );",
996
997 "#ifdef GAMMA_INPUT",
998
999 "cubeColor.xyz *= cubeColor.xyz;",
1000
1001 "#endif",
1002
1003 "gl_FragColor.xyz = mix( gl_FragColor.xyz, cubeColor.xyz, specularTex.r * reflectivity );",
1004
1005 "}",
1006
1007 THREE.ShaderChunk[ "shadowmap_fragment" ],
1008 THREE.ShaderChunk[ "linear_to_gamma_fragment" ],
1009 THREE.ShaderChunk[ "fog_fragment" ],
1010
1011 "}"
1012
1013 ].join("\n"),
1014
1015 vertexShader: [
1016
1017 "attribute vec4 tangent;",
1018
1019 "uniform vec2 uOffset;",
1020 "uniform vec2 uRepeat;",
1021
1022 "uniform bool enableDisplacement;",
1023
1024 "#ifdef VERTEX_TEXTURES",
1025
1026 "uniform sampler2D tDisplacement;",
1027 "uniform float uDisplacementScale;",
1028 "uniform float uDisplacementBias;",
1029
1030 "#endif",
1031
1032 "varying vec3 vTangent;",
1033 "varying vec3 vBinormal;",
1034 "varying vec3 vNormal;",
1035 "varying vec2 vUv;",
1036
1037 "varying vec3 vWorldPosition;",
1038 "varying vec3 vViewPosition;",
1039
1040 THREE.ShaderChunk[ "skinning_pars_vertex" ],
1041 THREE.ShaderChunk[ "shadowmap_pars_vertex" ],
1042
1043 "void main() {",
1044
1045 THREE.ShaderChunk[ "skinbase_vertex" ],
1046 THREE.ShaderChunk[ "skinnormal_vertex" ],
1047
1048 // normal, tangent and binormal vectors
1049
1050 "#ifdef USE_SKINNING",
1051
1052 "vNormal = normalize( normalMatrix * skinnedNormal.xyz );",
1053
1054 "vec4 skinnedTangent = skinMatrix * vec4( tangent.xyz, 0.0 );",
1055 "vTangent = normalize( normalMatrix * skinnedTangent.xyz );",
1056
1057 "#else",
1058
1059 "vNormal = normalize( normalMatrix * normal );",
1060 "vTangent = normalize( normalMatrix * tangent.xyz );",
1061
1062 "#endif",
1063
1064 "vBinormal = normalize( cross( vNormal, vTangent ) * tangent.w );",
1065
1066 "vUv = uv * uRepeat + uOffset;",
1067
1068 // displacement mapping
1069
1070 "vec3 displacedPosition;",
1071
1072 "#ifdef VERTEX_TEXTURES",
1073
1074 "if ( enableDisplacement ) {",
1075
1076 "vec3 dv = texture2D( tDisplacement, uv ).xyz;",
1077 "float df = uDisplacementScale * dv.x + uDisplacementBias;",
1078 "displacedPosition = position + normalize( normal ) * df;",
1079
1080 "} else {",
1081
1082 "#ifdef USE_SKINNING",
1083
1084 "vec4 skinVertex = vec4( position, 1.0 );",
1085
1086 "vec4 skinned = boneMatX * skinVertex * skinWeight.x;",
1087 "skinned += boneMatY * skinVertex * skinWeight.y;",
1088
1089 "displacedPosition = skinned.xyz;",
1090
1091 "#else",
1092
1093 "displacedPosition = position;",
1094
1095 "#endif",
1096
1097 "}",
1098
1099 "#else",
1100
1101 "#ifdef USE_SKINNING",
1102
1103 "vec4 skinVertex = vec4( position, 1.0 );",
1104
1105 "vec4 skinned = boneMatX * skinVertex * skinWeight.x;",
1106 "skinned += boneMatY * skinVertex * skinWeight.y;",
1107
1108 "displacedPosition = skinned.xyz;",
1109
1110 "#else",
1111
1112 "displacedPosition = position;",
1113
1114 "#endif",
1115
1116 "#endif",
1117
1118 //
1119
1120 "vec4 mvPosition = modelViewMatrix * vec4( displacedPosition, 1.0 );",
1121 "vec4 worldPosition = modelMatrix * vec4( displacedPosition, 1.0 );",
1122
1123 "gl_Position = projectionMatrix * mvPosition;",
1124
1125 //
1126
1127 "vWorldPosition = worldPosition.xyz;",
1128 "vViewPosition = -mvPosition.xyz;",
1129
1130 // shadows
1131
1132 "#ifdef USE_SHADOWMAP",
1133
1134 "for( int i = 0; i < MAX_SHADOWS; i ++ ) {",
1135
1136 "vShadowCoord[ i ] = shadowMatrix[ i ] * worldPosition;",
1137
1138 "}",
1139
1140 "#endif",
1141
1142 "}"
1143
1144 ].join("\n")
1145
1146 },
1147
1148 /* -------------------------------------------------------------------------
1149 // Cube map shader
1150 ------------------------------------------------------------------------- */
1151
1152 'cube': {
1153
1154 uniforms: { "tCube": { type: "t", value: null },
1155 "tFlip": { type: "f", value: -1 } },
1156
1157 vertexShader: [
1158
1159 "varying vec3 vWorldPosition;",
1160
1161 "void main() {",
1162
1163 "vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
1164 "vWorldPosition = worldPosition.xyz;",
1165
1166 "gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
1167
1168 "}"
1169
1170 ].join("\n"),
1171
1172 fragmentShader: [
1173
1174 "uniform samplerCube tCube;",
1175 "uniform float tFlip;",
1176
1177 "varying vec3 vWorldPosition;",
1178
1179 "void main() {",
1180
1181 "gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );",
1182
1183 "}"
1184
1185 ].join("\n")
1186
1187 },
1188
1189 // Depth encoding into RGBA texture
1190 // based on SpiderGL shadow map example
1191 // http://spidergl.org/example.php?id=6
1192 // originally from
1193 // http://www.gamedev.net/topic/442138-packing-a-float-into-a-a8r8g8b8-texture-shader/page__whichpage__1%25EF%25BF%25BD
1194 // see also here:
1195 // http://aras-p.info/blog/2009/07/30/encoding-floats-to-rgba-the-final/
1196
1197 'depthRGBA': {
1198
1199 uniforms: {},
1200
1201 vertexShader: [
1202
1203 THREE.ShaderChunk[ "morphtarget_pars_vertex" ],
1204 THREE.ShaderChunk[ "skinning_pars_vertex" ],
1205
1206 "void main() {",
1207
1208 THREE.ShaderChunk[ "skinbase_vertex" ],
1209 THREE.ShaderChunk[ "morphtarget_vertex" ],
1210 THREE.ShaderChunk[ "skinning_vertex" ],
1211 THREE.ShaderChunk[ "default_vertex" ],
1212
1213 "}"
1214
1215 ].join("\n"),
1216
1217 fragmentShader: [
1218
1219 "vec4 pack_depth( const in float depth ) {",
1220
1221 "const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );",
1222 "const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );",
1223 "vec4 res = fract( depth * bit_shift );",
1224 "res -= res.xxyz * bit_mask;",
1225 "return res;",
1226
1227 "}",
1228
1229 "void main() {",
1230
1231 "gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z );",
1232
1233 //"gl_FragData[ 0 ] = pack_depth( gl_FragCoord.z / gl_FragCoord.w );",
1234 //"float z = ( ( gl_FragCoord.z / gl_FragCoord.w ) - 3.0 ) / ( 4000.0 - 3.0 );",
1235 //"gl_FragData[ 0 ] = pack_depth( z );",
1236 //"gl_FragData[ 0 ] = vec4( z, z, z, 1.0 );",
1237
1238 "}"
1239
1240 ].join("\n")
1241
1242 }
1243
1244};
Note: See TracBrowser for help on using the repository browser.