diff --git a/Source/Core/Common/Matrix.cpp b/Source/Core/Common/Matrix.cpp
@@ -0,0 +1,164 @@
+// Copyright 2019 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#include "Common/Matrix.h"
+
+#include <algorithm>
+#include <cmath>
+
+namespace
+{
+void MatrixMul(int n, const float* a, const float* b, float* result)
+{
+  for (int i = 0; i < n; ++i)
+  {
+    for (int j = 0; j < n; ++j)
+    {
+      float temp = 0;
+      for (int k = 0; k < n; ++k)
+      {
+        temp += a[i * n + k] * b[k * n + j];
+      }
+      result[i * n + j] = temp;
+    }
+  }
+}
+}  // namespace
+
+namespace Common
+{
+Matrix33 Matrix33::Identity()
+{
+  Matrix33 mtx = {};
+  mtx.data[0] = 1.0f;
+  mtx.data[4] = 1.0f;
+  mtx.data[8] = 1.0f;
+  return mtx;
+}
+
+Matrix33 Matrix33::RotateX(float rad)
+{
+  const float s = sin(rad);
+  const float c = cos(rad);
+  Matrix33 mtx = {};
+  mtx.data[0] = 1;
+  mtx.data[4] = c;
+  mtx.data[5] = -s;
+  mtx.data[7] = s;
+  mtx.data[8] = c;
+  return mtx;
+}
+
+Matrix33 Matrix33::RotateY(float rad)
+{
+  const float s = sin(rad);
+  const float c = cos(rad);
+  Matrix33 mtx = {};
+  mtx.data[0] = c;
+  mtx.data[2] = s;
+  mtx.data[4] = 1;
+  mtx.data[6] = -s;
+  mtx.data[8] = c;
+  return mtx;
+}
+
+Matrix33 Matrix33::RotateZ(float rad)
+{
+  const float s = sin(rad);
+  const float c = cos(rad);
+  Matrix33 mtx = {};
+  mtx.data[0] = c;
+  mtx.data[1] = -s;
+  mtx.data[3] = s;
+  mtx.data[4] = c;
+  mtx.data[8] = 1;
+  return mtx;
+}
+
+Matrix33 Matrix33::Scale(const Vec3& vec)
+{
+  Matrix33 mtx = {};
+  mtx.data[0] = vec.x;
+  mtx.data[4] = vec.y;
+  mtx.data[8] = vec.z;
+  return mtx;
+}
+
+void Matrix33::Multiply(const Matrix33& a, const Matrix33& b, Matrix33* result)
+{
+  MatrixMul(3, a.data.data(), b.data.data(), result->data.data());
+}
+
+void Matrix33::Multiply(const Matrix33& a, const Vec3& vec, Vec3* result)
+{
+  for (int i = 0; i < 3; ++i)
+  {
+    result->data[i] = 0;
+
+    for (int k = 0; k < 3; ++k)
+    {
+      result->data[i] += a.data[i * 3 + k] * vec.data[k];
+    }
+  }
+}
+
+Matrix44 Matrix44::Identity()
+{
+  Matrix44 mtx = {};
+  mtx.data[0] = 1.0f;
+  mtx.data[5] = 1.0f;
+  mtx.data[10] = 1.0f;
+  mtx.data[15] = 1.0f;
+  return mtx;
+}
+
+Matrix44 Matrix44::FromMatrix33(const Matrix33& m33)
+{
+  Matrix44 mtx;
+  for (int i = 0; i < 3; ++i)
+  {
+    for (int j = 0; j < 3; ++j)
+    {
+      mtx.data[i * 4 + j] = m33.data[i * 3 + j];
+    }
+  }
+
+  for (int i = 0; i < 3; ++i)
+  {
+    mtx.data[i * 4 + 3] = 0;
+    mtx.data[i + 12] = 0;
+  }
+  mtx.data[15] = 1.0f;
+  return mtx;
+}
+
+Matrix44 Matrix44::FromArray(const std::array<float, 16>& arr)
+{
+  Matrix44 mtx;
+  mtx.data = arr;
+  return mtx;
+}
+
+Matrix44 Matrix44::Translate(const Vec3& vec)
+{
+  Matrix44 mtx = Matrix44::Identity();
+  mtx.data[3] = vec.x;
+  mtx.data[7] = vec.y;
+  mtx.data[11] = vec.z;
+  return mtx;
+}
+
+Matrix44 Matrix44::Shear(const float a, const float b)
+{
+  Matrix44 mtx = Matrix44::Identity();
+  mtx.data[2] = a;
+  mtx.data[6] = b;
+  return mtx;
+}
+
+void Matrix44::Multiply(const Matrix44& a, const Matrix44& b, Matrix44* result)
+{
+  MatrixMul(4, a.data.data(), b.data.data(), result->data.data());
+}
+}  // namespace Common
diff --git a/Source/Core/Common/Matrix.h b/Source/Core/Common/Matrix.h
@@ -0,0 +1,104 @@
+// Copyright 2019 Dolphin Emulator Project
+// Licensed under GPLv2+
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+
+// Tiny matrix/vector library.
+// Used for things like Free-Look in the gfx backend.
+
+namespace Common
+{
+union Vec3
+{
+  Vec3() = default;
+  Vec3(float _x, float _y, float _z) : data{_x, _y, _z} {}
+
+  Vec3& operator+=(const Vec3& rhs)
+  {
+    x += rhs.x;
+    y += rhs.y;
+    z += rhs.z;
+    return *this;
+  }
+
+  std::array<float, 3> data = {};
+
+  struct
+  {
+    float x;
+    float y;
+    float z;
+  };
+};
+
+inline Vec3 operator+(Vec3 lhs, const Vec3& rhs)
+{
+  return lhs += rhs;
+}
+
+class Matrix33
+{
+public:
+  static Matrix33 Identity();
+
+  // Return a rotation matrix around the x,y,z axis
+  static Matrix33 RotateX(float rad);
+  static Matrix33 RotateY(float rad);
+  static Matrix33 RotateZ(float rad);
+
+  static Matrix33 Scale(const Vec3& vec);
+
+  // set result = a x b
+  static void Multiply(const Matrix33& a, const Matrix33& b, Matrix33* result);
+  static void Multiply(const Matrix33& a, const Vec3& vec, Vec3* result);
+
+  Matrix33& operator*=(const Matrix33& rhs)
+  {
+    Multiply(Matrix33(*this), rhs, this);
+    return *this;
+  }
+
+  std::array<float, 9> data;
+};
+
+inline Matrix33 operator*(Matrix33 lhs, const Matrix33& rhs)
+{
+  return lhs *= rhs;
+}
+
+inline Vec3 operator*(const Matrix33& lhs, const Vec3& rhs)
+{
+  Vec3 result;
+  Matrix33::Multiply(lhs, rhs, &result);
+  return result;
+}
+
+class Matrix44
+{
+public:
+  static Matrix44 Identity();
+  static Matrix44 FromMatrix33(const Matrix33& m33);
+  static Matrix44 FromArray(const std::array<float, 16>& arr);
+
+  static Matrix44 Translate(const Vec3& vec);
+  static Matrix44 Shear(const float a, const float b = 0);
+
+  static void Multiply(const Matrix44& a, const Matrix44& b, Matrix44* result);
+
+  Matrix44& operator*=(const Matrix44& rhs)
+  {
+    Multiply(Matrix44(*this), rhs, this);
+    return *this;
+  }
+
+  std::array<float, 16> data;
+};
+
+inline Matrix44 operator*(Matrix44 lhs, const Matrix44& rhs)
+{
+  return lhs *= rhs;
+}
+}  // namespace Common
diff --git a/Source/Core/Core/Core.vcxproj b/Source/Core/Core/Core.vcxproj
@@ -451,7 +451,6 @@
     <ClInclude Include="HW\WiimoteEmu\Extension\Nunchuk.h" />
     <ClInclude Include="HW\WiimoteEmu\Extension\Turntable.h" />
     <ClInclude Include="HW\WiimoteEmu\I2CBus.h" />
-    <ClInclude Include="HW\WiimoteEmu\MatrixMath.h" />
     <ClInclude Include="HW\WiimoteEmu\MotionPlus.h" />
     <ClInclude Include="HW\WiimoteEmu\Speaker.h" />
     <ClInclude Include="HW\WiimoteEmu\WiimoteEmu.h" />
@@ -616,4 +615,4 @@
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
-</Project>
+</Project>
diff --git a/Source/Core/Core/Core.vcxproj.filters b/Source/Core/Core/Core.vcxproj.filters
@@ -1221,9 +1221,6 @@
     <ClInclude Include="HW\WiimoteEmu\Encryption.h">
       <Filter>HW %28Flipper/Hollywood%29\Wiimote\Emu</Filter>
     </ClInclude>
-    <ClInclude Include="HW\WiimoteEmu\MatrixMath.h">
-      <Filter>HW %28Flipper/Hollywood%29\Wiimote\Emu</Filter>
-    </ClInclude>
     <ClInclude Include="HW\WiimoteEmu\WiimoteEmu.h">
       <Filter>HW %28Flipper/Hollywood%29\Wiimote\Emu</Filter>
     </ClInclude>

diff --git a/Source/Core/Core/HW/WiimoteEmu/Camera.cpp b/Source/Core/Core/HW/WiimoteEmu/Camera.cpp
@@ -4,10 +4,12 @@
 
 #include "Core/HW/WiimoteEmu/Camera.h"
 
+#include <cmath>
+
 #include "Common/BitUtils.h"
 #include "Common/ChunkFile.h"
+#include "Common/Matrix.h"
 #include "Core/HW/WiimoteCommon/WiimoteReport.h"
-#include "Core/HW/WiimoteEmu/MatrixMath.h"
 
 namespace WiimoteEmu
 {
@@ -40,30 +42,25 @@ int CameraLogic::BusWrite(u8 slave_addr, u8 addr, int count, const u8* data_in)
 void CameraLogic::Update(const ControllerEmu::Cursor::StateData& cursor,
                          const NormalizedAccelData& accel, bool sensor_bar_on_top)
 {
-  double nsin, ncos;
+  double nsin;
 
   // Ugly code to figure out the wiimote's current angle.
   // TODO: Kill this.
   double ax = accel.x;
   double az = accel.z;
-  const double len = sqrt(ax * ax + az * az);
+  const double len = std::sqrt(ax * ax + az * az);
 
   if (len)
   {
     ax /= len;
     az /= len;  // normalizing the vector
     nsin = ax;
-    ncos = az;
   }
   else
   {
     nsin = 0;
-    ncos = 1;
   }
 
-  const double ir_sin = nsin;
-  const double ir_cos = ncos;
-
   static constexpr int camWidth = 1024;
   static constexpr int camHeight = 768;
   static constexpr double bndleft = 0.78820266;
@@ -73,7 +70,7 @@ void CameraLogic::Update(const ControllerEmu::Cursor::StateData& cursor,
 
   constexpr int NUM_POINTS = 4;
 
-  std::array<Vertex, NUM_POINTS> v;
+  std::array<Common::Vec3, NUM_POINTS> v;
 
   for (auto& vtx : v)
   {
@@ -95,23 +92,17 @@ void CameraLogic::Update(const ControllerEmu::Cursor::StateData& cursor,
   v[2].x -= (cursor.z * 0.5 + 1) * dist2;
   v[3].x += (cursor.z * 0.5 + 1) * dist2;
 
-#define printmatrix(m)                                                                             \
-  PanicAlert("%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n%f %f %f %f\n", m[0][0], m[0][1], m[0][2],    \
-             m[0][3], m[1][0], m[1][1], m[1][2], m[1][3], m[2][0], m[2][1], m[2][2], m[2][3],      \
-             m[3][0], m[3][1], m[3][2], m[3][3])
-  Matrix rot, tot;
-  static Matrix scale;
-  MatrixScale(scale, 1, camWidth / camHeight, 1);
-  MatrixRotationByZ(rot, ir_sin, ir_cos);
-  MatrixMultiply(tot, scale, rot);
+  const auto scale = Common::Matrix33::Scale({1, camWidth / camHeight, 1});
+  const auto rot = Common::Matrix33::RotateZ(std::asin(nsin));
+  const auto tot = scale * rot;
 
   u16 x[NUM_POINTS], y[NUM_POINTS];
   memset(x, 0xFF, sizeof(x));
   memset(y, 0xFF, sizeof(y));
 
   for (std::size_t i = 0; i < v.size(); i++)
   {
-    MatrixTransformVertex(tot, v[i]);
+    v[i] = tot * v[i];
 
     if ((v[i].x < -1) || (v[i].x > 1) || (v[i].y < -1) || (v[i].y > 1))
       continue;

diff --git a/Source/Core/Core/HW/WiimoteEmu/MatrixMath.h b/Source/Core/Core/HW/WiimoteEmu/MatrixMath.h
diff --git a/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp b/Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <algorithm>
+#include <array>
 #include <cstring>
 
 #include "Common/Assert.h"
@@ -847,4 +848,4 @@ void VulkanContext::InitDriverDetails()
                       static_cast<double>(m_device_properties.driverVersion),
                       DriverDetails::Family::UNKNOWN);
 }
-}
+}  // namespace Vulkan
diff --git a/Source/Core/VideoCommon/VertexShaderManager.cpp b/Source/Core/VideoCommon/VertexShaderManager.cpp
@@ -13,7 +13,7 @@
 #include "Common/CommonFuncs.h"
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
-#include "Common/MathUtil.h"
+#include "Common/Matrix.h"
 #include "Core/ConfigManager.h"
 #include "Core/Core.h"
 #include "VideoCommon/BPFunctions.h"
@@ -27,7 +27,7 @@
 #include "VideoCommon/VideoConfig.h"
 #include "VideoCommon/XFMemory.h"
 
-alignas(16) static float g_fProjectionMatrix[16];
+alignas(16) static std::array<float, 16> g_fProjectionMatrix;
 
 // track changes
 static bool bTexMatricesChanged[2], bPosNormalMatrixChanged, bProjectionChanged, bViewportChanged;
@@ -38,10 +38,10 @@ static int nNormalMatricesChanged[2];         // min,max
 static int nPostTransformMatricesChanged[2];  // min,max
 static int nLightsChanged[2];                 // min,max
 
-static Matrix44 s_viewportCorrection;
-static Matrix33 s_viewRotationMatrix;
-static Matrix33 s_viewInvRotationMatrix;
-static float s_fViewTranslationVector[3];
+static Common::Matrix44 s_viewportCorrection;
+static Common::Matrix33 s_viewRotationMatrix;
+static Common::Matrix33 s_viewInvRotationMatrix;
+static Common::Vec3 s_fViewTranslationVector;
 static float s_fViewRotation[2];
 
 VertexShaderConstants VertexShaderManager::constants;
@@ -57,7 +57,7 @@ bool VertexShaderManager::dirty;
 // [         0   (ih/ah)     0   ((-ih + 2*(ay-iy)) / ah + 1)   ]
 // [         0         0     1                              0   ]
 // [         0         0     0                              1   ]
-static void ViewportCorrectionMatrix(Matrix44& result)
+static void ViewportCorrectionMatrix(Common::Matrix44& result)
 {
   int scissorXOff = bpmem.scissorOffset.x * 2;
   int scissorYOff = bpmem.scissorOffset.y * 2;
@@ -86,7 +86,7 @@ static void ViewportCorrectionMatrix(Matrix44& result)
   float Wd = (X + intendedWd <= EFB_WIDTH) ? intendedWd : (EFB_WIDTH - X);
   float Ht = (Y + intendedHt <= EFB_HEIGHT) ? intendedHt : (EFB_HEIGHT - Y);
 
-  Matrix44::LoadIdentity(result);
+  result = Common::Matrix44::Identity();
   if (Wd == 0 || Ht == 0)
     return;
 
@@ -121,10 +121,8 @@ void VertexShaderManager::Init()
   ResetView();
 
   // TODO: should these go inside ResetView()?
-  Matrix44::LoadIdentity(s_viewportCorrection);
-  memset(g_fProjectionMatrix, 0, sizeof(g_fProjectionMatrix));
-  for (int i = 0; i < 4; ++i)
-    g_fProjectionMatrix[i * 5] = 1.0f;
+  s_viewportCorrection = Common::Matrix44::Identity();
+  g_fProjectionMatrix = Common::Matrix44::Identity().data;
 
   dirty = true;
 }
@@ -454,26 +452,21 @@ void VertexShaderManager::SetConstants()
 
     if (g_ActiveConfig.bFreeLook && xfmem.projection.type == GX_PERSPECTIVE)
     {
-      Matrix44 mtxA;
-      Matrix44 mtxB;
-      Matrix44 viewMtx;
-
-      Matrix44::Translate(mtxA, s_fViewTranslationVector);
-      Matrix44::LoadMatrix33(mtxB, s_viewRotationMatrix);
-      Matrix44::Multiply(mtxB, mtxA, viewMtx);  // view = rotation x translation
-      Matrix44::Set(mtxB, g_fProjectionMatrix);
-      Matrix44::Multiply(mtxB, viewMtx, mtxA);               // mtxA = projection x view
-      Matrix44::Multiply(s_viewportCorrection, mtxA, mtxB);  // mtxB = viewportCorrection x mtxA
-      memcpy(constants.projection.data(), mtxB.data, 4 * sizeof(float4));
+      using Common::Matrix44;
+
+      auto mtxA = Matrix44::Translate(s_fViewTranslationVector);
+      auto mtxB = Matrix44::FromMatrix33(s_viewRotationMatrix);
+      const auto viewMtx = mtxB * mtxA;  // view = rotation x translation
+
+      mtxA = Matrix44::FromArray(g_fProjectionMatrix) * viewMtx;  // mtxA = projection x view
+      mtxB = s_viewportCorrection * mtxA;  // mtxB = viewportCorrection x mtxA
+      memcpy(constants.projection.data(), mtxB.data.data(), 4 * sizeof(float4));
     }
     else
     {
-      Matrix44 projMtx;
-      Matrix44::Set(projMtx, g_fProjectionMatrix);
-
-      Matrix44 correctedMtx;
-      Matrix44::Multiply(s_viewportCorrection, projMtx, correctedMtx);
-      memcpy(constants.projection.data(), correctedMtx.data, 4 * sizeof(float4));
+      const auto projMtx = Common::Matrix44::FromArray(g_fProjectionMatrix);
+      const auto correctedMtx = s_viewportCorrection * projMtx;
+      memcpy(constants.projection.data(), correctedMtx.data.data(), 4 * sizeof(float4));
     }
 
     dirty = true;
@@ -661,41 +654,35 @@ void VertexShaderManager::SetMaterialColorChanged(int index)
 
 void VertexShaderManager::TranslateView(float x, float y, float z)
 {
-  float result[3];
-  float vector[3] = {x, z, y};
-
-  Matrix33::Multiply(s_viewInvRotationMatrix, vector, result);
-
-  for (size_t i = 0; i < ArraySize(result); i++)
-    s_fViewTranslationVector[i] += result[i];
+  s_fViewTranslationVector += s_viewInvRotationMatrix * Common::Vec3{x, z, y};
 
   bProjectionChanged = true;
 }
 
 void VertexShaderManager::RotateView(float x, float y)
 {
+  using Common::Matrix33;
+
   s_fViewRotation[0] += x;
   s_fViewRotation[1] += y;
 
-  Matrix33 mx;
-  Matrix33 my;
-  Matrix33::RotateX(mx, s_fViewRotation[1]);
-  Matrix33::RotateY(my, s_fViewRotation[0]);
-  Matrix33::Multiply(mx, my, s_viewRotationMatrix);
+  s_viewRotationMatrix =
+      Matrix33::RotateX(s_fViewRotation[1]) * Matrix33::RotateY(s_fViewRotation[0]);
 
   // reverse rotation
-  Matrix33::RotateX(mx, -s_fViewRotation[1]);
-  Matrix33::RotateY(my, -s_fViewRotation[0]);
-  Matrix33::Multiply(my, mx, s_viewInvRotationMatrix);
+  s_viewInvRotationMatrix =
+      Matrix33::RotateY(-s_fViewRotation[0]) * Matrix33::RotateX(-s_fViewRotation[1]);
 
   bProjectionChanged = true;
 }
 
 void VertexShaderManager::ResetView()
 {
-  memset(s_fViewTranslationVector, 0, sizeof(s_fViewTranslationVector));
-  Matrix33::LoadIdentity(s_viewRotationMatrix);
-  Matrix33::LoadIdentity(s_viewInvRotationMatrix);
+  using Common::Matrix33;
+
+  s_fViewTranslationVector = {};
+  s_viewRotationMatrix = Matrix33::Identity();
+  s_viewInvRotationMatrix = Matrix33::Identity();
   s_fViewRotation[0] = s_fViewRotation[1] = 0.0f;
 
   bProjectionChanged = true;