Align backslashes for great aesthetics (very important)

Redo test scripts
Test and fix _Generic
2025-12-28 15:44:33 +00:00 · 2025-02-24 17:45:35 -06:00 · 2025-02-23 20:33:06 -06:00 · 2025-02-23 20:33:06 -06:00 · 2024-05-28 09:46:45 -05:00 · 2024-05-28 09:46:22 -05:00
33 changed files with 7681 additions and 3801 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,34 @@
+name: CI
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macOS-latest]
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: TheMrMilchmann/setup-msvc-dev@v2
+      with:
+        arch: x64
+      if: matrix.os == 'windows-latest'
+    - name: Test (Windows, MSVC)
+      run: ./run_test_msvc.bat
+      working-directory: ./test
+      if: matrix.os == 'windows-latest'
+    - name: Test (Windows, clang)
+      run: ./run_test_clang.bat
+      working-directory: ./test
+      if: matrix.os == 'windows-latest'
+    - name: Test (${{ matrix.os }})
+      run: make all
+      working-directory: ./test
+      if: matrix.os != 'windows-latest'
--- a/.gitignore
+++ b/.gitignore
@@ -31,5 +31,4 @@
 *.exe
 *.out
 *.app
-hmm_test
-hmm_test*
+test/build
--- a/.gitmodules
+++ b/.gitmodules
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,10 +0,0 @@
-language: cpp
-compiler:
-  - clang
-  - gcc
-install:
-  - cd test
-  - make
-script:
-  - ./hmm_test_c
-  - ./hmm_test_cpp
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,51 +0,0 @@
-# Quick style guide
-
-* Put braces on a new line
-* Float literals should have digits both before and after the decimal.
-  ```cpp
-  // Good
-  0.0f;
-  0.5f;
-  1.0f;
-  3.14159f;
-  
-  // Bad
-  1.f
-  .0f
-  ```
-* Put macros and return types on a separate line from the function definition:
-  ```cpp
-  HINLINE float
-  HMM_MyFunction()
-  {
-      // ...
-  }
-  ```
-* Explicitly initialize variables to zero:
-  ```cpp
-  HINLINE float
-  HMM_MyFunction()
-  {
-      float MyFloat = 0.0f;
-      hmm_vec3 MyVector = {0};
-  }
-  ```
-* Put parentheses around the returned value:
-  ```cpp
-  HINLINE float
-  HMM_MyFunction()
-  {
-      return (1.0f);
-  }
-  ```
-
-
-# Other notes
-
-* If a new function is defined with different names for different datatypes, also add C++ overloaded versions of the functions. For example, if you have `HMM_LengthVec2(hmm_vec2)` and `HMM_LengthVec3(hmm_vec3)`, also provide `HMM_Length(hmm_vec2)` and `HMM_Length(hmm_vec3)`.
-
-  It is fine for the overloaded versions to call the C versions.
-* Only use operator overloading for analogous operators in C. That means `+` for vector addition is fine, but no using `^` for cross product or `|` for dot product.
-* Try to define functions in the same order as the prototypes.
-* Don't forget that Handmade Math uses column-major order for matrices!
-
--- a/HandmadeMath.h
+++ b/HandmadeMath.h
--- a/116
+++ b/116
@@ -0,0 +1,116 @@
+CC0 1.0 Universal
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator and
+subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for the
+purpose of contributing to a commons of creative, cultural and scientific
+works ("Commons") that the public can reliably and without fear of later
+claims of infringement build upon, modify, incorporate in other works, reuse
+and redistribute as freely as possible in any form whatsoever and for any
+purposes, including without limitation commercial purposes. These owners may
+contribute to the Commons to promote the ideal of a free culture and the
+further production of creative, cultural and scientific works, or to gain
+reputation or greater distribution for their Work in part through the use and
+efforts of others.
+
+For these and/or other purposes and motivations, and without any expectation
+of additional consideration or compensation, the person associating CC0 with a
+Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
+and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
+and publicly distribute the Work under its terms, with knowledge of his or her
+Copyright and Related Rights in the Work and the meaning and intended legal
+effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not limited
+to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display, communicate,
+  and translate a Work;
+
+  ii. moral rights retained by the original author(s) and/or performer(s);
+
+  iii. publicity and privacy rights pertaining to a person's image or likeness
+  depicted in a Work;
+
+  iv. rights protecting against unfair competition in regards to a Work,
+  subject to the limitations in paragraph 4(a), below;
+
+  v. rights protecting the extraction, dissemination, use and reuse of data in
+  a Work;
+
+  vi. database rights (such as those arising under Directive 96/9/EC of the
+  European Parliament and of the Council of 11 March 1996 on the legal
+  protection of databases, and under any national implementation thereof,
+  including any amended or successor version of such directive); and
+
+  vii. other similar, equivalent or corresponding rights throughout the world
+  based on applicable law or treaty, and any national implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention of,
+applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
+unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
+and Related Rights and associated claims and causes of action, whether now
+known or unknown (including existing as well as future claims and causes of
+action), in the Work (i) in all territories worldwide, (ii) for the maximum
+duration provided by applicable law or treaty (including future time
+extensions), (iii) in any current or future medium and for any number of
+copies, and (iv) for any purpose whatsoever, including without limitation
+commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
+the Waiver for the benefit of each member of the public at large and to the
+detriment of Affirmer's heirs and successors, fully intending that such Waiver
+shall not be subject to revocation, rescission, cancellation, termination, or
+any other legal or equitable action to disrupt the quiet enjoyment of the Work
+by the public as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason be
+judged legally invalid or ineffective under applicable law, then the Waiver
+shall be preserved to the maximum extent permitted taking into account
+Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
+is so judged Affirmer hereby grants to each affected person a royalty-free,
+non transferable, non sublicensable, non exclusive, irrevocable and
+unconditional license to exercise Affirmer's Copyright and Related Rights in
+the Work (i) in all territories worldwide, (ii) for the maximum duration
+provided by applicable law or treaty (including future time extensions), (iii)
+in any current or future medium and for any number of copies, and (iv) for any
+purpose whatsoever, including without limitation commercial, advertising or
+promotional purposes (the "License"). The License shall be deemed effective as
+of the date CC0 was applied by Affirmer to the Work. Should any part of the
+License for any reason be judged legally invalid or ineffective under
+applicable law, such partial invalidity or ineffectiveness shall not
+invalidate the remainder of the License, and in such case Affirmer hereby
+affirms that he or she will not (i) exercise any of his or her remaining
+Copyright and Related Rights in the Work or (ii) assert any associated claims
+and causes of action with respect to the Work, in either case contrary to
+Affirmer's express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+  a. No trademark or patent rights held by Affirmer are waived, abandoned,
+  surrendered, licensed or otherwise affected by this document.
+
+  b. Affirmer offers the Work as-is and makes no representations or warranties
+  of any kind concerning the Work, express, implied, statutory or otherwise,
+  including without limitation warranties of title, merchantability, fitness
+  for a particular purpose, non infringement, or the absence of latent or
+  other defects, accuracy, or the present or absence of errors, whether or not
+  discoverable, all to the greatest extent permissible under applicable law.
+
+  c. Affirmer disclaims responsibility for clearing rights of other persons
+  that may apply to the Work or any use thereof, including without limitation
+  any person's Copyright and Related Rights in the Work. Further, Affirmer
+  disclaims responsibility for obtaining any necessary consents, permissions
+  or other rights required for any use of the Work.
+
+  d. Affirmer understands and acknowledges that Creative Commons is not a
+  party to this document and has no duty or obligation with respect to this
+  CC0 or use of the Work.
+
+For more information, please see
+<http://creativecommons.org/publicdomain/zero/1.0/>
--- a/README.md
+++ b/README.md
@@ -1,43 +1,43 @@
-# Handmade-Math
------
+# Handmade Math

-[![Build Status](https://travis-ci.org/StrangeZak/Handmade-Math.svg?branch=master)](https://travis-ci.org/StrangeZak/Handmade-Math)
+A single-file, cross-platform, public domain graphics math library for both C and C++. Supports vectors, matrices, quaternions, and all the utilities you'd expect.

-Single-file cross-platform public domain game math library for C/C++
+To get started, go download [the latest release](https://github.com/HandmadeMath/HandmadeMath/releases).

-_This library is free and will stay free, but if you would like to support development, or you are a company using HandmadeMath, please consider financial support._
+> If you are upgrading to Handmade Math 2.0, save yourself some time and use our [automatic update tool](./update).

-[![Patreon](https://cloud.githubusercontent.com/assets/8225057/5990484/70413560-a9ab-11e4-8942-1a63607c0b00.png)](http://www.patreon.com/strangezak) [![PayPal](https://www.paypalobjects.com/en_US/i/btn/btn_donate_LG.gif)](https://www.paypal.me/zakarystrange)
+Here's what sets Handmade Math apart:
+
+- **A simple single-header library.** Just `#include "HandmadeMath.h"`.
+- **Supports both C and C++.** While libraries like GLM only support C++, Handmade Math supports both C and C++, with convenient overloads wherever possible. For example, C++ codebases get operator overloading, and C11 codebases get `_Generic` versions of common operations.
+- **Supports all graphics APIs.** Handmade Math has left- and right-handed versions of each operation, as well as support for zero-to-one and negative-one-to-one NDC conventions.
+- **Swizzling, sort of.** Handmade Math's vector types use unions to provide several ways of accessing the same underlying data. For example, the components of an `HMM_Vec3` can be accessed as `XYZ`, `RGB`, or `UVW` - or subsets can be accessed like `.XY` and `.YZ`.
+- **Your choice of angle unit.** While Handmade Math uses radians by default, you can configure it to use degrees or [turns](https://www.computerenhance.com/p/turns-are-better-than-radians) instead.


-Version         | Changes        | 
----------------|----------------|
-**1.1.3** | Fixed compile error in C mode
-**1.1.2** | Fixed invalid HMMDEF's in the function definitions
-**1.1.1** | Resolved compiler warnings on gcc and g++
-**1.1**   | Quaternions! |
-**1.0**   | Lots of testing |
-**0.7**   | Added HMM_Vec2, and HMM_Vec4 versions of  HMM_LengthSquared, HMM_Length, and HMM_Normalize.   |
-**0.6**   | Made HMM_Power faster, Fixed possible efficiency problem with HMM_Normalize, RENAMED HMM_LengthSquareRoot to HMM_LengthSquared, RENAMED HMM_RSqrtF to HMM_RSquareRootF, RENAMED HMM_SqrtF to HMM_SquareRootF, REMOVED Inner function (user should use Dot now), REMOVED HMM_FastInverseSquareRoot function declaration |
-**0.5.2**   | Fixed SSE code in HMM_SqrtF and HMM_RSqrtF |
-**0.5.1**   | Fixed HMM_Translate producing row-major matrices, ensured column-major order for matrices throughout |
-**0.5**     | Added scalar operations on vectors and matrices, added += and -= for hmm_mat4, reconciled headers and implementations, tidied up in general |
-**0.4**     | Added SSE Optimized HMM_SqrtF, HMM_RSqrtF, Removed use of C Runtime | 
-**0.3**     | Added +=,-=, *=, /= for hmm_vec2, hmm_vec3, hmm_vec4 | 
-**0.2b**    | Disabled warning C4201 on MSVC, Added 64bit percision on HMM_PI | 
-**0.2a**    | Prefixed Macros | 
-**0.2**     | Updated Documentation, Fixed C Compliance, Prefixed all functions, and added better operator overloading | 
-**0.1**     | Initial Version | 
+## Usage
+
+Simply `#include "HandmadeMath.h"`. All functions are `static inline`, so there is no need for an "implementation" file as with some other single-header libraries.
+
+A few config options are available. See the header comment in [the source](./HandmadeMath.h) for details.

-----
-_This library is free and will stay free, but if you would like to support development, or you are a company using HandmadeMath, please consider financial support._

 ## FAQ

+**What conventions does HMM use, e.g. row vs. column major, handedness, etc.?**
+
+Handmade Math's matrices are column-major, i.e. data is stored by columns, then rows. It also assumes column vectors, i.e. vectors are written vertically and matrix-vector multiplication is `M * V` instead of `V * M`. For more information, see [this issue](https://github.com/HandmadeMath/HandmadeMath/issues/124#issuecomment-775737253).
+
+For other properties, we provide variants for each common convention. Functions that care about handedness have left-handed (`LH`) and right-handed (`RH`) variants. Projection functions have zero-to-one (`ZO`) and negative-one-to-one (`NO`) variants for different NDC conventions.
+
+**What if I don't want the `HMM_` prefix?**
+
+Do a find and replace in the library source.
+
 **What's the license?**

 This library is in the public domain. You can do whatever you want with it.

 **Where can I contact you to ask questions?**

-You can email me at: Zak@Handmade.Network
+Feel free to make GitHub issues for any questions, concerns, or problems you encounter.
--- a/test/HandmadeMath.c
+++ b/test/HandmadeMath.c
@@ -1,4 +1,5 @@
+#ifndef WITHOUT_COVERAGE
+#include "HandmadeTest.h"
+#endif

-#define HANDMADE_MATH_IMPLEMENTATION
-#define HANDMADE_MATH_NO_INLINE
 #include "../HandmadeMath.h"
--- a/test/HandmadeMath.cpp
+++ b/test/HandmadeMath.cpp
@@ -1,5 +1,2 @@
-
-#define HANDMADE_MATH_IMPLEMENTATION
-#define HANDMADE_MATH_CPP_MODE
-#define HANDMADE_MATH_NO_INLINE
-#include "../HandmadeMath.h"
+#include "HandmadeMath.c"
+// C++ compilers complain when compiling a .c file...
--- a/test/HandmadeTest.h
+++ b/test/HandmadeTest.h
@@ -1,80 +1,455 @@
+/*
+  HandmadeTest.h
+
+  This is Handmade Math's test framework. It is fully compatible with both C
+  and C++, although it requires some compiler-specific features.
+
+  To use Handmade Test, you must #define HANDMADE_TEST_IMPLEMENTATION in
+  exactly one C or C++ file that includes the header, like this:
+
+    #define HANDMADE_TEST_IMPLEMENTATION
+    #include "HandmadeTest.h"
+
+  The basic way of creating a test is using the TEST macro, which registers a
+  single test to be run:
+
+    TEST(MyCategory, MyTestName) {
+        // test code, including asserts/expects
+    }
+
+  Handmade Test also provides macros you can use to check the coverage of
+  important parts of your code. Define a coverage case by using the COVERAGE
+  macro outside the function you wish to test, providing both a name and the
+  number of asserts you expect to see covered over the course of your test.
+  Then use the ASSERT_COVERED macro in every part of the function you wish to
+  check coverage on. For example:
+
+    COVERAGE(MyCoverageCase, 3)
+    void MyFunction(int a, int b) {
+        if (a > b) {
+            ASSERT_COVERED(MyCoverageCase);
+            return 10;
+        } else if (a < b) {
+            ASSERT_COVERED(MyCoverageCase);
+            return -10;
+        }
+
+        ASSERT_COVERED(MyCoverageCase);
+        return 0;
+    }
+
+  The main function of your test code should then call hmt_run_all_tests (and
+  optionally hmt_check_all_coverage) and return the result:
+
+    int main() {
+        return hmt_run_all_tests() || hmt_check_all_coverage();
+    }
+
+  =============================================================================
+
+  If Handmade Test's macros are conflicting with existing macros in your
+  project, you may define HMT_SAFE_MACROS before you include HandmadeTest.h.
+  You may then prefix each macro with HMT_. For example, you may use HMT_TEST
+  instead of TEST and HMT_EXPECT_TRUE instead of EXPECT_TRUE.
+
+ */
+
 #ifndef HANDMADETEST_H
 #define HANDMADETEST_H

 #include <float.h>
 #include <stdio.h>
+#include <string.h>

-int hmt_count_tests = 0;
-int hmt_count_failedtests = 0;
-int hmt_count_failures = 0;
+#include "initializer.h"

-#define RESET "\033[0m"
-#define RED   "\033[31m"
-#define GREEN "\033[32m"
+#define HMT_RESET "\033[0m"
+#define HMT_RED   "\033[31m"
+#define HMT_GREEN "\033[32m"

-#define CATEGORY_BEGIN(name) { \
-    int count_categorytests = 0; \
-    int count_categoryfailedtests = 0; \
-    int count_categoryfailures = 0; \
-    printf("\n" #name ":\n");
-#define CATEGORY_END(name) \
-    hmt_count_tests += count_categorytests; \
-    hmt_count_failedtests += count_categoryfailedtests; \
-    hmt_count_failures += count_categoryfailures; \
-    printf("%d/%d tests passed, %d failures\n", count_categorytests - count_categoryfailedtests, count_categorytests, count_categoryfailures); \
-}
+#define HMT_ARRAY_SIZE 1024

-#define TEST_BEGIN(name) { \
-    int count_testfailures = 0; \
-    count_categorytests++; \
-    printf("    " #name ":");
-#define TEST_END() \
-    count_categoryfailures += count_testfailures; \
-    if (count_testfailures > 0) { \
-        count_categoryfailedtests++; \
-        printf("\n"); \
-    } else { \
-        printf(GREEN " [PASS]\n" RESET); \
-    } \
-}
+typedef struct hmt_testresult_struct {
+    int count_cases;
+    int count_failures;
+} hmt_testresult;

-#define CASE_FAIL() \
-    count_testfailures++; \
-    printf("\n      - " RED "[FAIL] (%d) " RESET, __LINE__)
+typedef void (*hmt_test_func)(hmt_testresult*);
+
+typedef struct hmt_test_struct {
+    const char* name;
+    hmt_test_func func;
+} hmt_test;
+
+typedef struct hmt_category_struct {
+    const char* name;
+    int num_tests;
+    hmt_test* tests;
+} hmt_category;
+
+typedef struct hmt_covercase_struct {
+    const char* name;
+    int expected_asserts;
+    int actual_asserts;
+    int* asserted_lines;
+} hmt_covercase;
+
+hmt_category _hmt_new_category(const char* name);
+hmt_test _hmt_new_test(const char* name, hmt_test_func func);
+hmt_covercase _hmt_new_covercase(const char* name, int expected);
+void _hmt_register_test(const char* category, const char* name, hmt_test_func func);
+void _hmt_register_covercase(const char* name, const char* expected_asserts);
+void _hmt_count_cover(const char* name, int line);
+
+#define _HMT_TEST_FUNCNAME(category, name) _hmt_test_ ## category ## _ ## name
+#define _HMT_TEST_FUNCNAME_INIT(category, name) _hmt_test_ ## category ## _ ## name ## _init
+#define _HMT_COVERCASE_FUNCNAME_INIT(name) _hmt_covercase_ ## name ## _init
+
+#define HMT_TEST(category, name) \
+void _HMT_TEST_FUNCNAME(category, name)(hmt_testresult* _result); \
+INITIALIZER(_HMT_TEST_FUNCNAME_INIT(category, name)) { \
+    _hmt_register_test(#category, #name, _HMT_TEST_FUNCNAME(category, name)); \
+} \
+void _HMT_TEST_FUNCNAME(category, name)(hmt_testresult* _result)
+
+#define _HMT_CASE_START() \
+    _result->count_cases++;
+
+#define _HMT_CASE_FAIL() \
+    _result->count_failures++; \
+    printf("\n      - " HMT_RED "[FAIL] (line %d) " HMT_RESET, __LINE__);
+
+#define HMT_COVERAGE(name, num_asserts) \
+INITIALIZER(_HMT_COVERCASE_FUNCNAME_INIT(name)) { \
+    _hmt_register_covercase(#name, #num_asserts); \
+} \
+
+#define HMT_ASSERT_COVERED(name) \
+{ \
+    _hmt_count_cover(#name, __LINE__); \
+} \

 /*
 * Asserts and expects
 */
-#define EXPECT_FLOAT_EQ(_actual, _expected) do { \
+#define HMT_EXPECT_TRUE(_actual) { \
+    _HMT_CASE_START(); \
+    if (!(_actual)) { \
+        _HMT_CASE_FAIL(); \
+        printf("Expected true but got something false"); \
+    } \
+} \
+
+#define HMT_EXPECT_FALSE(_actual) { \
+    _HMT_CASE_START(); \
+    if (_actual) { \
+        _HMT_CASE_FAIL(); \
+        printf("Expected false but got something true"); \
+    } \
+} \
+
+#define HMT_EXPECT_FLOAT_EQ_MSG(_actual, _expected, _msg) { \
+    _HMT_CASE_START(); \
    float actual = (_actual); \
    float diff = actual - (_expected); \
    if (diff < -FLT_EPSILON || FLT_EPSILON < diff) { \
-        CASE_FAIL(); \
-        printf("Expected %f, got %f", (_expected), actual); \
+        _HMT_CASE_FAIL(); \
+        if ((_msg)[0] == 0) { \
+            printf("Expected %f, got %f (error: %.9g)", (_expected), actual, diff); \
+        } else { \
+            printf("%s: Expected %f, got %f (error: %.9g)", (_msg), (_expected), actual, diff); \
+        } \
    } \
-} while (0)
+}
+#define HMT_EXPECT_FLOAT_EQ(_actual, _expected) HMT_EXPECT_FLOAT_EQ_MSG(_actual, _expected, "");

-#define EXPECT_NEAR(_actual, _expected, _epsilon) do { \
+#define HMT_EXPECT_NEAR_MSG(_actual, _expected, _epsilon, _msg) { \
+    _HMT_CASE_START(); \
    float actual = (_actual); \
    float diff = actual - (_expected); \
    if (diff < -(_epsilon) || (_epsilon) < diff) { \
-        CASE_FAIL(); \
-        printf("Expected %f, got %f", (_expected), actual); \
+        _HMT_CASE_FAIL(); \
+        if ((_msg)[0] == 0) { \
+            printf("Expected %f, got %f", (_expected), actual); \
+        } else { \
+            printf("%s: Expected %f, got %f", (_msg), (_expected), actual); \
+        } \
    } \
-} while (0)
+}
+#define HMT_EXPECT_NEAR(_actual, _expected, _epsilon) HMT_EXPECT_NEAR_MSG(_actual, _expected, _epsilon, "");

-#define EXPECT_LT(_actual, _expected) do { \
+#define HMT_EXPECT_LT(_actual, _expected) { \
+    _HMT_CASE_START(); \
    if ((_actual) >= (_expected)) { \
-        CASE_FAIL(); \
+        _HMT_CASE_FAIL(); \
        printf("Expected %f to be less than %f", (_actual), (_expected)); \
    } \
-} while (0)
+} \

-#define EXPECT_GT(_actual, _expected) do { \
+#define HMT_EXPECT_GT(_actual, _expected) { \
+    _HMT_CASE_START(); \
    if ((_actual) <= (_expected)) { \
-        CASE_FAIL(); \
+        _HMT_CASE_FAIL(); \
        printf("Expected %f to be greater than %f", (_actual), (_expected)); \
    } \
-} while (0)
+} \

-#endif
+#ifndef HMT_SAFE_MACROS
+// Friendly defines
+#define TEST(category, name) HMT_TEST(category, name)
+#define COVERAGE(name, expected_asserts) HMT_COVERAGE(name, expected_asserts)
+#define ASSERT_COVERED(name) HMT_ASSERT_COVERED(name)
+#define EXPECT_TRUE(_actual) HMT_EXPECT_TRUE(_actual)
+#define EXPECT_FALSE(_actual) HMT_EXPECT_FALSE(_actual)
+#define EXPECT_FLOAT_EQ(_actual, _expected) HMT_EXPECT_FLOAT_EQ(_actual, _expected)
+#define EXPECT_V4_EQ(_actual, _expected) \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.X, _expected.X, "incorrect X"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Y, _expected.Y, "incorrect Y"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Z, _expected.Z, "incorrect Z"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.W, _expected.W, "incorrect W");
+#define EXPECT_M4_EQ(_actual, _expected) \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[0][0], _expected.Elements[0][0], "incorrect [0][0]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[0][1], _expected.Elements[0][1], "incorrect [0][1]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[0][2], _expected.Elements[0][2], "incorrect [0][2]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[0][3], _expected.Elements[0][3], "incorrect [0][3]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[1][0], _expected.Elements[1][0], "incorrect [1][0]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[1][1], _expected.Elements[1][1], "incorrect [1][1]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[1][2], _expected.Elements[1][2], "incorrect [1][2]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[1][3], _expected.Elements[1][3], "incorrect [1][3]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[2][0], _expected.Elements[2][0], "incorrect [2][0]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[2][1], _expected.Elements[2][1], "incorrect [2][1]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[2][2], _expected.Elements[2][2], "incorrect [2][2]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[2][3], _expected.Elements[2][3], "incorrect [2][3]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[3][0], _expected.Elements[3][0], "incorrect [3][0]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[3][1], _expected.Elements[3][1], "incorrect [3][1]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[3][2], _expected.Elements[3][2], "incorrect [3][2]"); \
+    HMT_EXPECT_FLOAT_EQ_MSG(_actual.Elements[3][3], _expected.Elements[3][3], "incorrect [3][3]");
+#define EXPECT_NEAR(_actual, _expected, _epsilon) HMT_EXPECT_NEAR(_actual, _expected, _epsilon)
+#define EXPECT_M4_NEAR(_actual, _expected, _epsilon) \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[0][0], _expected.Elements[0][0], _epsilon, "incorrect [0][0]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[0][1], _expected.Elements[0][1], _epsilon, "incorrect [0][1]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[0][2], _expected.Elements[0][2], _epsilon, "incorrect [0][2]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[0][3], _expected.Elements[0][3], _epsilon, "incorrect [0][3]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[1][0], _expected.Elements[1][0], _epsilon, "incorrect [1][0]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[1][1], _expected.Elements[1][1], _epsilon, "incorrect [1][1]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[1][2], _expected.Elements[1][2], _epsilon, "incorrect [1][2]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[1][3], _expected.Elements[1][3], _epsilon, "incorrect [1][3]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[2][0], _expected.Elements[2][0], _epsilon, "incorrect [2][0]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[2][1], _expected.Elements[2][1], _epsilon, "incorrect [2][1]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[2][2], _expected.Elements[2][2], _epsilon, "incorrect [2][2]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[2][3], _expected.Elements[2][3], _epsilon, "incorrect [2][3]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[3][0], _expected.Elements[3][0], _epsilon, "incorrect [3][0]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[3][1], _expected.Elements[3][1], _epsilon, "incorrect [3][1]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[3][2], _expected.Elements[3][2], _epsilon, "incorrect [3][2]"); \
+    HMT_EXPECT_NEAR_MSG(_actual.Elements[3][3], _expected.Elements[3][3], _epsilon, "incorrect [3][3]");
+#define EXPECT_LT(_actual, _expected) HMT_EXPECT_LT(_actual, _expected)
+#define EXPECT_GT(_actual, _expected) HMT_EXPECT_GT(_actual, _expected)
+#endif // HMT_SAFE_MACROS
+
+#endif // HANDMADETEST_H
+
+#ifdef HANDMADE_TEST_IMPLEMENTATION
+
+#ifndef HANDMADE_TEST_IMPLEMENTATION_GUARD
+#define HANDMADE_TEST_IMPLEMENTATION_GUARD
+
+int _hmt_num_categories = 0;
+hmt_category* _hmt_categories = 0;
+
+int _hmt_num_covercases = 0;
+hmt_covercase* _hmt_covercases = 0;
+
+int _hmt_num_covererrors = 0;
+
+hmt_category _hmt_new_category(const char* name) {
+    hmt_category cat = {
+        name, // name
+        0, // num_tests
+        (hmt_test*) malloc(HMT_ARRAY_SIZE * sizeof(hmt_test)), // tests
+    };
+
+    return cat;
+}
+
+hmt_test _hmt_new_test(const char* name, hmt_test_func func) {
+    hmt_test test = {
+        name, // name
+        func, // func
+    };
+
+    return test;
+}
+
+hmt_covercase _hmt_new_covercase(const char* name, int expected) {
+    hmt_covercase covercase = {
+        name, // name
+        expected, // expected_asserts
+        0, // actual_asserts
+        (int*) malloc(HMT_ARRAY_SIZE * sizeof(int)), // asserted_lines
+    };
+
+    return covercase;
+}
+
+void _hmt_register_test(const char* category, const char* name, hmt_test_func func) {
+    // initialize categories array if not initialized
+    if (!_hmt_categories) {
+        _hmt_categories = (hmt_category*) malloc(HMT_ARRAY_SIZE * sizeof(hmt_category));
+    }
+
+    // Find the matching category, if possible
+    int cat_index;
+    for (cat_index = 0; cat_index < _hmt_num_categories; cat_index++) {
+        if (strcmp(_hmt_categories[cat_index].name, category) == 0) {
+            break;
+        }
+    }
+
+    // Add a new category if necessary
+    if (cat_index >= _hmt_num_categories) {
+        _hmt_categories[cat_index] = _hmt_new_category(category);
+        _hmt_num_categories++;
+    }
+
+    hmt_category* cat = &_hmt_categories[cat_index];
+
+    // Add the test to the category
+    cat->tests[cat->num_tests] = _hmt_new_test(name, func);
+    cat->num_tests++;
+}
+
+void _hmt_register_covercase(const char* name, const char* expected_asserts) {
+    // initialize cases array if not initialized
+    if (!_hmt_covercases) {
+        _hmt_covercases = (hmt_covercase*) malloc(HMT_ARRAY_SIZE * sizeof(hmt_covercase));
+    }
+
+    // check for existing case with that name, because the macro can run multiple
+    // times in different translation units
+    for (int i = 0; i < _hmt_num_covercases; i++) {
+        if (strcmp(_hmt_covercases[i].name, name) == 0) {
+            return;
+        }
+    }
+
+    _hmt_covercases[_hmt_num_covercases] = _hmt_new_covercase(name, atoi(expected_asserts));
+    _hmt_num_covercases++;
+}
+
+hmt_covercase* _hmt_find_covercase(const char* name) {
+    for (int i = 0; i < _hmt_num_covercases; i++) {
+        if (strcmp(_hmt_covercases[i].name, name) == 0) {
+            return &_hmt_covercases[i];
+        }
+    }
+
+    return 0;
+}
+
+void _hmt_count_cover(const char* name, int line) {
+    hmt_covercase* covercase = _hmt_find_covercase(name);
+    if (covercase == 0) {
+        printf(HMT_RED "ERROR (line %d): Could not find coverage case with name \"%s\".\n" HMT_RESET, line, name);
+        _hmt_num_covererrors++;
+        return;
+    }
+
+    // see if this line has already been covered
+    for (int i = 0; i < covercase->actual_asserts; i++) {
+        if (covercase->asserted_lines[i] == line) {
+            return;
+        }
+    }
+
+    covercase->asserted_lines[covercase->actual_asserts] = line;
+    covercase->actual_asserts++;
+}
+
+int hmt_run_all_tests() {
+    int count_alltests = 0;
+    int count_allfailedtests = 0; // failed test cases
+    int count_allfailures = 0; // failed asserts
+
+    for (int i = 0; i < _hmt_num_categories; i++) {
+        hmt_category cat = _hmt_categories[i];
+        int count_catfailedtests = 0;
+        int count_catfailures = 0;
+
+        printf("\n%s:\n", cat.name);
+
+        for (int j = 0; j < cat.num_tests; j++) {
+            hmt_test test = cat.tests[j];
+
+            printf("    %s:", test.name);
+
+            hmt_testresult result = {
+                0, // count_cases
+                0, // count_failures
+            };
+            test.func(&result);
+
+            count_catfailures += result.count_failures;
+
+            if (result.count_failures > 0) {
+                count_catfailedtests++;
+                printf("\n      " HMT_RED "(%d/%d passed)" HMT_RESET, result.count_cases - result.count_failures, result.count_cases);
+                printf("\n");
+            } else {
+                printf(HMT_GREEN " [PASS] (%d/%d passed) \n" HMT_RESET, result.count_cases - result.count_failures, result.count_cases);
+            }
+        }
+
+        count_alltests += cat.num_tests;
+        count_allfailedtests += count_catfailedtests;
+        count_allfailures += count_catfailures;
+
+        printf("%d/%d tests passed, %d failures\n", cat.num_tests - count_catfailedtests, cat.num_tests, count_catfailures);
+    }
+
+    if (count_allfailedtests > 0) {
+        printf(HMT_RED);
+    } else {
+        printf(HMT_GREEN);
+    }
+    printf("\n%d/%d tests passed overall, %d failures\n" HMT_RESET, count_alltests - count_allfailedtests, count_alltests, count_allfailures);
+
+    printf("\n");
+
+    return (count_allfailedtests > 0);
+}
+
+int hmt_check_all_coverage() {
+    printf("Coverage:\n");
+
+    int count_failures = 0;
+
+    for (int i = 0; i < _hmt_num_covercases; i++) {
+        hmt_covercase covercase = _hmt_covercases[i];
+
+        if (covercase.expected_asserts != covercase.actual_asserts) {
+            count_failures++;
+            printf("%s: " HMT_RED "FAIL (expected %d asserts, got %d)\n" HMT_RESET, covercase.name, covercase.expected_asserts, covercase.actual_asserts);
+        }
+    }
+
+    if (count_failures > 0) {
+        printf("\n");
+        printf(HMT_RED);
+    } else {
+        printf(HMT_GREEN);
+    }
+    printf("%d coverage cases tested, %d failures\n", _hmt_num_covercases, count_failures);
+    printf(HMT_RESET);
+
+    printf("\n");
+
+    if (_hmt_num_covererrors > 0) {
+        printf(HMT_RED "There were %d other coverage errors; scroll up to see them.\n", _hmt_num_covererrors);
+        return 1;
+    }
+
+    return (count_failures > 0);
+}
+
+#endif // HANDMADE_TEST_IMPLEMENTATION_GUARD
+#endif // HANDMADE_TEST_IMPLEMENTATION
--- a/test/Makefile
+++ b/test/Makefile
@@ -1,17 +1,124 @@
-ROOT_DIR = ..
+BUILD_DIR=./build

-CXXFLAGS += -g -Wall -Wextra -pthread -Wno-missing-braces -Wno-missing-field-initializers
+CXXFLAGS+=-g -Wall -Wextra -pthread -Wno-missing-braces -Wno-missing-field-initializers -Wfloat-equal

-all: c cpp
+.PHONY: all all_c all_cpp
+all: all_c all_cpp
+all_c: c99 c99_no_simd c11 c17
+all_cpp: cpp98 cpp98_no_simd cpp03 cpp11 cpp14 cpp17 cpp20

+.PHONY: clean
 clean:
-	rm -f hmm_test_c hmm_test_cpp *.o
+	rm -rf $(BUILD_DIR)

-c: $(ROOT_DIR)/test/HandmadeMath.c test_impl
-	$(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c99 -c $(ROOT_DIR)/test/HandmadeMath.c $(ROOT_DIR)/test/hmm_test.c -lm
-	$(CC) -ohmm_test_c HandmadeMath.o hmm_test.o -lm
+.PHONY: c99
+c99:
+	@echo "\nCompiling as C99"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR)\
+		&& $(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c99 \
+			../HandmadeMath.c ../hmm_test.c \
+			-lm -o hmm_test_c99 \
+		&& ./hmm_test_c99

-cpp: $(ROOT_DIR)/test/HandmadeMath.cpp test_impl
-	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -ohmm_test_cpp $(ROOT_DIR)/test/HandmadeMath.cpp $(ROOT_DIR)/test/hmm_test.cpp
+.PHONY: c99_no_simd
+c99_no_simd:
+	@echo "\nCompiling as C99 (no SIMD)"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c99 \
+			-DHANDMADE_MATH_NO_SIMD \
+			../HandmadeMath.c ../hmm_test.c \
+			-lm -o hmm_test_c99_no_simd \
+		&& ./hmm_test_c99_no_simd

-test_impl: $(ROOT_DIR)/test/hmm_test.cpp $(ROOT_DIR)/test/hmm_test.c
+.PHONY: c11
+c11:
+	@echo "\nCompiling as C11"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR)\
+		&& $(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c11 \
+			../HandmadeMath.c ../hmm_test.c \
+			-lm -o hmm_test_c11 \
+		&& ./hmm_test_c11
+
+.PHONY: c17
+c17:
+	@echo "\nCompiling as C17"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR)\
+		&& $(CC) $(CPPFLAGS) $(CXXFLAGS) -std=c17 \
+			../HandmadeMath.c ../hmm_test.c \
+			-lm -o hmm_test_c17 \
+		&& ./hmm_test_c17
+
+.PHONY: cpp98
+cpp98:
+	@echo "\nCompiling as C++98"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++98 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp98 \
+		&& ./hmm_test_cpp98
+
+.PHONY: cpp98_no_simd
+cpp98_no_simd:
+	@echo "\nCompiling as C++98 (no SIMD)"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++98 \
+			-DHANDMADE_MATH_NO_SIMD \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp98 \
+		&& ./hmm_test_cpp98
+
+.PHONY: cpp03
+cpp03:
+	@echo "\nCompiling as C++03"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++03 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp03 \
+		&& ./hmm_test_cpp03
+
+.PHONY: cpp11
+cpp11:
+	@echo "\nCompiling as C++11"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++11 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp11 \
+		&& ./hmm_test_cpp11
+
+.PHONY: cpp14
+cpp14:
+	@echo "\nCompiling as C++14"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++14 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp14 \
+		&& ./hmm_test_cpp14
+
+.PHONY: cpp17
+cpp17:
+	@echo "\nCompiling as C++17"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++17 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp17 \
+		&& ./hmm_test_cpp17
+
+.PHONY: cpp20
+cpp20:
+	@echo "\nCompiling as C++20"
+	mkdir -p $(BUILD_DIR)
+	cd $(BUILD_DIR) \
+		&& $(CXX) $(CPPFLAGS) $(CXXFLAGS) -std=c++20 \
+			../HandmadeMath.cpp ../hmm_test.cpp \
+			-lm -o hmm_test_cpp20 \
+		&& ./hmm_test_cpp20
--- a/test/README.md
+++ b/test/README.md
@@ -0,0 +1,16 @@
+# Testing
+
+You can compile and run the tests yourself by running:
+
+```
+make
+```
+
+To run a specific test configuration, run one of:
+
+```
+make c
+make c_no_sse
+make cpp
+make cpp_no_sse
+```
--- a/test/categories/Addition.h
+++ b/test/categories/Addition.h
@@ -0,0 +1,347 @@
+#include "../HandmadeTest.h"
+
+TEST(Addition, Vec2)
+{
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
+
+    {
+        HMM_Vec2 result = HMM_AddV2(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Add(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2_1 + v2_2;
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+
+    v2_1 += v2_2;
+    EXPECT_FLOAT_EQ(v2_1.X, 4.0f);
+    EXPECT_FLOAT_EQ(v2_1.Y, 6.0f);
+#endif
+}
+
+TEST(Addition, Vec3)
+{
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    {
+        HMM_Vec3 result = HMM_AddV3(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 7.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Add(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 7.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3_1 + v3_2;
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 7.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+
+    v3_1 += v3_2;
+    EXPECT_FLOAT_EQ(v3_1.X, 5.0f);
+    EXPECT_FLOAT_EQ(v3_1.Y, 7.0f);
+    EXPECT_FLOAT_EQ(v3_1.Z, 9.0f);
+#endif
+}
+
+TEST(Addition, Vec4)
+{
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Vec4 result = HMM_AddV4(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Add(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4_1 + v4_2;
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+
+    v4_1 += v4_2;
+    EXPECT_FLOAT_EQ(v4_1.X, 6.0f);
+    EXPECT_FLOAT_EQ(v4_1.Y, 8.0f);
+    EXPECT_FLOAT_EQ(v4_1.Z, 10.0f);
+    EXPECT_FLOAT_EQ(v4_1.W, 12.0f);
+#endif
+}
+
+TEST(Addition, Mat2)
+{
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_AddM2(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f); 
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat2 result = HMM_Add(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = a + b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 6.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 8.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 10.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 12.0f); 
+    }
+    a += b;
+    EXPECT_FLOAT_EQ(a.Elements[0][0], 6.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][1], 8.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][0], 10.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][1], 12.0f); 
+#endif
+}
+
+TEST(Addition, Mat3) 
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_AddM3(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);   
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat3 result = HMM_Add(a, b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = a + b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 11.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 13.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 15.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 17.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 19.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 23.0f); 
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 25.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 27.0f);   
+    }
+    a += b;
+    EXPECT_FLOAT_EQ(a.Elements[0][0], 11.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][1], 13.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[0][2], 15.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][0], 17.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[1][1], 19.0f);
+    EXPECT_FLOAT_EQ(a.Elements[1][2], 21.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[2][0], 23.0f); 
+    EXPECT_FLOAT_EQ(a.Elements[2][1], 25.0f);
+    EXPECT_FLOAT_EQ(a.Elements[2][2], 27.0f);   
+#endif  
+}
+
+TEST(Addition, Mat4)
+{
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
+
+    // Fill the matrices
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_1.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_2.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Mat4 result = HMM_AddM4(m4_1, m4_2);
+        float Expected = 18.0f;
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], Expected);
+                Expected += 2.0f;
+            }
+        }
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat4 result = HMM_Add(m4_1, m4_2);
+        float Expected = 18.0f;
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], Expected);
+                Expected += 2.0f;
+            }
+        }
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat4 result = m4_1 + m4_2;
+        float Expected = 18.0f;
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], Expected);
+                Expected += 2.0f;
+            }
+        }
+    }
+
+    m4_1 += m4_2;
+    float Expected = 18.0f;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            EXPECT_FLOAT_EQ(m4_1.Elements[Column][Row], Expected);
+            Expected += 2.0f;
+        }
+    }
+#endif
+}
+
+TEST(Addition, Quaternion)
+{
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Quat result = HMM_AddQ(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Add(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Quat result = q1 + q2;
+        EXPECT_FLOAT_EQ(result.X, 6.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+
+    q1 += q2;
+    EXPECT_FLOAT_EQ(q1.X, 6.0f);
+    EXPECT_FLOAT_EQ(q1.Y, 8.0f);
+    EXPECT_FLOAT_EQ(q1.Z, 10.0f);
+    EXPECT_FLOAT_EQ(q1.W, 12.0f);
+#endif
+}
--- a/test/categories/Division.h
+++ b/test/categories/Division.h
@@ -0,0 +1,439 @@
+#include "../HandmadeTest.h"
+
+TEST(Division, Vec2Vec2)
+{
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 3.0f);
+    HMM_Vec2 v2_2 = HMM_V2(2.0f, 4.0f);
+
+    {
+        HMM_Vec2 result = HMM_DivV2(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Div(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2_1 / v2_2;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+    }
+
+    v2_1 /= v2_2;
+    EXPECT_FLOAT_EQ(v2_1.X, 0.5f);
+    EXPECT_FLOAT_EQ(v2_1.Y, 0.75f);
+#endif
+}
+
+TEST(Division, Vec2Scalar)
+{
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
+    float s = 2;
+
+    {
+        HMM_Vec2 result = HMM_DivV2F(v2, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Div(v2, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2 / s;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+    }
+
+    v2 /= s;
+    EXPECT_FLOAT_EQ(v2.X, 0.5f);
+    EXPECT_FLOAT_EQ(v2.Y, 1.0f);
+#endif
+}
+
+TEST(Division, Vec3Vec3)
+{
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 3.0f, 5.0f);
+    HMM_Vec3 v3_2 = HMM_V3(2.0f, 4.0f, 0.5f);
+
+    {
+        HMM_Vec3 result = HMM_DivV3(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Div(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3_1 / v3_2;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+    }
+
+    v3_1 /= v3_2;
+    EXPECT_FLOAT_EQ(v3_1.X, 0.5f);
+    EXPECT_FLOAT_EQ(v3_1.Y, 0.75f);
+    EXPECT_FLOAT_EQ(v3_1.Z, 10.0f);
+#endif
+}
+
+TEST(Division, Vec3Scalar)
+{
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
+    float s = 2;
+
+    {
+        HMM_Vec3 result = HMM_DivV3F(v3, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Div(v3, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3 / s;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+    }
+
+    v3 /= s;
+    EXPECT_FLOAT_EQ(v3.X, 0.5f);
+    EXPECT_FLOAT_EQ(v3.Y, 1.0f);
+    EXPECT_FLOAT_EQ(v3.Z, 1.5f);
+#endif
+}
+
+TEST(Division, Vec4Vec4)
+{
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 3.0f, 5.0f, 1.0f);
+    HMM_Vec4 v4_2 = HMM_V4(2.0f, 4.0f, 0.5f, 4.0f);
+
+    {
+        HMM_Vec4 result = HMM_DivV4(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 0.25f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Div(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 0.25f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4_1 / v4_2;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.75f);
+        EXPECT_FLOAT_EQ(result.Z, 10.0f);
+        EXPECT_FLOAT_EQ(result.W, 0.25f);
+    }
+
+    v4_1 /= v4_2;
+    EXPECT_FLOAT_EQ(v4_1.X, 0.5f);
+    EXPECT_FLOAT_EQ(v4_1.Y, 0.75f);
+    EXPECT_FLOAT_EQ(v4_1.Z, 10.0f);
+    EXPECT_FLOAT_EQ(v4_1.W, 0.25f);
+#endif
+}
+
+TEST(Division, Vec4Scalar)
+{
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    float s = 2;
+
+    {
+        HMM_Vec4 result = HMM_DivV4F(v4, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Div(v4, s);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4 / s;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+
+    v4 /= s;
+    EXPECT_FLOAT_EQ(v4.X, 0.5f);
+    EXPECT_FLOAT_EQ(v4.Y, 1.0f);
+    EXPECT_FLOAT_EQ(v4.Z, 1.5f);
+    EXPECT_FLOAT_EQ(v4.W, 2.0f);
+#endif
+}
+
+TEST(Division, Mat2Scalar) 
+{
+    HMM_Mat2 m = HMM_M2();
+    float s = 0.5f;
+
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column) {
+        for (int Row = 0; Row < 2; ++Row) {
+            m.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_DivM2F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat2 result = HMM_Div(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+#endif
+
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = m / s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 8.0f);
+    }
+#endif
+}
+
+
+TEST(Division, Mat3Scalar) 
+{
+    HMM_Mat3 m = HMM_M3();
+    float s = 0.5f;
+
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column) {
+        for (int Row = 0; Row < 3; ++Row) {
+            m.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_DivM3F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat3 result = HMM_Div(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+#endif
+
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = m / s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 8.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 14.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 16.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 18.0f);
+    }
+#endif
+}
+
+TEST(Division, Mat4Scalar)
+{
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
+    float s = 2;
+
+    // Fill the matrix
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Mat4 result = HMM_DivM4F(m4, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 2.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 3.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 4.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 5.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 5.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 6.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 7.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 7.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 8.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat4 result = HMM_Div(m4, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 2.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 3.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 4.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 5.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 5.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 6.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 7.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 7.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 8.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat4 result = m4 / s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 0.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 1.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 1.5f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 2.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 2.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 3.5f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 4.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 4.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 5.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 5.5f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 6.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 7.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 7.5f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 8.0f);
+    }
+
+    m4 /= s;
+    EXPECT_FLOAT_EQ(m4.Elements[0][0], 0.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][1], 1.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][2], 1.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][3], 2.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][0], 2.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][1], 3.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][2], 3.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][3], 4.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][0], 4.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][1], 5.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][2], 5.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][3], 6.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][0], 6.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][1], 7.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][2], 7.5f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][3], 8.0f);
+#endif
+}
+
+TEST(Division, QuaternionScalar)
+{
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    float f = 2.0f;
+
+    {
+        HMM_Quat result = HMM_DivQF(q, f);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Div(q, f);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Quat result = q / f;
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 1.5f);
+        EXPECT_FLOAT_EQ(result.W, 2.0f);
+    }
+
+    q /= f;
+    EXPECT_FLOAT_EQ(q.X, 0.5f);
+    EXPECT_FLOAT_EQ(q.Y, 1.0f);
+    EXPECT_FLOAT_EQ(q.Z, 1.5f);
+    EXPECT_FLOAT_EQ(q.W, 2.0f);
+#endif
+}
--- a/test/categories/Equality.h
+++ b/test/categories/Equality.h
@@ -0,0 +1,70 @@
+#include "../HandmadeTest.h"
+
+TEST(Equality, Vec2)
+{
+    HMM_Vec2 a = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 b = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 c = HMM_V2(3.0f, 4.0f);
+
+    EXPECT_TRUE(HMM_EqV2(a, b));
+    EXPECT_FALSE(HMM_EqV2(a, c));
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_TRUE(HMM_Eq(a, b));
+    EXPECT_FALSE(HMM_Eq(a, c));
+#endif
+
+#ifdef __cplusplus
+    EXPECT_TRUE(a == b);
+    EXPECT_FALSE(a == c);
+
+    EXPECT_FALSE(a != b);
+    EXPECT_TRUE(a != c);
+#endif
+}
+
+TEST(Equality, Vec3)
+{
+    HMM_Vec3 a = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 b = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 c = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    EXPECT_TRUE(HMM_EqV3(a, b));
+    EXPECT_FALSE(HMM_EqV3(a, c));
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_TRUE(HMM_Eq(a, b));
+    EXPECT_FALSE(HMM_Eq(a, c));
+#endif
+
+#ifdef __cplusplus
+    EXPECT_TRUE(a == b);
+    EXPECT_FALSE(a == c);
+
+    EXPECT_FALSE(a != b);
+    EXPECT_TRUE(a != c);
+#endif
+}
+
+TEST(Equality, Vec4)
+{
+    HMM_Vec4 a = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 b = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 c = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
+
+    EXPECT_TRUE(HMM_EqV4(a, b));
+    EXPECT_FALSE(HMM_EqV4(a, c));
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_TRUE(HMM_Eq(a, b));
+    EXPECT_FALSE(HMM_Eq(a, c));
+#endif
+
+#ifdef __cplusplus
+    EXPECT_TRUE(a == b);
+    EXPECT_FALSE(a == c);
+
+    EXPECT_FALSE(a != b);
+    EXPECT_TRUE(a != c);
+#endif
+}
--- a/test/categories/Initialization.h
+++ b/test/categories/Initialization.h
@@ -0,0 +1,321 @@
+#include "../HandmadeTest.h"
+
+TEST(Initialization, Vectors)
+{
+    //
+    // Test vec2
+    //
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
+
+    EXPECT_FLOAT_EQ(v2.X, 1.0f);
+    EXPECT_FLOAT_EQ(v2.Y, 2.0f);
+    EXPECT_FLOAT_EQ(v2.U, 1.0f);
+    EXPECT_FLOAT_EQ(v2.V, 2.0f);
+    EXPECT_FLOAT_EQ(v2.Left, 1.0f);
+    EXPECT_FLOAT_EQ(v2.Right, 2.0f);
+    EXPECT_FLOAT_EQ(v2.Width, 1.0f);
+    EXPECT_FLOAT_EQ(v2.Height, 2.0f);
+    EXPECT_FLOAT_EQ(v2.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v2.Elements[1], 2.0f);
+#ifdef __cplusplus
+    EXPECT_FLOAT_EQ(v2[0], 1.0f);
+    EXPECT_FLOAT_EQ(v2[1], 2.0f);
+#endif
+
+    //
+    // Test vec3
+    //
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
+
+    EXPECT_FLOAT_EQ(v3.X, 1.0f);
+    EXPECT_FLOAT_EQ(v3.Y, 2.0f);
+    EXPECT_FLOAT_EQ(v3.Z, 3.0f);
+    EXPECT_FLOAT_EQ(v3.U, 1.0f);
+    EXPECT_FLOAT_EQ(v3.V, 2.0f);
+    EXPECT_FLOAT_EQ(v3.W, 3.0f);
+    EXPECT_FLOAT_EQ(v3.R, 1.0f);
+    EXPECT_FLOAT_EQ(v3.G, 2.0f);
+    EXPECT_FLOAT_EQ(v3.B, 3.0f);
+    EXPECT_FLOAT_EQ(v3.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v3.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v3.Elements[2], 3.0f);
+    EXPECT_FLOAT_EQ(v3.XY.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v3.XY.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v3.YZ.Elements[0], 2.0f);
+    EXPECT_FLOAT_EQ(v3.YZ.Elements[1], 3.0f);
+    EXPECT_FLOAT_EQ(v3.UV.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v3.UV.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v3.VW.Elements[0], 2.0f);
+    EXPECT_FLOAT_EQ(v3.VW.Elements[1], 3.0f);
+#ifdef __cplusplus
+    EXPECT_FLOAT_EQ(v3[0], 1.0f);
+    EXPECT_FLOAT_EQ(v3[1], 2.0f);
+    EXPECT_FLOAT_EQ(v3[2], 3.0f);
+#endif
+
+    //
+    // Test vec4
+    //
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4v = HMM_V4V(v3, 4.0f);
+
+    EXPECT_FLOAT_EQ(v4.X, 1.0f);
+    EXPECT_FLOAT_EQ(v4.Y, 2.0f);
+    EXPECT_FLOAT_EQ(v4.Z, 3.0f);
+    EXPECT_FLOAT_EQ(v4.W, 4.0f);
+    EXPECT_FLOAT_EQ(v4.R, 1.0f);
+    EXPECT_FLOAT_EQ(v4.G, 2.0f);
+    EXPECT_FLOAT_EQ(v4.B, 3.0f);
+    EXPECT_FLOAT_EQ(v4.A, 4.0f);
+    EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4.YZ.Elements[0], 2.0f);
+    EXPECT_FLOAT_EQ(v4.YZ.Elements[1], 3.0f);
+    EXPECT_FLOAT_EQ(v4.ZW.Elements[0], 3.0f);
+    EXPECT_FLOAT_EQ(v4.ZW.Elements[1], 4.0f);
+    EXPECT_FLOAT_EQ(v4.XY.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4.XY.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4.XYZ.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4.XYZ.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4.XYZ.Elements[2], 3.0f);
+    EXPECT_FLOAT_EQ(v4.RGB.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4.RGB.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4.RGB.Elements[2], 3.0f);
+#ifdef __cplusplus
+    EXPECT_FLOAT_EQ(v4[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4[2], 3.0f);
+    EXPECT_FLOAT_EQ(v4[3], 4.0f);
+#endif
+
+    EXPECT_FLOAT_EQ(v4v.X, 1.0f);
+    EXPECT_FLOAT_EQ(v4v.Y, 2.0f);
+    EXPECT_FLOAT_EQ(v4v.Z, 3.0f);
+    EXPECT_FLOAT_EQ(v4v.W, 4.0f);
+    EXPECT_FLOAT_EQ(v4v.R, 1.0f);
+    EXPECT_FLOAT_EQ(v4v.G, 2.0f);
+    EXPECT_FLOAT_EQ(v4v.B, 3.0f);
+    EXPECT_FLOAT_EQ(v4v.A, 4.0f);
+    EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4v.YZ.Elements[0], 2.0f);
+    EXPECT_FLOAT_EQ(v4v.YZ.Elements[1], 3.0f);
+    EXPECT_FLOAT_EQ(v4v.ZW.Elements[0], 3.0f);
+    EXPECT_FLOAT_EQ(v4v.ZW.Elements[1], 4.0f);
+    EXPECT_FLOAT_EQ(v4v.XY.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4v.XY.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4v.XYZ.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4v.XYZ.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4v.XYZ.Elements[2], 3.0f);
+    EXPECT_FLOAT_EQ(v4v.RGB.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4v.RGB.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4v.RGB.Elements[2], 3.0f);
+#ifdef __cplusplus
+    EXPECT_FLOAT_EQ(v4v[0], 1.0f);
+    EXPECT_FLOAT_EQ(v4v[1], 2.0f);
+    EXPECT_FLOAT_EQ(v4v[2], 3.0f);
+    EXPECT_FLOAT_EQ(v4v[3], 4.0f);
+#endif
+}
+
+TEST(Initialization, MatrixEmpty)
+{
+    //
+    // Test mat2
+    //
+    HMM_Mat2 m2 = HMM_M2();
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            EXPECT_FLOAT_EQ(m2.Elements[Column][Row], 0.0f);
+#ifdef __cplusplus
+            EXPECT_FLOAT_EQ(m2[Column][Row], 0.0f);
+#endif
+        }
+    }
+
+    //
+    // Test mat3
+    //
+    HMM_Mat3 m3 = HMM_M3();
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            EXPECT_FLOAT_EQ(m3.Elements[Column][Row], 0.0f);
+#ifdef __cplusplus
+            EXPECT_FLOAT_EQ(m3[Column][Row], 0.0f);
+#endif
+        }
+    }
+
+    //
+    // Test mat4
+    //
+    HMM_Mat4 m4 = HMM_M4();
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            EXPECT_FLOAT_EQ(m4.Elements[Column][Row], 0.0f);
+#ifdef __cplusplus
+            EXPECT_FLOAT_EQ(m4[Column][Row], 0.0f);
+#endif
+        }
+    }
+}
+
+TEST(Initialization, MatrixDiagonal)
+{
+    //
+    // Test mat2
+    //
+    HMM_Mat2 m2d = HMM_M2D(1.0f);
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            if (Column == Row) {
+                EXPECT_FLOAT_EQ(m2d.Elements[Column][Row], 1.0f);
+            } else {
+                EXPECT_FLOAT_EQ(m2d.Elements[Column][Row], 0.0f);
+            }
+        }
+    }
+
+    //
+    // Test mat3
+    //
+    HMM_Mat3 m3d = HMM_M3D(1.0f);
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            if (Column == Row) {
+                EXPECT_FLOAT_EQ(m3d.Elements[Column][Row], 1.0f);
+            } else {
+                EXPECT_FLOAT_EQ(m3d.Elements[Column][Row], 0.0f);
+            }
+        }
+    }
+
+    //
+    // Test mat4
+    //
+    HMM_Mat4 m4d = HMM_M4D(1.0f);
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            if (Column == Row) {
+                EXPECT_FLOAT_EQ(m4d.Elements[Column][Row], 1.0f);
+            } else {
+                EXPECT_FLOAT_EQ(m4d.Elements[Column][Row], 0.0f);
+            }
+        }
+    }
+}
+
+TEST(Initialization, Quaternion)
+{
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+
+    EXPECT_FLOAT_EQ(q.X, 1.0f);
+    EXPECT_FLOAT_EQ(q.Y, 2.0f);
+    EXPECT_FLOAT_EQ(q.Z, 3.0f);
+    EXPECT_FLOAT_EQ(q.W, 4.0f);
+
+    EXPECT_FLOAT_EQ(q.Elements[0], 1.0f);
+    EXPECT_FLOAT_EQ(q.Elements[1], 2.0f);
+    EXPECT_FLOAT_EQ(q.Elements[2], 3.0f);
+    EXPECT_FLOAT_EQ(q.Elements[3], 4.0f);
+
+    HMM_Vec4 v = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat qv = HMM_QV4(v);
+
+    EXPECT_FLOAT_EQ(qv.X, 1.0f);
+    EXPECT_FLOAT_EQ(qv.Y, 2.0f);
+    EXPECT_FLOAT_EQ(qv.Z, 3.0f);
+    EXPECT_FLOAT_EQ(qv.W, 4.0f);
+}
+
+#ifdef __cplusplus
+TEST(Initialization, MatrixOverloads)
+{
+    // Operator overloads for matrix columns must allow mutation.
+
+    //
+    // Test mat2
+    //
+    HMM_Mat2 m2 = {0};
+    m2[0][0] = 1.0f;
+    m2[0][1] = 2.0f;
+    m2[1][0] = 3.0f;
+    m2[1][1] = 4.0f;
+    EXPECT_FLOAT_EQ(m2.Elements[0][0], 1.0f);
+    EXPECT_FLOAT_EQ(m2.Elements[0][1], 2.0f);
+    EXPECT_FLOAT_EQ(m2.Elements[1][0], 3.0f);
+    EXPECT_FLOAT_EQ(m2.Elements[1][1], 4.0f);
+
+    //
+    // Test mat3
+    //
+    HMM_Mat3 m3 = {0};
+    m3[0][0] = 1.0f;
+    m3[0][1] = 2.0f;
+    m3[0][2] = 3.0f;
+    m3[1][0] = 4.0f;
+    m3[1][1] = 5.0f;
+    m3[1][2] = 6.0f;
+    m3[2][0] = 7.0f;
+    m3[2][1] = 8.0f;
+    m3[2][2] = 9.0f;
+    EXPECT_FLOAT_EQ(m3.Elements[0][0], 1.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[0][1], 2.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[0][2], 3.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[1][0], 4.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[1][1], 5.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[1][2], 6.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[2][0], 7.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[2][1], 8.0f);
+    EXPECT_FLOAT_EQ(m3.Elements[2][2], 9.0f);
+
+    //
+    // Test mat4
+    //
+    HMM_Mat4 m4 = {0};
+    m4[0][0] = 1.0f;
+    m4[0][1] = 2.0f;
+    m4[0][2] = 3.0f;
+    m4[0][3] = 4.0f;
+    m4[1][0] = 5.0f;
+    m4[1][1] = 6.0f;
+    m4[1][2] = 7.0f;
+    m4[1][3] = 8.0f;
+    m4[2][0] = 9.0f;
+    m4[2][1] = 10.0f;
+    m4[2][2] = 11.0f;
+    m4[2][3] = 12.0f;
+    m4[3][0] = 13.0f;
+    m4[3][1] = 14.0f;
+    m4[3][2] = 15.0f;
+    m4[3][3] = 16.0f;
+    EXPECT_FLOAT_EQ(m4.Elements[0][0], 1.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][1], 2.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][2], 3.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][3], 4.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][0], 5.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][1], 6.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][2], 7.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][3], 8.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][0], 9.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][1], 10.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][2], 11.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][3], 12.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][0], 13.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][1], 14.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][2], 15.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][3], 16.0f);
+}
+#endif
--- a/test/categories/MatrixOps.h
+++ b/test/categories/MatrixOps.h
@@ -0,0 +1,359 @@
+#include "../HandmadeTest.h"
+
+TEST(InvMatrix, Transpose)
+{
+    {
+        HMM_Mat2 Matrix = {
+            1.0f, 3.0f,
+            2.0f, 4.0f,
+        };
+        HMM_Mat2 Expect = {
+            1.0f, 2.0f,
+            3.0f, 4.0f,
+        };
+
+        {
+            HMM_Mat2 result = HMM_TransposeM2(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+        }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+        {
+            HMM_Mat2 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+        }
+#endif
+    }
+
+    {
+        HMM_Mat3 Matrix = {
+            1.0f, 4.0f, 7.0f,
+            2.0f, 5.0f, 8.0f,
+            3.0f, 6.0f, 9.0f,
+        };
+        HMM_Mat3 Expect = {
+            1.0f, 2.0f, 3.0f,
+            4.0f, 5.0f, 6.0f,
+            7.0f, 8.0f, 9.0f
+        };
+
+        {
+            HMM_Mat3 result = HMM_TransposeM3(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+        {
+            HMM_Mat3 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#endif
+    }
+    {
+        HMM_Mat4 Matrix = {
+            1.0f, 5.0f,  9.0f, 13.0f,
+            2.0f, 6.0f, 10.0f, 14.0f, 
+            3.0f, 7.0f, 11.0f, 15.0f,
+            4.0f, 8.0f, 12.0f, 16.0f
+        };
+        HMM_Mat4 Expect = {
+            1.0f, 2.0f, 3.0f, 4.0f,
+            5.0f, 6.0f, 7.0f, 8.0f,
+            9.0f, 10.0f, 11.0f, 12.0f,
+            13.0f, 14.0f, 15.0f, 16.0f,
+        };
+        {
+            HMM_Mat4 result = HMM_TransposeM4(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+        {
+            HMM_Mat4 result = HMM_Transpose(Matrix);
+            EXPECT_FLOAT_EQ(result.Elements[0][0], Expect.Elements[0][0]);
+            EXPECT_FLOAT_EQ(result.Elements[0][1], Expect.Elements[0][1]);
+            EXPECT_FLOAT_EQ(result.Elements[0][2], Expect.Elements[0][2]);
+            EXPECT_FLOAT_EQ(result.Elements[1][0], Expect.Elements[1][0]);
+            EXPECT_FLOAT_EQ(result.Elements[1][1], Expect.Elements[1][1]);
+            EXPECT_FLOAT_EQ(result.Elements[1][2], Expect.Elements[1][2]);
+            EXPECT_FLOAT_EQ(result.Elements[2][0], Expect.Elements[2][0]);
+            EXPECT_FLOAT_EQ(result.Elements[2][1], Expect.Elements[2][1]);
+            EXPECT_FLOAT_EQ(result.Elements[2][2], Expect.Elements[2][2]);
+        }
+#endif
+    }
+
+}
+
+TEST(InvMatrix, InvGeneral)
+{
+    {
+        HMM_Mat4 Matrix = {
+            12.0f, 2.0f, 1.0f, 1.0f,
+            0.0f, 0.0f, 1.0f, 1.0f,
+            0.0f, 1.0f, 5.0f, 1.0f,
+            11.0f, 1.0f, 0.0f, 10.0f
+        };
+
+        HMM_Mat4 Expect = HMM_M4D(1.0);
+        HMM_Mat4 Inverse = HMM_InvGeneralM4(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM4(Matrix);
+        EXPECT_FLOAT_EQ(Det, -80.0f);
+
+        EXPECT_NEAR(Result.Elements[0][0], Expect.Elements[0][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][1], Expect.Elements[0][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][2], Expect.Elements[0][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][3], Expect.Elements[0][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][0], Expect.Elements[1][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][1], Expect.Elements[1][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][2], Expect.Elements[1][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][3], Expect.Elements[1][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][0], Expect.Elements[2][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][1], Expect.Elements[2][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][2], Expect.Elements[2][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][3], Expect.Elements[2][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][0], Expect.Elements[3][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][1], Expect.Elements[3][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][2], Expect.Elements[3][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][3], Expect.Elements[3][3], 0.00001f);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, -80.0f);
+
+        EXPECT_NEAR(Result.Elements[0][0], Expect.Elements[0][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][1], Expect.Elements[0][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][2], Expect.Elements[0][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[0][3], Expect.Elements[0][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][0], Expect.Elements[1][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][1], Expect.Elements[1][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][2], Expect.Elements[1][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[1][3], Expect.Elements[1][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][0], Expect.Elements[2][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][1], Expect.Elements[2][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][2], Expect.Elements[2][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[2][3], Expect.Elements[2][3], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][0], Expect.Elements[3][0], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][1], Expect.Elements[3][1], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][2], Expect.Elements[3][2], 0.00001f);
+        EXPECT_NEAR(Result.Elements[3][3], Expect.Elements[3][3], 0.00001f);
+#endif
+    }
+
+    {
+        HMM_Mat3 Matrix = {
+            12.0f, 2.0f, 1.0f,
+            0.0f, 0.0f, 1.0f,
+            0.0f, 1.0f, 5.0f
+        };
+
+        HMM_Mat3 Expect = HMM_M3D(1.0);
+        HMM_Mat3 Inverse = HMM_InvGeneralM3(Matrix);
+        HMM_Mat3 Result = HMM_MulM3(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM3(Matrix);
+        EXPECT_FLOAT_EQ(Det, -12.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, -12.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], Expect.Elements[0][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], Expect.Elements[1][2]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], Expect.Elements[2][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], Expect.Elements[2][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], Expect.Elements[2][2]);
+#endif
+    }
+
+    {
+        HMM_Mat2 Matrix = {
+            12.0f, 2.0f, 
+             1.0f, 5.0f
+        };
+
+        HMM_Mat2 Expect = HMM_M2D(1.0);
+        HMM_Mat2 Inverse = HMM_InvGeneralM2(Matrix);
+        HMM_Mat2 Result = HMM_MulM2(Matrix, Inverse);
+        
+        float Det = HMM_DeterminantM2(Matrix);
+        EXPECT_FLOAT_EQ(Det, 58.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+
+#ifdef __cplusplus
+        Inverse = HMM_InvGeneral(Matrix);
+        Result = HMM_Mul(Matrix, Inverse);
+        Det = HMM_Determinant(Matrix);
+        EXPECT_FLOAT_EQ(Det, 58.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], Expect.Elements[0][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], Expect.Elements[0][1]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], Expect.Elements[1][0]);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], Expect.Elements[1][1]);
+#endif
+    }    
+}
+
+TEST(InvMatrix, InvOrthographic)
+{
+    {
+        HMM_Mat4 Matrix = HMM_Orthographic_RH_NO(-160+100, 160+100, -90+200, 90+200, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvOrthographic(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Orthographic_RH_ZO(-160+100, 160+100, -90+200, 90+200, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvOrthographic(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Orthographic_LH_NO(-160+100, 160+100, -90+200, 90+200, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvOrthographic(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Orthographic_LH_ZO(-160+100, 160+100, -90+200, 90+200, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvOrthographic(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+}
+
+TEST(InvMatrix, InvPerspective)
+{
+    {
+        HMM_Mat4 Matrix = HMM_Perspective_RH_NO(HMM_AngleDeg(120), 16.0/9.0, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvPerspective_RH(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Perspective_RH_ZO(HMM_AngleDeg(120), 16.0/9.0, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvPerspective_RH(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Perspective_LH_NO(HMM_AngleDeg(120), 16.0/9.0, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvPerspective_LH(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+    {
+        HMM_Mat4 Matrix = HMM_Perspective_LH_ZO(HMM_AngleDeg(120), 16.0/9.0, 10, 10000);
+        HMM_Mat4 Inverse = HMM_InvPerspective_LH(Matrix);
+        EXPECT_M4_EQ(HMM_MulM4(Matrix, Inverse), HMM_M4D(1.0f));
+    }
+}
+
+TEST(InvMatrix, InvLookAt)
+{
+    {
+        HMM_Vec3 Eye = {10.0f, 10.0f, 10.0f};
+        HMM_Vec3 Center = {100.0f, 200.0f, 30.0f};
+        HMM_Vec3 Up = {0.0f, 0.0f, 1.0f};
+        HMM_Mat4 Matrix = HMM_LookAt_RH(Eye, Center, Up);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvLookAt(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        EXPECT_M4_NEAR(Result, Expect, 0.001f);
+    }
+    {
+        HMM_Vec3 Eye = {10.0f, 10.0f, 10.0f};
+        HMM_Vec3 Center = {100.0f, 200.0f, 30.0f};
+        HMM_Vec3 Up = {0.0f, 0.0f, 1.0f};
+        HMM_Mat4 Matrix = HMM_LookAt_LH(Eye, Center, Up);
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvLookAt(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        EXPECT_M4_NEAR(Result, Expect, 0.001f);
+    }
+}
+
+TEST(InvMatrix, InvRotate)
+{
+    {
+        HMM_Vec3 Axis = {1.0f, -1.0f, 0.5f};
+        HMM_Mat4 Matrix = HMM_Rotate_RH(HMM_AngleDeg(30), HMM_NormV3(Axis));
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvRotate(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        EXPECT_M4_NEAR(Result, Expect, 0.001f);
+    }
+    {
+        HMM_Vec3 Axis = {1.0f, -1.0f, 0.5f};
+        HMM_Mat4 Matrix = HMM_Rotate_LH(HMM_AngleDeg(30), HMM_NormV3(Axis));
+        HMM_Mat4 Expect = HMM_M4D(1.0f);
+        HMM_Mat4 Inverse = HMM_InvRotate(Matrix);
+        HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+        EXPECT_M4_NEAR(Result, Expect, 0.001f);
+    }
+}
+
+TEST(InvMatrix, InvScale)
+{
+    HMM_Vec3 Scale  = {1.0f, -1.0f, 0.5f};
+    HMM_Mat4 Matrix = HMM_Scale(Scale);
+    HMM_Mat4 Expect = HMM_M4D(1.0f);
+    HMM_Mat4 Inverse = HMM_InvScale(Matrix);
+    HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+    EXPECT_M4_EQ(Result, Expect);
+}
+
+TEST(InvMatrix, InvTranslate)
+{
+    HMM_Vec3 Move  = {1.0f, -1.0f, 0.5f};
+    HMM_Mat4 Matrix = HMM_Translate(Move);
+    HMM_Mat4 Expect = HMM_M4D(1.0f);
+    HMM_Mat4 Inverse = HMM_InvTranslate(Matrix);
+    HMM_Mat4 Result = HMM_MulM4(Matrix, Inverse);
+    EXPECT_M4_EQ(Result, Expect);
+}
--- a/test/categories/Multiplication.h
+++ b/test/categories/Multiplication.h
@@ -0,0 +1,868 @@
+#include "../HandmadeTest.h"
+
+TEST(Multiplication, Vec2Vec2)
+{
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
+
+    {
+        HMM_Vec2 result = HMM_MulV2(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Mul(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2_1 * v2_2;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 8.0f);
+    }
+
+    v2_1 *= v2_2;
+    EXPECT_FLOAT_EQ(v2_1.X, 3.0f);
+    EXPECT_FLOAT_EQ(v2_1.Y, 8.0f);
+#endif
+}
+
+TEST(Multiplication, Vec2Scalar)
+{
+    HMM_Vec2 v2 = HMM_V2(1.0f, 2.0f);
+    float s = 3.0f;
+
+    {
+        HMM_Vec2 result = HMM_MulV2F(v2, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Mul(v2, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2 * s;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+    {
+        HMM_Vec2 result = s * v2;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    }
+
+    v2 *= s;
+    EXPECT_FLOAT_EQ(v2.X, 3.0f);
+    EXPECT_FLOAT_EQ(v2.Y, 6.0f);
+#endif
+}
+
+TEST(Multiplication, Vec3Vec3)
+{
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    {
+        HMM_Vec3 result = HMM_MulV3(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 10.0f);
+        EXPECT_FLOAT_EQ(result.Z, 18.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Mul(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 10.0f);
+        EXPECT_FLOAT_EQ(result.Z, 18.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3_1 * v3_2;
+        EXPECT_FLOAT_EQ(result.X, 4.0f);
+        EXPECT_FLOAT_EQ(result.Y, 10.0f);
+        EXPECT_FLOAT_EQ(result.Z, 18.0f);
+    }
+
+    v3_1 *= v3_2;
+    EXPECT_FLOAT_EQ(v3_1.X, 4.0f);
+    EXPECT_FLOAT_EQ(v3_1.Y, 10.0f);
+    EXPECT_FLOAT_EQ(v3_1.Z, 18.0f);
+#endif
+}
+
+TEST(Multiplication, Vec3Scalar)
+{
+    HMM_Vec3 v3 = HMM_V3(1.0f, 2.0f, 3.0f);
+    float s = 3.0f;
+
+    {
+        HMM_Vec3 result = HMM_MulV3F(v3, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Mul(v3, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3 * s;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+    {
+        HMM_Vec3 result = s * v3;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+    }
+
+    v3 *= s;
+    EXPECT_FLOAT_EQ(v3.X, 3.0f);
+    EXPECT_FLOAT_EQ(v3.Y, 6.0f);
+    EXPECT_FLOAT_EQ(v3.Z, 9.0f);
+#endif
+}
+
+TEST(Multiplication, Vec4Vec4)
+{
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Vec4 result = HMM_MulV4(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 12.0f);
+        EXPECT_FLOAT_EQ(result.Z, 21.0f);
+        EXPECT_FLOAT_EQ(result.W, 32.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Mul(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 12.0f);
+        EXPECT_FLOAT_EQ(result.Z, 21.0f);
+        EXPECT_FLOAT_EQ(result.W, 32.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4_1 * v4_2;
+        EXPECT_FLOAT_EQ(result.X, 5.0f);
+        EXPECT_FLOAT_EQ(result.Y, 12.0f);
+        EXPECT_FLOAT_EQ(result.Z, 21.0f);
+        EXPECT_FLOAT_EQ(result.W, 32.0f);
+    }
+
+    v4_1 *= v4_2;
+    EXPECT_FLOAT_EQ(v4_1.X, 5.0f);
+    EXPECT_FLOAT_EQ(v4_1.Y, 12.0f);
+    EXPECT_FLOAT_EQ(v4_1.Z, 21.0f);
+    EXPECT_FLOAT_EQ(v4_1.W, 32.0f);
+#endif
+}
+
+TEST(Multiplication, Vec4Scalar)
+{
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    float s = 3.0f;
+
+    {
+        HMM_Vec4 result = HMM_MulV4F(v4, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Mul(v4, s);
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4 * s;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+    {
+        HMM_Vec4 result = s * v4;
+        EXPECT_FLOAT_EQ(result.X, 3.0f);
+        EXPECT_FLOAT_EQ(result.Y, 6.0f);
+        EXPECT_FLOAT_EQ(result.Z, 9.0f);
+        EXPECT_FLOAT_EQ(result.W, 12.0f);
+    }
+
+    v4 *= s;
+    EXPECT_FLOAT_EQ(v4.X, 3.0f);
+    EXPECT_FLOAT_EQ(v4.Y, 6.0f);
+    EXPECT_FLOAT_EQ(v4.Z, 9.0f);
+#endif
+}
+
+TEST(Multiplication, Mat2Mat2) {
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            a.Elements[Column][Row] = counter++;
+        }
+    }
+    
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            b.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_MulM2(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);        
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat2 result = HMM_Mul(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);
+    }
+#endif
+
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = a * b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 34.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 31.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 46.0f);        
+    }
+#endif
+}
+
+TEST(Multiplication, Mat2Scalar) {
+    HMM_Mat2 m = HMM_M2();
+    float s = 10.0f;
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_MulM2F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat2 result = HMM_Mul(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = m * s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+    {
+        HMM_Mat2 result = s * m;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 40.0f);
+    }
+    m *= s;
+    EXPECT_FLOAT_EQ(m.Elements[0][0], 10.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][1], 20.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][0], 30.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][1], 40.0f);
+#endif
+}
+
+TEST(Multiplication, Mat2Vec2) {
+    HMM_Mat2 m = HMM_M2();
+    HMM_Vec2 v = HMM_V2(0.0f, 0.0f);
+
+    int counter = 1;
+    for (int Column = 0; Column < 2; Column++) {
+        for (int Row = 0; Row < 2; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    for (int Row = 0; Row < 2; Row++) {
+        v.Elements[Row] = counter++;
+    }
+
+    {
+        HMM_Vec2 result = HMM_MulM2V2(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Mul(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+#endif
+
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = m * v;
+        EXPECT_FLOAT_EQ(result.Elements[0], 23.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 34.0f);
+    }
+#endif
+}
+ 
+TEST(Multiplication, Mat3Mat3) 
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            a.Elements[Column][Row] = counter++;
+        }
+    }
+    
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            b.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_MulM3(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat3 result = HMM_Mul(a,b);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+#endif
+
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = a * b;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 204.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 174.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 216.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 258.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 210.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 261.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 312.0f);
+    }
+#endif
+}
+
+TEST(Multiplication, Mat3Scalar) {
+    HMM_Mat3 m = HMM_M3();
+    float s = 10.0f;
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_MulM3F(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat3 result = HMM_Mul(m, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat3 result = m * s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+    {
+        HMM_Mat3 result = s * m;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 10.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 20.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 40.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 50.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 60.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 70.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 80.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 90.0f);
+    }
+    m *= s;
+    EXPECT_FLOAT_EQ(m.Elements[0][0], 10.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][1], 20.0f);
+    EXPECT_FLOAT_EQ(m.Elements[0][2], 30.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][0], 40.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][1], 50.0f);
+    EXPECT_FLOAT_EQ(m.Elements[1][2], 60.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][0], 70.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][1], 80.0f);
+    EXPECT_FLOAT_EQ(m.Elements[2][2], 90.0f);
+#endif
+}
+
+TEST(Multiplication, Mat3Vec3) {
+    HMM_Mat3 m = HMM_M3();
+    HMM_Vec3 v = HMM_V3(0.0f, 0.0f, 0.0f);
+
+    int counter = 1;
+    for (int Column = 0; Column < 3; Column++) {
+        for (int Row = 0; Row < 3; Row++) {
+            m.Elements[Column][Row] = counter++;
+        }
+    }
+
+    for (int Row = 0; Row < 3; Row++) {
+        v.Elements[Row] = counter++;
+    }
+
+    {
+        HMM_Vec3 result = HMM_MulM3V3(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Mul(m, v);
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = m * v;
+        EXPECT_FLOAT_EQ(result.Elements[0], 138.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1], 171.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2], 204.0f);
+    }
+#endif
+}
+
+TEST(Multiplication, Mat4Mat4)
+{
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
+
+    // Fill the matrices
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_1.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_2.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Mat4 result = HMM_MulM4(m4_1, m4_2);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 760.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 650.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 740.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 830.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 920.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 762.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 868.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 974.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 1080.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 874.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 996.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 1118.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 1240.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat4 result = HMM_Mul(m4_1, m4_2);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 760.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 650.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 740.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 830.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 920.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 762.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 868.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 974.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 1080.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 874.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 996.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 1118.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 1240.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat4 result = m4_1 * m4_2;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 538.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 612.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 686.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 760.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 650.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 740.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 830.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 920.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 762.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 868.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 974.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 1080.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 874.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 996.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 1118.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 1240.0f);
+    }
+
+    // At the time I wrote this, I intentionally omitted
+    // the *= operator for matrices because matrix
+    // multiplication is not commutative. (bvisness)
+#endif
+}
+
+TEST(Multiplication, Mat4Scalar)
+{
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
+    float s = 3;
+
+    // Fill the matrix
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Mat4 result = HMM_MulM4F(m4, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 15.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 18.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 24.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 27.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 33.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 36.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 39.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 42.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 45.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat4 result = HMM_Mul(m4, s);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 15.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 18.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 24.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 27.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 33.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 36.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 39.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 42.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 45.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat4 result = m4 * s;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 15.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 18.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 24.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 27.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 33.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 36.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 39.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 42.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 45.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
+    }
+    {
+        HMM_Mat4 result = s * m4;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 3.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 6.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+        EXPECT_FLOAT_EQ(result.Elements[0][3], 12.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 15.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 18.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 21.0f);
+        EXPECT_FLOAT_EQ(result.Elements[1][3], 24.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 27.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 30.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 33.0f);
+        EXPECT_FLOAT_EQ(result.Elements[2][3], 36.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][0], 39.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][1], 42.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][2], 45.0f);
+        EXPECT_FLOAT_EQ(result.Elements[3][3], 48.0f);
+    }
+
+    m4 *= s;
+    EXPECT_FLOAT_EQ(m4.Elements[0][0], 3.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][1], 6.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][2], 9.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[0][3], 12.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][0], 15.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][1], 18.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][2], 21.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[1][3], 24.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][0], 27.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][1], 30.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][2], 33.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[2][3], 36.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][0], 39.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][1], 42.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][2], 45.0f);
+    EXPECT_FLOAT_EQ(m4.Elements[3][3], 48.0f);
+#endif
+}
+
+TEST(Multiplication, Mat4Vec4)
+{
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
+    HMM_Vec4 v4 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+
+    // Fill the matrix
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Vec4 result = HMM_MulM4V4(m4, v4);
+        EXPECT_FLOAT_EQ(result.X, 90.0f);
+        EXPECT_FLOAT_EQ(result.Y, 100.0f);
+        EXPECT_FLOAT_EQ(result.Z, 110.0f);
+        EXPECT_FLOAT_EQ(result.W, 120.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Mul(m4, v4);
+        EXPECT_FLOAT_EQ(result.X, 90.0f);
+        EXPECT_FLOAT_EQ(result.Y, 100.0f);
+        EXPECT_FLOAT_EQ(result.Z, 110.0f);
+        EXPECT_FLOAT_EQ(result.W, 120.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = m4 * v4;
+        EXPECT_FLOAT_EQ(result.X, 90.0f);
+        EXPECT_FLOAT_EQ(result.Y, 100.0f);
+        EXPECT_FLOAT_EQ(result.Z, 110.0f);
+        EXPECT_FLOAT_EQ(result.W, 120.0f);
+    }
+
+    // *= makes no sense for this particular case.
+#endif
+}
+
+TEST(Multiplication, QuaternionQuaternion)
+{
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Quat result = HMM_MulQ(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, 24.0f);
+        EXPECT_FLOAT_EQ(result.Y, 48.0f);
+        EXPECT_FLOAT_EQ(result.Z, 48.0f);
+        EXPECT_FLOAT_EQ(result.W, -6.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Mul(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, 24.0f);
+        EXPECT_FLOAT_EQ(result.Y, 48.0f);
+        EXPECT_FLOAT_EQ(result.Z, 48.0f);
+        EXPECT_FLOAT_EQ(result.W, -6.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Quat result = q1 * q2;
+        EXPECT_FLOAT_EQ(result.X, 24.0f);
+        EXPECT_FLOAT_EQ(result.Y, 48.0f);
+        EXPECT_FLOAT_EQ(result.Z, 48.0f);
+        EXPECT_FLOAT_EQ(result.W, -6.0f);
+    }
+
+    // Like with matrices, we're not implementing the *=
+    // operator for quaternions because quaternion multiplication
+    // is not commutative.
+#endif
+}
+
+TEST(Multiplication, QuaternionScalar)
+{
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    float f = 2.0f;
+
+    {
+        HMM_Quat result = HMM_MulQF(q, f);
+        EXPECT_FLOAT_EQ(result.X, 2.0f);
+        EXPECT_FLOAT_EQ(result.Y, 4.0f);
+        EXPECT_FLOAT_EQ(result.Z, 6.0f);
+        EXPECT_FLOAT_EQ(result.W, 8.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Mul(q, f);
+        EXPECT_FLOAT_EQ(result.X, 2.0f);
+        EXPECT_FLOAT_EQ(result.Y, 4.0f);
+        EXPECT_FLOAT_EQ(result.Z, 6.0f);
+        EXPECT_FLOAT_EQ(result.W, 8.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Quat result = q * f;
+        EXPECT_FLOAT_EQ(result.X, 2.0f);
+        EXPECT_FLOAT_EQ(result.Y, 4.0f);
+        EXPECT_FLOAT_EQ(result.Z, 6.0f);
+        EXPECT_FLOAT_EQ(result.W, 8.0f);
+    }
+    {
+        HMM_Quat result = f * q;
+        EXPECT_FLOAT_EQ(result.X, 2.0f);
+        EXPECT_FLOAT_EQ(result.Y, 4.0f);
+        EXPECT_FLOAT_EQ(result.Z, 6.0f);
+        EXPECT_FLOAT_EQ(result.W, 8.0f);
+    }
+
+    q *= f;
+    EXPECT_FLOAT_EQ(q.X, 2.0f);
+    EXPECT_FLOAT_EQ(q.Y, 4.0f);
+    EXPECT_FLOAT_EQ(q.Z, 6.0f);
+    EXPECT_FLOAT_EQ(q.W, 8.0f);
+#endif
+}
--- a/test/categories/Projection.h
+++ b/test/categories/Projection.h
@@ -0,0 +1,85 @@
+#include "../HandmadeTest.h"
+
+TEST(Projection, Orthographic)
+{
+#define ORTHO_BOUNDS -8.0f, 12.0f, 5.0f, 10.0f, 1.0f, 100.0f
+
+    // Right-handed
+    {
+        // Near and far distances correspond to negative Z, hence the Z coordinates here are negative.
+        HMM_Vec4 minCorner = HMM_V4(-8.0f, 5.0f, -1.0f, 1.0);
+        HMM_Vec4 maxCorner = HMM_V4(12.0f, 10.0f, -100.0f, 1.0);
+
+        // Z from -1 to 1 (GL convention)
+        {
+            HMM_Mat4 projection = HMM_Orthographic_RH_NO(ORTHO_BOUNDS);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, minCorner), HMM_V4(-1.0f, -1.0f, -1.0f, 1.0f));
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, maxCorner), HMM_V4(1.0f, 1.0f, 1.0f, 1.0f));
+        }
+
+        // Z from 0 to 1 (DX convention)
+        {
+            HMM_Mat4 projection = HMM_Orthographic_RH_ZO(ORTHO_BOUNDS);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, minCorner), HMM_V4(-1.0f, -1.0f, 0.0f, 1.0f));
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, maxCorner), HMM_V4(1.0f, 1.0f, 1.0f, 1.0f));
+        }
+    }
+
+    // Left-handed
+    {
+        // Near and far distances correspond to positive Z, hence the Z coordinates here are positive.
+        HMM_Vec4 minCorner = HMM_V4(-8.0f, 5.0f, 1.0f, 1.0);
+        HMM_Vec4 maxCorner = HMM_V4(12.0f, 10.0f, 100.0f, 1.0);
+
+        // Z from -1 to 1 (GL convention)
+        {
+            HMM_Mat4 projection = HMM_Orthographic_LH_NO(ORTHO_BOUNDS);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, minCorner), HMM_V4(-1.0f, -1.0f, -1.0f, 1.0f));
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, maxCorner), HMM_V4(1.0f, 1.0f, 1.0f, 1.0f));
+        }
+
+        // Z from 0 to 1 (DX convention)
+        {
+            HMM_Mat4 projection = HMM_Orthographic_LH_ZO(ORTHO_BOUNDS);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, minCorner), HMM_V4(-1.0f, -1.0f, 0.0f, 1.0f));
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, maxCorner), HMM_V4(1.0f, 1.0f, 1.0f, 1.0f));
+        }
+    }
+}
+
+TEST(Projection, Perspective)
+{
+    // Right-handed
+    {
+        // Z from -1 to 1 (GL convention)
+        {
+            HMM_Mat4 projection = HMM_Perspective_RH_NO(HMM_AngleDeg(90.0f), 2.0f, 1.0f, 15.0f);
+            HMM_Vec4 original = HMM_V4(5.0f, 5.0f, -1.0f, 1.0f);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, original), HMM_V4(2.5f, 5.0f, -1.0f, 1.0f));
+        }
+
+        // Z from 0 to 1 (DX convention)
+        {
+            HMM_Mat4 projection = HMM_Perspective_RH_ZO(HMM_AngleDeg(90.0f), 2.0f, 1.0f, 15.0f);
+            HMM_Vec4 original = HMM_V4(5.0f, 5.0f, -1.0f, 1.0f);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, original), HMM_V4(2.5f, 5.0f, 0.0f, 1.0f));
+        }
+    }
+
+    // Left-handed
+    {
+        // Z from -1 to 1 (GL convention)
+        {
+            HMM_Mat4 projection = HMM_Perspective_LH_NO(HMM_AngleDeg(90.0f), 2.0f, 1.0f, 15.0f);
+            HMM_Vec4 original = HMM_V4(5.0f, 5.0f, 1.0f, 1.0f);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, original), HMM_V4(2.5f, 5.0f, -1.0f, 1.0f));
+        }
+
+        // Z from 0 to 1 (DX convention)
+        {
+            HMM_Mat4 projection = HMM_Perspective_LH_ZO(HMM_AngleDeg(90.0f), 2.0f, 1.0f, 15.0f);
+            HMM_Vec4 original = HMM_V4(5.0f, 5.0f, 1.0f, 1.0f);
+            EXPECT_V4_EQ(HMM_MulM4V4(projection, original), HMM_V4(2.5f, 5.0f, 0.0f, 1.0f));
+        }
+    }
+}
--- a/test/categories/QuaternionOps.h
+++ b/test/categories/QuaternionOps.h
@@ -0,0 +1,297 @@
+#include "../HandmadeTest.h"
+
+TEST(QuaternionOps, Inverse)
+{
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat inverse = HMM_InvQ(q1);
+
+    HMM_Quat result = HMM_MulQ(q1, inverse);
+
+    EXPECT_FLOAT_EQ(result.X, 0.0f);
+    EXPECT_FLOAT_EQ(result.Y, 0.0f);
+    EXPECT_FLOAT_EQ(result.Z, 0.0f);
+    EXPECT_FLOAT_EQ(result.W, 1.0f);
+}
+
+TEST(QuaternionOps, Dot)
+{
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        float result = HMM_DotQ(q1, q2);
+        EXPECT_FLOAT_EQ(result, 70.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        float result = HMM_Dot(q1, q2);
+        EXPECT_FLOAT_EQ(result, 70.0f);
+    }
+#endif
+}
+
+TEST(QuaternionOps, Normalize)
+{
+    HMM_Quat q = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+
+    {
+        HMM_Quat result = HMM_NormQ(q);
+        EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
+        EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
+        EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Norm(q);
+        EXPECT_NEAR(result.X, 0.1825741858f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.3651483717f, 0.001f);
+        EXPECT_NEAR(result.Z, 0.5477225575f, 0.001f);
+        EXPECT_NEAR(result.W, 0.7302967433f, 0.001f);
+    }
+#endif
+}
+
+TEST(QuaternionOps, NLerp)
+{
+    HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
+    HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
+
+    HMM_Quat result = HMM_NLerp(from, 0.5f, to);
+    EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
+    EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
+    EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
+    EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
+}
+
+TEST(QuaternionOps, SLerp)
+{
+    HMM_Quat from = HMM_Q(0.0f, 0.0f, 0.0f, 1.0f);
+    HMM_Quat to = HMM_Q(0.5f, 0.5f, -0.5f, 0.5f);
+
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.0f, to);
+        EXPECT_NEAR(result.X, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Z, 0.0f, 0.001f);
+        EXPECT_NEAR(result.W, 1.0, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.25f, to);
+        EXPECT_NEAR(result.X, 0.149429246f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.149429246f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.149429246f, 0.001f);
+        EXPECT_NEAR(result.W, 0.965925812f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.5f, to);
+        EXPECT_NEAR(result.X, 0.28867513f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.28867513f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.28867513f, 0.001f);
+        EXPECT_NEAR(result.W, 0.86602540f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 0.75f, to);
+        EXPECT_NEAR(result.X, 0.40824830f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.40824830f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.40824830f, 0.001f);
+        EXPECT_NEAR(result.W, 0.70710676f, 0.001f);
+    }
+    {
+        HMM_Quat result = HMM_SLerp(from, 1.0f, to);
+        EXPECT_NEAR(result.X, 0.5f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.5f, 0.001f);
+        EXPECT_NEAR(result.Z, -0.5f, 0.001f);
+        EXPECT_NEAR(result.W, 0.5f, 0.001f);
+    }
+}
+
+TEST(QuaternionOps, QuatToMat4)
+{
+    const float abs_error = 0.001f;
+
+    HMM_Quat rot = HMM_Q(0.707107f, 0.0f, 0.0f, 0.707107f);
+
+    HMM_Mat4 result = HMM_QToM4(rot);
+
+    EXPECT_NEAR(result.Elements[0][0], 1.0f, abs_error);
+    EXPECT_NEAR(result.Elements[0][1], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[0][2], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
+
+    EXPECT_NEAR(result.Elements[1][0], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[1][1], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[1][2], 1.0f, abs_error);
+    EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
+
+    EXPECT_NEAR(result.Elements[2][0], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[2][1], -1.0f, abs_error);
+    EXPECT_NEAR(result.Elements[2][2], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
+
+    EXPECT_NEAR(result.Elements[3][0], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[3][1], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[3][2], 0.0f, abs_error);
+    EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
+}
+
+TEST(QuaternionOps, Mat4ToQuat)
+{
+    const float abs_error = 0.0001f;
+
+    // Rotate 90 degrees on the X axis
+    {
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_RH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
+    {
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
+        HMM_Quat result = HMM_M4ToQ_RH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, sinf, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Z axis
+    {
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+        HMM_Quat result = HMM_M4ToQ_RH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, sinf, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 45 degrees on the X axis (this hits case 4)
+    {
+        HMM_Mat4 m = HMM_Rotate_RH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_RH(m);
+
+        float cosf = 0.9238795325f; // cos(90/2 degrees)
+        float sinf = 0.3826834324f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    /* NOTE(lcf): Left-handed cases. Since both Rotate and M4ToQ are LH results should be
+        the same with no changes to input. */
+    // Rotate 90 degrees on the X axis
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Y axis (axis not normalized, just for fun)
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 2, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, sinf, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 90 degrees on the Z axis
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.707107f; // cos(90/2 degrees)
+        float sinf = 0.707107f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, 0.0f, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, sinf, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+
+    // Rotate 45 degrees on the X axis (this hits case 4)
+    {
+        HMM_Mat4 m = HMM_Rotate_LH(HMM_AngleDeg(45.0f), HMM_V3(1, 0, 0));
+        HMM_Quat result = HMM_M4ToQ_LH(m);
+
+        float cosf = 0.9238795325f; // cos(90/2 degrees)
+        float sinf = 0.3826834324f; // sin(90/2 degrees)
+
+        EXPECT_NEAR(result.X, sinf, abs_error);
+        EXPECT_NEAR(result.Y, 0.0f, abs_error);
+        EXPECT_NEAR(result.Z, 0.0f, abs_error);
+        EXPECT_NEAR(result.W, cosf, abs_error);
+    }
+}
+
+TEST(QuaternionOps, RotateVectorAxisAngle)
+{
+    {
+        HMM_Vec3 axis = HMM_V3(0.0f, 1.0f, 0.0f);
+        float angle = HMM_AngleTurn(1.0/4);
+        HMM_Vec3 result = HMM_RotateV3AxisAngle_LH(HMM_V3(1.0f, 0.0f, 0.0f), axis, angle);
+        EXPECT_NEAR(result.X, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Y, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Z, 1.0f, 0.001f);
+    }
+    {
+        HMM_Vec3 axis = HMM_V3(1.0f, 0.0f, 0.0f);
+        float angle = HMM_AngleTurn(1.0/8);
+        HMM_Vec3 result = HMM_RotateV3AxisAngle_RH(HMM_V3(0.0f, 0.0f, 1.0f), axis, angle);
+        EXPECT_NEAR(result.X, 0.0f, 0.001f);
+        EXPECT_NEAR(result.Y, -0.707170f, 0.001f);
+        EXPECT_NEAR(result.Z, 0.707170f, 0.001f);
+    }
+}
+
+TEST(QuaternionOps, QuatFromPairs)
+{
+    {
+        HMM_Vec3 n1 = HMM_V3(0.0f, 1.0f, 0.0f);
+        HMM_Vec3 n2 = HMM_V3(0.0f, 0.0f, 1.0f);
+        HMM_Quat q = HMM_QFromNormPair(n1, n2);
+        HMM_Vec3 result = HMM_RotateV3Q(n1, q);
+        EXPECT_NEAR(result.X, n2.X, 0.001f);
+        EXPECT_NEAR(result.Y, n2.Y, 0.001f);
+        EXPECT_NEAR(result.Z, n2.Z, 0.001f);
+    }
+    {
+        HMM_Vec3 v1 = HMM_V3(2.0f, 2.0f, 2.0f);
+        HMM_Vec3 v2 = HMM_V3(3.0f, 0.0f, 0.0f);
+        HMM_Quat q = HMM_QFromVecPair(v1, v2);
+        HMM_Vec3 result = HMM_RotateV3Q(HMM_V3(0.0f, 1.0f, 0.0f), q);
+        EXPECT_NEAR(result.X, 0.577350, 0.001f);
+        EXPECT_NEAR(result.Y, 0.788675, 0.001f);
+        EXPECT_NEAR(result.Z, -0.211325, 0.001f);
+    }
+}
--- a/test/categories/SSE.h
+++ b/test/categories/SSE.h
@@ -0,0 +1,39 @@
+#include "../HandmadeTest.h"
+
+#ifdef HANDMADE_MATH__USE_SSE
+
+TEST(SSE, LinearCombine)
+{
+    HMM_Mat4 MatrixOne = HMM_M4D(2.0f);
+    HMM_Mat4 MatrixTwo = HMM_M4D(4.0f);
+    HMM_Mat4 Result;
+
+    Result.Columns[0] = HMM_LinearCombineV4M4(MatrixOne.Columns[0], MatrixTwo);
+    Result.Columns[1] = HMM_LinearCombineV4M4(MatrixOne.Columns[1], MatrixTwo);
+    Result.Columns[2] = HMM_LinearCombineV4M4(MatrixOne.Columns[2], MatrixTwo);
+    Result.Columns[3] = HMM_LinearCombineV4M4(MatrixOne.Columns[3], MatrixTwo);
+
+    {
+        EXPECT_FLOAT_EQ(Result.Elements[0][0], 8.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[0][1], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[0][2], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[0][3], 0.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[1][0], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[1][1], 8.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[1][2], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[1][3], 0.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[2][0], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[2][1], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[2][2], 8.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[2][3], 0.0f);
+
+        EXPECT_FLOAT_EQ(Result.Elements[3][0], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[3][1], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[3][2], 0.0f);
+        EXPECT_FLOAT_EQ(Result.Elements[3][3], 8.0f);
+    }
+}
+
+#endif
--- a/test/categories/ScalarMath.h
+++ b/test/categories/ScalarMath.h
@@ -0,0 +1,53 @@
+#include "../HandmadeTest.h"
+
+TEST(ScalarMath, Trigonometry)
+{
+    // We have to be a little looser with our equality constraint
+    // because of floating-point precision issues.
+    const float trigAbsError = 0.0001f;
+
+    EXPECT_NEAR(HMM_SinF(0.0f), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_SinF(HMM_PI32 / 2), 1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_SinF(HMM_PI32), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_SinF(3 * HMM_PI32 / 2), -1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_SinF(-HMM_PI32 / 2), -1.0f, trigAbsError);
+
+    EXPECT_NEAR(HMM_CosF(0.0f), 1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_CosF(HMM_PI32 / 2), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_CosF(HMM_PI32), -1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_CosF(3 * HMM_PI32 / 2), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_CosF(-HMM_PI32), -1.0f, trigAbsError);
+
+    EXPECT_NEAR(HMM_TanF(0.0f), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_TanF(HMM_PI32 / 4), 1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_TanF(3 * HMM_PI32 / 4), -1.0f, trigAbsError);
+    EXPECT_NEAR(HMM_TanF(HMM_PI32), 0.0f, trigAbsError);
+    EXPECT_NEAR(HMM_TanF(-HMM_PI32 / 4), -1.0f, trigAbsError);
+
+    // This isn't the most rigorous because we're really just sanity-
+    // checking that things work by default.
+}
+
+TEST(ScalarMath, SquareRoot)
+{
+    EXPECT_FLOAT_EQ(HMM_SqrtF(16.0f), 4.0f);
+}
+
+TEST(ScalarMath, RSquareRootF)
+{
+    EXPECT_NEAR(HMM_InvSqrtF(10.0f), 0.31616211f, 0.0001f);
+}
+
+TEST(ScalarMath, Lerp)
+{
+    EXPECT_FLOAT_EQ(HMM_Lerp(-2.0f, 0.0f, 2.0f), -2.0f);
+    EXPECT_FLOAT_EQ(HMM_Lerp(-2.0f, 0.5f, 2.0f), 0.0f);
+    EXPECT_FLOAT_EQ(HMM_Lerp(-2.0f, 1.0f, 2.0f), 2.0f);
+}
+
+TEST(ScalarMath, Clamp)
+{
+    EXPECT_FLOAT_EQ(HMM_Clamp(-2.0f, 0.0f, 2.0f), 0.0f);
+    EXPECT_FLOAT_EQ(HMM_Clamp(-2.0f, -3.0f, 2.0f), -2.0f);
+    EXPECT_FLOAT_EQ(HMM_Clamp(-2.0f, 3.0f, 2.0f), 2.0f);
+}
--- a/test/categories/Subtraction.h
+++ b/test/categories/Subtraction.h
@@ -0,0 +1,357 @@
+#include "../HandmadeTest.h"
+
+TEST(Subtraction, Vec2)
+{
+    HMM_Vec2 v2_1 = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 v2_2 = HMM_V2(3.0f, 4.0f);
+
+    {
+        HMM_Vec2 result = HMM_SubV2(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, -2.0f);
+        EXPECT_FLOAT_EQ(result.Y, -2.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Sub(v2_1, v2_2);
+        EXPECT_FLOAT_EQ(result.X, -2.0f);
+        EXPECT_FLOAT_EQ(result.Y, -2.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec2 result = v2_1 - v2_2;
+        EXPECT_FLOAT_EQ(result.X, -2.0f);
+        EXPECT_FLOAT_EQ(result.Y, -2.0f);
+    }
+
+    v2_1 -= v2_2;
+    EXPECT_FLOAT_EQ(v2_1.X, -2.0f);
+    EXPECT_FLOAT_EQ(v2_1.Y, -2.0f);
+#endif
+}
+
+TEST(Subtraction, Vec3)
+{
+    HMM_Vec3 v3_1 = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v3_2 = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    {
+        HMM_Vec3 result = HMM_SubV3(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, -3.0f);
+        EXPECT_FLOAT_EQ(result.Y, -3.0f);
+        EXPECT_FLOAT_EQ(result.Z, -3.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Sub(v3_1, v3_2);
+        EXPECT_FLOAT_EQ(result.X, -3.0f);
+        EXPECT_FLOAT_EQ(result.Y, -3.0f);
+        EXPECT_FLOAT_EQ(result.Z, -3.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec3 result = v3_1 - v3_2;
+        EXPECT_FLOAT_EQ(result.X, -3.0f);
+        EXPECT_FLOAT_EQ(result.Y, -3.0f);
+        EXPECT_FLOAT_EQ(result.Z, -3.0f);
+    }
+
+    v3_1 -= v3_2;
+    EXPECT_FLOAT_EQ(v3_1.X, -3.0f);
+    EXPECT_FLOAT_EQ(v3_1.Y, -3.0f);
+    EXPECT_FLOAT_EQ(v3_1.Z, -3.0f);
+#endif
+}
+
+TEST(Subtraction, Vec4)
+{
+    HMM_Vec4 v4_1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v4_2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Vec4 result = HMM_SubV4(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Sub(v4_1, v4_2);
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Vec4 result = v4_1 - v4_2;
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+
+    v4_1 -= v4_2;
+    EXPECT_FLOAT_EQ(v4_1.X, -4.0f);
+    EXPECT_FLOAT_EQ(v4_1.Y, -4.0f);
+    EXPECT_FLOAT_EQ(v4_1.Z, -4.0f);
+    EXPECT_FLOAT_EQ(v4_1.W, -4.0f);
+#endif
+}
+
+TEST(Subtraction, Mat2)
+{
+    HMM_Mat2 a = HMM_M2();
+    HMM_Mat2 b = HMM_M2();
+    
+    int Counter = 1;
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 2; ++Column)
+    {
+        for (int Row = 0; Row < 2; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat2 result = HMM_SubM2(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat2 result = HMM_Sub(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat2 result = b - a;
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 4.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 4.0);
+    }
+
+    b -= a;
+    EXPECT_FLOAT_EQ(b.Elements[0][0], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][1], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][0], 4.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][1], 4.0);
+#endif
+}
+
+
+TEST(Subtraction, Mat3)
+{
+    HMM_Mat3 a = HMM_M3();
+    HMM_Mat3 b = HMM_M3();
+    
+    int Counter = 1;
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            a.Elements[Column][Row] = Counter++;
+        }
+    }
+    for (int Column = 0; Column < 3; ++Column)
+    {
+        for (int Row = 0; Row < 3; ++Row)
+        {
+            b.Elements[Column][Row] = Counter++;
+        }
+    }
+
+    {
+        HMM_Mat3 result = HMM_SubM3(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 9.0);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat3 result = HMM_Sub(b,a);
+        EXPECT_FLOAT_EQ(result.Elements[0][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[1][2], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][0], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][1], 9.0);
+        EXPECT_FLOAT_EQ(result.Elements[2][2], 9.0);
+    }
+#endif
+
+#ifdef __cplusplus
+    b -= a;
+    EXPECT_FLOAT_EQ(b.Elements[0][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[0][2], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[1][2], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][0], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][1], 9.0);
+    EXPECT_FLOAT_EQ(b.Elements[2][2], 9.0);
+#endif
+}
+
+TEST(Subtraction, Mat4)
+{
+    HMM_Mat4 m4_1 = HMM_M4(); // will have 1 - 16
+    HMM_Mat4 m4_2 = HMM_M4(); // will have 17 - 32
+
+    // Fill the matrices
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_1.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4_2.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the results
+    {
+        HMM_Mat4 result = HMM_SubM4(m4_1, m4_2);
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], -16.0f);
+            }
+        }
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Mat4 result = HMM_Sub(m4_1, m4_2);
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], -16.0f);
+            }
+        }
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Mat4 result = m4_1 - m4_2;
+        for (int Column = 0; Column < 4; ++Column)
+        {
+            for (int Row = 0; Row < 4; ++Row)
+            {
+                EXPECT_FLOAT_EQ(result.Elements[Column][Row], -16.0f);
+            }
+        }
+    }
+
+    m4_1 -= m4_2;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            EXPECT_FLOAT_EQ(m4_1.Elements[Column][Row], -16.0f);
+        }
+    }
+#endif
+}
+
+TEST(Subtraction, Quaternion)
+{
+    HMM_Quat q1 = HMM_Q(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Quat q2 = HMM_Q(5.0f, 6.0f, 7.0f, 8.0f);
+
+    {
+        HMM_Quat result = HMM_SubQ(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Quat result = HMM_Sub(q1, q2);
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+#endif
+#ifdef __cplusplus
+    {
+        HMM_Quat result = q1 - q2;
+        EXPECT_FLOAT_EQ(result.X, -4.0f);
+        EXPECT_FLOAT_EQ(result.Y, -4.0f);
+        EXPECT_FLOAT_EQ(result.Z, -4.0f);
+        EXPECT_FLOAT_EQ(result.W, -4.0f);
+    }
+
+    q1 -= q2;
+    EXPECT_FLOAT_EQ(q1.X, -4.0f);
+    EXPECT_FLOAT_EQ(q1.Y, -4.0f);
+    EXPECT_FLOAT_EQ(q1.Z, -4.0f);
+    EXPECT_FLOAT_EQ(q1.W, -4.0f);
+#endif
+}
+
+#ifdef __cplusplus
+TEST(UnaryMinus, Vec2)
+{
+    HMM_Vec2 VectorOne = {1.0f, 2.0f};
+    HMM_Vec2 Result = -VectorOne;
+    EXPECT_FLOAT_EQ(Result.X, -1.0f);
+    EXPECT_FLOAT_EQ(Result.Y, -2.0f);
+}
+
+TEST(UnaryMinus, Vec3)
+{
+    HMM_Vec3 VectorOne = {1.0f, 2.0f, 3.0f};
+    HMM_Vec3 Result = -VectorOne;
+    EXPECT_FLOAT_EQ(Result.X, -1.0f);
+    EXPECT_FLOAT_EQ(Result.Y, -2.0f);
+    EXPECT_FLOAT_EQ(Result.Z, -3.0f);
+}
+
+TEST(UnaryMinus, Vec4)
+{
+    HMM_Vec4 VectorOne = {1.0f, 2.0f, 3.0f, 4.0f};
+    HMM_Vec4 Result = -VectorOne;
+    EXPECT_FLOAT_EQ(Result.X, -1.0f);
+    EXPECT_FLOAT_EQ(Result.Y, -2.0f);
+    EXPECT_FLOAT_EQ(Result.Z, -3.0f);
+    EXPECT_FLOAT_EQ(Result.W, -4.0f);
+}
+#endif
--- a/test/categories/Transformation.h
+++ b/test/categories/Transformation.h
@@ -0,0 +1,133 @@
+#include "../HandmadeTest.h"
+
+TEST(Transformations, Translate)
+{
+    HMM_Mat4 translate = HMM_Translate(HMM_V3(1.0f, -3.0f, 6.0f));
+
+    HMM_Vec3 original = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec4 translated = HMM_MulM4V4(translate, HMM_V4V(original, 1));
+
+    EXPECT_NEAR(translated.X, 2.0f, 0.001f);
+    EXPECT_NEAR(translated.Y, -1.0f, 0.001f);
+    EXPECT_NEAR(translated.Z, 9.0f, 0.001f);
+    EXPECT_NEAR(translated.W, 1.0f, 0.001f);
+}
+
+TEST(Transformations, Rotate)
+{
+    HMM_Vec3 original = HMM_V3(1.0f, 1.0f, 1.0f);
+
+    HMM_Mat4 rotateX = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(1, 0, 0));
+    HMM_Vec4 rotatedX = HMM_MulM4V4(rotateX, HMM_V4V(original, 1));
+    EXPECT_NEAR(rotatedX.X, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedX.Y, -1.0f, 0.001f);
+    EXPECT_NEAR(rotatedX.Z, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedX.W, 1.0f, 0.001f);
+
+    HMM_Mat4 rotateY = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 1, 0));
+    HMM_Vec4 rotatedY = HMM_MulM4V4(rotateY, HMM_V4V(original, 1));
+    EXPECT_NEAR(rotatedY.X, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedY.Y, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedY.Z, -1.0f, 0.001f);
+    EXPECT_NEAR(rotatedY.W, 1.0f, 0.001f);
+
+    HMM_Mat4 rotateZ = HMM_Rotate_RH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+    HMM_Vec4 rotatedZ = HMM_MulM4V4(rotateZ, HMM_V4V(original, 1));
+    EXPECT_NEAR(rotatedZ.X, -1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZ.Y, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZ.Z, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZ.W, 1.0f, 0.001f);
+
+    HMM_Mat4 rotateZLH = HMM_Rotate_LH(HMM_AngleDeg(90.0f), HMM_V3(0, 0, 1));
+    HMM_Vec4 rotatedZLH = HMM_MulM4V4(rotateZLH, HMM_V4V(original, 1));
+    EXPECT_NEAR(rotatedZLH.X, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.Y, -1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.Z, 1.0f, 0.001f);
+    EXPECT_NEAR(rotatedZLH.W, 1.0f, 0.001f);
+}
+
+TEST(Transformations, Scale)
+{
+    HMM_Mat4 scale = HMM_Scale(HMM_V3(2.0f, -3.0f, 0.5f));
+
+    HMM_Vec3 original = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec4 scaled = HMM_MulM4V4(scale, HMM_V4V(original, 1));
+
+    EXPECT_NEAR(scaled.X, 2.0f, 0.001f);
+    EXPECT_NEAR(scaled.Y, -6.0f, 0.001f);
+    EXPECT_NEAR(scaled.Z, 1.5f, 0.001f);
+    EXPECT_NEAR(scaled.W, 1.0f, 0.001f);
+}
+
+TEST(Transformations, LookAt)
+{
+    const float abs_error = 0.001f;
+
+    {
+        HMM_Mat4 result = HMM_LookAt_RH(HMM_V3(1.0f, 0.0f, 0.0f), HMM_V3(0.0f, 2.0f, 1.0f), HMM_V3(2.0f, 1.0f, 1.0f));
+
+        EXPECT_NEAR(result.Elements[0][0], 0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[0][1], 0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[0][2], 0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[1][0], 0.507093f, abs_error);
+        EXPECT_NEAR(result.Elements[1][1], 0.276026f, abs_error);
+        EXPECT_NEAR(result.Elements[1][2], -0.816497f, abs_error);
+        EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[2][0], -0.845154f, abs_error);
+        EXPECT_NEAR(result.Elements[2][1], 0.345033f, abs_error);
+        EXPECT_NEAR(result.Elements[2][2], -0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[3][0], -0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[3][1], -0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[3][2], -0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
+    }
+    {    
+        HMM_Mat4 result = HMM_LookAt_LH(HMM_V3(1.0f, 0.0f, 0.0f), HMM_V3(0.0f, 2.0f, 1.0f), HMM_V3(2.0f, 1.0f, 1.0f));
+
+        EXPECT_NEAR(result.Elements[0][0], -0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[0][1], 0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[0][2], -0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[0][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[1][0], -0.507093f, abs_error);
+        EXPECT_NEAR(result.Elements[1][1], 0.276026f, abs_error);
+        EXPECT_NEAR(result.Elements[1][2], 0.816497f, abs_error);
+        EXPECT_NEAR(result.Elements[1][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[2][0], 0.845154f, abs_error);
+        EXPECT_NEAR(result.Elements[2][1], 0.345033f, abs_error);
+        EXPECT_NEAR(result.Elements[2][2], 0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[2][3], 0.0f, abs_error);
+        EXPECT_NEAR(result.Elements[3][0], 0.169031f, abs_error);
+        EXPECT_NEAR(result.Elements[3][1], -0.897085f, abs_error);
+        EXPECT_NEAR(result.Elements[3][2], 0.408248f, abs_error);
+        EXPECT_NEAR(result.Elements[3][3], 1.0f, abs_error);
+    }
+}
+
+TEST(Transformations, RotateV2)
+{
+    HMM_Vec2 v2 = HMM_V2(1, 2);
+
+    float epsilon = 0.000001f;
+    {
+        HMM_Vec2 res = HMM_RotateV2(v2, HMM_AngleDeg(90));
+        EXPECT_NEAR(res.X, -2.0f, epsilon);
+        EXPECT_NEAR(res.Y, 1.0f, epsilon);
+    }
+    {
+        HMM_Vec2 res = HMM_RotateV2(v2, HMM_AngleDeg(180));
+        EXPECT_NEAR(res.X, -1.0f, epsilon);
+        EXPECT_NEAR(res.Y, -2.0f, epsilon);
+    }
+    {
+        HMM_Vec2 res = HMM_RotateV2(v2, HMM_AngleDeg(270));
+        EXPECT_NEAR(res.X, 2.0f, epsilon);
+        EXPECT_NEAR(res.Y, -1.0f, epsilon);
+    }
+    {
+        HMM_Vec2 res = HMM_RotateV2(v2, HMM_AngleDeg(360));
+        EXPECT_NEAR(res.X, 1.0f, epsilon);
+        EXPECT_NEAR(res.Y, 2.0f, epsilon);
+    }
+}
--- a/test/categories/VectorOps.h
+++ b/test/categories/VectorOps.h
@@ -0,0 +1,282 @@
+#include "../HandmadeTest.h"
+
+TEST(VectorOps, LengthSquared)
+{
+    HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, 1.0f);
+
+    EXPECT_FLOAT_EQ(HMM_LenSqrV2(v2), 5.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqrV3(v3), 14.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqrV4(v4), 15.0f);
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v2), 5.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v3), 14.0f);
+    EXPECT_FLOAT_EQ(HMM_LenSqr(v4), 15.0f);
+#endif
+}
+
+TEST(VectorOps, Length)
+{
+    HMM_Vec2 v2 = HMM_V2(1.0f, -9.0f);
+    HMM_Vec3 v3 = HMM_V3(2.0f, -3.0f, 6.0f);
+    HMM_Vec4 v4 = HMM_V4(2.0f, -3.0f, 6.0f, 12.0f);
+
+    EXPECT_FLOAT_EQ(HMM_LenV2(v2), 9.0553856f);
+    EXPECT_FLOAT_EQ(HMM_LenV3(v3), 7.0f);
+    EXPECT_FLOAT_EQ(HMM_LenV4(v4), 13.892444f);
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_FLOAT_EQ(HMM_Len(v2), 9.0553856f);
+    EXPECT_FLOAT_EQ(HMM_Len(v3), 7.0f);
+    EXPECT_FLOAT_EQ(HMM_Len(v4), 13.892444f);
+#endif
+}
+
+TEST(VectorOps, Normalize)
+{
+    HMM_Vec2 v2 = HMM_V2(1.0f, -2.0f);
+    HMM_Vec3 v3 = HMM_V3(1.0f, -2.0f, 3.0f);
+    HMM_Vec4 v4 = HMM_V4(1.0f, -2.0f, 3.0f, -1.0f);
+
+    {
+        HMM_Vec2 result = HMM_NormV2(v2);
+        EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+    }
+    {
+        HMM_Vec3 result = HMM_NormV3(v3);
+        EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+        EXPECT_GT(result.Z, 0.0f);
+    }
+    {
+        HMM_Vec4 result = HMM_NormV4(v4);
+        EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+        EXPECT_GT(result.Z, 0.0f);
+        EXPECT_LT(result.W, 0.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Norm(v2);
+        EXPECT_NEAR(HMM_LenV2(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+    }
+    {
+        HMM_Vec3 result = HMM_Norm(v3);
+        EXPECT_NEAR(HMM_LenV3(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+        EXPECT_GT(result.Z, 0.0f);
+    }
+    {
+        HMM_Vec4 result = HMM_Norm(v4);
+        EXPECT_NEAR(HMM_LenV4(result), 1.0f, 0.001f);
+        EXPECT_GT(result.X, 0.0f);
+        EXPECT_LT(result.Y, 0.0f);
+        EXPECT_GT(result.Z, 0.0f);
+        EXPECT_LT(result.W, 0.0f);
+    }
+#endif
+}
+
+TEST(VectorOps, NormalizeZero)
+{
+    HMM_Vec2 v2 = HMM_V2(0.0f, 0.0f);
+    HMM_Vec3 v3 = HMM_V3(0.0f, 0.0f, 0.0f);
+    HMM_Vec4 v4 = HMM_V4(0.0f, 0.0f, 0.0f, 0.0f);
+
+    {
+        HMM_Vec2 result = HMM_NormV2(v2);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+    }
+    {
+        HMM_Vec3 result = HMM_NormV3(v3);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.0f);
+    }
+    {
+        HMM_Vec4 result = HMM_NormV4(v4);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.0f);
+        EXPECT_FLOAT_EQ(result.W, 0.0f);
+    }
+
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Norm(v2);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+    }
+    {
+        HMM_Vec3 result = HMM_Norm(v3);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.0f);
+    }
+    {
+        HMM_Vec4 result = HMM_Norm(v4);
+        EXPECT_FLOAT_EQ(result.X, 0.0f);
+        EXPECT_FLOAT_EQ(result.Y, 0.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.0f);
+        EXPECT_FLOAT_EQ(result.W, 0.0f);
+    }
+#endif
+}
+
+TEST(VectorOps, Cross)
+{
+    HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    HMM_Vec3 result = HMM_Cross(v1, v2);
+
+    EXPECT_FLOAT_EQ(result.X, -3.0f);
+    EXPECT_FLOAT_EQ(result.Y, 6.0f);
+    EXPECT_FLOAT_EQ(result.Z, -3.0f);
+}
+
+TEST(VectorOps, DotVec2)
+{
+    HMM_Vec2 v1 = HMM_V2(1.0f, 2.0f);
+    HMM_Vec2 v2 = HMM_V2(3.0f, 4.0f);
+
+    EXPECT_FLOAT_EQ(HMM_DotV2(v1, v2), 11.0f);
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 11.0f);
+#endif
+}
+
+TEST(VectorOps, DotVec3)
+{
+    HMM_Vec3 v1 = HMM_V3(1.0f, 2.0f, 3.0f);
+    HMM_Vec3 v2 = HMM_V3(4.0f, 5.0f, 6.0f);
+
+    EXPECT_FLOAT_EQ(HMM_DotV3(v1, v2), 32.0f);
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 32.0f);
+#endif
+}
+
+TEST(VectorOps, DotVec4)
+{
+    HMM_Vec4 v1 = HMM_V4(1.0f, 2.0f, 3.0f, 4.0f);
+    HMM_Vec4 v2 = HMM_V4(5.0f, 6.0f, 7.0f, 8.0f);
+
+    EXPECT_FLOAT_EQ(HMM_DotV4(v1, v2), 70.0f);
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    EXPECT_FLOAT_EQ(HMM_Dot(v1, v2), 70.0f);
+#endif
+}
+
+TEST(VectorOps, LerpV2)
+{
+    HMM_Vec2 v1 = HMM_V2(1.0f, 0.0f);
+    HMM_Vec2 v2 = HMM_V2(0.0f, 1.0f);
+
+    {
+        HMM_Vec2 result = HMM_LerpV2(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.5f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec2 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 0.5f);
+    }
+#endif
+}
+
+TEST(VectorOps, LerpV3)
+{
+    HMM_Vec3 v1 = HMM_V3(1.0f, 1.0f, 0.0f);
+    HMM_Vec3 v2 = HMM_V3(0.0f, 1.0f, 1.0f);
+
+    {
+        HMM_Vec3 result = HMM_LerpV3(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec3 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+    }
+#endif
+}
+
+TEST(VectorOps, LerpV4)
+{
+    HMM_Vec4 v1 = HMM_V4(1.0f, 1.0f, 0.0f, 1.0f);
+    HMM_Vec4 v2 = HMM_V4(0.0f, 1.0f, 1.0f, 1.0f);
+
+    {
+        HMM_Vec4 result = HMM_LerpV4(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+        EXPECT_FLOAT_EQ(result.W, 1.0f);
+    }
+#if HANDMADE_MATH__USE_C11_GENERICS || defined(__cplusplus)
+    {
+        HMM_Vec4 result = HMM_Lerp(v1, 0.5, v2);
+        EXPECT_FLOAT_EQ(result.X, 0.5f);
+        EXPECT_FLOAT_EQ(result.Y, 1.0f);
+        EXPECT_FLOAT_EQ(result.Z, 0.5f);
+        EXPECT_FLOAT_EQ(result.W, 1.0f);
+    }
+#endif
+}
+
+/*
+ * MatrixOps tests
+ */
+
+TEST(MatrixOps, TransposeM4)
+{
+    HMM_Mat4 m4 = HMM_M4(); // will have 1 - 16
+
+    // Fill the matrix
+    int Counter = 1;
+    for (int Column = 0; Column < 4; ++Column)
+    {
+        for (int Row = 0; Row < 4; ++Row)
+        {
+            m4.Elements[Column][Row] = Counter;
+            ++Counter;
+        }
+    }
+
+    // Test the matrix
+    HMM_Mat4 result = HMM_TransposeM4(m4);
+    EXPECT_FLOAT_EQ(result.Elements[0][0], 1.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][1], 5.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][2], 9.0f);
+    EXPECT_FLOAT_EQ(result.Elements[0][3], 13.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][0], 2.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][1], 6.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][2], 10.0f);
+    EXPECT_FLOAT_EQ(result.Elements[1][3], 14.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][0], 3.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][1], 7.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][2], 11.0f);
+    EXPECT_FLOAT_EQ(result.Elements[2][3], 15.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][0], 4.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][1], 8.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][2], 12.0f);
+    EXPECT_FLOAT_EQ(result.Elements[3][3], 16.0f);
+}
--- a/test/hmm_test.c
+++ b/test/hmm_test.c
--- a/test/hmm_test.h
+++ b/test/hmm_test.h
@@ -0,0 +1,21 @@
+#include <float.h>
+
+#define HANDMADE_TEST_IMPLEMENTATION
+#include "HandmadeTest.h"
+
+#undef COVERAGE // Make sure we don't double-define initializers from the header part
+#include "../HandmadeMath.h"
+
+#include "categories/ScalarMath.h"
+#include "categories/Initialization.h"
+#include "categories/VectorOps.h"
+#include "categories/MatrixOps.h"
+#include "categories/QuaternionOps.h"
+#include "categories/Addition.h"
+#include "categories/Subtraction.h"
+#include "categories/Multiplication.h"
+#include "categories/Division.h"
+#include "categories/Equality.h"
+#include "categories/Projection.h"
+#include "categories/Transformation.h"
+#include "categories/SSE.h"
--- a/test/initializer.h
+++ b/test/initializer.h
@@ -0,0 +1,29 @@
+// Initializer/finalizer sample for MSVC and GCC/Clang.
+// 2010-2016 Joe Lowe. Released into the public domain.
+#include <stdio.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+    #define _INITIALIZER_T(f) f##_t_
+    #define _INITIALIZER_U(f) f##_
+    #define INITIALIZER(f) \
+        static void f(void); \
+        struct _INITIALIZER_T(f) { _INITIALIZER_T(f)(void) { f(); } }; static _INITIALIZER_T(f) _INITIALIZER_U(f); \
+        static void f(void)
+#elif defined(_MSC_VER)
+    #pragma section(".CRT$XCU",read)
+    #define INITIALIZER2_(f,p) \
+        static void f(void); \
+        __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
+        __pragma(comment(linker,"/include:" p #f "_")) \
+        static void f(void)
+    #ifdef _WIN64
+        #define INITIALIZER(f) INITIALIZER2_(f,"")
+    #else
+        #define INITIALIZER(f) INITIALIZER2_(f,"_")
+    #endif
+#else
+    #define INITIALIZER(f) \
+        static void f(void) __attribute__((constructor)); \
+        static void f(void)
+#endif
--- a/test/run_test_clang.bat
+++ b/test/run_test_clang.bat
@@ -0,0 +1,27 @@
+@echo off
+
+if not exist "build" mkdir build
+pushd build
+
+clang-cl /std:c11 /Fehmm_test_c11.exe ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c11 || exit /b 1
+
+clang-cl /std:c11 /Fehmm_test_c11_no_simd.exe /DHANDMADE_MATH_NO_SIMD ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c11_no_simd || exit /b 1
+
+clang-cl /std:c17 /Fehmm_test_c17.exe ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c17 || exit /b 1
+
+clang-cl /std:c++14 /Fehmm_test_cpp14.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp14 || exit /b 1
+
+clang-cl /std:c++14 /Fehmm_test_cpp14_no_simd.exe /DHANDMADE_MATH_NO_SIMD ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp14_no_simd || exit /b 1
+
+clang-cl /std:c++17 /Fehmm_test_cpp17.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp17 || exit /b 1
+
+clang-cl /std:c++20 /Fehmm_test_cpp20.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp20 || exit /b 1
+
+popd
--- a/test/run_test_msvc.bat
+++ b/test/run_test_msvc.bat
@@ -0,0 +1,32 @@
+@echo off
+
+where /q cl
+if ERRORLEVEL 1 (
+    for /f "delims=" %%a in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -find VC\Auxiliary\Build\vcvarsall.bat') do (%%a x64)
+)
+
+if not exist "build" mkdir build
+pushd build
+
+cl /std:c11 /Fehmm_test_c11.exe ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c11 || exit /b 1
+
+cl /std:c11 /Fehmm_test_c11_no_simd.exe /DHANDMADE_MATH_NO_SIMD ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c11_no_simd || exit /b 1
+
+cl /std:c17 /Fehmm_test_c17.exe ..\HandmadeMath.c ..\hmm_test.c || exit /b 1
+hmm_test_c17 || exit /b 1
+
+cl /std:c++14 /Fehmm_test_cpp14.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp14 || exit /b 1
+
+cl /std:c++14 /Fehmm_test_cpp14_no_simd.exe /DHANDMADE_MATH_NO_SIMD ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp14_no_simd || exit /b 1
+
+cl /std:c++17 /Fehmm_test_cpp17.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp17 || exit /b 1
+
+cl /std:c++20 /Fehmm_test_cpp20.exe ..\HandmadeMath.cpp ..\hmm_test.cpp || exit /b 1
+hmm_test_cpp20 || exit /b 1
+
+popd
--- a/update/README.md
+++ b/update/README.md
@@ -0,0 +1,24 @@
+# Handmade Math 2.0 Update Tool
+
+Due to the large number of breaking naming changes in Handmade Math 2, we provide a small Python script to update your programs automatically. It can run on individual files or on all files in a directory (recursively).
+
+**Warning!** This tool is not very smart! Please ensure that your work is committed and backed up, in case you have to revert this tool's changes.
+
+```
+# see usage info and options
+> python3 update_hmm.py -h
+usage: update_hmm [-h] [--exts .foo [.foo ...]] filename [filename ...]
+...
+
+# run on individual files
+> python3 update_hmm.py MyPlatformLayer.c MyPlatformLayer.h
+Updating: MyPlatformLayer.c
+Updating: MyPlatformLayer.h
+Updated 2 files with 0 warnings.
+
+# run on a whole directory
+> python3 update_hmm.py projects/MyCoolGame
+Updating: projects/MyCoolGame/src/MyPlatformLayer.c
+Updating: projects/MyCoolGame/include/MyPlatformLayer.h
+...
+```
--- a/update/update_hmm.py
+++ b/update/update_hmm.py
@@ -0,0 +1,166 @@
+#!/usr/bin/env python3
+
+import argparse
+import os
+import re
+
+typeReplacements = [
+    ('hmm_', 'HMM_'),
+
+    ('vec', 'Vec'),
+    ('mat', 'Mat'),
+    ('quaternion', 'Quaternion'),
+    ('bool', 'Bool'),
+    ('.InternalElementsSSE', '.SSE'),
+]
+
+funcReplacements = [
+    ('HMM_', 'HMM_'),
+    
+    ('Vec', 'V'),
+    ('Mat', 'M'),
+    ('Quaternion', 'Q'),
+    ('Equals', 'Eq'),
+    ('Subtract', 'Sub'),
+    ('Multiply', 'Mul'),
+    ('Divide', 'Div'),
+    ('Inverse', 'Inv'),
+    ('RSquareRoot', 'InvSqrt'),
+    ('SquareRoot', 'Sqrt'),
+    ('Squared', 'Sqr'),
+    ('Length', 'Len'),
+
+    ('Slerp', 'SLerp'),
+    ('By', ''),
+    ('LinearCombineSSE', 'LinearCombineV4M4'),
+    ('Transpose', 'TransposeM4'),
+    ('Fast', ''), # TODO(port): emit warning, lower precision
+    ('Normalize', 'Norm'),
+    ('ToRadians', 'ToRad')
+]
+
+handedFuncs = [
+    'Perspective',
+    'Rotate',
+    'Orthographic',
+    'LookAt',
+    'FromAxisAngle',
+    'ToQuaternion',
+]
+
+projectionFuncs = [
+    'Perspective',
+    'Orthographic',
+]
+
+numFiles = 0
+numWarnings = 0
+
+def printWarning(msg):
+    global numWarnings
+    numWarnings += 1
+    print('WARNING: {}'.format(msg))
+
+def updateFile(filename):
+    global numFiles
+    print('Updating: {}'.format(filename))
+    numFiles += 1
+    result = ''
+    with open(filename, 'r', newline='') as f:
+        for lineNo, line in enumerate(f):
+            updatedLine = line
+
+            def printLineWarning(msg):
+                printWarning('  Line {}: {}'.format(lineNo + 1, msg))
+
+            def replaceName(m):
+                name = m.group()
+                if name.startswith('hmm_'):
+                    # do type replacements
+                    for before, after in typeReplacements:
+                        if before not in name:
+                            continue
+                        name = name.replace(before, after)
+                else:
+                    # do func replacements
+                    for before, after in funcReplacements:
+                        if before not in name:
+                            continue
+                        name = name.replace(before, after)
+
+                        if after == 'LinearCombineV4M4':
+                            printLineWarning('HMM_LinearCombineSSE is now HMM_LinearCombineV4M4, and will now use a fallback method when SSE is not available. You no longer need to check for the availability of SSE.')
+                        if after == 'V' or after == 'M':
+                            # uppercase the modifier, if any
+                            name = re.sub(
+                                r'[VM]\d[ivfd]?',
+                                lambda m: m.group().upper(),
+                                name
+                            )
+                            # and also nuke the integer constructors
+                            vecIntMatch = re.search(r'(V\d)I', name)
+                            if vecIntMatch:
+                                name = name.replace(vecIntMatch.group(), vecIntMatch.group(1))
+
+                    # add handedness / NDC modifiers
+                    if not any(x in name for x in ['RH', 'LH', 'NO', 'ZO']):
+                        for handedFunc in handedFuncs:
+                            suffixed = handedFunc + '_RH'
+                            if handedFunc in projectionFuncs:
+                                suffixed += '_NO'
+                            name = name.replace(handedFunc, suffixed)
+                return name
+
+            def wrapDegrees(m):
+                name = m.group('name')
+                arg = m.group('arg')
+                if '(' in arg:
+                    # all bets are off, don't wrap the argument
+                    printLineWarning('{} now takes radians, but we were unable to automatically wrap the first argument with HMM_AngleDeg().'.format(name))
+                    return m.group()
+                return '{}(HMM_AngleDeg({}),'.format(name, arg)
+                
+            updatedLine = re.sub(r'(hmm_|HMM_)\w+', replaceName, updatedLine)
+            updatedLine = re.sub(r'(?P<name>HMM_Perspective_RH_NO|HMM_Rotate_RH)\((?P<arg>.*?),', wrapDegrees, updatedLine)
+
+            result += updatedLine
+
+    with open(filename, 'w', newline='') as f:
+        f.write(result)
+
+
+parser = argparse.ArgumentParser(
+    prog = 'update_hmm',
+    description = 'Updates C and C++ source code to use Handmade Math 2.0.',
+)
+parser.add_argument(
+    'filename', nargs='+',
+    help='A file or directory to update to HMM 2.0. If a directory, all files with extensions from --exts will be processed.',
+)
+parser.add_argument(
+    '--exts', nargs='+', default=['.c', '.cpp', '.h', '.hpp'],
+    help='File extensions to run the script on, when targeting a directory. Default: .c, .cpp, .h, .hpp.',
+    metavar='.foo',
+)
+
+args = parser.parse_args()
+
+for path in args.filename:
+    filenames = []
+    if os.path.isfile(path):
+        filenames = [path]
+    else:
+        for root, dirs, files in os.walk(path):
+            for file in files:
+                if file == 'HandmadeMath.h':
+                    printWarning('HandmadeMath.h will not be replaced by this script.')
+                elif file.endswith(tuple(args.exts)):
+                    filenames.append(os.path.join(root, file))
+    
+    for filename in filenames:
+        try:
+            updateFile(filename)
+        except UnicodeDecodeError:
+            pass
+
+    print('Updated {} files with {} warnings.'.format(numFiles, numWarnings))
Author	SHA1	Message	Date
Ben Visness	142ba3cd9d	Align backslashes for great aesthetics (very important)	2025-02-24 17:45:35 -06:00
Ben Visness	8c2ac269ba	Redo test scripts	2025-02-23 20:33:06 -06:00
Ben Visness	736ebaaf23	Test and fix _Generic	2025-02-23 20:33:06 -06:00
Ben Visness	bdc7dd2a51	Merge pull request #172 from jonasgf/whitespace Remove trailing whitespace and extra newlines at end of file	2024-05-28 09:46:45 -05:00
Ben Visness	b4ce44823b	Merge pull request #171 from jonasgf/missing-braces Ignore missing braces warning for all GCC versions	2024-05-28 09:46:22 -05:00
Jonas	2901e70ca3	Remove trailing whitespace and extra newlines at end of file	2024-04-27 22:56:11 +02:00
Jonas	21b4a0d209	Ignore missing braces warning for all GCC versions	2024-04-27 22:46:15 +02:00
Ben Visness	43836aa3a6	Merge pull request #170 from B-Y-P/master Add HMM_QFromNormPair() and HMM_QFromVecPair()	2024-04-11 11:08:32 -05:00
BYP	bdc04881de	Add HMM_QFromNormPair() and HMM_QFromVecPair()	2024-04-08 21:21:54 -04:00
Ben Visness	322826bcee	Merge pull request #169 from Jack-Punter/neon_support Neon support	2023-12-15 20:14:20 -06:00
jack punter	4e1e97522d	Address Ben's changes	2023-12-14 21:39:50 +00:00
Jack Punter	6603c796cc	Update test Makefile to use NO_SIMD over NO_SSE	2023-12-12 01:53:43 +00:00
Jack Punter	623215b228	NEON Quaternion Multiply	2023-12-12 01:47:01 +00:00
Jack Punter	fcc510f767	Fix scalar	2023-12-12 01:42:37 +00:00
Jack Punter	133a595b6f	Better Neon tranpose vld can de-interleave up to 4-float element structures in one go into multiple registers. This allows us to load each column of the matrix and put each element into a corresponding vector, essentially doing the entire transpose in 1 instruction Fixed it	2023-12-12 01:42:37 +00:00
Jack Punter	5f20d693c9	Add Neon implementations for all but Quaternion multiply	2023-12-11 22:57:19 +00:00
Ben Visness	e210d8729b	Add HMM_RotateV2	2023-11-03 11:34:49 -05:00
dev_dwarf	a1c84320f9	Style tweaks to RotateV3Q + axis angle variant	2023-10-31 13:09:20 -06:00
Olivier Perret	8df5da57f5	Clean trailing whitespace in HandmadeMath.h	2023-10-29 18:33:31 +01:00
Olivier Perret	149c18d449	Add HMM_RotateQV3(), for rotating a vec3 by a quaternion	2023-10-29 18:32:09 +01:00
Olivier Perret	98748f702c	Provide const versions of operator[] (#166 ) This makes it possible use to do something like const HMM_Vec3 v{1,2,3}; float val = v[1];	2023-10-27 13:15:58 -05:00
Logan Forman	6cf6226c57	remove most references from operators (#164 )	2023-08-05 12:57:56 -04:00
Ben Visness	aaa767bf0b	Update README.md	2023-02-20 13:29:24 -06:00
Ben Visness	422bc588e9	Fix inverse perspective	2023-02-20 13:03:46 -06:00
Ben Visness	beb837a3c6	Tweak docs, add tests, find bugs	2023-02-02 19:18:24 -06:00
Ben Visness	50ab55b3bc	Rewrite the update tool in Python Less than 200 lines, properly cross platform, actually outputs error messages if things break, better flag handling. Everyone has Python anyway.	2023-01-27 03:39:38 -06:00
Ben Visness	22d743ce3d	Change naming convention for NO/ZO (the update tool needs updating)	2023-01-26 22:27:09 -06:00
Logan Forman	d4918a514e	Drop Projection Matrix Config; Make explicit. (#154 ) * Add N0/Z0 projection Remove configuration macro * Update update_hmm.c Co-authored-by: Ben Visness <bvisness@users.noreply.github.com>	2023-01-26 21:01:31 -06:00
Logan Forman	37aa3fa6a0	Unroll sse (#153 ) * Unroll loops and SSE consistency * Fix tranposes	2023-01-26 20:56:28 -06:00
dev_dwarf	7e493a5481	Fix LH perspective matrix Off by a sign before.	2023-01-26 19:55:21 -06:00
Ben Visness	f106a0f5f3	Style and docs pass for release Remove V2I, V3I, V4I (and style changes) Totally useless. Add update tool, update docs Tweak docs Create ci.yml Big style pass Maybe fix CI on Windows Report coverage errors Fix a missing coverage case Try setting up MSVC another way Update readmes Fix remaining use of the name UpdateTool	2023-01-22 21:46:22 -06:00
Logan Forman	c24e4ff873	HMM2.0 (#149 ) These changes were all made by @dev-dwarf. Many thanks for his work on this! * Renaming * First Pass on 2.0UpdateTool * Another pass on UpdateTool, changed name * Another pass on UpdateTool, changed name * Do Renaming * Working on Angles Consistency * Passing Coverage * Remove unused arc-tangent functions * Change macro defaults By default if user is overriding trig functions assume their input and internal units are the same. * wrap in AngleDeg instead of AngleRad * Remove HMM_PREFIX configuration * Fix for Slerp https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265 Justified by most implementations of Slerp. EX: http://number-none.com/product/Understanding%20Slerp,%20Then%20Not%20Using%20It/ * Handedness Changes * More renaming. C11 _Generics Generics enable by default when available (see lines 97-104). User can also force them by defining HANDMADE_MATH_C11_GENERICS Also fixed some missed things w.r.t renaming. My old tool didn't catch cases like HMM_MultiplyVec3f needing to be HMM_MulV3F instead of HMM_MulV3f. * Reuse more SSE codepaths for Quaternions Also improved quaternion tests. More work could be done here, see discussion here about optimizing slerp: https://discord.com/channels/239737791225790464/489148972305350656/1055167647274246265 * Just saving these alternate versions of SLerp * Reduce V4/M4 Linear Comb. codepaths * Simple implementation of 2x2 and 3x3 basic matrix operations. Also renamed Transpose to TransposeM4, so that we can have TransposeM2,M3 * Norm is dead! Long live Norm! As can be seen from the tests, precision has declined quite a bit from using the FastNorm implementations for various things. We can only guarantee about 0.001f precision for anything where a norm happens now. If this is undesired we can change back easily. * Started work on Matrix Inverses TODO: Tests for simple 4x4 Inverses * Matrix Inverses + Tests * Generics for Matrices and Rename MXd/f functions * Fixes + Better Output for UpdateTool * I think I count as a contributor : ) * Ported UpdateTool, Inlined my library code. * Moved tool to different repo https://github.com/dev-dwarf/HMM2.0UpdateTool * Remove small test change * Found some more references to atan functions * Standardize angle function names, use short names * Remove other slerp comments * woops that wasnt meant to be commited. * Finish changing ToRadians to ToRad * Fix [] overloads per https://discord.com/channels/239737791225790464/600063880533770251/1051600188302692402 * Tests for 2x2, 3x3 Matrices and Other Matrix Ops * Add an option to use Z: [0, 1] range for projection matrices. This will make HMM more convenient to use with other graphics APIs such as Direct3d and Metal. * Update test imports * #if should've been #ifdef! * Implement requested changes	2023-01-22 17:34:50 -06:00
Zak Strange	ba5405ac0f	Update README.md	2021-08-31 17:11:42 -07:00
Zak Strange	d69a859d73	Fully inlined HandmadeMath.h (#139 ) * Fully inlined HandmadeMath.h, renamed test.bat to run_test_msvc.bat, and introduced run_test_clang.bat * General Cleanup	2021-08-31 17:10:46 -07:00
strangezak	8c18186b3b	Removed Unnecessary Square Root from InverseQuaternion. Closes #136	2021-08-31 09:28:02 -07:00
Tim Gates	5f816bf9b3	docs: fix simple typo, percision -> precision (#137 ) There is a small typo in README.md. Should read `precision` rather than `percision`.	2021-08-31 09:22:29 -07:00
Jørgen P. Tjernø	c5bc802042	Suppress two warnings on clang 12 (#138 ) Building with clang 12 with -Wextra, the following two warnings are generated: ``` HandmadeMath.h:1167:25: warning: missing field 'Y' initializer [-Wmissing-field-initializers] hmm_vec2 Result = {0}; ^ HandmadeMath.h:1167:24: warning: suggest braces around initialization of subobject [-Wmissing-braces] ``` This expands the `-Wmissing-braces` ignore to also target clang, and adds an ignore for `-Wmissing-field-initializers`	2021-08-31 09:37:54 -05:00
Ben Visness	43afc87fa7	Remove non-functioning issue link	2021-03-24 10:04:17 -05:00
Ben Visness	5bbac2167e	Update version and changelog	2021-03-24 10:02:08 -05:00
Wayde Reitsma	655c662528	Add brackets around HMM_MIN, HMM_MAX, and HMM_MOD (#133 ) * Add brackets around HMM_MIN and HMM_MAX * Add brackets around HMM_MOD	2021-03-24 09:54:13 -05:00
Zak Strange	1f0c6ba493	Update Docs.	2021-03-09 16:37:00 -08:00
Zak Strange	1d82b4f0bc	Unary minus vectors (#130 ) * Unary Minus operator for vec2, vec3, and vec4 * Update README.md Co-authored-by: zak <zak@DESKTOP-V1AQ0IT>	2021-03-06 18:39:17 -06:00
Zak Strange	2fa0b36715	Add HMM_STATIC option to statically link instead of extern (#127 ) Co-authored-by: zak <zak@DESKTOP-V1AQ0IT>	2021-02-17 19:36:05 -08:00
Ben Visness	ad169e649c	Make HMM_Clamp branchless in optimized builds (#122 )	2020-12-22 11:19:58 -06:00
Zak Strange	1900cc9275	Updated email in HandmadeMath.h	2020-07-09 18:22:22 -07:00
Ben Visness	ddb9971e71	Update README	2020-07-09 08:51:53 -05:00
GsxCasper	341a376a17	Added HMM_PREFIX macro to function implementations (#120 )	2020-07-08 16:32:29 -05:00
Ben Visness	c825fe48cf	Update version and release notes	2020-04-06 10:02:16 -05:00
Ben Visness	15bef820db	Add ability to customize HMM_ prefix (#114 ) * Add prefix macro and use it everywhere * Add lightweight test for prefix * Add a little doc blurb	2020-04-06 09:57:10 -05:00
Ben Visness	fe32f081f2	Suppress float equality warnings (#113 ) * Add a macro to help with deprecations * Suppress warnings about float equality	2020-04-06 09:55:40 -05:00
Zak Strange	785f19d4a7	Removed use of stdint.h (#110 )	2020-01-11 17:13:09 -08:00
Ben Visness	a9b08b9147	Run tests on Linux, macOS, and Windows (#105 ) * Try running tests on all three operating systems * Try adding an MSVC build * Make tests work on Windows * Try reconfiguring Travis for this * Maybe it's because we're in git bash * Try explicitly doing something else for travis * Remove a part I think is unnecessary * Run the test EXEs as they compile	2019-07-31 17:22:33 -05:00
Ben Visness	f376f2a2a7	Add test coverage macros (#104 ) * Add coverage features and add it, laboriously, to everything * Fix easy tests * Add tests for != operators * Clean up test framework a little * Add documentation of coverage macros * Fix tests for mat4 to quaternion * Slightly improve formatting of coverage output * Trailing whitespace must die	2019-07-31 16:43:56 -05:00
Ben Visness	78e6feea82	Add HMM_Mat4ToQuaternion (#103 ) * Add mat4 to quaternion method * Capitalize variables	2019-07-31 16:38:03 -05:00
Zak Strange	21aa828a08	Fixed issue related to unsigned/signed-ness of HMM_Power (#102 ) * Fixed issue related to unsigned/signed-ness of HMM_Power * Fixes missing braces around initializer warning with -Weverything with GCC.	2019-07-17 14:48:59 -07:00
Ben Visness	93e56be543	Use vertical instead of horizontal FOV in HMM_Perspective (#101 ) * Use vertical instead of horizontal FOV * Update readme * Fix tests	2019-07-10 11:29:51 -05:00
Ben Visness	45c91702a9	Added SSE support for Quaternion operations (#97 ) (#98 ) * Added SSE support for Quaternion operations (#97) * Added SSE support for Quaternion operations O2 \| Function \| SSE \| NO SSE \| ==================================================== \| Inverse \| 163 (0.89s) \| 165 (1.89s) \| \| NLerp \| 330 (1.70s) \| 330 (1.75s) \| \| Normalize \| 169 (1.03s) \| 169 (1.06s) \| \| Dot \| 22 (1.15s) \| 23 (1.14s) \| \| DivF \| 23 (0.72s) \| 23 (0.82s) \| \| MulF \| 22 (0.75s) \| 22 (0.79s) \| \| Mul \| 24 (1.14s) \| 23 (1.24s) \| \| Sub \| 23 (1.17s) \| 37 (1.20s) \| \| Add \| 23 (1.20s) \| 24 (1.19s) \| O0 \| Function \| SSE \| NO SSE \| ==================================================== \| Inverse \| 394 (1.62s) \| 430 (3.05s) \| \| NLerp \| 694 (2.71s) \| 1035(4.81s) \| \| Normalize \| 374 (1.58s) \| 412 (2.95s) \| \| Dot \| 81 (1.83s) \| 23 (2.50s) \| \| DivF \| 61 (1.12s) \| 25 (2.37s) \| \| MulF \| 58 (1.09s) \| 23 (2.31s) \| \| Mul \| 94 (1.97s) \| 42 (2.88s) \| \| Sub \| 75 (1.83s) \| 23 (2.82s) \| \| Add \| 75 (1.81s) \| 23 (2.81s) \| * Fixed quaternion multiplication Old quaternion multiplication had a bug, this is a different approach. * Added release notes and version for 1.9.0	2019-03-11 13:12:48 -05:00
Ben Visness	f7c8e1f7d1	Add fast vector normalization (#94 ) * Add fast normalization routines * Update readme and remove version history from main file * Update version at top of file	2018-11-29 22:02:41 -08:00
Ben Visness	5ca1d58b36	Improve grammar/spelling	2018-11-29 13:21:05 -06:00
Zak Strange	5bf727dbd5	Removed copy in operator[] (#93 ) * Removed copy in operator[] * Updated version info	2018-11-29 09:32:12 -08:00
Ben Visness	295f6c476f	Rename Rows to Columns on hmm_mat4 (#91 )	2018-08-17 11:02:44 -07:00
Ben Visness	e095aefaf7	Bump file version	2018-06-10 15:32:12 -04:00
Ben Visness	4e2f47db55	Add array subscript operators for all types (#88 ) * Add array subscript operators for all types * Taking the parameter for the operator[] as a reference. This should allow it to be inlined * I guess you can't do that. * Update version and readme	2018-06-10 15:26:48 -04:00
Ben Visness	bee0e0c569	WIP: Properly initialize all elements of LookAt matrix (#84 ) * Properly initialize all elements of LookAt matrix * Update version and readme * Add a test for LookAt good enough	2018-06-03 18:42:09 -05:00
Ben Visness	f8b3a84cec	WIP: Make tests quite a lot nicer (#81 ) Make tests quite a lot nicer	2018-02-18 14:19:31 -06:00
IJzerbaard	77914405c3	Use SSE in HMM_MultiplyMat4ByVec4 (#77 ) Implements HMM_MultiplyMat4ByVec4 with HMM_LinearCombineSSE if SSE is enabled.	2018-02-11 13:24:39 -06:00
IJzerbaard	eb5c659148	Improve HMM_MultiplyMat4 (#76 ) Remove all transposes, (AT BT)T = BA	2018-02-10 17:59:07 -06:00
Ben Visness	52fd5cceb4	Update README.md	2017-10-31 19:28:59 -05:00
Ben Visness	8e67482295	Update README.md	2017-10-31 11:07:07 -05:00
Ben Visness	c508ce342b	Create LICENSE	2017-10-31 11:04:56 -05:00
Ben Visness	250c38e845	Update README.md	2017-10-31 11:01:31 -05:00
Ben Visness	4981d5ab89	Convert everything to new inline scheme (#57 ) (#72 ) * Convert everything to new inline scheme * Add both extern and inline for some SSE vs. non-SSE functions Some functions had nice, compact SSE implementations but bulky non-SSE implementations, so this commit inlines just the implementations that make sense. Also updated documentation. * Convert HINLINE and HEXTERN to HMM_INLINE and HMM_EXTERN	2017-10-31 10:16:36 -05:00
Ben Visness	5f173e0176	Update CONTRIBUTING.md	2017-10-31 10:09:27 -05:00
Ben Visness	575fcb767d	Update README.md	2017-10-31 10:06:22 -05:00
strangezak	a08262b2d9	Removed old instructions	2017-10-14 19:34:51 -07:00
strangezak	53bc939d8e	Updated email	2017-10-04 09:40:31 -07:00
Ben Visness	7eb4ae1846	Update README for 1.4.0	2017-10-02 11:17:11 -05:00
StrangeZak	48bd24b05e	Updated docs	2017-10-01 10:32:53 -07:00
Zak Strange	064baeb5b9	V1.4 - SSE upgrades and bug fixes (#70 ) * Fixed bug when using handmademath in C mode * SSEd vec4 operations * Fixed hmm_vec4 for non-sse builds. Added SSE option for HMM_Vec4 to load in one instruction * Whoops. We were loading in the wrong order * SSEd more things * SSEd more functions * Minor fixups * SSE'd hmm_vec4 initialization * Removed zeroing * Vector normalization should be zero'd * Removed old comments	2017-09-30 14:38:28 -07:00
Ben Visness	afd726ab0b	Automatically include C++ definitions (#67 )	2017-08-02 10:12:06 -05:00
strangezak	98fffbd7cc	Forgot to update version	2017-07-16 21:29:26 -07:00
Ben Visness	efd9f2f4b7	Matrix Multiply SSE (#65 ) * SSEd HMM_MultiplyMat4 and HMM_Transpose. And added HMM_LinearCombineSSE * Maybe Travis doesn't support SSE? * Fix compile process so the SSE option is consistently defined * Fix link error * Documentation * Added function prototype for operator == * Added != operator for hmm_vec2, hmm_vec3, hmm_vec4 * Add C versions of equality checks Also made the C++ tests actually run...😳 * Update documentation	2017-07-16 21:19:34 -07:00
Ben Visness	c8ada18370	Update README for 1.1.5	2017-06-21 09:31:20 -05:00
Zak Strange	70ac2b7e5b	1.1.5 (#64 ) * Added Width, and Height to hmm_vec2, and fixed SqrtF when compiling without the CRT * Syntax error * Test all the vector access methods	2017-06-14 20:49:44 -07:00
Ben Visness	924ee43923	Update history to include @DanielGibson's SSE fixes	2017-06-13 11:39:42 -05:00
Ben Visness	440b885d59	Update version to 1.1.4	2017-06-13 11:26:46 -05:00
Emil Lauridsen	98f535aeec	Handle zero-vector normalization. (#63 ) * Handle zero-vector normalization. When normalizing a vectors, we have to check whether vector length is not zero, to avoid dividing by zero when normalizing zero-vectors. * Test for normalization of zero vectors	2017-06-13 11:21:55 -05:00
Ben Visness	09524f72ed	Merge branch 'sse-testing' # Conflicts: # HandmadeMath.h	2017-06-11 18:54:06 -05:00
Emil Lauridsen	be30046a5a	C89 style comments (#62 )	2017-06-11 10:32:46 -07:00
Daniel Gibson	ff4513ff33	Make it usable on non-SSE platforms (#60 ) * at one place HANDMADE_NO_SSE instead of HANDMADE_MATH_NO_SSE was used * introduce HANDMADE_MATH__USE_SSE for the SSE #ifdefs throughout code - use #ifdef HANDMADE_MATH_NO_SSE at only one place * only use SSE (#define HANDMADE_MATH__USE_SSE) if the targetplatform actually supports it => users don't have to #define HANDMADE_MATH_NO_SSE on ARM etc * at one place HMM_SqrtF instead of HMM_SquareRootF was used	2017-06-09 17:14:24 -07:00
Ben Visness	364569abe9	Fix wrong name for square root function	2017-06-09 10:43:11 -05:00
Ben Visness	a9972e71da	Test both with and without SSE	2017-06-09 10:37:38 -05:00