State refactor

.github/workflows/build.yml

@@ -0,0 +1,82 @@
+name: Build meson project
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: ${{ matrix.os }} / ${{ matrix.compiler }} (${{ matrix.build_type }})
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        build_type: [release]
+        compiler: [gcc, clang]
+
+        exclude:
+          - os: windows-latest # Issues with meson for whatever reason
+            compiler: clang
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+
+    - name: Cache Meson dependencies
+      uses: actions/cache@v4
+      with:
+        path: |
+          ${{ github.workspace }}/subprojects/*/
+        key: ${{ runner.os }}-meson-${{ hashFiles('**/meson.build', '**/meson_options.txt', '**/subprojects/*.wrap') }}
+        restore-keys: |
+          ${{ runner.os }}-meson-
+
+    - name: Set up C++ environment
+      uses: aminya/setup-cpp@v1
+      with:
+        ninja: true
+        meson: true
+        cmake: true
+        compiler: ${{ matrix.compiler }}
+
+    - name: Install System Dependencies (Linux)
+      if: runner.os == 'Linux'
+      run: |
+        sudo apt-get update
+        sudo apt-get install -y libglu1-mesa-dev libgl1-mesa-dev
+
+    - name: Set reusable workflow outputs
+      id: set_outputs
+      shell: bash
+      run: |
+        echo "build-dir=${{ github.workspace }}/build" >> $GITHUB_OUTPUT
+
+    - name: Configure Meson
+      run: meson setup ${{ steps.set_outputs.outputs.build-dir }} --buildtype=${{ matrix.build_type }}
+
+    - name: Build
+      run: meson compile -C ${{ steps.set_outputs.outputs.build-dir }}
+
+
+    - name: Prepare Artifacts (Linux)
+      if: github.event_name == 'push' && runner.os == 'Linux'
+      run: |
+        cp ${{ steps.set_outputs.outputs.build-dir }}/lowlevelgame ${{ github.workspace }}/lowlevelgame
+
+    - name: Prepare Artifacts (Windows)
+      if: github.event_name == 'push' && runner.os == 'Windows'
+      run: |
+        cp ${{ steps.set_outputs.outputs.build-dir }}/lowlevelgame.exe ${{ github.workspace }}/lowlevelgame.exe
+
+    - name: Upload Build Artifacts
+      if: github.event_name == 'push'
+      uses: actions/upload-artifact@v4
+      with:
+        name: build-${{ matrix.os }}-${{ matrix.compiler }}-${{ matrix.build_type }}
+        path: |
+          ${{ github.workspace }}/lowlevelgame
+          ${{ github.workspace }}/lowlevelgame.exe
+          ${{ github.workspace }}/resources/

debug.ps1

@@ -1,2 +1,3 @@
 meson setup build/debug
 meson compile -C build/debug
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

meson.build

@@ -27,7 +27,11 @@ if not assimp_dep.found()
     assimp_dep = cmake.subproject('assimp', options : assimp_opt).dependency('assimp')
 endif
 
-dependencies = [sdl2_dep, glew_dep, glm_dep, imgui_dep, assimp_dep]
+
+spdlog_options = ['default_library=static', 'compile_library=true', 'werror=false', 'tests=disabled', 'external_fmt=disabled', 'std_format=disabled']
+spdlog_dep = dependency('spdlog', default_options: spdlog_options)
+
+dependencies = [sdl2_dep, glew_dep, glm_dep, imgui_dep, assimp_dep, spdlog_dep]
 
 if host_machine.system() == 'windows'
     sdl2_main_dep = dependency('sdl2main')
@@ -37,28 +41,45 @@ endif
 sources = [
     'src/main.cpp',
     'src/engine/run.cpp',
-    'src/engine/logging.cpp',
-    'src/engine/loader/shader/shader_program.cpp',
-    'src/engine/loader/scene.cpp',
-    'src/engine/loader/texture.cpp',
-    'src/engine/loader/generic.cpp',
-    'src/engine/manager/texture.cpp',
-    'src/engine/manager/scene.cpp',
+    'src/engine/util/logging.cpp',
+    'src/engine/util/file.cpp',
+    'src/engine/resources/shader.cpp',
+    'src/engine/resources/texture.cpp',
+    'src/engine/resources/scene.cpp',
+    'src/engine/resources/mesh.cpp',
     'src/engine/render/overlay.cpp',
     'src/engine/render/frame_buffer.cpp',
+    'src/engine/resources/resource_manager.cpp',
 
     'src/game/game.cpp',
-    'src/game/camera.cpp',
+    'src/game/camera_utils.cpp',
+    'src/game/player.cpp',
     'src/game/skybox.cpp',
     'src/game/gui.cpp',
 ]
 
+
+bin2h = executable('bin2h', 'tools/bin2h.cpp')
+static_binaries = [
+    ['resources/static/error.png', 'error_png'],
+    ['resources/static/error.obj', 'error_obj'],
+    ['resources/static/error_shader.vert', 'error_shader_vert'],
+    ['resources/static/error_shader.frag', 'error_shader_frag'],
+]
+foreach binary : static_binaries
+    sources += custom_target(
+        'embed_binary_' + binary[1],
+        input: binary[0],
+        output: binary[1] + '.h',
+        command: [bin2h, '@INPUT@', '@OUTPUT@'],
+    )
+endforeach
+
+
 exe = executable(
     'lowlevelgame', sources,
-    # win_subsystem: 'windows',  # Supresses stdout on Windows
     include_directories : include_directories('src', 'include'),
     dependencies : dependencies,
     cpp_args : ['-std=c++23']
 )
-
 test('basic', exe)

release.ps1

@@ -1,2 +1,3 @@
 meson setup build/release --buildtype release --optimization=3
 meson compile -C build/release
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }

resources/assets/shaders/frag.frag

@@ -6,9 +6,11 @@ in vec3 Normal;
 in vec3 FragPos;
 
 struct Material {
-    sampler2D texture_diffuse;
-    sampler2D texture_specular;
-    float shininess;
+    sampler2D albedo_tex;
+    sampler2D normal_tex;
+    sampler2D roughness_tex;
+    sampler2D metallic_tex;
+    sampler2D ambientOcclusion_tex;
 };
 
 struct DirLight {
@@ -61,7 +63,7 @@ vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir);
 void main()
 {
     // TODO: Transparency blending
-    if (texture(material.texture_diffuse, TexCoord).a < 0.5)
+    if (texture(material.albedo_tex, TexCoord).a < 0.5)
         discard;
 
     vec3 norm = normalize(Normal);
@@ -84,11 +86,11 @@ vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
     float diff = max(dot(normal, lightDir), 0.0);
     // specular shading
     vec3 reflectDir = reflect(-lightDir, normal);
-    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 1); // material.shininess);
     // combine results
-    vec3 ambient = light.ambient * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 diffuse = light.diffuse * diff * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 specular = light.specular * spec * vec3(texture(material.texture_specular, TexCoord));
+    vec3 ambient = light.ambient * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 diffuse = light.diffuse * diff * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 specular = light.specular * spec * vec3(texture(material.roughness_tex, TexCoord));
     return (ambient + diffuse + specular);
 }
 
@@ -100,14 +102,14 @@ vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
     float diff = max(dot(normal, lightDir), 0.0);
     // specular shading
     vec3 reflectDir = reflect(-lightDir, normal);
-    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 1); // material.shininess);
     // attenuation
     float distance = length(light.position - fragPos);
     float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));
     // combine results
-    vec3 ambient = light.ambient * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 diffuse = light.diffuse * diff * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 specular = light.specular * spec * vec3(texture(material.texture_specular, TexCoord));
+    vec3 ambient = light.ambient * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 diffuse = light.diffuse * diff * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 specular = light.specular * spec * vec3(texture(material.roughness_tex, TexCoord));
     ambient *= attenuation;
     diffuse *= attenuation;
     specular *= attenuation;
@@ -122,7 +124,7 @@ vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
     float diff = max(dot(normal, lightDir), 0.0);
     // specular shading
     vec3 reflectDir = reflect(-lightDir, normal);
-    float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 1); // material.shininess);
     // attenuation
     float distance = length(light.position - fragPos);
     float attenuation = 1.0 / (light.constant + light.linear * distance + light.quadratic * (distance * distance));
@@ -131,9 +133,9 @@ vec3 CalcSpotLight(SpotLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
     float epsilon = light.cutOff - light.outerCutOff;
     float intensity = clamp((theta - light.outerCutOff) / epsilon, 0.0, 1.0);
     // combine results
-    vec3 ambient = light.ambient * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 diffuse = light.diffuse * diff * vec3(texture(material.texture_diffuse, TexCoord));
-    vec3 specular = light.specular * spec * vec3(texture(material.texture_specular, TexCoord));
+    vec3 ambient = light.ambient * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 diffuse = light.diffuse * diff * vec3(texture(material.albedo_tex, TexCoord));
+    vec3 specular = light.specular * spec * vec3(texture(material.roughness_tex, TexCoord));
     ambient *= attenuation * intensity;
     diffuse *= attenuation * intensity;
     specular *= attenuation * intensity;

resources/static/error_shader.frag

@@ -0,0 +1,16 @@
+#version 410 core
+out vec4 oFragColor;
+
+float hash(float x) {
+    return fract(sin(x) * 78657.11909);
+}
+
+void main()
+{
+    float id = float(gl_PrimitiveID);
+    float r = hash(id);
+    float g = hash(id+1);
+    float b = hash(id+2);
+    vec3 col = (vec3(r, g, b) - 0.5) * 0.75 + 0.5;
+    oFragColor = vec4(col, 1.0);
+}

resources/static/error_shader.vert

@@ -0,0 +1,14 @@
+#version 410 core
+
+in vec3 iPos;
+
+layout(std140) uniform Matrices
+{
+    mat4 projection;
+    mat4 view;
+};
+uniform mat4 model;
+
+void main() {
+    gl_Position = projection * view * vec4(vec3(model * vec4(iPos, 1.0)), 1.0);
+}

src/engine/game.h

@@ -1,16 +1,12 @@
-#ifndef GAME_H
-#define GAME_H
-#include "engine/run.h"
+#pragma once
 #include <SDL_events.h>
 
+bool setupGame();
+void shutdownGame();
 
-bool setupGame(StatePackage &statePackage, SDL_Window *sdlWindow, SDL_GLContext glContext);
-void shutdownGame(StatePackage &statePackage);
+bool renderUpdate(double deltaTime);
+bool fixedUpdate(double deltaTime);
 
-bool renderUpdate(double deltaTime, StatePackage &statePackage);
-bool fixedUpdate(double deltaTime, StatePackage &statePackage);
+bool handleEvent(const SDL_Event &event);
 
-bool handleEvent(const SDL_Event &event, StatePackage &statePackage);
 
-
-#endif //GAME_H