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