diff --git a/bin/Shader.frag.spv b/bin/Shader.frag.spv
index 1fb2f32..7fde5eb 100644
Binary files a/bin/Shader.frag.spv and b/bin/Shader.frag.spv differ
diff --git a/bin/Shader.vert.spv b/bin/Shader.vert.spv
index 699b878..8a0c6f7 100644
Binary files a/bin/Shader.vert.spv and b/bin/Shader.vert.spv differ
diff --git a/src/Common.h b/src/Common.h
index aa8e504..d034196 100644
--- a/src/Common.h
+++ b/src/Common.h
@@ -5,10 +5,6 @@
 
 #ifdef _WIN32
 
-#define MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
-#include <mathfu/glsl_mappings.h>
-#include <mathfu/constants.h>
-
 #include <iostream>
 #include <fstream>
 #include <vector>
@@ -44,15 +40,159 @@ inline float ToFloatSeconds(duration d)
 template <typename T>
 inline T ceil_div(T x, T y)
 {
-	return (x+y-1) / y;
+    return (x+y-1) / y;
 }
 
 template <typename T>
 static inline T align_up(T val, T align)
 {
-	return (val + align - 1) / align * align;
+    return (val + align - 1) / align * align;
 }
 
+static const float PI = 3.14159265358979323846264338327950288419716939937510582f;
+
+struct vec3
+{
+    float x, y, z;
+
+    vec3() { }
+    vec3(float x, float y, float z) : x(x), y(y), z(z) { }
+
+    float& operator[](uint32_t index) { return *(&x + index); }
+    const float& operator[](uint32_t index) const { return *(&x + index); }
+
+    vec3 operator+(const vec3& rhs) const { return vec3(x + rhs.x, y + rhs.y, z + rhs.z); }
+    vec3 operator-(const vec3& rhs) const { return vec3(x - rhs.x, y - rhs.y, z - rhs.z); }
+    vec3 operator*(float s) const { return vec3(x * s, y * s, z * s); }
+
+    vec3 Normalized() const
+    {
+        return (*this) * (1.f / sqrt(x * x + y * y + z * z));
+    }
+};
+
+inline float Dot(const vec3& lhs, const vec3& rhs)
+{
+    return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+}
+inline vec3 Cross(const vec3& lhs, const vec3& rhs)
+{
+    return vec3(
+        lhs.y * rhs.z - lhs.z * rhs.y,
+	    lhs.z * rhs.x - lhs.x * rhs.z,
+	    lhs.x * rhs.y - lhs.y * rhs.x);
+}
+
+struct vec4
+{
+    float x, y, z, w;
+
+    vec4() { }
+    vec4(float x, float y, float z, float w) : x(x), y(y), z(z), w(w) { }
+    vec4(const vec3& v, float w) : x(v.x), y(v.y), z(v.z), w(w) { }
+
+    float& operator[](uint32_t index) { return *(&x + index); }
+    const float& operator[](uint32_t index) const { return *(&x + index); }
+};
+
+struct mat4
+{
+    union
+    {
+        struct
+        {
+            float _11, _12, _13, _14;
+            float _21, _22, _23, _24;
+            float _31, _32, _33, _34;
+            float _41, _42, _43, _44;
+        };
+        float m[4][4]; // [row][column]
+    };
+
+    mat4() { }
+
+    mat4(
+        float _11, float _12, float _13, float _14,
+        float _21, float _22, float _23, float _24,
+        float _31, float _32, float _33, float _34,
+        float _41, float _42, float _43, float _44) :
+        _11(_11), _12(_12), _13(_13), _14(_14),
+        _21(_21), _22(_22), _23(_23), _24(_24),
+        _31(_31), _32(_32), _33(_33), _34(_34),
+        _41(_41), _42(_42), _43(_43), _44(_44)
+    {
+    }
+
+    mat4(
+        const vec4& row1,
+        const vec4& row2,
+        const vec4& row3,
+        const vec4& row4) :
+        _11(row1.x), _12(row1.y), _13(row1.z), _14(row1.w),
+        _21(row2.x), _22(row2.y), _23(row2.z), _24(row2.w),
+        _31(row3.x), _32(row3.y), _33(row3.z), _34(row3.w),
+        _41(row4.x), _42(row4.y), _43(row4.z), _44(row4.w)
+    {
+    }
+
+    mat4 operator*(const mat4 &rhs) const
+    {
+        return mat4(
+            _11 * rhs._11 + _12 * rhs._21 + _13 * rhs._31 + _14 * rhs._41,
+            _11 * rhs._12 + _12 * rhs._22 + _13 * rhs._32 + _14 * rhs._42,
+            _11 * rhs._13 + _12 * rhs._23 + _13 * rhs._33 + _14 * rhs._43,
+            _11 * rhs._14 + _12 * rhs._24 + _13 * rhs._34 + _14 * rhs._44,
+
+            _21 * rhs._11 + _22 * rhs._21 + _23 * rhs._31 + _24 * rhs._41,
+            _21 * rhs._12 + _22 * rhs._22 + _23 * rhs._32 + _24 * rhs._42,
+            _21 * rhs._13 + _22 * rhs._23 + _23 * rhs._33 + _24 * rhs._43,
+            _21 * rhs._14 + _22 * rhs._24 + _23 * rhs._34 + _24 * rhs._44,
+
+            _31 * rhs._11 + _32 * rhs._21 + _33 * rhs._31 + _34 * rhs._41,
+            _31 * rhs._12 + _32 * rhs._22 + _33 * rhs._32 + _34 * rhs._42,
+            _31 * rhs._13 + _32 * rhs._23 + _33 * rhs._33 + _34 * rhs._43,
+            _31 * rhs._14 + _32 * rhs._24 + _33 * rhs._34 + _34 * rhs._44,
+
+            _41 * rhs._11 + _42 * rhs._21 + _43 * rhs._31 + _44 * rhs._41,
+            _41 * rhs._12 + _42 * rhs._22 + _43 * rhs._32 + _44 * rhs._42,
+            _41 * rhs._13 + _42 * rhs._23 + _43 * rhs._33 + _44 * rhs._43,
+            _41 * rhs._14 + _42 * rhs._24 + _43 * rhs._34 + _44 * rhs._44);
+    }
+
+    static mat4 RotationY(float angle)
+    {
+        const float s = sin(angle), c = cos(angle);
+        return mat4(
+            c,   0.f, -s,  0.f,
+            0.f, 1.f, 0.f, 0.f,
+            s,   0.f, c,   0.f,
+            0.f, 0.f, 0.f, 1.f);
+    }
+
+    static mat4 Perspective(float fovY, float aspectRatio, float zNear, float zFar)
+    {
+        float yScale = 1.0f / tan(fovY * 0.5f);
+        float xScale = yScale / aspectRatio;
+        return mat4(
+            xScale, 0.0f, 0.0f, 0.0f,
+            0.0f, yScale, 0.0f, 0.0f,
+            0.0f, 0.0f, zFar / (zFar - zNear), 1.0f,
+            0.0f, 0.0f, -zNear * zFar / (zFar - zNear), 0.0f);
+    }
+
+    static mat4 LookAt(vec3 at, vec3 eye, vec3 up)
+    {
+        vec3 zAxis = (at - eye).Normalized();
+        vec3 xAxis = Cross(up, zAxis).Normalized();
+        vec3 yAxis = Cross(zAxis, xAxis);
+        return mat4(
+            xAxis.x, yAxis.x, zAxis.x, 0.0f,
+            xAxis.y, yAxis.y, zAxis.y, 0.0f,
+            xAxis.z, yAxis.z, zAxis.z, 0.0f,
+            -Dot(xAxis, eye), -Dot(yAxis, eye), -Dot(zAxis, eye), 1.0f);
+    }
+};
+
 class RandomNumberGenerator
 {
 public:
diff --git a/src/VulkanSample.cpp b/src/VulkanSample.cpp
index d3937b7..91f2bf2 100644
--- a/src/VulkanSample.cpp
+++ b/src/VulkanSample.cpp
@@ -573,7 +573,7 @@ static void CreateTexture(uint32_t sizeX, uint32_t sizeY)
 
 struct UniformBufferObject
 {
-    mathfu::vec4_packed ModelViewProj[4];
+    mat4 ModelViewProj;
 };
 
 static void RegisterDebugCallbacks()
@@ -1573,18 +1573,16 @@ static void DrawFrame()
         VK_PIPELINE_BIND_POINT_GRAPHICS,
         g_hPipeline);
 
-    mathfu::mat4 view = mathfu::mat4::LookAt(
-        mathfu::kZeros3f,
-        mathfu::vec3(0.f, -2.f, 4.f),
-        mathfu::kAxisY3f);
-    mathfu::mat4 proj = mathfu::mat4::Perspective(
+    mat4 view = mat4::LookAt(
+        vec3(0.f, 0.f, 0.f),
+        vec3(0.f, -2.f, 4.f),
+        vec3(0.f, 1.f, 0.f));
+    mat4 proj = mat4::Perspective(
         1.0471975511966f, // 60 degrees
         (float)g_Extent.width / (float)g_Extent.height,
         0.1f,
-        1000.f,
-        -1.f);
-    //proj[1][1] *= -1.f;
-    mathfu::mat4 viewProj = proj * view;
+        1000.f);
+    mat4 viewProj = view * proj;
 
     vkCmdBindDescriptorSets(
         hCommandBuffer,
@@ -1596,17 +1594,11 @@ static void DrawFrame()
         0,
         nullptr);
 
-    float rotationAngle = (float)GetTickCount() * 0.001f * (float)M_PI * 0.2f;
-    mathfu::mat3 model_3 = mathfu::mat3::RotationY(rotationAngle);
-    mathfu::mat4 model_4 = mathfu::mat4(
-        model_3(0, 0), model_3(0, 1), model_3(0, 2), 0.f,
-        model_3(1, 0), model_3(1, 1), model_3(1, 2), 0.f,
-        model_3(2, 0), model_3(2, 1), model_3(2, 2), 0.f,
-        0.f, 0.f, 0.f, 1.f);
-    mathfu::mat4 modelViewProj = viewProj * model_4;
+    float rotationAngle = (float)GetTickCount() * 0.001f * (float)PI * 0.2f;
+    mat4 model = mat4::RotationY(rotationAngle);
 
     UniformBufferObject ubo = {};
-    modelViewProj.Pack(ubo.ModelViewProj);
+    ubo.ModelViewProj = model * viewProj;
     vkCmdPushConstants(hCommandBuffer, g_hPipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(UniformBufferObject), &ubo);
 
     VkBuffer vertexBuffers[] = { g_hVertexBuffer };
diff --git a/third_party/mathfu-1.1.0/.gitignore b/third_party/mathfu-1.1.0/.gitignore
deleted file mode 100644
index 0b01b9c..0000000
--- a/third_party/mathfu-1.1.0/.gitignore
+++ /dev/null
@@ -1,37 +0,0 @@
-**/bin/**
-**/libs/**
-**/obj/**
-*.pyc
-apks/**
-docs/html/
-docs/linklint_results/
-CMakeCache.txt
-CMakeFiles
-CMakeScripts/
-Makefile
-MathFu.build/
-MathFu.xcodeproj/
-benchmarks/CMakeFiles
-benchmarks/Debug/
-benchmarks/Makefile
-benchmarks/MathFu.build/
-benchmarks/Release/
-benchmarks/cmake_install.cmake
-benchmarks/matrix_*benchmarks
-benchmarks/vector_*benchmarks
-unit_tests/CMakeFiles/
-unit_tests/Debug/
-unit_tests/Makefile
-unit_tests/MathFu.build/
-unit_tests/Release/
-unit_tests/cmake_install.cmake
-unit_tests/matrix_*tests
-unit_tests/quaternion_*tests
-unit_tests/vector_*tests
-build.xml
-cmake_install.cmake
-googletest/
-local.properties
-proguard-project.txt
-project.properties
-.DS_Store
diff --git a/third_party/mathfu-1.1.0/.gitmodules b/third_party/mathfu-1.1.0/.gitmodules
deleted file mode 100644
index 986d17b..0000000
--- a/third_party/mathfu-1.1.0/.gitmodules
+++ /dev/null
@@ -1,9 +0,0 @@
-[submodule "dependencies/fplutil"]
-	path = dependencies/fplutil
-	url = http://github.com/google/fplutil.git
-[submodule "dependencies/vectorial"]
-	path = dependencies/vectorial
-	url = http://github.com/scoopr/vectorial.git
-[submodule "dependencies/googletest"]
-	path = dependencies/googletest
-	url = http://github.com/google/googletest.git
diff --git a/third_party/mathfu-1.1.0/AndroidManifest.xml b/third_party/mathfu-1.1.0/AndroidManifest.xml
deleted file mode 100644
index 54c5340..0000000
--- a/third_party/mathfu-1.1.0/AndroidManifest.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- Empty Manifest so the NDK build process can find the project
-     directory. -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu"
-          android:versionCode="1"
-          android:versionName="1.0">
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- Empty application since this project just builds the mathfu
-         libraries -->
-    <application android:label="mathfu" android:enabled="false"
-                 android:hasCode="false">
-        <activity android:name="android.app.NativeActivity">
-            <meta-data android:name="android.app.lib_name"
-                       android:value="mathfu" />
-        </activity>
-    </application>
-</manifest>
diff --git a/third_party/mathfu-1.1.0/CMakeLists.txt b/third_party/mathfu-1.1.0/CMakeLists.txt
deleted file mode 100644
index 04a29f1..0000000
--- a/third_party/mathfu-1.1.0/CMakeLists.txt
+++ /dev/null
@@ -1,137 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-cmake_minimum_required(VERSION 2.8.12)
-
-set(PROJECT_NAME MathFu)
-project(MathFu)
-
-# Call fplutil to get locations of dependencies and set common build settings.
-include("cmake/find_fplutil.cmake")
-include("${fplutil_dir}/buildutil/cmake_common.txt")
-set_common_build_variables()
-
-# Options that control the build configuration.
-# To configure MathFu flags per build target, see the
-# mathfu_configure_flags() function.
-option(mathfu_enable_simd "Use SIMD implementations when available." ON)
-option(mathfu_build_benchmarks "Build MathFu benchmarks." ON)
-option(mathfu_build_tests "Build MathFu unit tests." ON)
-
-# Save the mathfu directory, store this in the cache so that it's globally
-# accessible from mathfu_configure_flags().
-set(mathfu_dir ${CMAKE_CURRENT_LIST_DIR} CACHE INTERNAL "mathfu directory")
-
-# Set build options for ${target} that are required to build with MathFu.
-# This takes the optional arguments "enable_simd force_padding".
-#
-# If enable_simd is specified it configures whether the project should be
-# built with SIMD optimized functions.  If force_padding is specified and
-# SIMD is enabled, some data structures are padded to work more efficiently
-# with SIMD instructions.
-#
-# If enable_simd is not specified, the mathfu_enable_simd option is used.
-# If force_padding isn't specified padding is enabled based upon the
-# best general configuration for the target architecture.
-function(mathfu_configure_flags target)
-  if(fpl_ios)
-    set(enable_simd NO)
-  else()
-    set(enable_simd ${mathfu_enable_simd})
-  endif()
-
-  # Add required includes to the target.
-  target_include_directories(${target}
-    PRIVATE ${mathfu_dir}/include ${dependencies_vectorial_dir}/include)
-
-  # Parse optional arguments.
-  set(additional_args ${ARGN})
-  list(LENGTH additional_args num_additional_args)
-  if(${num_additional_args} GREATER 0)
-    list(GET additional_args 0 enable_simd)
-  endif()
-  if(${num_additional_args} GREATER 1)
-    list(GET additional_args 1 force_padding)
-  endif()
-
-  # If the SIMD build option is enabled.
-  if(enable_simd)
-    # Enable SSE4.1 when building with GCC / Clang.
-    # NOTE: It's also possible to build the library using using SSE2 with GCC /
-    # Clang, change -msse4.1 to -msse2.
-    if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR
-        CMAKE_COMPILER_IS_CLANGXX)
-      target_compile_options(${target} PRIVATE -msse4.1)
-    endif()
-    # Enable SSE2 by default when building with MSVC for 32-bit targets.
-    # Note that SSE2 is enabled by default for 64-bit targets, and the
-    # compile option will generate an "unknown option" warning.
-    if(MSVC AND CMAKE_SIZEOF_VOID_P EQUAL 4)
-      target_compile_options(${target} PRIVATE /arch:SSE2)
-    endif()
-    # Conditionally enable padding.
-    if(DEFINED force_padding)
-      if(force_padding)
-        target_compile_definitions(${target} PRIVATE
-          -DMATHFU_COMPILE_FORCE_PADDING=1)
-      else()
-        target_compile_definitions(${target} PRIVATE
-          -DMATHFU_COMPILE_FORCE_PADDING=0)
-      endif()
-    endif()
-  else()
-    target_compile_definitions(${target} PRIVATE
-      -DMATHFU_COMPILE_WITHOUT_SIMD_SUPPORT)
-  endif()
-endfunction()
-
-# Modify CMAKE_C_FLAGS and CMAKE_CXX_FLAGS to enable a maximum reasonable
-# warning level.
-function(mathfu_enable_warnings target)
-  get_target_property(target_compile_flags ${target} COMPILE_FLAGS)
-  if(MSVC)
-    # C4127: conditional expression is constant
-    # C4577: 'noexcept' used with no exception handling mode specified.
-    target_compile_options(${target} PRIVATE /W4 /WX /wd4127 /wd4577)
-  elseif(CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX OR
-      CMAKE_COMPILER_IS_CLANGXX)
-    # Set the maximum warning level for gcc.
-    target_compile_options(${target} PRIVATE -Wall -Wextra -Werror
-      -Wno-long-long -Wno-variadic-macros)
-  endif()
-endfunction()
-
-# Macro defined here so that it can be used by all projects included
-macro(mathfu_set_ios_attributes project)
-  if(fpl_ios)
-    set_target_properties(${project} PROPERTIES
-      XCODE_ATTRIBUTE_SDKROOT "iphoneos")
-    set_target_properties(${project} PROPERTIES
-      XCODE_ATTRIBUTE_ARCHS "$(ARCHS_STANDARD)")
-    set_target_properties(${project} PROPERTIES
-      XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH "NO")
-    set_target_properties(${project} PROPERTIES
-      XCODE_ATTRIBUTE_VALID_ARCHS "$(ARCHS_STANDARD)")
-    set_target_properties(${project} PROPERTIES
-      XCODE_ATTRIBUTE_IPHONEOS_DEPLOYMENT_TARGET "8.0")
-  endif()
-endmacro(mathfu_set_ios_attributes)
-
-file(GLOB_RECURSE MATHFU_HEADERS ${CMAKE_CURRENT_LIST_DIR}/include/mathfu *.h)
-
-if(mathfu_build_benchmarks)
-  add_subdirectory(benchmarks)
-endif()
-if(mathfu_build_tests)
-  add_subdirectory(unit_tests)
-endif()
diff --git a/third_party/mathfu-1.1.0/CONTRIBUTING b/third_party/mathfu-1.1.0/CONTRIBUTING
deleted file mode 100644
index aebd885..0000000
--- a/third_party/mathfu-1.1.0/CONTRIBUTING
+++ /dev/null
@@ -1,28 +0,0 @@
-Contributing    {#contributing}
-============
-
-Want to contribute? Great! First, read this page (including the small print at
-the end).
-
-# Before you contribute
-Before we can use your code, you must sign the
-[Google Individual Contributor License Agreement](https://developers.google.com/open-source/cla/individual?csw=1)
-(CLA), which you can do online. The CLA is necessary mainly because you own the
-copyright to your changes, even after your contribution becomes part of our
-codebase, so we need your permission to use and distribute your code. We also
-need to be sure of various other things—for instance that you'll tell us if you
-know that your code infringes on other people's patents. You don't have to sign
-the CLA until after you've submitted your code for review and a member has
-approved it, but you must do it before we can put your code into our codebase.
-Before you start working on a larger contribution, you should get in touch with
-us first through the issue tracker with your idea so that we can help out and
-possibly guide you. Coordinating up front makes it much easier to avoid
-frustration later on.
-
-# Code reviews
-All submissions, including submissions by project members, require review. We
-use Github pull requests for this purpose.
-
-# The small print
-Contributions made by corporations are covered by a different agreement than
-the one above, the Software Grant and Corporate Contributor License Agreement.
diff --git a/third_party/mathfu-1.1.0/LICENSE b/third_party/mathfu-1.1.0/LICENSE
deleted file mode 100644
index d645695..0000000
--- a/third_party/mathfu-1.1.0/LICENSE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/third_party/mathfu-1.1.0/android_config.mk b/third_party/mathfu-1.1.0/android_config.mk
deleted file mode 100644
index d4a25df..0000000
--- a/third_party/mathfu-1.1.0/android_config.mk
+++ /dev/null
@@ -1,49 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-FIND_FPLUTIL_OK_IF_NOT_FOUND:=1
-include $(call my-dir)/jni/find_fplutil.mk
-
-ifneq ($(FPLUTIL_DIR),)
-  # If fplutil is found, grab the project locations from it.
-  include $(FPLUTIL_DIR)/buildutil/android_common.mk
-
-else
-  # If fplutil is not found, assume project locations are in 'dependencies'
-  # or are set externally with the DEPENDENCIES_ROOT value.
-  #
-  # If the dependencies directory exists either as a subdirectory or as the
-  # container of this project directory, assume the dependencies directory is
-  # the root directory for all libraries required by this project.
-  $(foreach dep_dir,$(wildcard $(MATHFU_DIR)/dependencies) \
-                    $(wildcard $(MATHFU_DIR)/../../dependencies),\
-    $(eval DEPENDENCIES_ROOT?=$(dep_dir)))
-
-  ifeq ($(DEPENDENCIES_ROOT),)
-    $(error "Cannot find directory with dependent projects.")
-  endif
-
-  # Location of the vectorial library.
-  DEPENDENCIES_VECTORIAL_DIR?=$(DEPENDENCIES_ROOT)/vectorial
-  # Location of the googletest library.
-  DEPENDENCIES_GTEST_DIR?=$(DEPENDENCIES_ROOT)/fplutil/libfplutil/jni/libs/googletest
-  # Location of the fplutil library.
-  DEPENDENCIES_FPLUTIL_DIR?=$(DEPENDENCIES_ROOT)/fplutil
-endif
-
-# Whether to disable SIMD.
-MATHFU_DISABLE_SIMD?=0
-# Whether to force padding of data structures with SIMD enabled.
-# -1 = default, 0 = no padding, 1 = padding
-MATHFU_FORCE_PADDING?=-1
diff --git a/third_party/mathfu-1.1.0/benchmarks/CMakeLists.txt b/third_party/mathfu-1.1.0/benchmarks/CMakeLists.txt
deleted file mode 100644
index 859e35d..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/CMakeLists.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-cmake_minimum_required(VERSION 2.8)
-
-# Generate a rule to build a performance test executable
-# ${benchmark_executable_name} from ${benchmark_source}.  For details of
-# additional arguments, see mathfu_configure_flags().
-function(benchmark_executable benchmark_executable_name benchmark_source)
-  add_executable(${benchmark_executable_name} ${benchmark_source})
-  mathfu_configure_flags(${benchmark_executable_name} ${ARGN})
-  mathfu_enable_warnings(${benchmark_executable_name})
-  target_include_directories(${benchmark_executable_name}
-    PRIVATE ${CMAKE_CURRENT_LIST_DIR})
-  if(UNIX AND NOT APPLE)
-    target_link_libraries(${benchmark_executable_name} rt)
-  endif(UNIX AND NOT APPLE)
-endfunction()
-
-# Generates a rule to build performance test executables.  This only builds
-# ${benchmark_name}_benchmarks if SIMD is disabled (see ${mathfu_enable_simd})
-# or ${benchmark_name}_benchmarks and ${benchmark_name}_no_simd_benchmarks if
-# SIMD is enabled where the no_simd_benchmarks binary has SIMD disabled.
-function(benchmark_executables benchmark_name benchmark_source)
-  # Default build options.
-  benchmark_executable(${benchmark_name}_benchmarks ${benchmark_source})
-  if(mathfu_enable_simd)
-    # NOTE: A build configuration below will deliberately duplicate the
-    # default build configuration, since these configs could result in
-    # different compile time preprocessor code paths.
-    # SIMD enabled, padding enabled.
-    benchmark_executable(${benchmark_name}_simd_padding_benchmarks
-      ${benchmark_source} TRUE TRUE)
-    # SIMD enabled, padding disabled.
-    benchmark_executable(${benchmark_name}_simd_no_padding_benchmarks
-      ${benchmark_source} TRUE FALSE)
-    # SIMD disabled, padding disabled.
-    benchmark_executable(${benchmark_name}_no_simd_benchmarks
-      ${benchmark_source} FALSE FALSE)
-  endif()
-endfunction()
-
-benchmark_executables(matrix matrix_benchmark/main.cpp)
-benchmark_executables(vector vector_benchmark/main.cpp)
diff --git a/third_party/mathfu-1.1.0/benchmarks/android_common.mk b/third_party/mathfu-1.1.0/benchmarks/android_common.mk
deleted file mode 100644
index 60983a8..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/android_common.mk
+++ /dev/null
@@ -1,48 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(CLEAR_VARS)
-
-# Configure the locations of MathFu's dependencies.
-MATHFU_DIR:=$(LOCAL_PATH)/../..
-MATHFU_DIR_BASENAME:=$(notdir $(abspath $(MATHFU_DIR)))
-include $(MATHFU_DIR)/android_config.mk
-
-namespace:=$(if $(NDK_PROJECT_PATH),,_mathfu)
-LOCAL_MODULE:=$(LOCAL_BENCHMARK_NAME)${namespace}
-LOCAL_MODULE_TAGS:=optional
-LOCAL_SRC_FILES:= main.cpp
-LOCAL_C_INCLUDES:=$(MATHFU_DIR)/benchmarks
-LOCAL_LDLIBS:=-llog -landroid
-LOCAL_WHOLE_STATIC_LIBRARIES:=\
-	libfplutil_main \
-	libfplutil_print
-# MATHFU_LIB (by default libmathfu) is used to select the build configuration
-# for the target using mathfu.
-LOCAL_STATIC_LIBRARIES:=\
-	android_native_app_glue \
-	libgtest \
-	$(MATHFU_LIB)
-LOCAL_CFLAGS:=-Wall -Werror
-LOCAL_ARM_MODE:=arm
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-add-path,$(abspath $(MATHFU_DIR)/..))
-$(call import-add-path,$(abspath $(DEPENDENCIES_FPLUTIL_DIR)))
-
-$(call import-module,$(MATHFU_DIR_BASENAME)/jni)
-$(call import-module,libfplutil/jni)
-$(call import-module,android/native_app_glue)
-
-LOCAL_BENCHMARK_NAME:=
-MATHFU_DIR:=
diff --git a/third_party/mathfu-1.1.0/benchmarks/application_common.mk b/third_party/mathfu-1.1.0/benchmarks/application_common.mk
deleted file mode 100644
index e0be21e..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/application_common.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-APP_PLATFORM:=android-10
-APP_ABI:=armeabi-v7a
-APP_STL:=c++_static
-
diff --git a/third_party/mathfu-1.1.0/benchmarks/benchmark_common.h b/third_party/mathfu-1.1.0/benchmarks/benchmark_common.h
deleted file mode 100644
index bb6dd80..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/benchmark_common.h
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_BENCHMARKS_BENCHMARKCOMMON_H_
-#define MATHFU_BENCHMARKS_BENCHMARKCOMMON_H_
-
-#if defined(_WIN32)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#else
-#include <sys/time.h>
-#include <time.h>
-#endif  // defined(_WIN32)
-
-// This macro stands in for a double loop over a vector with size elements.
-// This double loop is repeated iterations times to create more accurate
-// performance test.
-#define PERFTEST_2D_VECTOR_LOOP(iterations, size) \
-  for (unsigned int k = 0; k < iterations; k++) \
-  for (unsigned int i = 0; i < size; i++) \
-  for (unsigned int j = 0; j < size; j++)
-
-// High resolution timer.
-class Timer {
- public:
-  Timer() {
-    InitializeTickPeriod();
-    Reset();
-  }
-
-  // Save the current number of counter ticks.
-  void Reset() {
-    start_ = GetTicks();
-  }
-
-  // Get the time elapsed in counter ticks since Reset() was called.
-  unsigned long long GetElapsedTicks() {
-    return GetTicks() - start_;
-  }
-
-  // Get the time elapsed in seconds since Reset() was called.
-  double GetElapsedSeconds() {
-    return static_cast<double>(GetElapsedTicks()) * tick_period();
-  }
-
- public:
-  // Initialize the tick period value.
-  static void InitializeTickPeriod() {
-    if (tick_period_ != 0) {
-      return;
-    }
-#if defined(_WIN32)
-    LARGE_INTEGER frequency;
-    QueryPerformanceFrequency(&frequency);
-    tick_period_ = 1.0 / static_cast<double>(frequency.QuadPart);
-#elif defined(__linux__)
-    // Use a fixed frequency of 1ns to match timespec.
-    tick_period_ = 1e-9;
-#else
-    // Use a fixed frequency of 1us to match timeval.
-    tick_period_ = 1e-6;
-#endif // defined(_WIN32)
-  }
-
-  // Get the period of one counter tick.
-  static double tick_period() {
-    return tick_period_;
-  }
-
-  // Get the number of counter ticks elapsed.
-  static unsigned long long GetTicks() {
-#if defined(_WIN32)
-    LARGE_INTEGER ticks;
-    QueryPerformanceCounter(&ticks);
-    return ticks.QuadPart;
-#elif defined(__linux__)
-    struct timespec time;
-    clock_gettime(CLOCK_MONOTONIC, &time);
-    return (static_cast<unsigned long long>(time.tv_sec) * 1000000000ULL) +
-        time.tv_nsec;
-#else
-    struct timeval time;
-    gettimeofday(&time, NULL);
-    return (static_cast<unsigned long long>(time.tv_sec) * 1000000ULL) +
-        time.tv_usec;
-#endif
-  }
-
- private:
-  unsigned long long start_;
-  static double tick_period_;
-};
-double Timer::tick_period_ = 0;
-
-#endif  // MATHFU_BENCHMARKS_BENCHMARKCOMMON_H_
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/AndroidManifest.xml
deleted file mode 100644
index 64602c5..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Android.mk
deleted file mode 100644
index 538820c..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=matrix_benchmark
-MATHFU_LIB:=libmathfu
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Application.mk
deleted file mode 100644
index 5dfc700..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/res/values/strings.xml
deleted file mode 100644
index efd0618..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/default/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/main.cpp b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/main.cpp
deleted file mode 100644
index 5f8e834..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/main.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "mathfu/matrix_4x4.h"
-#include "mathfu/utilities.h"
-
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "benchmark_common.h"
-
-// Number of elements to iterate over
-static const size_t kMatrixSize = 1000;
-// Number of iterations of each operation.
-static const size_t kIterations = 50;
-
-using mathfu::Matrix;
-using mathfu::Random;
-
-#define MATRIX_DIMENSIONS 4
-
-typedef float T;
-
-typedef Matrix<T, MATRIX_DIMENSIONS> TestMatrix;
-
-// This test creates a number of matrices and performs some mathematical
-// operations on them in order to measure expected performance of matrix
-// operations.
-int main(int argc, char** argv) {
-  (void)argc;
-  (void)argv;
-  // Create an array of matrices containing random values.
-  TestMatrix * const matrices = new TestMatrix[kMatrixSize];
-  TestMatrix mul = TestMatrix::Identity();
-  for (size_t i = 0; i < kMatrixSize; ++i) {
-    TestMatrix mat;
-    for (size_t j = 0; j < MATRIX_DIMENSIONS; ++j) {
-      mat[static_cast<int>(j)] = Random<T>();
-    }
-    matrices[i] = mat;
-  }
-  // Start matrix benchmark, running a number of loops for more accurate
-  // numbers.
-  printf("Running matrix benchmark (%s)...\n", MATHFU_BUILD_OPTIONS_STRING);
-  Timer timer;
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kMatrixSize) mul += matrices[j];
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kMatrixSize) mul *= matrices[j];
-
-#if MATRIX_DIMENSIONS == 4
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kMatrixSize) {
-    mathfu::Vector<T, MATRIX_DIMENSIONS> tmp =
-      matrices[j] * mathfu::Vector<T, MATRIX_DIMENSIONS>(
-          matrices[i](0, 0), matrices[i](1, 0),
-          matrices[i](2, 0), matrices[i](3, 0));
-    mul -= TestMatrix::OuterProduct(tmp, tmp);
-  }
-#endif  // MATRIX_DIMENSIONS == 4
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kMatrixSize) {
-    mul += matrices[j] * Random<T>();
-  }
-  // End matrix performance code
-  double elapsed = timer.GetElapsedSeconds();
-  printf("Took %f seconds\n", elapsed);
-  delete [] matrices;
-  return 0;
-}
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/AndroidManifest.xml
deleted file mode 100644
index 9cf426c..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_no_simd_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_no_simd_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Android.mk
deleted file mode 100644
index 05e9251..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=matrix_no_simd_benchmark
-MATHFU_LIB:=libmathfu_no_simd
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Application.mk
deleted file mode 100644
index f8057f5..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_no_simd_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/res/values/strings.xml
deleted file mode 100644
index acf9caf..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/no_simd/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_no_simd_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/AndroidManifest.xml
deleted file mode 100644
index 6447fd2..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_simd_no_padding_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_simd_no_padding_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Android.mk
deleted file mode 100644
index 0faba83..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=matrix_simd_no_padding_benchmark
-MATHFU_LIB:=libmathfu_simd_no_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Application.mk
deleted file mode 100644
index 3b4fcc1..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_simd_no_padding_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/res/values/strings.xml
deleted file mode 100644
index 91e06cf..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_no_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_simd_no_padding_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/AndroidManifest.xml
deleted file mode 100644
index 0c15634..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_simd_padding_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_simd_padding_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Android.mk
deleted file mode 100644
index fe47935..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=matrix_simd_padding_benchmark
-MATHFU_LIB:=libmathfu_simd_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Application.mk
deleted file mode 100644
index 3f0fb8d..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_simd_padding_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/res/values/strings.xml
deleted file mode 100644
index 0ff300a..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/matrix_benchmark/simd_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_simd_padding_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/AndroidManifest.xml
deleted file mode 100644
index b1fddc4..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Android.mk
deleted file mode 100644
index 4a7bdf2..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=vector_benchmark
-MATHFU_LIB:=libmathfu
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Application.mk
deleted file mode 100644
index 4645783..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/res/values/strings.xml
deleted file mode 100644
index a256817..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/default/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/main.cpp b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/main.cpp
deleted file mode 100644
index d76dfe1..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/main.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "mathfu/vector.h"
-#include "mathfu/utilities.h"
-
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
-
-#include "benchmark_common.h"
-
-// Number of elements to iterate over.
-static const size_t kVectorSize = 1000;
-// Number of iterations of each operation.
-static const size_t kIterations = 100;
-
-using mathfu::Random;
-using mathfu::Vector;
-
-// This test creates a number of vectors and performs some mathematical
-// operations on them in order to measure expected performance of vector
-// operations.
-int main(int argc, char** argv) {
-  typedef float T;
-  (void)argc;
-  (void)argv;
-  // Create a array of vectors
-  Vector<T, 3> *vectors = new Vector<T, 3>[kVectorSize];
-  T final_sum = 0;
-  Vector<T, 3> sum(0.0f);
-  for (size_t i = 0; i < kVectorSize; i++) {
-    Vector<T, 3> vec(Random<T>(), Random<T>(), Random<T>());
-    if (vec.LengthSquared() == static_cast<T>(0.0)) {
-      vec.x = static_cast<T>(1.0);
-    }
-    vectors[i] = vec;
-  }
-  printf("Running vector benchmark (%s)...\n", MATHFU_BUILD_OPTIONS_STRING);
-  // Start vector performance code. Run a number of loops for more accurate
-  // numbers.
-  Timer timer;
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) sum += vectors[j];
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) sum -= vectors[j];
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) sum *= 0.1f;
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) {
-    sum += Vector<T, 3>::CrossProduct(vectors[i], vectors[j]);
-  }
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) {
-    final_sum += Vector<T, 3>::DotProduct(vectors[j], vectors[i]);
-  }
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) {
-      final_sum -= vectors[i].Length();
-  }
-  PERFTEST_2D_VECTOR_LOOP(kIterations, kVectorSize) {
-    final_sum += vectors[i].Normalize();
-  }
-  final_sum += sum[0] + sum[1] + sum[2];
-  // End vector performance code
-  double elapsed = timer.GetElapsedSeconds();
-  printf("Took %f seconds\n", elapsed);
-  delete [] vectors;
-  return 0;
-}
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/AndroidManifest.xml
deleted file mode 100644
index e964522..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_no_simd_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_no_simd_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Android.mk
deleted file mode 100644
index 4594bad..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=vector_no_simd_benchmark
-MATHFU_LIB:=libmathfu_no_simd
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Application.mk
deleted file mode 100644
index ce2854b..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_no_simd_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/res/values/strings.xml
deleted file mode 100644
index c69945b..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/no_simd/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_no_simd_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/AndroidManifest.xml
deleted file mode 100644
index 53d34ad..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_simd_no_padding_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_simd_no_padding_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Android.mk
deleted file mode 100644
index 919eefe..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=vector_simd_no_padding_benchmark
-MATHFU_LIB:=libmathfu_simd_no_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Application.mk
deleted file mode 100644
index 1d12b74..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_simd_no_padding_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/res/values/strings.xml
deleted file mode 100644
index 4e6f706..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_no_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_simd_no_padding_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/AndroidManifest.xml
deleted file mode 100644
index a05211a..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_simd_padding_benchmark"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_simd_padding_benchmark" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Android.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Android.mk
deleted file mode 100644
index da50be3..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_BENCHMARK_NAME:=vector_simd_padding_benchmark
-MATHFU_LIB:=libmathfu_simd_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Application.mk b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Application.mk
deleted file mode 100644
index f48bb01..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_simd_padding_benchmark
diff --git a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/res/values/strings.xml
deleted file mode 100644
index aa93f49..0000000
--- a/third_party/mathfu-1.1.0/benchmarks/vector_benchmark/simd_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_simd_padding_benchmark</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/cmake/find_fplutil.cmake b/third_party/mathfu-1.1.0/cmake/find_fplutil.cmake
deleted file mode 100644
index 0653c41..0000000
--- a/third_party/mathfu-1.1.0/cmake/find_fplutil.cmake
+++ /dev/null
@@ -1,41 +0,0 @@
-# Find the fplutil directory and set it in `fplutil_dir`.
-#
-# We search some standard locations, such as
-# (1) the cached variable ${dependencies_fplutil_dir}, which can be specified
-#     on the command line,
-#         cmake -Ddependencies_fplutil_dir=your_fplutil_directory
-# (2) under ${fpl_root}, which is another cached variable that can be
-#     specified on the command line,
-#         cmake -Dfpl_root=your_fpl_root_directory
-# (3) the "dependencies" directory that gets created when cloning from GitHub,
-# (4) several levels up in the directory tree.
-#
-# Notes
-# -----
-# - fplutil is the project where we keep all our shared code, so the code in
-#   this file (which locates fplutil) can unfortunately not be shared.
-# - Since this file is duplicated in all FPL projects (except fplutil itself),
-#   please copy new versions to all FPL projects whenever you make a change.
-
-set(fplutil_dir_possibilities
-    "${dependencies_fplutil_dir}"
-    "${fpl_root}/fplutil"
-    "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/fplutil"
-    "${CMAKE_CURRENT_LIST_DIR}/../../fplutil"
-    "${CMAKE_CURRENT_LIST_DIR}/../../../fplutil"
-    "${CMAKE_CURRENT_LIST_DIR}/../../../../fplutil"
-    "${CMAKE_CURRENT_LIST_DIR}/../../../../../fplutil")
-
-foreach(dir ${fplutil_dir_possibilities})
-  if(EXISTS ${dir})
-    set(fplutil_dir ${dir})
-    return()
-  endif()
-endforeach(dir)
-
-# Define this cached variable so that cmake GUIs can expose it to the user.
-set(dependencies_fplutil_dir ""
-    CACHE PATH "Directory containing the fplutil library.")
-
-MESSAGE(ERROR
-    "Can't find fplutil directory. Try cmake -Ddependencies_fplutil_dir=your_location.")
diff --git a/third_party/mathfu-1.1.0/disttools/config.json b/third_party/mathfu-1.1.0/disttools/config.json
deleted file mode 100644
index d36d7c7..0000000
--- a/third_party/mathfu-1.1.0/disttools/config.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-  "package": {
-    "name": "mathfu",
-    "url": "http://github.com/google/mathfu.git",
-    "branch": "develop",
-    "is_library": 1,
-    "third_party": 0,
-    "push": 1
-  },
-  "dependencies": [
-    {
-      "name": "googletest",
-      "url": "http://github.com/google/googletest.git",
-      "branch": "master",
-      "revision": "13206d6f53aaff844f2d3595a01ac83a29e383db",
-      "is_library": 1,
-      "third_party": 1,
-      "push": 0
-    },
-    {
-      "name": "fplutil",
-      "url": "http://github.com/google/fplutil.git",
-      "branch": "develop",
-      "is_library": 1,
-      "third_party": 0,
-      "push": 1
-    },
-    {
-      "name": "vectorial",
-      "url": "http://github.com/scoopr/vectorial.git",
-      "branch": "master",
-      "is_library": 1,
-      "third_party": 1,
-      "push": 0
-    }
-  ]
-}
diff --git a/third_party/mathfu-1.1.0/disttools/push_package.py b/third_party/mathfu-1.1.0/disttools/push_package.py
deleted file mode 100644
index c253f12..0000000
--- a/third_party/mathfu-1.1.0/disttools/push_package.py
+++ /dev/null
@@ -1,54 +0,0 @@
-#!/usr/bin/python
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Push this project and its dependencies to another git repo.
-
-Uses fplutil/disttools/push_package.py to push the remote of
-this git repository and its dependencies (defined by config.json)
-to another git repository.
-"""
-
-import os
-import sys
-sys.path.extend((
-    os.path.realpath(os.path.join(
-        os.path.dirname(__file__), os.path.pardir, 'dependencies', 'fplutil')),
-    os.path.realpath(os.path.join(
-        os.path.dirname(__file__), os.path.pardir, os.path.pardir,
-        'fplutil'))))
-import disttools.push_package  # pylint: disable=g-import-not-at-top
-
-## The directory containing this file.
-THIS_DIR = os.path.realpath(os.path.dirname(__file__))
-
-## Default root directory of the project.
-PROJECT_DIR = os.path.realpath(os.path.join(THIS_DIR, os.path.pardir))
-
-## Default package configuration file.
-CONFIG_JSON = os.path.realpath(os.path.join(THIS_DIR, 'config.json'))
-
-
-def main():
-  """See fplutil/disttools/push_package.py.
-
-  Returns:
-    0 if successful, non-zero otherwise.
-  """
-  return disttools.push_package.main(disttools.push_package.parse_arguments(
-      project_dir=PROJECT_DIR, config_json=CONFIG_JSON))
-
-
-if __name__ == '__main__':
-  sys.exit(main())
diff --git a/third_party/mathfu-1.1.0/docs/generate_docs.py b/third_party/mathfu-1.1.0/docs/generate_docs.py
deleted file mode 100644
index 3340eeb..0000000
--- a/third_party/mathfu-1.1.0/docs/generate_docs.py
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/usr/bin/python
-# Copyright 2014 Google Inc. All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Generate html documentation from markdown and doxygen comments."""
-
-import os
-import sys
-
-THIS_DIR = os.path.realpath(os.path.dirname(__file__))
-PROJECT_DIR = os.path.realpath(os.path.join(THIS_DIR, os.pardir))
-sys.path.extend(
-    [os.path.realpath(os.path.join(PROJECT_DIR, os.pardir, 'fplutil')),
-     os.path.realpath(os.path.join(PROJECT_DIR, 'dependencies', 'fplutil'))])
-import docs  # pylint: disable=C6204
-
-
-def main():
-  """Generate html documentation from markdown and doxygen comments.
-
-  Returns:
-    0 if successful, 1 otherwise.
-  """
-  sys.argv.extend(('--linklint-dir', THIS_DIR,
-                   '--source-dir', os.path.join(THIS_DIR, 'src'),
-                   '--project-dir', PROJECT_DIR))
-  return docs.generate_docs.main()
-
-if __name__ == '__main__':
-  sys.exit(main())
diff --git a/third_party/mathfu-1.1.0/docs/src/api_reference.md b/third_party/mathfu-1.1.0/docs/src/api_reference.md
deleted file mode 100644
index 967a9cf..0000000
--- a/third_party/mathfu-1.1.0/docs/src/api_reference.md
+++ /dev/null
@@ -1,37 +0,0 @@
-API Reference    {#mathfu_api_reference}
-=============
-
-This document describes all classes, functions, macros and files that make
-up the [MathFu][] library.  This is intended to be used as a reference for
-C++ programmers who are familiar with [geometry][], [vectors][], [matrices][],
-[quaternions][] and [linear algebra][].
-
-The API reference is broken into the following sections:
-   * [Build Configuration](@ref mathfu_build_config)
-      - Describes configuration options for [MathFu][] code generation.
-   * [Allocators](@ref mathfu_allocator)
-      - Allocators to simplify the process of memory allocation for [MathFu][]
-        data structures.
-   * [Constants](@ref mathfu_constants)
-      - Constants to use in conjunction with [MathFu][] classes.
-   * [Vectors](@ref mathfu_vector)
-      - Class and functions to manipulate [vectors][].
-   * [Matrices](@ref mathfu_matrix)
-      - Class and functions to manipulate [matrices][].
-   * [Quaternions](@ref mathfu_quaternion)
-      - Class and functions to manipulate [quaternions][].
-   * [GLSL Mappings](@ref mathfu_glsl)
-      - Mappings to GLSL data types and functions.
-   * [Utility Functions](@ref mathfu_utilities)
-      - Variety of useful functions that can be used with
-        [Vector](@ref mathfu::Vector) and [Matrix](@ref mathfu::Matrix)
-        classes.
-   * [Version Constants](@ref mathfu_version)
-      - Constants which identify the library version.
-
-   [MathFu]: @ref mathfu_overview
-   [geometry]: http://en.wikipedia.org/wiki/Geometry
-   [vectors]: http://en.wikipedia.org/wiki/Euclidean_vector
-   [matrices]: http://en.wikipedia.org/wiki/Matrix_(mathematics)
-   [quaternions]: http://en.wikipedia.org/wiki/Quaternion
-   [linear algebra]: http://en.wikipedia.org/wiki/Linear_algebra
diff --git a/third_party/mathfu-1.1.0/docs/src/contributing.md b/third_party/mathfu-1.1.0/docs/src/contributing.md
deleted file mode 100644
index 433b7d3..0000000
--- a/third_party/mathfu-1.1.0/docs/src/contributing.md
+++ /dev/null
@@ -1 +0,0 @@
-../../CONTRIBUTING
\ No newline at end of file
diff --git a/third_party/mathfu-1.1.0/docs/src/doxyfile b/third_party/mathfu-1.1.0/docs/src/doxyfile
deleted file mode 100644
index a5bd0d6..0000000
--- a/third_party/mathfu-1.1.0/docs/src/doxyfile
+++ /dev/null
@@ -1,2371 +0,0 @@
-
-# Doxyfile 1.8.5
-
-# This file describes the settings to be used by the documentation system
-# doxygen (www.doxygen.org) for a project.
-# 
-# All text after a double hash (##) is considered a comment and is placed in
-# front of the TAG it is preceding.
-# 
-# All text after a single hash (#) is considered a comment and will be ignored.
-# The format is:
-# TAG = value [value, ...]
-# For lists, items can also be appended using:
-# TAG += value [value, ...]
-# Values that contain spaces should be placed between quotes (\" \").
-
-#---------------------------------------------------------------------------
-# Project related configuration options
-#---------------------------------------------------------------------------
-
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
-# The default value is: UTF-8.
-
-DOXYFILE_ENCODING      = UTF-8
-
-# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by
-# double-quotes, unless you are using Doxywizard) that should identify the
-# project for which the documentation is generated. This name is used in the
-# title of most generated pages and in a few other places.
-# The default value is: My Project.
-
-PROJECT_NAME           = "MathFu"
-
-# The PROJECT_NUMBER tag can be used to enter a project or revision number. This
-# could be handy for archiving the generated documentation or if some version
-# control system is used.
-
-PROJECT_NUMBER         = 
-
-# Using the PROJECT_BRIEF tag one can provide an optional one line description
-# for a project that appears at the top of each page and should give viewer a
-# quick idea about the purpose of the project. Keep the description short.
-
-PROJECT_BRIEF          = 
-
-# With the PROJECT_LOGO tag one can specify an logo or icon that is included in
-# the documentation. The maximum height of the logo should not exceed 55 pixels
-# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo
-# to the output directory.
-
-PROJECT_LOGO           = 
-
-# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path
-# into which the generated documentation will be written. If a relative path is
-# entered, it will be relative to the location where doxygen was started. If
-# left blank the current directory will be used.
-
-OUTPUT_DIRECTORY       = "../"
-
-# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub-
-# directories (in 2 levels) under the output directory of each output format and
-# will distribute the generated files over these directories. Enabling this
-# option can be useful when feeding doxygen a huge amount of source files, where
-# putting all generated files in the same directory would otherwise causes
-# performance problems for the file system.
-# The default value is: NO.
-
-CREATE_SUBDIRS         = NO
-
-# The OUTPUT_LANGUAGE tag is used to specify the language in which all
-# documentation generated by doxygen is written. Doxygen will use this
-# information to generate all constant output in the proper language.
-# Possible values are: Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-
-# Traditional, Croatian, Czech, Danish, Dutch, English, Esperanto, Farsi,
-# Finnish, French, German, Greek, Hungarian, Italian, Japanese, Japanese-en,
-# Korean, Korean-en, Latvian, Norwegian, Macedonian, Persian, Polish,
-# Portuguese, Romanian, Russian, Serbian, Slovak, Slovene, Spanish, Swedish,
-# Turkish, Ukrainian and Vietnamese.
-# The default value is: English.
-
-OUTPUT_LANGUAGE        = English
-
-# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member
-# descriptions after the members that are listed in the file and class
-# documentation (similar to Javadoc). Set to NO to disable this.
-# The default value is: YES.
-
-BRIEF_MEMBER_DESC      = YES
-
-# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief
-# description of a member or function before the detailed description
-# 
-# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
-# brief descriptions will be completely suppressed.
-# The default value is: YES.
-
-REPEAT_BRIEF           = YES
-
-# This tag implements a quasi-intelligent brief description abbreviator that is
-# used to form the text in various listings. Each string in this list, if found
-# as the leading text of the brief description, will be stripped from the text
-# and the result, after processing the whole list, is used as the annotated
-# text. Otherwise, the brief description is used as-is. If left blank, the
-# following values are used ($name is automatically replaced with the name of
-# the entity):The $name class, The $name widget, The $name file, is, provides,
-# specifies, contains, represents, a, an and the.
-
-ABBREVIATE_BRIEF       = "The $name class" \
-                         "The $name widget" \
-                         "The $name file" \
-                         is \
-                         provides \
-                         specifies \
-                         contains \
-                         represents \
-                         a \
-                         an \
-                         the
-
-# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
-# doxygen will generate a detailed section even if there is only a brief
-# description.
-# The default value is: NO.
-
-ALWAYS_DETAILED_SEC    = NO
-
-# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
-# inherited members of a class in the documentation of that class as if those
-# members were ordinary class members. Constructors, destructors and assignment
-# operators of the base classes will not be shown.
-# The default value is: NO.
-
-INLINE_INHERITED_MEMB  = NO
-
-# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path
-# before files name in the file list and in the header files. If set to NO the
-# shortest path that makes the file name unique will be used
-# The default value is: YES.
-
-FULL_PATH_NAMES        = NO
-
-# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path.
-# Stripping is only done if one of the specified strings matches the left-hand
-# part of the path. The tag can be used to show relative paths in the file list.
-# If left blank the directory from which doxygen is run is used as the path to
-# strip.
-# 
-# Note that you can specify absolute paths here, but also relative paths, which
-# will be relative from the directory where doxygen is started.
-# This tag requires that the tag FULL_PATH_NAMES is set to YES.
-
-STRIP_FROM_PATH        =
-
-# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
-# path mentioned in the documentation of a class, which tells the reader which
-# header file to include in order to use a class. If left blank only the name of
-# the header file containing the class definition is used. Otherwise one should
-# specify the list of include paths that are normally passed to the compiler
-# using the -I flag.
-
-STRIP_FROM_INC_PATH    = 
-
-# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but
-# less readable) file names. This can be useful is your file systems doesn't
-# support long names like on DOS, Mac, or CD-ROM.
-# The default value is: NO.
-
-SHORT_NAMES            = NO
-
-# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the
-# first line (until the first dot) of a Javadoc-style comment as the brief
-# description. If set to NO, the Javadoc-style will behave just like regular Qt-
-# style comments (thus requiring an explicit @brief command for a brief
-# description.)
-# The default value is: NO.
-
-JAVADOC_AUTOBRIEF      = NO
-
-# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
-# line (until the first dot) of a Qt-style comment as the brief description. If
-# set to NO, the Qt-style will behave just like regular Qt-style comments (thus
-# requiring an explicit \brief command for a brief description.)
-# The default value is: NO.
-
-QT_AUTOBRIEF           = NO
-
-# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a
-# multi-line C++ special comment block (i.e. a block of //! or /// comments) as
-# a brief description. This used to be the default behavior. The new default is
-# to treat a multi-line C++ comment block as a detailed description. Set this
-# tag to YES if you prefer the old behavior instead.
-# 
-# Note that setting this tag to YES also means that rational rose comments are
-# not recognized any more.
-# The default value is: NO.
-
-MULTILINE_CPP_IS_BRIEF = NO
-
-# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
-# documentation from any documented member that it re-implements.
-# The default value is: YES.
-
-INHERIT_DOCS           = YES
-
-# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a
-# new page for each member. If set to NO, the documentation of a member will be
-# part of the file/class/namespace that contains it.
-# The default value is: NO.
-
-SEPARATE_MEMBER_PAGES  = NO
-
-# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen
-# uses this value to replace tabs by spaces in code fragments.
-# Minimum value: 1, maximum value: 16, default value: 4.
-
-TAB_SIZE               = 2
-
-# This tag can be used to specify a number of aliases that act as commands in
-# the documentation. An alias has the form:
-# name=value
-# For example adding
-# "sideeffect=@par Side Effects:\n"
-# will allow you to put the command \sideeffect (or @sideeffect) in the
-# documentation, which will result in a user-defined paragraph with heading
-# "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
-
-ALIASES                = 
-
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              = 
-
-# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
-# only. Doxygen will then generate output that is more tailored for C. For
-# instance, some of the names that are used will be different. The list of all
-# members will be omitted, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_FOR_C  = NO
-
-# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or
-# Python sources only. Doxygen will then generate output that is more tailored
-# for that language. For instance, namespaces will be presented as packages,
-# qualified scopes will look different, etc.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_JAVA   = NO
-
-# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
-# sources. Doxygen will then generate output that is tailored for Fortran.
-# The default value is: NO.
-
-OPTIMIZE_FOR_FORTRAN   = NO
-
-# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
-# sources. Doxygen will then generate output that is tailored for VHDL.
-# The default value is: NO.
-
-OPTIMIZE_OUTPUT_VHDL   = NO
-
-# Doxygen selects the parser to use depending on the extension of the files it
-# parses. With this tag you can assign which parser to use for a given
-# extension. Doxygen has a built-in mapping, but you can override or extend it
-# using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL. For instance to make
-# doxygen treat .inc files as Fortran files (default is PHP), and .f files as C
-# (default is Fortran), use: inc=Fortran f=C.
-# 
-# Note For files without extension you can use no_extension as a placeholder.
-# 
-# Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
-
-EXTENSION_MAPPING      = 
-
-# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
-# according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
-# The output of markdown processing is further processed by doxygen, so you can
-# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
-# case of backward compatibilities issues.
-# The default value is: YES.
-
-MARKDOWN_SUPPORT       = YES
-
-# When enabled doxygen tries to link words that correspond to documented
-# classes, or namespaces to their corresponding documentation. Such a link can
-# be prevented in individual cases by by putting a % sign in front of the word
-# or globally by setting AUTOLINK_SUPPORT to NO.
-# The default value is: YES.
-
-AUTOLINK_SUPPORT       = YES
-
-# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
-# to include (a tag file for) the STL sources as input, then you should set this
-# tag to YES in order to let doxygen match functions declarations and
-# definitions whose arguments contain STL classes (e.g. func(std::string);
-# versus func(std::string) {}). This also make the inheritance and collaboration
-# diagrams that involve STL classes more complete and accurate.
-# The default value is: NO.
-
-BUILTIN_STL_SUPPORT    = NO
-
-# If you use Microsoft's C++/CLI language, you should set this option to YES to
-# enable parsing support.
-# The default value is: NO.
-
-CPP_CLI_SUPPORT        = NO
-
-# Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
-# will parse them like normal C++ but will assume all classes use public instead
-# of private inheritance when no explicit protection keyword is present.
-# The default value is: NO.
-
-SIP_SUPPORT            = NO
-
-# For Microsoft's IDL there are propget and propput attributes to indicate
-# getter and setter methods for a property. Setting this option to YES will make
-# doxygen to replace the get and set methods by a property in the documentation.
-# This will only work if the methods are indeed getting or setting a simple
-# type. If this is not the case, or you want to show the methods anyway, you
-# should set this option to NO.
-# The default value is: YES.
-
-IDL_PROPERTY_SUPPORT   = YES
-
-# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
-# tag is set to YES, then doxygen will reuse the documentation of the first
-# member in the group (if any) for the other members of the group. By default
-# all members of a group must be documented explicitly.
-# The default value is: NO.
-
-DISTRIBUTE_GROUP_DOC   = NO
-
-# Set the SUBGROUPING tag to YES to allow class member groups of the same type
-# (for instance a group of public functions) to be put as a subgroup of that
-# type (e.g. under the Public Functions section). Set it to NO to prevent
-# subgrouping. Alternatively, this can be done per class using the
-# \nosubgrouping command.
-# The default value is: YES.
-
-SUBGROUPING            = YES
-
-# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions
-# are shown inside the group in which they are included (e.g. using \ingroup)
-# instead of on a separate page (for HTML and Man pages) or section (for LaTeX
-# and RTF).
-# 
-# Note that this feature does not work in combination with
-# SEPARATE_MEMBER_PAGES.
-# The default value is: NO.
-
-INLINE_GROUPED_CLASSES = NO
-
-# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions
-# with only public data fields or simple typedef fields will be shown inline in
-# the documentation of the scope in which they are defined (i.e. file,
-# namespace, or group documentation), provided this scope is documented. If set
-# to NO, structs, classes, and unions are shown on a separate page (for HTML and
-# Man pages) or section (for LaTeX and RTF).
-# The default value is: NO.
-
-INLINE_SIMPLE_STRUCTS  = NO
-
-# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or
-# enum is documented as struct, union, or enum with the name of the typedef. So
-# typedef struct TypeS {} TypeT, will appear in the documentation as a struct
-# with name TypeT. When disabled the typedef will appear as a member of a file,
-# namespace, or class. And the struct will be named TypeS. This can typically be
-# useful for C code in case the coding convention dictates that all compound
-# types are typedef'ed and only the typedef is referenced, never the tag name.
-# The default value is: NO.
-
-TYPEDEF_HIDES_STRUCT   = NO
-
-# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This
-# cache is used to resolve symbols given their name and scope. Since this can be
-# an expensive process and often the same symbol appears multiple times in the
-# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small
-# doxygen will become slower. If the cache is too large, memory is wasted. The
-# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range
-# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536
-# symbols. At the end of a run doxygen will report the cache usage and suggest
-# the optimal cache size from a speed point of view.
-# Minimum value: 0, maximum value: 9, default value: 0.
-
-LOOKUP_CACHE_SIZE      = 0
-
-#---------------------------------------------------------------------------
-# Build related configuration options
-#---------------------------------------------------------------------------
-
-# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
-# documentation are documented, even if no documentation was available. Private
-# class members and static file members will be hidden unless the
-# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES.
-# Note: This will also disable the warnings about undocumented members that are
-# normally produced when WARNINGS is set to YES.
-# The default value is: NO.
-
-EXTRACT_ALL            = NO
-
-# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will
-# be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PRIVATE        = NO
-
-# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
-# scope will be included in the documentation.
-# The default value is: NO.
-
-EXTRACT_PACKAGE        = NO
-
-# If the EXTRACT_STATIC tag is set to YES all static members of a file will be
-# included in the documentation.
-# The default value is: NO.
-
-EXTRACT_STATIC         = YES
-
-# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined
-# locally in source files will be included in the documentation. If set to NO
-# only classes defined in header files are included. Does not have any effect
-# for Java sources.
-# The default value is: YES.
-
-EXTRACT_LOCAL_CLASSES  = NO
-
-# This flag is only useful for Objective-C code. When set to YES local methods,
-# which are defined in the implementation section but not in the interface are
-# included in the documentation. If set to NO only methods in the interface are
-# included.
-# The default value is: NO.
-
-EXTRACT_LOCAL_METHODS  = NO
-
-# If this flag is set to YES, the members of anonymous namespaces will be
-# extracted and appear in the documentation as a namespace called
-# 'anonymous_namespace{file}', where file will be replaced with the base name of
-# the file that contains the anonymous namespace. By default anonymous namespace
-# are hidden.
-# The default value is: NO.
-
-EXTRACT_ANON_NSPACES   = NO
-
-# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
-# undocumented members inside documented classes or files. If set to NO these
-# members will be included in the various overviews, but no documentation
-# section is generated. This option has no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_MEMBERS     = NO
-
-# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all
-# undocumented classes that are normally visible in the class hierarchy. If set
-# to NO these classes will be included in the various overviews. This option has
-# no effect if EXTRACT_ALL is enabled.
-# The default value is: NO.
-
-HIDE_UNDOC_CLASSES     = NO
-
-# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO these declarations will be
-# included in the documentation.
-# The default value is: NO.
-
-HIDE_FRIEND_COMPOUNDS  = NO
-
-# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any
-# documentation blocks found inside the body of a function. If set to NO these
-# blocks will be appended to the function's detailed documentation block.
-# The default value is: NO.
-
-HIDE_IN_BODY_DOCS      = NO
-
-# The INTERNAL_DOCS tag determines if documentation that is typed after a
-# \internal command is included. If the tag is set to NO then the documentation
-# will be excluded. Set it to YES to include the internal documentation.
-# The default value is: NO.
-
-INTERNAL_DOCS          = NO
-
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
-# The default value is: system dependent.
-
-CASE_SENSE_NAMES       = NO
-
-# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with
-# their full class and namespace scopes in the documentation. If set to YES the
-# scope will be hidden.
-# The default value is: NO.
-
-HIDE_SCOPE_NAMES       = NO
-
-# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of
-# the files that are included by a file in the documentation of that file.
-# The default value is: YES.
-
-SHOW_INCLUDE_FILES     = YES
-
-# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include
-# files with double quotes in the documentation rather than with sharp brackets.
-# The default value is: NO.
-
-FORCE_LOCAL_INCLUDES   = NO
-
-# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the
-# documentation for inline members.
-# The default value is: YES.
-
-INLINE_INFO            = YES
-
-# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the
-# (detailed) documentation of file and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order.
-# The default value is: YES.
-
-SORT_MEMBER_DOCS       = YES
-
-# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief
-# descriptions of file, namespace and class members alphabetically by member
-# name. If set to NO the members will appear in declaration order.
-# The default value is: NO.
-
-SORT_BRIEF_DOCS        = NO
-
-# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the
-# (brief and detailed) documentation of class members so that constructors and
-# destructors are listed first. If set to NO the constructors will appear in the
-# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS.
-# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief
-# member documentation.
-# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting
-# detailed member documentation.
-# The default value is: NO.
-
-SORT_MEMBERS_CTORS_1ST = NO
-
-# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy
-# of group names into alphabetical order. If set to NO the group names will
-# appear in their defined order.
-# The default value is: NO.
-
-SORT_GROUP_NAMES       = NO
-
-# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by
-# fully-qualified names, including namespaces. If set to NO, the class list will
-# be sorted only by class name, not including the namespace part.
-# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
-# Note: This option applies only to the class list, not to the alphabetical
-# list.
-# The default value is: NO.
-
-SORT_BY_SCOPE_NAME     = NO
-
-# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper
-# type resolution of all parameters of a function it will reject a match between
-# the prototype and the implementation of a member function even if there is
-# only one candidate or it is obvious which candidate to choose by doing a
-# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still
-# accept a match between prototype and implementation in such cases.
-# The default value is: NO.
-
-STRICT_PROTO_MATCHING  = NO
-
-# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the
-# todo list. This list is created by putting \todo commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TODOLIST      = NO
-
-# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the
-# test list. This list is created by putting \test commands in the
-# documentation.
-# The default value is: YES.
-
-GENERATE_TESTLIST      = NO
-
-# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug
-# list. This list is created by putting \bug commands in the documentation.
-# The default value is: YES.
-
-GENERATE_BUGLIST       = NO
-
-# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO)
-# the deprecated list. This list is created by putting \deprecated commands in
-# the documentation.
-# The default value is: YES.
-
-GENERATE_DEPRECATEDLIST= YES
-
-# The ENABLED_SECTIONS tag can be used to enable conditional documentation
-# sections, marked by \if <section_label> ... \endif and \cond <section_label>
-# ... \endcond blocks.
-
-ENABLED_SECTIONS       = 
-
-# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the
-# initial value of a variable or macro / define can have for it to appear in the
-# documentation. If the initializer consists of more lines than specified here
-# it will be hidden. Use a value of 0 to hide initializers completely. The
-# appearance of the value of individual variables and macros / defines can be
-# controlled using \showinitializer or \hideinitializer command in the
-# documentation regardless of this setting.
-# Minimum value: 0, maximum value: 10000, default value: 30.
-
-MAX_INITIALIZER_LINES  = 30
-
-# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at
-# the bottom of the documentation of classes and structs. If set to YES the list
-# will mention the files that were used to generate the documentation.
-# The default value is: YES.
-
-SHOW_USED_FILES        = YES
-
-# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This
-# will remove the Files entry from the Quick Index and from the Folder Tree View
-# (if specified).
-# The default value is: YES.
-
-SHOW_FILES             = YES
-
-# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces
-# page. This will remove the Namespaces entry from the Quick Index and from the
-# Folder Tree View (if specified).
-# The default value is: YES.
-
-SHOW_NAMESPACES        = YES
-
-# The FILE_VERSION_FILTER tag can be used to specify a program or script that
-# doxygen should invoke to get the current version for each file (typically from
-# the version control system). Doxygen will invoke the program by executing (via
-# popen()) the command command input-file, where command is the value of the
-# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided
-# by doxygen. Whatever the program writes to standard output is used as the file
-# version. For an example see the documentation.
-
-FILE_VERSION_FILTER    = 
-
-# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
-# by doxygen. The layout file controls the global structure of the generated
-# output files in an output format independent way. To create the layout file
-# that represents doxygen's defaults, run doxygen with the -l option. You can
-# optionally specify a file name after the option, if omitted DoxygenLayout.xml
-# will be used as the name of the layout file.
-# 
-# Note that if you run doxygen from a directory containing a file called
-# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE
-# tag is left empty.
-
-LAYOUT_FILE            = doxygen_layout.xml
-
-# The CITE_BIB_FILES tag can be used to specify one or more bib files containing
-# the reference definitions. This must be a list of .bib files. The .bib
-# extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
-# For LaTeX the style of the bibliography can be controlled using
-# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
-# search path. Do not use file names with spaces, bibtex cannot handle them. See
-# also \cite for info how to create references.
-
-CITE_BIB_FILES         = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to warning and progress messages
-#---------------------------------------------------------------------------
-
-# The QUIET tag can be used to turn on/off the messages that are generated to
-# standard output by doxygen. If QUIET is set to YES this implies that the
-# messages are off.
-# The default value is: NO.
-
-QUIET                  = NO
-
-# The WARNINGS tag can be used to turn on/off the warning messages that are
-# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES
-# this implies that the warnings are on.
-# 
-# Tip: Turn warnings on while writing the documentation.
-# The default value is: YES.
-
-WARNINGS               = YES
-
-# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate
-# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag
-# will automatically be disabled.
-# The default value is: YES.
-
-WARN_IF_UNDOCUMENTED   = YES
-
-# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for
-# potential errors in the documentation, such as not documenting some parameters
-# in a documented function, or documenting parameters that don't exist or using
-# markup commands wrongly.
-# The default value is: YES.
-
-WARN_IF_DOC_ERROR      = YES
-
-# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
-# are documented, but have no documentation for their parameters or return
-# value. If set to NO doxygen will only warn about wrong or incomplete parameter
-# documentation, but not about the absence of documentation.
-# The default value is: NO.
-
-WARN_NO_PARAMDOC       = NO
-
-# The WARN_FORMAT tag determines the format of the warning messages that doxygen
-# can produce. The string should contain the $file, $line, and $text tags, which
-# will be replaced by the file and line number from which the warning originated
-# and the warning text. Optionally the format may contain $version, which will
-# be replaced by the version of the file (if it could be obtained via
-# FILE_VERSION_FILTER)
-# The default value is: $file:$line: $text.
-
-WARN_FORMAT            = "$file:$line: $text"
-
-# The WARN_LOGFILE tag can be used to specify a file to which warning and error
-# messages should be written. If left blank the output is written to standard
-# error (stderr).
-
-WARN_LOGFILE           = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the input files
-#---------------------------------------------------------------------------
-
-# The INPUT tag is used to specify the files and/or directories that contain
-# documented source files. You may enter file names like myfile.cpp or
-# directories like /usr/src/myproject. Separate the files or directories with
-# spaces.
-# Note: If this tag is empty the current directory is searched.
-
-INPUT                  = "index.md" \
-                         "programmers_guide/introduction.md" \
-                         "programmers_guide/building.md" \
-                         "programmers_guide/building_android.md" \
-                         "programmers_guide/building_linux.md" \
-                         "programmers_guide/building_osx.md" \
-                         "programmers_guide/building_windows.md" \
-                         "programmers_guide/vectors.md" \
-                         "programmers_guide/quaternions.md" \
-                         "programmers_guide/matrices.md" \
-                         "programmers_guide/utilities.md" \
-                         "api_reference.md" \
-                         "readme.md" \
-                         "contributing.md" \
-                         "groups" \
-                         "../../include"
-
-# This tag can be used to specify the character encoding of the source files
-# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
-# libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
-# The default value is: UTF-8.
-
-INPUT_ENCODING         = UTF-8
-
-# If the value of the INPUT tag contains directories, you can use the
-# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank the
-# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii,
-# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp,
-# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown,
-# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf,
-# *.qsf, *.as and *.js.
-
-FILE_PATTERNS          = *.c \
-                         *.cc \
-                         *.cxx \
-                         *.cpp \
-                         *.c++ \
-                         *.java \
-                         *.ii \
-                         *.ixx \
-                         *.ipp \
-                         *.i++ \
-                         *.inl \
-                         *.idl \
-                         *.ddl \
-                         *.odl \
-                         *.h \
-                         *.hh \
-                         *.hxx \
-                         *.hpp \
-                         *.h++ \
-                         *.cs \
-                         *.d \
-                         *.php \
-                         *.php4 \
-                         *.php5 \
-                         *.phtml \
-                         *.inc \
-                         *.m \
-                         *.markdown \
-                         *.md \
-                         *.mm \
-                         *.dox \
-                         *.py \
-                         *.f90 \
-                         *.f \
-                         *.for \
-                         *.tcl \
-                         *.vhd \
-                         *.vhdl \
-                         *.ucf \
-                         *.qsf \
-                         *.as \
-                         *.js
-
-# The RECURSIVE tag can be used to specify whether or not subdirectories should
-# be searched for input files as well.
-# The default value is: NO.
-
-RECURSIVE              = YES
-
-# The EXCLUDE tag can be used to specify files and/or directories that should be
-# excluded from the INPUT source files. This way you can easily exclude a
-# subdirectory from a directory tree whose root is specified with the INPUT tag.
-# 
-# Note that relative paths are relative to the directory from which doxygen is
-# run.
-
-EXCLUDE                =
-
-# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
-# directories that are symbolic links (a Unix file system feature) are excluded
-# from the input.
-# The default value is: NO.
-
-EXCLUDE_SYMLINKS       = NO
-
-# If the value of the INPUT tag contains directories, you can use the
-# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
-# certain files from those directories.
-# 
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories for example use the pattern */test/*
-
-EXCLUDE_PATTERNS       = *_test.py \
-                         __init__.py
-
-# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
-# (namespaces, classes, functions, etc.) that should be excluded from the
-# output. The symbol name can be a fully qualified name, a word, or if the
-# wildcard * is used, a substring. Examples: ANamespace, AClass,
-# AClass::ANamespace, ANamespace::*Test
-# 
-# Note that the wildcards are matched against the file with absolute path, so to
-# exclude all test directories use the pattern */test/*
-
-EXCLUDE_SYMBOLS        =
-
-# The EXAMPLE_PATH tag can be used to specify one or more files or directories
-# that contain example code fragments that are included (see the \include
-# command).
-
-EXAMPLE_PATH           = ../../unit_tests/
-
-# If the value of the EXAMPLE_PATH tag contains directories, you can use the
-# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and
-# *.h) to filter out the source-files in the directories. If left blank all
-# files are included.
-
-EXAMPLE_PATTERNS       = *.cpp
-
-# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
-# searched for input files to be used with the \include or \dontinclude commands
-# irrespective of the value of the RECURSIVE tag.
-# The default value is: NO.
-
-EXAMPLE_RECURSIVE      = NO
-
-# The IMAGE_PATH tag can be used to specify one or more files or directories
-# that contain images that are to be included in the documentation (see the
-# \image command).
-
-IMAGE_PATH             = 
-
-# The INPUT_FILTER tag can be used to specify a program that doxygen should
-# invoke to filter for each input file. Doxygen will invoke the filter program
-# by executing (via popen()) the command:
-# 
-# <filter> <input-file>
-# 
-# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the
-# name of an input file. Doxygen will then use the output that the filter
-# program writes to standard output. If FILTER_PATTERNS is specified, this tag
-# will be ignored.
-# 
-# Note that the filter must not add or remove lines; it is applied before the
-# code is scanned, but not when the output code is generated. If lines are added
-# or removed, the anchors will not be placed correctly.
-
-INPUT_FILTER           =
-
-# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
-# basis. Doxygen will compare the file name with each pattern and apply the
-# filter if there is a match. The filters are a list of the form: pattern=filter
-# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how
-# filters are used. If the FILTER_PATTERNS tag is empty or if none of the
-# patterns match the file name, INPUT_FILTER is applied.
-
-FILTER_PATTERNS        = *.py=py_filter
-
-# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
-# INPUT_FILTER ) will also be used to filter the input files that are used for
-# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES).
-# The default value is: NO.
-
-FILTER_SOURCE_FILES    = NO
-
-# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
-# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and
-# it is also possible to disable source filtering for a specific pattern using
-# *.ext= (so without naming a filter).
-# This tag requires that the tag FILTER_SOURCE_FILES is set to YES.
-
-FILTER_SOURCE_PATTERNS =
-
-# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that
-# is part of the input, its contents will be placed on the main page
-# (index.html). This can be useful if you have a project on for instance GitHub
-# and want to reuse the introduction page also for the doxygen output.
-
-USE_MDFILE_AS_MAINPAGE = index.md
-
-#---------------------------------------------------------------------------
-# Configuration options related to source browsing
-#---------------------------------------------------------------------------
-
-# If the SOURCE_BROWSER tag is set to YES then a list of source files will be
-# generated. Documented entities will be cross-referenced with these sources.
-# 
-# Note: To get rid of all source code in the generated output, make sure that
-# also VERBATIM_HEADERS is set to NO.
-# The default value is: NO.
-
-SOURCE_BROWSER         = NO
-
-# Setting the INLINE_SOURCES tag to YES will include the body of functions,
-# classes and enums directly into the documentation.
-# The default value is: NO.
-
-INLINE_SOURCES         = NO
-
-# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any
-# special comment blocks from generated source code fragments. Normal C, C++ and
-# Fortran comments will always remain visible.
-# The default value is: YES.
-
-STRIP_CODE_COMMENTS    = NO
-
-# If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
-# The default value is: NO.
-
-REFERENCED_BY_RELATION = NO
-
-# If the REFERENCES_RELATION tag is set to YES then for each documented function
-# all documented entities called/used by that function will be listed.
-# The default value is: NO.
-
-REFERENCES_RELATION    = NO
-
-# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set
-# to YES, then the hyperlinks from functions in REFERENCES_RELATION and
-# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will
-# link to the documentation.
-# The default value is: YES.
-
-REFERENCES_LINK_SOURCE = YES
-
-# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the
-# source code will show a tooltip with additional information such as prototype,
-# brief description and links to the definition and documentation. Since this
-# will make the HTML file larger and loading of large files a bit slower, you
-# can opt to disable this feature.
-# The default value is: YES.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-SOURCE_TOOLTIPS        = YES
-
-# If the USE_HTAGS tag is set to YES then the references to source code will
-# point to the HTML generated by the htags(1) tool instead of doxygen built-in
-# source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
-# 4.8.6 or higher.
-# 
-# To use it do the following:
-# - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
-# - Make sure the INPUT points to the root of the source tree
-# - Run doxygen as normal
-# 
-# Doxygen will invoke htags (and that will in turn invoke gtags), so these
-# tools must be available from the command line (i.e. in the search path).
-# 
-# The result: instead of the source browser generated by doxygen, the links to
-# source code will now point to the output of htags.
-# The default value is: NO.
-# This tag requires that the tag SOURCE_BROWSER is set to YES.
-
-USE_HTAGS              = NO
-
-# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a
-# verbatim copy of the header file for each class for which an include is
-# specified. Set to NO to disable this.
-# See also: Section \class.
-# The default value is: YES.
-
-VERBATIM_HEADERS       = YES
-
-# If the CLANG_ASSISTED_PARSING tag is set to YES, then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more acurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
-# Note: The availability of this option depends on whether or not doxygen was
-# compiled with the --with-libclang option.
-# The default value is: NO.
-
-CLANG_ASSISTED_PARSING = NO
-
-# If clang assisted parsing is enabled you can provide the compiler with command
-# line options that you would normally use when invoking the compiler. Note that
-# the include paths will already be set by doxygen for the files and directories
-# specified with INPUT and INCLUDE_PATH.
-# This tag requires that the tag CLANG_ASSISTED_PARSING is set to YES.
-
-CLANG_OPTIONS          = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the alphabetical class index
-#---------------------------------------------------------------------------
-
-# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all
-# compounds will be generated. Enable this if the project contains a lot of
-# classes, structs, unions or interfaces.
-# The default value is: YES.
-
-ALPHABETICAL_INDEX     = YES
-
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
-# In case all classes in a project start with a common prefix, all classes will
-# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
-# can be used to specify a prefix (or a list of prefixes) that should be ignored
-# while generating the index headers.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-IGNORE_PREFIX          = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the HTML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output
-# The default value is: YES.
-
-GENERATE_HTML          = YES
-
-# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_OUTPUT            = html
-
-# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each
-# generated HTML page (for example: .htm, .php, .asp).
-# The default value is: .html.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FILE_EXTENSION    = .html
-
-# The HTML_HEADER tag can be used to specify a user-defined HTML header file for
-# each generated HTML page. If the tag is left blank doxygen will generate a
-# standard header.
-# 
-# To get valid HTML the header file that includes any scripts and style sheets
-# that doxygen needs, which is dependent on the configuration options used (e.g.
-# the setting GENERATE_TREEVIEW). It is highly recommended to start with a
-# default header using
-# doxygen -w html new_header.html new_footer.html new_stylesheet.css
-# YourConfigFile
-# and then modify the file new_header.html. See also section "Doxygen usage"
-# for information on how to generate the default header that doxygen normally
-# uses.
-# Note: The header is subject to change so you typically have to regenerate the
-# default header when upgrading to a newer version of doxygen. For a description
-# of the possible markers and block names see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_HEADER            = $(SHARED_DOCS_PATH)/header.html
-
-# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each
-# generated HTML page. If the tag is left blank doxygen will generate a standard
-# footer. See HTML_HEADER for more information on how to generate a default
-# footer and what special commands can be used inside the footer. See also
-# section "Doxygen usage" for information on how to generate the default footer
-# that doxygen normally uses.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_FOOTER            = $(SHARED_DOCS_PATH)/footer.html
-
-# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style
-# sheet that is used by each HTML page. It can be used to fine-tune the look of
-# the HTML output. If left blank doxygen will generate a default style sheet.
-# See also section "Doxygen usage" for information on how to generate the style
-# sheet that doxygen normally uses.
-# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as
-# it is more robust and this tag (HTML_STYLESHEET) will in the future become
-# obsolete.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_STYLESHEET        = 
-
-# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user-
-# defined cascading style sheet that is included after the standard style sheets
-# created by doxygen. Using this option one can overrule certain style aspects.
-# This is preferred over using HTML_STYLESHEET since it does not replace the
-# standard style sheet and is therefor more robust against future updates.
-# Doxygen will copy the style sheet file to the output directory. For an example
-# see the documentation.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_STYLESHEET  = $(SHARED_DOCS_PATH)/style.css
-
-# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the HTML output directory. Note
-# that these files will be copied to the base HTML output directory. Use the
-# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
-# files. In the HTML_STYLESHEET file, use the file name only. Also note that the
-# files will be copied as-is; there are no commands or markers available.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_EXTRA_FILES       = 
-
-
-# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
-# will adjust the colors in the stylesheet and background images according to
-# this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
-# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
-# purple, and 360 is red again.
-# Minimum value: 0, maximum value: 359, default value: 220.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_HUE    = 220
-
-# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors
-# in the HTML output. For a value of 0 the output will use grayscales only. A
-# value of 255 will produce the most vivid colors.
-# Minimum value: 0, maximum value: 255, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_SAT    = 100
-
-# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the
-# luminance component of the colors in the HTML output. Values below 100
-# gradually make the output lighter, whereas values above 100 make the output
-# darker. The value divided by 100 is the actual gamma applied, so 80 represents
-# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not
-# change the gamma.
-# Minimum value: 40, maximum value: 240, default value: 80.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_COLORSTYLE_GAMMA  = 80
-
-# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
-# page will contain the date and time when the page was generated. Setting this
-# to NO can help when comparing the output of multiple runs.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_TIMESTAMP         = YES
-
-# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
-# documentation will contain sections that can be hidden and shown after the
-# page has loaded.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_DYNAMIC_SECTIONS  = NO
-
-# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries
-# shown in the various tree structured indices initially; the user can expand
-# and collapse entries dynamically later on. Doxygen will expand the tree to
-# such a level that at most the specified number of entries are visible (unless
-# a fully collapsed tree already exceeds this amount). So setting the number of
-# entries 1 will produce a full collapsed tree by default. 0 is a special value
-# representing an infinite number of entries and will result in a full expanded
-# tree by default.
-# Minimum value: 0, maximum value: 9999, default value: 100.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-HTML_INDEX_NUM_ENTRIES = 100
-
-# If the GENERATE_DOCSET tag is set to YES, additional index files will be
-# generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
-# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_DOCSET        = NO
-
-# This tag determines the name of the docset feed. A documentation feed provides
-# an umbrella under which multiple documentation sets from a single provider
-# (such as a company or product suite) can be grouped.
-# The default value is: Doxygen generated docs.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_FEEDNAME        = "Doxygen generated docs"
-
-# This tag specifies a string that should uniquely identify the documentation
-# set bundle. This should be a reverse domain-name style string, e.g.
-# com.mycompany.MyDocSet. Doxygen will append .docset to the name.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_BUNDLE_ID       = org.doxygen.Project
-
-# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify
-# the documentation publisher. This should be a reverse domain-name style
-# string, e.g. com.mycompany.MyDocSet.documentation.
-# The default value is: org.doxygen.Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
-
-# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher.
-# The default value is: Publisher.
-# This tag requires that the tag GENERATE_DOCSET is set to YES.
-
-DOCSET_PUBLISHER_NAME  = Publisher
-
-# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
-# additional HTML index files: index.hhp, index.hhc, and index.hhk. The
-# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
-# 
-# The HTML Help Workshop contains a compiler that can convert all HTML output
-# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
-# files are now used as the Windows 98 help format, and will replace the old
-# Windows help format (.hlp) on all Windows platforms in the future. Compressed
-# HTML files also contain an index, a table of contents, and you can search for
-# words in the documentation. The HTML workshop also contains a viewer for
-# compressed HTML files.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_HTMLHELP      = NO
-
-# The CHM_FILE tag can be used to specify the file name of the resulting .chm
-# file. You can add a path in front of the file if the result should not be
-# written to the html output directory.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_FILE               = 
-
-# The HHC_LOCATION tag can be used to specify the location (absolute path
-# including file name) of the HTML help compiler ( hhc.exe). If non-empty
-# doxygen will try to run the HTML help compiler on the generated index.hhp.
-# The file has to be specified with full path.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-HHC_LOCATION           = 
-
-# The GENERATE_CHI flag controls if a separate .chi index file is generated (
-# YES) or that it should be included in the master .chm file ( NO).
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-GENERATE_CHI           = NO
-
-# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc)
-# and project file content.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-CHM_INDEX_ENCODING     = 
-
-# The BINARY_TOC flag controls whether a binary table of contents is generated (
-# YES) or a normal table of contents ( NO) in the .chm file.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-BINARY_TOC             = NO
-
-# The TOC_EXPAND flag can be set to YES to add extra items for group members to
-# the table of contents of the HTML help documentation and to the tree view.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTMLHELP is set to YES.
-
-TOC_EXPAND             = NO
-
-# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
-# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that
-# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help
-# (.qch) of the generated HTML documentation.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_QHP           = NO
-
-# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify
-# the file name of the resulting .qch file. The path specified is relative to
-# the HTML output folder.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QCH_FILE               = 
-
-# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
-# Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_NAMESPACE          = org.doxygen.Project
-
-# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
-# Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
-# The default value is: doc.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_VIRTUAL_FOLDER     = doc
-
-# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
-# filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_NAME   = 
-
-# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
-# custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_CUST_FILTER_ATTRS  = 
-
-# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
-# project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHP_SECT_FILTER_ATTRS  = 
-
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
-# This tag requires that the tag GENERATE_QHP is set to YES.
-
-QHG_LOCATION           = 
-
-# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be
-# generated, together with the HTML files, they form an Eclipse help plugin. To
-# install this plugin and make it available under the help contents menu in
-# Eclipse, the contents of the directory containing the HTML and XML files needs
-# to be copied into the plugins directory of eclipse. The name of the directory
-# within the plugins directory should be the same as the ECLIPSE_DOC_ID value.
-# After copying Eclipse needs to be restarted before the help appears.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_ECLIPSEHELP   = NO
-
-# A unique identifier for the Eclipse help plugin. When installing the plugin
-# the directory name containing the HTML and XML files should also have this
-# name. Each documentation set should have its own identifier.
-# The default value is: org.doxygen.Project.
-# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES.
-
-ECLIPSE_DOC_ID         = org.doxygen.Project
-
-# If you want full control over the layout of the generated HTML pages it might
-# be necessary to disable the index and replace it with your own. The
-# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top
-# of each HTML page. A value of NO enables the index and the value YES disables
-# it. Since the tabs in the index contain the same information as the navigation
-# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-DISABLE_INDEX          = NO
-
-# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
-# structure should be generated to display hierarchical information. If the tag
-# value is set to YES, a side panel will be generated containing a tree-like
-# index structure (just like the one that is generated for HTML Help). For this
-# to work a browser that supports JavaScript, DHTML, CSS and frames is required
-# (i.e. any modern browser). Windows users are probably better off using the
-# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can
-# further fine-tune the look of the index. As an example, the default style
-# sheet generated by doxygen has an example that shows how to put an image at
-# the root of the tree instead of the PROJECT_NAME. Since the tree basically has
-# the same information as the tab index, you could consider setting
-# DISABLE_INDEX to YES when enabling this option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-GENERATE_TREEVIEW      = YES
-
-# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that
-# doxygen will group on one line in the generated HTML documentation.
-# 
-# Note that a value of 0 will completely suppress the enum values from appearing
-# in the overview section.
-# Minimum value: 0, maximum value: 20, default value: 4.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-ENUM_VALUES_PER_LINE   = 4
-
-# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used
-# to set the initial width (in pixels) of the frame in which the tree is shown.
-# Minimum value: 0, maximum value: 1500, default value: 250.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-TREEVIEW_WIDTH         = 250
-
-# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to
-# external symbols imported via tag files in a separate window.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-EXT_LINKS_IN_WINDOW    = NO
-
-# Use this tag to change the font size of LaTeX formulas included as images in
-# the HTML documentation. When you change the font size after a successful
-# doxygen run you need to manually remove any form_*.png images from the HTML
-# output directory to force them to be regenerated.
-# Minimum value: 8, maximum value: 50, default value: 10.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_FONTSIZE       = 10
-
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
-# generated for formulas are transparent PNGs. Transparent PNGs are not
-# supported properly for IE 6.0, but are supported on all modern browsers.
-# 
-# Note that when changing this option you need to delete any form_*.png files in
-# the HTML output directory before the changes have effect.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-FORMULA_TRANSPARENT    = YES
-
-# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
-# instead of using prerendered bitmaps. Use this if you do not have LaTeX
-# installed or if you want to formulas look prettier in the HTML output. When
-# enabled you may also need to install MathJax separately and configure the path
-# to it using the MATHJAX_RELPATH option.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-USE_MATHJAX            = NO
-
-# When MathJax is enabled you can set the default output format to be used for
-# the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
-# Possible values are: HTML-CSS (which is slower, but has the best
-# compatibility), NativeMML (i.e. MathML) and SVG.
-# The default value is: HTML-CSS.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_FORMAT         = HTML-CSS
-
-# When MathJax is enabled you need to specify the location relative to the HTML
-# output directory using the MATHJAX_RELPATH option. The destination directory
-# should contain the MathJax.js script. For instance, if the mathjax directory
-# is located at the same level as the HTML output directory, then
-# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
-# Content Delivery Network so you can quickly see the result without installing
-# MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
-
-# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
-# extension names that should be enabled during MathJax rendering. For example
-# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_EXTENSIONS     = 
-
-# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
-# of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
-# example see the documentation.
-# This tag requires that the tag USE_MATHJAX is set to YES.
-
-MATHJAX_CODEFILE       = 
-
-# When the SEARCHENGINE tag is enabled doxygen will generate a search box for
-# the HTML output. The underlying search engine uses javascript and DHTML and
-# should work on any modern browser. Note that when using HTML help
-# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET)
-# there is already a search function so this one should typically be disabled.
-# For large projects the javascript based search engine can be slow, then
-# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to
-# search using the keyboard; to jump to the search box use <access key> + S
-# (what the <access key> is depends on the OS and browser, but it is typically
-# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down
-# key> to jump into the search results window, the results can be navigated
-# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel
-# the search. The filter options can be selected when the cursor is inside the
-# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys>
-# to select a filter and <Enter> or <escape> to activate or cancel the filter
-# option.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_HTML is set to YES.
-
-SEARCHENGINE           = YES
-
-# When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
-# are two flavours of web server based searching depending on the
-# EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
-# searching and an index file used by the script. When EXTERNAL_SEARCH is
-# enabled the indexing and searching needs to be provided by external tools. See
-# the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SERVER_BASED_SEARCH    = NO
-
-# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP
-# script for searching. Instead the search results are written to an XML file
-# which needs to be processed by an external indexer. Doxygen will invoke an
-# external search engine pointed to by the SEARCHENGINE_URL option to obtain the
-# search results.
-# 
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
-# 
-# See the section "External Indexing and Searching" for details.
-# The default value is: NO.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH        = NO
-
-# The SEARCHENGINE_URL should point to a search engine hosted by a web server
-# which will return the search results when EXTERNAL_SEARCH is enabled.
-# 
-# Doxygen ships with an example indexer ( doxyindexer) and search engine
-# (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHENGINE_URL       = 
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
-# search data is written to a file for indexing by an external tool. With the
-# SEARCHDATA_FILE tag the name of this file can be specified.
-# The default file is: searchdata.xml.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-SEARCHDATA_FILE        = searchdata.xml
-
-# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the
-# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
-# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
-# projects and redirect the results back to the right project.
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTERNAL_SEARCH_ID     = 
-
-# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
-# projects other than the one defined by this configuration file, but that are
-# all added to the same external search index. Each project needs to have a
-# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of
-# to a relative location where the documentation can be found. The format is:
-# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ...
-# This tag requires that the tag SEARCHENGINE is set to YES.
-
-EXTRA_SEARCH_MAPPINGS  = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the LaTeX output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output.
-# The default value is: YES.
-
-GENERATE_LATEX         = NO
-
-# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_OUTPUT           = latex
-
-# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
-# invoked.
-# 
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_CMD_NAME         = latex
-
-# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
-# index for LaTeX.
-# The default file is: makeindex.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-MAKEINDEX_CMD_NAME     = makeindex
-
-# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-COMPACT_LATEX          = NO
-
-# The PAPER_TYPE tag can be used to set the paper type that is used by the
-# printer.
-# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x
-# 14 inches) and executive (7.25 x 10.5 inches).
-# The default value is: a4.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PAPER_TYPE             = a4
-
-# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names
-# that should be included in the LaTeX output. To get the times font for
-# instance you can specify
-# EXTRA_PACKAGES=times
-# If left blank no extra packages will be included.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-EXTRA_PACKAGES         = 
-
-# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the
-# generated LaTeX document. The header should contain everything until the first
-# chapter. If it is left blank doxygen will generate a standard header. See
-# section "Doxygen usage" for information on how to let doxygen write the
-# default header to a separate file.
-# 
-# Note: Only use a user-defined header if you know what you are doing! The
-# following commands have a special meaning inside the header: $title,
-# $datetime, $date, $doxygenversion, $projectname, $projectnumber. Doxygen will
-# replace them by respectively the title of the page, the current date and time,
-# only the current date, the version number of doxygen, the project name (see
-# PROJECT_NAME), or the project number (see PROJECT_NUMBER).
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HEADER           = 
-
-# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the
-# generated LaTeX document. The footer should contain everything after the last
-# chapter. If it is left blank doxygen will generate a standard footer.
-# 
-# Note: Only use a user-defined footer if you know what you are doing!
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_FOOTER           = 
-
-# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or
-# other source files which should be copied to the LATEX_OUTPUT output
-# directory. Note that the files will be copied as-is; there are no commands or
-# markers available.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_EXTRA_FILES      = 
-
-# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is
-# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will
-# contain links (just like the HTML output) instead of page references. This
-# makes the output suitable for online browsing using a PDF viewer.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-PDF_HYPERLINKS         = YES
-
-# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES to get a
-# higher quality PDF documentation.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-USE_PDFLATEX           = YES
-
-# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode
-# command to the generated LaTeX files. This will instruct LaTeX to keep running
-# if errors occur, instead of asking the user for help. This option is also used
-# when generating formulas in HTML.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BATCHMODE        = NO
-
-# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the
-# index chapters (such as File Index, Compound Index, etc.) in the output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_HIDE_INDICES     = NO
-
-# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source
-# code with syntax highlighting in the LaTeX output.
-# 
-# Note that which sources are shown also depends on other settings such as
-# SOURCE_BROWSER.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_SOURCE_CODE      = NO
-
-# The LATEX_BIB_STYLE tag can be used to specify the style to use for the
-# bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
-# The default value is: plain.
-# This tag requires that the tag GENERATE_LATEX is set to YES.
-
-LATEX_BIB_STYLE        = plain
-
-#---------------------------------------------------------------------------
-# Configuration options related to the RTF output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The
-# RTF output is optimized for Word 97 and may not look too pretty with other RTF
-# readers/editors.
-# The default value is: NO.
-
-GENERATE_RTF           = NO
-
-# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: rtf.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_OUTPUT             = rtf
-
-# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF
-# documents. This may be useful for small projects and may help to save some
-# trees in general.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-COMPACT_RTF            = NO
-
-# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will
-# contain hyperlink fields. The RTF file will contain links (just like the HTML
-# output) instead of page references. This makes the output suitable for online
-# browsing using Word or some other Word compatible readers that support those
-# fields.
-# 
-# Note: WordPad (write) and others do not support links.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_HYPERLINKS         = NO
-
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
-# 
-# See also section "Doxygen usage" for information on how to generate the
-# default style sheet that doxygen normally uses.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_STYLESHEET_FILE    = 
-
-# Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
-# This tag requires that the tag GENERATE_RTF is set to YES.
-
-RTF_EXTENSIONS_FILE    = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the man page output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for
-# classes and files.
-# The default value is: NO.
-
-GENERATE_MAN           = NO
-
-# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it. A directory man3 will be created inside the directory specified by
-# MAN_OUTPUT.
-# The default directory is: man.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_OUTPUT             = man
-
-# The MAN_EXTENSION tag determines the extension that is added to the generated
-# man pages. In case the manual section does not start with a number, the number
-# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is
-# optional.
-# The default value is: .3.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_EXTENSION          = .3
-
-# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it
-# will generate one additional man file for each entity documented in the real
-# man page(s). These additional files only source the real man page, but without
-# them the man command would be unable to find the correct page.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_MAN is set to YES.
-
-MAN_LINKS              = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the XML output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that
-# captures the structure of the code including all documentation.
-# The default value is: NO.
-
-GENERATE_XML           = NO
-
-# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a
-# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of
-# it.
-# The default directory is: xml.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_OUTPUT             = xml
-
-# The XML_SCHEMA tag can be used to specify a XML schema, which can be used by a
-# validating XML parser to check the syntax of the XML files.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_SCHEMA             = 
-
-# The XML_DTD tag can be used to specify a XML DTD, which can be used by a
-# validating XML parser to check the syntax of the XML files.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_DTD                = 
-
-# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program
-# listings (including syntax highlighting and cross-referencing information) to
-# the XML output. Note that enabling this will significantly increase the size
-# of the XML output.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_XML is set to YES.
-
-XML_PROGRAMLISTING     = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to the DOCBOOK output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files
-# that can be used to generate PDF.
-# The default value is: NO.
-
-GENERATE_DOCBOOK       = NO
-
-# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put.
-# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in
-# front of it.
-# The default directory is: docbook.
-# This tag requires that the tag GENERATE_DOCBOOK is set to YES.
-
-DOCBOOK_OUTPUT         = docbook
-
-#---------------------------------------------------------------------------
-# Configuration options for the AutoGen Definitions output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen
-# Definitions (see http://autogen.sf.net) file that captures the structure of
-# the code including all documentation. Note that this feature is still
-# experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_AUTOGEN_DEF   = NO
-
-#---------------------------------------------------------------------------
-# Configuration options related to the Perl module output
-#---------------------------------------------------------------------------
-
-# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module
-# file that captures the structure of the code including all documentation.
-# 
-# Note that this feature is still experimental and incomplete at the moment.
-# The default value is: NO.
-
-GENERATE_PERLMOD       = NO
-
-# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary
-# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI
-# output from the Perl module output.
-# The default value is: NO.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_LATEX          = NO
-
-# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely
-# formatted so it can be parsed by a human reader. This is useful if you want to
-# understand what is going on. On the other hand, if this tag is set to NO the
-# size of the Perl module output will be much smaller and Perl will parse it
-# just the same.
-# The default value is: YES.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_PRETTY         = YES
-
-# The names of the make variables in the generated doxyrules.make file are
-# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful
-# so different doxyrules.make files included by the same Makefile don't
-# overwrite each other's variables.
-# This tag requires that the tag GENERATE_PERLMOD is set to YES.
-
-PERLMOD_MAKEVAR_PREFIX = 
-
-#---------------------------------------------------------------------------
-# Configuration options related to the preprocessor
-#---------------------------------------------------------------------------
-
-# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all
-# C-preprocessor directives found in the sources and include files.
-# The default value is: YES.
-
-ENABLE_PREPROCESSING   = YES
-
-# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names
-# in the source code. If set to NO only conditional compilation will be
-# performed. Macro expansion can be done in a controlled way by setting
-# EXPAND_ONLY_PREDEF to YES.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-MACRO_EXPANSION        = YES
-
-# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
-# the macro expansion is limited to the macros specified with the PREDEFINED and
-# EXPAND_AS_DEFINED tags.
-# The default value is: NO.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_ONLY_PREDEF     = YES
-
-# If the SEARCH_INCLUDES tag is set to YES the includes files in the
-# INCLUDE_PATH will be searched if a #include is found.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SEARCH_INCLUDES        = YES
-
-# The INCLUDE_PATH tag can be used to specify one or more directories that
-# contain include files that are not input files but should be processed by the
-# preprocessor.
-# This tag requires that the tag SEARCH_INCLUDES is set to YES.
-
-INCLUDE_PATH           = "../../include/mathfu/"
-
-# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
-# patterns (like *.h and *.hpp) to filter out the header-files in the
-# directories. If left blank, the patterns specified with FILE_PATTERNS will be
-# used.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-INCLUDE_FILE_PATTERNS  = 
-
-# The PREDEFINED tag can be used to specify one or more macro names that are
-# defined before the preprocessor is started (similar to the -D option of e.g.
-# gcc). The argument of the tag is a list of macros of the form: name or
-# name=definition (no spaces). If the definition and the "=" are omitted, "=1"
-# is assumed. To prevent a macro definition from being undefined via #undef or
-# recursively expanded use the := operator instead of the = operator.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-PREDEFINED             = DOXYGEN \
-                         __ANDROID__ \
-                         __attribute__(x)= \
-                         MATHFU_COMPILE_WITH_SIMD
-
-# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this
-# tag can be used to specify a list of macro names that should be expanded. The
-# macro definition that is found in the sources will be used. Use the PREDEFINED
-# tag if you want to use a different macro definition that overrules the
-# definition found in the source code.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-EXPAND_AS_DEFINED      = 
-
-# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
-# remove all refrences to function-like macros that are alone on a line, have an
-# all uppercase name, and do not end with a semicolon. Such function macros are
-# typically used for boiler-plate code, and will confuse the parser if not
-# removed.
-# The default value is: YES.
-# This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
-
-SKIP_FUNCTION_MACROS   = YES
-
-#---------------------------------------------------------------------------
-# Configuration options related to external references
-#---------------------------------------------------------------------------
-
-# The TAGFILES tag can be used to specify one or more tag files. For each tag
-# file the location of the external documentation should be added. The format of
-# a tag file without this location is as follows:
-# TAGFILES = file1 file2 ...
-# Adding location for the tag files is done as follows:
-# TAGFILES = file1=loc1 "file2 = loc2" ...
-# where loc1 and loc2 can be relative or absolute paths or URLs. See the
-# section "Linking to external documentation" for more information about the use
-# of tag files.
-# Note: Each tag file must have an unique name (where the name does NOT include
-# the path). If a tag file is not located in the directory in which doxygen is
-# run, you must also specify the path to the tagfile here.
-
-TAGFILES               = 
-
-# When a file name is specified after GENERATE_TAGFILE, doxygen will create a
-# tag file that is based on the input files it reads. See section "Linking to
-# external documentation" for more information about the usage of tag files.
-
-GENERATE_TAGFILE       = 
-
-# If the ALLEXTERNALS tag is set to YES all external class will be listed in the
-# class index. If set to NO only the inherited external classes will be listed.
-# The default value is: NO.
-
-ALLEXTERNALS           = NO
-
-# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in
-# the modules index. If set to NO, only the current project's groups will be
-# listed.
-# The default value is: YES.
-
-EXTERNAL_GROUPS        = NO
-
-# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in
-# the related pages index. If set to NO, only the current project's pages will
-# be listed.
-# The default value is: YES.
-
-EXTERNAL_PAGES         = YES
-
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
-#---------------------------------------------------------------------------
-# Configuration options related to the dot tool
-#---------------------------------------------------------------------------
-
-# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram
-# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to
-# NO turns the diagrams off. Note that this option also works with HAVE_DOT
-# disabled, but it is recommended to install and use dot, since it yields more
-# powerful graphs.
-# The default value is: YES.
-
-CLASS_DIAGRAMS         = NO
-
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            =
-
-# If set to YES, the inheritance and collaboration graphs will hide inheritance
-# and usage relations if the target is undocumented or is not a class.
-# The default value is: YES.
-
-HIDE_UNDOC_RELATIONS   = YES
-
-# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
-# available from the path. This tool is part of Graphviz (see:
-# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent
-# Bell Labs. The other options in this section have no effect if this option is
-# set to NO
-# The default value is: NO.
-
-HAVE_DOT               = NO
-
-# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed
-# to run in parallel. When set to 0 doxygen will base this on the number of
-# processors available in the system. You can set it explicitly to a value
-# larger than 0 to get control over the balance between CPU load and processing
-# speed.
-# Minimum value: 0, maximum value: 32, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_NUM_THREADS        = 0
-
-# When you want a differently looking font n the dot files that doxygen
-# generates you can specify the font name using DOT_FONTNAME. You need to make
-# sure dot is able to find the font, which can be done by putting it in a
-# standard location or by setting the DOTFONTPATH environment variable or by
-# setting DOT_FONTPATH to the directory containing the font.
-# The default value is: Helvetica.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTNAME           = Helvetica
-
-# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of
-# dot graphs.
-# Minimum value: 4, maximum value: 24, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTSIZE           = 10
-
-# By default doxygen will tell dot to use the default font as specified with
-# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set
-# the path where dot can find it using this tag.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_FONTPATH           = 
-
-# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for
-# each documented class showing the direct and indirect inheritance relations.
-# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CLASS_GRAPH            = YES
-
-# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a
-# graph for each documented class showing the direct and indirect implementation
-# dependencies (inheritance, containment, and class references variables) of the
-# class with other documented classes.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-COLLABORATION_GRAPH    = YES
-
-# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for
-# groups, showing the direct groups dependencies.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GROUP_GRAPHS           = YES
-
-# If the UML_LOOK tag is set to YES doxygen will generate inheritance and
-# collaboration diagrams in a style similar to the OMG's Unified Modeling
-# Language.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LOOK               = NO
-
-# If the UML_LOOK tag is enabled, the fields and methods are shown inside the
-# class node. If there are many fields or methods and many nodes the graph may
-# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the
-# number of items for each type to make the size more manageable. Set this to 0
-# for no limit. Note that the threshold may be exceeded by 50% before the limit
-# is enforced. So when you set the threshold to 10, up to 15 fields may appear,
-# but if the number exceeds 15, the total amount of fields shown is limited to
-# 10.
-# Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-UML_LIMIT_NUM_FIELDS   = 10
-
-# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
-# collaboration graphs will show the relations between templates and their
-# instances.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-TEMPLATE_RELATIONS     = NO
-
-# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to
-# YES then doxygen will generate a graph for each documented file showing the
-# direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDE_GRAPH          = YES
-
-# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are
-# set to YES then doxygen will generate a graph for each documented file showing
-# the direct and indirect include dependencies of the file with other documented
-# files.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INCLUDED_BY_GRAPH      = YES
-
-# If the CALL_GRAPH tag is set to YES then doxygen will generate a call
-# dependency graph for every global function or class method.
-# 
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable call graphs for selected
-# functions only using the \callgraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALL_GRAPH             = NO
-
-# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller
-# dependency graph for every global function or class method.
-# 
-# Note that enabling this option will significantly increase the time of a run.
-# So in most cases it will be better to enable caller graphs for selected
-# functions only using the \callergraph command.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-CALLER_GRAPH           = NO
-
-# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical
-# hierarchy of all classes instead of a textual one.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GRAPHICAL_HIERARCHY    = YES
-
-# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the
-# dependencies a directory has on other directories in a graphical way. The
-# dependency relations are determined by the #include relations between the
-# files in the directories.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DIRECTORY_GRAPH        = YES
-
-# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
-# generated by dot.
-# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order
-# to make the SVG files visible in IE 9+ (other browsers do not have this
-# requirement).
-# Possible values are: png, jpg, gif and svg.
-# The default value is: png.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_IMAGE_FORMAT       = png
-
-# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
-# enable generation of interactive SVG images that allow zooming and panning.
-# 
-# Note that this requires a modern browser other than Internet Explorer. Tested
-# and working are Firefox, Chrome, Safari, and Opera.
-# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make
-# the SVG files visible. Older versions of IE do not have SVG support.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-INTERACTIVE_SVG        = NO
-
-# The DOT_PATH tag can be used to specify the path where the dot tool can be
-# found. If left blank, it is assumed the dot tool can be found in the path.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_PATH               = 
-
-# The DOTFILE_DIRS tag can be used to specify one or more directories that
-# contain dot files that are included in the documentation (see the \dotfile
-# command).
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOTFILE_DIRS           = 
-
-# The MSCFILE_DIRS tag can be used to specify one or more directories that
-# contain msc files that are included in the documentation (see the \mscfile
-# command).
-
-MSCFILE_DIRS           = 
-
-# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes
-# that will be shown in the graph. If the number of nodes in a graph becomes
-# larger than this value, doxygen will truncate the graph, which is visualized
-# by representing a node as a red box. Note that doxygen if the number of direct
-# children of the root node in a graph is already larger than
-# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that
-# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
-# Minimum value: 0, maximum value: 10000, default value: 50.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_GRAPH_MAX_NODES    = 50
-
-# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs
-# generated by dot. A depth value of 3 means that only nodes reachable from the
-# root by following a path via at most 3 edges will be shown. Nodes that lay
-# further from the root node will be omitted. Note that setting this option to 1
-# or 2 may greatly reduce the computation time needed for large code bases. Also
-# note that the size of a graph can be further restricted by
-# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
-# Minimum value: 0, maximum value: 1000, default value: 0.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-MAX_DOT_GRAPH_DEPTH    = 0
-
-# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
-# background. This is disabled by default, because dot on Windows does not seem
-# to support this out of the box.
-# 
-# Warning: Depending on the platform used, enabling this option may lead to
-# badly anti-aliased labels on the edges of a graph (i.e. they become hard to
-# read).
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_TRANSPARENT        = NO
-
-# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
-# files in one run (i.e. multiple -o and -T options on the command line). This
-# makes dot run faster, but since only newer versions of dot (>1.8.10) support
-# this, this feature is disabled by default.
-# The default value is: NO.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_MULTI_TARGETS      = NO
-
-# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page
-# explaining the meaning of the various boxes and arrows in the dot generated
-# graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-GENERATE_LEGEND        = YES
-
-# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot
-# files that are used to generate the various graphs.
-# The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
-
-DOT_CLEANUP            = YES
diff --git a/third_party/mathfu-1.1.0/docs/src/doxygen_layout.xml b/third_party/mathfu-1.1.0/docs/src/doxygen_layout.xml
deleted file mode 100644
index bca1c7b..0000000
--- a/third_party/mathfu-1.1.0/docs/src/doxygen_layout.xml
+++ /dev/null
@@ -1,370 +0,0 @@
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<doxygenlayout version="1.0">
-  <navindex>
-    <tab type="mainpage" visible="no" title=""/>
-    <tab type="usergroup" url="" title="Programmer's Guide">
-      <tab type="usergroup" url="@ref mathfu_guide_introduction"
-           title="Introduction">
-        <tab type="user" url="@ref mathfu_guide_about_mathfu"
-             title="About MathFu"/>
-        <tab type="user" url="@ref mathfu_guide_prerequisites"
-             title="Prerequisites"/>
-        <tab type="user" url="@ref mathfu_guide_about_guide"
-             title="About This Guide"/>
-        <tab type="user" url="@ref mathfu_guide_concepts"
-             title="Concepts"/>
-        <tab type="user" url="@ref mathfu_guide_optimization"
-             title="Optimization"/>
-      </tab>
-      <tab type="usergroup" url="@ref mathfu_guide_building"
-           title="Building">
-        <tab type="user" url="@ref mathfu_guide_building_options"
-             title="Integration Options"/>
-        <tab type="user" url="@ref mathfu_guide_building_compiler_config"
-             title="Manual Compiler Configuration"/>
-        <tab type="user" url="@ref mathfu_guide_building_cmake"
-             title="CMake"/>
-        <tab type="user" url="@ref mathfu_guide_building_android_makefiles"
-             title="Android NDK Makefiles"/>
-        <tab type="usergroup" url="" title="Building Unit Tests">
-          <tab type="usergroup" url="@ref mathfu_guide_building_android"
-               title="Building for Android">
-            <tab type="user" url="@ref mathfu_guide_building_android_version"
-                 title="Version Requirements"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_prerequisites"
-                 title="Prerequisites"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_building"
-                 title="Building"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_building_ndk_build"
-                 title="Building with ndk-build"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_building_fplutil"
-                 title="Building with fplutil"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_running"
-                 title="Installing and Running Applications"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_eclipse"
-                 title="Using Eclipse"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_fplutil"
-                 title="Using fplutil"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_android_code_generation"
-                 title="Code Generation"/>
-          </tab>
-          <tab type="usergroup" url="@ref mathfu_guide_building_linux"
-               title="Building for Linux">
-            <tab type="user" url="@ref mathfu_guide_building_linux_version"
-                 title="Version Requirements"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_linux_prerequisites"
-                 title="Prerequisites"/>
-            <tab type="user" url="@ref mathfu_guide_building_linux_building"
-                 title="Building"/>
-            <tab type="user" url="@ref mathfu_guide_building_linux_running"
-                 title="Running Applications"/>
-          </tab>
-          <tab type="usergroup" url="@ref mathfu_guide_building_osx"
-               title="Building for OS X">
-            <tab type="user" url="@ref mathfu_guide_building_osx_version"
-                 title="Version Requirements"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_osx_prerequisites"
-                 title="Prerequisites"/>
-            <tab type="user" url="@ref mathfu_guide_building_osx_building"
-                 title="Building with Xcode"/>
-            <tab type="user" url="@ref mathfu_guide_building_osx_running"
-                 title="Running Applications"/>
-          </tab>
-          <tab type="usergroup" url="@ref mathfu_guide_building_windows"
-               title="Building for Windows">
-            <tab type="user" url="@ref mathfu_guide_building_windows_version"
-                 title="Version Requirements"/>
-            <tab type="user"
-                 url="@ref mathfu_guide_building_windows_prerequisites"
-                 title="Prerequisites"/>
-            <tab type="user" url="@ref mathfu_guide_building_windows_building"
-                 title="Building with Visual Studio"/>
-            <tab type="user" url="@ref mathfu_guide_building_windows_running"
-                 title="Running Applications"/>
-          </tab>
-        </tab>
-      </tab>
-      <tab type="usergroup" url="@ref mathfu_guide_vectors"
-           title="Vectors">
-        <tab type="usergroup" url="@ref mathfu_guide_vectors_declaration"
-             title="Declaration">
-          <tab type="user" url="@ref mathfu_guide_vectors_initialization"
-               title="Initialization"/>
-        </tab>
-        <tab type="usergroup" url="@ref mathfu_guide_vectors_accessors"
-             title="Accessors">
-          <tab type="user" url="@ref mathfu_guide_vectors_assignment"
-               title="Assignment"/>
-        </tab>
-        <tab type="user" url="@ref mathfu_guide_vectors_arithmetic"
-             title="Arithmetic"/>
-        <tab type="user" url="@ref mathfu_guide_vectors_constants"
-             title="Constants"/>
-        <tab type="user" url="@ref mathfu_guide_vectors_geometric"
-             title="Geometric Operations"/>
-        <tab type="user" url="@ref mathfu_guide_vectors_other"
-             title="Other Operations"/>
-        <tab type="user" url="@ref mathfu_guide_vectors_packing"
-             title="Packing"/>
-      </tab>
-      <tab type="usergroup" url="@ref mathfu_guide_quaternions"
-           title="Quaternions">
-        <tab type="usergroup" url="@ref mathfu_guide_quaternions_declaration"
-             title="Declaration">
-          <tab type="user" url="@ref mathfu_guide_quaternions_initialization"
-               title="Initialization"/>
-        </tab>
-        <tab type="usergroup" url="@ref mathfu_guide_quaternions_accessors"
-             title="Accessors">
-          <tab type="user" url="@ref mathfu_guide_quaternions_assignment"
-               title="Assignment"/>
-        </tab>
-        <tab type="user" url="@ref mathfu_guide_quaternions_repr"
-             title="Converting Between Representations"/>
-        <tab type="user" url="@ref mathfu_guide_quaternions_manipulation"
-             title="Manipulation"/>
-        <tab type="user" url="@ref mathfu_guide_quaternions_application"
-             title="Application"/>
-      </tab>
-      <tab type="usergroup" url="@ref mathfu_guide_matrices"
-           title="Matrices">
-        <tab type="usergroup" url="@ref mathfu_guide_matrices_declaration"
-             title="Declaration">
-          <tab type="user" url="@ref mathfu_guide_matrices_initialization"
-               title="Initialization"/>
-        </tab>
-        <tab type="usergroup" url="@ref mathfu_guide_matrices_accessors"
-             title="Accessors">
-          <tab type="user" url="@ref mathfu_guide_matrices_assignment"
-               title="Assignment"/>
-        </tab>
-        <tab type="user" url="@ref mathfu_guide_matrices_arithmetic"
-             title="Arithmetic"/>
-        <tab type="user" url="@ref mathfu_guide_matrices_matrix_ops"
-             title="Matrix Operations"/>
-        <tab type="user" url="@ref mathfu_guide_matrices_packing"
-             title="Packing"/>
-      </tab>
-      <tab type="usergroup" url="@ref mathfu_guide_utilities"
-           title="Utilities">
-        <tab type="user" url="@ref mathfu_guide_utilities_allocation"
-             title="Memory Allocation"/>
-        <tab type="usergroup" url="@ref mathfu_guide_utilities_misc"
-             title="Miscellaneous Functions">
-          <tab type="user" url="@ref mathfu_guide_utilities_random"
-               title="Random Number Generation"/>
-        </tab>
-      </tab>
-    </tab>
-    <tab type="usergroup" url="@ref mathfu_api_reference"
-         title="API reference">
-      <tab type="modules" visible="yes" title="" intro=""/>
-      <tab type="classes" visible="yes" title="">
-        <tab type="classlist" visible="yes" title="" intro=""/>
-        <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/>
-        <tab type="hierarchy" visible="yes" title="" intro=""/>
-        <tab type="classmembers" visible="yes" title="" intro=""/>
-      </tab>
-      <tab type="files" visible="yes" title="">
-        <tab type="filelist" visible="yes" title="" intro=""/>
-        <tab type="globals" visible="yes" title="" intro=""/>
-      </tab>
-      <!--tab type="examples" visible="yes" title="" intro=""/-->
-    </tab>
-    <tab type="user" url="@ref mathfu_readme" title="readme"/>
-    <tab type="user" url="@ref contributing" title="contributing"/>
-  </navindex>
-
-  <!-- Layout definition for a class page -->
-  <class>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <inheritancegraph visible="$CLASS_GRAPH"/>
-    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
-    <detaileddescription title=""/>
-    <memberdecl>
-      <nestedclasses visible="yes" title=""/>
-      <publictypes title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <publicslots title=""/>
-      <signals title=""/>
-      <publicmethods title=""/>
-      <publicstaticmethods title=""/>
-      <publicattributes title=""/>
-      <publicstaticattributes title=""/>
-      <protectedtypes title=""/>
-      <protectedslots title=""/>
-      <protectedmethods title=""/>
-      <protectedstaticmethods title=""/>
-      <protectedattributes title=""/>
-      <protectedstaticattributes title=""/>
-      <packagetypes title=""/>
-      <packagemethods title=""/>
-      <packagestaticmethods title=""/>
-      <packageattributes title=""/>
-      <packagestaticattributes title=""/>
-      <properties title=""/>
-      <events title=""/>
-      <privatetypes title=""/>
-      <privateslots title=""/>
-      <privatemethods title=""/>
-      <privatestaticmethods title=""/>
-      <privateattributes title=""/>
-      <privatestaticattributes title=""/>
-      <friends title=""/>
-      <related title="" subtitle=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <services title=""/>
-      <interfaces title=""/>
-      <constructors title=""/>
-      <functions title=""/>
-      <related title=""/>
-      <variables title=""/>
-      <properties title=""/>
-      <events title=""/>
-    </memberdef>
-    <allmemberslink visible="yes"/>
-    <usedfiles visible="$SHOW_USED_FILES"/>
-    <authorsection visible="yes"/>
-  </class>
-
-  <!-- Layout definition for a namespace page -->
-  <namespace>
-    <briefdescription visible="yes"/>
-    <memberdecl>
-      <nestednamespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-    <memberdef>
-      <inlineclasses title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </namespace>
-
-  <!-- Layout definition for a file page -->
-  <file>
-    <briefdescription visible="yes"/>
-    <includes visible="$SHOW_INCLUDE_FILES"/>
-    <includegraph visible="$INCLUDE_GRAPH"/>
-    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
-    <sourcelink visible="yes"/>
-    <detaileddescription title=""/>
-    <memberdecl>
-      <classes visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <constantgroups visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <memberdef>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <functions title=""/>
-      <variables title=""/>
-    </memberdef>
-    <authorsection/>
-  </file>
-
-  <!-- Layout definition for a group page -->
-  <group>
-    <briefdescription visible="yes"/>
-    <groupgraph visible="$GROUP_GRAPHS"/>
-    <detaileddescription title=""/>
-    <memberdecl>
-      <nestedgroups visible="yes" title=""/>
-      <dirs visible="yes" title=""/>
-      <files visible="yes" title=""/>
-      <namespaces visible="yes" title=""/>
-      <classes visible="yes" title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-      <membergroups visible="yes"/>
-    </memberdecl>
-    <memberdef>
-      <pagedocs/>
-      <inlineclasses title=""/>
-      <defines title=""/>
-      <typedefs title=""/>
-      <enums title=""/>
-      <enumvalues title=""/>
-      <functions title=""/>
-      <variables title=""/>
-      <signals title=""/>
-      <publicslots title=""/>
-      <protectedslots title=""/>
-      <privateslots title=""/>
-      <events title=""/>
-      <properties title=""/>
-      <friends title=""/>
-    </memberdef>
-    <authorsection visible="yes"/>
-  </group>
-
-  <!-- Layout definition for a directory page -->
-  <directory>
-    <briefdescription visible="yes"/>
-    <directorygraph visible="yes"/>
-    <memberdecl>
-      <dirs visible="yes"/>
-      <files visible="yes"/>
-    </memberdecl>
-    <detaileddescription title=""/>
-  </directory>
-</doxygenlayout>
diff --git a/third_party/mathfu-1.1.0/docs/src/groups b/third_party/mathfu-1.1.0/docs/src/groups
deleted file mode 100644
index 1348fac..0000000
--- a/third_party/mathfu-1.1.0/docs/src/groups
+++ /dev/null
@@ -1,28 +0,0 @@
-
-/// @defgroup mathfu_build_config Build Configuration
-/// @brief Macros that control build configuration.
-
-/// @defgroup mathfu_allocator Allocators
-/// @brief SIMD-safe memory allocators.
-
-/// @defgroup mathfu_constants Constants
-/// @brief Vector constants for specific dimensions.
-
-/// @defgroup mathfu_vector Vectors
-/// @brief Vector class and functions.
-
-/// @defgroup mathfu_matrix Matrices
-/// @brief Matrix class and functions.
-
-/// @defgroup mathfu_quaternion Quaternions
-/// @brief Quaternion class and functions.
-
-/// @defgroup mathfu_glsl GLSL Mappings
-/// @brief <a href="https://www.opengl.org/documentation/glsl/">GLSL</a>
-/// compatible data types.
-
-/// @defgroup mathfu_utilities Utility Functions
-/// @brief Utility functions.
-
-/// @defgroup mathfu_version Version Constants
-/// @brief Macros and variables that describe the library version.
diff --git a/third_party/mathfu-1.1.0/docs/src/index.md b/third_party/mathfu-1.1.0/docs/src/index.md
deleted file mode 100644
index 546a833..0000000
--- a/third_party/mathfu-1.1.0/docs/src/index.md
+++ /dev/null
@@ -1,79 +0,0 @@
-MathFu    {#mathfu_index}
-======
-
-# Overview    {#mathfu_overview}
-
-[MathFu][] is a C++ math library developed primarily for games focused on
-simplicity and efficiency.
-
-It provides a suite of [vector][], [matrix][] and [quaternion][] classes
-to perform basic [geometry][] suitable for game developers.  This functionality
-can be used to construct geometry for graphics libraries like [OpenGL][] or
-perform calculations for animation or physics systems.
-
-[MathFu] can be downloaded from [GitHub](http://github.com/google/mathfu) or
-the [releases page](http://github.com/google/mathfu/releases).
-
-**Important**: MathFu uses submodules to reference other components it depends
-upon so download the source using:
-
-~~~{.sh}
-    git clone --recursive https://github.com/google/mathfu.git
-~~~
-
-# Functionality
-
-Each [vector][], [matrix][] and [quaternion][] class implements basic
-arithmetic operators (addition, subtraction, multiplication, division) in
-addition to simple [linear algebra][] operators (e.g dot product,
-cross product, inverse, slerp).
-
-# Optimization
-
-[MathFu][] is optimized using [SIMD][] instructions (including [NEON][] for
-[ARM][] and [SSE][] for [x86][] architectures).  [SIMD][] optimization is
-enabled by default based upon the target platform and compiler options used
-to build a project.  In addition, [MathFu][] provides compile time options to
-modify code generation, see [Build Configurations][] for more details.
-
-# Supported Platforms
-
-[MathFu][] has been tested on the following platforms:
-
-   * [Android][]
-   * [Linux][] (x86_64)
-   * [OS X][]
-   * [Windows][]
-
-This library is entirely written in C++ with the exception of some
-conditionally enabled compiler intrinsics and some workarounds for different
-compiler quirks, which means that it *should* work with either no or little
-modification on any platform that has a C++ compiler.
-
-# Feedback and Reporting Bugs
-
-   * Discuss MathFu with other developers and users on the
-     [MathFu Google Group][].
-   * File issues on the [MathFu Issues Tracker][].
-   * Post your questions to [stackoverflow.com][] with a mention of **mathfu**.
-
-  [Android]: http://www.android.com
-  [ARM]: http://en.wikipedia.org/wiki/ARM_architecture
-  [Build Configurations]: @ref mathfu_build_config
-  [Linux]: http://en.m.wikipedia.org/wiki/Linux
-  [MathFu Google Group]: http://groups.google.com/group/mathfulib
-  [MathFu Issues Tracker]: http://github.com/google/mathfu/issues
-  [MathFu]: @ref mathfu_overview
-  [NEON]: http://www.arm.com/products/processors/technologies/neon.php
-  [OS X]: http://www.apple.com/osx/
-  [OpenGL]: http://www.opengl.org/
-  [SIMD]: http://en.wikipedia.org/wiki/SIMD
-  [SSE]: http://en.wikipedia.org/wiki/Streaming_SIMD_Extensions
-  [Windows]: http://windows.microsoft.com/
-  [geometry]: http://en.wikipedia.org/wiki/Geometry
-  [linear algebra]: http://en.wikipedia.org/wiki/Linear_algebra
-  [matrix]: http://en.wikipedia.org/wiki/Matrix_(mathematics)
-  [quaternion]: http://en.wikipedia.org/wiki/Quaternion
-  [stackoverflow.com]: http://stackoverflow.com/search?q=mathfu
-  [vector]: http://en.wikipedia.org/wiki/Euclidean_vector
-  [x86]: http://en.wikipedia.org/wiki/X86
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/building.md
deleted file mode 100644
index b9b5dc8..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building.md
+++ /dev/null
@@ -1,177 +0,0 @@
-Building    {#mathfu_guide_building}
-========
-
-# Integration Options    {#mathfu_guide_building_options}
-
-[MathFu][] is designed as a C++ header only library to simplify the process
-of including the library in projects.  [MathFu] provides the following options
-for using it in a project:
-
-   * [Manually configure the compiler][] by simply include the appropriate
-     headers into a project's source code.
-   * Use the [CMake project][].
-   * Include the [Android NDK project][] when developing for [Android][]
-
-Before diving into using [MathFu][] in your project, we recommend you spend
-some time building and running the unit tests for each platform you wish to
-target by working through the following sections:
-
-   * [Building for Android][]
-   * [Building for Linux][]
-   * [Building for OS X][]
-   * [Building for Windows][]
-
-# Manual Compiler Configuration   {#mathfu_guide_building_compiler_config}
-
-The following directories need to be added to the include paths of a project
-to build the default configuration:
-   * `mathfu/include`
-   * `vectorial/include`
-      - If [vectorial][] was downloaded with the [MathFu][] project, this
-        will be located under the `dependencies/` directory.
-
-In addition, to compile with [SIMD][] enabled an architecture specific flag
-must be specified:
-
-Architecture    | Compiler            | Flag
-----------------|---------------------|------------
-[x86][]         | Android GCC / Clang | -msse
-[x86_64][]      | Android GCC / Clang | -msse4.1
-[x86][]         | GCC / Clang         | -msse4.1
-[ARM][]         | GCC / Clang         | -mfpu=neon
-[x86][]         | Visual Studio       | /arch:SSE2
-
-For example, to compile the following file `test.cpp` against [MathFu][] with
-gcc for x86:
-
-~~~{.cpp}
-#include <stdio.h>
-#include "mathfu/vector.h"
-
-int main(int argc, char *argv[]) {
-  mathfu::Vector<float, 3> v1(1.0f, 2.0f, 3.0f), v2(3.0f, 2.5f, 0.5f), v3;
-  v3 = v1 + v2;
-  printf("%.1f %.1f %.1f\n", v3.x(), v3.y(), v3.z());
-  return 0;
-}
-~~~
-
-requires the following command line (assuming vectorial is in the
-`mathfu/dependencies` directory):
-
-~~~{.sh}
-g++ -Imathfu/include -Imathfu/dependencies/vectorial/include test.cpp -msse4.1
-~~~
-
-In addition, [MathFu][] provides a set of build configuration options that
-are controlled using preprocessor symbols described by [Build Configuration][].
-
-# CMake    {#mathfu_guide_building_cmake}
-
-[MathFu][] uses a [CMake][] project to build unit tests and benchmarks
-for [Linux][], [OS X][] and [Windows][].
-
-[CMake][] is used to generate a platform projects for each target platform:
-  * [Makefiles][] ([Linux][] / [OS X][])
-  * [Xcode][] projects ([OS X][])
-  * [Visual Studio][] projects ([Windows][])
-
-If you're not familiar with [CMake][], see the following sections to learn how
-to build on each platform:
-
-   * [Building for Linux][]
-   * [Building for OS X][]
-   * [Building for Windows][]
-
-In addition to building the [MathFu][] unit tests and benchmarks,
-the [MathFu][] [CMake][] project can be used in developers own projects by:
-
-   * Disabling the build of unit tests and benchmarks using the options:
-      - `mathfu_build_benchmarks`
-      - `mathfu_build_tests`
-   * Including the [CMake][] project.
-   * Using the `mathfu_configure_flags` function to add the appropriate
-     include directories and compiler flags for the project.
-
-For example, in a CMakeLists.txt project file which contains the executable
-`mygame`:
-
-~~~
-# Include MathFu in this project with test and benchmark builds disabled
-# then add MathFu compiler flags to the mygame build target.
-set(mathfu_build_benchmarks OFF CACHE BOOL "")
-set(mathfu_build_tests OFF CACHE BOOL "")
-add_subdirectory(path/to/mathfu mathfu)
-
-mathfu_configure_flags(mygame)
-~~~
-
-[MathFu][] build options (see [Build Configuration][]) can be configured
-with the `mathfu_configure_flags` function using the optional arguments
-`enable_simd` and `force_padding`.  For example:
-
-Function Call                               | Build Configuration
---------------------------------------------|----------------------------------
-`mathfu_configure_flags(mygame)`            | Default, SIMD & padding enabled.
-`mathfu_configure_flags(mygame TRUE FALSE)` | SIMD enabled & padding disabled.
-`mathfu_configure_flags(mygame FALSE)`      | SIMD disabled.
-
-See the function comment in the CMakeLists.txt file for more information.
-
-# Android NDK Makefiles    {#mathfu_guide_building_android_makefiles}
-
-If you're not familiar developing applications with the [Android NDK][],
-see [Building for Android][] first.
-
-To use [MathFu][] with an [Android NDK][] makefile project, add the following
-lines to your project's `Android.mk` file.
-
-~~~{.mk}
-# Add the empty MathFu static library target to configure the project.
-LOCAL_STATIC_LIBRARIES += libmathfu
-
-# This is used to build your project's shared library, this should already
-# be in your Android.mk makefile.
-include $(BUILD_SHARED_LIBRARY)
-
-# Add the directory containing MathFu to the module search path.
-$(call import-add-path,$(abspath path/to/mathfu/..))
-# Import the MathFu project.
-$(call import-module,mathfu/jni)
-~~~
-
-[MathFu][] build options (see [Build Configuration][]) can be configured
-by linking against the different static libraries the [MathFu][] project
-builds:
-
-Library                | Build Configuration
------------------------|--------------------------------------------------
-`libmathfu`            | Default configuration, SIMD and padding enabled.
-`libmathfu_no_padding` | SIMD enabled (if supported), padding disabled.
-`libmathfu_no_simd`    | SIMD disabled, padding disabled.
-
-<br>
-
-  [Android NDK project]: @ref mathfu_guide_building_android_makefiles
-  [Android NDK]: http://developer.android.com/tools/sdk/ndk/index.html
-  [Android]: http://www.android.com
-  [ARM]: http://en.wikipedia.org/wiki/ARM_architecture
-  [Build Configuration]: @ref mathfu_build_config
-  [Building for Android]: @ref mathfu_guide_building_android
-  [Building for Linux]: @ref mathfu_guide_building_linux
-  [Building for OS X]: @ref mathfu_guide_building_osx
-  [Building for Windows]: @ref mathfu_guide_building_windows
-  [CMake project]: @ref mathfu_guide_building_cmake
-  [CMake]: http://www.cmake.org/
-  [Linux]: http://en.m.wikipedia.org/wiki/Linux
-  [Makefiles]: http://www.gnu.org/software/make/
-  [Manually configure the compiler]: @ref mathfu_guide_building_compiler_config
-  [MathFu]: @ref mathfu_overview
-  [OS X]: http://www.apple.com/osx/
-  [SIMD]: http://en.wikipedia.org/wiki/SIMD
-  [Visual Studio]: http://www.visualstudio.com/
-  [Windows]: http://windows.microsoft.com/
-  [Xcode]: http://developer.apple.com/xcode/
-  [vectorial]: http://github.com/scoopr/vectorial
-  [x86]: http://en.wikipedia.org/wiki/X86
-  [x86_64]: http://en.wikipedia.org/wiki/X86
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_android.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_android.md
deleted file mode 100644
index 6f1a40f..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_android.md
+++ /dev/null
@@ -1,159 +0,0 @@
-Building for Android    {#mathfu_guide_building_android}
-====================
-
-# Version Requirements    {#mathfu_guide_building_android_version}
-
-Following are the minimum tested versions of the tools and libraries you
-need to build [MathFu][] for Android:
-
-   * [Android SDK][]:  Android 2.3.3 (API Level 10) or above.
-   * [Android Developer Tools][] ([ADT][]): 20140702
-      - NDK plugn for Eclipse (bundled with [ADT][]) if using Eclipse to build.
-   * [Android NDK][]: android-ndk-r10e
-   * [fplutil][]: 1.0 or above, if using [fplutil][] to build, install and run.
-
-# Prerequisites    {#mathfu_guide_building_android_prerequisites}
-
-Prior to building:
-
-   * Install the [Android SDK][].
-   * Install the [Android NDK][].
-   * Install [fplutil prerequisites][] if using [fplutil][] to build, install
-     and run.
-
-# Building    {#mathfu_guide_building_android_building}
-
-Each [MathFu][] project for Android has an associated `AndroidManifest.xml`
-file and `jni` subdirectory.  Unit tests and benchmarks directories contain
-projects that each build an Android package ([apk][]) which can be installed
-and executed on Android devices.
-
-The following directories in the [MathFu] project contain [Android NDK][]
-projects:
-
-   * `mathfu/`
-      - Rules used to build the [MathFu][] library.
-   * `mathfu/benchmarks`
-      - Each subdirectory under this directory contains a simple benchmark
-        used to measure the performance of different build configurations.
-   * `mathfu/unit_tests`
-      - Each subdirectory under this directory contains a unit test application
-        used to test different components of the library in different build
-        configurations.
-
-## Building with ndk-build  {#mathfu_guide_building_android_building_ndk_build}
-
-To build a single [Android NDK][] project (without packaging the native
-component in an [apk][]):
-
-   * Open a command line window.
-   * Go to the directory containing the project to build.
-   * `ndk-build`
-
-For example, to build the matrix test for the default build configuration
-without generating an [apk][]:
-
-~~~{.sh}
-    cd mathfu/unit_tests/matrix_test/default
-    ndk-build
-~~~
-
-## Building with fplutil    {#mathfu_guide_building_android_building_fplutil}
-
-To build all [Android NDK][] projects, install and run them on a device:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Execute `dependencies/fplutil/bin/build_all_android.py`
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    ./dependencies/fplutil/bin/build_all_android.py
-~~~
-
-# Installing and Running Applications {#mathfu_guide_building_android_running}
-
-## Using Eclipse {#mathfu_guide_building_android_eclipse}
-
-Running a sample requires the [Android Developer Tools][] ([ADT][]) plugin and
-the [NDK Eclipse plugin][].
-
-   * Build a project using `ndk-build`
-     ([see above](@ref mathfu_guide_building_android_building_ndk_build)).
-   * Open [ADT][] Eclipse.
-   * Select "File->Import..." from the menu.
-   * Select "Android > Existing Android Code Into Workspace", and click "Next".
-   * Click the "Browse..." button next to `Root Directory:` and select the
-     project folder (e.g. `mathfu/unit_tests/matrix_test/default`).
-   * Click "Finish". Eclipse imports the project, and displays it in the
-     Package Explorer pane.
-   * Right-click the project, and select "Run->Run As->Android Application"
-      from the menu.
-   * If you do not have a physical device, you must define a virtual one.
-     For details about how to define a virtual device, see [managing avds][].
-     We don’t recommend a virtual device for development.
-   * None of the applications have a visual component so their output is
-     visible via the log ([adb][] logcat).
-
-## Using fplutil {#mathfu_guide_building_android_fplutil}
-
-To install and run a single application:
-
-   * Open a command line window.
-   * Go to the directory containing the project to install and run.
-   * Execute `dependencies/fplutil/bin/build_all_android.py` with the `-i`
-     and `-r` options.
-
-For example:
-
-~~~{.sh}
-    cd mathfu/unit_tests/matrix_test/default
-    ./dependencies/fplutil/bin/build_all_android.py -i -r
-~~~
-
-To install and run all applications:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Execute `dependencies/fplutil/bin/build_all_android.py` with the `-i`
-     and `-r` options.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    ./dependencies/fplutil/bin/build_all_android.py -i -r
-~~~
-
-# Code Generation    {#mathfu_guide_building_android_code_generation}
-
-By default, code is generated for devices that support the `armeabi-v7a`
-ABI.  Alternatively, you can generate a fat `.apk` that includes code for all
-ABIs.  To do so, override APP\_ABI on ndk-build's command line.
-
-Using `ndk-build`:
-
-~~~{.sh}
-    ndk-build APP_ABI=all
-~~~
-
-Using `fplutil`:
-~~~{.sh}
-    ./dependencies/fplutil/bin/build_all_android.py -f APP_ABI=all
-~~~
-
-<br>
-
-  [MathFu]: @ref mathfu_overview
-  [adb]: http://developer.android.com/tools/help/adb.html
-  [ADT]: http://developer.android.com/tools/sdk/eclipse-adt.html
-  [Android Developer Tools]: http://developer.android.com/sdk/index.html
-  [Android NDK]: http://developer.android.com/tools/sdk/ndk/index.html
-  [Android SDK]: http://developer.android.com/sdk/index.html
-  [NDK Eclipse plugin]: http://developer.android.com/sdk/index.html
-  [apk]: http://en.wikipedia.org/wiki/Android_application_package
-  [fplutil]: http://google.github.io/fplutil
-  [fplutil prerequisites]: http://google.github.io/fplutil/fplutil_prerequisites.html
-  [managing avds]: http://developer.android.com/tools/devices/managing-avds.html
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_linux.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_linux.md
deleted file mode 100644
index 7c3d294..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_linux.md
+++ /dev/null
@@ -1,106 +0,0 @@
-Building for Linux    {#mathfu_guide_building_linux}
-==================
-
-# Version Requirements    {#mathfu_guide_building_linux_version}
-
-Following are the minimum required versions of tools and libraries you
-need to build [MathFu][] for Android:
-
-   * [CMake][]: 2.8.12.1
-
-# Prerequisites    {#mathfu_guide_building_linux_prerequisites}
-
-Prior to building, install the following components using the [Linux][]
-distribution's package manager:
-
-   * [CMake][].  You can also manually install packages from
-     [cmake.org](http://cmake.org).
-
-For example, on [Ubuntu][]:
-
-~~~{.sh}
-    sudo apt-get install cmake
-~~~
-
-# Building    {#mathfu_guide_building_linux_building}
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Generate [Makefiles][] from the [CMake][] project.
-   * Execute `make` to build the unit tests and benchmarks.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    cmake -G'Unix Makefiles' .
-    make
-~~~
-
-To perform a debug build:
-
-~~~{.sh}
-    cd mathfu
-    cmake -G'Unix Makefiles' -DCMAKE_BUILD_TYPE=Debug .
-    make
-~~~
-
-Build targets can be configured using options exposed in
-`mathfu/CMakeLists.txt` by using [CMake]'s `-D` option.
-Build configuration set using the `-D` option is sticky across subsequent
-builds.
-
-For example, if a build is performed using:
-
-~~~{.sh}
-    cd mathfu
-    cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=Debug .
-    make
-~~~
-
-to switch to a release build CMAKE_BUILD_TYPE must be explicitly specified:
-
-~~~{.sh}
-    cd mathfu
-    cmake -G"Unix Makefiles" -DCMAKE_BUILD_TYPE=Release .
-    make
-~~~
-
-# Running Applications    {#mathfu_guide_building_linux_running}
-
-Each benchmark binaries are located in the `benchmarks/` directory and
-unit test binaries are located in the `unit_tests/` directory.
-
-To run all benchmarks:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each benchmark binary in the `benchmarks/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for binary in ./benchmarks/*_benchmarks; do ${binary}; done
-~~~
-
-To run all unit tests:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each unit test binary in the `unit_tests/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for binary in ./unit_tests/*_tests; do ${binary}; done
-~~~
-
-<br>
-
-  [CMake]: http://www.cmake.org/
-  [Linux]: http://en.wikipedia.org/wiki/Linux
-  [Makefiles]: http://www.gnu.org/software/make/
-  [MathFu]: @ref mathfu_overview
-  [Ubuntu]: http://www.ubuntu.com
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_osx.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_osx.md
deleted file mode 100644
index b34512b..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_osx.md
+++ /dev/null
@@ -1,98 +0,0 @@
-Building for OS X    {#mathfu_guide_building_osx}
-=================
-
-# Version Requirements    {#mathfu_guide_building_osx_version}
-
-Following are the minimum required versions of tools and libraries you
-need to build [MathFu][] for [OS X][]:
-
-   * [OS X][]: Mavericks 10.9.1.
-   * [Xcode][]: 5.0.1
-   * [CMake][]: 2.8.12.1
-
-# Prerequisites    {#mathfu_guide_building_osx_prerequisites}
-
-   * Install [Xcode][].
-   * Install [CMake][].
-
-# Building with Xcode    {#mathfu_guide_building_osx_building}
-
-Firstly, the [Xcode][] project needs to be generated using [CMake][]:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Use [CMake][] to generate the [Xcode][] project.
-
-~~~{.sh}
-    cd mathfu
-    cmake -G Xcode .
-~~~
-
-Then the project can be opened in [Xcode][] and built:
-
-   * Double-click on `mathfu/MathFu.xcodeproj` to open the project in
-     [Xcode][].
-   * Select "Product-->Build" from the menu.
-
-# Running Applications    {#mathfu_guide_building_osx_running}
-
-## Running in Xcode    {#mathfu_guide_building_osx_run_xcode}
-
-Open [Xcode][] select a build target and run it:
-
-   * Double-click on `mathfu/MathFu.xcodeproj` to open the project in
-     [Xcode][].
-   * Select an application `Scheme`, for example
-     "matrix_tests-->My Mac 64-bit", from the combo box to the right of the
-     "Run" button.
-   * Click the "Run" button.
-
-## Running from the Command Line {#mathfu_guide_building_osx_cmdline}
-
-To build:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Generate the [Xcode][] project.
-   * Run xcodebuild.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    cmake -G Xcode .
-    xcodebuild
-~~~
-
-To run all benchmarks:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each benchmark binary in the `benchmarks/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for binary in ./benchmarks/Debug/*_benchmarks; do ${binary}; done
-~~~
-
-To run all unit tests:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each unit test binary in the `unit_tests/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for binary in ./unit_tests/Debug/*_tests; do ${binary}; done
-~~~
-
-<br>
-
-  [CMake]: http://www.cmake.org
-  [MathFu]: @ref mathfu_overview
-  [OS X]: http://www.apple.com/osx/
-  [Xcode]: http://developer.apple.com/xcode/
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_windows.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_windows.md
deleted file mode 100644
index a99170b..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/building_windows.md
+++ /dev/null
@@ -1,84 +0,0 @@
-Building for Windows    {#mathfu_guide_building_windows}
-====================
-
-# Version Requirements    {#mathfu_guide_building_windows_version}
-
-Following are the minimum required versions of tools and libraries you
-need to build [MathFu][] for Android:
-
-   * [Windows][]: 7
-   * [Visual Studio][]: 2012
-   * [CMake][]: 2.8.12.1
-
-# Prerequisites    {#mathfu_guide_building_windows_prerequisites}
-
-Prior to building, install the following:
-
-   * [Visual Studio][]
-   * [CMake][] from [cmake.org](http://cmake.org).
-
-# Building with Visual Studio    {#mathfu_guide_building_windows_building}
-
-Generate the [Visual Studio][] project using [CMake][]:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Use [CMake][] to generate the [Visual Studio][] project.
-
-~~~{.sh}
-    cd mathfu
-    cmake -G "Visual Studio 11 2012" .
-~~~
-
-Open the [MathFu][] solution in [Visual Studio][].
-
-   * Double-click on `mathfu/MathFu.sln` to open the solution.
-   * Select "Build-->Build Solution" from the menu.
-
-# Running Applications    {#mathfu_guide_building_windows_running}
-
-## Running in Visual Studio    {#mathfu_guide_building_osx_run_vs}
-
-Open [Visual Studio][] select a build target and run it:
-
-   * Double-click on `mathfu/MathFu.sln` to open the solution in
-     [Visual Studio][].
-   * Right click on a project, for example `matrix_tests`, select
-     "Set as StartUp Project" from the menu.
-   * Select "Debug-->Start Debugging" from the menu.
-
-## Running from the Command Line {#mathfu_guide_building_windows_cmdline}
-
-To run all benchmarks:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each benchmark binary in the `benchmarks/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for %a in (benchmarks\Debug\*.exe) do %a
-~~~
-
-To run all unit tests:
-
-   * Open a command line window.
-   * Go to the [MathFu][] project directory.
-   * Run each unit test binary in the `unit_tests/` directory.
-
-For example:
-
-~~~{.sh}
-    cd mathfu
-    for %a in (unit_tests\Debug\*.exe) do %a
-~~~
-
-<br>
-
-  [CMake]: http://www.cmake.org
-  [MathFu]: @ref mathfu_overview
-  [Visual Studio]: http://www.visualstudio.com/
-  [Windows]: http://windows.microsoft.com/
-
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/introduction.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/introduction.md
deleted file mode 100644
index 325416f..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/introduction.md
+++ /dev/null
@@ -1,80 +0,0 @@
-Introduction    {#mathfu_guide_introduction}
-============
-
-# About MathFu    {#mathfu_guide_about_mathfu}
-
-[MathFu][] is a C++ math library developed primarily for games focused on
-simplicity and efficiency.
-
-It provides a suite of [vector][], [matrix][] and [quaternion][] classes
-to perform basic [geometry][] suitable for game developers.  This functionality
-can be used to construct geometry for graphics libraries like [OpenGL][] or
-perform calculations for animation or physics systems.
-
-# Prerequisites    {#mathfu_guide_prerequisites}
-
-[MathFu][] is written in C++, you are expected to be experienced in C++
-programming. [MathFu][] should not be your first C++ programming project! You
-should be comfortable with compiling, linking, and debugging.
-
-# About This Guide    {#mathfu_guide_about_guide}
-
-This guide provides an overview of the [MathFu] API, it does *not* cover
-every aspect of functionality provided by the library.  The entire API
-is documented by the [API reference][].  In addition, the unit tests
-(under `mathfu/unit_tests`) provide example usage of each class and function
-in the library.
-
-# Concepts    {#mathfu_guide_concepts}
-
-The core functionality of [MathFu][] is provided by the following classes:
-   * [Vector](@ref mathfu::Vector)
-   * [Matrix](@ref mathfu::Matrix)
-   * [Quaternion](@ref mathfu::Quaternion)
-
-Each class is described in the following sections of the guide:
-   * [Vector](@ref mathfu_guide_vectors)
-      - A geometric concept with a magnitude and direction, defined in any
-        dimensional space.
-   * [Matrix](@ref mathfu_guide_matrices)
-      - A set of data organized in rows and columns.
-        [MathFu][] matricies may have any number of rows and columns.
-   * [Quaternion](@ref mathfu_guide_quaternions)
-      - A specific type of four dimensional vector and defines a rotation in
-        three dimensional space.
-
-In addition, [MathFu][] provides a suite of general math functions and method
-that make it easier to handle the special requirements of [SIMD][] data types
-described in the [Utilities](@ref mathfu_guide_utilities) section.
-
-# Optimization    {#mathfu_guide_optimization}
-
-[MathFu][] is optimized using [SIMD][] instructions (including [NEON][] for
-[ARM][] and [SSE][] for [x86][] architectures).  [SIMD][] optimization is
-enabled by default based upon the target platform and compiler options used
-to build a project.  In addition, [MathFu][] provides compile time options to
-modify code generation, see [Build Configurations][] for more details.
-
-## Supporting Additional Architectures
-
-[MathFu][]'s [SIMD][] implementation uses [vectorial][] as an abstraction
-layer for common [SIMD][] instructions and data types.  To support additional
-architectures, contributors can add support for new [SIMD][] instructions and
-data types to the [vectorial][] project and then modify the code in
-mathfu/utilities.h to define the macro <code>MATHFU_COMPILE_WITH_SIMD</code>
-for the new architecture.
-
-  [ARM]: http://en.wikipedia.org/wiki/ARM_architecture
-  [API reference]: @ref mathfu_api_reference
-  [matrix]: http://en.wikipedia.org/wiki/Matrix_(mathematics)
-  [geometry]: http://en.wikipedia.org/wiki/Geometry
-  [vector]: http://en.wikipedia.org/wiki/Euclidean_vector
-  [quaternion]: http://en.wikipedia.org/wiki/Quaternion
-  [OpenGL]: http://www.opengl.org/
-  [MathFu]: @ref mathfu_overview
-  [vectorial]: http://github.com/scoopr/vectorial
-  [SIMD]: http://en.wikipedia.org/wiki/SIMD
-  [SSE]: http://en.wikipedia.org/wiki/Streaming_SIMD_Extensions
-  [x86]: http://en.wikipedia.org/wiki/X86
-  [NEON]: http://www.arm.com/products/processors/technologies/neon.php
-  [Build Configurations]: @ref mathfu_build_config
\ No newline at end of file
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/matrices.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/matrices.md
deleted file mode 100644
index 57ce28e..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/matrices.md
+++ /dev/null
@@ -1,358 +0,0 @@
-Matrices    {#mathfu_guide_matrices}
-========
-
-Matrices consist of a set of elements (usually floating point or integer
-scalars) arranged in rows and columns.  For more information see
-[this description](http://en.wikipedia.org/wiki/Matrix_(mathematics))
-of matrices.
-
-The [MathFu][] [Matrix][] class is a template declared in
-[mathfu/matrix.h](@ref mathfu/matrix.h) which has been specialized and
-optimized for the most regularly used case (floating point elements with
-4 rows and 4 columns).
-Implementing [Matrix][] as a template reduces code duplication, provides
-compile time optimization opportunities through specialization and allows
-users to use the class with any scalar type.
-
-# Declaration  {#mathfu_guide_matrices_declaration}
-
-The [Matrix][] class template takes either 2 or 3 arguments in the form:
-
-    * Matrix<type, number_of_rows_and_columns>
-    * Matrix<type, number_of_rows, number_of_columns>
-
-For example, a floating point 4 row, 4 column (4x4) matrix can be declared
-using either:
-
-~~~{.cpp}
-    mathfu::Matrix<float, 4, 4> matrix;
-~~~
-
-or:
-
-~~~{.cpp}
-    mathfu::Matrix<float, 4> matrix;
-~~~
-
-To eliminate the need for explicit template instantiation for common matrices,
-[GLSL][] style `typedef`s are provided in
-[mathfu/glsl_mappings.h](@ref mathfu/glsl_mappings.h).  Using a [GLSL][]
-style `typedef` a 4x4 floating point matrix variable is declared
-using the following:
-
-~~~{.cpp}
-    mathfu::mat4 matrix;
-~~~
-
-## Initialization  {#mathfu_guide_matrices_initialization}
-
-For efficiency, [Matrix][] is uninitialized when constructed.  Constructors
-are provided for common matrix sizes that allow initialization on construction.
-For example, to initialize a 2x2 floating point matrix:
-
-~~~{.cpp}
-    mathfu::mat2 matrix(1.0f, 2.0f,  // column 0
-                        3.0f, 4.0f); // column 1
-~~~
-
-It's also possible to initialize a [Matrix][] with another instance:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix1(1.0f, 2.0f,  // column 0
-                               3.0f, 4.0f); // column 1
-    mathfu::mat2 matrix2(matrix1);
-~~~
-
-This can also be achieved with:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix1(1.0f, 2.0f,  // column 0
-                               3.0f, 4.0f); // column 1
-    mathfu::mat2 matrix2 = matrix1;
-~~~
-
-# Accessors    {#mathfu_guide_matrices_accessors}
-
-[Matrix][] provides an array operator to retrieve individual elements in a
-flattened array and a parenthesis operator to access an element by row and
-column index.
-
-When using the array operator, the [Matrix][] is indexed by rows then columns.
-For example, a 3x3 matrix will access the following locations:
-
-Array Index | Column | Row
-------------|--------|--------
-0           | 0      | 0
-1           | 0      | 1
-2           | 0      | 2
-3           | 1      | 0
-4           | 1      | 1
-5           | 1      | 2
-6           | 2      | 0
-7           | 2      | 1
-8           | 2      | 2
-
-For example, to access column 1, row 2 of a 3x3 matrix using the array
-operator, use index "5":
-
-~~~{.cpp}
-    const mathfu::mat3 matrix(1.0f, 2.0f, 3.0f,   // column 0
-                              4.0f, 5.0f, 6.0f,   // column 1
-                              7.0f, 8.0f, 9.0f);  // column 2
-    float column1_row2 = matrix[5]; // 6.0f
-~~~
-
-The parenthesis operator allows access to an element by specifying the row
-and column indices directly.  For example, to access column 1, row 2 of a
-3x3 matrix:
-
-~~~{.cpp}
-    const mathfu::mat3 matrix(1.0f, 2.0f, 3.0f,   // column 0
-                              4.0f, 5.0f, 6.0f,   // column 1
-                              7.0f, 8.0f, 9.0f);  // column 2
-    float column1_row2 = matrix(2, 1);
-~~~
-
-
-## Assignment    {#mathfu_guide_matrices_assignment}
-
-[Matrix][] array and parenthesis operators return a reference to an element
-which can be modified by the caller.
-
-For example, to update column 1, row 2 of a 3x3 matrix using the array
-operator:
-
-~~~{.cpp}
-    mathfu::mat3 matrix(1.0f, 2.0f, 3.0f,   // column 0
-                        4.0f, 5.0f, 0.0f,   // column 1
-                        7.0f, 8.0f, 9.0f);  // column 2
-    matrix[5] = 6.0f;
-~~~
-
-To update column 1, row 2 of a 3x3 matrix using the parenthesis operator:
-
-~~~{.cpp}
-    mathfu::mat3 matrix(1.0f, 2.0f, 3.0f,   // column 0
-                        4.0f, 5.0f, 6.0f,   // column 1
-                        7.0f, 0.0f, 9.0f);  // column 2
-    matrix(2, 1) = 8.0f;
-~~~
-
-# Arithmetic    {#mathfu_guide_matrices_arithmetic}
-
-[Matrix][] supports in-place and out-of-place addition and subtraction
-with other matrices and scalars.  Multiplication and division of matrix
-elements is supported with scalars.
-
-For example, two matrices can be added together using the following:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix1(1.0f, 2.0f,
-                               3.0f, 4.0f);
-    const mathfu::mat2 matrix2(5.0f, 6.0f,
-                               7.0f, 8.0f);
-    mathfu::mat2 matrix3 = matrix1 + matrix2;
-~~~
-
-The above preserves the contents of `matrix1` and `matrix2` with the following
-in `matrix3`:
-
-    6.0f,  8.0f
-    10.0f, 12.0f
-
-The same can be achieved with an in-place addition which mutates `matrix1`:
-
-~~~{.cpp}
-    mathfu::mat2 matrix1(1.0f, 2.0f,
-                         3.0f, 4.0f);
-    const mathfu::mat2 matrix2(5.0f, 6.0f,
-                               7.0f, 8.0f);
-    matrix1 += matrix2;
-~~~
-
-Addition with a scalar results in the value being added to all elements.
-For example:
-
-~~~{.cpp}
-    mathfu::mat2 matrix1(1.0f, 2.0f,
-                         3.0f, 4.0f);
-    matrix1 += 1.0f;
-~~~
-
-where `matrix1` contains the following:
-
-    2.0f, 3.0f,
-    4.0f, 5.0f
-
-Subtraction is similar to addition:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix1(1.0f, 2.0f,
-                               3.0f, 4.0f);
-    const mathfu::mat2 matrix2(5.0f, 6.0f,
-                               7.0f, 8.0f);
-    mathfu::mat2 matrix3 = matrix2 - matrix1;
-~~~
-
-where `matrix3` contains the following:
-
-    4.0f, 4.0f,
-    4.0f, 4.0f
-
-Subtraction with a scalar:
-
-~~~{.cpp}
-    mathfu::mat2 matrix1(1.0f, 2.0f,
-                         3.0f, 4.0f);
-    matrix1 -= 1.0f;
-~~~
-
-where `matrix1` contains the following:
-
-    0.0f, 1.0f
-    2.0f, 3.0f
-
-Multiplication with a scalar:
-
-~~~{.cpp}
-    mathfu::mat2 matrix1(1.0f, 2.0f,
-                         3.0f, 4.0f);
-    matrix1 *= 2.0f;
-~~~
-
-where `matrix1` contains the following:
-
-    2.0f, 4.0f
-    6.0f, 8.0f
-
-Division with a scalar:
-
-~~~{.cpp}
-    mathfu::mat2 matrix1(1.0f, 2.0f,
-                         3.0f, 4.0f);
-    matrix1 /= 2.0f;
-~~~
-
-where `matrix1` contains the following:
-
-    0.5f, 1.0f
-    1.5f, 2.0f
-
-# Matrix Operations    {#mathfu_guide_matrices_matrix_ops}
-
-Identity matrices are constructed using
-[Matrix::Identity](@ref mathfu::Matrix::Identity):
-
-~~~{.cpp}
-    mathfu::mat2 identity = mathfu::mat2::Identity();
-~~~
-
-[Matrix][] supports matrix multiplication using the `* operator`.
-
-Matrix multiplication is performed using the `* operator`:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix1(1.0f, 2.0f,
-                               3.0f, 4.0f);
-    const mathfu::mat2 matrix2(5.0f, 6.0f,
-                               7.0f, 8.0f);
-    mathfu::mat2 matrix3 = matrix1 * matrix2;
-~~~
-
-which preserves `matrix1` and `matrix2` while storing the result in
-`matrix3`:
-
-    23.0f, 31.0f
-    34.0f, 46.0f
-
-The [inverse](http://en.wikipedia.org/wiki/Invertible_matrix) of a [Matrix][]
-can be calculated using [Matrix::Inverse](@ref mathfu::Matrix::Inverse):
-
-~~~{.cpp}
-    const mathfu::mat2 matrix(1.0f, 2.0f,
-                              3.0f, 4.0f);
-    const mathfu::mat2 inverse = matrix.Inverse();
-~~~
-
-A [Matrix][] multiplied with its' inverse yields the identity matrix:
-
-~~~{.cpp}
-    const mathfu::mat2 matrix(1.0f, 2.0f,
-                              3.0f, 4.0f);
-    const mathfu::mat2 inverse = matrix.Inverse();
-    const mathfu::mat2 identity = matrix * inverse;
-~~~
-
-[Matrix][] provides a set of static methods that construct
-[transformation matrices][]:
-
-   * [Matrix::FromTranslationVector()](@ref mathfu::Matrix::FromTranslationVector)
-   * [Matrix::FromScaleVector()](@ref mathfu::Matrix::FromScaleVector)
-   * [Matrix::RotationX()](@ref mathfu::Matrix::RotationX)
-   * [Matrix::RotationY()](@ref mathfu::Matrix::RotationY)
-   * [Matrix::RotationZ()](@ref mathfu::Matrix::RotationZ)
-
-Transformation matrices yielded by these operations can be multiplied with
-vector to translate, scale and rotate.  For example, to rotate a 3-dimensional
-vector around the X axis by PI/2 radians (90 degrees):
-
-~~~{.cpp}
-    const mathfu::vec3 vector(1.0f, 2.0f, 3.0f);
-    const mathfu::mat3 rotation_around_x(mathfu::mat3::RotationX(M_PI / 2.0f));
-    const mathfu::vec3 rotated_vector = vector * rotation_around_x;
-~~~
-
-To scale a vector:
-
-~~~{.cpp}
-    const mathfu::vec3 vector(1.0f, 2.0f, 3.0f);
-    const mathfu::mat4 scale_by_2(
-      mathfu::mat4::FromScaleVector(mathfu::vec3(2.0f)));
-    const mathfu::vec3 scaled_vector = scale_by_2 * vector;
-~~~
-
-In addition, a set of static methods are provided to construct
-[camera matrices][]:
-
-   * [Matrix::Perspective()](@ref mathfu::Matrix::Perspective)
-   * [Matrix::Ortho()](@ref mathfu::Matrix::Ortho)
-   * [Matrix::LookAt()](@ref mathfu::Matrix::LookAt)
-
-For example, to construct a perspective matrix:
-
-~~~{.cpp}
-  const mathfu::mat4 perspective_matrix_ = mathfu::mat4::Perspective(
-      1.0f, 16.0f / 9.0f, 1.0f, 100.0f, -1.0f);
-~~~
-
-# Packing    {#mathfu_guide_matrices_packing}
-
-The size of the class can change based upon the [Build Configuration][] so it
-should *not* be treated like a C style array.  To serialize the class to a
-flat array see [VectorPacked][].
-
-For example, to pack (store) a [Matrix] to an array of packed vectors:
-
-~~~{.cpp}
-    mathfu::mat4 matrix(1.0f);
-    mathfu::vec4_packed packed[4];
-    matrix.Pack(packed);
-~~~
-
-To unpack an array of packed vectors:
-
-~~~{.cpp}
-    mathfu::vec4_packed packed[4];
-    mathfu::mat4 matrix(packed);
-~~~
-
-<br>
-
-  [Build Configuration]: @ref mathfu_build_config
-  [GLSL]: http://www.opengl.org/documentation/glsl/
-  [MathFu]: @ref mathfu_overview
-  [Matrix]: @ref mathfu::Matrix
-  [camera matrices]: http://en.wikipedia.org/wiki/3D_projection
-  [transformation matrices]: http://en.wikipedia.org/wiki/Transformation_matrix
-  [transformation matrix]: http://en.wikipedia.org/wiki/Transformation_matrix
-  [VectorPacked]: @ref mathfu::VectorPacked
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/quaternions.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/quaternions.md
deleted file mode 100644
index 370fac4..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/quaternions.md
+++ /dev/null
@@ -1,220 +0,0 @@
-Quaternions    {#mathfu_guide_quaternions}
-===========
-
-[Quaternions] provide a representation of a 3-dimensional orientation or
-rotation.  [Quaternions] are especially useful when interpolating between
-angles to avoid [Gimbal lock][].  For more information, see [this description].
-
-[MathFu] implements a quaternion as the [Quaternion][] class template which is
-constructed from one 3-dimensional [Vector][] and scalar component.  The
-[Quaternion][] template is intended to be instanced with `float` or `double`
-floating point scalar types.
-
-# Declaration  {#mathfu_guide_quaternions_declaration}
-
-The [Quaternions][] template takes a single argument which specifies the
-floating point type of each element in the class:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion;
-~~~
-
-## Initialization  {#mathfu_guide_quaternions_initialization}
-
-For efficiency, [Quaternion][] is uninitialized when constructed.  Constructors
-are provided to initialize the class from a set of scalars, a 3-dimensional
-[Vector][] and a scalar or another [Quaternion][].
-
-For example, to initialize a [Quaternion][] using a set of scalars:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion(0.71f, 0.0f, 0.71f, 0.0f);
-~~~
-
-To initialize a [Quaternion][] from a scalar and 3-dimensional vector
-component:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion(
-        0.50f, mathfu::vec3(0.76f, 0.38f, 0.19f));
-~~~
-
-# Accessors    {#mathfu_guide_quaternions_accessors}
-
-[Quaternion][] provides an array operator to retrieve elements of the object.
-The first index is the scalar component with the remaining 3 indices referring
-to elements in the vector component.
-
-~~~{.cpp}
-    const mathfu::Quaternion<float> quaternion(
-        0.50f, mathfu::vec3(0.76f, 0.38f, 0.19f));
-    float s = quaternion[0];
-    float x = quaternion[1];
-    float y = quaternion[2];
-    float z = quaternion[3];
-~~~
-
-## Assignment    {#mathfu_guide_quaternions_assignment}
-
-The array operator returns a reference to an element in the [Quaternion][]
-which can be updated:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion;
-    quaternion[0] = 0.5f;
-    quaternion[1] = 0.76f;
-    quaternion[2] = 0.38f;
-    quaternion[3] = 0.19f;
-~~~
-
-# Converting Between Representations {#mathfu_guide_quaternions_repr}
-
-[Quaternion][] provides a number of ways to create a rotation or orientation:
-
-   * [Quaternion::FromAngleAxis()](@ref mathfu::Quaternion::FromAngleAxis)
-   * [Quaternion::FromEulerAngles()](@ref mathfu::Quaternion::FromEulerAngles)
-   * [Quaternion::FromMatrix()](@ref mathfu::Quaternion::FromMatrix)
-
-For example, to create a [Quaternion][] which rotates PI / 2 radians around
-the X-axis:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion =
-        mathfu::Quaternion<float>::FromAngleAxis(
-            M_PI / 2.0f, mathfu::vec3(1.0f, 0.0f, 0.0f));
-~~~
-
-The rotation of PI / 2 radians around the X-axis can also be achieved with:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion =
-        mathfu::Quaternion<float>::FromEulerAngles(
-            mathfu::vec3(M_PI / 2.0f, 0.0f, 0.0f));
-~~~
-
-Similarly, a quaternion can be constructed from an existing rotation matrix
-using:
-
-~~~{.cpp}
-    // Assuming rotation_matrix is an existing matrix.
-    mathfu::Quaternion<float> quaternion =
-        mathfu::Quaternion<float>::FromMatrix(rotation_matrix);
-~~~
-
-In addition, methods are provided to calculate an angle / axis pair,
-Euler angles, or rotation matrix from a [Quaternion][]:
-
-   * [Quaternion::ToAngleAxis()](@ref mathfu::Quaternion::ToAngleAxis)
-   * [Quaternion::ToEulerAngles()](@ref mathfu::Quaternion::ToEulerAngles)
-   * [Quaternion::ToMatrix()](@ref mathfu::Quaternion::ToMatrix)
-
-For example, to calculate the angle and axis from a [Quaternion][]:
-
-~~~{.cpp}
-    // Assuming "quaternion" is an existing float quaternion.
-    float angle;
-    mathfu::vec3 axis;
-    quaternion.ToAngleAxis(&angle, &axis);
-~~~
-
-To calculate a vector of Euler angles from a [Quaternion][]
-
-~~~{.cpp}
-    // Assuming "quaternion" is an existing float quaternion.
-    mathfu::vec3 euler_angles = quaternion.ToEulerAngles();
-~~~
-
-Finally, to convert a [Quaternion][] to a rotation matrix:
-
-~~~{.cpp}
-    // Assuming "quaternion" is an existing float quaternion.
-    mathfu::Matrix<float, 3> rotation_matrix = quaternion.ToMatrix();
-~~~
-
-# Manipulation    {#mathfu_guide_quaternions_manipulation}
-
-[Quaternion][] objects can be multiplied with each other to combine their
-rotations.
-
-For example, if a quaternion that rotates by PI / 2 radians around
-the X axis is multiplied by itself it will result in a quaternion that rotates
-by PI radians around the X axis:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion_pi_by_2_around_x =
-        mathfu::Quaternion<float>::FromAngleAxis(
-            M_PI / 2.0f, mathfu::vec3(1.0f, 0.0f, 0.0f));
-    mathfu::Quaternion<float> quaternion_pi_around_x =
-        quaternion_pi_by_2_around_x * quaternion_pi_by_2_around_x;
-~~~
-
-It's also possible to multiply a [Quaternion][] with a scalar to scale the
-existing rotation expressed by the object.
-
-For example, if a quaternion that rotates by PI / 2 radians around
-the X axis is multiplied by 2 it will result in a quaternion that rotates
-by PI radians around the X axis:
-
-~~~{.cpp}
-    mathfu::Quaternion<float> quaternion_pi_by_2_around_x =
-        mathfu::Quaternion<float>::FromAngleAxis(
-            M_PI / 2.0f, mathfu::vec3(1.0f, 0.0f, 0.0f));
-    mathfu::Quaternion<float> quaternion_pi_around_x =
-        quaternion_pi_by_2_around_x * 2.0f;
-~~~
-
-In addition, [Quaternion][] provides the ability to perform
-[spherical linear interpolation][] between two [Quaternion][] objects enabling
-smooth transitions between rotations while avoiding [Gimbal lock][].
-
-For example, the rotation half way between two quaternions can be calculated
-by the following:
-
-~~~{.cpp}
-    // Assuming "quaternion1" and "quaternion2" represent arbitrary rotations.
-    mathfu::Quaternion<float> quaternion3 =
-        mathfu::Quaternion<float>(quaternion1, quaternion2, 0.5f);
-~~~
-
-Finally, the inverse (opposite rotation) of a [Quaternion][] is calculated
-using [Quaternion::Inverse()](@ref mathfu::Quaternion::Inverse).  For example,
-if a [Quaternion][] represents a rotation PI / 2 radians around the X axis
-the rotation -PI / 2 degrees around the X axis can be calculated by:
-
-~~~{.cpp}
-    const mathfu::Quaternion<float> quaternion =
-        mathfu::Quaternion<float>::FromAngleAxis(
-            M_PI / 2.0f, mathfu::vec3(1.0f, 0.0f, 0.0f));
-    mathfu::Quaternion<float> inverse_rotation = quaternion.Inverse();
-~~~
-
-# Application    {#mathfu_guide_quaternions_application}
-
-A rotation expressed by a [Quaternion][] is applied to a [Vector][] by
-multiplying the [Quaternion][] with the [Vector][].
-
-For example, to rotate a [Vector][] by PI / 2 radians around the X axis:
-
-~~~{.cpp}
-    const mathfu::vec3 vector(0.0f, 1.0f, 0.0f);
-    const mathfu::Quaternion<float> quaternion =
-        mathfu::Quaternion<float>::FromAngleAxis(
-            M_PI / 2.0f, mathfu::vec3(1.0f, 0.0f, 0.0f));
-    mathfu::vec3 rotated_vector = quaternion * vector;
-~~~
-
-When  applying rotations to a large number of vectors or points
-(e.g transforming a set of vertices) it is easier to use
-[Quaternion::ToMatrix()](@ref mathfu::Quaternion::ToMatrix) to calculate
-the rotation matrix and apply the same transform to the set of vectors.
-
-<br>
-
-  [Quaternions]: http://en.wikipedia.org/wiki/Quaternion
-  [this description]: http://en.wikipedia.org/wiki/Quaternion
-  [Gimbal lock]: http://en.wikipedia.org/wiki/Gimbal_lock
-  [spherical linear interpolation]: http://en.wikipedia.org/wiki/Slerp
-  [Quaternion]: @ref mathfu::Quaternion
-  [MathFu]: @ref mathfu_overview
-  [Matrix]: @ref mathfu::Matrix
-  [Vector]: @ref mathfu::Vector
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/utilities.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/utilities.md
deleted file mode 100644
index 3816204..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/utilities.md
+++ /dev/null
@@ -1,113 +0,0 @@
-Utilities    {#mathfu_guide_utilities}
-=========
-
-# Memory Allocation    {#mathfu_guide_utilities_allocation}
-
-[MathFu][]'s use of [SIMD][] instructions provides significant performance
-gains in many use cases.  However, some architectures have memory
-alignment requirements for data used by [SIMD][] operations (e.g [SIMD][]
-data structures must be 16-byte aligned on x86).  Some STL implementations do
-not respect data type alignment which makes it more difficult to respect the
-[SIMD][] memory alignment requirements.
-
-In order to adhere to [SIMD][] alignment requirements, [MathFu][] provides a
-dynamic memory allocator [AllocateAligned()][] which ensures data is correctly
-aligned.  Memory allocated by [AllocateAligned()][] **must** be deallocated
-using [FreeAligned()][], for example:
-
-~~~{.cpp}
-   void *memory = mathfu::AllocateAligned(32);
-   mathfu::FreeAligned(memory);
-~~~
-
-The [simd_allocator](@ref mathfu::simd_allocator) class is provided to perform
-aligned memory allocation with STL classes like std::vector.  For example, the
-following constructs a vector of `vec4` which uses the aligned memory
-allocator:
-
-~~~{.cpp}
-    std::vector<vec4, mathfu::simd_allocator<mathfu::vec4>> myvector;
-~~~
-
-The aligned memory allocator uses [MATHFU_ALIGNMENT](@ref MATHFU_ALIGNMENT)
-bytes of additional memory per allocation.  If the additional memory usage
-per allocation is acceptable for an application, the most simple solution
-is to override the global `new` and `delete` operators by adding
-[MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE](@ref MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE)
-to the source file containing an application's entry point (e.g `main.cpp`):
-
-~~~{.cpp}
-#include "mathfu/utilities.h"
-
-MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE
-
-int main(int argc, char *argv[]) {
-  // The application.
-  return 0;
-}
-~~~
-
-# Miscellaneous Functions    {#mathfu_guide_utilities_misc}
-
-[Clamp](@ref mathfu_Clamp) is used to clamp a value within a specified
-range.  For example:
-
-~~~{.cpp}
-    float x = 1.0f;
-    z = mathfu::Clamp(x, 1.0f, 2.0f);  // z = 1.0
-    z = mathfu::Clamp(x, 1.5f, 2.0f);  // z = 1.5
-    z = mathfu::Clamp(x, 0.0f, 0.5f);  // z = 0.5
-~~~
-
-[Lerp](@ref mathfu_Lerp) linearly interpolates between two values of an
-arbitrary type in a specified range.  For example, an object whose position is
-specified by a [Vector][] could be moved over a range as time elapses:
-
-~~~{.cpp}
-    const mathfu::vec2 start(2.0f, 3.0f);
-    const mathfu::vec2 end(10.0f, 0.0f);
-    // Update the position of an object every 100ms.
-    for (float time = 0.0f; time < 1.1f; time += 0.1f) {
-      mathfu::vec2 position = mathfu::Lerp(start, end, time);
-      // Draw object.
-      // Wait 100ms.
-    }
-~~~
-
-## Random Number Generation    {#mathfu_guide_utilities_random}
-
-[Random()][] generates pseudo random floating point numbers using `rand()`
-from the C standard library.  For example, the following generates 3 random
-numbers:
-
-~~~{.cpp}
-    float value1, value2, value2;
-    value1 = mathfu::Random<float>();
-    value2 = mathfu::Random<float>();
-    value3 = mathfu::Random<float>();
-~~~
-
-[Random()][] is used by [RandomRange()](@ref mathfu_RandomRange) to generate
-a random number within a symmetric range.  For example, to generate a random
-value between -10.0f..10.0f:
-
-~~~{.cpp}
-    float random_value = mathfu::RandomRange(10.0f);
-~~~
-
-Finally, [RandomInRange](@ref mathfu_RandomInRange) can be used to generate
-a random number within an arbitrary range.  For example, to generate a random
-value between 5.0f..7.0f:
-
-~~~{.cpp}
-    float random_value = mathfu::RandomInRange(5.0f, 7.0f);
-~~~
-
-<br>
-
-  [AllocateAligned()]: @ref mathfu_AllocateAligned
-  [FreeAligned()]: @ref mathfu_FreeAligned
-  [MathFu]: @ref mathfu_overview
-  [Random()]: @ref mathfu_Random
-  [SIMD]: http://en.wikipedia.org/wiki/SIMD
-  [Vector]: @ref mathfu::Vector
diff --git a/third_party/mathfu-1.1.0/docs/src/programmers_guide/vectors.md b/third_party/mathfu-1.1.0/docs/src/programmers_guide/vectors.md
deleted file mode 100644
index b291662..0000000
--- a/third_party/mathfu-1.1.0/docs/src/programmers_guide/vectors.md
+++ /dev/null
@@ -1,272 +0,0 @@
-Vectors    {#mathfu_guide_vectors}
-=======
-
-Vectors consist of a set of elements (usually floating point or integer
-scalars) that are regularly used to describe a point in space or a direction.
-For more information see this description of
-[Euclidiean Vectors](http://en.wikipedia.org/wiki/Euclidean_vector).
-
-The [MathFu][] [Vector][] class is a template declared in
-[mathfu/vector.h](@ref mathfu/vector.h) which has been specialized and
-optimized for regularly used cases.  Implementing [Vector][] as a template
-reduces code duplication, provides compile time optimization opportunities
-through specialization and allows users to use the class with any scalar
-type.
-
-# Declaration  {#mathfu_guide_vectors_declaration}
-
-[Vector][] template takes two arguments: the type and number of elements in
-the [Vector][].
-
-For example, a 2-dimensional floating point vector variable is declared using
-the following:
-
-~~~{.cpp}
-    mathfu::Vector<float, 2> vector;
-~~~
-
-To eliminate the need for explicit template instantiation, [GLSL][] style
-`typedef`s are provided in
-[mathfu/glsl_mappings.h](@ref mathfu/glsl_mappings.h).  Using a [GLSL][]
-style `typedef` a 2-dimensional floating point vector variable is declared
-using the following:
-
-~~~{.cpp}
-    math::vec2 vector;
-~~~
-
-## Initialization  {#mathfu_guide_vectors_initialization}
-
-For efficiency, [Vector][] is uninitialized when constructed.  Constructors
-are provided for common vector sizes that allow initialization on construction:
-
-~~~{.cpp}
-    mathfu::vec2 vector(1.0f, 2.0f);
-~~~
-
-It's also possible to initialize a [Vector][] with another instance:
-
-~~~{.cpp}
-    mathfu::vec2 vector1(1.0f, 2.0f);
-    mathfu::vec2 vector2(vector1);
-~~~
-
-This can also be achieved with:
-
-~~~{.cpp}
-    mathfu::vec2 vector1(1.0f, 2.0f);
-    mathfu::vec2 vector2 = vector1;
-~~~
-
-# Accessors    {#mathfu_guide_vectors_accessors}
-
-[Vector][] provides array and [GLSL][] style accessors.  For example, to
-read two elements from a 2-dimensional vector using array accessors:
-
-~~~{.cpp}
-    const mathfu::vec2 vector(1.0f, 2.0f);
-    float x = vector[0];
-    float y = vector[1];
-~~~
-
-It's also possible to read elements from 2, 3 and 4-dimensional vectors using
-[GLSL][] style accessors:
-
-~~~{.cpp}
-    const mathfu::vec4 vector(1.0f, 2.0f, 3.0f, 4.0f);
-    float x = vector.x();
-    float y = vector.y();
-    float z = vector.z();
-    float w = vector.w();
-~~~
-
-Similar to [GLSL][], [Vector][] provides accessors which allow a subset of
-elements to be accessed:
-
-~~~{.cpp}
-    const mathfu::vec3 vector1(1.0f, 2.0f, 3.0f);
-    mathfu::vec3 xy = vector1.xy();
-~~~
-
-## Assignment    {#mathfu_guide_vectors_assignment}
-
-Individual elements returned by [Vector][]'s array accessors are references
-that can be assigned values to update the contents of the class:
-
-~~~{.cpp}
-    mathfu::vec2 vector(1.0f, 2.0f);
-    vector[0] = 3.0f;
-    vector[1] = 4.0f;
-~~~
-
-# Arithmetic    {#mathfu_guide_vectors_arithmetic}
-
-[Vector][] supports in-place and out-of-place arithmetic operators
-(addition, subtraction, multiplication, division) that perform
-component-wise operations.
-
-For example, two vectors can be added together using the following:
-
-~~~{.cpp}
-    const mathfu::vec2 vector1(1.0f, 2.0f), vector2(3.0f, 4.0f);
-    mathfu::vec2 vector3 = vector1 + vector2;
-~~~
-
-The above results in the values `(4.0f, 6.0f)` stored in `vector3` while
-preserving the values of `vector1` and `vector2`.
-
-The same can be achieved with an in-place addition which mutates `vector1`:
-
-~~~{.cpp}
-    mathfu::vec2 vector1(1.0f, 2.0f);
-    const mathfu::vec2 vector2(3.0f, 4.0f);
-    vector1 += vector2;
-~~~
-
-Subtraction is similar to addition:
-
-~~~{.cpp}
-    const mathfu::vec2 vector1(4.0f, 6.0f), vector2(3.0f, 4.0f);
-    mathfu::vec2 vector3 = vector2 - vector1;
-~~~
-
-Multiplication is performed component-wise, which means that each component
-is multiplied with the same index component in the other [Vector][] involved
-in the operation:
-
-~~~{.cpp}
-    const mathfu::vec2 vector1(2.0f, 0.5f), vector2(3.0f, 10.0f);
-    vector3 = vector1 * vector2;
-~~~
-
-The above results in the values `(6.0f, 5.0f)` stored in `vector3` while
-preserving the values of `vector1` and `vector2`.
-
-Similar to the other operators, multiplication can be performed in place:
-
-~~~{.cpp}
-    mathfu::vec2 vector1(2.0f, 0.5f);
-    const mathfu::vec2 vector2(3.0f, 10.0f);
-    vector1 *= vector2;
-~~~
-
-Division is also a component-wise operation:
-
-~~~{.cpp}
-    const mathfu::vec2 vector1(4.0f, 4.0f), vector2(2.0f, 4.0f);
-    vector3 = vector1 / vector2;
-~~~
-
-The above results in the values `(2.0f, 1.0f)` stored in `vector3` while
-preserving the values of `vector1` and `vector2`.
-
-# Constants    {#mathfu_guide_vectors_constants}
-
-Commonly used constants are provided by
-[mathfu/constants.h](@ref mathfu/constants.h).  These values eliminate the need
-to construct [Vector][] objects for common values like cardinal axes.
-
-For example, the following initializes a 2-dimensional vector with the X-axis:
-
-~~~{.cpp}
-    const mathfu::vec2 vector = mathfu::kAxisX2f;
-~~~
-
-# Geometric Operations    {#mathfu_guide_vectors_geometric}
-
-[Vector][] also provides functions for commonly used geometric operations
-that are utilized by graphics and games developers.
-
-For example, the length of a [Vector][] is calculated using
-[Length()](@ref mathfu::Vector::Length):
-
-~~~{.cpp}
-    const mathfu::vec2 vector(3.0f, 4.0f);
-    float length = vector.Length();
-~~~
-
-The projection of one [Vector][] onto another (dot product) can be calculated
-using [DotProduct()](@ref mathfu::Vector::DotProduct).  For example, the
-following calculates the projection of a vector onto the X-axis:
-
-~~~{.cpp}
-  float projection = mathfu::vec2::DotProduct(mathfu::vec2(5.0f, 2.0f),
-                                              mathfu::kAxisX2f);
-~~~
-
-It's possible to normalize (scale to a length of 1) a vector in-place using
-[Normalize()](@ref mathfu::Vector::Normalize) or out-of-place using
-[Normalized()](@ref mathfu::Vector::Normalized).  For example, the following
-normalizes the vector in-place:
-
-~~~{.cpp}
-    mathfu::vec2 vector(3.0f, 4.0f);
-    vector.Normalize();
-~~~
-
-The cross product of two 3-dimensional [Vectors][] (the vector perpendicular
-to two vectors) can be calculated using
-[CrossProduct()](@ref mathfu::Vector::CrossProduct), for example:
-
-~~~{.cpp}
-    mathfu::vec3 zaxis = mathfu::vec3::CrossProduct(mathfu::kAxisX3f,
-                                                    mathfu::kAxisY3f);
-~~~
-
-Alternatively, to create three points and compute the normal of the plane
-defined by the points use:
-
-~~~{.cpp}
-    mathfu::vec3 point1(0.5f, 0.4f, 0.1f);
-    mathfu::vec3 point2(0.4f, 0.9f, 0.1f);
-    mathfu::vec3 point3(0.1f, 0.8f, 0.6f);
-
-    mathfu::vec3 vector1 = point2 - point1;
-    mathfu::vec3 vector2 = point3 - point1;
-
-    mathfu::vec3 normal = Vector<float, 3>::CrossProduct(vector2, vector1);
-~~~
-
-# Other Operations    {#mathfu_guide_vectors_other}
-
-In addition, to basic arithmetic and geometric operations, [Vector][] also
-implements functions to perform the following:
-
-   * [Lerp](@ref mathfu::Vector::Lerp) to linearly interpolate between two
-     vectors.
-   * [RandomInRange](@ref mathfu::Vector::RandomInRange) to generate a vector
-     with random value for elements.
-
-# Packing    {#mathfu_guide_vectors_packing}
-
-The size of the class can change based upon the [Build Configuration][] so it
-should *not* be treated like a C style array.  To serialize the class to a
-flat array see [VectorPacked](@ref mathfu::VectorPacked).
-
-For example, to pack (store) an unpacked to packed vector:
-
-~~~{.cpp}
-    mathfu::vec3 vector(3.0f, 2.0f, 1.0f);
-    mathfu::vec3_packed packed = vector;
-~~~
-
-Since [VectorPacked][] is plain-old-data (POD) it can be cast to an array
-of elements of the same type used by the [Vector][] so it's possible to use
-an array of [VectorPacked][] data structures to contiguous arrays of data like
-vertex buffers.
-
-Similarly, [VectorPacked][] can be used to deserialize (load) data into
-[Vector][]:
-
-~~~{.cpp}
-    VectorPacked<float, 3> packed = { 3, 2, 1 };
-    Vector<float, 3> vector(packed);
-~~~
-
-<br>
-
-  [Build Configuration]: @ref mathfu_build_config
-  [MathFu]: @ref mathfu_overview
-  [GLSL]: http://www.opengl.org/documentation/glsl/
-  [Vector]: @ref mathfu::Vector
-  [VectorPacked]: @ref mathfu::VectorPacked
diff --git a/third_party/mathfu-1.1.0/docs/src/readme.md b/third_party/mathfu-1.1.0/docs/src/readme.md
deleted file mode 100644
index 2e75a7b..0000000
--- a/third_party/mathfu-1.1.0/docs/src/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-../../readme.md
\ No newline at end of file
diff --git a/third_party/mathfu-1.1.0/include/mathfu/constants.h b/third_party/mathfu-1.1.0/include/mathfu/constants.h
deleted file mode 100644
index e4f58f8..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/constants.h
+++ /dev/null
@@ -1,165 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_CONSTANTS_H
-#define MATHFU_CONSTANTS_H
-
-#include "mathfu/matrix.h"
-#include "mathfu/quaternion.h"
-#include "mathfu/vector.h"
-
-namespace mathfu {
-
-/// @file mathfu/constants.h
-/// @brief Vector constants for specific dimensions.
-/// @addtogroup mathfu_constants
-///
-/// It is preferable to use these constants rather than constructing them
-/// when they're required. Construction most-likely slower than loading them
-/// from memory.
-/// <p>
-/// For example, the following:<br>
-/// <code>
-/// lookat = mat4::LookAt(target, position, mathfu::kAxisY3f);
-/// </code>
-/// <br>is preferable to:<br>
-/// <code>
-/// lookat = mat4::LookAt(target, position,
-///                       mathfu::Vector<float, 3>(0.0f, 1.0f, 0.0f));
-/// </code>
-/// <br> in terms of efficiency and in addition to resulting in more concise
-/// code.
-/// </p>
-///
-/// Depending on your linker's sophistication and settings, these constants may
-/// be duplicated in every compilation unit in which they're used. However,
-/// most linkers should be able to detect and eliminate this duplication.
-
-/// @addtogroup mathfu_constants
-/// @{
-
-/// 2-dimensional <code>float</code> Vector of zeros.
-static const Vector<float, 2> kZeros2f(0.0f, 0.0f);
-/// 2-dimensional <code>float</code> Vector of ones.
-static const Vector<float, 2> kOnes2f(1.0f, 1.0f);
-/// 2-dimensional <code>float</code> unit Vector pointing along the X axis.
-static const Vector<float, 2> kAxisX2f(1.0f, 0.0f);
-/// 2-dimensional <code>float</code> unit Vector pointing along the Y axis.
-static const Vector<float, 2> kAxisY2f(0.0f, 1.0f);
-
-/// 3-dimensional <code>float</code> Vector of zeros.
-static const Vector<float, 3> kZeros3f(0.0f, 0.0f, 0.0f);
-/// 3-dimensional <code>float</code> Vector of ones.
-static const Vector<float, 3> kOnes3f(1.0f, 1.0f, 1.0f);
-/// 3-dimensional <code>float</code> unit Vector pointing along the X axis.
-static const Vector<float, 3> kAxisX3f(1.0f, 0.0f, 0.0f);
-/// 3-dimensional <code>float</code> unit Vector pointing along the Y axis.
-static const Vector<float, 3> kAxisY3f(0.0f, 1.0f, 0.0f);
-/// 3-dimensional <code>float</code> unit Vector pointing along the Z axis.
-static const Vector<float, 3> kAxisZ3f(0.0f, 0.0f, 1.0f);
-
-/// 4-dimensional <code>float</code> Vector of zeros.
-static const Vector<float, 4> kZeros4f(0.0f, 0.0f, 0.0f, 0.0f);
-/// 4-dimensional <code>float</code> Vector of ones.
-static const Vector<float, 4> kOnes4f(1.0f, 1.0f, 1.0f, 1.0f);
-/// 4-dimensional <code>float</code> unit Vector pointing along the X axis.
-static const Vector<float, 4> kAxisX4f(1.0f, 0.0f, 0.0f, 0.0f);
-/// 4-dimensional <code>float</code> unit Vector pointing along the Y axis.
-static const Vector<float, 4> kAxisY4f(0.0f, 1.0f, 0.0f, 0.0f);
-/// 4-dimensional <code>float</code> unit Vector pointing along the Z axis.
-static const Vector<float, 4> kAxisZ4f(0.0f, 0.0f, 1.0f, 0.0f);
-/// 4-dimensional <code>float</code> unit Vector pointing along the W axis.
-static const Vector<float, 4> kAxisW4f(0.0f, 0.0f, 0.0f, 1.0f);
-
-/// 2-dimensional <code>double</code> Vector of zeros.
-static const Vector<double, 2> kZeros2d(0.0, 0.0);
-/// 2-dimensional <code>double</code> Vector of ones.
-static const Vector<double, 2> kOnes2d(1.0, 1.0);
-/// 2-dimensional <code>double</code> unit Vector pointing along the X axis.
-static const Vector<double, 2> kAxisX2d(1.0, 0.0);
-/// 2-dimensional <code>double</code> unit Vector pointing along the Y axis.
-static const Vector<double, 2> kAxisY2d(0.0, 1.0);
-
-/// 3-dimensional <code>double</code> Vector of zeros.
-static const Vector<double, 3> kZeros3d(0.0, 0.0, 0.0);
-/// 3-dimensional <code>double</code> Vector of ones.
-static const Vector<double, 3> kOnes3d(1.0, 1.0, 1.0);
-/// 3-dimensional <code>double</code> unit Vector pointing along the X axis.
-static const Vector<double, 3> kAxisX3d(1.0, 0.0, 0.0);
-/// 3-dimensional <code>double</code> unit Vector pointing along the Y axis.
-static const Vector<double, 3> kAxisY3d(0.0, 1.0, 0.0);
-/// 3-dimensional <code>double</code> unit Vector pointing along the Z axis.
-static const Vector<double, 3> kAxisZ3d(0.0, 0.0, 1.0);
-
-/// 4-dimensional <code>double</code> Vector of zeros.
-static const Vector<double, 4> kZeros4d(0.0, 0.0, 0.0, 0.0);
-/// 4-dimensional <code>double</code> Vector of ones.
-static const Vector<double, 4> kOnes4d(1.0, 1.0, 1.0, 1.0);
-/// 4-dimensional <code>double</code> unit Vector pointing along the X axis.
-static const Vector<double, 4> kAxisX4d(1.0, 0.0, 0.0, 0.0);
-/// 4-dimensional <code>double</code> unit Vector pointing along the Y axis.
-static const Vector<double, 4> kAxisY4d(0.0, 1.0, 0.0, 0.0);
-/// 4-dimensional <code>double</code> unit Vector pointing along the Z axis.
-static const Vector<double, 4> kAxisZ4d(0.0, 0.0, 1.0, 0.0);
-/// 4-dimensional <code>double</code> unit Vector pointing along the W axis.
-static const Vector<double, 4> kAxisW4d(0.0, 0.0, 0.0, 1.0);
-
-/// 2-dimensional <code>int</code> Vector of zeros.
-static const Vector<int, 2> kOnes2i(1, 1);
-/// 2-dimensional <code>int</code> Vector of ones.
-static const Vector<int, 2> kZeros2i(0, 0);
-/// 2-dimensional <code>int</code> unit Vector pointing along the X axis.
-static const Vector<int, 2> kAxisX2i(1, 0);
-/// 2-dimensional <code>int</code> unit Vector pointing along the Y axis.
-static const Vector<int, 2> kAxisY2i(0, 1);
-
-/// 3-dimensional <code>int</code> Vector of zeros.
-static const Vector<int, 3> kZeros3i(0, 0, 0);
-/// 3-dimensional <code>int</code> Vector of ones.
-static const Vector<int, 3> kOnes3i(1, 1, 1);
-/// 3-dimensional <code>int</code> unit Vector pointing along the X axis.
-static const Vector<int, 3> kAxisX3i(1, 0, 0);
-/// 3-dimensional <code>int</code> unit Vector pointing along the Y axis.
-static const Vector<int, 3> kAxisY3i(0, 1, 0);
-/// 3-dimensional <code>int</code> unit Vector pointing along the Z axis.
-static const Vector<int, 3> kAxisZ3i(0, 0, 1);
-
-/// 4-dimensional <code>int</code> Vector of zeros.
-static const Vector<int, 4> kZeros4i(0, 0, 0, 0);
-/// 4-dimensional <code>int</code> Vector of ones.
-static const Vector<int, 4> kOnes4i(1, 1, 1 ,1);
-/// 4-dimensional <code>int</code> unit Vector pointing along the X axis.
-static const Vector<int, 4> kAxisX4i(1, 0, 0, 0);
-/// 4-dimensional <code>int</code> unit Vector pointing along the Z axis.
-static const Vector<int, 4> kAxisY4i(0, 1, 0, 0);
-/// 4-dimensional <code>int</code> unit Vector pointing along the Y axis.
-static const Vector<int, 4> kAxisZ4i(0, 0, 1, 0);
-/// 4-dimensional <code>int</code> unit Vector pointing along the W axis.
-static const Vector<int, 4> kAxisW4i(0, 0, 0, 1);
-
-/// Quaternion Identity
-static const Quaternion<float> kQuatIdentityf(1.0f, 0.0f, 0.0f, 0.0f);
-/// Quaternion Identity
-static const Quaternion<double> kQuatIdentityd(1.0, 0.0, 0.0, 0.0);
-
-// An AffineTransform versoin of the mat4 Identity matrix.
-static const AffineTransform kAffineIdentity(1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-                                             0.0f, 0.0f, 0.0f, 0.0f, 1.0f,
-                                             0.0f);
-/// @}
-
-}  // namespace mathfu
-
-#endif  // MATHFU_CONSTANTS_H
diff --git a/third_party/mathfu-1.1.0/include/mathfu/glsl_mappings.h b/third_party/mathfu-1.1.0/include/mathfu/glsl_mappings.h
deleted file mode 100644
index d00d828..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/glsl_mappings.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_GLSL_MAPPINGS_H_
-#define MATHFU_GLSL_MAPPINGS_H_
-
-#include "mathfu/matrix.h"
-#include "mathfu/quaternion.h"
-#include "mathfu/rect.h"
-#include "mathfu/vector.h"
-
-/// @file mathfu/glsl_mappings.h
-/// @brief GLSL compatible data types.
-/// @addtogroup mathfu_glsl
-///
-/// To simplify the use of MathFu template classes and make it possible to
-/// write code that looks similar to
-/// <a href="http://www.opengl.org/documentation/glsl/">GLSL</a> in C++,
-/// MathFu provides a set of data types that are similar in style to
-/// GLSL Vector and Matrix data types.
-
-/// @brief Namespace for MathFu library.
-namespace mathfu {
-
-/// @addtogroup mathfu_glsl
-/// @{
-
-/// 2-dimensional <code>float</code> Vector.
-typedef Vector<float, 2> vec2;
-/// 3-dimensional <code>float</code> Vector.
-typedef Vector<float, 3> vec3;
-/// 4-dimensional <code>float</code> Vector.
-typedef Vector<float, 4> vec4;
-
-/// 2-dimensional <code>int</code> Vector.
-typedef Vector<int, 2> vec2i;
-/// 3-dimensional <code>int</code> Vector.
-typedef Vector<int, 3> vec3i;
-/// 4-dimensional <code>int</code> Vector.
-typedef Vector<int, 4> vec4i;
-
-/// 2x2 <code>float</code> Matrix.
-typedef Matrix<float, 2, 2> mat2;
-/// 3x3 <code>float</code> Matrix.
-typedef Matrix<float, 3, 3> mat3;
-/// 3x3 <code>float</code> Matrix.
-typedef Matrix<float, 4, 4> mat4;
-
-/// 2-dimensional <code>float</code> packed Vector (VectorPacked).
-typedef VectorPacked<float, 2> vec2_packed;
-/// 3-dimensional <code>float</code> packed Vector (VectorPacked).
-typedef VectorPacked<float, 3> vec3_packed;
-/// 4-dimensional <code>float</code> packed Vector (VectorPacked).
-typedef VectorPacked<float, 4> vec4_packed;
-
-/// 2-dimensional <code>int</code> packed Vector (VectorPacked).
-typedef VectorPacked<int, 2> vec2i_packed;
-/// 3-dimensional <code>int</code> packed Vector (VectorPacked).
-typedef VectorPacked<int, 3> vec3i_packed;
-/// 4-dimensional <code>int</code> packed Vector (VectorPacked).
-typedef VectorPacked<int, 4> vec4i_packed;
-
-/// Float-based quaternion.  Note that this is not technically
-/// a GLES type, but is included for convenience.
-typedef mathfu::Quaternion<float> quat;
-
-/// Rect composed of type <code>float</code>.
-typedef Rect<float> rectf;
-/// Rect composed of type <code>double</code>.
-typedef Rect<double> rectd;
-/// Rect composed of type <code>int</code>.
-typedef Rect<int> recti;
-
-/// @brief Calculate the cross product of two 3-dimensional Vectors.
-///
-/// @param v1 Vector to multiply
-/// @param v2 Vector to multiply
-/// @return 3-dimensional vector that contains the result.
-template<class T>
-inline Vector<T, 3> cross(const Vector<T, 3>& v1, const Vector<T, 3>& v2) {
-  return Vector<T, 3>::CrossProduct(v1,v2);
-}
-
-/// @brief Calculate the dot product of two N-dimensional Vectors of any type.
-///
-/// @param v1 Vector to multiply
-/// @param v2 Vector to multiply
-/// @return Scalar dot product result.
-template<class TV>
-inline typename TV::Scalar dot(const TV& v1, const TV& v2) {
-  return TV::DotProduct(v1,v2);
-}
-
-/// @brief Normalize an N-dimensional Vector of an arbitrary type.
-///
-/// @param v1 Vector to normalize.
-/// @return Normalized vector.
-template<class TV>
-inline TV normalize(const TV& v1) {
-  return v1.Normalized();
-}
-
-/// @}
-
-}  // namespace mathfu
-
-#endif  // MATHFU_GLSL_MAPPINGS_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/hlsl_mappings.h b/third_party/mathfu-1.1.0/include/mathfu/hlsl_mappings.h
deleted file mode 100644
index 6db5213..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/hlsl_mappings.h
+++ /dev/null
@@ -1,134 +0,0 @@
-/*
-* Copyright 2017 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_HLSL_MAPPINGS_H_
-#define MATHFU_HLSL_MAPPINGS_H_
-
-#include "mathfu/matrix.h"
-#include "mathfu/quaternion.h"
-#include "mathfu/vector.h"
-
-/// @file mathfu/hlsl_mappings.h
-/// @brief HLSL compatible data types.
-/// @addtogroup mathfu_hlsl
-///
-/// To simplify the use of MathFu template classes and make it possible to
-/// write code that looks similar to
-/// <a href="https://msdn.microsoft.com/en-us/library/windows/desktop/bb509587(v=vs.85).aspx">HLSL</a> data types in C++,
-/// MathFu provides a set of data types that are similar in style to
-/// HLSL Vector and Matrix data types.
-
-/// @brief Namespace for MathFu library.
-namespace mathfu {
-
-/// @addtogroup mathfu_hlsl
-/// @{
-
-/// Scalar unsigned integer
-typedef unsigned int   uint;
-typedef unsigned int   dword;
-typedef unsigned short half;
-
-/// 2-dimensional <code>float</code> Vector.
-typedef Vector<float, 2> float2;
-/// 3-dimensional <code>float</code> Vector.
-typedef Vector<float, 3> float3;
-/// 4-dimensional <code>float</code> Vector.
-typedef Vector<float, 4> float4;
-
-/// 2-dimensional <code>int</code> Vector.
-typedef Vector<int, 2> int2;
-/// 3-dimensional <code>int</code> Vector.
-typedef Vector<int, 3> int3;
-/// 4-dimensional <code>int</code> Vector.
-typedef Vector<int, 4> int4;
-
-/// 2-dimensional <code>uint</code> Vector.
-typedef Vector<uint, 2> uint2;
-/// 3-dimensional <code>uint</code> Vector.
-typedef Vector<uint, 3> uint3;
-/// 4-dimensional <code>uint</code> Vector.
-typedef Vector<uint, 4> uint4;
-
-/// 1x1 <code>float</code> Matrix.
-typedef Matrix<float, 2, 2> float1x1;
-/// 2x2 <code>float</code> Matrix.
-typedef Matrix<float, 2, 2> float2x2;
-/// 3x3 <code>float</code> Matrix.
-typedef Matrix<float, 3, 3> float3x3;
-/// 3x3 <code>float</code> Matrix.
-typedef Matrix<float, 4, 4> float4x4;
-
-/// 1x1 <code>double</code> Matrix.
-typedef Matrix<double, 2, 2> double1x1;
-/// 2x2 <code>double</code> Matrix.
-typedef Matrix<double, 2, 2> double2x2;
-/// 3x3 <code>double</code> Matrix.
-typedef Matrix<double, 3, 3> double3x3;
-/// 3x3 <code>double</code> Matrix.
-typedef Matrix<double, 4, 4> double4x4;
-
-/// 1x1 <code>int</code> Matrix.
-typedef Matrix<int, 2, 2> int1x1;
-/// 2x2 <code>int</code> Matrix.
-typedef Matrix<int, 2, 2> int2x2;
-/// 3x3 <code>int</code> Matrix.
-typedef Matrix<int, 3, 3> int3x3;
-/// 3x3 <code>int</code> Matrix.
-typedef Matrix<int, 4, 4> int4x4;
-
-/// 1x1 <code>int</code> Matrix.
-typedef Matrix<int, 2, 2> uint1x1;
-/// 2x2 <code>int</code> Matrix.
-typedef Matrix<int, 2, 2> uint2x2;
-/// 3x3 <code>int</code> Matrix.
-typedef Matrix<int, 3, 3> uint3x3;
-/// 3x3 <code>int</code> Matrix.
-typedef Matrix<int, 4, 4> uint4x4;
-
-/// @brief Calculate the cross product of two 3-dimensional Vectors.
-///
-/// @param v1 Vector to multiply
-/// @param v2 Vector to multiply
-/// @return 3-dimensional vector that contains the result.
-template<class T>
-inline Vector<T, 3> cross(const Vector<T, 3>& v1, const Vector<T, 3>& v2) {
-  return Vector<T, 3>::CrossProduct(v1,v2);
-}
-
-/// @brief Calculate the dot product of two N-dimensional Vectors of any type.
-///
-/// @param v1 Vector to multiply
-/// @param v2 Vector to multiply
-/// @return Scalar dot product result.
-template<class TV>
-inline typename TV::Scalar dot(const TV& v1, const TV& v2) {
-  return TV::DotProduct(v1,v2);
-}
-
-/// @brief Normalize an N-dimensional Vector of an arbitrary type.
-///
-/// @param v1 Vector to normalize.
-/// @return Normalized vector.
-template<class TV>
-inline TV normalize(const TV& v1) {
-  return v1.Normalized();
-}
-
-/// @}
-
-}  // namespace mathfu
-
-#endif  // MATHFU_HLSL_MAPPINGS_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_begin.h b/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_begin.h
deleted file mode 100644
index 9f7bee1..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_begin.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-// Suppress pedantic warnings.
-// To re-enable, include "mathfu/internal/disable_warnings_end.h".
-//
-// We need this to use anonymous unions and structs, which generate the
-// the following warning in GCC and Clang,
-//     error: ISO C++ prohibits anonymous structs [-Werror=pedantic]
-// The only way to suppress this warning is to turn off all pedantic warnings.
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wpedantic"
-#pragma GCC diagnostic ignored "-Wignored-qualifiers"
-#endif  // defined(__GNUC__)
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpedantic"
-#pragma clang diagnostic ignored "-Wignored-qualifiers"
-#endif  // defined(__clang__)
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_end.h b/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_end.h
deleted file mode 100644
index 8639ff7..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/disable_warnings_end.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif  // defined(__clang__)
-
-#if defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif  // defined(__GNUC__)
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/matrix_4x4_simd.h b/third_party/mathfu-1.1.0/include/mathfu/internal/matrix_4x4_simd.h
deleted file mode 100644
index 73dc447..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/matrix_4x4_simd.h
+++ /dev/null
@@ -1,441 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_MATRIX_4X4_SIMD_H_
-#define MATHFU_MATRIX_4X4_SIMD_H_
-
-#include "mathfu/matrix.h"
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-#include "vectorial/simd4x4f.h"
-#endif
-
-/// @file mathfu/internal/matrix_4x4_simd.h MathFu Matrix<T, 4, 4>
-///       Specialization
-/// @brief 4x4 specialization of mathfu::Matrix for SIMD optimized builds.
-/// @see mathfu::Matrix
-
-namespace mathfu {
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-
-static const Vector<float, 4> kAffineWColumn(0.0f, 0.0f, 0.0f, 1.0f);
-
-/// @cond MATHFU_INTERNAL
-template <>
-class Matrix<float, 4> {
- public:
-  Matrix<float, 4>() {}
-
-  inline Matrix<float, 4>(const Matrix<float, 4>& m) {
-    data_.simd_matrix.x = m.data_.simd_matrix.x;
-    data_.simd_matrix.y = m.data_.simd_matrix.y;
-    data_.simd_matrix.z = m.data_.simd_matrix.z;
-    data_.simd_matrix.w = m.data_.simd_matrix.w;
-  }
-
-  explicit inline Matrix<float, 4>(const float& s) {
-    simd4f v = simd4f_create(s, s, s, s);
-    data_.simd_matrix = simd4x4f_create(v, v, v, v);
-  }
-
-  inline Matrix<float, 4>(const float& s00, const float& s10, const float& s20,
-                          const float& s30, const float& s01, const float& s11,
-                          const float& s21, const float& s31, const float& s02,
-                          const float& s12, const float& s22, const float& s32,
-                          const float& s03, const float& s13, const float& s23,
-                          const float& s33) {
-    data_.simd_matrix = simd4x4f_create(
-        simd4f_create(s00, s10, s20, s30), simd4f_create(s01, s11, s21, s31),
-        simd4f_create(s02, s12, s22, s32), simd4f_create(s03, s13, s23, s33));
-  }
-
-  explicit inline Matrix<float, 4>(const float* m) {
-    data_.simd_matrix =
-        simd4x4f_create(simd4f_create(m[0], m[1], m[2], m[3]),
-                        simd4f_create(m[4], m[5], m[6], m[7]),
-                        simd4f_create(m[8], m[9], m[10], m[11]),
-                        simd4f_create(m[12], m[13], m[14], m[15]));
-  }
-
-  inline Matrix<float, 4>(const Vector<float, 4>& column0,
-                          const Vector<float, 4>& column1,
-                          const Vector<float, 4>& column2,
-                          const Vector<float, 4>& column3) {
-#if defined(MATHFU_COMPILE_WITH_PADDING)
-    data_.simd_matrix = simd4x4f_create(column0.data_.simd, column1.data_.simd,
-                                        column2.data_.simd, column3.data_.simd);
-#else
-    data_.simd_matrix = simd4x4f_create(
-        simd4f_create(column0[0], column0[1], column0[2], column0[3]),
-        simd4f_create(column1[0], column1[1], column1[2], column1[3]),
-        simd4f_create(column2[0], column2[1], column2[2], column2[3]),
-        simd4f_create(column3[0], column3[1], column3[2], column3[3]));
-#endif  // defined(MATHFU_COMPILE_WITH_PADDING)
-  }
-
-  explicit inline Matrix(const VectorPacked<float, 4>* const vectors) {
-    data_.simd_matrix.x = simd4f_uload4(vectors[0].data);
-    data_.simd_matrix.y = simd4f_uload4(vectors[1].data);
-    data_.simd_matrix.z = simd4f_uload4(vectors[2].data);
-    data_.simd_matrix.w = simd4f_uload4(vectors[3].data);
-  }
-
-  inline const float& operator()(const int i, const int j) const {
-    return FindElem(i, FindColumn(j));
-  }
-
-  inline float& operator()(const int i, const int j) {
-    return FindElem(i, FindColumn(j));
-  }
-
-  inline const float& operator()(const int i) const {
-    return this->operator[](i);
-  }
-
-  inline float& operator()(const int i) { return this->operator[](i); }
-
-  inline const float& operator[](const int i) const {
-    const int col = i / 4;
-    const int row = i % 4;
-    return FindElem(row, FindColumn(col));
-  }
-
-  inline float& operator[](const int i) {
-    const int col = i / 4;
-    const int row = i % 4;
-    return FindElem(row, FindColumn(col));
-  }
-
-  inline void Pack(VectorPacked<float, 4>* const vector) const {
-    simd4f_ustore4(data_.simd_matrix.x, vector[0].data);
-    simd4f_ustore4(data_.simd_matrix.y, vector[1].data);
-    simd4f_ustore4(data_.simd_matrix.z, vector[2].data);
-    simd4f_ustore4(data_.simd_matrix.w, vector[3].data);
-  }
-
-  inline Matrix<float, 4> operator-() const {
-    Matrix<float, 4> m(0.f);
-    simd4x4f_sub(&m.data_.simd_matrix, &data_.simd_matrix,
-                 &m.data_.simd_matrix);
-    return m;
-  }
-
-  inline Matrix<float, 4> operator+(const Matrix<float, 4>& m) const {
-    Matrix<float, 4> return_m;
-    simd4x4f_add(&data_.simd_matrix, &m.data_.simd_matrix,
-                 &return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  inline Matrix<float, 4> operator-(const Matrix<float, 4>& m) const {
-    Matrix<float, 4> return_m;
-    simd4x4f_sub(&data_.simd_matrix, &m.data_.simd_matrix,
-                 &return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  inline Matrix<float, 4> operator*(const float& s) const {
-    Matrix<float, 4> m(s);
-    simd4x4f_mul(&m.data_.simd_matrix, &data_.simd_matrix,
-                 &m.data_.simd_matrix);
-    return m;
-  }
-
-  inline Matrix<float, 4> operator/(const float& s) const {
-    Matrix<float, 4> m(1 / s);
-    simd4x4f_mul(&m.data_.simd_matrix, &data_.simd_matrix,
-                 &m.data_.simd_matrix);
-    return m;
-  }
-
-  inline Vector<float, 3> operator*(const Vector<float, 3>& v) const {
-    Vector<float, 3> return_v;
-    Simd4fUnion temp_v;
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    temp_v.simd = v.data_.simd;
-    temp_v.float_array[3] = 1;
-    simd4x4f_matrix_vector_mul(&data_.simd_matrix, &temp_v.simd,
-                               &return_v.data_.simd);
-    return_v *= (1 / return_v.data_.float_array[3]);
-#else
-    temp_v.simd = simd4f_create(v[0], v[1], v[2], 1.0f);
-    simd4x4f_matrix_vector_mul(&data_.simd_matrix, &temp_v.simd, &temp_v.simd);
-    simd4f_mul(temp_v.simd, simd4f_splat(temp_v.float_array[3]));
-    MATHFU_VECTOR3_STORE3(temp_v.simd, return_v.data_);
-#endif  // MATHFU_COMPILE_WITH_PADDING
-    return return_v;
-  }
-
-  inline Vector<float, 4> operator*(const Vector<float, 4>& v) const {
-    Vector<float, 4> return_v;
-    simd4x4f_matrix_vector_mul(&data_.simd_matrix, &v.data_.simd,
-                               &return_v.data_.simd);
-    return return_v;
-  }
-
-  inline Vector<float, 4> VecMatTimes(const Vector<float, 4>& v) const {
-    return Vector<float, 4>(
-        simd4f_dot3_scalar(v.data_.simd, data_.simd_matrix.x),
-        simd4f_dot3_scalar(v.data_.simd, data_.simd_matrix.y),
-        simd4f_dot3_scalar(v.data_.simd, data_.simd_matrix.z),
-        simd4f_dot3_scalar(v.data_.simd, data_.simd_matrix.w));
-  }
-
-  inline Matrix<float, 4> operator*(const Matrix<float, 4>& m) const {
-    Matrix<float, 4> return_m;
-    simd4x4f_matrix_mul(&data_.simd_matrix, &m.data_.simd_matrix,
-                        &return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  inline Matrix<float, 4> Inverse() const {
-    Matrix<float, 4> return_m;
-    simd4x4f_inverse(&data_.simd_matrix, &return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  inline bool InverseWithDeterminantCheck(
-      Matrix<float, 4, 4>* const inverse) const {
-    return fabs(simd4f_get_x(simd4x4f_inverse(&data_.simd_matrix,
-                                              &inverse->data_.simd_matrix))) >=
-           Constants<float>::GetDeterminantThreshold();
-  }
-
-  /// Calculate the transpose of matrix.
-  /// @return The transpose of the specified matrix.
-  inline Matrix<float, 4, 4> Transpose() const {
-    Matrix<float, 4, 4> transpose;
-    simd4x4f_transpose(&data_.simd_matrix, &transpose.data_.simd_matrix);
-    return transpose;
-  }
-
-  inline Vector<float, 3> TranslationVector3D() const {
-    Vector<float, 3> return_v;
-    MATHFU_VECTOR3_STORE3(FindColumn(3).simd, return_v.data_);
-    return return_v;
-  }
-
-  inline Matrix<float, 4>& operator+=(const Matrix<float, 4>& m) {
-    simd4x4f_add(&data_.simd_matrix, &m.data_.simd_matrix, &data_.simd_matrix);
-    return *this;
-  }
-
-  inline Matrix<float, 4>& operator-=(const Matrix<float, 4>& m) {
-    simd4x4f_sub(&data_.simd_matrix, &m.data_.simd_matrix, &data_.simd_matrix);
-    return *this;
-  }
-
-  inline Matrix<float, 4>& operator*=(const float& s) {
-    Matrix<float, 4> m(s);
-    simd4x4f_mul(&m.data_.simd_matrix, &data_.simd_matrix, &data_.simd_matrix);
-    return *this;
-  }
-
-  inline Matrix<float, 4>& operator/=(const float& s) {
-    Matrix<float, 4> m(1 / s);
-    simd4x4f_mul(&m.data_.simd_matrix, &data_.simd_matrix, &data_.simd_matrix);
-    return *this;
-  }
-
-  inline Matrix<float, 4> operator*=(const Matrix<float, 4>& m) {
-    Matrix<float, 4> copy_of_this(*this);
-    simd4x4f_matrix_mul(&copy_of_this.data_.simd_matrix, &m.data_.simd_matrix,
-                        &data_.simd_matrix);
-    return *this;
-  }
-
-  template <typename CompatibleT>
-  static inline Matrix<float, 4> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<float, 4, 4, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Matrix<float, 4>& m) {
-    return ToTypeHelper<float, 4, 4, CompatibleT>(m);
-  }
-
-  static inline Matrix<float, 4> OuterProduct(const Vector<float, 4>& v1,
-                                              const Vector<float, 4>& v2) {
-    Matrix<float, 4> m;
-    m.data_.simd_matrix =
-        simd4x4f_create(simd4f_mul(v1.data_.simd, simd4f_splat(v2[0])),
-                        simd4f_mul(v1.data_.simd, simd4f_splat(v2[1])),
-                        simd4f_mul(v1.data_.simd, simd4f_splat(v2[2])),
-                        simd4f_mul(v1.data_.simd, simd4f_splat(v2[3])));
-    return m;
-  }
-
-  static inline Matrix<float, 4> HadamardProduct(const Matrix<float, 4>& m1,
-                                                 const Matrix<float, 4>& m2) {
-    Matrix<float, 4> return_m;
-    simd4x4f_mul(&m1.data_.simd_matrix, &m2.data_.simd_matrix,
-                 &return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  static inline Matrix<float, 4> Identity() {
-    Matrix<float, 4> return_m;
-    simd4x4f_identity(&return_m.data_.simd_matrix);
-    return return_m;
-  }
-
-  static inline Matrix<float, 4> FromTranslationVector(
-      const Vector<float, 3>& v) {
-    return Matrix<float, 4>(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, v[0], v[1],
-                            v[2], 1);
-  }
-
-  static inline Matrix<float, 4> FromScaleVector(const Vector<float, 3>& v) {
-    return Matrix<float, 4>(v[0], 0, 0, 0, 0, v[1], 0, 0, 0, 0, v[2], 0, 0, 0,
-                            0, 1);
-  }
-
-  static inline Matrix<float, 4> FromRotationMatrix(const Matrix<float, 3>& m) {
-    return Matrix<float, 4>(m[0], m[1], m[2], 0, m[3], m[4], m[5], 0, m[6],
-                            m[7], m[8], 0, 0, 0, 0, 1);
-  }
-
-  /// @brief Constructs a Matrix<float, 4> from an AffineTransform.
-  ///
-  /// @param affine An AffineTransform reference to be used to construct
-  /// a Matrix<float, 4> by adding in the 'w' row of [0, 0, 0, 1].
-  static inline Matrix<float, 4> FromAffineTransform(
-      const AffineTransform& affine) {
-    Matrix<float, 4> m;
-    m.data_.simd_matrix.x = simd4f_uload4(&affine[0]);
-    m.data_.simd_matrix.y = simd4f_uload4(&affine[4]);
-    m.data_.simd_matrix.z = simd4f_uload4(&affine[8]);
-    m.data_.simd_matrix.w = simd4f_uload4(&kAffineWColumn[0]);
-    return m.Transpose();
-  }
-
-  /// @brief Converts a Matrix<float, 4> into an AffineTransform.
-  ///
-  /// @param m A Matrix<float, 4> reference to be converted into an
-  /// AffineTransform by dropping the fixed 'w' row.
-  ///
-  /// @return Returns an AffineTransform that contains the essential
-  /// transformation data from the Matrix<float, 4>.
-  static inline AffineTransform ToAffineTransform(const Matrix<float, 4>& m) {
-    AffineTransform affine;
-    const Matrix<float, 4> mt = m.Transpose();
-    simd4f_ustore4(mt.data_.simd_matrix.x, &affine[0]);
-    simd4f_ustore4(mt.data_.simd_matrix.y, &affine[4]);
-    simd4f_ustore4(mt.data_.simd_matrix.z, &affine[8]);
-    return affine;
-  }
-
-  /// Create a 4x4 perpective matrix.
-  /// @handedness: 1.0f for RH, -1.0f for LH
-  static inline Matrix<float, 4, 4> Perspective(float fovy, float aspect,
-                                                float znear, float zfar,
-                                                float handedness = 1.0f) {
-    return PerspectiveHelper(fovy, aspect, znear, zfar, handedness);
-  }
-
-  /// Create a 4x4 orthographic matrix.
-  /// @param handedness 1.0f for RH, -1.0f for LH
-  static inline Matrix<float, 4, 4> Ortho(float left, float right, float bottom,
-                                          float top, float znear, float zfar,
-                                          float handedness = 1.0f) {
-    return OrthoHelper(left, right, bottom, top, znear, zfar, handedness);
-  }
-
-  /// Create a 3-dimensional camera matrix.
-  /// @param at The look-at target of the camera.
-  /// @param eye The position of the camera.
-  /// @param up The up vector in the world, for example (0, 1, 0) if the
-  /// @handedness: 1.0f for RH, -1.0f for LH
-  /// TODO: Change default handedness to 1.0f, to match Perspective().
-  /// y-axis is up.
-  static inline Matrix<float, 4, 4> LookAt(const Vector<float, 3>& at,
-                                           const Vector<float, 3>& eye,
-                                           const Vector<float, 3>& up,
-                                           float handedness = -1.0f) {
-    return LookAtHelper(at, eye, up, handedness);
-  }
-
-  /// @brief Get the 3D position in object space from a window coordinate.
-  ///
-  /// @param window_coord The window coordinate. The z value is for depth.
-  /// A window coordinate on the near plane will have 0 as the z value.
-  /// And a window coordinate on the far plane will have 1 as the z value.
-  /// z value should be with in [0, 1] here.
-  /// @param model_view The Model View matrix.
-  /// @param projection The projection matrix.
-  /// @param window_width Width of the window.
-  /// @param window_height Height of the window.
-  /// @return the mapped 3D position in object space.
-  static inline Vector<float, 3> UnProject(
-      const Vector<float, 3>& window_coord,
-      const Matrix<float, 4, 4>& model_view,
-      const Matrix<float, 4, 4>& projection, const float window_width,
-      const float window_height) {
-    Vector<float, 3> result;
-    UnProjectHelper(window_coord, model_view, projection, window_width,
-                    window_height, result);
-    return result;
-  }
-
-  // Dimensions of the matrix.
-  /// Number of rows in the matrix.
-  static const int kRows = 4;
-  /// Number of columns in the matrix.
-  static const int kColumns = 4;
-  /// Total number of elements in the matrix.
-  static const int kElements = 4 * 4;
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
- private:
-  inline const Simd4fUnion& FindColumn(const int i) const {
-    return data_.simd4f_union_array[i];
-  }
-
-  inline Simd4fUnion& FindColumn(const int i) {
-    return data_.simd4f_union_array[i];
-  }
-
-  static inline const float& FindElem(const int i, const Simd4fUnion& column) {
-    return column.float_array[i];
-  }
-
-  static inline float& FindElem(const int i, Simd4fUnion& column) {
-    return column.float_array[i];
-  }
-
-  // Contents of the Matrix in different representations to work around
-  // strict aliasing rules.
-  union {
-    simd4x4f simd_matrix;
-    Simd4fUnion simd4f_union_array[4];
-    float float_array[16];
-  } data_;
-};
-
-inline Matrix<float, 4> operator*(const float& s, const Matrix<float, 4>& m) {
-  return m * s;
-}
-
-inline Vector<float, 4> operator*(const Vector<float, 4>& v,
-                                  const Matrix<float, 4>& m) {
-  return m.VecMatTimes(v);
-}
-/// @endcond
-#endif  // MATHFU_COMPILE_WITH_SIMD
-}  // namespace mathfu
-
-#endif  // MATHFU_MATRIX_4X4_SIMD_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2.h
deleted file mode 100644
index 01c5b50..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_INTERNAL_VECTOR_2_H_
-#define MATHFU_INTERNAL_VECTOR_2_H_
-
-#include "mathfu/vector.h"
-
-namespace mathfu {
-
-template <class T>
-class Vector<T, 2> {
- public:
-  typedef T Scalar;
-  static const int d = 2;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<T, 2>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = v.data_[i]);
-  }
-
-  template <typename U>
-  explicit inline Vector(const Vector<U, 2>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = static_cast<T>(v[i]));
-  }
-
-  explicit inline Vector(const T& s) { MATHFU_VECTOR_OPERATION(data_[i] = s); }
-
-  explicit inline Vector(const T* a) {
-    MATHFU_VECTOR_OPERATION(data_[i] = a[i]);
-  }
-
-  inline Vector(const T& s1, const T& s2) {
-    x = s1;
-    y = s2;
-  }
-
-  explicit inline Vector(const VectorPacked<T, 2>& vector) {
-    MATHFU_VECTOR_OPERATION(data_[i] = vector.data[i]);
-  }
-
-  inline T& operator()(const int i) { return data_[i]; }
-
-  inline const T& operator()(const int i) const { return data_[i]; }
-
-  inline T& operator[](const int i) { return data_[i]; }
-
-  inline const T& operator[](const int i) const { return data_[i]; }
-
-  inline Vector<T, 2> xy() { return Vector<T, 2>(x, y); }
-
-  inline const Vector<T, 2> xy() const { return Vector<T, 2>(x, y); }
-
-  inline void Pack(VectorPacked<T, 2>* const vector) const {
-    MATHFU_VECTOR_OPERATION(vector->data[i] = data_[i]);
-  }
-
-  inline T LengthSquared() const { return LengthSquaredHelper(*this); }
-
-  inline T Length() const { return LengthHelper(*this); }
-
-  inline T Normalize() { return NormalizeHelper(*this); }
-
-  inline Vector<T, 2> Normalized() const { return NormalizedHelper(*this); }
-
-  template <typename CompatibleT>
-  static inline Vector<T, 2> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<T, d, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<T, 2>& v) {
-    return ToTypeHelper<T, d, CompatibleT>(v);
-  }
-
-  static inline T DotProduct(const Vector<T, 2>& v1, const Vector<T, 2>& v2) {
-    return DotProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 2> HadamardProduct(const Vector<T, 2>& v1,
-                                             const Vector<T, 2>& v2) {
-    return HadamardProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 2> Lerp(const Vector<T, 2>& v1,
-                                  const Vector<T, 2>& v2, const T percent) {
-    return LerpHelper(v1, v2, percent);
-  }
-
-  static inline Vector<T, 2> RandomInRange(const Vector<T, 2>& min,
-                                           const Vector<T, 2>& max) {
-    return RandomInRangeHelper(min, max);
-  }
-
-  static inline Vector<T, 2> Max(const Vector<T, 2>& v1,
-                                 const Vector<T, 2>& v2) {
-    return MaxHelper(v1, v2);
-  }
-
-  static inline Vector<T, 2> Min(const Vector<T, 2>& v1,
-                                 const Vector<T, 2>& v2) {
-    return MinHelper(v1, v2);
-  }
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  union {
-    T data_[2];
-    struct {
-      T x;
-      T y;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-template <class T>
-struct VectorPacked<T, 2> {
-  /// Create an uninitialized VectorPacked.
-  VectorPacked() {}
-
-  /// Create a VectorPacked from a Vector.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to create the VectorPacked from.
-  explicit VectorPacked(const Vector<T, 2>& vector) { vector.Pack(this); }
-
-  /// Copy a Vector to a VectorPacked.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to copy to the VectorPacked.
-  /// @returns A reference to this VectorPacked.
-  VectorPacked& operator=(const Vector<T, 2>& vector) {
-    vector.Pack(this);
-    return *this;
-  }
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  /// Elements of the packed vector one per dimension.
-  union {
-    T data[2];
-    struct {
-      T x;
-      T y;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-}  //  namespace mathfu
-
-#endif  // MATHFU_INTERNAL_VECTOR_2_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2_simd.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2_simd.h
deleted file mode 100644
index 21ea74e..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_2_simd.h
+++ /dev/null
@@ -1,253 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_VECTOR_2_SIMD_H_
-#define MATHFU_VECTOR_2_SIMD_H_
-
-#include "mathfu/internal/vector_2.h"
-#include "mathfu/utilities.h"
-
-#include <math.h>
-
-/// @file mathfu/internal/vector_2_simd.h MathFu Vector<T, 2> Specialization
-/// @brief 2-dimensional specialization of mathfu::Vector for SIMD optimized
-/// builds.
-/// @see mathfu::Vector
-
-#if !defined(MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT) && defined(__ARM_NEON__)
-#include <vectorial/simd2f.h>
-#endif
-
-namespace mathfu {
-
-#if !defined(MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT) && defined(__ARM_NEON__)
-/// @cond MATHFU_INTERNAL
-template <>
-class Vector<float, 2> {
- public:
-  typedef float Scalar;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<float, 2>& v) { simd = v.simd; }
-
-  explicit inline Vector(const Vector<int, 2>& v) {
-    data_[0] = static_cast<float>(v[0]);
-    data_[1] = static_cast<float>(v[1]);
-  }
-
-  explicit inline Vector(const simd2f& v) { simd = v; }
-
-  explicit inline Vector(const float& s) { simd = simd2f_create(s, s); }
-
-  inline Vector(const float& s1, const float& s2) {
-    simd = simd2f_create(s1, s2);
-  }
-
-  explicit inline Vector(const float* v) { simd = simd2f_uload2(v); }
-
-  explicit inline Vector(const VectorPacked<float, 2>& vector) {
-    simd = simd2f_uload2(vector.data);
-  }
-
-  inline float& operator()(const int i) { return data_[i]; }
-
-  inline const float& operator()(const int i) const { return data_[i]; }
-
-  inline float& operator[](const int i) { return data_[i]; }
-
-  inline const float& operator[](const int i) const { return data_[i]; }
-
-  inline void Pack(VectorPacked<float, 2>* const vector) const {
-    simd2f_ustore2(simd, vector->data);
-  }
-
-  inline Vector<float, 2> operator-() const {
-    return Vector<float, 2>(simd2f_sub(simd2f_zero(), simd));
-  }
-
-  inline Vector<float, 2> operator*(const Vector<float, 2>& v) const {
-    return Vector<float, 2>(simd2f_mul(simd, v.simd));
-  }
-
-  inline Vector<float, 2> operator/(const Vector<float, 2>& v) const {
-    return Vector<float, 2>(simd2f_div(simd, v.simd));
-  }
-
-  inline Vector<float, 2> operator+(const Vector<float, 2>& v) const {
-    return Vector<float, 2>(simd2f_add(simd, v.simd));
-  }
-
-  inline Vector<float, 2> operator-(const Vector<float, 2>& v) const {
-    return Vector<float, 2>(simd2f_sub(simd, v.simd));
-  }
-
-  inline Vector<float, 2> operator*(const float& s) const {
-    return Vector<float, 2>(simd2f_mul(simd, simd2f_splat(s)));
-  }
-
-  inline Vector<float, 2> operator/(const float& s) const {
-    return Vector<float, 2>(simd2f_div(simd, simd2f_splat(s)));
-  }
-
-  inline Vector<float, 2> operator+(const float& s) const {
-    return Vector<float, 2>(simd2f_add(simd, simd2f_splat(s)));
-  }
-
-  inline Vector<float, 2> operator-(const float& s) const {
-    return Vector<float, 2>(simd2f_sub(simd, simd2f_splat(s)));
-  }
-
-  inline Vector<float, 2>& operator*=(const Vector<float, 2>& v) {
-    simd = simd2f_mul(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator/=(const Vector<float, 2>& v) {
-    simd = simd2f_div(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator+=(const Vector<float, 2>& v) {
-    simd = simd2f_add(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator-=(const Vector<float, 2>& v) {
-    simd = simd2f_sub(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator*=(const float& s) {
-    simd = simd2f_mul(simd, simd2f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator/=(const float& s) {
-    simd = simd2f_div(simd, simd2f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator+=(const float& s) {
-    simd = simd2f_add(simd, simd2f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 2>& operator-=(const float& s) {
-    simd = simd2f_sub(simd, simd2f_splat(s));
-    return *this;
-  }
-
-  inline bool operator==(const Vector<float, 2>& v) const {
-    for (int i = 0; i < 2; ++i) {
-      if ((*this)[i] != v[i]) return false;
-    }
-    return true;
-  }
-
-  inline bool operator!=(const Vector<float, 2>& v) const {
-    return !operator==(v);
-  }
-
-  inline float LengthSquared() const {
-    return simd2f_get_x(simd2f_dot2(simd, simd));
-  }
-
-  inline float Length() const { return simd2f_get_x(simd2f_length2(simd)); }
-
-  inline float Normalize() {
-    const float length = Length();
-    simd = simd2f_mul(simd, simd2f_splat(1 / length));
-    return length;
-  }
-
-  inline Vector<float, 2> Normalized() const {
-    return Vector<float, 2>(simd2f_normalize2(simd));
-  }
-
-  template <typename CompatibleT>
-  static inline Vector<float, 2> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<float, 2, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<float, 2>& v) {
-    return ToTypeHelper<float, 2, CompatibleT>(v);
-  }
-
-  static inline float DotProduct(const Vector<float, 2>& v1,
-                                 const Vector<float, 2>& v2) {
-    return simd2f_get_x(simd2f_dot2(v1.simd, v2.simd));
-  }
-
-  static inline Vector<float, 2> HadamardProduct(const Vector<float, 2>& v1,
-                                                 const Vector<float, 2>& v2) {
-    return Vector<float, 2>(simd2f_mul(v1.simd, v2.simd));
-  }
-
-  static inline Vector<float, 2> Lerp(const Vector<float, 2>& v1,
-                                      const Vector<float, 2>& v2,
-                                      float percent) {
-    const Vector<float, 2> percentv(percent);
-    const Vector<float, 2> one_minus_percent(
-        simd2f_sub(simd2f_splat(1.0f), percentv.simd));
-    return Vector<float, 2>(
-        simd2f_add(simd2f_mul(one_minus_percent.simd, v1.simd),
-                   simd2f_mul(percentv.simd, v2.simd)));
-  }
-
-  /// Generates a random vector, where the range for each component is
-  /// bounded by min and max.
-  static inline Vector<float, 2> RandomInRange(const Vector<float, 2>& min,
-                                               const Vector<float, 2>& max) {
-    return Vector<float, 2>(mathfu::RandomInRange<float>(min[0], max[0]),
-                            mathfu::RandomInRange<float>(min[1], max[1]));
-  }
-
-  static inline Vector<float, 2> Max(const Vector<float, 2>& v1,
-                                     const Vector<float, 2>& v2) {
-    return Vector<float, 2>(std::max(v1[0], v2[0]), std::max(v1[1], v2[1]));
-  }
-
-  static inline Vector<float, 2> Min(const Vector<float, 2>& v1,
-                                     const Vector<float, 2>& v2) {
-    return Vector<float, 2>(std::min(v1[0], v2[0]), std::min(v1[1], v2[1]));
-  }
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpedantic"
-#endif  // defined(__clang__)
-  union {
-    simd2f simd;
-    float data_[2];
-    struct {
-      float x;
-      float y;
-    };
-  };
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif  // defined(__clang__)
-};
-/// @endcond
-#endif  // !defined(MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT) &&
-        // defined(__ARM_NEON__)
-
-}  // namespace mathfu
-
-#endif  // MATHFU_VECTOR_2_SIMD_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3.h
deleted file mode 100644
index 3e38335..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3.h
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_INTERNAL_VECTOR_3_H_
-#define MATHFU_INTERNAL_VECTOR_3_H_
-
-#include "mathfu/vector.h"
-
-namespace mathfu {
-
-template <class T>
-class Vector<T, 3> {
- public:
-  typedef T Scalar;
-  static const int d = 3;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<T, 3>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = v.data_[i]);
-  }
-
-  template <typename U>
-  explicit inline Vector(const Vector<U, 3>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = static_cast<T>(v[i]));
-  }
-
-  explicit inline Vector(const T& s) { MATHFU_VECTOR_OPERATION(data_[i] = s); }
-
-  explicit inline Vector(const T* a) {
-    MATHFU_VECTOR_OPERATION(data_[i] = a[i]);
-  }
-
-  inline Vector(const T& s1, const T& s2, const T& s3) {
-    x = s1;
-    y = s2;
-    z = s3;
-  }
-
-  inline Vector(const Vector<T, 2>& v12, const T& s3) {
-    x = v12[0];
-    y = v12[1];
-    z = s3;
-  }
-
-  explicit inline Vector(const VectorPacked<T, 3>& vector) {
-    MATHFU_VECTOR_OPERATION(data_[i] = vector.data[i]);
-  }
-
-  inline T& operator()(const int i) { return data_[i]; }
-
-  inline const T& operator()(const int i) const { return data_[i]; }
-
-  inline T& operator[](const int i) { return data_[i]; }
-
-  inline const T& operator[](const int i) const { return data_[i]; }
-
-  inline Vector<T, 3> xyz() { return Vector<T, 3>(x, y, z); }
-
-  inline const Vector<T, 3> xyz() const { return Vector<T, 3>(x, y, z); }
-
-  inline Vector<T, 2> xy() { return Vector<T, 2>(x, y); }
-
-  inline const Vector<T, 2> xy() const { return Vector<T, 2>(x, y); }
-
-  inline void Pack(VectorPacked<T, 3>* const vector) const {
-    MATHFU_VECTOR_OPERATION(vector->data[i] = data_[i]);
-  }
-
-  inline T LengthSquared() const { return LengthSquaredHelper(*this); }
-
-  inline T Length() const { return LengthHelper(*this); }
-
-  inline T Normalize() { return NormalizeHelper(*this); }
-
-  inline Vector<T, 3> Normalized() const { return NormalizedHelper(*this); }
-
-  template <typename CompatibleT>
-  static inline Vector<T, 3> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<T, d, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<T, 3>& v) {
-    return ToTypeHelper<T, d, CompatibleT>(v);
-  }
-
-  static inline T DotProduct(const Vector<T, 3>& v1, const Vector<T, 3>& v2) {
-    return DotProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 3> HadamardProduct(const Vector<T, 3>& v1,
-                                             const Vector<T, 3>& v2) {
-    return HadamardProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 3> CrossProduct(const Vector<T, 3>& v1,
-                                          const Vector<T, 3>& v2) {
-    return CrossProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 3> Lerp(const Vector<T, 3>& v1,
-                                  const Vector<T, 3>& v2, const T percent) {
-    return LerpHelper(v1, v2, percent);
-  }
-
-  static inline Vector<T, 3> RandomInRange(const Vector<T, 3>& min,
-                                           const Vector<T, 3>& max) {
-    return RandomInRangeHelper(min, max);
-  }
-
-  static inline Vector<T, 3> Max(const Vector<T, 3>& v1,
-                                 const Vector<T, 3>& v2) {
-    return MaxHelper(v1, v2);
-  }
-
-  static inline Vector<T, 3> Min(const Vector<T, 3>& v1,
-                                 const Vector<T, 3>& v2) {
-    return MinHelper(v1, v2);
-  }
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  union {
-    T data_[3];
-    struct {
-      T x;
-      T y;
-      T z;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-template <class T>
-struct VectorPacked<T, 3> {
-  /// Create an uninitialized VectorPacked.
-  VectorPacked() {}
-
-  /// Create a VectorPacked from a Vector.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to create the VectorPacked from.
-  explicit VectorPacked(const Vector<T, 3>& vector) { vector.Pack(this); }
-
-  /// Copy a Vector to a VectorPacked.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to copy to the VectorPacked.
-  /// @returns A reference to this VectorPacked.
-  VectorPacked& operator=(const Vector<T, 3>& vector) {
-    vector.Pack(this);
-    return *this;
-  }
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  /// Elements of the packed vector one per dimension.
-  union {
-    T data[3];
-    struct {
-      T x;
-      T y;
-      T z;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-}  //  namespace mathfu
-
-#endif  // MATHFU_INTERNAL_VECTOR_3_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3_simd.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3_simd.h
deleted file mode 100644
index a0af830..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_3_simd.h
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_VECTOR_3_SIMD_H_
-#define MATHFU_VECTOR_3_SIMD_H_
-
-#include "mathfu/internal/vector_3.h"
-#include "mathfu/utilities.h"
-
-#include <math.h>
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-#include "vectorial/simd4f.h"
-#endif
-
-/// @file mathfu/internal/vector_3_simd.h MathFu Vector<T, 3> Specialization
-/// @brief 3-dimensional specialization of mathfu::Vector for SIMD optimized
-/// builds.
-/// @see mathfu::Vector
-
-/// @cond MATHFU_INTERNAL
-/// Add macros to account for both the case where the vector is stored as a
-/// simd intrinsic using 4 elements or as 3 values of type T.
-/// MATHFU_VECTOR3_STORE3/MATHFU_VECTOR3_LOAD3 are additional operations used
-/// to load/store the non simd values from and to simd datatypes. If intrinsics
-/// are used these amount to essentially noops. MATHFU_VECTOR3_INIT3 either
-/// creates a simd datatype if the intrinsic is used or sets the T values if
-/// not.
-#ifdef MATHFU_COMPILE_WITH_PADDING
-#define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
-  { (data).simd = simd_to_store; }
-#define MATHFU_VECTOR3_LOAD3(data) (data).simd
-#define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
-  { (data).simd = simd4f_create(v1, v2, v3, 0); }
-#else
-#define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
-  { simd4f_ustore3(simd_to_store, (data).data_); }
-#define MATHFU_VECTOR3_LOAD3(data) simd4f_uload3((data).data_)
-#define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
-  {                                            \
-    (data).data_[0] = v1;                      \
-    (data).data_[1] = v2;                      \
-    (data).data_[2] = v3;                      \
-  }
-#endif  // MATHFU_COMPILE_WITH_PADDING
-/// @endcond
-
-namespace mathfu {
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-/// @cond MATHFU_INTERNAL
-// This class should remain plain old data.
-template <>
-class Vector<float, 3> {
- public:
-  typedef float Scalar;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<float, 3>& v) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd = v.simd;
-#else
-    MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  explicit inline Vector(const Vector<int, 3>& v) {
-    MATHFU_VECTOR3_INIT3(*this, static_cast<float>(v[0]),
-                         static_cast<float>(v[1]), static_cast<float>(v[2]));
-  }
-
-  inline Vector(const simd4f& v) { MATHFU_VECTOR3_STORE3(v, *this); }
-
-  explicit inline Vector(const float& s) {
-    MATHFU_VECTOR3_INIT3(*this, s, s, s);
-  }
-
-  inline Vector(const float& v1, const float& v2, const float& v3) {
-    MATHFU_VECTOR3_INIT3(*this, v1, v2, v3);
-  }
-
-  inline Vector(const Vector<float, 2>& v12, const float& v3) {
-    MATHFU_VECTOR3_INIT3(*this, v12[0], v12[1], v3);
-  }
-
-  explicit inline Vector(const float* v) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd = simd4f_uload3(v);
-#else
-    MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  explicit inline Vector(const VectorPacked<float, 3>& vector) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd = simd4f_uload3(vector.data);
-#else
-    MATHFU_VECTOR3_INIT3(*this, vector.data[0], vector.data[1], vector.data[2]);
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  inline float& operator()(const int i) { return data_[i]; }
-
-  inline const float& operator()(const int i) const { return data_[i]; }
-
-  inline float& operator[](const int i) { return data_[i]; }
-
-  inline const float& operator[](const int i) const { return data_[i]; }
-
-  /// GLSL style multi-component accessors.
-  inline Vector<float, 2> xy() { return Vector<float, 2>(x, y); }
-  inline const Vector<float, 2> xy() const { return Vector<float, 2>(x, y); }
-
-  inline void Pack(VectorPacked<float, 3>* const vector) const {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd4f_ustore3(simd, vector->data);
-#else
-    vector->data[0] = data_[0];
-    vector->data[1] = data_[1];
-    vector->data[2] = data_[2];
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  inline Vector<float, 3> operator-() const {
-    return Vector<float, 3>(
-        simd4f_sub(simd4f_zero(), MATHFU_VECTOR3_LOAD3(*this)));
-  }
-
-  inline Vector<float, 3> operator*(const Vector<float, 3>& v) const {
-    return Vector<float, 3>(
-        simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
-  }
-
-  inline Vector<float, 3> operator/(const Vector<float, 3>& v) const {
-    return Vector<float, 3>(
-        simd4f_div(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
-  }
-
-  inline Vector<float, 3> operator+(const Vector<float, 3>& v) const {
-    return Vector<float, 3>(
-        simd4f_add(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
-  }
-
-  inline Vector<float, 3> operator-(const Vector<float, 3>& v) const {
-    return Vector<float, 3>(
-        simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
-  }
-
-  inline Vector<float, 3> operator*(const float& s) const {
-    return Vector<float, 3>(
-        simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
-  }
-
-  inline Vector<float, 3> operator/(const float& s) const {
-    return Vector<float, 3>(
-        simd4f_div(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
-  }
-
-  inline Vector<float, 3> operator+(const float& s) const {
-    return Vector<float, 3>(
-        simd4f_add(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
-  }
-
-  inline Vector<float, 3> operator-(const float& s) const {
-    return Vector<float, 3>(
-        simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
-  }
-
-  inline Vector<float, 3>& operator*=(const Vector<float, 3>& v) {
-    *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator/=(const Vector<float, 3>& v) {
-    *this = simd4f_div(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator+=(const Vector<float, 3>& v) {
-    *this = simd4f_add(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator-=(const Vector<float, 3>& v) {
-    *this = simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator*=(const float& s) {
-    *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator/=(const float& s) {
-    *this = simd4f_div(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator+=(const float& s) {
-    *this = simd4f_add(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 3>& operator-=(const float& s) {
-    *this = simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
-    return *this;
-  }
-
-  inline bool operator==(const Vector<float, 3>& v) const {
-    for (int i = 0; i < 3; ++i) {
-      if ((*this)[i] != v[i]) return false;
-    }
-    return true;
-  }
-
-  inline bool operator!=(const Vector<float, 3>& v) const {
-    return !operator==(v);
-  }
-
-  inline float LengthSquared() const {
-    return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(*this),
-                              MATHFU_VECTOR3_LOAD3(*this));
-  }
-
-  inline float Length() const {
-    return simd4f_get_x(simd4f_length3(MATHFU_VECTOR3_LOAD3(*this)));
-  }
-
-  inline float Normalize() {
-    const float length = Length();
-    *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(1 / length));
-    return length;
-  }
-
-  inline Vector<float, 3> Normalized() const {
-    return Vector<float, 3>(simd4f_normalize3(MATHFU_VECTOR3_LOAD3(*this)));
-  }
-
-  template <typename CompatibleT>
-  static inline Vector<float, 3> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<float, 3, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<float, 3>& v) {
-    return ToTypeHelper<float, 3, CompatibleT>(v);
-  }
-
-  static inline float DotProduct(const Vector<float, 3>& v1,
-                                 const Vector<float, 3>& v2) {
-    return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(v1),
-                              MATHFU_VECTOR3_LOAD3(v2));
-  }
-
-  static inline Vector<float, 3> CrossProduct(const Vector<float, 3>& v1,
-                                              const Vector<float, 3>& v2) {
-    return Vector<float, 3>(
-        simd4f_cross3(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
-  }
-
-  static inline Vector<float, 3> HadamardProduct(const Vector<float, 3>& v1,
-                                                 const Vector<float, 3>& v2) {
-    return Vector<float, 3>(
-        simd4f_mul(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
-  }
-
-  static inline Vector<float, 3> Lerp(const Vector<float, 3>& v1,
-                                      const Vector<float, 3>& v2,
-                                      float percent) {
-    const Vector<float, 3> percentv(percent);
-    const Vector<float, 3> one(1.0f);
-    const Vector<float, 3> one_minus_percent = one - percentv;
-    return Vector<float, 3>(simd4f_add(
-        simd4f_mul(MATHFU_VECTOR3_LOAD3(one_minus_percent),
-                   MATHFU_VECTOR3_LOAD3(v1)),
-        simd4f_mul(MATHFU_VECTOR3_LOAD3(percentv), MATHFU_VECTOR3_LOAD3(v2))));
-  }
-
-  /// Generates a random vector, where the range for each component is
-  /// bounded by min and max.
-  static inline Vector<float, 3> RandomInRange(const Vector<float, 3>& min,
-                                               const Vector<float, 3>& max) {
-    return Vector<float, 3>(mathfu::RandomInRange<float>(min[0], max[0]),
-                            mathfu::RandomInRange<float>(min[1], max[1]),
-                            mathfu::RandomInRange<float>(min[2], max[2]));
-  }
-
-  static inline Vector<float, 3> Max(const Vector<float, 3>& v1,
-                                     const Vector<float, 3>& v2) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    return Vector<float, 3>(
-        simd4f_max(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
-#else
-    return Vector<float, 3>(std::max(v1[0], v2[0]), std::max(v1[1], v2[1]),
-                            std::max(v1[2], v2[2]));
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  static inline Vector<float, 3> Min(const Vector<float, 3>& v1,
-                                     const Vector<float, 3>& v2) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    return Vector<float, 3>(
-        simd4f_min(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
-#else
-    return Vector<float, 3>(std::min(v1[0], v2[0]), std::min(v1[1], v2[1]),
-                            std::min(v1[2], v2[2]));
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  template <class T, int rows, int cols>
-  friend class Matrix;
-  template <class T, int d>
-  friend class Vector;
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  union {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd4f simd;
-    float data_[4];
-#else
-    float data_[3];
-#endif  // MATHFU_COMPILE_WITH_PADDING
-
-    struct {
-      float x;
-      float y;
-      float z;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-/// @endcond
-#endif  // MATHFU_COMPILE_WITH_SIMD
-
-}  // namespace mathfu
-
-#endif  // MATHFU_VECTOR_3_SIMD_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4.h
deleted file mode 100644
index 269ecac..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4.h
+++ /dev/null
@@ -1,195 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_INTERNAL_VECTOR_4_H_
-#define MATHFU_INTERNAL_VECTOR_4_H_
-
-// Prefer including vector.h directly, since it includes specializations.
-#include "mathfu/vector.h"
-
-namespace mathfu {
-
-template <class T>
-class Vector<T, 4> {
- public:
-  typedef T Scalar;
-  static const int d = 4;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<T, 4>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = v.data_[i]);
-  }
-
-  template <typename U>
-  explicit inline Vector(const Vector<U, 4>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = static_cast<T>(v[i]));
-  }
-
-  explicit inline Vector(const T& s) { MATHFU_VECTOR_OPERATION(data_[i] = s); }
-
-  explicit inline Vector(const T* a) {
-    MATHFU_VECTOR_OPERATION(data_[i] = a[i]);
-  }
-
-  inline Vector(const T& s1, const T& s2, const T& s3, const T& s4) {
-    x = s1;
-    y = s2;
-    z = s3;
-    w = s4;
-  }
-
-  inline Vector(const Vector<T, 3>& vector3, const T& value) {
-    x = vector3[0];
-    y = vector3[1];
-    z = vector3[2];
-    w = value;
-  }
-
-  inline Vector(const Vector<T, 2>& v12, const Vector<T, 2>& v34) {
-    x = v12[0];
-    y = v12[1];
-    z = v34[0];
-    w = v34[1];
-  }
-
-  explicit inline Vector(const VectorPacked<T, 4>& vector) {
-    MATHFU_VECTOR_OPERATION(data_[i] = vector.data[i]);
-  }
-
-  inline T& operator()(const int i) { return data_[i]; }
-
-  inline const T& operator()(const int i) const { return data_[i]; }
-
-  inline T& operator[](const int i) { return data_[i]; }
-
-  inline const T& operator[](const int i) const { return data_[i]; }
-
-  inline Vector<T, 3> xyz() { return Vector<T, 3>(x, y, z); }
-
-  inline const Vector<T, 3> xyz() const { return Vector<T, 3>(x, y, z); }
-
-  inline Vector<T, 2> xy() { return Vector<T, 2>(x, y); }
-
-  inline const Vector<T, 2> xy() const { return Vector<T, 2>(x, y); }
-
-  inline Vector<T, 2> zw() { return Vector<T, 2>(z, w); }
-
-  inline const Vector<T, 2> zw() const { return Vector<T, 2>(z, w); }
-
-  inline void Pack(VectorPacked<T, 4>* const vector) const {
-    MATHFU_VECTOR_OPERATION(vector->data[i] = data_[i]);
-  }
-
-  inline T LengthSquared() const { return LengthSquaredHelper(*this); }
-
-  inline T Length() const { return LengthHelper(*this); }
-
-  inline T Normalize() { return NormalizeHelper(*this); }
-
-  inline Vector<T, 4> Normalized() const { return NormalizedHelper(*this); }
-
-  template <typename CompatibleT>
-  static inline Vector<T, 4> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<T, d, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<T, 4>& v) {
-    return ToTypeHelper<T, d, CompatibleT>(v);
-  }
-
-  static inline T DotProduct(const Vector<T, 4>& v1, const Vector<T, 4>& v2) {
-    return DotProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 4> HadamardProduct(const Vector<T, 4>& v1,
-                                             const Vector<T, 4>& v2) {
-    return HadamardProductHelper(v1, v2);
-  }
-
-  static inline Vector<T, 4> Lerp(const Vector<T, 4>& v1,
-                                  const Vector<T, 4>& v2, const T percent) {
-    return LerpHelper(v1, v2, percent);
-  }
-
-  static inline Vector<T, 4> RandomInRange(const Vector<T, 4>& min,
-                                           const Vector<T, 4>& max) {
-    return RandomInRangeHelper(min, max);
-  }
-
-  static inline Vector<T, 4> Max(const Vector<T, 4>& v1,
-                                 const Vector<T, 4>& v2) {
-    return MaxHelper(v1, v2);
-  }
-
-  static inline Vector<T, 4> Min(const Vector<T, 4>& v1,
-                                 const Vector<T, 4>& v2) {
-    return MinHelper(v1, v2);
-  }
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  union {
-    T data_[4];
-    struct {
-      T x;
-      T y;
-      T z;
-      T w;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-template <class T>
-struct VectorPacked<T, 4> {
-  /// Create an uninitialized VectorPacked.
-  VectorPacked() {}
-
-  /// Create a VectorPacked from a Vector.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to create the VectorPacked from.
-  explicit VectorPacked(const Vector<T, 4>& vector) { vector.Pack(this); }
-
-  /// Copy a Vector to a VectorPacked.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to copy to the VectorPacked.
-  /// @returns A reference to this VectorPacked.
-  VectorPacked& operator=(const Vector<T, 4>& vector) {
-    vector.Pack(this);
-    return *this;
-  }
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  /// Elements of the packed vector one per dimension.
-  union {
-    T data[4];
-    struct {
-      T x;
-      T y;
-      T z;
-      T w;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-
-}  // namespace mathfu
-
-#endif  // MATHFU_INTERNAL_VECTOR_4_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4_simd.h b/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4_simd.h
deleted file mode 100644
index c741feb..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/internal/vector_4_simd.h
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_VECTOR_4_SIMD_H_
-#define MATHFU_VECTOR_4_SIMD_H_
-
-#include "mathfu/internal/vector_4.h"
-#include "mathfu/utilities.h"
-
-#include <math.h>
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-#include "vectorial/simd4f.h"
-#endif
-
-/// @file mathfu/internal/vector_4_simd.h MathFu Vector<T, 4> Specialization
-/// @brief 4-dimensional specialization of mathfu::Vector for SIMD optimized
-/// builds.
-/// @see mathfu::Vector
-
-namespace mathfu {
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-
-template <>
-class Vector<float, 4> {
- public:
-  typedef float Scalar;
-
-  inline Vector() {}
-
-  inline Vector(const Vector<float, 4>& v) { simd = v.simd; }
-
-  explicit inline Vector(const Vector<int, 4>& v) {
-    data_[0] = static_cast<float>(v[0]);
-    data_[1] = static_cast<float>(v[1]);
-    data_[2] = static_cast<float>(v[2]);
-    data_[3] = static_cast<float>(v[3]);
-  }
-
-  explicit inline Vector(const simd4f& v) { simd = v; }
-
-  explicit inline Vector(const float& s) { simd = simd4f_splat(s); }
-
-  inline Vector(const float& s1, const float& s2, const float& s3,
-                const float& s4) {
-    simd = simd4f_create(s1, s2, s3, s4);
-  }
-
-  explicit inline Vector(const float* v) { simd = simd4f_uload4(v); }
-
-  inline Vector(const Vector<float, 3>& vector3, const float& value) {
-#ifdef MATHFU_COMPILE_WITH_PADDING
-    simd = vector3.simd;
-    (*this)[3] = value;
-#else
-    simd = simd4f_create(vector3[0], vector3[1], vector3[2], value);
-#endif  // MATHFU_COMPILE_WITH_PADDING
-  }
-
-  inline Vector(const Vector<float, 2>& vector12,
-                const Vector<float, 2>& vector34) {
-    simd = simd4f_create(vector12[0], vector12[1], vector34[0], vector34[1]);
-  }
-
-  explicit inline Vector(const VectorPacked<float, 4>& vector) {
-    simd = simd4f_uload4(vector.data);
-  }
-
-  inline float& operator()(const int i) { return data_[i]; }
-
-  inline const float& operator()(const int i) const { return data_[i]; }
-
-  inline float& operator[](const int i) { return data_[i]; }
-
-  inline const float& operator[](const int i) const { return data_[i]; }
-
-  /// GLSL style multi-component accessors.
-  inline Vector<float, 3> xyz() { return Vector<float, 3>(x, y, z); }
-  inline const Vector<float, 3> xyz() const {
-    return Vector<float, 3>(x, y, z);
-  }
-
-  inline Vector<float, 2> xy() { return Vector<float, 2>(x, y); }
-  inline const Vector<float, 2> xy() const { return Vector<float, 2>(x, y); }
-
-  inline Vector<float, 2> zw() { return Vector<float, 2>(z, w); }
-  inline const Vector<float, 2> zw() const { return Vector<float, 2>(z, w); }
-
-  inline void Pack(VectorPacked<float, 4>* const vector) const {
-    simd4f_ustore4(simd, vector->data);
-  }
-
-  inline Vector<float, 4> operator-() const {
-    return Vector<float, 4>(simd4f_sub(simd4f_zero(), simd));
-  }
-
-  inline Vector<float, 4> operator*(const Vector<float, 4>& v) const {
-    return Vector<float, 4>(simd4f_mul(simd, v.simd));
-  }
-
-  inline Vector<float, 4> operator/(const Vector<float, 4>& v) const {
-    return Vector<float, 4>(simd4f_div(simd, v.simd));
-  }
-
-  inline Vector<float, 4> operator+(const Vector<float, 4>& v) const {
-    return Vector<float, 4>(simd4f_add(simd, v.simd));
-  }
-
-  inline Vector<float, 4> operator-(const Vector<float, 4>& v) const {
-    return Vector<float, 4>(simd4f_sub(simd, v.simd));
-  }
-
-  inline Vector<float, 4> operator*(const float& s) const {
-    return Vector<float, 4>(simd4f_mul(simd, simd4f_splat(s)));
-  }
-
-  inline Vector<float, 4> operator/(const float& s) const {
-    return Vector<float, 4>(simd4f_div(simd, simd4f_splat(s)));
-  }
-
-  inline Vector<float, 4> operator+(const float& s) const {
-    return Vector<float, 4>(simd4f_add(simd, simd4f_splat(s)));
-  }
-
-  inline Vector<float, 4> operator-(const float& s) const {
-    return Vector<float, 4>(simd4f_sub(simd, simd4f_splat(s)));
-  }
-
-  inline Vector<float, 4>& operator*=(const Vector<float, 4>& v) {
-    simd = simd4f_mul(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator/=(const Vector<float, 4>& v) {
-    simd = simd4f_div(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator+=(const Vector<float, 4>& v) {
-    simd = simd4f_add(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator-=(const Vector<float, 4>& v) {
-    simd = simd4f_sub(simd, v.simd);
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator*=(const float& s) {
-    simd = simd4f_mul(simd, simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator/=(const float& s) {
-    simd = simd4f_div(simd, simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator+=(const float& s) {
-    simd = simd4f_add(simd, simd4f_splat(s));
-    return *this;
-  }
-
-  inline Vector<float, 4>& operator-=(const float& s) {
-    simd = simd4f_sub(simd, simd4f_splat(s));
-    return *this;
-  }
-
-  inline bool operator==(const Vector<float, 4>& v) const {
-    for (int i = 0; i < 4; ++i) {
-      if ((*this)[i] != v[i]) return false;
-    }
-    return true;
-  }
-
-  inline bool operator!=(const Vector<float, 4>& v) const {
-    return !operator==(v);
-  }
-
-  inline float LengthSquared() const {
-    return simd4f_get_x(simd4f_dot4(simd, simd));
-  }
-
-  inline float Length() const { return simd4f_get_x(simd4f_length4(simd)); }
-
-  inline float Normalize() {
-    const float length = Length();
-    simd = simd4f_mul(simd, simd4f_splat(1 / length));
-    return length;
-  }
-
-  inline Vector<float, 4> Normalized() const {
-    return Vector<float, 4>(simd4f_normalize4(simd));
-  }
-
-  template <typename CompatibleT>
-  static inline Vector<float, 4> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<float, 4, CompatibleT>(compatible);
-  }
-
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<float, 4>& v) {
-    return ToTypeHelper<float, 4, CompatibleT>(v);
-  }
-
-  static inline float DotProduct(const Vector<float, 4>& v1,
-                                 const Vector<float, 4>& v2) {
-    return simd4f_get_x(simd4f_dot4(v1.simd, v2.simd));
-  }
-
-  static inline Vector<float, 4> HadamardProduct(const Vector<float, 4>& v1,
-                                                 const Vector<float, 4>& v2) {
-    return Vector<float, 4>(simd4f_mul(v1.simd, v2.simd));
-  }
-
-  static inline Vector<float, 4> Lerp(const Vector<float, 4>& v1,
-                                      const Vector<float, 4>& v2,
-                                      float percent) {
-    const Vector<float, 4> percentv(percent);
-    const Vector<float, 4> one(1.0f);
-    const Vector<float, 4> one_minus_percent = one - percentv;
-    return Vector<float, 4>(
-        simd4f_add(simd4f_mul(one_minus_percent.simd, v1.simd),
-                   simd4f_mul(percentv.simd, v2.simd)));
-  }
-
-  /// Generates a random vector, where the range for each component is
-  /// bounded by min and max.
-  static inline Vector<float, 4> RandomInRange(const Vector<float, 4>& min,
-                                               const Vector<float, 4>& max) {
-    return Vector<float, 4>(mathfu::RandomInRange<float>(min[0], max[0]),
-                            mathfu::RandomInRange<float>(min[1], max[1]),
-                            mathfu::RandomInRange<float>(min[2], max[2]),
-                            mathfu::RandomInRange<float>(min[3], max[3]));
-  }
-
-  static inline Vector<float, 4> Max(const Vector<float, 4>& v1,
-                                     const Vector<float, 4>& v2) {
-    return Vector<float, 4>(simd4f_max(v1.simd, v2.simd));
-  }
-
-  static inline Vector<float, 4> Min(const Vector<float, 4>& v1,
-                                     const Vector<float, 4>& v2) {
-    return Vector<float, 4>(simd4f_min(v1.simd, v2.simd));
-  }
-
-  template <class T, int rows, int cols>
-  friend class Matrix;
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-#include "mathfu/internal/disable_warnings_begin.h"
-  union {
-    simd4f simd;
-    float data_[4];
-    struct {
-      float x;
-      float y;
-      float z;
-      float w;
-    };
-  };
-#include "mathfu/internal/disable_warnings_end.h"
-};
-/// @endcond
-#endif  // MATHFU_COMPILE_WITH_SIMD
-
-}  // namespace mathfu
-
-#endif  // MATHFU_VECTOR_4_SIMD_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/matrix.h b/third_party/mathfu-1.1.0/include/mathfu/matrix.h
deleted file mode 100644
index 8dda3e9..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/matrix.h
+++ /dev/null
@@ -1,1542 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_MATRIX_H_
-#define MATHFU_MATRIX_H_
-
-#include "mathfu/utilities.h"
-#include "mathfu/vector.h"
-
-#include <cmath>
-
-#include <assert.h>
-
-/// @file mathfu/matrix.h
-/// @brief Matrix class and functions.
-/// @addtogroup mathfu_matrix
-///
-/// MathFu provides a generic Matrix implementation which is specialized
-/// for 4x4 matrices to take advantage of optimization opportunities using
-/// SIMD instructions.
-
-#ifdef _MSC_VER
-#pragma warning(push)
-// The following disables warnings for MATHFU_MAT_OPERATION.
-// The buffer overrun warning must be disabled as MSVC doesn't treat
-// "columns" as constant and therefore assumes that it's possible
-// to overrun arrays indexed by "i".
-// The conditional expression is constant warning is disabled since
-// MSVC decides that "columns" *is* constant when unrolling the operation
-// loop.
-#pragma warning(disable : 4127)  // conditional expression is constant
-#pragma warning(disable : 4789)  // buffer overrun
-#if _MSC_VER >= 1900             // MSVC 2015
-#pragma warning(disable : 4456)  // allow shadowing in unrolled loops
-#pragma warning(disable : 4723)  // suppress "potential divide by 0" warning
-#endif                           // _MSC_VER >= 1900
-#endif                           // _MSC_VER
-
-/// @cond MATHFU_INTERNAL
-/// The stride of a vector (e.g Vector<T, 3>) when cast as an array of floats.
-#define MATHFU_VECTOR_STRIDE_FLOATS(vector) (sizeof(vector) / sizeof(float))
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// This will unroll loops for matrices with <= 4 columns
-#define MATHFU_MAT_OPERATION(OP) MATHFU_UNROLLED_LOOP(i, columns, OP)
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// This will perform a given OP on each matrix column and return the result
-#define MATHFU_MAT_OPERATOR(OP)                   \
-  {                                               \
-    Matrix<T, rows, columns> result;              \
-    MATHFU_MAT_OPERATION(result.data_[i] = (OP)); \
-    return result;                                \
-  }
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// This will perform a given OP on each matrix column
-#define MATHFU_MAT_SELF_OPERATOR(OP) \
-  {                                  \
-    MATHFU_MAT_OPERATION(OP);        \
-    return *this;                    \
-  }
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// This macro will take the dot product for a row from data1 and a column from
-/// data2.
-#define MATHFU_MATRIX_4X4_DOT(data1, data2, r)               \
-  ((data1)[r] * (data2)[0] + (data1)[(r) + 4] * (data2)[1] + \
-   (data1)[(r) + 8] * (data2)[2] + (data1)[(r) + 12] * (data2)[3])
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-#define MATHFU_MATRIX_3X3_DOT(data1, data2, r, size)              \
-  ((data1)[r] * (data2)[0] + (data1)[(r) + (size)] * (data2)[1] + \
-   (data1)[(r) + 2 * (size)] * (data2)[2])
-/// @endcond
-
-namespace mathfu {
-
-/// @cond MATHFU_INTERNAL
-template <class T, int rows, int columns = rows>
-class Matrix;
-template <class T, int rows, int columns>
-inline Matrix<T, rows, columns> IdentityHelper();
-template <bool check_invertible, class T, int rows, int columns>
-inline bool InverseHelper(const Matrix<T, rows, columns>& m,
-                          Matrix<T, rows, columns>* const inverse);
-template <class T, int rows, int columns>
-inline void TimesHelper(const Matrix<T, rows, columns>& m1,
-                        const Matrix<T, rows, columns>& m2,
-                        Matrix<T, rows, columns>* out_m);
-template <class T, int rows, int columns>
-static inline Matrix<T, rows, columns> OuterProductHelper(
-    const Vector<T, rows>& v1, const Vector<T, columns>& v2);
-template <class T>
-inline Matrix<T, 4, 4> PerspectiveHelper(T fovy, T aspect, T znear, T zfar,
-                                         T handedness);
-template <class T>
-static inline Matrix<T, 4, 4> OrthoHelper(T left, T right, T bottom, T top,
-                                          T znear, T zfar, T handedness);
-template <class T>
-static inline Matrix<T, 4, 4> LookAtHelper(const Vector<T, 3>& at,
-                                           const Vector<T, 3>& eye,
-                                           const Vector<T, 3>& up,
-                                           T handedness);
-template <class T>
-static inline bool UnProjectHelper(const Vector<T, 3>& window_coord,
-                                   const Matrix<T, 4, 4>& model_view,
-                                   const Matrix<T, 4, 4>& projection,
-                                   const float window_width,
-                                   const float window_height,
-                                   Vector<T, 3>& result);
-
-template <typename T, int rows, int columns, typename CompatibleT>
-static inline Matrix<T, rows, columns> FromTypeHelper(const CompatibleT& compatible);
-
-template <typename T, int rows, int columns, typename CompatibleT>
-static inline CompatibleT ToTypeHelper(const Matrix<T, rows, columns>& m);
-/// @endcond
-
-/// @addtogroup mathfu_matrix
-/// @{
-/// @class Matrix
-/// @brief Matrix stores a set of "rows" by "columns" elements of type T
-/// and provides functions that operate on the set of elements.
-///
-/// @tparam T type of each element in the matrix.
-/// @tparam rows Number of rows in the matrix.
-/// @tparam columns Number of columns in the matrix.
-template <class T, int rows, int columns>
-class Matrix {
- public:
-  /// @brief Construct a Matrix of uninitialized values.
-  inline Matrix() {}
-
-  /// @brief Construct a Matrix from another Matrix copying each element.
-  ////
-  /// @param m Matrix that the data will be copied from.
-  inline Matrix(const Matrix<T, rows, columns>& m) {
-    MATHFU_MAT_OPERATION(data_[i] = m.data_[i]);
-  }
-
-  /// @brief Construct a Matrix from a single float.
-  ///
-  /// @param s Scalar value used to initialize each element of the matrix.
-  explicit inline Matrix(const T& s) {
-    MATHFU_MAT_OPERATION((data_[i] = Vector<T, rows>(s)));
-  }
-
-  /// @brief Construct a Matrix from four floats.
-  ///
-  /// @note This method only works with a 2x2 Matrix.
-  ///
-  /// @param s00 Value of the first row and column.
-  /// @param s10 Value of the second row, first column.
-  /// @param s01 Value of the first row, second column.
-  /// @param s11 Value of the second row and column.
-  inline Matrix(const T& s00, const T& s10, const T& s01, const T& s11) {
-    MATHFU_STATIC_ASSERT(rows == 2 && columns == 2);
-    data_[0] = Vector<T, rows>(s00, s10);
-    data_[1] = Vector<T, rows>(s01, s11);
-  }
-
-  /// @brief Create a Matrix from nine floats.
-  ///
-  /// @note This method only works with a 3x3 Matrix.
-  ///
-  /// @param s00 Value of the first row and column.
-  /// @param s10 Value of the second row, first column.
-  /// @param s20 Value of the third row, first column.
-  /// @param s01 Value of the first row, second column.
-  /// @param s11 Value of the second row and column.
-  /// @param s21 Value of the third row, second column.
-  /// @param s02 Value of the first row, third column.
-  /// @param s12 Value of the second row, third column.
-  /// @param s22 Value of the third row and column.
-  inline Matrix(const T& s00, const T& s10, const T& s20, const T& s01,
-                const T& s11, const T& s21, const T& s02, const T& s12,
-                const T& s22) {
-    MATHFU_STATIC_ASSERT(rows == 3 && columns == 3);
-    data_[0] = Vector<T, rows>(s00, s10, s20);
-    data_[1] = Vector<T, rows>(s01, s11, s21);
-    data_[2] = Vector<T, rows>(s02, s12, s22);
-  }
-
-  /// @brief Creates a Matrix from twelve floats.
-  ///
-  /// @note This method only works with Matrix<float, 4, 3>.
-  ///
-  ///
-  /// @param s00 Value of the first row and column.
-  /// @param s10 Value of the second row, first column.
-  /// @param s20 Value of the third row, first column.
-  /// @param s30 Value of the fourth row, first column.
-  /// @param s01 Value of the first row, second column.
-  /// @param s11 Value of the second row and column.
-  /// @param s21 Value of the third row, second column.
-  /// @param s31 Value of the fourth row, second column.
-  /// @param s02 Value of the first row, third column.
-  /// @param s12 Value of the second row, third column.
-  /// @param s22 Value of the third row and column.
-  /// @param s32 Value of the fourth row, third column.
-  inline Matrix(const T& s00, const T& s10, const T& s20, const T& s30,
-                const T& s01, const T& s11, const T& s21, const T& s31,
-                const T& s02, const T& s12, const T& s22, const T& s32) {
-    MATHFU_STATIC_ASSERT(rows == 4 && columns == 3);
-    data_[0] = Vector<T, rows>(s00, s10, s20, s30);
-    data_[1] = Vector<T, rows>(s01, s11, s21, s31);
-    data_[2] = Vector<T, rows>(s02, s12, s22, s32);
-  }
-
-  /// @brief Create a Matrix from sixteen floats.
-  ///
-  /// @note This method only works with a 4x4 Matrix.
-  ///
-  /// @param s00 Value of the first row and column.
-  /// @param s10 Value of the second row, first column.
-  /// @param s20 Value of the third row, first column.
-  /// @param s30 Value of the fourth row, first column.
-  /// @param s01 Value of the first row, second column.
-  /// @param s11 Value of the second row and column.
-  /// @param s21 Value of the third row, second column.
-  /// @param s31 Value of the fourth row, second column.
-  /// @param s02 Value of the first row, third column.
-  /// @param s12 Value of the second row, third column.
-  /// @param s22 Value of the third row and column.
-  /// @param s32 Value of the fourth row, third column.
-  /// @param s03 Value of the first row, fourth column.
-  /// @param s13 Value of the second row, fourth column.
-  /// @param s23 Value of the third row, fourth column.
-  /// @param s33 Value of the fourth row and column.
-  inline Matrix(const T& s00, const T& s10, const T& s20, const T& s30,
-                const T& s01, const T& s11, const T& s21, const T& s31,
-                const T& s02, const T& s12, const T& s22, const T& s32,
-                const T& s03, const T& s13, const T& s23, const T& s33) {
-    MATHFU_STATIC_ASSERT(rows == 4 && columns == 4);
-    data_[0] = Vector<T, rows>(s00, s10, s20, s30);
-    data_[1] = Vector<T, rows>(s01, s11, s21, s31);
-    data_[2] = Vector<T, rows>(s02, s12, s22, s32);
-    data_[3] = Vector<T, rows>(s03, s13, s23, s33);
-  }
-
-  /// @brief Create 4x4 Matrix from 4, 4 element vectors.
-  ///
-  /// @note This method only works with a 4x4 Matrix.
-  ///
-  /// @param column0 Vector used for the first column.
-  /// @param column1 Vector used for the second column.
-  /// @param column2 Vector used for the third column.
-  /// @param column3 Vector used for the fourth column.
-  inline Matrix(const Vector<T, 4>& column0, const Vector<T, 4>& column1,
-                const Vector<T, 4>& column2, const Vector<T, 4>& column3) {
-    MATHFU_STATIC_ASSERT(rows == 4 && columns == 4);
-    data_[0] = column0;
-    data_[1] = column1;
-    data_[2] = column2;
-    data_[3] = column3;
-  }
-
-  /// @brief Create a Matrix from the first row * column elements of an array.
-  ///
-  /// @param a Array of values that the matrix will be iniitlized to.
-  explicit inline Matrix(const T* const a) {
-    MATHFU_MAT_OPERATION((data_[i] = Vector<T, rows>(&a[i * columns])));
-  }
-
-  /// @brief Create a Matrix from an array of "columns", "rows" element packed
-  /// vectors.
-  ///
-  /// @param vectors Array of "columns", "rows" element packed vectors.
-  explicit inline Matrix(const VectorPacked<T, rows>* const vectors) {
-    MATHFU_MAT_OPERATION((data_[i] = Vector<T, rows>(vectors[i])));
-  }
-
-  /// @brief Access an element of the matrix.
-  ///
-  /// @param row Index of the row to access.
-  /// @param column Index of the column to access.
-  /// @return Const reference to the element.
-  inline const T& operator()(const int row, const int column) const {
-    return data_[column][row];
-  }
-
-  /// @brief Access an element of the Matrix.
-  ///
-  /// @param row Index of the row to access.
-  /// @param column Index of the column to access.
-  /// @return Reference to the data that can be modified by the caller.
-  inline T& operator()(const int row, const int column) {
-    return data_[column][row];
-  }
-
-  /// @brief Access an element of the Matrix.
-  ///
-  /// @param i Index of the element to access in flattened memory.  Where
-  /// the column accessed is i / rows and the row is i % rows.
-  /// @return Reference to the data that can be modified by the caller.
-  inline const T& operator()(const int i) const { return operator[](i); }
-
-  /// @brief Access an element of the Matrix.
-  ///
-  /// @param i Index of the element to access in flattened memory.  Where
-  /// the column accessed is i / rows and the row is i % rows.
-  /// @return Reference to the data that can be modified by the caller.
-  inline T& operator()(const int i) { return operator[](i); }
-
-  /// @brief Access an element of the Matrix.
-  ///
-  /// @param i Index of the element to access in flattened memory.  Where
-  /// the column accessed is i / rows and the row is i % rows.
-  /// @return Const reference to the data.
-  inline const T& operator[](const int i) const {
-    return const_cast<Matrix<T, rows, columns>*>(this)->operator[](i);
-  }
-
-  /// @brief Access an element of the Matrix.
-  ///
-  /// @param i Index of the element to access in flattened memory.  Where
-  /// the column accessed is i / rows and the row is i % rows.
-  /// @return Reference to the data that can be modified by the caller.
-  inline T& operator[](const int i) {
-#if defined(MATHFU_COMPILE_WITH_PADDING)
-    // In this case Vector<T, 3> is padded, so the element offset must be
-    // accessed using the array operator.
-    if (rows == 3) {
-      const int row = i % rows;
-      const int col = i / rows;
-      return data_[col][row];
-    } else {
-      return reinterpret_cast<T*>(data_)[i];
-    }
-#else
-    return reinterpret_cast<T*>(data_)[i];
-#endif  // defined(MATHFU_COMPILE_WITH_PADDING)
-  }
-
-  /// @brief Pack the matrix to an array of "rows" element vectors,
-  /// one vector per matrix column.
-  ///
-  /// @param vector Array of "columns" entries to write to.
-  inline void Pack(VectorPacked<T, rows>* const vector) const {
-    MATHFU_MAT_OPERATION(GetColumn(i).Pack(&vector[i]));
-  }
-
-  /// @cond MATHFU_INTERNAL
-  /// @brief Access a column vector of the Matrix.
-  ///
-  /// @param i Index of the column to access.
-  /// @return Reference to the data that can be modified by the caller.
-  inline Vector<T, rows>& GetColumn(const int i) { return data_[i]; }
-
-  /// @brief Access a column vector of the Matrix.
-  ///
-  /// @param i Index of the column to access.
-  /// @return Const reference to the data.
-  inline const Vector<T, rows>& GetColumn(const int i) const {
-    return data_[i];
-  }
-  /// @endcond
-
-  /// @brief Negate this Matrix.
-  ///
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator-() const {
-    MATHFU_MAT_OPERATOR(-data_[i]);
-  }
-
-  /// @brief Add a Matrix to this Matrix.
-  ///
-  /// @param m Matrix to add to this Matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator+(
-      const Matrix<T, rows, columns>& m) const {
-    MATHFU_MAT_OPERATOR(data_[i] + m.data_[i]);
-  }
-
-  /// @brief Subtract a Matrix from this Matrix.
-  ///
-  /// @param m Matrix to subtract from this Matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator-(
-      const Matrix<T, rows, columns>& m) const {
-    MATHFU_MAT_OPERATOR(data_[i] - m.data_[i]);
-  }
-
-  /// @brief Add a scalar to each element of this Matrix.
-  ///
-  /// @param s Scalar to add to this Matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator+(const T& s) const {
-    MATHFU_MAT_OPERATOR(data_[i] + s);
-  }
-
-  /// @brief Subtract a scalar from each element of this Matrix.
-  ///
-  /// @param s Scalar to subtract from this matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator-(const T& s) const {
-    MATHFU_MAT_OPERATOR(data_[i] - s);
-  }
-
-  /// @brief Multiply each element of this Matrix with a scalar.
-  ///
-  /// @param s Scalar to multiply with this Matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator*(const T& s) const {
-    MATHFU_MAT_OPERATOR(data_[i] * s);
-  }
-
-  /// @brief Divide each element of this Matrix with a scalar.
-  ///
-  /// @param s Scalar to divide this Matrix with.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator/(const T& s) const {
-    return (*this) * (1 / s);
-  }
-
-  /// @brief Multiply this Matrix with another Matrix.
-  ///
-  /// @param m Matrix to multiply with this Matrix.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> operator*(
-      const Matrix<T, rows, columns>& m) const {
-    Matrix<T, rows, columns> result;
-    TimesHelper(*this, m, &result);
-    return result;
-  }
-
-  /// @brief Add a Matrix to this Matrix (in-place).
-  ///
-  /// @param m Matrix to add to this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator+=(
-      const Matrix<T, rows, columns>& m) {
-    MATHFU_MAT_SELF_OPERATOR(data_[i] += m.data_[i]);
-  }
-
-  /// @brief Subtract a Matrix from this Matrix (in-place).
-  ///
-  /// @param m Matrix to subtract from this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator-=(
-      const Matrix<T, rows, columns>& m) {
-    MATHFU_MAT_SELF_OPERATOR(data_[i] -= m.data_[i]);
-  }
-
-  /// @brief Add a scalar to each element of this Matrix (in-place).
-  ///
-  /// @param s Scalar to add to each element of this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator+=(const T& s) {
-    MATHFU_MAT_SELF_OPERATOR(data_[i] += s);
-  }
-
-  /// @brief Subtract a scalar from each element of this Matrix (in-place).
-  ///
-  /// @param s Scalar to subtract from each element of this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator-=(const T& s) {
-    MATHFU_MAT_SELF_OPERATOR(data_[i] -= s);
-  }
-
-  /// @brief Multiply each element of this Matrix with a scalar (in-place).
-  ///
-  /// @param s Scalar to multiply with each element of this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator*=(const T& s) {
-    MATHFU_MAT_SELF_OPERATOR(data_[i] *= s);
-  }
-
-  /// @brief Divide each element of this Matrix by a scalar (in-place).
-  ///
-  /// @param s Scalar to divide this Matrix by.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator/=(const T& s) {
-    return (*this) *= (1 / s);
-  }
-
-  /// @brief Multiply this Matrix with another Matrix (in-place).
-  ///
-  /// @param m Matrix to multiply with this Matrix.
-  /// @return Reference to this class.
-  inline Matrix<T, rows, columns>& operator*=(
-      const Matrix<T, rows, columns>& m) {
-    const Matrix<T, rows, columns> copy_of_this(*this);
-    TimesHelper(copy_of_this, m, this);
-    return *this;
-  }
-
-  /// @brief Calculate the inverse of this Matrix.
-  ///
-  /// This calculates the inverse Matrix such that
-  /// <code>(m * m).Inverse()</code> is the identity.
-  /// @return Matrix containing the result.
-  inline Matrix<T, rows, columns> Inverse() const {
-    Matrix<T, rows, columns> inverse;
-    InverseHelper<false>(*this, &inverse);
-    return inverse;
-  }
-
-  /// @brief Calculate the inverse of this Matrix.
-  ///
-  /// This calculates the inverse Matrix such that
-  /// <code>(m * m).Inverse()</code> is the identity.
-  /// By contrast to Inverse() this returns whether the matrix is invertible.
-  ///
-  /// The invertible check simply compares the calculated determinant with
-  /// Constants<T>::GetDeterminantThreshold() to roughly determine whether the
-  /// matrix is invertible.  This simple check works in common cases but will
-  /// fail for corner cases where the matrix is a combination of huge and tiny
-  /// values that can't be accurately represented by the floating point
-  /// datatype T.  More extensive checks (relative to the input values) are
-  /// possible but <b>far</b> more expensive, complicated and difficult to
-  /// test.
-  /// @return Whether the matrix is invertible.
-  inline bool InverseWithDeterminantCheck(
-      Matrix<T, rows, columns>* const inverse) const {
-    return InverseHelper<true>(*this, inverse);
-  }
-
-  /// @brief Calculate the transpose of this Matrix.
-  ///
-  /// @return The transpose of the specified Matrix.
-  inline Matrix<T, columns, rows> Transpose() const {
-    Matrix<T, columns, rows> transpose;
-    MATHFU_UNROLLED_LOOP(
-        i, columns, MATHFU_UNROLLED_LOOP(
-                        j, rows, transpose.GetColumn(j)[i] = GetColumn(i)[j]))
-    return transpose;
-  }
-
-  /// @brief Get the 2-dimensional translation of a 2-dimensional affine
-  /// transform.
-  ///
-  /// @note 2-dimensional affine transforms are represented by 3x3 matrices.
-  /// @return Vector with the first two components of column 2 of this Matrix.
-  inline Vector<T, 2> TranslationVector2D() const {
-    MATHFU_STATIC_ASSERT(rows == 3 && columns == 3);
-    return Vector<T, 2>(data_[2][0], data_[2][1]);
-  }
-
-  /// @brief Get the 3-dimensional translation of a 3-dimensional affine
-  /// transform.
-  ///
-  /// @note 3-dimensional affine transforms are represented by 4x4 matrices.
-  /// @return Vector with the first three components of column 3.
-  inline Vector<T, 3> TranslationVector3D() const {
-    MATHFU_STATIC_ASSERT(rows == 4 && columns == 4);
-    return Vector<T, 3>(data_[3][0], data_[3][1], data_[3][2]);
-  }
-
-  /// @brief Load from any byte-wise compatible external matrix.
-  ///
-  /// Format should be `columns` vectors, each holding `rows` values of type T.
-  ///
-  /// Use this for safe conversion from external matrix classes.
-  /// Often, external libraries will have their own matrix types that are,
-  /// byte-for-byte, exactly the same as mathfu::Matrix. This function allows
-  /// you to load a mathfu::Matrix from those external types, without potential
-  /// aliasing bugs that are caused by casting.
-  ///
-  /// @note If your external type gives you access to a T*, then you can
-  ///       equivalently use the Matrix(const T*) constructor.
-  ///
-  /// @param compatible reference to a byte-wise compatible matrix structure;
-  ///                   array of columns x rows Ts.
-  /// @returns `compatible` loaded as a mathfu::Matrix.
-  template <typename CompatibleT>
-  static inline Matrix<T, rows, columns> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<T, rows, columns, CompatibleT>(compatible);
-  }
-
-  /// @brief Load into any byte-wise compatible external matrix.
-  ///
-  /// Format should be `columns` vectors, each holding `rows` values of type T.
-  ///
-  /// Use this for safe conversion to external matrix classes.
-  /// Often, external libraries will have their own matrix types that are,
-  /// byte-for-byte, exactly the same as mathfu::Matrix. This function allows
-  /// you to load an external type from a mathfu::Matrix, without potential
-  /// aliasing bugs that are caused by casting.
-  ///
-  /// @param m reference to mathfu::Matrix to convert.
-  /// @returns CompatibleT loaded from m.
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Matrix<T, rows, columns>& m) {
-    return ToTypeHelper<T, rows, columns, CompatibleT>(m);
-  }
-
-  /// @brief Calculate the outer product of two Vectors.
-  ///
-  /// @return Matrix containing the result.
-  static inline Matrix<T, rows, columns> OuterProduct(
-      const Vector<T, rows>& v1, const Vector<T, columns>& v2) {
-    return OuterProductHelper(v1, v2);
-  }
-
-  /// @brief Calculate the hadamard / component-wise product of two matrices.
-  ///
-  /// @param m1 First Matrix.
-  /// @param m2 Second Matrix.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, rows, columns> HadamardProduct(
-      const Matrix<T, rows, columns>& m1, const Matrix<T, rows, columns>& m2) {
-    MATHFU_MAT_OPERATOR(m1[i] * m2[i]);
-  }
-
-  /// @brief Calculate the identity Matrix.
-  ///
-  /// @return Matrix containing the result.
-  static inline Matrix<T, rows, columns> Identity() {
-    return IdentityHelper<T, rows, columns>();
-  }
-
-  /// @brief Create a 3x3 translation Matrix from a 2-dimensional Vector.
-  ///
-  /// This matrix will have an empty or zero rotation component.
-  ///
-  /// @param v Vector of size 2.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> FromTranslationVector(const Vector<T, 2>& v) {
-    return Matrix<T, 3>(1, 0, 0, 0, 1, 0, v[0], v[1], 1);
-  }
-
-  /// @brief Create a 4x4 translation Matrix from a 3-dimensional Vector.
-  ///
-  /// This matrix will have an empty or zero rotation component.
-  ///
-  /// @param v The vector of size 3.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 4> FromTranslationVector(const Vector<T, 3>& v) {
-    return Matrix<T, 4>(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, v[0], v[1], v[2],
-                        1);
-  }
-
-  /// @brief Create a square Matrix with the diagonal component set to v.
-  ///
-  /// This is an affine transform matrix, so the dimension of the vector is
-  /// one less than the dimension of the matrix.
-  ///
-  /// @param v Vector containing components for scaling.
-  /// @return Matrix with v along the diagonal, and 1 in the bottom right.
-  static inline Matrix<T, rows> FromScaleVector(const Vector<T, rows - 1>& v) {
-    // TODO OPT: Use a helper function in a similar way to Identity to
-    // construct the matrix for the specialized cases 2, 3, 4, and only run
-    // this method in the general case. This will also allow you to use the
-    // helper methods from specialized classes like Matrix<T, 4, 4>.
-    Matrix<T, rows> return_matrix(Identity());
-    for (int i = 0; i < rows - 1; ++i) return_matrix(i, i) = v[i];
-    return return_matrix;
-  }
-
-  /// @brief Create a 4x4 Matrix from a 3x3 rotation Matrix.
-  ///
-  /// This Matrix will have an empty or zero translation component.
-  ///
-  /// @param m 3x3 rotation Matrix.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 4> FromRotationMatrix(const Matrix<T, 3>& m) {
-    return Matrix<T, 4>(m[0], m[1], m[2], 0, m[3], m[4], m[5], 0, m[6], m[7],
-                        m[8], 0, 0, 0, 0, 1);
-  }
-
-  /// @brief Constructs a Matrix<float, 4> from an AffineTransform.
-  ///
-  /// @param affine An AffineTransform reference to be used to construct
-  /// a Matrix<float, 4> by adding in the 'w' row of [0, 0, 0, 1].
-  static inline Matrix<T, 4> FromAffineTransform(
-      const Matrix<T, 4, 3>& affine) {
-    return Matrix<T, 4>(affine[0], affine[4], affine[8], static_cast<T>(0),
-                        affine[1], affine[5], affine[9], static_cast<T>(0),
-                        affine[2], affine[6], affine[10], static_cast<T>(0),
-                        affine[3], affine[7], affine[11], static_cast<T>(1));
-  }
-
-  /// @brief Converts a Matrix<float, 4> into an AffineTransform.
-  ///
-  /// @param m A Matrix<float, 4> reference to be converted into an
-  /// AffineTransform by dropping the fixed 'w' row.
-  ///
-  /// @return Returns an AffineTransform that contains the essential
-  /// transformation data from the Matrix<float, 4>.
-  static inline Matrix<T, 4, 3> ToAffineTransform(const Matrix<T, 4>& m) {
-    return Matrix<T, 4, 3>(m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13],
-                           m[2], m[6], m[10], m[14]);
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from a 2D normalized directional
-  /// Vector around the X axis.
-  ///
-  /// @param v 2D normalized directional Vector.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationX(const Vector<T, 2>& v) {
-    return Matrix<T, 3>(1, 0, 0, 0, v.x, v.y, 0, -v.y, v.x);
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from a 2D normalized directional
-  /// Vector around the Y axis.
-  ///
-  /// @param v 2D normalized directional Vector.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationY(const Vector<T, 2>& v) {
-    return Matrix<T, 3>(v.x, 0, -v.y, 0, 1, 0, v.y, 0, v.x);
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from a 2D normalized directional
-  /// Vector around the Z axis.
-  ///
-  /// @param v 2D normalized directional Vector.
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationZ(const Vector<T, 2>& v) {
-    return Matrix<T, 3>(v.x, v.y, 0, -v.y, v.x, 0, 0, 0, 1);
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from an angle (in radians) around
-  /// the X axis.
-  ///
-  /// @param angle Angle (in radians).
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationX(T angle) {
-    return RotationX(Vector<T, 2>(cosf(angle), sinf(angle)));
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from an angle (in radians) around
-  /// the Y axis.
-  ///
-  /// @param angle Angle (in radians).
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationY(T angle) {
-    return RotationY(Vector<T, 2>(cosf(angle), sinf(angle)));
-  }
-
-  /// @brief Create a 3x3 rotation Matrix from an angle (in radians)
-  /// around the Z axis.
-  ///
-  /// @param angle Angle (in radians).
-  /// @return Matrix containing the result.
-  static inline Matrix<T, 3> RotationZ(T angle) {
-    return RotationZ(Vector<T, 2>(cosf(angle), sinf(angle)));
-  }
-
-  /// @brief Create a 4x4 perspective Matrix.
-  ///
-  /// @param fovy Field of view.
-  /// @param aspect Aspect ratio.
-  /// @param znear Near plane location.
-  /// @param zfar Far plane location.
-  /// @param handedness 1.0f for RH, -1.0f for LH
-  /// @return 4x4 perspective Matrix.
-  static inline Matrix<T, 4, 4> Perspective(T fovy, T aspect, T znear, T zfar,
-                                            T handedness = 1) {
-    return PerspectiveHelper(fovy, aspect, znear, zfar, handedness);
-  }
-
-  /// @brief Create a 4x4 orthographic Matrix.
-  ///
-  /// @param left Left extent.
-  /// @param right Right extent.
-  /// @param bottom Bottom extent.
-  /// @param top Top extent.
-  /// @param znear Near plane location.
-  /// @param zfar Far plane location.
-  /// @param handedness 1.0f for RH, -1.0f for LH
-  /// @return 4x4 orthographic Matrix.
-  static inline Matrix<T, 4, 4> Ortho(T left, T right, T bottom, T top, T znear,
-                                      T zfar, T handedness = 1) {
-    return OrthoHelper(left, right, bottom, top, znear, zfar, handedness);
-  }
-
-  /// @brief Create a 3-dimensional camera Matrix.
-  ///
-  /// @param at The look-at target of the camera.
-  /// @param eye The position of the camera.
-  /// @param up The up vector in the world, for example (0, 1, 0) if the
-  /// y-axis is up.
-  /// @param handedness 1.0f for RH, -1.0f for LH.
-  /// @return 3-dimensional camera Matrix.
-  /// TODO: Change default handedness to +1 so that it matches Perspective().
-  static inline Matrix<T, 4, 4> LookAt(const Vector<T, 3>& at,
-                                       const Vector<T, 3>& eye,
-                                       const Vector<T, 3>& up,
-                                       T handedness = -1) {
-    return LookAtHelper(at, eye, up, handedness);
-  }
-
-  /// @brief Get the 3D position in object space from a window coordinate.
-  ///
-  /// @param window_coord The window coordinate. The z value is for depth.
-  /// A window coordinate on the near plane will have 0 as the z value.
-  /// And a window coordinate on the far plane will have 1 as the z value.
-  /// z value should be with in [0, 1] here.
-  /// @param model_view The Model View matrix.
-  /// @param projection The projection matrix.
-  /// @param window_width Width of the window.
-  /// @param window_height Height of the window.
-  /// @return the mapped 3D position in object space.
-  static inline Vector<T, 3> UnProject(const Vector<T, 3>& window_coord,
-                                       const Matrix<T, 4, 4>& model_view,
-                                       const Matrix<T, 4, 4>& projection,
-                                       const float window_width,
-                                       const float window_height) {
-    Vector<T, 3> result;
-    UnProjectHelper(window_coord, model_view, projection, window_width,
-                    window_height, result);
-    return result;
-  }
-
-  /// @brief Multiply a Vector by a Matrix.
-  ///
-  /// @param v Vector to multiply.
-  /// @param m Matrix to multiply.
-  /// @return Matrix containing the result.
-  friend inline Vector<T, columns> operator*(
-      const Vector<T, rows>& v, const Matrix<T, rows, columns>& m) {
-    const int d = columns;
-    MATHFU_VECTOR_OPERATOR((Vector<T, rows>::DotProduct(m.data_[i], v)));
-  }
-
-  // Dimensions of the matrix.
-  /// Number of rows in the matrix.
-  static const int kRows = rows;
-  /// Number of columns in the matrix.
-  static const int kColumns = columns;
-  /// Total number of elements in the matrix.
-  static const int kElements = rows * columns;
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
- private:
-  Vector<T, rows> data_[columns];
-};
-/// @}
-
-/// @addtogroup mathfu_matrix
-/// @{
-
-/// @brief Multiply each element of a Matrix by a scalar.
-///
-/// @param s Scalar to multiply by.
-/// @param m Matrix to multiply.
-/// @return Matrix containing the result.
-/// @tparam T Type of each element in the Matrix and the scalar type.
-/// @tparam rows Number of rows in the matrix.
-/// @tparam columns Number of columns in the matrix.
-///
-/// @related mathfu::Matrix
-template <class T, int rows, int columns>
-inline Matrix<T, rows, columns> operator*(const T& s,
-                                          const Matrix<T, columns, rows>& m) {
-  return m * s;
-}
-
-/// @brief Multiply a Matrix by a Vector.
-///
-/// @note Template specialized versions are implemented for 2x2, 3x3, and 4x4
-/// matrices to increase performance.  The 3x3 float is also specialized
-/// to supported padded the 3-dimensional Vector in SIMD build configurations.
-///
-/// @param m Matrix to multiply.
-/// @param v Vector to multiply.
-/// @return Vector containing the result.
-///
-/// @related mathfu::Matrix
-template <class T, int rows, int columns>
-inline Vector<T, rows> operator*(const Matrix<T, rows, columns>& m,
-                                 const Vector<T, columns>& v) {
-  const Vector<T, rows> result(0);
-  int offset = 0;
-  for (int column = 0; column < columns; column++) {
-    for (int row = 0; row < rows; row++) {
-      result[row] += m[offset + row] * v[column];
-    }
-    offset += rows;
-  }
-  return result;
-}
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Vector<T, 2> operator*(const Matrix<T, 2, 2>& m, const Vector<T, 2>& v) {
-  return Vector<T, 2>(m[0] * v[0] + m[2] * v[1], m[1] * v[0] + m[3] * v[1]);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Vector<T, 3> operator*(const Matrix<T, 3, 3>& m, const Vector<T, 3>& v) {
-  return Vector<T, 3>(MATHFU_MATRIX_3X3_DOT(&m[0], v, 0, 3),
-                      MATHFU_MATRIX_3X3_DOT(&m[0], v, 1, 3),
-                      MATHFU_MATRIX_3X3_DOT(&m[0], v, 2, 3));
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <>
-inline Vector<float, 3> operator*(const Matrix<float, 3, 3>& m,
-                                  const Vector<float, 3>& v) {
-  return Vector<float, 3>(
-      MATHFU_MATRIX_3X3_DOT(&m[0], v, 0, MATHFU_VECTOR_STRIDE_FLOATS(v)),
-      MATHFU_MATRIX_3X3_DOT(&m[0], v, 1, MATHFU_VECTOR_STRIDE_FLOATS(v)),
-      MATHFU_MATRIX_3X3_DOT(&m[0], v, 2, MATHFU_VECTOR_STRIDE_FLOATS(v)));
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Vector<T, 4> operator*(const Matrix<T, 4, 4>& m, const Vector<T, 4>& v) {
-  return Vector<T, 4>(
-      MATHFU_MATRIX_4X4_DOT(&m[0], v, 0), MATHFU_MATRIX_4X4_DOT(&m[0], v, 1),
-      MATHFU_MATRIX_4X4_DOT(&m[0], v, 2), MATHFU_MATRIX_4X4_DOT(&m[0], v, 3));
-}
-/// @endcond
-
-/// @brief Multiply a 4x4 Matrix by a 3-dimensional Vector.
-///
-/// This is provided as a convenience and assumes the vector has a fourth
-/// component equal to 1.
-///
-/// @param m 4x4 Matrix.
-/// @param v 3-dimensional Vector.
-/// @return 3-dimensional Vector result.
-///
-/// @related mathfu::Matrix
-template <class T>
-inline Vector<T, 3> operator*(const Matrix<T, 4, 4>& m, const Vector<T, 3>& v) {
-  Vector<T, 4> v4(v[0], v[1], v[2], 1);
-  v4 = m * v4;
-  return Vector<T, 3>(v4[0] / v4[3], v4[1] / v4[3], v4[2] / v4[3]);
-}
-
-/// @cond MATHFU_INTERNAL
-/// @brief Multiply a Matrix with another Matrix.
-///
-/// @note Template specialized versions are implemented for 2x2, 3x3, and 4x4
-/// matrices to improve performance. 3x3 float is also specialized because if
-/// SIMD is used the vectors of this type of length 4.
-///
-/// @param m1 Matrix to multiply.
-/// @param m2 Matrix to multiply.
-/// @param out_m Pointer to a Matrix which receives the result.
-///
-/// @tparam T Type of each element in the returned Matrix.
-/// @tparam size1 Number of rows in the returned Matrix and columns in m1.
-/// @tparam size2 Number of columns in the returned Matrix and rows in m2.
-/// @tparam size3 Number of columns in m3.
-template <class T, int size1, int size2, int size3>
-inline void TimesHelper(const Matrix<T, size1, size2>& m1,
-                        const Matrix<T, size2, size3>& m2,
-                        Matrix<T, size1, size3>* out_m) {
-  for (int i = 0; i < size1; i++) {
-    for (int j = 0; j < size3; j++) {
-      Vector<T, size2> row;
-      for (int k = 0; k < size2; k++) {
-        row[k] = m1(i, k);
-      }
-      (*out_m)(i, j) = Vector<T, size2>::DotProduct(m2.GetColumn(j), row);
-    }
-  }
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline void TimesHelper(const Matrix<T, 2, 2>& m1, const Matrix<T, 2, 2>& m2,
-                        Matrix<T, 2, 2>* out_m) {
-  Matrix<T, 2, 2>& out = *out_m;
-  out[0] = m1[0] * m2[0] + m1[2] * m2[1];
-  out[1] = m1[1] * m2[0] + m1[3] * m2[1];
-  out[2] = m1[0] * m2[2] + m1[2] * m2[3];
-  out[3] = m1[1] * m2[2] + m1[3] * m2[3];
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <typename T>
-inline void TimesHelper(const Matrix<T, 3, 3>& m1, const Matrix<T, 3, 3>& m2,
-                        Matrix<T, 3, 3>* out_m) {
-  Matrix<T, 3, 3>& out = *out_m;
-  {
-    Vector<T, 3> row(m1[0], m1[3], m1[6]);
-    out[0] = Vector<T, 3>::DotProduct(m2.GetColumn(0), row);
-    out[3] = Vector<T, 3>::DotProduct(m2.GetColumn(1), row);
-    out[6] = Vector<T, 3>::DotProduct(m2.GetColumn(2), row);
-  }
-  {
-    Vector<T, 3> row(m1[1], m1[4], m1[7]);
-    out[1] = Vector<T, 3>::DotProduct(m2.GetColumn(0), row);
-    out[4] = Vector<T, 3>::DotProduct(m2.GetColumn(1), row);
-    out[7] = Vector<T, 3>::DotProduct(m2.GetColumn(2), row);
-  }
-  {
-    Vector<T, 3> row(m1[2], m1[5], m1[8]);
-    out[2] = Vector<T, 3>::DotProduct(m2.GetColumn(0), row);
-    out[5] = Vector<T, 3>::DotProduct(m2.GetColumn(1), row);
-    out[8] = Vector<T, 3>::DotProduct(m2.GetColumn(2), row);
-  }
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline void TimesHelper(const Matrix<T, 4, 4>& m1, const Matrix<T, 4, 4>& m2,
-                        Matrix<T, 4, 4>* out_m) {
-  Matrix<T, 4, 4>& out = *out_m;
-  {
-    Vector<T, 4> row(m1[0], m1[4], m1[8], m1[12]);
-    out[0] = Vector<T, 4>::DotProduct(m2.GetColumn(0), row);
-    out[4] = Vector<T, 4>::DotProduct(m2.GetColumn(1), row);
-    out[8] = Vector<T, 4>::DotProduct(m2.GetColumn(2), row);
-    out[12] = Vector<T, 4>::DotProduct(m2.GetColumn(3), row);
-  }
-  {
-    Vector<T, 4> row(m1[1], m1[5], m1[9], m1[13]);
-    out[1] = Vector<T, 4>::DotProduct(m2.GetColumn(0), row);
-    out[5] = Vector<T, 4>::DotProduct(m2.GetColumn(1), row);
-    out[9] = Vector<T, 4>::DotProduct(m2.GetColumn(2), row);
-    out[13] = Vector<T, 4>::DotProduct(m2.GetColumn(3), row);
-  }
-  {
-    Vector<T, 4> row(m1[2], m1[6], m1[10], m1[14]);
-    out[2] = Vector<T, 4>::DotProduct(m2.GetColumn(0), row);
-    out[6] = Vector<T, 4>::DotProduct(m2.GetColumn(1), row);
-    out[10] = Vector<T, 4>::DotProduct(m2.GetColumn(2), row);
-    out[14] = Vector<T, 4>::DotProduct(m2.GetColumn(3), row);
-  }
-  {
-    Vector<T, 4> row(m1[3], m1[7], m1[11], m1[15]);
-    out[3] = Vector<T, 4>::DotProduct(m2.GetColumn(0), row);
-    out[7] = Vector<T, 4>::DotProduct(m2.GetColumn(1), row);
-    out[11] = Vector<T, 4>::DotProduct(m2.GetColumn(2), row);
-    out[15] = Vector<T, 4>::DotProduct(m2.GetColumn(3), row);
-  }
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// @brief Compute the identity matrix.
-///
-/// @note There are template specializations for 2x2, 3x3, and 4x4 matrices to
-/// increase performance.
-///
-/// @return Identity Matrix.
-/// @tparam T Type of each element in the returned Matrix.
-/// @tparam rows Number of rows in the returned Matrix.
-/// @tparam columns Number of columns in the returned Matrix.
-template <class T, int rows, int columns>
-inline Matrix<T, rows, columns> IdentityHelper() {
-  Matrix<T, rows, columns> return_matrix(0.f);
-  int min_d = rows < columns ? rows : columns;
-  for (int i = 0; i < min_d; ++i) return_matrix(i, i) = 1;
-  return return_matrix;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Matrix<T, 2, 2> IdentityHelper() {
-  return Matrix<T, 2, 2>(1, 0, 0, 1);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Matrix<T, 3, 3> IdentityHelper() {
-  return Matrix<T, 3, 3>(1, 0, 0, 0, 1, 0, 0, 0, 1);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline Matrix<T, 4, 4> IdentityHelper() {
-  return Matrix<T, 4, 4>(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// @brief Compute the outer product of two vectors.
-///
-/// @note There are template specialization for 2x2, 3x3, and 4x4 matrices to
-/// increase performance.
-template <class T, int rows, int columns>
-static inline Matrix<T, rows, columns> OuterProductHelper(
-    const Vector<T, rows>& v1, const Vector<T, columns>& v2) {
-  Matrix<T, rows, columns> result(0);
-  int offset = 0;
-  for (int column = 0; column < columns; column++) {
-    for (int row = 0; row < rows; row++) {
-      result[row + offset] = v1[row] * v2[column];
-    }
-    offset += rows;
-  }
-  return result;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline Matrix<T, 2, 2> OuterProductHelper(const Vector<T, 2>& v1,
-                                                 const Vector<T, 2>& v2) {
-  return Matrix<T, 2, 2>(v1[0] * v2[0], v1[1] * v2[0], v1[0] * v2[1],
-                         v1[1] * v2[1]);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline Matrix<T, 3, 3> OuterProductHelper(const Vector<T, 3>& v1,
-                                                 const Vector<T, 3>& v2) {
-  return Matrix<T, 3, 3>(v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0],
-                         v1[0] * v2[1], v1[1] * v2[1], v1[2] * v2[1],
-                         v1[0] * v2[2], v1[1] * v2[2], v1[2] * v2[2]);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline Matrix<T, 4, 4> OuterProductHelper(const Vector<T, 4>& v1,
-                                                 const Vector<T, 4>& v2) {
-  return Matrix<T, 4, 4>(
-      v1[0] * v2[0], v1[1] * v2[0], v1[2] * v2[0], v1[3] * v2[0], v1[0] * v2[1],
-      v1[1] * v2[1], v1[2] * v2[1], v1[3] * v2[1], v1[0] * v2[2], v1[1] * v2[2],
-      v1[2] * v2[2], v1[3] * v2[2], v1[0] * v2[3], v1[1] * v2[3], v1[2] * v2[3],
-      v1[3] * v2[3]);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Struct used for template specialization for functions that
-/// returns constants.
-template <class T>
-class Constants {
- public:
-  /// Minimum absolute value of the determinant of an invertible matrix.
-  static T GetDeterminantThreshold() {
-    // No constant defined for the general case.
-    assert(false);
-    return 0;
-  }
-};
-/// @endcond
-
-/// Functions that return constants for <code>float</code> values.
-template <>
-class Constants<float> {
- public:
-  /// @brief Minimum absolute value of the determinant of an invertible
-  /// <code>float</code> Matrix.
-  ///
-  /// <code>float</code> values have 23 bits of precision which is roughly
-  /// 1e7f, given that the final step of matrix inversion is multiplication
-  /// with the inverse of the determinant, the minimum value of the
-  /// determinant is 1e-7f before the precision too low to accurately
-  /// calculate the inverse.
-  /// @returns Minimum absolute value of the determinant of an invertible
-  /// <code>float</code> Matrix.
-  ///
-  /// @related mathfu::Matrix::InverseWithDeterminantCheck()
-  static float GetDeterminantThreshold() { return 1e-7f; }
-};
-
-/// Functions that return constants for <code>double</code> values.
-template <>
-class Constants<double> {
- public:
-  /// @brief Minimum absolute value of the determinant of an invertible
-  /// <code>double</code> Matrix.
-  ///
-  /// <code>double</code> values have 46 bits of precision which is roughly
-  /// 1e15, given that the final step of matrix inversion is multiplication
-  /// with the inverse of the determinant, the minimum value of the
-  /// determinant is 1e-15 before the precision too low to accurately
-  /// calculate the inverse.
-  /// @returns Minimum absolute value of the determinant of an invertible
-  /// <code>double</code> Matrix.
-  ///
-  /// @related mathfu::Matrix::InverseWithDeterminantCheck()
-  static double GetDeterminantThreshold() { return 1e-15; }
-};
-
-/// @cond MATHFU_INTERNAL
-/// @brief Compute the inverse of a matrix.
-///
-/// There is template specialization  for 2x2, 3x3, and 4x4 matrices to
-/// increase performance. Inverse is not implemented for dense matrices that
-/// are not of size 2x2, 3x3, and 4x4.  If check_invertible is true the
-/// determine of the matrix is compared with
-/// Constants<T>::GetDeterminantThreshold() to roughly determine whether the
-/// Matrix is invertible.
-template <bool check_invertible, class T, int rows, int columns>
-inline bool InverseHelper(const Matrix<T, rows, columns>& m,
-                          Matrix<T, rows, columns>* const inverse) {
-  assert(false);
-  (void)m;
-  *inverse = T::Identity();
-  return false;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <bool check_invertible, class T>
-inline bool InverseHelper(const Matrix<T, 2, 2>& m,
-                          Matrix<T, 2, 2>* const inverse) {
-  T determinant = m[0] * m[3] - m[1] * m[2];
-  if (check_invertible &&
-      fabs(determinant) < Constants<T>::GetDeterminantThreshold()) {
-    return false;
-  }
-  T inverseDeterminant = 1 / determinant;
-  (*inverse)[0] = inverseDeterminant * m[3];
-  (*inverse)[1] = -inverseDeterminant * m[1];
-  (*inverse)[2] = -inverseDeterminant * m[2];
-  (*inverse)[3] = inverseDeterminant * m[0];
-  return true;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <bool check_invertible, class T>
-inline bool InverseHelper(const Matrix<T, 3, 3>& m,
-                          Matrix<T, 3, 3>* const inverse) {
-  // Find determinant of matrix.
-  T sub11 = m[4] * m[8] - m[5] * m[7], sub12 = -m[1] * m[8] + m[2] * m[7],
-    sub13 = m[1] * m[5] - m[2] * m[4];
-  T determinant = m[0] * sub11 + m[3] * sub12 + m[6] * sub13;
-  if (check_invertible &&
-      fabs(determinant) < Constants<T>::GetDeterminantThreshold()) {
-    return false;
-  }
-  // Find determinants of 2x2 submatrices for the elements of the inverse.
-  *inverse = Matrix<T, 3, 3>(
-      sub11, sub12, sub13, m[6] * m[5] - m[3] * m[8], m[0] * m[8] - m[6] * m[2],
-      m[3] * m[2] - m[0] * m[5], m[3] * m[7] - m[6] * m[4],
-      m[6] * m[1] - m[0] * m[7], m[0] * m[4] - m[3] * m[1]);
-  *(inverse) *= 1 / determinant;
-  return true;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-inline int FindLargestPivotElem(const Matrix<T, 4, 4>& m) {
-  Vector<T, 4> fabs_column(fabs(m[0]), fabs(m[1]), fabs(m[2]), fabs(m[3]));
-  if (fabs_column[0] > fabs_column[1]) {
-    if (fabs_column[0] > fabs_column[2]) {
-      if (fabs_column[0] > fabs_column[3]) {
-        return 0;
-      } else {
-        return 3;
-      }
-    } else if (fabs_column[2] > fabs_column[3]) {
-      return 2;
-    } else {
-      return 3;
-    }
-  } else if (fabs_column[1] > fabs_column[2]) {
-    if (fabs_column[1] > fabs_column[3]) {
-      return 1;
-    } else {
-      return 3;
-    }
-  } else if (fabs_column[2] > fabs_column[3]) {
-    return 2;
-  } else {
-    return 3;
-  }
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <bool check_invertible, class T>
-bool InverseHelper(const Matrix<T, 4, 4>& m, Matrix<T, 4, 4>* const inverse) {
-  // This will find the pivot element.
-  int pivot_elem = FindLargestPivotElem(m);
-  // This will perform the pivot and find the row, column, and 3x3 submatrix
-  // for this pivot.
-  Vector<T, 3> row, column;
-  Matrix<T, 3> matrix;
-  if (pivot_elem == 0) {
-    row = Vector<T, 3>(m[4], m[8], m[12]);
-    column = Vector<T, 3>(m[1], m[2], m[3]);
-    matrix =
-        Matrix<T, 3>(m[5], m[6], m[7], m[9], m[10], m[11], m[13], m[14], m[15]);
-  } else if (pivot_elem == 1) {
-    row = Vector<T, 3>(m[5], m[9], m[13]);
-    column = Vector<T, 3>(m[0], m[2], m[3]);
-    matrix =
-        Matrix<T, 3>(m[4], m[6], m[7], m[8], m[10], m[11], m[12], m[14], m[15]);
-  } else if (pivot_elem == 2) {
-    row = Vector<T, 3>(m[6], m[10], m[14]);
-    column = Vector<T, 3>(m[0], m[1], m[3]);
-    matrix =
-        Matrix<T, 3>(m[4], m[5], m[7], m[8], m[9], m[11], m[12], m[13], m[15]);
-  } else {
-    row = Vector<T, 3>(m[7], m[11], m[15]);
-    column = Vector<T, 3>(m[0], m[1], m[2]);
-    matrix =
-        Matrix<T, 3>(m[4], m[5], m[6], m[8], m[9], m[10], m[12], m[13], m[14]);
-  }
-  T pivot_value = m[pivot_elem];
-  if (check_invertible &&
-      fabs(pivot_value) < Constants<T>::GetDeterminantThreshold()) {
-    return false;
-  }
-  // This will compute the inverse using the row, column, and 3x3 submatrix.
-  T inv = -1 / pivot_value;
-  row *= inv;
-  matrix += Matrix<T, 3>::OuterProduct(column, row);
-  Matrix<T, 3> mat_inverse;
-  if (!InverseHelper<check_invertible>(matrix, &mat_inverse) &&
-      check_invertible) {
-    return false;
-  }
-  Vector<T, 3> col_inverse = mat_inverse * (column * inv);
-  Vector<T, 3> row_inverse = row * mat_inverse;
-  T pivot_inverse = Vector<T, 3>::DotProduct(row, col_inverse) - inv;
-  if (pivot_elem == 0) {
-    *inverse = Matrix<T, 4, 4>(
-        pivot_inverse, col_inverse[0], col_inverse[1], col_inverse[2],
-        row_inverse[0], mat_inverse[0], mat_inverse[1], mat_inverse[2],
-        row_inverse[1], mat_inverse[3], mat_inverse[4], mat_inverse[5],
-        row_inverse[2], mat_inverse[6], mat_inverse[7], mat_inverse[8]);
-  } else if (pivot_elem == 1) {
-    *inverse = Matrix<T, 4, 4>(
-        row_inverse[0], mat_inverse[0], mat_inverse[1], mat_inverse[2],
-        pivot_inverse, col_inverse[0], col_inverse[1], col_inverse[2],
-        row_inverse[1], mat_inverse[3], mat_inverse[4], mat_inverse[5],
-        row_inverse[2], mat_inverse[6], mat_inverse[7], mat_inverse[8]);
-  } else if (pivot_elem == 2) {
-    *inverse = Matrix<T, 4, 4>(
-        row_inverse[0], mat_inverse[0], mat_inverse[1], mat_inverse[2],
-        row_inverse[1], mat_inverse[3], mat_inverse[4], mat_inverse[5],
-        pivot_inverse, col_inverse[0], col_inverse[1], col_inverse[2],
-        row_inverse[2], mat_inverse[6], mat_inverse[7], mat_inverse[8]);
-  } else {
-    *inverse = Matrix<T, 4, 4>(
-        row_inverse[0], mat_inverse[0], mat_inverse[1], mat_inverse[2],
-        row_inverse[1], mat_inverse[3], mat_inverse[4], mat_inverse[5],
-        row_inverse[2], mat_inverse[6], mat_inverse[7], mat_inverse[8],
-        pivot_inverse, col_inverse[0], col_inverse[1], col_inverse[2]);
-  }
-  return true;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Create a 4x4 perpective matrix.
-template <class T>
-inline Matrix<T, 4, 4> PerspectiveHelper(T fovy, T aspect, T znear, T zfar,
-                                         T handedness) {
-  const T y = 1 / std::tan(fovy * static_cast<T>(.5));
-  const T x = y / aspect;
-  const T zdist = (znear - zfar);
-  const T zfar_per_zdist = zfar / zdist;
-  return Matrix<T, 4, 4>(x, 0, 0, 0, 0, y, 0, 0, 0, 0,
-                         zfar_per_zdist * handedness, -1 * handedness, 0, 0,
-                         2.0f * znear * zfar_per_zdist, 0);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Create a 4x4 orthographic matrix.
-template <class T>
-static inline Matrix<T, 4, 4> OrthoHelper(T left, T right, T bottom, T top,
-                                          T znear, T zfar, T handedness) {
-  return Matrix<T, 4, 4>(static_cast<T>(2) / (right - left), 0, 0, 0, 0,
-                         static_cast<T>(2) / (top - bottom), 0, 0, 0, 0,
-                         -handedness * static_cast<T>(2) / (zfar - znear), 0,
-                         -(right + left) / (right - left),
-                         -(top + bottom) / (top - bottom),
-                         -(zfar + znear) / (zfar - znear), static_cast<T>(1));
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Calculate the axes required to construct a 3-dimensional camera matrix that
-/// looks at "at" from eye position "eye" with the up vector "up".  The axes
-/// are returned in a 4 element "axes" array.
-template <class T>
-static void LookAtHelperCalculateAxes(const Vector<T, 3>& at,
-                                      const Vector<T, 3>& eye,
-                                      const Vector<T, 3>& up, T handedness,
-                                      Vector<T, 3>* const axes) {
-  // Notice that y-axis is always the same regardless of handedness.
-  axes[2] = (at - eye).Normalized();
-  axes[0] = Vector<T, 3>::CrossProduct(up, axes[2]).Normalized();
-  axes[1] = Vector<T, 3>::CrossProduct(axes[2], axes[0]);
-  axes[3] = Vector<T, 3>(handedness * Vector<T, 3>::DotProduct(axes[0], eye),
-                         -Vector<T, 3>::DotProduct(axes[1], eye),
-                         handedness * Vector<T, 3>::DotProduct(axes[2], eye));
-
-  // Default calculation is left-handed (i.e. handedness=-1).
-  // Negate x and z axes for right-handed (i.e. handedness=+1) case.
-  const T neg = -handedness;
-  axes[0] *= neg;
-  axes[2] *= neg;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Create a 3-dimensional camera matrix.
-template <class T>
-static inline Matrix<T, 4, 4> LookAtHelper(const Vector<T, 3>& at,
-                                           const Vector<T, 3>& eye,
-                                           const Vector<T, 3>& up,
-                                           T handedness) {
-  Vector<T, 3> axes[4];
-  LookAtHelperCalculateAxes(at, eye, up, handedness, axes);
-  const Vector<T, 4> column0(axes[0][0], axes[1][0], axes[2][0], 0);
-  const Vector<T, 4> column1(axes[0][1], axes[1][1], axes[2][1], 0);
-  const Vector<T, 4> column2(axes[0][2], axes[1][2], axes[2][2], 0);
-  const Vector<T, 4> column3(axes[3], 1);
-  return Matrix<T, 4, 4>(column0, column1, column2, column3);
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-/// Get the 3D position in object space from a window coordinate.
-template <class T>
-static inline bool UnProjectHelper(const Vector<T, 3>& window_coord,
-                                   const Matrix<T, 4, 4>& model_view,
-                                   const Matrix<T, 4, 4>& projection,
-                                   const float window_width,
-                                   const float window_height,
-                                   Vector<T, 3>& result) {
-  if (window_coord.z < static_cast<T>(0) ||
-      window_coord.z > static_cast<T>(1)) {
-    // window_coord.z should be with in [0, 1]
-    // 0: near plane
-    // 1: far plane
-    return false;
-  }
-  Matrix<T, 4, 4> matrix = (projection * model_view).Inverse();
-  Vector<T, 4> standardized = Vector<T, 4>(
-      static_cast<T>(2) * (window_coord.x - window_width) / window_width +
-          static_cast<T>(1),
-      static_cast<T>(2) * (window_coord.y - window_height) / window_height +
-          static_cast<T>(1),
-      static_cast<T>(2) * window_coord.z - static_cast<T>(1),
-      static_cast<T>(1));
-
-  Vector<T, 4> multiply = matrix * standardized;
-  if (multiply.w == static_cast<T>(0)) {
-    return false;
-  }
-  result = multiply.xyz() / multiply.w;
-  return true;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <typename T, int rows, int columns, typename CompatibleT>
-static inline Matrix<T, rows, columns> FromTypeHelper(const CompatibleT& compatible) {
-// C++11 is required for constructed unions.
-#if __cplusplus >= 201103L
-  // Use a union instead of reinterpret_cast to avoid aliasing bugs.
-  union ConversionUnion {
-    ConversionUnion() {}  // C++11.
-    CompatibleT compatible;
-    VectorPacked<T, rows> packed[columns];
-  } u;
-  static_assert(sizeof(u.compatible) == sizeof(u.packed), "Conversion size mismatch.");
-
-  // The read of `compatible` and write to `u.compatible` gets optimized away,
-  // and this becomes essentially a safe reinterpret_cast.
-  u.compatible = compatible;
-
-  // Call the packed vector constructor with the `compatible` data.
-  return Matrix<T, rows, columns>(u.packed);
-#else
-  // Use the less-desirable memcpy technique if C++11 is not available.
-  // Most compilers understand memcpy deep enough to avoid replace the function
-  // call with a series of load/stores, which should then get optimized away,
-  // however in the worst case the optimize away may not happen.
-  // Note: Memcpy avoids aliasing bugs because it operates via unsigned char*,
-  // which is allowed to alias any type.
-  // See:
-  // http://stackoverflow.com/questions/15745030/type-punning-with-void-without-breaking-the-strict-aliasing-rule-in-c99
-  Matrix<T, rows, columns> m;
-  assert(sizeof(m) == sizeof(compatible));
-  memcpy(&m, &compatible, sizeof(m));
-  return m;
-#endif  // __cplusplus >= 201103L
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <typename T, int rows, int columns, typename CompatibleT>
-static inline CompatibleT ToTypeHelper(const Matrix<T, rows, columns>& m) {
-// See FromTypeHelper() for comments.
-#if __cplusplus >= 201103L
-  union ConversionUnion {
-    ConversionUnion() {}
-    CompatibleT compatible;
-    VectorPacked<T, rows> packed[columns];
-  } u;
-  static_assert(sizeof(u.compatible) == sizeof(u.packed), "Conversion size mismatch.");
-  m.Pack(u.packed);
-  return u.compatible;
-#else
-  CompatibleT compatible;
-  assert(sizeof(m) == sizeof(compatible));
-  memcpy(&compatible, &m, sizeof(compatible));
-  return compatible;
-#endif  // __cplusplus >= 201103L
-}
-/// @endcond
-
-/// @typedef AffineTransform
-///
-/// @brief A typedef representing a 4x3 float affine transformation.
-/// Since the last row ('w' row) of an affine transformation is fixed,
-/// this data type only includes the variable information for the transform.
-typedef Matrix<float, 4, 3> AffineTransform;
-/// @}
-
-}  // namespace mathfu
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-// Include the specializations to avoid template errors.
-// See includes at bottom of vector.h for further explanation.
-#include "mathfu/matrix_4x4.h"
-
-#endif  // MATHFU_MATRIX_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/matrix_4x4.h b/third_party/mathfu-1.1.0/include/mathfu/matrix_4x4.h
deleted file mode 100644
index 0635662..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/matrix_4x4.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_MATRIX_4X4_H_
-#define MATHFU_MATRIX_4X4_H_
-
-// Prefer including matrix.h directly, since it includes specializations.
-#include "mathfu/matrix.h"
-
-#endif  // MATHFU_MATRIX_4X4_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/quaternion.h b/third_party/mathfu-1.1.0/include/mathfu/quaternion.h
deleted file mode 100644
index 0046f2c..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/quaternion.h
+++ /dev/null
@@ -1,526 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_QUATERNION_H_
-#define MATHFU_QUATERNION_H_
-
-#ifdef _WIN32
-#if !defined(_USE_MATH_DEFINES)
-#define _USE_MATH_DEFINES  // For M_PI.
-#endif                     // !defined(_USE_MATH_DEFINES)
-#endif                     // _WIN32
-
-#include "mathfu/matrix.h"
-#include "mathfu/vector.h"
-
-#include <math.h>
-
-/// @file mathfu/quaternion.h
-/// @brief Quaternion class and functions.
-/// @addtogroup mathfu_quaternion
-///
-/// MathFu provides a Quaternion class that utilizes SIMD optimized
-/// Matrix and Vector classes.
-
-namespace mathfu {
-
-/// @addtogroup mathfu_quaternion
-/// @{
-/// @class Quaternion
-///
-/// @brief Stores a Quaternion of type T and provides a set of utility
-/// operations on each Quaternion.
-/// @tparam T Type of each element in the Quaternion.
-template <class T>
-class Quaternion {
- public:
-  /// @brief Construct an uninitialized Quaternion.
-  inline Quaternion() {}
-
-  /// @brief Construct a Quaternion from a copy.
-  /// @param q Quaternion to copy.
-  inline Quaternion(const Quaternion<T>& q) {
-    s_ = q.s_;
-    v_ = q.v_;
-  }
-
-  /// @brief Construct a Quaternion using scalar values to initialize each
-  /// element.
-  ///
-  /// @param s1 Scalar component.
-  /// @param s2 First element of the Vector component.
-  /// @param s3 Second element of the Vector component.
-  /// @param s4 Third element of the Vector component.
-  inline Quaternion(const T& s1, const T& s2, const T& s3, const T& s4) {
-    s_ = s1;
-    v_ = Vector<T, 3>(s2, s3, s4);
-  }
-
-  /// @brief Construct a quaternion from a scalar and 3-dimensional Vector.
-  ///
-  /// @param s1 Scalar component.
-  /// @param v1 Vector component.
-  inline Quaternion(const T& s1, const Vector<T, 3>& v1) {
-    s_ = s1;
-    v_ = v1;
-  }
-
-  /// @brief Return the scalar component of the quaternion.
-  ///
-  /// @return The scalar component
-  inline T& scalar() { return s_; }
-
-  /// @brief Return the scalar component of the quaternion.
-  ///
-  /// @return The scalar component
-  inline const T& scalar() const { return s_; }
-
-  /// @brief Set the scalar component of the quaternion.
-  ///
-  /// @param s Scalar component.
-  inline void set_scalar(const T& s) { s_ = s; }
-
-  /// @brief Return the vector component of the quaternion.
-  ///
-  /// @return The scalar component
-  inline Vector<T, 3>& vector() { return v_; }
-
-  /// @brief Return the vector component of the quaternion.
-  ///
-  /// @return The scalar component
-  inline const Vector<T, 3>& vector() const { return v_; }
-
-  /// @brief Set the vector component of the quaternion.
-  ///
-  /// @param v Vector component.
-  inline void set_vector(const Vector<T, 3>& v) { v_ = v; }
-
-  /// @brief Calculate the inverse Quaternion.
-  ///
-  /// This calculates the inverse such that <code>(q * q).Inverse()</code>
-  /// is the identity.
-  ///
-  /// @return Quaternion containing the result.
-  inline Quaternion<T> Inverse() const { return Quaternion<T>(s_, -v_); }
-
-  /// @brief Multiply this Quaternion with another Quaternion.
-  ///
-  /// @note This is equivalent to
-  /// <code>FromMatrix(ToMatrix() * q.ToMatrix()).</code>
-  /// @param q Quaternion to multiply with.
-  /// @return Quaternion containing the result.
-  inline Quaternion<T> operator*(const Quaternion<T>& q) const {
-    return Quaternion<T>(
-        s_ * q.s_ - Vector<T, 3>::DotProduct(v_, q.v_),
-        s_ * q.v_ + q.s_ * v_ + Vector<T, 3>::CrossProduct(v_, q.v_));
-  }
-
-  /// @brief Multiply this Quaternion by a scalar.
-  ///
-  /// This multiplies the angle of the rotation by a scalar factor.
-  /// @param s1 Scalar to multiply with.
-  /// @return Quaternion containing the result.
-  inline Quaternion<T> operator*(const T& s1) const {
-    T angle;
-    Vector<T, 3> axis;
-    ToAngleAxis(&angle, &axis);
-    angle *= s1;
-    return Quaternion<T>(cos(0.5f * angle),
-                         axis.Normalized() * static_cast<T>(sin(0.5f * angle)));
-  }
-
-  /// @brief Multiply a Vector by this Quaternion.
-  ///
-  /// This will rotate the specified vector by the rotation specified by this
-  /// Quaternion.
-  ///
-  /// @param v1 Vector to multiply by this Quaternion.
-  /// @return Rotated Vector.
-  inline Vector<T, 3> operator*(const Vector<T, 3>& v1) const {
-    T ss = s_ + s_;
-    return ss * Vector<T, 3>::CrossProduct(v_, v1) + (ss * s_ - 1) * v1 +
-           2 * Vector<T, 3>::DotProduct(v_, v1) * v_;
-  }
-
-  /// @brief Normalize this quaterion (in-place).
-  ///
-  /// @return Length of the quaternion.
-  inline T Normalize() {
-    T length = sqrt(s_ * s_ + Vector<T, 3>::DotProduct(v_, v_));
-    T scale = (1 / length);
-    s_ *= scale;
-    v_ *= scale;
-    return length;
-  }
-
-  /// @brief Calculate the normalized version of this quaternion.
-  ///
-  /// @return The normalized quaternion.
-  inline Quaternion<T> Normalized() const {
-    Quaternion<T> q(*this);
-    q.Normalize();
-    return q;
-  }
-
-  /// @brief Convert this Quaternion to an Angle and axis.
-  ///
-  /// The returned  angle is the size of the rotation in radians about the
-  /// axis represented by this Quaternion.
-  ///
-  /// @param angle Receives the angle.
-  /// @param axis Receives the normalized axis.
-  inline void ToAngleAxis(T* angle, Vector<T, 3>* axis) const {
-    *axis = s_ > 0 ? v_ : -v_;
-    *angle = 2 * atan2(axis->Normalize(), s_ > 0 ? s_ : -s_);
-  }
-
-  /// @brief Convert this Quaternion to 3 Euler Angles.
-  ///
-  /// @return 3-dimensional Vector where each element is a angle of rotation
-  /// (in radians) around the x, y, and z axes.
-  inline Vector<T, 3> ToEulerAngles() const {
-    Matrix<T, 3> m(ToMatrix());
-    T cos2 = m[0] * m[0] + m[1] * m[1];
-    if (cos2 < 1e-6f) {
-      return Vector<T, 3>(
-          0,
-          m[2] < 0 ? static_cast<T>(0.5 * M_PI) : static_cast<T>(-0.5 * M_PI),
-          -std::atan2(m[3], m[4]));
-    } else {
-      return Vector<T, 3>(std::atan2(m[5], m[8]),
-                          std::atan2(-m[2], std::sqrt(cos2)),
-                          std::atan2(m[1], m[0]));
-    }
-  }
-
-  /// @brief Convert to a 3x3 Matrix.
-  ///
-  /// @return 3x3 rotation Matrix.
-  inline Matrix<T, 3> ToMatrix() const {
-    const T x2 = v_[0] * v_[0], y2 = v_[1] * v_[1], z2 = v_[2] * v_[2];
-    const T sx = s_ * v_[0], sy = s_ * v_[1], sz = s_ * v_[2];
-    const T xz = v_[0] * v_[2], yz = v_[1] * v_[2], xy = v_[0] * v_[1];
-    return Matrix<T, 3>(1 - 2 * (y2 + z2), 2 * (xy + sz), 2 * (xz - sy),
-                        2 * (xy - sz), 1 - 2 * (x2 + z2), 2 * (sx + yz),
-                        2 * (sy + xz), 2 * (yz - sx), 1 - 2 * (x2 + y2));
-  }
-
-  /// @brief Convert to a 4x4 Matrix.
-  ///
-  /// @return 4x4 transform Matrix.
-  inline Matrix<T, 4> ToMatrix4() const {
-    const T x2 = v_[0] * v_[0], y2 = v_[1] * v_[1], z2 = v_[2] * v_[2];
-    const T sx = s_ * v_[0], sy = s_ * v_[1], sz = s_ * v_[2];
-    const T xz = v_[0] * v_[2], yz = v_[1] * v_[2], xy = v_[0] * v_[1];
-    return Matrix<T, 4>(1 - 2 * (y2 + z2), 2 * (xy + sz), 2 * (xz - sy), 0.0f,
-                        2 * (xy - sz), 1 - 2 * (x2 + z2), 2 * (sx + yz), 0.0f,
-                        2 * (sy + xz), 2 * (yz - sx), 1 - 2 * (x2 + y2), 0.0f,
-                        0.0f, 0.0f, 0.0f, 1.0f);
-  }
-
-  /// @brief Create a Quaternion from an angle and axis.
-  ///
-  /// @param angle Angle in radians to rotate by.
-  /// @param axis Axis in 3D space to rotate around.
-  /// @return Quaternion containing the result.
-  static Quaternion<T> FromAngleAxis(const T& angle, const Vector<T, 3>& axis) {
-    const T halfAngle = static_cast<T>(0.5) * angle;
-    Vector<T, 3> localAxis(axis);
-    return Quaternion<T>(
-        cos(halfAngle),
-        localAxis.Normalized() * static_cast<T>(sin(halfAngle)));
-  }
-
-  /// @brief Create a quaternion from 3 euler angles.
-  ///
-  /// @param angles 3-dimensional Vector where each element contains an
-  /// angle in radius to rotate by about the x, y and z axes.
-  /// @return Quaternion containing the result.
-  static Quaternion<T> FromEulerAngles(const Vector<T, 3>& angles) {
-    const Vector<T, 3> halfAngles(static_cast<T>(0.5) * angles[0],
-                                  static_cast<T>(0.5) * angles[1],
-                                  static_cast<T>(0.5) * angles[2]);
-    const T sinx = std::sin(halfAngles[0]);
-    const T cosx = std::cos(halfAngles[0]);
-    const T siny = std::sin(halfAngles[1]);
-    const T cosy = std::cos(halfAngles[1]);
-    const T sinz = std::sin(halfAngles[2]);
-    const T cosz = std::cos(halfAngles[2]);
-    return Quaternion<T>(cosx * cosy * cosz + sinx * siny * sinz,
-                         sinx * cosy * cosz - cosx * siny * sinz,
-                         cosx * siny * cosz + sinx * cosy * sinz,
-                         cosx * cosy * sinz - sinx * siny * cosz);
-  }
-
-  /// @brief Create a quaternion from a rotation Matrix.
-  ///
-  /// @param m 3x3 rotation Matrix.
-  /// @return Quaternion containing the result.
-  static Quaternion<T> FromMatrix(const Matrix<T, 3>& m) {
-    const T trace = m(0, 0) + m(1, 1) + m(2, 2);
-    if (trace > 0) {
-      const T s = sqrt(trace + 1) * 2;
-      const T oneOverS = 1 / s;
-      return Quaternion<T>(static_cast<T>(0.25) * s, (m[5] - m[7]) * oneOverS,
-                           (m[6] - m[2]) * oneOverS, (m[1] - m[3]) * oneOverS);
-    } else if (m[0] > m[4] && m[0] > m[8]) {
-      const T s = sqrt(m[0] - m[4] - m[8] + 1) * 2;
-      const T oneOverS = 1 / s;
-      return Quaternion<T>((m[5] - m[7]) * oneOverS, static_cast<T>(0.25) * s,
-                           (m[3] + m[1]) * oneOverS, (m[6] + m[2]) * oneOverS);
-    } else if (m[4] > m[8]) {
-      const T s = sqrt(m[4] - m[0] - m[8] + 1) * 2;
-      const T oneOverS = 1 / s;
-      return Quaternion<T>((m[6] - m[2]) * oneOverS, (m[3] + m[1]) * oneOverS,
-                           static_cast<T>(0.25) * s, (m[5] + m[7]) * oneOverS);
-    } else {
-      const T s = sqrt(m[8] - m[0] - m[4] + 1) * 2;
-      const T oneOverS = 1 / s;
-      return Quaternion<T>((m[1] - m[3]) * oneOverS, (m[6] + m[2]) * oneOverS,
-                           (m[5] + m[7]) * oneOverS, static_cast<T>(0.25) * s);
-    }
-  }
-
-  /// @brief Calculate the dot product of two Quaternions.
-  ///
-  /// @param q1 First quaternion.
-  /// @param q2 Second quaternion
-  /// @return The scalar dot product of both Quaternions.
-  static inline T DotProduct(const Quaternion<T>& q1, const Quaternion<T>& q2) {
-    return q1.s_ * q2.s_ + Vector<T, 3>::DotProduct(q1.v_, q2.v_);
-  }
-
-  /// @brief Calculate the spherical linear interpolation between two
-  /// Quaternions.
-  ///
-  /// @param q1 Start Quaternion.
-  /// @param q2 End Quaternion.
-  /// @param s1 The scalar value determining how far from q1 and q2 the
-  /// resulting quaternion should be.  A value of 0 corresponds to q1 and a
-  /// value of 1 corresponds to q2.
-  /// @result Quaternion containing the result.
-  static inline Quaternion<T> Slerp(const Quaternion<T>& q1,
-                                    const Quaternion<T>& q2, const T& s1) {
-    if (q1.s_ * q2.s_ + Vector<T, 3>::DotProduct(q1.v_, q2.v_) > 0.999999f)
-      return Quaternion<T>(q1.s_ * (1 - s1) + q2.s_ * s1,
-                           q1.v_ * (1 - s1) + q2.v_ * s1);
-    return q1 * ((q1.Inverse() * q2) * s1);
-  }
-
-  /// @brief Access an element of the quaternion.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A reference to the accessed data that can be modified by the
-  /// caller.
-  inline T& operator[](const int i) {
-    if (i == 0) return s_;
-    return v_[i - 1];
-  }
-
-  /// @brief Access an element of the quaternion.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A const reference to the accessed.
-  inline const T& operator[](const int i) const {
-    return const_cast<Quaternion<T>*>(this)->operator[](i);
-  }
-
-  /// @brief Returns a vector that is perpendicular to the supplied vector.
-  ///
-  /// @param v1 An arbitrary vector
-  /// @return A vector perpendicular to v1.  Normally this will just be
-  /// the cross product of v1, v2.  If they are parallel or opposite though,
-  /// the routine will attempt to pick a vector.
-  static inline Vector<T, 3> PerpendicularVector(const Vector<T, 3>& v) {
-    // We start out by taking the cross product of the vector and the x-axis to
-    // find something parallel to the input vectors.  If that cross product
-    // turns out to be length 0 (i. e. the vectors already lie along the x axis)
-    // then we use the y-axis instead.
-    Vector<T, 3> axis = Vector<T, 3>::CrossProduct(
-        Vector<T, 3>(static_cast<T>(1), static_cast<T>(0), static_cast<T>(0)),
-        v);
-    // We use a fairly high epsilon here because we know that if this number
-    // is too small, the axis we'll get from a cross product with the y axis
-    // will be much better and more numerically stable.
-    if (axis.LengthSquared() < static_cast<T>(0.05)) {
-      axis = Vector<T, 3>::CrossProduct(
-          Vector<T, 3>(static_cast<T>(0), static_cast<T>(1), static_cast<T>(0)),
-          v);
-    }
-    return axis;
-  }
-
-  /// @brief Returns the a Quaternion that rotates from start to end.
-  ///
-  /// @param v1 The starting vector
-  /// @param v2 The vector to rotate to
-  /// @param preferred_axis the axis to use, if v1 and v2 are parallel.
-  /// @return A Quaternion describing the rotation from v1 to v2
-  /// See the comment on RotateFromToWithAxis for an explanation of the math.
-  static inline Quaternion<T> RotateFromToWithAxis(
-      const Vector<T, 3>& v1, const Vector<T, 3>& v2,
-      const Vector<T, 3>& preferred_axis) {
-    Vector<T, 3> start = v1.Normalized();
-    Vector<T, 3> end = v2.Normalized();
-
-    T dot_product = Vector<T, 3>::DotProduct(start, end);
-    // Any rotation < 0.1 degrees is treated as no rotation
-    // in order to avoid division by zero errors.
-    // So we early-out in cases where it's less then 0.1 degrees.
-    // cos( 0.1 degrees) = 0.99999847691
-    if (dot_product >= static_cast<T>(0.99999847691)) {
-      return Quaternion<T>::identity;
-    }
-    // If the vectors point in opposite directions, return a 180 degree
-    // rotation, on the axis that they asked for.
-    if (dot_product <= static_cast<T>(-0.99999847691)) {
-      return Quaternion<T>(static_cast<T>(0), preferred_axis);
-    }
-    // Degenerate cases have been handled, so if we're here, we have to
-    // actually compute the angle we want:
-    Vector<T, 3> cross_product = Vector<T, 3>::CrossProduct(start, end);
-
-    return Quaternion<T>(static_cast<T>(1.0) + dot_product, cross_product)
-        .Normalized();
-  }
-
-  /// @brief Returns the a Quaternion that rotates from start to end.
-  ///
-  /// @param v1 The starting vector
-  /// @param v2 The vector to rotate to
-  /// @return A Quaternion describing the rotation from v1 to v2.  In the case
-  /// where the vectors are parallel, it returns the identity.  In the case
-  /// where
-  /// they point in opposite directions, it picks an arbitrary axis.  (Since
-  /// there
-  /// are technically infinite possible quaternions to represent a 180 degree
-  /// rotation.)
-  ///
-  /// The final equation used here is fairly elegant, but its derivation is
-  /// not obvious:  We want to find the quaternion that represents the angle
-  /// between Start and End.
-  ///
-  /// The angle can be expressed as a quaternion with the values:
-  ///  angle: ArcCos(dotproduct(start, end) / (|start|*|end|)
-  ///  axis: crossproduct(start, end).normalized * sin(angle/2)
-  ///
-  /// or written as:
-  ///  quaternion(cos(angle/2), axis * sin(angle/2))
-  ///
-  /// Using the trig identity:
-  ///  sin(angle * 2) = 2 * sin(angle) * cos*angle)
-  /// Via substitution, we can turn this into:
-  ///  sin(angle/2) = 0.5 * sin(angle)/cos(angle/2)
-  ///
-  /// Using this substitution, we get:
-  ///  quaternion( cos(angle/2),
-  ///             0.5 * crossproduct(start, end).normalized
-  ///                 * sin(angle) / cos(angle/2))
-  ///
-  /// If we scale the whole thing up by 2 * cos(angle/2) then we get:
-  ///  quaternion(2 * cos(angle/2) * cos(angle/2),
-  ///             crossproduct(start, end).normalized * sin(angle))
-  ///
-  /// (Note that the quaternion is no longer normalized after this scaling)
-  ///
-  /// Another trig identity:
-  ///   cos(angle/2) = sqrt((1 + cos(angle) / 2)
-  ///
-  /// Substituting this in, we can simplify the quaternion scalar:
-  ///
-  ///  quaternion(1 + cos(angle),
-  ///             crossproduct(start, end).normalized * sin(angle))
-  ///
-  /// Because cross(start, end) has a magnitude of |start|*|end|*sin(angle),
-  ///  crossproduct(start,end).normalized
-  /// is equivalent to
-  ///  crossproduct(start,end) / |start| * |end| * sin(angle)
-  /// So after that substitution:
-  ///
-  ///  quaternion(1 + cos(angle),
-  ///             crossproduct(start, end) / (|start| * |end|))
-  ///
-  /// dotproduct(start, end) has the value of |start| * |end| * cos(angle),
-  /// so by algebra,
-  ///  cos(angle) = dotproduct(start, end) / (|start| * |end|)
-  /// we can replace our quaternion scalar here also:
-  ///
-  ///  quaternion(1 + dotproduct(start, end) / (|start| * |end|),
-  ///             crossproduct(start, end) / (|start| * |end|))
-  ///
-  /// If start and end are normalized, then |start| * |end| = 1, giving us a
-  /// final quaternion of:
-  ///
-  /// quaternion(1 + dotproduct(start, end), crossproduct(start, end))
-  static inline Quaternion<T> RotateFromTo(const Vector<T, 3>& v1,
-                                           const Vector<T, 3>& v2) {
-    Vector<T, 3> start = v1.Normalized();
-    Vector<T, 3> end = v2.Normalized();
-
-    T dot_product = Vector<T, 3>::DotProduct(start, end);
-    // Any rotation < 0.1 degrees is treated as no rotation
-    // in order to avoid division by zero errors.
-    // So we early-out in cases where it's less then 0.1 degrees.
-    // cos( 0.1 degrees) = 0.99999847691
-    if (dot_product >= static_cast<T>(0.99999847691)) {
-      return Quaternion<T>::identity;
-    }
-    // If the vectors point in opposite directions, return a 180 degree
-    // rotation, on an arbitrary axis.
-    if (dot_product <= static_cast<T>(-0.99999847691)) {
-      return Quaternion<T>(0, PerpendicularVector(start));
-    }
-    // Degenerate cases have been handled, so if we're here, we have to
-    // actually compute the angle we want:
-    Vector<T, 3> cross_product = Vector<T, 3>::CrossProduct(start, end);
-
-    return Quaternion<T>(static_cast<T>(1.0) + dot_product, cross_product)
-        .Normalized();
-  }
-
-  /// @brief Contains a quaternion doing the identity transform.
-  static Quaternion<T> identity;
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
- private:
-  T s_;
-  Vector<T, 3> v_;
-};
-
-template <typename T>
-Quaternion<T> Quaternion<T>::identity = Quaternion<T>(1, 0, 0, 0);
-/// @}
-
-/// @addtogroup mathfu_quaternion
-/// @{
-
-/// @brief Multiply a Quaternion by a scalar.
-///
-/// This multiplies the angle of the rotation of the specified Quaternion
-/// by a scalar factor.
-/// @param s Scalar to multiply with.
-/// @param q Quaternion to scale.
-/// @return Quaternion containing the result.
-///
-/// @related Quaternion
-template <class T>
-inline Quaternion<T> operator*(const T& s, const Quaternion<T>& q) {
-  return q * s;
-}
-/// @}
-
-}  // namespace mathfu
-#endif  // MATHFU_QUATERNION_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/rect.h b/third_party/mathfu-1.1.0/include/mathfu/rect.h
deleted file mode 100644
index 04d3738..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/rect.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-* Copyright 2016 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_RECT_H_
-#define MATHFU_RECT_H_
-
-#include "mathfu/vector.h"
-
-namespace mathfu {
-
-/// @addtogroup mathfu_rect
-/// @{
-/// @class Rect "mathfu/rect.h"
-/// @brief Rect of type T containing position (pos) and width.
-///
-/// Rect contains two 2D <b>Vector</b>s of type <b>T</b> representing position
-/// (pos) and size.
-///
-/// @tparam T type of Rect elements.
-template <class T>
-struct Rect {
-  Vector<T, 2> pos;
-  Vector<T, 2> size;
-
-  /// @brief Create a rect from a vector4 of the same type.
-  ///
-  /// @param v Vector that the data will be copied from.
-  explicit Rect(const Vector<T, 4>& v)
-      : pos(v.x, v.y), size(v.z, v.w) {}
-
-  /// @brief Create a rect from x, y, width and height values.
-  ///
-  /// @param x the given x value.
-  /// @param y the given y value.
-  /// @param width the given width value.
-  /// @param height the given height value.
-  inline Rect(T x = static_cast<T>(0), T y = static_cast<T>(0),
-              T width = static_cast<T>(0), T height = static_cast<T>(0))
-      : pos(x, y), size(width, height) {}
-
-  /// @brief Create a rect from two vector2 representing position and size.
-  ///
-  /// @param pos Vector representing the position vector (x and y values).
-  /// @param size Vector represening the size vector (width and height values).
-  inline Rect(const Vector<T, 2>& pos, const Vector<T, 2>& size)
-      : pos(pos), size(size) {}
-};
-/// @}
-
-/// @brief Check if two rects are identical.
-///
-/// @param r1 Rect to be tested.
-/// @param r2 Other rect to be tested.
-template <class T>
-bool operator==(const Rect<T>& r1, const Rect<T>& r2) {
-  return (r1.pos == r2.pos && r1.size == r2.size);
-}
-
-/// @brief Check if two rects are <b>not</b> identical.
-///
-/// @param r1 Rect to be tested.
-/// @param r2 Other rect to be tested.
-template <class T>
-bool operator!=(const Rect<T>& r1, const Rect<T>& r2) {
-  return !(r1 == r2);
-}
-
-}  // namespace mathfu
-
-#endif  // MATHFU_RECT_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/utilities.h b/third_party/mathfu-1.1.0/include/mathfu/utilities.h
deleted file mode 100644
index 21dd52e..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/utilities.h
+++ /dev/null
@@ -1,618 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_UTILITIES_H_
-#define MATHFU_UTILITIES_H_
-
-#include <assert.h>
-#include <math.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include <algorithm>
-#include <memory>
-
-/// @file mathfu/utilities.h Utilities
-/// @brief Utility macros and functions.
-
-/// @addtogroup mathfu_build_config
-///
-/// By default MathFu will attempt to build with SIMD optimizations enabled
-/// based upon the target architecture and compiler options.  However, it's
-/// possible to change the default build configuration using the following
-/// macros:
-///
-/// @li @ref MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
-/// @li @ref MATHFU_COMPILE_FORCE_PADDING
-///
-/// <table>
-/// <tr>
-///   <th>MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT</th>
-///   <th>MATHFU_COMPILE_FORCE_PADDING</th>
-///   <th>Configuration</th>
-/// </tr>
-/// <tr>
-///   <td><em>undefined</em></td>
-///   <td><em>undefined</em> or 1</td>
-///   <td>Default build configuration, SIMD optimization is enabled based upon
-///       the target architecture, compiler options and MathFu library
-///       support.</td>
-/// </tr>
-/// <tr>
-///   <td><em>undefined</em></td>
-///   <td>0</td>
-///   <td>If SIMD is supported, padding of data structures is disabled.  See
-///       @ref MATHFU_COMPILE_FORCE_PADDING for more information.</td>
-/// </tr>
-/// <tr>
-///   <td><em>defined</em></td>
-///   <td><em>undefined/0/1</em></td>
-///   <td>Builds MathFu with explicit SIMD optimization disabled.  The compiler
-///       could still potentially optimize some code paths with SIMD
-///       instructions based upon the compiler options.</td>
-/// </tr>
-/// </table>
-
-#ifdef DOXYGEN
-/// @addtogroup mathfu_build_config
-/// @{
-/// @def MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
-/// @brief Disable SIMD build configuration.
-///
-/// When defined, this macro <b>disables</b> the default behavior of trying to
-/// build the library with SIMD enabled  based upon the target architecture
-/// and compiler options.
-///
-/// To use this build option, this macro <b>must</b> be defined in all modules
-/// of the project.
-#define MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
-/// @}
-#endif  // DOXYGEN
-#if !defined(MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT)
-#if defined(__SSE__)
-#define MATHFU_COMPILE_WITH_SIMD
-#elif defined(__ARM_NEON__)
-#define MATHFU_COMPILE_WITH_SIMD
-#elif defined(_M_IX86_FP)  // MSVC
-#if _M_IX86_FP >= 1        // SSE enabled
-#define MATHFU_COMPILE_WITH_SIMD
-#endif  // _M_IX86_FP >= 1
-#endif
-#endif  // !defined(MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT)
-
-#ifdef DOXYGEN
-/// @addtogroup mathfu_build_config
-/// @{
-/// @def MATHFU_COMPILE_FORCE_PADDING
-/// @brief Enable / disable padding of data structures.
-///
-/// By default, when @ref MATHFU_COMPILE_FORCE_PADDING is <b>not</b> defined,
-/// data structures are padded when SIMD is enabled
-/// (i.e when @ref MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT is also not defined).
-///
-/// If @ref MATHFU_COMPILE_FORCE_PADDING is defined as <b>1</b>, all data
-/// structures are padded to a power of 2 size which enables more efficient
-/// SIMD operations.  This  is the default build configuration when SIMD is
-/// enabled.
-///
-/// If @ref MATHFU_COMPILE_FORCE_PADDING is defined as <b>0</b>, all data
-/// structures are packed by the compiler (with no padding) even when the SIMD
-/// build configuration is enabled.  This build option can be useful in the
-/// rare occasion an application is CPU memory bandwidth constrained, at the
-/// expense of additional instructions to copy to / from SIMD registers.
-///
-/// To use this build option, this macro <b>must</b> be defined in all modules
-/// of the project.
-///
-/// @see MATHFU_COMPILE_WITHOUT_SIMD_SUPPORT
-#define MATHFU_COMPILE_FORCE_PADDING
-/// @}
-#endif  // DOXYGEN
-
-#ifdef MATHFU_COMPILE_WITH_SIMD
-/// @cond MATHFU_INTERNAL
-/// @addtogroup mathfu_build_config
-/// @{
-/// @def MATHFU_COMPILE_WITH_PADDING
-/// @brief Enable padding of data structures to be efficient with SIMD.
-///
-/// When defined, this option enables padding of some data structures (e.g
-/// @ref vec3) to be more efficient with SIMD operations.  This option is
-/// only applicable when @ref MATHFU_COMPILE_WITHOUT_SIMD is not defined and
-/// the target architecture and compiler support SIMD.
-///
-/// To use this build option, this macro <b>must</b> be defined in all modules
-/// of the project.
-/// @see MATHFU_COMPILE_FORCE_PADDING
-#define MATHFU_COMPILE_WITH_PADDING
-/// @}
-#if defined(MATHFU_COMPILE_FORCE_PADDING)
-#if MATHFU_COMPILE_FORCE_PADDING == 1
-#if !defined(MATHFU_COMPILE_WITH_PADDING)
-#define MATHFU_COMPILE_WITH_PADDING
-#endif  // !defined(MATHFU_COMPILE_WITH_PADDING)
-#else
-#if defined(MATHFU_COMPILE_WITH_PADDING)
-#undef MATHFU_COMPILE_WITH_PADDING
-#endif  // MATHFU_COMPILE_WITH_PADDING
-#endif  // MATHFU_COMPILE_FORCE_PADDING == 1
-#endif  // MATHFU_COMPILE_FORCE_PADDING
-/// @endcond
-#endif  // MATHFU_COMPILE_WITH_SIMD
-
-/// @addtogroup mathfu_version
-/// @{
-
-/// @def MATHFU_VERSION_MAJOR
-/// @brief Major version number of the library.
-/// @see kMathFuVersionString
-#define MATHFU_VERSION_MAJOR 1
-/// @def MATHFU_VERSION_MINOR
-/// @brief Minor version number of the library.
-/// @see kMathFuVersionString
-#define MATHFU_VERSION_MINOR 1
-/// @def MATHFU_VERSION_REVISION
-/// @brief Revision number of the library.
-/// @see kMathFuVersionString
-#define MATHFU_VERSION_REVISION 0
-
-/// @}
-
-/// @cond MATHFU_INTERNAL
-#define MATHFU_STRING_EXPAND(X) #X
-#define MATHFU_STRING(X) MATHFU_STRING_EXPAND(X)
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-// Generate string which contains build options for the library.
-#if defined(MATHFU_COMPILE_WITH_SIMD)
-#define MATHFU_BUILD_OPTIONS_SIMD "[simd]"
-#else
-#define MATHFU_BUILD_OPTIONS_SIMD "[no simd]"
-#endif  // defined(MATHFU_COMPILE_WITH_SIMD)
-#if defined(MATHFU_COMPILE_WITH_PADDING)
-#define MATHFU_BUILD_OPTIONS_PADDING "[padding]"
-#else
-#define MATHFU_BUILD_OPTIONS_PADDING "[no padding]"
-#endif  // defined(MATHFU_COMPILE_WITH_PADDING)
-/// @endcond
-
-/// @addtogroup mathfu_version
-/// @{
-/// @def MATHFU_BUILD_OPTIONS_STRING
-/// @brief String that describes the library's build configuration.
-#define MATHFU_BUILD_OPTIONS_STRING \
-  (MATHFU_BUILD_OPTIONS_SIMD " " MATHFU_BUILD_OPTIONS_PADDING)
-/// @}
-
-// Weak linkage is culled by VS & doesn't work on cygwin.
-#if !defined(_WIN32) && !defined(__CYGWIN__)
-
-extern volatile __attribute__((weak)) const char *kMathFuVersionString;
-/// @addtogroup mathfu_version
-/// @{
-
-/// @var kMathFuVersionString
-/// @brief String which identifies the current version of MathFu.
-///
-/// @ref kMathFuVersionString is used by Google developers to identify which
-/// applications uploaded to Google Play are using this library.  This allows
-/// the development team at Google to determine the popularity of the library.
-/// How it works: Applications that are uploaded to the Google Play Store are
-/// scanned for this version string.  We track which applications are using it
-/// to measure popularity.  You are free to remove it (of course) but we would
-/// appreciate if you left it in.
-///
-/// @see MATHFU_VERSION_MAJOR
-/// @see MATHFU_VERSION_MINOR
-/// @see MATHFU_VERSION_REVISION
-volatile __attribute__((weak)) const char *kMathFuVersionString =
-    "MathFu " MATHFU_STRING(MATHFU_VERSION_MAJOR) "." MATHFU_STRING(
-        MATHFU_VERSION_MINOR) "." MATHFU_STRING(MATHFU_VERSION_REVISION);
-/// @}
-
-#endif  // !defined(_WIN32) && !defined(__CYGWIN__)
-
-/// @cond MATHFU_INTERNAL
-template <bool>
-struct static_assert_util;
-template <>
-struct static_assert_util<true> {};
-/// @endcond
-
-/// @addtogroup mathfu_utilities
-/// @{
-/// @def MATHFU_STATIC_ASSERT
-/// @brief Compile time assert for pre-C++11 compilers.
-///
-/// For example:
-/// <blockquote><code>
-/// MATHFU_STATIC_ASSERT(0 == 1);
-/// </code></blockquote> will result in a compile error.
-#define MATHFU_STATIC_ASSERT(x) static_assert_util<(x)>()
-/// @}
-
-/// @cond MATHFU_INTERNAL
-/// Unroll an loop up to 4 iterations, where iterator is the identifier
-/// used in each operation (e.g "i"), number_of_iterations is a constant which
-/// specifies the number of times to perform the operation and "operation" is
-/// the statement to execute for each iteration of the loop (e.g data[i] = v).
-#define MATHFU_UNROLLED_LOOP(iterator, number_of_iterations, operation) \
-  {                                                                     \
-    const int iterator = 0;                                             \
-    { operation; }                                                      \
-    if ((number_of_iterations) > 1) {                                   \
-      const int iterator = 1;                                           \
-      { operation; }                                                    \
-      if ((number_of_iterations) > 2) {                                 \
-        const int iterator = 2;                                         \
-        { operation; }                                                  \
-        if ((number_of_iterations) > 3) {                               \
-          const int iterator = 3;                                       \
-          { operation; }                                                \
-          if ((number_of_iterations) > 4) {                             \
-            for (int iterator = 4; iterator < (number_of_iterations);   \
-                 ++iterator) {                                          \
-              operation;                                                \
-            }                                                           \
-          }                                                             \
-        }                                                               \
-      }                                                                 \
-    }                                                                   \
-  }
-/// @endcond
-
-namespace mathfu {
-
-/// @addtogroup mathfu_utilities
-/// @{
-
-/// @brief Clamp x within [lower, upper].
-/// @anchor mathfu_Clamp
-///
-/// @note Results are undefined if lower > upper.
-///
-/// @param x Value to clamp.
-/// @param lower Lower value of the range.
-/// @param upper Upper value of the range.
-/// @returns Clamped value.
-template <class T>
-T Clamp(const T &x, const T &lower, const T &upper) {
-  return std::max<T>(lower, std::min<T>(x, upper));
-}
-
-/// @brief Linearly interpolate between range_start and range_end, based on
-/// percent.
-/// @anchor mathfu_Lerp
-///
-/// @param range_start Start of the range.
-/// @param range_end End of the range.
-/// @param percent Value between 0.0 and 1.0 used to interpolate between
-/// range_start and range_end.  Where a value of 0.0 results in a return
-/// value of range_start and 1.0 results in a return value of range_end.
-/// @return Value between range_start and range_end.
-///
-/// @tparam T Type of the range to interpolate over.
-/// @tparam T2 Type of the value used to perform interpolation
-///         (e.g float or double).
-template <class T, class T2>
-T Lerp(const T &range_start, const T &range_end, const T2 &percent) {
-  const T2 one_minus_percent = static_cast<T2>(1.0) - percent;
-  return range_start * one_minus_percent + range_end * percent;
-}
-
-/// @brief Linearly interpolate between range_start and range_end, based on
-/// percent.
-/// @anchor mathfu_Lerp2
-///
-/// @param range_start Start of the range.
-/// @param range_end End of the range.
-/// @param percent Value between 0.0 and 1.0 used to interpolate between
-/// range_start and range_end.  Where a value of 0.0 results in a return
-/// value of range_start and 1.0 results in a return value of range_end.
-/// @return Value between range_start and range_end.
-///
-/// @tparam T Type of the range to interpolate over.
-template <class T>
-T Lerp(const T &range_start, const T &range_end, const T &percent) {
-  return Lerp<T, T>(range_start, range_end, percent);
-}
-
-/// @brief Check if val is within [range_start..range_end).
-/// @anchor mathfu_InRange
-///
-/// @param val Value to be tested.
-/// @param range_start Starting point of the range (inclusive).
-/// @param range_end Ending point of the range (non-inclusive).
-/// @return Bool indicating success.
-///
-/// @tparam T Type of values to test.
-template <class T>
-bool InRange(T val, T range_start, T range_end) {
-  return val >= range_start && val < range_end;
-}
-
-/// @brief  Generate a random value of type T.
-/// @anchor mathfu_Random
-///
-/// This method generates a random value of type T, greater than or equal to
-/// 0.0 and less than 1.0.
-///
-/// This function uses the standard C library function rand() from math.h to
-/// generate the random number.
-///
-/// @returns Random number greater than or equal to 0.0 and less than 1.0.
-///
-/// @see RandomRange()
-/// @see RandomInRange()
-template <class T>
-inline T Random() {
-  return static_cast<T>(rand()) / static_cast<T>(RAND_MAX);
-}
-
-/// @cond MATHFU_INTERNAL
-template <>
-inline float Random() {
-  return static_cast<float>(rand() >> 8) /
-         (static_cast<float>((RAND_MAX >> 8) + 1));
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <>
-inline double Random() {
-  return static_cast<double>(rand()) / (static_cast<double>(RAND_MAX + 1LL));
-}
-/// @endcond
-
-/// @brief Generate a random value of type T in the range -range...+range
-/// @anchor mathfu_RandomRange
-///
-/// This function uses the standard C library function rand() from math.h to
-/// generate the random number.
-///
-/// @param range Range of the random value to generate.
-/// @return Random value in the range -range to +range
-///
-/// @see Random()
-template <class T>
-inline T RandomRange(T range) {
-  return (Random<T>() * range * 2) - range;
-}
-
-/// @brief Generate a random number between [range_start, range_end]
-/// @anchor mathfu_RandomInRange
-///
-/// This function uses the standard C library function rand() from math.h to
-/// generate the random number.
-///
-/// @param range_start Minimum value.
-/// @param range_end Maximum value.
-/// @return Random value in the range [range_start, range_end].
-///
-/// @see Lerp()
-/// @see Random()
-template <class T>
-inline T RandomInRange(T range_start, T range_end) {
-  return Lerp(range_start, range_end, Random<T>());
-}
-
-/// @cond MATHFU_INTERNAL
-template <>
-inline int RandomInRange<int>(int range_start, int range_end) {
-  return static_cast<int>(RandomInRange<float>(static_cast<float>(range_start),
-                                               static_cast<float>(range_end)));
-}
-/// @endcond
-
-/// @brief Round a value up to the nearest power of 2.
-///
-/// @param x Value to round up.
-/// @returns Value rounded up to the nearest power of 2.
-template <class T>
-T RoundUpToPowerOf2(T x) {
-  return static_cast<T>(
-      pow(static_cast<T>(2), ceil(log(x) / log(static_cast<T>(2)))));
-}
-
-/// @brief Specialized version of RoundUpToPowerOf2 for int32_t.
-template <>
-inline int32_t RoundUpToPowerOf2<>(int32_t x) {
-  x--;
-  x |= x >> 1;
-  x |= x >> 2;
-  x |= x >> 4;
-  x |= x >> 8;
-  x |= x >> 16;
-  x++;
-  return x;
-}
-
-/// @brief Round a value up to the type's size boundary.
-///
-/// @param v Value to round up.
-/// @returns Value rounded up to the type's size boundary.
-template <typename T>
-uint32_t RoundUpToTypeBoundary(uint32_t v) {
-  return (v + sizeof(T) - 1) & ~(sizeof(T) - 1);
-}
-
-/// @}
-
-/// @addtogroup mathfu_allocator
-///
-/// If you use MathFu with SIMD (SSE in particular), you need to have all
-/// your allocations be 16-byte aligned (which isn't the case with the default
-/// allocators on most platforms except OS X).
-///
-/// You can either use simd_allocator, which solves the problem for
-/// any STL containers, but not for manual dynamic allocations or the
-/// new/delete override MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE will
-/// solve it for all allocations, at the cost of MATHFU_ALIGNMENT bytes per
-/// allocation.
-
-/// @addtogroup mathfu_allocator
-/// @{
-
-/// @def MATHFU_ALIGNMENT
-/// @brief Alignment (in bytes) of memory allocated by AllocateAligned.
-///
-/// @see mathfu::AllocateAligned()
-/// @see mathfu::simd_allocator
-#define MATHFU_ALIGNMENT 16
-
-/// @brief Allocate an aligned block of memory.
-/// @anchor mathfu_AllocateAligned
-///
-/// This function allocates a block of memory aligned to MATHFU_ALIGNMENT
-/// bytes.
-///
-/// @param n Size of memory to allocate.
-/// @return Pointer to aligned block of allocated memory or NULL if
-/// allocation failed.
-inline void *AllocateAligned(size_t n) {
-#if defined(_MSC_VER) && _MSC_VER >= 1900  // MSVC 2015
-  return _aligned_malloc(n, MATHFU_ALIGNMENT);
-#else
-  // We need to allocate extra bytes to guarantee alignment,
-  // and to store the pointer to the original buffer.
-  uint8_t *buf = reinterpret_cast<uint8_t *>(malloc(n + MATHFU_ALIGNMENT));
-  if (!buf) return NULL;
-  // Align to next higher multiple of MATHFU_ALIGNMENT.
-  uint8_t *aligned_buf = reinterpret_cast<uint8_t *>(
-      (reinterpret_cast<size_t>(buf) + MATHFU_ALIGNMENT) &
-      ~(MATHFU_ALIGNMENT - 1));
-  // Write out original buffer pointer before aligned buffer.
-  // The assert will fail if the allocator granularity is less than the pointer
-  // size, or if MATHFU_ALIGNMENT doesn't fit two pointers.
-  assert(static_cast<size_t>(aligned_buf - buf) > sizeof(void *));
-  *(reinterpret_cast<uint8_t **>(aligned_buf) - 1) = buf;
-  return aligned_buf;
-#endif  // defined(_MSC_VER) && _MSC_VER >= 1900 // MSVC 2015
-}
-
-/// @brief Deallocate a block of memory allocated with AllocateAligned().
-/// @anchor mathfu_FreeAligned
-///
-/// @param p Pointer to memory to deallocate.
-inline void FreeAligned(void *p) {
-#if defined(_MSC_VER) && _MSC_VER >= 1900  // MSVC 2015
-  _aligned_free(p);
-#else
-  if (p == NULL) return;
-  free(*(reinterpret_cast<uint8_t **>(p) - 1));
-#endif  // defined(_MSC_VER) && _MSC_VER >= 1900 // MSVC 2015
-}
-
-/// @brief SIMD-safe memory allocator, for use with STL types like std::vector.
-///
-/// For example:
-/// <blockquote><code><pre>
-/// std::vector<vec4, mathfu::simd_allocator<vec4>> myvector;
-/// </pre></code></blockquote>
-///
-/// @see MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE
-/// @tparam T type allocated by this object.
-template <typename T>
-class simd_allocator : public std::allocator<T> {
- public:
-  /// Size type.
-  typedef size_t size_type;
-  /// Pointer of type T.
-  typedef T *pointer;
-  /// Const pointer of type T.
-  typedef const T *const_pointer;
-
-  /// Constructs a simd_allocator.
-  simd_allocator() throw() : std::allocator<T>() {}
-  /// @brief Constructs and copies a simd_allocator.
-  ///
-  /// @param a Allocator to copy.
-  simd_allocator(const simd_allocator &a) throw() : std::allocator<T>(a) {}
-  /// @brief Constructs and copies a simd_allocator.
-  ///
-  /// @param a Allocator to copy.
-  /// @tparam U type of the object allocated by the allocator to copy.
-  template <class U>
-  simd_allocator(const simd_allocator<U> &a) throw() : std::allocator<T>(a) {}
-  /// @brief Destructs a simd_allocator.
-  ~simd_allocator() throw() {}
-
-  /// @brief Obtains an allocator of a different type.
-  ///
-  /// @tparam  _Tp1 type of the new allocator.
-  template <typename _Tp1>
-  struct rebind {
-    /// @brief Allocator of type _Tp1.
-    typedef simd_allocator<_Tp1> other;
-  };
-
-  /// @brief Allocate memory for object T.
-  ///
-  /// @param n Number of types to allocate.
-  /// @return Pointer to the newly allocated memory.
-  pointer allocate(size_type n) {
-    return reinterpret_cast<pointer>(AllocateAligned(n * sizeof(T)));
-  }
-
-  /// Deallocate memory referenced by pointer p.
-  ///
-  /// @param p Pointer to memory to deallocate.
-  void deallocate(pointer p, size_type) { FreeAligned(p); }
-};
-
-#if defined(_MSC_VER)
-#if _MSC_VER <= 1800  // MSVC 2013
-#if !defined(noexcept)
-#define noexcept
-#endif  // !defined(noexcept)
-#endif  // _MSC_VER <= 1800
-#endif  //  defined(_MSC_VER)
-
-/// @def MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE
-/// @brief Macro which overrides the default new and delete allocators.
-///
-/// To globally override new and delete, simply add the line:
-/// <blockquote><code><pre>
-/// MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE
-/// </pre></code></blockquote>
-/// to the end of your main .cpp file.
-#define MATHFU_DEFINE_GLOBAL_SIMD_AWARE_NEW_DELETE                           \
-  void *operator new(std::size_t n) { return mathfu::AllocateAligned(n); }   \
-  void *operator new[](std::size_t n) { return mathfu::AllocateAligned(n); } \
-  void operator delete(void *p) noexcept { mathfu::FreeAligned(p); }         \
-  void operator delete[](void *p) noexcept { mathfu::FreeAligned(p); }
-
-/// @def MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-/// @brief Macro which defines the new and delete for MathFu classes.
-#define MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE                       \
-  static void *operator new(std::size_t n) {                            \
-    return mathfu::AllocateAligned(n);                                  \
-  }                                                                     \
-  static void *operator new[](std::size_t n) {                          \
-    return mathfu::AllocateAligned(n);                                  \
-  }                                                                     \
-  static void *operator new(std::size_t /*n*/, void *p) { return p; }   \
-  static void *operator new[](std::size_t /*n*/, void *p) { return p; } \
-  static void operator delete(void *p) { mathfu::FreeAligned(p); }      \
-  static void operator delete[](void *p) { mathfu::FreeAligned(p); }    \
-  static void operator delete(void * /*p*/, void * /*place*/) {}        \
-  static void operator delete[](void * /*p*/, void * /*place*/) {}
-
-/// @}
-
-}  // namespace mathfu
-
-#endif  // MATHFU_UTILITIES_H_
diff --git a/third_party/mathfu-1.1.0/include/mathfu/vector.h b/third_party/mathfu-1.1.0/include/mathfu/vector.h
deleted file mode 100644
index 4d1625e..0000000
--- a/third_party/mathfu-1.1.0/include/mathfu/vector.h
+++ /dev/null
@@ -1,1007 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_VECTOR_H_
-#define MATHFU_VECTOR_H_
-
-#include "mathfu/utilities.h"
-
-#include <math.h>
-
-/// @file mathfu/vector.h Vector
-/// @brief Vector class and functions.
-/// @addtogroup mathfu_vector
-
-// Disable spurious warnings generated by MATHFU_VECTOR_OPERATION().
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable : 4127)  // conditional expression is constant
-#if _MSC_VER >= 1900             // MSVC 2015
-#pragma warning(disable : 4456)  // allow shadowing in unrolled loops
-#endif                           // _MSC_VER >= 1900
-#elif defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warray-bounds"
-#endif
-
-/// @cond MATHFU_INTERNAL
-#define MATHFU_VECTOR_OPERATION(OP) MATHFU_UNROLLED_LOOP(i, d, OP)
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-#define MATHFU_VECTOR_OPERATOR(OP)           \
-  {                                          \
-    Vector<T, d> result;                     \
-    MATHFU_VECTOR_OPERATION(result[i] = OP); \
-    return result;                           \
-  }
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-#define MATHFU_VECTOR_SELF_OPERATOR(OP) \
-  {                                     \
-    MATHFU_VECTOR_OPERATION(OP);        \
-    return *this;                       \
-  }
-/// @endcond
-
-namespace mathfu {
-
-template <class T, int d>
-class Vector;
-
-/// @cond MATHFU_INTERNAL
-template <class T, int d>
-static inline T DotProductHelper(const Vector<T, d>& v1,
-                                 const Vector<T, d>& v2);
-template <class T>
-static inline T DotProductHelper(const Vector<T, 2>& v1,
-                                 const Vector<T, 2>& v2);
-template <class T>
-static inline T DotProductHelper(const Vector<T, 3>& v1,
-                                 const Vector<T, 3>& v2);
-template <class T>
-static inline T DotProductHelper(const Vector<T, 4>& v1,
-                                 const Vector<T, 4>& v2);
-
-template <typename T, int d, typename CompatibleT>
-static inline Vector<T, d> FromTypeHelper(const CompatibleT& compatible);
-
-template <typename T, int d, typename CompatibleT>
-static inline CompatibleT ToTypeHelper(const Vector<T, d>& v);
-/// @endcond
-
-/// @addtogroup mathfu_vector
-/// @{
-
-/// @class VectorPacked "mathfu/vector.h"
-/// @brief Packed N-dimensional vector.
-///
-/// Some Vector classes are padded so that it's possible to use the data
-/// structures with SIMD instructions.  This structure can be used in
-/// conjunction with unpacked Vector classes to pack data
-/// into flat arrays suitable for sending to a GPU (e.g vertex buffers).
-///
-/// <p>
-/// For example, to pack (store) an unpacked to packed vector:<br>
-/// <blockquote><code><pre>
-/// VectorPacked<float, 3> packed;
-/// Vector<float, 3> vector(3, 2, 1);
-/// vector.Pack(&packed);
-/// </pre></code></blockquote>
-/// or<br>
-/// <blockquote><code><pre>
-/// Vector<float, 3> vector(3, 2, 1);
-/// VectorPacked<float, 3> packed = vector;
-/// </pre></code></blockquote>
-/// </p>
-///
-/// <p>
-/// To initialize a vector from a packed vector:<br>
-/// <blockquote><code><pre>
-/// VectorPacked<float, 3> packed = { 3, 2, 1 };
-/// Vector<float, 3> vector(packed);
-/// </pre></code></blockquote>
-///
-/// @tparam T type of VectorPacked elements.
-/// @tparam d dimensions (number of elements) in the VectorPacked structure.
-template <class T, int d>
-struct VectorPacked {
-  /// Create an uninitialized VectorPacked.
-  VectorPacked() {}
-
-  /// Create a VectorPacked from a Vector.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to create the VectorPacked from.
-  explicit VectorPacked(const Vector<T, d>& vector) { vector.Pack(this); }
-
-  /// Copy a Vector to a VectorPacked.
-  ///
-  /// Both VectorPacked and Vector must have the same number of dimensions.
-  /// @param vector Vector to copy to the VectorPacked.
-  /// @returns A reference to this VectorPacked.
-  VectorPacked& operator=(const Vector<T, d>& vector) {
-    vector.Pack(this);
-    return *this;
-  }
-
-  /// Elements of the packed vector one per dimension.
-  T data[d];
-};
-/// @}
-
-/// @addtogroup mathfu_vector
-/// @{
-/// @class Vector "mathfu/vector.h"
-/// @brief Vector of d elements with type T
-///
-/// Vector stores <b>d</b> elements of type <b>T</b> and provides a set
-/// functions to perform operations on the set of elements.
-///
-/// @tparam T type of Vector elements.
-/// @tparam d dimensions (number of elements) in the Vector structure.
-template <class T, int d>
-class Vector {
- public:
-  /// @brief Element type to enable reference by other classes.
-  typedef T Scalar;
-
-  /// @brief Create an uninitialized Vector.
-  inline Vector() {}
-
-  /// @brief Create a vector from another vector copying each element.
-  ///
-  /// @param v Vector that the data will be copied from.
-  inline Vector(const Vector<T, d>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = v.data_[i]);
-  }
-
-  /// @brief Create a vector from another vector of a different type.
-  ///
-  /// This copies each element of a Vector which makes it possible to between
-  /// vectors of different types, for example
-  /// <code>float/double/int</code> vectors.
-  /// @param v Vector that the data will be copied from.
-  /// @tparam U type of Vector elements to copy.
-  template <typename U>
-  explicit inline Vector(const Vector<U, d>& v) {
-    MATHFU_VECTOR_OPERATION(data_[i] = static_cast<T>(v[i]));
-  }
-
-  /// @brief Create a vector from a single float.
-  ///
-  /// Each elements is set to be equal to the value given.
-  /// @param s Scalar value that the vector will be initialized to.
-  explicit inline Vector(const T& s) { MATHFU_VECTOR_OPERATION(data_[i] = s); }
-
-  /// @brief Create a vector form the first d elements of an array.
-  ///
-  /// @param a Array of values that the vector will be iniitlized to.
-  explicit inline Vector(const T* a) {
-    MATHFU_VECTOR_OPERATION(data_[i] = a[i]);
-  }
-
-  /// @brief Create a vector from two values.
-  ///
-  /// @note This method only works when the vector is of size two.
-  ///
-  /// @param s1 Scalar value for the first element of the vector.
-  /// @param s2 Scalar value for the second element of the vector.
-  inline Vector(const T& s1, const T& s2) {
-    MATHFU_STATIC_ASSERT(d == 2);
-    data_[0] = s1;
-    data_[1] = s2;
-  }
-
-  /// @brief Create a vector from three values.
-  ///
-  /// @note This method only works when the vector is of size three.
-  ///
-  /// @param s1 Scalar value for the first element of the vector.
-  /// @param s2 Scalar value for the second element of the vector.
-  /// @param s3 Scalar value for the third element of the vector.
-  inline Vector(const T& s1, const T& s2, const T& s3) {
-    MATHFU_STATIC_ASSERT(d == 3);
-    data_[0] = s1;
-    data_[1] = s2;
-    data_[2] = s3;
-  }
-
-  /// @brief Create a vector from a 2 component vector and a third value.
-  ///
-  /// @note This method only works when the vector is of size three.
-  ///
-  /// @param v12 Vector containing the first 2 values.
-  /// @param s3 Scalar value for the third element of the vector.
-  inline Vector(const Vector<T, 2>& v12, const T& s3) {
-    MATHFU_STATIC_ASSERT(d == 3);
-    data_[0] = v12[0];
-    data_[1] = v12[1];
-    data_[2] = s3;
-  }
-
-  /// @brief Create a vector from four values.
-  ///
-  /// @note This method only works when the vector is of size four.
-  ///
-  /// @param s1 Scalar value for the first element of the vector.
-  /// @param s2 Scalar value for the second element of the vector.
-  /// @param s3 Scalar value for the third element of the vector.
-  /// @param s4 Scalar value for the forth element of the vector.
-  inline Vector(const T& s1, const T& s2, const T& s3, const T& s4) {
-    MATHFU_STATIC_ASSERT(d == 4);
-    data_[0] = s1;
-    data_[1] = s2;
-    data_[2] = s3;
-    data_[3] = s4;
-  }
-
-  /// @brief Create a 4-dimensional vector from a Vector<T, 3>.
-  ///
-  /// The last element is initialized to the specified value.
-  /// @note This method only works with 4 element vectors.
-  ///
-  /// @param vector3 Vector used to initialize the first 3 elements.
-  /// @param value Value used to set the last element of the vector.
-  inline Vector(const Vector<T, 3>& vector3, const T& value) {
-    MATHFU_STATIC_ASSERT(d == 4);
-    data_[0] = vector3[0];
-    data_[1] = vector3[1];
-    data_[2] = vector3[2];
-    data_[3] = value;
-  }
-
-  /// @brief Create a vector from two 2 component vectors.
-  ///
-  /// @note This method only works when the vector is of size four.
-  ///
-  /// @param v12 Vector containing the first 2 values.
-  /// @param v34 Vector containing the last 2 values.
-  inline Vector(const Vector<T, 2>& v12, const Vector<T, 2>& v34) {
-    MATHFU_STATIC_ASSERT(d == 4);
-    data_[0] = v12[0];
-    data_[1] = v12[1];
-    data_[2] = v34[0];
-    data_[3] = v34[1];
-  }
-
-  /// @brief Create a vector from packed vector (VectorPacked).
-  ///
-  /// @param vector Packed vector used to initialize an unpacked.
-  explicit inline Vector(const VectorPacked<T, d>& vector) {
-    MATHFU_VECTOR_OPERATION(data_[i] = vector.data[i]);
-  }
-
-  /// @brief Access an element of the vector.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A reference to the accessed data that can be modified by the
-  /// caller.
-  inline T& operator()(const int i) { return data_[i]; }
-
-  /// @brief Access an element of the vector.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A reference to the accessed data.
-  inline const T& operator()(const int i) const { return data_[i]; }
-
-  /// @brief Access an element of the vector.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A reference to the accessed data that can be modified by the
-  /// caller.
-  inline T& operator[](const int i) { return data_[i]; }
-
-  /// @brief Access an element of the vector.
-  ///
-  /// @param i Index of the element to access.
-  /// @return A const reference to the accessed.
-  inline const T& operator[](const int i) const { return data_[i]; }
-
-  /// @brief GLSL style 3 element accessor.
-  ///
-  /// This only works with vectors that contain more than 3 elements.
-  /// @returns A 3-dimensional Vector containing the first 3 elements of
-  // this Vector.
-  inline Vector<T, 3> xyz() {
-    MATHFU_STATIC_ASSERT(d > 3);
-    return Vector<T, 3>(data_[0], data_[1], data_[2]);
-  }
-
-  /// @brief GLSL style 3 element accessor.
-  ///
-  /// This only works with vectors that contain more than 3 elements.
-  /// @returns A 3-dimensional Vector containing the first 3 elements of
-  // this Vector.
-  inline const Vector<T, 3> xyz() const {
-    MATHFU_STATIC_ASSERT(d > 3);
-    return Vector<T, 3>(data_[0], data_[1], data_[2]);
-  }
-
-  /// @brief GLSL style 2 element accessor.
-  ///
-  /// This only works with vectors that contain more than 2 elements.
-  /// @returns A 2-dimensional Vector with the first 2 elements of this Vector.
-  inline Vector<T, 2> xy() {
-    MATHFU_STATIC_ASSERT(d > 2);
-    return Vector<T, 2>(data_[0], data_[1]);
-  }
-
-  /// @brief GLSL style 2 element accessor.
-  ///
-  /// This only works with vectors that contain more than 2 elements.
-  /// @returns A 2-dimensional Vector with the first 2 elements of this Vector.
-  inline const Vector<T, 2> xy() const {
-    MATHFU_STATIC_ASSERT(d > 2);
-    return Vector<T, 2>(data_[0], data_[1]);
-  }
-
-  /// @brief GLSL style 2 element accessor.
-  ///
-  /// This only works with vectors that contain 4 elements.
-  /// @returns A 2-dimensional Vector with the last 2 elements of this Vector.
-  inline Vector<T, 2> zw() {
-    MATHFU_STATIC_ASSERT(d == 4);
-    return Vector<T, 2>(data_[2], data_[3]);
-  }
-
-  /// @brief GLSL style 2 element accessor.
-  ///
-  /// This only works with vectors that contain 4 elements.
-  /// @returns A 2-dimensional Vector with the last 2 elements of this Vector.
-  inline const Vector<T, 2> zw() const {
-    MATHFU_STATIC_ASSERT(d == 4);
-    return Vector<T, 2>(data_[2], data_[3]);
-  }
-
-  /// @brief Pack a Vector to a packed "d" element vector structure.
-  ///
-  /// @param vector Packed "d" element vector to write to.
-  inline void Pack(VectorPacked<T, d>* const vector) const {
-    MATHFU_VECTOR_OPERATION(vector->data[i] = data_[i]);
-  }
-
-  /// @brief Calculate the squared length of this vector.
-  ///
-  /// @return The length of this vector squared.
-  inline T LengthSquared() const { return LengthSquaredHelper(*this); }
-
-  /// @brief Calculate the length of this vector.
-  ///
-  /// @return The length of this vector.
-  inline T Length() const { return LengthHelper(*this); }
-
-  /// @brief Normalize this vector in-place.
-  ///
-  /// @return The length of this vector.
-  inline T Normalize() { return NormalizeHelper(*this); }
-
-  /// @brief Calculate the normalized version of this vector.
-  ///
-  /// @return The normalized vector.
-  inline Vector<T, d> Normalized() const { return NormalizedHelper(*this); }
-
-  /// @brief Load from any type that is some formulation of a length d array of
-  ///        type T.
-  ///
-  /// Essentially this is just a type cast and a load, but it happens safely
-  /// so that we avoid aliasing bugs.
-  ///
-  /// @return `compatible` cast to `Vector<T,d>` and dereferenced.
-  template <typename CompatibleT>
-  static inline Vector<T, d> FromType(const CompatibleT& compatible) {
-    return FromTypeHelper<T, d, CompatibleT>(compatible);
-  }
-
-  /// @brief Load into any type that is some formulation of a length d array of
-  ///        type T.
-  ///
-  /// Essentially this is just a type cast and a load, but it happens safely
-  /// so that we avoid aliasing bugs.
-  ///
-  /// @return `v` cast to `CompatibleT` and dereferenced.
-  template <typename CompatibleT>
-  static inline CompatibleT ToType(const Vector<T, d>& v) {
-    return ToTypeHelper<T, d, CompatibleT>(v);
-  }
-
-  /// @brief Calculate the dot product of two vectors.
-  ///
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @return The dot product of v1 and v2.
-  static inline T DotProduct(const Vector<T, d>& v1, const Vector<T, d>& v2) {
-    return DotProductHelper(v1, v2);
-  }
-
-  /// @brief Calculate the hadamard or componentwise product of two vectors.
-  ///
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @return The hadamard product of v1 and v2.
-  static inline Vector<T, d> HadamardProduct(const Vector<T, d>& v1,
-                                             const Vector<T, d>& v2) {
-    return HadamardProductHelper(v1, v2);
-  }
-
-  /// @brief Calculate the cross product of two vectors.
-  ///
-  /// Note that this function is only defined for 3-dimensional Vectors.
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @return The cross product of v1 and v2.
-  static inline Vector<T, 3> CrossProduct(const Vector<T, 3>& v1,
-                                          const Vector<T, 3>& v2) {
-    return CrossProductHelper(v1, v2);
-  }
-
-  /// @brief Linearly interpolate two vectors.
-  ///
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @param percent Percentage from v1 to v2 in range 0.0...1.0.
-  /// @return The hadamard product of v1 and v2.
-  static inline Vector<T, d> Lerp(const Vector<T, d>& v1,
-                                  const Vector<T, d>& v2, const T percent) {
-    return LerpHelper(v1, v2, percent);
-  }
-
-  /// @brief Generates a random vector.
-  ///
-  /// The range of each component is bounded by min and max.
-  /// @param min Minimum value of the vector.
-  /// @param max Maximum value of the vector.
-  static inline Vector<T, d> RandomInRange(const Vector<T, d>& min,
-                                           const Vector<T, d>& max) {
-    return RandomInRangeHelper(min, max);
-  }
-
-  /// @brief Compare each component and returns max values.
-  ///
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @return Max value of v1 and v2.
-  static inline Vector<T, d> Max(const Vector<T, d>& v1,
-                                 const Vector<T, d>& v2) {
-    return MaxHelper(v1, v2);
-  }
-
-  /// @brief Compare each component and returns min values.
-  ///
-  /// @param v1 First vector.
-  /// @param v2 Second vector.
-  /// @return Min value of v1 and v2.
-  static inline Vector<T, d> Min(const Vector<T, d>& v1,
-                                 const Vector<T, d>& v2) {
-    return MinHelper(v1, v2);
-  }
-
-  MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE
-
-  /// Elements of the vector.
-  T data_[d];
-};
-/// @}
-
-/// @addtogroup mathfu_vector
-/// @{
-
-/// @brief Compare 2 Vectors of the same size for equality.
-///
-/// @note: The likelyhood of two float values being the same is very small.
-/// Instead consider comparing the difference between two float vectors using
-/// LengthSquared() with an epsilon value.
-/// For example, v1.LengthSquared(v2) < epsilon.
-///
-/// @return true if the 2 vectors contains the same value, false otherwise.
-template <class T, int d>
-inline bool operator==(const Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  for (int i = 0; i < d; ++i) {
-    if (lhs[i] != rhs[i]) return false;
-  }
-  return true;
-}
-
-/// @brief Compare 2 Vectors of the same size for inequality.
-///
-/// @return true if the elements of two vectors differ, false otherwise.
-template <class T, int d>
-inline bool operator!=(const Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  return !(lhs == rhs);
-}
-
-/// @brief Negate all elements of the Vector.
-///
-/// @return A new Vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator-(const Vector<T, d>& v) {
-  MATHFU_VECTOR_OPERATOR(-v.data_[i]);
-}
-
-/// @brief Multiply a Vector by a scalar.
-///
-/// Multiplies each component of the specified Vector with a scalar.
-///
-/// @param s scalar to multiply.
-/// @param v Vector to multiply.
-/// @return Vector containing the result.
-/// @related Vector
-template <class T, int d>
-inline Vector<T, d> operator*(const T& s, const Vector<T, d>& v) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] * s);
-}
-
-/// @brief Divide a Vector by a scalar.
-///
-/// Divides each component of the specified Vector by a scalar.
-///
-/// @param v Vector to be divided.
-/// @param s scalar to divide the vector by.
-/// @return Vector containing the result.
-/// @related Vector
-template <class T, int d>
-inline Vector<T, d> operator/(const Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] / s);
-}
-
-/// @brief Add a scalar to each element of a Vector.
-///
-/// @param s scalar to add to each element of a Vector.
-/// @param v Vector to add the scalar to.
-/// @return Vector containing the result.
-/// @related Vector
-template <class T, int d>
-inline Vector<T, d> operator+(const T& s, const Vector<T, d>& v) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] + s);
-}
-
-/// @brief Subtract a scalar from each element of a Vector.
-///
-/// @param s scalar to subtract from each element of a Vector.
-/// @param v Vector to subtract the scalar from.
-/// @return Vector containing the result.
-/// @related Vector
-template <class T, int d>
-inline Vector<T, d> operator-(const T& s, const Vector<T, d>& v) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] - s);
-}
-
-/// @brief Multiply a vector by another Vector.
-///
-/// In line with GLSL, this performs component-wise multiplication.
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to multiply by.
-/// @return A new Vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator*(const Vector<T, d>& lhs,
-                              const Vector<T, d>& rhs) {
-  return HadamardProductHelper(lhs, rhs);
-}
-
-/// @brief Divide a vector by another Vector.
-///
-/// In line with GLSL, this performs component-wise division.
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to divide by.
-/// @return A new Vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator/(const Vector<T, d>& lhs,
-                              const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATOR(lhs.data_[i] / rhs[i]);
-}
-
-/// @brief Add a vector with another Vector.
-///
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to add by.
-/// @return A new vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator+(const Vector<T, d>& lhs,
-                              const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATOR(lhs.data_[i] + rhs[i]);
-}
-
-/// @brief subtract a vector with another Vector.
-///
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to subtract by.
-/// @return A new vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator-(const Vector<T, d>& lhs,
-                              const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATOR(lhs.data_[i] - rhs[i]);
-}
-
-/// @brief Multiply a vector with a scalar.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to multiply the vector with.
-/// @return A new vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator*(const Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] * s);
-}
-
-/// @brief Add a scalar to all elements of a vector.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to add to the vector.
-/// @return A new vector containing the result.
-template <class T, int d>
-inline Vector<T, d> operator+(const Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] + s);
-}
-
-/// @brief Subtract a scalar from all elements of a vector.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to subtract from a vector.
-/// @return A new vector that stores the result.
-template <class T, int d>
-inline Vector<T, d> operator-(const Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATOR(v.data_[i] - s);
-}
-
-/// @brief Multiply (in-place) a vector with another Vector.
-///
-/// In line with GLSL, this performs component-wise multiplication.
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to multiply by.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator*=(Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATION(lhs.data_[i] *= rhs[i]);
-  return lhs;
-}
-
-/// @brief Divide (in-place) a vector by another Vector.
-///
-/// In line with GLSL, this performs component-wise division.
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to divide by.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator/=(Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATION(lhs.data_[i] /= rhs[i]);
-  return lhs;
-}
-
-/// @brief Add (in-place) a vector with another Vector.
-///
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to add.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator+=(Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATION(lhs.data_[i] += rhs[i]);
-  return lhs;
-}
-
-/// @brief Subtract (in-place) another Vector from a vector.
-///
-/// @param lhs First vector to use as a starting point.
-/// @param rhs Second vector to subtract by.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator-=(Vector<T, d>& lhs, const Vector<T, d>& rhs) {
-  MATHFU_VECTOR_OPERATION(lhs.data_[i] -= rhs[i]);
-  return lhs;
-}
-
-/// @brief Multiply (in-place) each element of a vector with a scalar.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to multiply the vector with.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator*=(Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATION(v.data_[i] *= s);
-  return v;
-}
-
-/// @brief Divide (in-place) each element of a vector by a scalar.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to divide the vector by.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator/=(Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATION(v.data_[i] /= s);
-  return v;
-}
-
-/// @brief Add (in-place) a scalar to each element of a vector.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to add the vector to.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator+=(Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATION(v.data_[i] += s);
-  return v;
-}
-
-/// @brief Subtract (in-place) a scalar from each element of a vector.
-///
-/// @param v Vector for the operation.
-/// @param s A scalar to subtract from the vector.
-/// @return A reference to the input <b>v</b> vector.
-template <class T, int d>
-inline Vector<T, d>& operator-=(Vector<T, d>& v, const T& s) {
-  MATHFU_VECTOR_OPERATION(v.data_[i] -= s);
-  return v;
-}
-
-/// @brief Calculate the hadamard or componentwise product of two vectors.
-///
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @return The hadamard product of v1 and v2.
-template <class T, int d>
-inline Vector<T, d> HadamardProductHelper(const Vector<T, d>& v1,
-                                          const Vector<T, d>& v2) {
-  MATHFU_VECTOR_OPERATOR(v1[i] * v2[i]);
-}
-
-/// @brief Calculate the cross product of two vectors.
-///
-/// Note that this function is only defined for 3-dimensional Vectors.
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @return The cross product of v1 and v2.
-template <class T>
-inline Vector<T, 3> CrossProductHelper(const Vector<T, 3>& v1,
-                                       const Vector<T, 3>& v2) {
-  return Vector<T, 3>(v1[1] * v2[2] - v1[2] * v2[1],
-                      v1[2] * v2[0] - v1[0] * v2[2],
-                      v1[0] * v2[1] - v1[1] * v2[0]);
-}
-
-/// @brief Calculate the squared length of a vector.
-///
-/// @param v Vector to get the squared length of.
-/// @return The length of the vector squared.
-template <class T, int d>
-inline T LengthSquaredHelper(const Vector<T, d>& v) {
-  return DotProductHelper(v, v);
-}
-
-/// @brief Calculate the length of a vector.
-///
-/// @param v Vector to get the squared length of.
-/// @return The length of the vector.
-template <class T, int d>
-inline T LengthHelper(const Vector<T, d>& v) {
-  return sqrt(LengthSquaredHelper(v));
-}
-
-/// @brief Normalize a vector in-place.
-///
-/// @param v Vector to get the squared length of.
-/// @return The length of the vector.
-template <class T, int d>
-inline T NormalizeHelper(Vector<T, d>& v) {
-  const T length = LengthHelper(v);
-  v *= (T(1) / length);
-  return length;
-}
-
-/// @brief Calculate the normalized version of a vector.
-///
-/// @param v Vector to get the squared length of.
-/// @return The normalized vector.
-template <class T, int d>
-inline Vector<T, d> NormalizedHelper(const Vector<T, d>& v) {
-  return v * (T(1) / LengthHelper(v));
-}
-
-/// @brief Linearly interpolate two vectors.
-///
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @param percent Percentage from v1 to v2 in range 0.0...1.0.
-/// @return The hadamard product of v1 and v2.
-template <class T, int d>
-inline Vector<T, d> LerpHelper(const Vector<T, d>& v1, const Vector<T, d>& v2,
-                               const T percent) {
-  const T one_minus_percent = static_cast<T>(1.0) - percent;
-  MATHFU_VECTOR_OPERATOR(one_minus_percent * v1[i] + percent * v2[i]);
-}
-
-/// @brief Generates a random vector.
-///
-/// The range of each component is bounded by min and max.
-/// @param min Minimum value of the vector.
-/// @param max Maximum value of the vector.
-template <class T, int d>
-inline Vector<T, d> RandomInRangeHelper(const Vector<T, d>& min,
-                                        const Vector<T, d>& max) {
-  Vector<T, d> result;
-  MATHFU_VECTOR_OPERATION(result[i] = mathfu::RandomInRange<T>(min[i], max[i]));
-  return result;
-}
-
-/// @brief Compare each component and returns max values.
-///
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @return Max value of v1 and v2.
-template <class T, int d>
-inline Vector<T, d> MaxHelper(const Vector<T, d>& v1, const Vector<T, d>& v2) {
-  Vector<T, d> result;
-  MATHFU_VECTOR_OPERATION(result[i] = std::max(v1[i], v2[i]));
-  return result;
-}
-
-/// @brief Compare each component and returns min values.
-///
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @return Min value of v1 and v2.
-template <class T, int d>
-inline Vector<T, d> MinHelper(const Vector<T, d>& v1, const Vector<T, d>& v2) {
-  Vector<T, d> result;
-  MATHFU_VECTOR_OPERATION(result[i] = std::min(v1[i], v2[i]));
-  return result;
-}
-
-/// @brief Check if val is within [range_start..range_end), denoting a
-/// rectangular area.
-///
-/// @param val 2D vector to be tested.
-/// @param range_start Starting point of the range (inclusive).
-/// @param range_end Ending point of the range (non-inclusive).
-/// @return Bool indicating success.
-///
-/// @tparam T Type of vector components to test.
-template <class T>
-bool InRange2D(const mathfu::Vector<T, 2>& val,
-               const mathfu::Vector<T, 2>& range_start,
-               const mathfu::Vector<T, 2>& range_end) {
-  return InRange(val[0], range_start[0], range_end[0]) &&
-         InRange(val[1], range_start[1], range_end[1]);
-}
-
-/// @cond MATHFU_INTERNAL
-/// @brief Calculate the dot product of two vectors.
-///
-/// @param v1 First vector.
-/// @param v2 Second vector.
-/// @return The dot product of v1 and v2.
-/// @related Vector
-template <class T, int d>
-static inline T DotProductHelper(const Vector<T, d>& v1,
-                                 const Vector<T, d>& v2) {
-  T result = 0;
-  MATHFU_VECTOR_OPERATION(result += v1[i] * v2[i]);
-  return result;
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline T DotProductHelper(const Vector<T, 2>& v1,
-                                 const Vector<T, 2>& v2) {
-  return v1[0] * v2[0] + v1[1] * v2[1];
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline T DotProductHelper(const Vector<T, 3>& v1,
-                                 const Vector<T, 3>& v2) {
-  return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2];
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <class T>
-static inline T DotProductHelper(const Vector<T, 4>& v1,
-                                 const Vector<T, 4>& v2) {
-  return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2] + v1[3] * v2[3];
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <typename T, int d, typename CompatibleT>
-static inline Vector<T, d> FromTypeHelper(const CompatibleT& compatible) {
-// C++11 is required for constructed unions.
-#if __cplusplus >= 201103L
-  // Use a union instead of reinterpret_cast to avoid aliasing bugs.
-  union ConversionUnion {
-    ConversionUnion() {}  // C++11.
-    CompatibleT compatible;
-    VectorPacked<T, d> packed;
-  } u;
-  static_assert(sizeof(u.compatible) == d * sizeof(T),
-                "Conversion size mismatch.");
-
-  // The read of `compatible` and write to `u.compatible` gets optimized away,
-  // and this becomes essentially a safe reinterpret_cast.
-  u.compatible = compatible;
-
-  // Call the packed vector constructor with the `compatible` data.
-  return Vector<T, d>(u.packed);
-#else
-  // Use the less-desirable memcpy technique if C++11 is not available.
-  // Most compilers understand memcpy deep enough to avoid replace the function
-  // call with a series of load/stores, which should then get optimized away,
-  // however in the worst case the optimize away may not happen.
-  // Note: Memcpy avoids aliasing bugs because it operates via unsigned char*,
-  // which is allowed to alias any type.
-  // See:
-  // http://stackoverflow.com/questions/15745030/type-punning-with-void-without-breaking-the-strict-aliasing-rule-in-c99
-  Vector<T, d> v;
-  assert(sizeof(compatible) == d * sizeof(T));
-  memcpy(&v, &compatible, sizeof(compatible));
-  return v;
-#endif  // __cplusplus >= 201103L
-}
-/// @endcond
-
-/// @cond MATHFU_INTERNAL
-template <typename T, int d, typename CompatibleT>
-static inline CompatibleT ToTypeHelper(const Vector<T, d>& v) {
-// See FromTypeHelper() for comments.
-#if __cplusplus >= 201103L
-  union ConversionUnion {
-    ConversionUnion() {}
-    CompatibleT compatible;
-    VectorPacked<T, d> packed;
-  } u;
-  static_assert(sizeof(u.compatible) == d * sizeof(T), "Conversion size mismatch.");
-  v.Pack(&u.packed);
-  return u.compatible;
-#else
-  CompatibleT compatible;
-  assert(sizeof(compatible) == d * sizeof(T));
-  memcpy(&compatible, &v, sizeof(compatible));
-  return compatible;
-#endif  // __cplusplus >= 201103L
-}
-/// @endcond
-
-/// @}
-
-/// @addtogroup mathfu_utilities
-/// @{
-
-/// @brief Specialized version of RoundUpToPowerOf2 for vector.
-template <typename T, int d>
-inline Vector<T, d> RoundUpToPowerOf2(const Vector<T, d>& v) {
-  Vector<T, d> ret;
-  MATHFU_VECTOR_OPERATION(ret(i) = RoundUpToPowerOf2(v(i)));
-  return ret;
-}
-/// @}
-
-}  // namespace mathfu
-
-// Include the specializations to avoid template errors.
-// For example, if you include vector.h, use Vector<float, 3>, and then
-// include vector_3.h, you the compiler will generate an error since you're
-// specializing something that has already been instantiated.
-#include "mathfu/internal/vector_2_simd.h"
-#include "mathfu/internal/vector_3_simd.h"
-#include "mathfu/internal/vector_4_simd.h"
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#elif defined(__clang__)
-#pragma clang diagnostic pop
-#endif
-
-#endif  // MATHFU_VECTOR_H_
diff --git a/third_party/mathfu-1.1.0/jni/Android.mk b/third_party/mathfu-1.1.0/jni/Android.mk
deleted file mode 100644
index c66faf4..0000000
--- a/third_party/mathfu-1.1.0/jni/Android.mk
+++ /dev/null
@@ -1,110 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-LOCAL_PATH:=$(call my-dir)/..
-
-MATHFU_DIR?=$(LOCAL_PATH)
-include $(LOCAL_PATH)/android_config.mk
-
-# Conditionally include libstlport (so include path is added to CFLAGS) if
-# it's not being built using the NDK build process.
-define add-stlport-includes
-$(eval \
-  ifeq ($(NDK_PROJECT_PATH),)
-  include external/stlport/libstlport.mk
-  endif)
-endef
-
-# mathfu-cflags: disable_simd force_padding debug
-# Expands to the compiler flags for applications or libraries that use MathFu.
-# Where disable_simd specifies whether SIMD code should be disabled,
-# force_padding specifies whether padding should be added to data structures
-# in SIMD mode (-1 = default, 0 = padding off, 1 = padding on).
-#
-# NOTE: armeabi-v7a-hard has been deprecated.  For more information see,
-#  https://android.googlesource.com/platform/ndk/+/master/docs/HardFloatAbi.md
-define mathfu-cflags
-  $(if $(subst 0,,$(strip $(1))),-DMATHFU_COMPILE_WITHOUT_SIMD_SUPPORT,\
-    $(if $(subst -1,,$(strip $(2))),\
-               -DMATHFU_COMPILE_FORCE_PADDING=$(strip $(2)),)) \
-  $(if $(APP_DEBUG),-DDEBUG=1,-DDEBUG=0) \
-  $(if $(filter armeabi-v7a-hard,$(TARGET_ARCH_ABI)),\
-             -mfpu=neon -mhard-float -mfloat-abi=hard) \
-  $(if $(filter x86,$(TARGET_ARCH_ABI)),-msse) \
-  $(if $(filter x86_64,$(TARGET_ARCH_ABI)),-msse4.1)
-endef
-
-
-# Configure common local variables to build mathfu adding $(1) to the end of
-# the build target's name.
-define mathfu-module
-$(eval \
-  LOCAL_MODULE:=libmathfu$(1)
-  LOCAL_MODULE_TAGS:=optional
-  LOCAL_COPY_HEADERS_TO:=mathfu$(1))
-endef
-
-# Configure local variables to build mathfu adding $(1) to the end of the
-# build target's name, disabling SIMD depending upon the value of $(2) (see
-# mathfu-cflags $(1)) and configuring padding (see mathfu-cflags $(2))
-# with $(3).
-define mathfu-build
-$(eval \
-  $$(call mathfu-module,$(1))
-  LOCAL_SRC_FILES:=
-  LOCAL_COPY_HEADERS:=\
-    $(subst $(LOCAL_PATH)/,,$(wildcard $(LOCAL_PATH)/include/mathfu/*.h))
-  LOCAL_CFLAGS:=$$(call mathfu-cflags,$(2),$(3))
-  LOCAL_EXPORT_CFLAGS:=$$(LOCAL_CFLAGS)
-  LOCAL_EXPORT_C_INCLUDES:=\
-	$(LOCAL_PATH)/include \
-	$(DEPENDENCIES_VECTORIAL_DIR)/include
-  LOCAL_EXPORT_LDLIBS:=-lm
-  LOCAL_ARM_MODE:=arm
-  LOCAL_ARM_NEON:=$(if $(filter \
-    armeabi-v7a armeabi-v7a-hard,$(TARGET_ARCH_ABI)),true,)
-  $$(call add-stlport-includes))
-endef
-
-# --- libmathfu ---
-# Target which builds an empty static library so that it's possible for
-# projects using this module to add the appropriate flags and includes to
-# their compile command line.  This builds mathfu using the default build
-# configuration specified in ${mathfu}/android_config.mk
-include $(CLEAR_VARS)
-$(call mathfu-build,,$(MATHFU_DISABLE_SIMD),$(MATHFU_FORCE_PADDING))
-include $(BUILD_STATIC_LIBRARY)
-
-# --- libmathfu_no_simd ---
-# Builds an empty static library (similar to libmathfu).
-# This build configuration has SIMD disabled.
-include $(CLEAR_VARS)
-$(call mathfu-build,_no_simd,1,-1)
-include $(BUILD_STATIC_LIBRARY)
-
-# --- libmathfu_simd ---
-# Builds an empty static library (similar to libmathfu).
-# This build configuration has SIMD enabled and padding enabled.
-include $(CLEAR_VARS)
-$(call mathfu-build,_simd_padding,0,1)
-include $(BUILD_STATIC_LIBRARY)
-
-# --- libmathfu_simd_no_padding ---
-# Builds an empty static library (similar to libmathfu).
-# This build configuration has SIMD enabled and padding disabled.
-include $(CLEAR_VARS)
-$(call mathfu-build,_simd_no_padding,0,0)
-include $(BUILD_STATIC_LIBRARY)
-
-mathfu_cflags:=
diff --git a/third_party/mathfu-1.1.0/jni/Application.mk b/third_party/mathfu-1.1.0/jni/Application.mk
deleted file mode 100644
index 472bcc2..0000000
--- a/third_party/mathfu-1.1.0/jni/Application.mk
+++ /dev/null
@@ -1,21 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-LOCAL_PATH:=$(call my-dir)
-
-APP_PLATFORM:=android-10
-APP_ABI:=armeabi-v7a armeabi x86 x86_64 mips mips64
-APP_STL:=c++_static
-APP_MODULES:=libmathfu
-
diff --git a/third_party/mathfu-1.1.0/jni/find_fplutil.mk b/third_party/mathfu-1.1.0/jni/find_fplutil.mk
deleted file mode 100644
index 928e254..0000000
--- a/third_party/mathfu-1.1.0/jni/find_fplutil.mk
+++ /dev/null
@@ -1,45 +0,0 @@
-# Copyright 2016 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Find the fplutil directory and set it in `FPLUTIL_DIR`.
-#
-# We search some standard locations, such as
-# (1) the variable $(DEPENDENCIES_ROOT), which can be specified
-#     in an environment variable,
-# (2) the "dependencies" directory that gets created when cloning from GitHub,
-# (3) several levels up in the directory tree.
-#
-# Notes
-# -----
-# - fplutil is the project where we keep all our shared code, so the code in
-#   this file (which locates fplutil) can unfortunately not be shared.
-# - Since this file is duplicated in all FPL projects (except fplutil itself),
-#   please copy new versions to all FPL projects whenever you make a change.
-
-FIND_FPLUTIL_DIR:=$(call my-dir)
-
-$(foreach dir,$(wildcard $(DEPENDENCIES_ROOT)) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../dependencies/fplutil) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../../dependencies/fplutil) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../fplutil) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../../fplutil) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../../../fplutil) \
-              $(wildcard $(FIND_FPLUTIL_DIR)/../../../../fplutil),\
-  $(eval FPLUTIL_DIR?=$(dir)))
-
-ifeq ($(FPLUTIL_DIR),)
-  ifndef (FIND_FPLUTIL_OK_IF_NOT_FOUND)
-    $(error "Cannot file fplutil project.")
-  endif
-endif
diff --git a/third_party/mathfu-1.1.0/readme.md b/third_party/mathfu-1.1.0/readme.md
deleted file mode 100644
index 2613569..0000000
--- a/third_party/mathfu-1.1.0/readme.md
+++ /dev/null
@@ -1,58 +0,0 @@
-MathFu Version 1.1.0    {#mathfu_readme}
-====================
-
-MathFu is a C++ math library developed primarily for games focused on
-simplicity and efficiency.
-
-It provides a suite of [vector][], [matrix][] and [quaternion][] classes
-to perform basic [geometry][] suitable for game developers.  This functionality
-can be used to construct geometry for graphics libraries like [OpenGL][] or
-perform calculations for animation or physics systems.
-
-The library is written in portable C++ with [SIMD][] compiler intrinsics and
-has been tested on the following platforms:
-
-   * [Android][]
-   * [Linux][] (x86_64)
-   * [OS X][]
-   * [Windows][]
-
-Go to our [landing page][] to browse our documentation and see some examples.
-
-   * Discuss MathFu with other developers and users on the
-     [MathFu Google Group][].
-   * File issues on the [MathFu Issues Tracker][]
-   * Post your questions to [stackoverflow.com][] with a mention of
-     **mathfu**.
-
-**Important**: MathFu uses submodules to reference other components it depends
-upon so download the source using:
-
-    git clone --recursive https://github.com/google/mathfu.git
-
-To contribute to this project see [CONTRIBUTING][].
-
-For applications on Google Play that integrate this tool, usage is tracked.
-This tracking is done automatically using the embedded version string
-(kMathFuVersionString), and helps us continue to optimize it. Aside from
-consuming a few extra bytes in your application binary, it shouldn't affect
-your application at all. We use this information to let us know if MathFu
-is useful and if we should continue to invest in it. Since this is open
-source, you are free to remove the version string but we would appreciate if
-you would leave it in.
-
-  [Android]: http://www.android.com
-  [Linux]: http://en.m.wikipedia.org/wiki/Linux
-  [MathFu Google Group]: http://groups.google.com/group/mathfulib
-  [MathFu Issues Tracker]: http://github.com/google/mathfu/issues
-  [OS X]: http://www.apple.com/osx/
-  [OpenGL]: http://www.opengl.org/
-  [SIMD]: http://en.wikipedia.org/wiki/SIMD
-  [Windows]: http://windows.microsoft.com/
-  [geometry]: http://en.wikipedia.org/wiki/Geometry
-  [landing page]: http://google.github.io/mathfu
-  [matrix]: http://en.wikipedia.org/wiki/Matrix_(mathematics)
-  [quaternion]: http://en.wikipedia.org/wiki/Quaternion
-  [stackoverflow.com]: http://stackoverflow.com/search?q=mathfu
-  [vector]: http://en.wikipedia.org/wiki/Euclidean_vector
-  [CONTRIBUTING]: http://github.com/google/mathfu/blob/master/CONTRIBUTING
diff --git a/third_party/mathfu-1.1.0/unit_tests/CMakeLists.txt b/third_party/mathfu-1.1.0/unit_tests/CMakeLists.txt
deleted file mode 100644
index 4310f29..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/CMakeLists.txt
+++ /dev/null
@@ -1,79 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-cmake_minimum_required(VERSION 2.8)
-
-set_compiler_flags_for_external_libraries()
-add_subdirectory(${dependencies_gtest_dir} googletest)
-restore_compiler_flags()
-
-set(gtest_incdir ${dependencies_gtest_dir}/include)
-if(EXISTS "${dependencies_gtest_dir}/../../third_party")
-  set(gtest_hack_incdir "${dependencies_gtest_dir}/../..")
-endif()
-set(gtest_libdir ${dependencies_gtest_dir})
-
-# Include helper functions and macros used by Google Test.
-include(${gtest_libdir}/cmake/internal_utils.cmake)
-config_compiler_and_linker()
-string(REPLACE "-W4" "-W3" cxx_default "${cxx_default}")
-string(REPLACE "-Wshadow" "" cxx_default "${cxx_default}")
-string(REPLACE "-Wextra" "" cxx_default "${cxx_default}")
-
-# This is the directory into which the executables are built.
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-
-include_directories(${gtest_incdir}
-                    ${gtest_hack_incdir}
-                    ${CMAKE_CURRENT_LIST_DIR}
-                    ${CMAKE_CURRENT_LIST_DIR}/..)
-
-# Common libraries for tests.
-if(NOT MSVC)
-  find_package(Threads)
-endif()
-set(COMMON_LIBS "gtest;${CMAKE_THREAD_LIBS_INIT}")
-
-# Generate a rule to build a unit test executable ${test_name} with
-# source file ${source}.  For details of additional arguments, see
-# mathfu_configure_flags().
-function(test_executable test_name source)
-  cxx_executable_with_flags(${test_name} "${cxx_default}" "${COMMON_LIBS}"
-    ${source} ${MATHFU_HEADERS})
-  mathfu_configure_flags(${test_name} ${ARGN})
-  mathfu_enable_warnings(${test_name})
-endfunction()
-
-# Generate a rule to build unit test executables.  This only builds
-# ${test_name}_tests if SIMD is disabled (see ${mathfu_enable_simd}) or
-# ${test_name}_tests and ${test_name}_no_simd_tests if SIMD is enabled where
-# the no_simd_tests binary has SIMD disabled.
-function(test_executables test_name source)
-  # Default build options for the target architecture.
-  test_executable(${test_name}_tests ${source})
-  if(mathfu_enable_simd)
-    # NOTE: A build configuration below will deliberately duplicate the
-    # default build configuration, since these configs could result in
-    # different compile time preprocessor code paths.
-    # SIMD enabled and padding enabled.
-    test_executable(${test_name}_simd_padding_tests ${source} TRUE TRUE)
-    # SIMD enabled and padding disabled.
-    test_executable(${test_name}_simd_no_padding_tests ${source} TRUE FALSE)
-    # SIMD disabled.
-    test_executable(${test_name}_no_simd_tests ${source} FALSE)
-  endif()
-endfunction()
-
-test_executables(vector vector_test/vector_test.cpp)
-test_executables(quaternion quaternion_test/quaternion_test.cpp)
-test_executables(matrix matrix_test/matrix_test.cpp)
diff --git a/third_party/mathfu-1.1.0/unit_tests/android_common.mk b/third_party/mathfu-1.1.0/unit_tests/android_common.mk
deleted file mode 100644
index 34cfc8d..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/android_common.mk
+++ /dev/null
@@ -1,52 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(CLEAR_VARS)
-
-# Configure the locations of MathFu's dependencies.
-MATHFU_DIR:=$(LOCAL_PATH)/../..
-MATHFU_DIR_BASENAME:=$(notdir $(abspath $(MATHFU_DIR)))
-TEST_DIR:=$(LOCAL_PATH)
-include $(MATHFU_DIR)/android_config.mk
-
-namespace:=$(if $(NDK_PROJECT_PATH),,_mathfu)
-LOCAL_MODULE:=$(LOCAL_TEST_NAME)${namespace}
-LOCAL_MODULE_TAGS:=optional
-LOCAL_SRC_FILES:=$(notdir $(abspath $(TEST_DIR))).cpp
-LOCAL_C_INCLUDES:=$(MATHFU_DIR)/unit_tests
-LOCAL_LDLIBS:=-llog -landroid
-LOCAL_WHOLE_STATIC_LIBRARIES:=\
-	libfplutil_main \
-	libfplutil_print
-# MATHFU_LIB (by default libmathfu) is used to select the build configuration
-# for the target using mathfu.
-LOCAL_STATIC_LIBRARIES:=\
-	android_native_app_glue \
-	libgtest \
-	$(MATHFU_LIB)
-LOCAL_CFLAGS:=-Wall -Werror
-LOCAL_ARM_MODE:=arm
-include $(BUILD_SHARED_LIBRARY)
-
-$(call import-add-path,$(abspath $(MATHFU_DIR)/..))
-$(call import-add-path,$(abspath $(DEPENDENCIES_FPLUTIL_DIR)))
-$(call import-add-path,$(abspath $(DEPENDENCIES_GTEST_DIR)/..))
-
-$(call import-module,$(MATHFU_DIR_BASENAME)/jni)
-$(call import-module,libfplutil/jni)
-$(call import-module,googletest)
-$(call import-module,android/native_app_glue)
-
-LOCAL_TEST_NAME:=
-MATHFU_DIR:=
-TEST_DIR:=
diff --git a/third_party/mathfu-1.1.0/unit_tests/application_common.mk b/third_party/mathfu-1.1.0/unit_tests/application_common.mk
deleted file mode 100644
index 760c907..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/application_common.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-APP_PLATFORM:=android-10
-APP_ABI:=armeabi-v7a armeabi x86 x86_64 mips mips64
-APP_STL:=c++_static
-
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/AndroidManifest.xml
deleted file mode 100644
index 6f0a3db..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Android.mk
deleted file mode 100644
index efef5f9..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=matrix_test
-MATHFU_LIB:=libmathfu
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Application.mk
deleted file mode 100644
index 7702145..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/res/values/strings.xml
deleted file mode 100644
index 22e57e5..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/default/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/matrix_test.cpp b/third_party/mathfu-1.1.0/unit_tests/matrix_test/matrix_test.cpp
deleted file mode 100644
index 10a13e6..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/matrix_test.cpp
+++ /dev/null
@@ -1,1147 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "mathfu/matrix.h"
-#include "mathfu/matrix_4x4.h"
-#include "mathfu/quaternion.h"
-#include "mathfu/utilities.h"
-#include "mathfu/vector.h"
-
-#include <cmath>
-#include <sstream>
-#include <string>
-
-#include "gtest/gtest.h"
-
-#include "precision.h"
-static const float kUnProjectFloatPrecision = 0.0012f;
-static const double kLookAtDoublePrecision = 1e-8;
-class MatrixTests : public ::testing::Test {
- protected:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-template <class T, int rows, int columns>
-struct MatrixExpectation {
-  const char* description;
-  mathfu::Matrix<T, rows, columns> calculated;
-  mathfu::Matrix<T, rows, columns> expected;
-};
-
-// This will automatically generate tests for each template parameter.
-#define TEST_ALL_F(MY_TEST, FLOAT_PRECISION_VALUE, DOUBLE_PRECISION_VALUE) \
-  TEST_F(MatrixTests, MY_TEST##_float_2) {                                 \
-    MY_TEST##_Test<float, 2>(FLOAT_PRECISION_VALUE);                       \
-  }                                                                        \
-  TEST_F(MatrixTests, MY_TEST##_double_2) {                                \
-    MY_TEST##_Test<double, 2>(DOUBLE_PRECISION_VALUE);                     \
-  }                                                                        \
-  TEST_F(MatrixTests, MY_TEST##_float_3) {                                 \
-    MY_TEST##_Test<float, 3>(FLOAT_PRECISION_VALUE);                       \
-  }                                                                        \
-  TEST_F(MatrixTests, MY_TEST##_double_3) {                                \
-    MY_TEST##_Test<double, 3>(DOUBLE_PRECISION_VALUE);                     \
-  }                                                                        \
-  TEST_F(MatrixTests, MY_TEST##_float_4) {                                 \
-    MY_TEST##_Test<float, 4>(FLOAT_PRECISION_VALUE);                       \
-  }                                                                        \
-  TEST_F(MatrixTests, MY_TEST##_double_4) {                                \
-    MY_TEST##_Test<double, 4>(DOUBLE_PRECISION_VALUE);                     \
-  }
-
-// This will automatically generate tests for each scalar template parameter.
-#define TEST_SCALAR_F(MY_TEST, FLOAT_PRECISION_VALUE, DOUBLE_PRECISION_VALUE) \
-  TEST_F(MatrixTests, MY_TEST##_float) {                                      \
-    MY_TEST##_Test<float>(FLOAT_PRECISION_VALUE);                             \
-  }                                                                           \
-  TEST_F(MatrixTests, MY_TEST##_double) {                                     \
-    MY_TEST##_Test<double>(DOUBLE_PRECISION_VALUE);                           \
-  }
-
-// This will test initialization by passing in values. The template paramter d
-// corresponds to the number of rows and columns.
-template <class T, int d>
-void Initialize_Test(const T& precision) {
-  // This will test initialization of the matrix using a random single value.
-  // The expected result is that all entries equal the given value.
-  mathfu::Matrix<T, d> matrix_splat(static_cast<T>(3.1));
-  for (int i = 0; i < d * d; ++i) {
-    EXPECT_NEAR(3.1, matrix_splat[i], precision);
-  }
-  // This will verify that the value is correct when using the (i, j) form
-  // of indexing.
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(3.1, matrix_splat(i, j), precision);
-    }
-  }
-  // This will test initialization of the matrix using a c style array of
-  // values.
-  T x[d * d];
-  for (int i = 0; i < d * d; ++i) {
-    x[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  mathfu::Matrix<T, d> matrix_arr(x);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(x[i + d * j], matrix_arr(i, j), precision);
-    }
-  }
-  // This will test the copy constructor making sure that the new matrix
-  // equals the old one.
-  mathfu::Matrix<T, d> matrix_copy(matrix_arr);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(x[i + d * j], matrix_copy(i, j), precision);
-    }
-  }
-  // This will verify that the copy was deep and changing the values of the
-  // copied matrix does not effect the original.
-  matrix_copy = matrix_copy - mathfu::Matrix<T, d>(1);
-  EXPECT_NE(matrix_copy(0, 0), matrix_arr(0, 0));
-  // This will test creation of the identity matrix.
-  mathfu::Matrix<T, d> identity(mathfu::Matrix<T, d>::Identity());
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(i == j ? 1 : 0, identity(i, j), precision);
-    }
-  }
-}
-TEST_ALL_F(Initialize, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test initialization by specifying all values explicitly.
-template <class T>
-void InitializePerDimension_Test(const T& precision) {
-  mathfu::Matrix<T, 2> matrix_f2x2(static_cast<T>(4.5), static_cast<T>(3.4),
-                                   static_cast<T>(2.6), static_cast<T>(9.8));
-  EXPECT_NEAR(4.5, matrix_f2x2(0, 0), precision);
-  EXPECT_NEAR(3.4, matrix_f2x2(1, 0), precision);
-  EXPECT_NEAR(2.6, matrix_f2x2(0, 1), precision);
-  EXPECT_NEAR(9.8, matrix_f2x2(1, 1), precision);
-  mathfu::Matrix<T, 3> matrix_f3x3(
-      static_cast<T>(3.7), static_cast<T>(2.4), static_cast<T>(6.4),
-      static_cast<T>(1.1), static_cast<T>(5.2), static_cast<T>(6.4),
-      static_cast<T>(2.7), static_cast<T>(7.4), static_cast<T>(0.1));
-  EXPECT_NEAR(3.7, matrix_f3x3(0, 0), precision);
-  EXPECT_NEAR(2.4, matrix_f3x3(1, 0), precision);
-  EXPECT_NEAR(6.4, matrix_f3x3(2, 0), precision);
-  EXPECT_NEAR(1.1, matrix_f3x3(0, 1), precision);
-  EXPECT_NEAR(5.2, matrix_f3x3(1, 1), precision);
-  EXPECT_NEAR(6.4, matrix_f3x3(2, 1), precision);
-  EXPECT_NEAR(2.7, matrix_f3x3(0, 2), precision);
-  EXPECT_NEAR(7.4, matrix_f3x3(1, 2), precision);
-  EXPECT_NEAR(0.1, matrix_f3x3(2, 2), precision);
-  mathfu::Matrix<T, 4> matrix_f4x4(
-      static_cast<T>(4.1), static_cast<T>(8.4), static_cast<T>(7.2),
-      static_cast<T>(4.8), static_cast<T>(0.9), static_cast<T>(7.8),
-      static_cast<T>(5.6), static_cast<T>(8.7), static_cast<T>(2.3),
-      static_cast<T>(4.2), static_cast<T>(6.1), static_cast<T>(2.7),
-      static_cast<T>(0.1), static_cast<T>(1.4), static_cast<T>(9.4),
-      static_cast<T>(3.6));
-  EXPECT_NEAR(4.1, matrix_f4x4(0, 0), precision);
-  EXPECT_NEAR(8.4, matrix_f4x4(1, 0), precision);
-  EXPECT_NEAR(7.2, matrix_f4x4(2, 0), precision);
-  EXPECT_NEAR(4.8, matrix_f4x4(3, 0), precision);
-  EXPECT_NEAR(0.9, matrix_f4x4(0, 1), precision);
-  EXPECT_NEAR(7.8, matrix_f4x4(1, 1), precision);
-  EXPECT_NEAR(5.6, matrix_f4x4(2, 1), precision);
-  EXPECT_NEAR(8.7, matrix_f4x4(3, 1), precision);
-  EXPECT_NEAR(2.3, matrix_f4x4(0, 2), precision);
-  EXPECT_NEAR(4.2, matrix_f4x4(1, 2), precision);
-  EXPECT_NEAR(6.1, matrix_f4x4(2, 2), precision);
-  EXPECT_NEAR(2.7, matrix_f4x4(3, 2), precision);
-  EXPECT_NEAR(0.1, matrix_f4x4(0, 3), precision);
-  EXPECT_NEAR(1.4, matrix_f4x4(1, 3), precision);
-  EXPECT_NEAR(9.4, matrix_f4x4(2, 3), precision);
-  EXPECT_NEAR(3.6, matrix_f4x4(3, 3), precision);
-}
-TEST_SCALAR_F(InitializePerDimension, FLOAT_PRECISION, DOUBLE_PRECISION)
-
-// Test initialization of a matrix from an array of packed vectors.
-template <class T, int d>
-void InitializePacked_Test(const T& precision) {
-  (void)precision;
-  mathfu::VectorPacked<T, d> packed[d];
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      packed[i].data[j] = static_cast<T>((i * d) + j);
-    }
-  }
-  mathfu::Matrix<T, d> matrix(packed);
-  for (int i = 0; i < d * d; ++i) {
-    EXPECT_NEAR(packed[i / d].data[i % d], matrix[i], static_cast<T>(0))
-        << "Element " << i;
-  }
-}
-TEST_ALL_F(InitializePacked, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test serialization to a packed array of vectors.
-template <class T, int d>
-void PackedSerialization_Test(const T& precision) {
-  (void)precision;
-  mathfu::Matrix<T, d> matrix;
-  for (int i = 0; i < d * d; ++i) {
-    matrix[i] = static_cast<T>(i);
-  }
-  mathfu::VectorPacked<T, d> packed[d];
-  matrix.Pack(packed);
-  for (int i = 0; i < d * d; ++i) {
-    EXPECT_NEAR(matrix[i], packed[i / d].data[i % d], static_cast<T>(0))
-        << "Element " << i;
-  }
-}
-TEST_ALL_F(PackedSerialization, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test the Addition and Subtraction of matrices. The template
-// parameter d corresponds to the number of rows and columns.
-template <class T, int d>
-void AddSub_Test(const T& precision) {
-  T x1[d * d], x2[d * d];
-  for (int i = 0; i < d * d; ++i) {
-    x1[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  for (int i = 0; i < d * d; ++i) {
-    x2[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  mathfu::Matrix<T, d> matrix1(x1), matrix2(x2);
-  // This will test the negation of a matrix and verify that each element
-  // is negated.
-  mathfu::Matrix<T, d> neg_mat1(-matrix1);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(-x1[i + d * j], neg_mat1(i, j), precision);
-    }
-  }
-  // This will test the addition of two matrices and verify that each element
-  // equal to the sum of the input values.
-  mathfu::Matrix<T, d> matrix_add(matrix1 + matrix2);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(x1[i + d * j] + x2[i + d * j], matrix_add(i, j), precision);
-    }
-  }
-  // This will test the subtraction of two matrices and verify that each
-  // element equal to the difference of the input values.
-  mathfu::Matrix<T, d> matrix_sub(matrix1 - matrix2);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(x1[i + d * j] - x2[i + d * j], matrix_sub(i, j), precision);
-    }
-  }
-}
-TEST_ALL_F(AddSub, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test the multiplication of matrices by matrices, vectors,
-// and scalars. The template parameter d corresponds to the number of rows and
-// columns.
-template <class T, int d>
-void Mult_Test(const T& precision) {
-  T x1[d * d], x2[d * d];
-  for (int i = 0; i < d * d; ++i) x1[i] = rand() / static_cast<T>(RAND_MAX);
-  for (int i = 0; i < d * d; ++i) x2[i] = rand() / static_cast<T>(RAND_MAX);
-  mathfu::Matrix<T, d> matrix1(x1), matrix2(x2);
-  // This will test scalar matrix multiplication and verify that each element
-  // is equal to multiplication by the scalar.
-  mathfu::Matrix<T, d> matrix_mults(matrix1 * static_cast<T>(1.1));
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(x1[i + d * j] * 1.1, matrix_mults(i, j), precision);
-    }
-  }
-  T v[d];
-  for (int i = 0; i < d; ++i) v[i] = rand() / static_cast<T>(RAND_MAX);
-  mathfu::Vector<T, d> vector(v);
-  // This will test matrix vector multiplication and verify that the resulting
-  // vector is mathematically correct.
-  mathfu::Vector<T, d> vector_multv(matrix1 * vector);
-  for (int i = 0; i < d; ++i) {
-    T v1[d];
-    for (int k = 0; k < d; ++k) v1[k] = matrix1(i, k);
-    mathfu::Vector<T, d> vec1(v1);
-    T dot = mathfu::Vector<T, d>::DotProduct(vec1, vector);
-    EXPECT_NEAR(dot, vector_multv[i], precision);
-  }
-  // This will test matrix multiplication and verify that the resulting
-  // matrix is mathematically correct.
-  mathfu::Matrix<T, d> matrix_multm(matrix1 * matrix2);
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      T v1[d], v2[d];
-      for (int k = 0; k < d; ++k) v1[k] = matrix1(i, k);
-      for (int k = 0; k < d; ++k) v2[k] = matrix2(k, j);
-      mathfu::Vector<T, d> vec1(v1), vec2(v2);
-      T dot = mathfu::Vector<T, d>::DotProduct(vec1, vec2);
-      EXPECT_NEAR(dot, matrix_multm(i, j), precision);
-    }
-  }
-}
-TEST_ALL_F(Mult, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test the outer product of two vectors. The template parameter d
-// corresponds to the number of rows and columns.
-template <class T, int d>
-void OuterProduct_Test(const T& precision) {
-  T x1[d], x2[d];
-  for (int i = 0; i < d; ++i) x1[i] = rand() / static_cast<T>(RAND_MAX);
-  for (int i = 0; i < d; ++i) x2[i] = rand() / static_cast<T>(RAND_MAX);
-  mathfu::Vector<T, d> vector1(x1), vector2(x2);
-  mathfu::Matrix<T, d> matrix(
-      mathfu::Matrix<T, d>::OuterProduct(vector1, vector2));
-  // This will verify that each element is mathematically correct.
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(vector1[i] * vector2[j], matrix(i, j), precision);
-    }
-  }
-}
-TEST_ALL_F(OuterProduct, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Print the specified matrix to output_string in the form.
-template <class T, int rows, int columns>
-std::string MatrixToString(const mathfu::Matrix<T, rows, columns>& matrix) {
-  std::stringstream ss;
-  ss.flags(std::ios::fixed);
-  ss.precision(4);
-  for (int col = 0; col < columns; ++col) {
-    for (int row = 0; row < rows; ++row) {
-      ss << (T)matrix(col, row) << " ";
-    }
-    ss << "\n";
-  }
-  return ss.str();
-}
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4127)  // conditional expression is constant
-#endif                           // _MSC_VER
-
-// Test the inverse of a set of noninvertible matrices.
-template <class T, int d>
-void InverseNonInvertible_Test(const T& precision) {
-  (void)precision;
-  T m[d * d];
-  const size_t matrix_size = sizeof(m) / sizeof(m[0]);
-  static const T kDeterminantThreshold =
-      mathfu::Constants<T>::GetDeterminantThreshold();
-  static const T kDeterminantThresholdInverse = 1 / kDeterminantThreshold;
-  static const T kDeterminantThresholdSmall =
-      kDeterminantThresholdInverse / 100;
-  static const T kDeterminantThresholdInverseLarge =
-      kDeterminantThresholdInverse * 100;
-  // Create a matrix with all zeros.
-  for (size_t i = 0; i < matrix_size; ++i) m[i] = 0;
-  // Verify that it's not possible to invert the matrix.
-  {
-    mathfu::Matrix<T, d> matrix(m);
-    mathfu::Matrix<T, d> inverse_matrix;
-    EXPECT_FALSE(matrix.InverseWithDeterminantCheck(&inverse_matrix));
-  }
-  // Check a matrix with all elements at the determinant threshold.
-  for (size_t i = 0; i < matrix_size; ++i) m[i] = kDeterminantThreshold;
-  {
-    mathfu::Matrix<T, d> matrix(m);
-    mathfu::Matrix<T, d> inverse_matrix;
-    EXPECT_FALSE(matrix.InverseWithDeterminantCheck(&inverse_matrix));
-  }
-  // Check a matrix with all very large elements.
-  for (size_t i = 0; i < matrix_size - 1; ++i) {
-    m[i] = kDeterminantThresholdInverse;
-  }
-  m[matrix_size - 1] = kDeterminantThresholdInverseLarge;
-  // NOTE: Due to precision, this case will pass the determinant check with a
-  // 2x2 matrix since the determinant of the matrix will be calculated as 1.
-  if (d != 2) {
-    // Create a matrix with all elements at the determinant threshold and one
-    // large value in the matrix.
-    for (size_t i = 0; i < matrix_size - 1; ++i) {
-      m[i] = kDeterminantThresholdSmall;
-    }
-    m[matrix_size - 1] = kDeterminantThresholdInverseLarge;
-    {
-      mathfu::Matrix<T, d> matrix(m);
-      mathfu::Matrix<T, d> inverse_matrix;
-      EXPECT_FALSE(matrix.InverseWithDeterminantCheck(&inverse_matrix));
-    }
-  }
-}
-TEST_ALL_F(InverseNonInvertible, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif  // _MSC_VER
-
-// This will test calculating the inverse of a matrix. The template parameter d
-// corresponds to the number of rows and columns.
-template <class T, int d>
-void Inverse_Test(const T& precision) {
-  T x[d * d];
-  for (int iterations = 0; iterations < 1000; ++iterations) {
-    // NOTE: This assumes that matrices generated here are invertible since
-    // there is a tiny probability that a randomly generated matrix will be
-    // noninvertible.  This does mean that this test can be flakey by
-    // occasionally generating noninvertible matrices.
-    for (int i = 0; i < mathfu::Matrix<T, d>::kElements; ++i) {
-      x[i] = mathfu::RandomRange<T>(1);
-    }
-    mathfu::Matrix<T, d> matrix(x);
-    std::string error_string = MatrixToString(matrix);
-    error_string += "\n";
-    mathfu::Matrix<T, d> inverse_matrix(matrix.Inverse());
-    mathfu::Matrix<T, d> identity_matrix(matrix * inverse_matrix);
-
-    error_string += MatrixToString(inverse_matrix);
-    error_string += "\n";
-    error_string += MatrixToString(identity_matrix);
-
-    // This will verify that M * Minv is equal to the identity.
-    for (int i = 0; i < d; ++i) {
-      for (int j = 0; j < d; ++j) {
-        EXPECT_NEAR(i == j ? 1 : 0, identity_matrix(i, j), 100 * precision)
-            << error_string << " row=" << i << " column=" << j;
-      }
-    }
-  }
-}
-// Due to the number of operations involved and the random numbers used to
-// generate the test matrices, the precision the inverse matrix is calculated
-// to is relatively low.
-TEST_ALL_F(Inverse, 1e-4f, 1e-8);
-
-// This will test converting from a translation into a matrix and back again.
-template <class T>
-void TranslationVector3D_Test(const T& precision) {
-  (void)precision;
-  const mathfu::Vector<T, 3> trans(static_cast<T>(-100.0), static_cast<T>(0.0),
-                                   static_cast<T>(0.00003));
-  const mathfu::Matrix<T, 4> trans_matrix =
-      mathfu::Matrix<T, 4>::FromTranslationVector(trans);
-  const mathfu::Vector<T, 3> trans_back = trans_matrix.TranslationVector3D();
-
-  // This will verify that the translation vector has not changed.
-  for (int i = 0; i < 3; ++i) {
-    EXPECT_EQ(trans[i], trans_back[i]);
-  }
-}
-TEST_SCALAR_F(TranslationVector3D, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test converting from a translation into a matrix and back again.
-template <class T>
-void TranslationVector2D_Test(const T& precision) {
-  (void)precision;
-  const mathfu::Vector<T, 2> trans(static_cast<T>(-100.0),
-                                   static_cast<T>(0.00003));
-  const mathfu::Matrix<T, 3> trans_matrix =
-      mathfu::Matrix<T, 3>::FromTranslationVector(trans);
-  const mathfu::Vector<T, 2> trans_back = trans_matrix.TranslationVector2D();
-
-  // This will verify that the translation vector has not changed.
-  for (int i = 0; i < 2; ++i) {
-    EXPECT_EQ(trans[i], trans_back[i]);
-  }
-}
-TEST_SCALAR_F(TranslationVector2D, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test converting from a scale into a matrix, then multiply by
-// a vector of 1's, which should produce the original scale again.
-template <class T, int d>
-void FromScaleVector_Test(const T& precision) {
-  mathfu::Vector<T, d> ones(static_cast<T>(1));
-  mathfu::Vector<T, d - 1> v;
-
-  // Tests that the scale vector is placed in the correct order in the matrix.
-  for (int i = 0; i < d - 1; ++i) {
-    v[i] = static_cast<T>(i + 10);
-  }
-  mathfu::Matrix<T, d> m = mathfu::Matrix<T, d>::FromScaleVector(v);
-
-  // Ensure that the v is on the diagonal.
-  for (int i = 0; i < d - 1; ++i) {
-    EXPECT_NEAR(v[i], m(i, i), precision);
-  }
-
-  // Ensure that the last diagonal element is one.
-  EXPECT_NEAR(m(d - 1, d - 1), 1, precision);
-
-  // Ensure that all non-diagonal elements are zero.
-  for (int i = 0; i < d - 1; ++i) {
-    for (int j = 0; j < d - 1; ++j) {
-      if (i == j) continue;
-      EXPECT_NEAR(m(i, j), 0, precision);
-    }
-  }
-}
-// Precision is zero. Results must be perfect for this test.
-TEST_ALL_F(FromScaleVector, 0.0f, 0.0);
-
-// Compare a set of Matrix<T, rows, columns> with expected values.
-template <class T, int rows, int columns>
-void VerifyMatrixExpectations(
-    const MatrixExpectation<T, rows, columns>* test_cases,
-    const size_t number_of_test_cases, const T& precision) {
-  for (size_t i = 0; i < number_of_test_cases; ++i) {
-    const MatrixExpectation<T, rows, columns>& test = test_cases[i];
-    for (int j = 0; j < mathfu::Matrix<T, rows, columns>::kElements; ++j) {
-      const mathfu::Matrix<T, rows, columns>& calculated = test.calculated;
-      const mathfu::Matrix<T, rows, columns>& expected = test.expected;
-      EXPECT_NEAR(calculated[j], expected[j], precision)
-          << "element " << j << " (" << (j / columns) << ", " << (j % columns)
-          << "), case " << test.description << "\n"
-          << MatrixToString(calculated) << "vs expected\n"
-          << MatrixToString(expected);
-    }
-  }
-}
-
-// Test perspective matrix calculation.
-template <class T>
-void Perspective_Test(const T& precision) {
-  // clang-format off
-  static const MatrixExpectation<T, 4, 4> kTestCases[] = {
-    {
-      "normalized handedness=1",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(1)) * 2, 1, 0, 1, 1),
-      mathfu::Matrix<T, 4>(1, 0, 0, 0,
-                           0, 1, 0, 0,
-                           0, 0, -1, -1,
-                           0, 0, 0, 0),
-    },
-    {
-      "normalized handedness=-1",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(1)) * 2, 1, 0, 1, -1),
-      mathfu::Matrix<T, 4>(1, 0, 0, 0,
-                           0, 1, 0, 0,
-                           0, 0, 1, 1,
-                           0, 0, 0, 0),
-    },
-    {
-      "widefov",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(2)) * 2, 1, 0, 1, 1),
-      mathfu::Matrix<T, 4>(0.5, 0, 0, 0,
-                           0, 0.5, 0, 0,
-                           0, 0, -1, -1,
-                           0, 0, 0, 0),
-    },
-    {
-      "narrowfov",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(0.1)) * 2, 1, 0, 1, 1),
-      mathfu::Matrix<T, 4>(10, 0, 0, 0,
-                           0, 10, 0, 0,
-                           0, 0, -1, -1,
-                           0, 0, 0, 0),
-    },
-    {
-      "2:1 aspect ratio",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(1)) * 2, 0.5, 0, 1, 1),
-      mathfu::Matrix<T, 4>(2, 0, 0, 0,
-                           0, 1, 0, 0,
-                           0, 0, -1, -1,
-                           0, 0, 0, 0),
-    },
-    {
-      "deeper view frustrum",
-      mathfu::Matrix<T, 4>::Perspective(
-          atan(static_cast<T>(1)) * 2, 1, -2, 2, 1),
-      mathfu::Matrix<T, 4>(1, 0, 0, 0,
-                           0, 1, 0, 0,
-                           0, 0, -0.5, -1,
-                           0, 0, 2, 0),
-    },
-  };
-  // clang-format on
-  VerifyMatrixExpectations(
-      kTestCases, sizeof(kTestCases) / sizeof(kTestCases[0]), precision);
-}
-TEST_SCALAR_F(Perspective, FLOAT_PRECISION, DOUBLE_PRECISION * 10);
-
-// Test orthographic matrix calculation.
-template <class T>
-void Ortho_Test(const T& precision) {
-  // clang-format off
-  static const MatrixExpectation<T, 4, 4> kTestCases[] = {
-    {
-      "normalized",
-      mathfu::Matrix<T, 4, 4>::Ortho(0, 2, 0, 2, 2, 0),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -1, -1, 1, 1),
-    },
-    {
-      "normalized RH",
-      mathfu::Matrix<T, 4, 4>::Ortho(0, 2, 0, 2, 2, 0, 1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -1, -1, 1, 1),
-    },
-    {
-      "narrow RH",
-      mathfu::Matrix<T, 4, 4>::Ortho(1, 3, 0, 2, 2, 0, 1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -2, -1, 1, 1),
-
-    },
-    {
-      "squat RH",
-      mathfu::Matrix<T, 4, 4>::Ortho(0, 2, 1, 3, 2, 0, 1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -1, -2, 1, 1),
-
-    },
-    {
-      "deep RH",
-      mathfu::Matrix<T, 4, 4>::Ortho(0, 2, 0, 2, 3, 1, 1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -1, -1, 2, 1),
-
-    },
-    {
-      "normalized LH",
-      mathfu::Matrix<T, 4, 4>::Ortho(0, 2, 0, 2, 2, 0, -1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, -1, 0,
-                              -1, -1, 1, 1),
-    },
-    {
-      "Canonical LH",
-      mathfu::Matrix<T, 4, 4>::Ortho(1, 3, 1, 3, 1, 3, -1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                             -2,-2,-2, 1),
-
-    },
-  };
-  // clang-format on
-  VerifyMatrixExpectations(
-      kTestCases, sizeof(kTestCases) / sizeof(kTestCases[0]), precision);
-}
-TEST_SCALAR_F(Ortho, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test look-at matrix calculation.
-template <class T>
-void LookAt_Test(const T& precision) {
-  // clang-format off
-  static const MatrixExpectation<T, 4, 4> kTestCases[] = {
-    {
-      "origin along z",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 0, 1), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(0, 1, 0)),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              0, 0, 0, 1),
-    },
-    {
-      "origin along diagonal",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 0, 0), mathfu::Vector<T, 3>(1, 1, 1),
-          mathfu::Vector<T, 3>(0, 1, 0), -1),
-      mathfu::Matrix<T, 4, 4>(
-          static_cast<T>(-0.707106781), static_cast<T>(-0.408248290),
-              static_cast<T>(-0.577350269), 0,
-          0, static_cast<T>(0.816496580), static_cast<T>(-0.577350269), 0,
-          static_cast<T>(0.707106781), static_cast<T>(-0.408248290),
-              static_cast<T>(-0.577350269), 0,
-          0, 0, static_cast<T>(1.732050808), 1),
-    },
-    {
-      "origin along z",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 0, 2), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(0, 1, 0), -1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              0, 0, 0, 1),
-    },
-    {
-      "origin along x",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(1, 0, 0), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(0, 1, 0), -1),
-      mathfu::Matrix<T, 4, 4>(0, 0, 1, 0,
-                              0, 1, 0, 0,
-                              -1, 0, 0, 0,
-                              0, 0, 0, 1),
-    },
-    {
-      "origin along y",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 1, 0), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(1, 0, 0), -1),
-      mathfu::Matrix<T, 4, 4>(0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              1, 0, 0, 0,
-                              0, 0, 0, 1),
-    },
-    {
-      "translated eye, looking along z",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(1, 1, 2), mathfu::Vector<T, 3>(1, 1, 1),
-          mathfu::Vector<T, 3>(0, 1, 0), -1),
-      mathfu::Matrix<T, 4, 4>(1, 0, 0, 0,
-                              0, 1, 0, 0,
-                              0, 0, 1, 0,
-                              -1, -1, -1, 1),
-    },
-    {
-      "right-handed diagonal along diagonal",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 0, 0), mathfu::Vector<T, 3>(1, 1, 1),
-          mathfu::Vector<T, 3>(0, 1, 0), 1),
-      mathfu::Matrix<T, 4, 4>(
-          static_cast<T>(0.707106781), static_cast<T>(-0.408248290),
-              static_cast<T>(0.577350269), 0,
-          0, static_cast<T>(0.816496581), static_cast<T>(0.577350269), 0,
-          static_cast<T>(-0.707106781), static_cast<T>(-0.408248290),
-              static_cast<T>(0.577350269), 0,
-          0, 0, static_cast<T>(-1.732050808), 1),
-    },
-    {
-      "right-handed origin along z",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 0, 1), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(0, 1, 0), 1),
-      mathfu::Matrix<T, 4, 4>(-1, 0, 0, 0,
-                               0, 1, 0, 0,
-                               0, 0, -1,0,
-                               0, 0, 0, 1),
-    },
-    {
-      "right-handed origin along x",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(1, 0, 0), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(0, 1, 0), 1),
-      mathfu::Matrix<T, 4, 4>(0, 0, -1, 0,
-                              0, 1, 0, 0,
-                              1, 0, 0, 0,
-                              0, 0, 0, 1),
-    },
-    {
-      "right-handed origin along y",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(0, 1, 0), mathfu::Vector<T, 3>(0, 0, 0),
-          mathfu::Vector<T, 3>(1, 0, 0), 1),
-      mathfu::Matrix<T, 4, 4>(0, 1, 0, 0,
-                              0, 0, -1, 0,
-                              -1, 0, 0, 0,
-                              0,  0, 0, 1),
-    },
-    {
-      "right-handed translated eye along x",
-      mathfu::Matrix<T, 4, 4>::LookAt(
-          mathfu::Vector<T, 3>(2, 1, 1), mathfu::Vector<T, 3>(1, 1, 1),
-          mathfu::Vector<T, 3>(0, 1, 0), 1),
-      mathfu::Matrix<T, 4, 4>(0, 0, -1, 0,
-                              0, 1, 0, 0,
-                              1, 0, 0, 0,
-                             -1,-1, 1, 1),
-    },
-  };
-  // clang-format on
-  VerifyMatrixExpectations(
-      kTestCases, sizeof(kTestCases) / sizeof(kTestCases[0]), precision);
-}
-TEST_SCALAR_F(LookAt, FLOAT_PRECISION, kLookAtDoublePrecision);
-
-// Test UnProject calculation.
-template <class T>
-void UnProject_Test(const T& precision) {
-  // clang-format off
-  mathfu::Matrix<T, 4, 4> modelView =
-      mathfu::Matrix<T, 4, 4>(-1, 0,                   0, 0,
-                               0, 1,                   0, 0,
-                               0, 0,                  -1, 0,
-                               0, 0, static_cast<T>(-10), 1);
-  mathfu::Matrix<T, 4, 4> projection =
-      mathfu::Matrix<T, 4, 4>(
-          static_cast<T>(1.81066),  0,                            0,   0,
-                        0, static_cast<T>(2.41421342),            0,   0,
-                        0,          0,   static_cast<T>(-1.00001991), -1,
-                        0,          0,  static_cast<T>(-0.200001985),  0);
-  // clang-format on
-  mathfu::Vector<T, 3> result = mathfu::Matrix<T, 4, 4>::UnProject(
-      mathfu::Vector<T, 3>(754, 1049, 1), modelView, projection, 1600, 1200);
-  EXPECT_NEAR(result.x, 319.00242400912055, 300.0 * precision);
-  EXPECT_NEAR(result.y, 3113.7409399625253, 3000.0 * precision);
-  EXPECT_NEAR(result.z, 10035.303114023569, 10000.0 * precision);
-}
-TEST_SCALAR_F(UnProject, kUnProjectFloatPrecision, DOUBLE_PRECISION);
-
-// Test matrix transposition.
-template <class T, int d>
-void Transpose_Test(const T& precision) {
-  (void)precision;
-  mathfu::Matrix<T, d> matrix;
-  for (int i = 0; i < d * d; ++i) {
-    matrix[i] = static_cast<T>(i);
-  }
-  mathfu::Matrix<T, d> transpose = matrix.Transpose();
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(matrix(i, j), transpose(j, i), static_cast<T>(0));
-    }
-  }
-}
-
-TEST_ALL_F(Transpose, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Return one of the numbers:
-//   offset, offset + width/d, offset + 2*width/d, ... , offset + (d-1)*width/d
-// For each i=0..d-1, the number returned is different.
-//
-// The order of the numbers is determined by 'prime' which should be a prime
-// number > d.
-template <class T, int d>
-static T WellSpacedNumber(int i, int prime, T width, T offset) {
-  // Reorder the i's from 0..(d-1) by using a prime number.
-  // The numbers get reordered (i.e. no duplicates) because 'd' and 'prime' are
-  // relatively prime.
-  const int remapped = ((i + 1) * prime) % d;
-
-  // Map to [0,1) range. That is, inclusive of 0, exclusive of 1.
-  const T zero_to_one = static_cast<T>(remapped) / static_cast<T>(d);
-
-  // Map to [offset, offset + width) range.
-  const T offset_and_scaled = zero_to_one * width + offset;
-  return offset_and_scaled;
-}
-
-// Generate a (probably) invertable matrix. I haven't gone through the math
-// to verify that it's actually invertable for all d, but for small d it is.
-//
-// We adjusting each element of an identity matrix by a small amount.
-// The amount must be small so that the matrix stays reasonably close to
-// the identity. Matrices become progressively less numerically stable the
-// further the get from identity.
-template <class T, int d>
-static mathfu::Matrix<T, d> InvertableMatrix() {
-  mathfu::Matrix<T, d> invertable = mathfu::Matrix<T, d>::Identity();
-
-  for (int i = 0; i < d; ++i) {
-    // The width and offset constants are arbitrary. We do want to keep the
-    // pseudo-random values centered near 0 though.
-    const T rand_i = WellSpacedNumber<T, d>(i, 7, 0.8f, -0.33f);
-
-    for (int j = 0; j < d; ++j) {
-      const T rand_j = WellSpacedNumber<T, d>(j, 13, 0.6f, -0.4f);
-      invertable(i, j) += rand_i * rand_j;
-    }
-  }
-  return invertable;
-}
-
-template <class T, int d>
-static void ExpectEqualMatrices(const mathfu::Matrix<T, d>& a,
-                                const mathfu::Matrix<T, d>& b, T precision) {
-  for (int i = 0; i < d; ++i) {
-    for (int j = 0; j < d; ++j) {
-      EXPECT_NEAR(a(i, j), b(i, j), precision);
-    }
-  }
-}
-
-// Test matrix operator*() by multiplying an invertable matrix by its
-// inverse. Should end up with identity.
-template <class T, int d>
-void MultiplyOperatorInverse_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat identity = Mat::Identity();
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to go way from the identity and then get back to it.
-  Mat product = identity;
-  product *= invertable;
-  product *= invertable.Inverse();
-
-  // Test that operator*() gets is back to where we need to go.
-  ExpectEqualMatrices(product, identity, precision);
-}
-
-TEST_ALL_F(MultiplyOperatorInverse, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test static operator*(a, b) by multiplying an invertable matrix by its
-// inverse. Should end up with identity.
-template <class T, int d>
-void ExternalMultiplyOperatorInverse_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat identity = Mat::Identity();
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to go way from the identity and then get back to it.
-  Mat product = identity;
-  product = product * invertable;
-  product = product * invertable.Inverse();
-
-  // Test that operator*() gets is back to where we need to go.
-  ExpectEqualMatrices(product, identity, precision);
-}
-
-TEST_ALL_F(ExternalMultiplyOperatorInverse, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test matrix operator*() by multiplying a non-zero matrix by identity.
-// Should be no change.
-template <class T, int d>
-void MultiplyOperatorIdentity_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat identity = Mat::Identity();
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to multipy by the identity.
-  Mat product = invertable;
-  product *= identity;
-
-  // Test that operator*() didn't change anything when multiplying by identity.
-  ExpectEqualMatrices(product, invertable, precision);
-}
-
-TEST_ALL_F(MultiplyOperatorIdentity, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test static operator*(a, b) by multiplying a non-zero matrix by identity.
-// Should be no change.
-template <class T, int d>
-void ExternalMultiplyOperatorIdentity_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat identity = Mat::Identity();
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to multipy by the identity.
-  const Mat product = invertable * identity;
-
-  // Test that operator*() didn't change anything when multiplying by identity.
-  ExpectEqualMatrices(product, invertable, precision);
-}
-
-TEST_ALL_F(ExternalMultiplyOperatorIdentity, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test matrix operator*() by multiplying a non-zero matrix by zero.
-// Should be no change.
-template <class T, int d>
-void MultiplyOperatorZero_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat zero(static_cast<T>(0));
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to multipy by the zero.
-  Mat product = invertable;
-  product *= zero;
-
-  // Test that operator*() didn't change anything when multiplying by zero.
-  ExpectEqualMatrices(product, zero, precision);
-}
-
-TEST_ALL_F(MultiplyOperatorZero, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test static operator*(a, b) by multiplying a non-zero matrix by zero.
-// Should be no change.
-template <class T, int d>
-void ExternalMultiplyOperatorZero_Test(const T& precision) {
-  typedef typename mathfu::Matrix<T, d> Mat;
-  const Mat zero(static_cast<T>(0));
-  const Mat invertable = InvertableMatrix<T, d>();
-
-  // Use operator*() to multipy by the zero.
-  const Mat product = invertable * zero;
-
-  // Test that operator*() didn't change anything when multiplying by zero.
-  ExpectEqualMatrices(product, zero, precision);
-}
-
-TEST_ALL_F(ExternalMultiplyOperatorZero, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test Matrix<>::ToAffineTransform().
-template <class T>
-void Mat4ToAffine_Test(const T&) {
-  typedef typename mathfu::Matrix<T, 4> Mat4;
-  typedef typename mathfu::Matrix<T, 4, 3> Affine;
-  const Mat4 indices4(0, 1, 2, 0, 4, 5, 6, 0, 8, 9, 10, 0, 12, 13, 14, 1);
-  const Affine indices_affine(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14);
-
-  const Affine to_affine = Mat4::ToAffineTransform(indices4);
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 3; j++) {
-      EXPECT_EQ(to_affine(i, j), indices_affine(i, j));
-    }
-  }
-}
-
-TEST_SCALAR_F(Mat4ToAffine, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test Matrix<>::FromAffineTransform().
-template <class T>
-void Mat4FromAffine_Test(const T&) {
-  typedef typename mathfu::Matrix<T, 4> Mat4;
-  typedef typename mathfu::Matrix<T, 4, 3> Affine;
-  const Mat4 indices4(0, 1, 2, 0, 4, 5, 6, 0, 8, 9, 10, 0, 12, 13, 14, 1);
-  const Affine indices_affine(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14);
-
-  const Mat4 to_mat4 = Mat4::FromAffineTransform(indices_affine);
-  ExpectEqualMatrices(to_mat4, indices4, static_cast<T>(0));
-}
-
-TEST_SCALAR_F(Mat4FromAffine, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// Test converting back and forth via Matrix<>::To/FromAffineTransform().
-template <class T>
-void Mat4ToAndFromAffine_Test(const T&) {
-  typedef typename mathfu::Matrix<T, 4> Mat4;
-  typedef typename mathfu::Matrix<T, 4, 3> Affine;
-  const Mat4 indices4(0, 1, 2, 0, 4, 5, 6, 0, 8, 9, 10, 0, 12, 13, 14, 1);
-  const Affine indices_affine(0, 4, 8, 12, 1, 5, 9, 13, 2, 6, 10, 14);
-
-  // Convert to/from AffineTransform and check to ensure the result is the same
-  // as the original.
-  const Mat4 converted =
-      Mat4::FromAffineTransform(Mat4::ToAffineTransform(indices4));
-
-  ExpectEqualMatrices(indices4, converted, static_cast<T>(0));
-
-  // Perform a normal mat4 * mat4 multiplication and compare its result with
-  // multiplications involving conversions.
-  const Mat4 mat4_multiplication = indices4 * indices4;
-  const Mat4 affine_multiplication = Mat4::FromAffineTransform(indices_affine) *
-                                     Mat4::FromAffineTransform(indices_affine);
-  const Mat4 affine_and_mat4_multiplication =
-      indices4 * Mat4::FromAffineTransform(indices_affine);
-
-  ExpectEqualMatrices(mat4_multiplication, affine_multiplication,
-                      static_cast<T>(0));
-  ExpectEqualMatrices(mat4_multiplication, affine_and_mat4_multiplication,
-                      static_cast<T>(0));
-
-  // Ensure that the result from the multiplication produces the expected
-  // AffineTransform result.
-  const Affine expected_result(20, 68, 116, 176, 23, 83, 143, 216, 26, 98, 170,
-                               256);
-  const Affine affine_result = Mat4::ToAffineTransform(affine_multiplication);
-
-  for (int i = 0; i < 4; i++) {
-    for (int j = 0; j < 3; j++) {
-      EXPECT_EQ(expected_result(i, j), affine_result(i, j));
-    }
-  }
-}
-
-TEST_SCALAR_F(Mat4ToAndFromAffine, FLOAT_PRECISION, DOUBLE_PRECISION);
-
-// This will test converting from a translation into a matrix and back again.
-// Test the compilation of basic matrix operations given in the sample file.
-// This will test transforming a vector with a matrix.
-TEST_F(MatrixTests, MatrixSample) {
-  using namespace mathfu;
-  /// @doxysnippetstart Chapter04_Matrices.md Matrix_Sample
-  Vector<float, 3> trans(3.f, 2.f, 8.f);
-  Vector<float, 3> rotation(0.4f, 1.4f, 0.33f);
-  Vector<float, 3> vector(4.f, 8.f, 1.f);
-
-  Quaternion<float> rotQuat = Quaternion<float>::FromEulerAngles(rotation);
-  Matrix<float, 3> rotMatrix = rotQuat.ToMatrix();
-  Matrix<float, 4> transMatrix = Matrix<float, 4>::FromTranslationVector(trans);
-  Matrix<float, 4> rotHMatrix = Matrix<float, 4>::FromRotationMatrix(rotMatrix);
-
-  Matrix<float, 4> matrix = transMatrix * rotHMatrix;
-  Vector<float, 3> rotatedVector = matrix * vector;
-  /// @doxysnippetend
-  const float precision = 1e-2f;
-  EXPECT_NEAR(5.14f, rotatedVector[0], precision);
-  EXPECT_NEAR(10.11f, rotatedVector[1], precision);
-  EXPECT_NEAR(4.74f, rotatedVector[2], precision);
-}
-
-// Simple class that represents a possible compatible type for a vector.
-// That is, it's just an array of T of length d, so can be loaded and
-// stored from mathfu::Vector<T,d> using ToType() and FromType().
-template <class T, int d>
-struct SimpleMatrix {
-  T values[d * d];
-};
-
-// This will test the FromType() conversion functions.
-template <class T, int d>
-void FromType_Test(const T& precision) {
-  typedef SimpleMatrix<T, d> CompatibleT;
-  typedef mathfu::Matrix<T, d> MatrixT;
-
-  CompatibleT compatible;
-  for (int i = 0; i < d * d; ++i) {
-    compatible.values[i] = static_cast<T>(i * precision);
-  }
-
-#ifdef MATHFU_COMPILE_WITH_PADDING
-  // With padding, vec3s take up 4-floats worth of memory, so byte-wise
-  // conversion won't work.
-  if (sizeof(CompatibleT) != sizeof(MatrixT)) {
-    EXPECT_EQ(d, 3);
-    return;
-  }
-#endif  // MATHFU_COMPILE_WITH_PADDING
-
-  const MatrixT matrix = MatrixT::FromType(compatible);
-
-  for (int i = 0; i < d * d; ++i) {
-    EXPECT_EQ(compatible.values[i], matrix[i]);
-  }
-}
-TEST_ALL_F(FromType, 0.0f, 0.0);
-
-// This will test the ToType() conversion functions.
-template <class T, int d>
-void ToType_Test(const T& precision) {
-  typedef SimpleMatrix<T, d> CompatibleT;
-  typedef mathfu::Matrix<T, d> MatrixT;
-
-  MatrixT matrix;
-  for (int i = 0; i < d * d; ++i) {
-    matrix[i] = static_cast<T>(i * precision);
-  }
-
-#ifdef MATHFU_COMPILE_WITH_PADDING
-  // With padding, vec3s take up 4-floats worth of memory, so byte-wise
-  // conversion won't work.
-  if (sizeof(CompatibleT) != sizeof(MatrixT)) {
-    EXPECT_EQ(d, 3);
-    return;
-  }
-#endif  // MATHFU_COMPILE_WITH_PADDING
-
-  const CompatibleT compatible = MatrixT::template ToType<CompatibleT>(matrix);
-
-  for (int i = 0; i < d * d; ++i) {
-    EXPECT_EQ(compatible.values[i], matrix[i]);
-  }
-}
-TEST_ALL_F(ToType, 0.0f, 0.0);
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  printf("%s (%s)\n", argv[0], MATHFU_BUILD_OPTIONS_STRING);
-  return RUN_ALL_TESTS();
-}
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/AndroidManifest.xml
deleted file mode 100644
index 6e4344a..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_no_simd_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_no_simd_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Android.mk
deleted file mode 100644
index 889586f..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=matrix_no_simd_test
-MATHFU_LIB:=libmathfu_no_simd
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Application.mk
deleted file mode 100644
index 6c9a709..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_no_simd_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/res/values/strings.xml
deleted file mode 100644
index d7871ac..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/no_simd/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_no_simd_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/AndroidManifest.xml
deleted file mode 100644
index d8c08ce..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_simd_no_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_simd_no_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Android.mk
deleted file mode 100644
index ce77885..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=matrix_simd_no_padding_test
-MATHFU_LIB:=libmathfu_simd_no_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Application.mk
deleted file mode 100644
index f9c088a..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_simd_no_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/res/values/strings.xml
deleted file mode 100644
index d683b22..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_no_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_simd_no_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/AndroidManifest.xml
deleted file mode 100644
index 6d0bddd..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.matrix_simd_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="matrix_simd_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Android.mk
deleted file mode 100644
index 2376654..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=matrix_simd_padding_test
-MATHFU_LIB:=libmathfu_simd_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Application.mk
deleted file mode 100644
index 8f725fd..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=matrix_simd_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/res/values/strings.xml
deleted file mode 100644
index cec9192..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/matrix_test/simd_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">matrix_simd_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/precision.h b/third_party/mathfu-1.1.0/unit_tests/precision.h
deleted file mode 100644
index 72a89e2..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/precision.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#ifndef MATHFU_UNITTESTS_PRECISION_H_
-#define MATHFU_UNITTESTS_PRECISION_H_
-
-// Precision for floats and doubles
-#define FLOAT_PRECISION 1e-6f
-#define DOUBLE_PRECISION 1e-15
-
-#endif  // MATHFU_UNITTESTS_PRECISION_H_
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/AndroidManifest.xml
deleted file mode 100644
index a3122ca..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.quaternion_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="quaternion_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Android.mk
deleted file mode 100644
index abb56ea..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=quaternion_test
-MATHFU_LIB:=libmathfu
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Application.mk
deleted file mode 100644
index d6575ed..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=quaternion_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/res/values/strings.xml
deleted file mode 100644
index 634ce16..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/default/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">quaternion_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/AndroidManifest.xml
deleted file mode 100644
index 2cdeadb..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.quaternion_no_simd_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="quaternion_no_simd_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Android.mk
deleted file mode 100644
index b844150..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=quaternion_no_simd_test
-MATHFU_LIB:=libmathfu_no_simd
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Application.mk
deleted file mode 100644
index 790e89f..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=quaternion_no_simd_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/res/values/strings.xml
deleted file mode 100644
index 70588b0..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/no_simd/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">quaternion_no_simd_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/quaternion_test.cpp b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/quaternion_test.cpp
deleted file mode 100644
index d1ba26d..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/quaternion_test.cpp
+++ /dev/null
@@ -1,434 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "mathfu/quaternion.h"
-#include "mathfu/constants.h"
-
-#include <math.h>
-
-#include "gtest/gtest.h"
-
-#include "precision.h"
-
-class QuaternionTests : public ::testing::Test {
- protected:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-// This will automatically generate tests for each template parameter.
-#define TEST_ALL_F(MY_TEST)                   \
-  TEST_F(QuaternionTests, MY_TEST) {          \
-    MY_TEST##_Test<float>(FLOAT_PRECISION);   \
-    MY_TEST##_Test<double>(DOUBLE_PRECISION); \
-  }
-
-// helper macro for comparing vectors
-#define EXPECT_NEAR_VEC3(v1, v2, precision)   \
-  {                                           \
-    EXPECT_NEAR((v1)[0], (v2)[0], precision); \
-    EXPECT_NEAR((v1)[1], (v2)[1], precision); \
-    EXPECT_NEAR((v1)[2], (v2)[2], precision); \
-  }
-#define EXPECT_EQ_QUAT(q1, q2)               \
-  {                                          \
-    EXPECT_EQ((q1).scalar(), (q2).scalar()); \
-    EXPECT_EQ((q1).vector(), (q2).vector()); \
-  }
-
-// Test accessing elements of the quaternion using the const array accessor.
-template <class T>
-void ConstAccessor_Test(const T& precision) {
-  (void)precision;
-  const mathfu::Quaternion<T> quaternion(
-      static_cast<T>(0.50), static_cast<T>(0.76), static_cast<T>(0.38),
-      static_cast<T>(0.19));
-  EXPECT_EQ(static_cast<T>(0.50), quaternion[0]);
-  EXPECT_EQ(static_cast<T>(0.76), quaternion[1]);
-  EXPECT_EQ(static_cast<T>(0.38), quaternion[2]);
-  EXPECT_EQ(static_cast<T>(0.19), quaternion[3]);
-}
-TEST_ALL_F(ConstAccessor);
-
-// Test updating elements of the quaternion using the array accessor.
-template <class T>
-void NonConstAccessor_Test(const T& precision) {
-  (void)precision;
-  mathfu::Quaternion<T> quaternion(static_cast<T>(0.19), static_cast<T>(0.38),
-                                   static_cast<T>(0.76), static_cast<T>(0.50));
-  quaternion[0] = static_cast<T>(0.50);
-  quaternion[1] = static_cast<T>(0.76);
-  quaternion[2] = static_cast<T>(0.38);
-  quaternion[3] = static_cast<T>(0.19);
-  EXPECT_EQ(static_cast<T>(0.50), quaternion[0]);
-  EXPECT_EQ(static_cast<T>(0.76), quaternion[1]);
-  EXPECT_EQ(static_cast<T>(0.38), quaternion[2]);
-  EXPECT_EQ(static_cast<T>(0.19), quaternion[3]);
-}
-TEST_ALL_F(NonConstAccessor);
-
-// Test accessing the scalar component of the quaternion using the scalar
-// accessor.
-template <class T>
-void ScalarAccessor_Test(const T& precision) {
-  (void)precision;
-  mathfu::Quaternion<T> quaternion(static_cast<T>(0.50), static_cast<T>(0.76),
-                                   static_cast<T>(0.38), static_cast<T>(0.19));
-  EXPECT_EQ(static_cast<T>(0.50), quaternion.scalar());
-}
-TEST_ALL_F(ScalarAccessor);
-
-// Test accessing the scalar component of the quaternion using the const scalar
-// accessor.
-template <class T>
-void ConstScalarAccessor_Test(const T& precision) {
-  (void)precision;
-  const mathfu::Quaternion<T> quaternion(
-      static_cast<T>(0.50), static_cast<T>(0.76), static_cast<T>(0.38),
-      static_cast<T>(0.19));
-  EXPECT_EQ(static_cast<T>(0.50), quaternion.scalar());
-}
-TEST_ALL_F(ConstScalarAccessor);
-
-// Test mutating the scalar component of the quaternion using the scalar
-// mutator.
-template <class T>
-void ScalarMutator_Test(const T& precision) {
-  (void)precision;
-  mathfu::Quaternion<T> quaternion;
-  quaternion.set_scalar(static_cast<T>(0.38));
-  EXPECT_EQ(static_cast<T>(0.38), quaternion[0]);
-}
-TEST_ALL_F(ScalarMutator);
-
-// Test accessing elements of the quaternion using the vector accessor.
-template <class T>
-void VectorAccessor_Test(const T& precision) {
-  (void)precision;
-  mathfu::Quaternion<T> quaternion(static_cast<T>(0.50), static_cast<T>(0.76),
-                                   static_cast<T>(0.38), static_cast<T>(0.19));
-  EXPECT_EQ(static_cast<T>(0.76), quaternion.vector()[0]);
-  EXPECT_EQ(static_cast<T>(0.38), quaternion.vector()[1]);
-  EXPECT_EQ(static_cast<T>(0.19), quaternion.vector()[2]);
-}
-TEST_ALL_F(VectorAccessor);
-
-// Test accessing elements of the quaternion using the const vector accessor.
-template <class T>
-void ConstVectorAccessor_Test(const T& precision) {
-  (void)precision;
-  const mathfu::Quaternion<T> quaternion(
-      static_cast<T>(0.50), static_cast<T>(0.76), static_cast<T>(0.38),
-      static_cast<T>(0.19));
-  EXPECT_EQ(static_cast<T>(0.76), quaternion.vector()[0]);
-  EXPECT_EQ(static_cast<T>(0.38), quaternion.vector()[1]);
-  EXPECT_EQ(static_cast<T>(0.19), quaternion.vector()[2]);
-}
-TEST_ALL_F(ConstVectorAccessor);
-
-// Test mutating the vector component of the quaternion using the vector
-// mutator.
-template <class T>
-void VectorMutator_Test(const T& precision) {
-  (void)precision;
-  mathfu::Quaternion<T> quaternion;
-  quaternion.set_vector(mathfu::Vector<T, 3>(
-      static_cast<T>(0.38), static_cast<T>(0.76), static_cast<T>(0.50)));
-  EXPECT_EQ(static_cast<T>(0.38), quaternion.vector()[0]);
-  EXPECT_EQ(static_cast<T>(0.76), quaternion.vector()[1]);
-  EXPECT_EQ(static_cast<T>(0.50), quaternion.vector()[2]);
-}
-TEST_ALL_F(VectorMutator);
-
-// This will test converting a Quaternion to and from Angle/Axis,
-// Euler Angles, and Matrices
-template <class T>
-void Conversion_Test(const T& precision) {
-  mathfu::Vector<T, 3> angles(static_cast<T>(1.5), static_cast<T>(2.3),
-                              static_cast<T>(0.6));
-  // This will create a Quaternion from Euler Angles, convert back to
-  // Euler Angles, and verify that they match
-  mathfu::Quaternion<T> qea(mathfu::Quaternion<T>::FromEulerAngles(angles));
-  mathfu::Vector<T, 3> convertedAngles(qea.ToEulerAngles());
-  EXPECT_NEAR(angles[0], M_PI + convertedAngles[0], precision);
-  EXPECT_NEAR(angles[1], M_PI - convertedAngles[1], precision);
-  EXPECT_NEAR(angles[2], M_PI + convertedAngles[2], precision);
-  // This will create a Quaternion from Axis Angle, convert back to
-  // Axis Angle, and verify that they match.
-  mathfu::Vector<T, 3> axis(static_cast<T>(4.3), static_cast<T>(7.6),
-                            static_cast<T>(1.2));
-  axis.Normalize();
-  T angle = static_cast<T>(1.2);
-  mathfu::Quaternion<T> qaa(mathfu::Quaternion<T>::FromAngleAxis(angle, axis));
-  mathfu::Vector<T, 3> convertedAxis;
-  T convertedAngle;
-  qaa.ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(angle, convertedAngle, precision);
-  EXPECT_NEAR(axis[0], convertedAxis[0], precision);
-  EXPECT_NEAR(axis[1], convertedAxis[1], precision);
-  EXPECT_NEAR(axis[2], convertedAxis[2], precision);
-  // This will create a Quaternion from a Matrix, convert back to a Matrix,
-  // and verify that they match.
-  mathfu::Matrix<T, 3> rx(1, 0, 0, 0, cos(angles[0]), sin(angles[0]), 0,
-                          -sin(angles[0]), cos(angles[0]));
-  mathfu::Matrix<T, 3> ry(cos(angles[1]), 0, -sin(angles[1]), 0, 1, 0,
-                          sin(angles[1]), 0, cos(angles[1]));
-  mathfu::Matrix<T, 3> rz(cos(angles[2]), sin(angles[2]), 0, -sin(angles[2]),
-                          cos(angles[2]), 0, 0, 0, 1);
-  mathfu::Matrix<T, 3> m(rz * ry * rx);
-  mathfu::Quaternion<T> qm(mathfu::Quaternion<T>::FromMatrix(m));
-  mathfu::Matrix<T, 3> convertedM(qm.ToMatrix());
-  for (int i = 0; i < 9; ++i) EXPECT_NEAR(m[i], convertedM[i], precision);
-}
-TEST_ALL_F(Conversion);
-
-// This will test inverting a quaternion and verify that their combination
-// corresponds to a rotation of 0.
-template <class T>
-void Inverse_Test(const T& precision) {
-  mathfu::Quaternion<T> q(static_cast<T>(1.4), static_cast<T>(6.3),
-                          static_cast<T>(8.5), static_cast<T>(5.9));
-  mathfu::Vector<T, 3> v((q.Inverse() * q).ToEulerAngles());
-  EXPECT_NEAR(0, v[0], precision);
-  EXPECT_NEAR(0, v[1], precision);
-  EXPECT_NEAR(0, v[2], precision);
-}
-TEST_ALL_F(Inverse);
-
-// This will test the multiplication of quaternions.
-template <class T>
-void Mult_Test(const T& precision) {
-  mathfu::Vector<T, 3> axis(static_cast<T>(4.3), static_cast<T>(7.6),
-                            static_cast<T>(1.2));
-  axis.Normalize();
-  T angle1 = static_cast<T>(1.2), angle2 = static_cast<T>(0.7),
-    angle3 = angle2 + precision * 10;
-  mathfu::Quaternion<T> qaa1(
-      mathfu::Quaternion<T>::FromAngleAxis(angle1, axis));
-  mathfu::Quaternion<T> qaa2(
-      mathfu::Quaternion<T>::FromAngleAxis(angle2, axis));
-  mathfu::Quaternion<T> qaa3(
-      mathfu::Quaternion<T>::FromAngleAxis(angle3, axis));
-  mathfu::Vector<T, 3> convertedAxis;
-  T convertedAngle;
-  // This will verify that multiplying two quaternions corresponds to the sum
-  // of the rotations.
-  (qaa1 * qaa2).ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(angle1 + angle2, convertedAngle, precision);
-  // This will verify that multiplying a quaternions with a scalar corresponds
-  // to scaling the rotation.
-  (qaa1 * 2).ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(angle1 * 2, convertedAngle, precision);
-  mathfu::Vector<T, 3> v(3.5f, 6.4f, 7.0f);
-  mathfu::Vector<T, 4> v4(3.5f, 6.4f, 7.0f, 0.0f);
-  // This will verify that multiplying by a vector corresponds to applying
-  // the rotation to that vector.
-  mathfu::Vector<T, 3> quatRotatedV(qaa1 * v);
-  mathfu::Vector<T, 3> matRotatedV(qaa1.ToMatrix() * v);
-  mathfu::Vector<T, 4> mat4RotatedV(qaa1.ToMatrix4() * v4);
-  EXPECT_NEAR(quatRotatedV[0], matRotatedV[0], 10 * precision);
-  EXPECT_NEAR(quatRotatedV[1], matRotatedV[1], 10 * precision);
-  EXPECT_NEAR(quatRotatedV[2], matRotatedV[2], 10 * precision);
-
-  EXPECT_NEAR(quatRotatedV[0], mat4RotatedV[0], 10 * precision);
-  EXPECT_NEAR(quatRotatedV[1], mat4RotatedV[1], 10 * precision);
-  EXPECT_NEAR(quatRotatedV[2], mat4RotatedV[2], 10 * precision);
-  // This will verify that interpolating two quaternions corresponds to
-  // interpolating the angle.
-  mathfu::Quaternion<T> slerp1(mathfu::Quaternion<T>::Slerp(qaa1, qaa2, 0.5));
-  slerp1.ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(.5 * (angle1 + angle2), convertedAngle, precision);
-  mathfu::Quaternion<T> slerp2(mathfu::Quaternion<T>::Slerp(qaa2, qaa3, 0.5));
-  slerp2.ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(.5 * (angle2 + angle3), convertedAngle, precision);
-  mathfu::Quaternion<T> slerp3(mathfu::Quaternion<T>::Slerp(qaa2, qaa2, 0.5));
-  slerp3.ToAngleAxis(&convertedAngle, &convertedAxis);
-  EXPECT_NEAR(angle2, convertedAngle, precision);
-}
-TEST_ALL_F(Mult);
-
-// This will test the dot product of quaternions.
-template <class T>
-void Dot_Test(const T& precision) {
-  mathfu::Vector<T, 3> axis(static_cast<T>(4.3), static_cast<T>(7.6),
-                            static_cast<T>(1.2));
-  axis.Normalize();
-  T angle1 = static_cast<T>(1.2), angle2 = static_cast<T>(angle1 + M_PI / 2.0),
-    angle3 = static_cast<T>(angle1 + M_PI), angle4 = static_cast<T>(0.7);
-  mathfu::Quaternion<T> qaa1(
-      mathfu::Quaternion<T>::FromAngleAxis(angle1, axis));
-  mathfu::Quaternion<T> qaa2(
-      mathfu::Quaternion<T>::FromAngleAxis(angle2, axis));
-  mathfu::Quaternion<T> qaa3(
-      mathfu::Quaternion<T>::FromAngleAxis(angle3, axis));
-  mathfu::Quaternion<T> qaa4(
-      mathfu::Quaternion<T>::FromAngleAxis(angle4, axis));
-
-  // This will verify that Dotting two quaternions works correctly.
-  EXPECT_NEAR(mathfu::Quaternion<T>::DotProduct(qaa1, qaa1), 1.0, precision);
-  EXPECT_NEAR(mathfu::Quaternion<T>::DotProduct(qaa1, qaa2), sqrt(2.0) / 2.0,
-              precision);
-  EXPECT_NEAR(mathfu::Quaternion<T>::DotProduct(qaa1, qaa3), 0.0, precision);
-  // 2 x acos(dot) should be the angle between two quaternions:
-  EXPECT_NEAR(acos(mathfu::Quaternion<T>::DotProduct(qaa1, qaa4)) * 2.0,
-              angle1 - angle4, precision);
-}
-TEST_ALL_F(Dot);
-
-// This will test normalization of quaternions.
-template <class T>
-void Normalize_Test(const T& precision) {
-  mathfu::Quaternion<T> quat_1(static_cast<T>(12), static_cast<T>(0),
-                               static_cast<T>(0), static_cast<T>(0));
-  const mathfu::Quaternion<T> const_quat_1 = quat_1;
-  const mathfu::Quaternion<T> normalized_quat_1 = const_quat_1.Normalized();
-  quat_1.Normalize();
-  mathfu::Quaternion<T> reference_quat_1(static_cast<T>(1), static_cast<T>(0),
-                                         static_cast<T>(0), static_cast<T>(0));
-  EXPECT_NEAR(reference_quat_1[0], quat_1[0], precision);
-  EXPECT_NEAR(reference_quat_1[1], quat_1[1], precision);
-  EXPECT_NEAR(reference_quat_1[2], quat_1[2], precision);
-  EXPECT_NEAR(reference_quat_1[3], quat_1[3], precision);
-  EXPECT_NEAR(reference_quat_1[0], normalized_quat_1[0], precision);
-  EXPECT_NEAR(reference_quat_1[1], normalized_quat_1[1], precision);
-  EXPECT_NEAR(reference_quat_1[2], normalized_quat_1[2], precision);
-  EXPECT_NEAR(reference_quat_1[3], normalized_quat_1[3], precision);
-
-  mathfu::Quaternion<T> quat_2(static_cast<T>(123), static_cast<T>(123),
-                               static_cast<T>(123), static_cast<T>(123));
-  mathfu::Quaternion<T> normalized_quat_2 = quat_2.Normalized();
-  quat_2.Normalize();
-  mathfu::Quaternion<T> reference_quat_2(
-      static_cast<T>(sqrt(.25)), static_cast<T>(sqrt(.25)),
-      static_cast<T>(sqrt(.25)), static_cast<T>(sqrt(.25)));
-  EXPECT_NEAR(reference_quat_2[0], quat_2[0], precision);
-  EXPECT_NEAR(reference_quat_2[1], quat_2[1], precision);
-  EXPECT_NEAR(reference_quat_2[2], quat_2[2], precision);
-  EXPECT_NEAR(reference_quat_2[3], quat_2[3], precision);
-  EXPECT_NEAR(reference_quat_2[0], normalized_quat_2[0], precision);
-  EXPECT_NEAR(reference_quat_2[1], normalized_quat_2[1], precision);
-  EXPECT_NEAR(reference_quat_2[2], normalized_quat_2[2], precision);
-  EXPECT_NEAR(reference_quat_2[3], normalized_quat_2[3], precision);
-}
-TEST_ALL_F(Normalize);
-
-// This will test normalization of quaternions.
-template <class T>
-void RotateFromTo_Test(const T& precision) {
-  mathfu::Vector<T, 3> x_axis = mathfu::Vector<T, 3>(
-      static_cast<T>(1), static_cast<T>(0), static_cast<T>(0));
-  mathfu::Vector<T, 3> y_axis = mathfu::Vector<T, 3>(
-      static_cast<T>(0), static_cast<T>(1), static_cast<T>(0));
-  mathfu::Vector<T, 3> z_axis = mathfu::Vector<T, 3>(
-      static_cast<T>(0), static_cast<T>(0), static_cast<T>(1));
-
-  mathfu::Quaternion<T> x_to_y =
-      mathfu::Quaternion<T>::RotateFromTo(x_axis, y_axis);
-  mathfu::Quaternion<T> y_to_z =
-      mathfu::Quaternion<T>::RotateFromTo(y_axis, z_axis);
-  mathfu::Quaternion<T> z_to_x =
-      mathfu::Quaternion<T>::RotateFromTo(z_axis, x_axis);
-
-  // Check some axis rotations:
-  // By definition, rotateFromTo(v1, v2) * v2 should always equal v2.
-  // if v1 and v2 are 90 degrees apart (as they are in the case of axes)
-  // then applying the same rotation twice should invert the vector.
-  mathfu::Vector<T, 3> x_to_y_result = x_to_y * x_axis;
-  mathfu::Vector<T, 3> x_to_y_twice_result = x_to_y * x_to_y * x_axis;
-  EXPECT_NEAR_VEC3(x_to_y_result, y_axis, precision);
-  EXPECT_NEAR_VEC3(x_to_y_twice_result, -x_axis, precision);
-
-  mathfu::Vector<T, 3> y_to_z_result = y_to_z * y_axis;
-  mathfu::Vector<T, 3> y_to_z_twice_result = y_to_z * y_to_z * y_axis;
-  EXPECT_NEAR_VEC3(y_to_z_result, z_axis, precision);
-  EXPECT_NEAR_VEC3(y_to_z_twice_result, -y_axis, precision);
-
-  mathfu::Vector<T, 3> z_to_x_result = z_to_x * z_axis;
-  mathfu::Vector<T, 3> z_to_x_twice_result = z_to_x * z_to_x * z_axis;
-  EXPECT_NEAR_VEC3(z_to_x_result, x_axis, precision);
-  EXPECT_NEAR_VEC3(z_to_x_twice_result, -z_axis, precision);
-
-  // Try some weirder vectors:
-  mathfu::Vector<T, 3> arbitrary_1 = mathfu::Vector<T, 3>(
-      static_cast<T>(2), static_cast<T>(-5), static_cast<T>(9));
-  mathfu::Vector<T, 3> arbitrary_2 = mathfu::Vector<T, 3>(
-      static_cast<T>(-1), static_cast<T>(3), static_cast<T>(16));
-
-  mathfu::Quaternion<T> arbitrary_to_arbitrary =
-      mathfu::Quaternion<T>::RotateFromTo(arbitrary_1, arbitrary_2);
-
-  mathfu::Vector<T, 3> arbitrary_1_to_2 = arbitrary_to_arbitrary * arbitrary_1;
-  arbitrary_1_to_2.Normalize();
-  mathfu::Vector<T, 3> arbitrary_2_normalized = arbitrary_2.Normalized();
-
-  EXPECT_NEAR_VEC3(arbitrary_1_to_2, arbitrary_2_normalized, precision);
-
-  // Using RotateFromTo on one vector should give us the identity quaternion:
-  mathfu::Quaternion<T> identity =
-      mathfu::Quaternion<T>::RotateFromTo(arbitrary_1, arbitrary_1);
-
-  mathfu::Vector<T, 3> arbitrary_2_identity = identity * arbitrary_2;
-  EXPECT_NEAR_VEC3(arbitrary_2_identity, arbitrary_2, precision);
-
-  // Using RotateFromTo on an inverted vector should give a 180 degree rotation:
-  mathfu::Quaternion<T> reverse =
-      mathfu::Quaternion<T>::RotateFromTo(arbitrary_1, -arbitrary_1);
-
-  // Relaxing the precision slightly, because there are a lot of chained
-  // float operations in here.
-  mathfu::Vector<T, 3> arbitrary_1_reversed = reverse * arbitrary_1;
-  EXPECT_NEAR_VEC3(arbitrary_1_reversed, -arbitrary_1, precision * 2.0);
-}
-TEST_ALL_F(RotateFromTo);
-
-// Test the compilation of basic quaternion operations given in the sample
-// file. This will test interpolating two rotations.
-TEST_F(QuaternionTests, QuaternionSample) {
-  using namespace mathfu;
-  /// @doxysnippetstart Chapter03_Quaternions.md Quaternion_Sample
-  // Use radians for angles
-  Vector<float, 3> angles1(0.66f, 1.3f, 0.76f);
-  Vector<float, 3> angles2(0.85f, 0.33f, 1.6f);
-
-  Quaternion<float> quat1 = Quaternion<float>::FromEulerAngles(angles1);
-  Quaternion<float> quat2 = Quaternion<float>::FromEulerAngles(angles2);
-
-  Quaternion<float> quatSlerp = Quaternion<float>::Slerp(quat1, quat2, 0.5);
-  Vector<float, 3> angleSlerp = quatSlerp.ToEulerAngles();
-  /// @doxysnippetend
-  const float precision = 1e-2f;
-  EXPECT_NEAR(0.93f, angleSlerp[0], precision);
-  EXPECT_NEAR(0.82f, angleSlerp[1], precision);
-  EXPECT_NEAR(1.33f, angleSlerp[2], precision);
-}
-
-// Test that the quaternion identity constants give the identity transform.
-TEST_F(QuaternionTests, IdentityConst) {
-  EXPECT_EQ_QUAT(mathfu::kQuatIdentityf, mathfu::Quaternion<float>::identity);
-  EXPECT_EQ_QUAT(mathfu::kQuatIdentityf,
-                 mathfu::Quaternion<float>(1.0f, 0.0f, 0.0f, 0.0f));
-  EXPECT_EQ(mathfu::kQuatIdentityf.ToEulerAngles(), mathfu::kZeros3f);
-
-  EXPECT_EQ_QUAT(mathfu::kQuatIdentityd, mathfu::Quaternion<double>::identity);
-  EXPECT_EQ_QUAT(mathfu::kQuatIdentityd,
-                 mathfu::Quaternion<double>(1.0, 0.0, 0.0, 0.0));
-  EXPECT_EQ(mathfu::kQuatIdentityd.ToEulerAngles(), mathfu::kZeros3d);
-}
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  printf("%s (%s)\n", argv[0], MATHFU_BUILD_OPTIONS_STRING);
-  return RUN_ALL_TESTS();
-}
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/AndroidManifest.xml
deleted file mode 100644
index 6b0e4f5..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.quaternion_simd_no_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="quaternion_simd_no_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Android.mk
deleted file mode 100644
index a77075b..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=quaternion_simd_no_padding_test
-MATHFU_LIB:=libmathfu_simd_no_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Application.mk
deleted file mode 100644
index 4cdf33f..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=quaternion_simd_no_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/res/values/strings.xml
deleted file mode 100644
index b7c7203..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_no_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">quaternion_simd_no_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/AndroidManifest.xml
deleted file mode 100644
index fcbc69e..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.quaternion_simd_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="quaternion_simd_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Android.mk
deleted file mode 100644
index 79b5f54..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=quaternion_simd_padding_test
-MATHFU_LIB:=libmathfu_simd_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Application.mk
deleted file mode 100644
index fd9be72..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=quaternion_simd_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/res/values/strings.xml
deleted file mode 100644
index 4d5f984..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/quaternion_test/simd_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">quaternion_simd_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/default/AndroidManifest.xml
deleted file mode 100644
index 24fb417..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Android.mk
deleted file mode 100644
index 5182147..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=vector_test
-MATHFU_LIB:=libmathfu
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Application.mk
deleted file mode 100644
index 2c644a6..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/default/res/values/strings.xml
deleted file mode 100644
index 6267e13..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/default/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/AndroidManifest.xml
deleted file mode 100644
index 4da1282..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_no_simd_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_no_simd_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Android.mk
deleted file mode 100644
index 3143cda..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=vector_no_simd_test
-MATHFU_LIB:=libmathfu_no_simd
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Application.mk
deleted file mode 100644
index 1b85978..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_no_simd_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/res/values/strings.xml
deleted file mode 100644
index b0a23fb..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/no_simd/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_no_simd_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/AndroidManifest.xml
deleted file mode 100644
index 27760b5..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_simd_no_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_simd_no_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Android.mk
deleted file mode 100644
index 57d3920..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=vector_simd_no_padding_test
-MATHFU_LIB:=libmathfu_simd_no_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Application.mk
deleted file mode 100644
index a13b45d..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_simd_no_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/res/values/strings.xml
deleted file mode 100644
index f5c3260..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_no_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_simd_no_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/AndroidManifest.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/AndroidManifest.xml
deleted file mode 100644
index 93f9828..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/AndroidManifest.xml
+++ /dev/null
@@ -1,44 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<!-- BEGIN_INCLUDE(manifest) -->
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.fpl.mathfu.vector_simd_padding_test"
-          android:versionCode="1"
-          android:versionName="1.0">
-
-    <!-- This is the platform API where NativeActivity was introduced. -->
-    <uses-sdk android:minSdkVersion="9" />
-
-    <!-- This .apk has no Java code itself, so set hasCode to false. -->
-    <application android:label="@string/app_name" android:hasCode="false">
-
-        <!-- Our activity is the built-in NativeActivity framework class.
-             This will take care of integrating with our NDK code. -->
-        <activity android:name="android.app.NativeActivity"
-                  android:label="@string/app_name"
-                  android:screenOrientation="landscape"
-                  android:configChanges="orientation|keyboardHidden">
-            <!-- Tell NativeActivity the name of the .so -->
-            <meta-data android:name="android.app.lib_name"
-                       android:value="vector_simd_padding_test" />
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest>
-<!-- END_INCLUDE(manifest) -->
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Android.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Android.mk
deleted file mode 100644
index 3f0f75e..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Android.mk
+++ /dev/null
@@ -1,17 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-LOCAL_PATH:=$(call my-dir)/../..
-LOCAL_TEST_NAME:=vector_simd_padding_test
-MATHFU_LIB:=libmathfu_simd_padding
-include $(LOCAL_PATH)/../android_common.mk
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Application.mk b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Application.mk
deleted file mode 100644
index 1efc1c5..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/jni/Application.mk
+++ /dev/null
@@ -1,15 +0,0 @@
-# Copyright 2014 Google Inc. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-include $(NDK_PROJECT_PATH)/../../application_common.mk
-APP_MODULES:=vector_simd_padding_test
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/res/values/strings.xml b/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/res/values/strings.xml
deleted file mode 100644
index ba084f3..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/simd_padding/res/values/strings.xml
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright 2014 Google Inc. All rights reserved.
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-
-          http://www.apache.org/licenses/LICENSE-2.0
-
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
- -->
-<resources>
-    <string name="app_name">vector_simd_padding_test</string>
-</resources>
diff --git a/third_party/mathfu-1.1.0/unit_tests/vector_test/vector_test.cpp b/third_party/mathfu-1.1.0/unit_tests/vector_test/vector_test.cpp
deleted file mode 100644
index b1676f6..0000000
--- a/third_party/mathfu-1.1.0/unit_tests/vector_test/vector_test.cpp
+++ /dev/null
@@ -1,783 +0,0 @@
-/*
-* Copyright 2014 Google Inc. All rights reserved.
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-#include "mathfu/vector.h"
-#include "mathfu/constants.h"
-
-#include "gtest/gtest.h"
-
-#include "precision.h"
-
-#include <sstream>
-#include <string>
-
-class VectorTests : public ::testing::Test {
- protected:
-  virtual void SetUp() {}
-  virtual void TearDown() {}
-};
-
-// This will automatically generate tests for each template parameter.
-#define TEST_ALL_F(MY_TEST)                      \
-  TEST_F(VectorTests, MY_TEST##_float_2) {       \
-    MY_TEST##_Test<float, 2>(FLOAT_PRECISION);   \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_double_2) {      \
-    MY_TEST##_Test<double, 2>(DOUBLE_PRECISION); \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_float_3) {       \
-    MY_TEST##_Test<float, 3>(FLOAT_PRECISION);   \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_double_3) {      \
-    MY_TEST##_Test<double, 3>(DOUBLE_PRECISION); \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_float_4) {       \
-    MY_TEST##_Test<float, 4>(FLOAT_PRECISION);   \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_double_4) {      \
-    MY_TEST##_Test<double, 4>(DOUBLE_PRECISION); \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_float_5) {       \
-    MY_TEST##_Test<float, 5>(FLOAT_PRECISION);   \
-  }                                              \
-  TEST_F(VectorTests, MY_TEST##_double_5) {      \
-    MY_TEST##_Test<double, 5>(DOUBLE_PRECISION); \
-  }
-
-#define TEST_ALL_INTS_F(MY_INT_TEST)                                      \
-  TEST_F(VectorTests, MY_INT_TEST##_2) { MY_INT_TEST##_Test<int, 2>(0); } \
-  TEST_F(VectorTests, MY_INT_TEST##_3) { MY_INT_TEST##_Test<int, 3>(0); } \
-  TEST_F(VectorTests, MY_INT_TEST##_4) { MY_INT_TEST##_Test<int, 4>(0); } \
-  TEST_F(VectorTests, MY_INT_TEST##_5) { MY_INT_TEST##_Test<int, 5>(0); }
-
-// This will automatically generate tests for each scalar template parameter.
-#define TEST_SCALAR_F(MY_TEST)                \
-  TEST_F(VectorTests, MY_TEST##_float) {      \
-    MY_TEST##_Test<float>(FLOAT_PRECISION);   \
-  }                                           \
-  TEST_F(VectorTests, MY_TEST##_double) {     \
-    MY_TEST##_Test<double>(DOUBLE_PRECISION); \
-  }
-
-// This will automatically generate tests for each scalar template parameter.
-#define TEST_SCALAR_AND_INT_F(MY_TEST)        \
-  TEST_F(VectorTests, MY_TEST##_float) {      \
-    MY_TEST##_Test<float>(FLOAT_PRECISION);   \
-  }                                           \
-  TEST_F(VectorTests, MY_TEST##_double) {     \
-    MY_TEST##_Test<double>(DOUBLE_PRECISION); \
-  }                                           \
-  TEST_F(VectorTests, MY_TEST##_int) { MY_TEST##_Test<int>(0); }
-
-// Tests float, double, and integer constants in one line.
-#define VECTOR_TEST_CONSTANT_EQ(kConst, index, value)                       \
-  EXPECT_FLOAT_EQ(mathfu::kConst##f[(index)], static_cast<float>(value));   \
-  EXPECT_DOUBLE_EQ(mathfu::kConst##d[(index)], static_cast<double>(value)); \
-  EXPECT_EQ(mathfu::kConst##i[(index)], static_cast<int>(value))
-
-template <class T, int d>
-std::string FormatVector(const char* expr, const mathfu::Vector<T, d>& v) {
-  std::string ret(expr);
-  ret += "(";
-  for (int32_t i = 0; i < d; ++i) {
-    std::stringstream ss;
-    ss << v[i];
-    ret += ss.str();
-    if (i != d - 1) ret += ", ";
-  }
-  ret += ")";
-  return ret;
-}
-
-// A predicate-formatter for asserting that compares 2 vectors are equal.
-template <class T, int d>
-::testing::AssertionResult AssertVectorEqual(const char* m_expr,
-                                             const char* n_expr,
-                                             const mathfu::Vector<T, d>& v1,
-                                             const mathfu::Vector<T, d>& v2) {
-  for (int32_t i = 0; i < d; ++i) {
-    if (v1[i] != v2[i]) {
-      return ::testing::AssertionFailure()
-             << FormatVector(m_expr, v1) << " and " << FormatVector(n_expr, v2)
-             << " are not same value.";
-    }
-  }
-
-  return ::testing::AssertionSuccess();
-}
-
-// A predicate-formatter for asserting that compares 2 vectors are nealy equal
-// with an error of abs_error.
-template <class T, int d>
-::testing::AssertionResult AssertVectorNear(const char* expr1,
-                                            const char* expr2,
-                                            const char* abs_error_expr,
-                                            const mathfu::Vector<T, d>& v1,
-                                            const mathfu::Vector<T, d>& v2,
-                                            const T abs_error) {
-  T diff;
-  for (int32_t i = 0; i < d; ++i) {
-    diff = fabs(v1[i] - v2[i]);
-    if (diff > abs_error) {
-      return ::testing::AssertionFailure()
-             << "The difference between " << FormatVector(expr1, v1) << " and "
-             << FormatVector(expr2, v2) << " is " << diff << ", which exceeds "
-             << abs_error_expr;
-    }
-  }
-
-  return ::testing::AssertionSuccess();
-}
-
-// This will test initialization by passing in values. The template parameter d
-// corresponds to the size of the vector.
-template <class T, int d>
-void Initialization_Test(const T& precision) {
-  // This will test initialization of the vector using a random single value.
-  // The expected result is that all entries equal the given value.
-  mathfu::Vector<T, d> vector_splat(static_cast<T>(3.1));
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(3.1, vector_splat[i], precision);
-  }
-  T x[d];
-  for (int i = 0; i < d; ++i) {
-    x[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  // This will test initialization of the vector using a c style array of
-  // values.
-  mathfu::Vector<T, d> vector_arr(x);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x[i], vector_arr[i], precision);
-  }
-  // This will test copy constructor making sure that the new matrix equals
-  // the old one.
-  mathfu::Vector<T, d> vector_copy(vector_arr);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x[i], vector_copy[i], precision);
-  }
-  // This will make sure the copy was deep and changing the values of the
-  // copied matrix does not effect the original.
-  vector_copy -= mathfu::Vector<T, d>(1);
-  EXPECT_NE(vector_copy[0], vector_arr[0]);
-
-  // Construct a vector from an integer vector.
-  mathfu::Vector<int, d> integer_vector;
-  for (int i = 0; i < d; ++i) {
-    integer_vector[i] = i;
-  }
-  mathfu::Vector<T, d> other_vector(integer_vector);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_EQ(static_cast<int>(other_vector[i]), integer_vector[i]);
-  }
-}
-TEST_ALL_F(Initialization)
-
-// This will test initialization by specifying all values explicitly.
-template <class T>
-void InitializationPerDimension_Test(const T& precision) {
-  mathfu::Vector<T, 2> f2_vector(static_cast<T>(5.3), static_cast<T>(7.1));
-  EXPECT_NEAR(5.3, f2_vector[0], precision);
-  EXPECT_NEAR(7.1, f2_vector[1], precision);
-  mathfu::Vector<T, 3> f3_vector(static_cast<T>(4.3), static_cast<T>(1.1),
-                                 static_cast<T>(3.2));
-  EXPECT_NEAR(4.3, f3_vector[0], precision);
-  EXPECT_NEAR(1.1, f3_vector[1], precision);
-  EXPECT_NEAR(3.2, f3_vector[2], precision);
-  mathfu::Vector<T, 4> f4_vector(static_cast<T>(2.3), static_cast<T>(4.6),
-                                 static_cast<T>(9.2), static_cast<T>(15.5));
-  EXPECT_NEAR(2.3, f4_vector[0], precision);
-  EXPECT_NEAR(4.6, f4_vector[1], precision);
-  EXPECT_NEAR(9.2, f4_vector[2], precision);
-  EXPECT_NEAR(15.5, f4_vector[3], precision);
-}
-TEST_SCALAR_F(InitializationPerDimension);
-
-// Test initialization from a packed vector.
-template <class T, int d>
-void InitializationPacked_Test(const T& precision) {
-  (void)precision;
-  mathfu::VectorPacked<T, d> packed;
-  for (int i = 0; i < d; ++i) {
-    packed.data[i] = static_cast<T>(i);
-  }
-  mathfu::Vector<T, d> unpacked(packed);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(packed.data[i], unpacked[i], static_cast<T>(0)) << "Element "
-                                                                << i;
-  }
-}
-TEST_ALL_F(InitializationPacked);
-
-// Test vector packing.
-template <class T, int d>
-void PackedSerialization_Test(const T& precision) {
-  (void)precision;
-  mathfu::Vector<T, d> unpacked;
-  for (int i = 0; i < d; ++i) {
-    unpacked[i] = static_cast<T>(i);
-  }
-
-  mathfu::VectorPacked<T, d> packed_construction(unpacked);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(unpacked[i], packed_construction.data[i], static_cast<T>(0))
-        << "Element " << i;
-  }
-
-  mathfu::VectorPacked<T, d> packed_assignment;
-  packed_assignment = unpacked;
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(unpacked[i], packed_assignment.data[i], static_cast<T>(0))
-        << "Element " << i;
-  }
-}
-TEST_ALL_F(PackedSerialization);
-
-// This will test the Addition and Subtraction of vectors. The template
-// parameter d corresponds to the size of the vector.
-template <class T, int d>
-void AddSub_Test(const T& precision) {
-  T x1[d], x2[d];
-  for (int i = 0; i < d; ++i) {
-    x1[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  for (int i = 0; i < d; ++i) {
-    x2[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-  mathfu::Vector<T, d> vector1(x1), vector2(x2);
-  // This will test the negation of a vector and make sure each element is
-  // negated.
-  mathfu::Vector<T, d> neg_vector1(-vector1);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(-x1[i], neg_vector1[i], precision);
-  }
-  // This will test the addition of vectors and make such each element is
-  // equal to the sum of the input values.
-  mathfu::Vector<T, d> sum_vector(vector1 + vector2);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] + x2[i], sum_vector[i], precision);
-  }
-  // This will test the subtraction of vectors and make such each element is
-  // equal to the difference of the input values.
-  mathfu::Vector<T, d> diff_vector(vector1 - vector2);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] - x2[i], diff_vector[i], precision);
-  }
-}
-TEST_ALL_F(AddSub)
-
-// This will test the multiplication of vectors by vectors and scalars. The
-// template parameter d corresponds to the size of the vector.
-template <class T, int d>
-void Mult_Test(const T& precision) {
-  T x1[d], x2[d], scalar(static_cast<T>(1.4));
-  for (int i = 0; i < d; ++i) x1[i] = rand() / static_cast<T>(RAND_MAX);
-  for (int i = 0; i < d; ++i) x2[i] = rand() / static_cast<T>(RAND_MAX);
-  mathfu::Vector<T, d> vector1(x1), vector2(x2);
-  // This will test the Hadamard Product of two vectors and verify that each
-  // element is the product of the input elements.
-  mathfu::Vector<T, d> mult_vec(
-      mathfu::Vector<T, d>::HadamardProduct(vector1, vector2));
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] * x2[i], mult_vec[i], precision);
-  }
-  // This will test multiplication by a scalar and verify that each
-  // element is the input element multiplied by the scalar.
-  mathfu::Vector<T, d> smult_vec1(vector1 * scalar);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] * 1.4, smult_vec1[i], precision);
-  }
-  mathfu::Vector<T, d> smult_vec2(scalar * vector2);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x2[i] * 1.4, smult_vec2[i], precision);
-  }
-  // This will test the dot product of two vectors and verify the result
-  // is mathematically correct.
-  T my_dot = 0;
-  for (int i = 0; i < d; ++i) my_dot += x1[i] * x2[i];
-  T vec_dot = mathfu::Vector<T, d>::DotProduct(vector1, vector2);
-  EXPECT_NEAR(my_dot, vec_dot, precision);
-}
-TEST_ALL_F(Mult)
-
-// This will test the division of vectors by vectors and scalars.  The template
-// parameter d coorresponds to the size of the vector.
-template <class T, int d>
-void Division_Test(const T& precision) {
-  T x1[d], x2[d], scalar(static_cast<T>(1.4));
-  for (int i = 0; i < d; ++i) x1[i] = (rand() / static_cast<T>(RAND_MAX)) + 1;
-  for (int i = 0; i < d; ++i) x2[i] = (rand() / static_cast<T>(RAND_MAX)) + 1;
-  mathfu::Vector<T, d> vector1(x1), vector2(x2);
-  // Test vector division.
-  mathfu::Vector<T, d> divided_component_wise(vector1 / vector2);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] / x2[i], divided_component_wise[i], precision);
-  }
-  // Test division by a scalar.
-  mathfu::Vector<T, d> divided_by_scalar(vector1 / scalar);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x1[i] / scalar, divided_by_scalar[i], precision);
-  }
-}
-TEST_ALL_F(Division)
-
-// This will test normalizing a vector. The template parameter d corresponds to
-// the size of the vector.
-template <class T, int d>
-void Norm_Test(const T& precision) {
-  T x[d];
-  for (int i = 0; i < d; ++i) x[i] = rand() / static_cast<T>(RAND_MAX);
-  mathfu::Vector<T, d> vector(x);
-  vector.Normalize();
-  // This will verify that the dot product is 1.
-  T dot = mathfu::Vector<T, d>::DotProduct(vector, vector);
-  EXPECT_NEAR(dot, 1, precision);
-}
-TEST_ALL_F(Norm)
-
-// This will test the cross product of two vectors.
-template <class T>
-void Cross_Test(const T& precision) {
-  mathfu::Vector<T, 3> f1_vector(static_cast<T>(1.1), static_cast<T>(4.5),
-                                 static_cast<T>(9.8));
-  mathfu::Vector<T, 3> f2_vector(-static_cast<T>(1.4), static_cast<T>(9.5),
-                                 static_cast<T>(3.2));
-  f1_vector.Normalize();
-  f2_vector.Normalize();
-  mathfu::Vector<T, 3> fcross_vector(
-      mathfu::Vector<T, 3>::CrossProduct(f1_vector, f2_vector));
-  // This will verify that v1*(v1xv2) and v2*(v1xv2) are 0.
-  T f1_dot = mathfu::Vector<T, 3>::DotProduct(fcross_vector, f1_vector);
-  T f2_dot = mathfu::Vector<T, 3>::DotProduct(fcross_vector, f2_vector);
-  EXPECT_NEAR(f1_dot, 0, precision * 10);
-  EXPECT_NEAR(f2_dot, 0, precision * 10);
-}
-TEST_SCALAR_F(Cross)
-
-// Create a vector with random values between 0~1.
-template <class T, int d>
-mathfu::Vector<T, d> RandomVector() {
-  T x[d];
-  for (int i = 0; i < d; ++i) {
-    x[i] = rand() / static_cast<T>(RAND_MAX);
-  }
-  return mathfu::Vector<T, d>(x);
-}
-
-// This will test an equal lerp of two vectors gives their average.
-template <class T, int d>
-void LerpHalf_Test(const T& precision) {
-  mathfu::Vector<T, d> vector1(RandomVector<T, d>());
-  mathfu::Vector<T, d> vector2(RandomVector<T, d>());
-  mathfu::Vector<T, d> flerp_vector(
-      mathfu::Vector<T, d>::Lerp(vector1, vector2, static_cast<T>(0.5)));
-  // This will verify f1_vector.x + f2_vector.x == 2 * flerp_vector
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(vector1[i] + vector2[i], static_cast<T>(2.0) * flerp_vector[i],
-                precision * 10);
-  }
-}
-TEST_ALL_F(LerpHalf)
-
-// This will test that lerp with weight 0 returns the first vector.
-template <class T, int d>
-void Lerp0_Test(const T& precision) {
-  mathfu::Vector<T, d> vector1(RandomVector<T, d>());
-  mathfu::Vector<T, d> vector2(RandomVector<T, d>());
-  mathfu::Vector<T, d> flerp_vector(
-      mathfu::Vector<T, d>::Lerp(vector1, vector2, static_cast<T>(0.0)));
-  // This will verify f1_vector.x + f2_vector.x == 2 * flerp_vector
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(vector1[i], flerp_vector[i], precision * 10);
-  }
-}
-TEST_ALL_F(Lerp0)
-
-// This will test that lerp with weight 1 returns the second vector.
-template <class T, int d>
-void Lerp1_Test(const T& precision) {
-  mathfu::Vector<T, d> vector1(RandomVector<T, d>());
-  mathfu::Vector<T, d> vector2(RandomVector<T, d>());
-  mathfu::Vector<T, d> flerp_vector(
-      mathfu::Vector<T, d>::Lerp(vector1, vector2, static_cast<T>(1.0)));
-  // This will verify f1_vector.x + f2_vector.x == 2 * flerp_vector
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(vector2[i], flerp_vector[i], precision * 10);
-  }
-}
-TEST_ALL_F(Lerp1)
-
-// This will test initialization by specifying all values explicitly.
-template <class T>
-void Clamp_Test() {
-  const T min = static_cast<T>(-1);
-  const T max = static_cast<T>(8);
-  const T inside = static_cast<T>(7);
-  const T above = static_cast<T>(9);
-  const T below = static_cast<T>(-11);
-
-  EXPECT_EQ(mathfu::Clamp<T>(inside, min, max), inside);
-  EXPECT_EQ(mathfu::Clamp<T>(above, min, max), max);
-  EXPECT_EQ(mathfu::Clamp<T>(below, min, max), min);
-  EXPECT_EQ(mathfu::Clamp<T>(max, min, max), max);
-  EXPECT_EQ(mathfu::Clamp<T>(min, min, max), min);
-}
-TEST_F(VectorTests, Clamp) {
-  Clamp_Test<float>();
-  Clamp_Test<double>();
-  Clamp_Test<int>();
-}
-
-// Tests for int/float/double based lerp.  (i. e. not part of a vector)
-template <class T>
-void Numeric_Lerp_Test(const T& precision) {
-  const T zero = static_cast<T>(0);
-  const T one = static_cast<T>(1);
-
-  const T a = static_cast<T>(10);
-  const T b = static_cast<T>(20);
-  const T midpoint = static_cast<T>(0.5);
-  const T two_fifths = static_cast<T>(0.4);
-  const T seven_tenths = static_cast<T>(0.7);
-  const T midpoint_result = static_cast<T>(15);
-  const T two_fifths_result = static_cast<T>(14);
-  const T seven_tenths_result = static_cast<T>(17);
-
-  EXPECT_EQ(mathfu::Lerp<T>(a, b, zero), a);
-  EXPECT_EQ(mathfu::Lerp<T>(a, b, one), b);
-  EXPECT_EQ(mathfu::Lerp<T>(-a, b, zero), -a);
-  EXPECT_EQ(mathfu::Lerp<T>(-a, b, one), b);
-  EXPECT_EQ(mathfu::Lerp<T>(a, -b, zero), a);
-  EXPECT_EQ(mathfu::Lerp<T>(a, -b, one), -b);
-  EXPECT_EQ(mathfu::Lerp<T>(-a, -b, zero), -a);
-  EXPECT_EQ(mathfu::Lerp<T>(-a, -b, one), -b);
-
-  EXPECT_NE(mathfu::Lerp<T>(a, b, midpoint), a);
-
-  EXPECT_NEAR(mathfu::Lerp<T>(a, b, midpoint), midpoint_result, precision);
-  EXPECT_NEAR(mathfu::Lerp<T>(a, b, two_fifths), two_fifths_result, precision);
-  EXPECT_NEAR(mathfu::Lerp<T>(a, b, seven_tenths), seven_tenths_result,
-              precision);
-}
-TEST_SCALAR_F(Numeric_Lerp)
-
-// Tests the random-in-range function for vectors.
-// Given a pair of vectors, it should return a third vector whose elements
-// are bounded by the corresponding elements in the argument vectors.
-template <class T, int d>
-void Vector_RandomInRange_Test(const T& precision) {
-  (void)precision;
-  mathfu::Vector<T, d> min, max, result1, result2;
-
-  for (int count = 0; count < 100; count++) {
-    for (int i = 0; i < d; i++) {
-      min[i] = -i - 10;
-      max[i] = i * 2 + 2;
-    }
-    result1 = mathfu::Vector<T, d>::RandomInRange(min, max);
-    result2 = mathfu::Vector<T, d>::RandomInRange(max, min);
-    for (int i = 0; i < d; i++) {
-      EXPECT_GE(result1[i], min[i]);
-      EXPECT_LE(result1[i], max[i]);
-
-      EXPECT_GE(result2[i], min[i]);
-      EXPECT_LE(result2[i], max[i]);
-    }
-  }
-}
-TEST_ALL_INTS_F(Vector_RandomInRange)
-
-// Tests the generic Random in Range function in Mathfu.
-template <class T>
-void RandomInRange_Test(const T& precision) {
-  (void)precision;
-  for (int count = 0; count < 100; count++) {
-    T result = mathfu::RandomInRange(static_cast<T>(0), static_cast<T>(100));
-    EXPECT_GE(result, 0);
-    EXPECT_LT(result, 100);
-  }
-  for (int count = 0; count < 100; count++) {
-    T result = mathfu::RandomInRange(static_cast<T>(-100), static_cast<T>(0));
-    EXPECT_GE(result, -100);
-    EXPECT_LE(result, 0);
-  }
-  EXPECT_EQ(0, mathfu::RandomInRange(0, 0));
-  EXPECT_EQ(-5, mathfu::RandomInRange(-5, -5));
-  EXPECT_EQ(23, mathfu::RandomInRange(23, 23));
-}
-TEST_SCALAR_AND_INT_F(RandomInRange)
-
-// This will test initialization by passing in values. The template parameter d
-// corresponds to the size of the vector.
-template <class T, int d>
-void Accessor_Test(const T& precision) {
-  (void)precision;
-  T x[d];
-  for (int i = 0; i < d; ++i) {
-    x[i] = rand() / static_cast<T>(RAND_MAX) * 100.f;
-  }
-
-  mathfu::Vector<T, d> vector(x);
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x[i], vector[i], static_cast<T>(0));
-  }
-  for (int i = 0; i < d; ++i) {
-    EXPECT_NEAR(x[i], vector(i), static_cast<T>(0));
-  }
-}
-TEST_ALL_F(Accessor)
-
-// This will test initialization by passing in values. The template parameter d
-// corresponds to the size of the vector.
-template <class T, int d>
-void Max_Test(const T& precision) {
-  (void)precision;
-  T value1[] = {0, 0, 0, 0, 0};
-  T value2[] = {1, 2, 3, 4, 5};
-  mathfu::Vector<T, d> v1(value1);
-  mathfu::Vector<T, d> v2(value2);
-
-  // vs. zero vector.
-  mathfu::Vector<T, d> v3 = mathfu::Vector<T, d>::Max(v1, v2);
-
-  // Comparing to {1, 2, 3, 4, 5}
-  mathfu::Vector<T, d> r1(value2);
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v3, r1);
-
-  // inverse vs. zero vector.
-  mathfu::Vector<T, d> v4 = mathfu::Vector<T, d>::Max(v2, v1);
-
-  // Comparing to {1, 2, 3, 4, 5}
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v4, r1);
-
-  // vs. negative vector.
-  T negative_value[] = {-1, -2, -3, -4, -5};
-  v2 = mathfu::Vector<T, d>(negative_value);
-  mathfu::Vector<T, d> v5 = mathfu::Vector<T, d>::Max(v1, v2);
-
-  // Comparing to {0, 0, 0, 0, 0}
-  mathfu::Vector<T, d> r2(value1);
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v5, r2);
-
-  // vs. interleaving 2 vectors.
-  T value3[] = {0, 2, 0, 4, 0};
-  T value4[] = {1, 0, 3, 0, 5};
-  v1 = mathfu::Vector<T, d>(value3);
-  v2 = mathfu::Vector<T, d>(value4);
-  mathfu::Vector<T, d> v6 = mathfu::Vector<T, d>::Max(v1, v2);
-
-  // Comparing to {1, 2, 3, 4, 5}
-  mathfu::Vector<T, d> r3(value2);
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v6, r3);
-}
-TEST_ALL_F(Max)
-
-// This will test initialization by passing in values. The template parameter d
-// corresponds to the size of the vector.
-template <class T, int d>
-void Min_Test(const T& precision) {
-  (void)precision;
-  T value1[] = {0, 0, 0, 0, 0};
-  T value2[] = {1, 2, 3, 4, 5};
-  mathfu::Vector<T, d> v1(value1);
-  mathfu::Vector<T, d> v2(value2);
-
-  // vs. zero vector.
-  mathfu::Vector<T, d> v3 = mathfu::Vector<T, d>::Min(v1, v2);
-
-  // Comparing to {0, 0, 0, 0, 0}
-  mathfu::Vector<T, d> r1(value1);
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v3, r1);
-
-  // inverse vs. zero vector.
-  mathfu::Vector<T, d> v4 = mathfu::Vector<T, d>::Min(v2, v1);
-
-  // Comparing to {0, 0, 0, 0, 0}
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v4, r1);
-
-  // vs. negative vector.
-  T negative_value[] = {-1, -2, -3, -4, -5};
-  v2 = mathfu::Vector<T, d>(negative_value);
-  mathfu::Vector<T, d> v5 = mathfu::Vector<T, d>::Min(v1, v2);
-
-  // Comparing to {-1, -2, -3, -4, -5}
-  mathfu::Vector<T, d> r2(negative_value);
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v5, r2);
-
-  // vs. interleaving 2 vectors.
-  T value3[] = {0, 2, 0, 4, 0};
-  T value4[] = {1, 0, 3, 0, 5};
-  v1 = mathfu::Vector<T, d>(value3);
-  v2 = mathfu::Vector<T, d>(value4);
-  mathfu::Vector<T, d> v6 = mathfu::Vector<T, d>::Min(v1, v2);
-
-  // Comparing to {0, 0, 0, 0, 0}
-  EXPECT_PRED_FORMAT2(AssertVectorEqual, v6, r1);
-}
-TEST_ALL_F(Min)
-
-// Tests the RoundUpToPowerOf2 function for vectors.
-// Given a vector, it should return a vector whose elements are rounded up to
-// the nearest power of 2.
-template <class T, int d>
-void Vector_RoundUpToPowerOf2_Test(const T& precision) {
-  (void)precision;
-  mathfu::Vector<T, d> powof2, result;
-
-  for (int count = 0; count < 1024; count++) {
-    for (int i = 0; i < d; i++) {
-      powof2[i] = static_cast<T>(count);
-    }
-    result = mathfu::RoundUpToPowerOf2(powof2);
-    T expected = static_cast<T>(mathfu::RoundUpToPowerOf2(count));
-    for (int i = 0; i < d; i++) {
-      EXPECT_EQ(result[i], expected);
-    }
-  }
-}
-TEST_ALL_INTS_F(Vector_RoundUpToPowerOf2)
-TEST_ALL_F(Vector_RoundUpToPowerOf2)
-
-// Test the compilation of basic vector opertations given in the sample file.
-// This will test creation of two vectors and computing their cross product.
-TEST_F(VectorTests, SampleTest) {
-  using namespace mathfu;
-  /// @doxysnippetstart Chapter02_Vectors.md Vector_Sample
-  Vector<float, 3> point1(0.5f, 0.4f, 0.1f);
-  Vector<float, 3> point2(0.4f, 0.9f, 0.1f);
-  Vector<float, 3> point3(0.1f, 0.8f, 0.6f);
-
-  Vector<float, 3> vector1 = point2 - point1;
-  Vector<float, 3> vector2 = point3 - point1;
-
-  Vector<float, 3> normal = Vector<float, 3>::CrossProduct(vector2, vector1);
-  /// @doxysnippetend
-  const float precision = 1e-2f;
-  EXPECT_NEAR(-0.25f, normal[0], precision);
-  EXPECT_NEAR(-0.05f, normal[1], precision);
-  EXPECT_NEAR(-0.16f, normal[2], precision);
-}
-
-// This will test that the constants have the correct values.
-TEST_F(VectorTests, ConstantTest) {
-  // Check values of various kinds of Vector2s.
-  for (int i = 0; i < 2; ++i) {
-    VECTOR_TEST_CONSTANT_EQ(kZeros2, i, 0);
-    VECTOR_TEST_CONSTANT_EQ(kOnes2, i, 1);
-    VECTOR_TEST_CONSTANT_EQ(kAxisX2, i, i == 0 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisY2, i, i == 1 ? 1 : 0);
-  }
-
-  // Check values of various kinds of Vector3s.
-  for (int i = 0; i < 3; ++i) {
-    VECTOR_TEST_CONSTANT_EQ(kZeros3, i, 0);
-    VECTOR_TEST_CONSTANT_EQ(kOnes3, i, 1);
-    VECTOR_TEST_CONSTANT_EQ(kAxisX3, i, i == 0 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisY3, i, i == 1 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisZ3, i, i == 2 ? 1 : 0);
-  }
-
-  // Check values of various kinds of Vector4s.
-  for (int i = 0; i < 4; ++i) {
-    VECTOR_TEST_CONSTANT_EQ(kZeros4, i, 0);
-    VECTOR_TEST_CONSTANT_EQ(kOnes4, i, 1);
-    VECTOR_TEST_CONSTANT_EQ(kAxisX4, i, i == 0 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisY4, i, i == 1 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisZ4, i, i == 2 ? 1 : 0);
-    VECTOR_TEST_CONSTANT_EQ(kAxisW4, i, i == 3 ? 1 : 0);
-  }
-}
-
-// This will test the == vectors operator.
-template <class T, int d>
-void Equal_Test(const T& precision) {
-  mathfu::Vector<T, d> expected;
-  for (int i = 0; i < d; ++i) {
-    expected[i] = static_cast<T>(i * precision);
-  }
-  mathfu::Vector<T, d> copy(expected);
-  EXPECT_TRUE(expected == copy);
-
-  mathfu::Vector<T, d> close(expected - static_cast<T>(1));
-  EXPECT_FALSE(expected == close);
-}
-TEST_ALL_F(Equal);
-TEST_ALL_INTS_F(Equal);
-
-// This will test the != vectors operator.
-template <class T, int d>
-void NotEqual_Test(const T& precision) {
-  mathfu::Vector<T, d> expected;
-  for (int i = 0; i < d; ++i) {
-    expected[i] = static_cast<T>(i * precision);
-  }
-  mathfu::Vector<T, d> copy(expected);
-  EXPECT_FALSE(expected != copy);
-
-  mathfu::Vector<T, d> close(expected - static_cast<T>(1));
-  EXPECT_TRUE(expected != close);
-}
-TEST_ALL_F(NotEqual);
-TEST_ALL_INTS_F(NotEqual);
-
-// Simple class that represents a possible compatible type for a vector.
-// That is, it's just an array of T of length d, so can be loaded and
-// stored from mathfu::Vector<T,d> using ToType() and FromType().
-template <class T, int d>
-struct SimpleVector {
-  T values[d];
-};
-
-// This will test the FromType() conversion functions.
-template <class T, int d>
-void FromType_Test(const T& precision) {
-  SimpleVector<T, d> compatible;
-  for (int i = 0; i < d; ++i) {
-    compatible.values[i] = static_cast<T>(i * precision);
-  }
-
-  const mathfu::Vector<T, d> vector = mathfu::Vector<T, d>::FromType(compatible);
-
-  for (int i = 0; i < d; ++i) {
-    EXPECT_EQ(compatible.values[i], vector[i]);
-  }
-}
-TEST_ALL_F(FromType);
-TEST_ALL_INTS_F(FromType);
-
-// This will test the ToType() conversion functions.
-template <class T, int d>
-void ToType_Test(const T& precision) {
-  typedef SimpleVector<T, d> CompatibleT;
-  typedef mathfu::Vector<T, d> VectorT;
-
-  VectorT vector;
-  for (int i = 0; i < d; ++i) {
-    vector[i] = static_cast<T>(i * precision);
-  }
-
-  const CompatibleT compatible = VectorT::template ToType<CompatibleT>(vector);
-
-  for (int i = 0; i < d; ++i) {
-    EXPECT_EQ(compatible.values[i], vector[i]);
-  }
-}
-TEST_ALL_F(ToType);
-TEST_ALL_INTS_F(ToType);
-
-int main(int argc, char** argv) {
-  ::testing::InitGoogleTest(&argc, argv);
-  printf("%s (%s)\n", argv[0], MATHFU_BUILD_OPTIONS_STRING);
-  return RUN_ALL_TESTS();
-}