Implement runtime display (test) (#318)

* Implement runtime display (test)

* Update runtime.cpp

* [game display] add "-nodisplay" argument

* style fixes

* Update gfx.cpp

* [deci2server] fix deadlock when killing a Deci2Server

* add libxrandr to linux github test

* correct package name to libxrandr-dev

* set g_main_thread_id in exec_runtime

* add libxinerama to linux test packages

* correct the name

* add libxcursor1 package

* Update linux-workflow.yaml

* add libxi-dev

* fix constructor for g_main_thread_id

* fix submodules + use -nodisplay during tests

* move the gfx loop to its own function and use a lambda for exit conditions

* fix include

* fix include

* fix includes (for real this time)

.github/workflows/linux-workflow.yaml

@@ -46,6 +46,7 @@ jobs:
           path: |
             ./third-party/googletest
             ./third-party/zydis
+            ./third-party/glfw
             ./.git/modules/
 
       - name: Checkout Submodules
@@ -69,7 +70,7 @@ jobs:
           echo "##[set-output name=artifact-metadata;]${ARTIFACT_NAME}"
 
       - name: Get Package Dependencies
-        run: sudo apt install build-essential cmake ccache clang gcc g++ lcov make nasm
+        run: sudo apt install build-essential cmake ccache clang gcc g++ lcov make nasm libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev
 
       # # -- SETUP CCACHE - https://cristianadam.eu/20200113/speeding-up-c-plus-plus-github-actions-using-ccache/
       # - name: Prepare ccache timestamp

.github/workflows/windows-workflow.yaml

@@ -45,6 +45,7 @@ jobs:
           path: |
             ./third-party/googletest
             ./third-party/zydis
+            ./third-party/glfw
             ./.git/modules/
 
       - name: Checkout Submodules

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "third-party/zydis"]
 	path = third-party/zydis
 	url = https://github.com/zyantific/zydis.git
+[submodule "third-party/glfw"]
+	path = third-party/glfw
+	url = https://github.com/glfw/glfw

.vs/launch.vs.json

@@ -35,6 +35,13 @@
       "name" : "Run Runtime (with kernel)",
       "args" : [ "-fakeiso", "-debug" ]
     },
+    {
+      "type" : "default",
+      "project" : "CMakeLists.txt",
+      "projectTarget" : "gk.exe (bin\\gk.exe)",
+      "name" : "Run Runtime (no kernel) (verbose)",
+      "args" : [ "-fakeiso", "-debug", "-nokernel", "-v" ]
+    },
     {
       "type" : "default",
       "project" : "CMakeLists.txt",

CMakeLists.txt

@@ -72,7 +72,12 @@ add_subdirectory(common)
 # build decompiler
 add_subdirectory(decompiler)
 
+# build glfw library
+add_subdirectory(third-party/glfw)
+
 # build the game code in C++
+include_directories(third-party/glad/include)
+include_directories(third-party/glfw/include)
 add_subdirectory(game)
 
 # build the compiler

game/CMakeLists.txt

@@ -21,7 +21,7 @@ if(UNIX)
         -Wshadow \
         -Wsign-promo")
 else()
-		set(CMAKE_CXX_FLAGS "/EHsc")
+        set(CMAKE_CXX_FLAGS "/EHsc")
 endif(UNIX)
 
 enable_language(ASM_NASM)
@@ -70,13 +70,15 @@ set(RUNTIME_SOURCE
         overlord/soundcommon.cpp
         overlord/srpc.cpp
         overlord/ssound.cpp
-        overlord/stream.cpp)
+        overlord/stream.cpp
+        graphics/gfx.cpp
+        graphics/display.cpp)
 
 
 # we build the runtime as a static library.
-add_library(runtime ${RUNTIME_SOURCE})
+add_library(runtime ${RUNTIME_SOURCE} "../third-party/glad/src/glad.c")
 
-target_link_libraries(runtime common fmt)
+target_link_libraries(runtime common fmt glfw)
 if(WIN32)
     target_link_libraries(runtime mman)
 else()

game/graphics/display.cpp

@@ -0,0 +1,54 @@
+/*!
+ * @file display.cpp
+ * Display for graphics. This is the game window, distinct from the runtime console.
+ */
+
+#include "display.h"
+
+#include "common/log/log.h"
+
+namespace Display {
+
+GLFWwindow* display = NULL;
+
+void InitDisplay(int width, int height, char* title, GLFWwindow*& d) {
+  if (d) {
+    lg::warn("InitDisplay has already created a display window");
+    return;
+  }
+
+  // request OpenGL 3.0 (placeholder)
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
+  glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+  d = glfwCreateWindow(width, height, title, NULL, NULL);
+
+  if (!d) {
+    lg::error("InitDisplay failed - Could not create display window");
+    return;
+  }
+
+  glfwMakeContextCurrent(d);
+  if (!gladLoadGL()) {
+    lg::error("GL init fail");
+    KillDisplay(d);
+    return;
+  }
+
+  // enable vsync by default
+  glfwSwapInterval(1);
+
+  lg::debug("init display #x{}", (uintptr_t)d);
+}
+
+void KillDisplay(GLFWwindow*& d) {
+  lg::debug("kill display #x{}", (uintptr_t)d);
+  if (!d) {
+    lg::warn("KillDisplay called when no display was available");
+    return;
+  }
+
+  glfwDestroyWindow(d);
+  d = NULL;
+}
+
+}  // namespace Display

game/graphics/display.h

@@ -0,0 +1,25 @@
+#pragma once
+
+/*!
+ * @file display.h
+ * Display for graphics. This is the game window, distinct from the runtime console.
+ */
+
+#ifndef RUNTIME_DISPLAY_H
+#define RUNTIME_DISPLAY_H
+
+#include "opengl.h"
+
+namespace Display {
+
+// TODO - eventually we might actually want to support having multiple windows and viewpoints
+// so it would be nice if we didn't end up designing this system such that this MUST be
+// a single window.
+extern GLFWwindow* display;
+
+void InitDisplay(int width, int height, char* title, GLFWwindow*& d);
+void KillDisplay(GLFWwindow*& d);
+
+}  // namespace Display
+
+#endif  // RUNTIME_DISPLAY_H

game/graphics/gfx.cpp

@@ -0,0 +1,46 @@
+/*!
+ * @file gfx.cpp
+ * Graphics component for the runtime. Handles some low-level routines.
+ */
+
+#include "gfx.h"
+#include "common/log/log.h"
+#include "game/runtime.h"
+#include "display.h"
+
+#include "opengl.h"
+
+namespace Gfx {
+
+void GlfwErrorCallback(int err, const char* msg) {
+  lg::error("GLFW ERR {}: " + std::string(msg), err);
+}
+
+u32 Init() {
+  if (glfwSetErrorCallback(GlfwErrorCallback) != NULL) {
+    lg::warn("glfwSetErrorCallback has been re-set!");
+  }
+
+  if (!glfwInit()) {
+    lg::error("glfwInit error");
+    return 1;
+  }
+
+  if (g_main_thread_id != std::this_thread::get_id()) {
+    lg::warn("ran Gfx::Init outside main thread. Init display elsewhere?");
+  } else {
+    Display::InitDisplay(640, 480, "testy", Display::display);
+  }
+
+  return 0;
+}
+
+u32 Exit() {
+  lg::debug("gfx exit");
+  Display::KillDisplay(Display::display);
+  glfwTerminate();
+  glfwSetErrorCallback(NULL);
+  return 0;
+}
+
+}  // namespace Gfx

game/graphics/gfx.h

@@ -0,0 +1,47 @@
+#pragma once
+
+/*!
+ * @file gfx.h
+ * Graphics component for the runtime. Handles some low-level routines.
+ */
+
+#ifndef RUNTIME_GFX_H
+#define RUNTIME_GFX_H
+
+#include "common/common_types.h"
+#include "display.h"
+#include "game/kernel/kboot.h"
+
+namespace Gfx {
+
+u32 Init();
+u32 Exit();
+
+template <typename T>
+void Loop(T f) {
+  while (f()) {
+    // run display-specific things
+    if (Display::display) {
+      // lg::debug("run display");
+      glfwMakeContextCurrent(Display::display);
+
+      // render graphics
+      glClear(GL_COLOR_BUFFER_BIT);
+
+      glfwSwapBuffers(Display::display);
+
+      // poll events TODO integrate input with cpad
+      glfwPollEvents();
+
+      // exit if display window was closed
+      if (glfwWindowShouldClose(Display::display)) {
+        // Display::KillDisplay(Display::display);
+        MasterExit = 1;
+      }
+    }
+  }
+}
+
+}  // namespace Gfx
+
+#endif  // RUNTIME_GFX_H

game/graphics/opengl.h

@@ -0,0 +1,15 @@
+#pragma once
+
+/*!
+ * @file opengl.h
+ * OpenGL includes.
+ */
+
+#ifndef RUNTIME_OPENGL_H
+#define RUNTIME_OPENGL_H
+
+#define GLFW_INCLUDE_NONE
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#endif  // RUNTIME_OPENGL_H

game/kernel/kmachine.cpp

@@ -121,7 +121,7 @@ void InitParms(int argc, const char* const* argv) {
       DebugSegment = 0;
     }
 
-    // the "debug" mode is used to set GOAL up for debugging/developemtn
+    // the "debug" mode is used to set GOAL up for debugging/development
     if (arg == "-debug") {
       Msg(6, "dkernel: debug mode\n");
       MasterDebug = 1;

game/runtime.cpp

@@ -47,10 +47,15 @@
 #include "game/overlord/srpc.h"
 #include "game/overlord/stream.h"
 
+#include "game/graphics/opengl.h"
+#include "game/graphics/gfx.h"
+#include "game/graphics/display.h"
+
 #include "common/goal_constants.h"
 #include "common/cross_os_debug/xdbg.h"
 
 u8* g_ee_main_mem = nullptr;
+std::thread::id g_main_thread_id = std::thread::id();
 
 namespace {
 
@@ -81,8 +86,6 @@ void deci2_runner(SystemThreadInterface& iface) {
   }
 
   lg::debug("[DECI2] Waiting for listener...");
-  // lg::debug("[DECI2] Waiting for listener..."); --> disabled temporarily, some weird race
-  // condition?
   bool saw_listener = false;
   while (!iface.get_want_exit()) {
     if (server.check_for_listener()) {
@@ -233,6 +236,15 @@ void iop_runner(SystemThreadInterface& iface) {
 u32 exec_runtime(int argc, char** argv) {
   g_argc = argc;
   g_argv = argv;
+  g_main_thread_id = std::this_thread::get_id();
+
+  bool enable_display = true;
+  for (int i = 1; i < argc; i++) {
+    if (std::string("-nodisplay") == argv[i]) {
+      enable_display = false;
+      break;
+    }
+  }
 
   // step 1: sce library prep
   iop::LIBRARY_INIT();
@@ -251,7 +263,15 @@ u32 exec_runtime(int argc, char** argv) {
   ee_thread.start(ee_runner);
   deci_thread.start(deci2_runner);
 
-  // step 4: wait for EE to signal a shutdown, which will cause the DECI thread to join.
+  // step 4: wait for EE to signal a shutdown. meanwhile, run video loop on main thread.
+  // TODO relegate this to its own function
+  // TODO also sync this up with how the game actually renders things (this is just a placeholder)
+  if (enable_display) {
+    Gfx::Init();
+    Gfx::Loop([&tm] { return !tm.all_threads_exiting(); });
+    Gfx::Exit();
+  }
+
   deci_thread.join();
   // DECI has been killed, shutdown!
 

game/runtime.h

@@ -9,8 +9,11 @@
 #define JAK1_RUNTIME_H
 
 #include "common/common_types.h"
+#include <thread>
 
 extern u8* g_ee_main_mem;
 u32 exec_runtime(int argc, char** argv);
 
+extern std::thread::id g_main_thread_id;
+
 #endif  // JAK1_RUNTIME_H

game/system/Deci2Server.cpp

@@ -31,6 +31,9 @@ Deci2Server::Deci2Server(std::function<bool()> shutdown_callback) {
 }
 
 Deci2Server::~Deci2Server() {
+  close_server_socket();
+  close_socket(new_sock);
+
   // if accept thread is running, kill it
   if (accept_thread_running) {
     kill_accept_thread = true;
@@ -39,9 +42,6 @@ Deci2Server::~Deci2Server() {
   }
 
   delete[] buffer;
-
-  close_server_socket();
-  close_socket(new_sock);
 }
 
 /*!

game/system/SystemThread.cpp

@@ -68,6 +68,17 @@ void SystemThreadManager::join() {
   }
 }
 
+/*!
+ * Return true if all threads are exiting (manager shutdown)
+ */
+bool SystemThreadManager::all_threads_exiting() {
+  for (int i = 0; i < thread_count; i++) {
+    if (!threads[i].want_exit)
+      return false;
+  }
+  return true;
+}
+
 /*!
  * bootstrap function to call a SystemThread's function
  */

game/system/SystemThread.h

@@ -77,6 +77,7 @@ class SystemThreadManager {
   void print_stats();
   void shutdown();
   void join();
+  bool all_threads_exiting();
 
  private:
   std::array<SystemThread, MAX_SYSTEM_THREADS> threads;

test/goalc/framework/test_runner.cpp

@@ -99,20 +99,20 @@ void CompilerTestRunner::run_always_pass(const std::string& test_category,
 }
 
 void runtime_no_kernel() {
-  constexpr int argc = 4;
-  const char* argv[argc] = {"", "-fakeiso", "-debug", "-nokernel"};
+  constexpr int argc = 5;
+  const char* argv[argc] = {"", "-fakeiso", "-debug", "-nokernel", "-nodisplay"};
   exec_runtime(argc, const_cast<char**>(argv));
 }
 
 void runtime_with_kernel() {
-  constexpr int argc = 3;
-  const char* argv[argc] = {"", "-fakeiso", "-debug"};
+  constexpr int argc = 4;
+  const char* argv[argc] = {"", "-fakeiso", "-debug", "-nodisplay"};
   exec_runtime(argc, const_cast<char**>(argv));
 }
 
 void runtime_with_kernel_no_debug_segment() {
-  constexpr int argc = 3;
-  const char* argv[argc] = {"", "-fakeiso", "-debug-mem"};
+  constexpr int argc = 4;
+  const char* argv[argc] = {"", "-fakeiso", "-debug-mem", "-nodisplay"};
   exec_runtime(argc, const_cast<char**>(argv));
 }
 

third-party/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_ */

third-party/glfw

@@ -0,0 +1 @@
+Subproject commit 4afa227a056681d2628894b0893527bf69496a41