urho3d/urho3dArchived

Features

• 3D Game Engines - A cross-platform 3D game engine with built-in scripting, physics, and a visual editor for rapid iteration.
• 2D and 3D - Renders visual scenes using hardware-accelerated graphics via Direct3D or OpenGL for both 2D and 3D content.
• Component-Based Node Hierarchies - Creates a hierarchy of nodes with attached components to define objects, transforms, and behaviors.
• Component-Based Scene Graphs - Constructs a scene hierarchy using nodes with attached components for modular object composition.
• Physics and Simulation - Ships a full physics simulation engine for rigid bodies, vehicles, and constraints in 2D and 3D.
• State Replication - Synchronizes scene state across UDP connections by replicating marked attributes with delta compression.
• Keyboard and Mouse Event Capture - Polls keyboard and mouse state with differentiation between press initiation and hold, and supports both symbolic keycodes and layout-independent scancodes.
• Cross-Platform Build Tools - Compiles the engine to run on desktop, mobile, console, and web platforms.
• Application Lifecycle Callbacks - Provides a base class with lifecycle callbacks and a macro to define the program entry point.
• 3D Scene Editors - Provides a built-in editor for composing 3D scenes and user interface layouts.
• Cross-Platform Game Compilation - Builds and deploys games on desktop, mobile, console, and web from a single codebase with CMake.
• Dynamic Navigation Meshes - Generates dynamic navigation meshes with runtime obstacle insertion for AI pathfinding in 3D worlds.
• Scripted Component Schemas - Defines custom behaviors by creating script objects or new components attached to scene nodes.
• Game Loops - Initializes the engine and runs the application loop until the user exits the game.
• Stage Event Hooks - Fires events at each stage of the frame lifecycle to let scripts run custom logic.
• 2D Game Frameworks - Provides tools for building 2D games with sprites, tile maps, orthographic cameras, and 2D physics.
• Component-Based Scripting Platforms - Attaches script classes as scene node components with automatic lifecycle method invocation.
• Game Logic Scripting - Uses embedded scripting languages to define game behavior that executes during the game loop.
• Integrated Scripting Engines - Integrates AngelScript and Lua scripting with editor support, debugging, and automatic serialization of script state.
• Multiplayer Networking - Connects players over UDP with automatic scene replication, NAT punchthrough, and reliable messaging.
• Navigation Mesh Generation - Builds navigation meshes from scene geometry with partial rebuilds for dynamic environments.
• Rigid Body Physics Engines - Simulates rigid body dynamics, vehicle physics, and collision detection using the Bullet library.
• Customizable Render Pass Pipelines - Renders scenes with configurable pass sequences supporting forward, deferred, and light pre-pass shading.
• 3D Scene Renderers - Renders 3D scenes with forward, deferred, or light pre-pass pipelines and customizable render paths.
• Binary Shader Loaders - Loads compiled vertex and pixel shaders from a custom binary format for a specific graphics API.
• Keyframe Animations - Animates any object property by defining keyframes with values over time, with looping or single-play modes.
• Skeletal Animation - Animates characters and objects using skeletal rigs from Spine and Spriter.
• Multi-API Renderers - Hardware-accelerated rendering supporting both OpenGL and Direct3D across desktop, mobile, and web platforms.
• Binary Skeletal Animation Loaders - Loads skeletal animations from a custom binary format with keyframes for position, rotation, and scale.
• AngelScript and Lua Game Scripting - Integrates AngelScript and Lua scripting for game logic with editor support and debugging.
• Lua Game Event Handlings - Subscribes Lua functions or object methods to engine events, receiving event data as parameters for custom response logic.
• Lua Script Attachments to Nodes - Adds Lua scripts as components to scene nodes with automatic lifecycle method invocation.
• Lua Script Loadings and Executions - Loads Lua script files from the resource cache and makes their functions available for programmatic calls.
• Scripted Game Executions - Loads and executes an application script file to run game logic, starting with the Start() function before the main loop.
• Real-Time Multiplayer Frameworks - Connects players for real-time cooperative or competitive multiplayer sessions over the network.
• Resource Loading - Loads resources from disk into a cache with background file I/O to prevent main thread stalls.
• Script Class Bindings to Scene Nodes - Creates components from script classes that respond to scene updates, events, serialization, and network replication.
• Engine Initialization Configurations - Accepts a configuration map to set up subsystems and rendering before the application loop begins.
• Game State Replication - Automatically syncs nodes and components between server and clients with delta updates.
• Scene Serialization - Saves and loads entire scenes or individual node hierarchies as prefabs in binary, JSON, or XML formats.
• Pre-Built Widget UI Compositions - Uses ready-made elements such as buttons, lists, text fields, and windows to compose interactive game interfaces.
• Game Loop Updates - Drives each frame iteration, triggering a sequence of update events for application logic, physics, and rendering.
• Subsystem Registries - Manages the registration, construction, and event routing of application subsystems.
• Frame Rate Controllers - Controls frame update timing, frame rate limiting, and the main loop iteration sequence.
• Input Handling - Provides events for keyboard, mouse, joystick, touch, and gesture input from the player.
• 3D Asset Loaders - Loads and converts 3D model and animation formats into engine-ready assets.
• 3D Model Binary Loaders - Loads 3D models from a custom binary format containing geometry, LOD levels, vertex morphs, skeleton, and bounding box data.
• Physics and Navigation Integrations - Integrates physics simulation with navigation mesh generation for AI pathfinding in 3D environments.
• IK Effector Configurations - Configures target position, rotation, chain length, and weight for inverse kinematic effectors.
• Joystick Interfaces - Processes signals from joystick and gamepad hardware devices to enable character and action control.
• Joystick State Polling - Detects connected joysticks automatically and exposes state by ID or index, with game controller mappings for known button and axis layouts.
• Touch and Gestures - Processes multi-touch inputs with events and polling, and supports gesture recognition with recording, matching, saving, loading, and desktop emulation.
• Orthographic Camera Setups - Configures orthographic cameras with size and zoom for 2D rendering in the engine.
• Attribute-Based Serializations - Saves and loads object properties to binary or XML via declared attributes for durable game state.
• Cross-Platform Build Systems - CMake-based build system with Docker support for cross-compilation to multiple targets including WebAssembly and Apple TV.
• Interactive Consoles - Displays an interactive command line for executing AngelScript code and inspecting engine state.
• 2D Rigid Body Physics Engines - Simulates 2D rigid body dynamics, collisions, and constraints for sprite-based games.
• Crowd Agent Navigations - Guides multiple AI agents along computed paths with area costs and event-driven state tracking.
• Inverse Kinematics Character Animations - Automatically adjusts limb positions to reach target points for natural character posing and interaction.
• Sparse Navigation Mesh Generators - Builds navigation meshes covering only walkable areas to reduce memory and enable world streaming.
• Physics Body Configurations - Configures collision shapes, mass, filtering, and motion constraints for rigid body physics.
• Physics World Queries - Supports raycasts, sphere casts, and overlap tests for detecting bodies in the physics world.
• Player State Synchronization - Synchronizes player input and state from clients to servers for authoritative multiplayer gameplay.
• Prefab Serialization - Saves a selected node with its components and children into a file, then loads it back to speed up scene construction.
• Scene Object Manipulators - Manipulates scene objects through creation, attribute editing, transform controls, variable management, and multi-selection editing.
• Navigation and Crowd State Managers - Tracks navigation mesh changes, crowd agent states, and obstacle updates for AI movement.
• Vehicle Physics Engines - Models vehicle movement and suspension using the Bullet RaycastVehicle system for realistic driving.
• Sprite Sequence Animations - Animates characters and objects using sprite sequences from Spine and Spriter.
• Spriter Sprite Animations - Loads Spriter .scml files and renders animated sprites with speed, looping, and mirroring controls.
• Static Sprite Renderers - Renders static 2D sprites from images or spritesheets with configurable hotspot, opacity, and material.
• Area Light Sources - Creates volumetric-looking particles and simulates non-point light sources for more realistic scenes.
• Rendering Quality Settings - Adjusts texture quality, shadow resolution, and other rendering options at runtime during gameplay.
• Sprite Layer Ordering - Sets a scene's background color and arranges sprites on layers with customizable ordering.
• Scene Element Queries by Criteria - Queries nodes and components by name, ID, or tag to locate specific objects in the scene.
• Tile Map Renderers - Parses Tiled TMX files and renders tile map layers with support for multiple projections.
• Particle Effects - Loads .pex particle definitions and renders dynamic particle emitters for visual effects.
• Per-Instance Rendering Data - Extends hardware instancing with custom per-instance data like color and offset for drawable classes.
• Per-Node Update and Render Toggles - Enables or disables updates and rendering per node or component to pause or hide parts of the scene.
• Dynamic Obstacle Managers - Adds or removes cylindrical obstacles on a navigation mesh without full rebuilds for faster updates.
• Connection Establishment Protocols - Establishes UDP connections to game servers with identity data for client-server multiplayer.
• NAT Punchthrough Connections - Provides NAT punchthrough via a master server to enable direct peer-to-peer multiplayer connections.
• Script Precompilers - Compiles AngelScript and Lua source files into bytecode for faster loading and distribution.
• IK Solver Configurations - Selects solver algorithms and adjusts iteration count and tolerance for inverse kinematic convergence.
• Scene Graph Mutation Events - Listens for events when nodes or components are added, removed, or modified to keep logic in sync.
• Multi-Viewport Renderers - Defines multiple viewports for split-screen, overlays, or off-screen rendering with configurable render order.
• Shared View Culling for Stereo Rendering - Shares a single culling camera across viewports to avoid redundant visibility queries in VR and multi-view setups.
• Layout and Anchoring Systems - Provides automatic horizontal/vertical layout modes and proportional anchoring for user interface elements.
• Rendering Optimizers - Automatically applies occlusion culling, hardware instancing, and light stencil masking to reduce load.
• Game Engines and Frameworks - Lightweight cross-platform 2D/3D engine.
• Game Frameworks - Cross-platform framework for 2D and 3D games.
• Graphics and Rendering - Cross-platform rendering and game engine.

Star history