propane 3.4.0-java → 3.7.0.pre-java

Sign up to get free protection for your applications and to get access to all the features.
Files changed (155) hide show
  1. checksums.yaml +4 -4
  2. data/.mvn/extensions.xml +1 -2
  3. data/.mvn/wrapper/MavenWrapperDownloader.java +2 -2
  4. data/.mvn/wrapper/maven-wrapper.properties +2 -2
  5. data/.travis.yml +2 -2
  6. data/CHANGELOG.md +12 -0
  7. data/Gemfile +2 -0
  8. data/README.md +17 -8
  9. data/Rakefile +10 -11
  10. data/bin/propane +3 -1
  11. data/lib/propane.rb +6 -4
  12. data/lib/propane/app.rb +20 -10
  13. data/lib/propane/creators/sketch_class.rb +7 -1
  14. data/lib/propane/creators/sketch_factory.rb +4 -2
  15. data/lib/propane/creators/sketch_writer.rb +1 -0
  16. data/lib/propane/helper_methods.rb +23 -24
  17. data/lib/propane/helpers/numeric.rb +2 -0
  18. data/lib/propane/helpers/version_error.rb +1 -0
  19. data/lib/propane/library.rb +5 -1
  20. data/lib/propane/library_loader.rb +2 -0
  21. data/lib/propane/native_folder.rb +10 -9
  22. data/lib/propane/native_loader.rb +3 -0
  23. data/lib/propane/runner.rb +14 -6
  24. data/lib/propane/version.rb +2 -1
  25. data/library/boids/boids.rb +21 -11
  26. data/library/color_group/color_group.rb +28 -0
  27. data/library/control_panel/control_panel.rb +8 -5
  28. data/library/dxf/dxf.rb +6 -0
  29. data/library/file_chooser/chooser.rb +10 -9
  30. data/library/file_chooser/file_chooser.rb +10 -9
  31. data/library/library_proxy/library_proxy.rb +2 -0
  32. data/library/net/net.rb +7 -0
  33. data/library/simplex_noise/simplex_noise.rb +2 -0
  34. data/library/slider/slider.rb +23 -22
  35. data/library/vector_utils/vector_utils.rb +4 -0
  36. data/library/video_event/video_event.rb +4 -1
  37. data/pom.rb +37 -36
  38. data/pom.xml +7 -7
  39. data/propane.gemspec +16 -12
  40. data/src/main/java/monkstone/ColorUtil.java +13 -1
  41. data/src/main/java/monkstone/MathToolModule.java +253 -203
  42. data/src/main/java/monkstone/PropaneLibrary.java +2 -2
  43. data/src/main/java/monkstone/fastmath/Deglut.java +1 -1
  44. data/src/main/java/monkstone/filechooser/Chooser.java +2 -1
  45. data/src/main/java/monkstone/noise/SimplexNoise.java +2 -2
  46. data/src/main/java/monkstone/slider/CustomHorizontalSlider.java +1 -1
  47. data/src/main/java/monkstone/slider/CustomVerticalSlider.java +1 -1
  48. data/src/main/java/monkstone/slider/SimpleHorizontalSlider.java +1 -1
  49. data/src/main/java/monkstone/slider/SimpleVerticalSlider.java +1 -1
  50. data/src/main/java/monkstone/slider/SliderBar.java +1 -1
  51. data/src/main/java/monkstone/slider/SliderGroup.java +1 -1
  52. data/src/main/java/monkstone/slider/WheelHandler.java +7 -6
  53. data/src/main/java/monkstone/vecmath/package-info.java +1 -1
  54. data/src/main/java/monkstone/vecmath/vec2/Vec2.java +1 -1
  55. data/src/main/java/monkstone/vecmath/vec3/Vec3.java +3 -3
  56. data/src/main/java/monkstone/videoevent/CaptureEvent.java +27 -0
  57. data/src/main/java/monkstone/videoevent/{VideoInterface.java → MovieEvent.java} +11 -27
  58. data/src/main/java/monkstone/videoevent/package-info.java +1 -1
  59. data/src/main/java/processing/awt/PGraphicsJava2D.java +781 -285
  60. data/src/main/java/processing/awt/PImageAWT.java +377 -0
  61. data/src/main/java/processing/awt/PShapeJava2D.java +56 -52
  62. data/src/main/java/processing/awt/PSurfaceAWT.java +309 -209
  63. data/src/main/java/processing/awt/ShimAWT.java +581 -0
  64. data/src/main/java/processing/core/PApplet.java +4510 -4503
  65. data/src/main/java/processing/core/PConstants.java +477 -447
  66. data/src/main/java/processing/core/PFont.java +914 -880
  67. data/src/main/java/processing/core/PGraphics.java +193 -177
  68. data/src/main/java/processing/core/PImage.java +611 -309
  69. data/src/main/java/processing/core/PMatrix.java +172 -159
  70. data/src/main/java/processing/core/PMatrix2D.java +478 -415
  71. data/src/main/java/processing/core/PMatrix3D.java +762 -735
  72. data/src/main/java/processing/core/PShape.java +2888 -2652
  73. data/src/main/java/processing/core/PShapeOBJ.java +97 -92
  74. data/src/main/java/processing/core/PShapeSVG.java +1705 -1490
  75. data/src/main/java/processing/core/PStyle.java +40 -37
  76. data/src/main/java/processing/core/PSurface.java +139 -97
  77. data/src/main/java/processing/core/PSurfaceNone.java +296 -218
  78. data/src/main/java/processing/core/PVector.java +997 -965
  79. data/src/main/java/processing/core/ThinkDifferent.java +15 -13
  80. data/src/main/java/processing/data/DoubleDict.java +756 -710
  81. data/src/main/java/processing/data/DoubleList.java +749 -696
  82. data/src/main/java/processing/data/FloatDict.java +748 -702
  83. data/src/main/java/processing/data/FloatList.java +751 -697
  84. data/src/main/java/processing/data/IntDict.java +720 -673
  85. data/src/main/java/processing/data/IntList.java +699 -633
  86. data/src/main/java/processing/data/JSONArray.java +931 -873
  87. data/src/main/java/processing/data/JSONObject.java +1262 -1165
  88. data/src/main/java/processing/data/JSONTokener.java +351 -341
  89. data/src/main/java/processing/data/LongDict.java +710 -663
  90. data/src/main/java/processing/data/LongList.java +701 -635
  91. data/src/main/java/processing/data/Sort.java +37 -41
  92. data/src/main/java/processing/data/StringDict.java +525 -486
  93. data/src/main/java/processing/data/StringList.java +626 -580
  94. data/src/main/java/processing/data/Table.java +3690 -3510
  95. data/src/main/java/processing/data/TableRow.java +182 -183
  96. data/src/main/java/processing/data/XML.java +957 -883
  97. data/src/main/java/processing/dxf/RawDXF.java +404 -0
  98. data/src/main/java/processing/event/Event.java +87 -67
  99. data/src/main/java/processing/event/KeyEvent.java +48 -41
  100. data/src/main/java/processing/event/MouseEvent.java +88 -113
  101. data/src/main/java/processing/event/TouchEvent.java +10 -6
  102. data/src/main/java/processing/javafx/PGraphicsFX2D.java +20 -345
  103. data/src/main/java/processing/javafx/PSurfaceFX.java +149 -121
  104. data/src/main/java/processing/net/Client.java +744 -0
  105. data/src/main/java/processing/net/Server.java +388 -0
  106. data/src/main/java/processing/opengl/FontTexture.java +289 -270
  107. data/src/main/java/processing/opengl/FrameBuffer.java +386 -364
  108. data/src/main/java/processing/opengl/LinePath.java +547 -500
  109. data/src/main/java/processing/opengl/LineStroker.java +588 -581
  110. data/src/main/java/processing/opengl/PGL.java +3047 -2914
  111. data/src/main/java/processing/opengl/PGraphics2D.java +408 -315
  112. data/src/main/java/processing/opengl/PGraphics3D.java +107 -72
  113. data/src/main/java/processing/opengl/PGraphicsOpenGL.java +12378 -12075
  114. data/src/main/java/processing/opengl/PJOGL.java +1753 -1670
  115. data/src/main/java/processing/opengl/PShader.java +1266 -1257
  116. data/src/main/java/processing/opengl/PShapeOpenGL.java +4678 -4580
  117. data/src/main/java/processing/opengl/PSurfaceJOGL.java +1114 -1027
  118. data/src/main/java/processing/opengl/Texture.java +1492 -1401
  119. data/src/main/java/processing/opengl/VertexBuffer.java +57 -55
  120. data/test/create_test.rb +21 -20
  121. data/test/deglut_spec_test.rb +4 -2
  122. data/test/helper_methods_test.rb +49 -20
  123. data/test/math_tool_test.rb +39 -32
  124. data/test/native_folder.rb +47 -0
  125. data/test/respond_to_test.rb +3 -2
  126. data/test/sketches/key_event.rb +2 -2
  127. data/test/sketches/library/my_library/my_library.rb +3 -0
  128. data/test/test_helper.rb +2 -0
  129. data/test/vecmath_spec_test.rb +35 -22
  130. data/vendors/Rakefile +33 -62
  131. metadata +56 -48
  132. data/src/main/java/processing/core/util/image/ImageLoadFacade.java +0 -161
  133. data/src/main/java/processing/core/util/image/ImageSaveFacade.java +0 -169
  134. data/src/main/java/processing/core/util/image/constants/TifConstants.java +0 -45
  135. data/src/main/java/processing/core/util/image/load/AwtImageLoadStrategy.java +0 -80
  136. data/src/main/java/processing/core/util/image/load/Base64StringImageLoadStrategy.java +0 -73
  137. data/src/main/java/processing/core/util/image/load/FallbackImageLoadStrategy.java +0 -70
  138. data/src/main/java/processing/core/util/image/load/ImageIoImageLoadStrategy.java +0 -132
  139. data/src/main/java/processing/core/util/image/load/ImageLoadStrategy.java +0 -48
  140. data/src/main/java/processing/core/util/image/load/ImageLoadUtil.java +0 -45
  141. data/src/main/java/processing/core/util/image/load/TgaImageLoadStrategy.java +0 -255
  142. data/src/main/java/processing/core/util/image/load/TiffImageLoadStrategy.java +0 -98
  143. data/src/main/java/processing/core/util/image/save/ImageSaveStrategy.java +0 -49
  144. data/src/main/java/processing/core/util/image/save/ImageSaveUtil.java +0 -48
  145. data/src/main/java/processing/core/util/image/save/ImageWriterImageSaveStrategy.java +0 -179
  146. data/src/main/java/processing/core/util/image/save/SaveImageException.java +0 -41
  147. data/src/main/java/processing/core/util/image/save/TgaImageSaveStrategy.java +0 -198
  148. data/src/main/java/processing/core/util/image/save/TiffImageSaveStrategy.java +0 -91
  149. data/src/main/java/processing/core/util/image/save/TiffNakedFilenameImageSaveStrategy.java +0 -57
  150. data/src/main/java/processing/core/util/io/InputFactory.java +0 -285
  151. data/src/main/java/processing/core/util/io/PathUtil.java +0 -109
  152. data/src/main/java/processing/opengl/shaders/LightVert-brcm.glsl +0 -154
  153. data/src/main/java/processing/opengl/shaders/LightVert-vc4.glsl +0 -154
  154. data/src/main/java/processing/opengl/shaders/TexLightVert-brcm.glsl +0 -160
  155. data/src/main/java/processing/opengl/shaders/TexLightVert-vc4.glsl +0 -160
@@ -1,3 +1,5 @@
1
+ /* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2
+
1
3
  /*
2
4
  Part of the Processing project - http://processing.org
3
5
 
@@ -16,471 +18,476 @@
16
18
  Public License along with this library; if not, write to the
17
19
  Free Software Foundation, Inc., 59 Temple Place, Suite 330,
18
20
  Boston, MA 02111-1307 USA
19
- */
21
+ */
22
+
20
23
  package processing.core;
21
24
 
25
+
22
26
  /**
23
- * 4x4 matrix implementation. Matrices are used to describe a transformation;
24
- * see {@link PMatrix} for a general description. This matrix looks like the
25
- * following when multiplying a vector (x, y, z, w) in {@code mult()}.
27
+ * 4x4 matrix implementation.
28
+ * Matrices are used to describe a transformation; see {@link PMatrix} for a
29
+ * general description. This matrix looks like the following when multiplying
30
+ * a vector (x, y, z, w) in {@code mult()}.
26
31
  * <pre>
27
32
  * [m00 m01 m02 m03][x] [m00*x + m01*y + m02*z + m03*w] [x']
28
33
  * [m10 m11 m12 m13][y] = [m10*x + m11*y + m12*z + m13*w] = [y']
29
34
  * [m20 m21 m22 m23][z] [m20*x + m21*y + m22*z + m23*w] [z']
30
- * [m30 m31 m32 m33][w] [m30*x + m31*y + m32*z + m33*w] [w']</pre> (x', y', z',
31
- * w') is returned. The values in the matrix determine the transformation. They
32
- * are modified by the various transformation functions.
35
+ * [m30 m31 m32 m33][w] [m30*x + m31*y + m32*z + m33*w] [w']</pre>
36
+ * (x', y', z', w') is returned. The values in the matrix determine the
37
+ * transformation. They are modified by the various transformation functions.
33
38
  *
34
- * To transform 3D coordinates, w is set to 1, amd w' is made to be 1 by setting
35
- * the bottom row of the matrix to <code>[0 0 0 1]</code>. The resulting point
36
- * is then (x', y', z').
39
+ * To transform 3D coordinates, w is set to 1, amd w' is made to be 1 by
40
+ * setting the bottom row of the matrix to <code>[0 0 0 1]</code>. The
41
+ * resulting point is then (x', y', z').
37
42
  */
38
43
  public final class PMatrix3D implements PMatrix /*, PConstants*/ {
39
44
 
40
- public float m00, m01, m02, m03;
41
- public float m10, m11, m12, m13;
42
- public float m20, m21, m22, m23;
43
- public float m30, m31, m32, m33;
45
+ public float m00, m01, m02, m03;
46
+ public float m10, m11, m12, m13;
47
+ public float m20, m21, m22, m23;
48
+ public float m30, m31, m32, m33;
44
49
 
45
- // locally allocated version to avoid creating new memory
46
- protected PMatrix3D inverseCopy;
47
50
 
48
- public PMatrix3D() {
49
- reset();
50
- }
51
+ // locally allocated version to avoid creating new memory
52
+ protected PMatrix3D inverseCopy;
51
53
 
52
- public PMatrix3D(float m00, float m01, float m02,
53
- float m10, float m11, float m12) {
54
- set(m00, m01, m02, 0,
55
- m10, m11, m12, 0,
56
- 0, 0, 1, 0,
57
- 0, 0, 0, 1);
58
- }
59
54
 
60
- public PMatrix3D(float m00, float m01, float m02, float m03,
61
- float m10, float m11, float m12, float m13,
62
- float m20, float m21, float m22, float m23,
63
- float m30, float m31, float m32, float m33) {
64
- set(m00, m01, m02, m03,
65
- m10, m11, m12, m13,
66
- m20, m21, m22, m23,
67
- m30, m31, m32, m33);
68
- }
55
+ public PMatrix3D() {
56
+ reset();
57
+ }
69
58
 
70
- public PMatrix3D(PMatrix matrix) {
71
- set(matrix);
72
- }
73
59
 
74
- public void reset() {
75
- set(1, 0, 0, 0,
76
- 0, 1, 0, 0,
77
- 0, 0, 1, 0,
78
- 0, 0, 0, 1);
79
- }
60
+ public PMatrix3D(float m00, float m01, float m02,
61
+ float m10, float m11, float m12) {
62
+ set(m00, m01, m02, 0,
63
+ m10, m11, m12, 0,
64
+ 0, 0, 1, 0,
65
+ 0, 0, 0, 1);
66
+ }
80
67
 
81
- /**
82
- * Returns a copy of this PMatrix.
83
- */
84
- public PMatrix3D get() {
85
- PMatrix3D outgoing = new PMatrix3D();
86
- outgoing.set(this);
87
- return outgoing;
88
- }
89
68
 
90
- /**
91
- * Copies the matrix contents into a 16 entry float array. If target is null
92
- * (or not the correct size), a new array will be created.
93
- */
94
- public float[] get(float[] target) {
95
- if ((target == null) || (target.length != 16)) {
96
- target = new float[16];
97
- }
98
- target[0] = m00;
99
- target[1] = m01;
100
- target[2] = m02;
101
- target[3] = m03;
102
-
103
- target[4] = m10;
104
- target[5] = m11;
105
- target[6] = m12;
106
- target[7] = m13;
107
-
108
- target[8] = m20;
109
- target[9] = m21;
110
- target[10] = m22;
111
- target[11] = m23;
112
-
113
- target[12] = m30;
114
- target[13] = m31;
115
- target[14] = m32;
116
- target[15] = m33;
117
-
118
- return target;
119
- }
69
+ public PMatrix3D(float m00, float m01, float m02, float m03,
70
+ float m10, float m11, float m12, float m13,
71
+ float m20, float m21, float m22, float m23,
72
+ float m30, float m31, float m32, float m33) {
73
+ set(m00, m01, m02, m03,
74
+ m10, m11, m12, m13,
75
+ m20, m21, m22, m23,
76
+ m30, m31, m32, m33);
77
+ }
120
78
 
121
- public void set(PMatrix matrix) {
122
- if (matrix instanceof PMatrix3D) {
123
- PMatrix3D src = (PMatrix3D) matrix;
124
- set(src.m00, src.m01, src.m02, src.m03,
125
- src.m10, src.m11, src.m12, src.m13,
126
- src.m20, src.m21, src.m22, src.m23,
127
- src.m30, src.m31, src.m32, src.m33);
128
- } else {
129
- PMatrix2D src = (PMatrix2D) matrix;
130
- set(src.m00, src.m01, 0, src.m02,
131
- src.m10, src.m11, 0, src.m12,
132
- 0, 0, 1, 0,
133
- 0, 0, 0, 1);
134
- }
135
- }
136
79
 
137
- public void set(float[] source) {
138
- if (source.length == 6) {
139
- set(source[0], source[1], source[2],
140
- source[3], source[4], source[5]);
141
-
142
- } else if (source.length == 16) {
143
- m00 = source[0];
144
- m01 = source[1];
145
- m02 = source[2];
146
- m03 = source[3];
147
-
148
- m10 = source[4];
149
- m11 = source[5];
150
- m12 = source[6];
151
- m13 = source[7];
152
-
153
- m20 = source[8];
154
- m21 = source[9];
155
- m22 = source[10];
156
- m23 = source[11];
157
-
158
- m30 = source[12];
159
- m31 = source[13];
160
- m32 = source[14];
161
- m33 = source[15];
162
- }
163
- }
80
+ public PMatrix3D(PMatrix matrix) {
81
+ set(matrix);
82
+ }
83
+
84
+
85
+ public void reset() {
86
+ set(1, 0, 0, 0,
87
+ 0, 1, 0, 0,
88
+ 0, 0, 1, 0,
89
+ 0, 0, 0, 1);
90
+ }
91
+
164
92
 
165
- public void set(float m00, float m01, float m02,
166
- float m10, float m11, float m12) {
167
- set(m00, m01, 0, m02,
168
- m10, m11, 0, m12,
169
- 0, 0, 1, 0,
170
- 0, 0, 0, 1);
93
+ /**
94
+ * Returns a copy of this PMatrix.
95
+ */
96
+ public PMatrix3D get() {
97
+ PMatrix3D outgoing = new PMatrix3D();
98
+ outgoing.set(this);
99
+ return outgoing;
100
+ }
101
+
102
+
103
+ /**
104
+ * Copies the matrix contents into a 16 entry float array.
105
+ * If target is null (or not the correct size), a new array will be created.
106
+ */
107
+ public float[] get(float[] target) {
108
+ if ((target == null) || (target.length != 16)) {
109
+ target = new float[16];
171
110
  }
111
+ target[0] = m00;
112
+ target[1] = m01;
113
+ target[2] = m02;
114
+ target[3] = m03;
115
+
116
+ target[4] = m10;
117
+ target[5] = m11;
118
+ target[6] = m12;
119
+ target[7] = m13;
120
+
121
+ target[8] = m20;
122
+ target[9] = m21;
123
+ target[10] = m22;
124
+ target[11] = m23;
125
+
126
+ target[12] = m30;
127
+ target[13] = m31;
128
+ target[14] = m32;
129
+ target[15] = m33;
172
130
 
173
- public void set(float m00, float m01, float m02, float m03,
174
- float m10, float m11, float m12, float m13,
175
- float m20, float m21, float m22, float m23,
176
- float m30, float m31, float m32, float m33) {
177
- this.m00 = m00;
178
- this.m01 = m01;
179
- this.m02 = m02;
180
- this.m03 = m03;
181
- this.m10 = m10;
182
- this.m11 = m11;
183
- this.m12 = m12;
184
- this.m13 = m13;
185
- this.m20 = m20;
186
- this.m21 = m21;
187
- this.m22 = m22;
188
- this.m23 = m23;
189
- this.m30 = m30;
190
- this.m31 = m31;
191
- this.m32 = m32;
192
- this.m33 = m33;
131
+ return target;
132
+ }
133
+
134
+
135
+ public void set(PMatrix matrix) {
136
+ if (matrix instanceof PMatrix3D) {
137
+ PMatrix3D src = (PMatrix3D) matrix;
138
+ set(src.m00, src.m01, src.m02, src.m03,
139
+ src.m10, src.m11, src.m12, src.m13,
140
+ src.m20, src.m21, src.m22, src.m23,
141
+ src.m30, src.m31, src.m32, src.m33);
142
+ } else {
143
+ PMatrix2D src = (PMatrix2D) matrix;
144
+ set(src.m00, src.m01, 0, src.m02,
145
+ src.m10, src.m11, 0, src.m12,
146
+ 0, 0, 1, 0,
147
+ 0, 0, 0, 1);
193
148
  }
149
+ }
150
+
151
+
152
+ @Override
153
+ public void set(float[] source) {
154
+ if (source.length == 6) {
155
+ set(source[0], source[1], source[2],
156
+ source[3], source[4], source[5]);
194
157
 
195
- public void translate(float tx, float ty) {
196
- translate(tx, ty, 0);
158
+ } else if (source.length == 16) {
159
+ m00 = source[0];
160
+ m01 = source[1];
161
+ m02 = source[2];
162
+ m03 = source[3];
163
+
164
+ m10 = source[4];
165
+ m11 = source[5];
166
+ m12 = source[6];
167
+ m13 = source[7];
168
+
169
+ m20 = source[8];
170
+ m21 = source[9];
171
+ m22 = source[10];
172
+ m23 = source[11];
173
+
174
+ m30 = source[12];
175
+ m31 = source[13];
176
+ m32 = source[14];
177
+ m33 = source[15];
197
178
  }
179
+ }
180
+
181
+
182
+ @Override
183
+ public void set(float m00, float m01, float m02,
184
+ float m10, float m11, float m12) {
185
+ set(m00, m01, 0, m02,
186
+ m10, m11, 0, m12,
187
+ 0, 0, 1, 0,
188
+ 0, 0, 0, 1);
189
+ }
190
+
191
+
192
+ @Override
193
+ public void set(float m00, float m01, float m02, float m03,
194
+ float m10, float m11, float m12, float m13,
195
+ float m20, float m21, float m22, float m23,
196
+ float m30, float m31, float m32, float m33) {
197
+ this.m00 = m00; this.m01 = m01; this.m02 = m02; this.m03 = m03;
198
+ this.m10 = m10; this.m11 = m11; this.m12 = m12; this.m13 = m13;
199
+ this.m20 = m20; this.m21 = m21; this.m22 = m22; this.m23 = m23;
200
+ this.m30 = m30; this.m31 = m31; this.m32 = m32; this.m33 = m33;
201
+ }
202
+
203
+
204
+ @Override
205
+ public void translate(float tx, float ty) {
206
+ translate(tx, ty, 0);
207
+ }
198
208
 
199
209
  // public void invTranslate(float tx, float ty) {
200
210
  // invTranslate(tx, ty, 0);
201
211
  // }
202
- public void translate(float tx, float ty, float tz) {
203
- m03 += tx * m00 + ty * m01 + tz * m02;
204
- m13 += tx * m10 + ty * m11 + tz * m12;
205
- m23 += tx * m20 + ty * m21 + tz * m22;
206
- m33 += tx * m30 + ty * m31 + tz * m32;
207
- }
208
212
 
209
- public void rotate(float angle) {
210
- rotateZ(angle);
211
- }
212
213
 
213
- public void rotateX(float angle) {
214
- float c = cos(angle);
215
- float s = sin(angle);
216
- apply(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
217
- }
214
+ @Override
215
+ public void translate(float tx, float ty, float tz) {
216
+ m03 += tx*m00 + ty*m01 + tz*m02;
217
+ m13 += tx*m10 + ty*m11 + tz*m12;
218
+ m23 += tx*m20 + ty*m21 + tz*m22;
219
+ m33 += tx*m30 + ty*m31 + tz*m32;
220
+ }
218
221
 
219
- public void rotateY(float angle) {
220
- float c = cos(angle);
221
- float s = sin(angle);
222
- apply(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
223
- }
224
222
 
225
- public void rotateZ(float angle) {
226
- float c = cos(angle);
227
- float s = sin(angle);
228
- apply(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
229
- }
223
+ @Override
224
+ public void rotate(float angle) {
225
+ rotateZ(angle);
226
+ }
230
227
 
231
- public void rotate(float angle, float v0, float v1, float v2) {
232
- float norm2 = v0 * v0 + v1 * v1 + v2 * v2;
233
- if (norm2 < PConstants.EPSILON) {
234
- // The vector is zero, cannot apply rotation.
235
- return;
236
- }
237
-
238
- if (Math.abs(norm2 - 1) > PConstants.EPSILON) {
239
- // The rotation vector is not normalized.
240
- float norm = PApplet.sqrt(norm2);
241
- v0 /= norm;
242
- v1 /= norm;
243
- v2 /= norm;
244
- }
245
-
246
- float c = cos(angle);
247
- float s = sin(angle);
248
- float t = 1.0f - c;
249
-
250
- apply((t * v0 * v0) + c, (t * v0 * v1) - (s * v2), (t * v0 * v2) + (s * v1), 0,
251
- (t * v0 * v1) + (s * v2), (t * v1 * v1) + c, (t * v1 * v2) - (s * v0), 0,
252
- (t * v0 * v2) - (s * v1), (t * v1 * v2) + (s * v0), (t * v2 * v2) + c, 0,
253
- 0, 0, 0, 1);
254
- }
255
228
 
256
- public void scale(float s) {
257
- //apply(s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1);
258
- scale(s, s, s);
259
- }
229
+ @Override
230
+ public void rotateX(float angle) {
231
+ float c = cos(angle);
232
+ float s = sin(angle);
233
+ apply(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
234
+ }
260
235
 
261
- public void scale(float sx, float sy) {
262
- //apply(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
263
- scale(sx, sy, 1);
264
- }
265
236
 
266
- public void scale(float x, float y, float z) {
267
- //apply(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
268
- m00 *= x;
269
- m01 *= y;
270
- m02 *= z;
271
- m10 *= x;
272
- m11 *= y;
273
- m12 *= z;
274
- m20 *= x;
275
- m21 *= y;
276
- m22 *= z;
277
- m30 *= x;
278
- m31 *= y;
279
- m32 *= z;
280
- }
237
+ @Override
238
+ public void rotateY(float angle) {
239
+ float c = cos(angle);
240
+ float s = sin(angle);
241
+ apply(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
242
+ }
281
243
 
282
- public void shearX(float angle) {
283
- float t = (float) Math.tan(angle);
284
- apply(1, t, 0, 0,
285
- 0, 1, 0, 0,
286
- 0, 0, 1, 0,
287
- 0, 0, 0, 1);
288
- }
289
244
 
290
- public void shearY(float angle) {
291
- float t = (float) Math.tan(angle);
292
- apply(1, 0, 0, 0,
293
- t, 1, 0, 0,
294
- 0, 0, 1, 0,
295
- 0, 0, 0, 1);
296
- }
245
+ @Override
246
+ public void rotateZ(float angle) {
247
+ float c = cos(angle);
248
+ float s = sin(angle);
249
+ apply(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
250
+ }
297
251
 
298
- public void apply(PMatrix source) {
299
- if (source instanceof PMatrix2D) {
300
- apply((PMatrix2D) source);
301
- } else if (source instanceof PMatrix3D) {
302
- apply((PMatrix3D) source);
303
- }
304
- }
305
252
 
306
- public void apply(PMatrix2D source) {
307
- apply(source.m00, source.m01, 0, source.m02,
308
- source.m10, source.m11, 0, source.m12,
309
- 0, 0, 1, 0,
310
- 0, 0, 0, 1);
253
+ @Override
254
+ public void rotate(float angle, float v0, float v1, float v2) {
255
+ float norm2 = v0 * v0 + v1 * v1 + v2 * v2;
256
+ if (norm2 < PConstants.EPSILON) {
257
+ // The vector is zero, cannot apply rotation.
258
+ return;
311
259
  }
312
260
 
313
- public void apply(PMatrix3D source) {
314
- apply(source.m00, source.m01, source.m02, source.m03,
315
- source.m10, source.m11, source.m12, source.m13,
316
- source.m20, source.m21, source.m22, source.m23,
317
- source.m30, source.m31, source.m32, source.m33);
261
+ if (Math.abs(norm2 - 1) > PConstants.EPSILON) {
262
+ // The rotation vector is not normalized.
263
+ float norm = PApplet.sqrt(norm2);
264
+ v0 /= norm;
265
+ v1 /= norm;
266
+ v2 /= norm;
318
267
  }
319
268
 
320
- public void apply(float n00, float n01, float n02,
321
- float n10, float n11, float n12) {
322
- apply(n00, n01, 0, n02,
323
- n10, n11, 0, n12,
324
- 0, 0, 1, 0,
325
- 0, 0, 0, 1);
326
- }
269
+ float c = cos(angle);
270
+ float s = sin(angle);
271
+ float t = 1.0f - c;
327
272
 
328
- public void apply(float n00, float n01, float n02, float n03,
329
- float n10, float n11, float n12, float n13,
330
- float n20, float n21, float n22, float n23,
331
- float n30, float n31, float n32, float n33) {
332
-
333
- float r00 = m00 * n00 + m01 * n10 + m02 * n20 + m03 * n30;
334
- float r01 = m00 * n01 + m01 * n11 + m02 * n21 + m03 * n31;
335
- float r02 = m00 * n02 + m01 * n12 + m02 * n22 + m03 * n32;
336
- float r03 = m00 * n03 + m01 * n13 + m02 * n23 + m03 * n33;
337
-
338
- float r10 = m10 * n00 + m11 * n10 + m12 * n20 + m13 * n30;
339
- float r11 = m10 * n01 + m11 * n11 + m12 * n21 + m13 * n31;
340
- float r12 = m10 * n02 + m11 * n12 + m12 * n22 + m13 * n32;
341
- float r13 = m10 * n03 + m11 * n13 + m12 * n23 + m13 * n33;
342
-
343
- float r20 = m20 * n00 + m21 * n10 + m22 * n20 + m23 * n30;
344
- float r21 = m20 * n01 + m21 * n11 + m22 * n21 + m23 * n31;
345
- float r22 = m20 * n02 + m21 * n12 + m22 * n22 + m23 * n32;
346
- float r23 = m20 * n03 + m21 * n13 + m22 * n23 + m23 * n33;
347
-
348
- float r30 = m30 * n00 + m31 * n10 + m32 * n20 + m33 * n30;
349
- float r31 = m30 * n01 + m31 * n11 + m32 * n21 + m33 * n31;
350
- float r32 = m30 * n02 + m31 * n12 + m32 * n22 + m33 * n32;
351
- float r33 = m30 * n03 + m31 * n13 + m32 * n23 + m33 * n33;
352
-
353
- m00 = r00;
354
- m01 = r01;
355
- m02 = r02;
356
- m03 = r03;
357
- m10 = r10;
358
- m11 = r11;
359
- m12 = r12;
360
- m13 = r13;
361
- m20 = r20;
362
- m21 = r21;
363
- m22 = r22;
364
- m23 = r23;
365
- m30 = r30;
366
- m31 = r31;
367
- m32 = r32;
368
- m33 = r33;
369
- }
273
+ apply((t*v0*v0) + c, (t*v0*v1) - (s*v2), (t*v0*v2) + (s*v1), 0,
274
+ (t*v0*v1) + (s*v2), (t*v1*v1) + c, (t*v1*v2) - (s*v0), 0,
275
+ (t*v0*v2) - (s*v1), (t*v1*v2) + (s*v0), (t*v2*v2) + c, 0,
276
+ 0, 0, 0, 1);
277
+ }
370
278
 
371
- /**
372
- * Apply the 3D equivalent of the 2D matrix supplied to the left of this
373
- * one.
374
- */
375
- public void preApply(PMatrix2D left) {
376
- preApply(left.m00, left.m01, 0, left.m02,
377
- left.m10, left.m11, 0, left.m12,
378
- 0, 0, 1, 0,
379
- 0, 0, 0, 1);
380
- }
381
279
 
382
- /**
383
- * Apply another matrix to the left of this one.
384
- */
385
- public void preApply(PMatrix source) {
386
- if (source instanceof PMatrix2D) {
387
- preApply((PMatrix2D) source);
388
- } else if (source instanceof PMatrix3D) {
389
- preApply((PMatrix3D) source);
390
- }
391
- }
280
+ public void scale(float s) {
281
+ //apply(s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1);
282
+ scale(s, s, s);
283
+ }
284
+
285
+
286
+ public void scale(float sx, float sy) {
287
+ //apply(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
288
+ scale(sx, sy, 1);
289
+ }
290
+
291
+
292
+ public void scale(float x, float y, float z) {
293
+ //apply(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1);
294
+ m00 *= x; m01 *= y; m02 *= z;
295
+ m10 *= x; m11 *= y; m12 *= z;
296
+ m20 *= x; m21 *= y; m22 *= z;
297
+ m30 *= x; m31 *= y; m32 *= z;
298
+ }
299
+
300
+
301
+ public void shearX(float angle) {
302
+ float t = (float) Math.tan(angle);
303
+ apply(1, t, 0, 0,
304
+ 0, 1, 0, 0,
305
+ 0, 0, 1, 0,
306
+ 0, 0, 0, 1);
307
+ }
392
308
 
393
- /**
394
- * Apply another matrix to the left of this one.
395
- */
396
- public void preApply(PMatrix3D left) {
397
- preApply(left.m00, left.m01, left.m02, left.m03,
398
- left.m10, left.m11, left.m12, left.m13,
399
- left.m20, left.m21, left.m22, left.m23,
400
- left.m30, left.m31, left.m32, left.m33);
401
- }
402
309
 
403
- /**
404
- * Apply the 3D equivalent of the 2D matrix supplied to the left of this
405
- * one.
406
- */
407
- public void preApply(float n00, float n01, float n02,
408
- float n10, float n11, float n12) {
409
- preApply(n00, n01, 0, n02,
410
- n10, n11, 0, n12,
411
- 0, 0, 1, 0,
412
- 0, 0, 0, 1);
310
+ public void shearY(float angle) {
311
+ float t = (float) Math.tan(angle);
312
+ apply(1, 0, 0, 0,
313
+ t, 1, 0, 0,
314
+ 0, 0, 1, 0,
315
+ 0, 0, 0, 1);
316
+ }
317
+
318
+
319
+ public void apply(PMatrix source) {
320
+ if (source instanceof PMatrix2D) {
321
+ apply((PMatrix2D) source);
322
+ } else if (source instanceof PMatrix3D) {
323
+ apply((PMatrix3D) source);
413
324
  }
325
+ }
326
+
327
+
328
+ public void apply(PMatrix2D source) {
329
+ apply(source.m00, source.m01, 0, source.m02,
330
+ source.m10, source.m11, 0, source.m12,
331
+ 0, 0, 1, 0,
332
+ 0, 0, 0, 1);
333
+ }
334
+
335
+
336
+ public void apply(PMatrix3D source) {
337
+ apply(source.m00, source.m01, source.m02, source.m03,
338
+ source.m10, source.m11, source.m12, source.m13,
339
+ source.m20, source.m21, source.m22, source.m23,
340
+ source.m30, source.m31, source.m32, source.m33);
341
+ }
342
+
343
+
344
+ public void apply(float n00, float n01, float n02,
345
+ float n10, float n11, float n12) {
346
+ apply(n00, n01, 0, n02,
347
+ n10, n11, 0, n12,
348
+ 0, 0, 1, 0,
349
+ 0, 0, 0, 1);
350
+ }
414
351
 
415
- /**
416
- * Apply another matrix to the left of this one.
417
- */
418
- public void preApply(float n00, float n01, float n02, float n03,
419
- float n10, float n11, float n12, float n13,
420
- float n20, float n21, float n22, float n23,
421
- float n30, float n31, float n32, float n33) {
422
-
423
- float r00 = n00 * m00 + n01 * m10 + n02 * m20 + n03 * m30;
424
- float r01 = n00 * m01 + n01 * m11 + n02 * m21 + n03 * m31;
425
- float r02 = n00 * m02 + n01 * m12 + n02 * m22 + n03 * m32;
426
- float r03 = n00 * m03 + n01 * m13 + n02 * m23 + n03 * m33;
427
-
428
- float r10 = n10 * m00 + n11 * m10 + n12 * m20 + n13 * m30;
429
- float r11 = n10 * m01 + n11 * m11 + n12 * m21 + n13 * m31;
430
- float r12 = n10 * m02 + n11 * m12 + n12 * m22 + n13 * m32;
431
- float r13 = n10 * m03 + n11 * m13 + n12 * m23 + n13 * m33;
432
-
433
- float r20 = n20 * m00 + n21 * m10 + n22 * m20 + n23 * m30;
434
- float r21 = n20 * m01 + n21 * m11 + n22 * m21 + n23 * m31;
435
- float r22 = n20 * m02 + n21 * m12 + n22 * m22 + n23 * m32;
436
- float r23 = n20 * m03 + n21 * m13 + n22 * m23 + n23 * m33;
437
-
438
- float r30 = n30 * m00 + n31 * m10 + n32 * m20 + n33 * m30;
439
- float r31 = n30 * m01 + n31 * m11 + n32 * m21 + n33 * m31;
440
- float r32 = n30 * m02 + n31 * m12 + n32 * m22 + n33 * m32;
441
- float r33 = n30 * m03 + n31 * m13 + n32 * m23 + n33 * m33;
442
-
443
- m00 = r00;
444
- m01 = r01;
445
- m02 = r02;
446
- m03 = r03;
447
- m10 = r10;
448
- m11 = r11;
449
- m12 = r12;
450
- m13 = r13;
451
- m20 = r20;
452
- m21 = r21;
453
- m22 = r22;
454
- m23 = r23;
455
- m30 = r30;
456
- m31 = r31;
457
- m32 = r32;
458
- m33 = r33;
352
+
353
+ public void apply(float n00, float n01, float n02, float n03,
354
+ float n10, float n11, float n12, float n13,
355
+ float n20, float n21, float n22, float n23,
356
+ float n30, float n31, float n32, float n33) {
357
+
358
+ float r00 = m00*n00 + m01*n10 + m02*n20 + m03*n30;
359
+ float r01 = m00*n01 + m01*n11 + m02*n21 + m03*n31;
360
+ float r02 = m00*n02 + m01*n12 + m02*n22 + m03*n32;
361
+ float r03 = m00*n03 + m01*n13 + m02*n23 + m03*n33;
362
+
363
+ float r10 = m10*n00 + m11*n10 + m12*n20 + m13*n30;
364
+ float r11 = m10*n01 + m11*n11 + m12*n21 + m13*n31;
365
+ float r12 = m10*n02 + m11*n12 + m12*n22 + m13*n32;
366
+ float r13 = m10*n03 + m11*n13 + m12*n23 + m13*n33;
367
+
368
+ float r20 = m20*n00 + m21*n10 + m22*n20 + m23*n30;
369
+ float r21 = m20*n01 + m21*n11 + m22*n21 + m23*n31;
370
+ float r22 = m20*n02 + m21*n12 + m22*n22 + m23*n32;
371
+ float r23 = m20*n03 + m21*n13 + m22*n23 + m23*n33;
372
+
373
+ float r30 = m30*n00 + m31*n10 + m32*n20 + m33*n30;
374
+ float r31 = m30*n01 + m31*n11 + m32*n21 + m33*n31;
375
+ float r32 = m30*n02 + m31*n12 + m32*n22 + m33*n32;
376
+ float r33 = m30*n03 + m31*n13 + m32*n23 + m33*n33;
377
+
378
+ m00 = r00; m01 = r01; m02 = r02; m03 = r03;
379
+ m10 = r10; m11 = r11; m12 = r12; m13 = r13;
380
+ m20 = r20; m21 = r21; m22 = r22; m23 = r23;
381
+ m30 = r30; m31 = r31; m32 = r32; m33 = r33;
382
+ }
383
+
384
+
385
+ /**
386
+ * Apply the 3D equivalent of the 2D matrix supplied to the left of this one.
387
+ */
388
+ public void preApply(PMatrix2D left) {
389
+ preApply(left.m00, left.m01, 0, left.m02,
390
+ left.m10, left.m11, 0, left.m12,
391
+ 0, 0, 1, 0,
392
+ 0, 0, 0, 1);
393
+ }
394
+
395
+
396
+ /**
397
+ * Apply another matrix to the left of this one.
398
+ */
399
+ public void preApply(PMatrix source) {
400
+ if (source instanceof PMatrix2D) {
401
+ preApply((PMatrix2D) source);
402
+ } else if (source instanceof PMatrix3D) {
403
+ preApply((PMatrix3D) source);
459
404
  }
405
+ }
460
406
 
461
- //////////////////////////////////////////////////////////////
462
- /**
463
- * Multiply source by this matrix, and return the result. The result will be
464
- * stored in target if target is non-null, and target will then be the
465
- * matrix returned. This improves performance if you reuse target, so it's
466
- * recommended if you call this many times in draw().
467
- */
468
- public PVector mult(PVector source, PVector target) {
469
- if (target == null) {
470
- target = new PVector();
471
- }
472
- target.set(m00 * source.x + m01 * source.y + m02 * source.z + m03,
473
- m10 * source.x + m11 * source.y + m12 * source.z + m13,
474
- m20 * source.x + m21 * source.y + m22 * source.z + m23);
407
+
408
+ /**
409
+ * Apply another matrix to the left of this one.
410
+ */
411
+ public void preApply(PMatrix3D left) {
412
+ preApply(left.m00, left.m01, left.m02, left.m03,
413
+ left.m10, left.m11, left.m12, left.m13,
414
+ left.m20, left.m21, left.m22, left.m23,
415
+ left.m30, left.m31, left.m32, left.m33);
416
+ }
417
+
418
+
419
+ /**
420
+ * Apply the 3D equivalent of the 2D matrix supplied to the left of this one.
421
+ */
422
+ public void preApply(float n00, float n01, float n02,
423
+ float n10, float n11, float n12) {
424
+ preApply(n00, n01, 0, n02,
425
+ n10, n11, 0, n12,
426
+ 0, 0, 1, 0,
427
+ 0, 0, 0, 1);
428
+ }
429
+
430
+
431
+ /**
432
+ * Apply another matrix to the left of this one.
433
+ */
434
+ public void preApply(float n00, float n01, float n02, float n03,
435
+ float n10, float n11, float n12, float n13,
436
+ float n20, float n21, float n22, float n23,
437
+ float n30, float n31, float n32, float n33) {
438
+
439
+ float r00 = n00*m00 + n01*m10 + n02*m20 + n03*m30;
440
+ float r01 = n00*m01 + n01*m11 + n02*m21 + n03*m31;
441
+ float r02 = n00*m02 + n01*m12 + n02*m22 + n03*m32;
442
+ float r03 = n00*m03 + n01*m13 + n02*m23 + n03*m33;
443
+
444
+ float r10 = n10*m00 + n11*m10 + n12*m20 + n13*m30;
445
+ float r11 = n10*m01 + n11*m11 + n12*m21 + n13*m31;
446
+ float r12 = n10*m02 + n11*m12 + n12*m22 + n13*m32;
447
+ float r13 = n10*m03 + n11*m13 + n12*m23 + n13*m33;
448
+
449
+ float r20 = n20*m00 + n21*m10 + n22*m20 + n23*m30;
450
+ float r21 = n20*m01 + n21*m11 + n22*m21 + n23*m31;
451
+ float r22 = n20*m02 + n21*m12 + n22*m22 + n23*m32;
452
+ float r23 = n20*m03 + n21*m13 + n22*m23 + n23*m33;
453
+
454
+ float r30 = n30*m00 + n31*m10 + n32*m20 + n33*m30;
455
+ float r31 = n30*m01 + n31*m11 + n32*m21 + n33*m31;
456
+ float r32 = n30*m02 + n31*m12 + n32*m22 + n33*m32;
457
+ float r33 = n30*m03 + n31*m13 + n32*m23 + n33*m33;
458
+
459
+ m00 = r00; m01 = r01; m02 = r02; m03 = r03;
460
+ m10 = r10; m11 = r11; m12 = r12; m13 = r13;
461
+ m20 = r20; m21 = r21; m22 = r22; m23 = r23;
462
+ m30 = r30; m31 = r31; m32 = r32; m33 = r33;
463
+ }
464
+
465
+
466
+ //////////////////////////////////////////////////////////////
467
+
468
+
469
+ /**
470
+ * Multiply source by this matrix, and return the result.
471
+ * The result will be stored in target if target is non-null, and target
472
+ * will then be the matrix returned. This improves performance if you reuse
473
+ * target, so it's recommended if you call this many times in draw().
474
+ */
475
+ public PVector mult(PVector source, PVector target) {
476
+ if (target == null) {
477
+ target = new PVector();
478
+ }
479
+ target.set(m00*source.x + m01*source.y + m02*source.z + m03,
480
+ m10*source.x + m11*source.y + m12*source.z + m13,
481
+ m20*source.x + m21*source.y + m22*source.z + m23);
475
482
  // float tw = m30*source.x + m31*source.y + m32*source.z + m33;
476
483
  // if (tw != 0 && tw != 1) {
477
484
  // target.div(tw);
478
485
  // }
479
- return target;
480
- }
486
+ return target;
487
+ }
481
488
 
482
489
 
483
- /*
490
+ /*
484
491
  public PVector cmult(PVector source, PVector target) {
485
492
  if (target == null) {
486
493
  target = new PVector();
@@ -494,370 +501,390 @@ public final class PMatrix3D implements PMatrix /*, PConstants*/ {
494
501
  }
495
502
  return target;
496
503
  }
497
- */
498
- /**
499
- * Multiply a three or four element vector against this matrix. If out is
500
- * null or not length 3 or 4, a new float array (length 3) will be returned.
501
- * Supplying and recycling a target array improves performance, so it's
502
- * recommended if you call this many times in draw.
503
- */
504
- public float[] mult(float[] source, float[] target) {
505
- if (target == null || target.length < 3) {
506
- target = new float[3];
507
- }
508
- if (source == target) {
509
- throw new RuntimeException("The source and target vectors used in "
510
- + "PMatrix3D.mult() cannot be identical.");
511
- }
512
- if (target.length == 3) {
513
- target[0] = m00 * source[0] + m01 * source[1] + m02 * source[2] + m03;
514
- target[1] = m10 * source[0] + m11 * source[1] + m12 * source[2] + m13;
515
- target[2] = m20 * source[0] + m21 * source[1] + m22 * source[2] + m23;
516
- //float w = m30*source[0] + m31*source[1] + m32*source[2] + m33;
517
- //if (w != 0 && w != 1) {
518
- // target[0] /= w; target[1] /= w; target[2] /= w;
519
- //}
520
- } else if (target.length > 3) {
521
- target[0] = m00 * source[0] + m01 * source[1] + m02 * source[2] + m03 * source[3];
522
- target[1] = m10 * source[0] + m11 * source[1] + m12 * source[2] + m13 * source[3];
523
- target[2] = m20 * source[0] + m21 * source[1] + m22 * source[2] + m23 * source[3];
524
- target[3] = m30 * source[0] + m31 * source[1] + m32 * source[2] + m33 * source[3];
525
- }
526
- return target;
504
+ */
505
+
506
+
507
+ /**
508
+ * Multiply a three or four element vector against this matrix. If out is
509
+ * null or not length 3 or 4, a new float array (length 3) will be returned.
510
+ * Supplying and recycling a target array improves performance, so it's
511
+ * recommended if you call this many times in draw.
512
+ */
513
+ public float[] mult(float[] source, float[] target) {
514
+ if (target == null || target.length < 3) {
515
+ target = new float[3];
516
+ }
517
+ if (source == target) {
518
+ throw new RuntimeException("The source and target vectors used in " +
519
+ "PMatrix3D.mult() cannot be identical.");
520
+ }
521
+ if (target.length == 3) {
522
+ target[0] = m00*source[0] + m01*source[1] + m02*source[2] + m03;
523
+ target[1] = m10*source[0] + m11*source[1] + m12*source[2] + m13;
524
+ target[2] = m20*source[0] + m21*source[1] + m22*source[2] + m23;
525
+ //float w = m30*source[0] + m31*source[1] + m32*source[2] + m33;
526
+ //if (w != 0 && w != 1) {
527
+ // target[0] /= w; target[1] /= w; target[2] /= w;
528
+ //}
529
+ } else if (target.length > 3) {
530
+ target[0] = m00*source[0] + m01*source[1] + m02*source[2] + m03*source[3];
531
+ target[1] = m10*source[0] + m11*source[1] + m12*source[2] + m13*source[3];
532
+ target[2] = m20*source[0] + m21*source[1] + m22*source[2] + m23*source[3];
533
+ target[3] = m30*source[0] + m31*source[1] + m32*source[2] + m33*source[3];
527
534
  }
535
+ return target;
536
+ }
528
537
 
529
- /**
530
- * Returns the x-coordinate of the result of multiplying the point (x, y) by
531
- * this matrix.
532
- */
533
- public float multX(float x, float y) {
534
- return m00 * x + m01 * y + m03;
535
- }
536
538
 
537
- /**
538
- * Returns the y-coordinate of the result of multiplying the point (x, y) by
539
- * this matrix.
540
- */
541
- public float multY(float x, float y) {
542
- return m10 * x + m11 * y + m13;
543
- }
539
+ /**
540
+ * Returns the x-coordinate of the result of multiplying the point (x, y)
541
+ * by this matrix.
542
+ */
543
+ public float multX(float x, float y) {
544
+ return m00*x + m01*y + m03;
545
+ }
544
546
 
545
- /**
546
- * Returns the x-coordinate of the result of multiplying the point (x, y, z)
547
- * by this matrix.
548
- */
549
- public float multX(float x, float y, float z) {
550
- return m00 * x + m01 * y + m02 * z + m03;
551
- }
552
547
 
553
- /**
554
- * Returns the y-coordinate of the result of multiplying the point (x, y, z)
555
- * by this matrix.
556
- */
557
- public float multY(float x, float y, float z) {
558
- return m10 * x + m11 * y + m12 * z + m13;
559
- }
548
+ /**
549
+ * Returns the y-coordinate of the result of multiplying the point (x, y)
550
+ * by this matrix.
551
+ */
552
+ public float multY(float x, float y) {
553
+ return m10*x + m11*y + m13;
554
+ }
560
555
 
561
- /**
562
- * Returns the z-coordinate of the result of multiplying the point (x, y, z)
563
- * by this matrix.
564
- */
565
- public float multZ(float x, float y, float z) {
566
- return m20 * x + m21 * y + m22 * z + m23;
567
- }
568
556
 
569
- /**
570
- * Returns the fourth element of the result of multiplying the vector (x, y,
571
- * z) by this matrix. (Acts as if w = 1 was supplied.)
572
- */
573
- public float multW(float x, float y, float z) {
574
- return m30 * x + m31 * y + m32 * z + m33;
575
- }
557
+ /**
558
+ * Returns the x-coordinate of the result of multiplying the point (x, y, z)
559
+ * by this matrix.
560
+ */
561
+ public float multX(float x, float y, float z) {
562
+ return m00*x + m01*y + m02*z + m03;
563
+ }
576
564
 
577
- /**
578
- * Returns the x-coordinate of the result of multiplying the vector (x, y,
579
- * z, w) by this matrix.
580
- */
581
- public float multX(float x, float y, float z, float w) {
582
- return m00 * x + m01 * y + m02 * z + m03 * w;
583
- }
584
565
 
585
- /**
586
- * Returns the y-coordinate of the result of multiplying the vector (x, y,
587
- * z, w) by this matrix.
588
- */
589
- public float multY(float x, float y, float z, float w) {
590
- return m10 * x + m11 * y + m12 * z + m13 * w;
591
- }
566
+ /**
567
+ * Returns the y-coordinate of the result of multiplying the point (x, y, z)
568
+ * by this matrix.
569
+ */
570
+ public float multY(float x, float y, float z) {
571
+ return m10*x + m11*y + m12*z + m13;
572
+ }
592
573
 
593
- /**
594
- * Returns the z-coordinate of the result of multiplying the vector (x, y,
595
- * z, w) by this matrix.
596
- */
597
- public float multZ(float x, float y, float z, float w) {
598
- return m20 * x + m21 * y + m22 * z + m23 * w;
599
- }
600
574
 
601
- /**
602
- * Returns the w-coordinate of the result of multiplying the vector (x, y,
603
- * z, w) by this matrix.
604
- */
605
- public float multW(float x, float y, float z, float w) {
606
- return m30 * x + m31 * y + m32 * z + m33 * w;
607
- }
575
+ /**
576
+ * Returns the z-coordinate of the result of multiplying the point (x, y, z)
577
+ * by this matrix.
578
+ */
579
+ public float multZ(float x, float y, float z) {
580
+ return m20*x + m21*y + m22*z + m23;
581
+ }
608
582
 
609
- /**
610
- * Transpose this matrix; rows become columns and columns rows.
611
- */
612
- public void transpose() {
613
- float temp;
614
- temp = m01;
615
- m01 = m10;
616
- m10 = temp;
617
- temp = m02;
618
- m02 = m20;
619
- m20 = temp;
620
- temp = m03;
621
- m03 = m30;
622
- m30 = temp;
623
- temp = m12;
624
- m12 = m21;
625
- m21 = temp;
626
- temp = m13;
627
- m13 = m31;
628
- m31 = temp;
629
- temp = m23;
630
- m23 = m32;
631
- m32 = temp;
632
- }
633
583
 
634
- /**
635
- * Invert this matrix. Will not necessarily succeed, because some matrices
636
- * map more than one point to the same image point, and so are irreversible.
637
- *
638
- * @return true if successful
639
- */
640
- public boolean invert() {
641
- float determinant = determinant();
642
- if (determinant == 0) {
643
- return false;
644
- }
645
-
646
- // first row
647
- float t00 = determinant3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33);
648
- float t01 = -determinant3x3(m10, m12, m13, m20, m22, m23, m30, m32, m33);
649
- float t02 = determinant3x3(m10, m11, m13, m20, m21, m23, m30, m31, m33);
650
- float t03 = -determinant3x3(m10, m11, m12, m20, m21, m22, m30, m31, m32);
651
-
652
- // second row
653
- float t10 = -determinant3x3(m01, m02, m03, m21, m22, m23, m31, m32, m33);
654
- float t11 = determinant3x3(m00, m02, m03, m20, m22, m23, m30, m32, m33);
655
- float t12 = -determinant3x3(m00, m01, m03, m20, m21, m23, m30, m31, m33);
656
- float t13 = determinant3x3(m00, m01, m02, m20, m21, m22, m30, m31, m32);
657
-
658
- // third row
659
- float t20 = determinant3x3(m01, m02, m03, m11, m12, m13, m31, m32, m33);
660
- float t21 = -determinant3x3(m00, m02, m03, m10, m12, m13, m30, m32, m33);
661
- float t22 = determinant3x3(m00, m01, m03, m10, m11, m13, m30, m31, m33);
662
- float t23 = -determinant3x3(m00, m01, m02, m10, m11, m12, m30, m31, m32);
663
-
664
- // fourth row
665
- float t30 = -determinant3x3(m01, m02, m03, m11, m12, m13, m21, m22, m23);
666
- float t31 = determinant3x3(m00, m02, m03, m10, m12, m13, m20, m22, m23);
667
- float t32 = -determinant3x3(m00, m01, m03, m10, m11, m13, m20, m21, m23);
668
- float t33 = determinant3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
669
-
670
- // transpose and divide by the determinant
671
- m00 = t00 / determinant;
672
- m01 = t10 / determinant;
673
- m02 = t20 / determinant;
674
- m03 = t30 / determinant;
675
-
676
- m10 = t01 / determinant;
677
- m11 = t11 / determinant;
678
- m12 = t21 / determinant;
679
- m13 = t31 / determinant;
680
-
681
- m20 = t02 / determinant;
682
- m21 = t12 / determinant;
683
- m22 = t22 / determinant;
684
- m23 = t32 / determinant;
685
-
686
- m30 = t03 / determinant;
687
- m31 = t13 / determinant;
688
- m32 = t23 / determinant;
689
- m33 = t33 / determinant;
690
-
691
- return true;
692
- }
584
+ /**
585
+ * Returns the fourth element of the result of multiplying the vector
586
+ * (x, y, z) by this matrix. (Acts as if w = 1 was supplied.)
587
+ */
588
+ public float multW(float x, float y, float z) {
589
+ return m30*x + m31*y + m32*z + m33;
590
+ }
693
591
 
694
- /**
695
- * Calculate the determinant of a 3x3 matrix.
696
- *
697
- * @return result
698
- */
699
- private float determinant3x3(float t00, float t01, float t02,
700
- float t10, float t11, float t12,
701
- float t20, float t21, float t22) {
702
- return (t00 * (t11 * t22 - t12 * t21)
703
- + t01 * (t12 * t20 - t10 * t22)
704
- + t02 * (t10 * t21 - t11 * t20));
705
- }
706
592
 
707
- /**
708
- * @return the determinant of the matrix
709
- */
710
- public float determinant() {
711
- float f
712
- = m00
713
- * ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32)
714
- - m13 * m22 * m31
715
- - m11 * m23 * m32
716
- - m12 * m21 * m33);
717
- f -= m01
718
- * ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32)
719
- - m13 * m22 * m30
720
- - m10 * m23 * m32
721
- - m12 * m20 * m33);
722
- f += m02
723
- * ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31)
724
- - m13 * m21 * m30
725
- - m10 * m23 * m31
726
- - m11 * m20 * m33);
727
- f -= m03
728
- * ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31)
729
- - m12 * m21 * m30
730
- - m10 * m22 * m31
731
- - m11 * m20 * m32);
732
- return f;
733
- }
593
+ /**
594
+ * Returns the x-coordinate of the result of multiplying the vector
595
+ * (x, y, z, w) by this matrix.
596
+ */
597
+ public float multX(float x, float y, float z, float w) {
598
+ return m00*x + m01*y + m02*z + m03*w;
599
+ }
734
600
 
735
- //////////////////////////////////////////////////////////////
736
- // REVERSE VERSIONS OF MATRIX OPERATIONS
737
- // These functions should not be used, as they will be removed in the future.
738
- protected void invTranslate(float tx, float ty, float tz) {
739
- preApply(1, 0, 0, -tx,
740
- 0, 1, 0, -ty,
741
- 0, 0, 1, -tz,
742
- 0, 0, 0, 1);
743
- }
744
601
 
745
- protected void invRotateX(float angle) {
746
- float c = cos(-angle);
747
- float s = sin(-angle);
748
- preApply(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
749
- }
602
+ /**
603
+ * Returns the y-coordinate of the result of multiplying the vector
604
+ * (x, y, z, w) by this matrix.
605
+ */
606
+ public float multY(float x, float y, float z, float w) {
607
+ return m10*x + m11*y + m12*z + m13*w;
608
+ }
750
609
 
751
- protected void invRotateY(float angle) {
752
- float c = cos(-angle);
753
- float s = sin(-angle);
754
- preApply(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
755
- }
756
610
 
757
- protected void invRotateZ(float angle) {
758
- float c = cos(-angle);
759
- float s = sin(-angle);
760
- preApply(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
761
- }
611
+ /**
612
+ * Returns the z-coordinate of the result of multiplying the vector
613
+ * (x, y, z, w) by this matrix.
614
+ */
615
+ public float multZ(float x, float y, float z, float w) {
616
+ return m20*x + m21*y + m22*z + m23*w;
617
+ }
762
618
 
763
- protected void invRotate(float angle, float v0, float v1, float v2) {
764
- //TODO should make sure this vector is normalized
765
619
 
766
- float c = cos(-angle);
767
- float s = sin(-angle);
768
- float t = 1.0f - c;
620
+ /**
621
+ * Returns the w-coordinate of the result of multiplying the vector
622
+ * (x, y, z, w) by this matrix.
623
+ */
624
+ public float multW(float x, float y, float z, float w) {
625
+ return m30*x + m31*y + m32*z + m33*w;
626
+ }
769
627
 
770
- preApply((t * v0 * v0) + c, (t * v0 * v1) - (s * v2), (t * v0 * v2) + (s * v1), 0,
771
- (t * v0 * v1) + (s * v2), (t * v1 * v1) + c, (t * v1 * v2) - (s * v0), 0,
772
- (t * v0 * v2) - (s * v1), (t * v1 * v2) + (s * v0), (t * v2 * v2) + c, 0,
773
- 0, 0, 0, 1);
774
- }
775
628
 
776
- protected void invScale(float x, float y, float z) {
777
- preApply(1 / x, 0, 0, 0, 0, 1 / y, 0, 0, 0, 0, 1 / z, 0, 0, 0, 0, 1);
778
- }
629
+ /**
630
+ * Transpose this matrix; rows become columns and columns rows.
631
+ */
632
+ @Override
633
+ public void transpose() {
634
+ float temp;
635
+ temp = m01; m01 = m10; m10 = temp;
636
+ temp = m02; m02 = m20; m20 = temp;
637
+ temp = m03; m03 = m30; m30 = temp;
638
+ temp = m12; m12 = m21; m21 = temp;
639
+ temp = m13; m13 = m31; m31 = temp;
640
+ temp = m23; m23 = m32; m32 = temp;
641
+ }
642
+
779
643
 
780
- protected boolean invApply(float n00, float n01, float n02, float n03,
781
- float n10, float n11, float n12, float n13,
782
- float n20, float n21, float n22, float n23,
783
- float n30, float n31, float n32, float n33) {
784
- if (inverseCopy == null) {
785
- inverseCopy = new PMatrix3D();
786
- }
787
- inverseCopy.set(n00, n01, n02, n03,
788
- n10, n11, n12, n13,
789
- n20, n21, n22, n23,
790
- n30, n31, n32, n33);
791
- if (!inverseCopy.invert()) {
792
- return false;
793
- }
794
- preApply(inverseCopy);
795
- return true;
644
+ /**
645
+ * Invert this matrix. Will not necessarily succeed, because some matrices
646
+ * map more than one point to the same image point, and so are irreversible.
647
+ * @return true if successful
648
+ */
649
+ @Override
650
+ public boolean invert() {
651
+ float determinant = determinant();
652
+ if (determinant == 0) {
653
+ return false;
654
+ }
655
+
656
+ // first row
657
+ float t00 = determinant3x3(m11, m12, m13, m21, m22, m23, m31, m32, m33);
658
+ float t01 = -determinant3x3(m10, m12, m13, m20, m22, m23, m30, m32, m33);
659
+ float t02 = determinant3x3(m10, m11, m13, m20, m21, m23, m30, m31, m33);
660
+ float t03 = -determinant3x3(m10, m11, m12, m20, m21, m22, m30, m31, m32);
661
+
662
+ // second row
663
+ float t10 = -determinant3x3(m01, m02, m03, m21, m22, m23, m31, m32, m33);
664
+ float t11 = determinant3x3(m00, m02, m03, m20, m22, m23, m30, m32, m33);
665
+ float t12 = -determinant3x3(m00, m01, m03, m20, m21, m23, m30, m31, m33);
666
+ float t13 = determinant3x3(m00, m01, m02, m20, m21, m22, m30, m31, m32);
667
+
668
+ // third row
669
+ float t20 = determinant3x3(m01, m02, m03, m11, m12, m13, m31, m32, m33);
670
+ float t21 = -determinant3x3(m00, m02, m03, m10, m12, m13, m30, m32, m33);
671
+ float t22 = determinant3x3(m00, m01, m03, m10, m11, m13, m30, m31, m33);
672
+ float t23 = -determinant3x3(m00, m01, m02, m10, m11, m12, m30, m31, m32);
673
+
674
+ // fourth row
675
+ float t30 = -determinant3x3(m01, m02, m03, m11, m12, m13, m21, m22, m23);
676
+ float t31 = determinant3x3(m00, m02, m03, m10, m12, m13, m20, m22, m23);
677
+ float t32 = -determinant3x3(m00, m01, m03, m10, m11, m13, m20, m21, m23);
678
+ float t33 = determinant3x3(m00, m01, m02, m10, m11, m12, m20, m21, m22);
679
+
680
+ // transpose and divide by the determinant
681
+ m00 = t00 / determinant;
682
+ m01 = t10 / determinant;
683
+ m02 = t20 / determinant;
684
+ m03 = t30 / determinant;
685
+
686
+ m10 = t01 / determinant;
687
+ m11 = t11 / determinant;
688
+ m12 = t21 / determinant;
689
+ m13 = t31 / determinant;
690
+
691
+ m20 = t02 / determinant;
692
+ m21 = t12 / determinant;
693
+ m22 = t22 / determinant;
694
+ m23 = t32 / determinant;
695
+
696
+ m30 = t03 / determinant;
697
+ m31 = t13 / determinant;
698
+ m32 = t23 / determinant;
699
+ m33 = t33 / determinant;
700
+
701
+ return true;
702
+ }
703
+
704
+
705
+ /**
706
+ * Calculate the determinant of a 3x3 matrix.
707
+ * @return result
708
+ */
709
+ private float determinant3x3(float t00, float t01, float t02,
710
+ float t10, float t11, float t12,
711
+ float t20, float t21, float t22) {
712
+ return (t00 * (t11 * t22 - t12 * t21) +
713
+ t01 * (t12 * t20 - t10 * t22) +
714
+ t02 * (t10 * t21 - t11 * t20));
715
+ }
716
+
717
+
718
+ /**
719
+ * @return the determinant of the matrix
720
+ */
721
+ @Override
722
+ public float determinant() {
723
+ float f =
724
+ m00
725
+ * ((m11 * m22 * m33 + m12 * m23 * m31 + m13 * m21 * m32)
726
+ - m13 * m22 * m31
727
+ - m11 * m23 * m32
728
+ - m12 * m21 * m33);
729
+ f -= m01
730
+ * ((m10 * m22 * m33 + m12 * m23 * m30 + m13 * m20 * m32)
731
+ - m13 * m22 * m30
732
+ - m10 * m23 * m32
733
+ - m12 * m20 * m33);
734
+ f += m02
735
+ * ((m10 * m21 * m33 + m11 * m23 * m30 + m13 * m20 * m31)
736
+ - m13 * m21 * m30
737
+ - m10 * m23 * m31
738
+ - m11 * m20 * m33);
739
+ f -= m03
740
+ * ((m10 * m21 * m32 + m11 * m22 * m30 + m12 * m20 * m31)
741
+ - m12 * m21 * m30
742
+ - m10 * m22 * m31
743
+ - m11 * m20 * m32);
744
+ return f;
745
+ }
746
+
747
+
748
+ //////////////////////////////////////////////////////////////
749
+
750
+ // REVERSE VERSIONS OF MATRIX OPERATIONS
751
+
752
+ // These functions should not be used, as they will be removed in the future.
753
+
754
+
755
+ protected void invTranslate(float tx, float ty, float tz) {
756
+ preApply(1, 0, 0, -tx,
757
+ 0, 1, 0, -ty,
758
+ 0, 0, 1, -tz,
759
+ 0, 0, 0, 1);
760
+ }
761
+
762
+
763
+ protected void invRotateX(float angle) {
764
+ float c = cos(-angle);
765
+ float s = sin(-angle);
766
+ preApply(1, 0, 0, 0, 0, c, -s, 0, 0, s, c, 0, 0, 0, 0, 1);
767
+ }
768
+
769
+
770
+ protected void invRotateY(float angle) {
771
+ float c = cos(-angle);
772
+ float s = sin(-angle);
773
+ preApply(c, 0, s, 0, 0, 1, 0, 0, -s, 0, c, 0, 0, 0, 0, 1);
774
+ }
775
+
776
+
777
+ protected void invRotateZ(float angle) {
778
+ float c = cos(-angle);
779
+ float s = sin(-angle);
780
+ preApply(c, -s, 0, 0, s, c, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
781
+ }
782
+
783
+
784
+ protected void invRotate(float angle, float v0, float v1, float v2) {
785
+ //TODO should make sure this vector is normalized
786
+
787
+ float c = cos(-angle);
788
+ float s = sin(-angle);
789
+ float t = 1.0f - c;
790
+
791
+ preApply((t*v0*v0) + c, (t*v0*v1) - (s*v2), (t*v0*v2) + (s*v1), 0,
792
+ (t*v0*v1) + (s*v2), (t*v1*v1) + c, (t*v1*v2) - (s*v0), 0,
793
+ (t*v0*v2) - (s*v1), (t*v1*v2) + (s*v0), (t*v2*v2) + c, 0,
794
+ 0, 0, 0, 1);
795
+ }
796
+
797
+
798
+ protected void invScale(float x, float y, float z) {
799
+ preApply(1/x, 0, 0, 0, 0, 1/y, 0, 0, 0, 0, 1/z, 0, 0, 0, 0, 1);
800
+ }
801
+
802
+
803
+ protected boolean invApply(float n00, float n01, float n02, float n03,
804
+ float n10, float n11, float n12, float n13,
805
+ float n20, float n21, float n22, float n23,
806
+ float n30, float n31, float n32, float n33) {
807
+ if (inverseCopy == null) {
808
+ inverseCopy = new PMatrix3D();
796
809
  }
810
+ inverseCopy.set(n00, n01, n02, n03,
811
+ n10, n11, n12, n13,
812
+ n20, n21, n22, n23,
813
+ n30, n31, n32, n33);
814
+ if (!inverseCopy.invert()) {
815
+ return false;
816
+ }
817
+ preApply(inverseCopy);
818
+ return true;
819
+ }
820
+
797
821
 
798
- //////////////////////////////////////////////////////////////
799
- public void print() {
800
- /*
822
+ //////////////////////////////////////////////////////////////
823
+
824
+
825
+ public void print() {
826
+ /*
801
827
  System.out.println(m00 + " " + m01 + " " + m02 + " " + m03 + "\n" +
802
828
  m10 + " " + m11 + " " + m12 + " " + m13 + "\n" +
803
829
  m20 + " " + m21 + " " + m22 + " " + m23 + "\n" +
804
830
  m30 + " " + m31 + " " + m32 + " " + m33 + "\n");
805
- */
806
- int big = (int) Math.abs(max(max(max(max(abs(m00), abs(m01)),
807
- max(abs(m02), abs(m03))),
808
- max(max(abs(m10), abs(m11)),
809
- max(abs(m12), abs(m13)))),
810
- max(max(max(abs(m20), abs(m21)),
811
- max(abs(m22), abs(m23))),
812
- max(max(abs(m30), abs(m31)),
813
- max(abs(m32), abs(m33))))));
814
-
815
- int digits = 1;
816
- if (Float.isNaN(big) || Float.isInfinite(big)) { // avoid infinite loop
817
- digits = 5;
818
- } else {
819
- while ((big /= 10) != 0) {
820
- digits++; // cheap log()
821
- }
822
- }
823
-
824
- System.out.println(PApplet.nfs(m00, digits, 4) + " "
825
- + PApplet.nfs(m01, digits, 4) + " "
826
- + PApplet.nfs(m02, digits, 4) + " "
827
- + PApplet.nfs(m03, digits, 4));
828
-
829
- System.out.println(PApplet.nfs(m10, digits, 4) + " "
830
- + PApplet.nfs(m11, digits, 4) + " "
831
- + PApplet.nfs(m12, digits, 4) + " "
832
- + PApplet.nfs(m13, digits, 4));
833
-
834
- System.out.println(PApplet.nfs(m20, digits, 4) + " "
835
- + PApplet.nfs(m21, digits, 4) + " "
836
- + PApplet.nfs(m22, digits, 4) + " "
837
- + PApplet.nfs(m23, digits, 4));
838
-
839
- System.out.println(PApplet.nfs(m30, digits, 4) + " "
840
- + PApplet.nfs(m31, digits, 4) + " "
841
- + PApplet.nfs(m32, digits, 4) + " "
842
- + PApplet.nfs(m33, digits, 4));
843
-
844
- System.out.println();
845
- }
831
+ */
832
+ int big = (int) Math.abs(max(max(max(max(abs(m00), abs(m01)),
833
+ max(abs(m02), abs(m03))),
834
+ max(max(abs(m10), abs(m11)),
835
+ max(abs(m12), abs(m13)))),
836
+ max(max(max(abs(m20), abs(m21)),
837
+ max(abs(m22), abs(m23))),
838
+ max(max(abs(m30), abs(m31)),
839
+ max(abs(m32), abs(m33))))));
840
+
841
+ int digits = 1;
842
+ if (Float.isNaN(big) || Float.isInfinite(big)) { // avoid infinite loop
843
+ digits = 5;
844
+ } else {
845
+ while ((big /= 10) != 0) digits++; // cheap log()
846
+ }
847
+
848
+ System.out.println(PApplet.nfs(m00, digits, 4) + " " +
849
+ PApplet.nfs(m01, digits, 4) + " " +
850
+ PApplet.nfs(m02, digits, 4) + " " +
851
+ PApplet.nfs(m03, digits, 4));
852
+
853
+ System.out.println(PApplet.nfs(m10, digits, 4) + " " +
854
+ PApplet.nfs(m11, digits, 4) + " " +
855
+ PApplet.nfs(m12, digits, 4) + " " +
856
+ PApplet.nfs(m13, digits, 4));
857
+
858
+ System.out.println(PApplet.nfs(m20, digits, 4) + " " +
859
+ PApplet.nfs(m21, digits, 4) + " " +
860
+ PApplet.nfs(m22, digits, 4) + " " +
861
+ PApplet.nfs(m23, digits, 4));
862
+
863
+ System.out.println(PApplet.nfs(m30, digits, 4) + " " +
864
+ PApplet.nfs(m31, digits, 4) + " " +
865
+ PApplet.nfs(m32, digits, 4) + " " +
866
+ PApplet.nfs(m33, digits, 4));
867
+
868
+ System.out.println();
869
+ }
846
870
 
847
- //////////////////////////////////////////////////////////////
848
- static private final float max(float a, float b) {
849
- return (a > b) ? a : b;
850
- }
851
871
 
852
- static private final float abs(float a) {
853
- return (a < 0) ? -a : a;
854
- }
872
+ //////////////////////////////////////////////////////////////
855
873
 
856
- static private final float sin(float angle) {
857
- return (float) Math.sin(angle);
858
- }
859
874
 
860
- static private final float cos(float angle) {
861
- return (float) Math.cos(angle);
862
- }
875
+ private static float max(float a, float b) {
876
+ return (a > b) ? a : b;
877
+ }
878
+
879
+ private static float abs(float a) {
880
+ return (a < 0) ? -a : a;
881
+ }
882
+
883
+ private static float sin(float angle) {
884
+ return (float) Math.sin(angle);
885
+ }
886
+
887
+ private static float cos(float angle) {
888
+ return (float) Math.cos(angle);
889
+ }
863
890
  }