forked from ixshells/three.js.sourcecode
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathVector3.js
More file actions
1226 lines (885 loc) · 41.2 KB
/
Vector3.js
File metadata and controls
1226 lines (885 loc) · 41.2 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// File:src/math/Vector3.js
/**
* @author mrdoob / http://mrdoob.com/
* @author *kile / http://kile.stravaganza.org/
* @author philogb / http://blog.thejit.org/
* @author mikael emtinger / http://gomo.se/
* @author egraether / http://egraether.com/
* @author WestLangley / http://github.com/WestLangley
*/
/*
///Vector3对象的构造函数.用来创建一个三维向量的对象.Vector3对象的功能函数采用
///定义构造的函数原型对象来实现.
///
/// 用法: var p2d = new Vector3(5,3,2)
/// 创建一个x坐标为5,y坐标为3的向量,z坐标为2的向量.
/// NOTE: 参数(x,y,z)坐标为可选参数,如果不指定参数(x,y,z),将创建一个坐标为(0,0,0)的向量.
*/
///<summary>Vector3</summary>
///<param name ="x" type="number">x坐标</param>
///<param name ="y" type="number">y坐标</param>
///<param name ="z" type="number">z坐标</param>
THREE.Vector3 = function ( x, y, z ) {
this.x = x || 0;
this.y = y || 0;
this.z = z || 0;
};
/****************************************
****下面是Vector3对象提供的功能函数.
****************************************/
THREE.Vector3.prototype = {
constructor: THREE.Vector3, //构造器,返回对创建此对象的Vector3函数的引用
/*
///set方法用来重新设置三维向量的x,y,z坐标值.并返回新的坐标值的三维向量.
*/
///<summary>set</summary>
///<param name ="x" type="number">x坐标</param>
///<param name ="y" type="number">y坐标</param>
///<param name ="z" type="number">y坐标</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
set: function ( x, y, z ) {
this.x = x;
this.y = y;
this.z = z;
return this; //返回新坐标值的三维向量
},
/*
///setX方法用来重新设置三维向量的x坐标值.并返回新的坐标值的三维向量.
*/
///<summary>setX</summary>
///<param name ="x" type="number">x坐标</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
setX: function ( x ) {
this.x = x;
return this; //返回新坐标值的三维向量
},
/*
///setY方法用来重新设置三维向量的y坐标值.并返回新的坐标值的三维向量.
*/
///<summary>setY</summary>
///<param name ="y" type="number">y坐标</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
setY: function ( y ) {
this.y = y;
return this; //返回新坐标值的三维向量
},
/*
///setZ方法用来重新设置三维向量的z坐标值.并返回新的坐标值的三维向量.
*/
///<summary>setZ</summary>
///<param name ="z" type="number">z坐标</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
setZ: function ( z ) {
this.z = z;
return this; //返回新坐标值的三维向量
},
/*
///setComponent方法用来重新设置三维向量的(x,y)坐标值.并返回新的坐标值的三维向量.
///参数index取值为0,1 或者 2,取值为0,参数value设置x的坐标值,取值为1,参数value设置y的坐标,
///取值为2,参数value设置z的坐标.
*/
///<summary>setComponent</summary>
///<param name ="index" type="number">0,1或2</param>
///<param name ="value" type="number">x, y 或 z坐标</param>
setComponent: function ( index, value ) {
switch ( index ) {
case 0: this.x = value; break;
case 1: this.y = value; break;
case 2: this.z = value; break;
default: throw new Error( 'index is out of range: ' + index );
}
},
/*
///getComponent方法用获得三维向量的(x,y,z)坐标值.
///参数index取值为0,1 或者 2,取值为0,获得x的坐标值,取值为1,获得y的坐标,
///取值为2,获得z的坐标.
*/
///<summary>getComponent</summary>
///<param name ="index" type="number">0,1或2</param>
getComponent: function ( index ) {
switch ( index ) {
case 0: return this.x;
case 1: return this.y;
case 2: return this.z;
default: throw new Error( 'index is out of range: ' + index );
}
},
/*
///copy方法用来复制三维向量的(x,y,z)坐标值.并返回新的坐标值的三维向量.
*/
///<summary>copy</summary>
///<param name ="v" type="Vector3">三维向量</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
copy: function ( v ) {
this.x = v.x;
this.y = v.y;
this.z = v.z;
return this; //返回新坐标值的三维向量
},
/*
///add方法用来将三维向量的(x,y,z)坐标值与参数v的(x,y,z)相加.并返回新的坐标值的三维向量.
/// NOTE:add()方法虽然有两个参数,但实际上只对参数v做运算,这里的参数w,如果设置的话,调用.addVectors()方法.
*/
///<summary>add</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)坐标值增加的向量</param>
///<param name ="w" type="Vector3">判断是否有第二个参数w,如果有的话,调用.addVectors()方法</param>
///<returns type="Vector3">返回新坐标值的二维向量</returns>
add: function ( v, w ) {
if ( w !== undefined ) { //判断是否有第二个参数w,如果有的话,调用.addVectors()方法.
//THREE.Vector3: .add()方法现在只有一个参数,如果2个参数使用.addVectors( a, b )方法来替代.
console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
return this.addVectors( v, w );
}
this.x += v.x;
this.y += v.y;
this.z += v.z;
return this; //返回新坐标值的三维向量
},
/*
///addScalar方法用来将三维向量的(x,y,z)坐标值直接与参数s相加.并返回新的坐标值的三维向量.
/// NOTE:这里与add()方法不同的是,这里传递的参数s是一个标量,而add()方法的参数v是一个三维向量.
*/
///<summary>addScalar</summary>
///<param name ="s" type="number">(x,y,z)要增加的数值</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
addScalar: function ( s ) {
this.x += s;
this.y += s;
this.z += s;
return this; //返回新坐标值的三维向量
},
/*
///addVectors方法用来将三维向量的(x,y,z)坐标值等于参数(a,b)的(x,y,z)相加.并返回新的坐标值的三维向量.
/// NOTE:两个矢量组件对应相加。
*/
///<summary>addVectors</summary>
///<param name ="a" type="Vector3">三维向量</param>
///<param name ="b" type="Vector3">三维向量</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
addVectors: function ( a, b ) {
this.x = a.x + b.x;
this.y = a.y + b.y;
this.z = a.z + b.z;
return this; //返回新坐标值的三维向量
},
/*
///sub方法用来将三维向量的(x,y,z)坐标值与参数v的(x,y,z)相减.并返回新的坐标值的三维向量.
/// NOTE:sub()方法虽然有两个参数,但实际上只对参数v做运算,这里的参数w,如果设置的话,调用.subVectors()方法.
*/
///<summary>sub</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)坐标值增加的三维向量</param>
///<param name ="w" type="Vector3">判断是否有第二个参数w,如果有的话,调用.subVectors()方法</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
sub: function ( v, w ) {
if ( w !== undefined ) { //判断是否有第二个参数w,如果有的话,调用.subVectors()方法.
//THREE.Vector3: .sub()方法现在只有一个参数,如果2个参数使用.subVectors( a, b )方法来替代.
console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
return this.subVectors( v, w );
}
this.x -= v.x;
this.y -= v.y;
this.z -= v.z;
return this; //返回新坐标值的三维向量
},
/*
///subVectors方法用来将三维向量的(x,y,z)坐标值分别于参数(a,b)的(x,y,z)相减.并返回新的坐标值的三维向量.
*/
///<summary>subVectors</summary>
///<param name ="a" type="Vector3">三维向量</param>
///<param name ="b" type="Vector3">三维向量</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
subVectors: function ( a, b ) {
this.x = a.x - b.x;
this.y = a.y - b.y;
this.z = a.z - b.z;
return this; //返回新坐标值的三维向量
},
/*
///multiply方法用来将三维向量的(x,y,z)坐标值与参数v的(x,y,z)相乘.并返回新的坐标值的三维向量.
*/
///<summary>multiply</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)值相乘的三维向量</param>
///<param name ="w" type="Vector3">判断是否有第二个参数w,如果有的话,调用.multiplyVectors()方法</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
multiply: function ( v, w ) {
if ( w !== undefined ) {
//THREE.Vector3: .multiply()方法现在只有一个参数,如果2个参数使用.multiplyVectors( a, b )方法来替代.
console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );
return this.multiplyVectors( v, w );
}
this.x *= v.x;
this.y *= v.y;
this.z *= v.z;
return this; //返回新坐标值的三维向量
},
/*
///multiplyScalar方法用来将三维向量的(x,y,z)坐标值直接与参数s相乘.并返回新的坐标值的三维向量.
/// NOTE:这里与multiply()方法不同的是,这里传递的参数scalar是一个标量,而multiply()方法的参数v是一个三维向量.
*/
///<summary>multiplyScalar</summary>
///<param name ="scalar" type="number">与当前对象(x,y,z)值相乘的标量,数值</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
multiplyScalar: function ( scalar ) {
this.x *= scalar;
this.y *= scalar;
this.z *= scalar;
return this; //返回新坐标值的三维向量
},
/*
///multiplyVectors方法用来将三维向量的(x,y,z)坐标值等于参数(a,b)的(x,y,z)相乘.并返回新的坐标值的三维向量.
/// NOTE:两个矢量组件对应相乘。
*/
///<summary>multiplyVectors</summary>
///<param name ="a" type="Vector3">三维向量</param>
///<param name ="b" type="Vector3">三维向量</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
multiplyVectors: function ( a, b ) {
this.x = a.x * b.x;
this.y = a.y * b.y;
this.z = a.z * b.z;
return this; //返回新坐标值的三维向量
},
/*
///applyEuler方法将当前向量通过参数euler(THREE.Euler对象,欧拉对象)转换成四元数,应用四元数变换.
/// 实际上就是调用四元数下的.setFromEuler()方法.
*/
///<summary>applyEuler</summary>
///<param name ="euler" type="THREE.Euler">THREE.Euler对象,欧拉对象</param>
///<returns type="Vector3">返回变换后的三维向量</returns>
applyEuler: function () {
var quaternion;
return function ( euler ) {
if ( euler instanceof THREE.Euler === false ) {
console.error( 'THREE.Vector3: .applyEuler() now expects a Euler rotation rather than a Vector3 and order.' );
}
if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
this.applyQuaternion( quaternion.setFromEuler( euler ) );
return this; //返回变换后的三维向量
};
}(),
/*
///applyMatrix3方法将当前向量根据指定的轴(一个标准单位的向量),和角度旋转.或者说根据指定的轴和角度应用旋转.
*/
///<summary>applyMatrix3</summary>
///<param name ="axis" type="Vector3">三维向量</param>
///<param name ="angle" type="Matrix3">3x3矩阵</param>
///<returns type="Vector3">返回变换后的三维向量</returns>
applyAxisAngle: function () {
var quaternion;
return function ( axis, angle ) {
if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) ); //实际调用的四元数下面的方法.setFromAxisAngle()
return this; //返回变换后的三维向量
};
}(),
/*
///applyMatrix3方法将当前向量乘以一个3x3的矩阵,参数m(一个Matrix3的矩阵)
*/
///<summary>applyMatrix3</summary>
///<param name ="m" type="Matrix3">3x3矩阵</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
applyMatrix3: function ( m ) {
var x = this.x;
var y = this.y;
var z = this.z;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
return this; //返回新坐标值的三维向量
},
/*
///applyMatrix4方法乘以该向量和参数m(一个Matrix4投影矩阵)的4x4的子集
/// NOTE:applyToVector3Array方法经常用来对三维向量应用某种变换.
*/
///<summary>applyMatrix4</summary>
///<param name ="m" type="Matrix4">仿射矩阵</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
applyMatrix4: function ( m ) {
// input: THREE.Matrix4 affine matrix
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ];
this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ];
this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ];
return this; //返回新坐标值的三维向量
},
/*
///applyProjection方法乘以该向量和参数m(一个Matrix4投影矩阵),然后除以视角.
*/
///<summary>applyProjection</summary>
///<param name ="m" type="Matrix4">投影矩阵</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
applyProjection: function ( m ) {
// input: THREE.Matrix4 projection matrix
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
var d = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] ); // perspective divide
this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * d;
this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * d;
this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * d;
return this;
},
/*
///applyQuaternion方法应用一个四元数变换到当前三维向量.
*/
///<summary>applyQuaternion</summary>
///<param name ="q" type="Quaternion">四元数</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
applyQuaternion: function ( q ) {
var x = this.x;
var y = this.y;
var z = this.z;
var qx = q.x;
var qy = q.y;
var qz = q.z;
var qw = q.w;
// calculate quat * vector
var ix = qw * x + qy * z - qz * y;
var iy = qw * y + qz * x - qx * z;
var iz = qw * z + qx * y - qy * x;
var iw = - qx * x - qy * y - qz * z;
// calculate result * inverse quat
this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
return this; //返回新坐标值的三维向量
},
/*
///transformDirection方法通过参数m(一个Matrix4投射矩阵的3x3子集)转换这个向量的方向
*/
///<summary>transformDirection</summary>
///<param name ="m" type="Matrix4">仿射矩阵</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
transformDirection: function ( m ) {
// input: THREE.Matrix4 affine matrix
// vector interpreted as a direction
var x = this.x, y = this.y, z = this.z;
var e = m.elements;
this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
this.normalize(); //返回单位量
return this; //返回新的三维向量
},
/*
///divide方法用来将三维向量的(x,y,z)坐标值与参数v的(x,y,z)相除.并返回新的坐标值的三维向量.
*/
///<summary>divide</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)值相除的三维向量</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
divide: function ( v ) {
this.x /= v.x;
this.y /= v.y;
this.z /= v.z;
return this; //返回新坐标值的三维向量
},
/*
///divideScalar方法用来将三维向量的(x,y,z)坐标值直接与参数scalar相除.并返回新的坐标值的三维向量.
/// NOTE:1. 参数scalar如果为0,当前对象(x,y,z)值直接设置为0!!
/// NOTE:2. 这里与divide()方法不同的是,这里传递的参数scalar是一个标量,而divide()方法的参数v是一个三维向量.
*/
///<summary>divideScalar</summary>
///<param name ="scalar" type="number">与当前对象(x,y,z)值相除的标量,数值</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
divideScalar: function ( scalar ) {
if ( scalar !== 0 ) {
var invScalar = 1 / scalar; //将被除数换算成小数
this.x *= invScalar;
this.y *= invScalar;
this.z *= invScalar;
} else {
//参数scalar如果为0,当前对象(x,y,z)值直接设置为0!!
this.x = 0;
this.y = 0;
this.z = 0;
}
return this; //返回新坐标值的三维向量
},
/*
///min方法用来将三维向量的(x,y,z)坐标值直接与参数v的(x,y,z)比较,如果当前三维向量的值大于参数v的(x,y,z),
///将参数v的(x,y,z)赋值给当前向量,并返回(x,y,z)值最小的三维向量.
*/
///<summary>min</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)值参数v的(x,y,z)比较,并返回(x,y,z)值最小的三维向量.</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
min: function ( v ) {
if ( this.x > v.x ) { //如果当前三维向量的x值大于参数v.x
this.x = v.x; //将参数v的x值赋值给当前向量
}
if ( this.y > v.y ) { //如果当前三维向量的y值大于参数v.y
this.y = v.y; //将参数v的y值赋值给当前向量
}
if ( this.z > v.z ) { //如果当前三维向量的z值大于参数v.z
this.z = v.z; //将参数v的z值赋值给当前向量
}
return this; //返回新坐标值的三维向量
},
/*
///max方法用来将三维向量的(x,y,z)坐标值直接与参数v的(x,y,z)比较,如果当前三维向量的值小于参数v的(x,y,z),
///将参数v的(x,y,z)赋值给当前向量,并返回(x,y,z)值最大的三维向量.
*/
///<summary>min</summary>
///<param name ="v" type="Vector3">与当前对象(x,y,z)值参数v的(x,y,z)比较,并返回(x,y,z)值最大的三维向量.</param>
///<returns type="Vector3">返回新坐标值的三维向量</returns>
max: function ( v ) {
if ( this.x < v.x ) { //如果当前三维向量的x值小于参数v.x
this.x = v.x; //将参数v的x值赋值给当前向量
}
if ( this.y < v.y ) { //如果当前三维向量的y值小于参数v.y
this.y = v.y; //将参数v的y值赋值给当前向量
}
if ( this.z < v.z ) { //如果当前三维向量的z值小于参数v.z
this.z = v.z; //将参数v的z值赋值给当前向量
}
return this; //返回新坐标值的三维向量
},
/*
///clamp方法用来将三维向量的(x,y,z)坐标值直接与参数min,参数max的(x,y,z)比较,如果当前三维向量的值小于参数min的(x,y,z)
///或者大于参数max的(x,y,z),对应的将参数min或max的(x,y,z)赋值给当前三维向量,
/// NOTE:保持当前三维向量在min,max所组成的三维空间的之内,最大不超过max的(x,y,z)值,最小不小于min的(x,y,z)值.
*/
///<summary>clamp</summary>
///<param name ="min" type="Vector3">三维向量.</param>
///<param name ="max" type="Vector3">三维向量.</param>
///<returns type="Vector3">返回指定界限内的三维向量</returns>
clamp: function ( min, max ) {
// This function assumes min < max, if this assumption isn't true it will not operate correctly
// 这个方法用来获得三维向量的最小值于最大值,如果没有获取到,说明函数运行错误.
if ( this.x < min.x ) { //如果当前三维向量的x值小于参数min的x值
this.x = min.x; //将参数min的x值赋值给当前向量
} else if ( this.x > max.x ) { //如果当前三维向量的x值大于参数max的x值
this.x = max.x; //将参数max的x值赋值给当前向量
}
if ( this.y < min.y ) { //如果当前三维向量的y值小于参数min的y值
this.y = min.y; //将参数min的y值赋值给当前向量
} else if ( this.y > max.y ) { //如果当前三维向量的y值大于参数max的y值
this.y = max.y; //将参数max的y值赋值给当前向量
}
if ( this.z < min.z ) { //如果当前三维向量的z值小于参数min的z值
this.z = min.z; //将参数min的z值赋值给当前向量
} else if ( this.z > max.z ) { //如果当前三维向量的z值大于参数max的z值
this.z = max.z; //将参数max的z值赋值给当前向量
}
return this; //返回指定界限内的三维向量
},
/*
///clampScalar方法用来将三维向量的(x,y,z)坐标值直接与参数minVal,参数maxVal比较,如果当前三维向量的值小于参数minVal
///或者大于参数maxVal,将参数minVal或maxVal赋值给当前三维向量,
/// NOTE: 1. 保持当前三维向量在minVal,maxVal所组成的三维空间的之内,最大不超过maxVal值,最小不小于minVal值.
/// NOTE: 2. 这里与clamp()方法不同的是,这里传递的参数minVal,maxVal是一个标量,而clamp()方法的参数min,参数max是两个三维向量.
*/
///<summary>clampScalar</summary>
///<param name ="minVal" type="number">下限.</param>
///<param name ="maxVal" type="number">上限.</param>
///<returns type="Vector3">返回指定界限内的三维向量</returns>
clampScalar: ( function () { //外侧括号是一种特殊的用法,似乎代表立即执行.小白,请见谅!
var min, max;
return function ( minVal, maxVal ) { //创建匿名函数
if ( min === undefined ) {
min = new THREE.Vector3();
max = new THREE.Vector3();
}
min.set( minVal, minVal, minVal );
max.set( maxVal, maxVal, maxVal );
return this.clamp( min, max ); //调用clamp()方法,返回指定界限内的三维向量
};
} )(),
/*
///floor方法用来返回小于或等于三维向量的(x,y,z)坐标值的最大整数
/// NOTE:去掉小数部分
*/
///<summary>floor</summary>
///<returns type="Vector3">返回圆整后的三维向量</returns>
floor: function () {
this.x = Math.floor( this.x );
this.y = Math.floor( this.y );
this.z = Math.floor( this.z );
return this; //返回圆整后的三维向量
},
/*
///ceil方法用来返回大于或等于三维向量的(x,y,z)坐标值的最小整数
/// NOTE:将小数部分去掉加1.
*/
///<summary>ceil</summary>
///<returns type="Vector3">返回圆整后的三维向量</returns>
ceil: function () {
this.x = Math.ceil( this.x );
this.y = Math.ceil( this.y );
this.z = Math.ceil( this.z );
return this; //返回圆整后的三维向量
},
/*
///round方法用来返回最接近三维向量的(x,y,z)坐标值的整数
/// NOTE:也就是四舍五入
*/
///<summary>round</summary>
///<returns type="Vector3">返回圆整后的三维向量</returns>
round: function () {
this.x = Math.round( this.x );
this.y = Math.round( this.y );
this.z = Math.round( this.z );
return this; //返回圆整后的三维向量
},
/*
///roundToZero方法将当前三维向量的(x,y,z)坐标值若为负数时,返回大于或等于三维向量的(x,y,z)坐标值的最小整数
/// 而当前三维向量的(x,y,z)坐标值若为正数时,返回小于或等于三维向量的(x,y,z)坐标值的最大整数
*/
///<summary>roundToZero</summary>
///<returns type="Vector3">返回圆整后的三维向量</returns>
roundToZero: function () {
this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
return this; //返回圆整后的三维向量
},
/*
///negate方法将当前三维向量的(x,y,z)坐标值若为负数时,返回正数.
/// 而当前三维向量的(x,y,z)坐标值若为正数时,返回负数.
/// NOTE:取当前三维向量的(x,y,z)坐标值相反数,经常用来翻转法线
*/
///<summary>negate</summary>
///<returns type="Vector3">返回取相反数后的三维向量</returns>
negate: function () {
this.x = - this.x;
this.y = - this.y;
this.z = - this.z;
return this; //返回取相反数后的三维向量
},
/*
///dot方法将返回两个向量的点乘积(点乘,数量积).
/// NOTE:1. 关于点积的介绍参考维基百科:http://zh.wikipedia.org/wiki/%E6%95%B0%E9%87%8F%E7%A7%AF, 常用来进行方向性判断，如两向量点积大于0，则它们的方向朝向相近；如果小于0，则方向相反。
/// NOTE:2. Vector3.Dot也叫点积，它返回1个-1.0～1.0之间的一个值。网上确实也这么说。但是这个值表示什么呢？恩，表示返回进行Dot计算的两个向量之间的夹角的余弦值(Cos弧度角).要注意的是能进行Dot计算的前提是两个向量首先要变成单位向量！
*/
///<summary>dot</summary>
///<param name ="v" type="Vector3">三维向量</param>
///<returns type="number">返回点乘积(点乘,数量积)</returns>
dot: function ( v ) {
return this.x * v.x + this.y * v.y + this.z * v.z; //返回点乘积(点乘,数量积)
},
/*
///lengthSq方法将返回这个三维向量的长度的平方（只读）.
/// NOTE：勾股定理a^2 + b^2 +c^2= d^2,这里返回的是d^2.
*/
///<summary>lengthSq</summary>
///<returns type="number">返回三维向量的长度的平方（只读）</returns>
lengthSq: function () {
return this.x * this.x + this.y * this.y + this.z * this.z; //返回三维向量的长度的平方（只读）
},
/*
///length方法将返回三维向量的长度（只读）.
/// NOTE：勾股定理a^2 + b^2 + c^2=d^2,d=Math.sqrt(a^2 + b^2+c^2),这里返回的是d.
*/
///<summary>length</summary>
///<returns type="number">返回三维向量的长度（只读）</returns>
length: function () {
return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z ); //返回三维向量的长度（只读）
},
/*
///lengthManhattan方法将返回三维向量(x,y,z)值的和（只读）.
///曼哈顿距离——两点在南北方向上的距离加上在东西方向上的距离，即d（i，j）=|xi-xj|+|yi-yj|。对于一个具有
///正南正北、正东正西方向规则布局的城镇街道，从一点到达另一点的距离正是在南北方向上旅行的距离加上在东西方向
///上旅行的距离，因此曼哈顿距离又称为出租车距离，曼哈顿距离不是距离不变量，当坐标轴变动时，点间的距离就会不同。
///维基百科上的内容:http://zh.wikipedia.org/zh/%E6%9B%BC%E5%93%88%E9%A0%93%E8%B7%9D%E9%9B%A2
/// NOTE：曼哈顿距离,this.x + this.y + this.z.
/// TODO:曼哈顿距离,这个功能应该二维向量中增加这个方法呀?计算路径的时候很常用呀.
*/
///<summary>lengthManhattan</summary>
///<returns type="number">返回三维向量的长度（只读）</returns>
lengthManhattan: function () {
return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
},
/*
///normalize方法将返回向量的长度为1（只读）.
/// 复习一下初中的几何吧,三角恒等式,给你准备好了 :) ,见维基百科:
/// http://zh.wikipedia.org/wiki/%E4%B8%89%E8%A7%92%E5%87%BD%E6%95%B0#.E4.B8.89.E8.A7.92.E6.81.92.E7.AD.89.E5.BC.8F
*/
///<summary>normalize</summary>
///<returns type="number">返回三维向量(x,y,z)值的和（只读）</returns>
normalize: function () {
return this.divideScalar( this.length() ); //返回三维向量(x,y,z)值的和（只读）
},
/*
///setLength方法用来按照参数l(长度)设置新的三维向量(x,y,z)值.
/// NOTE:将以原点到当前向量的线段等比例缩放到参数l所指定的长度.
*/
///<summary>setLength</summary>
///<param name ="l" type="number">指定的长度</param>
///<returns type="Vector3">返回按照参数l(长度)设置新的三维向量(x,y,z)值.</returns>
setLength: function ( l ) {
var oldLength = this.length();
if ( oldLength !== 0 && l !== oldLength ) { //做个判断,如果原长度与新长度不相等,并且原长度不为0.
this.multiplyScalar( l / oldLength ); //调用.multiplyScalar()方法,传递新长度与原长度的比.
}
return this; //返回按照参数l(长度)设置新的三维向量(x,y,z)值.
},
/*lerp方法
///lerp方法在将当前三维向量(x,y,z)设置为下限和参数v(x,y,z)设为上限 之间进行线性插值，
/// alpha 表示权值。从下限当前三维向量(x,y,z)到上限参数v(x,y,z)乘以百分比alpha(0.0-1.0),加上当前三维向量(x,y,z)
///当前二维向量(x,y,z)的和赋值给当前三维向量(x,y,z),返回当前三维向量(x,y,z).
/// NOTE:注意，如果 当前三维向量(x,y,z) 和 参数v(x,y,z)是向量，则权值 alpha 必须是标量,取值范围是0.0-1.0.
*/
///<summary>lerp</summary>
///<param name ="v" type="Vector3">三维向量</param>
///<param name ="alpha" type="number">百分比权值(0.0-1.0)</param>
///<returns type="Vector3">三维向量</returns>
lerp: function ( v, alpha ) {
this.x += ( v.x - this.x ) * alpha;
this.y += ( v.y - this.y ) * alpha;
this.z += ( v.z - this.z ) * alpha;
return this; //返回三维向量
},
/*cross方法
///cross方法将返回两个交叉乘积,调用者本身与v的叉乘。叉乘是一个向量，垂直于参与叉乘的两个向量并呈右手螺旋法则。
/// 返回为同时垂直于两个参数向量的向量，方向可朝上也可朝下，由两向量夹角的方向决定。
/// NOTE:借助右手定则辅助判断方向。
/// 叉乘是一种在向量空间中向量的二元运算。与点乘不同，它的运算结果是一个伪向量而不是一个标量。
/// 叉乘的运算结果叫叉积（即交叉乘积）、外积或向量积。叉积与原来的两个向量都垂直。
1、理论知识
数学上的定义：c=axb【注：粗体小写字母表示向量】其中a,b,c均为向量。即两个向量的叉积得到的还是向量！
性质1：c⊥a，c⊥b，即向量c垂直与向量a,b所在的平面。
性质2：模长|c|=|a||b|sin<a,b>
性质3：满足右手法则。从这点我们有axb ≠ bxa，而axb = - bxa。所以我们可以使用叉积的正负值来判断向量a，b的相对
位置，即向量b是处于向量a的顺时针方向还是逆时针方向。
*/
///<summary>cross</summary>
///<param name ="v" type="Vector3">三维向量</param>
///<param name ="w" type="Vector3">三维向量</param>
///<returns type="Vector3">三维向量</returns>
cross: function ( v, w ) {
if ( w !== undefined ) {
console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );
return this.crossVectors( v, w ); //如果存在第二个参数,将调用.crossVectors()方法.
}
var x = this.x, y = this.y, z = this.z;
this.x = y * v.z - z * v.y;
this.y = z * v.x - x * v.z;
this.z = x * v.y - y * v.x;
return this; //返回三维向量
},
/*crossVectors方法
///crossVectors方法将返回两个交叉乘积,调用者变为a，b的叉乘。叉乘是一个向量，垂直于参与叉乘的两个向量并呈右手螺旋法则。
/// 返回为同时垂直于两个参数向量的向量，方向可朝上也可朝下，由两向量夹角的方向决定。
/// NOTE:借助右手定则辅助判断方向。参考:http://zh.wikipedia.org/zh/%E5%90%91%E9%87%8F%E7%A7%AF
/// 叉乘是一种在向量空间中向量的二元运算。与点乘不同，它的运算结果是一个伪向量而不是一个标量。
/// 叉乘的运算结果叫叉积（即交叉乘积）、外积或向量积。叉积与原来的两个向量都垂直。
1、理论知识
数学上的定义：c=axb【注：粗体小写字母表示向量】其中a,b,c均为向量。即两个向量的叉积得到的还是向量！
性质1：c⊥a，c⊥b，即向量c垂直与向量a,b所在的平面。
性质2：模长|c|=|a||b|sin<a,b>
性质3：满足右手法则。从这点我们有axb ≠ bxa，而axb = - bxa。所以我们可以使用叉积的正负值来判断向量a，b的相对位置，
即向量b是处于向量a的顺时针方向还是逆时针方向。
*/
///<summary>crossVectors</summary>
///<param name ="a" type="Vector3">三维向量</param>
///<param name ="b" type="Vector3">三维向量</param>
///<returns type="Vector3">三维向量</returns>
crossVectors: function ( a, b ) {
var ax = a.x, ay = a.y, az = a.z;
var bx = b.x, by = b.y, bz = b.z;
this.x = ay * bz - az * by;
this.y = az * bx - ax * bz;
this.z = ax * by - ay * bx;
return this; //返回三维向量
},
/*projectOnVector方法
///projectOnVector方法在将当前三维向量(x,y,z)投影一个向量到另一个向量,参数vector(x,y,z).
/// NOTE:进行Dot计算的前提是两个向量首先要变成单位向量,这里通过调用.normalize()得到单位向量.
*/
///<summary>projectOnVector</summary>
///<param name ="vector" type="Vector3">三维向量</param>
///<returns type="Vector3">三维向量</returns>
projectOnVector: function () {
var v1, dot;
return function ( vector ) {
if ( v1 === undefined ) v1 = new THREE.Vector3();
v1.copy( vector ).normalize(); //NOTE:进行Dot计算的前提是两个向量首先要变成单位向量,这里通过调用.normalize()得到单位向量.
dot = this.dot( v1 ); //dot常用来进行方向性判断，如两向量点积大于0，则它们的方向朝向相近；如果小于0，则方向相反。
return this.copy( v1 ).multiplyScalar( dot ); //投影一个向量到另一个向量。
};
}(),
/*projectOnPlane方法
///projectOnPlane方法在将当前三维向量(x,y,z)投影一个向量到一个平面(用一个向量表示,参数planeNormal(x,y,z)),然后当前向量减去
///从这个向量到这个向量到平面法线的投影.
*/
///<summary>projectOnPlane</summary>
///<param name ="planeNormal" type="Vector3">三维向量</param>
///<returns type="Vector3">三维向量</returns>
projectOnPlane: function () {
var v1;
return function ( planeNormal ) {
if ( v1 === undefined ) v1 = new THREE.Vector3();
v1.copy( this ).projectOnVector( planeNormal ); //调用.projectVector方法.
return this.sub( v1 );
}
}(),
/*reflect方法
///reflect方法沿着法线(参数normal)反射向量.
/// NOTE:reflect方法其实就是对一个向量进行镜像.
*/
///<summary>reflect</summary>
///<param name ="normal" type="Vector3">三维向量</param>
///<returns type="Vector3">返回一个反射过后的向量.</returns>
reflect: function () {