o3de/o3de

Features

• 3D Game Engines - Provides a comprehensive framework for rendering high-performance 3D graphics and managing interactive game and simulation logic.
• Forward+ Rendering Pipelines - Implements a multi-threaded Forward+ renderer to produce high-fidelity visuals with optimized lighting passes.
• Simulation Frameworks - Provides high-fidelity simulation frameworks and extensible modules for building robotic scenarios and AAA games.
• Autonomous Agent Creation - Provides frameworks for building autonomous agents that perform ground-based navigation and follow behavior trees.
• Behavior Trees - Provides visually scripted behavior trees to control complex agent actions, logic, and pathfinding.
• Entity Management - Manages the creation, naming, and component attachment of game entities via a bus-based messaging system.
• Robotics Simulators - Serves as a simulation environment integrating with ROS 2 to model robot controllers, sensors, and physical interactions.
• ROS Libraries and Tools - Integrates with ROS 2 to simulate robot controllers, sensors, Lidar, and real-world geo-referencing.
• Graphics Rendering - Implements a high-performance graphics engine capable of producing cinematic 3D worlds and simulations.
• Asset Build Pipelines - Transforms raw source meshes and textures into platform-optimized runtime assets via an asynchronous processor.
• State Replication - Synchronizes data from a server to clients automatically, triggering events when values change.
• Packageable Tooling Modules - Packages code, assets, and tools into modular units that can be independently enabled or disabled.
• Plugin Dependency Management - Provides tools to add, remove, and register external plugins and code modules to extend project capabilities.
• Modular Feature Sets - Allows adding, removing, and configuring modular feature sets called Gems to customize project capabilities.
• Game Object Compositions - Implements a modular system for building game objects by attaching functional components to entities.
• Visual Scripting Systems - Provides a graphical node-based editor for developing runtime gameplay logic and AI behavior trees.
• Cloud Infrastructure Integrations - Connects 3D environments to AWS services for authentication, resource mapping, and multiplayer session hosting.
• Agent Navigation Systems - Implements ground-based AI agents that navigate 3D environments using visually scripted behavior trees.
• Client-Server Architectures - Implements a network model that isolates authoritative server behavior from client-side logic.
• Component Property Editing - Enables adding and configuring individual components on an entity to change visual appearance or behavior.
• Entity Component Systems - Utilizes a component-based entity system to define game object behavior, visuals, and physics.
• Entity Definition - Enables the definition and modification of basic objects that populate 3D scenes.
• Entity Templates - Implements templates for objects that can be instanced multiple times to maintain consistency across the world.
• Entity Transformations - Implements mouse-driven manipulators for adjusting the position, rotation, and scale of 3D entities.
• Game Logic Scripting - Enables development of runtime behaviors and game mechanics through a node-based visual scripting editor and Lua scripting.
• Landscape Authoring Tools - Provides tools to create terrain with height and color mapping and populate worlds with vegetation using a node-graph.
• Level Construction - Provides tools to build the fundamental 3D environments and scene structures for games and simulations.
• Navigation Mesh Generation - Builds navigation meshes and calculates walkable paths for agents to move through a 3D world.
• NavMesh Tiling Systems - Creates a network of 2D tiles defining navigable areas of a level based on configurable agent sizes.
• Network Latency Compensation - Handles entity replication, local prediction, and server-side backward reconciliation for multiplayer gameplay.
• State Synchronization Engines - Synchronizes state between clients and servers using low-latency transport and server-authoritative replication.
• Physics Simulation Engines - Integrates a physics engine to create realistic movement and interactions for 3D objects.
• Prefab Instantiation - Places saved prefabs into a level as instances that receive updates from the source file.
• Scripted Logic Systems - Enables game logic development using pre-compiled components and scripting languages without requiring a C++ compiler.
• Simulation Worlds - Provides a unified environment for creating high-fidelity 3D worlds and managing global simulation properties.
• Component-Based Entity Definitions - Creates entities by combining various components to define an object's specific behavior and position.
• World Design Tools - Provides tools for arranging entities, prefabs, lights, and cameras to define simulation maps and environmental rules.
• Source-to-Runtime Asset Conversion - Deno converts raw source files into platform-specific runtime assets automatically.
• Spatial Editors - Provides a visual spatial editing environment for arranging objects and environments to build interactive worlds.
• 3D Asset Pipelines - Implements a unified, asynchronous loading pipeline to import and optimize industry-standard 3D file formats into runtime assets.
• 3D Rendering Engines - Provides a high-performance 3D rendering engine with hardware-accelerated ray tracing and global illumination.
• Custom Shader Programs - Provides a specialized language for writing custom GPU shader programs to control the render pipeline.
• Vertex Shaders - Allows developers to author vertex shaders for geometry effects like vegetation bending.
• Node-Based Shader Editors - Includes a dedicated node-based editor for creating textures, shaders, and color profiles.
• Physically Based Rendering Materials - Implements a physically based rendering workflow using base color, roughness, and normals.
• Physically Based Rendering - Implements a multi-threaded Forward+ rendering pipeline supporting hardware-accelerated ray tracing and global illumination.
• Object Hierarchy Management - Implements a system for nesting 3D objects to propagate transformations and manage complex scene compositions.
• Scene Composition - Allows users to place, group, and configure entities within a viewport to assemble interactive environments.
• Multiplayer Game Servers - Coordinates multiplayer session management and server scaling through integration with Amazon GameLift.
• Remote Procedure Calls - Triggers specific functions across the network, allowing clients to send data or requests to the server.
• Platform Support - Supports installation and project creation across Windows, Linux, and macOS environments.
• State Replication - Synchronizes entity data from server to clients using low-latency transport and latency compensation.
• Event Bus Architectures - Implements a request and publish/subscribe event bus to decouple independent modules and threads.
• Custom Module Implementations - Supports the development of independent packages (Gems) containing assets and source code to share functionality across projects.
• Modular Extension Architectures - Uses a modular Gem-based architecture to add or replace features without recompiling core binaries.
• Modular Extension Systems - Implements a plugin architecture using Gems to add or replace engine features and assets without modifying core binaries.
• Asset Packages - Packages C++ code and assets into modular, loadable units that can be shared across different projects.
• Networked Component Development - Develops C++ components that synchronize state and data across multiple clients in a shared environment.
• Prefab Systems - Provides a system to define complex entities with properties and hierarchies that can be shared and spawned dynamically.
• Programmatic Component Management - Provides an API to programmatically add component types to entities and query their metadata.
• Modular Dependency Management - Manages modular feature sets called Gems to control loaded assets and code dependencies.
• Asset Optimization Pipelines - Transforms raw meshes, textures, and animations into runtime-optimized product assets using a configurable processing pipeline.
• Multiplayer Synchronization - Builds networked components to synchronize state and logic across multiple clients.
• Agent Profiling - Defines agent properties and default behavior trees via XML to determine how agents interact with the world.
• Game Physics Integration - Integrates heightfield colliders and physics materials to enable physical simulations within a landscape.
• Terrain and Elevation - Creates 3D terrain by mapping image-based elevation data to world-space entities.
• Gradient-to-Elevation Transformation - Transforms image gradients into elevation data and material weight masks to create landscapes.
• 3D Terrain Mesh Generation - Generates 3D surfaces and landscapes by triangulating elevation models derived from image-based heightmaps.
• Cross-Platform Compilers - Produces binaries for Windows, Linux, macOS, iOS, and Android using platform-specific compiler toolchains.
• Legacy Asset Parsers - Transforms entity components and assets from previous engine versions into compatible current formats.
• JSON Patching - Imports external settings into the engine registry using standard JSON Patch and Merge Patch algorithms.
• SIMD-Accelerated Arithmetic - Executes precise mathematical calculations using SIMD-accelerated libraries optimized for x64 and ARM architectures.
• Application Configuration Management - Implements a centralized system to define, query, and modify application settings using JSON files and JSON Pointer syntax.
• Graphics Asset Compilers - Implements build-time tools for processing and optimizing 3D geometry, shaders, and textures for real-time rendering.
• Build Configurations - Creates platform-specific project files and configuration settings to define parameters for the software build process.
• Compiler Configurations - Uses configurable build types and settings to adjust compiler behavior for various development needs when building engine binaries.
• Library Bundling Configurations - Defines configuration parameters to determine whether the project uses static or shared libraries for code bundling.
• Asset Bundling - Identifies and bundles only the necessary assets for a production release using a dependency-based system.
• Editor Tooling - Enables the creation of custom editor tools and dialog windows using Python and Qt for automating configurations.
• Platform-Specific Restrictions - Includes or excludes specific Gem modules based on the target operating system or hardware platform.
• Runtime Debugging - Visualizes runtime data through debug drawing, immediate mode GUI overlays, and remote debugging.
• Editor APIs - Provides a UI API to create custom dockable tool widgets using C++ to expand the editor interface.
• Editor Extensions - Allows the creation of custom dockable widgets and dialog windows in the editor using C++ or Python.
• Engine Compilation Tooling - Compiles the core engine, editor, and associated tool dependencies into target output directories.
• Executable Binary Production - Compiles project source and third-party dependencies into executable binaries for a specific platform.
• Extension Repository Scaffolding - Creates the necessary folder and file structure to host and distribute a collection of modular Gems.
• Extension Scaffolders - Generates boilerplate directory structures and files to scaffold new modular engine extensions.
• Extension Unregistration - Provides the ability to unregister previously linked external feature sets by removing their configuration paths.
• External Binary Lifecycle Managers - Manages the integration and versioning of pre-compiled libraries and external binaries as project dependencies.
• Global Configuration Managers - Implements a system for storing and retrieving global configuration values using JSON pointers.
• IDE Project Generators - Automatically creates project structure and configuration files to enable development within specific IDEs.
• Project Configuration - Provides tools for managing the association between a specific project and its target engine build.
• Project Initializers - Ships tools to bootstrap new project directories and populate them with selected templates via GUI or CLI.
• Project Templates - Provides pre-configured project structures that automatically configure default gems and C++ modules.
• Project Scaffolding Templates - Provides tools to generate new project structures and custom source templates to accelerate development.
• Project Settings Managers - Defines build variables and manages build modes and dependency groups through a CLI or graphical tool.
• Asset Optimization Tools - Converts source resource files into platform-optimized versions via an automated background processor.
• CLI Build Executors - Provides a command-line interface for triggering the compilation of project source code into runnable applications.
• Cloud Deployment - Implements automated deployment of infrastructure resources for 3D projects using Cloud Development Kits.
• Cloud Service Orchestrations - Orchestrates server scaling, authorization, and metrics submission via AWS cloud services.
• Cloud Provisioning - Provisions cloud compute and infrastructure resources using AWS Cloud Development Kit and CloudFormation.
• Asset-to-Resource Mappings - Defines associations between local assets and remote cloud resources via JSON schemas.
• Cloud Service Integrations - Integrates 3D environments with cloud services using a native SDK and RESTful HTTPS calls.
• Configuration Merging Engines - Combines settings from CLI parameters, in-memory JSON, and external files using a defined precedence order.
• Configuration Merging - Combines multiple JSON-formatted settings files into a single registry using import directives.
• Cross-Platform Packaging Tools - Compiles and packages applications into native executables for multiple operating systems including Windows, Linux, and mobile platforms.
• Logical-to-Resource Mappings - Decouples code from deployments by mapping logical lookup names to specific AWS resource attributes.
• Configuration Set Grouping - Organizes variables into hierarchies to apply predefined sets of values simultaneously across the engine.
• Scene Importers - Loads 3D content from standard formats and allows for the addition of new scene file type support.
• Asset-to-Backend Linking - Links cloud-based resources to 3D project assets to enable shared data and asset usage.
• Rapid Prototyping - Enables quick creation of small-scale playable projects to test gameplay ideas across different perspectives.
• Actor Asset Processing - Deno converts 3D actor source files into runtime assets by defining mesh groups and skeleton root bones.
• Dual-Target Binary Production - Produces single-user application builds or dedicated server binaries from a shared codebase.
• Hierarchical Entity Management - Deno views, selects, and manages all entities within a scene through a hierarchical list.
• Gameplay Extensions - Provides a system for adding custom gameplay mechanics and features through modular extensions.
• Object Spawning - Triggers the creation and removal of prefabs during runtime using a visual scripting interface.
• Game State Management - Tracks and controls high-level game states such as menus, loading, and active gameplay.
• Game State Variables - Tracks entity status using boolean or numeric variables to conditionally trigger logic.
• Greyboxing Tools - Allows sculpting and manipulating geometric volumes directly in-engine to quickly sketch world layouts.
• GUI Build Interfaces - Ships a graphical user interface for compiling project source code and dependencies into binaries.
• Physical Material Properties - Maps specific physical properties like friction and bounce to collider surfaces.
• Collision Detection - Adds collision shapes and physical properties to terrain surfaces for interactive simulations.
• Specialized Physical Simulations - Provides advanced realism through SDKs for rigid body dynamics, cloth simulation, and hair and fur.
• Prefab Instance Overrides - Changes properties or structure of specific prefab instances without affecting the original template.
• Prefab Serialization - Saves entity configurations to disk files as prefabs for reuse or runtime spawning.
• Runtime Entity Despawning - Removes spawned prefab objects from the scene based on triggers or timed delays.
• Runtime Prefab Spawning - Creates and places prefab objects into the scene at runtime using a visual node-based scripting system.
• Activation States - Defines whether an entity starts as active, remains inactive until triggered, or exists only in the editor.
• Prefab Templates - Converts entities into reusable templates that can be instantiated multiple times across a scene.
• Procedural Generation - Uses procedural generation techniques to create high-quality, expansive 3D landscapes.
• Viewport Selection Tools - Provides selection boxes to group multiple objects in the viewport for simultaneous transformation.
• World Entity Optimization - Manages high volumes of entities and complex assets to ensure performance in expansive 3D projects.
• 2D Sprite Animations - Implements a system for rendering and animating 2D spritesheets within a 3D environment.
• Animation Graph Authoring - Creates sophisticated motion sets and animation graphs using blend trees and state-based logic.
• Audio Playback - Provides audio playback, positioning, microphone input, and integration with external sound engines.
• Character Animation Authoring - Provides a dedicated animation editor to build animated behaviors and simulated objects for rigged actors.
• Custom Shader Programming - Supports writing custom shader code to control vertex and fragment processing and configure pipeline states.
• Mesh Decomposition - Splits complex input meshes into smaller parts to fit primitive or convex colliders for better physics accuracy.
• Vertex Manipulation - Manipulates geometry at the vertex level to create specialized effects like vegetation bending.
• 3D Lighting Models - Allows for the implementation of custom diffuse and specular lighting functions to determine surface response to light.
• Image-Based Lighting - Simulates environment reflections on surfaces by sampling skyboxes using image-based lighting techniques.
• Custom Material Definitions - Enables the definition of unique material behaviors through custom shaders for effects such as volumetrics.
• Material Instancing - Allows the creation of specific visual instances based on material types with adjustable properties.
• Material Templates - Defines reusable material templates by linking shaders to specific property groups.
• Post-Processing Pipelines - Implements post-processing pipelines for visual enhancements like bloom and depth of field.
• Multi-Pass Rendering Pipelines - Configures multi-pass rendering pipelines by assigning specific shaders to stages like depth or shadowmaps.
• Render Pass Inspection - Visualizes the output of specific rendering passes and shader stages using a tree-based tool.
• Post-Processing Effects - Provides runtime adjustment of full-screen filters and exposure control using shape weight modifiers.
• Scene Management Systems - Includes a framework for organizing, initializing, and managing the hierarchical structure of objects within 3D scenes.
• Scene Initialization - Handles the initial configuration of rendering contexts, cameras, and default environment entities.
• Material and Shader Configuration - Defines the visual properties and shaders of 3D surfaces to achieve specific artistic looks.
• Real-Time Shader Parameters - Creates JSON layout parameters that can be modified in a visual editor to control shaders in real-time.
• Graphics Pipeline Customization - Enables the modification of the rendering process through custom passes and feature processors.
• Cinematic Animation Sequences - Includes a track-based editor for authoring animated sequences and cinematic timelines.
• Mesh-Based Collision Geometry - Creates optimized collider assets from 3D source meshes using triangle meshes, primitives, or convex hulls.
• Mesh Processing Configuration - Defines rules for how 3D source files are converted into engine-ready assets, including grouping and transformations.
• Root Motion Synchronization - Translates an actor's world position based on animation data to ensure characters move physically through space.
• Surface Property Editors - Provides a dedicated editor to define and modify the visual properties of 3D surfaces.
• Terrain Texture Blending - Implements alpha and height-based blending using displacement maps for realistic terrain transitions.
• Texture Frequency Separation - Manages different levels of detail in materials to separate broad shapes from fine surface textures.
• Dynamic Library Loading - Automatically loads shared library modules (Gems) at runtime based on project build dependencies.
• Build Optimizations - Generates binaries tailored for debugging, performance profiling, or final release by adjusting compiler optimization levels.
• Loading Overrides - Prevents specific Gem modules from loading automatically using registry overrides.
• Source Code Generators - Programmatically generates C++ source files from Jinja templates and XML or JSON data files during the build process.
• Authentication Flows - Implements secure cloud authentication and resource sharing via AWS SDK and OpenID token flows.
• AWS Authentication Strategies - Configures cloud service access using IAM keys, Cognito tokens, and local authentication profiles.
• AWS Credential Management - Manages AWS credentials through CLI profiles, IAM roles, and console variables for secure cloud access.
• Resource Access Control - Controls interaction with cloud services by configuring authentication profiles and resource mapping files.
• Entity Behavior Modules - Defines logic using a visual graph to handle input events, calculations, and entity property manipulation.
• Configuration Registries - Manages application state and settings using a hierarchical JSON registry with merge-patch overrides.
• External Extension Registrations - Enables the linking of external feature sets and assets from local or remote sources into a project.
• Build Performance Optimization - Accelerates compilation times by merging multiple source files into single compilation units to reduce overhead.
• Platform-Specific Configuration Merging - Applies configuration files from platform-named directories to ensure OS-specific engine behavior.
• Programmatic Plugin Loading - Triggers the loading of modular Gem extensions programmatically through C++ code.
• Programmatic Entity Manipulation - Provides an API to programmatically create entities and modify their transform properties through internal engine buses.
• Extension Set Management - Adds, removes, or toggles feature sets from internal or external sources using a project manager.
• Project Organization - Creates, renames, deletes, duplicates, and moves 3D assets within the project directory to organize resources.
• Simulation Blueprints - Provides pre-configured project blueprints for game mechanics and robotic simulations to accelerate setup.
• Project Asset Browsers - Organizes on-disk project assets and internal editor files through a directory-based browser.
• Component Property Systems - Enables the addition, removal, and modification of components and their properties for 3D entities.
• Component Property Configurators - Provides a visual interface to modify specific attributes of entity components directly within the 3D view.
• View Pivot Point Management - Allows toggling between a model's local origin and geometric center to adjust rotation and scaling points.
• Vector Interpolators - Calculates smooth transitions between two positions over time to avoid instant teleportation.
• Coordinate Space Transformations - Provides tools to transform selected objects relative to local, world, or custom coordinate systems for precise positioning.
• Extensible UI Component Kits - Provides a modular UI framework and standardized widgets to create consistent editor tools and extensions.
• Runtime UI Construction - Creates runtime UI elements and interfaces using a dedicated UI system and editor.
• Texture Mapping - Maps global color and normal textures to terrain surfaces to establish base visual appearance.
• Terrain Material Assignment - Assigns surface types and materials to terrain using either entity references or a node-based graph.
• Gradient-Based Material Mapping - Maps textures and surface types to landscapes based on image-derived gradient masks.
• Terrain Detail Material Configuration - Creates specialized materials with texture blend modes and displacement maps for specific surface tags.
• Splat Map Application - Maps specific materials to landscape areas using splat map textures to define surface appearance.
• Texture Detail Splitting - Splits a texture into low-pass macro maps and high-pass detail maps for terrain painting.
• UI Design Tools - Provides a dedicated editor for creating interactive UI canvases and spatial layouts.
• Viewport Navigation Controls - Implements real-time camera movement through scenes using keyboard and DCC-style orbit/dolly controls.
• Visual Node Editors - Provides a framework and data model for building custom graphical node-based editors.
• Instance-Specific Theming - Provides capabilities for applying unique property overrides to individual instances of a prefab.
• Simulators - Multi-platform 3D engine for virtual worlds.
• 3D Game Engines - Open-source real-time multi-platform 3D engine.
• Game Development Engines - Modular, open-source engine for 3D content and games.
• Game Engines - Multi-platform AAA engine focused on high-fidelity 3D visuals.
• Game-Engines - Real-time multi-platform 3D engine.

Star-Verlauf