1 | import { Vector3 } from './Vector3.js';
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | function Matrix3() {
|
11 |
|
12 | this.elements = [
|
13 |
|
14 | 1, 0, 0,
|
15 | 0, 1, 0,
|
16 | 0, 0, 1
|
17 |
|
18 | ];
|
19 |
|
20 | if ( arguments.length > 0 ) {
|
21 |
|
22 | console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );
|
23 |
|
24 | }
|
25 |
|
26 | }
|
27 |
|
28 | Object.assign( Matrix3.prototype, {
|
29 |
|
30 | isMatrix3: true,
|
31 |
|
32 | set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
|
33 |
|
34 | var te = this.elements;
|
35 |
|
36 | te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
|
37 | te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
|
38 | te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
|
39 |
|
40 | return this;
|
41 |
|
42 | },
|
43 |
|
44 | identity: function () {
|
45 |
|
46 | this.set(
|
47 |
|
48 | 1, 0, 0,
|
49 | 0, 1, 0,
|
50 | 0, 0, 1
|
51 |
|
52 | );
|
53 |
|
54 | return this;
|
55 |
|
56 | },
|
57 |
|
58 | clone: function () {
|
59 |
|
60 | return new this.constructor().fromArray( this.elements );
|
61 |
|
62 | },
|
63 |
|
64 | copy: function ( m ) {
|
65 |
|
66 | var te = this.elements;
|
67 | var me = m.elements;
|
68 |
|
69 | te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
|
70 | te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
|
71 | te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
|
72 |
|
73 | return this;
|
74 |
|
75 | },
|
76 |
|
77 | setFromMatrix4: function ( m ) {
|
78 |
|
79 | var me = m.elements;
|
80 |
|
81 | this.set(
|
82 |
|
83 | me[ 0 ], me[ 4 ], me[ 8 ],
|
84 | me[ 1 ], me[ 5 ], me[ 9 ],
|
85 | me[ 2 ], me[ 6 ], me[ 10 ]
|
86 |
|
87 | );
|
88 |
|
89 | return this;
|
90 |
|
91 | },
|
92 |
|
93 | applyToBufferAttribute: function () {
|
94 |
|
95 | var v1 = new Vector3();
|
96 |
|
97 | return function applyToBufferAttribute( attribute ) {
|
98 |
|
99 | for ( var i = 0, l = attribute.count; i < l; i ++ ) {
|
100 |
|
101 | v1.x = attribute.getX( i );
|
102 | v1.y = attribute.getY( i );
|
103 | v1.z = attribute.getZ( i );
|
104 |
|
105 | v1.applyMatrix3( this );
|
106 |
|
107 | attribute.setXYZ( i, v1.x, v1.y, v1.z );
|
108 |
|
109 | }
|
110 |
|
111 | return attribute;
|
112 |
|
113 | };
|
114 |
|
115 | }(),
|
116 |
|
117 | multiply: function ( m ) {
|
118 |
|
119 | return this.multiplyMatrices( this, m );
|
120 |
|
121 | },
|
122 |
|
123 | premultiply: function ( m ) {
|
124 |
|
125 | return this.multiplyMatrices( m, this );
|
126 |
|
127 | },
|
128 |
|
129 | multiplyMatrices: function ( a, b ) {
|
130 |
|
131 | var ae = a.elements;
|
132 | var be = b.elements;
|
133 | var te = this.elements;
|
134 |
|
135 | var a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
|
136 | var a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
|
137 | var a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
|
138 |
|
139 | var b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
|
140 | var b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
|
141 | var b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
|
142 |
|
143 | te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
|
144 | te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
|
145 | te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
|
146 |
|
147 | te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
|
148 | te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
|
149 | te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
|
150 |
|
151 | te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
|
152 | te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
|
153 | te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
|
154 |
|
155 | return this;
|
156 |
|
157 | },
|
158 |
|
159 | multiplyScalar: function ( s ) {
|
160 |
|
161 | var te = this.elements;
|
162 |
|
163 | te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
|
164 | te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
|
165 | te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
|
166 |
|
167 | return this;
|
168 |
|
169 | },
|
170 |
|
171 | determinant: function () {
|
172 |
|
173 | var te = this.elements;
|
174 |
|
175 | var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
|
176 | d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
|
177 | g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
|
178 |
|
179 | return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
|
180 |
|
181 | },
|
182 |
|
183 | getInverse: function ( matrix, throwOnDegenerate ) {
|
184 |
|
185 | if ( matrix && matrix.isMatrix4 ) {
|
186 |
|
187 | console.error( "THREE.Matrix3: .getInverse() no longer takes a Matrix4 argument." );
|
188 |
|
189 | }
|
190 |
|
191 | var me = matrix.elements,
|
192 | te = this.elements,
|
193 |
|
194 | n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],
|
195 | n12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],
|
196 | n13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ],
|
197 |
|
198 | t11 = n33 * n22 - n32 * n23,
|
199 | t12 = n32 * n13 - n33 * n12,
|
200 | t13 = n23 * n12 - n22 * n13,
|
201 |
|
202 | det = n11 * t11 + n21 * t12 + n31 * t13;
|
203 |
|
204 | if ( det === 0 ) {
|
205 |
|
206 | var msg = "THREE.Matrix3: .getInverse() can't invert matrix, determinant is 0";
|
207 |
|
208 | if ( throwOnDegenerate === true ) {
|
209 |
|
210 | throw new Error( msg );
|
211 |
|
212 | } else {
|
213 |
|
214 | console.warn( msg );
|
215 |
|
216 | }
|
217 |
|
218 | return this.identity();
|
219 |
|
220 | }
|
221 |
|
222 | var detInv = 1 / det;
|
223 |
|
224 | te[ 0 ] = t11 * detInv;
|
225 | te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
|
226 | te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
|
227 |
|
228 | te[ 3 ] = t12 * detInv;
|
229 | te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
|
230 | te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
|
231 |
|
232 | te[ 6 ] = t13 * detInv;
|
233 | te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
|
234 | te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
|
235 |
|
236 | return this;
|
237 |
|
238 | },
|
239 |
|
240 | transpose: function () {
|
241 |
|
242 | var tmp, m = this.elements;
|
243 |
|
244 | tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
|
245 | tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
|
246 | tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
|
247 |
|
248 | return this;
|
249 |
|
250 | },
|
251 |
|
252 | getNormalMatrix: function ( matrix4 ) {
|
253 |
|
254 | return this.setFromMatrix4( matrix4 ).getInverse( this ).transpose();
|
255 |
|
256 | },
|
257 |
|
258 | transposeIntoArray: function ( r ) {
|
259 |
|
260 | var m = this.elements;
|
261 |
|
262 | r[ 0 ] = m[ 0 ];
|
263 | r[ 1 ] = m[ 3 ];
|
264 | r[ 2 ] = m[ 6 ];
|
265 | r[ 3 ] = m[ 1 ];
|
266 | r[ 4 ] = m[ 4 ];
|
267 | r[ 5 ] = m[ 7 ];
|
268 | r[ 6 ] = m[ 2 ];
|
269 | r[ 7 ] = m[ 5 ];
|
270 | r[ 8 ] = m[ 8 ];
|
271 |
|
272 | return this;
|
273 |
|
274 | },
|
275 |
|
276 | setUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) {
|
277 |
|
278 | var c = Math.cos( rotation );
|
279 | var s = Math.sin( rotation );
|
280 |
|
281 | this.set(
|
282 | sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
|
283 | - sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
|
284 | 0, 0, 1
|
285 | );
|
286 |
|
287 | },
|
288 |
|
289 | scale: function ( sx, sy ) {
|
290 |
|
291 | var te = this.elements;
|
292 |
|
293 | te[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;
|
294 | te[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;
|
295 |
|
296 | return this;
|
297 |
|
298 | },
|
299 |
|
300 | rotate: function ( theta ) {
|
301 |
|
302 | var c = Math.cos( theta );
|
303 | var s = Math.sin( theta );
|
304 |
|
305 | var te = this.elements;
|
306 |
|
307 | var a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];
|
308 | var a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];
|
309 |
|
310 | te[ 0 ] = c * a11 + s * a21;
|
311 | te[ 3 ] = c * a12 + s * a22;
|
312 | te[ 6 ] = c * a13 + s * a23;
|
313 |
|
314 | te[ 1 ] = - s * a11 + c * a21;
|
315 | te[ 4 ] = - s * a12 + c * a22;
|
316 | te[ 7 ] = - s * a13 + c * a23;
|
317 |
|
318 | return this;
|
319 |
|
320 | },
|
321 |
|
322 | translate: function ( tx, ty ) {
|
323 |
|
324 | var te = this.elements;
|
325 |
|
326 | te[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];
|
327 | te[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];
|
328 |
|
329 | return this;
|
330 |
|
331 | },
|
332 |
|
333 | equals: function ( matrix ) {
|
334 |
|
335 | var te = this.elements;
|
336 | var me = matrix.elements;
|
337 |
|
338 | for ( var i = 0; i < 9; i ++ ) {
|
339 |
|
340 | if ( te[ i ] !== me[ i ] ) return false;
|
341 |
|
342 | }
|
343 |
|
344 | return true;
|
345 |
|
346 | },
|
347 |
|
348 | fromArray: function ( array, offset ) {
|
349 |
|
350 | if ( offset === undefined ) offset = 0;
|
351 |
|
352 | for ( var i = 0; i < 9; i ++ ) {
|
353 |
|
354 | this.elements[ i ] = array[ i + offset ];
|
355 |
|
356 | }
|
357 |
|
358 | return this;
|
359 |
|
360 | },
|
361 |
|
362 | toArray: function ( array, offset ) {
|
363 |
|
364 | if ( array === undefined ) array = [];
|
365 | if ( offset === undefined ) offset = 0;
|
366 |
|
367 | var te = this.elements;
|
368 |
|
369 | array[ offset ] = te[ 0 ];
|
370 | array[ offset + 1 ] = te[ 1 ];
|
371 | array[ offset + 2 ] = te[ 2 ];
|
372 |
|
373 | array[ offset + 3 ] = te[ 3 ];
|
374 | array[ offset + 4 ] = te[ 4 ];
|
375 | array[ offset + 5 ] = te[ 5 ];
|
376 |
|
377 | array[ offset + 6 ] = te[ 6 ];
|
378 | array[ offset + 7 ] = te[ 7 ];
|
379 | array[ offset + 8 ] = te[ 8 ];
|
380 |
|
381 | return array;
|
382 |
|
383 | }
|
384 |
|
385 | } );
|
386 |
|
387 |
|
388 | export { Matrix3 };
|