Skip to main content

​
Overview

Atlas Engine follows a modular architecture with specialized subsystems that work together to provide a complete game development framework. The engine is composed of several independent libraries, each responsible for a specific domain.

​
Core Modules

Atlas Engine consists of six primary modules:

Atlas

Main renderer handling graphics, input, window management, and scene coordination

Opal

Low-level rendering abstraction layer supporting OpenGL, Vulkan, and Metal backends

Bezel

Physics engine built on Jolt Physics (v5.5.0) for rigid body dynamics and collision detection

Finewave

Audio engine for 3D spatial audio playback and processing using OpenAL

Aurora

Procedural terrain generation and rendering system

Hydra

Environmental effects including atmosphere simulation and fluid rendering

​
Backend Support

Atlas Engine supports multiple rendering backends through the Opal abstraction layer: 
// From CMakeLists.txt - Backend configuration
set(BACKEND "AUTO" CACHE STRING "Rendering backend: AUTO, VULKAN, METAL, OPENGL")

if(BACKEND STREQUAL "AUTO")
    if(APPLE)
        set(BACKEND "METAL")
    else()
        set(BACKEND "VULKAN")
    endif()
endif()
Automatic Backend Selection: The engine automatically selects Metal on macOS and Vulkan on other platforms when set to AUTO mode.

​
Rendering Pipeline

The engine supports both forward and deferred rendering pipelines:

​
Deferred Rendering

// Enable deferred rendering for advanced lighting
window.usesDeferred = true;
window.enableSSR(true); // Screen-space reflections

// Objects can opt into deferred rendering
cube.useDeferredRendering = true;

​
Forward Rendering

// Disable deferred rendering for specific objects
particles.disableDeferredRendering();

​
Component Architecture

Atlas uses an Entity-Component System (ECS) approach where game objects can have components attached: 
// From window.h:217
class Window {
    std::shared_ptr<bezel::PhysicsWorld> physicsWorld;
    std::shared_ptr<AudioEngine> audioEngine;
    std::shared_ptr<opal::Device> device;
    // ...
};

​
Memory Management

The engine uses modern C++ smart pointers for automatic memory management:
  • std::shared_ptr<T> for shared ownership (e.g., render targets, pipelines)
  • std::unique_ptr<T> for exclusive ownership
  • Raw pointers for non-owning references (scene objects, lights)
Object Lifetime: Objects added to scenes via addObject() or addLight() must remain valid for the entire scene lifetime. Declare them as class members, not local variables.

​
Build System

The engine uses CMake with the following structure: 
atlas/
├── atlas/          # Main rendering engine
├── bezel/          # Physics engine
├── finewave/       # Audio engine
├── aurora/         # Terrain system
├── hydra/          # Environment system
├── opal/           # Rendering backend abstraction
├── include/        # Public headers
├── shaders/        # Shader sources (opengl/vulkan/metal)
└── test/           # Example applications

​
Shader Management

Shaders are compiled and embedded into the engine at build time: 
# Shaders are packed into C++ header files
set(SHADER_OUTPUT_FILE "${CMAKE_SOURCE_DIR}/include/atlas/core/default_shaders.h")

add_custom_command(
    OUTPUT ${SHADER_OUTPUT_FILE}
    COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/pack_shaders.py 
            ${SHADER_INPUT_DIR} ${SHADER_OUTPUT_FILE} vulkan
    DEPENDS ${SHADER_SOURCES}
)

​
Version Information

// Current versions (from CMakeLists.txt)
#define ATLAS_VERSION "Alpha 6.1"
#define OPAL_VERSION "2 Platonic"
#define JOLT_VERSION "5.5.0"

​
Next Steps

Window Management

Learn how to create and configure windows

Scene Management

Understand scenes and rendering loops

Objects & Components

Work with game objects and components

API Reference

Explore the complete API documentation

Build docs developers (and LLMs) love

Get started for freeTalk to us