Rename `Vector3D` to `Vector`

[shadowclad.git] / src / engine / geometry.c

diff --git a/src/engine/geometry.c b/src/engine/geometry.c
index 311a645864adf0fa08fed6017a187574ae658372..ae224b133ab3ef3ae9e13276cd2bbb69c4f2fa29 100644 (file)
--- a/src/engine/geometry.c
+++ b/src/engine/geometry.c
@@ -3,10 +3,6 @@
 #include <math.h>
 #include <stddef.h>
 
-const float TAU = 6.28318530718f;
-
-
-
 Transform identity() {
        return (Transform) { .a1 = 1.0f, .a2 = 0.0f, .a3 = 0.0f, .a4 = 0.0f,
                             .b1 = 0.0f, .b2 = 1.0f, .b3 = 0.0f, .b4 = 0.0f,
@@ -32,7 +28,7 @@ Transform multiply(Transform t1, Transform t2) {
        return result;
 }
 
-void translate(Transform* transform, Vector3D vec) {
+void translate(Transform* transform, Vector vec) {
        *transform = multiply(
                (Transform) { .a1 = 1.0f, .a2 = 0.0f, .a3 = 0.0f, .a4 = vec.x,
                              .b1 = 0.0f, .b2 = 1.0f, .b3 = 0.0f, .b4 = vec.y,
@@ -41,7 +37,7 @@ void translate(Transform* transform, Vector3D vec) {
                *transform);
 }
 
-void rotate(Transform* transform, Vector3D axis, float angle) {
+void rotate(Transform* transform, Vector axis, float angle) {
        axis = normalized(axis);
        float l = axis.x;
        float m = axis.y;
@@ -58,21 +54,43 @@ void rotate(Transform* transform, Vector3D axis, float angle) {
                *transform);
 }
 
-Vector3D addVectors(Vector3D v1, Vector3D v2){
-       return (Vector3D) { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
+Vector addVectors(Vector v1, Vector v2){
+       return (Vector) { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
+}
+
+Vector subtractVectors(Vector v1, Vector v2) {
+       return (Vector) { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
+}
+
+Vector crossProduct(Vector v1, Vector v2) {
+       return (Vector) { .x = (v1.y * v2.z) - (v1.z * v2.y),
+                         .y = (v1.z * v2.x) - (v1.x * v2.z),
+                         .z = (v1.x * v2.y) - (v1.y * v2.x) };
+}
+
+float dotProduct(Vector v1, Vector v2) {
+       return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
 }
 
-Vector3D subtractVectors(Vector3D v1, Vector3D v2) {
-       return (Vector3D) { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
+Vector scaleVector(Vector vec, float scale) {
+       return (Vector) { vec.x * scale,
+                         vec.y * scale,
+                         vec.z * scale };
+}
+
+Vector clampMagnitude(Vector vec, float maxMagnitude) {
+       float m = magnitude(vec);
+       if (m > maxMagnitude) {
+               vec = scaleVector(vec, maxMagnitude / m);
+       }
+       return vec;
 }
 
-Vector3D crossProduct(Vector3D v1, Vector3D v2) {
-       return (Vector3D) { .x = (v1.y * v2.z) - (v1.z * v2.y),
-                           .y = (v1.z * v2.x) - (v1.x * v2.z),
-                           .z = (v1.x * v2.y) - (v1.y * v2.x) };
+float magnitude(Vector vec) {
+       return sqrtf(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
 }
 
-Vector3D applyTransform(Transform transform, Vector3D vec) {
+Vector applyTransform(Transform transform, Vector vec) {
        GLfloat* a = (GLfloat*) &transform;
        GLfloat b[4] = { vec.x, vec.y, vec.z, 1.0f };
        GLfloat c[4];
@@ -84,14 +102,14 @@ Vector3D applyTransform(Transform transform, Vector3D vec) {
                        + a[(row * 4) + 2] * b[2]
                        + a[(row * 4) + 3] * b[3];
        }
-       return (Vector3D) { c[0], c[1], c[2] };
+       return (Vector) { c[0], c[1], c[2] };
 }
 
-Vector3D translationOf(Transform transform) {
-       return (Vector3D) { transform.a4, transform.b4, transform.c4 };
+Vector translationOf(Transform transform) {
+       return (Vector) { transform.a4, transform.b4, transform.c4 };
 }
 
-Vector3D normalized(Vector3D vec) {
-       float magnitude = sqrtf(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
-       return (Vector3D) {vec.x / magnitude, vec.y / magnitude, vec.z / magnitude};
+Vector normalized(Vector vec) {
+       float m = magnitude(vec);
+       return (Vector) { vec.x / m, vec.y / m, vec.z / m };
 }