Object Editor

The Object Editor is the harness’s 3D geometry editor: it lets you edit a table’s playfield directly in the rendered scene rather than by hand-editing .cade source. You pick meshes in the 3D view to place, move, rotate, tune, and rename the scoring devices (bumpers, slingshots, targets, drops, lanes, lamps, spotlights, spinners, one-way gates), draw the walls that shape the playfield, and lay the tracks the ball rides. Every edit rebuilds the live table, so what you change becomes real physics and scoring immediately.

Unlike the rules, lightshow, and sound editors, this is not a node editor — it works on the 3D scene, not a node graph. It shares only the common toolbar and context-menu chrome with them.

Opening the editor

Press E — or click Object editor (E) in the harness actions — to enter. The camera swings to a straight-down top-down view and the Object editor chrome appears; press E again (or Exit edit mode) to leave and restore your previous camera.

The chrome sits in two docks, tools on the left and detail on the right. The Tools rail is flush to the left edge and runs the full height of the page; the Properties column on the right holds the hint line, the placement card, the inspectors, and the snap controls. The playfield shrinks to sit between them rather than hiding underneath, so nothing you place is behind a panel.

While the editor is open the normal gameplay controls are inert — flippers, plunger, start, and cabinet nudge/tilt do nothing, so arrow-key nudges move the selected device instead of shaking the table. Only E (toggle the editor) and P (performance HUD) stay live.

The panel header’s – button minimizes it to a restore tab when you want the full playfield.

Two things about the table’s own look change while you edit, both to keep the playfield legible. The backglass display steps aside — it is parked over exactly the part of the table you are working on — and it comes back live, not frozen, when you leave. And cast shadows are held off, because a device’s own shadow reads as a second offset copy of it. Shadows are the thing you want back once a model is placed, so ⚙ Menu ▸ Preferences ▸ Playfield shadows turns them on again without leaving the editor. The same submenu has Show model colliders.

While the editor is open, the bottom tray also lists the gestures and shortcuts that are live — camera gestures on the left, editing commands on the right. They clear when you leave, because none of them do anything during play.

What you can edit

The editor is modeless — there’s no Devices/Walls switch to flip. A single Tools palette holds every placement tool, and clicking any object in the scene selects it whatever its kind:

• Scoring devices — bumpers, slingshots, targets, drops, lanes, lamps, and one-way gates. Each device’s name is its switch ID, so renaming a device renames the switch the engine scores on.
• Flippers — movable and tunable (see the inspector), though you don’t place them from the palette.
• Walls — the static geometry that bounds and guides the ball: straight Segment walls, Spline walls (Bézier anchors), and Polygon footprints (convex or concave).
• Tracks — the elevated geometry the ball rides: ramps, wireforms, habitrails, and guides. See Tracks below.

Selecting and moving objects

One selection spans every kind. Devices, walls, and tracks all live in it at once, so a marquee that sweeps a bumper, a wall, and a ramp holds all three, and the next gesture acts on all three.

• Click an object to select it; Shift-click to add or remove one; drag a box over empty playfield to marquee-select — the box catches every element kind under it, not just devices.
• Ctrl/Cmd+A selects every unlocked element on the table.
• Drag the selection to move it — a whole group moves together, whatever it is made of, and the translucent floor discs preview the entire pending move rather than just the piece you grabbed.
• Arrow keys nudge the selection (hold Shift for a coarser step).
• Shift-scroll over a selected rotatable device spins it about its own center. Hold Alt as well and the whole selection orbits rigidly about its shared pivot — which is the only way walls and tracks turn, since neither has a rotation of its own.
• The on-canvas move / rotate gizmos work on the floor plane; in track mode the gizmo’s vertical axis comes alive too, so a node can be raised directly.
• Snap to grid in the panel constrains placement to a grid whose step you set (in table units — 1 unit = 5 cm).

Right-click offers Align (edges or centers) and Distribute, and both work across a mixed selection.

Only the ball release is inspect-and-rename only; it can’t be moved or placed.

When the selection spans kinds

A selection holding more than one kind swaps the per-kind inspector for a small shared block: what you have selected, written the way the clipboard writes it (3 devices + 1 wall), and a Layer dropdown that moves every selected element onto one layer in a single undoable step. Position, rotation, and name aren’t there, because they have no single value to show for a group — move a mixed selection with the arrow keys or a drag instead.

Camera navigation

The 3D view has its own camera gestures, independent of selection:

• Scroll to zoom about the cursor.
• Middle-drag or hold Space + drag to pan.
• Alt-drag, Shift+Space+drag, or a drag on the orientation compass to orbit. The compass is the discoverable one: it is always on screen and needs no modifier chord.
• F to frame — zoom-to-fit the current selection, or the whole table when nothing is selected. Framing keeps the angle you are looking from.

The editor opens looking straight down, but it is not locked there — you can orbit while editing devices, walls, and tracks alike. Because screen-up stops being up-table the moment you do, the compass rose reads out which way you are facing.

Named angles sit on the numpad, the layout every 3D tool shares:

A named angle changes only where you look from: it never re-frames or re-zooms what you were working on.

The inspector

Selecting one object fills the inspector with its editable detail. For a device that’s the head glyph and kind, then rows for Name (switch ID), position (x, z), and — depending on the device — rotation°, radius, length, width, and, for lamps, light type (GI or RGB), a rest color (RGB lamps), and a rest brightness — how brightly the lamp glows when nothing is driving it, 0–1. A GI insert defaults to full, so placing one lights the playfield around it with no rule or show behind it; an RGB lamp idles dim, waiting for a lightshow or scoring rule to drive it, and setting the rest to 0 keeps a lamp dark until driven. A one-way gate adds a hidden in play checkbox — the gate’s panel disappears during gameplay while still blocking the ball (it stays visible, ghosted, in the editor). A Layer dropdown assigns the device to a layer, and any grouping Tags from the .cade device block are shown read-only.

Two device kinds add a block of feel controls:

• Slingshot — a Slingshot sub-block with sliders (each paired with a number field) for strength, back depth, height, and bounce, alongside the shared length and rotation°.
• Flipper — strength (0–100, scales launch power) and sweep° (the up-stroke arc), plus length and rotation°. Selecting several flippers at once fans an edit out across all of them.

Type a new value and it applies on change; Apply rename commits a name change, and Revert discards uncommitted edits. A Wall selection shows the matching wall fields — name, endpoints, Thickness, Height, and Samples/seg for curved walls — while its shape is edited by dragging handles in the scene. A status line below the inspector reports whether each edit validated.

Every number box in the inspector is also a slider in disguise: press it and drag up or down to walk the value, hold Shift while you drag for a ten-times coarser step, and press Escape mid-drag to abandon the change. A whole drag lands as one edit and one undo step. A plain click still puts the caret in the field, so you can always type a value instead. The same gesture works on the node editors’ number fields, so the sensitivity you learn in one is the sensitivity you get in the other.

Reshaping a wall

Drag a spline anchor or a polygon vertex to reshape the wall. Two more gestures live on the shape itself:

• Point anywhere along the wall and press I to insert a new anchor or vertex right where you are pointing, or right-click the spot and pick Insert anchor / Insert vertex from the menu.
• Right-click an anchor to smooth or sharpen it, and double-click its ◇ handle for the modes that apply to it.

A wall’s status line spells out whichever of these are available while it is selected, so you do not have to remember which shape offers what.

Placing devices and drawing walls

The Tools rail on the left edge is a grid of square tiles, glyph over label, plus Wall ▾ and Track ▾ tiles. The first ten tiles carry a digit badge in the corner, and most also carry a letter mnemonic; press either, or click the tile, to arm the tool. Right-click or Esc cancels the armed tool.

Placing is one gesture: press the playfield to anchor the device, hold and drag to aim it if that kind has a facing, and release to commit. A callout follows the cursor and says which part of the gesture you are in, so the instruction is next to the ghost rather than across the page in a status line. You can also Shift+scroll while merely hovering to pre-aim before you press.

The mnemonics can safely reuse letters the game binds (S starts a game, T nudges) because gameplay keys are inert while the editor is open. Spotlight is the one tile with no letter — every plausible one is already taken — so arm it from its digit or by clicking it.

The One-way gate passes a ball along one direction and blocks it from the other — a placeable replacement for the old fixed shooter-lane gate. The Trough is the volume that swallows a ball and ends its life; placing one is what clears a “needs placement” drain warning (a plain Switch named drain looks similar but makes one physical drain report twice). A Spinner scores once per revolution, so a single fast shot through one can award many times.

The tools with no score — lamp, spotlight, one-way gate, and trough — are that way by design: a light is output-only, a one-way gate is passive geometry, and a trough’s switch drives the ball lifecycle rather than an award.

Names the editor mints

Placing a device names it <kind>_NNN — bumper_001, one_way_gate_001 — in the same lowercase, underscore-separated style the table’s built-in devices use. That name is the switch ID the engine scores on, so the spelling matters: the editor declares the device to the running engine the moment you commit it and synthesizes a scoring rule from the name it just minted, which is why a bumper you drop scores 500 the first time a ball hits it, with no rule-writing at all and nothing reserved in advance.

A tile’s label is cosmetic and separate from the name it mints, so the palette can be re-worded without silently renaming devices.

Clicking the Wall ▾ tile a second time opens a drill-down with Segment (drag to draw), Spline, and Polygon (click to drop anchors or vertices, then Enter or right-click to finish). Selected walls can be combined with Merge (union) of two or more (Ctrl/Cmd+J), or Subtract (A − B) of exactly two (Ctrl/Cmd+Shift+J), from the context menu or the keyboard.

The Track ▾ tile works the same way and is covered in Tracks: ramps, wireforms, and habitrails below — it draws elevated 3D track rather than flat playfield geometry, so it has a gesture and a camera of its own.

Right-clicking the playfield opens a context menu for the rest — add a device, paste, duplicate, copy/cut, delete, align (edges or centers), distribute, and move to layer.

Binding an asset to a device

Right-clicking a device offers a single Bind asset… entry, which opens the asset browser over both inventories at once — media you’ve uploaded (models, images, audio, video) and what the live table already has (synth patches, clips, lightshows, triggers). Pick a row and the editor binds it the way that kind of asset is meant to be bound; you don’t have to know which of those two worlds the thing came from.

Models can arrive here straight from Blender: the Blender Bridge extension uploads your selection to the catalog as a GLB, ready to bind. See Sending a Model for that flow end to end.

Jumping to another editor

Right-clicking a single device offers Open in editor with an entry for each editor the device is wired into — Rules editor, Light editor, and Sound editor — each as a Same tab / New tab choice. Opening one deep-links into that editor focused on the device, so you can jump from a bumper in 3D straight to its scoring rules, lamp, or sound without hunting for it.

Tracks: ramps, wireforms, and habitrails

A track is elevated 3D geometry the ball actually rides — a ramp up off the playfield, a wireform that carries it across the table, a habitrail that returns it to the flippers. It is real physics, not a scripted ride: the ball is held by the track’s cross-section (a ramp’s floor and side rails, a habitrail’s enclosing tube), so it can be shot too slowly and roll back down, or too fast and climb a rail.

Tracks are their own kind of object — not a wall and not a device — and they live in the same name space, so a track’s name has to be unique across the table.

Drawing a track

Click the Track ▾ tile to arm it; click it again for the four shapes:

Click the playfield to plant the track. It starts flush with the felt so a ball rolling along the playfield can get onto it — a raised end is a lip the ball bounces off rather than a ramp it climbs.

From there the track grows one segment at a time, the way a coaster editor builds track: the end you are growing from is the active end, a translucent ghost previews the next segment, and you commit it before drawing the next.

Each committed segment is one undo, so Ctrl-Z walks back down the track a segment at a time rather than discarding the whole run.

The ghost turns amber when the segment cannot be built. That happens when a turn is tighter than the track is wide — a swept shape cannot round a corner tighter than its own half-width, exactly as a router bit cannot cut an inside corner tighter than its radius. Widen the turn, or lengthen the segment, and it goes back to blue.

Drawing at height

Track mode gets an angle and a drawing plane of its own, because a top-down view cannot show height:

• Entering track mode tilts the camera to about 45° by itself, so the gizmo’s vertical arrow has real length on screen to grab. Orbit further from there with any of the camera gestures — and leaving track mode keeps whatever angle you orbited to rather than snapping you back.
• PageUp / PageDown raise and lower the construction plane — the height new segments are drawn at, shown as a faint lattice once it is off the playfield.
• The plane follows the active end, so extending an existing track always starts at the height that track has already reached.

Tracks fit under the glass, so there is a ceiling: how high depends on the shape, since a habitrail’s roof stands higher above the ball than an open ramp’s floor does. The editor refuses a node above it and says so.

Snapping, joining, and closing a circuit

Three detents keep drawn track tidy, under All settings… in the ⚙ menu alongside grid and rotation snapping:

• Snap track angles — quantizes an aimed turn and pitch (15° by default).
• Snap track height — the construction plane’s step (0.25).
• Snap track length — the aimed segment length (0.5).

They apply to pointer aiming only; the arrow-key steps are already exact. Hold Ctrl to suspend them for one adjustment.

Bring a draft’s endpoint near a free end — either end of any open track — and it snaps onto it, marking that end. Clicking then does one of two things instead of adding a segment:

• The same track’s other end — closes it into a circuit, a continuous loop with no ends.
• A different track — joins the two into one, keeping the name and cross-section of the track you were drawing and absorbing the other.

Either way it is a single undo. Any sensors on either track keep their real positions on the finished track — a join does not slide them along it.

Hold Ctrl to ignore a nearby end and keep drawing past it.

Editing a track’s shape

Selecting a track shows a handle on every node. Click one to select it, then move it with the gizmo — in track mode the gizmo’s Y axis is live, so a node can be raised and lowered directly. With a node selected, [ and ] bank it, the same keys the drawing gesture uses.

A node can also carry an explicit tangent, which overrides the smooth curve the editor otherwise fits through it; nodes that have one show a second handle.

A track does not only grow from its ends. Point anywhere on the ribbon and press I, or right-click the spot and pick ＋ Insert node here, and a new node lands right there, sitting on the curve you already drew rather than reshaping it. Double-clicking a node’s ◇ handle opens the same action on its glyph ring, splitting the span just after that node. Either way the selection lands on the node you just added, so the next gesture — moving it, banking it — acts on it immediately.

The editor refuses an insert, and says why, rather than building bad geometry:

Drawing does not have to happen in one sitting, either. Select a track you have already drawn and press Enter to pick up drafting from its tail again, exactly as if you had never stopped. Tab flips which end you are extending from — the head instead of the tail — and both are on the track’s right-click menu, which names the end it would extend from. A closed circuit has no free end to grow from, and Enter says so rather than doing nothing.

Shaping one part of a selection

Some detail belongs to a part of what you have selected — a single track node, a single wall anchor — rather than to the whole thing. For those, pick the part and then a mode, and the keyboard drives that one value until you leave.

Inside a mode, [ and ] step the value, 0 resets it, and Esc leaves. Shift halves the step for a fine adjustment. Flare, taper and reach can also be dragged directly. The current value shows as a chip at the handle you are shaping, so you are reading it where you are looking rather than across the page.

The modes available for what you have selected are listed in the Properties column. One that does not apply to this selection stays visible but disabled, with the reason — a mode that vanished would be indistinguishable from one that never existed.

Nothing else stops working while a mode is active: the tool digits and letters still arm their tools, and arming one leaves the mode, because you have plainly moved on to something else.

The track inspector

Selecting a track fills the inspector with its shape and the fields that shape actually uses — a wireform has a rail radius and no floor, a habitrail adds a roof, so the rows change with the kind rather than offering fields the geometry ignores. Width, rail height and thickness, floor thickness, Samples/seg (how finely the curve is divided), and friction / restitution are all editable, as is Closed for a circuit.

Sensors are how a track scores. Add one by name at a position along the track (0 is the entry, 1 the exit), and it behaves like any other switch: the name is the switch ID, so a scoring rule written for that name fires when the ball passes it. A sensor name has to be unique across the whole table, the same as a device’s.

The Browser: outliner, tags, rules, and layers

A right-rail Browser island (with its own – minimize button) collects the list panels that track your table:

• Devices (outliner) — a searchable list of every device; click a row to select and reveal it in the scene.
• Tag groups — one chip per device tag; click a chip to select and highlight every device carrying that tag, click it again to clear.
• Rules involving selection — the autofire and scoring rules that touch the current selection, so you can see what a device (or a whole tag group) actually drives without leaving the editor.
• Layers — organize devices into named layers you can add, rename, and delete. Each layer has a visibility toggle and a lock toggle — devices on a locked layer are fully non-interactive, so you can freeze part of the table while you work on the rest. Assign a device to a layer from its inspector or the right-click move to layer menu.

Diagnostics

Problems with the current table surface in the global bottom bar, not the editor panel — so they stay visible even with the editor closed. A Diagnostics chip reads the outstanding count (and · Needs placement when devices still need a home); clicking it expands a dock listing each issue. Layout-validation problems and lightshow lamp mappings that point at a device that no longer exists both show up here, and any row with a device target is click-to-select, so a warning takes you straight to the object that caused it.

Undo, saving, and autosave

Every edit is undoable: Ctrl-Z undoes and Ctrl-Shift-Z / Ctrl-Y redoes, back to the start of the session. The toolbar shows a ● unsaved badge whenever there are uncommitted edits. Delete or Backspace removes the selection; with a track node picked, Shift+Delete trims just that node instead of the whole track.

To keep your work, from the ⚙ Menu:

• Save (also Ctrl/Cmd+S) downloads the table as a portable .showcade.json (devices, walls, tracks, and layers) and clears the unsaved badge; Open loads one back through the same validation.
• Export table + rules… writes your placed devices back into the running engine’s .cade source, then downloads a matching pair — the .showcade.json geometry and a .cade file of the rules, each naming the other. It needs the live engine, which is why the plain Save stays geometry-only.
• Session ▸ Restore last session brings back the autosave the browser keeps while you have unsaved edits — a banner offers it on the next load too. Session ▸ Reset to default throws away both the saved geometry and any saved .cade draft.

The same menu carries Table (the table library — new, open, rename, duplicate, delete), Asset catalog…, and Share ▸ Share this table… / Browse public tables….

Rebinding the keys

Every shortcut on this page can be changed. The editor’s own commands live under Object editor in the settings modal, in three groups:

• Tile shortcuts — the letter mnemonic on each Tools tile, and the digit row as an ordered row: the first key you bind arms the first tile, the second the second, and so on. Because the row is positional, it works on layouts (French AZERTY, for one) where the digits need Shift, and the numpad digits work too.
• The Ctrl/Cmd commands — select all, copy, cut, paste, duplicate, and the two wall booleans.
• The bare-key commands and the camera keys — frame, delete, the component modes, the named views, and the view nudges.

Click a key chip to replace it, ＋ to add a second binding, ✕ to remove one. A tile mnemonic has to be a single letter, and the editor says so rather than storing a binding that could never fire. Binding two commands to one key is allowed but flagged: the widget tells you which one actually runs.

Gameplay keys are in a separate group and are covered on Playing the Table; the node editors’ shortcuts are a third group, on Node Editor Basics.

Live edits and the engine

The Object Editor edits the live table: each change rebuilds the table through the same path the .cade loader uses, so a moved bumper collides and scores, a renamed device reports under its new switch ID, and a new lamp lights immediately. A device you place is declared to the engine the moment you commit it, not when you export, which is why it scores on the very next ball. Edits also persist across a reload and sync live between open windows — move a device in one tab and the same table’s editor in another tab follows. If the engine later applies a rules change, that clears the editor’s override so the engine’s version wins. In sample mode the editor still runs against the bundled sample table, but engine-only actions like Export table + rules… are unavailable.

The text behind all of this is editable directly, too — see Source.