| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "matrix.h" |
| |
| #include <string.h> |
| |
| #include "common/alog.h" |
| #include "vector.h" |
| |
| namespace emugl { |
| |
| Matrix::Matrix(float row0col0, float row0col1, float row0col2, float row0col3, |
| float row1col0, float row1col1, float row1col2, float row1col3, |
| float row2col0, float row2col1, float row2col2, float row2col3, |
| float row3col0, float row3col1, float row3col2, float row3col3) { |
| entries_[0][0] = row0col0; |
| entries_[1][0] = row0col1; |
| entries_[2][0] = row0col2; |
| entries_[3][0] = row0col3; |
| entries_[0][1] = row1col0; |
| entries_[1][1] = row1col1; |
| entries_[2][1] = row1col2; |
| entries_[3][1] = row1col3; |
| entries_[0][2] = row2col0; |
| entries_[1][2] = row2col1; |
| entries_[2][2] = row2col2; |
| entries_[3][2] = row2col3; |
| entries_[0][3] = row3col0; |
| entries_[1][3] = row3col1; |
| entries_[2][3] = row3col2; |
| entries_[3][3] = row3col3; |
| } |
| |
| void Matrix::AssignIdentity() { |
| entries_[0][0] = 1; |
| entries_[0][1] = 0; |
| entries_[0][2] = 0; |
| entries_[0][3] = 0; |
| entries_[1][0] = 0; |
| entries_[1][1] = 1; |
| entries_[1][2] = 0; |
| entries_[1][3] = 0; |
| entries_[2][0] = 0; |
| entries_[2][1] = 0; |
| entries_[2][2] = 1; |
| entries_[2][3] = 0; |
| entries_[3][0] = 0; |
| entries_[3][1] = 0; |
| entries_[3][2] = 0; |
| entries_[3][3] = 1; |
| } |
| |
| void Matrix::Transpose() { |
| for (int i = 0; i < kN; ++i) { |
| for (int j = i + 1; j < kN; ++j) { |
| const float temp = Get(i, j); |
| Set(i, j, Get(j, i)); |
| Set(j, i, temp); |
| } |
| } |
| } |
| |
| void Matrix::RescaleNormal() { |
| for (int i = 0; i < 3; ++i) { |
| Vector v(Get(i, 0), Get(i, 1), Get(i, 2), 0.f); |
| v.Normalize(); |
| Set(i, 0, v.Get(0)); |
| Set(i, 1, v.Get(1)); |
| Set(i, 2, v.Get(2)); |
| } |
| } |
| |
| void Matrix::Inverse() { |
| const float a00 = entries_[0][0]; |
| const float a01 = entries_[0][1]; |
| const float a02 = entries_[0][2]; |
| const float a03 = entries_[0][3]; |
| const float a10 = entries_[1][0]; |
| const float a11 = entries_[1][1]; |
| const float a12 = entries_[1][2]; |
| const float a13 = entries_[1][3]; |
| const float a20 = entries_[2][0]; |
| const float a21 = entries_[2][1]; |
| const float a22 = entries_[2][2]; |
| const float a23 = entries_[2][3]; |
| const float a30 = entries_[3][0]; |
| const float a31 = entries_[3][1]; |
| const float a32 = entries_[3][2]; |
| const float a33 = entries_[3][3]; |
| |
| float b00 = a00 * a11 - a01 * a10; |
| float b01 = a00 * a12 - a02 * a10; |
| float b02 = a00 * a13 - a03 * a10; |
| float b03 = a01 * a12 - a02 * a11; |
| float b04 = a01 * a13 - a03 * a11; |
| float b05 = a02 * a13 - a03 * a12; |
| float b06 = a20 * a31 - a21 * a30; |
| float b07 = a20 * a32 - a22 * a30; |
| float b08 = a20 * a33 - a23 * a30; |
| float b09 = a21 * a32 - a22 * a31; |
| float b10 = a21 * a33 - a23 * a31; |
| float b11 = a22 * a33 - a23 * a32; |
| |
| // Calculate the determinant |
| const float det = |
| b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; |
| LOG_ALWAYS_FATAL_IF(det == 0); |
| |
| const float invdet = 1.0 / det; |
| b00 *= invdet; |
| b01 *= invdet; |
| b02 *= invdet; |
| b03 *= invdet; |
| b04 *= invdet; |
| b05 *= invdet; |
| b06 *= invdet; |
| b07 *= invdet; |
| b08 *= invdet; |
| b09 *= invdet; |
| b10 *= invdet; |
| b11 *= invdet; |
| |
| entries_[0][0] = a11 * b11 - a12 * b10 + a13 * b09; |
| entries_[0][1] = a02 * b10 - a01 * b11 - a03 * b09; |
| entries_[0][2] = a31 * b05 - a32 * b04 + a33 * b03; |
| entries_[0][3] = a22 * b04 - a21 * b05 - a23 * b03; |
| entries_[1][0] = a12 * b08 - a10 * b11 - a13 * b07; |
| entries_[1][1] = a00 * b11 - a02 * b08 + a03 * b07; |
| entries_[1][2] = a32 * b02 - a30 * b05 - a33 * b01; |
| entries_[1][3] = a20 * b05 - a22 * b02 + a23 * b01; |
| entries_[2][0] = a10 * b10 - a11 * b08 + a13 * b06; |
| entries_[2][1] = a01 * b08 - a00 * b10 - a03 * b06; |
| entries_[2][2] = a30 * b04 - a31 * b02 + a33 * b00; |
| entries_[2][3] = a21 * b02 - a20 * b04 - a23 * b00; |
| entries_[3][0] = a11 * b07 - a10 * b09 - a12 * b06; |
| entries_[3][1] = a00 * b09 - a01 * b07 + a02 * b06; |
| entries_[3][2] = a31 * b01 - a30 * b03 - a32 * b00; |
| entries_[3][3] = a20 * b03 - a21 * b01 + a22 * b00; |
| } |
| |
| void Matrix::AssignMatrixMultiply(const Matrix& a, const Matrix& b) { |
| // If a or b is this matrix, we cannot store result in place, so have to use |
| // an extra matrix object. |
| const bool use_storage = (this == &a || this == &b); |
| Matrix storage(UNINITIALIZED_CONSTRUCTOR); |
| Matrix* result = use_storage ? &storage : this; |
| |
| for (int a_row = 0; a_row < kN; ++a_row) { |
| for (int b_col = 0; b_col < kN; ++b_col) { |
| float dp = 0.0f; |
| for (int k = 0; k < kN; ++k) { |
| dp += a.Get(a_row, k) * b.Get(k, b_col); |
| } |
| result->Set(a_row, b_col, dp); |
| } |
| } |
| |
| if (use_storage) { |
| *this = storage; |
| } |
| } |
| |
| float* Matrix::GetColumnMajorArray(float* entries, size_t count) const { |
| // It's safe to memcpy because entries are stored in column-major order. |
| memcpy(entries, entries_, count * sizeof(entries[0])); |
| return entries; |
| } |
| |
| void Matrix::SetColumnMajorArray(const float *entries) { |
| memcpy(entries_, entries, sizeof(entries[0]) * kEntries); |
| } |
| |
| Matrix Matrix::GeneratePerspective(float left, float right, |
| float bottom, float top, |
| float z_near, float z_far) { |
| LOG_ALWAYS_FATAL_IF(left == right); |
| LOG_ALWAYS_FATAL_IF(top == bottom); |
| LOG_ALWAYS_FATAL_IF(z_near == z_far); |
| |
| // See http://www.songho.ca/opengl/gl_projectionmatrix.html. |
| return Matrix((2.0f * z_near) / (right - left), |
| 0.0f, |
| (right + left) / (right - left), |
| 0.0f, |
| |
| 0.0f, |
| (2.0f * z_near) / (top - bottom), |
| (top + bottom) / (top - bottom), |
| 0.0f, |
| |
| 0.0f, |
| 0.0f, |
| -(z_far + z_near) / (z_far - z_near), |
| (-2.0f * z_far * z_near) / (z_far - z_near), |
| |
| 0.0f, |
| 0.0f, |
| -1.0f, |
| 0.0f); |
| } |
| |
| Matrix Matrix::GenerateOrthographic(float left, float right, |
| float bottom, float top, |
| float z_near, float z_far) { |
| LOG_ALWAYS_FATAL_IF(left == right); |
| LOG_ALWAYS_FATAL_IF(top == bottom); |
| LOG_ALWAYS_FATAL_IF(z_near == z_far); |
| |
| // See http://www.songho.ca/opengl/gl_projectionmatrix.html. |
| return Matrix(2.0f / (right - left), |
| 0.0f, |
| 0.0f, |
| -(right + left) / (right - left), |
| 0.0f, |
| 2.0f / (top - bottom), |
| 0.0f, |
| -(top + bottom) / (top - bottom), |
| 0.0f, |
| 0.0f, |
| -2.0f / (z_far - z_near), |
| -(z_far + z_near) / (z_far - z_near), |
| 0.0f, |
| 0.0f, |
| 0.0f, |
| 1.0f); |
| } |
| |
| Matrix Matrix::GenerateScale(const Vector& v) { |
| Matrix result; |
| for (int i = 0; i < kN; ++i) { |
| result.Set(i, i, v.Get(i)); |
| } |
| return result; |
| } |
| |
| Matrix Matrix::GenerateTranslation(const Vector& v) { |
| Matrix result; |
| for (int i = 0; i < kN; ++i) { |
| result.Set(i, 3, v.Get(i)); |
| } |
| return result; |
| } |
| |
| Matrix Matrix::GenerateRotationByDegrees(float degrees, |
| const Vector& v) { |
| Vector w = v; |
| w.Normalize(); |
| // See http://mathworld.wolfram.com/RodriguesRotationFormula.html or |
| // http://www.manpagez.com/man/3/glRotatef/ for formulas. |
| const float theta = degrees * kRadiansPerDegree; |
| const float sin_t = sin(theta); |
| const float cos_t = cos(theta); |
| const float x_cos_t = 1.0f - cos_t; |
| const float wx = w.Get(0); |
| const float wy = w.Get(1); |
| const float wz = w.Get(2); |
| |
| return Matrix(cos_t + wx * wx * x_cos_t, |
| wx * wy * x_cos_t - wz * sin_t, |
| wy * sin_t + wx * wz * x_cos_t, |
| 0.0f, |
| wz * sin_t + wx * wy * x_cos_t, |
| cos_t + wy * wy * x_cos_t, |
| -wx * sin_t + wy * wz * x_cos_t, |
| 0.0f, |
| -wy * sin_t + wx * wz * x_cos_t, |
| wx * sin_t + wy * wz * x_cos_t, |
| cos_t + wz * wz * x_cos_t, |
| 0.0f, |
| 0.0f, |
| 0.0f, |
| 0.0f, |
| 1.0f); |
| } |
| |
| } // namespace emugl |
