Merge pull request #924 from RIscRIpt/manual_sdl2

[nothing.git] / src / math / point.c

diff --git a/src/math/point.c b/src/math/point.c
index 9f10864d203b67bb0189cfebd4171296fcbe9b9b..dbdfc54537c8a0d28e08e6025333f941a25ff441 100644 (file)
--- a/src/math/point.c
+++ b/src/math/point.c
@@ -1,55 +1,64 @@
-#include <assert.h>
+#include "system/stacktrace.h"
 #include <math.h>
 
-#include "./point.h"
+#include "point.h"
 
-vec_t vec(float x, float y)
+Vec vec(float x, float y)
 {
-    vec_t result = {
+    Vec result = {
         .x = x,
         .y = y
     };
     return result;
 }
 
-vec_t vec_from_polar(float arg, float mag)
+Vec vec_from_polar(float arg, float mag)
 {
     return vec_scala_mult(
         vec(cosf(arg), sinf(arg)),
         mag);
 }
 
-vec_t vec_from_ps(point_t p1, point_t p2)
+Vec vec_from_ps(Point p1, Point p2)
 {
-    vec_t result = {
+    Vec result = {
         .x = p2.x - p1.x,
         .y = p2.y - p1.y
     };
     return result;
 }
 
-float vec_arg(vec_t v)
+float vec_arg(Vec v)
 {
     return atan2f(v.y, v.x);
 }
 
-float vec_mag(vec_t v)
+float vec_mag(Vec v)
 {
     return sqrtf(v.x * v.x + v.y * v.y);
 }
 
-vec_t vec_sum(vec_t v1, vec_t v2)
+Vec vec_sum(Vec v1, Vec v2)
 {
-    vec_t result = {
+    Vec result = {
         .x = v1.x + v2.x,
         .y = v1.y + v2.y
     };
     return result;
 }
 
-vec_t vec_neg(vec_t v)
+Vec vec_sub(Vec v1, Vec v2)
 {
-    vec_t result = {
+    Vec result = {
+        .x = v1.x - v2.x,
+        .y = v1.y - v2.y
+    };
+    return result;
+}
+
+Vec vec_neg(Vec v)
+{
+    Vec result = {
         .x = -v.x,
         .y = -v.y
     };
@@ -57,29 +66,29 @@ vec_t vec_neg(vec_t v)
     return result;
 }
 
-float vec_length(vec_t v)
+float vec_length(Vec v)
 {
     return sqrtf(v.x * v.x + v.y * v.y);
 }
 
-void vec_add(vec_t *v1, vec_t v2)
+void vec_add(Vec *v1, Vec v2)
 {
     v1->x += v2.x;
     v1->y += v2.y;
 }
 
-vec_t vec_scala_mult(vec_t v, float scalar)
+Vec vec_scala_mult(Vec v, float scalar)
 {
-    vec_t result = {
+    Vec result = {
         .x = v.x * scalar,
         .y = v.y * scalar
     };
     return result;
 }
 
-vec_t vec_entry_mult(vec_t v1, vec_t v2)
+Vec vec_entry_mult(Vec v1, Vec v2)
 {
-    vec_t result = {
+    Vec result = {
         .x = v1.x * v2.x,
         .y = v1.y * v2.y
     };
@@ -87,9 +96,9 @@ vec_t vec_entry_mult(vec_t v1, vec_t v2)
     return result;
 }
 
-vec_t vec_entry_div(vec_t v1, vec_t v2)
+Vec vec_entry_div(Vec v1, Vec v2)
 {
-    vec_t result = {
+    Vec result = {
         .x = v1.x / v2.x,
         .y = v1.y / v2.y
     };
@@ -102,7 +111,7 @@ float rad_to_deg(float a)
     return 180 / PI * a;
 }
 
-point_t point_mat3x3_product(point_t p, mat3x3 m)
+Point point_mat3x3_product(Point p, mat3x3 m)
 {
     /* Convert p to Homogeneous coordinates */
     const float homo_p[3] = {p.x, p.y, 1};
@@ -115,10 +124,29 @@ point_t point_mat3x3_product(point_t p, mat3x3 m)
     };
 
     /* Convert p back to Cartesian coordinates */
-    const point_t result_p = {
+    const Point result_p = {
         .x = trans_p[0] / trans_p[2],
         .y = trans_p[1] / trans_p[2]
     };
 
     return result_p;
 }
+
+Vec vec_norm(Vec v)
+{
+    // TODO(#657): math/point/vec_norm: using vec_length is too expensive
+    //   It involves multiplication and sqrt. We can just check if its components are close to 0.0f.
+
+    const float l = vec_length(v);
+
+    if (l < 1e-6) {
+        return vec(0.0f, 0.0f);
+    }
+
+    return vec(v.x / l, v.y / l);
+}
+
+float vec_sqr_norm(Vec v)
+{
+    return v.x * v.x + v.y * v.y;
+}