Assets¶

Assets are the files a project is built from: scenes, meshes, materials, textures, robot models, procedural graphs, learned policies and scripts. Lucky Engine keeps every asset inside the project's Assets folder and tracks it in a registry. Scenes and components reference an asset by a stable handle, so a reference keeps working after the asset is renamed or moved within the editor.

In short

The Content Browser is the home for project assets. Import copies a source file into the project, the New menu creates engine-native assets such as scenes, materials, scripts and procedural graphs, and dragging assets into the viewport places them in the scene. Ctrl+S saves the current scene and the project. Ready-made robots, environments and other packs arrive through the Content Vault.

The Content Browser¶

The Content Browser is the panel for browsing, importing, creating and organising project assets. In the built-in Scene layout it is docked at the bottom and cannot be closed. In other layouts, open it from View → Content Browser or with the Content Browser button in the title bar.

The panel has four parts:

A folder tree on the left, showing the Assets folder and its subfolders.
A grid on the right, showing the contents of the current folder.
A top bar above the grid, for navigation, filtering and search.
A status line along the bottom, showing the path of the selected item (for example Assets/Meshes/Crate.hsmesh), or how many items are selected.

The grid shows a rendered thumbnail for textures, materials, meshes, static meshes, mesh sources, environment maps, prefabs and procedural graphs, and a file-type icon for everything else. Thumbnails are created in the background and kept in the project's Cache folder, and a thumbnail is updated when its asset changes. Hover over an asset for a moment to see its file name and type; textures also show their size and pixel format.

Other panels work alongside the Content Browser:

Panel	Use it to
Content Vault	Install ready-made packs: robots, meshes, materials, procedural graphs, environments and example projects. See Content Vault.
File Tree	Browse the whole project folder, including files outside `Assets` such as recordings. See Viewing Files.
Material Editor	Edit a material's channels and textures. Opens when you double-click a material.

Navigating¶

Control	What it does
Back / Forward	Step through the folders you have visited, like a web browser. Also `Alt`+`Left` / `Alt`+`Right`, or the mouse's back and forward buttons. Greyed out when there is nowhere to go.
Up to parent directory	Opens the folder above the current one. Greyed out in `Assets`.
Refresh	Scans the `Assets` folder again and updates the grid. Also `F5`.
Clear thumbnail cache	Reloads the thumbnails shown in the grid.
Filter assets by type	Opens an Asset Type list. Pick a type to hide folders and list every asset of that type in the current folder and all its subfolders. Pick All to go back to the normal view.
Search box	Shows the assets whose file name contains the text, ignoring case, from the current folder and all its subfolders. Respects the type filter. `Ctrl`+`F` jumps to it.
Breadcrumbs	The path of the current folder, starting at Assets. Click an entry to go there.
Content Browser settings	The button on the far right. Show Asset Types shows each asset's type on its tile (on by default), and a slider sets the thumbnail size, from 96 to 512 (default 128).

Double-click a folder in the grid to open it, or click it in the folder tree.

Selecting¶

Click an item to select it. Ctrl + click adds an item to the selection or removes it, and Shift + click selects a range. Click an empty part of the grid, or press Esc, to clear the selection.

How assets are stored¶

A project is a folder on disk. The editor writes a project file and an Assets directory next to it:

MyProject/
  MyProject.hproj          project file (YAML)
  Assets/
    AssetRegistry.hzr      asset registry (handle, path, type)
    Scenes/
    Materials/
    Meshes/
    Scripts/
    Textures/
    ...
  Cache/                   generated data, safe to delete
  DataSessions/            recordings, created when you first record

Every asset has a 64-bit handle. The registry, Assets/AssetRegistry.hzr, maps each handle to a file path and an asset type. Scenes, prefabs and components store the handle rather than the path, which is why an asset can move between folders without breaking the things that point at it.

The Cache folder holds data the editor can rebuild, such as thumbnails and collision shapes. Deleting it is safe, but the editor then has to rebuild that data, which can take a while for large scenes. Recordings go to DataSessions, outside Assets, so they do not appear in the Content Browser; see Viewing Files for how to open them.

Organise inside the Content Browser

Renaming and moving assets from the Content Browser keeps the registry in sync. Moving the same files from outside the editor can leave the registry pointing at the old location, so prefer the in-editor actions. Files you copy into Assets from outside the editor are registered the next time the Content Browser refreshes.

Asset types¶

Lucky Engine recognises an asset by its file extension. Two groups exist: source files imported from outside, and engine-native files created and saved in the editor.

Imported from source files:

Content	Source files	Becomes
3D models	`.fbx` `.gltf` `.glb` `.obj` `.dae` `.vrm` `.stl`	Mesh source
Images, textures	`.png` `.jpg` `.jpeg`	Texture
Environment maps	`.hdr`	Environment map
Robot and world models	`.xml`	MuJoCo scene (MJCF)
Policy models	`.onnx`	ONNX model, or a policy through Import ONNX Policy (.honnx)
Motion clips	`.json`	Motion
Datasets	`.parquet` `.parq` `.pq`	Parquet data
Audio	`.wav` `.ogg`	Audio
Fonts	`.ttf` `.otf` `.ttc`	Font

Created and saved in the editor (native formats):

Asset	File	Made with
Scene	`.hscene`	New → Scene
Material	`.hmaterial`	New → Material, edited in the Material Editor
Prefab	`.hprefab`	Drag entities from the Scene Hierarchy into the Content Browser
Static mesh	`.hsmesh`	The mesh source wizard, or Convert to Static Mesh (.hsmesh)
Mesh (skinned)	`.hmesh`	The mesh source wizard, or Convert to Dynamic Mesh (.hmesh)
Animation	`.hanim`	The mesh source wizard, one per animation clip
Procedural graph	`.hpodgraph`	New → Procedural Graph, New → Motion Graph, New → Animation Graph, Promote to Graph on a procedural primitive, or the mesh source wizard
ONNX policy	`.honnx`	Import ONNX Policy (.honnx)
Script	`.cs`	New → Script
Sound config	`.hsoundc`	New → Audio → Sound Config
Spatialization config	`.hspatconfig`	New → Audio → Spatialization Config
Mesh collider, convex hull	`.hmc`, `.hchull`	Generated by the editor when it builds collision shapes

Procedural graphs are node graphs that produce geometry, robot and character motion, or sound. They have a page of their own: Procedural Graphs.

Every .json imports as a Motion asset

The .json extension always maps to a Motion asset. Policy configuration files such as model_config.json and policy_descriptor.*.json are read by path where they are needed, not used as standalone assets, so their classification in the browser can be ignored.

Upgrading from 2026.2

The 2026.2 graph formats are no longer supported: motion graphs (.hmograph), animation graphs (.hanimgraph) and sound graphs (.sound_graph). The editor no longer recognises these files as assets and does not convert them. Content Vault packs and projects brought in with File → Import Project... that still contain them are rejected. Their replacement is the procedural graph; see Procedural Graphs.

Importing assets¶

Importing brings an outside file into the project. Right-click an empty area of the Content Browser grid and pick one of:

Menu item	What it does
Import	Opens a file picker and copies the chosen file into the current folder. Importing a MuJoCo `.xml` also copies the meshes, textures and included files it references.
Import ONNX Policy (.honnx)	Picks an `.onnx` model and bundles it with its `model_config.json` into a `.honnx` policy in the current folder. A `model_config.json` next to the model is found automatically; otherwise a second file picker asks for one.
Bulk Import	Picks a folder and copies its whole tree into a folder of the same name inside the current folder.

Imported files are registered straight away, using the type that matches their extension. A file whose extension is not recognised is copied but not tracked, so it does not appear in the Content Browser.

For learned policies, Import ONNX Policy (.honnx) writes a .honnx manifest that points at the copied .onnx model and its model_config.json. Registering that policy on a robot is covered in Robots → Adding policies and motion graphs.

The mesh source wizard¶

Importing a 3D model only copies the file into the project as a mesh source. To turn it into assets a scene can use, drag the mesh source into the viewport, or drop it onto a Mesh or Static Mesh field in the Inspector. This opens the Create Assets From Mesh Source wizard:

The left list, ITEMS IN the source file, shows what can be created: a Static Mesh, a Dynamic Mesh, one item per animation clip, and a Default Animation Graph (saved as a procedural graph).
Select items and click Add --> to move them to the ASSETS TO CREATE list on the right. <-- Remove moves them back.
Select an item on the right to edit its settings below the list. Static and dynamic meshes each have a Generate Colliders option.
Tick Overwrite existing files to replace assets created earlier. Problems, such as a file that already exists, are highlighted in red.
Click Create.

When the wizard creates a Default Animation Graph along with a mesh, it also gives the mesh's entity an Animation component that uses the graph. This is how a character gets an Animation component: Add Component does not offer one. See Procedural Graphs → Animation graphs.

Drop several mesh sources at once and the editor opens one wizard after another, titled Create Assets From Mesh Source (1 of 3) and so on. Cancel skips the current file; Cancel All also skips the ones still waiting.

For a quick conversion without the wizard, select one or more mesh sources, right-click an empty area of the grid and choose Convert to Static Mesh (.hsmesh) or Convert to Dynamic Mesh (.hmesh). The new assets are written to the project's Assets/Meshes folder rather than next to the source. These menu items do not generate colliders; use the wizard's Generate Colliders option for that.

Creating assets¶

Right-click an empty area of the grid and open the New submenu. New assets are created in the current folder and are not opened automatically: double-click one to edit it.

New →	Creates
Folder	A folder named `New Folder`, with its name ready to edit.
Scene	`New Scene.hscene`, which already contains a ground, a directional light, a sky light and a camera.
Animation Graph	`New Animation Graph.hpodgraph`, a procedural graph for skeletal animation, the kind an Animation component's Animation Graph field takes.
Motion Graph	`New Motion Graph.hpodgraph`, a Motion graph with only its output node, the kind a robot's Motion Graph field takes.
Material	`New Material.hmaterial`, a PBR material.
Procedural Graph → Geometry, Simulation, Motion, Audio	A procedural graph of that kind, such as `New Geometry Graph.hpodgraph`, in a `Graphs` subfolder of the current folder. The subfolder is created if needed. A Geometry graph starts as a cube and an Audio graph as a quiet tone; Simulation and Motion graphs start with only their output node. The submenu also lists kinds these pages do not cover.
Audio → Sound Config, Spatialization Config	`New Sound Config.hsoundc` or `New Spatialization Config.hspatconfig`.
Script	A C# script. The New Script dialog asks for a Namespace (the project's default namespace if left empty) and a Class Name, and shows the file it Creates. The script starts with empty `OnCreate` and `OnUpdate` methods.

What each kind of procedural graph is for, and how to edit one, is covered in Procedural Graphs. Writing and building scripts is covered in Creating and Building Scripts.

Right-clicking a folder in the folder tree offers a shorter New menu (Folder, Scene, Material, Sound Config) that creates the asset in that folder, along with Rename, Delete and Show in Explorer. Delete asks Delete this folder and everything in it? before it deletes the folder and its contents.

Saving¶

Ctrl+S saves the current scene and then the project, and shows Scene Saved. When a Text Editor tab has focus, Ctrl+S saves that file instead. File → Save saves the scene and the project and shows Project Saved. Ctrl+Shift+S saves the current scene under a new name, like File → Save Scene As....

Native assets are files in the Assets folder, written by their editors: the Material Editor saves a material as you edit it, and the graph editor saves a procedural graph when you click its Save graph button. Imported source files are never rewritten by the engine: the file on disk stays authoritative, and the engine only reads from it. Even the MuJoCo Import Editor, which chooses which MuJoCo render groups are shown, stores its choice in a separate <model>.xml.mjimport file next to the model.

The editor keeps track of unsaved changes in the scene, in Text Editor tabs and in graph editor tabs. Before anything closes them (closing the tab, opening another scene or project, or quitting), it asks whether to save. See Viewing Files → Unsaved changes.

The File menu holds the scene and project actions: New Scene..., Open Scene..., Save Scene As..., Set Scene as Startup and Revert to Saved, along with Import Project... and Export Project.... New Scene... asks for a Scene name; Create Scene, or Enter, saves the new scene in the project's Assets/Scenes folder and opens it.

Organizing assets¶

Right-click an asset or folder in the grid for its actions:

Action	Notes
Reload	Re-reads the asset from disk.
Rename	Inline rename, also `F2`. Shown when exactly one item is selected. Keeps every reference to the asset intact.
Copy	Marks the item for Paste; see below.
Duplicate	Makes a copy next to the original with a numbered suffix, such as `Crate_01.hmaterial`. Also `Ctrl`+`D`.
Delete	Asks Delete this item? (or Delete these N items?) and lists what it will delete; folders are deleted with everything in them. Delete deletes them. Cancel, `Esc` or a click outside the dialog keeps the files. Also `Del`.
Open in Text Editor	Opens the file as text in the editor's own Text Editor tab. See Viewing Files.
Show In Explorer	Reveals the file in the operating system's file manager.
Open Externally	Opens the file in the operating system's default application for it.
Export (scenes)	Copies the scene and every asset it uses into a folder you choose, with an asset registry of its own.

Copy (Ctrl+C) and Paste (Ctrl+V) work within the folder you are viewing: pasting creates numbered copies next to the originals, the same as Duplicate. To put an asset in a different folder, move it instead.

Move assets and folders by dragging them onto a folder in the grid, a folder in the folder tree, or a breadcrumb entry, including the root Assets. Moving and renaming inside the editor keep every reference to the asset working. A folder cannot be moved into itself or into one of its own subfolders.

These shortcuts work while the Content Browser has focus and you are not typing in a text field:

Shortcut	Action
`Alt`+`Left` / `Alt`+`Right`	Back / Forward
`Ctrl`+`F`	Jump to the search box
`Ctrl`+`Shift`+`N`	New folder, with its name ready to edit
`Ctrl`+`C` / `Ctrl`+`V` / `Ctrl`+`D`	Copy / Paste / Duplicate
`F2`	Rename the selected item, or the current folder in the folder tree
`Del`	Delete the selection, after a confirmation
`F5`	Refresh
`Esc`	Clear the selection

Using assets in a scene¶

Most assets are placed by dragging them from the Content Browser into the viewport while the scene is in Edit mode. Drops are ignored while the scene is playing.

Drag this	Onto	Result
Mesh or static mesh	The viewport	A new entity at the drop point
Procedural graph	The viewport	A new entity at the drop point, named after the file, with a Procedural Mesh component that uses the graph
Prefab	The viewport	A prefab instance
MJCF model	The viewport	A robot or world with MuJoCo physics
Material	A surface in the viewport	Assigns the material to that part of the mesh and selects the object
Scene	The viewport	Opens the scene
Mesh source	The viewport	Opens the mesh source wizard
Texture	A texture slot in the Material Editor	Assigns the texture to that slot
Any asset	A matching asset field in the Inspector	Assigns the asset to the field
Entities from the Scene Hierarchy	The Content Browser grid	Saves them as a prefab in the current folder

The drop point is the surface under the cursor, or the ground plane if there is nothing under it.

You can drag several assets at once. Meshes, static meshes and procedural graphs dropped together are laid out side by side in a grid centred on the drop point, and all of them are selected. Each mesh source in the drop opens its own wizard in turn. A scene opens only when it is the only asset being dragged.

One dragged entity becomes <EntityName>.hprefab; several become one prefab named after the first, such as Table-[3]-Group.hprefab. Assets cannot be dropped onto the Scene Hierarchy's entity tree: drop them into the viewport instead. More on placing objects is in Viewport.

The lifecycle of an imported asset is short and linear:

graph LR
    A([Source file]):::s -->|Import| B([Copied under Assets/]):::s
    B --> C([Registered with a handle]):::s
    C -->|loaded on first use| D([Placed in a scene]):::s
    D -->|referenced by handle| E([Scenes and components]):::s
    classDef s fill:#2d3a4f,stroke:#4a5e7e,color:#ffffff;

Editing prefab instances¶

Each entity of a placed prefab shows a Prefab section in the Inspector. To save changes you have made to an instance into the prefab asset, right-click the instance's root entity, which is named after the prefab file, in the Scene Hierarchy and choose Update Prefab. The prefab's other instances in the scene take on the changes, apart from components they have changed themselves in the Inspector.

The settings in the Prefab section apply to the selected entity:

Revert To Source Prefab: the Revert button resets the entity and its children to match the prefab. It is greyed out until you change one of the entity's components in the Inspector.
Ignore Updates From Prefab: the entity keeps its own values when the prefab is updated. Its children still follow the prefab unless you tick it on them too.
Don't Push Changes to Prefab: Update Prefab leaves the changes to this entity and its children out of the prefab.

Opening assets¶

Double-click an asset to open it:

Asset	Opens in
Scene	The viewport. If the current scene has unsaved changes, the editor asks first.
Material	The Material Editor
Procedural graph	The graph editor. See Procedural Graphs.
Texture (`.png`, `.jpg`, `.jpeg`)	An Image Viewer tab
Script (`.cs`) or Motion (`.json`)	A Text Editor tab
MuJoCo model (`.xml`)	The MuJoCo Import Editor, which chooses which MuJoCo render groups are shown
Prefab, audio file, sound config, spatialization config, animation	That asset's editor

Each of these, apart from scenes and the Material Editor, opens as its own tab named after the file. Meshes, static meshes, mesh sources, environment maps, fonts, ONNX files and Parquet files have no double-click action. To view a Parquet file, open it from the File Tree; see Viewing Files.

Asset fields¶

Components refer to assets through asset fields in the Inspector (the selected entity's properties, shown in the Scene Hierarchy panel). A field shows the asset's name, Null when it is empty, or the name followed by (Missing), in red, when the file is gone.

Click a field to open the asset picker next to it. Its search box is ready for typing: type part of a name to narrow the list, which is sorted by name and shows each asset's type on the right. The current asset is highlighted, and the list updates as assets are added or deleted. Click an asset to assign it, or choose Clear (when the field can be empty) to empty the field. Double-click a field to open the asset it points to.

The picker also works from the keyboard: Up and Down move the highlight, and Enter assigns the highlighted asset, or the first match once you have typed a search. Esc, or a click outside the picker, closes it without changing the field. The same picker is used to choose an entity or a script in a field that takes one.

Robotics assets¶

The robot-specific asset types fit into the same system:

MJCF models (.xml) are MuJoCo scenes. A robot is an MJCF model with its meshes and textures. Dragging one into the viewport builds the robot with its physics, and double-clicking one opens the MuJoCo Import Editor.
Policies (.honnx) bundle an ONNX model with its configuration. They are imported through Import ONNX Policy (.honnx) and registered on a robot from the robot's right-click menu.
Motion graphs are procedural graphs (.hpodgraph) of the Motion kind. A robot's Robot Controller component takes one in its Motion Graph field. They are edited in the graph editor; see Procedural Graphs.

Most robots arrive prebuilt as Content Vault packs, so these files are already wired up on placement. The pack contents and the robot setup are covered in Robots. Policy configuration files (model_config.json, policy_descriptor.*.json) and the project's PolicyRegistry.yaml are plain configuration read by path, not catalogue assets.

Where to go next¶

Content Vault installs robots, meshes, materials, procedural graphs and example projects.
Procedural Graphs explains the graph asset used for procedural meshes, robot motion, animation and sound.
Viewing Files covers the Image Viewer, Video Player, Parquet Table and Text Editor tabs, and the unsaved-changes prompt.
Robots covers robot packs and registering policies and motion graphs on a robot.
Working with components shows how scripts reference meshes, materials and MuJoCo bodies at runtime.