CMakeLists.txt

@@ -4,7 +4,9 @@ project(core)
 set(CMAKE_C_STANDARD 23)
 
 set(SRC
+    "src/Box.c"
     "src/Buffer.c"
+    "src/Frustum.c"
     "src/Logger.c"
     "src/Matrix.c"
     "src/Plane.c"
@@ -15,14 +17,14 @@ set(SRC
     "src/Vector.c"
     "src/View.c"
     #"src/BitArray.cpp"
-    #"src/Box.cpp"
-    #"src/Frustum.cpp"
 )
 
 set(SRC_TESTS
     "test/Main.c"
     "test/Test.c"
+    "test/modules/BoxTests.c"
     "test/modules/BufferTests.c"
+    "test/modules/FrustumTests.c"
     "test/modules/MatrixTests.c"
     "test/modules/PlaneTests.c"
     "test/modules/QuaternionTests.c"
@@ -32,9 +34,7 @@ set(SRC_TESTS
     "test/modules/VectorTests.c"
     "test/modules/ViewTests.c"
     #"test/modules/BitArrayTests.cpp"
-    #"test/modules/BoxTests.cpp"
     #"test/modules/ComponentsTests.cpp"
-    #"test/modules/FrustumTests.cpp"
     #"test/modules/HashMapTests.cpp"
     #"test/modules/LinkedListTests.cpp"
     #"test/modules/ListTests.cpp"
@@ -96,8 +96,10 @@ target_sources(core PUBLIC
     FILE_SET HEADERS
     BASE_DIRS include
     FILES 
+        ./include/core/Box.h
         ./include/core/Buffer.h
         ./include/core/Check.h
+        ./include/core/Frustum.h
         ./include/core/Logger.h
         ./include/core/Matrix.h
         ./include/core/Plane.h
@@ -108,9 +110,7 @@ target_sources(core PUBLIC
         ./include/core/Utility.h
         ./include/core/View.h
 #        ./include/core/BitArray.hpp
-#        ./include/core/Box.hpp
 #        ./include/core/Components.hpp
-#        ./include/core/Frustum.hpp
 #        ./include/core/HashMap.hpp
 #        ./include/core/LinkedList.hpp
 #        ./include/core/List.hpp

include/core/Box.h

@@ -0,0 +1,18 @@
+#ifndef CORE_BOX_H
+#define CORE_BOX_H
+
+#include "core/Vector.h"
+
+typedef struct {
+    CoreVector3 min;
+    CoreVector3 max;
+} CoreBox;
+
+CoreBox* coreSetBox(CoreBox* box, const CoreVector3* size);
+CoreBox* coreOffsetBox(CoreBox* box, const CoreVector3* offset);
+bool coreCollidesWithBox(const CoreBox* box, const CoreBox* other);
+CoreBox* coreExpandBox(CoreBox* box, const CoreVector3* offset);
+CoreBox* coreGrowBox(CoreBox* box, const CoreVector3* growth);
+size_t coreToStringBox(const CoreBox* box, char* buffer, size_t n);
+
+#endif

include/core/Frustum.h

@@ -0,0 +1,28 @@
+#ifndef CORE_FRUSTUM_H
+#define CORE_FRUSTUM_H
+
+#include "core/Matrix.h"
+#include "core/Plane.h"
+
+typedef struct {
+    CoreMatrix projection;
+    CorePlane planes[6];
+    float tan;
+    float nearClip;
+    float farClip;
+} CoreFrustum;
+
+CoreFrustum* coreInitFrustum(CoreFrustum* f, float fieldOfView, float nearClip,
+                             float farClip);
+const CoreMatrix* coreUpdateProjection(CoreFrustum* f,
+                                       const CoreIntVector2* size);
+void coreUpdateFrustumPlanes(CoreFrustum* f, const CoreVector3* pos,
+                             const CoreVector3* right, const CoreVector3* up,
+                             const CoreVector3* front,
+                             const CoreIntVector2* size);
+bool coreIsInsideFrustum(const CoreFrustum* f, const CoreVector3* pos);
+bool coreIsInsideFrustumRadius(const CoreFrustum* f, const CoreVector3* pos,
+                               float radius);
+size_t coreToStringFrustum(const CoreFrustum* f, char* buffer, size_t n);
+
+#endif

include/core/Plane.h

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

src/Box.c

@@ -0,0 +1,68 @@
+#include "core/Box.h"
+
+#include <stdio.h>
+
+CoreBox* coreSetBox(CoreBox* box, const CoreVector3* size) {
+    for(size_t i = 0; i < 3; i++) {
+        if(size->data[i] < 0.0f) {
+            box->min.data[i] = size->data[i];
+            box->max.data[i] = 0.0f;
+        } else {
+            box->min.data[i] = 0.0f;
+            box->max.data[i] = size->data[i];
+        }
+    }
+    return box;
+}
+
+CoreBox* coreOffsetBox(CoreBox* box, const CoreVector3* offset) {
+    coreAddSetV3(&box->min, offset);
+    coreAddSetV3(&box->max, offset);
+    return box;
+}
+
+bool coreCollidesWithBox(const CoreBox* box, const CoreBox* other) {
+    return box->max.data[0] > other->min.data[0] &&
+           box->min.data[0] < other->max.data[0] &&
+           box->max.data[1] > other->min.data[1] &&
+           box->min.data[1] < other->max.data[1] &&
+           box->max.data[2] > other->min.data[2] &&
+           box->min.data[2] < other->max.data[2];
+}
+
+CoreBox* coreExpandBox(CoreBox* box, const CoreVector3* offset) {
+    for(size_t i = 0; i < 3; i++) {
+        if(offset->data[i] > 0.0f) {
+            box->max.data[i] += offset->data[i];
+        } else {
+            box->min.data[i] += offset->data[i];
+        }
+    }
+    return box;
+}
+
+CoreBox* coreGrowBox(CoreBox* box, const CoreVector3* growth) {
+    CoreVector3 half = {0};
+    coreMulV3F(&half, growth, 0.5f);
+    CoreVector3 nMin = {0};
+    coreSubV3(&nMin, &box->min, &half);
+    CoreVector3 nMax = {0};
+    coreAddV3(&nMax, &box->max, &half);
+    for(size_t i = 0; i < 3; i++) {
+        if(nMin.data[i] > nMax.data[i]) {
+            nMin.data[i] = (box->min.data[i] + box->max.data[i]) * 0.5f;
+            nMax.data[i] = nMin.data[i];
+        }
+    }
+    box->min = nMin;
+    box->max = nMax;
+    return box;
+}
+
+size_t coreToStringBox(const CoreBox* box, char* buffer, size_t n) {
+    int w = snprintf(buffer, n, "Box([%.3f, %.3f, %.3f], [%.3f, %.3f, %.3f])",
+                     (double)box->min.data[0], (double)box->min.data[1],
+                     (double)box->min.data[2], (double)box->min.data[3],
+                     (double)box->min.data[4], (double)box->min.data[5]);
+    return w < 0 ? 0 : (size_t)w;
+}

src/Frustum.c

@@ -0,0 +1,113 @@
+#include "core/Frustum.h"
+
+#include <math.h>
+#include <stdio.h>
+
+#include "core/Utility.h"
+
+#define CV30 (&(CoreVector3){0})
+#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] = (CorePlane){0};
+    }
+    f->tan = tanf(coreDegreeToRadian(fieldOfView) * 0.5f);
+    f->nearClip = nearClip;
+    f->farClip = farClip;
+
+    float diff = 1.0f / (nearClip - farClip);
+    f->projection.data[0] = CV4(0.0f, 0.0f, 0.0f, 0.0f);
+    f->projection.data[1] = CV4(0.0f, 1.0f / f->tan, 0.0f, 0.0f);
+    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);
+    return &f->projection;
+}
+
+void coreUpdateFrustumPlanes(CoreFrustum* f, const CoreVector3* pos,
+                             const CoreVector3* right, const CoreVector3* up,
+                             const CoreVector3* front,
+                             const CoreIntVector2* size) {
+    float aspect = (float)size->data[0] / (float)size->data[1];
+
+    float hNearHeight = f->tan * f->nearClip;
+    float hNearWidth = hNearHeight * aspect;
+
+    float hFarHeight = f->tan * f->farClip;
+    float hFarWidth = hFarHeight * aspect;
+
+    CoreVector3 fCenter;
+    coreAddV3(&fCenter, pos, coreMulV3F(CV30, front, f->farClip));
+    CoreVector3 upFar;
+    coreMulV3F(&upFar, up, hFarHeight);
+    CoreVector3 rightFar;
+    coreMulV3F(&rightFar, right, hFarWidth);
+
+    CoreVector3 fTopLeft;
+    coreAddV3(&fTopLeft, &fCenter, coreSubV3(CV30, &upFar, &rightFar));
+    CoreVector3 fTopRight;
+    coreAddV3(&fTopRight, &fCenter, coreAddV3(CV30, &upFar, &rightFar));
+    CoreVector3 fBottomRight;
+    coreSubV3(&fBottomRight, &fCenter, coreSubV3(CV30, &upFar, &rightFar));
+
+    CoreVector3 nCenter;
+    coreAddV3(&nCenter, pos, coreMulV3F(CV30, front, f->nearClip));
+    CoreVector3 upNear;
+    coreMulV3F(&upNear, up, hNearHeight);
+    CoreVector3 rightNear;
+    coreMulV3F(&rightNear, right, hNearWidth);
+
+    CoreVector3 nTopLeft;
+    coreAddV3(&nTopLeft, &nCenter, coreSubV3(CV30, &upNear, &rightNear));
+    CoreVector3 nBottomLeft;
+    coreSubV3(&nBottomLeft, &nCenter, coreAddV3(CV30, &upNear, &rightNear));
+    CoreVector3 nBottomRight;
+    coreSubV3(&nBottomRight, &nCenter, coreSubV3(CV30, &upNear, &rightNear));
+
+    coreInitPlane(f->planes + 0, &nBottomRight, &nTopLeft,
+                  &nBottomLeft); // n plane
+    coreInitPlane(f->planes + 1, &fTopRight, &fBottomRight,
+                  &fTopLeft); // f plane
+    coreInitPlane(f->planes + 2, &nBottomRight, &nBottomLeft,
+                  &fBottomRight); // bottom plane
+    coreInitPlane(f->planes + 3, &fTopLeft, &nTopLeft, &fTopRight); // top plane
+    coreInitPlane(f->planes + 4, &nBottomLeft, &nTopLeft,
+                  &fTopLeft); // left plane
+    coreInitPlane(f->planes + 5, &fBottomRight, &fTopRight,
+                  &nBottomRight); // right plane
+}
+
+bool coreIsInsideFrustum(const CoreFrustum* f, const CoreVector3* pos) {
+    for(size_t i = 0; i < CORE_ARRAY_LENGTH(f->planes); i++) {
+        if(coreSignedDistance(f->planes + i, pos) < 0.0f) {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool coreIsInsideFrustumRadius(const CoreFrustum* f, const CoreVector3* pos,
+                               float radius) {
+    for(size_t i = 0; i < CORE_ARRAY_LENGTH(f->planes); i++) {
+        if(coreSignedDistance(f->planes + i, pos) < -radius) {
+            return false;
+        }
+    }
+    return true;
+}
+
+size_t coreToStringFrustum(const CoreFrustum* f, char* buffer, size_t n) {
+    int w = snprintf(buffer, n, "(tan = %.3f, nearClip = %.3f, farClip = %.3f)",
+                     (double)f->tan, (double)f->nearClip, (double)f->farClip);
+    return w < 0 ? 0 : (size_t)w;
+}

src/Plane.c

@@ -12,7 +12,7 @@ CorePlane* coreInitPlane(CorePlane* p, const CoreVector3* a,
     return p;
 }
 
-float coreGetSignedDistance(CorePlane* p, const CoreVector3* v) {
+float coreSignedDistance(const CorePlane* p, const CoreVector3* v) {
     return coreDotV3(&p->abc, v) + p->d;
 }
 

test/Main.c

@@ -32,16 +32,16 @@ int main(int argAmount, const char** args) {
     }
 
     // coreTestBitArray();
-    // coreTestBox();
     // coreTestComponents();
-    // coreTestFrustum();
     // coreTestHashMap(light);
     // coreTestLinkedList(light);
     // coreTestList(light);
     // coreTestMatrixStack(light);
     // coreTestRingBuffer();
     // coreTestStack(light);
+    coreTestBox();
     coreTestBuffer(light);
+    coreTestFrustum();
     coreTestMatrix();
     coreTestPlane();
     coreTestQuaternion();

test/modules/BoxTests.c

@@ -0,0 +1,100 @@
+#include "../Tests.h"
+#include "core/Box.h"
+
+#define CV3(a, b, c) (&(CoreVector3){{a, b, c}})
+
+static void testInit() {
+    CoreBox box = {0};
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    char buffer[128];
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([0.000, 0.000, 0.000], [1.000, 2.000, 3.000])",
+                     buffer);
+    coreToStringV3(&box.min, buffer, sizeof(buffer));
+    CORE_TEST_STRING("[0.000, 0.000, 0.000]", buffer);
+    coreToStringV3(&box.max, buffer, sizeof(buffer));
+    CORE_TEST_STRING("[1.000, 2.000, 3.000]", buffer);
+
+    coreSetBox(&box, CV3(-1.0f, -2.0f, -3.0f));
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([-1.000, -2.000, -3.000], [0.000, 0.000, 0.000])",
+                     buffer);
+    coreToStringV3(&box.min, buffer, sizeof(buffer));
+    CORE_TEST_STRING("[-1.000, -2.000, -3.000]", buffer);
+    coreToStringV3(&box.max, buffer, sizeof(buffer));
+    CORE_TEST_STRING("[0.000, 0.000, 0.000]", buffer);
+}
+
+static void testOffset() {
+    CoreBox box = {0};
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreOffsetBox(&box, CV3(7.0f, -4.0f, 6.0f));
+    char buffer[128];
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([7.000, -4.000, 6.000], [8.000, -2.000, 9.000])",
+                     buffer);
+}
+
+static void testCollidesWith() {
+    CoreBox boxA = {0};
+    coreSetBox(&boxA, CV3(1.0f, 2.0f, 3.0f));
+    CoreBox boxB = {0};
+    coreSetBox(&boxB, CV3(-1.0f, -2.0f, -3.0f));
+    CoreBox boxC = {0};
+    coreSetBox(&boxC, CV3(2.0f, 2.0f, 2.0f));
+    coreOffsetBox(&boxC, CV3(-1.0f, -1.0f, -1.0f));
+
+    CORE_TEST_TRUE(coreCollidesWithBox(&boxC, &boxA));
+    CORE_TEST_TRUE(coreCollidesWithBox(&boxC, &boxB));
+    CORE_TEST_TRUE(coreCollidesWithBox(&boxA, &boxC));
+    CORE_TEST_TRUE(coreCollidesWithBox(&boxB, &boxC));
+    CORE_TEST_FALSE(coreCollidesWithBox(&boxA, &boxB));
+    CORE_TEST_FALSE(coreCollidesWithBox(&boxB, &boxA));
+}
+
+static void testExpand() {
+    CoreBox box = {0};
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreExpandBox(&box, CV3(7.0f, -4.0f, 6.0f));
+
+    char buffer[128];
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([0.000, -4.000, 0.000], [8.000, 2.000, 9.000])",
+                     buffer);
+
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreExpandBox(&box, CV3(-7.0f, 4.0f, -6.0f));
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([-7.000, 0.000, -6.000], [1.000, 6.000, 3.000])",
+                     buffer);
+}
+
+static void testGrow() {
+    CoreBox box = {0};
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreGrowBox(&box, CV3(4.0f, 2.0f, 6.0f));
+    char buffer[128];
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([-2.000, -1.000, -3.000], [3.000, 3.000, 6.000])",
+                     buffer);
+
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreGrowBox(&box, CV3(-4.0f, -2.0f, -6.0f));
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([0.500, 1.000, 1.500], [0.500, 1.000, 1.500])",
+                     buffer);
+
+    coreSetBox(&box, CV3(1.0f, 2.0f, 3.0f));
+    coreGrowBox(&box, CV3(-0.1f, -4.0f, -1.0f));
+    coreToStringBox(&box, buffer, sizeof(buffer));
+    CORE_TEST_STRING("Box([0.050, 1.000, 0.500], [0.950, 1.000, 2.500])",
+                     buffer);
+}
+
+void coreTestBox() {
+    testInit();
+    testOffset();
+    testCollidesWith();
+    testExpand();
+    testGrow();
+}

test/modules/FrustumTests.c

@@ -0,0 +1,74 @@
+#include "../Tests.h"
+#include "core/Frustum.h"
+
+#define CV3(a, b, c) (&(CoreVector3){{a, b, c}})
+
+static void testToString() {
+    CoreFrustum f = {0};
+    coreInitFrustum(&f, 60.0f, 0.1f, 1000.0f);
+    char buffer[128];
+    coreToStringFrustum(&f, buffer, sizeof(buffer));
+    CORE_TEST_STRING("(tan = 0.577, nearClip = 0.100, farClip = 1000.000)",
+                     buffer);
+}
+
+static void testPointIsInside() {
+    CoreIntVector2 size = {{200, 100}};
+    CoreFrustum f = {0};
+    coreInitFrustum(&f, 60.0f, 0.1f, 1000.0f);
+    coreUpdateFrustumPlanes(&f, CV3(0, 0, 0), CV3(1, 0, 0), CV3(0, 1, 0),
+                            CV3(0, 0, 1), &size);
+
+    CORE_TEST_TRUE(coreIsInsideFrustum(&f, CV3(0, 0, 5)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(0, 0, 1004)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(0, 0, -5)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(0, 50, 5)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(0, -50, 5)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(50, 0, 5)));
+    CORE_TEST_FALSE(coreIsInsideFrustum(&f, CV3(-50, 0, 5)));
+}
+
+static void testSphereIsInside() {
+    CoreIntVector2 size = {{200, 100}};
+    CoreFrustum f = {0};
+    coreInitFrustum(&f, 60.0f, 0.1f, 1000.0f);
+    coreUpdateFrustumPlanes(&f, CV3(0, 0, 0), CV3(1, 0, 0), CV3(0, 1, 0),
+                            CV3(0, 0, 1), &size);
+
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, 0, 5), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(0, 0, 1004), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(0, 0, -5), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(0, 50, 5), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(0, -50, 5), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(50, 0, 5), 3));
+    CORE_TEST_FALSE(coreIsInsideFrustumRadius(&f, CV3(-50, 0, 5), 3));
+
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, 0, 5), 3));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, 0, 1004), 50));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, 0, -5), 50));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, 50, 5), 50));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(0, -50, 5), 50));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(50, 0, 5), 50));
+    CORE_TEST_TRUE(coreIsInsideFrustumRadius(&f, CV3(-50, 0, 5), 50));
+}
+
+static void testUpdateProjection() {
+    CoreFrustum f = {0};
+    coreInitFrustum(&f, 60.0f, 0.1f, 1000.0f);
+    const CoreMatrix* m =
+        coreUpdateProjection(&f, &(CoreIntVector2){{400, 300}});
+    char buffer[128];
+    coreToStringMatrix(m, buffer, sizeof(buffer));
+    CORE_TEST_STRING("[[1.299, 0.000, 0.000, 0.000], "
+                     "[0.000, 1.732, 0.000, 0.000], "
+                     "[0.000, 0.000, -1.000, -0.200], "
+                     "[0.000, 0.000, -1.000, 0.000]]",
+                     buffer);
+}
+
+void coreTestFrustum() {
+    testToString();
+    testPointIsInside();
+    testSphereIsInside();
+    testUpdateProjection();
+}

test/modules/PlaneTests.c

@@ -14,26 +14,23 @@ static void testToString1() {
 
 static void testToString2() {
     CorePlane p = CORE_PLANE;
-    coreInitPlane(&p, CV3(3.0f, 6.0f, 8.0f), CV3(7.0f, 6.0f, 2.0f),
-                  CV3(4.0f, 4.0f, 4.0f));
+    coreInitPlane(&p, CV3(3, 6, 8), CV3(7, 6, 2), CV3(4, 4, 4));
     char buffer[128];
     coreToStringPlane(&p, buffer, sizeof(buffer));
     CORE_TEST_STRING("(-0.684 x + 0.570 y + -0.456 z + 2.279)", buffer);
 }
 
 static void testSignedDistance() {
-    CoreVector3 a = {{3.0f, 6.0f, 8.0f}};
-    CoreVector3 b = {{7.0f, 6.0f, 2.0f}};
-    CoreVector3 c = {{4.0f, 4.0f, 4.0f}};
+    CoreVector3 a = {{3, 6, 8}};
+    CoreVector3 b = {{7, 6, 2}};
+    CoreVector3 c = {{4, 4, 4}};
     CorePlane p = CORE_PLANE;
     coreInitPlane(&p, &a, &b, &c);
-    CORE_TEST_FLOAT(0.0f, coreGetSignedDistance(&p, &a), eps);
-    CORE_TEST_FLOAT(0.0f, coreGetSignedDistance(&p, &b), eps);
-    CORE_TEST_FLOAT(0.0f, coreGetSignedDistance(&p, &c), eps);
-    CORE_TEST_FLOAT(-1.13960576f,
-                    coreGetSignedDistance(&p, CV3(5.0f, 8.0f, 10.0f)), eps);
-    CORE_TEST_FLOAT(0.911684612f,
-                    coreGetSignedDistance(&p, CV3(3.0f, 2.0f, 1.0f)), eps);
+    CORE_TEST_FLOAT(0.0f, coreSignedDistance(&p, &a), eps);
+    CORE_TEST_FLOAT(0.0f, coreSignedDistance(&p, &b), eps);
+    CORE_TEST_FLOAT(0.0f, coreSignedDistance(&p, &c), eps);
+    CORE_TEST_FLOAT(-1.13960576f, coreSignedDistance(&p, CV3(5, 8, 10)), eps);
+    CORE_TEST_FLOAT(0.911684612f, coreSignedDistance(&p, CV3(3, 2, 1)), eps);
 }
 
 void coreTestPlane() {