Volux Docs

Capabilities Reference

The object-kind capability matrix — every flag, every kind's row, and how modules compose the rows they own.

Every Object3D kind — meshes, text, curves, cameras, lights, and the pilot kinds — carries a capability row: a set of boolean flags that gate what the editor offers for objects of that kind. Context-menu entries, panel sections, edit-mode entry, resize handles, physics participation — all of it reads the row instead of a hardcoded type list. Feature modules compose these rows: the base module declares most of them, each pilot owns its own kinds' rows, and flag deltas add or remove individual cells.

This page documents the flags, the full matrix as composed on an all-on build, and the rules of composition.

The flags

There are exactly fifteen capability flags. The columns never change — they come from a compile-time union — so a module's presence or absence can only move the cell values, never add or remove a column:

Prop

Type

The matrix

On an all-on build the composition reproduces Volux's built-in matrix exactly. Kinds are grouped below by identical rows; a dash means the flag is false:

Kind(s)materialtransformdimensionscollisionpresentationcomponenttype marker
box, sphere, cylinder, cone, torus, torusKnot, capsule, plane, circle, ring, tetrahedron, octahedron, dodecahedron, icosahedronyesyesyesyes*yesyes—
text3dyesyesyesyes*yesyestext3d
curveyesyesyesyes*yesyescurve
textnoyesyesnoyesyestext
particlesnoyesnononoyesparticles
speakernoyesnononoyesspeaker
htmlnoyesnononoyeshtml
modelnoyesnonoyesyes—
forceFieldnoyesnonononoforceField
cameranoyesnonononocamera
lightnoyesnonononolight

* The collision cells are composed: they exist on an all-on build because the physics module contributes flag deltas, not because the base rows carry them. See below.

How the rows compose

No single module owns the whole matrix. Three contribution patterns cooperate:

The base module declares the non-pilot rows. core-builtin — the always-registered base — declares capability rows for every kind the pilots do not own: the 14 mesh primitives, text, text3d, curve, html, model, camera, and light. Where a pilot owns a flag, the base row strips it: core-builtin's declared rows omit collision entirely, because collision belongs to physics.

Pilot modules own their kinds' rows. The speaker pilot declares the speaker row; the particles pilot declares both the particles and forceField rows. Each pilot references the single-homed default so the row exists exactly once in the codebase:

objectKinds: [{ kind: 'speaker', capabilities: OBJECT3D_CAPABILITIES.speaker }]

Flag deltas compose individual cells. A module can contribute contributesCapabilities — per-kind flag overlays merged onto the collected rows ({...row, ...deltas}). The physics pilot owns no kind at all; it owns a flag on other kinds' rows:

const contributesCapabilities = {
  box: { collision: true },
  sphere: { collision: true }
  // …14 primitives + text3d + curve = 16 kinds
};

All-on, this composition reproduces the built-in matrix byte-for-byte. With the physics module absent, exactly those 16 collision cells flip to false — nothing else moves. Composing is also constrained: rows and deltas naming a kind outside the known union are skipped with a dev-visible warning, so the flag set and kind set stay closed.

Absence degrades to "no capabilities"

A kind with no row at all has no capabilities — every predicate answering on the row degrades to false. That is the ratified excluded-kind semantics: when the speaker module is absent (an unlicensed build, a free edition), speaker objects have no row, so no speaker capability is ever offered. The matrix reader describeCapabilities() — and the capabilities.describe query on the command bus — simply emits no row for such kinds, while the flag columns stay complete on every row it does emit.

window.voluxPlugin.describeCapabilities();
// { box: { material: true, transform: true, … }, … }  — no `speaker` key when the module is absent

Read flags through the matrix, not your own table

Capability gating belongs to the composed rows, not to hardcoded type lists in extension code. Query capabilities.describe (or describeCapabilities()) at runtime and your UI stays correct on every edition — including the editions where pilot kinds disappear entirely.

Next

Last updated on

On this page