FyroxEngine/Fyrox

Fyrox is an open-source, cross-platform 3D and 2D game engine and editor written in Rust. It provides a comprehensive suite of tools for game development, including a visual editor with scene management, asset pipelines, and UI layout design, alongside core engine subsystems for rendering, physics, audio, and animation. The system supports multiple graphics backends, dynamic plugin architecture, and export to PC, mobile, and web platforms.

37 changes.

The project was renamed from rg3d to Fyrox, accompanied by a major version update and dependency refresh. Significant effort focused on releasing the standalone editor source code, implementing core UI components like the inspector and asset browser, and establishing a robust reflection and serialization system via procedural macros.

71 changes.

This period focused on restructuring the editor into a modular plugin architecture, extracting components like the material, animation, and inspector editors into standalone units. Simultaneously, the engine underwent a significant rendering overhaul, introducing a new cache subsystem, native shader support, and optimized GPU resource management. The work also expanded core capabilities with new 2D physics, tilemap, and terrain systems, alongside improved asset loading and UI styling.

18 changes.

This period focused on restructuring the engine's architecture by extracting materials, shaders, and UI resources into dedicated crates, while simultaneously introducing a new WGPU graphics backend alongside the existing OpenGL implementation. Significant features were added to support game development, including a kinematic character controller, an autotiling library, and enhanced editor tooling for project export and shader editing.

The \fyrox-graphics-gl\ module now includes a new \shared.glsl\ file that provides common GLSL functions automatically included in all engine shaders. This adds support for physically-based rendering (PBR) calculations, including GGX distribution, Smith geometry, and Fresnel-Schlick approximations, as well as utility functions for ray-sphere intersection, light attenuation, and point shadowing.

fyrox-graphics-gl/src/shaders · high confidence

The renderer now includes a new tile-based occlusion culling system in the \occlusion\ module. This feature introduces a \GridCache\ that stores visibility information in a spatial grid based on observer position, allowing the engine to bypass latency issues by caching visibility data. The \OcclusionTester\ manages GPU framebuffers and tile buffers to determine object visibility, while the \VisibilityBufferOptimizer\ processes visibility masks and uses an asynchronous read buffer to efficiently transfer results from the GPU, reducing the number of draw calls for objects outside the view frustum.

fyrox-impl/src/renderer/occlusion · high confidence

The animation blending state machine in \fyrox-animation/src/machine\ now includes a new \IsAnimationEnded\ logic node within the \LogicNode\ enum. This allows transition rules to evaluate whether a specific animation has finished playing, enabling state changes that are triggered by animation completion rather than just boolean parameters. This change is part of a broader restructuring of the animation machine module, which also introduces dedicated modules for events, layers, masks, and parameters to support more complex, layered animation graphs.

fyrox-animation/src/machine · high confidence

The standalone editor now accepts command-line arguments to specify the project root directory, a list of scenes to load, and a flag to enable named objects. This allows users to launch the editor with a specific project context and initial scene state directly from the terminal, rather than relying solely on interactive selection.

editor-standalone/src · high confidence

The editor now includes a dedicated collider shape editing plugin that provides in-scene gizmo handles for editing various collider shapes (ball, capsule, cone, cuboid, cylinder, segment, triangle) in both 3D and 2D modes. Users can directly manipulate shape parameters like radius, half-extents, and endpoints via visual handles. A new control panel with 'Try Fit' and 'Edit' buttons allows users to automatically fit colliders to their parent rigid body's bounding box or toggle the shape editing interaction mode.

editor/src/plugins/collider · high confidence

The docking manager now supports saving and restoring its layout configuration, allowing users to persist their window arrangements across sessions. This change introduces a new serialization format that identifies windows by name rather than internal identifiers, ensuring layouts remain valid even if widget handles change. Additionally, the docking system now supports multi-window tabs, allowing multiple windows to be grouped within a single tile, and improves the restoration process to correctly handle window visibility and opening states when a saved layout is applied.

fyrox-ui/src/dock · high confidence

The editor now includes a dedicated camera preview control panel that appears when a camera is selected in the scene, allowing users to view the camera's output in a separate window. This feature is supported by the introduction of a configurable exposure setting for the editor's camera, which is applied during camera initialization. The implementation also adds a built-in grid for spatial reference and refactors the camera controller to support orbital rotation modes and improved picking logic.

editor/src/camera · high confidence

The \fyrox-template\ tool now provides a structured command-line interface for managing Fyrox engine projects. Users can initialize new game projects with \init\, specifying the project name, style (2D or 3D), and version control system (defaulting to Git). The tool also supports generating script skeletons via the \script\ command and updating the engine version of existing projects using the \upgrade\ command, which allows targeting specific SemVer versions, the latest stable release, or a local engine path for development.

template · high confidence

The Fyrox game engine crate has been updated to support a new \dylib\ feature. When this feature is enabled, the public API is re-exported from the \fyrox\_dylib\ crate instead of the default \fyrox\_impl\ crate, allowing users to link against the engine as a dynamic library. This change is implemented in the main library entry point (\src/lib.rs\) and is accompanied by the addition of a README file providing project information, learning materials, and community links.

fyrox · high confidence

The scene graph now includes an event broadcaster that notifies subscribers when nodes are added or removed. This allows external systems, such as the editor or UI, to react to structural changes in the scene graph in real-time by subscribing to the new \GraphEventBroadcaster\.

fyrox-impl/src/scene/graph · high confidence

The editor now supports a WGPU rendering backend alongside the existing OpenGL one. This change adds WGPU-specific shader definitions for editor tools (gizmo, grid, highlight, overlay, sprite\_gizmo) and implements the core graphics abstractions (buffers, formats, framebuffers) required to drive the renderer via the WGPU API.

editor/resources/shaders, fyrox-graphics-wgpu, fyrox-impl/src/renderer/shaders · high confidence

The editor source code is now available in the \editor/src\ directory, providing the complete implementation for the editor's user interface, scene management, and plugin system.

editor/src · high confidence

This change introduces the first version of the glTF loader, enabling the import of .gltf and .glb files. The implementation includes modules for parsing animation tracks (with curve simplification), materials (mapping glTF properties to the engine's shader system), mesh surfaces (including blend shapes and skinning), and node hierarchy management (with automatic duplicate name resolution). It also registers a built-in standard shader and provides the necessary infrastructure to load textures and buffers from glTF documents.

fyrox-impl/src/resource/gltf · high confidence

The Inspector now includes a dedicated property editor for HashMaps, allowing users to view, add, edit, and remove key-value pairs directly within the UI. This change introduces a new \HashMapPropertyEditor\ component that renders individual entries with separate editors for keys and values, along with a dialog for selecting or modifying keys. Users can now manage dynamic collections in their scenes or assets without needing external tools.

fyrox-ui/src/inspector/editors/hashmap · high confidence

The new Inspector widget in fyrox-ui provides a visual interface for introspecting and editing arbitrary structures and enumerations using reflection. It supports editing complex properties, including collections (with add/remove/update actions), hash maps (with insert/remove/key-change actions), and inheritable variables (with revert-to-parent functionality). The widget features context menus for copying/pasting values, filtering properties by name, keyboard navigation, and tooltips displaying property descriptions and type names. It integrates with the editor's scene graph and property editor system to allow dynamic plugin registration and robust error handling for missing environments.

fyrox-ui/src/inspector · high confidence

A new Project Manager application is introduced, providing a dedicated UI to create, import, rename, delete, and run Fyrox projects. It features a project wizard for setting up 2D/3D projects with version control (Git, Mercurial, Pijul, Fossil), a list view with search filtering, and the ability to run projects with or without hot reloading. The manager includes an upgrade tool to update the Fyrox engine version (specific, local, or nightly), an integrated build window with a log panel, and settings management for IDE integration and cargo update behavior. It also supports opening projects in external IDEs and displays project sizes.

project-manager/src · high confidence

The UI library now supports centralized visual theming through a new \Style\ resource system. Users can apply styles to widgets using a \StyledProperty\ mechanism that binds widget properties to named style entries. The system includes two built-in themes, \DEFAULT\_STYLE\ (dark) and \LIGHT\_STYLE\, and supports properties for numbers, thickness, colors, brushes, and textures. A dedicated loader handles \.style\ files, allowing for external customization of the UI appearance.

fyrox-ui/src/style · high confidence

The formatted text system now supports granular styling through 'runs', allowing different formatting attributes (such as font, color, size, and shadow) to be applied to specific character ranges within a single text block. This change introduces the \Run\ and \RunSet\ structures to manage these style variations. Additionally, new text wrapping strategies have been added, including \NoWrap\, \LetterWrap\, and \WordWrap\, giving users control over how text breaks lines based on character count or word boundaries.

_fyrox-ui/src/formatted\text · high confidence

The \fyrox-core-derive\ crate is introduced, providing \\#\[derive(Visit)\]\ and \\#\[derive(Reflect)\]\ macros to automatically generate serialization and reflection implementations for structs and enums. The \Visit\ macro handles data traversal and serialization logic, while the \Reflect\ macro generates field metadata, property constants, and accessors, supporting features like field hiding, display names, and read-only flags. Additionally, a \ScriptMessagePayload\ derive macro is included to implement message payload traits.

fyrox-core-derive/src · high confidence

Added two new example applications: a 2D scene demonstrating sprite rendering with orthographic camera and point/spot lighting, and a navigation mesh example showcasing agent pathfinding, ray-casting for cursor interaction, and debug visualization of the navmesh.

examples · high confidence

The 2D scene module now includes dedicated nodes for 2D physics and rendering. Users can attach various collider shapes (Ball, Cuboid, Capsule, Segment, Triangle, Trimesh, Heightfield, TileMap) to rigid bodies for collision detection. The module introduces Joint nodes (Ball, Fixed, Prismatic) with support for motor parameters (target velocity/position, stiffness, damping, max force) and limits. A new RigidBody node handles physics dynamics, including velocity, damping, mass, sleep settings, and CCD. Additionally, a Rectangle node is available for 2D graphics, supporting texture mapping, color, UV rect regions, and flipping on X/Y axes.

fyrox-impl/src/scene/dim2 · high confidence

The editor now includes a dedicated Absm plugin that provides a complete visual editor for animation state machines. This new component introduces a canvas for graphically arranging states and transitions, a blend space editor for configuring animation blending, and a parameter panel for managing machine inputs. It also features a command system to support undo/redo operations for state and transition modifications, along with box selection and multi-selection capabilities for efficient node management.

editor/src/plugins/absm · high confidence

The \fyrox-sound\ crate now includes a new \dsp\ module providing core digital signal processing primitives. This adds a \DelayLine\ component for buffering audio samples, along with a \filters\ submodule containing reusable filter structures such as \OnePole\, \LpfComb\ (lowpass-feedback comb), \AllPass\, and a \BiquadKind\ enum for biquad filter configurations. These components are designed for sample-by-sample audio processing and support serialization via the \Visit\ trait.

fyrox-sound/src/dsp · high confidence

The FBX resource loader now uses a new internal parser located in \fyrox-impl/src/resource/fbx/scene\ to read and convert FBX files. This implementation introduces a document object model (DOM) that supports both ASCII and binary FBX formats, and parses scene components including meshes, models, materials, textures, lights, and animation curves. Users importing FBX files will now rely on this new parsing logic, which handles geometry, lighting, and animation data extraction from the FBX structure.

fyrox-impl/src/resource/fbx/scene · high confidence

The \fyrox-scripts\ crate now includes a \FlyingCameraController\ script, allowing users to create spectator-style cameras that rotate via mouse and move via keyboard. This new script is registered in the library's \register\ function, making it available for use in scenes without requiring manual implementation.

fyrox-scripts · high confidence

A new \template-core\ utility has been added to generate new Fyrox project scaffolds. It creates a workspace containing a Game library, an Editor plugin, and an Executor runner, with support for both 2D and 3D scene styles. The tool includes build scripts to automatically extract engine versions, validates project names against Cargo reserved keywords, and provides specific boilerplate and build instructions for Android and WebAssembly (WASM) targets.

template-core · high confidence

The sound engine now includes a Head-Related Transfer Function (HRTF) renderer, accessible via the \Renderer::HrtfRenderer\ variant in \fyrox-sound/src/renderer/mod.rs\. This renderer processes spatial sounds using HRIR sphere data to create binaural audio, significantly improving 3D sound perception. Users can switch to this renderer by providing an \HrirSphereResource\ when initializing the \HrtfRenderer\. Note that HRTF rendering is computationally intensive (4-5x slower than the default renderer) and is currently limited to mono spatial sources; stereo sounds will fall back to the default renderer.

fyrox-sound/src/renderer · high confidence

A new Scene Settings window has been added to the editor, providing a dedicated UI for inspecting and modifying properties of both Game Scenes and UI Scenes. The window features an inspector that supports editing physics integration parameters, physics worlds (2D and 3D), scene rendering options, and colors. It includes a property filter to hide internal node and widget pools, sets a fixed name column width, and ensures changes are applied via the command system to maintain undo/redo history.

editor/src/scene/settings · high confidence

The engine introduces a comprehensive TileMap subsystem located in \fyrox-impl/src/scene/tilemap\. This includes a new \TileMap\ node and \TileSet\ resource for managing 2D tile-based worlds, along with \TileMapData\ for chunked storage. Key features added are an autotiling system (\autotile.rs\) that uses nine-slice properties to automatically select tile patterns, a \TileMapBrush\ resource (\brush.rs\) for editing tools, and a \TileMapEffect\ system (\effect.rs\) that allows custom rendering overlays like cursors, selections, and tile updates. The system also supports tile properties (\property.rs\) for storing arbitrary data on tiles and \TileCollider\ definitions (\tile\_collider.rs\) for physics integration.

fyrox-impl/src/scene/tilemap · high confidence

The editor now includes a dedicated UI scene module that allows users to create, edit, and manage user interface layouts. This adds a context menu for widgets (copy, paste, delete, make root), a clipboard system for duplicating UI elements, and a BBCode panel for editing rich text properties. The world viewer now displays UI widgets with specific icons and type names, and the inspector supports reverting inheritable properties for widgets.

_editor/src/ui\scene · high confidence

The fyrox-ui library introduces several new widget types and animation capabilities. A new Animation Blending State Machine (ABSM) node allows mixing multiple animations from an Animation Player into a single output, with support for various blending nodes like BlendAnimations, BlendSpace, and logic nodes (And, Or, Xor, Not). The BitField widget provides a visual representation of numeric values as switchable bits. Additionally, a BBCode parser is added to support formatted text styling (bold, italic, color, size, shadow) within FormattedText widgets.

fyrox-ui/src · high confidence

The editor now includes a new World Viewer and Entity Creator interface. The World Viewer displays the scene hierarchy with icons for different node types (lights, joints, rigid bodies, colliders, sounds), supports searching, filtering, and context menu actions like creating child/parent nodes, copying, pasting, and saving as prefabs. The Entity Creator provides a searchable list of entities to instantiate, with sections for recently created items and matches, and supports creating child, parent, or replacement nodes. Selection handling is unified via GraphSelection, and the viewer respects editor settings for tracking selection and node validation.

editor/src/world · high confidence

The animation machine now includes new node types for evaluating and blending animation poses: \PlayAnimation\ extracts a pose from a specific animation, \BlendAnimations\ mixes multiple poses with configurable weights, and \BlendSpace\ uses 2D coordinate sampling to blend between poses. These nodes are registered as variants of the \PoseNode\ enum and implement the \AnimationPoseSource\ trait, enabling more complex animation state machines with dynamic blending capabilities.

fyrox-animation/src/machine/node · high confidence

The editor now includes a new asset management module under \editor/src/asset\ that provides a complete user interface for handling resources. This adds a Resource Creator dialog for generating new assets, a Dependency Viewer to visualize and export resource dependency graphs, and an Asset Browser with context menus for renaming, moving, and deleting assets. It also introduces an Asset Selector widget for picking resources in property editors and an Asset Selection container that integrates with the inspector to manage import options and save changes.

editor/src/asset · high confidence

The editor now uses a dedicated preview subsystem that generates and caches visual previews for various asset types (textures, models, sounds, shaders, materials, fonts, UI resources, surfaces, and curves). A background cache service processes preview requests asynchronously to reduce UI lag, storing generated textures by UUID and serving them to the asset browser or resource field editors. Each asset type has a specific generator that produces either a rendered scene preview, a waveform (for sound), or a simple icon, with a fallback placeholder for unsupported types.

editor/src/asset/preview · high confidence

The editor now includes a dedicated audio panel that allows users to create, delete, and link audio buses, as well as configure the distance model, sound renderer, and HRIR sphere for HRTF rendering. A new audio bus view widget enables visualizing bus hierarchies and managing parent-child relationships. Additionally, an audio preview panel provides playback controls (play, pause, stop, rewind) and a time slider for previewing sounds, with the time slider clamped to the buffer length to prevent invalid states.

editor/src/audio · high confidence

The sound system now includes a suite of new audio effects that can be applied to audio buses. Users can apply LowPass, HighPass, BandPass, AllPass, LowShelf, and HighShelf filters to shape the frequency content of sounds, as well as a Reverb effect to add spatial depth. These effects are exposed via the \Effect\ enum and are configurable through properties like cutoff frequency, gain, quality, decay time, and wet/dry mix.

fyrox-sound/src/effects · high confidence

The engine now includes a new behavior tree implementation in \fyrox-impl/src/utils/behavior\, providing a structured way to define artificial intelligence logic. This system introduces composite nodes (Sequence and Selector) for controlling execution flow, leaf nodes for user-defined actions, and inverter nodes to toggle success/failure states. These components are integrated into the \BehaviorTree\ structure, allowing developers to build complex AI decision-making trees.

fyrox-impl/src/utils/behavior · high confidence

The \fyrox-build-tools\ crate introduces a dedicated build system that includes a new \BuildWindow\ UI component, which appears on-demand to display build progress and logs while allowing users to stop the process. This tooling adds support for hot-reloading workflows via specific build profiles (e.g., \Debug (HR)\), enabling faster iteration by building game plugins as dynamic libraries. The implementation also ensures robust output handling by streaming both stdout and stderr in separate threads and prevents data loss from buffer dropping, while providing a \CommandDescriptor\ that can optionally skip the standard \--\ passthrough marker for greater compatibility with various build executables.

fyrox-build-tools/src · high confidence

The editor now supports copying and pasting scene nodes via a new clipboard system that deep-clones selected nodes into a separate graph, allowing users to duplicate or move content between scenes. A unified \SceneController\ trait and \EditorSceneEntry\ structure manage scene-specific logic, interaction modes, and command stacks for both game and UI scenes, while a new \NullSceneController\ handles the empty editor state. Additionally, a node removal dialog now warns users when deleting nodes referenced elsewhere in the scene, listing the specific reference pairs to prevent engine issues.

editor/src/scene · high confidence

Added new UI widgets for color manipulation, including a ColorGradientEditor that allows users to add, remove, and change the color of gradient points, as well as supporting widgets like ColorField, HueBar, AlphaBar, and SaturationBrightnessField to provide a complete color picking and gradient editing experience within the application.

fyrox-ui/src/color · high confidence

The editor now includes a dedicated Command Stack panel that displays a history of executed commands. Users can interact with this panel to undo, redo, or clear the command stack for the current scene. The panel features a list view showing command names, with visual distinction between executed and unexecuted states, and provides buttons for undo, redo, and clearing the history.

editor/src/command · high confidence

This update introduces several new foundational modules to fyrox-core. It adds a comprehensive Color type with HSV/HSL conversion and arithmetic operators, alongside a ColorGradient system for defining and interpolating color ramps. A new DynType system is introduced, allowing user-defined data structures to be dynamically typed, serialized, and inspected by the editor. The core also now includes a cross-platform I/O layer (supporting desktop, Android, and WebAssembly) with file loading and path checking, a configurable logging system with file output and listener support, and a basic TCP networking abstraction (NetListener/NetStream). Additionally, utility modules for safe locking (preventing deadlocks), numeric range operations, and early-return macros are added to improve engine stability and developer ergonomics.

fyrox-core/src · high confidence

The editor now includes a new \DocWindow\ utility that provides a dedicated, scrollable window for displaying documentation text, as well as a \make\_pick\_button\ helper for creating consistent selection buttons in UI layouts. Additionally, several general-purpose utility functions have been added to \editor/src/utils\, including helpers for creating file selectors with specific type filters, fetching node screen coordinates, applying visibility filters to UI trees, and opening files in the native OS explorer.

editor/src/utils · high confidence

The editor now includes a dedicated ExportWindow UI component that allows users to select a target platform and specific build targets before exporting a project. This interface provides controls for managing export options, including the ability to disable optimizations and asset conversion, and displays a log of the export process with support for cancelling ongoing operations.

editor/src/export · high confidence

The fyrox-autotile crate has been introduced, providing two autotiling algorithms for regular tile grids: deterministic terrain-based autotiling (based on the Godot terrain-autotiler) and randomized content generation using Wave Function Collapse (based on fast-wfc). This library allows users to automatically select matching tiles for grid cells based on adjacency rules, supporting both 2D and 3D grids and generic coordinate systems.

fyrox-autotile · high confidence

A new \fyrox-dylib\ crate has been added, which re-exports the entire Fyrox engine to allow it to be used as a dynamically linked library. This enables faster prototyping by avoiding the time-consuming static linking stage, and can be integrated by redefining the \fyrox\ dependency to point to the \fyrox-dylib\ package.

fyrox-dylib · high confidence

The fyrox-impl crate has been introduced as a central library module, re-exporting core engine subsystems (core, animation, graph, asset, gui, autotile, graphics) under convenient aliases. It also exposes a define\_with macro for builder patterns and provides reflection capabilities that allow users to retrieve the assembly name of types via type\_info\_ref().assembly\_name, as demonstrated by the included test verifying assembly names for core, impl, ui, and sound types.

fyrox-impl/src · high confidence

The \fyrox-math\ crate has been introduced, consolidating the \math\, \curve\, and \octree\ modules into a single library. This adds foundational geometry types including \AxisAlignedBoundingBox\, \Ray\, \Plane\, \Frustum\, \LineSegment\, and \Curve\, along with an \Octree\ for spatial queries and a \Triangulator\ for polygon decomposition. These primitives provide the underlying mathematical structures for collision detection, rendering frustums, animation curves, and spatial partitioning within the engine.

fyrox-math · high confidence

The \fyrox-resource\ crate has been introduced to centralize resource management, shifting resource handles from path-based to UUID-based identification for improved stability. This change adds built-in resource support for embedding data directly into the executable, a resource dependency graph to track relationships between assets (such as models and their textures), and a comprehensive I/O abstraction layer (\ResourceIo\) that supports virtual file systems and cross-platform operations. The resource manager now includes an event broadcasting system for load/reload notifications, a constructor container for type-agnostic resource creation, and a registry system that persists metadata and handles resource scanning and updates.

fyrox-resource · high confidence

The fyrox-graph crate now includes a new constructor module and enhanced handle mapping capabilities. Users can define and register node constructors with variants via GraphNodeConstructorContainer, enabling flexible scene node creation in the editor. Additionally, the NodeHandleMap provides robust methods to remap node handles during copy operations, ensuring cross-references (like parent-child links or bone assignments) are correctly updated to point to the new copies.

fyrox-graph · high confidence

The HDR renderer now includes a new \HistogramLuminanceEvaluator\ that calculates average luminance by binning pixel values into a histogram, selecting the bins with the most samples, and averaging those values. This implementation is exposed via the \LuminanceEvaluator\ trait and is accompanied by unit tests to verify histogram construction and sample reduction logic.

fyrox-impl/src/renderer/hdr/luminance · high confidence

The editor now supports direct manipulation of UI widgets within the scene. Users can select individual widgets by clicking or select multiple widgets using a box-selection drag gesture, with support for toggling selection via the Control key. Additionally, a new move mode allows users to drag selected widgets to reposition them, with the editor automatically snapping coordinates to a grid if that setting is enabled.

_editor/src/ui\scene/interaction · high confidence

The physics module now includes a new \KinematicCharacterController\ component that enables classic game character movement, including walking on floors, sliding on slopes, climbing stairs, and snapping to the ground. This controller is kinematic rather than physics-based, allowing direct control over movement. The implementation supports both 2D and 3D environments, with configurable options for auto-stepping over obstacles, slope climbing angles, and ground snapping. The feature is disabled by default for performance reasons but can be enabled via the \autostep\ property.

fyrox-impl/src/scene/dim2/physics, fyrox-impl/src/scene/graph/physics · high confidence

The engine now supports three distinct light types: Directional, Point, and Spot. Directional lights use cascaded shadow maps with configurable frustum split options (Absolute or Relative) and shadow bias. Point lights emit light spherically with a configurable radius and shadow bias. Spot lights emit light in a cone shape with configurable hotspot angle, falloff delta, distance, shadow bias, and cookie (gobo) textures. All light types share common properties like color, intensity, and light scattering.

fyrox-impl/src/scene/light · high confidence

The engine now includes a dedicated \ModelLoader\ for loading \.rgs\ and \.fbx\ model files, handling import settings and dynamic type construction via the serialization context. Additionally, the \Model\ resource exposes a builder-style \InstantiationContext\ API, allowing users to specify local position, rotation, scale, and transform when creating instances, as well as assign specific node IDs for consistent multiplayer synchronization.

fyrox-impl/src/resource/model · high confidence

The editor now includes dedicated gizmo components for moving, rotating, and scaling selected objects. The move gizmo displays axis-aligned arrows and planes for translation, the rotate gizmo uses torus-shaped ribbons for pitch, yaw, and roll adjustments, and the scale gizmo provides axis-specific scaling handles. These gizmos are automatically positioned, rotated, and scaled based on the current selection and camera distance, and their colors reset to default states when interaction ends.

editor/src/interaction/gizmo · high confidence

The editor now includes a dedicated floating Navmesh panel that appears when a navigational mesh is selected, providing a 'Connect Edges' button to merge selected edges. This change introduces a new selection model (NavmeshSelection) that tracks specific navmesh vertices and edges, enabling precise editing operations like connecting edges through undoable commands.

editor/src/interaction/navmesh · high confidence

The \fyrox-build-tools\ crate now includes a new export module that provides the infrastructure for building and exporting Fyrox projects to PC, Android, and WebAssembly targets. This change introduces platform-specific build logic (using \cargo\, \cargo-apk\, and \wasm-pack\), asset copying and conversion utilities, and a central \ExportOptions\ struct to configure the build process. Users can now leverage these tools to automate the packaging of their games for distribution on these platforms.

fyrox-build-tools/src/export · high confidence

The inspector now includes dedicated property editors for several asset and scene types, allowing users to select and manage these resources directly within the property grid. Users can now pick animations from a dropdown list, assign fonts with a live text preview, select scene nodes via a node selector or picker, and manage resources (such as textures and surfaces) with asset previews and locate buttons. Script properties can be edited with a dropdown and opened in an external IDE (VS Code, Xcode, Emacs, Zed, or system default). Surface data and texture fields display previews and support drag-and-drop assignment, improving the workflow for material and mesh editing.

editor/src/plugins/inspector/editors · high confidence

The scene viewer now includes a scene gizmo that allows users to rotate the editor camera and switch between 2D and 3D projection modes directly from the viewport. Additionally, a context menu has been added to scene tabs, enabling users to close scenes, show them in the file explorer, or mark/unmark them as startup scenes.

_editor/src/scene\viewer · high confidence

The scene module has been significantly expanded with new capabilities for spatial acceleration, physics, and scene management. An octree-based spatial acceleration structure (\accel.rs\) is now available to optimize sphere, AABB, and point queries against scene nodes. Physics interactions are enhanced through a comprehensive set of collider shapes (ball, cylinder, cone, cuboid, capsule, segment, triangle) and joint types (ball, fixed, prismatic, revolute) with configurable motor parameters, all integrated with the Rapier physics engine. Additionally, the module introduces new node types for decals (with diffuse/normal map support and layer masking), navigational meshes for pathfinding, and environment lighting sources (skybox or ambient color), alongside foundational structures for LOD groups and custom properties.

fyrox-impl/src/scene · high confidence

The inspector now includes a dedicated editor for shader source code properties. When a user clicks the "Edit Source Code..." button in the inspector field, a modal window opens containing a scrollable, multi-line text box for editing the shader code. Changes are committed when the text box loses focus or Enter is pressed, and the updated code is immediately reflected in the inspector property.

editor/src/plugins/inspector/editors/shader · high confidence

The terrain editor now uses a new brushstroke module that processes brush operations in a dedicated background thread. This system rasterizes brush shapes (circle or rectangle) into pixel strength maps and uses a triple-buffer architecture to decouple UI input from texture updates, allowing for smoother interaction. To prevent the editor from freezing on excessively large brushes, a sanity check limits the number of pixels processed per step to 1,000,000. The implementation also includes logic to handle terrain chunk boundaries and texture margins, ensuring that height and mask textures are updated correctly across chunk edges.

fyrox-impl/src/scene/terrain/brushstroke · high confidence

The tile map editor now includes a comprehensive set of interaction modes and UI components for managing tile sets and brushes. Users can pick, draw, erase, and perform rectangular fill operations on tile maps, with visual feedback for selection and cursor positions. The tile set editor has been expanded with a dedicated colliders tab, allowing users to create, rename, reorder, and change the colors of collider layers, as well as edit custom collider definitions. Additionally, the editor introduces brush macros and autotiling support, enabling automatic tile pattern generation based on configurable constraints and properties. A new handle editor widget allows direct editing of tile definition handles within the inspector, and command-based operations ensure that all tile map and tile set modifications are undoable.

editor/src/plugins/tilemap · high confidence

The editor now supports undo and redo for a wider range of scene modifications, including moving, rotating, and scaling nodes, as well as editing materials (shaders, bindings, properties), meshes (textures), terrain (layers, height, holes), navigation meshes (edges, connections), and audio buses (adding/removing, linking). These changes allow users to safely experiment with scene structure and assets, knowing that their actions can be reversed through the standard undo/redo workflow.

editor/src/scene/commands · high confidence

The engine now includes new utility modules in fyrox-impl/src/utils: A\* pathfinding (astar.rs), navigation mesh generation and management (navmesh.rs), a CPU-based lightmap generator (lightmap.rs), a procedural mesh builder (raw\_mesh.rs), and UV generation utilities (uvgen.rs). These additions provide core algorithms for AI movement, static lighting, and mesh processing.

fyrox-impl/src/utils · high confidence

The \fyrox-graphics-gl\ crate now provides the concrete OpenGL implementation for the engine's graphics server, moving OpenGL-specific rendering logic out of the generic \fyrox-graphics\ layer. This change introduces native support for GPU buffers, framebuffers, geometry buffers, shader programs, textures, samplers, and asynchronous read-backs via the \glow\ bindings. Users benefit from corrected memory usage tracking for buffers, proper handling of cube map face attachments in framebuffers, and platform-specific fixes for WASM compilation and WebGL limitations (such as disabling texture LOD bias and using \glGetBufferSubData\ for pixel reads).

fyrox-graphics-gl/src · high confidence

The Project Manager now shows its current version number in the application window's title bar. This is achieved by a new build script that reads the version from Cargo.toml and writes it to a version file, which the application then uses to update the UI.

project-manager · high confidence

The inspector now includes a dedicated editor for sprite sheet frames. When a user selects a property containing a sprite sheet frame container, they can click the 'Edit...' button to open a modal window. This window allows users to define the grid dimensions (width and height), select specific frames via checkboxes, and preview the animation. Changes are applied when the user clicks 'OK', updating the sprite sheet data in the scene.

editor/src/plugins/inspector/editors/spritesheet · high confidence

The plugin system now supports dynamic plugins (loaded from .dll/.so files) with automatic hot-reloading during development, allowing developers to update plugin code without restarting the engine. This is implemented via the new \DyLibDynamicPlugin\ and \DynamicPlugin\ trait in \fyrox-impl/src/plugin\. Additionally, a new \GameError\ system (\fyrox-impl/src/plugin/error.rs\) provides structured error reporting with optional backtrace capture, replacing previous ad-hoc error handling. The \PluginContext\ has been expanded to support multiple user interfaces and dynamic type constructors, enabling more flexible plugin integration.

fyrox-impl/src/plugin · high confidence

The texture handling code has been extracted from the main engine into a separate \fyrox-texture\ crate. This change introduces a dedicated \TextureLoader\ responsible for loading image formats (such as PNG, JPG, DDS, and TGA) and defines the \TextureKind\ enum to support 1D, 2D, 3D, and Cube textures. By isolating this functionality, the engine's core dependencies are reduced, and texture management is now handled by a distinct module.

fyrox-texture · high confidence

The editor's internal architecture has been reorganized by moving several previously monolithic or scattered editor components into their own dedicated plugin modules under \editor/src/plugins\. This change introduces distinct modules for the curve editor, reflection probe, ragdoll wizard, settings window, and editor statistics, each exposing its own \EditorPlugin\ implementation. For users, this represents a structural improvement to the editor's modularity, separating concerns for curve editing, reflection probe adjustment, ragdoll creation, settings management, and performance statistics into independent, self-contained units.

editor/src/plugins · high confidence

The material editing functionality has been detached from the main editor codebase and moved into its own dedicated plugin located at \editor/src/plugins/material\. This change introduces new modules (\editor.rs\ and \mod.rs\) that handle the \MaterialFieldEditor\ for the inspector and the main \MaterialEditor\ window, including property previews, asset selection, and shader binding management. Users will now interact with the material editor through this isolated plugin structure, which improves modularity and separation of concerns within the editor's architecture.

editor/src/plugins/material · high confidence

The material module in fyrox-impl now acts as a re-export for the fyrox-material crate, centralizing material definitions and simplifying the module structure for users accessing material-related functionality.

fyrox-impl/src/material, fyrox-impl/src/resource/texture · high confidence

The material system, including the Material struct, property groups, texture bindings, and the MaterialLoader, has been moved into a new dedicated crate (fyrox-material). This change centralizes material-related code, separating it from the core engine, and introduces a dedicated loader for .material files that integrates with the resource manager to handle shader and texture dependencies.

fyrox-material/src · high confidence

A change to existing behaviour in examples/data — 10 commits (4 fixs), 2 files.

examples/data · medium confidence · unverified

The animation editor has been moved into its own dedicated plugin module, introducing a new toolbar split into top and bottom panels, a custom time ruler for managing animation signals, a playback position thumb overlay, and a dedicated selection system. This restructuring supports new capabilities such as adding keys for any numeric properties, disabling background curves, and using toggle buttons for preview and loop options, while also fixing crashes related to property rebinding and animation track creation.

editor/src/plugins/animation · high confidence

The animation engine in \fyrox-animation\ has been restructured to decouple animation data from specific instances, introducing \AnimationTracksData\ as a shared resource that multiple animations can reference to reduce memory consumption. This change introduces new core modules including \container\ (for \TrackDataContainer\ and \TrackValueKind\), \pose\ (for \NodePose\ and \AnimationPose\ blending), \signal\ (for timeline events), and \value\ (for typed property values). The system now supports configurable interpolation modes, such as short-path angle interpolation for rotations, and utilizes \ImmutableString\ for bindings to optimize memory usage. Existing animations are maintained through backward compatibility measures, but the underlying data structures for tracks, curves, and poses have been fundamentally redesigned.

fyrox-animation/src · high confidence

The sound engine now supports hierarchical audio buses via the new \AudioBus\ and \AudioBusGraph\ types, allowing sounds to be routed through chains of effects and gain stages. To support this, \SoundContext\ serialization has been enhanced with \SerializationOptions\ to selectively skip sources or the bus graph during save/load operations. Additionally, the engine now exposes a headless mode (\SoundEngine::without\_device\) for custom audio output handling and allows runtime configuration of the sample rate.

fyrox-sound/src · high confidence

The bloom rendering implementation has been refactored to reduce VRAM consumption by switching from RGBA16F to RGB10A2 pixel formats for its internal framebuffers and textures. Additionally, the bloom effect now exposes a configurable threshold setting via QualitySettings, allowing users to control when the bloom effect activates based on brightness levels.

fyrox-impl/src/renderer/bloom · high confidence

The fyrox-ui module now includes a centralized resource storage mechanism that loads built-in bitmap icons (such as check, add, remove, shuffle, and error icons) as texture resources. This change consolidates icon management into a single module, ensuring consistent loading of these UI assets across the interface.

fyrox-ui/src/resources · high confidence

The UI system now uses a centralized \WidgetConstructorContainer\ to instantiate widgets by their type UUID, replacing the previous hardcoded or scattered registration methods. This change introduces a new \constructor\ module that registers built-in widgets (such as \Button\, \Menu\, \TextBox\, and various editors) into a single container, enabling more flexible and maintainable widget creation during scene deserialization and runtime. The \WidgetContainer\ wrapper now relies on this container to resolve and create widget instances, ensuring that all UI elements are managed through a consistent, type-UUID-based lookup mechanism.

fyrox-ui/src/node · high confidence

The curve editor widget in fyrox-ui has been significantly enhanced with new interaction capabilities, including non-uniform zooming (via Shift or Ctrl), configurable grid sizes, and the ability to add keys on multiple curves simultaneously. Users can now customize the appearance by setting different brushes for each curve, show/hide background curves, and toggle axis values. The widget also supports copy/pasting selections, preserving curve and key IDs, and features a 'zoom to fit' function with configurable delay. Under the hood, the implementation was refactored to use typed handles, improved message handling, and safer locking mechanisms to prevent deadlocks and crashes, while also fixing various clipping and coordinate space issues.

fyrox-ui/src/curve · high confidence

The curve resource module now uses the renamed \FileError\ type for I/O errors instead of the previous \FileLoadError\, and the loader explicitly supports both \.curve\ and \.crv\ file extensions. Additionally, the resource state now implements \try\_clone\_box\ to support cloning, while saving remains unsupported.

fyrox-impl/src/resource/curve · high confidence

The editor now supports full undo and redo capabilities for UI scene modifications, including adding, deleting, and linking widgets, as well as moving widgets and reverting inheritable properties. This is implemented via new command structures (AddWidgetCommand, LinkWidgetsCommand, DeleteWidgetsSubGraphCommand, MoveWidgetCommand, RevertWidgetPropertyCommand) that manage state transitions and allow users to safely reverse changes within the UI scene context.

_editor/src/ui\scene/commands · high confidence

The editor's menu bar has been refactored into distinct, modular components (Edit, File, View, Utils, Help) located in \editor/src/menu\. This change introduces specific UI capabilities: the Edit menu now supports Copy, Paste, Undo, and Redo operations with keyboard shortcuts; the File menu includes scene management (New, Load, Save, Save All, Close) and a recent files list; the View menu allows toggling editor panels (Inspector, Asset Browser, Log, etc.) and managing layout persistence (Save/Load/Reset Layout); the Utils menu provides access to a Rendering Statistics window; and the Help menu opens the documentation and API reference. This modularization replaces the previous monolithic menu implementation, improving maintainability and enabling independent handling of menu interactions.

editor/src/menu · high confidence

The editor's configuration system has been refactored to use a structured, serializable settings model that persists user preferences across sessions. This change introduces dedicated settings modules for build profiles (PC, WASM, Android), camera controls (speed, sensitivity, zoom range, exposure), general editor behavior (suspension when unfocused, script editor selection, preview generation, log limits), graphics (quality, grid, gizmo scale), debugging (debug geometry visibility, pictogram size), key bindings (including terrain and navmesh shortcuts), and window management (position, size, maximized state, docking layout). Users can now customize these aspects via the editor's settings interface, and the editor will automatically save and restore these values, ensuring a consistent workspace and tailored development experience.

editor/src/settings · high confidence

The engine module has been restructured to introduce dedicated modules for error handling, input state, and asynchronous task management, alongside a new hot-reloading system for plugins and resources. This change adds simplified input shortcuts for checking pressed/released mouse buttons and keys, enables resource hot reloading by default in the executor, and introduces a task pool handler for off-threading heavy operations in scripts and plugins. Additionally, the engine now supports headless mode and includes specific utilities for WebAssembly panic handling.

fyrox-impl/src/engine · high confidence

The \Visit\ derive macro now supports specifying \pre\_visit\_method\ and \post\_visit\_method\ attributes to inject custom logic before and after the generated visit code, and allows marking struct fields or the entire type as \optional\ to gracefully ignore missing data during deserialization. Additionally, the generated code no longer uses the \?\ operator for field visits, instead explicitly handling errors to prevent infinite recursion in trait bounds and allowing the use of \RegionGuard\ for cleaner region management.

fyrox-core-derive/src/visit · high confidence

The file browser UI has been restructured into distinct modules (dialog, field, filter, fs\_tree, menu, selector) to improve testability and maintainability. This change introduces a new FileSelectorField widget for binding file paths, a configurable PathFilter system supporting specific file type extensions and folder-only modes, and a dedicated FolderNameDialog for creating new directories. The FileSelector now supports both Open and Save modes with overwrite confirmation, while the FileBrowser widget itself gains context menus for item deletion and folder creation, drag-and-drop support, and improved tree rendering with folder icons.

_fyrox-ui/src/file\browser · high confidence

The font system in fyrox-ui has been refactored to support font fallbacks, allowing special characters to be rendered using alternative fonts when the primary font lacks the necessary glyphs. This change introduces a new \FontImportOptions\ structure that lets users configure import settings such as the atlas page size and specify associated bold, italic, and bold-italic font variants. The \FontLoader\ now utilizes these options to manage the loading process, and the underlying \Font\ resource implementation includes logic to traverse a chain of fallback fonts (up to a defined recursion depth) to ensure complete text coverage.

fyrox-ui/src/font · high confidence

The FBX loader now provides better support for materials exported from 3ds Max and allows for chained texture nodes, resulting in more accurate visual representation of imported models. Additionally, a dedicated \FbxError\ type has been introduced to replace generic file load errors, offering specific, user-friendly messages for issues like unsupported versions, invalid strings, or missing bone references during parsing.

fyrox-impl/src/resource/fbx · high confidence

The inspector plugin has been moved into the dedicated \editor/src/plugins/inspector\ directory, introducing a new modular structure with separate \editors\ and \handlers\ submodules. This change includes the introduction of an \EditorEnvironment\ struct to manage editor-specific context (such as resource management and animation definitions) and adds a search bar to the inspector UI for filtering properties by name.

editor/src/plugins/inspector · high confidence

The inspector now wraps property modifications in undoable commands rather than applying changes directly. This allows users to revert property edits via the standard undo system, including specific handling for terrain layer additions and deletions, while ensuring inheritable properties are only reverted when a parent resource exists.

editor/src/plugins/inspector/handlers/node · high confidence

The Inspector's property editing UI has been refactored to use a modular, type-specific editor system. Instead of a monolithic implementation, the editor now uses dedicated modules for different data types (such as arrays, collections, booleans, colors, curves, and inheritable variables). This change introduces a \PropertyEditorDefinition\ interface that allows the Inspector to dynamically instantiate the correct UI widget for any reflectable type, improving maintainability and enabling more specialized editing experiences for complex types like curves and color gradients.

fyrox-ui/src/inspector/editors · high confidence

The math module has been restructured to re-export the \fyrox\_math\ crate and consolidate serialization logic. This change introduces \Reflect\ implementations for core geometric types including \Rect\, \TriangleDefinition\, \AxisAlignedBoundingBox\, \Frustum\, \Plane\, \SmoothAngle\, and curve-related structures (\CurveKey\, \CurveKeyKind\, \Curve\). Additionally, \Visit\ implementations are provided for these types to handle data persistence, ensuring they are properly serialized with specific field mappings (e.g., \Rect\ fields as X, Y, W, H).

fyrox-core/src/math · high confidence

The mesh module has been restructured to replace the previous static mesh implementation with a more flexible system. A new dynamic vertex buffer system (buffer.rs) now handles vertex layouts, supporting both static and animated (skinned) vertices with explicit attribute descriptors for positions, normals, tangents, and bone weights. Additionally, blend shape animation data is no longer passed implicitly to shaders; instead, it is packed into a volume texture (surface.rs) and stored as a resource, requiring materials to bind this texture explicitly for morph targets.

fyrox-impl/src/scene/mesh · high confidence

The shadow rendering subsystem has been restructured into a new, modular architecture located in \fyrox-impl/src/renderer/shadow\. This change introduces dedicated renderers for Cascaded Shadow Maps (CSM) for directional lights, as well as new shadow map renderers for point and spot lights. The implementation supports configurable shadow map precision (Full D32F or Half D16) and uses a cascading strategy for point and spot lights to optimize resolution based on distance. This refactoring isolates shadow-specific logic, improves code organization, and prepares the renderer for more advanced lighting features.

fyrox-impl/src/renderer/shadow · high confidence

The renderer now uses a dedicated cache module to manage GPU resources more efficiently. GeometryCache handles dynamic geometry buffers, automatically uploading vertex and triangle data when modifications are detected or recreating the buffer if the layout changes. TextureCache manages GPU textures and samplers, supporting various pixel formats (including sRGB) and texture types, while ensuring unique registration. ShaderCache introduces a new resource binding system using sampler+texture pairs and property groups, replacing older combined texture approaches. UniformBufferCache and UniformMemoryAllocator provide pooled and allocated uniform buffer management, preventing uncontrolled growth by marking buffers as unused per frame and clearing pages instead of reallocating.

fyrox-impl/src/renderer/cache · high confidence

The terrain module has been replaced with a new implementation that uses a quadtree for level-of-detail rendering and introduces one-pixel margins around height map chunks to improve normal calculation accuracy at chunk boundaries. This change updates the internal geometry and rendering logic for terrains, affecting how terrain data is structured and displayed.

fyrox-impl/src/scene/terrain · high confidence

The particle system module has been refactored to improve rendering performance and code organization. A new dedicated \draw.rs\ module defines the vertex layout for particle rendering, utilizing \bytemuck\ traits for memory safety. The core \Particle\ struct has been reorganized to explicitly track position, velocity, size, lifetime, and color, while the main \ParticleSystem\ module now integrates these components with a deterministic pseudo-random number generator for consistent visual effects across runs.

_fyrox-impl/src/scene/particle\system · high confidence

The engine has been renamed from rg3d to Fyrox. This change updates the README to reflect the new name and logo, revises the LICENSE to credit Fyrox Engine contributors, and introduces new documentation files including ARCHITECTURE.md and CONTRIBUTING.md to guide users and developers.

(repo-wide) · high confidence

The HDR rendering pipeline has been restructured to replace custom shader implementations with native engine equivalents for luminance calculation, adaptation, and downscaling. This change introduces a new \AdaptationChain\ for managing luminance framebuffers and exposes configuration options for HDR adaptation speed and bloom threshold. Additionally, the auto-exposure logic has been corrected to fix previous inaccuracies in frame luminance calculation, ensuring more consistent visual results across different lighting conditions.

fyrox-impl/src/renderer/hdr · high confidence

The editor's scene interaction logic (move, rotate, scale, select, and terrain tools) has been restructured around a new \InteractionMode\ trait. This change replaces the previous implementation with a dynamic dispatch system, allowing interaction modes to be registered, removed, and switched at runtime. For users, this provides a more stable foundation for editor tools, enabling features like dynamic plugin support and improved keyboard event handling, while maintaining existing behaviors for gizmo manipulation and terrain editing.

editor/src/interaction · high confidence

The pool implementation in \fyrox-core/src/pool\ has been reorganized into distinct modules (\handle.rs\, \payload.rs\, \multiborrow.rs\) to improve code structure and maintainability. This change introduces a dedicated \Handle\<T\>\ struct with explicit generation tracking for validity checks, a generic \PayloadContainer\ trait to abstract payload storage (defaulting to \Option\<T\>\), and a \MultiBorrowContext\ that enables safe, concurrent unique references to pool elements via runtime borrow checking. The \Reflect\ trait implementations for \Handle\ and \Pool\ have been updated to support these new structures, including field reflection for handle index/generation and type info aggregation for pools.

fyrox-core/src/pool · high confidence

The engine's scene graph node system has been restructured to improve serialization reliability and extensibility. A new \NodeConstructorContainer\ now manages the creation of built-in nodes (such as lights, cameras, and meshes) via their type UUIDs, replacing previous hardcoded instantiation logic. Additionally, a dedicated \NodeContainer\ wrapper has been introduced to provide full control over the deserialization process, ensuring that nodes are correctly instantiated and visited during scene loading. These changes underpin the shift to UUID-based resource handles and support hot-reloading capabilities for user-defined scene nodes.

fyrox-impl/src/scene/node · high confidence

The sound subsystem in the scene graph has been restructured to introduce a dedicated Listener node, which acts as the directional microphone for spatial audio, and a new SoundContext component that manages the underlying audio engine state. This change replaces previous hardcoded node creation patterns with a more flexible architecture, allowing users to attach the listener to any scene node (typically the main camera) and providing explicit control over audio properties like distance models, gain, panning, and spatial blending through the new Sound component. The refactoring also improves how sound sources are synchronized with their scene nodes and handles resource management more robustly.

fyrox-impl/src/scene/sound · high confidence

The \\#\[derive(Reflect)\]\ macro in \fyrox-core-derive\ has been updated to support more granular control over reflection metadata. Users can now specify custom clone functions via \clone\_fn\, define custom type boundaries with \bounds\, and explicitly ignore type UUIDs for generic types using \ignore\_generics\_type\_uuid\. The macro also introduces \ReflectArray\ and \ReflectList\ implementations via the \impl\_as\_array\ and \impl\_as\_list\ attributes, and allows hiding fields or the entire type with \hidden\ and \hide\_all\. Property key constants are now generated with specific naming conventions (e.g., \Variant@field\ for enum variants), and doc comments are forwarded to provide property descriptions. Additionally, struct fields can now define custom setters via the \setter\ attribute, enabling \Reflect::set\_field\ to invoke specific methods.

fyrox-core-derive/src/reflect · high confidence

The reflection module has been restructured to support richer data structures and clearer error handling. New sub-traits ReflectArray, ReflectList, ReflectHashMap, and ReflectHashSet have been added, enabling runtime inspection and modification of arrays, vectors, hash maps, and hash sets via reflection. The Reflect trait's field access methods have been renamed (e.g., field -\> find\_field) and refactored to return values directly rather than through closures, simplifying API usage. Additionally, a comprehensive set of error types (ReflectPathError, CastError, SetFieldError) has been introduced to provide detailed feedback on reflection failures, and the ReflectInheritableVariable trait has been streamlined by removing the clone\_value\_box method.

fyrox-core/src/reflect · high confidence

The renderer implementation has been restructured to replace legacy texture-based uniform passing with uniform buffers for effects like bloom, HDR, and UI rendering, while migrating built-in shaders (such as FXAA, skybox, and ambient lighting) to the engine's native shader format. This change improves GPU cache utilization and reduces code bloat, resulting in more efficient rendering passes for lighting, post-processing, and user interface elements.

fyrox-impl/src/renderer · high confidence

The Screen Space Ambient Occlusion (SSAO) implementation has been rewritten to use the engine's native shader format and a new bindless GPU texture API. This change replaces the previous combined texture approach with explicit sampler and texture pairs, allowing for more flexible resource binding. The refactoring includes a dedicated blur pass that utilizes the new \RenderMaterial\ and \UniformBufferCache\ systems, improving integration with the rest of the renderer while maintaining the same visual output for ambient occlusion.

fyrox-impl/src/renderer/ssao · high confidence

The animation module now exposes scene-specific type aliases for the generic animation system, binding generic types to the engine's node handle system. This includes the AnimationBlendingStateMachine (ABSM) and its constituent nodes (such as BlendAnimations, BlendSpace, and transitions), as well as sprite sheet animations. These changes enable the ABSM to directly reference and control animations from the animation player within the scene graph, allowing for more integrated character animation workflows.

fyrox-impl/src/scene/animation · high confidence

The script subsystem has been restructured to support dynamic script message typing and improved serialization. A new \ScriptConstructorContainer\ has been introduced to manage script instance creation by type UUID, facilitating better serialization and hot-reload capabilities. Script messages now support dynamic typing via the \ScriptMessagePayload\ trait, allowing messages to be dispatched by a runtime type identifier rather than just static types, which enables more flexible message routing strategies (Targeted, Global, Hierarchical).

fyrox-impl/src/script · high confidence

The shader loading infrastructure and standard shader definitions have been relocated to the new \fyrox-material\ crate. This change introduces a dedicated \ShaderLoader\ for \.shader\ files and provides the core \Shader\ module documentation, along with the complete set of standard rendering shaders (including Standard, StandardTwoSides, Standard2D, ParticleSystem, Sprite, Terrain, Tile, and Widget) for both OpenGL and Wgpu backends. Users relying on these assets will find them now reside in the \fyrox-material\ package.

fyrox-material/src/shader · high confidence

The sound buffer module has been restructured to replace the previous audio handling implementation with the Symphonia library, enabling support for additional file formats and fixing issues with fetching stream lengths for OGG/Vorbis files. This change introduces a new \SoundBufferLoader\ that manages resource loading via import options (distinguishing between generic and streaming buffers) and updates the internal \Decoder\ to use Symphonia's format reader and codec registry. Users benefit from more robust audio decoding, better format support, and a cleaner resource loading API that integrates with the engine's new UUID-based resource system.

fyrox-sound/src/buffer · high confidence

The sprite sheet animation system has been refactored to use a generic texture parameter, allowing it to work with any type implementing the new \SpriteSheetTexture\ trait rather than being tied to a specific texture implementation. Additionally, the system now supports animation signals, enabling developers to attach specific events (identified by a numeric ID) to particular frames, which are exposed to users via an \Event\ enum for handling frame-specific logic like jump or crouch triggers.

fyrox-animation/src/spritesheet · high confidence

The sound examples in fyrox-sound/examples have been updated to explicitly pass the sample rate to SoundEngine constructors and to use FsResourceIo for loading audio assets. This change ensures consistent resource loading across all examples (including hrtf, listener, play\_sound, play\_spatial\_sound, raw\_samples, raw\_streaming, reverb, streaming, and write\_wav) and aligns the examples with the current resource API.

fyrox-sound/examples · high confidence

The visitor module in fyrox-core has been restructured to isolate serialization logic into separate ASCII and binary readers and writers, introducing a \Blackboard\ for passing shared context during deserialization and a comprehensive \VisitError\ enum with breadcrumb tracking for better debugging. This change also adds support for serializing \winit::KeyCode\ values (behind the \winit\_impls\ feature), implements \Visit\ for various nalgebra types (matrices, vectors, quaternions), and introduces a versioned serialization format (\VisitorVersion\) to manage future compatibility.

fyrox-core/src/visitor · high confidence

The \fyrox-graphics\ crate has been restructured to provide a cleaner, more modular rendering API. The diff introduces dedicated modules for core graphics concepts: \buffer\ (with \GpuBuffer\ and \BufferKind\), \framebuffer\ (with \Attachment\ and \ResourceBinding\), \geometry\_buffer\ (with \AttributeDefinition\ and \GpuGeometryBuffer\), \gpu\_program\ (with \GpuShader\, \GpuProgram\, and \SamplerKind\), \gpu\_texture\ (with \GpuTexture\ and \PixelKind\), \query\ (for async occlusion queries), \read\_buffer\ (for async pixel reads), and \sampler\. This refactoring replaces previous monolithic or implicit structures with explicit descriptors (e.g., \GpuBufferDescriptor\, \GpuGeometryBufferDescriptor\) and traits (e.g., \GpuBufferTrait\, \GpuFrameBufferTrait\), improving type safety and separation of concerns. Error handling is centralized in \error.rs\ with \FrameworkError\. This change affects how users define and manage GPU resources, shaders, and rendering commands within the graphics layer.

fyrox-graphics · high confidence

Added editor test infrastructure and utilities; Added integration tests for derive macro reflection and visitor behavior; Added integration tests for editor file menu operations; Added test output for behavior save/load functionality; Added tests for the Visit proc-macro derive implementation.

The Fyrox game engine and its standalone editor (fyroxed) have been bumped to version 2.0.0-rc.1. This release updates the Rust minimum supported version to 1.94 and refreshes several key dependencies, including winit to 0.30, glutin to 0.32, glow to 0.17.0, wgpu to 30.0.0, rapier to 0.33, and nalgebra to 0.35. Other notable dependency updates include image to 0.25.1, fontdue to 0.9.2, and hrtf to 0.9.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 60 (+0.1)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 81 → 81 (+0.0)
• Architecture 97 → 95 (-1.7)
• Maturity 62 → 63 (+0.3)
• Readiness 64 → 65 (+0.5)
• Security 80 → 80 (+0.0)
• Event Sourcing 49 → 49 (+0.0)
• Performance 100 (new)

• Change coupling: mod.rs ↔ selection.rs (editor/src/audio/mod.rs)
• Change-coupling hub: selection.rs → mod.rs, selection.rs, selection.rs (editor/src/world/selection.rs)
• Duplicated block (10 lines × 2) (editor/src/world/create.rs)
• Duplicated block (11 lines × 2) (editor/src/world/create.rs)
• Duplicated block (12 lines × 2) (editor/src/scene/commands/effect.rs)
• Duplicated block (7 lines × 2) (editor/src/scene/commands/effect.rs)
• Duplicated block (8 lines × 2) (fyrox-core-derive/src/reflect.rs)
• Hotspot: editor/src/plugins/absm/state_graph/mod.rs (editor/src/plugins/absm/state_graph/mod.rs)
• Hotspot: editor/src/ui_scene/menu.rs (editor/src/ui_scene/menu.rs)
• Hotspot: editor/src/world/menu.rs (editor/src/world/menu.rs)
• Hotspot: editor/src/world/mod.rs (editor/src/world/mod.rs)
• Hotspot: fyrox-animation/src/lib.rs (fyrox-animation/src/lib.rs)
• Hotspot: fyrox-graph/src/lib.rs (fyrox-graph/src/lib.rs)
• Hotspot: fyrox-impl/src/engine/mod.rs (fyrox-impl/src/engine/mod.rs)
• Hotspot: fyrox-impl/src/renderer/bundle.rs (fyrox-impl/src/renderer/bundle.rs)
• Hotspot: fyrox-impl/src/scene/dim2/physics/mod.rs (fyrox-impl/src/scene/dim2/physics/mod.rs)
• Hotspot: fyrox-impl/src/scene/graph/mod.rs (fyrox-impl/src/scene/graph/mod.rs)
• Hotspot: fyrox-impl/src/scene/graph/physics/mod.rs (fyrox-impl/src/scene/graph/physics/mod.rs)
• Hotspot: fyrox-resource/src/lib.rs (fyrox-resource/src/lib.rs)
• Hotspot: fyrox-texture/src/lib.rs (fyrox-texture/src/lib.rs)
• …and 5 more

• Change coupling: selection.rs ↔ selection.rs (editor/src/interaction/navmesh/selection.rs)
• Change coupling: selection.rs ↔ selection.rs (editor/src/ui_scene/selection.rs)
• Change-coupling hub: mod.rs → selection.rs, selection.rs, selection.rs (editor/src/audio/mod.rs)
• Dependency hygiene PARTLY measured — Cargo dependencies read, no committed lock to grade for currency
• Documentation: contradicts the code (template-core/src/android/README.md)
• Duplicated block (7 lines × 2) (fyrox-ui/src/formatted_text/textwrapper.rs)
• Hotspot: fyrox-ui/src/formatted_text.rs (fyrox-ui/src/formatted_text.rs)
• Inconsistent method signatures for UI message handling. The parameters vary significantly: some include 'engine', some 'sender', some 'editor_selection', some 'entry', and some none. This makes it difficult to implement a unified message dispatch system or understand the required context for each component.
• Inconsistent naming for setting a path. AssetItemBuilder uses 'with_path', while the AssetSelector builders use 'with_selected_asset_path'. Given that AssetItem represents a file/resource and the selector selects one, 'with_path' is the more generic and consistent term for setting a location.
• Inconsistent removal API. 'remove' takes an ID and returns a boxed trait object, while 'remove_typed' takes no arguments (implying it removes the specific type T) and returns the concrete type. This splits the removal logic between ID-based and Type-based removal without a clear pattern (e.g., 'remove_by_id' vs 'remove_by_type').
• Members sharing a duplicated core (4 members, 50+ identical tokens) (editor/src/asset/creator.rs)
• MethodTooLong: FormattedText.arrange (fyrox-ui/src/formatted_text.rs)
• Off the main sequence: fyrox-autotile
• Off the main sequence: fyrox-math
• Redundant methods with overlapping intent. 'push' and 'push_command' both add a command to the group. One likely accepts a generic type C and the other a concrete Command, but this creates confusion for users on which to use.
• Repeated repair: fyrox-core-derive/src/reflect.rs (fyrox-core-derive/src/reflect.rs)
• SceneViewer::sync_to_model (cognitive 20) (editor/src/scene_viewer/mod.rs)
• Split editor
• Split fyrox-impl
• Unstable project fyrox-impl
• …and 1 more

• 33 commits — 24 feature/other, 9 fixes

• editor/src — 17 commits
• fyrox-ui/src — 13 commits
• fyrox-core-derive/src — 2 commits
• fyrox-graph/src — 1 commit

• fix: fixed field_direct_ref/mut for structs with hidden fields
• fix: fixed alignment of inline text elements
• fix: fixed crash when adding/removing audio bus + fixed crashes in undo/redo
• fix: fixed crash when running standalone editor without startup data
• fix: fixed doc provider
• fix: fixed incorrect arrangement of text inline elements
• fix: fixed incorrect line height calculation for inline text elements
• fix: fixed inline widgets position in markdown
• fix: fixed mutex timeout crash when using text as inline widget of some text
• change: GraphNodeConstructor api improvements
• change: add placeholder for inspector search bar
• change: do not format doc comments in reflection
• change: docs for inline text elements
• change: expand collapsed tree items when searching in entity creator
• change: experimental ability to insert inline elements in text
• change: experimental markdown support
• change: expose some of the hidden fields of Widget in inspector
• change: hide unused toolbar items for ui scenes
• change: highlight "create" button in entity creator
• change: highlight scene title for startup scenes
• …and 13 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

FyroxEngine/Fyrox was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.