Welcome to TEGE

TEGE (The Enjin Game Engine) is an open-source (BSL 1.1) game engine built entirely from scratch using C++20 and the Vulkan graphics API. It ships with a complete editor powered by Dear ImGui, an Entity-Component-System architecture with over 70 component types, physically-based rendering, skeletal animation, and AngelScript scripting — everything you need to create 2D, 2.5D, and 3D games from a single, unified toolset.

Feature Highlights

• 70+ ECS components — Transform, Mesh, Material, Light, Camera, Rigidbody, Sprite, Tilemap, Audio, UI Canvas, Dialogue, and many more.
• Vulkan PBR rendering — Physically-based materials with metallic/roughness workflow, normal maps, height maps, emissive, transmission, subsurface scattering, and cel shading.
• Ray tracing — Full RT pipeline for shadows, reflections, ambient occlusion, global illumination, translucency, and caustics with SVGF, OIDN, and OptiX denoisers.
• 6 character controllers — First-person, third-person, top-down, platformer, vehicle, and planet-gravity controllers.
• Jolt 3D + Box2D 2D physics — Dual physics backends via a unified interface, with collision filtering, sensors, joints, gravity zones, and conveyors.
• AngelScript + visual scripting — Sandboxed text scripting with a complete API, plus a 76-node blueprint-style visual script editor with debugger.
• Tiered save system — Three persistence tiers (RunState, SceneState, MetaProgression) covering collectibles, checkpoints, and cross-session progression.
• LAN multiplayer — Built-in networking layer for local-area multiplayer and splitscreen support.
• 23+ templates — Ready-made starting points across 5 categories: Foundations, Genre Showcases, Systems Deep-Dives, Retro & Flash, and Advanced.
• Procedural generation — Terrain, dungeon, and world generation utilities built on Perlin/simplex noise.
• Accessibility — 11 editor themes, colorblind simulation modes, reduced-motion settings, subtitle sizing, and focus-navigable UI.
• Build pipeline — One-click export to a standalone player with asset packing (.enjpak), CRC integrity checks, and configurable window settings.

Philosophy

TEGE is built from the ground up with zero middleware dependencies. Every subsystem — rendering, physics abstraction, audio, scripting, animation, networking, UI, AI, and the editor itself — is implemented in-house. This gives you a single, cohesive codebase where every layer is designed to work together, with no hidden third-party licenses, no black-box libraries, and full source access under the BSL 1.1 license.

Installation and Build

Prerequisites

Before building TEGE, ensure the following tools are installed on your system:

Installing Dependencies

Ubuntu / Debian

sudo apt-get update
sudo apt-get install -y \
    build-essential \
    cmake \
    libvulkan-dev \
    vulkan-tools \
    vulkan-validationlayers \
    libglfw3-dev \
    glslang-tools

Fedora / RHEL

sudo dnf install -y \
    gcc-c++ \
    cmake \
    vulkan-devel \
    vulkan-tools \
    glfw-devel \
    glslang

Arch Linux

sudo pacman -S \
    base-devel \
    cmake \
    vulkan-devel \
    vulkan-tools \
    glfw \
    glslang

macOS (Homebrew)

brew install cmake vulkan-headers vulkan-loader glfw glslang
brew install molten-vk   # MoltenVK required for Vulkan on macOS

Windows (vcpkg)

1. Install Visual Studio 2019 or 2022 with the "Desktop development with C++" workload.
2. Install CMake 3.20+ — download from cmake.org or run winget install Kitware.CMake.
3. Install the Vulkan SDK from LunarG. The installer sets VULKAN_SDK and PATH automatically.
4. Install GLFW3 via vcpkg (recommended):

   git clone https://github.com/Microsoft/vcpkg.git
   cd vcpkg
   ./bootstrap-vcpkg.bat
   ./vcpkg install glfw3:x64-windows
   ./vcpkg integrate install

Platform Build Instructions

Windows (Visual Studio)

Open an x64 Native Tools Command Prompt and run:

mkdir build && cd build
cmake .. -G "Visual Studio 17 2022" -A x64
cmake --build . --config Release

If using vcpkg for GLFW, add the toolchain file:

cmake .. -G "Visual Studio 17 2022" -A x64 \
    -DCMAKE_TOOLCHAIN_FILE=C:/path/to/vcpkg/scripts/buildsystems/vcpkg.cmake

The editor executable will be located at build/bin/Release/EnjinEditor.exe.

Linux

mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(nproc)

The editor executable will be located at build/bin/EnjinEditor.

macOS

mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
cmake --build . -j$(sysctl -n hw.ncpu)

The editor executable will be located at build/bin/EnjinEditor.

CMake Build Options

Pass options on the CMake configure line:

cmake .. \
    -DCMAKE_BUILD_TYPE=Release \
    -DENJIN_BUILD_EDITOR=ON \
    -DENJIN_BUILD_PLAYER=ON \
    -DENJIN_BUILD_TESTS=OFF \
    -DENJIN_PHYSICS_JOLT=ON \
    -DENJIN_PHYSICS_BOX2D=ON

Verifying Your Installation

After installing dependencies, verify each tool is available:

# Check CMake version
cmake --version

# Check Vulkan runtime and driver
vulkaninfo --summary

# Check shader compiler
glslc --version

# Check GLFW (Linux/macOS)
pkg-config --modversion glfw3

First Launch

Launch Sequence

When you run the editor for the first time, the following sequence occurs:

1. Splash screen — A brief engine splash screen appears while subsystems initialize (Vulkan context, audio device, asset caches).
2. Template Selector — A dialog opens presenting 23+ built-in templates organized into 5 categories. Pick one to create a pre-populated starting scene, or choose Blank for an empty canvas.
3. Editor opens — The editor workspace loads with the selected template's scene, entities, and components already in place. A default 5-panel layout is applied: Hierarchy, Inspector, Viewport, Console, and Asset Browser.

Template Selector

The template selector provides 23+ ready-made starting points across five categories, each designed to showcase different engine subsystems and game genres:

Each template creates the appropriate entities (ground, lights, player with controller, camera) and pre-configures component values for its genre. Every template includes NotesComponent hints explaining the featured systems.

You can also save your own templates: set up a scene the way you want it, go to File > Save as Template, give it a name, and it will appear alongside the built-in templates in the selector.

Setting a Custom Window Icon

To brand your project with a custom window icon, you have two options:

• File-based: Place an icon.png file next to the editor executable. The engine loads it automatically on startup.
• Settings-based: Go to View > Settings > Project > Window Icon, browse for any PNG file, and click Apply. The icon updates immediately and the path is saved in the .enjinproject file so it auto-applies on future launches. Use Clear to revert to the OS default icon.

Editor Tour

The TEGE editor is a panel-based workspace. All panels can be toggled from the View menu in the top menu bar, and every panel is dockable — drag tabs to rearrange, split, or stack them however you prefer.

Panels

Entity and Component Icons

Entities in the Hierarchy panel display bracket-tag icons based on their primary component type, making it easy to identify entity roles at a glance. The same icon convention is used in component headers within the Inspector panel.

Empty States

Panels display helpful empty-state messages when there is nothing to show, guiding you toward the next action:

• Hierarchy — "No World Loaded" or "No Entities" (with a Create Entity button).
• Inspector — "No Entity Selected".
• Asset Browser — "Directory Not Found".
• Dialogue — "No DialogueComponent".
• Plugin Browser — "No Plugins Found".

Keyboard Shortcuts

Multi-Select

TEGE supports selecting multiple entities at once for batch operations. Selection works in both the Hierarchy panel and the 3D/2D viewport:

• Ctrl + click — Toggles an individual entity in or out of the current selection, in both the hierarchy and the viewport.
• Shift + click — Performs a range select in the hierarchy from the current primary selected entity to the clicked entity, selecting everything in between.
• Drag in viewport — Draws a marquee (rubber-band) rectangle; all entities enclosed by the rectangle are added to the selection on mouse release.
• Primary entity — The last entity clicked becomes the primary selection. The Inspector and gizmo use the primary entity as their reference point.

When multiple entities are selected, the following batch operations become available:

• The Inspector displays a list of all selected entities and provides batch transform editing:
  • Position offset — Apply a positional offset to all selected entities.
  • Rotation offset — Apply a rotational offset to all selected entities.
  • Scale multiplier — Multiply the scale of all selected entities.
  Each transform operation has an Apply button to commit the change.
• The Gizmo appears at the centroid of all selected entities. Dragging the gizmo applies the delta transform to every selected entity simultaneously, preserving their relative positions and orientations.

Projects and Scenes

Every game in TEGE is organized around two file types: the project manifest (.enjinproject) and one or more scene files (.enjin). Understanding how these relate is essential before you start building.

Project vs. Scene Files

The project manifest acts as a table of contents. It does not store entity data itself; that lives entirely in the individual .enjin scene files.

Project Manifest Format

A .enjinproject file is a small JSON document with the following structure:

{
  "name": "My Game",
  "scenes": [
    { "name": "Main Menu", "path": "scenes/main.enjin",   "buildIndex": 0, "isStart": true },
    { "name": "Level 1",   "path": "scenes/level1.enjin", "buildIndex": 1 },
    { "name": "Level 2",   "path": "scenes/level2.enjin", "buildIndex": 2 }
  ]
}

Scene List Panel

Open the Scene List panel via View > Scene List. It provides a central place to manage all scenes within your project:

• Add — create a new scene or add an existing .enjin file to the project.
• Reorder — drag scenes up or down to change their build index order.
• Load — click any scene entry to load it into the editor viewport.
• Set Start Scene — right-click a scene and choose "Set as Start" to designate the scene that loads first in exported builds.

Scene Transitions

When switching between scenes at runtime (e.g., from a main menu to gameplay), TEGE provides four transition types:

All transitions except Instant have a configurable duration (in seconds). Scene transitions can be triggered from AngelScript or visual scripts at runtime.

Additive Scene Loading

Scenes can be loaded additively, meaning the new scene's entities are merged on top of the currently loaded scene rather than replacing it. This is useful for layering concerns—for example, loading a UI overlay scene on top of a gameplay scene, or streaming in a new section of a level without unloading the current one.

Project File Structure

A typical TEGE project on disk follows this directory layout:

my_game/
  my_game.enjinproject      # Project manifest (JSON)
  scenes/
    main.enjin               # Scene files
    level1.enjin
    level2.enjin
  assets/
    textures/                # Texture files (PNG, JPG)
    models/                  # 3D models (GLTF, GLB)
    audio/                   # Audio files (WAV, OGG, MP3)
    fonts/                   # TTF fonts
  scripts/                   # AngelScript files (.as)
  templates/                 # Custom scene templates

All paths inside the .enjinproject manifest and scene files are relative to the project root directory. This makes projects fully portable—move or rename the root folder and everything continues to work.

Entity-Component-System

TEGE uses an Entity-Component-System (ECS) architecture as the foundation for all game objects. Instead of deep inheritance hierarchies, ECS separates identity, data, and logic into three orthogonal concepts:

ECS::World

The central manager is ECS::World. It owns all entities and their component storage, and provides the API for creating, querying, and destroying entities. Structural operations (creating or destroying entities, adding or removing components) are thread-safe.

TEGE ships with over 70 component types spanning core rendering, physics, gameplay, AI, networking, animation, and more. You can compose any game object by mixing and matching the components it needs.

Creating Entities

There are two ways to create entities in the editor:

1. Entity menu — use the top menu bar's Entity menu to create common objects:

   Category	Options
   General	Create Empty
   3D Objects	Cube, Sphere, Plane, Cylinder, Cone
   2D Objects	Sprite, Animated Sprite, Tilemap
   Lights	Directional Light, Point Light, Spot Light
   Camera	Camera
   Environment	Ground Plane

2. Hierarchy panel — right-click in the Hierarchy panel to access the same creation options via a context menu. You can also right-click an existing entity to create a child entity parented to it.

Adding Components

Select an entity in the Hierarchy or viewport, then click the Add Component button at the bottom of the Inspector panel. A searchable dropdown lists all available component types. Type a few characters to filter—for example, typing "light" will show LightComponent, SpotLightComponent, and similar matches.

ECS Data Flow

The following diagram illustrates how entities, components, and systems relate at runtime. Entities are composed of components, and systems read (and sometimes write) those components each frame:

This design makes it easy to add new behavior to existing entities. Need an entity to play footstep sounds? Attach a FootstepComponent—the FootstepSystem will pick it up automatically on the next frame. No base class changes required.

Coordinate System and Transform

TEGE uses a left-handed coordinate system:

• +X points to the right.
• +Y points up.
• +Z points forward (into the screen).

This is the same convention used by DirectX and many popular game engines. If you import models from tools that use a right-handed system (e.g., Blender defaults), the GLTF importer handles the coordinate conversion automatically.

TransformComponent

Every entity has a TransformComponent. It defines the entity's position, orientation, and size in the scene:

The Inspector panel displays editable fields for each transform property. You can type exact values or use the drag handles on the numeric fields for quick adjustments.

Hierarchy and Parenting

Entities can be parented to other entities by dragging them in the Hierarchy panel. When entity B is parented to entity A:

• B's transform becomes relative to A's transform.
• Moving, rotating, or scaling A will carry B along with it.
• B's local position (0, 0, 0) means "at the same position as A."

This is essential for building compound objects—for example, a car entity with child entities for each wheel, or a character entity with an attached weapon.

Transform Gizmos

The viewport provides visual gizmos for manipulating transforms interactively. Switch between gizmo modes using the number keys:

Play Mode

Play Mode lets you test your game directly inside the editor. The Game View panel provides three buttons for controlling playback:

What Happens on Play

When you press Play, the engine takes a snapshot of the entire scene state (every entity and all their components). This snapshot is held in memory so the editor can restore it when you stop. Then, all runtime systems begin updating each frame.

Behavior During Play

• Editor input is locked. Panels receive NoInputs flags to prevent accidental edits. Keyboard shortcuts are suppressed so they don't conflict with game controls.
• The game camera renders in the Game View panel using the highest-priority active CameraComponent in the scene.
• The editor camera continues to be visible in the main viewport, allowing you to observe the scene from any angle while the game runs.

Active Systems During Play

The following systems are updated each frame while play mode is active:

What Happens on Stop

When you press Stop, the engine performs the following steps:

1. All runtime systems are deactivated.
2. The engine computes a JSON diff between the pre-play snapshot and the current scene state.
3. The original editor state is restored from the snapshot.
4. If the diff contains any changes, the PlayModeDiff dialog appears.

PlayModeDiff Dialog

The PlayModeDiff dialog lets you selectively keep changes that occurred during play. This is invaluable for level design—for example, you might play-test to find the perfect position for an object, then apply just that transform change back to the editor scene.

• Tree view — all changed entities are listed in an expandable tree. Expand an entity to see its changed components, and expand a component to see individual property changes.
• Color-coded actions:
  • Green — entity or component was created during play.
  • Red — entity or component was deleted during play.
  • Yellow — entity or component was modified during play.
• Checkboxes — every node in the tree (entity, component, and individual property) has a checkbox. Check only the changes you want to keep.
• Apply Selected — re-applies the checked changes to the restored editor scene.
• Discard All — closes the dialog without applying any changes. The scene returns to its exact pre-play state.

Play Mode Flow

The complete state machine for play mode is shown below:

Note that stopping from either Playing or Paused state always goes through the diff dialog (when changes exist). If nothing changed during play, the editor returns directly to the Editing state without showing the dialog.

9. Core Components

Core components provide the foundational data every entity may need: spatial placement, naming, tagging, and developer annotations. Most entities will carry at least a TransformComponent and a NameComponent.

TransformComponent

Every entity has a transform. It controls the entity's position, rotation, and scale in the scene. The transform is the single most commonly used component and is automatically present on all entities created through the editor.

NameComponent

Gives the entity a human-readable display name shown in the hierarchy panel.

MeshComponent

Stores the vertex and index data used by the renderer to draw geometry. Each vertex contains position, normal, UV coordinates, vertex color, tangent, bone weights, and bone indices. The mesh is typically populated by importing a 3D model (GLTF/GLB) or by using a built-in primitive such as Cube, Sphere, Plane, or Cylinder.

NotesComponent

Attaches text annotations to entities for documentation or design notes. Notes are visible only in the editor and are stripped from exported builds.

TagComponent

String-based tags for filtering and identification. An entity can have multiple tags, enabling flexible querying (e.g., find all entities tagged "enemy" or "destructible").

Methods:

LayerComponent

Numeric layer assignment used for collision filtering and selective rendering. Layers work with CameraComponent::cullingMask and the collision bitmask system.

10. Rendering Components

Rendering components control how entities appear in the viewport: surface materials, lighting, cameras, billboards, text, and post-processing volumes.

MaterialComponent

Controls the visual surface properties of a mesh. Supports physically-based rendering (PBR), texture maps, alpha modes, and a full suite of retro rendering flags for stylized visuals.

PBR & Surface Fields

Retro Rendering Flags

Per-material flags that enable retro visual styles (PS1-era aesthetics, dithered transparency, Gouraud shading, etc.).

LightComponent

Adds a light source to the entity. The engine supports multiple simultaneous lights with shadow mapping. For directional and spot lights the direction field controls the light direction; you can also extract the forward vector from the entity's TransformComponent rotation.

CameraComponent

Attaches a game camera to an entity. The editor has its own camera; this component is for in-game cameras used during play mode. The highest-priority active camera is used for rendering. Camera frustum visualization is shown in the editor viewport for game cameras.

Camera Presets

The editor provides 9 built-in camera presets that configure the camera component and entity transform in one click:

BillboardComponent

Makes the entity always face the camera. Useful for sprites, health bars, labels, and particle-like effects in 3D scenes.

TextComponent

Renders 3D text in the world using stb_truetype font rasterization to a texture. Supports any TrueType (.ttf) font file.

PostProcessVolumeComponent

Defines a spatial region with custom post-processing settings. When the active camera enters a volume, the volume's settings blend with the global/default settings based on priority and distance-based weight falloff. Multiple volumes can overlap; blending is priority-sorted. A global volume applies everywhere and serves as a scene-wide base layer.

The overrideMask bitmask allows partial overrides. For example, a volume can modify only bloom without touching tone mapping. Override flag bits include: ToneMapping (bit 0), Bloom (1), Vignette (2), ChromaticAberration (3), ColorGrading (4), FilmGrain (5), FXAA (6), Dither (7), ColorQuantize (8), ResolutionDownscale (9), CRT (10), LUT (11), VHS (12), Palette (13), DepthOfField (14), TiltShift (15), CelOutline (16), Stipple (17), CRTPhosphor (18), GodRays (19), SSAO (20), ContactShadows (21), Caustics (22), and FogShafts (23).

11. Physics 3D Components

3D physics components enable physical simulation for entities: rigid body dynamics, collision shapes, trigger zones, and collision filtering. The engine uses Jolt Physics v5.2.0 as the 3D physics backend.

RigidbodyComponent

Adds physics simulation to an entity. Controls mass, velocity, gravity, and per-axis constraints. Pair with one or more collider components to define the collision shape.

BoxColliderComponent

Axis-aligned box collision shape.

SphereColliderComponent

Spherical collision shape.

CapsuleColliderComponent

Capsule collision shape, commonly used for characters.

TriggerZoneComponent

Fires events when entities enter, exit, or stay inside the zone. Useful for area-based game logic (cutscene triggers, damage zones, checkpoints).

Collision Filtering

Collision filtering uses a bilateral bitmask system. Two objects A and B only collide when both sides agree:

(A.categoryBits & B.collisionMask) && (B.categoryBits & A.collisionMask)

Defaults: categoryBits = 1, collisionMask = 0xFFFFFFFF. This means every object belongs to group 1 and collides with all groups by default. The engine supports up to 32 named collision groups, configurable per-scene via SceneManager::m_CollisionGroupNames.

Example: to make object A (player, group 1) ignore object B (ghost, group 4), set A's collisionMask to exclude bit 4, or set B's categoryBits to 4 and A's collisionMask to 0xFFFFFFF7.

12. Physics 2D Components

2D physics components provide collision detection and rigid body dynamics for side-scrollers, top-down games, and other 2D projects. The engine uses Box2D v3.0.0 as the 2D physics backend. The 2D physics system shares the same bilateral bitmask collision filtering as the 3D system.

Body2DComponent

The primary 2D physics body. Defines shape, material properties, and body behavior. Add alongside TransformComponent to enable 2D physics simulation. The shapeType field selects which sub-shape (circle, box, polygon, or capsule) is used for collision.

Physics Material

Each Body2DComponent contains a PhysicsMaterial2D controlling surface behavior:

2D Collider Shapes

The shape used by Body2DComponent is selected via shapeType. Each shape type has its own configuration:

CircleShape2D

BoxShape2D

PolygonShape2D

CapsuleShape2D

PolygonCollider2DComponent

A standalone polygon collider for 2D sprite silhouettes. Unlike the polygon shape embedded in Body2DComponent, this is a separate component that can be added alongside other physics components.

Joint2DComponent

Connects two 2D bodies with a physical constraint. Five joint types are available, each with type-specific parameters:

Common Joint Fields

Revolute Joint Fields

Prismatic Joint Fields

Distance & Rope Joint Fields

Sensor Bodies

When Body2DComponent::isSensor is set to true, the body becomes a sensor. Sensor bodies have a critical difference in how position synchronization works:

• Normal bodies: Box2D simulates physics and writes positions to the ECS (Box2D → ECS).
• Sensor bodies: Box2D syncs positions from the ECS (ECS → Box2D). The ECS transform is the source of truth.

This design enables entities driven by character controllers, AI systems, or tweens to still receive collision callbacks (enter, exit, stay) without Box2D overwriting their positions. Common use cases include:

• Player characters controlled by Platformer2DController or TopDown2DController that need overlap detection.
• AI-driven enemies that patrol via waypoints but need to detect the player.
• Tween-animated platforms or moving hazards that should trigger events on contact.

Character Controllers

Character controllers provide pre-built movement behaviors that handle input processing, camera management, and physics integration out of the box. Adding any controller component to an entity auto-creates a configured camera entity appropriate for that controller type. TEGE ships with six controller types covering first-person, third-person, top-down, side-scrolling, and vehicle gameplay.

Common Base Fields

All six controllers inherit a shared set of input and movement properties. These fields appear in the inspector for every controller type:

Platformer2DController

Side-scrolling movement with gravity, jumping, and optional wall mechanics. Ideal for platformers ranging from tight precision games to floaty adventure titles. Supports double-jump (via maxJumps), coyote time for forgiving ledge jumps, and input buffering for responsive controls.

TopDown2DController

Overhead 2D movement with 8-directional input and optional dash. Suitable for top-down shooters, adventure games, and Zelda-style exploration. The entity can optionally rotate to face the direction of travel.

TopDown3DController

Isometric or overhead 3D movement, similar to Diablo-style or CRPG games. Features a fixed-angle camera that follows the player and optional click-to-move navigation.

ThirdPersonController

Over-the-shoulder camera that orbits the player. The camera supports smooth interpolation, geometry collision avoidance, and lock-on targeting for action-RPG combat. Movement is relative to the camera facing direction, so the character naturally strafes and circles targets.

FirstPersonController

FPS-style camera and movement with mouse look, crouching, head bob, and optional dungeon-crawler mode. The camera is placed at the entity position offset by standingHeight. Sprinting temporarily increases the field of view by sprintFOVIncrease for a sense of speed.

VehicleController

Car-like physics with steering, acceleration, braking, and drift mechanics. Uses a simplified bicycle model driven by wheelBase, with visual body roll and pitch for a convincing driving feel without full wheel simulation.

PossessableComponent

Allows the player to switch which entity they control at runtime. Attach this component to any entity that has a controller, and the player can possess and unpossess it during gameplay. When possession transfers, the camera smoothly blends to the new entity over transitionDuration seconds.

2D Components

TEGE provides dedicated 2D rendering components for sprite-based games. These work alongside the engine's scene classification system — scenes containing only 2D components are automatically classified as Scene2D, which skips the shadow pipeline for better performance.

Sprite2DComponent

Renders a 2D sprite from a texture or sprite sheet region. Sprites are sorted by sortingLayer first, then by orderInLayer within each layer. The pivot point controls the sprite's origin for rotation and positioning.

AnimatedSprite2DComponent

Sprite sheet animation with per-frame timing. Each frame specifies a source rectangle and duration, allowing variable frame rates within a single animation. Attach alongside a Sprite2DComponent — the animated sprite system updates the parent sprite's source rectangle each frame.

TilemapComponent

Grid-based tile rendering for retro-style 2D games. The component stores a flat array of tile indices that map into a tileset texture. A value of -1 represents an empty tile. Collision data is stored in a parallel boolean array.

Helper methods: GetTile(x, y) returns the tile index at the given grid coordinate, and SetTile(x, y, tileIndex) updates it at runtime.

Camera2DBoundsComponent

Constrains a 2D camera within world-space boundaries, with smooth follow and zoom control. Attach to a camera entity to prevent the view from scrolling beyond the level edges.

Audio Components

TEGE's audio system is built on miniaudio and provides 3D spatial audio, volume falloff, looping, and priority-based voice management. For advanced spatialization, the engine optionally integrates with Steam Audio for HRTF-based binaural rendering, occlusion, and environmental reverb.

AudioSourceComponent

Plays audio clips with 3D spatialization support. Each audio source can be positioned in the world and will attenuate based on distance from the active AudioListenerComponent.

AudioListenerComponent

Defines the "ears" of the scene. Typically attached to the player or camera entity. Only one active listener should exist at a time — if multiple listeners have isActive set to true, the first one found in the entity list takes precedence.

Steam Audio Integration

When built with the ENJIN_AUDIO_STEAM_AUDIO CMake flag enabled, TEGE integrates the Steam Audio SDK for physics-based audio processing. This provides:

• HRTF binaural rendering — head-related transfer function filtering for realistic headphone spatialization.
• Occlusion and transmission — sounds are attenuated when blocked by geometry, with material-dependent transmission.
• Environmental reverb — automatic reverb based on room geometry and surface materials.

AI and Navigation

TEGE includes a suite of AI components for enemy behavior, NPC following, target tracking, and pathfinding. The AI system uses a simple state machine with six states, and integrates with the navigation mesh for obstacle-aware movement.

AIControllerComponent

A state-based AI controller with detection, patrol, chase, attack, flee, and death states. The AI scans for targets within its detectionRange and fieldOfView cone, transitions between states based on distance thresholds, and attacks when within range.

AI State Behavior

The AI transitions between states automatically based on distance to the target and internal timers. The following table summarizes the behavior of each state:

FollowTargetComponent

Makes an entity follow another entity with smooth movement. Useful for companion NPCs, pets, camera rigs, or any entity that should maintain a consistent distance from a target.

LookAtTargetComponent

Rotates an entity to face a target entity or a fixed world position. Supports per-axis constraints and angle limits for turrets, security cameras, character heads, and similar use cases.

WaypointComponent

Marks a position in the world as a waypoint for AI pathfinding or patrol routes. Waypoints can be linked into chains via nextWaypoint to form paths, or referenced by index from patrolPoints in an AIControllerComponent.

A* Pathfinding

The navigation mesh system provides A* pathfinding for AI entities:

• Navmesh generation — automatically builds a navigation mesh from scene geometry. Static meshes and colliders in the scene are voxelized and converted into a walkable surface representation.
• Path queries — find a path from point A to point B on the navmesh. AI entities use pathfinding results to navigate around obstacles instead of moving in straight lines.
• Debug visualization — toggle navmesh and path rendering in the editor to inspect walkable areas, obstacles, and computed paths in real time.

Gameplay Components

TEGE ships with a comprehensive set of gameplay-ready components covering health and damage, resources, interaction, item collection, inventory management, spawning, and timers. These components work together to build complete game loops without writing a single line of code.

HealthComponent

Tracks hit points, shield, regeneration, and invulnerability. Shield points absorb damage before health. Both health and shield support independent regeneration with configurable delays after taking damage.

Helper methods: GetHealthPercent() (0–1), GetShieldPercent() (0–1), IsFullHealth().

DamageComponent

Attach to projectiles, hazards, or weapons to deal damage to entities with a HealthComponent. Supports one-shot, per-entity, and continuous damage modes. The damage type interacts with DamageResistanceComponent multipliers.

DamageResistanceComponent

Per-type damage multipliers. Pair with HealthComponent to create resistances and weaknesses. When an entity takes damage, the incoming amount is multiplied by the corresponding resistance value before being applied.

ResourceComponent

A generic resource bar for stamina, mana, energy, or any depletable value. Integrates with character controllers for sprint and jump costs. When the resource is depleted, it stays in the depleted state until regeneration reaches depletedThreshold, preventing rapid sprint toggling.

Helper methods: GetPercent() (0–1), TryConsume(amount) (returns false if insufficient), Regenerate(deltaTime). Auto-regeneration happens automatically each frame. Controllers check TryConsume() before allowing sprint/jump actions.

InteractableComponent

Makes an entity interactable by the player (doors, NPCs, switches, chests, etc.). When the player is within interactionRange and facing the entity (if requiresLookAt is enabled), a UI prompt is displayed.

PickupComponent

Collectible items that the player can pick up. Supports six built-in types plus a custom type with a string identifier. Pickups can optionally magnetize toward the player, respawn after collection, and display floating bob and spin animations.

InventoryComponent

Manages an item inventory with slots, currency, and keys. Each slot holds an item ID, a quantity, and a maximum stack size. The keys list is checked by LockComponent to determine if a door or chest can be opened.

SpawnPointComponent

Defines where and how entities are spawned in the scene. Spawn points can instantiate prefabs on play start, after a delay, or on a repeating timer. Use spawnRadius to add positional randomness around the spawn location.

TimerComponent

A general-purpose countdown timer that can notify another entity on completion. Useful for delayed actions, cooldowns, wave spawning intervals, and timed events.

Helper queries: GetProgress() returns a 0–1 normalized value, GetRemaining() returns seconds left, and IsComplete() returns true once the timer has finished.

Puzzle and Level Design

TEGE provides a rich set of puzzle and level-design components for building interactive environments. From locked doors and pushable crates to conveyor belts and moving platforms, these components can be combined to create everything from Sokoban-style block puzzles to side-scrolling platformer levels.

LockComponent

Represents a locked entity (door, gate, chest) that requires a key to open. The key is matched against the player's InventoryComponent. Three open modes control how the lock behaves once unlocked.

PushableComponent

Makes an entity pushable by the player or other forces. Enable gridSnap for Sokoban-style block puzzles where crates snap to discrete grid cells.

SwitchComponent

Pressure plates, toggles, one-shot triggers, timed switches, and sequence pads that activate linked entities. When isActive changes, all entities in linkedEntities receive an activation event.

GoalZoneComponent

Target area for puzzle completion: Sokoban push targets, stand-on zones, item deposits, checkpoints, and level exits. When all goals in a goalGroup are satisfied, the group fires a completion event.

ConveyorComponent

Moves entities along a direction while they overlap the conveyor volume, like a conveyor belt. Can affect the player, pushable objects, or both.

TeleporterComponent

Instantly moves entities to a target position when they enter the teleporter volume. Supports bidirectional links between two teleporters and an optional cooldown to prevent ping-pong re-activation.

DestructibleComponent

An entity that can be destroyed by damage or interaction. Supports pickup drops, screen shake on hit, and optional respawning.

MovingPlatformComponent

A platform that travels between a list of waypoints, optionally carrying entities standing on it. Four movement modes cover most level-design patterns.

State and Dialogue

The state and dialogue systems let you build interactive NPCs, branching conversations, and general-purpose state machines for game logic and AI.

StateMachineComponent

A general-purpose state machine for game logic, AI, or animation. States are identified by string names. Named parameters (float, int, bool) can be used by scripts and visual scripts to drive transitions.

Methods

DialogueComponent

Retro RPG-style dialogue system with a typewriter text effect and branching choices. Attach to an NPC or interactive object. The dialogue system renders lines sequentially, one character at a time, with an optional per-character sound effect.

DialogueBoxComponent

Automatically builds a UICanvas-based dialogue overlay. Attach alongside a DialogueComponent and a UICanvasComponent on the same entity. The system creates and synchronizes all UI elements (speaker label, text area, portrait, choice buttons, and continue indicator) automatically. Settings are organized into five groups in the Inspector.

Box Layout

Text Style

Portrait

Choices

Continue Indicator

Save System

TEGE provides a comprehensive tiered save system that supports everything from per-scene state (enemies killed, doors opened) to permanent cross-run progression (unlocks, achievements). The system is built around three persistence tiers, 20 save slots, and pluggable cloud-sync backends.

SaveDataComponent

Marks an entity for persistence in the tiered save system. Controls which transform fields are saved, the persistence tier, custom tags for filtering, and key-value data for game-specific state.

Methods

SaveLoadMenuComponent

In-game save/load grid overlay. Add this component to any entity to enable a pause-menu-style save/load UI during play mode. The UI renders as a grid of save slots with Save, Load, and Delete buttons.

TieredSaveSystem

The engine's tiered save system organizes persisted data into three tiers based on how long the data should survive. Each entity's SaveDataComponent specifies which tier it belongs to.

Persistence Tiers

Save Slots

The system provides 20 save slots: 17 manual save slots (0-16) and 3 rotating auto-save slots (17-19). Auto-save fires on a configurable timed interval (default 5 minutes), on scene transitions, and on checkpoint calls.

Meta-Progression

A separate meta.enjsave file stores permanent key-value data (float, int, bool, string) that survives across all runs and save slot deletion. Use this for unlockable characters, achievement flags, lifetime statistics, and meta-currencies.

Cloud Sync Backends

Save backends are pluggable via the ISaveBackend interface. Three backends ship with the engine:

QuestStateComponent

Tracks quest progress for RPG and narrative games. Attach to an entity that represents a quest. The QuestSystem updates timeElapsed automatically while a quest is active.

QuestFlowComponent

Visual node-graph-based quest authoring for complex, branching quests. While QuestStateComponent works for simple linear quests, QuestFlowComponent provides a visual editor (accessible from the Inspector) for designing quest flows with conditions, branching, delays, rewards, and events.

Authored Fields (Serialized)

Runtime State (Not Serialized)

HUD and UI

TEGE provides two complementary UI systems: HUD widgets for quick data-bound overlays (health bars, labels, markers), and a full UICanvas system for building complete in-game menus and interfaces.

HUDWidgetComponent

Displays data-bound UI elements such as health bars, resource bars, labels, objective markers, crosshairs, and minimaps. Widgets can be screen-space (fixed position) or world-space (billboarded above entities).

UICanvasComponent

A full retained-mode UI system. Attach a UICanvasComponent to any entity to give it a tree of UI elements rendered as an overlay during play mode. The canvas provides a design resolution, a scale mode, and a theme for consistent styling.

UIElement Types

Each element in a UICanvasComponent has a widget type that determines its appearance and interaction behavior:

UISystem

The UISystem handles four responsibilities for all active canvases each frame:

• Layout — resolves anchors, pivots, margins, and the element tree hierarchy into screen-space rectangles.
• Render — draws all visible elements as ImGui draw commands in the Game View overlay.
• Input — processes mouse clicks, hover states, and drag events, dispatching them to the correct element.
• Focus navigation — manages keyboard/gamepad focus traversal for accessible UI control.

Focus Navigation

UICanvas supports full keyboard and gamepad navigation for in-game UI, enabling accessible menu control without a mouse:

Focus indicators are rendered as an outset rounded-rect border around the focused element, using the theme's inputFocused color or a per-element focusColor override. Elements can be marked as focusable/unfocusable via the focusable flag and ordered with tabOrder (0 = auto from element order).

Cinematic and Animation

TEGE provides a complete animation and cinematic toolset: scripted camera sequences with waypoint interpolation, a skeletal animation state machine with blending, a bone hierarchy for skinned meshes, and a timeline system for keyframing any property over time.

CinematicCameraComponent

Scripted camera sequences with waypoints, easing curves, and hold times. Use for intro fly-throughs, cutscenes, and dramatic reveals. The CinematicSystem interpolates the camera between waypoints during play mode.

Waypoint Fields

AnimatorComponent

Drives skeletal animation playback with a state machine. Each state maps to an animation clip, and transitions between states can be blended over a configurable duration. The AnimatorComponent reads bone transforms from the SkeletonComponent on the same entity and uploads them to the GPU bone SSBO (binding 7) for vertex skinning.

SkeletonComponent

Stores the bone hierarchy for skinned meshes. Populated automatically when importing glTF models that contain skeletal data. Each bone stores its name, parent index, inverse bind matrix, and current local/world transforms. The AnimatorComponent writes to these transforms each frame; the RenderSystem reads them for GPU upload.

TimelineComponent

A general-purpose keyframe animation system that can animate any entity property over time. Add a TimelineComponent to any entity and configure tracks with keyframes.

Track Types

Playback Controls

• Play / Pause / Stop — standard playback controls.
• Loop — restart when reaching the end.
• Ping-Pong — play forward then backward.
• Speed — playback rate multiplier.

Easing Functions

Keyframes support five interpolation curves: Linear, EaseIn, EaseOut, EaseInOut, and Step (instant jump to the next keyframe value).

Networking

TEGE includes a built-in LAN multiplayer system with entity replication, interpolation, client-side prediction, and remote procedure calls. The networking layer is designed for local-area games with up to 64 players.

NetworkIdentityComponent

Marks an entity for network replication. The NetworkSystem assigns a unique networkId at runtime and tracks ownership so that only the owning client can author state updates for the entity.

NetworkTransformComponent

Stores network synchronization state for interpolation and client-side prediction. The NetworkSystem writes to this component on remote entities and reads from it to smoothly interpolate between sync snapshots.

LAN Multiplayer Overview

The multiplayer system operates over UDP on the local network. One player hosts the session; others join by IP address. Key concepts:

• Host/Join — The host creates a session on a configurable port (default 7777). Clients connect by entering the host's IP address.
• Entity Ownership — Each replicated entity has an ownerId. Only the owning client sends authoritative state updates. Other clients receive and interpolate.
• RPCs (Remote Procedure Calls) — Scripts can invoke functions on remote clients via named RPCs. Both AngelScript and visual script bindings are provided (Host Game, Join Game, Disconnect, Call RPC nodes).
• Delta Sync — The NetworkSystem sends state updates at 20 Hz by default, with HMAC-SHA256 authentication for packet integrity.
• Client-Side Prediction — Locally owned entities are simulated immediately; prediction errors are smoothly corrected when authoritative state arrives.

Network Configuration

Network settings are loaded from config/network_settings.json at startup. The same settings can be edited visually from Settings > Project > Networking in the editor.

{
  "port": 7777,
  "maxPlayers": 16,
  "serverIP": "127.0.0.1",
  "syncRate": 0.05,
  "rateLimit": {
    "maxPacketsPerSecond": 200.0,
    "maxBytesPerSecond": 131072.0,
    "burstPackets": 50.0,
    "burstBytes": 65536.0
  },
  "security": {
    "maxViolations": 10,
    "violationWindowSeconds": 10.0,
    "banSeconds": 30.0,
    "kickOnViolation": true
  }
}

The rateLimit block controls per-sender packet and bandwidth throttling with a token-bucket burst allowance. The security block determines how many violations within a rolling window will trigger a temporary ban and optional kick. For competitive or high-traffic games, raise maxBytesPerSecond, burstBytes, and/or maxPacketsPerSecond to match your netcode needs.

Environment and Effects

TEGE includes a suite of environment components for defining weather zones, temperature regions, custom gravity fields, water/fluid volumes, camera overrides, and particle effects. These components are volume-based: attach them to entities and the engine evaluates which volumes overlap the player or other entities each frame.

WeatherZoneComponent

Defines a bounding-box region with per-zone weather overrides. When the camera or player enters this zone, the scene weather switches to the zone's settings. Higher-priority zones take precedence when zones overlap.

TemperatureZoneComponent

Defines a region with a specific temperature. Below 0 degrees Celsius, the zone produces snow and ice effects; above 5 degrees, rain. Temperature zones also drive water freeze/thaw mechanics on overlapping WaterVolumeComponent entities.

GravityZoneComponent

Overrides gravity for entities within the zone. Supports directional gravity (e.g., sideways rooms), point gravity (toward the zone center, Mario Galaxy-style), and zero-G (set gravityStrength to 0).

WaterVolumeComponent

Defines a water body with Gerstner wave rendering, shore foam, and freeze/thaw mechanics. The entity's Y position defines the water surface level; halfExtents defines the horizontal area and depth below the surface.

CameraTriggerComponent

A camera override volume. When the player enters this zone, the game camera smoothly transitions to the specified target camera entity over blendTime seconds. Useful for fixed-angle rooms, dramatic reveal shots, and side-scrolling camera locks.

ParticleEmitterComponent

Emits particles with configurable shape, lifetime, color gradients, and forces. Supports continuous emission, burst emission, and texture sheet animation.

Vegetation and Terrain

TEGE provides terrain components for both 3D heightmap landscapes and 2D side-scrolling terrain profiles, plus a vegetation system for wind-animated foliage.

TerrainComponent

A grid-based 3D heightmap terrain with multi-layer texture splatting. The terrain mesh is automatically regenerated by the RenderSystem whenever meshDirty is set to true. Supports up to 4 texture layers blended via a splatmap.

Methods

Terrain2DComponent

A polyline-based 2D terrain for side-scrolling games. Control points define the surface profile; a filled mesh is generated below the surface to a configurable depth. Collision can be auto-generated from the terrain shape.

VegetationComponent

Tag component for trees, bushes, and other foliage. When attached to a mesh entity, enables GPU-driven wind sway in the vertex shader. The vertex color red channel controls per-vertex sway weight (trunk = 0, leaves/branches = 1), allowing realistic deformation where the base stays anchored while the canopy sways.

Advanced Components

TEGE includes several advanced components for scripting, object pooling, audio, level of detail, and specialized simulation systems.

ScriptComponent

Attaches AngelScript behavior to an entity. Each entity can have multiple script attachments. Scripts receive lifecycle callbacks (OnCreate, OnUpdate, OnDestroy, collision/trigger events) and have access to the full engine API through registered bindings.

VisualScriptComponent

Blueprint-style visual node graph for gameplay logic. Provides a no-code alternative to AngelScript for common gameplay patterns. The visual script editor (accessible from the Inspector) supports drag-and-drop node placement, pin connections, variable management, and a built-in debugger with breakpoints and execution highlighting.

The component stores the full node graph (nodes, pins, links), local variables, event-to-node mappings, and per-node metadata. Over 140 node types are available across categories including Events, Flow Control, Math, Entity, Physics, Audio, Animation, Gameplay, and Networking.

PoolableComponent

Marks an entity as part of an object pool for efficient reuse. Common uses include bullets, particle effects, enemies, and pickups. The ObjectPool system manages activation, deactivation, and lifetime tracking.

FootstepComponent

Surface-aware footstep sounds. Plays different audio clips based on the surface material the character is walking on. The FootstepSystem detects the surface tag from terrain or collider data and selects the matching sound.

Surface Sound Mapping

LODComponent

Level-of-detail management with up to 5 LOD levels. The engine automatically switches between mesh simplification levels based on camera distance. LOD meshes can be auto-generated from the original mesh using the built-in MeshSimplifier, or assigned manually.

LODLevel Fields

Other Advanced Components

The following specialized components are available for advanced use cases:

Settings Window

The Settings window is a unified configuration panel accessed via View > Settings. It consolidates all engine, project, and per-scene options into a single window with three tabs: System, Project, and Scene. You can also open it programmatically with OpenSettings(tab) to jump directly to a specific tab.

System Tab

System-level settings that apply globally across all projects. These are saved persistently to disk in JSON format (on Windows, under %APPDATA%/enjin/).

Project Tab

Project-wide settings that are saved in the .enjinproject manifest file. These apply to the entire project regardless of which scene is loaded.

Scene Tab

Per-scene settings that are serialized with each .enjscene file. When you switch scenes, these settings change accordingly.

Keyboard Shortcuts

TEGE provides a comprehensive set of keyboard shortcuts for fast editor navigation and entity manipulation. All shortcuts are active when the editor viewport has focus.

Gizmo and Transform

Camera Navigation

Selection

Entity Editing

File and Global

Asset Browser

The Asset Browser provides a visual interface for browsing, searching, and managing project files. Open it from the View menu or use the default docked panel layout.

Layout

The panel is divided into two areas:

• Toolbar — search bar, grid/list toggle button, and a thumbnail size slider.
• Content Area — file cards displayed in either grid or list view.

Features

File Type Labels

Files are automatically categorized and color-coded based on their extension: