Lumina Game Engine

A modern, high-performance game engine built with Vulkan

Blog • Discord • Documentation

Lumina is a modern C++ game engine designed for learning and experimentation with real-world engine architecture. Built from the ground up with Vulkan, it demonstrates professional engine design patterns including reflection systems, ECS architecture, and advanced rendering techniques.

Perfect for:

• Learning modern game engine architecture
• Experimenting with Vulkan rendering techniques
• Building prototypes with a clean, modular codebase
• Understanding how engines like Unreal and Godot work under the hood

Note: Lumina is an educational project in active development. APIs may change, and some features are experimental. If you encounter build issues, please reach out on Discord for assistance.

• Vulkan-powered renderer with automatic resource tracking and barrier placement
• Forward+ rendering pipeline with clustered lighting for efficient multi-light scenes
• PBR materials

• Entity Component System (ECS) using EnTT for high-performance gameplay code
• Reflection system for automatic serialization and editor integration
• Modular design with clean separation of concerns

• ImGui-based editor with real-time scene manipulation
• Visual hierarchy for easy entity management
• Component inspector with automatic UI generation via reflection

• Multi-threaded task system with EnkiTS
• Custom memory allocators using RPMalloc for optimal performance
• Built-in profiling with Tracy integration

Full ECS access from Lua - Create systems, query entities, modify components Hot-reloadable scripts - Iterate on gameplay without recompiling Automatic binding generation - C++ components instantly available in Lua through reflection Performance profiling - Built-in Lua script profiling with Tracy

New Images Coming Soon

• Windows 10/11 (64-bit)
• Visual Studio 2022 or 2019 with MSVC v143 toolset (17.8+)
• Python 3.8+ added to your system PATH

1. Clone the repository

   git clone https://github.com/mrdrelliot/luminaengine
   cd LuminaEngine

2. Run the setup script

   python Setup.py

   • This downloads and extracts all dependencies automatically
   • If the download fails, manually download External.7z and extract it to the LuminaEngine folder

3. Open the solution

   • Open Lumina.sln in Visual Studio

4. Build and run Editor

   • Select Development configuration
   • Press F5 or click Build -> Run

5. Start developing

   • Open the Sandbox project to experiment
   • Or run Tools/ProjectConfigurator.py to create a new project

• Missing v143 toolset? Install it via Visual Studio Installer -> Individual Components -> MSVC v143 Build Tools
• "Cannot find .generated.h" error? Build again - Visual Studio sometimes needs a second pass to detect new files
• Python not found? Ensure Python is added to PATH during installation (check "Add Python to PATH" when installing)
• Error C1076 compiler limit: internal heap limit reached - Try again, this is currently an issue with a font file.
• Build fails? Submit an issue or contact me on Discord

Note: The LUMINA_DIR environment variable is set automatically during build. If needed, set it manually:

setx LUMINA_DIR "C:\path\to\lumina"

• GLTF
• GLB
• OBJ
• PNG
• JPG

• Khronos GLTF Samples
• Kenney 3D Assets
• Flightradar24 Models

• ImGui - Immediate mode graphical user interface for rapid tool development with minimal dependencies
• Tracy - Real-time frame profiler with GPU profiling, memory tracking, and remote access capabilities
• SPDLog - Fast C++ logging library with async mode, custom formatting, and multiple sink support
• NlohmannJson - Modern JSON library with intuitive syntax and full STL compatibility
• XXHash - Extremely fast non-cryptographic hash algorithm optimized for speed over collision resistance
• ConcurrentQueue - Industrial-strength lock-free queue supporting multiple producers and consumers
• EASTL - Electronic Arts Standard Template Library optimized for game development with custom allocators
• EnkiTS - Lightweight task scheduler for creating parallel-for, task sets, and dependency graphs across multiple threads
• EnTT - Fast and reliable entity component system with sparse set implementation and signal/delegate support
• FastGLTF - High-performance GLTF 2.0 parser with complete specification support and efficient memory handling
• GLM - Header-only C++ mathematics library designed for graphics programming with GLSL-compatible syntax
• JoltPhysics - High-performance multi-threaded physics engine with continuous collision detection and ragdoll support
• Sol2 - Modern C++/Lua binding library with compile-time safety and automatic type conversions
• MeshOptimizer - Mesh optimization library providing vertex cache optimization, overdraw reduction, and vertex/index buffer compression
• RenderDoc - Graphics debugging tool integration for frame capture and analysis
• RPMalloc - Lock-free thread-caching memory allocator providing 10-thread scalability with minimal overhead
• STBImage - Public domain image loading library supporting PNG, JPG, TGA, BMP, PSD, GIF, HDR, and PIC formats
• TinyObjLoader - Lightweight single-header OBJ file parser with MTL material support
• ShaderC - Google's GLSL to SPIR-V compiler with optimization passes and shader reflection capabilities
• Vulkan - Modern low-level graphics API providing explicit control over GPU resources and high-performance rendering
• VKBootsrap - Simplifies Vulkan initialization with sensible defaults and reduced boilerplate code
• Volk - Meta-loader for Vulkan that eliminates linking issues and enables runtime API loading
• VulkanMemoryAllocator - Production-ready memory management for Vulkan with defragmentation and optimal allocation strategies

Lumina follows a consistent naming convention:

General Rules:

• PascalCase for all identifiers
• Tabs for indentation
• Braces on new lines
• Descriptive variable names

See CONTRIBUTING.md for complete guidelines.

Contributions are welcome! Whether it's bug fixes, features, or documentation improvements.

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes following the coding standards
4. Add tests if applicable
5. Commit with clear messages (git commit -m 'Add amazing feature')
6. Push to your branch (git push origin feature/amazing-feature)
7. Open a Pull Request

Requirements:

• Clean, well-documented code
• Follow existing architecture patterns
• Include tests where appropriate
• Update documentation as needed

Lumina is inspired by and learns from these excellent open-source engines:

• Spartan Engine - Feature-rich Vulkan engine
• Kohi Game Engine - Educational engine series
• ezEngine - Professional open-source engine
• GoDot - AAA quality open source C++ game engine.
• Unreal Engine - Does it need an introduction?

Special thanks to the entire game engine development community for sharing knowledge and resources.

Lumina is licensed under the Apache 2.0 License.

Copyright 2024 Dr. Elliot

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

• Blog: dr-elliot.com
• Discord: Join our community
• GitHub: mrdrelliot/lumina