Intial commit

.envrc

@@ -0,0 +1,5 @@
+if ! has nix_direnv_version || ! nix_direnv_version 3.1.0; then
+  source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/3.1.0/direnvrc" "sha256-yMJ2OVMzrFaDPn7q8nCBZFRYpL/f0RcHzhmw/i6btJM="
+fi
+
+use flake

.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+.idea
+*.log
+tmp/
+.cache/
+build/
+.direnv/

flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1772433332,
+        "narHash": "sha256-izhTDFKsg6KeVBxJS9EblGeQ8y+O8eCa6RcW874vxEc=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "cf59864ef8aa2e178cccedbe2c178185b0365705",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,34 @@
+{
+  description = "Vektor flake";
+
+  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+  outputs =
+    {
+      self,
+      nixpkgs,
+    }:
+    let
+      system = "x86_64-linux";
+      pkgs = import nixpkgs { inherit system; };
+    in
+    {
+      devShells.${system}.default = pkgs.mkShell {
+        nativeBuildInputs = with pkgs; [
+          gcc
+          clang-tools
+          lldb
+
+          meson
+          ninja
+          pkg-config
+
+          gtk4
+
+          gdb
+        ];
+
+        shellHook = "";
+      };
+    };
+}

meson.build

@@ -0,0 +1,27 @@
+project(
+  'vektor',
+  'c',
+  version: '0.0.0',
+  meson_version: '>=0.63',
+  default_options: [
+    'c_std=c23',
+    'warning_level=3',
+    'buildtype=debug',
+  ],
+)
+
+gtk = dependency('gtk4', required: true)
+
+src = files(
+  'src/main.c',
+  'src/matrix.c'
+)
+
+executable(
+  'vektor',
+  src,
+  dependencies: [gtk],
+  link_args: ['-lm'],
+  install: true,
+)
+

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_