LevelController2 (Transform Levels At Runtime In Realtime)

Calling Blueprint Functions for Realtime Map Transformation

Working with LevelController2 begins inside the Unreal Engine Blueprint editor, where level-wide spatial adjustments are driven directly by calling the plugin's dedicated Blueprint functions. Instead of moving individual scene components or managing complex hierarchies of attached parent actors, the tool operates at the map level, exposing controls to transform entire loaded levels simultaneously during live gameplay.

Triggering these functions within gameplay graphs allows projects to alter map orientation, position, and dynamic placement on the fly. The workflow bypasses manual iteration through every static mesh, light, or volume contained within a sub-level. By routing transform calls directly through runtime nodes, maps can shift dynamically in response to gameplay triggers, scripted sequences, or active simulation data.

Because the logic is wrapped cleanly into Blueprint nodes, developers do not need to construct low-level C++ manipulation routines to reposition maps. The core functions accept standard transformation parameters, mapping location and rotation vectors straight to the loaded level structure while the engine continues rendering frames uninterrupted.

Custom Origin Point Shifts and Tick Execution

A primary mechanical expansion in this second iteration over the base LevelController1 build is the ability to transform levels using a custom origin point. When executing map-wide rotations or positional translations, picking an arbitrary center point defines how the entire geometry cluster orbits, pivots, or scales within world space.

This origin point is fully dynamic. It can be modified every single tick at runtime, granting fine-grained mathematical control over complex motion paths. For instances where a level must rotate around a moving pawn, track an external vehicle, or pivot around shifting world coordinates, the origin updates smoothly on an per-frame basis without locking the transform to the default map zero vector.

Running continuous level transformations per tick requires strict computational efficiency. The internal architecture of this package provides an execution rate measured at 165% of the performance of the free version. That optimization margin ensures that updating the custom origin and pushing new map transform matrices every tick does not introduce unacceptable frame-time spikes into the game loop.

Editor and Runtime Ticking with AExActor and AExLevelScriptActor

Beyond broad map movement, the plugin provides low-level execution hooks designed to control actor and level blueprint updates across both development and live play environments. This functionality is implemented through two specialized foundational classes:

• AExActor: A C++ base actor class that allows derived actors to execute tick logic either inside the Unreal Editor without running a PIE session, or actively during runtime play sessions.
• AExLevelScriptActor: A specialized subclass intended to replace or serve as a custom LevelScriptActor, enabling the Level Blueprint itself to tick within the editor or throughout runtime execution.

Under default Unreal Engine behavior, Level Blueprints and standard scene actors operate under strict ticking constraints when working inside editor viewports. By inheriting from AExActor, custom game assets gain the ability to evaluate transform calculations, update internal states, or synchronize relative scene coordinates before launching the game.

Applying AExLevelScriptActor Directly to a level configuration opens up the same persistent ticking workflow for Level Blueprints. This setup enables map-specific scripts to continuously evaluate custom origin points, monitor target positions, and calculate dynamic transformations without relying exclusively on standalone external manager actors to trigger update ticks.

Module Architecture and Target Platform Support

Under the hood, the plugin is organized as a streamlined runtime package. The asset footprint contains a concise technical payload consisting of:

• 1 Blueprint asset.
• 4 compiled C++ classes providing the underlying transform and actor ticking logic.
• 1 runtime code module designated as LevelController.

Network replication is not built into the system. Transformations, origin shifts, and actor ticking routines are handled locally on the client or standalone instance. Multiplayer projects requiring map shifts across multiple clients must govern synchronization and function triggering through external networked game state logic.

Development is fully supported on Windows (x64) and Mac operating systems, making it straightforward to integrate into cross-platform team environments. Compatibility extends to full Blueprint graph viewing regardless of editor screen resolutions or monitor configurations, maintaining readable node networks across varied workstation setups.

When packaging projects, the plugin compiles across an exceptionally wide range of target build platforms. Supported build targets include:

• Windows desktop platforms (both x86 and x64 / x84 configurations).
• Mac workstations and standalone targets.
• Mobile operating systems across iOS and Android.
• Web deployments targeting HTML5.

This extensive platform coverage ensures that runtime level manipulation mechanics remain stable whether deployed to high-end desktop workstations, portable mobile games, or browser-based builds.

Production Setup and Verification

Integrating the plugin into existing project pipelines is reinforced by available documentation and public example project resources. These references outline the explicit steps needed to reparent target classes to AExActor, assign AExLevelScriptActor In world settings, and wire transform nodes into standard Blueprint execution paths.

By verifying custom origin behavior and inspecting runtime tick rates inside the provided project files, teams can validate performance budgets before committing map-transform logic to main production branches. The isolated nature of the runtime module ensures that enabling or packaging the plugin introduces zero external framework bloat while providing robust, real-time map transformation tools.

More From The Same Workflow

• Mazen Level Tool
• RealTime Import/Export Plugin
• Firebase Goodies
• Quiet Runtime Editor
• Runtime Speech Recognizer (Real-Time, Offline, AI)