MotaEngine Editor Manual

The MotaEngine editor is where you build a game: place and edit entities in scenes, make assets (materials, blueprints, particle systems, sounds, UI), script with Lua, play the game inside the editor, and package it for players. This manual covers the editor. The engine itself (C++ SDK, Lua API, servers, packaging details) is in the User Manual, the C++ SDK Reference and the Lua API Reference.

Contents

1. Installing
2. Projects and the Project Browser
3. The Editor Window
4. Working in the Viewport
5. Entities and Components
6. Assets and the Content Browser
7. Asset Editors
8. Level Tools: Landscape, Foliage, PCG, World Partition
9. Scripting: Lua, Blueprints, Python
10. Playing in the Editor
11. Tools Menu
12. Building and Packaging
13. Debugging Panels
14. Source Control
15. Preferences, Layouts and Settings
16. Keyboard Shortcuts
17. Console Commands for Automation
18. Files, Folders and Troubleshooting

1. Installing

Run MotaEngine-<version>-Setup.exe. By default it installs for the current user only, in %LOCALAPPDATA%\Programs\MotaEngine, without asking for administrator rights; the wizard also offers an all-users install. It adds a Start menu shortcut, optionally a desktop shortcut, and can make .motaproj files open in the editor.

Requirements: Windows 10 or 11 (64-bit) and a GPU with Vulkan 1.3 drivers. Ray-traced lighting needs a GPU with hardware ray tracing; without one the editor uses its other lighting paths.

Updates: Help > Check for Updates compares your version with the latest release (it can also check by itself a minute after start-up, then daily: Edit > Editor Preferences). An installed editor downloads the new installer, verifies its SHA-256 hash and runs it; your projects and settings are kept.

To uninstall, use Windows Settings > Apps. Your projects in Documents\MotaEngine and your settings in %LOCALAPPDATA%\MotaEngine are not removed.

2. Projects and the Project Browser

The editor starts on the Project Browser. Turn off Show at startup and it reopens your most recent project instead (the browser still comes up when that project is gone). Its tabs:

• Projects: open a .motaproj by path or Browse, or pick a recent project. A missing project shows (missing) with Remove from list.
• New Project: a name, a folder (default MyProjects in your workspace) and a starting point: empty, or a copy of a sample. A copy gets its own folder and every path inside the sample is rewritten to it.
• Samples: the games that ship with the editor. Open copies the sample into your workspace (Documents\MotaEngine\projects\<Name>) the first time, then opens it; your changes stay in that copy. Copy as New Project makes an independent project from it.
• Settings: editor preferences that apply before a project is open.

Continue without a project opens the editor on an empty scene.

File > New Project / Open Project / Recent Projects do the same from the editor. A project is a folder with a .motaproj file:

File > Project Settings edits the .motaproj: name, company, startup scene, game module (empty = a script-only game), icon, input bindings, startup console commands, physics (gravity, solver iterations, collision matrix), rendering (anti-aliasing, sun shadow cascades), world streaming, packaging.

3. The Editor Window

The window is a menu bar, a toolbar, docked panels and a status bar. The default layout:

• Viewport (center): the scene.
• World Outliner (right): every entity in the scene, searchable, with visibility and lock toggles; drag to parent.
• Details (right, below): the selected entity's components.
• Content Browser (bottom left): the project's files.
• Console (bottom right): the log and the command line.

Panels are tabs: drag a tab to another area or to an edge to split it. Window opens every other panel, grouped as General, Visual Editors, Systems, Level Tools, Scripting, Game Services, Debug and Utility. View > Save Layout As / Load Layout / Reset Layout manage arrangements; the editor reopens with the layout it closed with.

The toolbar has Save, Undo/Redo, the transform tools (move, rotate, scale), snapping, local/world space, Play / Pause / Stop and the build target.

4. Working in the Viewport

Camera:

• Right mouse drag: look around; with W A S D fly, Q / E down / up.
• Middle mouse drag: pan. Mouse wheel: zoom toward the cursor.
• Alt + left drag: orbit the selection. Alt + right drag: dolly.
• F frames the selection, View > Frame All the whole scene, View > Go to Location a coordinate.
• Ctrl+Shift+1..9 stores a camera bookmark, Ctrl+1..9 returns to it.
• The viewport toolbar sets camera speed, field of view, perspective or orthographic views (top, front, side), and the view mode (lit, unlit, wireframe, normals and other visualizations).

Selection and editing:

• Click selects; Ctrl+click adds; Ctrl+A selects all.
• W / E / R switch the gizmo between move, rotate and scale. Snapping and grid size are on the toolbar; the same values drive every tool.
• Ctrl+D duplicates, Delete removes, Ctrl+C / X / V copy, cut, paste.
• Every change is undoable (Ctrl+Z / Ctrl+Y); Window > Utility > Undo History lists the steps. The title bar shows * while the scene has unsaved changes, and closing or switching scenes asks to save.
• Drag a model, sound or sound cue, Lua script, prefab or particle system from the Content Browser onto the viewport to place it under the cursor; a material dropped on a mesh is applied to it.

View toggles the grid (G), world axes, FPS, statistics, the navigation mesh and light gizmos.

5. Entities and Components

An entity is a set of components. Select one and use Details: Add Component lists every component by category (rendering, physics, audio, AI, scripting, gameplay, cinematics, lighting); each component shows its fields, and removing one is undoable.

Common components:

World Settings (Window > General) holds per-scene overrides: gravity, a kill height (entities falling below it are removed), world bounds, ambient light, fog and time scale; they are saved with the scene.

Layers groups entities so you can hide or lock them together.

6. Assets and the Content Browser

The Content Browser shows the project folder. Double-click opens a file in the right place: a scene opens as the level, a model in the Static Mesh Editor, an image in the Texture Editor, and each asset type in its editor.

• Import (Assets > Import Asset, or the browser's import button): models (glTF with its .bin and textures, FBX, OBJ), images, sounds. Files are copied into the folder you are viewing.
• Reimport (Assets > Reimport Selected / Reimport All) reads changed source files again.
• Create (the + button, or Assets > Create) makes a new asset in the current folder and opens its editor:

• Rename / Move (right-click, or drag onto a folder) updates every scene and asset in the project that refers to the file.
• Find References lists the files that use an asset.
• Thumbnails show models, textures and particle systems.
• Collections (Window > General) are named sets of assets across folders.

7. Asset Editors

Each editor opens full-window with Save, Save As and Close; unsaved changes are marked and confirmed on close.

• Material Editor: a node graph compiled to material parameters (texture samples, constants, math). The preview sphere shows the result. Material Instance overrides a material's parameters.
• Blueprint Editor: visual scripting (see 9).
• Static Mesh Editor (a model file): import scale, the material, sockets, levels of detail (reduction and switch distance per level, with a preview picker) and collision. Settings are saved beside the model in <model>.meshsettings.
• Texture Editor (an image): sRGB, mip-maps, maximum size, compression, filtering and wrapping, saved in <image>.texsettings and used by the game and by packaging.
• Skeleton Editor: imports a skeleton from a rigged model and edits bone sockets (<model>.motaskel); games attach things to sockets with mota.getSocket.
• Persona: animation blueprints (state machines and blends for rigged models).
• Sequencer: level sequences (keyed transforms, events, cameras).
• VFX System / Emitter / Module: particle systems with live preview.
• Sound Cue / MetaSounds: sound graphs; a sound cue plays anywhere a sound file does.
• Behavior Tree / Blackboard: AI logic run by AI Controller components.
• UI Widget Designer: HUDs and menus (.motawidget); Lua shows them with mota.showWidget.
• Data Table / Curve: data for gameplay code and scripts.
• Mesh Modeling: edit a mesh's vertices, edges and faces.
• Physical Material: friction, restitution and density, used by physics.

8. Level Tools

Landscape (Modes > Landscape, or Window > Level Tools): sculpt (raise, lower, flatten, smooth) and paint layers on a height field with the left mouse button. The landscape is saved in the scene's sidecar file and has collision in the game.

Foliage (Modes > Foliage): paint instances of a mesh with density, scale range and surface offset; Shift + left mouse erases.

PCG (Window > Level Tools > PCG): a procedural graph that scatters meshes; evaluate, spawn and clear its results.

World Partition (Window > Level Tools > World Partition): stream a large world in cells.

• The level's far content lives in cell scenes, <cell folder>/cell_<x>_<z>.json. Each is an ordinary scene: Open one from the panel and edit it.
• Set the cell folder, cell size and load radius, then Save to Project.
• While the game runs (Play, and in packaged games), the cells around the camera are loaded and the rest unloaded. In the editor nothing streams while you edit, so cell content never ends up in the main scene.
• The panel's map shows the cell files, the cells loaded right now and the camera's cell; New Cell Here creates the cell under the camera.

Navigation (Build > Build Navigation Mesh): builds a walkable mesh from static colliders and the landscape, saved with the scene; AI "Move To" follows it. View > Show NavMesh draws it.

9. Scripting

Lua. Add a Script component and choose a .lua file. Scripts get OnCreate, OnUpdate, OnDestroy, and OnTriggerEnter / OnTriggerExit on trigger colliders; they reload when the file is saved. The full API is in the Lua API Reference. The Console runs Lua with lua <code>; Window > Scripting > Script Console is a Lua REPL.

Blueprints. A visual script (.motabp) attached with a Blueprint component. Events: On Create, On Update, On Input (an input action), On Trigger, On Collision, On Destroy. Nodes cover flow (Branch, Sequence, For Loop), variables, math, transforms, forces, sounds, spawning prefabs and logging. Each entity running a blueprint has its own variables. The Problems panel at the bottom lists anything that cannot run.

Debugging blueprints. Open a saved blueprint, select a node and press F9 for a breakpoint (a red dot). When a running blueprint reaches it, the game pauses before that node and Window > Debug > Blueprint Debugger shows the entity, the node and the blueprint's variables; the node is outlined in the Blueprint Editor. F10 runs one node, F5 (or Continue, or Resume on the toolbar) runs on. Stop ends the paused event.

Python (Window > Scripting > Python) is an editor-only Python console for automating the editor. Verse (Window > Scripting > Verse) edits and runs Verse-style scripts.

10. Playing in the Editor

F5 (or the Play button) plays the open scene in the viewport; F6 pauses, Play > Step Frame advances one frame, Shift+F5 stops and restores the scene as it was. Play in New Window runs the game as a separate process.

F8 ejects: the viewport switches to the free editor camera while the game keeps running without input, so you can look around and select things; F8 again returns to the game.

Multiplayer (Play > Play Settings):

• Multiplayer Mode: Standalone (in the viewport), Listen Server (a game window that hosts plus client windows), or Dedicated Server (a headless server plus client windows).
• Number of Players: 1 to 4.
• Network Emulation: none, LAN, broadband (30 ms, 1 % loss) or mobile (100 ms, 5 % loss).

Play then launches the instances with a snapshot of the scene, in tiled windows, over the encrypted transport. Each writes a log to Saved/PIE/; errors also appear in the editor's console. Stop ends them all. What is shared between players depends on what the game replicates.

11. Tools Menu

• Merge Meshes: combines the selected meshes into one model file.
• Generate LODs: builds levels of detail for the selected models.
• Collision Generator: fits a box, sphere, convex hull or exact triangle collider to the selected meshes.
• Texture Atlas Generator: packs the images of the current Content Browser folder into one atlas (.atlas.json + image); widgets and sprites refer to atlas.json#sprite.
• Localization Dashboard: string tables, languages and missing translations.
• Source Control: see 14.
• Command Palette (Ctrl+Shift+P): every menu command by name.

12. Building and Packaging

Build > Build All packages the open project for players into dist/<Game>/ (in your workspace for an installed editor): the game executable (the editor-free runtime, renamed after the game, with the project's icon), a signed, compressed .pak with the game's content, run.bat, and the license and third-party notices players must receive. Build and Run starts it afterwards. Build Settings chooses the output folder and options; Clean Build Output removes old output.

Build > Build Navigation Mesh and Build Reflection Captures bake level data.

DLC and patches (Window > Game Services > DLC Manifest): choose the released game's .pak (Before) and this project (After), Build Delta, and Save Delta writes a signed .dpk with only what changed. A game mounts it with the console command dlc.mount <label> <file> (put it in the project's startup commands to apply it at launch).

A game with a C++ module builds with the mota tool and the C++ SDK from motaengine.com; see the User Manual.

13. Debugging Panels

Window > Debug:

Window > Game Services: Online (sign-in, achievements, leaderboards, cloud saves, friends, parties), Save Inspector (the game's save slots and the numbers Lua stores with mota.saveNumber; load and save while playing), Telemetry, Localization Dashboard, DLC Manifest.

14. Source Control

Tools > Source Control (or Window > Debug) works with git in the project's folder: the branch and last commit, changed files with checkboxes to stage and unstage, a commit message, and the recent history. A project that is not in a repository offers Initialize Repository. Git runs in the background, so a large repository does not stall the editor. It needs git installed and on PATH.

15. Preferences, Layouts and Settings

Edit > Editor Preferences: theme (dark / light), UI scale, viewport defaults (grid, axes, snapping, camera speed, field of view), Content Browser view, the external code editor for scripts, and update checks. Preferences are saved per user.

16. Keyboard Shortcuts

Help > Keyboard Shortcuts lists them all. The main ones:

17. Console Commands for Automation

The Console runs engine commands (help lists them). Editor commands, also usable from the command line with --exec="cmd1;wait 60;cmd2" (wait N waits N frames):

18. Files, Folders and Troubleshooting

An installed editor keeps:

After a crash, the next start shows MotaEngine closed unexpectedly with buttons to open the crash folder and report the bug; attach the .dmp and .log from that folder to your report (Help > Report Bug). Help > Open Crash Reports Folder opens it at any time.

A project looks wrong after opening it: check File > Project Settings > startup console commands (render settings the game applies) and the Console for warnings.

The editor's layout is broken: View > Reset Layout.

Third-party software: Help > About lists the open-source components the editor and every packaged game are built on, with their licenses.