Adding back GLFW

CMakeLists.txt

@@ -35,7 +35,7 @@ project(Dawn
 # add_subdirectory(tools)
 
 # Add Libraries
-# add_subdirectory(lib)
+add_subdirectory(lib)
 
 # Add Project Files
 add_subdirectory(src)

lib/CMakeLists.txt

@@ -0,0 +1,15 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+include(FetchContent)
+
+add_library(font8x8 INTERFACE)
+target_include_directories(font8x8 INTERFACE font8x8)
+
+add_subdirectory(glad)
+
+# GLFW
+FetchContent_Declare(glfw URL https://github.com/glfw/glfw/releases/download/3.4/glfw-3.4.zip)
+FetchContent_MakeAvailable(glfw)

lib/glad/CMakeLists.txt

@@ -0,0 +1,12 @@
+cmake_minimum_required(VERSION 3.11)
+project(glad)
+set(CMAKE_C_STANDARD 99)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+
+add_library(${PROJECT_NAME}
+  src/glad.c
+)
+target_include_directories(${PROJECT_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_SOURCE_DIR}/include
+)

lib/glad/include/KHR/khrplatform.h

@@ -0,0 +1,290 @@
+#ifndef __khrplatform_h_
+#define __khrplatform_h_
+
+/*
+** Copyright (c) 2008-2018 The Khronos Group Inc.
+**
+** Permission is hereby granted, free of charge, to any person obtaining a
+** copy of this software and/or associated documentation files (the
+** "Materials"), to deal in the Materials without restriction, including
+** without limitation the rights to use, copy, modify, merge, publish,
+** distribute, sublicense, and/or sell copies of the Materials, and to
+** permit persons to whom the Materials are 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 Materials.
+**
+** THE MATERIALS ARE 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
+** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+*/
+
+/* Khronos platform-specific types and definitions.
+ *
+ * The master copy of khrplatform.h is maintained in the Khronos EGL
+ * Registry repository at https://github.com/KhronosGroup/EGL-Registry
+ * The last semantic modification to khrplatform.h was at commit ID:
+ *      67a3e0864c2d75ea5287b9f3d2eb74a745936692
+ *
+ * Adopters may modify this file to suit their platform. Adopters are
+ * encouraged to submit platform specific modifications to the Khronos
+ * group so that they can be included in future versions of this file.
+ * Please submit changes by filing pull requests or issues on
+ * the EGL Registry repository linked above.
+ *
+ *
+ * See the Implementer's Guidelines for information about where this file
+ * should be located on your system and for more details of its use:
+ *    http://www.khronos.org/registry/implementers_guide.pdf
+ *
+ * This file should be included as
+ *        #include <KHR/khrplatform.h>
+ * by Khronos client API header files that use its types and defines.
+ *
+ * The types in khrplatform.h should only be used to define API-specific types.
+ *
+ * Types defined in khrplatform.h:
+ *    khronos_int8_t              signed   8  bit
+ *    khronos_uint8_t             unsigned 8  bit
+ *    khronos_int16_t             signed   16 bit
+ *    khronos_uint16_t            unsigned 16 bit
+ *    khronos_int32_t             signed   32 bit
+ *    khronos_uint32_t            unsigned 32 bit
+ *    khronos_int64_t             signed   64 bit
+ *    khronos_uint64_t            unsigned 64 bit
+ *    khronos_intptr_t            signed   same number of bits as a pointer
+ *    khronos_uintptr_t           unsigned same number of bits as a pointer
+ *    khronos_ssize_t             signed   size
+ *    khronos_usize_t             unsigned size
+ *    khronos_float_t             signed   32 bit floating point
+ *    khronos_time_ns_t           unsigned 64 bit time in nanoseconds
+ *    khronos_utime_nanoseconds_t unsigned time interval or absolute time in
+ *                                         nanoseconds
+ *    khronos_stime_nanoseconds_t signed time interval in nanoseconds
+ *    khronos_boolean_enum_t      enumerated boolean type. This should
+ *      only be used as a base type when a client API's boolean type is
+ *      an enum. Client APIs which use an integer or other type for
+ *      booleans cannot use this as the base type for their boolean.
+ *
+ * Tokens defined in khrplatform.h:
+ *
+ *    KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
+ *
+ *    KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
+ *    KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
+ *
+ * Calling convention macros defined in this file:
+ *    KHRONOS_APICALL
+ *    KHRONOS_APIENTRY
+ *    KHRONOS_APIATTRIBUTES
+ *
+ * These may be used in function prototypes as:
+ *
+ *      KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
+ *                                  int arg1,
+ *                                  int arg2) KHRONOS_APIATTRIBUTES;
+ */
+
+#if defined(__SCITECH_SNAP__) && !defined(KHRONOS_STATIC)
+#   define KHRONOS_STATIC 1
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APICALL
+ *-------------------------------------------------------------------------
+ * This precedes the return type of the function in the function prototype.
+ */
+#if defined(KHRONOS_STATIC)
+    /* If the preprocessor constant KHRONOS_STATIC is defined, make the
+     * header compatible with static linking. */
+#   define KHRONOS_APICALL
+#elif defined(_WIN32)
+#   define KHRONOS_APICALL __declspec(dllimport)
+#elif defined (__SYMBIAN32__)
+#   define KHRONOS_APICALL IMPORT_C
+#elif defined(__ANDROID__)
+#   define KHRONOS_APICALL __attribute__((visibility("default")))
+#else
+#   define KHRONOS_APICALL
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIENTRY
+ *-------------------------------------------------------------------------
+ * This follows the return type of the function  and precedes the function
+ * name in the function prototype.
+ */
+#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
+    /* Win32 but not WinCE */
+#   define KHRONOS_APIENTRY __stdcall
+#else
+#   define KHRONOS_APIENTRY
+#endif
+
+/*-------------------------------------------------------------------------
+ * Definition of KHRONOS_APIATTRIBUTES
+ *-------------------------------------------------------------------------
+ * This follows the closing parenthesis of the function prototype arguments.
+ */
+#if defined (__ARMCC_2__)
+#define KHRONOS_APIATTRIBUTES __softfp
+#else
+#define KHRONOS_APIATTRIBUTES
+#endif
+
+/*-------------------------------------------------------------------------
+ * basic type definitions
+ *-----------------------------------------------------------------------*/
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
+
+
+/*
+ * Using <stdint.h>
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__VMS ) || defined(__sgi)
+
+/*
+ * Using <inttypes.h>
+ */
+#include <inttypes.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
+
+/*
+ * Win32
+ */
+typedef __int32                 khronos_int32_t;
+typedef unsigned __int32        khronos_uint32_t;
+typedef __int64                 khronos_int64_t;
+typedef unsigned __int64        khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif defined(__sun__) || defined(__digital__)
+
+/*
+ * Sun or Digital
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#if defined(__arch64__) || defined(_LP64)
+typedef long int                khronos_int64_t;
+typedef unsigned long int       khronos_uint64_t;
+#else
+typedef long long int           khronos_int64_t;
+typedef unsigned long long int  khronos_uint64_t;
+#endif /* __arch64__ */
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#elif 0
+
+/*
+ * Hypothetical platform with no float or int64 support
+ */
+typedef int                     khronos_int32_t;
+typedef unsigned int            khronos_uint32_t;
+#define KHRONOS_SUPPORT_INT64   0
+#define KHRONOS_SUPPORT_FLOAT   0
+
+#else
+
+/*
+ * Generic fallback
+ */
+#include <stdint.h>
+typedef int32_t                 khronos_int32_t;
+typedef uint32_t                khronos_uint32_t;
+typedef int64_t                 khronos_int64_t;
+typedef uint64_t                khronos_uint64_t;
+#define KHRONOS_SUPPORT_INT64   1
+#define KHRONOS_SUPPORT_FLOAT   1
+
+#endif
+
+
+/*
+ * Types that are (so far) the same on all platforms
+ */
+typedef signed   char          khronos_int8_t;
+typedef unsigned char          khronos_uint8_t;
+typedef signed   short int     khronos_int16_t;
+typedef unsigned short int     khronos_uint16_t;
+
+/*
+ * Types that differ between LLP64 and LP64 architectures - in LLP64,
+ * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
+ * to be the only LLP64 architecture in current use.
+ */
+#ifdef _WIN64
+typedef signed   long long int khronos_intptr_t;
+typedef unsigned long long int khronos_uintptr_t;
+typedef signed   long long int khronos_ssize_t;
+typedef unsigned long long int khronos_usize_t;
+#else
+typedef signed   long  int     khronos_intptr_t;
+typedef unsigned long  int     khronos_uintptr_t;
+typedef signed   long  int     khronos_ssize_t;
+typedef unsigned long  int     khronos_usize_t;
+#endif
+
+#if KHRONOS_SUPPORT_FLOAT
+/*
+ * Float type
+ */
+typedef          float         khronos_float_t;
+#endif
+
+#if KHRONOS_SUPPORT_INT64
+/* Time types
+ *
+ * These types can be used to represent a time interval in nanoseconds or
+ * an absolute Unadjusted System Time.  Unadjusted System Time is the number
+ * of nanoseconds since some arbitrary system event (e.g. since the last
+ * time the system booted).  The Unadjusted System Time is an unsigned
+ * 64 bit value that wraps back to 0 every 584 years.  Time intervals
+ * may be either signed or unsigned.
+ */
+typedef khronos_uint64_t       khronos_utime_nanoseconds_t;
+typedef khronos_int64_t        khronos_stime_nanoseconds_t;
+#endif
+
+/*
+ * Dummy value used to pad enum types to 32 bits.
+ */
+#ifndef KHRONOS_MAX_ENUM
+#define KHRONOS_MAX_ENUM 0x7FFFFFFF
+#endif
+
+/*
+ * Enumerated boolean type
+ *
+ * Values other than zero should be considered to be true.  Therefore
+ * comparisons should not be made against KHRONOS_TRUE.
+ */
+typedef enum {
+    KHRONOS_FALSE = 0,
+    KHRONOS_TRUE  = 1,
+    KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
+} khronos_boolean_enum_t;
+
+#endif /* __khrplatform_h_ */

src/CMakeLists.txt

@@ -8,12 +8,16 @@ add_executable(${DAWN_TARGET_NAME})
 
 # Add base
 add_subdirectory(dawn)
-add_subdirectory(dawnterm)
 
 # Compile entries
-if(DAWN_TARGET STREQUAL "linux-x64-glfw")
+if(DAWN_TARGET STREQUAL "linux-x64-terminal")
   add_subdirectory(dawnlinux)
+  add_subdirectory(dawnterm)
   add_subdirectory(dawntermlinux)
+elseif(DAWN_TARGET STREQUAL "linux-x64-glfw")
+  add_subdirectory(dawnlinux)
+  add_subdirectory(dawnglfw)
+  add_subdirectory(dawnopengl)
 else()
   message(FATAL_ERROR "Unknown target: ${DAWN_TARGET}")
 endif()

src/dawn/CMakeLists.txt

@@ -17,6 +17,7 @@ target_include_directories(${DAWN_TARGET_NAME}
 # Subdirs
 add_subdirectory(assert)
 add_subdirectory(rpg)
+add_subdirectory(ui)
 
 # Sources
 target_sources(${DAWN_TARGET_NAME}

src/dawn/game.c

@@ -10,6 +10,9 @@
 #include "input.h"
 #include "display/display.h"
 #include "rpg/world/maps/testmap.h"
+#include "ui/textbox.h"
+
+#include <font8x8_basic.h>
 
 map_t MAP;
 game_t GAME;
@@ -20,7 +23,8 @@ void gameInit() {
   timeInit();
   inputInit();
   displayInit();
-
+  textboxInit();
+  
   testMapInit(&MAP);
   gameSetMap(&MAP);
 }

src/dawn/rpg/entity/entity.c

@@ -10,6 +10,7 @@
 #include "rpg/world/map.h"
 #include "assert/assert.h"
 #include "time.h"
+#include "ui/textbox.h"
 
 void entityInit(
   entity_t *entity,
@@ -69,6 +70,7 @@ void entityUpdate(entity_t *entity) {
       break;
 
     case ENTITY_STATE_TALKING:
+      if(!textboxIsOpen()) entity->state = ENTITY_STATE_IDLE;
       break;
 
     default:

src/dawn/rpg/entity/player.c

@@ -11,6 +11,7 @@
 #include "rpg/world/map.h"
 #include "input.h"
 #include "assert/assert.h"
+#include "ui/textbox.h"
 
 void playerInit(entity_t *entity) {
   assertTrue(entity->type == ENTITY_TYPE_PLAYER, "Entity is not a player.");
@@ -44,6 +45,7 @@ void playerUpdate(entity_t *entity) {
 
       target->state = ENTITY_STATE_TALKING;
       entity->state = ENTITY_STATE_TALKING;
+      textboxSetText("Hello Player");
       return;
     }
   }

src/dawn/ui/CMakeLists.txt

@@ -0,0 +1,12 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    textbox.c
+)

src/dawn/ui/textbox.c

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "textbox.h"
+#include "assert/assert.h"
+
+textbox_t TEXTBOX;
+
+void textboxInit() {
+  memset(&TEXTBOX, 0, sizeof(textbox_t));
+}
+
+void textboxSetText(const char_t *text) {
+  assertNotNull(text, "Text cannot be NULL.");
+  size_t len = strlen(text);
+  assertTrue(len < TEXTBOX_TEXT_MAX - 1, "Text is too long.");
+  strcpy(TEXTBOX.text, text);
+  TEXTBOX.open = true;
+}
+
+bool_t textboxIsOpen() {
+  return TEXTBOX.open;
+}

src/dawn/ui/textbox.h

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+#define TEXTBOX_TEXT_MAX 256
+
+typedef struct {
+  char_t text[TEXTBOX_TEXT_MAX];
+  bool_t open;
+} textbox_t;
+
+extern textbox_t TEXTBOX;
+
+/**
+ * Initializes the textbox.
+ */
+void textboxInit();
+
+/**
+ * Sets the text of the textbox, and opens it.
+ * 
+ * @param text Text to set.
+ */
+void textboxSetText(const char_t *text);
+
+/**
+ * Returns whether the textbox is open.
+ * 
+ * @return Whether the textbox is open.
+ */
+bool_t textboxIsOpen();

src/dawnglfw/CMakeLists.txt

@@ -0,0 +1,26 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Libraries
+target_link_libraries(${DAWN_TARGET_NAME}
+  PUBLIC
+    glfw
+)
+
+# Includes
+target_include_directories(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    dawnglfw.c
+    linuxhost.c
+    input.c
+)

src/dawnglfw/dawnglfw.c

@@ -0,0 +1,143 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dawnglfw.h"
+#include "game.h"
+#include "assert/assert.h"
+#include "assert/assertgl.h"
+#include "display/backbuffer.h"
+
+dawnglfw_t DAWN_GLFW;
+
+int32_t dawnGlfwStart() {
+  memset(&DAWN_GLFW, 0, sizeof(DAWN_GLFW));
+  
+  // Init GLFW
+  if(!glfwInit()) {
+    assertUnreachable("Failed to initialize GLFW");
+    return -1;
+  }
+  
+  // Setup window hints
+  glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, false);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
+  glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+  glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
+  
+  // Create Window
+  DAWN_GLFW.window = glfwCreateWindow(
+    DAWN_GLFW_WIDTH_DEFAULT,
+    DAWN_GLFW_HEIGHT_DEFAULT,
+    "Dawn",
+    NULL,
+    NULL
+  );
+  if(DAWN_GLFW.window == NULL) {
+    glfwTerminate();
+    assertUnreachable("Failed to create GLFW window");
+  }
+  
+  // Load GLAD
+  glfwMakeContextCurrent(DAWN_GLFW.window);
+  glfwSwapInterval(1);
+  gladLoadGLLoader((GLADloadproc)glfwGetProcAddress);
+  assertNoGLError();
+
+  // Override the defaults
+  int32_t fbWidth, fbHeight;
+  int32_t windowWidth, windowHeight;
+  glfwGetFramebufferSize(DAWN_GLFW.window, &fbWidth, &fbHeight);
+  glfwGetWindowSize(DAWN_GLFW.window, &windowWidth, &windowHeight);
+  assertNoGLError();
+  
+  assertTrue(fbWidth > 0, "Detected framebuffer width is too small?");
+  assertTrue(fbWidth > 0, "Detected framebuffer height is too small?");
+  assertTrue(windowWidth > 0, "Detected window width is too small?");
+  assertTrue(windowHeight > 0, "Detected window height is too small?");
+
+  DAWN_GLFW.width = windowWidth;
+  DAWN_GLFW.height = windowHeight;
+
+  backBufferSetSize(
+    fbWidth,
+    fbHeight,
+    ((float_t)fbWidth) / ((float_t)windowWidth)
+  );
+
+  // Set the input binds
+  dawnGlfwInputBind(INPUT_BIND_UP, GLFW_KEY_W);
+  dawnGlfwInputBind(INPUT_BIND_UP, GLFW_KEY_UP);
+  dawnGlfwInputBind(INPUT_BIND_DOWN, GLFW_KEY_S);
+  dawnGlfwInputBind(INPUT_BIND_DOWN, GLFW_KEY_DOWN);
+  dawnGlfwInputBind(INPUT_BIND_LEFT, GLFW_KEY_A);
+  dawnGlfwInputBind(INPUT_BIND_LEFT, GLFW_KEY_LEFT);
+  dawnGlfwInputBind(INPUT_BIND_RIGHT, GLFW_KEY_D);
+  dawnGlfwInputBind(INPUT_BIND_RIGHT, GLFW_KEY_RIGHT);
+  dawnGlfwInputBind(INPUT_BIND_ACCEPT, GLFW_KEY_ENTER);
+  dawnGlfwInputBind(INPUT_BIND_ACCEPT, GLFW_KEY_SPACE);
+  dawnGlfwInputBind(INPUT_BIND_ACCEPT, GLFW_KEY_E);
+  dawnGlfwInputBind(INPUT_BIND_CANCEL, GLFW_KEY_ESCAPE);
+  dawnGlfwInputBind(INPUT_BIND_CANCEL, GLFW_KEY_Q);
+  dawnGlfwInputBind(INPUT_BIND_CANCEL, GLFW_KEY_BACKSPACE);
+
+
+  // Event callbacks
+  glfwSetFramebufferSizeCallback(DAWN_GLFW.window, &dawnGlfwOnResize);
+  
+  // Main Loop
+  double_t time, newTime;
+  float_t fDelta;
+  uint8_t updateResult;
+
+  // Main Render Loop 
+  time = 0.0f;
+  while(!glfwWindowShouldClose(DAWN_GLFW.window)) {
+    // Determine the delta.
+    newTime = glfwGetTime();
+    fDelta = (float_t)(newTime - time);
+    time = newTime;
+    
+    // Perform updates
+    updateResult = gameUpdate(fDelta);
+    
+    // Update GLFW
+    glfwSwapBuffers(DAWN_GLFW.window);
+    glfwPollEvents();
+
+    if(updateResult == GAME_UPDATE_RESULT_EXIT) break;
+    if(updateResult != GAME_UPDATE_RESULT_CONTINUE) break;
+  }
+
+  // Terminate GLFW
+  glfwDestroyWindow(DAWN_GLFW.window);
+  glfwTerminate();
+
+  // Reset the state incase of re-start.
+  DAWN_GLFW.window = NULL;
+  DAWN_GLFW.width = 0;
+  DAWN_GLFW.height = 0;
+
+  return updateResult;
+}
+
+void dawnGlfwInputBind(inputbind_t bind, int32_t key) {
+  assertTrue(bind < INPUT_BIND_COUNT, "Invalid input bind");
+  assertTrue(
+    DAWN_GLFW.inputBinds[bind].keyCount < DAWN_GLFW_BIND_KEYS_MAX,
+    "Too many keys bound to input"
+  );
+  DAWN_GLFW.inputBinds[bind].keys[DAWN_GLFW.inputBinds[bind].keyCount++] = key;
+}
+
+void dawnGlfwOnResize(GLFWwindow *window, int32_t w, int32_t h) {
+  assertTrue(window == DAWN_GLFW.window, "glfwOnResize: Window mismatch");
+  int32_t windowWidth, windowHeight;
+  glfwGetWindowSize(window, &windowWidth, &windowHeight);
+  // TODO: I may throttle this, it calls for every frame the window's resized.
+  backBufferSetSize(w, h, ((float_t)w) / ((float_t)windowWidth));
+}

src/dawnglfw/dawnglfw.h

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawnopengl.h"
+#include "input.h"
+#include <GLFW/glfw3.h>
+
+#define DAWN_GLFW_WIDTH_DEFAULT 640
+#define DAWN_GLFW_HEIGHT_DEFAULT 480
+#define DAWN_GLFW_BIND_KEYS_MAX 8
+
+typedef struct {
+  int32_t keys[DAWN_GLFW_BIND_KEYS_MAX];
+  int32_t keyCount;
+} dawnglfwbind_t;
+
+typedef struct {
+  GLFWwindow *window;
+  int32_t width;
+  int32_t height;
+  dawnglfwbind_t inputBinds[INPUT_BIND_COUNT];
+} dawnglfw_t;
+
+extern dawnglfw_t DAWN_GLFW;
+
+/**
+ * Initialies GLFW.
+ */
+int32_t dawnGlfwStart();
+
+/**
+ * Binds a key to an input.
+ * 
+ * @param bind Bind to bind to.
+ * @param key Key to bind.
+ */
+void dawnGlfwInputBind(inputbind_t bind, int32_t key);
+
+/**
+ * Event listener for when the window is resized.
+ * 
+ * @param window The window that was resized.
+ * @param w The new width of the window.
+ * @param h The new height of the window.
+ */
+void dawnGlfwOnResize(GLFWwindow *window, int32_t w, int32_t h);

src/dawnglfw/input.c

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "input.h"
+#include "dawnglfw.h"
+#include "assert/assert.h"
+
+inputstate_t inputGetState(const inputbind_t bind) {
+  assertTrue(bind < INPUT_BIND_COUNT, "Invalid input bind index.");
+
+  dawnglfwbind_t *binds = &DAWN_GLFW.inputBinds[bind];
+  for(int32_t i = 0; i < binds->keyCount; i++) {
+    if(glfwGetKey(DAWN_GLFW.window, binds->keys[i]) == GLFW_PRESS) return true;
+  }
+  return false;
+}

src/dawnglfw/linuxhost.c

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "linuxhost.h"
+#include "dawnglfw.h"
+
+int32_t linuxHostBeginUpdating() {
+  return dawnGlfwStart();
+}

src/dawnglfw/linuxhost.h

@@ -6,12 +6,9 @@
  */
 
 #pragma once
-#include "dusk.h"
+#include "dawn.h"
 
-typedef struct {
-
-} cutsceneevent_t;
-
-typedef struct {
-  
-} cutscene_t;
+/**
+ * Linux Host Compatibility
+ */
+int32_t linuxHostBeginUpdating();

src/dawnlinux/main.c

@@ -13,6 +13,5 @@
 
 int32_t main() {
   gameInit();
-
   return linuxHostBeginUpdating();
 }

src/dawnopengl/CMakeLists.txt

@@ -0,0 +1,26 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Libraries
+target_link_libraries(${DAWN_TARGET_NAME}
+  PUBLIC
+    font8x8
+    glad
+)
+
+# Includes
+target_include_directories(${DAWN_TARGET_NAME}
+  PUBLIC
+    ${CMAKE_CURRENT_LIST_DIR}
+)
+
+# Subdirs
+add_subdirectory(assert)
+add_subdirectory(display)
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+)

src/dawnopengl/assert/CMakeLists.txt

@@ -0,0 +1,10 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https:#opensource.org/licenses/MIT
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    assertgl.c
+)

src/dawnopengl/assert/assertgl.c

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) 2023 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "dawnopengl.h"
+#include "assert/assert.h"
+#include "assertgl.h"
+
+void assertNotGLErrorCheck(const char_t *file, const int32_t line) {
+  assertNotNull(file, "assertNotGLErrorCheck: File is an invlaid string");
+  assertTrue(line > 0, "assertNotGLErrorCheck: line is invalid");
+
+  char_t *buffer;
+  GLenum errorCode;
+  int32_t errorCount = 0;
+
+  while((errorCode = glGetError()) != GL_NO_ERROR) {
+    if(errorCount == 0) {
+      buffer = malloc(sizeof(char_t) * 4096);
+      sprintf(buffer, "assertNotGLErrorCheck: %s:%d\n", file, line);
+    }
+
+    errorCount++;
+    
+    switch (errorCode) {
+      case GL_INVALID_ENUM:
+        sprintf(buffer, "%s\nINVALID_ENUM", buffer);
+        break;
+
+      case GL_INVALID_VALUE:
+        sprintf(buffer, "%s\nINVALID_ENUM", buffer);
+        break;
+      
+      case GL_INVALID_OPERATION:
+        sprintf(buffer, "%s\nINVALID_OPERATION", buffer);
+        break;
+
+      // case GL_INVALID_FRAMEBUFFER_OPERATION:
+      //   sprintf(buffer, "%s\nINVALID_FRAMEBUFFER_OPERATION", buffer);
+      //   break;
+      
+      case GL_OUT_OF_MEMORY:
+        sprintf(buffer, "%s\nOUT_OF_MEMORY", buffer);
+        break;
+      
+      case GL_STACK_UNDERFLOW:
+        sprintf(buffer, "%s\nSTACK_UNDERFLOW", buffer);
+        break;
+      
+      case GL_STACK_OVERFLOW:
+        sprintf(buffer, "%s\nSTACK_OVERFLOW", buffer);
+        break;
+
+      default:
+        sprintf(buffer, "%s\nUNKNOWN_ERROR", buffer);
+        break;
+    }
+
+    sprintf(buffer, "%s (%i)\n", buffer, errorCode);
+  }
+
+  if(errorCount > 0) {
+    assertUnreachable(buffer);
+    free(buffer);
+  }
+}

src/dawnopengl/assert/assertgl.h

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2023 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+
+/**
+ * Asserts that there are no OpenGL errors.
+ * 
+ * @param file The file the assertion is being made in.
+ * @param line The line the assertion is being made in.
+ */
+void assertNotGLErrorCheck(const char_t *file, const int32_t line);
+
+/**
+ * Asserts that there are no OpenGL errors.
+ */
+#define assertNoGLError() assertNotGLErrorCheck(__FILE__, __LINE__) 

src/dawnopengl/dawnopengl.h

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "dawn.h"
+#include <glad/glad.h>

src/dawnopengl/display/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Dominic Masters
+# 
+# This software is released under the MIT License.
+# https://opensource.org/licenses/MIT
+
+# Subdirs
+
+# Sources
+target_sources(${DAWN_TARGET_NAME}
+  PRIVATE
+    display.c
+    backbuffer.c
+)

src/dawnopengl/display/backbuffer.c

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "backbuffer.h"
+#include "assert/assert.h"
+#include "assert/assertgl.h"
+#include "dawnopengl.h"
+
+int32_t BACK_BUFFER_WIDTH;
+int32_t BACK_BUFFER_HEIGHT;
+float_t BACK_BUFFER_SCALE;
+
+void backBufferSetSize(
+  const int32_t width,
+  const int32_t height,
+  const float_t scale
+) {
+  assertTrue(width >= 0, "backBufferSetSize: Width must be >= 0");
+  assertTrue(height >= 0, "backBufferSetSize: Height must be >= 0");
+  assertTrue(scale > 0, "backBufferSetSize: Scale must be > 0");
+
+  BACK_BUFFER_WIDTH = width;
+  BACK_BUFFER_HEIGHT = height;
+  BACK_BUFFER_SCALE = scale;
+}
+
+void backBufferBind() {
+  glBindFramebuffer(GL_FRAMEBUFFER, 0);
+  assertNoGLError();
+  glViewport(0, 0, BACK_BUFFER_WIDTH, BACK_BUFFER_HEIGHT);
+  assertNoGLError();
+}
+
+void backBufferClear() {
+  glClearColor(0,0,0,1);
+  assertNoGLError();
+  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+  assertNoGLError();
+}

src/dawnopengl/display/backbuffer.h

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#pragma once
+#include "display/color.h"
+
+extern int32_t BACK_BUFFER_WIDTH;
+extern int32_t BACK_BUFFER_HEIGHT;
+extern float_t BACK_BUFFER_SCALE;
+
+/**
+ * Called by the host whenever the backbuffer size changes. Also includes a 
+ * scale parameter to deal with highdpi screens.
+ * 
+ * @param width Width in pixels.
+ * @param height Height in pixels.
+ * @param scale Scale/Pixel density.
+ */
+void backBufferSetSize(
+  const int32_t width,
+  const int32_t height,
+  const float_t scale
+);
+
+/**
+ * Binds the backbuffer to the current framebuffer.
+ */
+void backBufferBind();
+
+/**
+ * Clears the backbuffer.
+ * 
+ * @param clearFlags Specifies rules on how to clear.
+ * @param color Color to use when clearing (assuming you are clearing colors).
+ */
+void backBufferClear();

src/dawnopengl/display/display.c

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) 2024 Dominic Masters
+ * 
+ * This software is released under the MIT License.
+ * https://opensource.org/licenses/MIT
+ */
+
+#include "display/display.h"
+#include "assert/assert.h"
+
+void displayInit() {
+}
+
+void displayUpdate() {
+}
+
+void displayDispose() {
+}

src/dawnterm/display/frame.h

@@ -8,8 +8,9 @@
 #pragma once
 #include "display/color.h"
 
-#define FRAME_WIDTH 30
-#define FRAME_HEIGHT 12
+#define FRAME_WIDTH 320/8
+#define FRAME_HEIGHT 240/8
+
 
 extern char_t FRAME_BUFFER[FRAME_HEIGHT * FRAME_WIDTH];
 extern uint8_t FRAME_COLOR[FRAME_HEIGHT * FRAME_WIDTH];

src/dawntermlinux/CMakeLists.txt

@@ -6,7 +6,6 @@
 # Libraries
 target_link_libraries(${DAWN_TARGET_NAME}
   PUBLIC
-    m
 )
 
 # Includes