Rev 835 | Details | Compare with Previous | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 835 | chris | 1 | package com.gebauz.bauzoid.math; |
| 2 | |||
| 3 | import java.nio.FloatBuffer; |
||
| 4 | |||
| 5 | import com.badlogic.gdx.utils.BufferUtils; |
||
| 6 | |||
| 7 | public class Matrix4 |
||
| 8 | { |
||
| 9 | /* OpenGL Colum Major: |
||
| 10 | * m[0] m[4] m[8] m[12] |
||
| 11 | * m[1] m[5] m[9] m[13] |
||
| 12 | * m[2] m[6] m[10] m[14] |
||
| 13 | * m[3] m[7] m[11] m[15] |
||
| 14 | */ |
||
| 15 | |||
| 16 | public static final int M11 = 0; |
||
| 17 | public static final int M21 = 1; |
||
| 18 | public static final int M31 = 2; |
||
| 19 | public static final int M41 = 3; |
||
| 20 | public static final int M12 = 4; |
||
| 21 | public static final int M22 = 5; |
||
| 22 | public static final int M32 = 6; |
||
| 23 | public static final int M42 = 7; |
||
| 24 | public static final int M13 = 8; |
||
| 25 | public static final int M23 = 9; |
||
| 26 | public static final int M33 = 10; |
||
| 27 | public static final int M43 = 11; |
||
| 28 | public static final int M14 = 12; |
||
| 29 | public static final int M24 = 13; |
||
| 30 | public static final int M34 = 14; |
||
| 31 | public static final int M44 = 15; |
||
| 32 | |||
| 33 | /* public float m11; |
||
| 34 | public float m21; |
||
| 35 | public float m31; |
||
| 36 | public float m41; |
||
| 37 | public float m12; |
||
| 38 | public float m22; |
||
| 39 | public float m32; |
||
| 40 | public float m42; |
||
| 41 | public float m13; |
||
| 42 | public float m23; |
||
| 43 | public float m33; |
||
| 44 | public float m43; |
||
| 45 | public float m14; |
||
| 46 | public float m24; |
||
| 47 | public float m34; |
||
| 48 | public float m44;*/ |
||
| 49 | |||
| 50 | public static final int MATRIX_SIZE = 4; |
||
| 51 | |||
| 52 | public float values[] = new float[MATRIX_SIZE*MATRIX_SIZE]; |
||
| 53 | |||
| 54 | public Matrix4() |
||
| 55 | { |
||
| 56 | } |
||
| 57 | |||
| 58 | /** Copy constructor. */ |
||
| 59 | public Matrix4(Matrix4 b) |
||
| 60 | { |
||
| 61 | for (int i = 0; i < values.length; i++) |
||
| 62 | this.values[i] = b.values[i]; |
||
| 63 | |||
| 64 | /*this.m11 = b.m11; this.m21 = b.m21; this.m31 = b.m31; this.m41 = b.m41; |
||
| 65 | this.m12 = b.m12; this.m22 = b.m22; this.m32 = b.m32; this.m42 = b.m42; |
||
| 66 | this.m13 = b.m13; this.m23 = b.m23; this.m33 = b.m33; this.m43 = b.m43; |
||
| 67 | this.m14 = b.m14; this.m24 = b.m24; this.m34 = b.m34; this.m44 = b.m44;*/ |
||
| 68 | } |
||
| 69 | |||
| 70 | public Matrix4(float[] m) |
||
| 71 | { |
||
| 72 | //fromGLMatrix(m); |
||
| 73 | for (int i = 0; i < values.length; i++) |
||
| 74 | this.values[i] = m[i]; |
||
| 75 | } |
||
| 76 | |||
| 77 | public float get(int row, int col) |
||
| 78 | { |
||
| 79 | return values[col*MATRIX_SIZE + row]; |
||
| 80 | |||
| 81 | /* switch (row) |
||
| 82 | { |
||
| 83 | case 0: |
||
| 84 | switch (col) |
||
| 85 | { |
||
| 86 | case 0: return m11; |
||
| 87 | case 1: return m12; |
||
| 88 | case 2: return m13; |
||
| 89 | case 3: return m14; |
||
| 90 | } |
||
| 91 | break; |
||
| 92 | case 1: |
||
| 93 | switch (col) |
||
| 94 | { |
||
| 95 | case 0: return m21; |
||
| 96 | case 1: return m22; |
||
| 97 | case 2: return m23; |
||
| 98 | case 3: return m24; |
||
| 99 | } |
||
| 100 | break; |
||
| 101 | case 2: |
||
| 102 | switch (col) |
||
| 103 | { |
||
| 104 | case 0: return m31; |
||
| 105 | case 1: return m32; |
||
| 106 | case 2: return m33; |
||
| 107 | case 3: return m34; |
||
| 108 | } |
||
| 109 | break; |
||
| 110 | case 3: |
||
| 111 | switch (col) |
||
| 112 | { |
||
| 113 | case 0: return m41; |
||
| 114 | case 1: return m42; |
||
| 115 | case 2: return m43; |
||
| 116 | case 3: return m44; |
||
| 117 | } |
||
| 118 | break; |
||
| 119 | } |
||
| 120 | // should never reach here -> TODO: assert |
||
| 121 | return 0.0f;*/ |
||
| 122 | } |
||
| 123 | |||
| 124 | public void set(int row, int col, float value) |
||
| 125 | { |
||
| 126 | values[col*MATRIX_SIZE + row] = value; |
||
| 127 | |||
| 128 | /*switch (row) |
||
| 129 | { |
||
| 130 | case 0: |
||
| 131 | switch (col) |
||
| 132 | { |
||
| 133 | case 0: |
||
| 134 | m11 = value; |
||
| 135 | break; |
||
| 136 | case 1: |
||
| 137 | m12 = value; |
||
| 138 | break; |
||
| 139 | case 2: |
||
| 140 | m13 = value; |
||
| 141 | break; |
||
| 142 | case 3: |
||
| 143 | m14 = value; |
||
| 144 | break; |
||
| 145 | } |
||
| 146 | break; |
||
| 147 | case 1: |
||
| 148 | switch (col) |
||
| 149 | { |
||
| 150 | case 0: |
||
| 151 | m21 = value; |
||
| 152 | break; |
||
| 153 | case 1: |
||
| 154 | m22 = value; |
||
| 155 | break; |
||
| 156 | case 2: |
||
| 157 | m23 = value; |
||
| 158 | break; |
||
| 159 | case 3: |
||
| 160 | m24 = value; |
||
| 161 | break; |
||
| 162 | } |
||
| 163 | break; |
||
| 164 | case 2: |
||
| 165 | switch (col) |
||
| 166 | { |
||
| 167 | case 0: |
||
| 168 | m31 = value; |
||
| 169 | break; |
||
| 170 | case 1: |
||
| 171 | m32 = value; |
||
| 172 | break; |
||
| 173 | case 2: |
||
| 174 | m33 = value; |
||
| 175 | break; |
||
| 176 | case 3: |
||
| 177 | m34 = value; |
||
| 178 | break; |
||
| 179 | } |
||
| 180 | break; |
||
| 181 | case 3: |
||
| 182 | switch (col) |
||
| 183 | { |
||
| 184 | case 0: |
||
| 185 | m41 = value; |
||
| 186 | break; |
||
| 187 | case 1: |
||
| 188 | m42 = value; |
||
| 189 | break; |
||
| 190 | case 2: |
||
| 191 | m43 = value; |
||
| 192 | break; |
||
| 193 | case 3: |
||
| 194 | m44 = value; |
||
| 195 | break; |
||
| 196 | } |
||
| 197 | break; |
||
| 198 | }*/ |
||
| 199 | } |
||
| 200 | |||
| 201 | public void zero() |
||
| 202 | { |
||
| 203 | for (int i = 0; i < values.length; i++) |
||
| 204 | values[i] = 0.0f; |
||
| 205 | /*m11 = 0.0f; m12 = 0.0f; m13 = 0.0f; m14 = 0.0f; |
||
| 206 | m21 = 0.0f; m22 = 0.0f; m23 = 0.0f; m24 = 0.0f; |
||
| 207 | m31 = 0.0f; m32 = 0.0f; m33 = 0.0f; m34 = 0.0f; |
||
| 208 | m41 = 0.0f; m42 = 0.0f; m43 = 0.0f; m44 = 0.0f;*/ |
||
| 209 | } |
||
| 210 | |||
| 211 | public void identity() |
||
| 212 | { |
||
| 213 | zero(); |
||
| 214 | //m11 = 1.0f; m22 = 1.0f; m33 = 1.0f; m44 = 1.0f; |
||
| 215 | values[M11] = 1.0f; values[M22] = 1.0f; values[M33] = 1.0f; values[M44] = 1.0f; |
||
| 216 | } |
||
| 217 | |||
| 218 | public boolean equals(Matrix4 other) |
||
| 219 | { |
||
| 220 | for (int i = 0; i < values.length; i++) |
||
| 221 | { |
||
| 222 | if (this.values[i] != other.values[i]) |
||
| 223 | return false; |
||
| 224 | } |
||
| 225 | return true; |
||
| 226 | |||
| 227 | /*return ((m11 == other.m11) && (m12 == other.m12) && (m13 == other.m13) && (m14 == other.m14) && |
||
| 228 | (m21 == other.m21) && (m22 == other.m22) && (m23 == other.m23) && (m24 == other.m24) && |
||
| 229 | (m31 == other.m31) && (m32 == other.m32) && (m33 == other.m33) && (m34 == other.m34) && |
||
| 230 | (m41 == other.m41) && (m42 == other.m42) && (m43 == other.m43) && (m44 == other.m44));*/ |
||
| 231 | } |
||
| 232 | |||
| 233 | public boolean isSingular() |
||
| 234 | { |
||
| 235 | float determinant = getDeterminant(); |
||
| 236 | return ((float)Math.abs(determinant) < MathUtil.EPSILON); |
||
| 237 | } |
||
| 238 | |||
| 239 | public Matrix4 getTranspose() |
||
| 240 | { |
||
| 241 | Matrix4 result = new Matrix4(); |
||
| 242 | |||
| 243 | for (int row = 0; row < MATRIX_SIZE; row++) |
||
| 244 | { |
||
| 245 | for (int col = 0; col < MATRIX_SIZE; col++) |
||
| 246 | { |
||
| 247 | float v = this.get(row, col); |
||
| 248 | this.set(col, row, v); |
||
| 249 | } |
||
| 250 | } |
||
| 251 | |||
| 252 | /* result.m11 = m11; |
||
| 253 | result.m12 = m21; |
||
| 254 | result.m13 = m31; |
||
| 255 | result.m14 = m41; |
||
| 256 | result.m21 = m12; |
||
| 257 | result.m22 = m22; |
||
| 258 | result.m23 = m32; |
||
| 259 | result.m24 = m42; |
||
| 260 | result.m31 = m13; |
||
| 261 | result.m32 = m23; |
||
| 262 | result.m33 = m33; |
||
| 263 | result.m34 = m43; |
||
| 264 | result.m41 = m14; |
||
| 265 | result.m42 = m24; |
||
| 266 | result.m43 = m34; |
||
| 267 | result.m44 = m44;*/ |
||
| 268 | return result; |
||
| 269 | } |
||
| 270 | |||
| 271 | public float getDeterminant() |
||
| 272 | { |
||
| 273 | |||
| 274 | float result = |
||
| 275 | values[M14] * values[M23] * values[M32] * values[M41] - |
||
| 276 | values[M13] * values[M24] * values[M32] * values[M41] - |
||
| 277 | values[M14] * values[M22] * values[M33] * values[M41] + |
||
| 278 | values[M12] * values[M24] * values[M33] * values[M41] + |
||
| 279 | values[M13] * values[M22] * values[M34] * values[M41] - |
||
| 280 | values[M12] * values[M23] * values[M34] * values[M41] - |
||
| 281 | values[M14] * values[M23] * values[M31] * values[M42] + |
||
| 282 | values[M13] * values[M24] * values[M31] * values[M42] + |
||
| 283 | values[M14] * values[M21] * values[M33] * values[M42] - |
||
| 284 | values[M11] * values[M24] * values[M33] * values[M42] - |
||
| 285 | values[M13] * values[M21] * values[M34] * values[M42] + |
||
| 286 | values[M11] * values[M23] * values[M34] * values[M42] + |
||
| 287 | values[M14] * values[M22] * values[M31] * values[M43] - |
||
| 288 | values[M12] * values[M24] * values[M31] * values[M43] - |
||
| 289 | values[M14] * values[M21] * values[M32] * values[M43] + |
||
| 290 | values[M11] * values[M24] * values[M32] * values[M43] + |
||
| 291 | values[M12] * values[M21] * values[M34] * values[M43] - |
||
| 292 | values[M11] * values[M22] * values[M34] * values[M43] - |
||
| 293 | values[M13] * values[M22] * values[M31] * values[M44] + |
||
| 294 | values[M12] * values[M23] * values[M31] * values[M44] + |
||
| 295 | values[M13] * values[M21] * values[M32] * values[M44] - |
||
| 296 | values[M11] * values[M23] * values[M32] * values[M44] - |
||
| 297 | values[M12] * values[M21] * values[M33] * values[M44] + |
||
| 298 | values[M11] * values[M22] * values[M33] * values[M44]; |
||
| 299 | return result; |
||
| 300 | |||
| 301 | /* float result = |
||
| 302 | m14 * m23 * m32 * m41 - |
||
| 303 | m13 * m24 * m32 * m41 - |
||
| 304 | m14 * m22 * m33 * m41 + |
||
| 305 | m12 * m24 * m33 * m41 + |
||
| 306 | m13 * m22 * m34 * m41 - |
||
| 307 | m12 * m23 * m34 * m41 - |
||
| 308 | m14 * m23 * m31 * m42 + |
||
| 309 | m13 * m24 * m31 * m42 + |
||
| 310 | m14 * m21 * m33 * m42 - |
||
| 311 | m11 * m24 * m33 * m42 - |
||
| 312 | m13 * m21 * m34 * m42 + |
||
| 313 | m11 * m23 * m34 * m42 + |
||
| 314 | m14 * m22 * m31 * m43 - |
||
| 315 | m12 * m24 * m31 * m43 - |
||
| 316 | m14 * m21 * m32 * m43 + |
||
| 317 | m11 * m24 * m32 * m43 + |
||
| 318 | m12 * m21 * m34 * m43 - |
||
| 319 | m11 * m22 * m34 * m43 - |
||
| 320 | m13 * m22 * m31 * m44 + |
||
| 321 | m12 * m23 * m31 * m44 + |
||
| 322 | m13 * m21 * m32 * m44 - |
||
| 323 | m11 * m23 * m32 * m44 - |
||
| 324 | m12 * m21 * m33 * m44 + |
||
| 325 | m11 * m22 * m33 * m44; |
||
| 326 | return result;*/ |
||
| 327 | } |
||
| 328 | |||
| 329 | public Matrix4 getInverse() |
||
| 330 | { |
||
| 331 | Matrix4 result = new Matrix4(); |
||
| 332 | |||
| 333 | float determinant = getDeterminant(); |
||
| 334 | if (determinant == 0.0f) |
||
| 335 | { |
||
| 336 | // singular matrix cannot be inverted |
||
| 337 | return this; |
||
| 338 | } |
||
| 339 | |||
| 340 | result.values[M11] = values[M23] * values[M34] * values[M42] |
||
| 341 | - values[M24] * values[M33] * values[M42] |
||
| 342 | + values[M24] * values[M32] * values[M43] |
||
| 343 | - values[M22] * values[M34] * values[M43] |
||
| 344 | - values[M23] * values[M32] * values[M44] |
||
| 345 | + values[M22] * values[M33] * values[M44]; |
||
| 346 | result.values[M12] = values[M14] * values[M33] * values[M42] |
||
| 347 | - values[M13] * values[M34] * values[M42] |
||
| 348 | - values[M14] * values[M32] * values[M43] |
||
| 349 | + values[M12] * values[M34] * values[M43] |
||
| 350 | + values[M13] * values[M32] * values[M44] |
||
| 351 | - values[M12] * values[M33] * values[M44]; |
||
| 352 | result.values[M13] = values[M13] * values[M24] * values[M42] |
||
| 353 | - values[M14] * values[M23] * values[M42] |
||
| 354 | + values[M14] * values[M22] * values[M43] |
||
| 355 | - values[M12] * values[M24] * values[M43] |
||
| 356 | - values[M13] * values[M22] * values[M44] |
||
| 357 | + values[M12] * values[M23] * values[M44]; |
||
| 358 | result.values[M14] = values[M14] * values[M23] * values[M32] |
||
| 359 | - values[M13] * values[M24] * values[M32] |
||
| 360 | - values[M14] * values[M22] * values[M33] |
||
| 361 | + values[M12] * values[M24] * values[M33] |
||
| 362 | + values[M13] * values[M22] * values[M34] |
||
| 363 | - values[M12] * values[M23] * values[M34]; |
||
| 364 | result.values[M21] = values[M24] * values[M33] * values[M41] |
||
| 365 | - values[M23] * values[M34] * values[M41] |
||
| 366 | - values[M24] * values[M31] * values[M43] |
||
| 367 | + values[M21] * values[M34] * values[M43] |
||
| 368 | + values[M23] * values[M31] * values[M44] |
||
| 369 | - values[M21] * values[M33] * values[M44]; |
||
| 370 | result.values[M22] = values[M13] * values[M34] * values[M41] |
||
| 371 | - values[M14] * values[M33] * values[M41] |
||
| 372 | + values[M14] * values[M31] * values[M43] |
||
| 373 | - values[M11] * values[M34] * values[M43] |
||
| 374 | - values[M13] * values[M31] * values[M44] |
||
| 375 | + values[M11] * values[M33] * values[M44]; |
||
| 376 | result.values[M23] = values[M14] * values[M23] * values[M41] |
||
| 377 | - values[M13] * values[M24] * values[M41] |
||
| 378 | - values[M14] * values[M21] * values[M43] |
||
| 379 | + values[M11] * values[M24] * values[M43] |
||
| 380 | + values[M13] * values[M21] * values[M44] |
||
| 381 | - values[M11] * values[M23] * values[M44]; |
||
| 382 | result.values[M24] = values[M13] * values[M24] * values[M31] |
||
| 383 | - values[M14] * values[M23] * values[M31] |
||
| 384 | + values[M14] * values[M21] * values[M33] |
||
| 385 | - values[M11] * values[M24] * values[M33] |
||
| 386 | - values[M13] * values[M21] * values[M34] |
||
| 387 | + values[M11] * values[M23] * values[M34]; |
||
| 388 | result.values[M31] = values[M22] * values[M34] * values[M41] |
||
| 389 | - values[M24] * values[M32] * values[M41] |
||
| 390 | + values[M24] * values[M31] * values[M42] |
||
| 391 | - values[M21] * values[M34] * values[M42] |
||
| 392 | - values[M22] * values[M31] * values[M44] |
||
| 393 | + values[M21] * values[M32] * values[M44]; |
||
| 394 | result.values[M32] = values[M14] * values[M32] * values[M41] |
||
| 395 | - values[M12] * values[M34] * values[M41] |
||
| 396 | - values[M14] * values[M31] * values[M42] |
||
| 397 | + values[M11] * values[M34] * values[M42] |
||
| 398 | + values[M12] * values[M31] * values[M44] |
||
| 399 | - values[M11] * values[M32] * values[M44]; |
||
| 400 | result.values[M33] = values[M12] * values[M24] * values[M41] |
||
| 401 | - values[M14] * values[M22] * values[M41] |
||
| 402 | + values[M14] * values[M21] * values[M42] |
||
| 403 | - values[M11] * values[M24] * values[M42] |
||
| 404 | - values[M12] * values[M21] * values[M44] |
||
| 405 | + values[M11] * values[M22] * values[M44]; |
||
| 406 | result.values[M34] = values[M14] * values[M22] * values[M31] |
||
| 407 | - values[M12] * values[M24] * values[M31] |
||
| 408 | - values[M14] * values[M21] * values[M32] |
||
| 409 | + values[M11] * values[M24] * values[M32] |
||
| 410 | + values[M12] * values[M21] * values[M34] |
||
| 411 | - values[M11] * values[M22] * values[M34]; |
||
| 412 | result.values[M41] = values[M23] * values[M32] * values[M41] |
||
| 413 | - values[M22] * values[M33] * values[M41] |
||
| 414 | - values[M23] * values[M31] * values[M42] |
||
| 415 | + values[M21] * values[M33] * values[M42] |
||
| 416 | + values[M22] * values[M31] * values[M43] |
||
| 417 | - values[M21] * values[M32] * values[M43]; |
||
| 418 | result.values[M42] = values[M12] * values[M33] * values[M41] |
||
| 419 | - values[M13] * values[M32] * values[M41] |
||
| 420 | + values[M13] * values[M31] * values[M42] |
||
| 421 | - values[M11] * values[M33] * values[M42] |
||
| 422 | - values[M12] * values[M31] * values[M43] |
||
| 423 | + values[M11] * values[M32] * values[M43]; |
||
| 424 | result.values[M43] = values[M13] * values[M22] * values[M41] |
||
| 425 | - values[M12] * values[M23] * values[M41] |
||
| 426 | - values[M13] * values[M21] * values[M42] |
||
| 427 | + values[M11] * values[M23] * values[M42] |
||
| 428 | + values[M12] * values[M21] * values[M43] |
||
| 429 | - values[M11] * values[M22] * values[M43]; |
||
| 430 | result.values[M44] = values[M12] * values[M23] * values[M31] |
||
| 431 | - values[M13] * values[M22] * values[M31] |
||
| 432 | + values[M13] * values[M21] * values[M32] |
||
| 433 | - values[M11] * values[M23] * values[M32] |
||
| 434 | - values[M12] * values[M21] * values[M33] |
||
| 435 | + values[M11] * values[M22] * values[M33]; |
||
| 436 | |||
| 437 | /* result.m11 = m23 * m34 * m42 |
||
| 438 | - m24 * m33 * m42 |
||
| 439 | + m24 * m32 * m43 |
||
| 440 | - m22 * m34 * m43 |
||
| 441 | - m23 * m32 * m44 |
||
| 442 | + m22 * m33 * m44; |
||
| 443 | result.m12 = m14 * m33 * m42 |
||
| 444 | - m13 * m34 * m42 |
||
| 445 | - m14 * m32 * m43 |
||
| 446 | + m12 * m34 * m43 |
||
| 447 | + m13 * m32 * m44 |
||
| 448 | - m12 * m33 * m44; |
||
| 449 | result.m13 = m13 * m24 * m42 |
||
| 450 | - m14 * m23 * m42 |
||
| 451 | + m14 * m22 * m43 |
||
| 452 | - m12 * m24 * m43 |
||
| 453 | - m13 * m22 * m44 |
||
| 454 | + m12 * m23 * m44; |
||
| 455 | result.m14 = m14 * m23 * m32 |
||
| 456 | - m13 * m24 * m32 |
||
| 457 | - m14 * m22 * m33 |
||
| 458 | + m12 * m24 * m33 |
||
| 459 | + m13 * m22 * m34 |
||
| 460 | - m12 * m23 * m34; |
||
| 461 | result.m21 = m24 * m33 * m41 |
||
| 462 | - m23 * m34 * m41 |
||
| 463 | - m24 * m31 * m43 |
||
| 464 | + m21 * m34 * m43 |
||
| 465 | + m23 * m31 * m44 |
||
| 466 | - m21 * m33 * m44; |
||
| 467 | result.m22 = m13 * m34 * m41 |
||
| 468 | - m14 * m33 * m41 |
||
| 469 | + m14 * m31 * m43 |
||
| 470 | - m11 * m34 * m43 |
||
| 471 | - m13 * m31 * m44 |
||
| 472 | + m11 * m33 * m44; |
||
| 473 | result.m23 = m14 * m23 * m41 |
||
| 474 | - m13 * m24 * m41 |
||
| 475 | - m14 * m21 * m43 |
||
| 476 | + m11 * m24 * m43 |
||
| 477 | + m13 * m21 * m44 |
||
| 478 | - m11 * m23 * m44; |
||
| 479 | result.m24 = m13 * m24 * m31 |
||
| 480 | - m14 * m23 * m31 |
||
| 481 | + m14 * m21 * m33 |
||
| 482 | - m11 * m24 * m33 |
||
| 483 | - m13 * m21 * m34 |
||
| 484 | + m11 * m23 * m34; |
||
| 485 | result.m31 = m22 * m34 * m41 |
||
| 486 | - m24 * m32 * m41 |
||
| 487 | + m24 * m31 * m42 |
||
| 488 | - m21 * m34 * m42 |
||
| 489 | - m22 * m31 * m44 |
||
| 490 | + m21 * m32 * m44; |
||
| 491 | result.m32 = m14 * m32 * m41 |
||
| 492 | - m12 * m34 * m41 |
||
| 493 | - m14 * m31 * m42 |
||
| 494 | + m11 * m34 * m42 |
||
| 495 | + m12 * m31 * m44 |
||
| 496 | - m11 * m32 * m44; |
||
| 497 | result.m33 = m12 * m24 * m41 |
||
| 498 | - m14 * m22 * m41 |
||
| 499 | + m14 * m21 * m42 |
||
| 500 | - m11 * m24 * m42 |
||
| 501 | - m12 * m21 * m44 |
||
| 502 | + m11 * m22 * m44; |
||
| 503 | result.m34 = m14 * m22 * m31 |
||
| 504 | - m12 * m24 * m31 |
||
| 505 | - m14 * m21 * m32 |
||
| 506 | + m11 * m24 * m32 |
||
| 507 | + m12 * m21 * m34 |
||
| 508 | - m11 * m22 * m34; |
||
| 509 | result.m41 = m23 * m32 * m41 |
||
| 510 | - m22 * m33 * m41 |
||
| 511 | - m23 * m31 * m42 |
||
| 512 | + m21 * m33 * m42 |
||
| 513 | + m22 * m31 * m43 |
||
| 514 | - m21 * m32 * m43; |
||
| 515 | result.m42 = m12 * m33 * m41 |
||
| 516 | - m13 * m32 * m41 |
||
| 517 | + m13 * m31 * m42 |
||
| 518 | - m11 * m33 * m42 |
||
| 519 | - m12 * m31 * m43 |
||
| 520 | + m11 * m32 * m43; |
||
| 521 | result.m43 = m13 * m22 * m41 |
||
| 522 | - m12 * m23 * m41 |
||
| 523 | - m13 * m21 * m42 |
||
| 524 | + m11 * m23 * m42 |
||
| 525 | + m12 * m21 * m43 |
||
| 526 | - m11 * m22 * m43; |
||
| 527 | result.m44 = m12 * m23 * m31 |
||
| 528 | - m13 * m22 * m31 |
||
| 529 | + m13 * m21 * m32 |
||
| 530 | - m11 * m23 * m32 |
||
| 531 | - m12 * m21 * m33 |
||
| 532 | + m11 * m22 * m33;*/ |
||
| 533 | |||
| 534 | float multiply = 1.0f / determinant; |
||
| 535 | |||
| 536 | for (int i = 0; i < values.length; i++) |
||
| 537 | result.values[i] *= multiply; |
||
| 538 | |||
| 539 | /* result.m11 *= multiply; |
||
| 540 | result.m21 *= multiply; |
||
| 541 | result.m31 *= multiply; |
||
| 542 | result.m41 *= multiply; |
||
| 543 | result.m12 *= multiply; |
||
| 544 | result.m22 *= multiply; |
||
| 545 | result.m32 *= multiply; |
||
| 546 | result.m42 *= multiply; |
||
| 547 | result.m13 *= multiply; |
||
| 548 | result.m23 *= multiply; |
||
| 549 | result.m33 *= multiply; |
||
| 550 | result.m43 *= multiply; |
||
| 551 | result.m14 *= multiply; |
||
| 552 | result.m24 *= multiply; |
||
| 553 | result.m34 *= multiply; |
||
| 554 | result.m44 *= multiply;*/ |
||
| 555 | |||
| 556 | return result; |
||
| 557 | } |
||
| 558 | |||
| 559 | public void copyTo(Matrix4 target) |
||
| 560 | { |
||
| 561 | for (int i = 0; i < values.length; i++) |
||
| 562 | target.values[i] = this.values[i]; |
||
| 563 | /*target.m11 = m11; target.m12 = m12; target.m13 = m13; target.m14 = m14; |
||
| 564 | target.m21 = m21; target.m22 = m22; target.m23 = m23; target.m24 = m24; |
||
| 565 | target.m31 = m31; target.m32 = m32; target.m33 = m33; target.m34 = m34; |
||
| 566 | target.m41 = m41; target.m42 = m42; target.m43 = m43; target.m44 = m44;*/ |
||
| 567 | } |
||
| 568 | |||
| 569 | public void copyFrom(Matrix4 source) |
||
| 570 | { |
||
| 571 | for (int i = 0; i < values.length; i++) |
||
| 572 | this.values[i] = source.values[i]; |
||
| 573 | /*m11 = source.m11; m12 = source.m12; m13 = source.m13; m14 = source.m14; |
||
| 574 | m21 = source.m21; m22 = source.m22; m23 = source.m23; m24 = source.m24; |
||
| 575 | m31 = source.m31; m32 = source.m32; m33 = source.m33; m34 = source.m34; |
||
| 576 | m41 = source.m41; m42 = source.m42; m43 = source.m43; m44 = source.m44;*/ |
||
| 577 | } |
||
| 578 | |||
| 579 | public void postMultiply(Matrix4 v) |
||
| 580 | { |
||
| 581 | multiply(this, this, v); |
||
| 582 | } |
||
| 583 | |||
| 584 | public void preMultiply(Matrix4 v) |
||
| 585 | { |
||
| 586 | multiply(this, v, this); |
||
| 587 | } |
||
| 588 | |||
| 589 | static public void multiply(Matrix4 result, Matrix4 a, Matrix4 b) |
||
| 590 | { |
||
| 591 | float result11 = a.values[M11] * b.values[M11] + a.values[M21] * b.values[M12] + a.values[M31] * b.values[M13] + a.values[M41] * b.values[M14]; |
||
| 592 | float result21 = a.values[M11] * b.values[M21] + a.values[M21] * b.values[M22] + a.values[M31] * b.values[M23] + a.values[M41] * b.values[M24]; |
||
| 593 | float result31 = a.values[M11] * b.values[M31] + a.values[M21] * b.values[M32] + a.values[M31] * b.values[M33] + a.values[M41] * b.values[M34]; |
||
| 594 | float result41 = a.values[M11] * b.values[M41] + a.values[M21] * b.values[M42] + a.values[M31] * b.values[M43] + a.values[M41] * b.values[M44]; |
||
| 595 | float result12 = a.values[M12] * b.values[M11] + a.values[M22] * b.values[M12] + a.values[M32] * b.values[M13] + a.values[M42] * b.values[M14]; |
||
| 596 | float result22 = a.values[M12] * b.values[M21] + a.values[M22] * b.values[M22] + a.values[M32] * b.values[M23] + a.values[M42] * b.values[M24]; |
||
| 597 | float result32 = a.values[M12] * b.values[M31] + a.values[M22] * b.values[M32] + a.values[M32] * b.values[M33] + a.values[M42] * b.values[M34]; |
||
| 598 | float result42 = a.values[M12] * b.values[M41] + a.values[M22] * b.values[M42] + a.values[M32] * b.values[M43] + a.values[M42] * b.values[M44]; |
||
| 599 | float result13 = a.values[M13] * b.values[M11] + a.values[M23] * b.values[M12] + a.values[M33] * b.values[M13] + a.values[M43] * b.values[M14]; |
||
| 600 | float result23 = a.values[M13] * b.values[M21] + a.values[M23] * b.values[M22] + a.values[M33] * b.values[M23] + a.values[M43] * b.values[M24]; |
||
| 601 | float result33 = a.values[M13] * b.values[M31] + a.values[M23] * b.values[M32] + a.values[M33] * b.values[M33] + a.values[M43] * b.values[M34]; |
||
| 602 | float result43 = a.values[M13] * b.values[M41] + a.values[M23] * b.values[M42] + a.values[M33] * b.values[M43] + a.values[M43] * b.values[M44]; |
||
| 603 | float result14 = a.values[M14] * b.values[M11] + a.values[M24] * b.values[M12] + a.values[M34] * b.values[M13] + a.values[M44] * b.values[M14]; |
||
| 604 | float result24 = a.values[M14] * b.values[M21] + a.values[M24] * b.values[M22] + a.values[M34] * b.values[M23] + a.values[M44] * b.values[M24]; |
||
| 605 | float result34 = a.values[M14] * b.values[M31] + a.values[M24] * b.values[M32] + a.values[M34] * b.values[M33] + a.values[M44] * b.values[M34]; |
||
| 606 | float result44 = a.values[M14] * b.values[M41] + a.values[M24] * b.values[M42] + a.values[M34] * b.values[M43] + a.values[M44] * b.values[M44]; |
||
| 607 | result.values[M11] = result11; |
||
| 608 | result.values[M21] = result21; |
||
| 609 | result.values[M31] = result31; |
||
| 610 | result.values[M41] = result41; |
||
| 611 | result.values[M12] = result12; |
||
| 612 | result.values[M22] = result22; |
||
| 613 | result.values[M32] = result32; |
||
| 614 | result.values[M42] = result42; |
||
| 615 | result.values[M13] = result13; |
||
| 616 | result.values[M23] = result23; |
||
| 617 | result.values[M33] = result33; |
||
| 618 | result.values[M43] = result43; |
||
| 619 | result.values[M14] = result14; |
||
| 620 | result.values[M24] = result24; |
||
| 621 | result.values[M34] = result34; |
||
| 622 | result.values[M44] = result44; |
||
| 623 | } |
||
| 624 | |||
| 625 | static public Matrix4 multiply(Matrix4 a, Matrix4 b) |
||
| 626 | { |
||
| 627 | Matrix4 result = new Matrix4(); |
||
| 628 | multiply(result, a, b); |
||
| 629 | return result; |
||
| 630 | } |
||
| 631 | |||
| 632 | public void multiply(Matrix4 other) |
||
| 633 | { |
||
| 634 | Matrix4.multiply(this, this, other); |
||
| 635 | } |
||
| 636 | |||
| 637 | static public Matrix4 createIdentity() |
||
| 638 | { |
||
| 639 | return createScale(1.0f, 1.0f, 1.0f); |
||
| 640 | } |
||
| 641 | |||
| 642 | static public Matrix4 createScale(float sx, float sy, float sz) |
||
| 643 | { |
||
| 644 | Matrix4 result = new Matrix4(); |
||
| 645 | result.setScale(sx, sy, sz); |
||
| 646 | return result; |
||
| 647 | } |
||
| 648 | |||
| 649 | static public Matrix4 createScale(Vector3 scale) |
||
| 650 | { |
||
| 651 | return createScale(scale.x, scale.y, scale.z); |
||
| 652 | } |
||
| 653 | |||
| 654 | static public Matrix4 createScale(float s) |
||
| 655 | { |
||
| 656 | return createScale(s, s, s); |
||
| 657 | } |
||
| 658 | |||
| 659 | public void setScale(float sx, float sy, float sz) |
||
| 660 | { |
||
| 661 | zero(); |
||
| 662 | this.values[M11] = sx; |
||
| 663 | this.values[M22] = sy; |
||
| 664 | this.values[M33] = sz; |
||
| 665 | this.values[M44] = 1.0f; |
||
| 666 | } |
||
| 667 | |||
| 668 | public void setScale(Vector3 scale) |
||
| 669 | { |
||
| 670 | setScale(scale.x, scale.y, scale.z); |
||
| 671 | } |
||
| 672 | |||
| 673 | public void setScale(float s) |
||
| 674 | { |
||
| 675 | setScale(s, s, s); |
||
| 676 | } |
||
| 677 | |||
| 678 | static public Matrix4 createRotationX(float degrees) |
||
| 679 | { |
||
| 680 | Matrix4 matrix = new Matrix4(); |
||
| 681 | matrix.setRotationX(degrees); |
||
| 682 | return matrix; |
||
| 683 | } |
||
| 684 | |||
| 685 | public void setRotationX(float degrees) |
||
| 686 | { |
||
| 687 | float degreesrad = MathUtil.degToRad(degrees); |
||
| 688 | float sinvalue = (float)Math.sin(degreesrad); |
||
| 689 | float cosvalue = (float)Math.cos(degreesrad); |
||
| 690 | |||
| 691 | this.identity(); |
||
| 692 | this.values[M22] = cosvalue; |
||
| 693 | this.values[M32] = -sinvalue; |
||
| 694 | this.values[M23] = sinvalue; |
||
| 695 | this.values[M33] = cosvalue; |
||
| 696 | } |
||
| 697 | |||
| 698 | static public Matrix4 createRotationY(float degrees) |
||
| 699 | { |
||
| 700 | Matrix4 matrix = new Matrix4(); |
||
| 701 | matrix.setRotationY(degrees); |
||
| 702 | return matrix; |
||
| 703 | } |
||
| 704 | |||
| 705 | public void setRotationY(float degrees) |
||
| 706 | { |
||
| 707 | float degreesrad = MathUtil.degToRad(degrees); |
||
| 708 | float sinvalue = (float)Math.sin(degreesrad); |
||
| 709 | float cosvalue = (float)Math.cos(degreesrad); |
||
| 710 | |||
| 711 | this.identity(); |
||
| 712 | this.values[M11] = cosvalue; |
||
| 713 | this.values[M31] = sinvalue; |
||
| 714 | this.values[M13] = -sinvalue; |
||
| 715 | this.values[M33] = cosvalue; |
||
| 716 | } |
||
| 717 | |||
| 718 | static public Matrix4 createRotationZ(float degrees) |
||
| 719 | { |
||
| 720 | Matrix4 matrix = new Matrix4(); |
||
| 721 | matrix.setRotationZ(degrees); |
||
| 722 | return matrix; |
||
| 723 | } |
||
| 724 | |||
| 725 | public void setRotationZ(float degrees) |
||
| 726 | { |
||
| 727 | float degreesrad = MathUtil.degToRad(degrees); |
||
| 728 | float sinvalue = (float)Math.sin(degreesrad); |
||
| 729 | float cosvalue = (float)Math.cos(degreesrad); |
||
| 730 | |||
| 731 | this.identity(); |
||
| 732 | this.values[M11] = cosvalue; |
||
| 733 | this.values[M21] = -sinvalue; |
||
| 734 | this.values[M12] = sinvalue; |
||
| 735 | this.values[M22] = cosvalue; |
||
| 736 | } |
||
| 737 | |||
| 738 | static public Matrix4 createRotation(Vector3 axis, float degrees) |
||
| 739 | { |
||
| 740 | Matrix4 matrix = new Matrix4(); |
||
| 741 | matrix.setRotation(axis, degrees); |
||
| 742 | return matrix; |
||
| 743 | } |
||
| 744 | |||
| 745 | public void setRotation(Vector3 axis, float degrees) |
||
| 746 | { |
||
| 747 | float radangle = MathUtil.degToRad(degrees); |
||
| 748 | float radcos = (float)Math.cos(radangle); |
||
| 749 | float radsin = (float)Math.sin(radangle); |
||
| 750 | |||
| 751 | this.identity(); |
||
| 752 | this.values[M11] = radcos + axis.x * axis.x * (1 - radcos); |
||
| 753 | this.values[M21] = axis.z * radsin + axis.y * axis.x * (1 - radcos); |
||
| 754 | this.values[M31] = -axis.y * radsin + axis.z * axis.x * (1 - radcos); |
||
| 755 | this.values[M12] = -axis.z * radsin + axis.x * axis.y * (1 - radcos); |
||
| 756 | this.values[M22] = radcos + axis.y * axis.y * (1 - radcos); |
||
| 757 | this.values[M32] = axis.x * radsin + axis.z * axis.y * (1 - radcos); |
||
| 758 | this.values[M13] = axis.y * radsin + axis.x * axis.z * (1 - radcos); |
||
| 759 | this.values[M23] = -axis.x * radsin + axis.y * axis.z * (1 - radcos); |
||
| 760 | this.values[M33] = radcos + axis.z * axis.z * (1 - radcos); |
||
| 761 | this.values[M44] = 1.0f; |
||
| 762 | } |
||
| 763 | |||
| 764 | static public Matrix4 createTranslation(float x, float y, float z) |
||
| 765 | { |
||
| 766 | Matrix4 result = new Matrix4(); |
||
| 767 | result.setTranslation(x, y, z); |
||
| 768 | return result; |
||
| 769 | } |
||
| 770 | |||
| 771 | static public Matrix4 createTranslation(Vector3 translate) |
||
| 772 | { |
||
| 773 | return createTranslation(translate.x, translate.y, translate.z); |
||
| 774 | } |
||
| 775 | |||
| 776 | public void setTranslation(float x, float y, float z) |
||
| 777 | { |
||
| 778 | /*result.m11 = 1.0f; result.m21 = 0.0f; result.m31 = 0.0f; result.m41 = x; |
||
| 779 | result.m12 = 0.0f; result.m22 = 1.0f; result.m32 = 0.0f; result.m42 = y; |
||
| 780 | result.m13 = 0.0f; result.m23 = 0.0f; result.m33 = 1.0f; result.m43 = z; |
||
| 781 | result.m14 = 0.0f; result.m24 = 0.0f; result.m34 = 0.0f; result.m44 = 1.0f;*/ |
||
| 782 | this.values[M11] = 1.0f; this.values[M21] = 0.0f; this.values[M31] = 0.0f; this.values[M41] = 0.0f; |
||
| 783 | this.values[M12] = 0.0f; this.values[M22] = 1.0f; this.values[M32] = 0.0f; this.values[M42] = 0.0f; |
||
| 784 | this.values[M13] = 0.0f; this.values[M23] = 0.0f; this.values[M33] = 1.0f; this.values[M43] = 0.0f; |
||
| 785 | this.values[M14] = x; this.values[M24] = y; this.values[M34] = z; this.values[M44] = 1.0f; |
||
| 921 | chris | 786 | /*this.values[M11] = 1.0f; this.values[M21] = 0.0f; this.values[M31] = 0.0f; this.values[M41] = x; |
| 787 | this.values[M12] = 0.0f; this.values[M22] = 1.0f; this.values[M32] = 0.0f; this.values[M42] = y; |
||
| 788 | this.values[M13] = 0.0f; this.values[M23] = 0.0f; this.values[M33] = 1.0f; this.values[M43] = z; |
||
| 789 | this.values[M14] = 0; this.values[M24] = 0; this.values[M34] = 0; this.values[M44] = 1.0f;*/ |
||
| 835 | chris | 790 | } |
| 791 | |||
| 792 | public void setTranslation(Vector3 translate) |
||
| 793 | { |
||
| 794 | setTranslation(translate.x, translate.y, translate.z); |
||
| 795 | } |
||
| 796 | |||
| 797 | static public Matrix4 createFromVectors(Vector3 forward, Vector3 up, Vector3 right) |
||
| 798 | { |
||
| 799 | forward.normalize(); |
||
| 800 | up.normalize(); |
||
| 801 | right.normalize(); |
||
| 802 | |||
| 803 | Matrix4 result = new Matrix4(); |
||
| 804 | result.setFromVectors(forward, up, right); |
||
| 805 | return result; |
||
| 806 | } |
||
| 807 | |||
| 808 | public void setFromVectors(Vector3 forward, Vector3 up, Vector3 right) |
||
| 809 | { |
||
| 810 | forward.normalize(); |
||
| 811 | up.normalize(); |
||
| 812 | right.normalize(); |
||
| 813 | |||
| 814 | identity(); |
||
| 815 | |||
| 816 | this.values[M11] = right.x; |
||
| 817 | this.values[M12] = right.y; |
||
| 818 | this.values[M13] = right.z; |
||
| 819 | this.values[M21] = up.x; |
||
| 820 | this.values[M22] = up.y; |
||
| 821 | this.values[M23] = up.z; |
||
| 822 | this.values[M31] = -forward.x; |
||
| 823 | this.values[M32] = -forward.y; |
||
| 824 | this.values[M33] = -forward.z; |
||
| 825 | this.values[M44] = 1.0f; |
||
| 826 | } |
||
| 827 | |||
| 828 | static public Matrix4 createPerspective(float fovDegreesY, float aspect, float zNear, float zFar) |
||
| 829 | { |
||
| 830 | Matrix4 result = new Matrix4(); |
||
| 831 | result.setPerspective(fovDegreesY, aspect, zNear, zFar); |
||
| 832 | return result; |
||
| 833 | } |
||
| 834 | |||
| 835 | public void setPerspective(float fovDegreesY, float aspect, float zNear, float zFar) |
||
| 836 | { |
||
| 837 | float f = 1.0f / (float) Math.tan(fovDegreesY * (Math.PI / 360.0)); |
||
| 838 | float rangeReciprocal = 1.0f / (zNear - zFar); |
||
| 839 | |||
| 840 | this.values[M11] = f / aspect; |
||
| 841 | this.values[M21] = 0.0f; |
||
| 842 | this.values[M31] = 0.0f; |
||
| 843 | this.values[M41] = 0.0f; |
||
| 844 | |||
| 845 | this.values[M12] = 0.0f; |
||
| 846 | this.values[M22] = f; |
||
| 847 | this.values[M32] = 0.0f; |
||
| 848 | this.values[M42] = 0.0f; |
||
| 849 | |||
| 850 | this.values[M13] = 0.0f; |
||
| 851 | this.values[M23] = 0.0f; |
||
| 852 | this.values[M33] = (zFar + zNear) * rangeReciprocal; |
||
| 853 | this.values[M43] = -1.0f; |
||
| 854 | |||
| 855 | this.values[M14] = 0.0f; |
||
| 856 | this.values[M24] = 0.0f; |
||
| 857 | this.values[M34] = 2.0f * zFar * zNear * rangeReciprocal; |
||
| 858 | this.values[M44] = 0.0f; |
||
| 859 | } |
||
| 860 | |||
| 861 | static public Matrix4 createFrustum(float left, float right, float bottom, float top, float near, float far) |
||
| 862 | { |
||
| 863 | Matrix4 matrix = new Matrix4(); |
||
| 864 | matrix.setFrustum(left, right, bottom, top, near, far); |
||
| 865 | return matrix; |
||
| 866 | } |
||
| 867 | |||
| 868 | public void setFrustum(float left, float right, float bottom, float top, float near, float far) |
||
| 869 | { |
||
| 870 | if (left == right) |
||
| 871 | { |
||
| 872 | throw new IllegalArgumentException("left == right"); |
||
| 873 | } |
||
| 874 | if (top == bottom) |
||
| 875 | { |
||
| 876 | throw new IllegalArgumentException("top == bottom"); |
||
| 877 | } |
||
| 878 | if (near == far) |
||
| 879 | { |
||
| 880 | throw new IllegalArgumentException("near == far"); |
||
| 881 | } |
||
| 882 | if (near <= 0.0f) |
||
| 883 | { |
||
| 884 | throw new IllegalArgumentException("near <= 0.0f"); |
||
| 885 | } |
||
| 886 | if (far <= 0.0f) |
||
| 887 | { |
||
| 888 | throw new IllegalArgumentException("far <= 0.0f"); |
||
| 889 | } |
||
| 890 | |||
| 891 | final float r_width = 1.0f / (right - left); |
||
| 892 | final float r_height = 1.0f / (top - bottom); |
||
| 893 | final float r_depth = 1.0f / (near - far); |
||
| 894 | final float x = 2.0f * (near * r_width); |
||
| 895 | final float y = 2.0f * (near * r_height); |
||
| 896 | final float A = 2.0f * ((right + left) * r_width); |
||
| 897 | final float B = (top + bottom) * r_height; |
||
| 898 | final float C = (far + near) * r_depth; |
||
| 899 | final float D = 2.0f * (far * near * r_depth); |
||
| 900 | |||
| 901 | this.values[M11] = x; |
||
| 902 | this.values[M21] = 0.0f; |
||
| 903 | this.values[M31] = 0.0f; |
||
| 904 | this.values[M41] = 0.0f; |
||
| 905 | |||
| 906 | this.values[M12] = 0.0f; |
||
| 907 | this.values[M22] = y; |
||
| 908 | this.values[M32] = 0.0f; |
||
| 909 | this.values[M42] = 0.0f; |
||
| 910 | |||
| 911 | this.values[M13] = A; |
||
| 912 | this.values[M23] = B; |
||
| 913 | this.values[M33] = C; |
||
| 914 | this.values[M43] = -1.0f; |
||
| 915 | |||
| 916 | this.values[M14] = 0.0f; |
||
| 917 | this.values[M24] = 0.0f; |
||
| 918 | this.values[M34] = D; |
||
| 919 | this.values[M44] = 0.0f; |
||
| 920 | } |
||
| 921 | |||
| 922 | static public Matrix4 createOrtho(float left, float right, float bottom, float top, float near, float far) |
||
| 923 | { |
||
| 924 | Matrix4 matrix = new Matrix4(); |
||
| 925 | matrix.setOrtho(left, right, bottom, top, near, far); |
||
| 926 | return matrix; |
||
| 927 | } |
||
| 928 | |||
| 929 | public void setOrtho(float left, float right, float bottom, float top, float near, float far) |
||
| 930 | { |
||
| 931 | if (left == right) |
||
| 932 | throw new IllegalArgumentException("left and right must not be identical!"); |
||
| 933 | |||
| 934 | if (bottom == top) |
||
| 935 | throw new IllegalArgumentException("bottom and top must not be identical!"); |
||
| 936 | |||
| 937 | if (near == far) |
||
| 938 | throw new IllegalArgumentException("near and far must not be identical!"); |
||
| 939 | |||
| 940 | final float r_width = 1.0f / (right - left); |
||
| 941 | final float r_height = 1.0f / (top - bottom); |
||
| 942 | final float r_depth = 1.0f / (far - near); |
||
| 943 | final float x = 2.0f * (r_width); |
||
| 944 | final float y = 2.0f * (r_height); |
||
| 945 | final float z = -2.0f * (r_depth); |
||
| 946 | final float tx = -(right + left) * r_width; |
||
| 947 | final float ty = -(top + bottom) * r_height; |
||
| 948 | final float tz = -(far + near) * r_depth; |
||
| 949 | |||
| 950 | |||
| 951 | /* m[mOffset + 0] = x; |
||
| 952 | m[mOffset + 5] = y; |
||
| 953 | m[mOffset +10] = z; |
||
| 954 | m[mOffset +12] = tx; |
||
| 955 | m[mOffset +13] = ty; |
||
| 956 | m[mOffset +14] = tz; |
||
| 957 | m[mOffset +15] = 1.0f; |
||
| 958 | m[mOffset + 1] = 0.0f; |
||
| 959 | m[mOffset + 2] = 0.0f; |
||
| 960 | m[mOffset + 3] = 0.0f; |
||
| 961 | m[mOffset + 4] = 0.0f; |
||
| 962 | m[mOffset + 6] = 0.0f; |
||
| 963 | m[mOffset + 7] = 0.0f; |
||
| 964 | m[mOffset + 8] = 0.0f; |
||
| 965 | m[mOffset + 9] = 0.0f; |
||
| 966 | m[mOffset + 11] = 0.0f;*/ |
||
| 967 | |||
| 968 | this.values[M11] = x; this.values[M21] = 0.0f; this.values[M31] = 0.0f; this.values[M41] = 0.0f; |
||
| 969 | this.values[M12] = 0.0f; this.values[M22] = y; this.values[M32] = 0.0f; this.values[M42] = 0.0f; |
||
| 970 | this.values[M13] = 0.0f; this.values[M23] = 0.0f; this.values[M33] = z; this.values[M43] = 0.0f; |
||
| 971 | this.values[M14] = tx; this.values[M24] = ty; this.values[M34] = tz; this.values[M44] = 1.0f; |
||
| 972 | } |
||
| 973 | /* m[0] = m11; m[1] = m21; m[2] = m31; m[3] = m41; |
||
| 974 | m[4] = m12; m[5] = m22; m[6] = m32; m[7] = m42; |
||
| 975 | m[8] = m13; m[9] = m23; m[10] = m33; m[11] = m43; |
||
| 976 | m[12] = m14; m[13] = m24; m[14] = m34; m[15] = m44;*/ |
||
| 977 | |||
| 978 | static public Matrix4 createLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) |
||
| 979 | { |
||
| 980 | Matrix4 matrix = new Matrix4(); |
||
| 981 | matrix.setLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ); |
||
| 982 | return matrix; |
||
| 983 | } |
||
| 984 | |||
| 985 | public void setLookAt(float eyeX, float eyeY, float eyeZ, float centerX, float centerY, float centerZ, float upX, float upY, float upZ) |
||
| 986 | { |
||
| 987 | float fx = centerX - eyeX; |
||
| 988 | float fy = centerY - eyeY; |
||
| 989 | float fz = centerZ - eyeZ; |
||
| 990 | |||
| 991 | // Normalize f |
||
| 992 | float rlf = 1.0f / Vector3.length(fx, fy, fz); |
||
| 993 | fx *= rlf; |
||
| 994 | fy *= rlf; |
||
| 995 | fz *= rlf; |
||
| 996 | |||
| 997 | // compute s = f x up (x means "cross product") |
||
| 998 | float sx = fy * upZ - fz * upY; |
||
| 999 | float sy = fz * upX - fx * upZ; |
||
| 1000 | float sz = fx * upY - fy * upX; |
||
| 1001 | |||
| 1002 | // and normalize s |
||
| 1003 | float rls = 1.0f / Vector3.length(sx, sy, sz); |
||
| 1004 | sx *= rls; |
||
| 1005 | sy *= rls; |
||
| 1006 | sz *= rls; |
||
| 1007 | |||
| 1008 | // compute u = s x f |
||
| 1009 | float ux = sy * fz - sz * fy; |
||
| 1010 | float uy = sz * fx - sx * fz; |
||
| 1011 | float uz = sx * fy - sy * fx; |
||
| 1012 | |||
| 1013 | this.values[M11] = sx; |
||
| 1014 | this.values[M21] = ux; |
||
| 1015 | this.values[M31] = -fx; |
||
| 1016 | this.values[M41] = 0.0f; |
||
| 1017 | |||
| 1018 | this.values[M12] = sy; |
||
| 1019 | this.values[M22] = uy; |
||
| 1020 | this.values[M32] = -fy; |
||
| 1021 | this.values[M42] = 0.0f; |
||
| 1022 | |||
| 1023 | this.values[M13] = sz; |
||
| 1024 | this.values[M23] = uz; |
||
| 1025 | this.values[M33] = -fz; |
||
| 1026 | this.values[M43] = 0.0f; |
||
| 1027 | |||
| 1028 | this.values[M14] = 0.0f; |
||
| 1029 | this.values[M24] = 0.0f; |
||
| 1030 | this.values[M34] = 0.0f; |
||
| 1031 | this.values[M44] = 1.0f; |
||
| 1032 | |||
| 1033 | this.values[M14] = this.values[M11] * -eyeX + this.values[M12] * -eyeY + this.values[M13] * -eyeZ + this.values[M14]; |
||
| 1034 | this.values[M24] = this.values[M21] * -eyeX + this.values[M22] * -eyeY + this.values[M23] * -eyeZ + this.values[M24]; |
||
| 1035 | this.values[M34] = this.values[M31] * -eyeX + this.values[M32] * -eyeY + this.values[M33] * -eyeZ + this.values[M34]; |
||
| 1036 | this.values[M44] = this.values[M41] * -eyeX + this.values[M42] * -eyeY + this.values[M43] * -eyeZ + this.values[M44]; |
||
| 1037 | } |
||
| 1038 | |||
| 1039 | public Vector3 transform(Vector3 vector) |
||
| 1040 | { |
||
| 921 | chris | 1041 | return new Vector3( |
| 1042 | values[M11] * vector.x + values[M12] * vector.y + values[M13] * vector.z, |
||
| 1043 | values[M21] * vector.x + values[M22] * vector.y + values[M32] * vector.z, |
||
| 1044 | values[M31] * vector.x + values[M32] * vector.y + values[M33] * vector.z); |
||
| 835 | chris | 1045 | |
| 921 | chris | 1046 | /*return new Vector3( |
| 835 | chris | 1047 | values[M11] * vector.x + values[M21] * vector.y + values[M31] * vector.z + values[M41], |
| 1048 | values[M12] * vector.x + values[M22] * vector.y + values[M32] * vector.z + values[M42], |
||
| 921 | chris | 1049 | values[M13] * vector.x + values[M23] * vector.y + values[M33] * vector.z + values[M43]);*/ |
| 835 | chris | 1050 | } |
| 1051 | |||
| 1052 | public Vector4 transform(Vector4 vector) |
||
| 1053 | { |
||
| 1054 | return new Vector4( |
||
| 921 | chris | 1055 | values[M11] * vector.x + values[M12] * vector.y + values[M13] * vector.z + values[M14] * vector.w, |
| 1056 | values[M21] * vector.x + values[M22] * vector.y + values[M32] * vector.z + values[M24] * vector.w, |
||
| 1057 | values[M31] * vector.x + values[M32] * vector.y + values[M33] * vector.z + values[M34] * vector.w, |
||
| 1058 | values[M41] * vector.x + values[M42] * vector.y + values[M43] * vector.z + values[M44] * vector.w); |
||
| 1059 | |||
| 1060 | /* return new Vector4( |
||
| 835 | chris | 1061 | values[M11] * vector.x + values[M21] * vector.y + values[M31] * vector.z + values[M41] * vector.w, |
| 1062 | values[M12] * vector.x + values[M22] * vector.y + values[M32] * vector.z + values[M42] * vector.w, |
||
| 1063 | values[M13] * vector.x + values[M23] * vector.y + values[M33] * vector.z + values[M43] * vector.w, |
||
| 921 | chris | 1064 | values[M14] * vector.x + values[M24] * vector.y + values[M34] * vector.z + values[M44] * vector.w);*/ |
| 835 | chris | 1065 | } |
| 1066 | |||
| 921 | chris | 1067 | public Vector4 homogenousTransform(Vector4 vector) |
| 1068 | { |
||
| 1069 | Vector4 result = transform(vector); |
||
| 1070 | result.x /= result.w; |
||
| 1071 | result.y /= result.w; |
||
| 1072 | result.z /= result.w; |
||
| 1073 | result.w /= result.w; |
||
| 1074 | return result; |
||
| 1075 | } |
||
| 1076 | |||
| 835 | chris | 1077 | static public void interpolate(Matrix4 result, Matrix4 a, Matrix4 b, float ratio) |
| 1078 | { |
||
| 1079 | result.values[M11] = a.values[M11] + (b.values[M11] - a.values[M11]) * ratio; |
||
| 1080 | result.values[M21] = a.values[M21] + (b.values[M21] - a.values[M21]) * ratio; |
||
| 1081 | result.values[M31] = a.values[M31] + (b.values[M31] - a.values[M31]) * ratio; |
||
| 1082 | result.values[M41] = a.values[M41] + (b.values[M41] - a.values[M41]) * ratio; |
||
| 1083 | result.values[M12] = a.values[M12] + (b.values[M12] - a.values[M12]) * ratio; |
||
| 1084 | result.values[M22] = a.values[M22] + (b.values[M22] - a.values[M22]) * ratio; |
||
| 1085 | result.values[M32] = a.values[M32] + (b.values[M32] - a.values[M32]) * ratio; |
||
| 1086 | result.values[M42] = a.values[M42] + (b.values[M42] - a.values[M42]) * ratio; |
||
| 1087 | result.values[M13] = a.values[M13] + (b.values[M13] - a.values[M13]) * ratio; |
||
| 1088 | result.values[M23] = a.values[M23] + (b.values[M23] - a.values[M23]) * ratio; |
||
| 1089 | result.values[M33] = a.values[M33] + (b.values[M33] - a.values[M33]) * ratio; |
||
| 1090 | result.values[M43] = a.values[M43] + (b.values[M43] - a.values[M43]) * ratio; |
||
| 1091 | result.values[M14] = a.values[M14] + (b.values[M14] - a.values[M14]) * ratio; |
||
| 1092 | result.values[M24] = a.values[M24] + (b.values[M24] - a.values[M24]) * ratio; |
||
| 1093 | result.values[M34] = a.values[M34] + (b.values[M34] - a.values[M34]) * ratio; |
||
| 1094 | result.values[M44] = a.values[M44] + (b.values[M44] - a.values[M44]) * ratio; |
||
| 1095 | } |
||
| 1096 | |||
| 1097 | static public Matrix4 interpolate(Matrix4 a, Matrix4 b, float ratio) |
||
| 1098 | { |
||
| 1099 | Matrix4 result = createIdentity(); |
||
| 1100 | interpolate(result, a, b, ratio); |
||
| 1101 | return result; |
||
| 1102 | } |
||
| 1103 | |||
| 1104 | public Vector3 getForwardVector() |
||
| 1105 | { |
||
| 1106 | Vector3 forward = new Vector3(-values[M31], -values[M32], -values[M33]); |
||
| 1107 | forward.normalize(); |
||
| 1108 | return forward; |
||
| 1109 | } |
||
| 1110 | |||
| 1111 | public Vector3 getUpVector() |
||
| 1112 | { |
||
| 1113 | Vector3 up = new Vector3(values[M21], values[M22], values[M23]); |
||
| 1114 | up.normalize(); |
||
| 1115 | return up; |
||
| 1116 | } |
||
| 1117 | |||
| 1118 | public Vector3 getRightVector() |
||
| 1119 | { |
||
| 1120 | Vector3 right = new Vector3(values[M11], values[M12], values[M13]); |
||
| 1121 | right.normalize(); |
||
| 1122 | return right; |
||
| 1123 | } |
||
| 1124 | |||
| 1125 | public float[] toGLMatrix() |
||
| 1126 | { |
||
| 1127 | return values; |
||
| 1128 | /*float[] m = new float[16]; |
||
| 1129 | |||
| 1130 | m[0] = m11; m[1] = m21; m[2] = m31; m[3] = m41; |
||
| 1131 | m[4] = m12; m[5] = m22; m[6] = m32; m[7] = m42; |
||
| 1132 | m[8] = m13; m[9] = m23; m[10] = m33; m[11] = m43; |
||
| 1133 | m[12] = m14; m[13] = m24; m[14] = m34; m[15] = m44; |
||
| 1134 | |||
| 1135 | return m;*/ |
||
| 1136 | } |
||
| 1137 | |||
| 1138 | public void fromGLMatrix(float[] m) |
||
| 1139 | { |
||
| 1140 | values = m; |
||
| 1141 | /*m11 = m[0]; m21 = m[1]; m31 = m[2]; m41 = m[3]; |
||
| 1142 | m12 = m[4]; m22 = m[5]; m32 = m[6]; m42 = m[7]; |
||
| 1143 | m13 = m[8]; m23 = m[9]; m33 = m[10]; m43 = m[11]; |
||
| 1144 | m14 = m[12]; m24 = m[13]; m34 = m[14]; m44 = m[15];*/ |
||
| 1145 | } |
||
| 1146 | |||
| 1147 | public FloatBuffer toFloatBuffer() |
||
| 1148 | { |
||
| 1149 | FloatBuffer buffer = BufferUtils.newFloatBuffer(16); |
||
| 1150 | |||
| 1151 | BufferUtils.copy(values, buffer, values.length, 0); |
||
| 1152 | |||
| 1153 | /* buffer.put(m11); buffer.put(m21); buffer.put(m31); buffer.put(m41); |
||
| 1154 | buffer.put(m12); buffer.put(m22); buffer.put(m32); buffer.put(m42); |
||
| 1155 | buffer.put(m13); buffer.put(m23); buffer.put(m33); buffer.put(m43); |
||
| 1156 | buffer.put(m14); buffer.put(m24); buffer.put(m34); buffer.put(m44);*/ |
||
| 1157 | |||
| 1158 | return buffer; |
||
| 1159 | } |
||
| 1160 | } |
||
| 1161 | |||
| 1162 |