faceQuad(b: ?, p1: ?, p2: ?, p3: ?, p4: ?, col: ?) → void

faceTri(b: ?, p1: ?, p2: ?, p3: ?, col: ?) → void

hoop(b: ?, cx: ?, cy: ?, cz: ?, r: ?, thick: ?, h: ?, seg: ?, col: ?) → void

A hoop: a ring of short boxes around a circle. `Builder:cylinder` builds a CAPPED solid, so anything that should read as a ring — a corona, a cornice band, a drum — is built from segments instead.

hipRoof(b: ?, cx: ?, y0: ?, cz: ?, w: ?, d: ?, h: ?, ov: ?, ridge: ?, col: ?) → void

hipped roof: rectangular eave at y0, ridge along X at y0+h

edges(lo: ?, hi: ?, openings: ?, a: ?, b2: ?) → void

sorted, de-duplicated cut lines for one axis of a punched panel

punchedPanel(u0: ?, u1: ?, v0: ?, v1: ?, openings: ?, emit: ?) → void

A rectangular panel spanning u0..u1 by v0..v1 with rectangular holes cut out of it. The panel is diced on every opening edge and the solid cells are merged back into horizontal runs, so arbitrary openings — including ones stacked in the same column — come out correct with few boxes. `emit` takes the bounds of one solid run.

wallAlongX(b: ?, zc: ?, t: ?, x0: ?, x1: ?, y0: ?, y1: ?, openings: ?, col: ?) → void

A wall panel standing in the XY plane, centred on z = zc with thickness t. Openings are { x0, x1, y0, y1 }. The surrounding boxes' own faces line each hole, so every aperture gets its reveals.

wallAlongZ(b: ?, xc: ?, t: ?, z0: ?, z1: ?, y0: ?, y1: ?, openings: ?, col: ?) → void

The same panel standing in the ZY plane, centred on x = xc. Openings are { z0, z1, y0, y1 }.

lineAlongX(b: ?, zc: ?, x0: ?, x1: ?, y0: ?, y1: ?, openings: ?, col: ?) → void

Plaster skins on the room side of the masonry, carrying the same openings so the apertures stay clear.

lineAlongZ(b: ?, xc: ?, z0: ?, z1: ?, y0: ?, y1: ?, openings: ?, col: ?) → void

corinthianCap(b: ?, x: ?, y: ?, z: ?, r: ?, col: ?) → void

A Corinthian capital: bell, two tiers of acanthus, corner volutes, abacus.

columnAt(b: ?, x: ?, z: ?, y0: ?, h: ?, r: ?, col: ?) → void

A fluted column with an attic base and a Corinthian capital. `h` is the full height from the plinth top to the top of the abacus.

pilasterZ(b: ?, x: ?, zc: ?, y0: ?, h: ?, w: ?, face: ?, col: ?) → void

A flat engaged pilaster of the same order, standing against a z-facing wall.

pilasterX(b: ?, z: ?, xc: ?, y0: ?, h: ?, w: ?, face: ?, col: ?) → void

The same pilaster against an x-facing wall.

entablatureX(b: ?, x0: ?, x1: ?, y: ?, zc: ?, d: ?, col: ?) → void

A full entablature run — architrave, frieze, dentils, modillions, cornice.

entablatureZ(b: ?, z0: ?, z1: ?, y: ?, xc: ?, d: ?, col: ?) → void

rusticateX(b: ?, x0: ?, x1: ?, y0: ?, y1: ?, zc: ?, face: ?, openings: ?, col: ?) → void

Rusticated ashlar: banded courses with recessed joints, on a z-facing wall.

balustrade(b: ?, x0: ?, x1: ?, y0: ?, z: ?, col: ?, alongZ: ?) → void

put(o: ?, yy: ?, sy: ?, wide: ?) → void

urn(b: ?, x: ?, z: ?, y0: ?, s: ?, col: ?) → void

statue(b: ?, x: ?, z: ?, y0: ?, s: ?, yaw: ?, col: ?) → void

A roofline figure: a robed statue, readable in silhouette against the sky.

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?) → void

sashZ(bs: ?, x: ?, y: ?, zc: ?, t: ?, w: ?, h: ?, face: ?, crown: ?) → void

A glazed sash sitting in an aperture on a z-facing wall: glass leaf, marble architrave, glazing bars, sill, and an oak lining inside. `face` is +1 when the outside lies toward +z, -1 when it lies toward -z.

sashX(bs: ?, z: ?, y: ?, xc: ?, t: ?, w: ?, h: ?, face: ?) → void

The same sash in an aperture on an x-facing wall.

palladianZ(bs: ?, x: ?, y0: ?, zc: ?, t: ?, w: ?, h: ?, face: ?) → void

A Venetian (Palladian) window: arched centre light between two square heads.

chequerFloor(b: ?, x0: ?, x1: ?, z0: ?, z1: ?, y: ?, cell: ?, ca: ?, cb: ?) → void

chequered stone floor over a rectangle

parquet(b: ?, x0: ?, x1: ?, z0: ?, z1: ?, y: ?, col: ?) → void

herringbone parquet, laid in blocks so the grain alternates

dadoX(b: ?, x0: ?, x1: ?, z: ?, y: ?, face: ?, h: ?) → void

panelled dado with a moulded rail, run along x

dadoZ(b: ?, z0: ?, z1: ?, x: ?, y: ?, face: ?, h: ?) → void

cornice(b: ?, x0: ?, x1: ?, z0: ?, z1: ?, y: ?, col: ?, big: ?) → void

a moulded cornice run around the top of a rectangular room

run(cx: ?, cy: ?, cz: ?, sx: ?, sy: ?, sz: ?) → void

coffers(b: ?, x0: ?, x1: ?, z0: ?, z1: ?, y: ?, col: ?, cell: ?) → void

a coffered ceiling panel grid

paintingZ(bs: ?, x: ?, y: ?, z: ?, w: ?, h: ?, face: ?, canvas: ?) → void

framed painting hung flat on a z-facing wall

paintingX(bs: ?, z: ?, y: ?, x: ?, w: ?, h: ?, face: ?, canvas: ?) → void

mirrorZ(bs: ?, x: ?, y: ?, z: ?, w: ?, h: ?, face: ?) → void

a tall pier glass in a carved gilt frame

nicheZ(bs: ?, x: ?, y0: ?, z: ?, w: ?, h: ?, face: ?) → void

an arched niche with a figure in it, on a z-facing wall

rug(b: ?, cx: ?, cz: ?, w: ?, d: ?, y: ?, field: ?, border: ?) → void

carpet with a border and a centre medallion

turnedLeg(b: ?, x: ?, y0: ?, z: ?, h: ?, r: ?, col: ?) → void

a turned leg: stacked discs of varying radius, so it reads as lathe-work

cabrioleLeg(b: ?, x: ?, y0: ?, z: ?, h: ?, r: ?, col: ?, ox: ?, oz: ?) → void

sofa(b: ?, cx: ?, cz: ?, w: ?, yaw: ?, cloth: ?, frame: ?) → void

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?) → void

leg(ox: ?, oz: ?) → void

armchair(b: ?, cx: ?, cz: ?, yaw: ?, cloth: ?, frame: ?) → void

table4(b: ?, cx: ?, cy: ?, cz: ?, w: ?, d: ?, h: ?, col: ?, turned: ?) → void

chair(b: ?, cx: ?, cz: ?, yaw: ?, cloth: ?, frame: ?) → void

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?) → void

fireplaceZ(bs: ?, x: ?, z: ?, y: ?, face: ?) → void

bookcaseX(bs: ?, z: ?, y: ?, x: ?, w: ?, h: ?, face: ?) → void

bookcaseZ(bs: ?, x: ?, y: ?, z: ?, w: ?, h: ?, face: ?) → void

candelabrum(bs: ?, x: ?, y: ?, z: ?, s: ?, arms: ?) → void

a branched candelabrum standing on a surface

chandelierAt(bs: ?, x: ?, yTop: ?, z: ?, drop: ?, r: ?, arms: ?) → void

a hanging chandelier of gilt arms and glass drops

longcaseClock(bs: ?, x: ?, z: ?, y: ?, yaw: ?) → void

a longcase clock

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?, bb: ?) → void

grandPiano(bs: ?, cx: ?, cz: ?, yaw: ?) → void

a grand piano, lid raised

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?, tb: ?) → void

harp(bs: ?, cx: ?, cz: ?, yaw: ?) → void

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?, tb: ?) → void

bust(bs: ?, x: ?, z: ?, y: ?, s: ?) → void

a marble bust on a pedestal

commode(bs: ?, cx: ?, cz: ?, w: ?, yaw: ?, face: ?) → void

a sideboard / commode with drawers and gilt mounts

put(ox: ?, oy: ?, oz: ?, sx: ?, sy: ?, sz: ?, col: ?, tb: ?) → void

drapesZ(bs: ?, x: ?, y: ?, z: ?, w: ?, h: ?, cloth: ?) → void

floor-length drapes with a swagged pelmet, framing an aperture

pottedTree(bs: ?, x: ?, z: ?, y: ?, s: ?) → void

a potted palm / orange tree in a gilt tub

boingBall(b: ?, cx: ?, cy: ?, cz: ?, r: ?, lat: ?, lon: ?) → void

Amiga ball: meridians and parallels chequered red and white

P(th: ?, ph: ?) → void

ballMesh( ) → void

the ball rides its own entity so the part can spin it

doorLeafMesh(w: ?, mirror: ?) → void

One door leaf, hinged on the mesh origin. The leaf reaches along +x, or along -x when `mirror` is set, so the pair meets on the centreline.

shell(bs: ?) → void

pavilions(bs: ?) → void

The colonnaded links and the end pavilions.

hall(bs: ?) → void

The entrance hall: floor, order, gallery, dome soffit and dressing.

v(a: ?, r: ?, y: ?) → void

The soffit is the INSIDE of a dome, so its normals point back at the centre of curvature. Deriving them from winding gives the outward face and the hall reads unlit, so they are explicit.

staircase(bs: ?) → void

railRun(x: ?, y0: ?, z0: ?, y1: ?, z1: ?, col: ?) → void

roomShell(bs: ?, x0: ?, x1: ?, z0: ?, z1: ?, y: ?, ceil: ?, wallCol: ?, floorKind: ?) → void

drawingRoom(bs: ?) → void

musicRoom(bs: ?) → void

library(bs: ?) → void

diningRoom(bs: ?) → void

pavilionRooms(bs: ?) → void

The west pavilion: a ballroom. The east: an orangery.

lightPlan( ) → void

Each is { x, y, z, radius, intensity, { r, g, b }, castsShadows } in MESH-LOCAL space; the estate transforms them onto the world.

add(x: ?, y: ?, z: ?, r: ?, i: ?, c: ?, sh: ?) → void

build(bs: ?) → void

Fills the shared builders with the whole house. Returns the local-space anchors the estate needs to place the animated pieces and the lights.