Allaboard

7 files changed, 1540 insertions, 134 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 30ca37f..d2f2f8f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -2,6 +2,10 @@ bin_PROGRAMS = game
 
 common_sources = state.h
 
+debug_flags = -O2 -DVKDEBUG
+release_flags = -O3
+common_flags = $(release_flags) -Wall -Wextra -march=native -fno-math-errno -funroll-loops -flto -pthread -ggdb -Wno-string-plus-int
+
 AM_LDFLAGS = -fuse-ld=lld -flto
 
 # -fwhole-program allows cross-file inlining, but only works when you put all
@@ -14,10 +18,10 @@ AM_LDFLAGS = -fuse-ld=lld -flto
 # -fno-math-errno and stuff like that, without enabling
 # -funsafe-math-optimizations. Some FP code can get big speedups from
 # fast-math, like auto-vectorization.
-AM_CFLAGS = -march=native -fno-math-errno -funroll-loops -flto -pthread -ggdb -DVKDEBUG
+AM_CFLAGS = $(common_flags)
 # AM_CFLAGS = -O0 -march=native -fno-math-errno -funroll-loops -flto -pthread -ggdb -fsanitize=address
 
-AM_CXXFLAGS = -Wall -Wextra -O2 -g -std=c++17
+AM_CXXFLAGS = $(common_flags) -std=c++17
 
 game_SOURCES = render.c cplusplus.cpp $(common_sources)
 game_LDADD = -lSDL2 -lm -lvulkan -lshaderc_shared -lstdc++
diff --git a/src/b.h b/src/b.h
new file mode 100644
index 0000000..cdf6772
--- /dev/null
+++ b/src/b.h
@@ -0,0 +1,860 @@
+// This is an attempt on build library for building C with C akin to nob.h from
+// tsoding which is itself based on https://github.com/tsoding/nobuild
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef B_H_
+#define B_H_
+
+#define B_ASSERT assert
+#define B_REALLOC realloc
+#define B_FREE free
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+
+#define B_ARRAY_LEN(array) (sizeof(array)/sizeof(array[0]))
+#define B_ARRAY_GET(array, index) \
+    (B_ASSERT(index >= 0), B_ASSERT(index < B_ARRAY_LEN(array)), array[index])
+
+typedef enum {
+    B_INFO,
+    B_WARNING,
+    B_ERROR,
+} B_Log_Level;
+
+void b_log(B_Log_Level level, const char *fmt, ...);
+
+// It is an equivalent of shift command from bash. It basically pops a command line
+// argument from the beginning.
+char *b_shift_args(int *argc, char ***argv);
+
+typedef struct {
+    const char **items;
+    size_t count;
+    size_t capacity;
+} B_File_Paths;
+
+typedef enum {
+    B_FILE_REGULAR = 0,
+    B_FILE_DIRECTORY,
+    B_FILE_SYMLINK,
+    B_FILE_OTHER,
+} B_File_Type;
+
+bool b_mkdir_if_not_exists(const char *path);
+bool b_copy_file(const char *src_path, const char *dst_path);
+bool b_copy_directory_recursively(const char *src_path, const char *dst_path);
+bool b_read_entire_dir(const char *parent, B_File_Paths *children);
+bool b_write_entire_file(const char *path, const void *data, size_t size);
+B_File_Type b_get_file_type(const char *path);
+
+#define b_return_defer(value) do { result = (value); goto defer; } while(0)
+
+// Initial capacity of a dynamic array
+#define B_DA_INIT_CAP 256
+
+// Append an item to a dynamic array
+#define b_da_append(da, item)                                                          \
+    do {                                                                               \
+        if ((da)->count >= (da)->capacity) {                                           \
+            (da)->capacity = (da)->capacity == 0 ? B_DA_INIT_CAP : (da)->capacity*2;   \
+            (da)->items = B_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items)); \
+            B_ASSERT((da)->items != NULL && "Buy more RAM lol");                       \
+        }                                                                              \
+                                                                                       \
+        (da)->items[(da)->count++] = (item);                                           \
+    } while (0)
+
+#define b_da_free(da) B_FREE((da).items)
+
+// Append several items to a dynamic array
+#define b_da_append_many(da, new_items, new_items_count)                                        \
+    do {                                                                                        \
+        if ((da)->count + (new_items_count) > (da)->capacity) {                                 \
+            if ((da)->capacity == 0) {                                                          \
+                (da)->capacity = B_DA_INIT_CAP;                                                 \
+            }                                                                                   \
+            while ((da)->count + (new_items_count) > (da)->capacity) {                          \
+                (da)->capacity *= 2;                                                            \
+            }                                                                                   \
+            (da)->items = B_REALLOC((da)->items, (da)->capacity*sizeof(*(da)->items));          \
+            B_ASSERT((da)->items != NULL && "Buy more RAM lol");                                \
+        }                                                                                       \
+        memcpy((da)->items + (da)->count, (new_items), (new_items_count)*sizeof(*(da)->items)); \
+        (da)->count += (new_items_count);                                                       \
+    } while (0)
+
+typedef struct {
+    char *items;
+    size_t count;
+    size_t capacity;
+} B_String_Builder;
+
+bool b_read_entire_file(const char *path, B_String_Builder *sb);
+
+// Append a sized buffer to a string builder
+#define b_sb_append_buf(sb, buf, size) b_da_append_many(sb, buf, size)
+
+// Append a NULL-terminated string to a string builder
+#define b_sb_append_cstr(sb, cstr)  \
+    do {                            \
+        const char *s = (cstr);     \
+        size_t n = strlen(s);       \
+        b_da_append_many(sb, s, n); \
+    } while (0)
+
+// Append a single NULL character at the end of a string builder. So then you can
+// use it a NULL-terminated C string
+#define b_sb_append_null(sb) b_da_append_many(sb, "", 1)
+
+// Free the memory allocated by a string builder
+#define b_sb_free(sb) B_FREE((sb).items)
+
+// Process handle
+typedef int B_Proc;
+#define B_INVALID_PROC (-1)
+
+typedef struct {
+    B_Proc *items;
+    size_t count;
+    size_t capacity;
+} B_Procs;
+
+bool b_procs_wait(B_Procs procs);
+
+// Wait until the process has finished
+bool b_proc_wait(B_Proc proc);
+
+// A command - the main workhorse of B. B is all about building commands an running them
+typedef struct {
+    const char **items;
+    size_t count;
+    size_t capacity;
+} B_Cmd;
+
+// Render a string representation of a command into a string builder. Keep in mind the the
+// string builder is not NULL-terminated by default. Use b_sb_append_null if you plan to
+// use it as a C string.
+void b_cmd_render(B_Cmd cmd, B_String_Builder *render);
+
+#define b_cmd_append(cmd, ...) \
+    b_da_append_many(cmd, ((const char*[]){__VA_ARGS__}), (sizeof((const char*[]){__VA_ARGS__})/sizeof(const char*)))
+
+// Free all the memory allocated by command arguments
+#define b_cmd_free(cmd) B_FREE(cmd.items)
+
+// Run command asynchronously
+B_Proc b_cmd_run_async(B_Cmd cmd);
+
+// Run command synchronously
+bool b_cmd_run_sync(B_Cmd cmd);
+
+#ifndef B_TEMP_CAPACITY
+#define B_TEMP_CAPACITY (8*1024*1024)
+#endif // B_TEMP_CAPACITY
+char *b_temp_strdup(const char *cstr);
+void *b_temp_alloc(size_t size);
+char *b_temp_sprintf(const char *format, ...);
+void b_temp_reset(void);
+size_t b_temp_save(void);
+void b_temp_rewind(size_t checkpoint);
+
+int is_path1_modified_after_path2(const char *path1, const char *path2);
+bool b_rename(const char *old_path, const char *new_path);
+int b_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count);
+int b_needs_rebuild1(const char *output_path, const char *input_path);
+int b_file_exists(const char *file_path);
+
+// TODO: add MinGW support for Go Rebuild Urself™ Technology
+#ifndef B_REBUILD_URSELF
+#  if _WIN32
+#    if defined(__GNUC__)
+#       define B_REBUILD_URSELF(binary_path, source_path) "gcc", "-o", binary_path, source_path
+#    elif defined(__clang__)
+#       define B_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path
+#    elif defined(_MSC_VER)
+#       define B_REBUILD_URSELF(binary_path, source_path) "cl.exe", b_temp_sprintf("/Fe:%s", (binary_path)), source_path
+#    endif
+#  else
+#    if defined(__clang__)
+#      define B_REBUILD_URSELF(binary_path, source_path) "clang", "-o", binary_path, source_path
+#    else
+#      define B_REBUILD_URSELF(binary_path, source_path) "cc", "-o", binary_path, source_path
+#    endif
+#  endif
+#endif
+
+// Go Rebuild Urself™ Technology
+//
+//   How to use it:
+//     int main(int argc, char** argv) {
+//         GO_REBUILD_URSELF(argc, argv);
+//         // actual work
+//         return 0;
+//     }
+//
+//   After your added this macro every time you run ./build it will detect
+//   that you modified its original source code and will try to rebuild itself
+//   before doing any actual work. So you only need to bootstrap your build system
+//   once.
+//
+//   The modification is detected by comparing the last modified times of the executable
+//   and its source code. The same way the make utility usually does it.
+//
+//   The rebuilding is done by using the REBUILD_URSELF macro which you can redefine
+//   if you need a special way of bootstraping your build system. (which I personally
+//   do not recommend since the whole idea of build is to keep the process of bootstrapping
+//   as simple as possible and doing all of the actual work inside of the build)
+//
+#define B_GO_REBUILD_URSELF(argc, argv)                                         \
+    do {                                                                        \
+        const char *source_path = __FILE__;                                     \
+        assert(argc >= 1);                                                      \
+        const char *binary_path = argv[0];                                      \
+                                                                                \
+        int rebuild_is_needed = b_needs_rebuild(binary_path, &source_path, 1);  \
+        if (rebuild_is_needed < 0) exit(1);                                     \
+        if (rebuild_is_needed) {                                                \
+            B_String_Builder sb = {0};                                          \
+            b_sb_append_cstr(&sb, binary_path);                                 \
+            b_sb_append_cstr(&sb, ".old");                                      \
+            b_sb_append_null(&sb);                                              \
+                                                                                \
+            if (!b_rename(binary_path, sb.items)) exit(1);                      \
+            B_Cmd rebuild = {0};                                                \
+            b_cmd_append(&rebuild, B_REBUILD_URSELF(binary_path, source_path)); \
+            bool rebuild_succeeded = b_cmd_run_sync(rebuild);                   \
+            b_cmd_free(rebuild);                                                \
+            if (!rebuild_succeeded) {                                           \
+                b_rename(sb.items, binary_path);                                \
+                exit(1);                                                        \
+            }                                                                   \
+                                                                                \
+            B_Cmd cmd = {0};                                                    \
+            b_da_append_many(&cmd, argv, argc);                                 \
+            if (!b_cmd_run_sync(cmd)) exit(1);                                  \
+            exit(0);                                                            \
+        }                                                                       \
+    } while(0)
+// The implementation idea is stolen from https://github.com/zhiayang/nabs
+
+typedef struct {
+    size_t count;
+    const char *data;
+} B_String_View;
+
+const char *b_temp_sv_to_cstr(B_String_View sv);
+
+B_String_View b_sv_chop_by_delim(B_String_View *sv, char delim);
+B_String_View b_sv_trim(B_String_View sv);
+bool b_sv_eq(B_String_View a, B_String_View b);
+B_String_View b_sv_from_cstr(const char *cstr);
+B_String_View b_sv_from_parts(const char *data, size_t count);
+
+// printf macros for String_View
+#ifndef SV_Fmt
+#define SV_Fmt "%.*s"
+#endif // SV_Fmt
+#ifndef SV_Arg
+#define SV_Arg(sv) (int) (sv).count, (sv).data
+#endif // SV_Arg
+// USAGE:
+//   String_View name = ...;
+//   printf("Name: "SV_Fmt"\n", SV_Arg(name));
+
+#endif // B_H_
+
+#ifdef B_IMPLEMENTATION
+
+static size_t b_temp_size = 0;
+static char b_temp[B_TEMP_CAPACITY] = {0};
+
+bool b_mkdir_if_not_exists(const char *path)
+{
+    int result = mkdir(path, 0755);
+    if (result < 0) {
+        if (errno == EEXIST) {
+            b_log(B_INFO, "directory `%s` already exists", path);
+            return true;
+        }
+        b_log(B_ERROR, "could not create directory `%s`: %s", path, strerror(errno));
+        return false;
+    }
+
+    b_log(B_INFO, "created directory `%s`", path);
+    return true;
+}
+
+bool b_copy_file(const char *src_path, const char *dst_path)
+{
+    b_log(B_INFO, "copying %s -> %s", src_path, dst_path);
+
+    int src_fd = -1;
+    int dst_fd = -1;
+    size_t buf_size = 32*1024;
+    char *buf = B_REALLOC(NULL, buf_size);
+    B_ASSERT(buf != NULL && "Buy more RAM lol!!");
+    bool result = true;
+
+    src_fd = open(src_path, O_RDONLY);
+    if (src_fd < 0) {
+        b_log(B_ERROR, "Could not open file %s: %s", src_path, strerror(errno));
+        b_return_defer(false);
+    }
+
+    struct stat src_stat;
+    if (fstat(src_fd, &src_stat) < 0) {
+        b_log(B_ERROR, "Could not get mode of file %s: %s", src_path, strerror(errno));
+        b_return_defer(false);
+    }
+
+    dst_fd = open(dst_path, O_CREAT | O_TRUNC | O_WRONLY, src_stat.st_mode);
+    if (dst_fd < 0) {
+        b_log(B_ERROR, "Could not create file %s: %s", dst_path, strerror(errno));
+        b_return_defer(false);
+    }
+
+    for (;;) {
+        ssize_t n = read(src_fd, buf, buf_size);
+        if (n == 0) break;
+        if (n < 0) {
+            b_log(B_ERROR, "Could not read from file %s: %s", src_path, strerror(errno));
+            b_return_defer(false);
+        }
+        char *buf2 = buf;
+        while (n > 0) {
+            ssize_t m = write(dst_fd, buf2, n);
+            if (m < 0) {
+                b_log(B_ERROR, "Could not write to file %s: %s", dst_path, strerror(errno));
+                b_return_defer(false);
+            }
+            n    -= m;
+            buf2 += m;
+        }
+    }
+
+defer:
+    free(buf);
+    close(src_fd);
+    close(dst_fd);
+    return result;
+}
+
+void b_cmd_render(B_Cmd cmd, B_String_Builder *render)
+{
+    for (size_t i = 0; i < cmd.count; ++i) {
+        const char *arg = cmd.items[i];
+        if (arg == NULL) break;
+        if (i > 0) b_sb_append_cstr(render, " ");
+        if (!strchr(arg, ' ')) {
+            b_sb_append_cstr(render, arg);
+        } else {
+            b_da_append(render, '\'');
+            b_sb_append_cstr(render, arg);
+            b_da_append(render, '\'');
+        }
+    }
+}
+
+B_Proc b_cmd_run_async(B_Cmd cmd)
+{
+    if (cmd.count < 1) {
+        b_log(B_ERROR, "Could not run empty command");
+        return B_INVALID_PROC;
+    }
+
+    B_String_Builder sb = {0};
+    b_cmd_render(cmd, &sb);
+    b_sb_append_null(&sb);
+    b_log(B_INFO, "CMD: %s", sb.items);
+    b_sb_free(sb);
+    memset(&sb, 0, sizeof(sb));
+
+    pid_t cpid = fork();
+    if (cpid < 0) {
+        b_log(B_ERROR, "Could not fork child process: %s", strerror(errno));
+        return B_INVALID_PROC;
+    }
+
+    if (cpid == 0) {
+        // NOTE: This leaks a bit of memory in the child process.
+        // But do we actually care? It's a one off leak anyway...
+        B_Cmd cmd_null = {0};
+        b_da_append_many(&cmd_null, cmd.items, cmd.count);
+        b_cmd_append(&cmd_null, NULL);
+
+        if (execvp(cmd.items[0], (char * const*) cmd_null.items) < 0) {
+            b_log(B_ERROR, "Could not exec child process: %s", strerror(errno));
+            exit(1);
+        }
+        B_ASSERT(0 && "unreachable");
+    }
+
+    return cpid;
+}
+
+bool b_procs_wait(B_Procs procs)
+{
+    bool success = true;
+    for (size_t i = 0; i < procs.count; ++i) {
+        success = b_proc_wait(procs.items[i]) && success;
+    }
+    return success;
+}
+
+bool b_proc_wait(B_Proc proc)
+{
+    if (proc == B_INVALID_PROC) return false;
+
+    for (;;) {
+        int wstatus = 0;
+        if (waitpid(proc, &wstatus, 0) < 0) {
+            b_log(B_ERROR, "could not wait on command (pid %d): %s", proc, strerror(errno));
+            return false;
+        }
+
+        if (WIFEXITED(wstatus)) {
+            int exit_status = WEXITSTATUS(wstatus);
+            if (exit_status != 0) {
+                b_log(B_ERROR, "command exited with exit code %d", exit_status);
+                return false;
+            }
+
+            break;
+        }
+
+        if (WIFSIGNALED(wstatus)) {
+            b_log(B_ERROR, "command process was terminated by %s", strsignal(WTERMSIG(wstatus)));
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool b_cmd_run_sync(B_Cmd cmd)
+{
+    B_Proc p = b_cmd_run_async(cmd);
+    if (p == B_INVALID_PROC) return false;
+    return b_proc_wait(p);
+}
+
+char *b_shift_args(int *argc, char ***argv)
+{
+    B_ASSERT(*argc > 0);
+    char *result = **argv;
+    (*argv) += 1;
+    (*argc) -= 1;
+    return result;
+}
+
+void b_log(B_Log_Level level, const char *fmt, ...)
+{
+    switch (level) {
+    case B_INFO:
+        fprintf(stderr, "[INFO] ");
+        break;
+    case B_WARNING:
+        fprintf(stderr, "[WARNING] ");
+        break;
+    case B_ERROR:
+        fprintf(stderr, "[ERROR] ");
+        break;
+    default:
+        B_ASSERT(0 && "unreachable");
+    }
+
+    va_list args;
+    va_start(args, fmt);
+    vfprintf(stderr, fmt, args);
+    va_end(args);
+    fprintf(stderr, "\n");
+}
+
+bool b_read_entire_dir(const char *parent, B_File_Paths *children)
+{
+    bool result = true;
+    DIR *dir = NULL;
+
+    dir = opendir(parent);
+    if (dir == NULL) {
+        b_log(B_ERROR, "Could not open directory %s: %s", parent, strerror(errno));
+        b_return_defer(false);
+    }
+
+    errno = 0;
+    struct dirent *ent = readdir(dir);
+    while (ent != NULL) {
+        b_da_append(children, b_temp_strdup(ent->d_name));
+        ent = readdir(dir);
+    }
+
+    if (errno != 0) {
+        b_log(B_ERROR, "Could not read directory %s: %s", parent, strerror(errno));
+        b_return_defer(false);
+    }
+
+defer:
+    if (dir) closedir(dir);
+    return result;
+}
+
+bool b_write_entire_file(const char *path, const void *data, size_t size)
+{
+    bool result = true;
+
+    FILE *f = fopen(path, "wb");
+    if (f == NULL) {
+        b_log(B_ERROR, "Could not open file %s for writing: %s\n", path, strerror(errno));
+        b_return_defer(false);
+    }
+
+    //           len
+    //           v
+    // aaaaaaaaaa
+    //     ^
+    //     data
+
+    const char *buf = data;
+    while (size > 0) {
+        size_t n = fwrite(buf, 1, size, f);
+        if (ferror(f)) {
+            b_log(B_ERROR, "Could not write into file %s: %s\n", path, strerror(errno));
+            b_return_defer(false);
+        }
+        size -= n;
+        buf  += n;
+    }
+
+defer:
+    if (f) fclose(f);
+    return result;
+}
+
+B_File_Type b_get_file_type(const char *path)
+{
+    struct stat statbuf;
+    if (stat(path, &statbuf) < 0) {
+        b_log(B_ERROR, "Could not get stat of %s: %s", path, strerror(errno));
+        return -1;
+    }
+
+    switch (statbuf.st_mode & S_IFMT) {
+        case S_IFDIR:  return B_FILE_DIRECTORY;
+        case S_IFREG:  return B_FILE_REGULAR;
+        case S_IFLNK:  return B_FILE_SYMLINK;
+        default:       return B_FILE_OTHER;
+    }
+}
+
+bool b_copy_directory_recursively(const char *src_path, const char *dst_path)
+{
+    bool result = true;
+    B_File_Paths children = {0};
+    B_String_Builder src_sb = {0};
+    B_String_Builder dst_sb = {0};
+    size_t temp_checkpoint = b_temp_save();
+
+    B_File_Type type = b_get_file_type(src_path);
+    if (type < 0) return false;
+
+    switch (type) {
+        case B_FILE_DIRECTORY: {
+            if (!b_mkdir_if_not_exists(dst_path)) b_return_defer(false);
+            if (!b_read_entire_dir(src_path, &children)) b_return_defer(false);
+
+            for (size_t i = 0; i < children.count; ++i) {
+                if (strcmp(children.items[i], ".") == 0) continue;
+                if (strcmp(children.items[i], "..") == 0) continue;
+
+                src_sb.count = 0;
+                b_sb_append_cstr(&src_sb, src_path);
+                b_sb_append_cstr(&src_sb, "/");
+                b_sb_append_cstr(&src_sb, children.items[i]);
+                b_sb_append_null(&src_sb);
+
+                dst_sb.count = 0;
+                b_sb_append_cstr(&dst_sb, dst_path);
+                b_sb_append_cstr(&dst_sb, "/");
+                b_sb_append_cstr(&dst_sb, children.items[i]);
+                b_sb_append_null(&dst_sb);
+
+                if (!b_copy_directory_recursively(src_sb.items, dst_sb.items)) {
+                    b_return_defer(false);
+                }
+            }
+        } break;
+
+        case B_FILE_REGULAR: {
+            if (!b_copy_file(src_path, dst_path)) {
+                b_return_defer(false);
+            }
+        } break;
+
+        case B_FILE_SYMLINK: {
+            b_log(B_WARNING, "TODO: Copying symlinks is not supported yet");
+        } break;
+
+        case B_FILE_OTHER: {
+            b_log(B_ERROR, "Unsupported type of file %s", src_path);
+            b_return_defer(false);
+        } break;
+
+        default: B_ASSERT(0 && "unreachable");
+    }
+
+defer:
+    b_temp_rewind(temp_checkpoint);
+    b_da_free(src_sb);
+    b_da_free(dst_sb);
+    b_da_free(children);
+    return result;
+}
+
+char *b_temp_strdup(const char *cstr)
+{
+    size_t n = strlen(cstr);
+    char *result = b_temp_alloc(n + 1);
+    B_ASSERT(result != NULL && "Increase B_TEMP_CAPACITY");
+    memcpy(result, cstr, n);
+    result[n] = '\0';
+    return result;
+}
+
+void *b_temp_alloc(size_t size)
+{
+    if (b_temp_size + size > B_TEMP_CAPACITY) return NULL;
+    void *result = &b_temp[b_temp_size];
+    b_temp_size += size;
+    return result;
+}
+
+char *b_temp_sprintf(const char *format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    int n = vsnprintf(NULL, 0, format, args);
+    va_end(args);
+
+    B_ASSERT(n >= 0);
+    char *result = b_temp_alloc(n + 1);
+    B_ASSERT(result != NULL && "Extend the size of the temporary allocator");
+    // TODO: use proper arenas for the temporary allocator;
+    va_start(args, format);
+    vsnprintf(result, n + 1, format, args);
+    va_end(args);
+
+    return result;
+}
+
+void b_temp_reset(void)
+{
+    b_temp_size = 0;
+}
+
+size_t b_temp_save(void)
+{
+    return b_temp_size;
+}
+
+void b_temp_rewind(size_t checkpoint)
+{
+    b_temp_size = checkpoint;
+}
+
+const char *b_temp_sv_to_cstr(B_String_View sv)
+{
+    char *result = b_temp_alloc(sv.count + 1);
+    B_ASSERT(result != NULL && "Extend the size of the temporary allocator");
+    memcpy(result, sv.data, sv.count);
+    result[sv.count] = '\0';
+    return result;
+}
+
+int b_needs_rebuild(const char *output_path, const char **input_paths, size_t input_paths_count)
+{
+    struct stat statbuf = {0};
+
+    if (stat(output_path, &statbuf) < 0) {
+        // NOTE: if output does not exist it 100% must be rebuilt
+        if (errno == ENOENT) return 1;
+        b_log(B_ERROR, "could not stat %s: %s", output_path, strerror(errno));
+        return -1;
+    }
+    int output_path_time = statbuf.st_mtime;
+
+    for (size_t i = 0; i < input_paths_count; ++i) {
+        const char *input_path = input_paths[i];
+        if (stat(input_path, &statbuf) < 0) {
+            // NOTE: non-existing input is an error cause it is needed for building in the first place
+            b_log(B_ERROR, "could not stat %s: %s", input_path, strerror(errno));
+            return -1;
+        }
+        int input_path_time = statbuf.st_mtime;
+        // NOTE: if even a single input_path is fresher than output_path that's 100% rebuild
+        if (input_path_time > output_path_time) return 1;
+    }
+
+    return 0;
+}
+
+int b_needs_rebuild1(const char *output_path, const char *input_path)
+{
+    return b_needs_rebuild(output_path, &input_path, 1);
+}
+
+bool b_rename(const char *old_path, const char *new_path)
+{
+    b_log(B_INFO, "renaming %s -> %s", old_path, new_path);
+    if (rename(old_path, new_path) < 0) {
+        b_log(B_ERROR, "could not rename %s to %s: %s", old_path, new_path, strerror(errno));
+        return false;
+    }
+    return true;
+}
+
+bool b_read_entire_file(const char *path, B_String_Builder *sb)
+{
+    bool result = true;
+
+    FILE *f = fopen(path, "rb");
+    if (f == NULL)                 b_return_defer(false);
+    if (fseek(f, 0, SEEK_END) < 0) b_return_defer(false);
+    long m = ftell(f);
+    if (m < 0)                     b_return_defer(false);
+    if (fseek(f, 0, SEEK_SET) < 0) b_return_defer(false);
+
+    size_t new_count = sb->count + m;
+    if (new_count > sb->capacity) {
+        sb->items = realloc(sb->items, new_count);
+        B_ASSERT(sb->items != NULL && "Buy more RAM lool!!");
+        sb->capacity = new_count;
+    }
+
+    fread(sb->items + sb->count, m, 1, f);
+    if (ferror(f)) {
+        // TODO: Afaik, ferror does not set errno. So the error reporting in defer is not correct in this case.
+        b_return_defer(false);
+    }
+    sb->count = new_count;
+
+defer:
+    if (!result) b_log(B_ERROR, "Could not read file %s: %s", path, strerror(errno));
+    if (f) fclose(f);
+    return result;
+}
+
+B_String_View b_sv_chop_by_delim(B_String_View *sv, char delim)
+{
+    size_t i = 0;
+    while (i < sv->count && sv->data[i] != delim) {
+        i += 1;
+    }
+
+    B_String_View result = b_sv_from_parts(sv->data, i);
+
+    if (i < sv->count) {
+        sv->count -= i + 1;
+        sv->data  += i + 1;
+    } else {
+        sv->count -= i;
+        sv->data  += i;
+    }
+
+    return result;
+}
+
+B_String_View b_sv_from_parts(const char *data, size_t count)
+{
+    B_String_View sv;
+    sv.count = count;
+    sv.data = data;
+    return sv;
+}
+
+B_String_View b_sv_trim_left(B_String_View sv)
+{
+    size_t i = 0;
+    while (i < sv.count && isspace(sv.data[i])) {
+        i += 1;
+    }
+
+    return b_sv_from_parts(sv.data + i, sv.count - i);
+}
+
+B_String_View b_sv_trim_right(B_String_View sv)
+{
+    size_t i = 0;
+    while (i < sv.count && isspace(sv.data[sv.count - 1 - i])) {
+        i += 1;
+    }
+
+    return b_sv_from_parts(sv.data, sv.count - i);
+}
+
+B_String_View b_sv_trim(B_String_View sv)
+{
+    return b_sv_trim_right(b_sv_trim_left(sv));
+}
+
+B_String_View b_sv_from_cstr(const char *cstr)
+{
+    return b_sv_from_parts(cstr, strlen(cstr));
+}
+
+bool b_sv_eq(B_String_View a, B_String_View b)
+{
+    if (a.count != b.count) {
+        return false;
+    } else {
+        return memcmp(a.data, b.data, a.count) == 0;
+    }
+}
+
+// RETURNS:
+//  0 - file does not exists
+//  1 - file exists
+// -1 - error while checking if file exists. The error is logged
+int b_file_exists(const char *file_path)
+{
+    struct stat statbuf;
+    if (stat(file_path, &statbuf) < 0) {
+        if (errno == ENOENT) return 0;
+        b_log(B_ERROR, "Could not check if file %s exists: %s", file_path, strerror(errno));
+        return -1;
+    }
+    return 1;
+}
+
+#endif
diff --git a/src/render.c b/src/render.c
index b6383c4..db3c168 100644
--- a/src/render.c
+++ b/src/render.c
@@ -1,4 +1,7 @@
+
+#include <emmintrin.h>
 #include <stddef.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <time.h>
 
@@ -22,48 +25,25 @@
 #define VKSETUP_IMPLEMENTATION
 #include "vksetup.h"
 
+#define FAST_OBJ_IMPLEMENTATION
+#include "../lib/fast_obj.h"
+
+#define CGLTF_IMPLEMENTATION
+#include "../lib/cgltf.h"
+
 //#include "cplusplus.h"
-#include "vkutil.h"
+//#include "vkutil.h"
 #include "state.h"
 
+#define MODEL_PATH "assets/human.obj"
+#define TEXTURE_PATH "assets/viking_room.png"
+
+void load_model_obj();
+
 // embedded clgm library
 uint32_t currentFrame = 0;
 state_t s;
 
-const char *const validation_layers[] = {
-  "VK_LAYER_KHRONOS_validation"
-};
-const uint32_t validation_layer_count = VK_ARRAY_LEN(validation_layers);
-
-const char *const device_extensions[] = {
-    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
-};
-const uint32_t deviceExtensionCount = VK_ARRAY_LEN(device_extensions);
-
-
-#ifdef VKDEBUG
-    const bool enableValidationLayers = true;
-#else
-    const bool enableValidationLayers = false;
-#endif
-
-typedef struct {
-  float x;
-  float y;
-} V2;
-
-typedef struct {
-  float x;
-  float y;
-  float z;
-} V3;
-
-typedef struct {
-  V3 pos;
-  V3 color;
-  V2 texCoord;
-} Vertex;
-
 /* Vertex vertices[] = { */
 /*   (Vertex) { (V2) {-0.2f, -0.5f}, (V3) {0.0f, 1.0f, 0.0f}}, */
 /*   (Vertex) { (V2) {0.5f,  0.3f}, (V3) {0.0f, 0.0f, 1.0f}}, */
@@ -97,7 +77,7 @@ Vertex vertices[] = {
 };
 const int VERTICES_SIZE = VK_ARRAY_LEN(vertices);
 
-const uint16_t indices[] = {
+const uint32_t indices[] = {
   0, 1, 2, 2, 3, 0, 4, 5, 6, 6, 7, 4, 8, 5, 4
 };
 const int INDICES_SIZE = VK_ARRAY_LEN(indices);
@@ -117,7 +97,8 @@ const int INDICES_SIZE = VK_ARRAY_LEN(indices);
 /* }; */
 /* const int INDICES_SIZE = VK_ARRAY_LEN(indices); */
 
-static int resizing_event_watcher(void* data, SDL_Event* event) {
+static int resizing_event_watcher(void *data, SDL_Event *event) {
+  (void) data;
   if (event->type == SDL_WINDOWEVENT &&
       event->window.event == SDL_WINDOWEVENT_RESIZED) {
     s.sdl_window_resized = 1;
@@ -180,6 +161,9 @@ debugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
               const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
               void* pUserData)
 {
+  (void) messageSeverity;
+  (void) messageType;
+  (void) pUserData;
   vk_log(VK_ERROR, "validation layer: %s\n", pCallbackData->pMessage);
   return VK_FALSE;
 }
@@ -527,7 +511,6 @@ void
 mouseCallback(SDL_Event *event)
 {
   if (event->type != SDL_MOUSEMOTION) return;
-  if (!s.mouse_pressed) return;
   float xoffset = event->motion.xrel;
   float yoffset = -event->motion.yrel; // Reversed since y-coordinates range from bottom to top
 
@@ -535,7 +518,20 @@ mouseCallback(SDL_Event *event)
   xoffset *= sensitivity;
   yoffset *= sensitivity;
 
-  update_camera(xoffset, yoffset);
+  if (s.mouse_pressed) {
+    update_camera(xoffset, yoffset);
+  } else if (s.middle_click) {
+    vec4 _up = {0, 1, 0, 0};
+    vec4 _right = {1, 0, 0, 0};
+
+    vec4 up, right;
+    glm_mat4_mulv(s.ubo.model, _up, up);
+    glm_mat4_mulv(s.ubo.model, _right, right);
+
+    glm_rotate(s.ubo.model, glm_rad(xoffset * glm_rad(90.0f)), GLM_ZUP);
+    glm_rotate(s.ubo.model, glm_rad(yoffset * glm_rad(90.0f)), GLM_XUP);
+  }
+  return;
 }
 
 void
@@ -612,7 +608,7 @@ vulkan_create_swap_chain()
 
 
 VkImageView
-create_image_view(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags)
+create_image_view(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags, uint32_t mipLevels)
 {
   VkImageViewCreateInfo viewInfo = {0};
   viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
@@ -621,7 +617,7 @@ create_image_view(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags
   viewInfo.format = format;
   viewInfo.subresourceRange.aspectMask = aspectFlags;
   viewInfo.subresourceRange.baseMipLevel = 0;
-  viewInfo.subresourceRange.levelCount = 1;
+  viewInfo.subresourceRange.levelCount = mipLevels;
   viewInfo.subresourceRange.baseArrayLayer = 0;
   viewInfo.subresourceRange.layerCount = 1;
 
@@ -635,7 +631,7 @@ void
 vulkan_create_image_views()
 {
   for (size_t i = 0; i < s.vk_swap_chain_image_count; i++) {
-    s.vk_swap_chain_image_views[i] = create_image_view(s.vk_swap_chain_images[i], s.vk_swap_chain_image_format, VK_IMAGE_ASPECT_COLOR_BIT);
+    s.vk_swap_chain_image_views[i] = create_image_view(s.vk_swap_chain_images[i], s.vk_swap_chain_image_format, VK_IMAGE_ASPECT_COLOR_BIT, 1);
   }
   vk_log(VK_INFO, "Vulkan image views created!\n");
 }
@@ -725,7 +721,7 @@ findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties)
 }
 
 void
-createImage(uint32_t width, uint32_t height, VkFormat format,
+createImage(uint32_t width, uint32_t height, uint32_t mipLevels, VkFormat format,
             VkImageTiling tiling, VkImageUsageFlags usage,
             VkMemoryPropertyFlags properties, VkImage *image,
             VkDeviceMemory *imageMemory)
@@ -736,7 +732,7 @@ createImage(uint32_t width, uint32_t height, VkFormat format,
   imageInfo.extent.width = width;
   imageInfo.extent.height = height;
   imageInfo.extent.depth = 1;
-  imageInfo.mipLevels = 1;
+  imageInfo.mipLevels = mipLevels;
   imageInfo.arrayLayers = 1;
   imageInfo.format = format;
   imageInfo.tiling = tiling;
@@ -807,7 +803,7 @@ void
 transitionImageLayout(VkImage image, VkFormat format,
                       VkAccessFlags srcAccessMask, VkAccessFlags dstAccessMask,
                       VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask,
-                      VkImageLayout oldLayout, VkImageLayout newLayout)
+                      VkImageLayout oldLayout, VkImageLayout newLayout, uint32_t mipLevels)
 {
   VkCommandBuffer commandBuffer = beginSingleTimeCommands();
 
@@ -833,7 +829,7 @@ transitionImageLayout(VkImage image, VkFormat format,
   }
 
   barrier.subresourceRange.baseMipLevel = 0;
-  barrier.subresourceRange.levelCount = 1;
+  barrier.subresourceRange.levelCount = mipLevels;
   barrier.subresourceRange.baseArrayLayer = 0;
   barrier.subresourceRange.layerCount = 1;
 
@@ -880,18 +876,18 @@ void
 vulkan_create_depth_resources()
 {
   VkFormat depthFormat = findDepthFormat();
-  createImage(s.vk_swap_chain_extent.width, s.vk_swap_chain_extent.height,
+  createImage(s.vk_swap_chain_extent.width, s.vk_swap_chain_extent.height, 1,
               depthFormat, VK_IMAGE_TILING_OPTIMAL,
               VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
               &s.vk_depth_image, &s.vk_depth_image_memory);
   s.vk_depth_image_view = create_image_view(s.vk_depth_image, depthFormat,
-                                            VK_IMAGE_ASPECT_DEPTH_BIT);
+                                            VK_IMAGE_ASPECT_DEPTH_BIT, 1);
 
   transitionImageLayout(s.vk_depth_image, depthFormat,
                         VK_ACCESS_NONE, VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
                         VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
-                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
+                        VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL, 1);
 }
 
 void
@@ -1013,7 +1009,7 @@ vulkan_create_graphics_pipeline(VkPolygonMode polygon_mode)
   rasterizer.lineWidth = 1.0f;
   rasterizer.cullMode = VK_CULL_MODE_NONE;
   //rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
-  //rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
+  rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
   rasterizer.depthBiasEnable = VK_FALSE;
   rasterizer.depthBiasConstantFactor = 0.0f; // Optional
   rasterizer.depthBiasClamp = 0.0f; // Optional
@@ -1159,7 +1155,7 @@ recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
                         s.vk_swap_chain_images[imageIndex], VK_FORMAT_R8G8B8A8_SRGB, 0,
                         VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
-                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
+                        VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 1);
 
   VkRenderingAttachmentInfo colorAttachment = {0};
   colorAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
@@ -1168,7 +1164,7 @@ recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
   colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
   colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
   colorAttachment.clearValue.color =
-    (VkClearColorValue){0.0f, 0.0f, 0.0f, 1.0f};
+    (VkClearColorValue){{0.0f, 0.0f, 0.0f, 1.0f}};
 
   VkRenderingAttachmentInfo depthAttachment = {0};
   depthAttachment.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
@@ -1210,13 +1206,13 @@ recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
   VkDeviceSize offsets[] = {0};
   vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);
   vkCmdBindIndexBuffer(commandBuffer, s.vk_index_buffer, 0,
-                       VK_INDEX_TYPE_UINT16);
+                       VK_INDEX_TYPE_UINT32);
   vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS,
                           s.vk_pipeline_layout, 0, 1,
                           &s.frames[currentFrame].vk_descriptor_set, 0, NULL);
 
   
-  vkCmdDrawIndexed(commandBuffer, INDICES_SIZE, 1, 0, 0, 0);
+  vkCmdDrawIndexed(commandBuffer, s.indices_count, 1, 0, 0, 0); 
   vkCmdEndRendering(commandBuffer);
 
   transitionImageLayout(s.vk_swap_chain_images[imageIndex],
@@ -1225,7 +1221,7 @@ recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex)
                         VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
                         VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                         VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
-                        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR);
+                        VK_IMAGE_LAYOUT_PRESENT_SRC_KHR, 1);
 
   VK_CHECK(vkEndCommandBuffer(commandBuffer));
 }
@@ -1288,7 +1284,8 @@ void copy_buffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size) {
 void
 vulkan_create_vertex_buffer()
 {
-  VkDeviceSize bufferSize = sizeof(vertices[0]) * VERTICES_SIZE;
+  VkDeviceSize bufferSize = sizeof(s.vertices[0]) * s.vertices_count;
+  /* VkDeviceSize bufferSize = sizeof(vertices[0]) * VERTICES_SIZE; */
 
   VkBuffer stagingBuffer;
   VkDeviceMemory stagingBufferMemory;
@@ -1300,7 +1297,8 @@ vulkan_create_vertex_buffer()
 
   void* data;
   VK_CHECK(vkMapMemory(s.vk_device, stagingBufferMemory, 0, bufferSize, 0, &data));
-  memcpy(data, vertices, (size_t) bufferSize);
+  // memcpy(data, vertices, (size_t) bufferSize);
+  memcpy(data, s.vertices, (size_t) bufferSize);
   vkUnmapMemory(s.vk_device, stagingBufferMemory);
 
   createBuffer(bufferSize,
@@ -1317,7 +1315,8 @@ vulkan_create_vertex_buffer()
 void
 vulkan_create_index_buffer()
 {
-  VkDeviceSize bufferSize = sizeof(indices[0]) * INDICES_SIZE;
+  VkDeviceSize bufferSize = sizeof(s.indices[0]) * s.indices_count;
+  /* VkDeviceSize bufferSize = sizeof(indices[0]) * INDICES_SIZE; */
 
   VkBuffer stagingBuffer;
   VkDeviceMemory stagingBufferMemory;
@@ -1329,7 +1328,8 @@ vulkan_create_index_buffer()
 
   void* data;
   VK_CHECK(vkMapMemory(s.vk_device, stagingBufferMemory, 0, bufferSize, 0, &data));
-  memcpy(data, indices, (size_t) bufferSize);
+  memcpy(data, s.indices, (size_t) bufferSize);
+  /* memcpy(data, indices, (size_t) bufferSize); */
   vkUnmapMemory(s.vk_device, stagingBufferMemory);
 
   createBuffer(bufferSize,
@@ -1544,6 +1544,25 @@ handle_input(bool * quit)
       case SDLK_l:
         s.rotate = s.rotate ? 0 : 1;
         break;
+      case SDLK_m:
+        vkDeviceWaitIdle(s.vk_device);
+        free(s.vertices);
+        free(s.indices);
+        if (!strcmp(s.model_path, "assets/human.obj"))
+          strcpy(s.model_path, "assets/viking_room.obj");
+        else if (!strcmp(s.model_path, "assets/viking_room.obj"))
+          strcpy(s.model_path, "assets/test.obj");
+        else
+          strcpy(s.model_path, "assets/human.obj");
+        load_model_obj();
+        vkDestroyBuffer(s.vk_device, s.vk_vertex_buffer, NULL);
+        vkFreeMemory(s.vk_device, s.vk_vertex_buffer_memory, NULL);
+
+        vkDestroyBuffer(s.vk_device, s.vk_index_buffer, NULL);
+        vkFreeMemory(s.vk_device, s.vk_index_buffer_memory, NULL);
+        vulkan_create_vertex_buffer();
+        vulkan_create_index_buffer();
+        break;
       case SDLK_r:
         s.camera.pos[0] = 1.0f;
         s.camera.pos[1] = 1.0f;
@@ -1562,6 +1581,10 @@ handle_input(bool * quit)
         s.camera.lastX = 400.0f;
         s.camera.lastY = 300.0f;
         s.camera.fov = 45.0f;
+
+        glm_mat4_identity(s.ubo.model);
+
+        s.zoom = 10;
         update_camera(0,0);
         break;
       }
@@ -1569,19 +1592,28 @@ handle_input(bool * quit)
     else if (e.type == SDL_MOUSEWHEEL) {
       if(e.wheel.y > 0) // scroll up
         {
-          s.zoom += 1;
+          s.zoom -= 1;
         }
       else if(e.wheel.y < 0) // scroll down
         {
-          s.zoom -= 1;
+          s.zoom += 1;
           if (s.zoom == -100) s.zoom = 1;
         }
     }
     else if (e.type == SDL_MOUSEBUTTONDOWN) {
-      s.mouse_pressed = 1;
+      if (e.button.button != 2) {
+        s.mouse_pressed = 1;
+      } else {
+        s.middle_click = 1;
+      }
+      
     }
     else if (e.type == SDL_MOUSEBUTTONUP) {
-      s.mouse_pressed = 0;
+      if (e.button.button != 2) {
+        s.mouse_pressed = 0;
+      } else {
+        s.middle_click = 0;
+      }
     }
     mouseCallback(&e);
   }
@@ -1617,13 +1649,88 @@ copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width,
   endSingleTimeCommands(commandBuffer);
 }
 
+void generateMipmaps(VkImage image, VkFormat imageFormat, int32_t texWidth, int32_t texHeight, uint32_t mipLevels) {
+  VkCommandBuffer commandBuffer = beginSingleTimeCommands();
+
+  VkImageMemoryBarrier barrier = {0};
+  barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
+  barrier.image = image;
+  barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
+  barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+  barrier.subresourceRange.baseArrayLayer = 0;
+  barrier.subresourceRange.layerCount = 1;
+  barrier.subresourceRange.levelCount = 1;
+
+  int32_t mipWidth = texWidth;
+  int32_t mipHeight = texHeight;
+
+  for (uint32_t i = 1; i < mipLevels; i++) {
+    barrier.subresourceRange.baseMipLevel = i - 1;
+    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
+    barrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+
+    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1,
+                         &barrier);
+
+    VkImageBlit blit = {0};
+    blit.srcOffsets[0] = (VkOffset3D){ 0, 0, 0 };
+    blit.srcOffsets[1] = (VkOffset3D){ mipWidth, mipHeight, 1 };
+    blit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    blit.srcSubresource.mipLevel = i - 1;
+    blit.srcSubresource.baseArrayLayer = 0;
+    blit.srcSubresource.layerCount = 1;
+    blit.dstOffsets[0] = (VkOffset3D){ 0, 0, 0 };
+    blit.dstOffsets[1] = (VkOffset3D){ mipWidth > 1 ? mipWidth / 2 : 1, mipHeight > 1 ? mipHeight / 2 : 1, 1 };
+    blit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
+    blit.dstSubresource.mipLevel = i;
+    blit.dstSubresource.baseArrayLayer = 0;
+    blit.dstSubresource.layerCount = 1;
+
+    vkCmdBlitImage(commandBuffer, image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
+                   image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
+                   VK_FILTER_LINEAR);
+
+    barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
+    barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
+    barrier.srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
+    barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
+
+    vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                         VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, 0, NULL, 0,
+                         NULL, 1, &barrier);
+
+    if (mipWidth > 1) mipWidth /= 2;
+    if (mipHeight > 1) mipHeight /= 2;
+  }
+
+  /* barrier.subresourceRange.baseMipLevel = mipLevels - 1; */
+  /* barrier.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; */
+  /* barrier.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; */
+  /* barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; */
+  /* barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; */
+
+  /* vkCmdPipelineBarrier(commandBuffer, */
+  /*                      VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, 0, */
+  /*                      0, NULL, */
+  /*                      0, NULL, */
+  /*                      1, &barrier); */
+
+  endSingleTimeCommands(commandBuffer);
+}
+
 void
 vulkan_create_texture_image()
 {
   int texWidth, texHeight, texChannels;
-  stbi_uc* pixels = stbi_load("assets/texture.jpg", &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);
+  stbi_uc* pixels = stbi_load(TEXTURE_PATH, &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);
   VkDeviceSize imageSize = texWidth * texHeight * 4;
 
+  s.vk_mip_levels = (uint32_t)floor(log2(fmax(texWidth, texHeight))) + 1;
+
   if (!pixels) {
     vk_log(VK_ERROR, "failed to load texture image!\n");
   }
@@ -1639,9 +1746,9 @@ vulkan_create_texture_image()
 
   stbi_image_free(pixels);
 
-  createImage(texWidth, texHeight, VK_FORMAT_R8G8B8A8_SRGB,
+  createImage(texWidth, texHeight, s.vk_mip_levels, VK_FORMAT_R8G8B8A8_SRGB,
               VK_IMAGE_TILING_OPTIMAL,
-              VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
+              VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT,
               VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &s.vk_texture_image,
               &s.vk_texture_image_memory);
 
@@ -1649,15 +1756,16 @@ vulkan_create_texture_image()
                         s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, 0,
                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                         VK_PIPELINE_STAGE_TRANSFER_BIT, VK_IMAGE_LAYOUT_UNDEFINED,
-                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
+                        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, s.vk_mip_levels);
   copyBufferToImage(stagingBuffer, s.vk_texture_image, (uint32_t)texWidth,
                     (uint32_t)texHeight);
+  generateMipmaps(s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, texWidth, texHeight, s.vk_mip_levels);
   transitionImageLayout(
                         s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB,
                         VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
                         VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
+                        VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, s.vk_mip_levels);
 
   vkDestroyBuffer(s.vk_device, stagingBuffer, NULL);
   vkFreeMemory(s.vk_device, stagingBufferMemory, NULL);
@@ -1666,7 +1774,7 @@ vulkan_create_texture_image()
 void
 vulkan_create_texture_image_view()
 {
-  s.vk_texture_image_view = create_image_view(s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT);
+  s.vk_texture_image_view = create_image_view(s.vk_texture_image, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_ASPECT_COLOR_BIT, s.vk_mip_levels);
 }
 
 void vulkan_create_texture_sampler() {
@@ -1690,12 +1798,235 @@ void vulkan_create_texture_sampler() {
   samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
   samplerInfo.mipLodBias = 0.0f;
   samplerInfo.minLod = 0.0f;
-  samplerInfo.maxLod = 0.0f;
+  samplerInfo.maxLod = VK_LOD_CLAMP_NONE;
 
   VK_CHECK(vkCreateSampler(s.vk_device, &samplerInfo, NULL, &s.vk_texture_sampler));
 }
 
 void
+load_model_obj()
+{
+  fastObjMesh *m = fast_obj_read(s.model_path);
+
+  if (!m) {
+    vk_log(VK_ERROR, "Can't load object\n");
+  }
+
+  s.indices_count = m->index_count;
+  s.indices = (uint32_t *)malloc(s.indices_count * sizeof(uint32_t));
+  s.vertices_count = 0;
+
+  if (m->group_count > 1) {
+    vk_log(VK_WARN, "fast_obj Mesh with groups > 1 not supported.");
+  }
+
+  /*
+    Since blender exports objs indexed we use those same indices for our
+    indexed draw call.
+   */
+
+  /* Count indexs and vertices */
+  size_t c = 0;
+  for (size_t ii = 0; ii < m->group_count; ii++) {
+    const fastObjGroup *grp = &m->groups[ii];
+    for (unsigned int jj = 0; jj < grp->face_count; jj++) {
+      unsigned int fv = m->face_vertices[grp->face_offset + jj];
+      for (unsigned int kk = 0; kk < fv; kk++) {
+        /* position index */
+        uint32_t mip = m->indices[grp->index_offset + c].p - 1; /* make index start from zero */
+
+        /* flag if we've seen the index*/
+        int index_seen = 0;
+        for (size_t i = 0; i < c; i++) {
+          if (mip == s.indices[i]) {
+            index_seen = 1;
+            break;
+          }
+        }
+        s.indices[c] = mip;
+        if (!index_seen) {
+          /* If not seen, incremet vertices */
+          s.vertices_count++;
+        }
+        c++;
+      }
+    }
+  }
+
+  printf("vertex count %ld!!!!!!!!!!!!!!!!!!\n", s.vertices_count);
+  s.vertices = (Vertex *)malloc(s.vertices_count * sizeof(Vertex));
+
+  /* for (size_t i = 0; i < s.indices_count; i++) { */
+  /*   uint32_t mip = s.indices[i]; */
+  /*   int index_seen = 0; */
+  /*   for (size_t j = 0; j < i; j++) { */
+  /*     if (mip == s.indices[j]) { */
+  /*       index_seen = 1; */
+  /*       break; */
+  /*     } */
+  /*   } */
+  /*   if (!index_seen) { */
+  /*     s.vertices[mip].pos.x = m->positions[3 * (mip + 1) + 0]; */
+  /*     s.vertices[mip].pos.y = m->positions[3 * (mip + 1) + 1]; */
+  /*     s.vertices[mip].pos.z = m->positions[3 * (mip + 1) + 2]; */
+  /*   } */
+  /* } */
+ 
+  for (size_t ii = 0; ii < m->group_count; ii++) {
+    const fastObjGroup *grp = &m->groups[ii];
+    size_t idx = 0;
+    for (unsigned int jj = 0; jj < grp->face_count; jj++) {
+      unsigned int fv = m->face_vertices[grp->face_offset + jj];
+      for (unsigned int kk = 0; kk < fv; kk++) {
+        fastObjIndex mi = m->indices[grp->index_offset + idx];
+
+        int flag = 0;
+        for (size_t i = 0; i < idx; i++) {
+          /* if it exists */
+          if (mi.p - 1 == s.indices[i]) {
+            flag = 1;
+            break;
+          }
+        }
+        if (!flag) {
+          int index = mi.p - 1; /* zero indexed */
+          if (mi.p) {
+            s.vertices[index].pos.x = m->positions[3 * mi.p + 0];
+            s.vertices[index].pos.y = m->positions[3 * mi.p + 1];
+            s.vertices[index].pos.z = m->positions[3 * mi.p + 2];
+          }
+          if (mi.t) {
+            s.vertices[index].texCoord.x = m->texcoords[2 * mi.t + 0];
+            s.vertices[index].texCoord.y = 1.0f - m->texcoords[2 * mi.t + 1];
+          }
+          if (mi.n) {
+            s.vertices[index].color.x = m->normals[3 * mi.n + 0];
+            s.vertices[index].color.y = m->normals[3 * mi.n + 1];
+            s.vertices[index].color.z = m->normals[3 * mi.n + 2];
+          }
+        }
+        idx++;
+      }
+    }
+  }
+  
+  fast_obj_destroy(m);
+}
+
+void load_model_gltf() {
+  // TODO maybe copy the raylib implemenetation
+  /*
+       RESTRICTIONS:
+     - Only triangle meshes supported
+     - Vertex attribute types and formats supported:
+         > Vertices (position): vec3: float
+         > Normals: vec3: float
+         > Texcoords: vec2: float
+         > Colors: vec4: u8, u16, f32 (normalized)
+         > Indices: u16, u32 (truncated to u16)
+     - Node hierarchies or transforms not supported
+   */
+
+  /* cgltf_options options; */
+  /* memset(&options, 0, sizeof(cgltf_options)); */
+  /* cgltf_data* data = NULL; */
+  /* cgltf_result result = cgltf_parse_file(&options, MODEL_PATH, &data); */
+
+  /* if (result == cgltf_result_success) */
+  /*   result = cgltf_load_buffers(&options, data, MODEL_PATH); */
+
+  /* if (result == cgltf_result_success) */
+  /*   result = cgltf_validate(data); */
+
+  /* if (data->meshes_count < 1) { */
+  /*   cgltf_free(data); */
+  /*   return; */
+  /* } */
+
+  /* int idx = 0; */
+  /* int meshIndex = 0; */
+  /* for (unsigned int i = 0, meshIndex = 0; i < data->meshes_count; i++) { */
+  /*   for (unsigned int p = 0; p < data->meshes[i].primitives_count; p++) { */
+  /*     // NOTE: We only support primitives defined by triangles */
+  /*     // Other alternatives: points, lines, line_strip, triangle_strip */
+  /*     if (data->meshes[i].primitives[p].type != cgltf_primitive_type_triangles) continue; */
+
+  /*     // NOTE: Attributes data could be provided in several data formats (8, 8u, 16u, 32...), */
+  /*     // Only some formats for each attribute type are supported, read info at the top of this function! */
+
+  /*     for (unsigned int j = 0; j < data->meshes[i].primitives[p].attributes_count; j++) { */
+  /*       // Check the different attributes for every primitive */
+  /*       if (data->meshes[i].primitives[p].attributes[j].type == cgltf_attribute_type_position) {     // POSITION, vec3, float */
+  /*         cgltf_accessor *attribute = data->meshes[i].primitives[p].attributes[j].data; */
+
+  /*         // WARNING: SPECS: POSITION accessor MUST have its min and max properties defined */
+
+  /*         if ((attribute->type == cgltf_type_vec3) && (attribute->component_type == cgltf_component_type_r_32f)) { */
+  /*           // Init raylib mesh vertices to copy glTF attribute data */
+  /*           s.vertices_count = attribute->count / 3; */
+  /*           s.vertices = calloc(attribute->count, attribute->count*sizeof(Vertex)); */
+
+  /*           size_t float_count = cgltf_accessor_unpack_floats(attribute, NULL, 0); */
+  /*           printf("This many floats: %ld\n", float_count); */
+  /*           float floats[float_count] = {}; */
+  /*           cgltf_accessor_unpack_floats(attribute, floats, float_count); */
+
+  /*           for (unsigned int k = 0; k < attribute->count + 3; k+=3) {                                */
+  /*             s.vertices[idx].pos.x = floats[k + 0]; */
+  /*             s.vertices[idx].pos.y = floats[k + 1];                                         */
+  /*             s.vertices[idx].pos.z = floats[k + 2];                                         */
+  /*             //s.indices[idx] = idx; */
+  /*             idx++; */
+  /*           } */
+  /*           // Load 3 components of float data type into mesh.vertices */
+  /*         } */
+  /*       } */
+  /*     } */
+  /*     if (data->meshes[i].primitives[p].indices != NULL) { */
+  /*       printf("THERE ARE INDIXCES!!!\n"); */
+  /*       cgltf_accessor *attribute = data->meshes[i].primitives[p].indices; */
+
+  /*       s.indices_count = attribute->count / 3; */
+  /*       s.indices = calloc(attribute->count, attribute->count*sizeof(uint32_t)); */
+
+  /*       if (attribute->component_type == cgltf_component_type_r_16u) { */
+  /*         size_t float_count = cgltf_accessor_unpack_indices(attribute, NULL, 0, 0); */
+  /*         printf("This many floats: %ld\n", float_count); */
+  /*         uint16_t floats[float_count] = {}; */
+  /*         cgltf_accessor_unpack_indices(attribute, floats, float_count, */
+  /*                                       float_count); */
+
+  /*         for (int x = 0; x < float_count; x++) { */
+  /*           printf("%d \n", floats[x]); */
+  /*         } */
+          
+  /*       } */
+  /*       else if (attribute->component_type == cgltf_component_type_r_32u) { */
+  /*         printf("ASDASDASDAS2222222!\n"); */
+  /*           // Init raylib mesh indices to copy glTF attribute data */
+  /*           /\* model.meshes[meshIndex].indices = RL_MALLOC(attribute->count*sizeof(unsigned short)); *\/ */
+
+  /*           /\* // Load data into a temp buffer to be converted to raylib data type *\/ */
+  /*           /\* unsigned int *temp = malloc(attribute->count*sizeof(unsigned int)); *\/ */
+  /*           /\* LOAD_ATTRIBUTE(attribute, 1, unsigned int, temp); *\/ */
+
+  /*           /\* // Convert data to raylib indices data type (unsigned short) *\/ */
+  /*           /\* for (unsigned int d = 0; d < attribute->count; d++) model.meshes[meshIndex].indices[d] = (unsigned short)temp[d]; *\/ */
+
+  /*           //free(temp); */
+  /*       } */
+  /*     } */
+  /*   } */
+  /* } */
+
+  /* for (int i = 0; i < s.vertices_count; i++) { */
+  /*   printf("%d: %f %f %f\n",i, s.vertices[i].pos.x, s.vertices[i].pos.y, s.vertices[i].pos.z); */
+  /* } */
+
+  /* cgltf_free(data); */
+}
+  
+void
 init_vulkan()
 {
   vk_log(VK_WARN, "====================================\n");
@@ -1704,8 +2035,8 @@ init_vulkan()
 
   //vulkan_create_instance();
   s.vk_instance =
-      vksetup_create_instance(enableValidationLayers, validation_layers,
-                              validation_layer_count, s.sdl_window);
+    vks_create_instance(enableValidationLayers, validation_layers,
+                        validation_layer_count, s.sdl_window);
   // vulkan_setup_debug_messenger();
   vulkan_create_surface();
   vulkan_pick_physical_device();
@@ -1719,6 +2050,8 @@ init_vulkan()
   vulkan_create_texture_image();
   vulkan_create_texture_image_view();
   vulkan_create_texture_sampler();
+  load_model_obj();
+  //load_model_gltf();
   vulkan_create_vertex_buffer();
   vulkan_create_index_buffer();
   vulkan_create_uniform_buffers();
@@ -1777,6 +2110,9 @@ close_vulkan()
   if (s.prev_frag_result) {
     shaderc_result_release(s.prev_frag_result);
   }
+
+  free(s.vertices);
+  free(s.indices);
 }
 
 float
@@ -1798,24 +2134,28 @@ current_time()
 }
 
 void
-updateUniformBuffer(uint32_t currentImage)
+updateUniformBuffer(uint32_t currentImage, float dt)
 {
-  float time = current_time();
-
   UniformBufferObject ubo = {0};
 
+  ubo.time = current_time();
+  ubo.dt = dt;
+
   ubo.resolution[0] = s.vk_swap_chain_extent.width;
   ubo.resolution[1] = s.vk_swap_chain_extent.height;
   
-  glm_mat4_identity(ubo.model);
+  //glm_mat4_identity(ubo.model);
+  glm_mat4_dup(s.ubo.model, ubo.model);
+
+  if (s.rotate)
+    glm_rotate(ubo.model, glm_rad(30 * dt * glm_rad(90.0f)), GLM_ZUP);
 
-  if (!s.rotate)
-    glm_rotate(ubo.model, glm_rad(50 * time * glm_rad(90.0f)), GLM_ZUP);
+  glm_mat4_dup(ubo.model, s.ubo.model);
 
-  vec3 eye = GLM_VEC3_ONE_INIT;
-  vec3 center = GLM_VEC3_ZERO_INIT;
+  /* vec3 eye = GLM_VEC3_ONE_INIT; */
+  /* vec3 center = GLM_VEC3_ZERO_INIT; */
 
-//  vk_log(VK_INFO, "{%.2f, %.2f, %.2f}\n", s.camera.front[0], s.camera.front[1], s.camera.front[2]);
+  //  vk_log(VK_INFO, "{%.2f, %.2f, %.2f}\n", s.camera.front[0], s.camera.front[1], s.camera.front[2]);
   /* glm_vec3_add(s.camera.pos, s.camera.front, center); */
   glm_lookat(s.camera.pos, s.camera.front, s.camera.up, ubo.view);
 
@@ -1830,8 +2170,15 @@ updateUniformBuffer(uint32_t currentImage)
   memcpy(s.frames[currentImage].vk_uniform_buffer_mapped, &ubo, sizeof(ubo));
 }
 
+float prev_time = 0;
+
 void
 draw_frame() {
+  float time = current_time();
+
+  float dt = time - prev_time;
+  
+
   vkWaitForFences(s.vk_device, 1, &s.frames[currentFrame].in_flight_fence, VK_TRUE, UINT64_MAX);
 
   uint32_t imageIndex;
@@ -1844,7 +2191,7 @@ draw_frame() {
     vk_log(VK_ERROR, "failed to acquire swap chain image!\n");
   }
 
-  updateUniformBuffer(currentFrame);
+  updateUniformBuffer(currentFrame, dt);
 
   vkResetFences(s.vk_device, 1, &s.frames[currentFrame].in_flight_fence);
 
@@ -1892,11 +2239,16 @@ draw_frame() {
   }
 
   currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
+    
+  prev_time = time;
 }
 
 int
-main(int argc, char* args[])
+main(int argc, char* argv[])
 {
+  (void) argc;
+  (void)argv;
+
   init_state(&s);
   if (!init()) {
     vk_log(VK_INFO, "Failed to initialize!\n");
diff --git a/src/shader.frag b/src/shader.frag
index 3f76290..075c2ae 100644
--- a/src/shader.frag
+++ b/src/shader.frag
@@ -12,10 +12,77 @@ layout(binding = 0) uniform UniformBufferObject {
   mat4 view;
   mat4 proj;
   vec2 resolution;
+  float time;
+  float dt;
 } ubo;
 
 void main() {
-  //outColor = vec4(fragColor * texture(texSampler, fragTexCoord).rgb, 1.0);
-  outColor = texture(texSampler, fragTexCoord);
-  //outColor = vec4(fragColor ,1);
+  float pulse = sin(ubo.time * .2) * .5 + .5;
+  outColor = vec4(fragColor * texture(texSampler, fragTexCoord).rgb * pulse, 1.0);
+  //outColor = texture(texSampler, fragTexCoord);
+//   float repeat = 10;
+//   float f = mod(ubo.time, repeat);
+//   if (f < repeat / 2) {
+//     outColor = vec4(fragColor * radians(f) ,1);
+//   } else {
+//     outColor = vec4(fragColor * radians(1 - f) ,1);
+//   }
+//   //outColor = (vec4(1) * ubo.model + vec4(1)) * vec4(texture(texSampler, fragTexCoord).rgb * fragColor, 1.0);
 }
+
+// float noise(vec2 p) {
+//     return fract(sin(dot(p, vec2(12.9898, 78.233))) * 43758.5453);
+// }
+
+// float smoothNoise(vec2 p) {
+//     vec2 i = floor(p);
+//     vec2 f = fract(p);
+//     vec2 u = f * f * (3.0 - 2.0 * f);
+//     return mix(mix(noise(i + vec2(0.0, 0.0)), noise(i + vec2(1.0, 0.0)), u.x),
+//                mix(noise(i + vec2(0.0, 1.0)), noise(i + vec2(1.0, 1.0)), u.x), u.y);
+// }
+
+// float fbm(vec2 p) {
+//     float value = 0.0;
+//     float amplitude = 0.5;
+//     for (int i = 0; i < 6; i++) {
+//         value += amplitude * smoothNoise(p);
+//         p *= 2.0;
+//         amplitude *= 0.5;
+//     }
+//     return value;
+// }
+
+// void main() {
+//     vec2 uv = gl_FragCoord.xy / ubo.resolution.xy;
+//     vec2 p = uv * 2.0 - vec2(1.0);
+//     float n = fbm(p * 5.0 - vec2(0.0, ubo.time * 2.0));
+//     outColor = vec4(n, n * 0.5, 0.0, 1.0) * vec4(texture(texSampler, fragTexCoord).rgb, 1.0);
+// }
+
+// void main() {
+
+//     // Calculate a pulsating factor based on sine wave
+//     float pulse = sin(ubo.time * 2.0) * 0.5 + 0.5;
+    
+//     // Set the color using the pulse factor
+//     outColor = vec4(pulse, 0.0, 1.0 - pulse, .5);
+// }
+
+// void main() {
+//     vec2 uv = gl_FragCoord.xy / ubo.resolution;
+//     vec2 center = uv - 0.5;
+    
+//     float angle = ubo.time;
+//     float cosA = cos(angle);
+//     float sinA = sin(angle);
+    
+//     vec2 rotated = vec2(
+//         center.x * cosA - center.y * sinA,
+//         center.x * sinA + center.y * cosA
+//     );
+    
+//     float pattern = step(0.5, mod(rotated.x * 10.0, 1.0)) * step(0.5, mod(rotated.y * 10.0, 1.0));
+    
+//     outColor = vec4(vec3(pattern), 1.0);
+// }
diff --git a/src/shader.vert b/src/shader.vert
index dd50683..182bd51 100644
--- a/src/shader.vert
+++ b/src/shader.vert
@@ -5,6 +5,8 @@ layout(binding = 0) uniform UniformBufferObject {
   mat4 view;
   mat4 proj;
   vec2 resolution;
+  float time;
+  float dt;
 } ubo;
 
 layout(location = 0) in vec3 inPosition;
@@ -17,7 +19,7 @@ layout(location = 1) out vec2 fragTexCoord;
 void main() {
   gl_Position = ubo.proj * ubo.view * ubo.model * vec4(inPosition, 1.0);
   //gl_Position = vec4(inPosition * 2, 1.0);
-  gl_PointSize = 10.0f;
+  gl_PointSize = 1.5f;
 
   fragColor = inColor;
   fragTexCoord = inTexCoord;
diff --git a/src/state.h b/src/state.h
index b56544a..c7b567f 100644
--- a/src/state.h
+++ b/src/state.h
@@ -27,6 +27,8 @@ typedef struct {
   mat4 view;
   mat4 proj;
   vec2 resolution;
+  float time;
+  float dt;
 } UniformBufferObject;
 
 typedef struct {
@@ -43,6 +45,23 @@ typedef struct {
   VkDescriptorSet vk_descriptor_set;
 } frame_data;
 
+typedef struct {
+  float x;
+  float y;
+} V2;
+
+typedef struct {
+  float x;
+  float y;
+  float z;
+} V3;
+
+typedef struct {
+  V3 pos;
+  V3 color;
+  V2 texCoord;
+} Vertex;
+
 typedef struct state {
   camera3d camera;
 
@@ -54,6 +73,7 @@ typedef struct state {
 
   int rotate;
   int mouse_pressed;
+  int middle_click;
 
   UniformBufferObject ubo;
 
@@ -102,6 +122,7 @@ typedef struct state {
   shaderc_compilation_result_t prev_vert_result;
   shaderc_compilation_result_t prev_frag_result;
 
+  uint32_t vk_mip_levels;
   VkImage vk_texture_image;
   VkDeviceMemory vk_texture_image_memory;
   VkImageView vk_texture_image_view;
@@ -112,11 +133,22 @@ typedef struct state {
   VkImageView vk_depth_image_view;
 
   VkPolygonMode polygon_mode;
-} state_t ;
+
+  Vertex *vertices;
+  size_t vertices_count;
+  uint32_t * indices;
+  size_t indices_count;
+  VkBuffer vertexBuffer;
+  VkDeviceMemory vertexBufferMemory;
+
+  char model_path[1000];
+} state_t;
 
 static void
-init_state(state_t * s)
+init_state(state_t *s)
 {
+
+  strcpy(s->model_path, "assets/viking_room.obj");
   s->camera.pos[0] = 2.0f;
   s->camera.pos[1] = 2.0f;
   s->camera.pos[2] = 2.0f;
@@ -137,6 +169,7 @@ init_state(state_t * s)
 
   s->rotate = 0;
   s->mouse_pressed = 0;
+  s->middle_click = 0;
 
   s->sdl_window_resized = 0;
 
@@ -154,6 +187,8 @@ init_state(state_t * s)
   s->zoom = 10;
   s->x = 0.0f;
 
+  glm_mat4_identity(s->ubo.model);
+
   s->sdl_window = NULL;
 
   s->vk_swap_chain_image_count = 0;
diff --git a/src/vksetup.h b/src/vksetup.h
index 2feb533..88f579a 100644
--- a/src/vksetup.h
+++ b/src/vksetup.h
@@ -15,6 +15,10 @@
   - Using shaderc for compiling glsl
   - Using vulkan(!)
 
+  This is not meant to be a generic werapper around vulkan. It is actively
+  paired and chaned by the currently in development application, whatever that
+  might be. Think of it as the vulkan setup configuratior and helper.
+
   USAGE:
   ~~~~~~
    Do this:
@@ -32,60 +36,141 @@
 
 #define SDL_MAIN_HANDLED
 #define VK_USE_PLATFORM_XCB_KHR
+#include <stdarg.h>
+
 #include <SDL2/SDL.h>
 #include <SDL2/SDL_vulkan.h>
 
 #include <vulkan/vulkan.h>
+#include <vulkan/vk_enum_string_helper.h> // for string_VkResult
 
 #include <shaderc/shaderc.h>
 
 #include "../lib/cglm/include/cglm/cglm.h"
 
+#define VK_ARRAY_LEN(arr) sizeof((arr))/sizeof((arr)[0])
+
+#ifdef __clang__
+#define __FILENAME__ __FILE_NAME__
+#else
+#define __FILENAME__ __FILE__
+#endif
+
+#define VK_CHECK(x)                                   \
+do {                                                  \
+  VkResult err = x;                                   \
+  if (err < 0) {                                      \
+    fprintf(stderr, "src/%s:%d:0: vulkan error: %s   \n", \
+    __FILENAME__, __LINE__, string_VkResult(err));        \
+    abort();                                          \
+  }                                                   \
+} while (0)
+
+typedef enum {
+  VK_INFO = 0,
+  VK_WARN,
+  VK_ERROR,
+} log_type;
+
+static inline void
+_vk_log(log_type t, const char * f, ...)
+{
+#ifdef VKDEBUG
+  va_list args;
+  va_start(args, f);
+  switch (t) {
+  case VK_INFO:
+    printf("INFO: ");
+    vprintf(f, args);
+    break;
+  case VK_WARN:
+    fprintf(stderr, "WARN: ");
+    vfprintf(stderr, f, args);
+    break;
+  case VK_ERROR:
+    fprintf(stderr, "ERROR: ");
+    vfprintf(stderr, f, args);
+    break;
+  }
+  va_end(args);
+#else
+  return;
+#endif
+}
+
+#ifdef VKDEBUG
+#define vk_log(t, ...) do {                                \
+  fprintf(t == VK_INFO ? stdout : stderr, "src/%s:%d:0: ", \
+  __FILENAME__, __LINE__);                                 \
+  _vk_log(t, __VA_ARGS__);                                 \
+} while(0)
+#else
+#define vk_log(t, ...)
+#endif
+
+/**********/
+/* config */
+/**********/
+
+const char *const validation_layers[] = {
+  "VK_LAYER_KHRONOS_validation"
+};
+const uint32_t validation_layer_count = VK_ARRAY_LEN(validation_layers);
+
+const char *const device_extensions[] = {
+    VK_KHR_SWAPCHAIN_EXTENSION_NAME,
+};
+const uint32_t deviceExtensionCount = VK_ARRAY_LEN(device_extensions);
+
+#ifdef VKDEBUG
+    const bool enableValidationLayers = true;
+#else
+    const bool enableValidationLayers = false;
+#endif
+
+
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#ifndef VKSETUPDEF
-#ifdef VKSETUP_STATIC
-#define VKSETUPDEF static
+#ifndef VKSDEF
+#ifdef VKS_STATIC
+#define VKSDEF static
 #else
-#define VKSETUPDEF extern
+#define VKSDEF extern
 #endif
 #endif
 
 // TODO Create structs for vulkan data
 
-typedef struct {void * a;} vksetup_vulkan;
-typedef struct {void * a;} vksetup_image;
-typedef struct {void * a;} vksetup_;
-
-// need abstraction with the
-
+typedef struct {void * a;} vks_vulkan;
+typedef struct {void * a;} vks_image;
+typedef struct {void * a;} vks_;
 
 /**
    Create a VkInstance
  */
-VKSETUPDEF VkInstance vksetup_create_instance(bool validation_layers_toggle, const char * const validation_layers[], uint32_t validation_layer_count, SDL_Window *window);
-/* VKSETUPDEF void vulkan_create_surface(); */
-/* VKSETUPDEF void vulkan_pick_physical_device(); */
-/* VKSETUPDEF void vulkan_create_logical_device(); */
-/* VKSETUPDEF void vulkan_create_swap_chain(); */
-/* VKSETUPDEF void vulkan_create_image_views(); */
-/* VKSETUPDEF void vulkan_create_descriptor_set_layout(); */
-/* VKSETUPDEF void vulkan_create_graphics_pipeline(); */
-/* VKSETUPDEF void vulkan_create_command_pool(); */
-/* VKSETUPDEF void vulkan_create_depth_resources(); */
-/* VKSETUPDEF void vulkan_create_texture_image(); */
-/* VKSETUPDEF void vulkan_create_texture_image_view(); */
-/* VKSETUPDEF void vulkan_create_texture_sampler(); */
-/* VKSETUPDEF void vulkan_create_vertex_buffer(); */
-/* VKSETUPDEF void vulkan_create_index_buffer(); */
-/* VKSETUPDEF void vulkan_create_uniform_buffers(); */
-/* VKSETUPDEF void vulkan_create_descriptor_pool(); */
-/* VKSETUPDEF void vulkan_create_descriptor_sets(); */
-/* VKSETUPDEF void vulkan_create_command_buffer(); */
-/* VKSETUPDEF void vulkan_create_sync_objects(); */
+VKSDEF VkInstance vks_create_instance(bool validation_layers_toggle, const char * const validation_layers[], uint32_t validation_layer_count, SDL_Window *window);
+/* VKSDEF void vulkan_create_surface(); */
+/* VKSDEF void vulkan_pick_physical_device(); */
+/* VKSDEF void vulkan_create_logical_device(); */
+/* VKSDEF void vulkan_create_swap_chain(); */
+/* VKSDEF void vulkan_create_image_views(); */
+/* VKSDEF void vulkan_create_descriptor_set_layout(); */
+/* VKSDEF void vulkan_create_graphics_pipeline(); */
+/* VKSDEF void vulkan_create_command_pool(); */
+/* VKSDEF void vulkan_create_depth_resources(); */
+/* VKSDEF void vulkan_create_texture_image(); */
+/* VKSDEF void vulkan_create_texture_image_view(); */
+/* VKSDEF void vulkan_create_texture_sampler(); */
+/* VKSDEF void vulkan_create_vertex_buffer(); */
+/* VKSDEF void vulkan_create_index_buffer(); */
+/* VKSDEF void vulkan_create_uniform_buffers(); */
+/* VKSDEF void vulkan_create_descriptor_pool(); */
+/* VKSDEF void vulkan_create_descriptor_sets(); */
+/* VKSDEF void vulkan_create_command_buffer(); */
+/* VKSDEF void vulkan_create_sync_objects(); */
 
 #ifdef __cplusplus
 }
@@ -99,10 +184,11 @@ VKSETUPDEF VkInstance vksetup_create_instance(bool validation_layers_toggle, con
 #include <stddef.h>
 #include <stdlib.h>
 #include <time.h>
-#include "vkutil.h"
+
+/* Vks helpers */
 
 bool
-_checkValidationLayerSupport(const char * const validation_layers[], uint32_t validation_layer_count)
+vks_check_validation_layer_support(const char * const validation_layers[], uint32_t validation_layer_count)
 {
   uint32_t layerCount;
   vkEnumerateInstanceLayerProperties(&layerCount, NULL);
@@ -110,29 +196,28 @@ _checkValidationLayerSupport(const char * const validation_layers[], uint32_t va
   VkLayerProperties availableLayers[layerCount];
   vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);
 
+  bool layerFound = false;
   for (uint32_t i = 0; i < validation_layer_count; i++) {
-    bool layerFound = false;
-
     for (uint32_t j = 0; j < layerCount; j++) {
       if (strcmp(validation_layers[i], availableLayers[j].layerName) == 0) {
         layerFound = true;
         break;
       }
     }
-
-    if (!layerFound) {
-      return false;
-    }
   }
 
-  return true;
+  return layerFound;
 }
 
-VKSETUPDEF VkInstance
-vksetup_create_instance(bool validation_layers_toggle, const char * const validation_layers[], uint32_t validation_layer_count, SDL_Window *window)
+/* Vks API implementation */
+
+VKSDEF VkInstance
+vks_create_instance(bool validation_layers_toggle, const char * const validation_layers[],
+                    uint32_t validation_layer_count, SDL_Window *window)
 {
-  if (validation_layers_toggle && !_checkValidationLayerSupport(validation_layers, validation_layer_count)) {
+  if (validation_layers_toggle && !vks_check_validation_layer_support(validation_layers, validation_layer_count)) {
     vk_log(VK_ERROR, "validation layers requested, but not available!\n");
+    abort();
   }
 
   uint32_t instanceVersion;
@@ -166,6 +251,7 @@ vksetup_create_instance(bool validation_layers_toggle, const char * const valida
 
   if (SDL_Vulkan_GetInstanceExtensions(window, &sdlExtensionCount, NULL) == SDL_FALSE) {
     vk_log(VK_ERROR, "SDL_Vulkan_GetInstanceExtensions failed: %s\n", SDL_GetError());
+    abort();
   }
 
   // make space for debug extenetion
@@ -177,6 +263,7 @@ vksetup_create_instance(bool validation_layers_toggle, const char * const valida
 
   if (SDL_Vulkan_GetInstanceExtensions(window, &sdlExtensionCount, sdlExtensions) == SDL_FALSE) {
     vk_log(VK_ERROR, "SDL_Vulkan_GetInstanceExtensions failed: %s\n", SDL_GetError());
+    abort();
   }
 
   // add debug extenetion
@@ -213,4 +300,3 @@ vksetup_create_instance(bool validation_layers_toggle, const char * const valida
 }
 
 #endif /* VKSETUP_IMPLEMENTATION */
-