OloEngine

OloEngine is primarily an early-stage cross-platform (Windows and Linux) interactive application and rendering engine based on Hazel.

Screenshots

3D Physics Integration

Animated Models

PBR Material Rendering

Getting Started

Supported platforms: Windows (Visual Studio 2026 via the default msvc preset; Visual Studio 2022 also supported via scripts/Win-GenerateProjectVS2022.bat), Linux (GCC 14+). WSL can compile all targets and run OloServer, but OloEditor requires a native OpenGL 4.6 GPU (WSL2's software renderer only supports OpenGL 4.5).

Requirements:

• Python 3.10+, with the 'jinja2' package installed (needed for building glad2)
• CMake 4.2+ (required by CMakePresets.json; the root CMakeLists.txt itself only requires 3.25, so plain cmake -B build -G "Visual Studio 17 2022" still works without presets)
• Vulkan SDK (for SPIR-V shader compilation)

You can clone the repository to a local destination using git:

git clone https://github.com/drsnuggles8/OloEngineBase

This project uses CMake to build the project's solution files. The scripts/ directory contains Win-GenerateProjectVS2022.bat and Win-GenerateProjectVS2026.bat helpers.

Visual Studio Code Users: The project includes predefined VS Code tasks for building and running. Use tasks like build-oloeditor-debug, run-oloeditor-release, etc. from the Command Palette (Ctrl+Shift+P → "Tasks: Run Task").

CLion Users: Open the OloEngineBase folder, let CLion initialize the CMake project, then edit the run configurations by changing the working directory of the OloEditor application to be the OloEditor folder.

CMake downloads all dependencies via FetchContent and CPM (CMake Package Manager) and stores them in the OloEngine/vendor/ directory. CMake will also create the build/ directory, which contains the Visual Studio solution files.

Current Features

Core Engine

• Entity-Component-System (ECS): Built on EnTT for high-performance entity management
• Multi-threaded Asset System: Async loading with hot-reload support via filewatch
• Dual Scripting Support: C# scripting via Mono integration + Lua scripting via Sol2
• Comprehensive Serialization: YAML-based scene and entity serialization
• Advanced Memory Management: Custom allocators and RAII resource management

Rendering

• OpenGL-based Renderer: Modern OpenGL 4.6 with SPIR-V shader compilation
• Physically-Based Rendering (PBR): Advanced material system with metallic-roughness workflow
• Multi-threaded Command Queue: Stateless, layered rendering architecture based on Molecular Matters' design
• 2D/3D Rendering Support: Unified pipeline for both 2D sprites and 3D models
• Animated Models: Skeletal animation system with Assimp integration

Physics

• 3D Physics: Jolt Physics integration for rigid body dynamics
• 2D Physics: Box2D integration for 2D game mechanics
• Custom Collision Layers: Flexible collision filtering and detection

Editor & Tools

• Full-Featured Editor: ImGui-based editor with scene hierarchy and content browser
• Visual Scene Editing: Gizmos, transform tools, and real-time scene manipulation
• Asset Management: Comprehensive asset browser with drag-and-drop functionality
• Profiling & Debugging: Tracy profiler integration with custom renderer profilers
• Memory Tracking: Real-time GPU/CPU memory usage visualization

Audio

• 3D Audio System: Miniaudio-based with spatial audio support
• Audio Components: Source and listener components for ECS integration

UI System

• ECS-Based UI: 16 widget component types (Canvas, RectTransform, ResolvedRect, Panel, Text, Image, Button, Slider, Checkbox, Toggle, Progress Bar, Input Field, Dropdown, Scroll View, Grid Layout, WorldAnchor)
• Anchor Layout: RectTransform-style anchoring, pivot, and auto-layout via grid containers
• Editor Integration: "Create UI" context menu, per-component property panels, editor-time preview in both 2D and 3D modes
• Scripting Support: Full C# (Mono) and Lua (Sol2) bindings for all UI components

Future Features

• Advanced lighting (global illumination, ray tracing)
• Scripting debugger and hot-reload
• GPU-driven particle compute pipeline
• Expanded post-processing pipeline (motion blur, additional AA modes)

Dependencies

All dependencies are automatically fetched via FetchContent and CPM (CMake Package Manager — CPM hosts Sol2, choc, nlohmann/json, ImGui, and ImGuizmo; FetchContent hosts the rest) and stored in OloEngine/vendor/:

Core Libraries

• entt - Fast and reliable entity-component system (ECS)
• glm - OpenGL Mathematics library for graphics transformations
• spdlog - Fast C++ logging library
• yaml-cpp - YAML parser and emitter for serialization
• nlohmann/json - JSON parsing used for tools and IPC
• choc - Header-only C++ utility library (audio, threading, etc.)
• atomic_queue - Lock-free MPMC queue
• meshoptimizer - Mesh simplification and indexing

Rendering & Graphics

• glad - OpenGL loader and meta loader
• glfw - Multi-platform library for OpenGL, window and input
• assimp - 3D model importing with scene post-processing
• stb - Single-file public domain libraries (stb_image for textures)
• zlib - Compression library

Physics

• joltphysics - Multi-platform 3D physics engine
• box2d - 2D physics engine for games

Networking

• GameNetworkingSockets - Reliable UDP transport
• libsodium - Crypto primitives used by the transport
• protobuf - Wire format for snapshots / RPC

Navigation

• recastnavigation - Navigation mesh generation

Audio

• miniaudio - Single-file audio playback and capture library

Scripting

• sol2 - C++ ↔ Lua API wrapper with advanced features
• lua - Lightweight, embeddable scripting language
• Mono - C# scripting runtime (manually integrated)

UI & Editor

• imgui - Immediate mode GUI for tools and debugging
• imguizmo - Immediate mode 3D gizmo for scene editing

Development & Profiling

• tracy - Real-time profiler with nanosecond resolution
• googletest - Google Testing and Mocking Framework
• filewatch - File system monitoring for hot-reload

Code formatting & pre-commit hooks ✅

We trim trailing whitespace and enforce a few formatting rules via pre-commit hooks.

• Install pre-commit locally (Python/pip required):
  • python -m pip install --user pre-commit
  • pre-commit install in the repo root to enable the git hook
  • Optionally run pre-commit run --all-files to apply the hooks across the repo

Included hooks/config:

• trailing-whitespace (removes trailing spaces)
• end-of-file-fixer (ensure final newline)
• clang-format for C/C++ (configured to use .clang-format in the repo root)

We also include a .editorconfig to configure editor behavior (trim trailing whitespace, insert final newline). The pre-commit hooks ignore the vendor/, .vs/, .vscode/, build/, and other generated/IDE folders to avoid touching third-party or editor metadata.

A GitHub Action runs pre-commit on push and pull requests so formatting checks run on PRs automatically.

Influences & References

• Hazel - As mentioned, this game engine follows The Cherno's game engine series as a foundation
• Lumos - Ideas for OpenGL rendering implementation and engine architecture
• Arc - Ideas for the audio engine implementation
• Molecular Matters Blog - Core inspiration for the multi-threaded render command queue architecture