Focal Engine is an open-source, modular real-time 3D rendering and game engine designed for building interactive 3D applications, games, and scientific visualizations. It excels at handling complex geospatial data and GPU-driven rendering, empowering developers and researchers to create sophisticated graphical solutions efficiently.
- Focal Engine Ecosystem
- Projects Using Focal Engine
- Features
- Editor
- Build and Setup
- Testing
- Example Application
- Third-Party Licenses
The Focal Engine project consists of four modular components that work together to provide a complete development environment:
Basic Application Module - A foundation layer for OpenGL and ImGui applications that provides essential utilities including time measurement, thread pooling, logging, TCP networking, and profiling capabilities.
Visual Node System - A framework for creating visual node-based interfaces with features like zoom, reroute nodes, group comments, and JSON serialization, ideal for material editors and visual scripting.
Focal Engine (this repository) - The engine with all core functionality.
Focal Engine Editor - A comprehensive editor for the engine.
This modularity makes it easier to include just the engine in applications that don't need the editor's complexity. It also simplifies the implementation of export functionality in the editor, allowing users to compile their projects into standalone executable applications with all necessary resources.
HabiCAT 3D - An open-source software that implements novel algorithms for generating multi-scale complexity metrics maps(like rugosity, fractal dimension, vector dispersion and others) for complex 3D habitat models.
- Physically-based rendering
- High dynamic range (HDR) rendering internally
- Gamma correction
- Deferred shading
- Screen-Space Ambient Occlusion (SSAO)
- Cascaded soft shadows
- Sky with atmospheric scattering
- Compressed textures support with multi-threaded loading
- Fast Approximate Anti-Aliasing (FXAA)
- Dynamic render scale adjustment
- Camera temporal jitter and partial motion vector calculations, needed for future TAA and third-party upscalers
- Each camera has its own unique rendering pipeline with customizable settings
The Focal Engine provides specialized capabilities for working with large-scale point cloud data:
-
LAS/LAZ File Format Support
⚠️ Work in progress⚠️ -
High-Performance Rendering: Support for real-time visualization of massive point clouds (hundreds of millions to billions of points)
⚠️ Work in progress⚠️ -
GPU-Accelerated Editing: Tools for manipulating and editing huge point clouds directly in GPU memory
⚠️ Work in progress⚠️
- Chunked terrain with tessellation for LOD
- Frustum culling of sub chunks
- Up to 8 terrain layer materials
- Each layer can define foliage spawn rules
The Focal Engine leverages OpenXR integration to provide support for a wide range of VR headsets and controllers. The engine has a virtual UI system specifically designed for comfortable and intuitive interaction in VR space.
Focal Engine employs EnTT ECS for optimized performance and flexible architecture. Easily compose entities from modular components, enabling scalable and maintainable code.
Easily define reusable entities or groups of entities as Prefabs. Prefabs encapsulate entities and their component configurations as scenes, allowing you to instantiate complex object setups multiple times efficiently. Prefabs simplify asset management and accelerate level design.
Attach custom scripts directly to entities for rapid prototyping, modular gameplay logic, and efficient runtime performance.
Focal Engine features a GPU-driven rendering pipeline (
Engine submodule includes a profiling system that provides detailed analysis of CPU utilization across threads. This system is designed to handle complex, highly multithreaded workloads, allowing to identify and address performance bottlenecks.
The Focal Engine Editor provides project management capabilities through its project browser window:
The editor interface includes several key windows:
- Scene Entities: Displays entities in a hierarchical graph structure.
- Scene/Scenes: Supports multiple scene windows simultaneously. Prefabs are handled as simplified scenes for modular design.
- Inspector: Provides list of components of the selected entity for viewing and editing.
- Content Browser: Serves as an explorer for the project's virtual file system with structured access to all resources.
- Editor Cameras: Provides settings for editor-specific cameras. While game cameras (entities with camera components) are only functional in game mode, editor cameras allow navigation through scenes even when no game camera is present.
- Log Window: Displays filtered categories of warnings, errors, and informational messages for debugging.
Standard editor layout:
The Material Editor employs the Visual Node System to enhance editing intuitiveness.
Terrain editing is facilitated with different brushes (sculpt, smooth, paint layers). Each terrain can support up to eight material layers, with each layer capable of enforcing the type of foliage that can spawn on it.
The Focal Engine Editor includes functionality to compile projects into standalone executable (.exe) files, along with packaged resource files containing all necessary scripts, assets, and resources. This allows for easy distribution of completed applications without requiring the editor or engine development environment.
Users can edit shaders on-the-fly in the built-in shader editor and debug compilation errors:
In addition, the editor supports real-time retrieval of shader variable values from the GPU. (Please note that not all variables are supported and further testing is needed for this feature.)
During the development of the engine and its tools, inadequate testing was identified as a source of setbacks. To address this, a multi-layered testing approach has been implemented:
-
Continuous Integration - GitHub Actions run on every push as a sanity check to ensure the engine compiles successfully.
-
Unit Testing - Using Google Test framework to verify individual components. Currently limited to scene graph testing, with plans to expand coverage to more subsystems over time.
-
Visual Testing Platform - Due to the graphical nature of the engine, unit tests and GitHub Actions are insufficient for comprehensive testing. A specialized testing platform is being developed that will evaluate the engine's visual output and UI functionality.
This comprehensive testing strategy will enable more confident feature iteration and establish a proper regression testing pipeline.
# Initialize a new Git repository
git init
# Add the remote repository
git remote add origin https://github.com/Azzinoth/FocalEngine
# Pull the contents of the remote repository
git pull origin master
# Initialize and update submodules
git submodule update --init --recursive
# Generate the build files using CMake
# Will work in Windows PowerShell
cmake CMakeLists.txtAn example of a simple application that integrates the Engine: Example.
This project uses the following third-party libraries:
-
GLM: This library is licensed under a permissive open-source license, similar to the MIT license. The full license text can be found at GLM's GitHub repository.
-
jsoncpp: This library is licensed under the MIT License. The full license text can be found at jsoncpp's GitHub repository.
-
lodepng: This library is licensed under the zlib License. The full license text can be found at lodepng's GitHub repository.
-
stb: This library is licensed under the MIT License. The full license text can be found at stb's GitHub repository.
-
OpenXR: This library is licensed under Apache 2.0 License. The full license text can be found at OpenXR's GitHub repository.
-
googletest: This library is under the BSD-3-Clause license. The full license text can be found at googletest's GitHub repository.
-
EnTT: This library is under the MIT License. The full license text can be found at EnTT's GitHub repository.