refactor(renderer): Introduce renderer lib that handles backend selection and common functionality

src/asset_compiler/shader_compiler.h

@@ -3,7 +3,7 @@
 
 #include "runtime/runtime.h"
 #include "runtime/mem_arena.h"
-#include "renderer/common/renderer_api.h"
+#include "renderer/renderer.h"
 
 #ifdef __cplusplus
 extern "C" {

src/launcher/launcher.c

@@ -21,7 +21,7 @@
 #include <runtime/runtime.h>
 #include <runtime/config.h>
 #include <runtime/dynamic_libs.h>
-#include <renderer/common/renderer_api.h>
+#include <renderer/renderer.h>
 #include <runtime/fsutils.h>
 
 #include <string.h>
@@ -30,8 +30,6 @@
  
 #include "game_api.h"
 
-
-RT_CVAR_S(rt_Renderer, "The used renderer. Available options: vk, dx11. (Default: vk)", "vk");
 RT_CVAR_S(rt_WindowTitle, "The title used for the game window. (Default: rtengine)", "rtengine");
 RT_CVAR_I(rt_WindowWidth, "The window width. (Default: 1024)", 1024);
 RT_CVAR_I(rt_WindowHeight, "The window height. (Default: 768)", 768);
@@ -71,7 +69,6 @@ static HINSTANCE _hInstance;
 #endif
 
 static void SetupConfig(void) {
-    rtRegisterCVAR(&rt_Renderer);
     rtRegisterCVAR(&rt_WindowTitle);
     rtRegisterCVAR(&rt_WindowWidth);
     rtRegisterCVAR(&rt_WindowHeight);
@@ -246,14 +243,16 @@ static int Entry(int argc, char **argv) {
     }
     DisplayMonitors();
 
+    rtRegisterRenderCVARs();
+
     /* Load the renderer library.
      * We need it before window creation, to give it an opportunity to register its cvars */
-    if (rtLoadRenderer() != RT_SUCCESS) {
+    if (rtLoadRenderBackend() != RT_SUCCESS) {
         rtShutdownRuntime();
         glfwTerminate();
         return -1;
     }
-    g_renderer.RegisterCVARs();
+    rtRegisterRenderBackendCVARs();
 
     _launcher_api = (rt_launcher_api){
         .GetWindow = LauncherAPIGetWindow,
@@ -350,7 +349,7 @@ static int Entry(int argc, char **argv) {
 #endif
     renderer_init_info.is_fullscreen = rt_WindowMode.i != WINDOW_MODE_WINDOWED;
     glfwGetFramebufferSize(window, (int*)&renderer_init_info.width, (int*)&renderer_init_info.height);
-    if (g_renderer.Init(&renderer_init_info) != RT_SUCCESS) {
+    if (rtInitRenderer(&renderer_init_info) != RT_SUCCESS) {
         rtReportError("LAUNCHER", "Failed to initialize the renderer.");
         if (_game_lib)
             rtCloseLib(_game_lib);
@@ -396,7 +395,7 @@ static int Entry(int argc, char **argv) {
     }
 
     _game.Shutdown(&_launcher_api, _game_obj);
-    g_renderer.Shutdown();
+    rtShutdownRenderer();
 
     glfwDestroyWindow(window);
     glfwTerminate();

src/launcher/meson.build

@@ -1,21 +1,10 @@
 launcher_deps = [thread_dep, glfw_dep, m_dep]
-launcher_link_libs = [runtime_lib]
-
-if get_option('default_library') == 'static'
-  if get_option('static_renderer') == 'vk'
-    launcher_link_libs += vk_renderer_lib
-  elif get_option('static_renderer') == 'dx11'
-    launcher_link_libs += dx11_renderer_lib
-  else
-    error('Invalid static_renderer option ', get_option('static_renderer'))
-  endif
-endif
+launcher_link_libs = [runtime_lib, renderer_lib]
 
 launcher_name = get_option('launcher_name')
 
 executable(launcher_name,
   'launcher.c',
-  '../renderer/common/load_stub.c',
   include_directories: engine_incdir,
   dependencies: launcher_deps,
   link_with: launcher_link_libs,

src/meson.build

@@ -1,9 +1,7 @@
 subdir('runtime')
 subdir('asset_compiler')
 
-subdir('renderer/common')
-subdir('renderer/dx11')
-subdir('renderer/vk')
+subdir('renderer')
 
 subdir('launcher')
 

src/renderer/backend_api.h

@@ -0,0 +1,20 @@
+#ifndef RT_RENCOM_RENDERER_API_H
+#define RT_RENCOM_RENDERER_API_H
+
+#include "runtime/runtime.h"
+#include "renderer.h"
+
+typedef void rt_render_backend_register_cvars_fn(void);
+typedef rt_result rt_render_backend_init_fn(const rt_renderer_init_info *info);
+typedef void rt_render_backend_shutdown_fn(void);
+
+/* Public renderer interface */
+typedef struct {
+    rt_render_backend_register_cvars_fn *RegisterCVARs;
+    rt_render_backend_init_fn *Init;
+    rt_render_backend_shutdown_fn *Shutdown;
+} rt_render_backend_api;
+
+extern rt_render_backend_api g_render_backend;
+
+#endif

src/renderer/common/meson.build

@@ -1,10 +0,0 @@
-common_renderer_lib = static_library('common_renderer',
-    '../common/renderer_api.h',
-    '../common/render_mesh.h',
-
-    '../common/meshlet_pools.c',
-    '../common/render_mesh.c',
-	dependencies: [m_dep, thread_dep],
-	link_with: runtime_lib,
-    include_directories: [engine_incdir, contrib_incdir],
-	install: false)

src/renderer/common/renderer_api.h

@@ -1,56 +0,0 @@
-#ifndef RT_RENCOM_RENDERER_API_H
-#define RT_RENCOM_RENDERER_API_H
-
-#include "runtime/runtime.h"
-
-/* Defines the outward facing renderer api */
-
-#ifdef _WIN32
-struct HINSTANCE__;
-struct HWND__;
-#elif defined(RT_USE_XLIB)
-struct _XDisplay;
-#endif
-
-/* Platform specific init info for the renderer */
-typedef struct {
-#ifdef _WIN32
-    struct HINSTANCE__ *hInstance;
-    struct HWND__ *hWnd;
-#elif defined(RT_USE_XLIB)
-    struct _XDisplay *display;
-    unsigned long window;
-#endif
-
-    unsigned int width;
-    unsigned int height;
-    int is_fullscreen;
-} rt_renderer_init_info;
-
-typedef void rt_renderer_register_cvars_fn(void);
-typedef rt_result rt_renderer_init_fn(const rt_renderer_init_info *info);
-typedef void rt_renderer_shutdown_fn(void);
-
-typedef enum {
-    RT_SHADER_STAGE_VERTEX,
-    RT_SHADER_STAGE_FRAGMENT,
-    RT_SHADER_STAGE_COMPUTE,
-} rt_shader_stage;
-
-
-/* Public renderer interface */
-typedef struct {
-    rt_renderer_register_cvars_fn *RegisterCVARs;
-    rt_renderer_init_fn *Init;
-    rt_renderer_shutdown_fn *Shutdown;
-} rt_renderer_api;
-
-
-/* Global renderer object */
-RT_DLLIMPORT extern rt_renderer_api g_renderer;
-
-/* This function is declared here, but it's definition is not necessarily compiled,
- * where you think it is. Normally, you will not have to call this. */
-RT_DLLEXPORT rt_result rtLoadRenderer(void);
-
-#endif

src/renderer/dx11/device.hpp

@@ -5,7 +5,7 @@
 #error This file must only be used from C++ code
 #endif
 
-#include "renderer/common/renderer_api.h"
+#include "renderer/backend_api.h"
 #include "runtime/runtime.h"
 
 #include <d3d11_4.h>

src/renderer/dx11/init.cpp

@@ -1,5 +1,4 @@
-#include "renderer/common/render_mesh.h"
-#include "renderer/common/renderer_api.h"
+#include "renderer/backend_api.h"
 
 #include "device.hpp"
 
@@ -10,19 +9,16 @@ rt_result Dx11Init(const rt_renderer_init_info *info) {
     rt_result res = rt_dx11_device::GetInstance()->Initialize(info);
     if (res != RT_SUCCESS)
         return res;
-
-    res = rtInitMeshStreaming();
     return res;
 }
 
 void Dx11Shutdown(void) {
-    rtShutdownMeshStreaming();
     rt_dx11_device::GetInstance()->Shutdown();
 }
 
 // Called by the application to retrieve the renderer api
-extern "C" RT_DLLEXPORT rt_renderer_api rtLoadRendererImpl(void) {
-    rt_renderer_api api = {
+extern "C" RT_DLLEXPORT rt_render_backend_api rtLoadRenderBackendImpl(void) {
+    rt_render_backend_api api = {
         .RegisterCVARs = Dx11RegisterCVARs,
         .Init          = Dx11Init,
         .Shutdown      = Dx11Shutdown,

src/renderer/dx11/meson.build

@@ -9,7 +9,7 @@ if get_option('build_dx11')
 
     dependencies: [m_dep, dx11_dep, thread_dep],
     include_directories: [engine_incdir, contrib_incdir],
-    link_with: [runtime_lib, common_renderer_lib],
+    link_with: [runtime_lib],
     cpp_pch: 'pch/dx11_pch.h',
     override_options: ['b_sanitize=none'],
     install: true)

src/renderer/init.c

@@ -0,0 +1,23 @@
+#include "renderer.h"
+#include "backend_api.h" 
+
+#include <runtime/config.h>
+
+RT_CVAR_S(rt_Renderer, "The used renderer. Available options: vk, dx11. (Default: vk)", "vk");
+
+RT_DLLEXPORT void rtRegisterRenderCVARs(void) {
+    rtRegisterCVAR(&rt_Renderer);
+}
+
+RT_DLLEXPORT void rtRegisterRenderBackendCVARs(void) {
+    g_render_backend.RegisterCVARs();    
+}
+
+
+RT_DLLEXPORT rt_result rtInitRenderer(const rt_renderer_init_info *info) {
+    return g_render_backend.Init(info);
+}
+
+RT_DLLEXPORT void rtShutdownRenderer(void) {
+    g_render_backend.Shutdown();
+}

src/renderer/load_stub.c

@@ -1,4 +1,4 @@
-#include "renderer_api.h"
+#include "backend_api.h"
 #include "runtime/dynamic_libs.h"
 #include "runtime/config.h"
 #include "runtime/runtime.h"
@@ -6,20 +6,20 @@
 #include <string.h>
 
 
-RT_DLLEXPORT rt_renderer_api g_renderer;
+RT_DLLEXPORT rt_render_backend_api g_render_backend;
 
-typedef rt_renderer_api rt_load_renderer_impl_fn(void);
+typedef rt_render_backend_api rt_load_renderer_impl_fn(void);
 
 #ifdef RT_STATIC_LIB
-extern rt_renderer_api rtLoadRendererImpl(void);
+extern rt_render_backend_api rtLoadRenderBackendImpl(void);
 #else
 static rt_dynlib _renderer_lib;
 #endif
 
 #define DEFAULT_RENDERER "vk"
 
-RT_DLLEXPORT rt_result rtLoadRenderer(void) {
-    rt_load_renderer_impl_fn *LoadRendererImpl = NULL;
+RT_DLLEXPORT rt_result rtLoadRenderBackend(void) {
+    rt_load_renderer_impl_fn *LoadRenderBackendImpl = NULL;
     rt_cvar *rt_Renderer = rtGetCVAR("rt_Renderer");
     const char *renderer = DEFAULT_RENDERER;
     if (!rt_Renderer) {
@@ -31,7 +31,7 @@ RT_DLLEXPORT rt_result rtLoadRenderer(void) {
     
 #ifdef RT_STATIC_LIB
     RT_UNUSED((void*)renderer);
-    LoadRendererImpl = rtLoadRendererImpl;
+    LoadRenderBackendImpl = rtLoadRenderBackendImpl;
 #else
     const char *dllname = NULL;
     if (strcmp(renderer, "dx11")==0)
@@ -47,12 +47,12 @@ RT_DLLEXPORT rt_result rtLoadRenderer(void) {
         rtReportError("RENDERER", "Unable to load renderer backend: %s", dllname);
         return RT_UNKNOWN_ERROR;
     }
-    LoadRendererImpl = (rt_load_renderer_impl_fn *)rtGetSymbol(_renderer_lib, "rtLoadRendererImpl");
-    if (!LoadRendererImpl) {
+    LoadRenderBackendImpl = (rt_load_renderer_impl_fn *)rtGetSymbol(_renderer_lib, "rtLoadRenderBackendImpl");
+    if (!LoadRenderBackendImpl) {
         rtReportError("RENDERER", "Invalid renderer. Could not find rtLoadRendererImpl");
         return RT_UNKNOWN_ERROR;
     }
 #endif
-    g_renderer = LoadRendererImpl();
+    g_render_backend = LoadRenderBackendImpl();
     return RT_SUCCESS;
 }

src/renderer/meson.build

@@ -0,0 +1,31 @@
+# Add backends here
+subdir('dx11')
+subdir('vk')
+
+renderer_link_libs = [runtime_lib]
+
+if get_option('default_library') == 'static'
+  if get_option('static_renderer') == 'vk'
+    renderer_link_libs += vk_renderer_lib
+  elif get_option('static_renderer') == 'dx11'
+    renderer_link_libs += dx11_renderer_lib
+  else
+    error('Invalid static_renderer option ', get_option('static_renderer'))
+  endif
+endif
+
+
+renderer_lib = library('renderer',
+    'backend_api.h',
+    'renderer.h',
+    'render_mesh.h',
+
+    'init.c',
+    'load_stub.c',
+    'meshlet_pools.c',
+    'render_mesh.c',
+	dependencies: [m_dep, thread_dep],
+	link_with: renderer_link_libs,
+	include_directories: engine_incdir,
+	install: true)
+

src/renderer/renderer.h

@@ -0,0 +1,55 @@
+#ifndef RT_RENDERER_H
+#define RT_RENDERER_H
+
+#include "runtime/runtime.h"
+
+#ifdef _WIN32
+struct HINSTANCE__;
+struct HWND__;
+#elif defined(RT_USE_XLIB)
+struct _XDisplay;
+#endif
+
+/* Platform specific init info for the renderer */
+typedef struct {
+#ifdef _WIN32
+    struct HINSTANCE__ *hInstance;
+    struct HWND__ *hWnd;
+#elif defined(RT_USE_XLIB)
+    struct _XDisplay *display;
+    unsigned long window;
+#endif
+
+    unsigned int width;
+    unsigned int height;
+    int is_fullscreen;
+} rt_renderer_init_info;
+
+typedef enum {
+    RT_SHADER_STAGE_VERTEX,
+    RT_SHADER_STAGE_FRAGMENT,
+    RT_SHADER_STAGE_COMPUTE,
+} rt_shader_stage;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+RT_DLLEXPORT void rtRegisterRenderCVARs(void);
+
+/* Loads the requested render backend */
+RT_DLLEXPORT rt_result rtLoadRenderBackend(void);
+
+RT_DLLEXPORT void rtRegisterRenderBackendCVARs(void);
+
+
+RT_DLLEXPORT rt_result rtInitRenderer(const rt_renderer_init_info *info);
+
+RT_DLLEXPORT void rtShutdownRenderer(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

src/renderer/vk/init.c

@@ -1,4 +1,4 @@
-#include "renderer/common/renderer_api.h"
+#include "renderer/backend_api.h"
 
 void VkRegisterCVARs(void) {
     
@@ -12,8 +12,8 @@ void VkShutdown(void) {
 }
 
 // Called by the application to retrieve the renderer api
-RT_DLLEXPORT rt_renderer_api rtLoadRendererImpl(void) {
-    rt_renderer_api api = {
+RT_DLLEXPORT rt_render_backend_api rtLoadRenderBackendImpl(void) {
+    rt_render_backend_api api = {
         .RegisterCVARs = VkRegisterCVARs,
         .Init          = VkInit,
         .Shutdown      = VkShutdown,

src/renderer/vk/meson.build

@@ -1,10 +1,7 @@
 if get_option('build_vk')
-  #dx11_dep = declare_dependency(link_args: ['-ld3d11', '-ldxgi', '-lwinmm', '-ldxguid'])
   vma_proj = subproject('vulkan-memory-allocator', default_options: ['warning_level=0', 'werror=false'])
   vma_dep = vma_proj.get_variable('vma_allocator_dep')
 
-  #vk_dep = dependency('vulkan', required : true)
-  #vk_inc_dep = vk_dep.partial_dependency(compile_args: true, includes: true)
   vk_inc_proj = subproject('vulkan-headers')
   vk_inc_dep = vk_inc_proj.get_variable('vulkan_headers_dep')  
 
@@ -16,7 +13,7 @@ if get_option('build_vk')
     
     dependencies: [m_dep, vk_inc_dep, vma_dep, thread_dep],
     include_directories: [engine_incdir, contrib_incdir],
-    link_with: [runtime_lib, common_renderer_lib],
+    link_with: [runtime_lib],
     cpp_pch: 'pch/vk_pch.h',
     override_options: ['b_sanitize=none'],
     install: true)

src/runtime/resource_manager.c

@@ -10,7 +10,7 @@
 #include "resources.h"
 #include "threading.h"
 
-#include "renderer/common/renderer_api.h"
+#include "renderer/renderer.h"
 
 #include <assert.h>
 #include <stdlib.h>