Removed more makros, improved hashmap iterator

include/core/Check.h

@@ -1,14 +1,6 @@
 #ifndef CORE_CHECK_H
 #define CORE_CHECK_H
 
-#if defined(__STDC_VERSION__) && __STDC_VERSION__ > 202300L
-#define check_return [[nodiscard]]
-#elif defined(__GNUC__)
-#define check_return __attribute__((warn_unused_result))
-#else
-#error "please add a 'check_return' option"
-#endif
-
 #if defined(__GNUC__)
 #define check_format(format_index, arg_start_index)                            \
     __attribute__((format(printf, format_index, arg_start_index)))
@@ -24,6 +16,4 @@
 #define unlikely(x) x
 #endif
 
-#define cbool check_return bool
-
 #endif

include/core/Frustum.h

@@ -12,8 +12,8 @@ typedef struct {
     float farClip;
 } CoreFrustum;
 
-CoreFrustum* coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
-                             float farClip);
+void coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
+                     float farClip);
 const CoreMatrix* coreUpdateProjection(CoreFrustum* f,
                                        const CoreIntVector2* size);
 void coreUpdateFrustumPlanes(CoreFrustum* f, const CoreVector3* pos,

include/core/HashMap.h

@@ -22,10 +22,9 @@ struct CoreHashMap {
     CoreSearchValue search;
 };
 
-CoreHashMap coreInitHashMap(size_t keySize, size_t valueSize, CoreHasher hasher,
-                            CoreEqual equal);
-#define CORE_HASH_MAP(keySize, valueSize, hasher, equal)                       \
-    coreInitHashMap(keySize, valueSize, hasher, equal)
+void coreInitHashMap(CoreHashMap* m, size_t keySize, size_t valueSize);
+void coreInitHashMapF(CoreHashMap* m, size_t keySize, size_t valueSize,
+                      CoreHasher hasher, CoreEqual equal);
 void coreDestroyHashMap(CoreHashMap* m);
 void coreRehashHashMap(CoreHashMap* m, size_t minCapacity);
 void* coreHashMapPutPointer(CoreHashMap* m, const void* key, const void* value);
@@ -58,13 +57,16 @@ typedef struct {
 } CoreHashMapNode;
 
 typedef struct {
+    char* key;
+    char* endKey;
+    char* value;
+    char* endValue;
     const CoreHashMap* map;
-    size_t index;
     CoreHashMapNode node;
 } CoreHashMapIterator;
 
-#define CORE_HASH_MAP_ITERATOR(map)                                            \
-    ((CoreHashMapIterator){map, (size_t)-1, {0}})
+void coreInitHashMapIterator(CoreHashMapIterator* mi, CoreHashMap* m);
+bool coreHashMapHasNext(CoreHashMapIterator* mi);
 CoreHashMapNode* coreHashMapNext(CoreHashMapIterator* mi);
 #define coreHashMapKeyPointer(node, type) ((const type*)node->key)
 #define coreHashMapKey(node, type) (*coreHashMapKeyPointer(node, type))

include/core/Plane.h

@@ -8,9 +8,8 @@ typedef struct {
     float d;
 } CorePlane;
 
-#define CORE_PLANE ((CorePlane){0})
-CorePlane* coreInitPlane(CorePlane* p, const CoreVector3* a,
-                         const CoreVector3* b, const CoreVector3* c);
+void coreInitPlane(CorePlane* p, const CoreVector3* a, const CoreVector3* b,
+                   const CoreVector3* c);
 float coreSignedDistance(const CorePlane* p, const CoreVector3* v);
 size_t coreToStringPlane(const CorePlane* p, char* buffer, size_t n);
 

performance/Main.c

@@ -58,8 +58,8 @@ static i64 average(CoreHashMap* m, i64 (*f)(const CoreHashMap* m), int n) {
 }
 
 static void order(int n) {
-    CoreHashMap m =
-        CORE_HASH_MAP(sizeof(int), sizeof(int), coreHash, coreEqual);
+    CoreHashMap m;
+    coreInitHashMap(&m, sizeof(int), sizeof(int));
     fillOrder(&m);
     m.hasher = nullptr;
     puts("Order Probing");
@@ -69,8 +69,8 @@ static void order(int n) {
 }
 
 static void chaos(int n) {
-    CoreHashMap m =
-        CORE_HASH_MAP(sizeof(int), sizeof(int), coreHash, coreEqual);
+    CoreHashMap m;
+    coreInitHashMap(&m, sizeof(int), sizeof(int));
     fillChaos(&m);
     puts("Chaos Probing");
     printf("Search | %ld ms\n", average(&m, testSearch, n));

src/Components.c

@@ -1,8 +1,7 @@
 #include "core/Components.h"
 
 void coreInitComponents(CoreComponents* c, size_t componentSize) {
-    c->entityToIndex =
-        CORE_HASH_MAP(sizeof(CoreEntity), sizeof(size_t), coreHash, coreEqual);
+    coreInitHashMap(&c->entityToIndex, sizeof(CoreEntity), sizeof(size_t));
     c->indexToEntity = CORE_LIST(sizeof(CoreEntity));
     c->components = CORE_LIST(componentSize);
 }

src/Frustum.c

@@ -8,11 +8,8 @@
 #define CV30 (&CORE_VECTOR3)
 #define CV4(a, b, c, d) ((CoreVector4){{a, b, c, d}})
 
-CoreFrustum* coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
-                             float farClip) {
-    for(size_t i = 0; i < CORE_ARRAY_LENGTH(f->planes); i++) {
-        f->planes[i] = CORE_PLANE;
-    }
+void coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
+                     float farClip) {
     f->tan = tanf(coreDegreeToRadian(fieldOfView) * 0.5f);
     f->nearClip = nearClip;
     f->farClip = farClip;
@@ -23,14 +20,12 @@ CoreFrustum* coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
     f->projection.data[2] = CV4(0.0f, 0.0f, (nearClip + farClip) * diff,
                                 (2.0f * nearClip * farClip) * diff);
     f->projection.data[3] = CV4(0.0f, 0.0f, -1.0f, 0.0f);
-    return f;
 }
 
 const CoreMatrix* coreUpdateProjection(CoreFrustum* f,
                                        const CoreIntVector2* size) {
-    f->projection.data[0] =
-        CV4((float)size->data[1] / (f->tan * (float)size->data[0]), 0.0f, 0.0f,
-            0.0f);
+    float x = (float)size->data[1] / (f->tan * (float)size->data[0]);
+    f->projection.data[0] = CV4(x, 0.0f, 0.0f, 0.0f);
     return &f->projection;
 }
 

src/HashMap.c

@@ -99,8 +99,12 @@ static size_t roundUp2(size_t n) {
     return w;
 }
 
-CoreHashMap coreInitHashMap(size_t keySize, size_t valueSize, CoreHasher hasher,
-                            CoreEqual equal) {
+void coreInitHashMap(CoreHashMap* m, size_t keySize, size_t valueSize) {
+    coreInitHashMapF(m, keySize, valueSize, coreHash, coreEqual);
+}
+
+void coreInitHashMapF(CoreHashMap* m, size_t keySize, size_t valueSize,
+                      CoreHasher hasher, CoreEqual equal) {
     CoreSearchValue search = searchValue;
     if(hasher == coreHash && equal == coreEqual) {
         switch(keySize) {
@@ -108,8 +112,15 @@ CoreHashMap coreInitHashMap(size_t keySize, size_t valueSize, CoreHasher hasher,
             case sizeof(u64): search = searchValueU64; break;
         }
     }
-    return (CoreHashMap){nullptr, nullptr, keySize, valueSize, 0,
-                         0,       hasher,  equal,   search};
+    m->keys = nullptr;
+    m->values = nullptr;
+    m->keySize = keySize;
+    m->valueSize = valueSize;
+    m->capacity = 0;
+    m->entries = 0;
+    m->hasher = hasher;
+    m->equal = equal;
+    m->search = search;
 }
 
 void coreDestroyHashMap(CoreHashMap* m) {
@@ -123,8 +134,8 @@ void coreRehashHashMap(CoreHashMap* m, size_t minCapacity) {
         return;
     }
     size_t l = roundUp2(coreMaxSize(minCapacity, 8lu)) + 1;
-    CoreHashMap map =
-        CORE_HASH_MAP(m->keySize, m->valueSize, m->hasher, m->equal);
+    CoreHashMap map;
+    coreInitHashMapF(&map, m->keySize, m->valueSize, m->hasher, m->equal);
     size_t keyBytes = l * m->keySize;
     map.keys = coreAllocate(keyBytes);
     memset(map.keys, 0, keyBytes);
@@ -189,15 +200,13 @@ void coreClearHashMap(CoreHashMap* m) {
 
 bool coreHashMapRemovePointer(CoreHashMap* m, const void* key) {
     // ToDo: This is a very slow remove
-    CoreHashMap n =
-        CORE_HASH_MAP(m->keySize, m->valueSize, m->hasher, m->equal);
-    CoreHashMapIterator i = CORE_HASH_MAP_ITERATOR(m);
+    CoreHashMap n;
+    coreInitHashMapF(&n, m->keySize, m->valueSize, m->hasher, m->equal);
+    CoreHashMapIterator i;
+    coreInitHashMapIterator(&i, m);
     bool r = false;
-    while(true) {
+    while(coreHashMapHasNext(&i)) {
         CoreHashMapNode* node = coreHashMapNext(&i);
-        if(node == nullptr) {
-            break;
-        }
         if(!m->equal(key, node->key, n.keySize)) {
             coreHashMapPutPointer(&n, node->key, node->value);
         } else {
@@ -279,18 +288,30 @@ bool coreEqual(const void* keyA, const void* keyB, size_t n) {
     return memcmp(keyA, keyB, n) == 0;
 }
 
-CoreHashMapNode* coreHashMapNext(CoreHashMapIterator* mi) {
-    const CoreHashMap* m = mi->map;
-    mi->index++;
-    size_t end = m->capacity - 1;
-    while(mi->index < m->capacity) {
-        void* key = getKey(m, mi->index);
-        if(isInvalidKey(m, key) == (mi->index == end)) {
-            mi->node.key = key;
-            mi->node.value = getValue(m, mi->index);
-            return &mi->node;
+void coreInitHashMapIterator(CoreHashMapIterator* mi, CoreHashMap* m) {
+    mi->key = m->keys;
+    mi->endKey = mi->key + m->capacity * m->keySize;
+    mi->value = m->values;
+    mi->endValue = mi->value + m->capacity * m->valueSize;
+    mi->map = m;
+}
+
+bool coreHashMapHasNext(CoreHashMapIterator* mi) {
+    while(mi->key != mi->endKey) {
+        char* nextKey = mi->key + mi->map->keySize;
+        if(isInvalidKey(mi->map, mi->key) == (nextKey == mi->endKey)) {
+            break;
         }
-        mi->index++;
+        mi->key = nextKey;
+        mi->value += mi->map->valueSize;
     }
-    return nullptr;
+    return mi->key != mi->endKey;
+}
+
+CoreHashMapNode* coreHashMapNext(CoreHashMapIterator* mi) {
+    mi->node.key = mi->key;
+    mi->node.value = mi->value;
+    mi->key += mi->map->keySize;
+    mi->value += mi->map->valueSize;
+    return &mi->node;
 }

src/Plane.c

@@ -4,12 +4,11 @@
 
 #define CV30 (&CORE_VECTOR3)
 
-CorePlane* coreInitPlane(CorePlane* p, const CoreVector3* a,
-                         const CoreVector3* b, const CoreVector3* c) {
+void coreInitPlane(CorePlane* p, const CoreVector3* a, const CoreVector3* b,
+                   const CoreVector3* c) {
     coreCross(&p->abc, coreSubV3(CV30, b, a), coreSubV3(CV30, c, a));
     coreNormalizeV3(&p->abc);
     p->d = -coreDotV3(&p->abc, b);
-    return p;
 }
 
 float coreSignedDistance(const CorePlane* p, const CoreVector3* v) {

test/modules/HashMapTests.c

@@ -2,10 +2,14 @@
 #include "core/HashMap.h"
 #include "core/Utility.h"
 
-#define INT_MAP CORE_HASH_MAP(sizeof(int), sizeof(int), coreHash, coreEqual)
+static CoreHashMap createIntMap() {
+    CoreHashMap map;
+    coreInitHashMap(&map, sizeof(int), sizeof(int));
+    return map;
+}
 
 static CoreHashMap getTestIntMap() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     coreHashMapPut(&map, int, 1, int, 3);
     coreHashMapPut(&map, int, 2, int, 4);
     coreHashMapPut(&map, int, 3, int, 5);
@@ -28,7 +32,7 @@ static void checkIntMap(CoreHashMap* map) {
 }
 
 static void testAdd() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     coreHashMapPut(&map, int, 5, int, 4);
     int* value = coreHashMapSearch(&map, int, 5, int);
     if(CORE_TEST_NOT_NULL(value)) {
@@ -58,7 +62,7 @@ static void testSearch() {
 }
 
 static void testSearchEmpty() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     CORE_TEST_NULL(coreHashMapSearch(&map, int, 6, int));
     coreDestroyHashMap(&map);
 }
@@ -86,7 +90,7 @@ static void testClear() {
 }
 
 static void testClearEmpty() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     coreClearHashMap(&map);
     coreDestroyHashMap(&map);
 }
@@ -128,19 +132,17 @@ static void testToString() {
 }
 
 static void testEntryForEach() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     coreHashMapPut(&map, int, 0, int, -1);
     coreHashMapPut(&map, int, 5, int, 4);
     coreHashMapPut(&map, int, 10, int, 3);
     coreHashMapPut(&map, int, 15, int, 2);
 
     int counter = 0;
-    CoreHashMapIterator i = CORE_HASH_MAP_ITERATOR(&map);
-    while(true) {
+    CoreHashMapIterator i;
+    coreInitHashMapIterator(&i, &map);
+    while(coreHashMapHasNext(&i)) {
         CoreHashMapNode* n = coreHashMapNext(&i);
-        if(n == nullptr) {
-            break;
-        }
         counter += coreHashMapKey(n, int) + coreHashMapValue(n, int);
     }
     CORE_TEST_INT(38, counter);
@@ -149,7 +151,7 @@ static void testEntryForEach() {
 }
 
 static void testInvalidPut() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
 
     char buffer[128];
     coreToStringHashMap(&map, buffer, sizeof(buffer), coreToStringInt,
@@ -180,7 +182,7 @@ static void testAddCollisions() {
 }
 
 static void testRemove() {
-    CoreHashMap map = INT_MAP;
+    CoreHashMap map = createIntMap();
     coreHashMapPut(&map, int, 1, int, 3);
     coreHashMapPut(&map, int, 2, int, 4);
     coreHashMapPut(&map, int, 3, int, 5);
@@ -216,8 +218,8 @@ typedef struct {
 } A;
 
 static void testSearchStruct() {
-    CoreHashMap map =
-        CORE_HASH_MAP(sizeof(A), sizeof(int), coreHash, coreEqual);
+    CoreHashMap map;
+    coreInitHashMap(&map, sizeof(A), sizeof(int));
     A a = {1, 2};
     A b = {1, 3};
     A c = {0, 0};
@@ -245,8 +247,8 @@ static void testSearchStruct() {
 }
 
 static void testSearchSize() {
-    CoreHashMap map =
-        CORE_HASH_MAP(sizeof(size_t), sizeof(int), coreHash, coreEqual);
+    CoreHashMap map;
+    coreInitHashMap(&map, sizeof(size_t), sizeof(int));
     CORE_TEST_NULL(coreHashMapSearch(&map, size_t, 0, int));
     CORE_TEST_NULL(coreHashMapSearch(&map, size_t, 1, int));
     CORE_TEST_NULL(coreHashMapSearch(&map, size_t, 2, int));

test/modules/PlaneTests.c

@@ -5,15 +5,8 @@ static const float eps = 0.0001f;
 
 #define CV3(a, b, c) (&(CoreVector3){{a, b, c}})
 
-static void testToString1() {
-    CorePlane p = CORE_PLANE;
-    char buffer[128];
-    coreToStringPlane(&p, buffer, sizeof(buffer));
-    CORE_TEST_STRING("(0.000 x + 0.000 y + 0.000 z + 0.000)", buffer);
-}
-
-static void testToString2() {
-    CorePlane p = CORE_PLANE;
+static void testToString() {
+    CorePlane p;
     coreInitPlane(&p, CV3(3, 6, 8), CV3(7, 6, 2), CV3(4, 4, 4));
     char buffer[128];
     coreToStringPlane(&p, buffer, sizeof(buffer));
@@ -24,7 +17,7 @@ static void testSignedDistance() {
     CoreVector3 a = {{3, 6, 8}};
     CoreVector3 b = {{7, 6, 2}};
     CoreVector3 c = {{4, 4, 4}};
-    CorePlane p = CORE_PLANE;
+    CorePlane p;
     coreInitPlane(&p, &a, &b, &c);
     CORE_TEST_FLOAT(0.0f, coreSignedDistance(&p, &a), eps);
     CORE_TEST_FLOAT(0.0f, coreSignedDistance(&p, &b), eps);
@@ -34,7 +27,6 @@ static void testSignedDistance() {
 }
 
 void coreTestPlane() {
-    testToString1();
-    testToString2();
+    testToString();
     testSignedDistance();
 }