glTFRuntime

Enabling Graphics Modding and Post-Packaging Manipulation

Games and complex interactive applications often require the ability to introduce new 3D assets long after the final build has been packaged. Whether building a platform that relies on user-generated content or structuring a project to fully support community graphics modding, developers need a way to bypass the standard asset baking process. GlTFRuntime provides this capability for Unreal Engine by enabling the direct ingestion of standard glTF files at runtime. Instead of relying solely on assets pre-packaged into the project directory, an application can load, view, and manipulate new 3D data dynamically as the user plays or interacts with the software.

When an application is packaged in Unreal Engine, the original art assets are typically cooked into a proprietary format, making it exceptionally difficult for end-users to swap out a character model or introduce a new prop design. The main goal of this runtime solution is to bypass that limitation entirely. By targeting standard glTF files, it opens the door for project graphics modding using widely available 3D modeling tools. A player or community modder can create a new asset, export it as a GLTF 2.0 Embedded or Binary file, and the application can ingest it seamlessly. This applies to any scenario requiring the viewing or manipulation of assets post-packaging, such as architectural visualization viewers, virtual production stages, or dynamic product configurators.

Handling Static Meshes, Skeletal Rigs, and Curve Animations

The plugin processes a comprehensive range of 3D data required for complex interactive scenes, rather than being limited to static environmental props. Developers can load Static Meshes for standard geometry alongside Skeletal Meshes for characters and rigged objects. Beyond the geometry itself, the system handles the associated Textures and Materials necessary to render the imported assets correctly within the Unreal Engine environment.

The runtime loading capabilities also extend deeply into motion data, fully supporting both Curve-based Animations and Skeletal-based Animations. A modder or a remote server can supply entirely new animated characters or moving mechanical parts that the base application has never encountered before, complete with their necessary skeletal rigs and material definitions. To demonstrate the versatility of these supported asset types, the plugin successfully processes a variety of established glTF sample models. These include assets like the DamagedHelmet for complex material setups, and the AlphaBlendModeTest for verifying transparency behaviors. For motion and rigging, it handles the BoxAnimated model, the CesiumMilkTruck, and the humanoid CesiumMan. It even processes intricate skeletal setups like the BrainStem model and the classic Collada Duck.

Dynamic Sourcing via HTTP Servers, Clipboard, and JSON Strings

A highly practical aspect of glTFRuntime is the variety of methods it offers for retrieving 3D files. Assets do not need to be restricted to a local filesystem directory. The system can fetch 3D models and animations directly from HTTP servers, enabling cloud-based asset streaming or the dynamic updating of game content without requiring a traditional patch.

For more unconventional data pipelines, the plugin can interpret command-line outputs, read directly from the system clipboard, or build assets entirely from JSON strings. Building assets from JSON strings allows for heavy procedural generation. A server could send a lightweight JSON string containing the mathematical description of a curve-based animation or the structural layout of a skeletal mesh, and the plugin translates that text directly into a physical asset within the game world. The inclusion of clipboard and command-line output reading provides unique avenues for workflow automation, allowing external scripts to generate a 3D model and have Unreal Engine instantly read and construct that asset.

Modifying Bone Hierarchies with Blueprint and C++

Simply loading an asset is often only the first step in a dynamic pipeline; the imported data usually needs to be adjusted to fit the current state of the application. The package includes specific functions tailored for modifying the internal structures of the imported assets. Accessible through both Blueprint visual scripting and C++, these tools allow developers to interact deeply with the loaded data.

A developer can dynamically alter the bone hierarchy of a newly imported Skeletal Mesh directly through Blueprints. This level of control is vital when attaching new modded equipment to a character, adjusting rigs to match different animation retargeting standards, or procedurally altering a skeleton based on gameplay variables. Having access to these structures in both C++ and Blueprint ensures that both programmers and technical artists can manipulate the incoming glTF data.

Testing Workflows within the Unreal Editor

While the primary goal of glTFRuntime is manipulating assets after the game has been packaged, the system is equally functional within the Unreal Editor itself. Loading assets directly in the Editor simplifies the testing and fixing process. Developers can preview exactly how a specific glTF file will behave at runtime, ensuring that the materials map correctly and the skeletal animations play as intended before committing to a packaged build. This editor-level support helps bridge the gap between the external 3D modeling environment and the final runtime application.

Expanding Format Support Beyond GLTF 2.0

At its core, the package supports the GLTF 2.0 specification, accommodating both Embedded and Binary formats. The underlying architecture is designed to be extensible, allowing development teams to integrate support for additional features and entirely different file formats. Through available GitHub extensions, the runtime loading capabilities can be expanded to include OBJ and STL files. Extensions are also available for FBX files and MagicaVoxel files.

Because the project is fully open source under the MIT License, developers have the freedom to tailor the runtime loading environment to accept the specific file types required by their user base or production pipeline. Teams building custom modding platforms or specialized post-packaging viewers benefit directly from this open architecture, allowing them to adapt the plugin to their precise asset ingestion requirements.

Related Resources Worth Checking

• MSC Screen & Camera Recorder
• .bat Extension
• MeshBlend - Next generation mesh blending without RVT
• Screen Space Fog Scattering
• Did it hit - Trace Detection Plugin