Remove unnecessary UI element math.

chrome/browser/android/vr_shell/vr_math.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_math.h"
 
 #include <cmath>
 
 namespace vr_shell {
 
@@ skipping 28 matching lines @@
       for (int j = 0; j < 4; ++j) {
         tmat.m[i][j] = mat.m[i][j];
       }
     }
   }
   tmat.m[0][3] += x;
   tmat.m[1][3] += y;
   tmat.m[2][3] += z;
 }
 
-// Right multiply a translation matrix.
-void TranslateMRight(gvr::Mat4f& tmat,

[tiborg, 2017/03/06 17:51:43]

Should we delete all these matrix operations? Maybe they are useful in the
future.

[cjgrant, 2017/03/06 18:41:02]

We should add the methods only when we need them. I'm pretty sure that thinking
applies across Chromium/Google3.

-                     gvr::Mat4f& mat,
-                     float x,
-                     float y,
-                     float z) {
-  if (&tmat != &mat) {
-    for (int i = 0; i < 4; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        tmat.m[i][j] = mat.m[i][j];
-      }
-    }
-  }
-
-  for (int i = 0; i < 4; i++) {
-    tmat.m[i][3] =
-        mat.m[i][0] * x + mat.m[i][1] * y + mat.m[i][2] * z + mat.m[i][3];
-  }
-}
-
 // Left multiply a scale matrix.
 void ScaleM(gvr::Mat4f& tmat,
             const gvr::Mat4f& mat,
             float x,
             float y,
             float z) {
   if (&tmat != &mat) {
     for (int i = 0; i < 4; ++i) {
       for (int j = 0; j < 3; ++j) {
         tmat.m[i][j] = mat.m[i][j];
       }
     }
   }
   // Multiply all rows including translation components.
   for (int j = 0; j < 4; ++j) {
     tmat.m[0][j] *= x;
     tmat.m[1][j] *= y;
     tmat.m[2][j] *= z;
   }
 }
 
-// Right multiply a scale matrix.
-void ScaleMRight(gvr::Mat4f& tmat,
-                 const gvr::Mat4f& mat,
-                 float x,
-                 float y,
-                 float z) {
-  if (&tmat != &mat) {
-    for (int i = 0; i < 4; ++i) {
-      for (int j = 0; j < 3; ++j) {
-        tmat.m[i][j] = mat.m[i][j];
-      }
-    }
-  }
-  // Multiply columns, don't change translation components.
-  for (int i = 0; i < 3; ++i) {
-    tmat.m[i][0] *= x;
-    tmat.m[i][1] *= y;
-    tmat.m[i][2] *= z;
-  }
-}
-
-gvr::Mat4f MatrixTranspose(const gvr::Mat4f& mat) {
-  gvr::Mat4f result;
-  for (int i = 0; i < 4; ++i) {
-    for (int k = 0; k < 4; ++k) {
-      result.m[i][k] = mat.m[k][i];
-    }
-  }
-  return result;
-}
-
-std::array<float, 4> MatrixVectorMul(const gvr::Mat4f& matrix,
-                                     const std::array<float, 4>& vec) {
-  std::array<float, 4> result;
-  for (int i = 0; i < 4; ++i) {
-    result[i] = 0;
-    for (int k = 0; k < 4; ++k) {
-      result[i] += matrix.m[i][k] * vec[k];
-    }
-  }
-  return result;
-}
-
-std::array<float, 3> MatrixVectorMul(const gvr::Mat4f& matrix,
-                                     const std::array<float, 3>& vec) {
-  // Use homogeneous coordinates for the multiplication.
-  std::array<float, 4> vec_h = {{vec[0], vec[1], vec[2], 1.0f}};
-  std::array<float, 4> result;
-  for (int i = 0; i < 4; ++i) {
-    result[i] = 0;
-    for (int k = 0; k < 4; ++k) {
-      result[i] += matrix.m[i][k] * vec_h[k];
-    }
-  }
-  // Convert back from homogeneous coordinates.
-  float rw = 1.0f / result[3];
-  return {{rw * result[0], rw * result[1], rw * result[2]}};
-}
-
 gvr::Vec3f MatrixVectorMul(const gvr::Mat4f& m, const gvr::Vec3f& v) {
   gvr::Vec3f res;
   res.x = m.m[0][0] * v.x + m.m[0][1] * v.y + m.m[0][2] * v.z + m.m[0][3];
   res.y = m.m[1][0] * v.x + m.m[1][1] * v.y + m.m[1][2] * v.z + m.m[1][3];
   res.z = m.m[2][0] * v.x + m.m[2][1] * v.y + m.m[2][2] * v.z + m.m[2][3];
   return res;
 }
 
 // Rotation only, ignore translation components.
 gvr::Vec3f MatrixVectorRotate(const gvr::Mat4f& m, const gvr::Vec3f& v) {
@@ skipping 58 matching lines @@
 }
 
 gvr::Vec3f GetTranslation(const gvr::Mat4f& matrix) {
   return {matrix.m[0][3], matrix.m[1][3], matrix.m[2][3]};
 }
 
 float VectorLength(const gvr::Vec3f& vec) {
   return sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
 }
 
+gvr::Vec3f VectorSubtract(const gvr::Vec3f& a, const gvr::Vec3f& b) {
+  return {a.x - b.x, a.y - b.y, a.z - b.z};
+}
+
 float NormalizeVector(gvr::Vec3f& vec) {
   float len = VectorLength(vec);
   vec.x /= len;
   vec.y /= len;
   vec.z /= len;
   return len;
 }
 
 float VectorDot(const gvr::Vec3f& a, const gvr::Vec3f& b) {
   return a.x * b.x + a.y * b.y + a.z * b.z;
@@ skipping 63 matching lines @@
                        const gvr::Vec3f& rayVector,
                        float scale) {
   gvr::Vec3f v;
   v.x = rayOrigin.x + scale * rayVector.x;
   v.y = rayOrigin.y + scale * rayVector.y;
   v.z = rayOrigin.z + scale * rayVector.z;
   return v;
 }
 
 }  // namespace vr_shell