TEGE

The Enjin Game Engine

An open-source game engine built from scratch using C++20 and the Vulkan graphics API. Features a complete editor with 20+ ImGui panels, an Entity-Component-System architecture with 70+ component types, AngelScript scripting with ~721 API bindings and 146+ node visual scripting, Jolt Physics (3D) and Box2D (2D) backends, ray tracing pipeline with denoising, node graph editors for shaders, dialogue, behavior trees, quests, audio events, and particles, a built-in pixel editor and sprite pipeline, runtime UI system, asset libraries, and a standalone game player with HTML5 export and asset packing.

Download for Windows v0.8.5 View on GitHub

C++20 Vulkan 1.3 GLFW3 Dear ImGui ImGuizmo AngelScript Jolt Physics Box2D miniaudio Assimp nlohmann/json nanosvg stb_truetype CMake

Features

Architecture

enjin/
+-- Core/           # Foundation layer (Memory, Math, Logging, Platform)
+-- Engine/         # Engine layer (Renderer, ECS, Audio, Effects, Editor, Build, Assets)
+-- Editor/         # Editor application entry point
+-- Player/         # Standalone game player entry point
+-- third_party/    # External dependencies (GLFW, ImGui, ImGuizmo)
+-- build/          # Build output (bin/, lib/)

Core Layer

Foundation systems: memory management (stack, pool, linear allocators), math library (vectors, matrices, quaternions, splines), thread-safe logging, and platform abstraction.

Engine Layer

Vulkan renderer with multi-threaded command recording, async compute, and ray tracing pipeline. ECS with 70+ component types. Jolt Physics (3D) and Box2D (2D) backends. AngelScript scripting with ~721 bindings. Audio (miniaudio), asset loading (Assimp for glTF), animation (skeletal + sprite + timeline), AI and behavior trees, profiler, plugin system, level streaming, runtime UI, and scene management.

Editor Layer

Full editor application: 20+ ImGui panels including asset browser, profiler, shader graph, visual script editor, animation graph, behavior tree editor, quest flow editor, audio event graph, particle editor, UI editor, pixel editor, vector drawing editor, and sprite sheet importer. ImGuizmo gizmos, play mode, undo/redo, entity clipboard, 44 startup templates, template marketplace, terrain brushes, command palette, native file dialogs, build dialog.

Player Layer

Standalone runtime that loads .enjpak asset packs with build manifest. No editor dependency - ships as a minimal executable for distribution. Includes AngelScript integration for game scripting with hot-reload and coroutines.

Vulkan Renderer

Core Pipeline

• Vulkan context initialization and swapchain management
• SPIR-V shader pipeline, depth buffer / Z-testing
• Blinn-Phong lighting with deferred rendering framework
• PBR material system (baseColor, metallic, roughness, emissive, transmission/IOR/thickness, subsurface scattering) with dithered gradient banding, receiveShadows toggle, material presets (Glass, Water, Skin, Leaf)
• Texture support (albedo, normal, height, metallic-roughness, emissive)
• Normal mapping (tangent-space) and parallax occlusion mapping (4 modes: Basic, Steep, Occlusion, Relief)
• Multiple light sources (directional, point, spot)
• Alpha cutoff / transparency, stipple transparency
• GPU skinning via bone matrix SSBO
• Render-to-texture (Game View offscreen rendering with separate UBOs)
• Per-scene render settings with project-level defaults and editor UI
• Wireframe rendering with wide line support
• World curvature (vertex-shader horizon bending)
• Instanced vegetation rendering (grass, shrubs, trees with wind sway)
• Sprite texture atlas batching (shelf-packing into 4096x4096 GPU texture)
• Editable terrain with brush tools (2D heightmap and 3D sculpting, plus 2D polyline terrain with drag-to-edit)
• CPU particle system (5 emitter shapes, size/speed curves, gravity/drag) with GPU instanced billboard rendering
• Descriptor set caching with material sort for minimal GPU descriptor writes

Shadow System

• 4-cascade CSM for directional lights with texel stabilization and distance fade
• Point light shadow maps (cubemap array, up to 4 shadow-casting lights)
• Spot light shadow maps (2D array, up to 4 shadow-casting lights)
• Soft shadows via 16-sample Poisson disk PCF with configurable softness radius
• Per-entity shadow dither modes (by darkness, distance, angle) with 6 built-in patterns (Bayer 4x4/8x8, Blue Noise, Halftone, Crosshatch, Overlook)
• Per-entity cast/receive shadow flags, pipeline depth bias
• Configurable shadow resolution (512-4096), shadow distance, shadow strength
• Point/spot shadow light selection by intensity/distance scoring

Ray Tracing

• RT shadows, reflections, ambient occlusion, global illumination, translucency (refraction/SSS), caustics (photon-traced)
• Path tracing with 3 denoiser options (SVGF compute, OIDN Intel neural, OptiX NVIDIA CUDA)
• RT composition pass
• Real depth buffer and RT composition pass
• SH light probes - L2 spherical harmonics irradiance probes with grid generation, baking, and renderer integration

Advanced Rendering Techniques

• Order-independent transparency (Weighted Blended OIT with accumulation + revealage textures)
• Depth of field with bokeh (aperture shapes: circle, hexagon, octagon), CoC debug visualization
• Tilt-shift miniature/toy-model post-process blur with configurable focus band
• SDF scene evaluation (6 primitives, 6 boolean ops including smooth), GPU buffer packing
• Voxel cone tracing (VXGI) with mip chain, conservative rasterization, cone-traced diffuse/specular GI, AO, volumetric god rays
• SDF rendering - mesh-to-SDF conversion, sphere tracing, marching cubes extraction, 8SSEDT text rendering
• Non-Euclidean geometry - portal rendering with stencil-buffer recursion, hyperbolic/spherical/toroidal space warping
• Metaball/blob rendering - implicit surface field evaluation with marching cubes mesh extraction
• Framebuffer feedback effects (8 presets: Echo, Melt, InfiniteMirror, VHS, Kaleidoscope, Phosphor, DreamSequence)
• Screen-space distortion (7 types: HeatHaze, Shockwave, Underwater, PortalEdge, Ripple, BarrelFisheye, Custom)
• IK-driven mesh deformation - FABRIK with Verlet physics, tube/ribbon mesh generation for tentacles/ropes/tails
• Mesh audio reactivity - FFT analysis with per-vertex displacement (4 mapping modes, 4 axes)
• Inverse/differentiable rendering - CPU-based scene parameter optimization via gradient descent with finite differences
• 9 camera presets (Isometric 45/30, TopDown, SideScroller, FPS, TPS, Cinematic, SecurityCam, BirdsEye)

Pipeline Optimization

• Multi-threaded command buffer recording
• Indirect rendering (VkCmdDrawIndexedIndirect) with GPU payload batching
• Async compute queue for culling, particles, and post-processing
• Hi-Z occlusion culling
• GPU-driven frustum culling
• Frame graph resource scheduling
• Merged geometry buffer
• Bindless resource management

Post-Processing

Standard Effects

• Bloom
• Tone mapping (exposure, gamma)
• Vignette
• Color grading and LUT color grading
• FXAA anti-aliasing
• Film grain
• Chromatic aberration
• Palette lock
• Full-screen stipple/dither (8 combinable patterns, 3 color modes)
• Post-process volumes with spatial blending (Box/Sphere shapes, priority-based, smoothstep falloff, selective override mask)

Retro Effects

• PSX-style flat shading, affine texturing, vertex snapping
• Stipple transparency
• CRT filter (scanlines, curved screen, phosphor glow, phosphor mask types)
• VHS filter
• Dithering and color quantization
• Global retro shading

Environmental

• Weather system (rain, snow, fog, storms with toggleable lightning)
• Water rendering (Gerstner waves, shore foam, freeze system, ocean mode)
• Distance fog
• World time / day-night cycle with seasonal weather

Entity-Component System

70+ component types with full inspector UI. Entities are IDs, components are pure data, systems operate on component groups.

Character Controllers (5 types)

• 2D Platformer (coyote time, input buffer, wall jump/slide)
• 2D Top-Down (8-directional, optional dash)
• 3D Top-Down (isometric, click-to-move)
• 3D Third Person (orbit camera, lock-on targeting)
• 3D First Person (head bob, crouch, dungeon crawler mode)

Physics Components

• Rigidbody (dynamic, kinematic, static body types)
• Box, Sphere, and Capsule colliders with layers and masks
• Trigger zones (box/sphere shape, enter/exit/stay events)

Joint Components

• Distance, Hinge, Ball Socket, Spring, Fixed, Slider (6 types)
• All joints support breakable mode with force threshold
• Ragdoll component (per-bone joints, animation blend weight, auto-settle)

Combat Components

• Health, Damage, DamageResistance (per-type multipliers)
• Resource/stamina system with regeneration

Gameplay Components

• Camera with projection settings and frustum visualization
• Gravity zones (directional, point, zero-G)
• Temperature zones (heat/cold environmental effects)
• Camera trigger zones (camera override volumes)
• Text rendering (stb_truetype rasterization)
• Vegetation (grass, shrub, tree volume definitions)
• AudioSource and AudioListener
• Interactable, Pickup, Inventory
• Script, Timeline, Visual Script, Behavior Tree
• Streaming Volume and Streaming Portal
• LOD system (distance-based mesh swapping)
• Runtime UI (anchor-based layout, 8 widget types, 6 theme presets, font scaling, accessible labels)
• Dialogue box (auto-built UICanvas display with speaker, portrait, choices)
• Surface aligned controller (planet gravity walking on spherical surfaces)

Animation

2D

Frame-based sprite animation with flipbook support.

3D

• Skeletal animation - glTF and Assimp (FBX/DAE/3DS/20+ formats) skin/joint/animation import
• GPU skinning via bone matrix SSBO
• Animation blending and state machines (FSM with transitions)
• Auto-play support

Inverse Kinematics

• LookAt IK
• FABRIK chain solving
• Interaction IK

Timeline / Sequencer

• Flash-style keyframe animation editor with layers
• Property tracks - keyframe any component field over time (position, rotation, scale, material)
• Event tracks - fire callbacks at specific timestamps
• Animation tracks - play/blend skeletal animations
• 4 interpolation modes (Constant, Linear, Bezier, CatmullRom) with curve editor
• Onion skinning and auto-key
• Loop and ping-pong playback modes

Audio

• Cross-platform backend via miniaudio (WAV, MP3, FLAC, Vorbis)
• 3D spatialization with distance attenuation models
• Multi-channel mixing (multiple simultaneous sounds)
• Audio channels - SFX/Music/UI/Voice with independent volume (Music/UI force non-diegetic 2D)
• Category volumes (master, SFX, music, ambient, voice)
• AudioSource and AudioListener components serialized with scenes

Physics

Physics Backends

• IPhysicsBackend abstraction supporting multiple backends
• Jolt Physics v5.2.0 (3D) - enabled by default
• Box2D v3.0.0 (2D) - circle, box, polygon shapes with 5 joint types, CCD, SAT collision
• Legacy SimplePhysics fallback (compile-optional via ENJIN_PHYSICS_SIMPLE)
• Debug wireframes for colliders and joints
• 2D/3D ground detection for character controllers

Constraint Solver

• Sequential impulse solver with configurable iterations (default 8)
• Warm starting for improved convergence
• 6 joint types:
  • Distance - fixed distance between entities with stiffness
  • Hinge - rotation around one axis with angle limits and motor
  • Ball Socket - free rotation with cone and twist limits
  • Spring - Hooke's law spring with damping
  • Fixed - rigid connection (breakable under force)
  • Slider - translation along one axis with limits and motor
• All joints support breakable mode with force threshold and stress tracking

Ragdoll

• Per-bone joint definitions mapped to skeleton
• Blend weight for animation-to-ragdoll transition
• Auto-settle detection

AI & Procedural Generation

AI Systems

• Spline system (linear, Bezier, Catmull-Rom, B-spline)
• Enemy behaviors (patrol, chase, flee, attack patterns)
• AI state machines (FSM with transitions)
• Behavior trees with 20 node types, blackboard system, and editor panel
• Navmesh generation and A* pathfinding with path following
• AI components: AIController, FollowTarget, LookAtTarget, Waypoint

Procedural Generation

• 2D: Prefab-based levels with marked openings
• 3D: Room/corridor system, fractal terrain with erosion, advanced L-systems
• Reaction-diffusion (Gray-Scott model, 9 presets, bake-to-texture and heightmap export)
• Cellular automata geometry (7 CA rules, 3 mesh modes: Voxels, Marching Cubes, Point Cloud)
• Physarum simulation (agent-based slime mold network generation, 5 presets)
• Fourier transform meshes (DFT decomposition of 2D contours, progressive reconstruction)
• 4D stereographic projection (5 polytopes, 6 rotation planes, wireframe mesh generation)

Gameplay Systems

Core

• 5 character controller types (2D Platformer, 2D Top-Down, 3D Top-Down, 3D Third Person, 3D First Person)
• Gravity zones (directional, point, zero-G per-entity override)
• Temperature zones (heat/cold environmental effects)
• Camera trigger zones (camera override volumes)
• Wind system with vegetation sway
• Terrain editing with brushes (raise, lower, flatten, smooth, paint)
• World time & seasonal weather
• In-game text rendering

Advanced Systems

• Save/Load system - 10-slot persistence with quick save/load support
• HUD overlay - health bars, resource bars, labels, and crosshair rendering
• Quest/objective tracking - start, complete, and fail quests with objective tracking
• Damage resistance/weakness - per-type damage multipliers
• Stamina/resource system - generic resource with regeneration and controller integration
• Footstep audio - surface-based footstep sounds with walk/run interval support
• Object pooling - entity recycling with configurable pool sizes and auto-release
• Cinematic camera - waypoint sequences with easing curves for cutscenes
• Entity event bus - decoupled C++ entity communication system
• Raw mouse input - bypass OS mouse acceleration with smoothing options
• Destructible environments - 4 fracture patterns (Voronoi, Grid, Radial, Shatter) with debris physics
• Fluid-terrain coupling - bidirectional simulation with erosion and accumulation modes
• Interactive water - grid-based spring-damper wave propagation, object splashes and V-wakes, buoyancy, shallow/deep/foam color blending, boundary modes
• Localization - string tables, CSV/JSON I/O, parameterized strings, LOC() macro
• Dialogue assets (.enjdlg) with visual tree editor
• DataAsset system - schema definitions with typed instances, JSON I/O, script bindings

Scripting (AngelScript)

Architecture

• ScriptEngine manages the AngelScript VM, module compilation, and hot-reload
• TegeBehavior base class for all gameplay scripts (lifecycle: OnCreate, OnUpdate, OnDestroy)
• CoroutineScheduler for script coroutines (yield seconds, frames, end-of-frame)
• ScriptEventBus for script-to-script event dispatch with typed EventData
• C++ hot-reload with file watching, DLL reload, state save/restore

Script Bindings (~721 functions)

• Scene: entity transform, visibility, tags, scene loading, entity creation/destruction
• Physics: raycast, sphere/box overlap, force/impulse/velocity, gravity scale, layer masks (2D and 3D)
• Audio: play/stop/volume/pitch per entity, positional audio, master volume, audio graph
• Components: Health, Material, Light, Camera, AudioSource, Animator, Controller, State Machine, Camera2D, AI/BT, accessibility, networking, plugins, text components, particle presets, material transmission/SSS
• Core: coroutines, events, logging, input (keyboard, mouse, gamepad), input actions, time, math, procedural generation, noise, MIDI, screen-space effects, HUD widgets
• Flash API shim: ~40 bindings emulating Flash APIs (DisplayObject, MovieClip, Stage, Mouse, TextField, Sound, Timer)
• AS2/AS3 transpiler: pattern-based ActionScript to AngelScript conversion
• SWF converter: SWF binary import to ECS entities (shapes to sprites, MovieClips to entity hierarchy with timeline)

Tween System

• Position, rotation, scale, color, opacity tweening
• 25 easing functions
• Completion callbacks and delay support

Noise System

• Base noise: Value, Perlin, Simplex, Worley (2D and 3D)
• Fractal noise: FBM, Ridged, Billow with octaves, lacunarity, persistence
• Domain warping (2D and 3D)

Visual Scripting

• Blueprint-style node graph editor with 146+ node types
• Event nodes, flow control (Branch, ForLoop, While, Delay, Sequence, Gate)
• Math/logic, transform, physics, AI/BT, accessibility, tween, dialogue, audio, audio graph, plugins, noise, streaming, networking, procedural generation, HUD widgets, text, particle presets, material transmission/SSS, debug nodes
• Latent nodes (Delay, WaitForAudioComplete, WaitForAnimationComplete) for multi-frame operations
• Variable system (Bool, Int, Float, String, Vector3, Entity) with exposed option
• Collision callbacks (OnCollisionEnter/Exit, OnTriggerEnter/Exit)
• Subgraph/function nodes with 32-level call depth
• AngelScript interop (call AS functions from visual scripts and vice versa)
• Multi-select editing (box selection, Ctrl+click, multi-node drag, copy/paste with preserved links)
• Full undo/redo for nodes, links, properties, and variables

Debugger

• Breakpoints with conditional expressions and hit counts (F9 toggle, Shift+F9 edit)
• Step-through execution (F5 continue, F10 step)
• Call stack view with push/pop tracking
• Watch window for variable inspection
• Execution visualization (highlighted currently-executing node)
• Execution timeline profiler with color-coded node bars and duration tooltips

Node Graph Editors

All node graph editors share a common framework: 12 typed pins, Bezier curve visualization, pan/zoom canvas with minimap, box select, keyboard navigation, and full JSON serialization.

Shader Graph

• Visual shader authoring with 54 node types
• Topological sort GLSL code generation
• .enjshader save/load format

Animation Graph

• Dual-mode visual state machine editor
• AnimatorComponent mode (clip dropdown, speed, blend/exit time, ASM parameters)
• StateMachineComponent mode (game logic SM with script callbacks)
• Entry pseudo-node, transitions, play-mode state highlighting

Dialogue Tree Editor

• 7 node types for branching dialogue
• DialoguePlayer state machine with typewriter effect
• EntityEventBus integration and SubtitleSystem support
• Choice navigation and variable conditions
• 10 AngelScript bindings for runtime control

Behavior Tree Editor

• 20 node types (composite, decorator, action, condition)
• Blackboard data system for AI state
• Auto-layout with color-coded node categories
• Play-mode status visualization
• Configurable tick interval

Quest Flow Editor

• Visual quest graph with node types for start, objectives, conditions, rewards, branches, and end states
• Sequential and parallel objective support
• Integration with QuestSystem for runtime tracking

Audio Event Graph

• Dynamic audio mixing with runtime execution
• Trigger events, parameter thresholds, delay scheduling
• .enjaudiopkg save/load format

Particle Graph

• Visual particle system authoring
• Compiler to ParticleEmitterComponent
• .enjparticle save/load format

2D Art Pipeline

Pixel Editor

• 8 drawing tools: pencil, eraser, fill (flood fill BFS), line (Bresenham), rectangle, ellipse (midpoint), eyedropper, selection
• Layer stack with add/remove, visibility toggle, opacity
• 9 retro resolution presets (Game Boy, NES, SNES, GBA, Genesis, PC Engine, EarthBound, DS, Custom)
• Onion skinning (before/after tint, configurable frames/opacity)
• Frame timeline with thumbnails and FPS playback preview
• 16-color default palette with color picker and custom palette support
• 50-entry undo/redo stack
• Export as PNG sheet or individual frames

Sprite Sheet Importer

• Grid slicing with configurable cell width/height and padding
• Auto-detect slicing via BFS flood fill for connected non-transparent regions
• Slice thumbnails with apply-to-entity button

Auto Collider Generation

• Alpha-based bounds detection with configurable threshold
• Auto-fit box, capsule, and sphere colliders from sprite bounds
• World-space conversion relative to sprite pivot and size

SVG Import

• Parse SVG via nanosvg, rasterize to RGBA at configurable scale
• Max 4096x4096 with auto-scale
• Integrated into engine texture loading pipeline

Vector Drawing Editor

• 7 shape types with layers
• Undo/redo, SVG export
• Snap-to-grid, zoom/pan

Prefab Output

Complete draw-to-game workflow: draw sprite (or import PNG/SVG), slice into frames, define animations, generate colliders, export as prefab with Transform, Sprite2D, AnimatedSprite2D, and BoxCollider components.

Asset Libraries

Font Library

• 42 curated OFL/Apache fonts across 8 categories (Sans-Serif, Serif, Monospace, Display, Handwriting, Pixel, Fantasy, Sci-Fi)
• Editor browser with search and install

3D Asset Library

• 16 CC0 3D model packs (Kenney, Quaternius)
• Categories: Architecture, Nature, Props, Characters, Vehicles, Weapons, Dungeon, Sci-Fi

2D Asset Library

• 15 CC0 2D sprite/tileset/UI packs
• Categories: UI Kits, Tilesets, Sprites, VFX, Backgrounds, Textures

Debug & Profiler

• Profiler singleton with ENJIN_PROFILE_SCOPE("name") macro
• Per-frame breakdown: render, physics, scripting, ECS, audio
• FPS counter with 240-frame rolling history
• Draw call, entity, and triangle counters
• Memory usage tracking
• ImGui overlay panel with graphs, progress bars, and detailed scope table

Plugin System

• IPlugin interface with PluginContext (World, RenderSystem, ScriptEngine, Audio, SceneManager)
• PluginSDK.h single-header for plugin development
• Dynamic library loading (LoadLibrary / dlopen)
• Hot-reload with state save/restore
• C++ hot-reload with file watching and DLL reload
• Plugin manifest (JSON: name, version, dependencies)
• Plugin registration with engine subsystems
• Editor panel for plugin management (load, unload, status display)

Level Streaming

• StreamingManager with distance-based chunk loading/unloading
• StreamingChunk spatial regions with entity lists, load states, and LOD levels
• StreamingVolumeComponent defines chunk boundaries
• StreamingPortalComponent connects chunks (doorways, corridors)
• Priority-sorted load queue with concurrent load limiting
• Async chunk loading via SceneSerializer
• ImGui debug overlay showing chunk states

Accessibility

• Editor themes: Dark, Light, High Contrast Dark, High Contrast Light (WCAG AAA 7:1+ contrast ratios)
• Colorblind correction: 8 GPU modes (protanopia, deuteranopia, tritanopia, anomalous variants, achromatopsia)
• Colorblind-safe theme: Blue/orange palette universally distinguishable across all color vision types
• Colorblind-safe UI palettes: 9 palettes with patterns (Stripes/Dots/Crosshatch/Chevron) + icons alongside color
• Remappable input: Semantic game actions with hold/toggle modes and one-handed presets
• Alternative input: Switch access (one-button auto-scan mode for UICanvas focus navigation), eye tracking, sip-and-puff, head tracking support
• Motor accessibility: Adjustable click/drag thresholds, dwell-click and sticky drag on UICanvas elements with configurable timings, motor impaired preset
• Reduced motion: Weather particle reduction, head-bob disable
• Subtitles: Configurable font size, background, speaker names, direction indicators
• Content warnings: Per-scene warning flags with dismissable overlay (editor and player)
• Screen reader support: Priority-queued text announcer with visual status bar
• Audio visual indicators: Colored dot overlays for audio events
• Keyboard navigation: Panel focus shortcuts (Ctrl+1-5), gizmo nudge, focus rings
• Command palette: Ctrl+P for keyboard-driven command access
• Font scaling: Runtime font size multiplier for UISystem (0.5-3.0x)
• Dyslexia mode: OpenDyslexic font family, configurable letter/word/line spacing
• Quick presets: Low Vision, Motor Impaired, Photosensitive, Reset All

Skybox

Dedicated Skybox panel (View > Skybox) for configuring the scene background.

Supported Types

• None - No skybox
• Procedural - Gradient sky with configurable top, horizon, bottom colors and sun direction
• Solid Color - Single flat color fill
• Cubemap - Six-face cubemap with individual texture paths

Procedural Presets

One-click presets that configure colors and sun direction:

• Midday - Bright blue sky with overhead sun
• Sunset - Warm orange horizon with low sun
• Dawn - Soft pinks and purples with rising sun
• Night - Deep dark sky with sun below horizon
• Overcast - Flat grey tones with diffused light

All non-None types support Y-axis rotation (0-360). Configuration persists with scene save/load.

Build & Distribution

Build Pipeline

• Scan project, validate assets, compress/obfuscate, pack into .enjpak with CRC32 integrity verification
• Asset packer - .enjpak archive format with compression, XOR obfuscation, and per-file CRC32 checksums
• Build dialog - editor UI for configuring and running builds with progress tracking
• Build manifest - window title, resolution, fullscreen, and start scene baked into the pack
• Texture compression - CPU-side BCn/ASTC compression (BC1/BC3/BC4/BC5/BC7, ASTC 4x4/6x6/8x8) with mipmap generation
• Asset thumbnails - auto-generated previews for images, 3D models (software rasterizer), and scenes with caching
• Import presets for 10 DCC tools (Blender, Maya, 3ds Max, Houdini, Cinema 4D, ZBrush, Substance Painter, Unreal, Unity, SketchUp)

Standalone Player

• Editor-free runtime that loads game.enjpak, reads the build manifest, and runs the game loop
• Full particle, subtitle, announcer, alternative input, and post-processing support
• Splitscreen rendering support
• Scripting language (AngelScript with hot-reload, coroutines, event bus)

Distribution Formats

• HTML5 export with preloader and responsive scaling
• Newgrounds.io themed export template with medal sidebar, scoreboard, embed codes
• Linux AppImage packaging with .desktop file generation
• Windows ZIP + NSIS installer (Start Menu shortcuts, file associations, uninstaller) via CMake install rules + CPack, one-command build scripts (package.bat/package.sh)
• Adaptive quality - FPS-based auto-adjustment of render scale, shadow quality, and particle count (5 quality levels)

Editor

Panels

• Scene hierarchy with entity tree, drag-and-drop reparenting, bracket-tag entity icons by component type
• Entity inspector (70+ component types with full UI)
• Console (log output for engine messages, warnings, errors)
• Asset browser (grid/list view, thumbnails, search, type-colored labels)
• Viewport with fly camera
• Game View (renders from in-scene camera, independent from editor camera)
• Settings panel (camera, grid, gizmo, accent color options, 6 harmony presets)
• Project Settings panel (rendering/physics defaults separated from editor preferences)
• Effects panel (post-processing, retro effects)
• Skybox panel with procedural presets
• Stats overlay (FPS, frame time, draw calls, triangle count)
• Profiler (per-system breakdown, scope timers, memory tracking)
• Shader Graph editor (54 node types, GLSL code generation)
• Visual Script editor (146+ node types, variables, debugger, execution profiler)
• Animation Graph editor (dual-mode state machine, play-mode highlighting)
• Behavior Tree editor (20 node types, blackboard, auto-layout)
• Quest Flow editor (visual quest graph)
• Audio Event Graph editor (dynamic mixing, runtime execution)
• Particle Graph editor (visual authoring, compiler to component)
• Particle Editor (12 presets, color gradient bar, size/speed curves, shape preview)
• UI Editor (WYSIWYG with click-select, drag-move, resize handles, element tree)
• Pixel Editor (8 tools, layers, retro presets, onion skinning)
• Sprite Sheet Importer (grid/auto-detect slicing)
• Vector Drawing Editor (7 shapes, layers, SVG export)
• Scene List (multi-scene project management)
• Command palette (Ctrl+P, 25+ commands for quick access)
• Project Hub (startup wizard with template browser, recent projects)
• Keyboard Shortcuts Help (Ctrl+Shift+/, searchable modal)

Tools

• Transform gizmos (translate, rotate, scale via ImGuizmo)
• Entity selection via ray casting, double-click to focus
• Multi-select (Ctrl+click toggle, Shift+click range, viewport marquee selection with batch transform)
• Play/Pause/Stop with input isolation (scene changes persist on stop)
• Undo/redo (command pattern)
• Entity clipboard (cut/copy/paste via JSON)
• Terrain brushes (5 modes: raise, lower, flatten, smooth, paint) with adjustable radius/strength/falloff
• Native file dialogs (Win32, macOS osascript, Linux zenity/kdialog)
• Asset hot-reload (file watcher polls texture files)
• Build dialog - configure and export standalone game builds from the editor
• Bug reporting and feedback - built-in reports with auto-captured diagnostics, satisfaction ratings
• Collaborative editing - real-time multi-user scene editing with OT protocol, peer cursors, conflict resolution
• Symbol library - reusable graphic symbols as prefabs with nested editing and update propagation
• Notification toasts - stacked bottom-right toast notifications with slide-in animation
• Theme preview - live preview pane in editor settings showing current theme in real-time
• Smart suggestions - 12 context-aware rules detect missing components and recommend collider shapes based on entity context and mesh bounds
• Quick setup patterns - 7 one-click patterns (Basic Movement, 2D Platformer, Patroller, NPC, Collectible, Destructible, Physics Object) with 2D/3D adaptation
• Empty state patterns - helpful empty-state messages with call-to-action buttons in all panels

Templates

44 startup templates across 7 categories:

• Foundations: Blank, 2D Platformer, 2D Top-Down, 3D Isometric, 3D Third Person, 3D First Person
• Genre Showcases: Visual Novel, RPG Village, Survival, PS1 RPG, City Builder
• Systems Deep-Dives: Game Manager, 3D Narrative, and more
• Retro & Flash: Flash-style templates
• Advanced: 4P Racing, Arena Fighter
• Multiplayer & Debug/Test: Networking and testing templates

Template Creator (View > Tools) for saving custom templates with metadata. Template Marketplace with 15 curated templates, search, filter by category, sort by name/rating/downloads.

Controls

Scene Management

• .enjinproject JSON manifest format
• Scene manager with project manifests, scene lists, build indices
• Scene transitions (Instant, Fade Black, Fade White, Cross Fade with configurable duration)
• Prefab system (save/load entity templates)
• Full JSON scene serialization with all component data

Platform Support

• Windows: Primary development platform, ZIP packaging via CMake/CPack
• Linux: LinuxPlatform helpers (XDG paths, zenity dialogs, fork/exec), AppImage packaging
• HTML5: Web export with preloader and responsive scaling, Newgrounds.io API integration
• Steam Deck: Auto-detection, adaptive quality, gyro input stubs, suspend/resume lifecycle, Steam Input API stubs
• Nintendo Switch 1: NVN render backend stub, Joy-Con/touch/docked mode stubs (requires licensed devkit)
• Hub Application: Standalone project launcher with project manager, engine version manager, template browser

System Requirements

The primary requirement is a GPU with Vulkan 1.3 support. This includes NVIDIA GTX 600 series or newer, AMD Radeon RX 400 series or newer, and Intel Arc or UHD 600+ with up-to-date drivers. Ray tracing features are optional and will be disabled automatically if the GPU does not support them.

Technical Analysis

A comprehensive technical analysis of the engine architecture, systems, and design decisions.

Roadmap

Building

Prerequisites

• CMake 3.20+
• C++20 compatible compiler (GCC 10+, Clang 12+, MSVC 2019+)
• Vulkan SDK
• GLFW3

Linux / macOS

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

Windows

mkdir build && cd build
cmake .. -G "Visual Studio 16 2019" -A x64
cmake --build . --config Release

Running

# Editor
./build/bin/Release/EnjinEditor.exe   # Windows
./build/bin/EnjinEditor               # Linux/macOS

# Standalone Player (requires game.enjpak in same directory)
./build/bin/Release/EnjinPlayer.exe   # Windows
./build/bin/EnjinPlayer               # Linux/macOS

Build Options

Technology Stack

All dependencies use permissive licenses compatible with WBSL and Apache 2.0.

License

TEGE is released under the WBSL (Works-Based Source License). Source code is open and available for use, modification, and distribution. After approximately 3 years, the license converts to Apache 2.0.