Merge branch 'features/r2_11_2/JAL-3821_reinstate_patch' into develop
[jalview.git] / unused / javajs / util / M4.java
1 /*
2    Copyright (C) 1997,1998,1999
3    Kenji Hiranabe, Eiwa System Management, Inc.
4
5    This program is free software.
6    Implemented by Kenji Hiranabe(hiranabe@esm.co.jp),
7    conforming to the Java(TM) 3D API specification by Sun Microsystems.
8
9    Permission to use, copy, modify, distribute and sell this software
10    and its documentation for any purpose is hereby granted without fee,
11    provided that the above copyright notice appear in all copies and
12    that both that copyright notice and this permission notice appear
13    in supporting documentation. Kenji Hiranabe and Eiwa System Management,Inc.
14    makes no representations about the suitability of this software for any
15    purpose.  It is provided "AS IS" with NO WARRANTY.
16 */
17 package javajs.util;
18
19 /**
20  * A single precision floating point 4 by 4 matrix.
21  * 
22  * @author Kenji hiranabe
23  * 
24  *         additions by Bob Hanson hansonr@stolaf.edu 9/30/2012 for unique
25  *         constructor and method names for the optimization of compiled
26  *         JavaScript using Java2Script
27  */
28 public class M4 extends M34 {
29
30   /**
31    * The fourth element of the first row.
32    */
33   public float m03;
34
35   /**
36    * The fourth element of the second row.
37    */
38   public float m13;
39
40   /**
41    * The fourth element of the third row.
42    */
43   public float m23;
44
45   /**
46    * The first element of the fourth row.
47    */
48   public float m30;
49
50   /**
51    * The second element of the fourth row.
52    */
53   public float m31;
54
55   /**
56    * The third element of the fourth row.
57    */
58   public float m32;
59
60   /**
61    * The fourth element of the fourth row.
62    */
63   public float m33 = 0;
64
65   /**
66    * all zeros
67    */
68   public M4() {
69   }
70   /**
71    * Constructs and initializes a Matrix4f from the specified 16 element array.
72    * this.m00 =v[0], this.m01=v[1], etc.
73    * 
74    * @param v
75    *        the array of length 16 containing in order
76    * @return m
77    */
78   public static M4 newA16(float[] v) {
79     M4 m = new M4();
80     m.m00 = v[0];
81     m.m01 = v[1];
82     m.m02 = v[2];
83     m.m03 = v[3];
84
85     m.m10 = v[4];
86     m.m11 = v[5];
87     m.m12 = v[6];
88     m.m13 = v[7];
89
90     m.m20 = v[8];
91     m.m21 = v[9];
92     m.m22 = v[10];
93     m.m23 = v[11];
94
95     m.m30 = v[12];
96     m.m31 = v[13];
97     m.m32 = v[14];
98     m.m33 = v[15];
99
100     return m;
101   }
102
103   /**
104    * Constructs a new matrix with the same values as the Matrix4f parameter.
105    * 
106    * @param m1
107    *        the source matrix
108    * @return m
109    */
110   public static M4 newM4(M4 m1) {
111     M4 m = new M4();
112     if (m1 == null) {
113       m.setIdentity();
114       return m;
115     }
116     m.setToM3(m1);
117     m.m03 = m1.m03;
118     m.m13 = m1.m13;
119     m.m23 = m1.m23;
120     m.m30 = m1.m30;
121     m.m31 = m1.m31;
122     m.m32 = m1.m32;
123     m.m33 = m1.m33;
124     return m;
125   }
126
127   /**
128    * Constructs and initializes a Matrix4f from the rotation matrix and
129    * translation.
130    * 
131    * @param m1
132    *        The rotation matrix representing the rotational components
133    * @param t
134    *        The translational components of the matrix
135    * @return m
136    */
137   public static M4 newMV(M3 m1, T3 t) {
138     M4 m = new M4();
139     m.setMV(m1, t);
140     return m;
141   }
142
143   /**
144    * Sets this matrix to all zeros.
145    */
146   public void setZero() {
147     clear33();
148     m03 = m13 = m23 = m30 = m31 = m32 = m33 = 0.0f;
149   }
150
151   /**
152    * Sets this Matrix4f to identity.
153    */
154   public void setIdentity() {
155     setZero();
156     m00 = m11 = m22 = m33 = 1.0f;
157   }
158
159   /**
160    * Sets the value of this matrix to a copy of the passed matrix m1.
161    * 
162    * @param m1
163    *        the matrix to be copied
164    * @return this
165    */
166   public M4 setM4(M4 m1) {
167     setM33(m1);
168     m03 = m1.m03;
169     m13 = m1.m13;
170     m23 = m1.m23;
171     m30 = m1.m30;
172     m31 = m1.m31;
173     m32 = m1.m32;
174     m33 = m1.m33;
175     return this;
176   }
177
178   /**
179    * Initializes a Matrix4f from the rotation matrix and translation.
180    * 
181    * @param m1
182    *        The rotation matrix representing the rotational components
183    * @param t
184    *        The translational components of the matrix
185    */
186   public void setMV(M3 m1, T3 t) {
187     setM33(m1);
188     setTranslation(t);
189     m33 = 1;
190   }
191
192   /**
193    * Sets the rotational component (upper 3x3) of this matrix to the matrix
194    * values in the single precision Matrix3f argument; the other elements of
195    * this matrix are initialized as if this were an identity matrix (ie, affine
196    * matrix with no translational component).
197    * 
198    * @param m1
199    *        the 3x3 matrix
200    */
201   public void setToM3(M34 m1) {
202     setM33(m1);
203     m03 = m13 = m23 = m30 = m31 = m32 = 0.0f;
204     m33 = 1.0f;
205   }
206
207   /**
208    * Sets the rotational component (upper 3x3) of this matrix 
209    * to a rotation given by an axis angle
210    * 
211    * @param a
212    *        the axis and angle to be converted
213    */
214   public void setToAA(A4 a) {
215     setIdentity();
216     setAA33(a);
217   }
218
219   /**
220    * Sets the values in this Matrix4f equal to the row-major array parameter
221    * (ie, the first four elements of the array will be copied into the first row
222    * of this matrix, etc.).
223    * 
224    * @param m
225    */
226   public void setA(float m[]) {
227     m00 = m[0];
228     m01 = m[1];
229     m02 = m[2];
230     m03 = m[3];
231     m10 = m[4];
232     m11 = m[5];
233     m12 = m[6];
234     m13 = m[7];
235     m20 = m[8];
236     m21 = m[9];
237     m22 = m[10];
238     m23 = m[11];
239     m30 = m[12];
240     m31 = m[13];
241     m32 = m[14];
242     m33 = m[15];
243   }
244
245   /**
246    * Modifies the translational components of this matrix to the values of the
247    * Vector3f argument; the other values of this matrix are not modified.
248    * 
249    * @param trans
250    *        the translational component
251    */
252   public void setTranslation(T3 trans) {
253     m03 = trans.x;
254     m13 = trans.y;
255     m23 = trans.z;
256   }
257
258   /**
259    * Sets the specified element of this matrix4f to the value provided.
260    * 
261    * @param row
262    *        the row number to be modified (zero indexed)
263    * @param col
264    *        the column number to be modified (zero indexed)
265    * @param v
266    *        the new value
267    */
268   public void setElement(int row, int col, float v) {
269     if (row < 3 && col < 3) {
270       set33(row, col, v);
271       return;
272     }
273     if (row > 3 || col > 3)
274       err();
275     switch (row) {
276     case 0:
277       m03 = v;
278       return;
279     case 1:
280       m13 = v;
281       return;
282     case 2:
283       m23 = v;
284       return;
285     }
286     switch (col) {
287     case 0:
288       m30 = v;
289       return;
290     case 1:
291       m31 = v;
292       return;
293     case 2:
294       m32 = v;
295       return;
296     case 3:
297       m33 = v;
298       return;
299     }
300   }
301
302   /**
303    * Retrieves the value at the specified row and column of this matrix.
304    * 
305    * @param row
306    *        the row number to be retrieved (zero indexed)
307    * @param col
308    *        the column number to be retrieved (zero indexed)
309    * @return the value at the indexed element
310    */
311   public float getElement(int row, int col) {
312     if (row < 3 && col < 3)
313       return get33(row, col);
314     if (row > 3 || col > 3) {
315       err();
316       return 0;
317     }
318     switch (row) {
319     case 0:
320       return m03;
321     case 1:
322       return m13;
323     case 2:
324       return m23;
325     default:
326       switch (col) {
327       case 0:
328         return m30;
329       case 1:
330         return m31;
331       case 2:
332         return m32;
333       default:
334         return m33;
335       }
336     }
337   }
338
339   /**
340    * Retrieves the translational components of this matrix.
341    * 
342    * @param trans
343    *        the vector that will receive the translational component
344    */
345   public void getTranslation(T3 trans) {
346     trans.x = m03;
347     trans.y = m13;
348     trans.z = m23;
349   }
350
351   /**
352    * Gets the upper 3x3 values of this matrix and places them into the matrix
353    * m1.
354    * 
355    * @param m1
356    *        The matrix that will hold the values
357    */
358   public void getRotationScale(M3 m1) {
359     m1.m00 = m00;
360     m1.m01 = m01;
361     m1.m02 = m02;
362     m1.m10 = m10;
363     m1.m11 = m11;
364     m1.m12 = m12;
365     m1.m20 = m20;
366     m1.m21 = m21;
367     m1.m22 = m22;
368   }
369
370   /**
371    * Replaces the upper 3x3 matrix values of this matrix with the values in the
372    * matrix m1.
373    * 
374    * @param m1
375    *        The matrix that will be the new upper 3x3
376    */
377   public void setRotationScale(M3 m1) {
378     m00 = m1.m00;
379     m01 = m1.m01;
380     m02 = m1.m02;
381     m10 = m1.m10;
382     m11 = m1.m11;
383     m12 = m1.m12;
384     m20 = m1.m20;
385     m21 = m1.m21;
386     m22 = m1.m22;
387   }
388
389   /**
390    * Sets the specified row of this matrix4f to the four values provided.
391    * 
392    * @param row
393    *        the row number to be modified (zero indexed)
394    * @param v
395    *        the replacement row
396    */
397   public void setRowA(int row, float v[]) {
398     if (row < 3)
399       setRow33(row, v);
400     switch (row) {
401     case 0:
402       m03 = v[3];
403       return;
404     case 1:
405       m13 = v[3];
406       return;
407     case 2:
408       m23 = v[3];
409       return;
410     case 3:
411       m30 = v[0];
412       m31 = v[1];
413       m32 = v[2];
414       m33 = v[3];
415       return;
416     }
417     err();
418   }
419
420   /**
421    * Copies the matrix values in the specified row into the array parameter.
422    * 
423    * @param row
424    *        the matrix row
425    * @param v
426    *        The array into which the matrix row values will be copied
427    */
428   @Override
429   public void getRow(int row, float v[]) {
430     if (row < 3)
431       getRow33(row, v);
432     switch (row) {
433     case 0:
434       v[3] = m03;
435       return;
436     case 1:
437       v[3] = m13;
438       return;
439     case 2:
440       v[3] = m23;
441       return;
442     case 3:
443       v[0] = m30;
444       v[1] = m31;
445       v[2] = m32;
446       v[3] = m33;
447       return;
448     }
449     err();
450   }
451
452   /**
453    * Sets the specified column of this matrix4f to the four values provided.
454    * 
455    * @param column
456    *        the column number to be modified (zero indexed)
457    * @param x
458    *        the first row element
459    * @param y
460    *        the second row element
461    * @param z
462    *        the third row element
463    * @param w
464    *        the fourth row element
465    */
466   public void setColumn4(int column, float x, float y, float z, float w) {
467     if (column == 0) {
468       m00 = x;
469       m10 = y;
470       m20 = z;
471       m30 = w;
472     } else if (column == 1) {
473       m01 = x;
474       m11 = y;
475       m21 = z;
476       m31 = w;
477     } else if (column == 2) {
478       m02 = x;
479       m12 = y;
480       m22 = z;
481       m32 = w;
482     } else if (column == 3) {
483       m03 = x;
484       m13 = y;
485       m23 = z;
486       m33 = w;
487     } else {
488       err();
489     }
490   }
491
492   /**
493    * Sets the specified column of this matrix4f to the four values provided.
494    * 
495    * @param column
496    *        the column number to be modified (zero indexed)
497    * @param v
498    *        the replacement column
499    */
500   public void setColumnA(int column, float v[]) {
501     if (column < 3)
502       setColumn33(column, v);
503     switch (column) {
504     case 0:
505       m30 = v[3];
506       return;
507     case 1:
508       m31 = v[3];
509       return;
510     case 2:
511       m32 = v[3];
512       return;
513     case 3:
514       m03 = v[0];
515       m13 = v[1];
516       m23 = v[2];
517       m33 = v[3];
518       return;
519     default:
520       err();
521     }
522   }
523
524   /**
525    * Copies the matrix values in the specified column into the array parameter.
526    * 
527    * @param column
528    *        the matrix column
529    * @param v
530    *        The array into which the matrix column values will be copied
531    */
532   public void getColumn(int column, float v[]) {
533     if (column < 3)
534       getColumn33(column, v);
535     switch (column) {
536     case 0:
537       v[3] = m30;
538       return;
539     case 1:
540       v[3] = m31;
541       return;
542     case 2:
543       v[3] = m32;
544       return;
545     case 3:
546       v[0] = m03;
547       v[1] = m13;
548       v[2] = m23;
549       v[3] = m33;
550       return;
551     default:
552       err();
553     }
554   }
555
556   /**
557    * Sets the value of this matrix to the matrix difference of itself and matrix
558    * m1 (this = this - m1).
559    * 
560    * @param m1
561    *        the other matrix
562    */
563   public void sub(M4 m1) {
564     sub33(m1);
565     m03 -= m1.m03;
566     m13 -= m1.m13;
567     m23 -= m1.m23;
568     m30 -= m1.m30;
569     m31 -= m1.m31;
570     m32 -= m1.m32;
571     m33 -= m1.m33;
572   }
573
574   /**
575    * Sets the value of this matrix to its transpose.
576    */
577   public void transpose() {
578     transpose33();
579     float tmp = m03;
580     m03 = m30;
581     m30 = tmp;
582
583     tmp = m13;
584     m13 = m31;
585     m31 = tmp;
586
587     tmp = m23;
588     m23 = m32;
589     m32 = tmp;
590   }
591
592   /**
593    * Sets the value of this matrix to its inverse.
594    * @return this
595    */
596   public M4 invert() {
597     float s = determinant4();
598     if (s == 0.0)
599       return this;
600     s = 1 / s;
601     // alias-safe way.
602     // less *,+,- calculation than expanded expression.
603     set(m11 * (m22 * m33 - m23 * m32) + m12 * (m23 * m31 - m21 * m33) + m13
604         * (m21 * m32 - m22 * m31), m21 * (m02 * m33 - m03 * m32) + m22
605         * (m03 * m31 - m01 * m33) + m23 * (m01 * m32 - m02 * m31), m31
606         * (m02 * m13 - m03 * m12) + m32 * (m03 * m11 - m01 * m13) + m33
607         * (m01 * m12 - m02 * m11), m01 * (m13 * m22 - m12 * m23) + m02
608         * (m11 * m23 - m13 * m21) + m03 * (m12 * m21 - m11 * m22),
609
610     m12 * (m20 * m33 - m23 * m30) + m13 * (m22 * m30 - m20 * m32) + m10
611         * (m23 * m32 - m22 * m33), m22 * (m00 * m33 - m03 * m30) + m23
612         * (m02 * m30 - m00 * m32) + m20 * (m03 * m32 - m02 * m33), m32
613         * (m00 * m13 - m03 * m10) + m33 * (m02 * m10 - m00 * m12) + m30
614         * (m03 * m12 - m02 * m13), m02 * (m13 * m20 - m10 * m23) + m03
615         * (m10 * m22 - m12 * m20) + m00 * (m12 * m23 - m13 * m22),
616
617     m13 * (m20 * m31 - m21 * m30) + m10 * (m21 * m33 - m23 * m31) + m11
618         * (m23 * m30 - m20 * m33), m23 * (m00 * m31 - m01 * m30) + m20
619         * (m01 * m33 - m03 * m31) + m21 * (m03 * m30 - m00 * m33), m33
620         * (m00 * m11 - m01 * m10) + m30 * (m01 * m13 - m03 * m11) + m31
621         * (m03 * m10 - m00 * m13), m03 * (m11 * m20 - m10 * m21) + m00
622         * (m13 * m21 - m11 * m23) + m01 * (m10 * m23 - m13 * m20),
623
624     m10 * (m22 * m31 - m21 * m32) + m11 * (m20 * m32 - m22 * m30) + m12
625         * (m21 * m30 - m20 * m31), m20 * (m02 * m31 - m01 * m32) + m21
626         * (m00 * m32 - m02 * m30) + m22 * (m01 * m30 - m00 * m31), m30
627         * (m02 * m11 - m01 * m12) + m31 * (m00 * m12 - m02 * m10) + m32
628         * (m01 * m10 - m00 * m11), m00 * (m11 * m22 - m12 * m21) + m01
629         * (m12 * m20 - m10 * m22) + m02 * (m10 * m21 - m11 * m20));
630     scale(s);
631     return this;
632   }
633
634   /**
635    * Sets 16 values
636    * 
637    * @param m00
638    * @param m01
639    * @param m02
640    * @param m03
641    * @param m10
642    * @param m11
643    * @param m12
644    * @param m13
645    * @param m20
646    * @param m21
647    * @param m22
648    * @param m23
649    * @param m30
650    * @param m31
651    * @param m32
652    * @param m33
653    */
654   private void set(float m00, float m01, float m02, float m03, float m10,
655                    float m11, float m12, float m13, float m20, float m21,
656                    float m22, float m23, float m30, float m31, float m32,
657                    float m33) {
658     this.m00 = m00;
659     this.m01 = m01;
660     this.m02 = m02;
661     this.m03 = m03;
662     this.m10 = m10;
663     this.m11 = m11;
664     this.m12 = m12;
665     this.m13 = m13;
666     this.m20 = m20;
667     this.m21 = m21;
668     this.m22 = m22;
669     this.m23 = m23;
670     this.m30 = m30;
671     this.m31 = m31;
672     this.m32 = m32;
673     this.m33 = m33;
674   }
675   /**
676    * Computes the determinant of this matrix.
677    * 
678    * @return the determinant of the matrix
679    */
680   public float determinant4() {
681     // less *,+,- calculation than expanded expression.
682     return (m00 * m11 - m01 * m10) * (m22 * m33 - m23 * m32)
683         - (m00 * m12 - m02 * m10) * (m21 * m33 - m23 * m31)
684         + (m00 * m13 - m03 * m10) * (m21 * m32 - m22 * m31)
685         + (m01 * m12 - m02 * m11) * (m20 * m33 - m23 * m30)
686         - (m01 * m13 - m03 * m11) * (m20 * m32 - m22 * m30)
687         + (m02 * m13 - m03 * m12) * (m20 * m31 - m21 * m30);
688
689   }
690
691   /**
692    * Multiplies each element of this matrix by a scalar.
693    * 
694    * @param scalar
695    *        The scalar multiplier.
696    */
697   public void scale(float scalar) {
698     mul33(scalar);
699     m03 *= scalar;
700     m13 *= scalar;
701     m23 *= scalar;
702     m30 *= scalar;
703     m31 *= scalar;
704     m32 *= scalar;
705     m33 *= scalar;
706   }
707
708   /**
709    * Sets the value of this matrix to the result of multiplying itself with
710    * matrix m1.
711    * 
712    * @param m1
713    *        the other matrix
714    */
715   public void mul(M4 m1) {
716     mul2(this, m1);
717   }
718
719   /**
720    * Sets the value of this matrix to the result of multiplying the two argument
721    * matrices together.
722    * 
723    * @param m1
724    *        the first matrix
725    * @param m2
726    *        the second matrix
727    */
728   public void mul2(M4 m1, M4 m2) {
729     // alias-safe way.
730     set(m1.m00 * m2.m00 + m1.m01 * m2.m10 + m1.m02 * m2.m20 + m1.m03 * m2.m30,
731         m1.m00 * m2.m01 + m1.m01 * m2.m11 + m1.m02 * m2.m21 + m1.m03 * m2.m31,
732         m1.m00 * m2.m02 + m1.m01 * m2.m12 + m1.m02 * m2.m22 + m1.m03 * m2.m32,
733         m1.m00 * m2.m03 + m1.m01 * m2.m13 + m1.m02 * m2.m23 + m1.m03 * m2.m33,
734
735         m1.m10 * m2.m00 + m1.m11 * m2.m10 + m1.m12 * m2.m20 + m1.m13 * m2.m30,
736         m1.m10 * m2.m01 + m1.m11 * m2.m11 + m1.m12 * m2.m21 + m1.m13 * m2.m31,
737         m1.m10 * m2.m02 + m1.m11 * m2.m12 + m1.m12 * m2.m22 + m1.m13 * m2.m32,
738         m1.m10 * m2.m03 + m1.m11 * m2.m13 + m1.m12 * m2.m23 + m1.m13 * m2.m33,
739
740         m1.m20 * m2.m00 + m1.m21 * m2.m10 + m1.m22 * m2.m20 + m1.m23 * m2.m30,
741         m1.m20 * m2.m01 + m1.m21 * m2.m11 + m1.m22 * m2.m21 + m1.m23 * m2.m31,
742         m1.m20 * m2.m02 + m1.m21 * m2.m12 + m1.m22 * m2.m22 + m1.m23 * m2.m32,
743         m1.m20 * m2.m03 + m1.m21 * m2.m13 + m1.m22 * m2.m23 + m1.m23 * m2.m33,
744
745         m1.m30 * m2.m00 + m1.m31 * m2.m10 + m1.m32 * m2.m20 + m1.m33 * m2.m30,
746         m1.m30 * m2.m01 + m1.m31 * m2.m11 + m1.m32 * m2.m21 + m1.m33 * m2.m31,
747         m1.m30 * m2.m02 + m1.m31 * m2.m12 + m1.m32 * m2.m22 + m1.m33 * m2.m32,
748         m1.m30 * m2.m03 + m1.m31 * m2.m13 + m1.m32 * m2.m23 + m1.m33 * m2.m33);
749   }
750
751   /**
752    * Transform the vector vec using this Matrix4f and place the result back into
753    * vec.
754    * 
755    * @param vec
756    *        the single precision vector to be transformed
757    */
758   public void transform(T4 vec) {
759     transform2(vec, vec);
760   }
761
762   /**
763    * Transform the vector vec using this Matrix4f and place the result into
764    * vecOut.
765    * 
766    * @param vec
767    *        the single precision vector to be transformed
768    * @param vecOut
769    *        the vector into which the transformed values are placed
770    */
771   public void transform2(T4 vec, T4 vecOut) {
772     // alias-safe
773     vecOut.set4(m00 * vec.x + m01 * vec.y + m02 * vec.z + m03 * vec.w, m10
774         * vec.x + m11 * vec.y + m12 * vec.z + m13 * vec.w, m20 * vec.x + m21
775         * vec.y + m22 * vec.z + m23 * vec.w, m30 * vec.x + m31 * vec.y + m32
776         * vec.z + m33 * vec.w);
777   }
778
779   /**
780    * Transforms the point parameter with this Matrix4f and places the result
781    * back into point. The fourth element of the point input parameter is assumed
782    * to be one.
783    * 
784    * @param point
785    *        the input point to be transformed.
786    */
787   public void rotTrans(T3 point) {
788     rotTrans2(point, point);
789   }
790
791   /**
792    * Transforms the point parameter with this Matrix4f and places the result
793    * into pointOut. The fourth element of the point input parameter is assumed to
794    * be one. point may be pointOut
795    * 
796    * @param point
797    *        the input point to be transformed.
798    * @param pointOut
799    *        the transformed point
800    * @return pointOut
801    */
802   public T3 rotTrans2(T3 point, T3 pointOut) {
803       pointOut.set(
804           m00 * point.x + m01 * point.y + m02 * point.z + m03, 
805           m10 * point.x + m11 * point.y + m12 * point.z + m13, 
806           m20 * point.x + m21 * point.y + m22 * point.z + m23);
807       return pointOut;
808   }
809
810   /**
811    * Sets the value of this matrix to a rotation matrix about the w axis by the
812    * passed angle.
813    * 
814    * @param angle
815    *        the angle to rotate about the W axis in radians
816    * @return this
817    */
818   public M4 setAsXYRotation(float angle) {
819     setIdentity();
820     double c = Math.cos(angle);
821     double s = Math.sin(angle);
822     m22 = (float) c;
823     m23 = (float) -s;
824     m32 = (float) s;
825     m33 = (float) c;
826     return this;
827   }
828
829   /**
830    * Sets the value of this matrix to a rotation matrix about the w axis by the
831    * passed angle.
832    * 
833    * @param angle
834    *        the angle to rotate about the W axis in radians
835    * @return this
836    */
837   public M4 setAsYZRotation(float angle) {
838     setIdentity();
839     double c = Math.cos(angle);
840     double s = Math.sin(angle);
841     m00 = (float) c;
842     m03 = (float) -s;
843     m30 = (float) s;
844     m33 = (float) c;
845     return this;
846   }
847
848   /**
849    * Sets the value of this matrix to a rotation matrix about the w axis by the
850    * passed angle.
851    * 
852    * @param angle
853    *        the angle to rotate about the W axis in radians
854    * @return this
855    */
856   public M4 setAsXZRotation(float angle) {
857     setIdentity();
858     double c = Math.cos(angle);
859     double s = Math.sin(angle);
860     m11 = (float) c;
861     m13 = (float) -s;
862     m31 = (float) s;
863     m33 = (float) c;
864     return this;
865   }
866
867   /**
868    * Returns true if the Object o is of type Matrix4f and all of the data
869    * members of t1 are equal to the corresponding data members in this Matrix4f.
870    * 
871    * @param o
872    *        the object with which the comparison is made.
873    */
874   @Override
875   public boolean equals(Object o) {
876     if (!(o instanceof M4))
877       return false;
878     M4 m = (M4) o;
879     return (this.m00 == m.m00 && this.m01 == m.m01 && this.m02 == m.m02
880         && this.m03 == m.m03 && this.m10 == m.m10 && this.m11 == m.m11
881         && this.m12 == m.m12 && this.m13 == m.m13 && this.m20 == m.m20
882         && this.m21 == m.m21 && this.m22 == m.m22 && this.m23 == m.m23
883         && this.m30 == m.m30 && this.m31 == m.m31 && this.m32 == m.m32 && this.m33 == m.m33);
884   }
885
886   /**
887    * Returns a hash number based on the data values in this object. Two
888    * different Matrix4f objects with identical data values (ie, returns true for
889    * equals(Matrix4f) ) will return the same hash number. Two objects with
890    * different data members may return the same hash value, although this is not
891    * likely.
892    * 
893    * @return the integer hash value
894    */
895   @Override
896   public int hashCode() {
897     return T3.floatToIntBits(m00) ^ T3.floatToIntBits(m01)
898         ^ T3.floatToIntBits(m02) ^ T3.floatToIntBits(m03)
899         ^ T3.floatToIntBits(m10) ^ T3.floatToIntBits(m11)
900         ^ T3.floatToIntBits(m12) ^ T3.floatToIntBits(m13)
901         ^ T3.floatToIntBits(m20) ^ T3.floatToIntBits(m21)
902         ^ T3.floatToIntBits(m22) ^ T3.floatToIntBits(m23)
903         ^ T3.floatToIntBits(m30) ^ T3.floatToIntBits(m31)
904         ^ T3.floatToIntBits(m32) ^ T3.floatToIntBits(m33);
905   }
906
907   /**
908    * Returns a string that contains the values of this Matrix4f.
909    * 
910    * @return the String representation
911    */
912   @Override
913   public String toString() {
914     return "[\n  [" + m00 + "\t" + m01 + "\t" + m02 + "\t" + m03 + "]"
915         + "\n  [" + m10 + "\t" + m11 + "\t" + m12 + "\t" + m13 + "]" + "\n  ["
916         + m20 + "\t" + m21 + "\t" + m22 + "\t" + m23 + "]" + "\n  [" + m30
917         + "\t" + m31 + "\t" + m32 + "\t" + m33 + "] ]";
918   }
919   public M4 round(float f) {
920     m00 = rnd(m00, f);
921     m01 = rnd(m01, f);
922     m02 = rnd(m02, f);
923     m03 = rnd(m03, f);
924     m10 = rnd(m10, f);
925     m11 = rnd(m11, f);
926     m12 = rnd(m12, f);
927     m13 = rnd(m13, f);
928     m20 = rnd(m20, f);
929     m21 = rnd(m21, f);
930     m22 = rnd(m22, f);
931     m23 = rnd(m23, f);
932     m30 = rnd(m30, f);
933     m31 = rnd(m31, f);
934     m32 = rnd(m32, f);
935     m33 = rnd(m33, f);
936     return this;
937   }
938
939   private float rnd(float n, float f) {
940     return (Math.abs(n) < f ? 0 : n);
941   }
942 }