Intial commit

src/main.c

@@ -0,0 +1,26 @@
+#include "gtk/gtk.h"
+#include "stdio.h"
+
+static void activate(GtkApplication *app, gpointer user_data) {
+  GtkWidget *window;
+
+  window = gtk_application_window_new(app);
+  gtk_window_set_title(GTK_WINDOW(window), "Vektor");
+  gtk_window_set_default_size(GTK_WINDOW(window), 200, 200);
+
+  gtk_window_present(GTK_WINDOW(window));
+}
+
+int main(int argc, char **argv) {
+  printf("\x1b[1;46m IGNITION \x1b[0m\n");
+
+  GtkApplication *app;
+  int status;
+
+  app = gtk_application_new("dev.frox.vektor", G_APPLICATION_DEFAULT_FLAGS);
+  g_signal_connect(app, "activate", G_CALLBACK(activate), NULL);
+  status = g_application_run(G_APPLICATION(app), argc, argv);
+  g_object_unref(app);
+
+  return status;
+}

src/matrix.c

@@ -0,0 +1,83 @@
+#include "matrix.h"
+#include <math.h>
+
+inline M33 m33_identity(void) {
+  return (M33){{{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}};
+}
+
+inline M33 m33_translate(double tx, double ty) {
+  return (M33){{{1, 0, tx}, {0, 1, ty}, {0, 0, 1}}};
+}
+
+inline M33 m33_scale(double sx, double sy) {
+  return (M33){{{sx, 0, 0}, {0, sy, 0}, {0, 0, 1}}};
+}
+
+inline M33 m33_rotate(double theta) {
+  return (M33){
+      {{cos(theta), -sin(theta), 0}, {sin(theta), cos(theta), 0}, {0, 0, 1}}};
+}
+
+M33 m33_add(const M33 m1, const M33 m2) {
+  M33 res;
+  for (int i = 0; i < 3; ++i)
+    for (int j = 0; j < 3; ++j)
+      res.m[i][j] = m1.m[i][j] + m2.m[i][j];
+  return res;
+}
+
+M33 m33_sub(const M33 m1, const M33 m2) {
+  M33 res;
+  for (int i = 0; i < 3; ++i)
+    for (int j = 0; j < 3; ++j)
+      res.m[i][j] = m1.m[i][j] - m2.m[i][j];
+  return res;
+}
+
+M33 m33_mul(const M33 m1, const M33 m2) {
+  M33 res = {{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}}};
+  for (int i = 0; i < 3; ++i)
+    for (int j = 0; j < 3; ++j)
+      for (int k = 0; k < 3; ++k)
+        res.m[i][j] += m1.m[i][k] * m2.m[k][j];
+  return res;
+}
+
+M33 m33_transpose(const M33 m) {
+  M33 res;
+  for (int i = 0; i < 3; ++i)
+    for (int j = 0; j < 3; ++j)
+      res.m[i][j] = m.m[j][i];
+  return res;
+}
+
+// 2D affine transform inversion (not general 3x3 inversion)
+M33 m33_inverse(const M33 m) {
+  M33 inv;
+  double det;
+
+  det = m.m[0][0] * m.m[1][1] - m.m[0][1] * m.m[1][0];
+  if (det == 0.0) {
+    return m33_identity();
+  }
+  double invDet = 1.0 / det;
+
+  inv.m[0][0] = m.m[1][1] * invDet;
+  inv.m[0][1] = -m.m[0][1] * invDet;
+  inv.m[1][0] = -m.m[1][0] * invDet;
+  inv.m[1][1] = m.m[0][0] * invDet;
+
+  inv.m[0][2] = -(inv.m[0][0] * m.m[0][2] + inv.m[0][1] * m.m[1][2]);
+  inv.m[1][2] = -(inv.m[1][0] * m.m[0][2] + inv.m[1][1] * m.m[1][2]);
+
+  inv.m[2][0] = 0;
+  inv.m[2][1] = 0;
+  inv.m[2][2] = 1;
+
+  return inv;
+}
+
+V2 m33_transform(const M33 mat, const V2 v) {
+  return (V2){mat.m[0][0] * v.x + mat.m[0][1] * v.y + mat.m[0][2],
+              mat.m[1][0] * v.x + mat.m[1][1] * v.y + mat.m[1][2]};
+}

src/matrix.h

@@ -0,0 +1,24 @@
+#ifndef MATRIX_H_
+#define MATRIX_H_
+
+#include "vector.h"
+
+// Row major 3x3 matricies
+typedef struct {
+  double m[3][3];
+} M33;
+
+M33 m33_identity(void);
+M33 m33_translate(double tx, double ty);
+M33 m33_scale(double sx, double sy);
+M33 m33_rotate(double rad);
+
+M33 m33_add(const M33 m1, const M33 m2);
+M33 m33_sub(const M33 m1, const M33 m2);
+M33 m33_mul(const M33 m1, const M33 m2);
+M33 m33_transpose(const M33 m);
+M33 m33_inverse(const M33 m);
+
+V2 m33_transform(const M33 mat, const V2 v);
+
+#endif // MATRIX_H_

src/vector.h

@@ -0,0 +1,47 @@
+#ifndef VECTOR_H_
+#define VECTOR_H_
+
+#include "math.h"
+
+typedef struct {
+  double x;
+  double y;
+} V2;
+
+static inline V2 vec2_add(const V2 v1, const V2 v2) {
+  return (V2){v1.x + v2.x, v1.y + v2.y};
+}
+
+static inline V2 vec2_sub(const V2 v1, const V2 v2) {
+  return (V2){v1.x - v2.x, v1.y - v2.y};
+}
+
+static inline V2 vec2_mul(const V2 v1, const V2 v2) {
+  return (V2){v1.x * v2.x, v1.y * v2.y};
+}
+
+static inline V2 vec2_scale(const V2 v, const double k) {
+  return (V2){v.x * k, v.y * k};
+}
+
+static inline double vec2_dot(const V2 v1, const V2 v2) {
+  return v1.x * v2.x + v1.y * v2.y;
+}
+
+static inline double vec2_cross(const V2 a, const V2 b) {
+  return a.x * b.y - a.y * b.x;
+}
+
+static inline double vec2_norm(const V2 v) {
+  return sqrt(v.x * v.x + v.y * v.y);
+}
+
+static inline double vec2_quadrance(const V2 v) {
+  return (v.x * v.x + v.y * v.y);
+}
+
+static inline V2 vec2_normalize(const V2 v) {
+  return vec2_scale(v, 1 / vec2_norm(v));
+}
+
+#endif // VECTOR_H_