https://carauto.app/vendor/three/three.core.js

77
78 */
79const PCFSoftShadowMap = 2;
80
81/**
82 * Filters shadow maps using the Variance Shadow Map (VSM) algorithm.
83 * When using VSMShadowMap all shadow receivers will also cast shadows.
84 *
85 * @type {number}
86 * @constant
87 */
88const VSMShadowMap = 3;
89
90/**
91 * Only front faces are rendered.
92 *
93 * @type {number}
94 * @constant
95 */
96const FrontSide = 0;
97
98/**
99 * Only back faces are rendered.
100 *
101 * @type {number}
102 * @constant
103 */
104const BackSide = 1;
105
106/**
107 * Both front and back faces are rendered.
108 *
109 * @type {number}
110 * @constant
111 */
112const DoubleSide = 2;
113
114/**
115 * No blending is performed which effectively disables
116 * alpha transparency.
117 *
118 * @type {number}
119 * @constant
120 */
121const NoBlending = 0;
122
123/**
124 * The default blending.
125 *
126 * @type {number}
127 * @constant
128 */
129const NormalBlending = 1;
130
131/**
132 * Represents additive blending.
133 *
134 * @type {number}
135 * @constant
136 */
137const AdditiveBlending = 2;
138
139/**
140 * Represents subtractive blending.
141 *
142 * @type {number}
143 * @constant
144 */
145const SubtractiveBlending = 3;
146
147/**
148 * Represents multiply blending.
149 *
150 * @type {number}
151 * @constant
152 */
153const MultiplyBlending = 4;
154
155/**
156 * Represents custom blending.
157 *
158 * @type {number}
159 * @constant
160 */
161const CustomBlending = 5;
162
163/**
164 * Represents material blending.
165 *
166 * @type {number}
167 * @constant
168 */
169const MaterialBlending = 6;
170
171/**
172 * A `source + destination` blending equation.
173 *
174 * @type {number}
175 * @constant
176 */
177const AddEquation = 100;
178
179/**
180 * A `source - destination` blending equation.
181 *
182 * @type {number}
183 * @constant
184 */
185const SubtractEquation = 101;
186
187/**
188 * A `destination - source` blending equation.
189 *
190 * @type {number}
191 * @constant
192 */
193const ReverseSubtractEquation = 102;
194
195/**
196 * A blend equation that uses the minimum of source and destination.
197 *
198 * @type {number}
199 * @constant
200 */
201const MinEquation = 103;
202
203/**
204 * A blend equation that uses the maximum of source and destination.
205 *
206 * @type {number}
207 * @constant
208 */
209const MaxEquation = 104;
210
211/**
212 * Multiplies all colors by `0`.
213 *
214 * @type {number}
215 * @constant
216 */
217const ZeroFactor = 200;
218
219/**
220 * Multiplies all colors by `1`.
221 *
222 * @type {number}
223 * @constant
224 */
225const OneFactor = 201;
226
227/**
228 * Multiplies all colors by the source colors.
229 *
230 * @type {number}
231 * @constant
232 */
233const SrcColorFactor = 202;
234
235/**
236 * Multiplies all colors by `1` minus each source color.
237 *
238 * @type {number}
239 * @constant
240 */
241const OneMinusSrcColorFactor = 203;
242
243/**
244 * Multiplies all colors by the source alpha value.
245 *
246 * @type {number}
247 * @constant
248 */
249const SrcAlphaFactor = 204;
250
251/**
252 * Multiplies all colors by 1 minus the source alpha value.
253 *
254 * @type {number}
255 * @constant
256 */
257const OneMinusSrcAlphaFactor = 205;
258
259/**
260 * Multiplies all colors by the destination alpha value.
261 *
262 * @type {number}
263 * @constant
264 */
265const DstAlphaFactor = 206;
266
267/**
268 * Multiplies all colors by `1` minus the destination alpha value.
269 *
270 * @type {number}
271 * @constant
272 */
273const OneMinusDstAlphaFactor = 207;
274
275/**
276 * Multiplies all colors by the destination color.
277 *
278 * @type {number}
279 * @constant
280 */
281const DstColorFactor = 208;
282
283/**
284 * Multiplies all colors by `1` minus each destination color.
285 *
286 * @type {number}
287 * @constant
288 */
289const OneMinusDstColorFactor = 209;
290
291/**
292 * Multiplies the RGB colors by the smaller of either the source alpha
293 * value or the value of `1` minus the destination alpha value. The alpha
294 * value is multiplied by `1`.
295 *
296 * @type {number}
297 * @constant
298 */
299const SrcAlphaSaturateFactor = 210;
300
301/**
302 * Multiplies all colors by a constant color.
303 *
304 * @type {number}
305 * @constant
306 */
307const ConstantColorFactor = 211;
308
309/**
310 * Multiplies all colors by `1` minus a constant color.
311 *
312 * @type {number}
313 * @constant
314 */
315const OneMinusConstantColorFactor = 212;
316
317/**
318 * Multiplies all colors by a constant alpha value.
319 *
320 * @type {number}
321 * @constant
322 */
323const ConstantAlphaFactor = 213;
324
325/**
326 * Multiplies all colors by 1 minus a constant alpha value.
327 *
328 * @type {number}
329 * @constant
330 */
331const OneMinusConstantAlphaFactor = 214;
332
333/**
334 * Never pass.
335 *
336 * @type {number}
337 * @constant
338 */
339const NeverDepth = 0;
340
341/**
342 * Always pass.
343 *
344 * @type {number}
345 * @constant
346 */
347const AlwaysDepth = 1;
348
349/**
350 * Pass if the incoming value is less than the depth buffer value.
351 *
352 * @type {number}
353 * @constant
354 */
355const LessDepth = 2;
356
357/**
358 * Pass if the incoming value is less than or equal to the depth buffer value.
359 *
360 * @type {number}
361 * @constant
362 */
363const LessEqualDepth = 3;
364
365/**
366 * Pass if the incoming value equals the depth buffer value.
367 *
368 * @type {number}
369 * @constant
370 */
371const EqualDepth = 4;
372
373/**
374 * Pass if the incoming value is greater than or equal to the depth buffer value.
375 *
376 * @type {number}
377 * @constant
378 */
379const GreaterEqualDepth = 5;
380
381/**
382 * Pass if the incoming value is greater than the depth buffer value.
383 *
384 * @type {number}
385 * @constant
386 */
387const GreaterDepth = 6;
388
389/**
390 * Pass if the incoming value is not equal to the depth buffer value.
391 *
392 * @type {number}
393 * @constant
394 */
395const NotEqualDepth = 7;
396
397/**
398 * Multiplies the environment map color with the surface color.
399 *
400 * @type {number}
401 * @constant
402 */
403const MultiplyOperation = 0;
404
405/**
406 * Uses reflectivity to blend between the two colors.
407 *
408 * @type {number}
409 * @constant
410 */
411const MixOperation = 1;
412
413/**
414 * Adds the two colors.
415 *
416 * @type {number}
417 * @constant
418 */
419const AddOperation = 2;
420
421/**
422 * No tone mapping is applied.
423 *
424 * @type {number}
425 * @constant
426 */
427const NoToneMapping = 0;
428
429/**
430 * Linear tone mapping.
431 *
432 * @type {number}
433 * @constant
434 */
435const LinearToneMapping = 1;
436
437/**
438 * Reinhard tone mapping.
439 *
440 * @type {number}
441 * @constant
442 */
443const ReinhardToneMapping = 2;
444
445/**
446 * Cineon tone mapping.
447 *
448 * @type {number}
449 * @constant
450 */
451const CineonToneMapping = 3;
452
453/**
454 * ACES Filmic tone mapping.
455 *
456 * @type {number}
457 * @constant
458 */
459const ACESFilmicToneMapping = 4;
460
461/**
462 * Custom tone mapping.
463 *
464 * Expects a custom implementation by modifying shader code of the material's fragment shader.
465 *
466 * @type {number}
467 * @constant
468 */
469const CustomToneMapping = 5;
470
471/**
472 * AgX tone mapping.
473 *
474 * @type {number}
475 * @constant
476 */
477const AgXToneMapping = 6;
478
479/**
480 * Neutral tone mapping.
481 *
482 * Implementation based on the Khronos 3D Commerce Group standard tone mapping.
483 *
484 * @type {number}
485 * @constant
486 */
487const NeutralToneMapping = 7;
488
489/**
490 * The skinned mesh shares the same world space as the skeleton.
491 *
492 * @type {string}
493 * @constant
494 */
495const AttachedBindMode = 'attached';
496
497/**
498 * The skinned mesh does not share the same world space as the skeleton.
499 * This is useful when a skeleton is shared across multiple skinned meshes.
500 *
501 * @type {string}
502 * @constant
503 */
504const DetachedBindMode = 'detached';
505
506/**
507 * Maps textures using the geometry's UV coordinates.
508 *
509 * @type {number}
510 * @constant
511 */
512const UVMapping = 300;
513
514/**
515 * Reflection mapping for cube textures.
516 *
517 * @type {number}
518 * @constant
519 */
520const CubeReflectionMapping = 301;
521
522/**
523 * Refraction mapping for cube textures.
524 *
525 * @type {number}
526 * @constant
527 */
528const CubeRefractionMapping = 302;
529
530/**
531 * Reflection mapping for equirectangular textures.
532 *
533 * @type {number}
534 * @constant
535 */
536const EquirectangularReflectionMapping = 303;
537
538/**
539 * Refraction mapping for equirectangular textures.
540 *
541 * @type {number}
542 * @constant
543 */
544const EquirectangularRefractionMapping = 304;
545
546/**
547 * Reflection mapping for PMREM textures.
548 *
549 * @type {number}
550 * @constant
551 */
552const CubeUVReflectionMapping = 306;
553
554/**
555 * The texture will simply repeat to infinity.
556 *
557 * @type {number}
558 * @constant
559 */
560const RepeatWrapping = 1000;
561
562/**
563 * The last pixel of the texture stretches to the edge of the mesh.
564 *
565 * @type {number}
566 * @constant
567 */
568const ClampToEdgeWrapping = 1001;
569
570/**
571 * The texture will repeats to infinity, mirroring on each repeat.
572 *
573 * @type {number}
574 * @constant
575 */
576const MirroredRepeatWrapping = 1002;
577
578/**
579 * Returns the value of the texture element that is nearest (in Manhattan distance)
580 * to the specified texture coordinates.
581 *
582 * @type {number}
583 * @constant
584 */
585const NearestFilter = 1003;
586
587/**
588 * Chooses the mipmap that most closely matches the size of the pixel being textured
589 * and uses the `NearestFilter` criterion (the texel nearest to the center of the pixel)
590 * to produce a texture value.
591 *
592 * @type {number}
593 * @constant
594 */
595const NearestMipmapNearestFilter = 1004;
596const NearestMipMapNearestFilter = 1004; // legacy
597
598/**
599 * Chooses the two mipmaps that most closely match the size of the pixel being textured and
600 * uses the `NearestFilter` criterion to produce a texture value from each mipmap.
601 * The final texture value is a weighted average of those two values.
602 *
603 * @type {number}
604 * @constant
605 */
606const NearestMipmapLinearFilter = 1005;
607const NearestMipMapLinearFilter = 1005; // legacy
608
609/**
610 * Returns the weighted average of the four texture elements that are closest to the specified
611 * texture coordinates, and can include items wrapped or repeated from other parts of a texture,
612 * depending on the values of `wrapS` and `wrapT`, and on the exact mapping.
613 *
614 * @type {number}
615 * @constant
616 */
617const LinearFilter = 1006;
618
619/**
620 * Chooses the mipmap that most closely matches the size of the pixel being textured and uses
621 * the `LinearFilter` criterion (a weighted average of the four texels that are closest to the
622 * center of the pixel) to produce a texture value.
623 *
624 * @type {number}
625 * @constant
626 */
627const LinearMipmapNearestFilter = 1007;
628const LinearMipMapNearestFilter = 1007; // legacy
629
630/**
631 * Chooses the two mipmaps that most closely match the size of the pixel being textured and uses
632 * the `LinearFilter` criterion to produce a texture value from each mipmap. The final texture value
633 * is a weighted average of those two values.
634 *
635 * @type {number}
636 * @constant
637 */
638const LinearMipmapLinearFilter = 1008;
639const LinearMipMapLinearFilter = 1008; // legacy
640
641/**
642 * An unsigned byte data type for textures.
643 *
644 * @type {number}
645 * @constant
646 */
647const UnsignedByteType = 1009;
648
649/**
650 * A byte data type for textures.
651 *
652 * @type {number}
653 * @constant
654 */
655const ByteType = 1010;
656
657/**
658 * A short data type for textures.
659 *
660 * @type {number}
661 * @constant
662 */
663const ShortType = 1011;
664
665/**
666 * An unsigned short data type for textures.
667 *
668 * @type {number}
669 * @constant
670 */
671const UnsignedShortType = 1012;
672
673/**
674 * An int data type for textures.
675 *
676 * @type {number}
677 * @constant
678 */
679const IntType = 1013;
680
681/**
682 * An unsigned int data type for textures.
683 *
684 * @type {number}
685 * @constant
686 */
687const UnsignedIntType = 1014;
688
689/**
690 * A float data type for textures.
691 *
692 * @type {number}
693 * @constant
694 */
695const FloatType = 1015;
696
697/**
698 * A half float data type for textures.
699 *
700 * @type {number}
701 * @constant
702 */
703const HalfFloatType = 1016;
704
705/**
706 * An unsigned short 4_4_4_4 (packed) data type for textures.
707 *
708 * @type {number}
709 * @constant
710 */
711const UnsignedShort4444Type = 1017;
712
713/**
714 * An unsigned short 5_5_5_1 (packed) data type for textures.
715 *
716 * @type {number}
717 * @constant
718 */
719const UnsignedShort5551Type = 1018;
720
721/**
722 * An unsigned int 24_8 data type for textures.
723 *
724 * @type {number}
725 * @constant
726 */
727const UnsignedInt248Type = 1020;
728
729/**
730 * An unsigned int 5_9_9_9 (packed) data type for textures.
731 *
732 * @type {number}
733 * @constant
734 */
735const UnsignedInt5999Type = 35902;
736
737/**
738 * An unsigned int 10_11_11 (packed) data type for textures.
739 *
740 * @type {number}
741 * @constant
742 */
743const UnsignedInt101111Type = 35899;
744
745/**
746 * Discards the red, green and blue components and reads just the alpha component.
747 *
748 * @type {number}
749 * @constant
750 */
751const AlphaFormat = 1021;
752
753/**
754 * Discards the alpha component and reads the red, green and blue component.
755 *
756 * @type {number}
757 * @constant
758 */
759const RGBFormat = 1022;
760
761/**
762 * Reads the red, green, blue and alpha components.
763 *
764 * @type {number}
765 * @constant
766 */
767const RGBAFormat = 1023;
768
769/**
770 * Reads each element as a single depth value, converts it to floating point, and clamps to the range `[0,1]`.
771 *
772 * @type {number}
773 * @constant
774 */
775const DepthFormat = 1026;
776
777/**
778 * Reads each element is a pair of depth and stencil values. The depth component of the pair is interpreted as
779 * in `DepthFormat`. The stencil component is interpreted based on the depth + stencil internal format.
780 *
781 * @type {number}
782 * @constant
783 */
784const DepthStencilFormat = 1027;
785
786/**
787 * Discards the green, blue and alpha components and reads just the red component.
788 *
789 * @type {number}
790 * @constant
791 */
792const RedFormat = 1028;
793
794/**
795 * Discards the green, blue and alpha components and reads just the red component. The texels are read as integers instead of floating point.
796 *
797 * @type {number}
798 * @constant
799 */
800const RedIntegerFormat = 1029;
801
802/**
803 * Discards the alpha, and blue components and reads the red, and green components.
804 *
805 * @type {number}
806 * @constant
807 */
808const RGFormat = 1030;
809
810/**
811 * Discards the alpha, and blue components and reads the red, and green components. The texels are read as integers instead of floating point.
812 *
813 * @type {number}
814 * @constant
815 */
816const RGIntegerFormat = 1031;
817
818/**
819 * Discards the alpha component and reads the red, green and blue component. The texels are read as integers instead of floating point.
820 *
821 * @type {number}
822 * @constant
823 */
824const RGBIntegerFormat = 1032;
825
826/**
827 * Reads the red, green, blue and alpha components. The texels are read as integers instead of floating point.
828 *
829 * @type {number}
830 * @constant
831 */
832const RGBAIntegerFormat = 1033;
833
834/**
835 * A DXT1-compressed image in an RGB image format.
836 *
837 * @type {number}
838 * @constant
839 */
840const RGB_S3TC_DXT1_Format = 33776;
841
842/**
843 * A DXT1-compressed image in an RGB image format with a simple on/off alpha value.
844 *
845 * @type {number}
846 * @constant
847 */
848const RGBA_S3TC_DXT1_Format = 33777;
849
850/**
851 * A DXT3-compressed image in an RGBA image format. Compared to a 32-bit RGBA texture, it offers 4:1 compression.
852 *
853 * @type {number}
854 * @constant
855 */
856const RGBA_S3TC_DXT3_Format = 33778;
857
858/**
859 * A DXT5-compressed image in an RGBA image format. It also provides a 4:1 compression, but differs to the DXT3
860 * compression in how the alpha compression is done.
861 *
862 * @type {number}
863 * @constant
864 */
865const RGBA_S3TC_DXT5_Format = 33779;
866
867/**
868 * PVRTC RGB compression in 4-bit mode. One block for each 4×4 pixels.
869 *
870 * @type {number}
871 * @constant
872 */
873const RGB_PVRTC_4BPPV1_Format = 35840;
874
875/**
876 * PVRTC RGB compression in 2-bit mode. One block for each 8×4 pixels.
877 *
878 * @type {number}
879 * @constant
880 */
881const RGB_PVRTC_2BPPV1_Format = 35841;
882
883/**
884 * PVRTC RGBA compression in 4-bit mode. One block for each 4×4 pixels.
885 *
886 * @type {number}
887 * @constant
888 */
889const RGBA_PVRTC_4BPPV1_Format = 35842;
890
891/**
892 * PVRTC RGBA compression in 2-bit mode. One block for each 8×4 pixels.
893 *
894 * @type {number}
895 * @constant
896 */
897const RGBA_PVRTC_2BPPV1_Format = 35843;
898
899/**
900 * ETC1 RGB format.
901 *
902 * @type {number}
903 * @constant
904 */
905const RGB_ETC1_Format = 36196;
906
907/**
908 * ETC2 RGB format.
909 *
910 * @type {number}
911 * @constant
912 */
913const RGB_ETC2_Format = 37492;
914
915/**
916 * ETC2 RGBA format.
917 *
918 * @type {number}
919 * @constant
920 */
921const RGBA_ETC2_EAC_Format = 37496;
922
923/**
924 * EAC R11 UNORM format.
925 *
926 * @type {number}
927 * @constant
928 */
929const R11_EAC_Format = 37488; // 0x9270
930
931/**
932 * EAC R11 SNORM format.
933 *
934 * @type {number}
935 * @constant
936 */
937const SIGNED_R11_EAC_Format = 37489; // 0x9271
938
939/**
940 * EAC RG11 UNORM format.
941 *
942 * @type {number}
943 * @constant
944 */
945const RG11_EAC_Format = 37490; // 0x9272
946
947/**
948 * EAC RG11 SNORM format.
949 *
950 * @type {number}
951 * @constant
952 */
953const SIGNED_RG11_EAC_Format = 37491; // 0x9273
954
955/**
956 * ASTC RGBA 4x4 format.
957 *
958 * @type {number}
959 * @constant
960 */
961const RGBA_ASTC_4x4_Format = 37808;
962
963/**
964 * ASTC RGBA 5x4 format.
965 *
966 * @type {number}
967 * @constant
968 */
969const RGBA_ASTC_5x4_Format = 37809;
970
971/**
972 * ASTC RGBA 5x5 format.
973 *
974 * @type {number}
975 * @constant
976 */
977const RGBA_ASTC_5x5_Format = 37810;
978
979/**
980 * ASTC RGBA 6x5 format.
981 *
982 * @type {number}
983 * @constant
984 */
985const RGBA_ASTC_6x5_Format = 37811;
986
987/**
988 * ASTC RGBA 6x6 format.
989 *
990 * @type {number}
991 * @constant
992 */
993const RGBA_ASTC_6x6_Format = 37812;
994
995/**
996 * ASTC RGBA 8x5 format.
997 *
998 * @type {number}
999 * @constant
1000 */
1001const RGBA_ASTC_8x5_Format = 37813;
1002
1003/**
1004 * ASTC RGBA 8x6 format.
1005 *
1006 * @type {number}
1007 * @constant
1008 */
1009const RGBA_ASTC_8x6_Format = 37814;
1010
1011/**
1012 * ASTC RGBA 8x8 format.
1013 *
1014 * @type {number}
1015 * @constant
1016 */
1017const RGBA_ASTC_8x8_Format = 37815;
1018
1019/**
1020 * ASTC RGBA 10x5 format.
1021 *
1022 * @type {number}
1023 * @constant
1024 */
1025const RGBA_ASTC_10x5_Format = 37816;
1026
1027/**
1028 * ASTC RGBA 10x6 format.
1029 *
1030 * @type {number}
1031 * @constant
1032 */
1033const RGBA_ASTC_10x6_Format = 37817;
1034
1035/**
1036 * ASTC RGBA 10x8 format.
1037 *
1038 * @type {number}
1039 * @constant
1040 */
1041const RGBA_ASTC_10x8_Format = 37818;
1042
1043/**
1044 * ASTC RGBA 10x10 format.
1045 *
1046 * @type {number}
1047 * @constant
1048 */
1049const RGBA_ASTC_10x10_Format = 37819;
1050
1051/**
1052 * ASTC RGBA 12x10 format.
1053 *
1054 * @type {number}
1055 * @constant
1056 */
1057const RGBA_ASTC_12x10_Format = 37820;
1058
1059/**
1060 * ASTC RGBA 12x12 format.
1061 *
1062 * @type {number}
1063 * @constant
1064 */
1065const RGBA_ASTC_12x12_Format = 37821;
1066
1067/**
1068 * BPTC RGBA format.
1069 *
1070 * @type {number}
1071 * @constant
1072 */
1073const RGBA_BPTC_Format = 36492;
1074
1075/**
1076 * BPTC Signed RGB format.
1077 *
1078 * @type {number}
1079 * @constant
1080 */
1081const RGB_BPTC_SIGNED_Format = 36494;
1082
1083/**
1084 * BPTC Unsigned RGB format.
1085 *
1086 * @type {number}
1087 * @constant
1088 */
1089const RGB_BPTC_UNSIGNED_Format = 36495;
1090
1091/**
1092 * RGTC1 Red format.
1093 *
1094 * @type {number}
1095 * @constant
1096 */
1097const RED_RGTC1_Format = 36283;
1098
1099/**
1100 * RGTC1 Signed Red format.
1101 *
1102 * @type {number}
1103 * @constant
1104 */
1105const SIGNED_RED_RGTC1_Format = 36284;
1106
1107/**
1108 * RGTC2 Red Green format.
1109 *
1110 * @type {number}
1111 * @constant
1112 */
1113const RED_GREEN_RGTC2_Format = 36285;
1114
1115/**
1116 * RGTC2 Signed Red Green format.
1117 *
1118 * @type {number}
1119 * @constant
1120 */
1121const SIGNED_RED_GREEN_RGTC2_Format = 36286;
1122
1123/**
1124 * Animations are played once.
1125 *
1126 * @type {number}
1127 * @constant
1128 */
1129const LoopOnce = 2200;
1130
1131/**
1132 * Animations are played with a chosen number of repetitions, each time jumping from
1133 * the end of the clip directly to its beginning.
1134 *
1135 * @type {number}
1136 * @constant
1137 */
1138const LoopRepeat = 2201;
1139
1140/**
1141 * Animations are played with a chosen number of repetitions, alternately playing forward
1142 * and backward.
1143 *
1144 * @type {number}
1145 * @constant
1146 */
1147const LoopPingPong = 2202;
1148
1149/**
1150 * Discrete interpolation mode for keyframe tracks.
1151 *
1152 * @type {number}
1153 * @constant
1154 */
1155const InterpolateDiscrete = 2300;
1156
1157/**
1158 * Linear interpolation mode for keyframe tracks.
1159 *
1160 * @type {number}
1161 * @constant
1162 */
1163const InterpolateLinear = 2301;
1164
1165/**
1166 * Smooth interpolation mode for keyframe tracks.
1167 *
1168 * @type {number}
1169 * @constant
1170 */
1171const InterpolateSmooth = 2302;
1172
1173/**
1174 * Bezier interpolation mode for keyframe tracks.
1175 *
1176 * Uses cubic Bezier curves with explicit 2D control points.
1177 * Requires tangent data to be set on the track.
1178 *
1179 * @type {number}
1180 * @constant
1181 */
1182const InterpolateBezier = 2303;
1183
1184/**
1185 * Zero curvature ending for animations.
1186 *
1187 * @type {number}
1188 * @constant
1189 */
1190const ZeroCurvatureEnding = 2400;
1191
1192/**
1193 * Zero slope ending for animations.
1194 *
1195 * @type {number}
1196 * @constant
1197 */
1198const ZeroSlopeEnding = 2401;
1199
1200/**
1201 * Wrap around ending for animations.
1202 *
1203 * @type {number}
1204 * @constant
1205 */
1206const WrapAroundEnding = 2402;
1207
1208/**
1209 * Default animation blend mode.
1210 *
1211 * @type {number}
1212 * @constant
1213 */
1214const NormalAnimationBlendMode = 2500;
1215
1216/**
1217 * Additive animation blend mode. Can be used to layer motions on top of
1218 * each other to build complex performances from smaller re-usable assets.
1219 *
1220 * @type {number}
1221 * @constant
1222 */
1223const AdditiveAnimationBlendMode = 2501;
1224
1225/**
1226 * For every three vertices draw a single triangle.
1227 *
1228 * @type {number}
1229 * @constant
1230 */
1231const TrianglesDrawMode = 0;
1232
1233/**
1234 * For each vertex draw a triangle from the last three vertices.
1235 *
1236 * @type {number}
1237 * @constant
1238 */
1239const TriangleStripDrawMode = 1;
1240
1241/**
1242 * For each vertex draw a triangle from the first vertex and the last two vertices.
1243 *
1244 * @type {number}
1245 * @constant
1246 */
1247const TriangleFanDrawMode = 2;
1248
1249/**
1250 * The depth value is inverted (1.0 - z) for visualization purposes.
1251 *
1252 * @type {number}
1253 * @constant
1254 */
1255const BasicDepthPacking = 3200;
1256
1257/**
1258 * The depth value is packed into 32 bit RGBA.
1259 *
1260 * @type {number}
1261 * @constant
1262 */
1263const RGBADepthPacking = 3201;
1264
1265/**
1266 * The depth value is packed into 24 bit RGB.
1267 *
1268 * @type {number}
1269 * @constant
1270 */
1271const RGBDepthPacking = 3202;
1272
1273/**
1274 * The depth value is packed into 16 bit RG.
1275 *
1276 * @type {number}
1277 * @constant
1278 */
1279const RGDepthPacking = 3203;
1280
1281/**
1282 * Normal information is relative to the underlying surface.
1283 *
1284 * @type {number}
1285 * @constant
1286 */
1287const TangentSpaceNormalMap = 0;
1288
1289/**
1290 * Normal information is relative to the object orientation.
1291 *
1292 * @type {number}
1293 * @constant
1294 */
1295const ObjectSpaceNormalMap = 1;
1296
1297// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names where available.
1298
1299/**
1300 * No color space.
1301 *
1302 * @type {string}
1303 * @constant
1304 */
1305const NoColorSpace = '';
1306
1307/**
1308 * sRGB color space.
1309 *
1310 * @type {string}
1311 * @constant
1312 */
1313const SRGBColorSpace = 'srgb';
1314
1315/**
1316 * sRGB-linear color space.
1317 *
1318 * @type {string}
1319 * @constant
1320 */
1321const LinearSRGBColorSpace = 'srgb-linear';
1322
1323/**
1324 * Linear transfer function.
1325 *
1326 * @type {string}
1327 * @constant
1328 */
1329const LinearTransfer = 'linear';
1330
1331/**
1332 * sRGB transfer function.
1333 *
1334 * @type {string}
1335 * @constant
1336 */
1337const SRGBTransfer = 'srgb';
1338
1339/**
1340 * No normal map packing.
1341 *
1342 * @type {string}
1343 * @constant
1344 */
1345const NoNormalPacking = '';
1346
1347/**
1348 * Normal RG packing.
1349 *
1350 * @type {string}
1351 * @constant
1352 */
1353const NormalRGPacking = 'rg';
1354
1355/**
1356 * Normal GA packing.
1357 *
1358 * @type {string}
1359 * @constant
1360 */
1361const NormalGAPacking = 'ga';
1362
1363/**
1364 * Sets the stencil buffer value to `0`.
1365 *
1366 * @type {number}
1367 * @constant
1368 */
1369const ZeroStencilOp = 0;
1370
1371/**
1372 * Keeps the current value.
1373 *
1374 * @type {number}
1375 * @constant
1376 */
1377const KeepStencilOp = 7680;
1378
1379/**
1380 * Sets the stencil buffer value to the specified reference value.
1381 *
1382 * @type {number}
1383 * @constant
1384 */
1385const ReplaceStencilOp = 7681;
1386
1387/**
1388 * Increments the current stencil buffer value. Clamps to the maximum representable unsigned value.
1389 *
1390 * @type {number}
1391 * @constant
1392 */
1393const IncrementStencilOp = 7682;
1394
1395/**
1396 * Decrements the current stencil buffer value. Clamps to `0`.
1397 *
1398 * @type {number}
1399 * @constant
1400 */
1401const DecrementStencilOp = 7683;
1402
1403/**
1404 * Increments the current stencil buffer value. Wraps stencil buffer value to zero when incrementing
1405 * the maximum representable unsigned value.
1406 *
1407 * @type {number}
1408 * @constant
1409 */
1410const IncrementWrapStencilOp = 34055;
1411
1412/**
1413 * Decrements the current stencil buffer value. Wraps stencil buffer value to the maximum representable
1414 * unsigned value when decrementing a stencil buffer value of `0`.
1415 *
1416 * @type {number}
1417 * @constant
1418 */
1419const DecrementWrapStencilOp = 34056;
1420
1421/**
1422 * Inverts the current stencil buffer value bitwise.
1423 *
1424 * @type {number}
1425 * @constant
1426 */
1427const InvertStencilOp = 5386;
1428
1429/**
1430 * Will never return true.
1431 *
1432 * @type {number}
1433 * @constant
1434 */
1435const NeverStencilFunc = 512;
1436
1437/**
1438 * Will return true if the stencil reference value is less than the current stencil value.
1439 *
1440 * @type {number}
1441 * @constant
1442 */
1443const LessStencilFunc = 513;
1444
1445/**
1446 * Will return true if the stencil reference value is equal to the current stencil value.
1447 *
1448 * @type {number}
1449 * @constant
1450 */
1451const EqualStencilFunc = 514;
1452
1453/**
1454 * Will return true if the stencil reference value is less than or equal to the current stencil value.
1455 *
1456 * @type {number}
1457 * @constant
1458 */
1459const LessEqualStencilFunc = 515;
1460
1461/**
1462 * Will return true if the stencil reference value is greater than the current stencil value.
1463 *
1464 * @type {number}
1465 * @constant
1466 */
1467const GreaterStencilFunc = 516;
1468
1469/**
1470 * Will return true if the stencil reference value is not equal to the current stencil value.
1471 *
1472 * @type {number}
1473 * @constant
1474 */
1475const NotEqualStencilFunc = 517;
1476
1477/**
1478 * Will return true if the stencil reference value is greater than or equal to the current stencil value.
1479 *
1480 * @type {number}
1481 * @constant
1482 */
1483const GreaterEqualStencilFunc = 518;
1484
1485/**
1486 * Will always return true.
1487 *
1488 * @type {number}
1489 * @constant
1490 */
1491const AlwaysStencilFunc = 519;
1492
1493/**
1494 * Never pass.
1495 *
1496 * @type {number}
1497 * @constant
1498 */
1499const NeverCompare = 512;
1500
1501/**
1502 * Pass if the incoming value is less than the texture value.
1503 *
1504 * @type {number}
1505 * @constant
1506 */
1507const LessCompare = 513;
1508
1509/**
1510 * Pass if the incoming value equals the texture value.
1511 *
1512 * @type {number}
1513 * @constant
1514 */
1515const EqualCompare = 514;
1516
1517/**
1518 * Pass if the incoming value is less than or equal to the texture value.
1519 *
1520 * @type {number}
1521 * @constant
1522 */
1523const LessEqualCompare = 515;
1524
1525/**
1526 * Pass if the incoming value is greater than the texture value.
1527 *
1528 * @type {number}
1529 * @constant
1530 */
1531const GreaterCompare = 516;
1532
1533/**
1534 * Pass if the incoming value is not equal to the texture value.
1535 *
1536 * @type {number}
1537 * @constant
1538 */
1539const NotEqualCompare = 517;
1540
1541/**
1542 * Pass if the incoming value is greater than or equal to the texture value.
1543 *
1544 * @type {number}
1545 * @constant
1546 */
1547const GreaterEqualCompare = 518;
1548
1549/**
1550 * Always pass.
1551 *
1552 * @type {number}
1553 * @constant
1554 */
1555const AlwaysCompare = 519;
1556
1557/**
1558 * The contents are intended to be specified once by the application, and used many
1559 * times as the source for drawing and image specification commands.
1560 *
1561 * @type {number}
1562 * @constant
1563 */
1564const StaticDrawUsage = 35044;
1565
1566/**
1567 * The contents are intended to be respecified repeatedly by the application, and
1568 * used many times as the source for drawing and image specification commands.
1569 *
1570 * @type {number}
1571 * @constant
1572 */
1573const DynamicDrawUsage = 35048;
1574
1575/**
1576 * The contents are intended to be specified once by the application, and used at most
1577 * a few times as the source for drawing and image specification commands.
1578 *
1579 * @type {number}
1580 * @constant
1581 */
1582const StreamDrawUsage = 35040;
1583
1584/**
1585 * The contents are intended to be specified once by reading data from the 3D API, and queried
1586 * many times by the application.
1587 *
1588 * @type {number}
1589 * @constant
1590 */
1591const StaticReadUsage = 35045;
1592
1593/**
1594 * The contents are intended to be respecified repeatedly by reading data from the 3D API, and queried
1595 * many times by the application.
1596 *
1597 * @type {number}
1598 * @constant
1599 */
1600const DynamicReadUsage = 35049;
1601
1602/**
1603 * The contents are intended to be specified once by reading data from the 3D API, and queried at most
1604 * a few times by the application
1605 *
1606 * @type {number}
1607 * @constant
1608 */
1609const StreamReadUsage = 35041;
1610
1611/**
1612 * The contents are intended to be specified once by reading data from the 3D API, and used many times as
1613 * the source for WebGL drawing and image specification commands.
1614 *
1615 * @type {number}
1616 * @constant
1617 */
1618const StaticCopyUsage = 35046;
1619
1620/**
1621 * The contents are intended to be respecified repeatedly by reading data from the 3D API, and used many times
1622 * as the source for WebGL drawing and image specification commands.
1623 *
1624 * @type {number}
1625 * @constant
1626 */
1627const DynamicCopyUsage = 35050;
1628
1629/**
1630 * The contents are intended to be specified once by reading data from the 3D API, and used at most a few times
1631 * as the source for WebGL drawing and image specification commands.
1632 *
1633 * @type {number}
1634 * @constant
1635 */
1636const StreamCopyUsage = 35042;
1637
1638/**
1639 * GLSL 1 shader code.
1640 *
1641 * @type {string}
1642 * @constant
1643 */
1644const GLSL1 = '100';
1645
1646/**
1647 * GLSL 3 shader code.
1648 *
1649 * @type {string}
1650 * @constant
1651 */
1652const GLSL3 = '300 es';
1653
1654/**
1655 * WebGL coordinate system.
1656 *
1657 * @type {number}
1658 * @constant
1659 */
1660const WebGLCoordinateSystem = 2000;
1661
1662/**
1663 * WebGPU coordinate system.
1664 *
1665 * @type {number}
1666 * @constant
1667 */
1668const WebGPUCoordinateSystem = 2001;
1669
1670/**
1671 * Represents the different timestamp query types.
1672 *
1673 * @type {ConstantsTimestampQuery}
1674 * @constant
1675 */
1676const TimestampQuery = {
1677	COMPUTE: 'compute',
1678	RENDER: 'render'
1679};
1680
1681/**
1682 * Represents mouse buttons and interaction types in context of controls.
1683 *
1684 * @type {ConstantsInterpolationSamplingType}
1685 * @constant
1686 */
1687const InterpolationSamplingType = {
1688	PERSPECTIVE: 'perspective',
1689	LINEAR: 'linear',
1690	FLAT: 'flat'
1691};
1692
1693/**
1694 * Represents the different interpolation sampling modes.
1695 *
1696 * @type {ConstantsInterpolationSamplingMode}
1697 * @constant
1698 */
1699const InterpolationSamplingMode = {
1700	NORMAL: 'normal',
1701	CENTROID: 'centroid',
1702	SAMPLE: 'sample',
1703	FIRST: 'first',
1704	EITHER: 'either'
1705};
1706
1707/**
1708 * Compatibility flags for features that may not be supported across all platforms.
1709 *
1710 * @type {Object}
1711 * @constant
1712 */
1713const Compatibility = {
1714	TEXTURE_COMPARE: 'depthTextureCompare'
1715};
1716
1717/**
1718 * 

1764.
1765 */
1766
1767/**
1768 * Checks if an array contains values that require Uint32 representation.
1769 *
1770 * This function determines whether the array contains any values >= 65535,
1771 * which would require a Uint32Array rather than a Uint16Array for proper storage.
1772 * The function iterates from the end of the array, assuming larger values are
1773 * typically located at the end.
1774 *
1775 * @private
1776 * @param {Array<number>} array - The array to check.
1777 * @return {boolean} True if the array contains values >= 65535, false otherwise.
1778 */
1779function arrayNeedsUint32( array ) {
1780
1781	// assumes larger values usually on last
1782
1783	for ( let i = array.length - 1; i >= 0; -- i ) {
1784
1785		if ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
1786
1787	}
1788
1789	return false;
1790
1791}
1792
1793/**
1794 * Map of typed array constructor names to their constructors.
1795 * This mapping enables dynamic creation of typed arrays based on string type names.
1796 *
1797 * @private
1798 * @constant
1799 * @type {Object<string, TypedArrayConstructor>}
1800 */
1801const TYPED_ARRAYS = {
1802	Int8Array: Int8Array,
1803	Uint8Array: Uint8Array,
1804	Uint8ClampedArray: Uint8ClampedArray,
1805	Int16Array: Int16Array,
1806	Uint16Array: Uint16Array,
1807	Int32Array: Int32Array,
1808	Uint32Array: Uint32Array,
1809	Float32Array: Float32Array,
1810	Float64Array: Float64Array
1811};
1812
1813/**
1814 * Creates a typed array of the specified type from the given buffer.
1815 *
1816 * @private
1817 * @param {string} type - The name of the typed array type (e.g., 'Float32Array', 'Uint16Array').
1818 * @param {ArrayBuffer} buffer - The buffer to create the typed array from.
1819 * @return {TypedArray} A new typed array of the specified type.
1820 */
1821function getTypedArray( type, buffer ) {
1822
1823	return new TYPED_ARRAYS[ type ]( buffer );
1824
1825}
1826
1827/**
1828 * Returns `true` if the given object is a typed array.
1829 *
1830 * @param {any} array - The object to check.
1831 * @return {boolean} Whether the given object is a typed array.
1832 */
1833function isTypedArray( array ) {
1834
1835	return ArrayBuffer.isView( array ) && ! ( array instanceof DataView );
1836
1837}
1838
1839/**
1840 * Creates an XHTML element with the specified tag name.
1841 *
1842 * This function uses the XHTML namespace to create DOM elements,
1843 * ensuring proper element creation in XML-based contexts.
1844 *
1845 * @private
1846 * @param {string} name - The tag name of the element to create (e.g., 'canvas', 'div').
1847 * @return {HTMLElement} The created XHTML element.
1848 */
1849function createElementNS( name ) {
1850
1851	return document.createElementNS( 'http://www.w3.org/1999/xhtml', name );
1852
1853}
1854
1855/**
1856 * Creates a canvas element configured for block display.
1857 *
1858 * This is a convenience function that creates a canvas element with
1859 * display style set to 'block', which is commonly used in three.js
1860 * rendering contexts to avoid inline element spacing issues.
1861 *
1862 * @return {HTMLCanvasElement} A canvas element with display set to 'block'.
1863 */
1864function createCanvasElement() {
1865
1866	const canvas = createElementNS( 'canvas' );
1867	canvas.style.display = 'block';
1868	return canvas;
1869
1870}
1871
1872/**
1873 * Internal cache for tracking warning messages to prevent duplicate warnings.
1874 *
1875 * @private
1876 * @type {Object<string, boolean>}
1877 */
1878const _cache = {};
1879
1880/**
1881 * Custom console function handler for intercepting log, warn, and error calls.
1882 *
1883 * @private
1884 * @type {Function|null}
1885 */
1886let _setConsoleFunction = null;
1887
1888/**
1889 * Sets a custom function to handle console output.
1890 *
1891 * This allows external code to intercept and handle console.log, console.warn,
1892 * and console.error calls made by three.js, which is useful for custom logging,
1893 * testing, or debugging workflows.
1894 *
1895 * @param {Function} fn - The function to handle console output. Should accept
1896 *                        (type, message, ...params) where type is 'log', 'warn', or 'error'.
1897 */
1898function setConsoleFunction( fn ) {
1899
1900	_setConsoleFunction = fn;
1901
1902}
1903
1904/**
1905 * Gets the currently set custom console function.
1906 *
1907 * @return {Function|null} The custom console function, or null if not set.
1908 */
1909function getConsoleFunction() {
1910
1911	return _setConsoleFunction;
1912
1913}
1914
1915/**
1916 * Logs an informational message with the 'THREE.' prefix.
1917 *
1918 * If a custom console function is set via setConsoleFunction(), it will be used
1919 * instead of the native console.log. The first parameter is treated as the
1920 * method name and is automatically prefixed with 'THREE.'.
1921 *
1922 * @param {...any} params - The message components. The first param is used as
1923 *                          the method name and prefixed with 'THREE.'.
1924 */
1925function log( ...params ) {
1926
1927	const message = 'THREE.' + params.shift();
1928
1929	if ( _setConsoleFunction ) {
1930
1931		_setConsoleFunction( 'log', message, ...params );
1932
1933	} else {
1934
1935		console.log( message, ...params );
1936
1937	}
1938
1939}
1940
1941/**
1942 * Enhances log/warn/error messages related to TSL.
1943 *
1944 * @param {Array<any>} params - The original message parameters.
1945 * @returns {Array<any>} The filtered and enhanced message parameters.
1946 */
1947function enhanceLogMessage( params ) {
1948
1949	const message = params[ 0 ];
1950
1951	if ( typeof message === 'string' && message.startsWith( 'TSL:' ) ) {
1952
1953		const stackTrace = params[ 1 ];
1954
1955		if ( stackTrace && stackTrace.isStackTrace ) {
1956
1957			params[ 0 ] += ' ' + stackTrace.getLocation();
1958
1959		} else {
1960
1961			params[ 1 ] = 'Stack trace not available. Enable "THREE.Node.captureStackTrace" to capture stack traces.';
1962
1963		}
1964
1965	}
1966
1967	return params;
1968
1969}
1970
1971/**
1972 * Logs a warning message with the 'THREE.' prefix.
1973 *
1974 * If a custom console function is set via setConsoleFunction(), it will be used
1975 * instead of the native console.warn. The first parameter is treated as the
1976 * method name and is automatically prefixed with 'THREE.'.
1977 *
1978 * @param {...any} params - The message components. The first param is used as
1979 *                          the method name and prefixed with 'THREE.'.
1980 */
1981function warn( ...params ) {
1982
1983	params = enhanceLogMessage( params );
1984
1985	const message = 'THREE.' + params.shift();
1986
1987	if ( _setConsoleFunction ) {
1988
1989		_setConsoleFunction( 'warn', message, ...params );
1990
1991	} else {
1992
1993		const stackTrace = params[ 0 ];
1994
1995		if ( stackTrace && stackTrace.isStackTrace ) {
1996
1997			console.warn( stackTrace.getError( message ) );
1998
1999		} else {
2000
2001			console.warn( message, ...params );
2002
2003		}
2004
2005	}
2006
2007}
2008
2009/**
2010 * Logs an error message with the 'THREE.' prefix.
2011 *
2012 * If a custom console function is set via setConsoleFunction(), it will be used
2013 * instead of the native console.error. The first parameter is treated as the
2014 * method name and is automatically prefixed with 'THREE.'.
2015 *
2016 * @param {...any} params - The message components. The first param is used as
2017 *                          the method name and prefixed with 'THREE.'.
2018 */
2019function error( ...params ) {
2020
2021	params = enhanceLogMessage( params );
2022
2023	const message = 'THREE.' + params.shift();
2024
2025	if ( _setConsoleFunction ) {
2026
2027		_setConsoleFunction( 'error', message, ...params );
2028
2029	} else {
2030
2031		const stackTrace = params[ 0 ];
2032
2033		if ( stackTrace && stackTrace.isStackTrace ) {
2034
2035			console.error( stackTrace.getError( message ) );
2036
2037		} else {
2038
2039			console.error( message, ...params );
2040
2041		}
2042
2043	}
2044
2045}
2046
2047/**
2048 * Logs a warning message only once, preventing duplicate warnings.
2049 *
2050 * This function maintains an internal cache of warning messages and will only
2051 * output each unique warning message once. Useful for warnings that may be
2052 * triggered repeatedly but should only be shown to the user once.
2053 *
2054 * @param {...any} params - The warning message components.
2055 */
2056function warnOnce( ...params ) {
2057
2058	const message = params.join( ' ' );
2059
2060	if ( message in _cache ) return;
2061
2062	_cache[ message ] = true;
2063
2064	warn( ...params );
2065
2066}
2067
2068/**
2069 * Yields execution to the main thread to allow rendering and other tasks.
2070 * Uses scheduler.yield() when available (Chrome 115+), falls back to requestAnimationFrame.
2071 *
2072 * @return {Promise<void>}
2073 */
2074function yieldToMain() {
2075
2076	if ( typeof self !== 'undefined' && typeof self.scheduler !== 'undefined' && typeof self.scheduler.yield !== 'undefined' ) {
2077
2078		return self.scheduler.yield();
2079
2080	}
2081
2082	return new Promise( resolve => {
2083
2084		requestAnimationFrame( resolve );
2085
2086	} );
2087
2088}
2089
2090/**
2091 * Asynchronously probes for WebGL sync object completion.
2092 *
2093 * This function creates a promise that resolves when the WebGL sync object
2094 * signals completion or rejects if the sync operation fails. It uses polling
2095 * at the specified interval to check the sync status without blocking the
2096 * main thread. This is useful for GPU-CPU synchronization in WebGL contexts.
2097 *
2098 * @private
2099 * @param {WebGL2RenderingContext} gl - The WebGL rendering context.
2100 * @param {WebGLSync} sync - The WebGL sync object to wait for.
2101 * @param {number} interval - The polling interval in milliseconds.
2102 * @return {Promise<void>} A promise that resolves when the sync completes or rejects if it fails.
2103 */
2104function probeAsync( gl, sync, interval ) {
2105
2106	return new Promise( function ( resolve, reject ) {
2107
2108		function probe() {
2109
2110			switch ( gl.clientWaitSync( sync, gl.SYNC_FLUSH_COMMANDS_BIT, 0 ) ) {
2111
2112				case gl.WAIT_FAILED:
2113					reject();
2114					break;
2115
2116				case gl.TIMEOUT_EXPIRED:
2117					setTimeout( probe, interval );
2118					break;
2119
2120				default:
2121					resolve();
2122
2123			}
2124
2125		}
2126
2127		setTimeout( probe, interval );
2128
2129	} );
2130
2131}
2132
2133/**
2134 * Used to select the correct depth functions
2135 * when reversed depth buffer is used.
2136 *
2137 * @private
2138 * @type {Object}
2139 */
2140const ReversedDepthFuncs = {
2141	[ NeverDepth ]: AlwaysDepth,
2142	[ LessDepth ]: GreaterDepth,
2143	[ EqualDepth ]: NotEqualDepth,
2144	[ LessEqualDepth ]: GreaterEqualDepth,
2145
2146	[ AlwaysDepth ]: NeverDepth,
2147	[ GreaterDepth ]: LessDepth,
2148	[ NotEqualDepth ]: EqualDepth,
2149	[ GreaterEqualDepth ]: LessEqualDepth,
2150};
2151
2152/**
2153 * This modules allows to dispatch event objects on custom JavaScript objects.
2154 *
2155 * Main repository: [eventdispatcher.js](https://github.com/mrdoob/eventdispatcher.js/)
2156 *
2157 * Code Example:
2158 * ```js
2159 * class Car extends EventDispatcher {
2160 * 	start() {
2161 *		this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
2162 *	}
2163 *};
2164 *
2165 * // Using events with the custom object
2166 * const car = new Car();
2167 * car.addEventListener( 'start', function ( event ) {
2168 * 	alert( event.message );
2169 * } );
2170 *
2171 * car.start();
2172 * ```
2173 */
2174class EventDispatcher {
2175
2176	/**
2177	 * Adds the given event listener to the given event type.
2178	 *
2179	 * @param {string} type - The type of event to listen to.
2180	 * @param {Function} listener - The function that gets called when the event is fired.
2181	 */
2182	addEventListener( type, listener ) {
2183
2184		if ( this._listeners === undefined ) this._listeners = {};
2185
2186		const listeners = this._listeners;
2187
2188		if ( listeners[ type ] === undefined ) {
2189
2190			listeners[ type ] = [];
2191
2192		}
2193
2194		if ( listeners[ type ].indexOf( listener ) === -1 ) {
2195
2196			listeners[ type ].push( listener );
2197
2198		}
2199
2200	}
2201
2202	/**
2203	 * Returns `true` if the given event listener has been added to the given event type.
2204	 *
2205	 * @param {string} type - The type of event.
2206	 * @param {Function} listener - The listener to check.
2207	 * @return {boolean} Whether the given event listener has been added to the given event type.
2208	 */
2209	hasEventListener( type, listener ) {
2210
2211		const listeners = this._listeners;
2212
2213		if ( listeners === undefined ) return false;
2214
2215		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== -1;
2216
2217	}
2218
2219	/**
2220	 * Removes the given event listener from the given event type.
2221	 *
2222	 * @param {string} type - The type of event.
2223	 * @param {Function} listener - The listener to remove.
2224	 */
2225	removeEventListener( type, listener ) {
2226
2227		const listeners = this._listeners;
2228
2229		if ( listeners === undefined ) return;
2230
2231		const listenerArray = listeners[ type ];
2232
2233		if ( listenerArray !== undefined ) {
2234
2235			const index = listenerArray.indexOf( listener );
2236
2237			if ( index !== -1 ) {
2238
2239				listenerArray.splice( index, 1 );
2240
2241			}
2242
2243		}
2244
2245	}
2246
2247	/**
2248	 * Dispatches an event object.
2249	 *
2250	 * @param {Object} event - The event that gets fired.
2251	 */
2252	dispatchEvent( event ) {
2253
2254		const listeners = this._listeners;
2255
2256		if ( listeners === undefined ) return;
2257
2258		const listenerArray = listeners[ event.type ];
2259
2260		if ( listenerArray !== undefined ) {
2261
2262			event.target = this;
2263
2264			// Make a copy, in case listeners are removed while iterating.
2265			const array = listenerArray.slice( 0 );
2266
2267			for ( let i = 0, l = array.length; i < l; i ++ ) {
2268
2269				array[ i ].call( this, event );
2270
2271			}
2272
2273			event.target = null;
2274
2275		}
2276
2277	}
2278
2279}
2280
2281const _lut = [ '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff' ];
2282
2283let _seed = 1234567;
2284
2285
2286const DEG2RAD = Math.PI / 180;
2287const RAD2DEG = 180 / Math.PI;
2288
2289/**
2290 * Generate a [UUID](https://en.wikipedia.org/wiki/Universally_unique_identifier)
2291 * (universally unique identifier).
2292 *
2293 * @return {string} The UUID.
2294 */
2295function generateUUID() {
2296
2297	// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
2298
2299	const d0 = Math.random() * 0xffffffff | 0;
2300	const d1 = Math.random() * 0xffffffff | 0;
2301	const d2 = Math.random() * 0xffffffff | 0;
2302	const d3 = Math.random() * 0xffffffff | 0;
2303	const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
2304			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
2305			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
2306			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
2307
2308	// .toLowerCase() here flattens concatenated strings to save heap memory space.
2309	return uuid.toLowerCase();
2310
2311}
2312
2313/**
2314 * Clamps the given value between min and max.
2315 *
2316 * @param {number} value - The value to clamp.
2317 * @param {number} min - The min value.
2318 * @param {number} max - The max value.
2319 * @return {number} The clamped value.
2320 */
2321function clamp( value, min, max ) {
2322
2323	return Math.max( min, Math.min( max, value ) );
2324
2325}
2326
2327/**
2328 * Computes the Euclidean modulo of the given parameters that
2329 * is `( ( n % m ) + m ) % m`.
2330 *
2331 * @param {number} n - The first parameter.
2332 * @param {number} m - The second parameter.
2333 * @return {number} The Euclidean modulo.
2334 */
2335function euclideanModulo( n, m ) {
2336
2337	// https://en.wikipedia.org/wiki/Modulo_operation
2338
2339	return ( ( n % m ) + m ) % m;
2340
2341}
2342
2343/**
2344 * Performs a linear mapping from range `<a1, a2>` to range `<b1, b2>`
2345 * for the given value. `a2` must be greater than `a1`.
2346 *
2347 * @param {number} x - The value to be mapped.
2348 * @param {number} a1 - Minimum value for range A.
2349 * @param {number} a2 - Maximum value for range A.
2350 * @param {number} b1 - Minimum value for range B.
2351 * @param {number} b2 - Maximum value for range B.
2352 * @return {number} The mapped value.
2353 */
2354function mapLinear( x, a1, a2, b1, b2 ) {
2355
2356	return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
2357
2358}
2359
2360/**
2361 * Returns the percentage in the closed interval `[0, 1]` of the given value
2362 * between the start and end point.
2363 *
2364 * @param {number} x - The start point
2365 * @param {number} y - The end point.
2366 * @param {number} value - A value between start and end.
2367 * @return {number} The interpolation factor.
2368 */
2369function inverseLerp( x, y, value ) {
2370
2371	// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
2372
2373	if ( x !== y ) {
2374
2375		return ( value - x ) / ( y - x );
2376
2377	} else {
2378
2379		return 0;
2380
2381	}
2382
2383}
2384
2385/**
2386 * Returns a value linearly interpolated from two known points based on the given interval -
2387 * `t = 0` will return `x` and `t = 1` will return `y`.
2388 *
2389 * @param {number} x - The start point
2390 * @param {number} y - The end point.
2391 * @param {number} t - The interpolation factor in the closed interval `[0, 1]`.
2392 * @return {number} The interpolated value.
2393 */
2394function lerp( x, y, t ) {
2395
2396	return ( 1 - t ) * x + t * y;
2397
2398}
2399
2400/**
2401 * Smoothly interpolate a number from `x` to `y` in  a spring-like manner using a delta
2402 * time to maintain frame rate independent movement. For details, see
2403 * [Frame rate independent damping using lerp](http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/).
2404 *
2405 * @param {number} x - The current point.
2406 * @param {number} y - The target point.
2407 * @param {number} lambda - A higher lambda value will make the movement more sudden,
2408 * and a lower value will make the movement more gradual.
2409 * @param {number} dt - Delta time in seconds.
2410 * @return {number} The interpolated value.
2411 */
2412function damp( x, y, lambda, dt ) {
2413
2414	return lerp( x, y, 1 - Math.exp( - lambda * dt ) );
2415
2416}
2417
2418/**
2419 * Returns a value that alternates between `0` and the given `length` parameter.
2420 *
2421 * @param {number} x - The value to pingpong.
2422 * @param {number} [length=1] - The positive value the function will pingpong to.
2423 * @return {number} The alternated value.
2424 */
2425function pingpong( x, length = 1 ) {
2426
2427	// https://www.desmos.com/calculator/vcsjnyz7x4
2428
2429	return length - Math.abs( euclideanModulo( x, length * 2 ) - length );
2430
2431}
2432
2433/**
2434 * Returns a value in the range `[0,1]` that represents the percentage that `x` has
2435 * moved between `min` and `max`, but smoothed or slowed down the closer `x` is to
2436 * the `min` and `max`.
2437 *
2438 * See [Smoothstep](http://en.wikipedia.org/wiki/Smoothstep) for more details.
2439 *
2440 * @param {number} x - The value to evaluate based on its position between `min` and `max`.
2441 * @param {number} min - The min value. Any `x` value below `min` will be `0`. `min` must be lower than `max`.
2442 * @param {number} max - The max value. Any `x` value above `max` will be `1`. `max` must be greater than `min`.
2443 * @return {number} The alternated value.
2444 */
2445function smoothstep( x, min, max ) {
2446
2447	if ( x <= min ) return 0;
2448	if ( x >= max ) return 1;
2449
2450	x = ( x - min ) / ( max - min );
2451
2452	return x * x * ( 3 - 2 * x );
2453
2454}
2455
2456/**
2457 * A [variation on smoothstep](https://en.wikipedia.org/wiki/Smoothstep#Variations)
2458 * that has zero 1st and 2nd order derivatives at `x=0` and `x=1`.
2459 *
2460 * @param {number} x - The value to evaluate based on its position between `min` and `max`.
2461 * @param {number} min - The min value. Any `x` value below `min` will be `0`. `min` must be lower than `max`.
2462 * @param {number} max - The max value. Any `x` value above `max` will be `1`. `max` must be greater than `min`.
2463 * @return {number} The alternated value.
2464 */
2465function smootherstep( x, min, max ) {
2466
2467	if ( x <= min ) return 0;
2468	if ( x >= max ) return 1;
2469
2470	x = ( x - min ) / ( max - min );
2471
2472	return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
2473
2474}
2475
2476/**
2477 * Returns a random integer from `<low, high>` interval.
2478 *
2479 * @param {number} low - The lower value boundary.
2480 * @param {number} high - The upper value boundary
2481 * @return {number} A random integer.
2482 */
2483function randInt( low, high ) {
2484
2485	return low + Math.floor( Math.random() * ( high - low + 1 ) );
2486
2487}
2488
2489/**
2490 * Returns a random float from `<low, high>` interval.
2491 *
2492 * @param {number} low - The lower value boundary.
2493 * @param {number} high - The upper value boundary
2494 * @return {number} A random float.
2495 */
2496function randFloat( low, high ) {
2497
2498	return low + Math.random() * ( high - low );
2499
2500}
2501
2502/**
2503 * Returns a random integer from `<-range/2, range/2>` interval.
2504 *
2505 * @param {number} range - Defines the value range.
2506 * @return {number} A random float.
2507 */
2508function randFloatSpread( range ) {
2509
2510	return range * ( 0.5 - Math.random() );
2511
2512}
2513
2514/**
2515 * Returns a deterministic pseudo-random float in the interval `[0, 1]`.
2516 *
2517 * @param {number} [s] - The integer seed.
2518 * @return {number} A random float.
2519 */
2520function seededRandom( s ) {
2521
2522	if ( s !== undefined ) _seed = s;
2523
2524	// Mulberry32 generator
2525
2526	let t = _seed += 0x6D2B79F5;
2527
2528	t = Math.imul( t ^ t >>> 15, t | 1 );
2529
2530	t ^= t + Math.imul( t ^ t >>> 7, t | 61 );
2531
2532	return ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;
2533
2534}
2535
2536/**
2537 * Converts degrees to radians.
2538 *
2539 * @param {number} degrees - A value in degrees.
2540 * @return {number} The converted value in radians.
2541 */
2542function degToRad( degrees ) {
2543
2544	return degrees * DEG2RAD;
2545
2546}
2547
2548/**
2549 * Converts radians to degrees.
2550 *
2551 * @param {number} radians - A value in radians.
2552 * @return {number} The converted value in degrees.
2553 */
2554function radToDeg( radians ) {
2555
2556	return radians * RAD2DEG;
2557
2558}
2559
2560/**
2561 * Returns `true` if the given