Gabriel West · Computer Engineering, University of Illinois Urbana-Champaign · gwest9@illinois.edu · github.com/gw12343

cpp-engine: Modern 3D Game Engine

cpp-engine is a complete C++17 3D game engine and editor for single-player desktop games. The runtime is a custom deferred OpenGL renderer with physics simulation, skeletal animation, and particle effects. The editor imports meshes, textures, sounds, animations, and effects; you assemble a scene, attach Lua, save the project, and play it in place. CMake builds the same sources as the editor or a GAME_BUILD executable. Both share one project format and one EDITOR / PAUSED / PLAYING loop, so play-in-editor and the shipped game stay on the same code path.

Performance

~120 FPS on the exterior Amazon Lumberyard Bistro scene¹ (1.8M triangles) at 4K on an RTX 3060. The frame includes 4096×4096 cascaded shadow maps with PCF, SSAO, bloom, and HDR IBL.

Architecture Overview

The engine is one process. Modules tick a scene of entities every frame. A new subsystem implements a small lifecycle (init, update, shutdown, optional Lua bindings) and is registered in that tick order: animation and particles run before the renderer so poses and effects are current when it draws. Shared state lives on EngineData, a singleton. Extension becomes easy because the list is explicit. The tradeoff is coupling: module order is a list in one constructor, and the deferred renderer is a fixed pass list.

The scene is an EnTT registry. Entities have persistent GUIDs, a parent/child transform hierarchy, and components for rendering, physics, animation, audio, and Lua. Assets are typed GUID handles behind one AssetManager, including prefabs that remap inner entity GUIDs on instantiate. A worker pool runs CPU work (transforms, pose sampling, skinning, physics sync); OpenGL stays on the main thread. The diagram below is startup through that loop to shutdown.

Complete engine initialization and runtime flow from entry point through shutdown

Core Technology Stack

• Graphics: OpenGL 4.6 deferred pipeline (G-buffer, 4096×4096 cascaded shadows with PCF, SSAO, bloom, HDR IBL)
• Physics: Jolt Physics for high-performance simulation
• Animation: Ozz-Animation for skeletal animation systems
• Particles: Effekseer integration for advanced VFX
• Audio: OpenAL for 3D spatial audio
• Scripting: Lua with Sol3 binding framework
• Asset Loading: Assimp for 3D model import
• UI Framework: Dear ImGui for editor interface
• Serialization: Cereal library for scene persistence
• Profiling: Tracy

Module Dependencies Graph

Physics Integration

Jolt Physics Implementation

CPP-Engine integrates Jolt Physics for multithreaded and stable simulation. The RigidBodyComponent and PlayerControllerComponent provide physics functionality accessible through the Lua scripting interface.

Physics Features:

• Rigid Body Dynamics: Full 6DOF simulation with proper mass properties
• Collision Detection: Efficient broad and narrow phase algorithms
• Character Controller: Smooth player movement with ground detection
• Trigger Volumes: Event-based collision detection for gameplay systems

Animation System

Ozz-Animation Integration

Animation Features:

• Skeletal Animation: Full bone hierarchy
• Animation Blending: Smooth transitions between animation states
• Pose Interpolation: Frame-accurate animation sampling
• Skinned Mesh Rendering: vertex skinning

Particle Effects

Effekseer Integration

Particle Features:

• GPU-Accelerated Rendering: High-performance particle simulation
• Advanced Effects: Fire, smoke, magic, explosions, weather
• 3D Spatial Effects: Proper depth sorting and 3D effects

Editor Systems

The editor is Dear ImGui in the same process as the runtime. Play/stop runs the simulation in place. Entities keep a persistent GUID. Hierarchy entities and assets drag onto inspector handle fields. Each component draws its own inspector UI.

Hierarchy Panel

• Parent/child transform hierarchy
• Right-click context menu for quick entity creation
• Drag-and-drop integration directly to EntityHandle fields in inspector

Scene View

• Interactive 3D viewport with real-time rendering
• Transform gizmos for translate, rotate, scale operations
• Mouse picking for direct entity selection
• Play/pause/stop controls for instant playtesting

Inspector System

• Entity management with delete, rename, and tag fields
• GUID display showing the persistent entity identifier
• Component headers with collapsible sections and individual delete buttons
• Custom component rendering where each component handles its own inspector UI

Console Window

• Filtered logging with search capabilities
• Auto-scroll support for development workflow
• Error tracking and debugging information

Asset Manager

• Tabbed interface for each asset type (Texture, Model, TerrainTile, SoundBuffer, Scene, Particle, Material, Animation)
• Asset preview and thumbnail support
• Drag-and-drop integration to AssetHandle<T> fields in inspector

Material Editor

• Texture slot management for albedo, normal, and roughness maps
• Color and numeric property editing with real-time preview
• Material asset creation and saving

This project contains 20K+ non-blank lines of original C++ code for the engine, editor, and Lua bindings. That excludes Jolt, Ozz, Effekseer, and the rest of the vendor tree. Code is released under Apache License 2.0 and is available at cpp-engine.

Built with: C++17, OpenGL 4.6, Jolt Physics, Ozz-Animation, Effekseer, Sol3, Dear ImGui, Cereal, Assimp, OpenAL, Tracy Profiler