Improved lighting

.github/workflows/build.yml

@@ -62,7 +62,7 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with: 
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
           cache: ${{ env.USE_CACHE }}
 
       # This doesn't work when the Visual Studio C++ CLI was set up first (maybe needs a setup with 2019 version)
@@ -176,7 +176,7 @@ jobs:
           compression-level: 9
 
   linux-build:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     name: Build on Linux
     # Run both builds in parallel and don't cancel if one fails
     strategy:
@@ -206,7 +206,7 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with: 
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
           cache: ${{ env.USE_CACHE }}
 
       - name: Setup Ninja
@@ -225,8 +225,10 @@ jobs:
         shell: bash
         # Add additional scripting steps here
         run: |
-          sudo apt-get update
-          sudo apt-get install libgl1-mesa-dev
+          sudo apt update
+          sudo apt install libgl1-mesa-dev autoconf automake libtool pkg-config libltdl-dev g++-14 gcc-14 -y
+          sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-14 14
+          sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-14 14
           cd ${{ github.workspace }}
           ${{ github.workspace }}/vcpkg/vcpkg install --clean-after-build --triplet=x64-linux
           rm -r vcpkg_installed
@@ -337,7 +339,7 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with: 
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
           cache: ${{ env.USE_CACHE }}
 
       - name: Setup Ninja

.github/workflows/release.yml

@@ -31,7 +31,7 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with:
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
 
       - name: Delete MSVC tool version
         shell: pwsh
@@ -110,7 +110,7 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with:
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
 
       - name: Setup Ninja
         uses: ashutoshvarma/setup-ninja@master
@@ -178,7 +178,8 @@ jobs:
         uses: friendlyanon/setup-vcpkg@v1
         # Committish: The commit sha of the vcpkg repo, same as in vcpkg.json
         with: 
-          committish: 821100d967e1737d96414a308e3f7cbe0d1abf18
+          committish: a993be073c6baea8674117f3eaed6e2d2486aaae
+          cache: ${{ env.USE_CACHE }}
 
       - name: Setup Ninja
         uses: ashutoshvarma/setup-ninja@master

.gitignore

@@ -50,3 +50,7 @@ data/pirates
 data/meadow
 .vscode
 data/elven
+data/dungeon
+data/namaqualand
+data/quarry
+data/hiddenalley

CMakeLists.txt

@@ -8,11 +8,12 @@ if(COMMAND cmake_policy)
     cmake_policy(SET CMP0074 NEW)
     cmake_policy(SET CMP0011 NEW)
     cmake_policy(SET CMP0042 NEW)
+    cmake_policy(SET CMP0141 NEW)
 endif(COMMAND cmake_policy)
 
-cmake_minimum_required(VERSION 3.24)
+cmake_minimum_required(VERSION 3.25)
 
-project(AtlasEngine VERSION 0.2.0)
+project(AtlasEngine VERSION 0.2.1)
 
 # Only 64 bit is supported
 ###################################################################
@@ -31,13 +32,19 @@ option(ATLAS_ASSIMP "Activate Assimp integration" ON)
 option(ATLAS_HEADLESS "Activate support for running the engine in headless mode" OFF)
 option(ATLAS_BINDLESS "Activate support for running the engine with bindless resources turned on" ON)
 option(ATLAS_BUNDLE "Allows the applications to be bundled and installed on MacOS" OFF)
+option(ATLAS_MSVC_HOT_RELOAD "Configures all targets to be hot-reloadable" OFF)
 
 if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
     option(ATLAS_TESTS "Activate support for running the engine with bindless resources turned on" ON)
 else()
     option(ATLAS_TESTS "Activate support for running the engine with bindless resources turned on" OFF)
 endif()
 
+# Hot reloading in Windows, enabled for all targets
+if ((CMAKE_CXX_COMPILER_ID MATCHES "MSVC") AND ATLAS_MSVC_HOT_RELOAD)
+    set(CMAKE_MSVC_DEBUG_INFORMATION_FORMAT "$<$<CONFIG:Debug,RelWithDebInfo>:EditAndContinue>")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /INCREMENTAL:YES" )
+endif()
 
 if (ATLAS_DEMO)
     set (ATLAS_IMGUI ON)
@@ -49,13 +56,13 @@ if (ATLAS_EDITOR)
     set (ATLAS_IMGUI ON)
 endif()
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_BINARY_DIR ${CMAKE_CURRENT_SOURCE_DIR}/bin/${CMAKE_BUILD_TYPE})
 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
 
 if (CYGWIN OR MINGW)
-    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -O3 -std=gnu++20" )
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -O3 -std=gnu++23" )
 endif()
 
 if (ANDROID)
@@ -91,7 +98,7 @@ find_package(VulkanMemoryAllocator CONFIG REQUIRED)
 find_package(glslang CONFIG REQUIRED)
 find_package(SPIRV-Tools-opt CONFIG REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)
-find_package(unofficial-joltphysics CONFIG REQUIRED)
+find_package(Jolt CONFIG REQUIRED)
 find_package(Lua REQUIRED)
 find_package(sol2 CONFIG REQUIRED)
 

README.md

@@ -15,7 +15,7 @@ This is a cross platform toy engine developed in my spare time that is available
 >The current version (0.2.0) contains many API changes and is still an active WIP
 ## Requirements
 - Vulkan SDK
-- C++20 compatible compiler
+- C++23 compatible compiler
 - CMake
 - Vcpkg
 ## Set up

data/shader/bloom/bloomDownsample.csh

@@ -0,0 +1,112 @@
+layout (local_size_x = 16, local_size_y = 16) in;
+
+#include <../common/utility.hsh>
+#include <../common/types.hsh>
+#include <../common/flatten.hsh>
+
+layout (set = 3, binding = 0, rgba16f) writeonly uniform image2D textureOut;
+layout (set = 3, binding = 1) uniform sampler2D textureIn;
+
+layout(push_constant) uniform constants {
+    int mipLevel;
+    float threshold;
+} pushConstants;
+
+const uint supportSize = 2;
+const uint sharedDataSize = (2u * gl_WorkGroupSize.x + 2u * supportSize) * (2u * gl_WorkGroupSize.y + 2u * supportSize);
+const ivec2 unflattenedSharedDataSize = 2 * ivec2(gl_WorkGroupSize) + 2 * int(supportSize);
+
+shared vec3 sharedMemory[sharedDataSize];
+
+const ivec2 pixelOffsets[4] = ivec2[4](
+    ivec2(0, 0),
+    ivec2(1, 0),
+    ivec2(0, 1),
+    ivec2(1, 1)
+);
+
+AeF16 Luma(AeF16x3 color) {
+
+    const AeF16x3 luma = AeF16x3(0.299, 0.587, 0.114);
+    return dot(color, luma);
+
+}
+
+AeF16x3 Prefilter(AeF16x3 color) {
+
+    AeF16 brightness = Luma(color);
+	AeF16 contribution = max(AeF16(0.0), brightness - AeF16(pushConstants.threshold));
+    contribution /= max(brightness, AeF16(0.001));
+    return color * contribution;
+
+}
+
+
+AeF16x3 Sample(vec2 texCoord) {
+
+    if (pushConstants.mipLevel == 0) {
+        return Prefilter(AeF16x3(textureLod(textureIn, texCoord, float(pushConstants.mipLevel)).rgb));
+    }
+    else {
+        return AeF16x3(textureLod(textureIn, texCoord, float(pushConstants.mipLevel)).rgb);
+    }
+
+}
+
+void main() {
+
+    ivec2 size = imageSize(textureOut);
+    ivec2 coord = ivec2(gl_GlobalInvocationID);
+
+    if (coord.x < size.x && coord.y < size.y) {
+
+        // Lower mip tex coord 
+        vec2 texCoord = (coord + 0.5) / size;
+        // Upper mip texel size
+        vec2 texelSize = 1.0 / vec2(textureSize(textureIn, pushConstants.mipLevel));
+
+        // We always sample at pixel border, not centers
+        AeF16x3 outer00 = Sample(texCoord + vec2(-2.0 * texelSize.x, -2.0 * texelSize.y));
+        AeF16x3 outer10 = Sample(texCoord + vec2(0.0, -2.0 * texelSize.y));
+        AeF16x3 outer20 = Sample(texCoord + vec2(2.0 * texelSize.x, -2.0 * texelSize.y));
+
+        AeF16x3 outer01 = Sample(texCoord + vec2(-2.0 * texelSize.x, 0.0));
+        AeF16x3 outer11 = Sample(texCoord + vec2(0.0, 0.0));
+        AeF16x3 outer21 = Sample(texCoord + vec2(2.0 * texelSize.x, 0.0));
+
+        AeF16x3 outer02 = Sample(texCoord + vec2(-2.0 * texelSize.x, 2.0 * texelSize.y));
+        AeF16x3 outer12 = Sample(texCoord + vec2(0.0, 2.0 * texelSize.y));
+        AeF16x3 outer22 = Sample(texCoord + vec2(2.0 * texelSize.x, 2.0 * texelSize.y));
+
+        AeF16x3 inner00 = Sample(texCoord + vec2(-texelSize.x, -texelSize.y));
+        AeF16x3 inner10 = Sample(texCoord + vec2(texelSize.x, -texelSize.y));
+        AeF16x3 inner01 = Sample(texCoord + vec2(-texelSize.x, texelSize.y));
+        AeF16x3 inner11 = Sample(texCoord + vec2(texelSize.x, texelSize.y));
+
+        AeF16x3 outerGroup0 = AeF16(0.125 * 0.25) * (outer00 + outer10 + outer01 + outer11);
+        AeF16x3 outerGroup1 = AeF16(0.125 * 0.25) * (outer10 + outer20 + outer11 + outer21);
+        AeF16x3 outerGroup2 = AeF16(0.125 * 0.25) * (outer01 + outer11 + outer02 + outer12);
+        AeF16x3 outerGroup3 = AeF16(0.125 * 0.25) * (outer11 + outer21 + outer12 + outer22);
+        AeF16x3 innerGroup = AeF16(0.5 * 0.25) * (inner00 + inner10 + inner01 + inner11);
+
+        if (pushConstants.mipLevel == 0) {
+            AeF16 outerGroup0Weight = (AeF16(1.0) / (AeF16(1.0) + Luma(outerGroup0)));
+            AeF16 outerGroup1Weight = (AeF16(1.0) / (AeF16(1.0) + Luma(outerGroup1)));
+            AeF16 outerGroup2Weight = (AeF16(1.0) / (AeF16(1.0) + Luma(outerGroup2)));
+            AeF16 outerGroup3Weight = (AeF16(1.0) / (AeF16(1.0) + Luma(outerGroup3)));
+            AeF16 innerGroupWeight = (AeF16(1.0) / (AeF16(1.0) + Luma(innerGroup)));
+
+            outerGroup0 *= outerGroup0Weight;
+            outerGroup1 *= outerGroup1Weight;
+            outerGroup2 *= outerGroup2Weight;
+            outerGroup3 *= outerGroup3Weight;
+            innerGroup *= innerGroupWeight;
+        }
+
+        vec3 filtered = outerGroup0 + outerGroup1 + outerGroup2 + outerGroup3 + innerGroup;
+
+        imageStore(textureOut, coord, vec4(filtered, 1.0));
+
+    }
+
+}

data/shader/bloom/bloomUpsample.csh

@@ -0,0 +1,64 @@
+#include <../common/types.hsh>
+
+layout (local_size_x = 8, local_size_y = 8) in;
+
+layout (set = 3, binding = 0, rgba16f) writeonly uniform image2D textureOut;
+layout (set = 3, binding = 1) uniform sampler2D textureIn;
+
+layout(push_constant) uniform constants {
+    int additive;
+    int mipLevel;
+    float filterSize;
+} pushConstants;
+
+AeF16x3 Sample(vec2 texCoord) {
+
+    return AeF16x3(textureLod(textureIn, texCoord, float(pushConstants.mipLevel)).rgb);
+
+}
+
+void main() {
+
+    ivec2 size = imageSize(textureOut);
+    ivec2 coord = ivec2(gl_GlobalInvocationID);
+
+    if (coord.x < size.x &&
+        coord.y < size.y) {
+
+        // Lower mip tex coord 
+        vec2 texCoord = (coord + 0.5) / size;
+        // Upper mip texel size
+        vec2 texelSize = 1.0 / textureSize(textureIn, pushConstants.mipLevel);
+        vec2 filterSize = vec2(pushConstants.filterSize);
+        texelSize = max(filterSize, filterSize);
+
+        // We always sample at pixel border, not centers
+        AeF16x3 filter00 = Sample(texCoord + vec2(-texelSize.x, -texelSize.y));
+        AeF16x3 filter10 = Sample(texCoord + vec2(0.0, -texelSize.y));
+        AeF16x3 filter20 = Sample(texCoord + vec2(texelSize.x, -texelSize.y));
+
+        AeF16x3 filter01 = Sample(texCoord + vec2(-texelSize.x, 0.0));
+        AeF16x3 filter11 = Sample(texCoord + vec2(0.0, 0.0));
+        AeF16x3 filter21 = Sample(texCoord + vec2(texelSize.x, 0.0));
+
+        AeF16x3 filter02 = Sample(texCoord + vec2(-texelSize.x, texelSize.y));
+        AeF16x3 filter12 = Sample(texCoord + vec2(0.0, texelSize.y));
+        AeF16x3 filter22 = Sample(texCoord + vec2(texelSize.x, texelSize.y));
+
+        AeF16x3 filtered = AeF16x3(0.0);
+
+        filtered += AeF16(4.0) * filter11;
+        filtered += AeF16(2.0) * (filter10 + filter01 + filter21 + filter12);
+        filtered += AeF16(1.0) * (filter00 + filter20 + filter02 + filter22);
+        filtered /= AeF16(16.0);
+
+        if (pushConstants.additive > 0) {
+            imageStore(textureOut, coord, vec4(filtered + filter11, 1.0));
+        }
+        else {
+            imageStore(textureOut, coord, vec4(filtered, 1.0));
+        }
+
+    }
+
+}

data/shader/clouds/clouds.hsh

@@ -1,12 +1,12 @@
 #include <../common/utility.hsh>
-#include <../structures>
+#include <../structures.hsh>
 
 layout(set = 3, binding = 1) uniform sampler2D depthTexture;
 layout(set = 3, binding = 2) uniform sampler3D shapeTexture;
 layout(set = 3, binding = 3) uniform sampler3D detailTexture;
 layout(set = 3, binding = 4) uniform sampler2D coverageTexture;
 
-layout(set = 1, binding = 10) uniform samplerCube diffuseProbe;
+layout(set = 1, binding = 12) uniform samplerCube diffuseProbe;
 
 layout(std140, set = 3, binding = 5) uniform CloudUniformBuffer {
     Light light;

data/shader/clouds/integrate.csh

@@ -1,5 +1,5 @@
 #include <../globals.hsh>
-#include <../structures>
+#include <../structures.hsh>
 #include <../common/stencil.hsh>
 #include <../common/convert.hsh>
 #include <../common/utility.hsh>