Add rendering stuff, cross-platform support, camera controller & SDL input logic

.github/workflows/linux_build.yml

@@ -0,0 +1,99 @@
+name: 🐧 Linux Builds
+
+on:
+  push:
+    branches:
+      - '**'
+  pull_request:
+    branches:
+      - '**'
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-24.04
+
+    steps:
+      - name: Checkout Source Code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Set up Clang Compiler
+        uses: egor-tensin/setup-clang@v1
+        with:
+          version: 20
+
+      - name: Install System Dependencies
+        run: |
+          wget https://github.com/Kitware/CMake/releases/download/v4.3.0/cmake-4.3.0-linux-x86_64.tar.gz
+          tar -xzf cmake-4.3.0-linux-x86_64.tar.gz
+          echo "$(pwd)/cmake-4.3.0-linux-x86_64/bin" >> $GITHUB_PATH
+
+          sudo apt-get update
+          sudo apt-get install -y \
+            ninja-build \
+            ccache \
+            llvm-20 \
+            llvm-20-tools \
+            clang-tools-20 \
+            libc++-20-dev \
+            libc++abi-20-dev \
+            libgl1-mesa-dev \
+            libegl1-mesa-dev \
+            libwayland-egl1-mesa \
+            libasound2-dev \
+            libpulse-dev \
+            libwayland-dev \
+            libx11-dev \
+            libxext-dev \
+            libxrender-dev \
+            libxrandr-dev \
+            libxinerama-dev \
+            libxcursor-dev \
+            libxi-dev \
+            libxtst-dev
+          echo "/usr/lib/llvm-20/bin" >> $GITHUB_PATH
+
+      - name: Verify LLVM Toolchain
+        run: |
+          which clang
+          which clang++
+          which clang-scan-deps
+          clang --version
+          clang++ --version
+          clang-scan-deps --version
+
+      - name: Cache Build Artifacts
+        uses: hendrikmuhs/[email protected]
+        with:
+          key: ${{ runner.os }}-ccache-${{ hashFiles('**/CMakeLists.txt', '**/*.cmake') }}
+          restore-keys: |
+            ${{ runner.os }}-ccache-
+          max-size: "500M"
+
+      - name: Configure Build System
+        run: |
+          cmake --preset debug \
+            -B build/debug \
+            -DCMAKE_C_COMPILER=clang \
+            -DCMAKE_CXX_COMPILER=clang++ \
+            -DCMAKE_C_COMPILER_LAUNCHER=ccache \
+            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
+            -DCMAKE_BUILD_WITH_INSTALL_RPATH=TRUE \
+            -DCMAKE_INSTALL_RPATH="\$ORIGIN:\$ORIGIN/engine/native"
+
+      - name: Compile Target Binary
+        run: |
+          cmake --build build/debug -j$(nproc)
+
+      - name: Run Unit Tests
+        run: |
+          ctest --test-dir build/debug --output-on-failure -j$(nproc)
+
+      - name: Upload Engine Artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: linux_debug
+          path: build/debug/
+          if-no-files-found: error
+          retention-days: 7

.gitmodules

@@ -7,3 +7,6 @@
 [submodule "engine/native/thirdparty/bgfx"]
 	path = engine/native/thirdparty/bgfx
 	url = https://github.com/bkaradzic/bgfx
+[submodule "engine/native/thirdparty/sdl"]
+	path = engine/native/thirdparty/sdl
+	url = https://github.com/libsdl-org/SDL

CMakeLists.txt

@@ -3,6 +3,7 @@ cmake_minimum_required(VERSION 4.0)
 project(DraconicEngine LANGUAGES C CXX)
 
 find_package(Git QUIET)
+find_package(Threads REQUIRED)
 
 if(GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
     message(STATUS "Updating submodules...")
@@ -22,5 +23,51 @@ list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
 include(CTest)
 include(Compiler)
 include(Modules)
+include(Shaders)
 
-add_subdirectory(engine/native)
+# Subdirectories for engine libs
+add_subdirectory(engine/native)
+
+# Main Executable
+add_executable(draconic engine/native/main/main.cpp)
+
+target_link_libraries(draconic
+    PRIVATE
+    core
+    math
+    io
+    memory
+    platform
+    input
+    rendering
+    scene
+    bgfx
+    bx
+    bimg
+)
+
+if(UNIX AND NOT APPLE)
+    target_link_libraries(draconic PRIVATE SDL3::SDL3-static Threads::Threads dl)
+    target_link_options(draconic PRIVATE -Wl,--whole-archive $<TARGET_FILE:SDL3::SDL3-static> -Wl,--no-whole-archive)
+elseif(APPLE)
+    target_link_libraries(draconic PRIVATE SDL3::SDL3-static)
+    target_link_options(draconic PRIVATE -Wl,-force_load,$<TARGET_FILE:SDL3::SDL3-static>)
+else()
+    target_link_libraries(draconic PRIVATE SDL3::SDL3-static)
+endif()
+
+compile_shaders(draconic)
+
+set(TEST_IMAGE
+    "${CMAKE_SOURCE_DIR}/assets/draconic_logo_no_text.png"
+)
+
+add_custom_command(
+    TARGET draconic POST_BUILD
+
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+        ${TEST_IMAGE}
+        $<TARGET_FILE_DIR:draconic>/test.png
+
+    COMMENT "Copying test texture..."
+)

cmake/Compiler.cmake

@@ -20,4 +20,10 @@ if (CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
         # TODO: Make SIMD level configurable or detect at runtime
         add_compile_options(-mavx2 -mfma)
     endif()
-endif()
+endif()
+
+if(WIN32)
+    add_compile_definitions("_${CMAKE_SYSTEM_PROCESSOR}_")
+else()
+    add_compile_definitions(_GNU_SOURCE)
+endif()

cmake/Shaders.cmake

@@ -0,0 +1,84 @@
+include_guard(GLOBAL)
+
+set(SHADER_SRC_DIR "${CMAKE_SOURCE_DIR}/engine/native/rendering/shaders")
+set(SHADER_BIN_DIR "${CMAKE_BINARY_DIR}")
+set(BGFX_INCLUDE "${CMAKE_SOURCE_DIR}/engine/native/thirdparty/bgfx/src")
+
+function(compile_shaders TARGET_NAME)
+    file(MAKE_DIRECTORY ${SHADER_BIN_DIR})
+
+    if(APPLE)
+        set(VERTEX_PROFILE "metal")
+        set(FRAGMENT_PROFILE "metal")
+        set(SHADER_PLATFORM "osx")
+    elseif(WIN32)
+        set(VERTEX_PROFILE "s_5_0")
+        set(FRAGMENT_PROFILE "s_5_0")
+        set(SHADER_PLATFORM "windows")
+    else()
+        set(VERTEX_PROFILE "spirv")
+        set(FRAGMENT_PROFILE "spirv")
+        set(SHADER_PLATFORM "linux")
+    endif()
+
+    set(VERTEX_INPUT "${SHADER_SRC_DIR}/vs.sc")
+    set(VERTEX_OUTPUT "${SHADER_BIN_DIR}/vs.bin")
+
+    set(FRAGMENT_INPUT "${SHADER_SRC_DIR}/fs.sc")
+    set(FRAGMENT_OUTPUT "${SHADER_BIN_DIR}/fs.bin")
+
+    set(QUAD_VERTEX_INPUT "${SHADER_SRC_DIR}/vs_quad.sc")
+    set(QUAD_VERTEX_OUTPUT "${SHADER_BIN_DIR}/vs_quad.bin")
+
+    set(QUAD_FRAGMENT_INPUT "${SHADER_SRC_DIR}/fs_quad.sc")
+    set(QUAD_FRAGMENT_OUTPUT "${SHADER_BIN_DIR}/fs_quad.bin")
+
+    set(VARYING_DEF "${SHADER_SRC_DIR}/varying.def.sc")
+    set(QUAD_VARYING_DEF "${SHADER_SRC_DIR}/varying_quad.def.sc")
+
+    add_custom_command(
+        TARGET draconic POST_BUILD
+        COMMENT "Compiling asset pipelines and core engine shaders via native tools..."
+
+        COMMAND $<TARGET_FILE:shaderc>
+            -f ${VERTEX_INPUT}
+            -o ${VERTEX_OUTPUT}
+            --type vertex
+            --platform ${SHADER_PLATFORM}
+            -p ${VERTEX_PROFILE}
+            --varyingdef ${VARYING_DEF}
+            -i ${BGFX_INCLUDE}
+
+        COMMAND $<TARGET_FILE:shaderc>
+            -f ${FRAGMENT_INPUT}
+            -o ${FRAGMENT_OUTPUT}
+            --type fragment
+            --platform ${SHADER_PLATFORM}
+            -p ${FRAGMENT_PROFILE}
+            --varyingdef ${VARYING_DEF}
+            -i ${BGFX_INCLUDE}
+
+        COMMAND $<TARGET_FILE:shaderc>
+            -f ${QUAD_VERTEX_INPUT}
+            -o ${QUAD_VERTEX_OUTPUT}
+            --type vertex
+            --platform ${SHADER_PLATFORM}
+            -p ${VERTEX_PROFILE}
+            --varyingdef ${QUAD_VARYING_DEF}
+            -i ${BGFX_INCLUDE}
+
+        COMMAND $<TARGET_FILE:shaderc>
+            -f ${QUAD_FRAGMENT_INPUT}
+            -o ${QUAD_FRAGMENT_OUTPUT}
+            --type fragment
+            --platform ${SHADER_PLATFORM}
+            -p ${FRAGMENT_PROFILE}
+            --varyingdef ${QUAD_VARYING_DEF}
+            -i ${BGFX_INCLUDE}
+
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${VERTEX_OUTPUT} $<TARGET_FILE_DIR:draconic>
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${FRAGMENT_OUTPUT} $<TARGET_FILE_DIR:draconic>
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QUAD_VERTEX_OUTPUT} $<TARGET_FILE_DIR:draconic>
+        COMMAND ${CMAKE_COMMAND} -E copy_if_different ${QUAD_FRAGMENT_OUTPUT} $<TARGET_FILE_DIR:draconic>
+    )
+endfunction()

engine/native/CMakeLists.txt

@@ -1,4 +1,12 @@
+add_modules_library(core SHARED)
+add_modules_library(input)
+add_modules_library(rendering)
+add_modules_library(scene)
+
 add_subdirectory(thirdparty SYSTEM)
+add_subdirectory(platform)
 
-add_modules_library(core SHARED)
-target_link_libraries(core PUBLIC definitions math memory)
+target_link_libraries(core PUBLIC definitions math io memory)
+target_link_libraries(input PRIVATE SDL3::SDL3-static core)
+target_link_libraries(rendering PUBLIC rhi rendergraph mesh material quad_renderer renderer)
+target_link_libraries(scene PUBLIC renderable transform_component camera)

engine/native/core/CMakeLists.txt

@@ -1,5 +1,8 @@
 add_modules_library(definitions PIC)
 add_modules_library(math)
+add_modules_library(io)
 add_modules_library(memory)
-target_link_libraries(math PUBLIC definitions)
-target_link_libraries(memory PUBLIC definitions)
+
+target_link_libraries(math PUBLIC definitions bx)
+target_link_libraries(io PUBLIC definitions stb_image)
+target_link_libraries(memory PUBLIC definitions math)

engine/native/core/core.cppm

@@ -2,3 +2,4 @@ export module core;
 export import core.defs;
 export import core.math;
 export import core.memory;
+export import core.io;

engine/native/core/io/filesystem.cpp

@@ -0,0 +1,45 @@
+module;
+
+#include <vector>
+#include <string>
+#include <fstream>
+#include <print>
+
+module core.io.filesystem;
+
+import core.stdtypes;
+
+namespace draco::core::io::filesystem
+{
+    std::vector<u8> load_binary(const std::string& path)
+    {
+        // Open at the end (ate) to get size and in binary mode
+        std::ifstream file(path, std::ios::binary | std::ios::ate);
+
+        if (!file.is_open()) {
+            std::println("Error: Could not open file at: {}", path);
+            // Return an empty vector
+            return {}; 
+        }
+
+        std::streamsize size = file.tellg();
+        if (size < 0) {
+            std::println("Error: File is empty or unreadable: {}", path);
+            return {};
+        }
+
+        if (size == 0) {
+            return {};
+        }
+
+        file.seekg(0, std::ios::beg);
+
+        std::vector<u8> buffer(static_cast<std::size_t>(size));
+        if (file.read(reinterpret_cast<char*>(buffer.data()), size)) {
+            return buffer;
+        }
+
+        std::println("Error: Failed to read file contents: {}", path);
+        return {};
+    }
+}

engine/native/core/io/filesystem.cppm

@@ -0,0 +1,15 @@
+module;
+
+#include <vector>
+#include <string>
+#include <fstream>
+
+export module core.io.filesystem;
+
+import core.stdtypes;
+
+export namespace draco::core::io::filesystem
+{
+    // Returns a buffer of the file data
+    std::vector<u8> load_binary(const std::string& path);
+}