SIByLEngine
is a personal toy game engine by @SuikaSibyl. I am planning to keep working on it for a long time and implement lots of realtime & offline effects in it.
Previous version could be find in: SibylEngine2021. Version 2023 is a complete refactoring including better and more extendable structure, solution, design.
Only support Windows platform and MSVC compiler for now.
Either directly open SIByLEngine.sln
with VisualStudio 2022
on Windows, or use any CMake tools to open the CMake project (Visual Studio open Folder / vscode / CLion etc.).
By default, Nvidia GPU with Turing or higher architecture is required to correctly run the engine, as vulkan hardware raytracing is defaultly used. In the future, better compatibility with CPU raytracing fallback might be supported. If no corresponding GPU exists, compilation should still be successful, but you should manually turn off ray-tracing-related features to run it without fatal error.
-
NOT Use C++ 20 Module
for the all the modules. Although I had previously used it extensively and found it to be a great feature. Despite MSVC's support for the feature, compilation is not always stable, sometimes resulting in weird 'internal error' messages that force the process to be abandoned. Moreover, as the project grows, both IntelliSense and ReSharper struggle to provide proper code highlighting and intelligent code completions, which makes coding extremely painful. Also, analysising the project eat up all the memory quickly and get the IDE and compiler super slow... Given these challenges, I have opted to deprecate the feature. -
Only Support Vulkan Backend
for RHI module. It seems that there are some API logistic differences between Vulkan / OpenGL / DirectX. But the main reason is probably simply because I am too lazy to implement and test for all the backends for now. As Vulkan is supporting most of the features exists, I find no good reason to support other backends at this stage. -
Use Render Graph
to manage GPU pipeline. The main motivation is that Vulkan is too verbose about memory barriers. Render graph helps me to support automatic barrier insertion (within the graph) and resource management. It may also be a good idea to do automatic barrier insertion at a lower layer like RHI, which may be helpful to support a more flexible pipeline, but I am not sure with that for now.
-
- SE.Core.Log: Log print system from scratch.
- SE.Core.Memory: Memory management system from scratch (experimental).
- SE.Core.ECS: ECS system from scratch (experimental).
- SE.Core.Resource: Resource management system from scratch (experimental).
- SE.Math: Basic math computation library from scratch with SIMD acceleration.
-
- SE.RHI Module: Abstract layer with
WebGPU
-style API supportingVulkan
backend. - SE.Tracer:
CPU ray tracing
implementation based on PBRT v3 (GPU
implementation seeSE.SRenderer
) - SE.Image:
Image
loader/storer for various format. - SE.Video:
Video
loader/storer for various format, decoding viaffmpeg
. - SE.GFX: Higher-Level infrastructure on top pf
SE.RHI
- Defining
scene
, with many basiccomponent
s andresource
s. - Providing
serializing
&deserializing
viayaml-cpp
.
- Defining
- SE.RDG:
Render Dependency Graph
System (experimental).Pass
: rhi-pipeline-level (rasterize/fullscreen/compute/raytrace) atomic node in graph, with automatic pipeline and resource binding layouts creation viaspirv-cross
reflection of SPIR-V shaders.Graph
: a directed acyclic graph ofPass
es, automatic resource management and barrier insertion.Pipeline
: a interface enabling cross-frame switching between multipleGraph
s.
- SE.SRenderer: Retained mode renderer based on SE.RDG
Retained mode rendering
infrastructure for both rasterization and ray tracing- Providing lots of
RDG Pass/Graph/Pipeline
algorithm implementation.
- SE.RHI Module: Abstract layer with
-
- // TODO.
-
Editor_Core module
: ImGui-Vulkan interoperate and extensible GUI framework.Editor_GFX module
: Provides many editor widgets for SIByL Engine.Editor_RDG module
: Provides DebugDraw system via RDG and RDG Viewer (no RDG editor yet).
Interactive GPU implementation of BDPT (left)
[code] and MMLT (right)
[code]
Axis-Aligned Filtering for soft shadow (left)
[code] and and global illumination
[code]
(aliasing is caused by gif compression)
2D FLIP Fluid Simulation
[code]
3D tetrahedral elastic body simlation
[code]
Vulkan tiny-MLP writen by
Differentiable Slang
with glsl WMMA
Calling Vulkan functionality in PyTorch in
[SE2024]
! A simple differentiable rendering demo is shown.
-
Triangle Intersection Offset
: A Fast and Robust Method for Avoiding Self-IntersectionSphere Intersection Query
: Precision Improvements for Ray/Sphere IntersectionSpherical Rectangle Sampling
: An Area-Preserving Parametrization for Spherical Rectangles
-
Lambertian BSDF
: Photometria, sive De mensura et gradibus luminus, colorum et umbraeRoughPlastic & Dielectric BSDF
: Average irregularity representation of a rough surface for ray reflectionDisney Principled BSDF
: Physically Based Shading at DisneyImportance Sampling of GGX Microfacet Model
: Sampling the GGX Distribution of Visible Normals
-
Unidirectional Path Tracing with MIS
: Robust - Veach's Thesis [Chapter 9 - Multiple Importance Sampling]Bidirectional Path Tracing
: Robust - Veach's Thesis [Chapter 10 - Bidirectional Path Tracing]Multiplexed Metropolis Light Transport
: Multiplexed Metropolis Light TransportLight Tracing as VPL
: [wiki page] | Instant Radiosity
-
Screen-Space Path Guiding
: Real-Time Path-Guiding Based on Parametric Mixture ModelsNeural Importance Sampling (modified)
: [project page] | Neural Importance SamplingReSTIR GI (Global Illumination)
: ReSTIR GI: Path Resampling for Real-Time Path Tracing
-
Real-time Stochastic Lightcuts
: wiki page | Real-Time Stochastic LightcutsReSTIR DI (Direct Lighting)
: ------- Under development -------
-
- Realtime Local Frequency Analysis Based Approaches [project page]
- Spatial-Temporal Reuse Based Approaches With Moment Estimation [wiki page]
SVGF Denoiser
: SVGF: Real-Time Reconstruction for Path-Traced Global IlluminationA-SVGF Denoiser
: Gradient Estimation for Real-Time Adaptive Temporal Filtering
-
Voxel Global Illumination
: Deferred voxel shading for real-time global illuminationRealtime Voxelization Based on Rasterization
: The Basics of GPU Voxelization
Stochastic Substitute Tree
: Stochastic Substitute Trees for Real-Time Global IlluminationScreen Space Reflection / Global Illumination
: Stochastic Screen Space ReflectionsDDGI
: ------- Under development -------
-
- Shadow Mapping Casting curved shadows on curved surfaces
Cascaded Shadow Maps
: Cascaded Shadow MapsPercentage-Closer Filtering
: GPU Gems [Chapter 11. Shadow Map Antialiasing]
- Shadow Mapping Casting curved shadows on curved surfaces
-
- Parallel Sorting Algorithms on GPU
Parallel Bitonic Sort
: GPU Gem 2 [Chapter 46. Improved GPU Sorting]A Faster Parallel Radix Sort
: A Faster Radix Sort Implementation
- Screen Space Passes and Computer Vision Processing
G-Buffer
: Comprehensible rendering of 3-D shapesV-Buffer
: The Visibility Buffer: A Cache-Friendly Approach to Deferred ShadinggSLICr Superpixel Segmentation
: gSLICr: SLIC superpixels at over 250Hz
- Parallel Sorting Algorithms on GPU
dear_imgui
: Bloat-free Graphical User interface for C++ with minimal dependenciesffmpeg
: A complete, cross-platform solution to record, convert and stream audio and video.glad
: Multi-Language Vulkan/GL/GLES/EGL/GLX/WGL Loader-Generator based on the official specs.glfw
: A multi-platform library for OpenGL, OpenGL ES, Vulkan, window and input.slang
: Making it easier to work with shaders.spirv-cross
: A practical tool and library for performing reflection on SPIR-V and disassembling SPIR-V back to high level languages.stb
: stb single-file public domain libraries for C/C++tinygltf
: Header only C++11 tiny glTF 2.0 librarytinyobjloader
: Tiny but powerful single file wavefront obj loadervma
: Easy to integrate Vulkan memory allocation libraryvulkan
: A low-overhead, cross-platform API, open standard for 3D graphics and computingyaml-cpp
: A YAML parser and emitter in C++
I learned a lot from various renderers to build up this engine, here are some great references for those who might be interested.
- PBRT: Rendering bible.
- Lajolla Renderer: Well-written offline renderer, learned so much from it.
- Hazel Engine: Fancy usage of ImGui editor and good tutorial on engine development.
- Falcor: Easy to use, I especially imitate its RDG interface.
- Unreal Engine: Needless to say.
- Unity: The most commonly used engine for me, I am deeply influenced in many ways.