Removed glm. Some opt. on hash.

10 files changed, 46 insertions, 1126 deletions

diff --git a/benchmark.c b/benchmark.c
index c7fbc956..8672e1ca 100644
--- a/benchmark.c
+++ b/benchmark.c
@@ -14,13 +14,19 @@
 

 // Visual Studio: compile with -TP to force C++:  cl -TP -EHsc -O2 benchmark.c

 

-declare_CMap(ii, int64_t, int64_t, c_noDestroy, c_lowbias32Hash);

+

+static inline uint32_t fibonacci_hash(const void* data, size_t len) {

+    const uint64_t key = *(const uint64_t *) data;

+    return (uint32_t) (key * 11400714819323198485llu);

+}

+declare_CMap(ii, int64_t, int64_t, c_noDestroy, fibonacci_hash); // c_lowbias32Hash);

 

 KHASH_MAP_INIT_INT64(ii, uint64_t)

 

-const size_t seed = 123; // time(NULL);

-const double maxLoadFactor = 0.77;

-#define SEED(s) sfc64_t rng = sfc64_seed(s)

+size_t seed = 1234;

+static const double maxLoadFactor = 0.77;

+sfc64_t rng;

+#define SEED(s) rng = sfc64_seed(seed)

 #define RAND(N) (sfc64_rand(&rng) & ((1 << N) - 1))

 

 //#define SEED(s) mt19937_t rng = mt19937_seed(s)

@@ -86,6 +92,7 @@ int rr = RR;
 { \

     M##_SETUP(tag, int64_t, int64_t); \

     uint64_t checksum = 0, erased = 0; \

+    seed = time(NULL); \

     SEED(seed); \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N1; ++i) { \

@@ -101,13 +108,30 @@ int rr = RR;
 #define MAP_TEST2(M, tag) \

 { \

     M##_SETUP(tag, int64_t, int64_t); \

-    SEED(seed); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N2; ++i) \

-        M##_PUT(tag, i*17, i); \

+        M##_PUT(tag, i, i); \

     for (size_t i = 0; i < N2; ++i) \

-        erased += M##_ERASE(tag, i*17); \

+        erased += M##_ERASE(tag, i); \

+    difference = clock() - before; \

+    printf(#M "(" #tag "): sz: %zu, bucks: %zu, time: %.02f, erase %zu\n", \

+           M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

+    M##_CLEAR(tag); \

+}

+

+#define MAP_TEST3(M, tag) \

+{ \

+    M##_SETUP(tag, int64_t, int64_t); \

+    size_t erased = 0; \

+    seed = time(NULL); \

+    clock_t difference, before = clock(); \

+    SEED(seed); \

+    for (size_t i = 0; i < N2; ++i) \

+        M##_PUT(tag, RAND(rr), i); \

+    SEED(seed); \

+    for (size_t i = 0; i < N2; ++i) \

+        erased += M##_ERASE(tag, RAND(rr)); \

     difference = clock() - before; \

     printf(#M "(" #tag "): sz: %zu, bucks: %zu, time: %.02f, erase %zu\n", \

            M##_SIZE(tag), M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

@@ -128,7 +152,7 @@ int main(int argc, char* argv[])
     MAP_TEST1(RMAP, ii)

 #endif

 

-    printf("\nmap<uint64_t, uint64_t>: Insert %zu keys, THEN remove them in same order:\n", N2);

+    printf("\nmap<uint64_t, uint64_t>: Insert %zu linear keys, THEN remove them in same order:\n", N2);

     MAP_TEST2(CMAP, ii)

     MAP_TEST2(KMAP, ii)

 #ifdef __cplusplus

@@ -137,4 +161,14 @@ int main(int argc, char* argv[])
     MAP_TEST2(FMAP, ii)

     MAP_TEST2(RMAP, ii)

 #endif

+

+    printf("\nmap<uint64_t, uint64_t>: Insert %zu random keys, THEN remove them in same order:\n", N2);

+    MAP_TEST3(CMAP, ii)

+    MAP_TEST3(KMAP, ii)

+#ifdef __cplusplus

+    MAP_TEST3(UMAP, ii)

+    MAP_TEST3(BMAP, ii)

+    MAP_TEST3(FMAP, ii)

+    MAP_TEST3(RMAP, ii)

+#endif

 }

diff --git a/glm/mat3.h b/glm/mat3.h
deleted file mode 100644
index ad9e03ea..00000000
--- a/glm/mat3.h
+++ /dev/null
@@ -1,137 +0,0 @@
-// MIT License
-//
-// Copyright (c) 2020 Tyge Løvset, NORCE, www.norceresearch.no
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#ifndef GLM_MAT3__H__
-#define GLM_MAT3__H__
-
-#include "vec3.h"
-
-#define glm_mat3_identity_init {1, 0, 0,  0, 1, 0,  0, 0, 1}
-#define glm_mat3_zero_init     {0, 0, 0,  0, 0, 0,  0, 0, 0}
-                              
-#define glm_mat3f_identity     ((glm_mat3f) glm_mat3_identity_init)
-#define glm_mat3d_identity     ((glm_mat3d) glm_mat3_identity_init)
-#define glm_mat3f_zero         ((glm_mat3f) glm_mat3_zero_init)
-#define glm_mat3d_zero         ((glm_mat3d) glm_mat3_zero_init)
-
-#define declare_glm_mat3(tag, T) \
-    typedef const T (*glm_mat3##tag##m)[3]; \
- \
-    typedef union glm_mat3##tag { \
-        glm_vec3##tag v[3]; \
-        T m[3][3], arr[3*3]; \
-    } glm_mat3##tag; \
- \
-    static inline glm_mat3##tag \
-    glm_mat3##tag##_mult(glm_mat3##tag##m m1, glm_mat3##tag##m m2) { \
-        const T *a = m1[0], *b = m2[0]; \
-        return (glm_mat3##tag) { \
-            a[0] * b[0] + a[3] * b[1] + a[6] * b[2], \
-            a[1] * b[0] + a[4] * b[1] + a[7] * b[2], \
-            a[2] * b[0] + a[5] * b[1] + a[8] * b[2], \
-            a[0] * b[3] + a[3] * b[4] + a[6] * b[5], \
-            a[1] * b[3] + a[4] * b[4] + a[7] * b[5], \
-            a[2] * b[3] + a[5] * b[4] + a[8] * b[5], \
-            a[0] * b[6] + a[3] * b[7] + a[6] * b[8], \
-            a[1] * b[6] + a[4] * b[7] + a[7] * b[8], \
-            a[2] * b[6] + a[5] * b[7] + a[8] * b[8], \
-        }; \
-    } \
- \
-    static inline glm_mat3##tag* \
-    glm_mat3##tag##_scale(glm_mat3##tag* self, T s) { \
-        T* a = self->arr; \
-        a[0] *= s, a[1] *= s, a[2] *= s, \
-        a[3] *= s, a[4] *= s, a[5] *= s, \
-        a[6] *= s, a[7] *= s, a[8] *= s; \
-        return self; \
-    } \
-    static inline glm_mat3##tag \
-    glm_mat3##tag##_scalarMult(glm_mat3##tag##m m, T s) { \
-        glm_mat3##tag dst; \
-        T *c = dst.arr; const T *a = m[0]; \
-        for (int i = 0; i < 9; ++i) *c++ = *a++ * s; \
-        return dst; \
-    } \
-    static inline glm_mat3##tag \
-    glm_mat3##tag##_compMult(glm_mat3##tag##m m1, glm_mat3##tag##m m2) { \
-        glm_mat3##tag dst; \
-        T *c = dst.arr; const T *a = m1[0], *b = m2[0]; \
-        for (int i = 0; i < 9; ++i) *c++ = *a++ * *b++; \
-        return dst; \
-    } \
-    static inline glm_vec3##tag \
-    glm_mat3##tag##_vecMult(glm_mat3##tag##m m, glm_vec3##tag v) { \
-        return (glm_vec3##tag) { \
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z, \
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z, \
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z, \
-        }; \
-    } \
- \
-    static inline glm_mat3##tag \
-    glm_mat3##tag##_transpose(glm_mat3##tag##m m) { \
-        return (glm_mat3##tag) { \
-            m[0][0], m[1][0], m[2][0], \
-            m[0][1], m[1][1], m[2][1], \
-            m[0][2], m[1][2], m[2][2], \
-        }; \
-    } \
- \
-    static inline T \
-    glm_mat3##tag##_trace(glm_mat3##tag##m m) { \
-        return m[0][0] + m[1][1] + m[2][2]; \
-    } \
- \
- \
-    static inline T \
-    glm_mat3##tag##_determinant(glm_mat3##tag##m m) { \
-        const T *a = m[0]; \
-        return a[0] * (a[4] * a[8] - a[7] * a[5]) \
-             - a[3] * (a[1] * a[8] - a[2] * a[7]) \
-             + a[6] * (a[1] * a[5] - a[2] * a[4]); \
-    } \
- \
-    static inline glm_mat3##tag \
-    glm_mat3##tag##_inverse(glm_mat3##tag##m m) { \
-        const T *a = m[0]; \
-        T k = 1.0f / glm_mat3##tag##_determinant(m); \
-        return (glm_mat3##tag) { \
-             (a[4] * a[8] - a[5] * a[7]) * k, \
-            -(a[1] * a[8] - a[7] * a[2]) * k, \
-             (a[1] * a[5] - a[4] * a[2]) * k, \
-            -(a[3] * a[8] - a[6] * a[5]) * k, \
-             (a[0] * a[8] - a[2] * a[6]) * k, \
-            -(a[0] * a[5] - a[3] * a[2]) * k, \
-             (a[3] * a[7] - a[6] * a[4]) * k, \
-            -(a[0] * a[7] - a[6] * a[1]) * k, \
-             (a[0] * a[4] - a[1] * a[3]) * k, \
-        }; \
-    }  \
- \
-    typedef T glm_mat3##tag##_value_t
-
-declare_glm_mat3(d, double);
-declare_glm_mat3(f, float);
-
-
-#endif
diff --git a/glm/mat4.h b/glm/mat4.h
deleted file mode 100644
index 34638ec5..00000000
--- a/glm/mat4.h
+++ /dev/null
@@ -1,204 +0,0 @@
-// MIT License
-//
-// Copyright (c) 2020 Tyge Løvset, NORCE, www.norceresearch.no
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#ifndef GLM_MAT4__H__
-#define GLM_MAT4__H__
-
-#include "mat3.h"
-#include "vec4.h"
-
-#define glm_mat4_identity_init {1, 0, 0, 0,  0, 1, 0, 0, \
-                             0, 0, 1, 0,  0, 0, 0, 1}
-#define glm_mat4_zero_init     {0, 0, 0, 0,  0, 0, 0, 0, \
-                             0, 0, 0, 0,  0, 0, 0, 0}
-                              
-#define glm_mat4f_identity     ((glm_mat4f) glm_mat4_identity_init)
-#define glm_mat4d_identity     ((glm_mat4d) glm_mat4_identity_init)
-#define glm_mat4f_zero         ((glm_mat4f) glm_mat4_zero_init)
-#define glm_mat4d_zero         ((glm_mat4d) glm_mat4_zero_init)
-
-#define declare_glm_mat4(tag, T) \
-    typedef const T (*glm_mat4##tag##m)[4]; \
- \
-    typedef union glm_mat4##tag { \
-        glm_vec4##tag v[4]; \
-        T m[4][4], arr[4*4]; \
-    } glm_mat4##tag; \
- \
-    static inline glm_mat4##tag \
-    glm_mat4##tag##_mult(glm_mat4##tag##m mat1, glm_mat4##tag##m mat2) { \
-        const T *a = mat1[0], *b = mat2[0]; \
-        return (glm_mat4##tag) { \
-            a[ 0] * b[ 0] + a[ 4] * b[ 1] + a[ 8] * b[ 2] + a[12] * b[ 3], \
-            a[ 1] * b[ 0] + a[ 5] * b[ 1] + a[ 9] * b[ 2] + a[13] * b[ 3], \
-            a[ 2] * b[ 0] + a[ 6] * b[ 1] + a[10] * b[ 2] + a[14] * b[ 3], \
-            a[ 3] * b[ 0] + a[ 7] * b[ 1] + a[11] * b[ 2] + a[15] * b[ 3], \
-            a[ 0] * b[ 4] + a[ 4] * b[ 5] + a[ 8] * b[ 6] + a[12] * b[ 7], \
-            a[ 1] * b[ 4] + a[ 5] * b[ 5] + a[ 9] * b[ 6] + a[13] * b[ 7], \
-            a[ 2] * b[ 4] + a[ 6] * b[ 5] + a[10] * b[ 6] + a[14] * b[ 7], \
-            a[ 3] * b[ 4] + a[ 7] * b[ 5] + a[11] * b[ 6] + a[15] * b[ 7], \
-            a[ 0] * b[ 8] + a[ 4] * b[ 9] + a[ 8] * b[10] + a[12] * b[11], \
-            a[ 1] * b[ 8] + a[ 5] * b[ 9] + a[ 9] * b[10] + a[13] * b[11], \
-            a[ 2] * b[ 8] + a[ 6] * b[ 9] + a[10] * b[10] + a[14] * b[11], \
-            a[ 3] * b[ 8] + a[ 7] * b[ 9] + a[11] * b[10] + a[15] * b[11], \
-            a[ 0] * b[12] + a[ 4] * b[13] + a[ 8] * b[14] + a[12] * b[15], \
-            a[ 1] * b[12] + a[ 5] * b[13] + a[ 9] * b[14] + a[13] * b[15], \
-            a[ 2] * b[12] + a[ 6] * b[13] + a[10] * b[14] + a[14] * b[15], \
-            a[ 3] * b[12] + a[ 7] * b[13] + a[11] * b[14] + a[15] * b[15], \
-        }; \
-    } \
- \
-    static inline glm_mat4##tag* \
-    glm_mat4##tag##_scale(glm_mat4##tag* self, T s) { \
-        T* a = self->arr; \
-        for (int i = 0; i < 16; ++i) *a++ *= s; \
-        return self; \
-    } \
-    static inline glm_mat4##tag \
-    glm_mat4##tag##_scalarMult(glm_mat4##tag##m m, T s) { \
-        glm_mat4##tag dst; \
-        T *c = dst.arr; const T *a = m[0]; \
-        for (int i = 0; i < 16; ++i) *c++ = *a++ * s; \
-        return dst; \
-    } \
-    static inline glm_mat4##tag \
-    glm_mat4##tag##_compMult(glm_mat4##tag##m m1, glm_mat4##tag##m m2) { \
-        glm_mat4##tag dst; \
-        T *c = dst.arr; const T *a = m1[0], *b = m2[0]; \
-        for (int i = 0; i < 16; ++i) *c++ = *a++ * *b++; \
-        return dst; \
-    } \
-    static inline glm_vec4##tag \
-    glm_mat4##tag##_vecMult(glm_mat4##tag##m m, glm_vec4##tag v) { \
-        return (glm_vec4##tag) { \
-            m[0][0] * v.x + m[1][0] * v.y + m[2][0] * v.z + m[3][0] * v.w, \
-            m[0][1] * v.x + m[1][1] * v.y + m[2][1] * v.z + m[3][1] * v.w, \
-            m[0][2] * v.x + m[1][2] * v.y + m[2][2] * v.z + m[3][2] * v.w, \
-            m[0][3] * v.x + m[1][3] * v.y + m[2][3] * v.z + m[3][3] * v.w, \
-        }; \
-    } \
- \
-    static inline glm_mat4##tag \
-    glm_mat4##tag##_transpose(glm_mat4##tag##m m) { \
-        return (glm_mat4##tag) { \
-            m[0][0], m[1][0], m[2][0], m[3][0], \
-            m[0][1], m[1][1], m[2][1], m[3][1], \
-            m[0][2], m[1][2], m[2][2], m[3][2], \
-            m[0][3], m[1][3], m[2][3], m[3][3], \
-        }; \
-    } \
- \
-    static inline glm_mat3##tag \
-    glm_mat4##tag##_transpose3(glm_mat4##tag##m m) { \
-        return (glm_mat3##tag) { \
-            m[0][0], m[1][0], m[2][0], \
-            m[0][1], m[1][1], m[2][1], \
-            m[0][2], m[1][2], m[2][2], \
-        }; \
-    } \
- \
-    static inline glm_mat3##tag \
-    glm_mat4##tag##_to3(glm_mat4##tag##m m) { \
-        return (glm_mat3##tag) { \
-            m[0][0], m[0][1], m[0][2], \
-            m[1][0], m[1][1], m[1][2], \
-            m[2][0], m[2][1], m[2][2], \
-        }; \
-    } \
- \
-    static inline T \
-    glm_mat4##tag##_trace(glm_mat4##tag##m m) { \
-        return m[0][0] + m[1][1] + m[2][2] + m[3][3]; \
-    } \
- \
-    static inline T \
-    glm_mat4##tag##_determinant(glm_mat4##tag##m mat) { \
-        const T *p = mat[0]; \
-        T a, b, c, d, e, f; \
-        a = p[10] * p[15] - p[14] * p[11], \
-        b = p[ 9] * p[15] - p[13] * p[11], \
-        c = p[ 9] * p[14] - p[13] * p[10], \
-        d = p[ 8] * p[15] - p[12] * p[11], \
-        e = p[ 8] * p[14] - p[12] * p[10], \
-        f = p[ 8] * p[13] - p[12] * p[ 9]; \
-        return p[0] * (p[5] * a - p[6] * b + p[7] * c) \
-             - p[1] * (p[4] * a - p[6] * d + p[7] * e) \
-             + p[2] * (p[4] * b - p[5] * d + p[7] * f) \
-             - p[3] * (p[4] * c - p[5] * e + p[6] * f); \
-    } \
- \
- \
-    static inline glm_mat4##tag \
-    glm_mat4##tag##_inverse(glm_mat4##tag##m mat) { \
-        glm_mat4##tag dst; \
-        const T *p = mat[0]; \
-        T a, b, c, d, e, f, det; \
-        a = p[10] * p[15] - p[14] * p[11], \
-        b = p[ 9] * p[15] - p[13] * p[11], \
-        c = p[ 9] * p[14] - p[13] * p[10], \
-        d = p[ 8] * p[15] - p[12] * p[11], \
-        e = p[ 8] * p[14] - p[12] * p[10], \
-        f = p[ 8] * p[13] - p[12] * p[ 9]; \
-        dst.m[0][0] =  (p[5] * a - p[6] * b + p[7] * c); \
-        dst.m[1][0] = -(p[4] * a - p[6] * d + p[7] * e); \
-        dst.m[2][0] =  (p[4] * b - p[5] * d + p[7] * f); \
-        dst.m[3][0] = -(p[4] * c - p[5] * e + p[6] * f); \
- \
-        dst.m[0][1] = -(p[1] * a - p[2] * b + p[3] * c); \
-        dst.m[1][1] =  (p[0] * a - p[2] * d + p[3] * e); \
-        dst.m[2][1] = -(p[0] * b - p[1] * d + p[3] * f); \
-        dst.m[3][1] =  (p[0] * c - p[1] * e + p[2] * f); \
- \
-        a = p[6] * p[15] - p[14] * p[7], \
-        b = p[5] * p[15] - p[13] * p[7], \
-        c = p[5] * p[14] - p[13] * p[6], \
-        d = p[4] * p[15] - p[12] * p[7], \
-        e = p[4] * p[14] - p[12] * p[6], \
-        f = p[4] * p[13] - p[12] * p[5]; \
-        dst.m[0][2] =  (p[1] * a - p[2] * b + p[3] * c); \
-        dst.m[1][2] = -(p[0] * a - p[2] * d + p[3] * e); \
-        dst.m[2][2] =  (p[0] * b - p[1] * d + p[3] * f); \
-        dst.m[3][2] = -(p[0] * c - p[1] * e + p[2] * f); \
- \
-        a = p[6] * p[11] - p[10] * p[7], \
-        b = p[5] * p[11] - p[ 9] * p[7], \
-        c = p[5] * p[10] - p[ 9] * p[6], \
-        d = p[4] * p[11] - p[ 8] * p[7], \
-        e = p[4] * p[10] - p[ 8] * p[6], \
-        f = p[4] * p[ 9] - p[ 8] * p[5]; \
-        dst.m[0][3] = -(p[1] * a - p[2] * b + p[3] * c); \
-        dst.m[1][3] =  (p[0] * a - p[2] * d + p[3] * e); \
-        dst.m[2][3] = -(p[0] * b - p[1] * d + p[3] * f); \
-        dst.m[3][3] =  (p[0] * c - p[1] * e + p[2] * f); \
- \
-        det = p[0] * dst.m[0][0] + p[1] * dst.m[1][0] \
-            + p[2] * dst.m[2][0] + p[3] * dst.m[3][0]; \
-        return *glm_mat4##tag##_scale(&dst, 1.0f / det); \
-    }  \
- \
-    typedef T glm_mat4##tag##_value_t
-
-declare_glm_mat4(d, double);
-declare_glm_mat4(f, float);
-
-
-#endif
diff --git a/glm/quat.h b/glm/quat.h
deleted file mode 100644
index 8a237237..00000000
--- a/glm/quat.h
+++ /dev/null
@@ -1,206 +0,0 @@
-// MIT License
-//
-// Copyright (c) 2020 Tyge Løvset, NORCE, www.norceresearch.no
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-#ifndef GLM_QUAT__H__
-#define GLM_QUAT__H__
-
-#include "mat4.h"
-
-#define glm_quat_arr(q)    (&(q).x)
-#define glm_quatf_identity ((glm_quatf) {0.f, 0.f, 0.f, 1.f})
-#define glm_quatd_identity ((glm_quatd) {0.0, 0.0, 0.0, 1.0})
-
-#define declare_glm_quat(tag, T) \
-    typedef glm_vec4##tag glm_quat##tag; \
- \
-    static inline glm_quat##tag \
-    glm_quat##tag##_init(T x, T y, T z, T w) { return (glm_quat##tag) {x, y, z, w}; } \
- \
-    static inline glm_quat##tag \
-    glm_quat##tag##_normalize(glm_quat##tag q) { \
-        T dot = _glm_vec4_DOT(q, q); \
-        if (dot <= 0.0f) return glm_quat##tag##_identity; \
-        return glm_vec4##tag##_mult(q, 1.0f / glm_sqrt_##tag(dot)); \
-    } \
-  \
-    static inline glm_quat##tag \
-    glm_quat##tag##_fromAxis(T angle, glm_vec3##tag axis) { \
-        T a = angle * 0.5f, c = glm_cos_##tag(a), s = glm_sin_##tag(a); \
-        glm_vec3##tag u = glm_vec3##tag##_normalize(axis); \
-        return (glm_quat##tag) {s * u.x, s * u.y, s * u.z, c}; \
-    } \
- \
-    static inline glm_quat##tag \
-    glm_quat##tag##_fromVectors(glm_vec3##tag u, glm_vec3##tag v) { \
-        T d = glm_sqrt_##tag(_glm_vec3_DOT(u, u) * _glm_vec3_DOT(v, v)); \
-        T real_part = d + _glm_vec3_DOT(u, v); \
-        glm_vec3##tag t; \
-        if (real_part < 1.e-6f * d) { \
-            /* If u and v are exactly opposite, rotate 180 degrees */ \
-            /* around an arbitrary orthogonal axis. */ \
-            real_part = 0; \
-            t = fabs(u.x) > fabs(u.z) ? (glm_vec3##tag) {-u.y, u.x, 0} : (glm_vec3##tag) {0, -u.z, u.y}; \
-        } else  /* Build quaternion the standard way.*/ \
-            t = (glm_vec3##tag) {_glm_vec3_CROSS(u, v)}; \
-        glm_quat##tag q = (glm_quat##tag) {t.x, t.y, t.z, real_part}; \
-        return glm_quat##tag##_normalize(q); \
-    } \
-  \
-    static inline glm_quat##tag \
-    glm_quat##tag##_fromMat4(glm_mat4##tag##m m) { \
-        T trace = m[0][0] + m[1][1] + m[2][2], r, rinv; \
-        glm_quat##tag dst; \
-        if (trace >= 0.0f) { \
-            r = glm_sqrt_##tag(1.0f + trace); \
-            rinv = 0.5f / r; \
-            dst.x = rinv * (m[1][2] - m[2][1]); \
-            dst.y = rinv * (m[2][0] - m[0][2]); \
-            dst.z = rinv * (m[0][1] - m[1][0]); \
-            dst.w = r * 0.5f; \
-        } else if (m[0][0] >= m[1][1] && m[0][0] >= m[2][2]) { \
-            r = glm_sqrt_##tag(1.0f + m[0][0] - m[1][1] - m[2][2]); \
-            rinv = 0.5f / r; \
-            dst.x = r * 0.5f; \
-            dst.y = rinv * (m[0][1] + m[1][0]); \
-            dst.z = rinv * (m[0][2] + m[2][0]); \
-            dst.w = rinv * (m[1][2] - m[2][1]); \
-        } else if (m[1][1] >= m[2][2]) { \
-            r = glm_sqrt_##tag(1.0f - m[0][0] + m[1][1] - m[2][2]); \
-            rinv = 0.5f / r; \
-            dst.x = rinv * (m[0][1] + m[1][0]); \
-            dst.y = r * 0.5f; \
-            dst.z = rinv * (m[1][2] + m[2][1]); \
-            dst.w = rinv * (m[2][0] - m[0][2]); \
-        } else { \
-            r = glm_sqrt_##tag(1.0f - m[0][0] - m[1][1] + m[2][2]); \
-            rinv = 0.5f / r; \
-            dst.x = rinv * (m[0][2] + m[2][0]); \
-            dst.y = rinv * (m[1][2] + m[2][1]); \
-            dst.z = r * 0.5f; \
-            dst.w = rinv * (m[0][1] - m[1][0]); \
-        } \
-        return dst; \
-    } \
- \
-    static inline glm_mat4##tag \
-    glm_quat##tag##_toMat4(glm_quat##tag q) { \
-        glm_mat4##tag dst; \
-        T norm = glm_quat##tag##_length(q), \
-          s  = norm > 0.0f ? 2.0f / norm : 0.0f, \
-          xx = s * q.x * q.x, xy = s * q.x * q.y, wx = s * q.w * q.x, \
-          yy = s * q.y * q.y, yz = s * q.y * q.z, wy = s * q.w * q.y, \
-          zz = s * q.z * q.z, xz = s * q.x * q.z, wz = s * q.w * q.z; \
- \
-        dst.m[0][0] = 1.0f - yy - zz; \
-        dst.m[1][1] = 1.0f - xx - zz; \
-        dst.m[2][2] = 1.0f - xx - yy; \
-        dst.m[0][1] = xy + wz; \
-        dst.m[1][2] = yz + wx; \
-        dst.m[2][0] = xz + wy; \
-        dst.m[1][0] = xy - wz; \
-        dst.m[2][1] = yz - wx; \
-        dst.m[0][2] = xz - wy; \
-        dst.m[0][3] = dst.m[1][3] = dst.m[2][3] = 0.0f; \
-        dst.m[3][0] = dst.m[3][1] = dst.m[3][2] = 0.0f; \
-        dst.m[3][3] = 1.0f; \
-        return dst; \
-    }  \
- \
-     static inline glm_quat##tag \
-    glm_quat##tag##_conjugate(glm_quat##tag q) { \
-        q.x = -q.x, q.y = -q.y, q.z = -q.z; \
-        return q; \
-    } \
- \
-    static inline glm_quat##tag \
-    glm_quat##tag##_cross(glm_quat##tag p, glm_quat##tag q) { \
-        return (glm_quat##tag) {p.w * q.x + p.x * q.w + p.y * q.z - p.z * q.y, \
-                                p.w * q.y - p.x * q.z + p.y * q.w + p.z * q.x, \
-                                p.w * q.z + p.x * q.y - p.y * q.x + p.z * q.w, \
-                                p.w * q.w - p.x * q.x - p.y * q.y - p.z * q.z}; \
-    } \
-    static inline glm_quat##tag \
-    glm_quat##tag##_inverse(glm_quat##tag q) { \
-        q.x = -q.x, q.y = -q.y, q.z = -q.z; \
-        return glm_vec4##tag##_mult(q, 1.0f / _glm_vec4_DOT(q, q)); \
-    } \
-    static inline T \
-    glm_quat##tag##_angle(glm_quat##tag q) { \
-        /* sin(theta / 2) = length(x*x + y*y + z*z) */ \
-        /* cos(theta / 2) = w */ \
-        /* theta          = 2 * atan(sin(theta / 2) / cos(theta / 2)) */ \
-        return 2.0f * glm_atan2_##tag(glm_sqrt_##tag(_glm_vec3_DOT(q, q)), q.w); \
-    } \
-    static inline T \
-    glm_quat##tag##_imagLength(glm_quat##tag q) { \
-        return glm_sqrt_##tag(_glm_vec3_DOT(q, q)); \
-    } \
-    typedef T glm_quat##tag##_value_t
-
-#define glm_quatf_fromArray(arr) glm_vec4f_fromArray(arr)
-#define glm_quatd_fromArray(arr) glm_vec4d_fromArray(arr)
-
-#define glm_quatf_assign(q, x, y, z, w) glm_vec4f_assign(q, x, y, z, w)
-#define glm_quatd_assign(q, x, y, z, w) glm_vec4d_assign(q, x, y, z, w)
-
-#define glm_quatf_assignArray(q, arr) glm_vec4f_assignArray(q, arr)
-#define glm_quatd_assignArray(q, arr) glm_vec4d_assignArray(q, arr)
-
-#define glm_quatf_length(q) glm_vec4f_length(q)
-#define glm_quatd_length(q) glm_vec4d_length(q)
-
-#define glm_quatf_length2(q) glm_vec4f_length2(q)
-#define glm_quatd_length2(q) glm_vec4d_length2(q)
-
-#define glm_quatf_dot(p, q) glm_vec4f_dot(p, q)
-#define glm_quatd_dot(p, q) glm_vec4d_dot(p, q)
-
-#define glm_quatf_lerp(p, q, t) glm_vec4f_lerp(p, q, t)
-#define glm_quatd_lerp(p, q, t) glm_vec4d_lerp(p, q, t)
-
-#define glm_quatf_swizzle(q, swz) glm_vec4f_swizzle(q, swz)
-#define glm_quatd_swizzle(q, swz) glm_vec4d_swizzle(q, swz)
-
-#define glm_quatf_equals(p, q) glm_vec4f_equals(p, q)
-#define glm_quatd_equals(p, q) glm_vec4d_equals(p, q)
-
-#define glm_quatf_compare(p, q) glm_vec4f_compare(p, q)
-#define glm_quatd_compare(p, q) glm_vec4d_compare(p, q)
-
-#define glm_quatf_imag(q) glm_vec4f_to3(q)
-#define glm_quatd_imag(q) glm_vec4d_to3(q)
-
-#define glm_quatf_real(q) ((float) (q).w)
-#define glm_quatd_real(q) ((double) (q).w)
-
-declare_glm_quat(f, float);
-declare_glm_quat(d, double);
-
-
-static inline glm_quatd glm_quatf_tod(glm_quatf v) {
-    return (glm_quatd) {v.x, v.y, v.z, v.w};
-}
-static inline glm_quatf glm_quatd_tof(glm_quatd v) {
-    return (glm_quatf) {(float) v.x, (float) v.y, (float) v.z, (float) v.w};
-}
-
-#endif
diff --git a/glm/transform.h b/glm/transform.h
deleted file mode 100644
index 29053453..00000000
--- a/glm/transform.h
+++ /dev/null
@@ -1,155 +0,0 @@
-#include "mat4.h"
-
-#define declare_mat4_transform(tag, T) \
-    /* right handed, opengl spec functions */ \
- \
-    static inline glm_mat4##tag glm_mat4##tag_##ortho(T left, T right, T bottom, T top, T zNear, T zFar) \
-    { \
-        glm_mat4##tag dst = glm_mat4##tag##_identity; \
-        dst.m[0][0] = 2.0f / (right - left); \
-        dst.m[1][1] = 2.0f / (top - bottom); \
-        dst.m[2][2] = -2.0f / (zFar - zNear); \
-        dst.m[3][0] = -(right + left) / (right - left); \
-        dst.m[3][1] = -(top + bottom) / (top - bottom); \
-        dst.m[3][2] = -(zFar + zNear) / (zFar - zNear); \
-        return dst; \
-    } \
- \
-    static inline glm_mat4##tag glm_mat4##tag_##frustum(T left, T right, T bottom, T top, T nearVal, T farVal) \
-    { \
-        glm_mat4##tag dst = glm_mat4##tag##_zero; \
-        dst.m[0][0] = (2.0f * nearVal) / (right - left); \
-        dst.m[1][1] = (2.0f * nearVal) / (top - bottom); \
-        dst.m[2][0] = (right + left) / (right - left); \
-        dst.m[2][1] = (top + bottom) / (top - bottom); \
-        dst.m[2][2] = -(farVal + nearVal) / (farVal - nearVal); \
-        dst.m[2][3] = -1.0f; \
-        dst.m[3][2] = -(2.0f * farVal * nearVal) / (farVal - nearVal); \
-        return dst; \
-    } \
-     \
-    static inline glm_mat4##tag glm_mat4##tag##_perspective(T fovy, T aspect, T zNear, T zFar) \
-    { \
-        const T tanHalfFovy = glm_tan_##tag(fovy / 2.0f); \
- \
-        glm_mat4##tag dst = glm_mat4##tag##_zero; \
-        dst.m[0][0] = 1.0f / (aspect * tanHalfFovy); \
-        dst.m[1][1] = 1.0f / (tanHalfFovy); \
-        dst.m[2][2] = -(zFar + zNear) / (zFar - zNear); \
-        dst.m[2][3] = -1.0f; \
-        dst.m[3][2] = -(2.0f * zFar * zNear) / (zFar - zNear); \
-        return dst; \
-    }     \
-     \
-    static inline glm_mat4##tag glm_mat4##tag_##perspectiveFov(T fov, T width, T height, T zNear, T zFar) \
-    { \
-        const T rad = fov; \
-        const T h = glm_cos_##tag(0.5f * rad) / glm_sin_##tag(0.5f * rad); \
-        const T w = h * height / width; /* todo max(width , Height) / min(width , Height)? */ \
- \
-        glm_mat4##tag dst = glm_mat4##tag##_zero; \
-        dst.m[0][0] = w; \
-        dst.m[1][1] = h; \
-        dst.m[2][2] = -(zFar + zNear) / (zFar - zNear); \
-        dst.m[2][3] = -1.0f; \
-        dst.m[3][2] = -(2.0f * zFar * zNear) / (zFar - zNear); \
-        return dst; \
-    }     \
-     \
-    static inline glm_mat4##tag glm_mat4##tag_##infinitePerspective(T fovy, T aspect, T zNear) \
-    { \
-        const T range = glm_tan_##tag(fovy / 2.0f) * zNear; \
-        const T left = -range * aspect; \
-        const T right = range * aspect; \
-        const T bottom = -range; \
-        const T top = range; \
- \
-        glm_mat4##tag dst = glm_mat4##tag##_zero; \
-        dst.m[0][0] = (2.0f * zNear) / (right - left); \
-        dst.m[1][1] = (2.0f * zNear) / (top - bottom); \
-        dst.m[2][2] = -1.0f; \
-        dst.m[2][3] = -1.0f; \
-        dst.m[3][2] = -2.0f * zNear; \
-        return dst; \
-    } \
- \
-    static inline glm_mat4##tag translate(const glm_mat4##tag##m m, glm_vec3##tag v) \
-    { \
-        glm_mat4##tag dst = *(const glm_mat4##tag *) m; \
-        glm_vec4##tag##_add(&dst.v[3], glm_vec4##tag##_mult(dst.v[0], v.x) \
-                                     + glm_vec4##tag##_mult(dst.v[1], v.y) \
-                                     + glm_vec4##tag##_mult(dst.v[2], v.z)); \
-        return dst; \
-    } \
- \
- \
-    static inline glm_mat4##tag rotate(glm_mat4##tag##m m, T angle, glm_vec3##tag v) \
-    { \
-        const T a = angle; \
-        const T c = glm_cos_##tag(a); \
-        const T s = glm_sin_##tag(a); \
- \
-        glm_vec3##tag axis = glm_vec3##tag##_normalize(v); \
-        glm_vec3##tag temp = glm_vec3##tag##_mult(axis, 1.0f - c); \
- \
-        glm_mat4##tag rot; \
-        rot.m[0][0] = c + temp.x * axis.x; \
-        rot.m[0][1] = temp.x * axis.y + s * axis.z; \
-        rot.m[0][2] = temp.x * axis.z - s * axis.y; \
- \
-        rot.m[1][0] = temp.y * axis.x - s * axis.z; \
-        rot.m[1][1] = c + temp.y * axis.y; \
-        rot.m[1][2] = temp.y * axis.z + s * axis.x; \
- \
-        rot.m[2][0] = temp.z * axis.x + s * axis.y; \
-        rot.m[2][1] = temp.z * axis.y - s * axis.x; \
-        rot.m[2][2] = c + temp.z * axis.z; \
- \
-        glm_mat4##tag dst; \
-        const glm_vec4##tag* mv = (const glm_vec4##tag *) m; \
-        dst.v[0] = glm_vec4##tag##_mult(mv[0], rot.m[0][0]) \
-                 + glm_vec4##tag##_mult(mv[1], rot.m[0][1]) \
-                 + glm_vec4##tag##_mult(mv[2], rot.m[0][2]); \
-        dst.v[1] = glm_vec4##tag##_mult(mv[0], rot.m[1][0]) \
-                 + glm_vec4##tag##_mult(mv[1], rot.m[1][1]) \
-                 + glm_vec4##tag##_mult(mv[2], rot.m[1][2]); \
-        dst.v[2] = glm_vec4##tag##_mult(mv[0], rot.m[2][0]) \
-                 + glm_vec4##tag##_mult(mv[1], rot.m[2][1]) \
-                 + glm_vec4##tag##_mult(mv[2], rot.m[2][2]); \
-        dst.v[3] = mv[3]; \
-        return dst; \
-    } \
- \
- \
-    static inline glm_mat4##tag scale(glm_mat4##tag##m m, glm_vec3##tag v) \
-    { \
-        glm_mat4##tag dst = glm_mat4##tag##_zero; \
-        const glm_vec4##tag* mv = (const glm_vec4##tag *) m; \
-        dst.v[0] = glm_vec4##tag##_mult(mv[0], v.x); \
-        dst.v[1] = glm_vec4##tag##_mult(mv[1], v.y); \
-        dst.v[2] = glm_vec4##tag##_mult(mv[2], v.z); \
-        dst.v[3] = mv[3]; \
-        return dst; \
-    } \
- \
-    static inline glm_mat4##tag lookAtRH(glm_vec3##tag eye, glm_vec3##tag center, glm_vec3##tag up) \
-    { \
-        const glm_vec3##tag f = glm_vec3##tag##_normalize(glm_vec3##tag##_minus(center, eye)); \
-        const glm_vec3##tag s = glm_vec3##tag##_normalize(glm_vec3##tag##_cross(f, up)); \
-        const glm_vec3##tag u = glm_vec3##tag##_cross(s, f); \
- \
-        glm_mat4##tag dst = glm_mat4##tag##_identity; \
-        dst.m[0][0] =  s.x; \
-        dst.m[1][0] =  s.y; \
-        dst.m[2][0] =  s.z; \
-        dst.m[0][1] =  u.x; \
-        dst.m[1][1] =  u.y; \
-        dst.m[2][1] =  u.z; \
-        dst.m[0][2] = -f.x; \
-        dst.m[1][2] = -f.y; \
-        dst.m[2][2] = -f.z; \
-        dst.m[3][0] = -glm_vec3##tag##_dot(s, eye); \
-        dst.m[3][1] = -glm_vec3##tag##_dot(u, eye); \
-        dst.m[3][2] =  glm_vec3##tag##_dot(f, eye); \
-        return dst; \
-    }
diff --git a/glm/vec3.h b/glm/vec3.h
deleted file mode 100644
index 1d4b0312..00000000
--- a/glm/vec3.h
+++ /dev/null
@@ -1,220 +0,0 @@
-// MIT License

-//

-// Copyright (c) 2020 Tyge Løvset, NORCE, www.norceresearch.no

-//

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

-//

-// The above copyright notice and this permission notice shall be included in all

-// copies or substantial portions of the Software.

-//

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

-// SOFTWARE.

-

-#ifndef GLM_VEC3__H__

-#define GLM_VEC3__H__

-

-#include <stdint.h>

-#include <stdbool.h>

-#include <math.h>

-

-#define glm_sqrt_f(x) sqrtf(x)

-#define glm_sqrt_d(x) sqrt(x)

-#define glm_sin_f(x) sinf(x)

-#define glm_sin_d(x) sin(x)

-#define glm_cos_f(x) cosf(x)

-#define glm_cos_d(x) cos(x)

-#define glm_atan2_f(x, y) atan2f(x, y)

-#define glm_atan2_d(x, y) atan2(x, y)

-

-#ifdef GLM_NO_ANONYMOUS_STRUCT

-#define _glm_VEC3(tag, T) struct glm_vec3##tag { T x, y, z; }

-#else

-#define _glm_VEC3(tag, T) union glm_vec3##tag { struct { T x, y, z; }; T arr[3]; }

-#endif

-

-#define glm_vec3_arr(v) (&(v).x)

-#define glm_vec3f_zero ((glm_vec3f) {0.f, 0.f, 0.f})

-#define glm_vec3d_zero ((glm_vec3d) {0.0, 0.0, 0.0})

-

-#define declare_glm_vec3(tag, T) \

-    typedef _glm_VEC3(tag, T) glm_vec3##tag; \

-    static glm_vec3##tag \

-    glm_vec3##tag##_axis[3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}; \

- \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_init(T x, T y, T z) { return (glm_vec3##tag) {x, y, z}; } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_fromArray(const T* a) { return (glm_vec3##tag) {a[0], a[1], a[2]}; } \

- \

-    static inline glm_vec3##tag* \

-    glm_vec3##tag##_assign(glm_vec3##tag* self, T x, T y, T z) { \

-         self->x = x, self->y = y, self->z = z; return self; \

-    } \

-    static inline glm_vec3##tag* \

-    glm_vec3##tag##_assignArray(glm_vec3##tag* self, const T* a) { \

-         self->x = a[0], self->y = a[1], self->z = a[2]; return self; \

-    } \

-    static inline glm_vec3##tag* \

-    glm_vec3##tag##_add(glm_vec3##tag* self, glm_vec3##tag v) { \

-         self->x += v.x, self->y += v.y, self->z += v.z; return self; \

-    } \

-    static inline glm_vec3##tag* \

-    glm_vec3##tag##_sub(glm_vec3##tag* self, glm_vec3##tag v) { \

-         self->x -= v.x, self->y -= v.y, self->z -= v.z; return self; \

-    } \

-    static inline glm_vec3##tag* \

-    glm_vec3##tag##_scale(glm_vec3##tag* self, T s) { \

-         self->x *= s, self->y *= s, self->z *= s; return self; \

-    } \

-    static inline T \

-    glm_vec3##tag##_length(glm_vec3##tag v) { \

-        return glm_sqrt_##tag(_glm_vec3_DOT(v, v)); \

-    } \

-    static inline T \

-    glm_vec3##tag##_length2(glm_vec3##tag v) { \

-        return _glm_vec3_DOT(v, v); \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_plus(glm_vec3##tag u, glm_vec3##tag v) { \

-        u.x += v.x, u.y += v.y, u.z += v.z; return u; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_minus(glm_vec3##tag u, glm_vec3##tag v) { \

-        u.x -= v.x, u.y -= v.y, u.z -= v.z; return u; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_mult(glm_vec3##tag v, T s) { \

-        v.x *= s, v.y *= s, v.z *= s; return v; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_neg(glm_vec3##tag v) { \

-        v.x = -v.x, v.y = -v.y, v.z = -v.z; return v; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_normalize(glm_vec3##tag v) { \

-        T s = 1.0f / glm_sqrt_##tag(_glm_vec3_DOT(v, v)); \

-        s; v.x *= s, v.y *= s, v.z *= s; \

-        return v; \

-    } \

-    static inline T \

-    glm_vec3##tag##_dot(glm_vec3##tag u, glm_vec3##tag v) { \

-        return _glm_vec3_DOT(u, v); \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_cross(glm_vec3##tag u, glm_vec3##tag v) { \

-        return (glm_vec3##tag) {_glm_vec3_CROSS(u, v)}; \

-    } \

-    static inline T \

-    glm_vec3##tag##_triple(glm_vec3##tag u, glm_vec3##tag v, glm_vec3##tag w) { \

-        glm_vec3##tag cross = {_glm_vec3_CROSS(u, v)}; \

-        return _glm_vec3_DOT(cross, w); \

-    } \

-    /* Reflect u on plane with given normal vector pn */ \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_reflect(glm_vec3##tag u, glm_vec3##tag pn) { \

-        T dot2 = 2.0f * _glm_vec3_DOT(u, pn); \

-        u.x -= dot2 * pn.x, u.y -= dot2 * pn.y, u.z -= dot2 * pn.z; \

-        return u; \

-    } \

-    /* Refract u incident on plane with given normal vector pn */ \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_refract(glm_vec3##tag u, glm_vec3##tag pn, T eta) { \

-        T dot = _glm_vec3_DOT(pn, u); \

-        T k = 1.0f - eta * eta * (1.0f - dot * dot); \

-        if (k < 0.0f) return glm_vec3##tag##_zero; \

-        glm_vec3##tag##_scale(&u, eta); \

-        glm_vec3##tag##_scale(&pn, eta * dot + glm_sqrt_##tag(k)); \

-        return *glm_vec3##tag##_sub(&u, pn); \

-    } \

-    static inline T \

-    glm_vec3##tag##_distance(glm_vec3##tag u, glm_vec3##tag v) { \

-        u.x -= v.x, u.y -= v.y, u.z -= v.z; \

-        return glm_sqrt_##tag(_glm_vec3_DOT(u, u)); \

-    } \

-    /* Signed distance between point u and a plane (pp, pn), pn normalized. */ \

-    static inline T \

-    glm_vec3##tag##_distanceToPlane(glm_vec3##tag u, glm_vec3##tag pp, glm_vec3##tag pn) { \

-        u.x -= pp.x, u.y -= pp.y, u.z -= pp.z; \

-        return _glm_vec3_DOT(u, pn); \

-    } \

-    /* Linear interpolation */ \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_lerp(glm_vec3##tag u, glm_vec3##tag v, T t) { \

-        T s = 1.0f - t; \

-        u.x = s*u.x + t*v.x, u.y = s*u.y + t*v.y, u.z = s*u.z + t*v.z; \

-        return u; \

-    } \

-    /* Swizzle */ \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_xzy(glm_vec3##tag u) { \

-        return (glm_vec3##tag) {u.x, u.z, u.y}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_yxz(glm_vec3##tag u) { \

-        return (glm_vec3##tag) {u.y, u.x, u.z}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_yzx(glm_vec3##tag u) { \

-        return (glm_vec3##tag) {u.y, u.z, u.x}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_zxy(glm_vec3##tag u) { \

-        return (glm_vec3##tag) {u.z, u.x, u.y}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_zyx(glm_vec3##tag u) { \

-        return (glm_vec3##tag) {u.z, u.y, u.x}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec3##tag##_swizzle(glm_vec3##tag u, const char* swz) { \

-        T* a = glm_vec3_arr(u); \

-        return (glm_vec3##tag) {a[swz[0] - 'x'], a[swz[1] - 'x'], a[swz[2] - 'x']}; \

-    } \

-    static inline bool \

-    glm_vec3##tag##_rayPlaneIntersection(glm_vec3##tag* out, glm_vec3##tag u, glm_vec3##tag dir, \

-                                                         glm_vec3##tag pp, glm_vec3##tag pn) { \

-        T d = _glm_vec3_DOT(dir, pn); if (d == 0) return false; \

-        T t = (_glm_vec3_DOT(pp, pn) - _glm_vec3_DOT(u, pn)) / d; \

-        if (t < 0) return false; \

-        u.x += dir.x*t, u.y += dir.y*t, u.z += dir.z*t; \

-        *out = u; return true; \

-    } \

-    static inline bool \

-    glm_vec3##tag##_equals(glm_vec3##tag u, glm_vec3##tag v) { \

-        if (u.x != v.x) return false; \

-        if (u.y != v.y) return false; \

-        return u.z == v.z; \

-    } \

-    static inline int \

-    glm_vec3##tag##_compare(glm_vec3##tag* u, glm_vec3##tag* v) { \

-        if (u->x != v->x)  return 1 - ((u->x < v->x)<<1); \

-        if (u->y != v->y)  return 1 - ((u->y < v->y)<<1); \

-        return u->z == v->z ? 0 : 1 - ((u->z < v->z)<<1); \

-    } \

-    typedef T glm_vec3##tag##_value_t

-

-#define _glm_vec3_DOT(u, v) (u.x*v.x + u.y*v.y + u.z*v.z)

-#define _glm_vec3_SUB(u, v) u.x - v.x, u.y - v.y, u.z - v.z

-#define _glm_vec3_CROSS(u, v) u.y*v.z - v.y*u.z, u.z*v.x - v.z*u.x, u.x*v.y - u.y*v.x

-    

-declare_glm_vec3(d, double);

-declare_glm_vec3(f, float);

-

-static inline glm_vec3f glm_vec3d_tof(glm_vec3d v) {

-    return (glm_vec3f) {(float) v.x, (float) v.y, (float) v.z};

-}

-static inline glm_vec3d glm_vec3f_tod(glm_vec3f v) {

-    return (glm_vec3d) {v.x, v.y, v.z};

-}

-

-#endif

diff --git a/glm/vec4.h b/glm/vec4.h
deleted file mode 100644
index 761b2237..00000000
--- a/glm/vec4.h
+++ /dev/null
@@ -1,191 +0,0 @@
-// MIT License

-//

-// Copyright (c) 2020 Tyge Løvset, NORCE, www.norceresearch.no

-//

-// Permission is hereby granted, free of charge, to any person obtaining a copy

-// of this software and associated documentation files (the "Software"), to deal

-// in the Software without restriction, including without limitation the rights

-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

-// copies of the Software, and to permit persons to whom the Software is

-// furnished to do so, subject to the following conditions:

-//

-// The above copyright notice and this permission notice shall be included in all

-// copies or substantial portions of the Software.

-//

-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

-// SOFTWARE.

-

-#ifndef GLM_VEC4__H__

-#define GLM_VEC4__H__

-

-#include "vec3.h"

-

-#ifdef GLM_NO_ANONYMOUS_STRUCT

-#define _glm_VEC4(tag, T) struct glm_vec4##tag { T x, y, z, w; }

-#else

-#define _glm_VEC4(tag, T) union glm_vec4##tag { struct { T x, y, z, w; }; T arr[4]; }

-#endif

-

-#define glm_vec4_arr(v) (&(v).x)

-#define glm_vec4f_zero ((glm_vec4f) {0.f, 0.f, 0.f, 0.f})

-#define glm_vec4d_zero ((glm_vec4d) {0.0, 0.0, 0.0, 0.0})

-

-#define declare_glm_vec4(tag, T) \

-    typedef _glm_VEC4(tag, T) glm_vec4##tag; \

-    static glm_vec4##tag glm_vec4##tag##_axis[4] = {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}; \

- \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_init(T x, T y, T z, T w) { return (glm_vec4##tag) {x, y, z, w}; } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_fromArray(const T* a) { return (glm_vec4##tag) {a[0], a[1], a[2], a[3]}; } \

- \

-    static inline glm_vec4##tag* \

-    glm_vec4##tag##_assign(glm_vec4##tag* self, T x, T y, T z, T w) { \

-         self->x = x, self->y = y, self->z = z, self->z = z, self->w = w; return self; \

-    } \

-    static inline glm_vec4##tag* \

-    glm_vec4##tag##_assignArray(glm_vec4##tag* self, const T* a) { \

-         self->x = a[0], self->y = a[1], self->z = a[2], self->w = a[3]; return self; \

-    } \

-    static inline glm_vec4##tag* \

-    glm_vec4##tag##_add(glm_vec4##tag* self, glm_vec4##tag v) { \

-         self->x += v.x, self->y += v.y, self->z += v.z, self->w += v.w; return self; \

-    } \

-    static inline glm_vec4##tag* \

-    glm_vec4##tag##_sub(glm_vec4##tag* self, glm_vec4##tag v) { \

-         self->x -= v.x, self->y -= v.y, self->z -= v.z, self->w -= v.w; return self; \

-    } \

-    static inline glm_vec4##tag* \

-    glm_vec4##tag##_scale(glm_vec4##tag* self, T s) { \

-         self->x *= s, self->y *= s, self->z *= s, self->w *= s; return self; \

-    } \

-    static inline T \

-    glm_vec4##tag##_length(glm_vec4##tag v) { \

-        return glm_sqrt_##tag(_glm_vec4_DOT(v, v)); \

-    } \

-    static inline T \

-    glm_vec4##tag##_length2(glm_vec4##tag v) { \

-        return _glm_vec4_DOT(v, v); \

-    } \

-    static inline T \

-    glm_vec4##tag##_distance(glm_vec4##tag u, glm_vec4##tag v) { \

-        u.x -= v.x, u.y -= v.y, u.z -= v.z, u.w -= v.w; \

-        return glm_sqrt_##tag(_glm_vec4_DOT(u, u)); \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_plus(glm_vec4##tag u, glm_vec4##tag v) { \

-        u.x += v.x, u.y += v.y, u.z += v.z, u.w += v.w; return u; \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_minus(glm_vec4##tag u, glm_vec4##tag v) { \

-        u.x -= v.x, u.y -= v.y, u.z -= v.z, u.w -= v.w; return u; \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_mult(glm_vec4##tag v, T s) { \

-        v.x *= s, v.y *= s, v.z *= s, v.w *= s; return v; \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_neg(glm_vec4##tag v) { \

-        v.x = -v.x, v.y = -v.y, v.z = -v.z, v.w = -v.w; return v; \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_normalize(glm_vec4##tag v) { \

-        T s = glm_sqrt_##tag(_glm_vec4_DOT(v, v)); \

-        if (s < 1e-8) return glm_vec4##tag##_zero; \

-        s = 1.0f / s; v.x *= s, v.y *= s, v.z *= s, v.w *= s; \

-        return v; \

-    } \

-    static inline T \

-    glm_vec4##tag##_dot(glm_vec4##tag u, glm_vec4##tag v) { \

-        return _glm_vec4_DOT(u, v); \

-    } \

-    static inline glm_vec4##tag \

-    glm_vec3##tag##_xyzw(glm_vec3##tag u, T w) { \

-        return (glm_vec4##tag) {u.x, u.y, u.z, w}; \

-    } \

-    /* Swizzle */ \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_xyz(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.x, u.y, u.z}; \

-    }; \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_xzy(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.x, u.z, u.y}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_yxz(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.y, u.x, u.z}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_yzx(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.y, u.z, u.x}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_zxy(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.z, u.x, u.y}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_zyx(glm_vec4##tag u) { \

-        return (glm_vec3##tag) {u.z, u.y, u.x}; \

-    } \

- \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_swizzle(glm_vec4##tag u, const char* swz) { \

-        const T* a = glm_vec4_arr(u); \

-        return (glm_vec4##tag) {a[(swz[0] - 'x') & 3], \

-                                a[(swz[1] - 'x') & 3], \

-                                a[(swz[2] - 'x') & 3], \

-                                a[(swz[3] - 'x') & 3]}; \

-    } \

-    static inline glm_vec3##tag \

-    glm_vec4##tag##_swizzle3(glm_vec4##tag u, const char* swz) { \

-        const T* a = glm_vec4_arr(u); \

-        return (glm_vec3##tag) {a[(swz[0] - 'x') & 3], \

-                                a[(swz[1] - 'x') & 3], \

-                                a[(swz[2] - 'x') & 3]}; \

-    } \

-    /* Linear interpolation */ \

-    static inline glm_vec4##tag \

-    glm_vec4##tag##_lerp(glm_vec4##tag u, glm_vec4##tag v, T t) { \

-        T s = 1.0f - t; \

-        u.x = s*u.x + t*v.x, u.y = s*u.y + t*v.y, \

-        u.z = s*u.z + t*v.z, u.w = s*u.w + t*v.w; \

-        return u; \

-    } \

-    static inline bool \

-    glm_vec4##tag##_equals(glm_vec4##tag u, glm_vec4##tag v) { \

-        if (u.x != v.x) return false; \

-        if (u.y != v.y) return false; \

-        if (u.z != v.z) return false; \

-        return u.w == v.w; \

-    } \

-    static inline int \

-    glm_vec4##tag##_compare(glm_vec4##tag* u, glm_vec4##tag* v) { \

-        if (u->x != v->x)  return 1 - ((u->x < v->x)<<1); \

-        if (u->y != v->y)  return 1 - ((u->y < v->y)<<1); \

-        if (u->z != v->z)  return 1 - ((u->z < v->z)<<1); \

-        return u->w == v->w ? 0 : 1 - ((u->w < v->w)<<1); \

-    } \

-    typedef T glm_vec4##tag##_value_t

-

-#define _glm_vec4_DOT(u, v) (u.x*v.x + u.y*v.y + u.z*v.z + u.w*v.w)

-#define _glm_vec4_SUB(u, v) u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w

-    

-declare_glm_vec4(d, double);

-declare_glm_vec4(f, float);

-

-static inline glm_vec4d

-glm_vec4f_tod(glm_vec4f v) {

-    return (glm_vec4d) {v.x, v.y, v.z, v.w};

-}

-static inline glm_vec4f

-glm_vec4d_tof(glm_vec4d v) {

-    return (glm_vec4f) {(float) v.x, (float) v.y, (float) v.z, (float) v.w};

-}

-

-#endif

diff --git a/stc/cdefs.h b/stc/cdefs.h
index a5201a25..3d5e5766 100644
--- a/stc/cdefs.h
+++ b/stc/cdefs.h
@@ -83,15 +83,13 @@ static inline uint32_t  c_defaultHash(const void *data, size_t len) {
 }

 

 /* https://nullprogram.com/blog/2018/07/31/: assume len positive multiple of 4 */

+/* https://probablydance.com/2018/06/16/fibonacci-hashing-the-optimization-that-the-world-forgot-or-a-better-alternative-to-integer-modulo/ */

 static inline uint32_t c_lowbias32Hash(const void *data, size_t len) {

     const volatile uint32_t *key = (const uint32_t *) data;

     uint32_t x = *key;

     do {

         x ^= *key++ >> 16;

         x *= UINT32_C(0x7feb352d);

-        //x ^= x >> 15;

-        //x *= UINT32_C(0x846ca68b);

-        //x ^= x >> 16;

     } while (len -= 4);

     return x;

 }

diff --git a/stc/cmap.h b/stc/cmap.h
index 5990dedf..cfe57519 100644
--- a/stc/cmap.h
+++ b/stc/cmap.h
@@ -275,8 +275,8 @@ cmap_##tag##_swap(CMap_##tag* a, CMap_##tag* b) { \
 } \

  \

 STC_API size_t \

-cmap_##tag##_reserve(CMap_##tag* self, size_t size) { \

-    size_t oldcap = cmap_bucketCount(*self), newcap = 1 + (size / 2) * 2; \

+cmap_##tag##_reserve(CMap_##tag* self, size_t newcap) { \

+    size_t oldcap = cmap_bucketCount(*self); newcap |= 1; \

     if (cmap_size(*self) >= newcap * self->maxLoadPercent * 0.01) return oldcap; \

     CMap_##tag tmp = { \

         c_new_2(CMapEntry_##tag, newcap), \

diff --git a/stc/cstring.h b/stc/cstring.h
index 9cbdcfb5..ca22c4d5 100644
--- a/stc/cstring.h
+++ b/stc/cstring.h
@@ -24,6 +24,7 @@
 #define CSTRING__H__

 

 #include <stdlib.h> /* alloca, malloc */

+#include <malloc.h>

 #include <string.h>

 #include <stdarg.h>

 #include <stdio.h> /* vsnprintf */