tippesi/atlas-engine

Cross platform toy render engine supporting physically based rendering and hardware/software ray tracing

Atlas Engine

Realtime Sponza scene with raytraced GI, AO and reflections (model from Intel Graphics Research Sample Library)

Introduction

This is a cross platform toy engine developed in my spare time that is available on Linux, Windows and MacOS.

Note: The current version (0.2.0) contains many API changes and is still an active WIP

Requirements

• Vulkan SDK
• C++20 compatible compiler
• CMake
• Vcpkg

Set up

Dependencies are managed through vcpkg. You can either install the packages manually or while doing the build configuration with CMake. To use vcpkg together with CMake follow the steps described here.

Compiling the demo application

Run CMake with the option ATLAS_DEMO=ON to include the demo application in the project. For easier use, the vsbuild.bat does exactly that and launches Visual Studio afterwards. After launching the IDE, set AtlasEngineDemo as your target.

Including the library into your own project

It is possible to compile the engine either as a shared or static library. Set the ATLAS_BUILD_SHARED option accordingly. To make the library work with its dependencies, the root CMakeLists.txt of this repository has to be added as a subdirectory. As an entry point to create an application from scratch take a look at the Hello World tutorial. For reference, the source folder contains an empty app header and an empty app source.

CMake build options

• ATLAS_BUILD_SHARED Force project to be build as a shared library
• ATLAS_EXPORT_MAIN Export the main file to be added as executable to parent project (only if main function cannot be found)
• ATLAS_NO_APP Disables the engines main function and app functionality. You have to code the main function and initialize the engine yourself
• ATLAS_IMGUI Enables the ImGui integration. Is enabled by default if the demo project is build.
• ATLAS_ASSIMP Enables the Assimp integration. Is enabled by default.
• ATLAS_HEADLESS Enables the headless support, which means no window needs to be created. Is disabled by default.
• ATLAS_BINDLESS Enables support for bindless resources. Might be problematic on MacOS. Enabled by default.
• ATLAS_TESTS Generates the testing project and allows to target it.

Documentation

If you want more information have a look into the Documentation.

License

The source code is licensed under the MIT license. The copyright notices of the dependencies can be found in the LICENSE.md file in the dependency directory.

Note: The files in the data folder (except the shaders) use a different license.

Code Example

For a code example have a look at the demo application.

Latest executables

The latest non-release executables can be found in the latest run of the build pipeline. They contain both the demo application and the editor.

Screenshots

Sponza demo scene opened in the editor Rasterized image using real time global illumination Path traced scene Island demo scene using the terrain and ocean systems

atlas-engine's Issues

Shader compile issue: #extension directives shouldn't be in the middle of the shader

The shader compiler needs to take care of includes which might have extensions declared. For an example have a look into the shadow.hsh. Additionally constants might land in front of these extensions due to the processing in the shader compiler

Please support MSYS2 MINGW64

Currently, cmake configuration failed with:

$ cmake ..
-- Building for: Ninja
CMake Warning (dev) at CMakeLists.txt:13 (project):
  cmake_minimum_required() should be called prior to this top-level project()
  call.  Please see the cmake-commands(7) manual for usage documentation of
  both commands.
This warning is for project developers.  Use -Wno-dev to suppress it.

-- The C compiler identification is GNU 12.2.0
-- The CXX compiler identification is GNU 12.2.0
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Check for working C compiler: C:/msys64/mingw64/bin/cc.exe - skipped
-- Detecting C compile features
-- Detecting C compile features - done
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Check for working CXX compiler: C:/msys64/mingw64/bin/c++.exe - skipped
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Found OpenGL: opengl32
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD
-- Performing Test CMAKE_HAVE_LIBC_PTHREAD - Success
-- Found Threads: TRUE
CMake Error at CMakeLists.txt:81 (find_package):
  Could not find a package configuration file provided by "volk" with any of
  the following names:

    volkConfig.cmake
    volk-config.cmake

  Add the installation prefix of "volk" to CMAKE_PREFIX_PATH or set
  "volk_DIR" to a directory containing one of the above files.  If "volk"
  provides a separate development package or SDK, be sure it has been
  installed.


-- Configuring incomplete, errors occurred!

Discrepancy between DDGI and pathtracer in regards to lighting intensity

There seems to be an energy loss when using DDGI. Further investigation is required

Workaround for NDK issue

https://github.com/android-ndk/ndk/issues/929

Link failed when I use MINGW64.

MSYS MINGW64 compiling AtlasEngine under Windows 11:

1. ffx_fsr2.cpp, std::size need #include
2. ShaderLoader.cpp, std::find need #include
3. Popup.h, int32_t need #include <stdint.h>

When I solve the above three problems, I can compile successfully, but there is an error during the linking process.

AtlasEngineEditor.dir/App.cpp.obj: in function `Atlas::Editor::App::SetupMainDockspace(unsigned int)':
Atlas-Engine/src/editor/App.cpp:320:(.text+0x9c6): undefined reference to `ImGui::SetWindowSize(ImVec2 const&, int)'


C:/Software/MSYS2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: C:/Codes/GraphicsProj/Atlas-Engine/src/editor/App.cpp:321:(.text+0x9dc): undefined reference to `ImGui::SetWindowPos(ImVec2 const&, int)'
C:/Software/MSYS2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: C:/Codes/GraphicsProj/Atlas-Engine/src/editor/App.cpp:323:(.text+0x9e3): undefined reference to `ImGui::DockBuilderRemoveNode(unsigned int)'
C:/Software/MSYS2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: C:/Codes/GraphicsProj/Atlas-Engine/src/editor/App.cpp:324:(.text+0x9ec): undefined reference to `ImGui::DockBuilderAddNode(unsigned int, int)'
C:/Software/MSYS2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: C:/Codes/GraphicsProj/Atlas-Engine/src/editor/App.cpp:327:(.text+0xa0f): undefined reference to `ImGui::DockBuilderSplitNode(unsigned int, int, float, unsigned int*, unsigned int*)'
C:/Software/MSYS2/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/13.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: C:/Codes/GraphicsProj/Atlas-Engine/src/editor/App.cpp:330:(.text+0xa40): undefined reference to `ImGui::DockBuilderDockWindow(char const*, unsigned int)'

....

Link failed.

Jolt.lib(JobSystemThreadPool.cpp.obj) : error LNK2019: unresolved external symbol _Thrd_sleep_for referenced in function 
"void __cdecl std::this_thread::sleep_until<struct std::chrono::steady_clock,class std::chrono::duration<__int64,struct std::ratio<1,1000000000>>>(class std::chrono::time_point<struct std::chrono::steady_clock,class std::chrono::duration<__int64,struct std::ratio<1,1000000000>>> const & ...

IDE :CLion, Compiler: MSVC, OS:Windows11,

Font Rendering: Some characters are too close or too far apart

Examples of this issue:

• Characters following on "j" are too close to the j
• Characters following on "1" are too far away from the 1

Low shadow bias makes cascade seams visible

Calculate a bias for every cascade taking the area of the shadow map into account

Some surfaces don't seem to be lit correctly in the path tracer

Issue is visible with a low amount of bounces (1). Might be the normals or the new ray directions/origin generated for the indirect lighting.

Software raytracing breaks down in emerald square scene

Keyboard Text Editing Support missing

You are unable to retrieve characters that are dependent on multiple keys being pressed.
E.g. (On qwertz keyboard layout) ! is achieved by pressing Shift and 1.

Inquiry on Just a Deferred Rendering Implementation Without Ray Tracing or DDGI power by Atlas-Engine.

Dear Simon,

I am reaching out to ensure that my previous email reached you.

I've decided to create a new issue here so that others may also benefit from the discussion of this topic.

Thank you for your attention, and I look forward to your guidance.

Seams between cascades visible on Nvidia cards

There are also issues on geometry edges where a low resolution shadow map leads to incorrect results. Only happens when the filtering is set to GL_LINEAR and hardware pcf is used.