diff -r 000000000000 -r 593b60458157 src/core.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/core.c	Fri Oct 06 21:21:10 2023 +0200
@@ -0,0 +1,285 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ * Copyright 2023 Mike Becker. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *
+ *   2. Redistributions in binary form must reproduce the above copyright
+ *      notice, this list of conditions and the following disclaimer in the
+ *      documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "ascension/core.h"
+#include "ascension/utils.h"
+
+#include <cx/linked_list.h>
+#include <cx/printf.h>
+
+static void asc_gl_debug_callback(
+        GLenum source, GLenum type, GLuint id, GLenum severity,
+        GLsizei length, const GLchar* message,
+        const void* userParam
+) {
+    cxmutstr buf = cx_asprintf(
+            "source = %d, id = %u, type = %d, severity= %d, message = %.*s",
+            source, id, type, severity, length, message);
+    if (type == GL_DEBUG_TYPE_ERROR) {
+        asc_error(buf.ptr);
+    } else {
+        asc_dprintf("GL debug: %*.s", (int)buf.length, buf.ptr);
+    }
+    cx_strfree(&buf);
+}
+
+AscContext asc_context;
+
+// forward declarations
+static void asc_window_destroy_impl(AscWindow* window);
+
+void asc_context_initialize(void) {
+    if (asc_test_flag(asc_context.flags, ASC_FLAG_INITILIZED))
+        return;
+    asc_clear_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);
+
+    // initialize error buffer
+    cxBufferInit(
+            &asc_context.error_buffer,
+            NULL,
+            256,
+            NULL,
+            CX_BUFFER_AUTO_EXTEND
+    );
+
+    // initialize lists
+    asc_context.windows = cxLinkedListCreateSimple(CX_STORE_POINTERS);
+    asc_context.windows->simple_destructor =
+            (cx_destructor_func)asc_window_destroy_impl;
+
+    // initialize SDL
+    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
+        asc_error(SDL_GetError());
+    } else {
+        if (TTF_Init() < 0) {
+            asc_error(TTF_GetError());
+        }
+    }
+    SDL_ClearError();
+    asc_set_flag(&asc_context.flags, ASC_FLAG_INITILIZED);
+    asc_dprintf("Ascension context initialized.");
+}
+
+void asc_context_destroy(void) {
+    // destroy lists
+    cxListDestroy(asc_context.windows);
+
+    // quit SDL
+    if (TTF_WasInit())
+        TTF_Quit();
+    SDL_Quit();
+
+    // destroy the error buffer
+    cxBufferDestroy(&asc_context.error_buffer);
+    asc_context.flags = 0;
+    asc_dprintf("Ascension context destroyed.");
+}
+
+void asc_error_cchar(char const* text) {
+    asc_error_cxstr(cx_str(text));
+}
+
+void asc_error_cuchar(unsigned char const* text) {
+    asc_error_cxstr(cx_str((char const*)text));
+}
+
+void asc_error_cxstr(cxstring text) {
+    if (text.length == 0) return;
+
+    // write error to debug output
+    asc_dprintf("ERROR: %*.s", (int)text.length, text.ptr);
+
+    // write error to buffer
+    CxBuffer* buf = &asc_context.error_buffer;
+    cxBufferWrite(text.ptr, 1, text.length, buf);
+    cxBufferPut(buf, '\n');
+
+    asc_set_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);
+}
+
+bool asc_has_error(void) {
+    return asc_test_flag(asc_context.flags, ASC_FLAG_HAS_ERROR);
+}
+
+char const* asc_get_error(void) {
+    // we zero-terminate the current buffer contents before providing them
+    cxBufferPut(&asc_context.error_buffer, 0);
+    --asc_context.error_buffer.pos;
+    --asc_context.error_buffer.size;
+    return asc_context.error_buffer.space;
+}
+
+void asc_clear_error(void) {
+    cxBufferClear(&asc_context.error_buffer);
+    asc_clear_flag(&asc_context.flags, ASC_FLAG_HAS_ERROR);
+}
+
+static void asc_event_window_resized(Uint32 id, Sint32 width, Sint32 height) {
+    CxIterator iter = cxListIterator(asc_context.windows);
+    cx_foreach(AscWindow*, w, iter) {
+        if (w->id == id) {
+            w->width = width;
+            w->height = height;
+            return;
+        }
+    }
+}
+
+bool asc_loop_next(void) {
+    // dispatch SDL events
+    SDL_Event event;
+    while (SDL_PollEvent(&event)) {
+        switch (event.type) {
+        case SDL_QUIT:return false;
+        case SDL_WINDOWEVENT: {
+            if (event.window.type == SDL_WINDOWEVENT_RESIZED)
+                asc_event_window_resized(
+                        event.window.windowID,
+                        event.window.data1,
+                        event.window.data2
+                );
+            break;
+        }
+        case SDL_KEYDOWN:
+            // TODO: remove this code and implement key press map instead
+            if (event.key.keysym.sym == SDLK_ESCAPE)
+                return false;
+            break;
+        case SDL_KEYUP:
+            // TODO: implement key press map
+            break;
+        }
+    }
+
+    // sync the windows
+    CxMutIterator windows = cxListMutIterator(asc_context.windows);
+    cx_foreach(AscWindow*, w, windows) {
+        asc_window_sync(w);
+    }
+    return true;
+}
+
+void asc_window_settings_init_defaults(AscWindowSettings* settings) {
+    settings->depth_size = 24;
+    settings->vsync = 1;
+    settings->width = 800;
+    settings->height = 600;
+    settings->fullscreen = 0;
+    settings->gl_major_version = 3;
+    settings->gl_minor_version = 3;
+    settings->title = "Ascended Window";
+}
+
+void asc_window_initialize(AscWindow* window, AscWindowSettings const* settings) {
+    Uint32 flags = SDL_WINDOW_OPENGL | SDL_WINDOW_SHOWN;
+    flags |= settings->fullscreen ? SDL_WINDOW_FULLSCREEN_DESKTOP : SDL_WINDOW_RESIZABLE;
+
+    window->window = SDL_CreateWindow(
+            settings->title,
+            SDL_WINDOWPOS_CENTERED,
+            SDL_WINDOWPOS_CENTERED,
+            settings->width,
+            settings->height,
+            flags
+    );
+    if (window->window == NULL) {
+        asc_error(SDL_GetError());
+        return;
+    }
+
+    window->id = SDL_GetWindowID(window->window);
+    SDL_GetWindowSize(window->window, &window->width, &window->height);
+
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, settings->gl_major_version);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, settings->gl_minor_version);
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, settings->depth_size);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    window->glctx = SDL_GL_CreateContext(window->window);
+    if (window->glctx == NULL) {
+        asc_dprintf("Creating GL context failed for window %u", window->id);
+    } else {
+        glewExperimental = GL_TRUE;
+        GLenum err = glewInit();
+        if (err == GLEW_OK) {
+            SDL_GL_SetSwapInterval(settings->vsync);
+            glEnable(GL_DEPTH_TEST);
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+            glEnable(GL_DEBUG_OUTPUT);
+            glDebugMessageCallback(asc_gl_debug_callback, NULL);
+            asc_dprintf("Window %u initialized", window->id);
+            cxListAdd(asc_context.windows, window);
+            return;
+        } else {
+            asc_error(glewGetErrorString(err));
+        }
+    }
+
+    // cleanup on error
+    if (window->glctx != NULL) {
+        SDL_GL_DeleteContext(window->glctx);
+    }
+    window->glctx = NULL;
+    SDL_DestroyWindow(window->window);
+    window->window = NULL;
+    window->id = 0;
+}
+
+void asc_window_destroy_impl(AscWindow* window) {
+    // destory the GL context and the window
+    if (window->glctx != NULL) {
+        SDL_GL_DeleteContext(window->glctx);
+    }
+    if (window->window != NULL) {
+        SDL_DestroyWindow(window->window);
+    }
+
+    // clean the data
+    asc_dprintf("Window %u and its OpenGL context destroyed.", window->id);
+    memset(window, 0, sizeof(AscWindow));
+}
+
+void asc_window_destroy(AscWindow* window) {
+    // find the window in the context and remove it
+    CxMutIterator iter = cxListMutIterator(asc_context.windows);
+    cx_foreach(AscWindow*, w, iter) {
+        if (w == window) {
+            asc_dprintf("Window %u removed from context.", window->id);
+            cxIteratorFlagRemoval(iter);
+        }
+    }
+    asc_window_destroy_impl(window);
+}
+
+void asc_window_sync(AscWindow const* window) {
+    SDL_GL_MakeCurrent(window->window, window->glctx);
+    SDL_GL_SwapWindow(window->window);
+    glViewport(0, 0, window->width, window->height);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}