Merge branch 'r/meson_refactor'

meson.build

@@ -46,8 +46,6 @@ if buildtype == 'debug' or buildtype == 'debugoptimized'
 endif
 
 # Gather dependencies
-common_incdirs = [include_directories(['contrib', 'src'])]
-
 thread_dep = dependency('threads')
 m_dep = compiler.find_library('m', required : false)
 vk_dep = dependency('vulkan', required : false)
@@ -61,172 +59,35 @@ endif
 # Copy file utility
 copy_util = find_program('scripts/copy_util.py')
 
-runtime_incdirs = common_incdirs
-runtime_linkargs = []
-runtime_additional_sources = []
-runtime_cargs = []
-runtime_deps = [thread_dep, m_dep, windowing_dep]
+engine_incdir = include_directories('src')
 
-if get_option('build_asset_compiler')
-  runtime_cargs += ['-DRT_BUILD_ASSET_COMPILER']
-
-  # DXC for vulkan & directx shaders
-  if get_option('enable_dxc_shader_compiler')
-    # We package dxc binaries under contrib/dxc
-    dxc_include = include_directories('contrib' / 'dxc' / 'inc')
-    dxc_libdir = 'NONE'
-    if host_machine.system() == 'windows'
-        dxc_libdir = meson.project_source_root() / 'contrib' / 'dxc' / 'lib' / 'x64'
-        custom_target('copy dxcompiler.dll',
-            input : 'contrib' / 'dxc' / 'bin' / 'x64' / 'dxcompiler.dll',
-            output : 'dxcompiler.dll',
-            command : [copy_util, '@INPUT@', '@OUTPUT@'],
-            install : false,
-            build_by_default : true)
-    endif
-    dxc_dep = declare_dependency(link_args : ['-L'+dxc_libdir, '-ldxcompiler'], include_directories : dxc_include)
-    runtime_deps += dxc_dep
-    runtime_additional_sources += [
-        'src/runtime/dxc_shader_compiler.cpp'
-    ]
-    runtime_cargs += ['-DRT_BUILD_DXC_SHADER_COMPILER']
-  endif
-
-  # Asset compiler sources
-  runtime_additional_sources += [
-    'src/runtime/asset_compiler.h',
-    'src/runtime/description_parser.h',
-    'src/runtime/shader_compiler.h',
-
-    'src/runtime/asset_compiler.c',
-    'src/runtime/description_parser.c',
-    'src/runtime/framegraph_processor.c',
-    'src/runtime/pipeline_processor.c',
-    'src/runtime/shader_compiler.c',
-  ]
-endif
-
-runtime_lib = library('rt',
-  # Project Sources
-  'src/runtime/aio.h',
-  'src/runtime/app.h',
-  'src/runtime/buffer_manager.h',
-  'src/runtime/compression.h',
-  'src/runtime/config.h',
-  'src/runtime/ds.h',
-  'src/runtime/dynamic_libs.h',
-  'src/runtime/file_tab.h',
-  'src/runtime/fsutils.h',
-  'src/runtime/gfx.h',
-  'src/runtime/handles.h',
-  'src/runtime/hashing.h',
-  'src/runtime/jobs.h',
-  'src/runtime/mem_arena.h',
-  'src/runtime/renderer_api.h',
-  'src/runtime/resources.h',
-  'src/runtime/runtime.h',
-  'src/runtime/threading.h',
-  
-  'src/runtime/aio.c',
-  'src/runtime/app.c',
-  'src/runtime/assert.c',
-  'src/runtime/buffer_manager.c',
-  'src/runtime/compression.c',
-  'src/runtime/config.c',
-  'src/runtime/ds_minheap.c',
-  'src/runtime/dynamic_libs.c',
-  'src/runtime/error_report.c',
-  'src/runtime/file_tab.c',
-  'src/runtime/fsutils.c',
-  'src/runtime/gfx_framegraph.c',
-  'src/runtime/gfx_main.c',
-  'src/runtime/hashing.c',
-  'src/runtime/init.c',
-  'src/runtime/jobs.c',
-  'src/runtime/mem_arena.c',
-  'src/runtime/resource_manager.c',
-  'src/runtime/sprint.c',
-  'src/runtime/text.c',
-  'src/runtime/threading_cond.c',
-  'src/runtime/threading_mutex.c',
-  'src/runtime/threading_rwlock.c',
-  'src/runtime/threading_thread.c',
-
-  # Contrib Sources
-  'contrib/xxhash/xxhash.c',
-  'contrib/lz4/lz4.c',
-  sources : runtime_additional_sources,
-  dependencies : runtime_deps,
-  include_directories : runtime_incdirs,
-  link_args : runtime_linkargs,
-  c_args : runtime_cargs,
-  c_pch : 'pch/rt_pch.h',
-  cpp_args : runtime_cargs,
-  cpp_pch : 'pch/rt_pch.h')
-
-
-# Renderer libraries
-static_renderer_lib = 'NONE'
-
-if vk_dep.found()
-  platform_defs = []
-  if get_option('use_xlib')
-    platform_defs = ['-DVK_USE_PLATFORM_XLIB_KHR']
-  elif host_machine.system() == 'windows'
-    platform_defs = ['-DVK_USE_PLATFORM_WIN32_KHR']
-  endif
-
-  vk_inc_dep = vk_dep.partial_dependency(compile_args : true, includes : true)
-  vk_renderer_lib = library('rtvk',
-    # Project Sources
-    'src/renderer/vk/gpu.h',
-    'src/renderer/vk/pipelines.h',
-    'src/renderer/vk/render_targets.h',
-    'src/renderer/vk/swapchain.h',
-
-    'src/renderer/vk/helper.c',
-    'src/renderer/vk/init.c',
-    'src/renderer/vk/pipelines.c',
-    'src/renderer/vk/render_targets.c',
-    'src/renderer/vk/swapchain.c',
-
-    # Contrib Sources
-    'contrib/volk/volk.h',
-    'contrib/volk/volk.c',
-    'contrib/vma/vk_mem_alloc.h',
-    'src/renderer/vk/vma_impl.cpp',
-    dependencies : [m_dep, vk_inc_dep, windowing_dep],
-    include_directories : common_incdirs,
-    link_with : [runtime_lib],
-    c_pch : 'pch/vk_pch.h',
-    c_args : platform_defs,
-    cpp_pch : 'pch/vk_pch.h',
-    cpp_args : platform_defs)
-
-  static_renderer_lib = vk_renderer_lib
-endif
+contrib_dir = meson.project_source_root() / 'contrib'
 
+subdir('src')
 
 # Handle linking against both runtime and renderer if we build static libs
 engine_link_libs = []
 if get_option('default_library') == 'static'
-  engine_link_libs = [runtime_lib, static_renderer_lib]
+  if get_option('static_renderer') == 'vk'
+    engine_link_libs = [runtime_lib, vk_renderer_lib]
+  else
+    error('Invalid static_renderer option ', get_option('static_renderer'))
+  endif
 else
   engine_link_libs = [runtime_lib]
 endif
 
-# Game
-executable('voyage',
-  'src/game/entry.c',
-  'src/game/main.c',
-  include_directories : common_incdirs,
-  link_with : engine_link_libs,
-  win_subsystem : 'windows')
+# Unit/Integration test driver
+subdir('tests')
 
-# Unit Tests
-rttest_exe = executable('rttest',
-  'src/tests/rttest.c',
-  link_with : engine_link_libs,
-  include_directories : common_incdirs,
-  win_subsystem : 'console')
-test('runtime test', rttest_exe)
+# Declare dependencies, to enable using the engine as a subproject
+engine_dep = declare_dependency(link_with : engine_link_libs,
+  include_directories : engine_incdir)
+
+assetc_dep = declare_dependency(link_with : asset_compiler,
+  include_directories : engine_incdir)
+
+# "inline" game
+if get_option('game_as_subdir')
+  subdir('src/game')
+endif

meson_options.txt

@@ -1,4 +1,5 @@
+option('static_renderer', type : 'string', value : 'vk', description : 'Name of the renderer used for static builds')
 option('use_xlib', type : 'boolean', value : false, description : 'Use Xlib for window creation under linux')
 option('error_report_debugbreak', type : 'boolean', value : true, description : 'Debugbreak in ReportError')
-option('build_asset_compiler', type : 'boolean', value : true, description : 'Enables or disables the asset compiler inside runtime.')
 option('enable_dxc_shader_compiler', type : 'boolean', value : true, description : 'Enables building the dxc-based shader compiler.')
+option('game_as_subdir', type : 'boolean', value : false, description : 'If true, adds the directory "src/game" to the build.')

src/asset_compiler/asset_compiler.c

@@ -1,22 +1,21 @@
 #include "asset_compiler.h"
-#include "buffer_manager.h"
-#include "config.h"
-#include "file_tab.h"
-#include "fsutils.h"
-#include "mem_arena.h"
-#include "resources.h"
-#include "runtime.h"
-#include "threading.h"
+#include "processor.h"
+
+#include "runtime/aio.h"
+#include "runtime/buffer_manager.h"
+#include "runtime/config.h"
+#include "runtime/file_tab.h"
+#include "runtime/fsutils.h"
+#include "runtime/mem_arena.h"
+#include "runtime/resources.h"
+#include "runtime/runtime.h"
+#include "runtime/threading.h"
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
-#ifndef RT_BUILD_ASSET_COMPILER
-#error This should only be built when RT_BUILD_ASSET_COMPILER is defined.
-#endif
-
 typedef struct {
     uint64_t last_processed;
     rt_resource_id resources[RT_MAX_RESOURCES_PER_ASSET];
@@ -75,7 +74,15 @@ static rt_asset_processor _processors[] = {
 static void ProcessorThreadEntry(void *);
 static void CompilerThreadEntry(void *);
 
-rt_result InitAssetCompiler(void) {
+
+RT_DLLEXPORT void rtRegisterAssetCompilerCVars(void) {
+    rtRegisterCVAR(&rt_AssetDirectory);
+    rtRegisterCVAR(&rt_AssetDBSize);
+    rtRegisterCVAR(&rt_AssetProcessingThreads);
+    rtRegisterCVAR(&rt_AssetProcessorArenaSize);
+}
+
+RT_DLLEXPORT rt_result rtInitAssetCompiler(void) {
 
     unsigned int db_size = (unsigned int)rt_AssetDBSize.i;
     void *mem            = malloc((sizeof(rt_file_id) + sizeof(rt_asset_data)) * db_size);
@@ -125,7 +132,7 @@ rt_result InitAssetCompiler(void) {
     return RT_SUCCESS;
 }
 
-void ShutdownAssetCompiler(void) {
+RT_DLLEXPORT void rtShutdownAssetCompiler(void) {
     _keep_running = false;
     rtJoinThread(_compiler_thread);
     for (int i = 0; i < rt_AssetProcessingThreads.i; ++i)
@@ -384,8 +391,6 @@ static void ProcessorThreadEntry(void *param) {
 
 /* Utilities for asset processors*/
 
-#include "aio.h"
-
 rt_loaded_asset LoadAsset(rt_file_id file) {
     const char *path = rtGetFilePath(file);
     size_t file_size = rtGetFileSize(path);

src/asset_compiler/asset_compiler.h

@@ -0,0 +1,22 @@
+#ifndef RT_ASSET_PROCESSOR_H
+#define RT_ASSET_PROCESSOR_H
+
+/* Public header for the asset processor */
+
+#include "runtime/runtime.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+RT_DLLEXPORT void rtRegisterAssetCompilerCVars(void);
+
+RT_DLLEXPORT rt_result rtInitAssetCompiler(void);
+
+RT_DLLEXPORT void rtShutdownAssetCompiler(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/asset_compiler/description_parser.c

@@ -1,6 +1,7 @@
 #include "description_parser.h"
-#include "runtime.h"
-#include "mem_arena.h"
+
+#include "runtime/runtime.h"
+#include "runtime/mem_arena.h"
 
 #include <stdbool.h>
 #include <limits.h>

src/asset_compiler/dxc_shader_compiler.cpp

@@ -4,7 +4,7 @@
 #endif
 #include <dxcapi.h>
 
-#include "asset_compiler.h"
+#include "processor.h"
 #include "shader_compiler.h"
 
 extern "C" rt_shader_bytecode CompileVulkanShader(rt_shader_stage stage,

src/asset_compiler/framegraph_processor.c

@@ -1,7 +1,8 @@
-#include "asset_compiler.h"
-#include "buffer_manager.h"
+#include "processor.h"
 #include "description_parser.h"
-#include "gfx.h"
+
+#include "runtime/buffer_manager.h"
+#include "runtime/gfx.h"
 
 #include <stdio.h>
 #include <string.h>

src/asset_compiler/meson.build

@@ -0,0 +1,44 @@
+# Asset Compiler 
+ac_deps = []
+ac_sources = []
+ac_cargs = []
+
+# DXC for vulkan & directx shaders
+if get_option('enable_dxc_shader_compiler')
+  # We package dxc binaries under contrib/dxc
+  dxc_include = include_directories(meson.project_source_root() / 'contrib' / 'dxc' / 'inc')
+  dxc_libdir = 'NONE'
+  if host_machine.system() == 'windows'
+    dxc_libdir = meson.project_source_root() / 'contrib' / 'dxc' / 'lib' / 'x64'
+    custom_target('copy dxcompiler.dll',
+      input : meson.project_source_root() / 'contrib' / 'dxc' / 'bin' / 'x64' / 'dxcompiler.dll',
+      output : 'dxcompiler.dll',
+      command : [copy_util, '@INPUT@', '@OUTPUT@'],
+      install : false,
+      build_by_default : true)
+  endif
+  dxc_dep = declare_dependency(link_args : ['-L'+dxc_libdir, '-ldxcompiler'], include_directories : dxc_include)
+  ac_deps += dxc_dep
+  ac_sources += [
+    'dxc_shader_compiler.cpp'
+  ]
+  ac_cargs += '-DRT_BUILD_DXC_SHADER_COMPILER'
+endif
+
+asset_compiler = static_library('asset_compiler',
+  'asset_compiler.h',
+  'description_parser.h',
+  'processor.h',
+  'shader_compiler.h',
+
+  'asset_compiler.c',
+  'description_parser.c',
+  'framegraph_processor.c',
+  'pipeline_processor.c',
+  'shader_compiler.c',
+  sources : ac_sources,
+  include_directories : engine_incdir,
+  link_with : runtime_lib,
+  c_args : ac_cargs,
+  cpp_args : ac_cargs,
+  dependencies : ac_deps)

src/asset_compiler/pipeline_processor.c

@@ -1,12 +1,13 @@
-#include "asset_compiler.h"
-#include "buffer_manager.h"
-#include "config.h"
+#include "processor.h"
 #include "description_parser.h"
-#include "gfx.h"
-#include "mem_arena.h"
-#include "runtime.h"
 #include "shader_compiler.h"
 
+#include "runtime/buffer_manager.h"
+#include "runtime/config.h"
+#include "runtime/gfx.h"
+#include "runtime/mem_arena.h"
+#include "runtime/runtime.h"
+
 #include <assert.h>
 #include <limits.h>
 #include <string.h>

src/asset_compiler/processor.h

@@ -1,13 +1,9 @@
-#ifndef RT_ASSET_COMPILER_H
-#define RT_ASSET_COMPILER_H
+#ifndef RT_PROCESSOR_H
+#define RT_PROCESSOR_H
 
-#ifndef RT_BUILD_ASSET_COMPILER
-#error This file should only be included if RT_BUILD_ASSET_COMPILER is defined.
-#endif
-
-#include "file_tab.h"
-#include "resources.h"
-#include "mem_arena.h"
+#include "runtime/file_tab.h"
+#include "runtime/mem_arena.h"
+#include "runtime/resources.h"
 
 #ifdef __cplusplus
 extern "C" {

src/asset_compiler/shader_compiler.h

@@ -1,10 +1,9 @@
 #ifndef RT_SHADER_COMPILER_H
 #define RT_SHADER_COMPILER_H
 
-#include "mem_arena.h"
-#include "runtime.h"
-
-#include "renderer_api.h"
+#include "runtime/runtime.h"
+#include "runtime/mem_arena.h"
+#include "runtime/renderer_api.h"
 
 #ifdef __cplusplus
 extern "C" {

src/game/main.c

@@ -2,12 +2,20 @@
 #include "runtime/resources.h"
 #include "runtime/mem_arena.h"
 
+#include "asset_compiler/asset_compiler.h"
+
 static rt_framegraph *_framegraph;
 
+void RegisterCVars(void) {
+    rtRegisterAssetCompilerCVars();
+}
+
 /* Called after the runtime has finished its initialization and before entering the main-loop*/
 void Init(void) {
     rtLog("GAME", "Init");
 
+    rtInitAssetCompiler();
+
     #if 0
     rt_render_target_id rt_ids[4] = {rtCalculateRenderTargetID("rt0", sizeof("rt0")),
                                      rtCalculateRenderTargetID("rt1", sizeof("rt1")),
@@ -61,6 +69,8 @@ void Init(void) {
 
     rt_resource_id id  = rtGetResourceID("assets/test.framegraph");
     rt_temp_arena temp = rtGetTemporaryArena(NULL, 0);
+    while (rtGetResourceSize(id) == 0)
+        ;
     rt_resource *resource =
         rtArenaPush(temp.arena, rtGetResourceSize(id));
     
@@ -72,5 +82,6 @@ void Init(void) {
 /* Called after exiting the main-loop and before the runtime starts its shutdown */
 void Shutdown(void) {
     rtLog("GAME", "Shutdown");
+    rtShutdownAssetCompiler();
     rtDestroyFramegraph(_framegraph);
 }

src/game/meson.build

@@ -0,0 +1,10 @@
+vy_link_libs = engine_link_libs
+vy_link_libs += asset_compiler
+
+executable('voyage',
+  'entry.c',
+  'main.c',
+  link_with : vy_link_libs,
+  include_directories : engine_incdir,
+  c_pch : 'pch/game_pch.h',
+  win_subsystem : 'windows')

src/game/pch/game_pch.h

@@ -0,0 +1,2 @@
+// Runtime dir
+#include "runtime/runtime.h"

src/meson.build

@@ -0,0 +1,5 @@
+subdir('runtime')
+subdir('asset_compiler')
+
+# Renderer libs
+subdir('renderer/vk')

src/renderer/vk/meson.build

@@ -0,0 +1,36 @@
+if vk_dep.found()
+  platform_defs = []
+  if get_option('use_xlib')
+    platform_defs = ['-DVK_USE_PLATFORM_XLIB_KHR']
+  elif host_machine.system() == 'windows'
+    platform_defs = ['-DVK_USE_PLATFORM_WIN32_KHR']
+  endif
+
+  vk_inc_dep = vk_dep.partial_dependency(compile_args : true, includes : true)
+  vk_renderer_lib = library('rtvk',
+    # Project Sources
+    'gpu.h',
+    'pipelines.h',
+    'render_targets.h',
+    'swapchain.h',
+
+    'helper.c',
+    'init.c',
+    'pipelines.c',
+    'render_targets.c',
+    'swapchain.c',
+
+    # Contrib Sources
+    contrib_dir / 'volk/volk.h',
+    contrib_dir / 'volk/volk.c',
+    contrib_dir / 'vma/vk_mem_alloc.h',
+   'vma_impl.cpp',
+    dependencies : [m_dep, vk_inc_dep, windowing_dep],
+    include_directories : [engine_incdir, include_directories(contrib_dir)],
+    link_with : [runtime_lib],
+    c_pch : 'pch/vk_pch.h',
+    c_args : platform_defs,
+    cpp_pch : 'pch/vk_pch.h',
+    cpp_args : platform_defs)
+endif
+

src/runtime/app.c

@@ -32,6 +32,9 @@ rtWin32Entry(HINSTANCE hInstance, HINSTANCE hPrevInstance, PWSTR pCmdLine, int n
 
     rtRegisterRendererCVars();
 
+    if (app_callbacks.RegisterCVars)
+        app_callbacks.RegisterCVars();
+
     WNDCLASSEXW wndclass = {
         .cbSize        = sizeof(wndclass),
         .hInstance     = hInstance,
@@ -165,7 +168,9 @@ RT_DLLEXPORT int rtXlibEntry(int argc, char **argv, rt_app_callbacks app_callbac
         return 1;
 
     rtRegisterRendererCVars();
-
+    
+    if (app_callbacks.RegisterCVars())
+        app_callbacks.RegisterCVars();
 
     Display *dpy = XOpenDisplay(NULL);
     if (!dpy) {

src/runtime/app.h

@@ -9,10 +9,14 @@
 extern "C" {
 #endif
 
+typedef void rt_app_register_cvars_fn(void);
 typedef void rt_app_init_fn(void);
 typedef void rt_app_shutdown_fn(void);
 
 typedef struct {
+    /* Called before initialization. */
+    rt_app_register_cvars_fn *RegisterCVars;
+
     /* Called after the runtime has finished initialization and
      * before entering the main-loop */
     rt_app_init_fn *Init;

src/runtime/config.c

@@ -12,6 +12,8 @@ static unsigned int _next = 0;
 static rt_mutex *_mutex   = NULL;
 
 void rtRegisterCVAR(rt_cvar *cvar) {
+    /* TODO(Kevin): Check if we have a loaded value for that cvar. 
+     * If yes, override the provided default value. */
     if (!_mutex)
         _mutex = rtCreateMutex();
     rtLockMutex(_mutex);

src/runtime/init.c

@@ -18,10 +18,6 @@ extern rt_cvar rt_ResourceNamespaceSize;
 extern rt_cvar rt_DisableResourceNamespaceLoad;
 extern rt_cvar rt_MaxFramegraphs;
 
-#ifdef RT_BUILD_ASSET_COMPILER
-extern rt_cvar rt_AssetDirectory;
-#endif
-
 void RegisterRuntimeCVars(void) {
     rtRegisterCVAR(&rt_Renderer);
     rtRegisterCVAR(&rt_Fullscreen);
@@ -36,9 +32,6 @@ void RegisterRuntimeCVars(void) {
     rtRegisterCVAR(&rt_ResourceNamespaceSize);
     rtRegisterCVAR(&rt_DisableResourceNamespaceLoad);
     rtRegisterCVAR(&rt_MaxFramegraphs);
-#ifdef RT_BUILD_ASSET_COMPILER
-    rtRegisterCVAR(&rt_AssetDirectory);
-#endif
 }
 
 extern void SetMainThreadId(void);
@@ -52,11 +45,6 @@ extern void ShutdownAIO(void);
 extern rt_result InitResourceManager(void);
 extern void ShutdownResourceManager(void);
 
-#ifdef RT_BUILD_ASSET_COMPILER
-extern rt_result InitAssetCompiler(void);
-extern void ShutdownAssetCompiler(void);
-#endif
-
 RT_DLLEXPORT rt_result rtInitRuntime(void) {
     SetMainThreadId();
     RegisterRuntimeCVars();
@@ -82,20 +70,10 @@ RT_DLLEXPORT rt_result rtInitRuntime(void) {
         return res;
     }
 
-#ifdef RT_BUILD_ASSET_COMPILER
-    if ((res = InitAssetCompiler()) != RT_SUCCESS) {
-        rtReportError("AC", "Init failed.");
-        return res;
-    }
-#endif
-
     return RT_SUCCESS;
 }
 
 RT_DLLEXPORT void rtShutdownRuntime(void) {
-#ifdef RT_BUILD_ASSET_COMPILER
-    ShutdownAssetCompiler();
-#endif
     ShutdownResourceManager();
     ShutdownAIO();
     ShutdownFileTab();

src/runtime/meson.build

@@ -0,0 +1,55 @@
+# Runtime 
+runtime_deps = [thread_dep, m_dep, windowing_dep]
+runtime_incdirs = include_directories(meson.project_source_root() / 'contrib')
+runtime_lib = library('rt',
+  # Project Sources
+  'aio.h',
+  'app.h',
+  'buffer_manager.h',
+  'compression.h',
+  'config.h',
+  'ds.h',
+  'dynamic_libs.h',
+  'file_tab.h',
+  'fsutils.h',
+  'gfx.h',
+  'handles.h',
+  'hashing.h',
+  'jobs.h',
+  'mem_arena.h',
+  'renderer_api.h',
+  'resources.h',
+  'runtime.h',
+  'threading.h',
+  
+  'aio.c',
+  'app.c',
+  'assert.c',
+  'buffer_manager.c',
+  'compression.c',
+  'config.c',
+  'ds_minheap.c',
+  'dynamic_libs.c',
+  'error_report.c',
+  'file_tab.c',
+  'fsutils.c',
+  'gfx_framegraph.c',
+  'gfx_main.c',
+  'hashing.c',
+  'init.c',
+  'jobs.c',
+  'mem_arena.c',
+  'resource_manager.c',
+  'sprint.c',
+  'text.c',
+  'threading_cond.c',
+  'threading_mutex.c',
+  'threading_rwlock.c',
+  'threading_thread.c',
+
+  # Contrib Sources
+  contrib_dir / 'xxhash/xxhash.c',
+  contrib_dir / 'lz4/lz4.c',
+  dependencies : runtime_deps,
+  include_directories : [engine_incdir, runtime_incdirs],
+  c_pch : 'pch/rt_pch.h')

tests/meson.build

@@ -0,0 +1,6 @@
+rttest_exe = executable('rttest',
+  'rttest.c',
+  link_with : engine_link_libs,
+  include_directories : engine_incdir,
+  win_subsystem : 'console')
+test('runtime test', rttest_exe)