SuikaSibyl / SIByLEngine2023

SIByLEngine 2023.1

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.

Builds

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.

Design Decisions

• 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.

Modules

• Core Modules

  • 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.

• Rendering Modules

  • SE.RHI Module: Abstract layer with WebGPU-style API supporting Vulkan backend.
  • SE.Tracer: CPU ray tracing implementation based on PBRT v3 (GPU implementation see SE.SRenderer)
  • SE.Image: Image loader/storer for various format.
  • SE.Video: Video loader/storer for various format, decoding via ffmpeg.
  • SE.GFX: Higher-Level infrastructure on top pf SE.RHI
    • Defining scene, with many basic components and resources.
    • Providing serializing & deserializing via yaml-cpp.
  • 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 via spirv-cross reflection of SPIR-V shaders.
    • Graph: a directed acyclic graph of Passes, automatic resource management and barrier insertion.
    • Pipeline: a interface enabling cross-frame switching between multiple Graphs.
  • 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.

• Physics

  • // TODO.

• Editor

  • 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).

Demo Gallery

 
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.

Selected Feature List

• Primitive Intersection and Sampling

  • Triangle Intersection Offset: A Fast and Robust Method for Avoiding Self-Intersection
  • Sphere Intersection Query: Precision Improvements for Ray/Sphere Intersection
  • Spherical Rectangle Sampling: An Area-Preserving Parametrization for Spherical Rectangles

• Material Models and BSDF Sampling

  • Lambertian BSDF: Photometria, sive De mensura et gradibus luminus, colorum et umbrae
  • RoughPlastic & Dielectric BSDF: Average irregularity representation of a rough surface for ray reflection
  • Disney Principled BSDF: Physically Based Shading at Disney
  • Importance Sampling of GGX Microfacet Model: Sampling the GGX Distribution of Visible Normals

• Various Formulations of Light Transport

  • 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 Transport
  • Light Tracing as VPL: [wiki page] | Instant Radiosity

• Importance Sampling for Efficient Light Transport

  • Screen-Space Path Guiding: Real-Time Path-Guiding Based on Parametric Mixture Models
  • Neural Importance Sampling (modified): [project page] | Neural Importance Sampling
  • ReSTIR GI (Global Illumination): ReSTIR GI: Path Resampling for Real-Time Path Tracing

• Efficient Many Lights Sampling

  • Real-time Stochastic Lightcuts: wiki page | Real-Time Stochastic Lightcuts
  • ReSTIR DI (Direct Lighting): ------- Under development -------

• Denoiser For Noisy Path Traced Image

  • Realtime Local Frequency Analysis Based Approaches [project page]
    • AAF Softshadow: Axis-Aligned Filtering for Interactive Sampled Soft Shadows
    • AAF GI: Axis-Aligned Filtering for Interactive Physically-Based Diffuse Indirect Lighting
    • MAAF Combined Effects: Multiple Axis-Aligned Filters for Rendering of Combined Distribution Effects
  • Spatial-Temporal Reuse Based Approaches With Moment Estimation [wiki page]
    • SVGF Denoiser: SVGF: Real-Time Reconstruction for Path-Traced Global Illumination
    • A-SVGF Denoiser: Gradient Estimation for Real-Time Adaptive Temporal Filtering

• Biased Global Illumination with Approximation

  • Voxel Global Illumination: Deferred voxel shading for real-time global illumination
    • Realtime Voxelization Based on Rasterization: The Basics of GPU Voxelization
  • Stochastic Substitute Tree: Stochastic Substitute Trees for Real-Time Global Illumination
  • Screen Space Reflection / Global Illumination: Stochastic Screen Space Reflections
  • DDGI: ------- Under development -------

• Rasterizer-Specific Rendering Algorithms

  • Shadow Mapping Casting curved shadows on curved surfaces
    • Cascaded Shadow Maps: Cascaded Shadow Maps
    • Percentage-Closer Filtering: GPU Gems [Chapter 11. Shadow Map Antialiasing]

• Miscellaneous Utils as GPU Parallel Computing

  • 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 shapes
    • V-Buffer: The Visibility Buffer: A Cache-Friendly Approach to Deferred Shading
    • gSLICr Superpixel Segmentation: gSLICr: SLIC superpixels at over 250Hz

Dependencies

• dear_imgui: Bloat-free Graphical User interface for C++ with minimal dependencies
• ffmpeg: 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 library
• tinyobjloader: Tiny but powerful single file wavefront obj loader
• vma: Easy to integrate Vulkan memory allocation library
• vulkan: A low-overhead, cross-platform API, open standard for 3D graphics and computing
• yaml-cpp: A YAML parser and emitter in C++

References

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.