Properties & Components¶

The Properties window displays every component attached to the selected entity and lets you read and change their values. It is the primary place to configure transforms, materials, physics, scripts, UI layout, audio, animations, and any other component data.

Selecting an entity¶

Click an entity in the Structure panel or directly in the Scene view to select it. The Properties window updates immediately to show its components.

The field at the top holds the entity name: edit it to rename the entity, or press F2 anywhere in the scene windows to jump straight into it with the name selected. With several entities selected the field is read-only; with none selected, the window shows the scene settings instead and the same field renames it.

While a scene is playing, an entity the game created (drawn in green in the Structure panel) is shown read-only: you can watch its values change, but not rename it, edit its fields, or add and remove components, because Stop destroys it.

Adding components¶

Use the New component button at the top of the Properties window. A searchable dialog lists all available component types grouped by category; type in its search field to narrow the list. Components are added to the entity immediately and their defaults appear in the panel for editing.

Component groups¶

The dialog groups the components into these categories:

Editing component fields¶

Most fields are edited with the mouse or keyboard directly in the panel:

When a field differs from the component's default value, a small reset arrow appears next to its label; clicking it restores the default. Edits apply to every selected entity and every change is undoable.

A texture field set to a camera shows that camera's live output (render-to-texture). The camera is switched to render-to-texture automatically and can no longer be the scene's main camera. This is the manual building block behind effects like minimaps and monitors; for reflections, prefer the Mirror component, which manages its own camera.

Once a camera is in render-to-texture mode, its own properties gain a Render Target section for setting the framebuffer Width, Height, and sampling Filter (Nearest or Linear). These control the resolution and look of the output texture, are saved with the scene, and are applied in exported projects.

When the field holds an image texture (not a camera link or an empty slot), a sliders button next to the camera button opens the Texture Settings popup:

• Min Filter / Mag Filter — sampling filters for minification and magnification. Picking a mipmap variant for Min Filter enables mipmap generation for the texture.
• Wrap U / Wrap V — wrapping mode per texture axis.
• Alpha Border — whether transparent pixels next to visible ones take their color on load, so filtering does not draw a dark outline. Auto fixes sprites, tilemaps, polygons, UI and particles and keeps 3D materials as they are; see Texture.alphaBorder.
• SVG Scale (only for .svg sources) — a multiplier on the vector's intrinsic size (a drag field plus 0.5×–4× presets), so the image rasterizes crisp when drawn larger or on high-DPI displays. The scale is stored on the texture reference, so different slots can use the same SVG at different resolutions.

Like any other field, each row shows the reset arrow when it differs from the component's default, and the settings are saved with the scene and applied in exported projects. See Vector images (SVG) for the underlying behavior.

Text fonts¶

The Text component's Font row controls the main font. Pick a .ttf, .otf, or .ttc file with the folder button, drag one from the Resources Browser, or use the clear button to return to the built-in default. Font files must be inside the project's assets directory.

The stacked layers button opens Additional fonts with three fallback slots. The engine tries Fallback 1, Fallback 2, and Fallback 3 in order whenever the main font does not contain a character; empty slots are skipped, and the built-in Roboto and Arabic fonts finish the chain. Each slot has its own picker, drag target, clear button, and reset action. A highlighted layers button means at least one fallback is configured.

Dropping a font directly onto a Text entity in the Scene view replaces only the main font and keeps its fallbacks. The preview is live and the final assignment is undoable. Every slot is saved, generated into exported scene and bundle code, included in asset path updates, and copied with the project assets.

The editor's AI assistant also treats a Font property as this ordered chain. A full-chain edit replaces the main font and fallbacks, clearing slots omitted from the request; a main-font-only edit preserves the current fallbacks. The assistant accepts only safe, project-relative font paths inside the assets directory.

See Text and fonts for runtime behavior and the Text API for C++ and Lua access.

Model component¶

The Model component loads a GLTF/GLB/OBJ/FBX file onto the entity (an FBX through its glTF conversion). Multi-node GLTF files usually create child entities under the model root — the full node tree when the file has animation clips or more than one skin, otherwise one child mesh per mesh node. See 3D Graphics — GLTF node hierarchy.

For static multi-node models that need same-entity features such as Instanced Mesh, use Merge static model on the entity in Structure (or Restore model mesh children to undo). That sets the serialized mergeStaticMeshes flag and reloads the model in one undoable step. See 3D Graphics — Merging static model meshes.

Setting Model File rebuilds the child entities. Re-assigning the same file keeps what you arranged: a static model whose parts you have rearranged in Structure keeps those parts and refreshes them in place, an animated model is rebuilt and your moved parts are put back by node name, and entities attached to bones or parts are kept in both cases. See 3D Graphics — Reloading a rearranged model.

Instanced Mesh¶

Instanced Mesh draws many copies of the same entity's mesh geometry with per-instance transforms. Add it from Add Component, then populate the instance list in Properties or from script via Mesh::createInstancedMesh / addInstance.

Instancing only uses geometry on the entity that owns the component. If a Model still stores its meshes as child entities (the default multi-node or animated GLTF layout), the editor shows a warning and writes to the Output panel: instances will not render until you merge the static model.

A clone mark next to the entity in Structure indicates the instance count. See Rendering Pipeline — GPU instancing.

Mesh materials and IBL¶

The Mesh component exposes rendering flags beyond per-submesh material slots:

Each Submesh section contains a Material row with a shaded preview sphere. The preview reflects the current Receive IBL setting so you can see environment reflections before entering play mode.

On a mesh that came from a model file, every field you change in the Submesh section is kept as an override on the model and re-applied whenever the file reloads, while the fields you leave alone keep following the file. See 3D Graphics — Editing an imported model's submeshes.

Expand the Material row to edit Alpha Mode and Alpha Cutoff alongside the base colour, textures, metallic, and roughness controls:

Alpha Cutoff ranges from 0 to 1, defaults to 0.5, and only affects Mask. Masked cutouts use the same threshold in the visible surface, shadows, depth, and SSR G-buffer.

Leaf Transmission (0–1, default 0) lets light through a thin surface when it is lit from behind — backlit foliage. Leave it at 0 on bark, trunks, and solid geometry. Like the other material fields it is stored as an override on imported models; a glTF can also carry it as the material extra doriax_foliage_transmission. See 3D Graphics — PBR materials.

For explicit Opaque, Mask, and Blend modes, the engine derives Texture Shadow from the alpha mode: it is enabled for Mask and disabled for the other two. The separate Texture Shadow checkbox remains meaningful in Auto mode for legacy materials and sprites.

Linking material files¶

The Material row supports three workflows:

1. Edit inline — expand the material section and change factors and textures directly in the scene (values stored on the mesh component).
2. Link to a file — drag a .material file from the Resources Browser onto the Material row or preview; the mesh submesh links to that file and reloads when it changes on disk.
3. Create a shared file — drag the material preview from Properties into the Resources Browser; the editor writes a new .material file and links the submesh to it automatically.

When linked, the material name shows the file name and an unlink button (broken chain icon) appears. Unlinking keeps the current values on the mesh but stops syncing with the file.

You can also drop a single image onto the Material row to assign only the base colour texture without replacing the rest of the material.

Custom shaders¶

Mesh, UI, Points, Lines, Sky, and Water components expose a Shader row. By default it shows Built-in; Fork opens a dialog to choose where the fork is created and what it is called, then writes it and opens the GLSL in the Code Editor. The remaining buttons pick the .vert/.frag files, reopen the assigned shader, and reset to the engine default. You can also drag an existing .vert/.frag from the Resources Browser onto the row.

A Mesh has a second Depth Shader row with the same controls. It forks the shader behind the mesh's shadow maps and depth pre-pass, for colour forks that move vertices or discard fragments, so the shadow follows — see Custom Shaders — The Depth Shader row. A Water has an Underwater Shader row instead, for the fade seen from below the surface — see Custom Shaders — Water shaders.

A fork that declares a u_vs_customParams or u_fs_customParams block gets one editable row per member below the Shader row, under a line named after the fork (time and resolution come first, written by the engine); the values are saved on the component, shared with the depth fork, and also scriptable through setShaderUniform — see Custom Shaders — Shader uniforms.

A scene can also define a default custom shader per type (in the scene settings' Default Shaders section). Components with no shader of their own inherit it, and their Shader row shows its name followed by (scene default). A shader assigned on the component always takes priority over the scene default. When the default declares uniforms, the section has rows for them too: those values belong to the scene, and an inheriting component reads them for every member it does not set itself.

The scene settings also have a Post-processing section: an ordered list of fullscreen passes, each one a forked shader under a collapsible header with reorder and remove buttons, and an enable checkbox in its Shader row. Any value the pass declares in its u_fs_postParams block becomes an editable row here.

See Custom Shaders for the full workflow, scene defaults, post-process passes, includes, and project settings.

Sky component¶

The Sky component controls the scene cubemap background and the IBL environment:

Use Default sky to restore the built-in editor cubemap.

Mirror component¶

The Mirror component turns its mesh into a planar reflection surface. Add it to a flat mesh (a Wall works out of the box), or use the Mirror entry in the Structure create menu, which sets up the wall and component together.

The reflection camera is created and managed by the engine — there is nothing else to wire. If the reflection is clipped on the wrong side, flip the sign of Normal. See Rendering Pipeline — Mirrors and planar reflections for how it works and its cost.

Reflection Probe component¶

The Reflection Probe component gives meshes inside its box-shaped influence volume a local reflection environment instead of the global sky — see Rendering Pipeline — Reflection probes for how probes are selected, blended, and captured.

Selecting the probe draws its influence box in the viewport — cyan for static, purple for dynamic — with a gold marker at the capture origin when Box Offset moves the box away from it. The Refresh Probe button forces a re-capture (or re-bake of the authored cubemap) regardless of mode.

Water component¶

The Water component draws an animated water surface at the entity's height. Use the Water entry in the Structure create menu, or add the component to any entity with a Transform. See Rendering Pipeline — Water for how each feature is drawn and what it costs.

Under the Shader and Underwater Shader rows, the fields are grouped into sections:

In the editor the waves and ripples hold still while the scene is stopped or paused, and move during Play. To keep the editor view clear when the camera dips below the surface, turn on Disable underwater in the viewport settings.

A dynamic 3D Physics Body floats on the water once its Buoyancy is above 0, unless the water's own Buoyancy is off.

Water Exclusion component¶

The Water Exclusion component keeps water out of a volume: the water surface is not drawn inside it, a camera inside sees no underwater fade, and the dynamic bodies inside get no buoyancy. Add it to a boat to keep the waves out of it, or create a Water Exclusion entity from the Structure create menu for a volume of its own. See WaterExclusion.

While selected, the volume is drawn as an orange wireframe. A Hull on an entity without meshes shows No mesh on this entity to wrap.

Scene settings¶

With no entity selected, Properties edits the scene. Lighting, shadows, SSAO, SSR, fixed resolution, default shaders, and post-processing live here — see Rendering Pipeline for those.

Two scene-wide performance switches sit with the lighting block:

Each mesh can still opt out with Detail Levels on the Mesh component.

Scripts¶

Two buttons at the top of the Properties window create scripts:

• New Script — opens a dialog that generates the script files (Lua module, or C++ header + source), adds a ScriptComponent if the entity lacks one, and links an enabled entry to the new files — all in one undoable step. Its Attach existing option links script files that already exist instead, without changing them.
• New component → Script, then Add Script inside the component — adds an empty script entry without creating files. Use the entry's pencil button to set the class name and link existing header/source (or .lua) files.

Each script entry shows an enable checkbox, buttons to open its files in the Code Editor, and a right-click menu to reorder or remove it.

Script properties¶

When a script is linked, the Properties window shows every property declared with the DPROPERTY macro (C++) or in the properties table (Lua). These fields are serialized with the scene and injected into the script instance at play and export time.

See Creating Scripts for the full workflow and Script Properties for declaring and typing custom script properties.

Entity references¶

Some fields take another entity as their value. For example, a physics joint links two Body entities, an action animates a target entity, and script properties of pointer types show an entity picker. Drag the target entity from the Structure panel into the field, or use the picker icon.

Which scene the entity can come from depends on the field:

An entity from a child scene dropped on a component field is refused with the tooltip Entity belongs to another scene. A joint can therefore never connect bodies in two scenes, since each scene runs its own physics world.

A script property that points into another scene is resolved when the script starts. That scene must already be built at that point, for example as a child scene of the same stack. If it isn't, the property is nil in Lua, and nullptr in C++ with an error in the log.

Transform gizmo¶

Selecting a transform field highlights the corresponding gizmo in the Scene view. You can edit numeric values in the Properties window and see the result in the viewport at the same time, or manipulate the gizmo and watch the numbers update live.

Undo / redo¶

Every property edit is recorded in the command history. Use Ctrl+Z / Ctrl+Y to step back and forward through changes made in the Properties window or in the viewport.

Best practices¶

• Prefer editor-exposed DPROPERTY fields for any value a designer should tune, rather than hard-coding it in script logic.
• Keep generated or runtime-only data out of serialized component fields.
• After changing physics, script, or animation fields, test in play mode immediately because those affect runtime behavior, not just visual appearance.
• Use bundles for repeated configured entity hierarchies so the same property values do not have to be re-entered manually in many scenes. For entities inside a bundle instance, the component header's right-click menu offers Make Unique (override this instance) and Revert to Bundle (re-link to the shared values).