6 files changed, 154 insertions, 18 deletions

diff --git a/examples/main_loop/ex_main_loop.c b/examples/main_loop/ex_main_loop.c
index 0ea9ded..de0caa6 100644
--- a/examples/main_loop/ex_main_loop.c
+++ b/examples/main_loop/ex_main_loop.c
@@ -1,22 +1,45 @@
 #include <GLFW/glfw3.h>
 
 #include "core.h"
+#include "file.h"
 #include "render.h"
+#include "str.h"
 
 int main() {
   core* core = core_bringup();
 
-  // Main loop
-  while (!glfwWindowShouldClose(core->renderer.window)) {
-    input_update(&core->input);
-    threadpool_process_results(&core->threadpool, 1);
+  size_t arena_size = 1024;
+  arena scratch = arena_create(malloc(arena_size), arena_size);
+  arena* a = &scratch;
+
+  str8 hello = str8lit("Hello World");
+
+  // this works but we should be careful because str8 is not *guaranteed* to point to
+  // a null-terminated string
+  printf("String before: '%s' (null-terminated: %s) \n ", hello.buf,
+         str8_is_null_term(hello) ? "true" : "false");
 
-    render_frame_begin(&core->renderer);
+  char* c = str8_to_cstr(&scratch, hello);
 
-    // insert work here
+  printf("String after: %s\n", c);
 
-    render_frame_end(&core->renderer);
+  str8_opt test_file = str8_from_file(&scratch, str8lit("assets/shaders/ui_rect.vert"));
+  if (test_file.has_value) {
+    printf("Contents: %.*s \n", (int)test_file.contents.len, test_file.contents.buf);
+    printf("Null-terminated: %s\n", str8_is_null_term(test_file.contents) ? "true" : "false");
   }
 
+  // Main loop
+  // while (!glfwWindowShouldClose(core->renderer.window)) {
+  //   input_update(&core->input);
+  //   threadpool_process_results(&core->threadpool, 1);
+  //
+  //   render_frame_begin(&core->renderer);
+  //
+  //   // insert work here
+  //
+  //   render_frame_end(&core->renderer);
+  // }
+
   return 0;
-}
\ No newline at end of file
+}
diff --git a/src/platform/file.c b/src/platform/file.c
index 45c5b30..44aa9d0 100644
--- a/src/platform/file.c
+++ b/src/platform/file.c
@@ -7,6 +7,8 @@
 #include <stdlib.h>
 
 #include "log.h"
+#include "mem.h"
+#include "str.h"
 
 const char *string_from_file(const char *path) {
   FILE *f = fopen(path, "rb");
@@ -29,4 +31,33 @@ const char *string_from_file(const char *path) {
   string[fsize] = '\0';
 
   return string;
+}
+
+str8_opt str8_from_file(arena *a, str8 path) {
+  char *p = cstr(a, path);
+  str8_opt result = { .has_value = false };
+
+  FILE *f = fopen(p, "rb");
+  if (f == NULL) {
+    ERROR("Error reading file: %s. errno: %d", path, errno);
+    return result;
+  }
+  if (ferror(f)) {
+    ERROR("Error reading file: %s. errno: %d", path, errno);
+    return result;
+  }
+  fseek(f, 0, SEEK_END);
+  long fsize = ftell(f);
+  rewind(f);
+
+  u8 *raw = arena_alloc(a, fsize + 1);
+  str8 contents = str8_create(raw, fsize);
+  contents.buf[contents.len] = '\0';
+
+  fread(raw, fsize, 1, f);
+  fclose(f);
+  result.contents = contents;
+  result.has_value = true;
+
+  return result;
 }
\ No newline at end of file
diff --git a/src/platform/file.h b/src/platform/file.h
index b965ceb..fa09891 100644
--- a/src/platform/file.h
+++ b/src/platform/file.h
@@ -6,6 +6,14 @@
  */
 #pragma once
 
-#include <stdbool.h>
+#include "defines.h"
+#include "str.h"
+
+typedef struct str8_opt {
+    str8 contents;
+    bool has_value;
+} str8_opt;
 
 const char* string_from_file(const char* path);
+
+str8_opt str8_from_file(arena* a, str8 path);
\ No newline at end of file
diff --git a/src/renderer/render_types.h b/src/renderer/render_types.h
index a3639e7..e24fc24 100644
--- a/src/renderer/render_types.h
+++ b/src/renderer/render_types.h
@@ -9,6 +9,7 @@
 
 #include "darray.h"
 #include "maths_types.h"
+#include "str.h"
 
 struct GLFWwindow;
 
@@ -65,7 +66,7 @@ KITC_DECL_TYPED_ARRAY(mesh)  // creates "mesh_darray"
 #endif
 
 typedef struct model {
-  char name[256];
+  str8 name;
 } model;
 
 #ifndef TYPED_MODEL_ARRAY
diff --git a/src/std/str.c b/src/std/str.c
index 27f8f68..3b2770e 100644
--- a/src/std/str.c
+++ b/src/std/str.c
@@ -1,4 +1,9 @@
 #include "str.h"
+#include <string.h>
+
+#include "mem.h"
+
+str8 str8_create(u8* buf, size_t len) { return (str8){ .buf = buf, .len = len }; }
 
 bool str8_equals(str8 a, str8 b) {
   if (a.len != b.len) {
@@ -11,4 +16,29 @@ bool str8_equals(str8 a, str8 b) {
     }
   }
   return true;
+}
+
+char* str8_to_cstr(arena* a, str8 s) {
+  bool is_null_terminated = s.buf[s.len - 1] == 0;
+  size_t n_bytes = is_null_terminated ? s.len : s.len + 1;
+
+  u8* dest = arena_alloc(a, n_bytes);
+
+  memcpy(dest, s.buf, s.len);
+  if (is_null_terminated) {
+    dest[s.len] = '\0';
+  }
+  return (char*)dest;
+}
+
+str8 str8_concat(arena* a, str8 left, str8 right) {
+  size_t n_bytes = left.len + right.len + 1;
+
+  u8* dest = arena_alloc(a, n_bytes);
+  memcpy(dest, left.buf, left.len);
+  memcpy(dest + right.len, right.buf, right.len);
+
+  dest[n_bytes - 1] = '\0';
+
+  return str8_create(dest, n_bytes);
 }
\ No newline at end of file
diff --git a/src/std/str.h b/src/std/str.h
index 3d3cb41..d2fa891 100644
--- a/src/std/str.h
+++ b/src/std/str.h
@@ -1,30 +1,73 @@
 /**
- * @brief
- *
+ * @file str.h
+ * @author your name (you@domain.com)
+ * @brief 
+ * @version 0.1
+ * @date 2024-02-25
+ * 
+ * @copyright Copyright (c) 2024
+ * 
  */
 #pragma once
 
 #include "defines.h"
+#include "mem.h"
 
 /**
- * @brief Fat pointer representing a UTF8 (TODO) encoded string
- * @note when using `printf` you must use %s.*s length, string
+ * @brief Fat pointer representing a UTF8 encoded string
+ * @note when using `printf` you must use %s.*s length, string until our own modified
+         print routines are written. alternatively wrap in `cstr()` and pass to `%s`.
  */
 typedef struct {
   u8 *buf;
   size_t len;
 } str8;
 
+
+// --- Constructors
+
+/** @brief Take a string literal and turn it into a `str8` */
+#define str8lit(s) (str8){(u8 *)s, ((sizeof(s) / sizeof(*(s)) - 1))}
+
+str8 str8_create(u8* buf, size_t len);
+
+/** @brief Return a null-terminated C string cloned onto an arena */
+char* str8_to_cstr(arena* a, str8 s);
+
+#define cstr(a, s) (str8_to_cstr(a, s)) // Shorthand
+
+// --- Comparisons
+
 /** @brief Compare two strings for exact equality */
 bool str8_equals(str8 a, str8 b);
 
 /**
  * @brief Compare the first `first_nchars` of each string for equality
-          If either of the strings are shorter than the number only the characters up until the end
- of the shorter string will be compared.
+ * @details If either of the strings are shorter than the number only the characters up until the end
+            of the shorter string will be compared.
  * @returns 0 if they are fully equal up until `first_nchars`, i.e they never differed, else it
- returns the index at which the first string differed from the second string.
+            returns the index at which the first string differed from the second string.
 */
 size_t str8_nequals(str8 a, str8 b, size_t first_nchars);
 
-bool str8_ends_with(str8 input_str, str8 suffix);
\ No newline at end of file
+bool str8_ends_with(str8 input_str, str8 suffix);
+
+/// --- Subviews
+
+str8 str8_substr(str8 s, u64 min, u64 max);
+/** @brief Keeps only the `first_n` chars of `s` */
+str8 str8_take(str8 s, u64 first_n);
+/** @brief Keeps only the `last_n` chars of `s` */
+str8 str8_drop(str8 s, u64 last_n);
+/** @brief Keeps everything after the first `n` chars of `s` */
+str8 str8_skip(str8 s, u64 n);
+/** @brief Keeps everything before the last `n` chars of `s` */
+str8 str8_chop(str8 s, u64 n);
+
+str8 str8_concat(arena* a, str8 left, str8 right);
+
+/// --- Misc
+
+static inline bool str8_is_null_term(str8 a) {
+  return a.buf[a.len] == 0; // This doesn't seem safe. YOLO
+}
\ No newline at end of file