@el4cteo/rbx-studio-mcp 0.3.0 → 0.3.5

package/plugin/src/Themes/Blueprint.luau

@@ -0,0 +1,213 @@
+--!strict
+--[[
+	Blueprint -- the only preset with no perspective.
+
+	An orthographic cube on a drafting grid, with tick marks on two edges. Every
+	other theme leans on depth to make the cell interesting; this one refuses it
+	on purpose, because a drawing that says "this is a measurement, not a
+	picture" is a genuinely different thing to look at, and it is the one preset
+	that reads as an engineering instrument rather than as an ornament.
+
+	Orthographic here means the projection divide is simply skipped: the cube
+	turns, but a far edge is exactly as long as a near one. That looks wrong for
+	a second and then reads as a plan view, which is the effect.
+
+	It is also the lightest preset -- pale lines on navy, no glow, no bloom. On
+	a bright monitor in a bright room it is the only one of the eight that is
+	comfortable to look at all day.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+local Blueprint = {}
+
+Blueprint.id = "blueprint"
+Blueprint.label = "Blueprint"
+Blueprint.blurb = "Drafting grid"
+
+Blueprint.palette = {
+	background = Color3.fromRGB(12, 22, 42),
+	surface = Color3.fromRGB(18, 32, 58),
+	rule = Color3.fromRGB(126, 196, 240),
+	text = Color3.fromRGB(206, 226, 246),
+	dim = Color3.fromRGB(86, 122, 164),
+	green = Color3.fromRGB(128, 226, 190),
+	red = Color3.fromRGB(248, 138, 138),
+	amber = Color3.fromRGB(244, 202, 130),
+	cyan = Color3.fromRGB(140, 210, 246),
+	violet = Color3.fromRGB(170, 176, 240),
+}
+
+local CUBE = {
+	Vector3.new(-1, -1, -1), Vector3.new(1, -1, -1),
+	Vector3.new(1, 1, -1), Vector3.new(-1, 1, -1),
+	Vector3.new(-1, -1, 1), Vector3.new(1, -1, 1),
+	Vector3.new(1, 1, 1), Vector3.new(-1, 1, 1),
+}
+
+local EDGES = {
+	{ 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 1 },
+	{ 5, 6 }, { 6, 7 }, { 7, 8 }, { 8, 5 },
+	{ 1, 5 }, { 2, 6 }, { 3, 7 }, { 4, 8 },
+}
+
+local edges: { Frame } = {}
+local corners: { Frame } = {}
+local grid: { Frame } = {}
+local ticks: { Frame } = {}
+
+--[[
+	Builds the grid the drawing sits on.
+
+	Drawn once and never touched again -- it does not react to anything, which
+	is the point of graph paper. Kept out of `paint` entirely so the per-frame
+	loop stays proportional to the cube.
+]]
+local function drawGrid(cell: Frame, palette: Theme.Palette, size: number)
+	local spacing = 8
+	local lines: { Frame } = {}
+	for offset = spacing, size - 1, spacing do
+		local vertical = Instance.new("Frame")
+		vertical.BorderSizePixel = 0
+		vertical.BackgroundColor3 = palette.dim
+		vertical.BackgroundTransparency = 0.86
+		vertical.Size = UDim2.new(0, 1, 1, 0)
+		vertical.Position = UDim2.fromOffset(offset, 0)
+		vertical.Parent = cell
+		table.insert(lines, vertical)
+
+		local horizontal = Instance.new("Frame")
+		horizontal.BorderSizePixel = 0
+		horizontal.BackgroundColor3 = palette.dim
+		horizontal.BackgroundTransparency = 0.86
+		horizontal.Size = UDim2.new(1, 0, 0, 1)
+		horizontal.Position = UDim2.fromOffset(0, offset)
+		horizontal.Parent = cell
+		table.insert(lines, horizontal)
+	end
+	return lines
+end
+
+function Blueprint.mount(cell: Frame)
+	local size = cell.AbsoluteSize.X
+	if size < 8 then
+		size = 40
+	end
+	grid = drawGrid(cell, Blueprint.palette, size)
+	ticks = Draw.pool(cell, 8, "Tick", false)
+	edges = Draw.pool(cell, #EDGES, "Edge", false)
+	corners = Draw.pool(cell, #CUBE, "Corner", false)
+end
+
+function Blueprint.unmount()
+	edges = {}
+	corners = {}
+	grid = {}
+	ticks = {}
+end
+
+function Blueprint.paint(ctx: Theme.Context, _delta: number)
+	local radius = ctx.size * 0.2 * ctx.scale
+	-- Slower than Lattice and on two axes rather than three. A plan view that
+	-- tumbles is not a plan view.
+	local angle = Vector3.new(ctx.angle.X * 0.5, ctx.angle.Y * 0.5, 0)
+
+	local projected: { Vector2 } = {}
+	for index, vertex in CUBE do
+		local turned = Draw.rotate(vertex, angle)
+		-- No perspective divide. This is the whole theme.
+		projected[index] = ctx.centre + Vector2.new(turned.X * radius, turned.Y * radius)
+	end
+
+	for index, edge in EDGES do
+		local frame = edges[index]
+		if frame == nil then
+			continue
+		end
+		Draw.edge(
+			frame,
+			projected[edge[1]],
+			projected[edge[2]],
+			1,
+			ctx.tint:Lerp(Color3.new(1, 1, 1), ctx.flare * 0.5),
+			math.clamp(0.55 - ctx.flare * 0.35, 0, 1)
+		)
+	end
+
+	--[[
+		Corners as small open squares rather than filled dots -- a draughtsman's
+		node. Uniform weight, because in an orthographic drawing no corner is
+		nearer than another and shading one would be a lie the rest of the theme
+		is built on refusing.
+	]]
+	for index = 1, #CUBE do
+		local frame = corners[index]
+		if frame == nil then
+			continue
+		end
+		Draw.dot(frame, projected[index], 2, ctx.palette.cyan, 0.35)
+	end
+
+	--[[
+		Dimension ticks along the bottom and left, marching with the rotation.
+
+		They carry no data. They are there because a technical drawing has them,
+		and their slow travel is what gives an idle Blueprint something moving
+		to look at now that nothing is glowing or blooming.
+	]]
+	for index = 1, 8 do
+		local frame = ticks[index]
+		if frame == nil then
+			continue
+		end
+		local along = ((index / 8) + ctx.angle.Y * 0.05) % 1
+		if index <= 4 then
+			local x = along * ctx.size
+			Draw.edge(
+				frame,
+				Vector2.new(x, ctx.size - 4),
+				Vector2.new(x, ctx.size - 1),
+				1,
+				ctx.palette.dim,
+				0.5
+			)
+		else
+			local y = along * ctx.size
+			Draw.edge(frame, Vector2.new(1, y), Vector2.new(4, y), 1, ctx.palette.dim, 0.5)
+		end
+	end
+end
+
+--[[
+	History as a section drawing: hairline columns with a tick at the top of
+	each, so a bar's height is marked as well as drawn.
+]]
+function Blueprint.paintSlot(slot: Theme.Slot, ctx: Theme.Context)
+	local frame = slot.frame
+	local recency = 1 - slot.age
+	local height = math.max(1, math.floor(1 + slot.weight * 21))
+
+	frame.AnchorPoint = Vector2.new(0.5, 1)
+	frame.Size = UDim2.fromOffset(1, height)
+	frame.Position = UDim2.new(frame.Position.X.Scale, frame.Position.X.Offset, 1, 0)
+	frame.BackgroundColor3 = if slot.ok then ctx.palette.cyan else ctx.palette.red
+	frame.BackgroundTransparency = math.clamp(0.6 - recency * 0.5, 0, 1)
+	frame.Rotation = 0
+end
+
+function Blueprint.swatch(frame: Frame, palette: Theme.Palette)
+	drawGrid(frame, palette, 24)
+	local centre = Vector2.new(20, 12)
+	local pool = Draw.pool(frame, #EDGES, "Edge", false)
+	local projected: { Vector2 } = {}
+	for index, vertex in CUBE do
+		local turned = Draw.rotate(vertex, Vector3.new(0.45, 0.6, 0))
+		projected[index] = centre + Vector2.new(turned.X * 6, turned.Y * 6)
+	end
+	for index, edge in EDGES do
+		Draw.edge(pool[index], projected[edge[1]], projected[edge[2]], 1, palette.cyan, 0.4)
+	end
+end
+
+return Blueprint

package/plugin/src/Themes/Draw.luau

@@ -0,0 +1,177 @@
+--!strict
+--[[
+	Drawing primitives shared by the presets.
+
+	Roblox has no line primitive and no point primitive, so both are Frames --
+	a segment is a thin rectangle turned about its midpoint, a point is a small
+	square with a full corner radius. Every preset that draws either would
+	otherwise carry its own copy, and they did not stay identical: the pooling
+	rule (build once in `mount`, never allocate in `paint`) is easy to state and
+	easy to forget, so it lives here where forgetting it is not an option.
+]]
+
+local Draw = {}
+
+--[[
+	Turns a point about all three axes.
+
+	Applied X, then Y, then Z. The order is arbitrary but must not change: the
+	presets were tuned against this one, and swapping it silently re-aims every
+	spin axis in the project.
+]]
+function Draw.rotate(point: Vector3, angle: Vector3): Vector3
+	local sinX, cosX = math.sin(angle.X), math.cos(angle.X)
+	local sinY, cosY = math.sin(angle.Y), math.cos(angle.Y)
+	local sinZ, cosZ = math.sin(angle.Z), math.cos(angle.Z)
+
+	local y1 = point.Y * cosX - point.Z * sinX
+	local z1 = point.Y * sinX + point.Z * cosX
+	local x2 = point.X * cosY + z1 * sinY
+	local z2 = -point.X * sinY + z1 * cosY
+	local x3 = x2 * cosZ - y1 * sinZ
+	local y3 = x2 * sinZ + y1 * cosZ
+
+	return Vector3.new(x3, y3, z2)
+end
+
+--[[
+	A perspective divide. Returns the screen point and the depth it came from,
+	because depth is what makes a wireframe read as solid -- near edges are
+	brighter and thicker because they genuinely are nearer.
+]]
+function Draw.project(
+	turned: Vector3,
+	focal: number,
+	radius: number,
+	centre: Vector2
+): (Vector2, number)
+	local scale = focal / (focal - turned.Z)
+	return centre + Vector2.new(turned.X * scale * radius, turned.Y * scale * radius), turned.Z
+end
+
+--[[
+	One segment as a rectangle turned about its midpoint. `Rotation` pivots a
+	GuiObject around its centre, which is exactly what a segment needs.
+]]
+function Draw.edge(
+	frame: Frame,
+	a: Vector2,
+	b: Vector2,
+	thickness: number,
+	color: Color3,
+	transparency: number
+)
+	local delta = b - a
+	local length = delta.Magnitude
+	if length < 0.5 then
+		frame.Visible = false
+		return
+	end
+	frame.Visible = true
+	frame.Position = UDim2.fromOffset((a.X + b.X) / 2, (a.Y + b.Y) / 2)
+	frame.Size = UDim2.fromOffset(math.ceil(length), thickness)
+	frame.Rotation = math.deg(math.atan2(delta.Y, delta.X))
+	frame.BackgroundColor3 = color
+	frame.BackgroundTransparency = transparency
+end
+
+--[[
+	A point. Square frames with a full corner radius, so `size` is a diameter.
+]]
+function Draw.dot(frame: Frame, at: Vector2, size: number, color: Color3, transparency: number)
+	frame.Visible = true
+	frame.Position = UDim2.fromOffset(at.X, at.Y)
+	frame.Size = UDim2.fromOffset(size, size)
+	frame.BackgroundColor3 = color
+	frame.BackgroundTransparency = transparency
+	frame.Rotation = 0
+end
+
+--[[
+	Builds a pool of centred frames. `round` gives them a full corner radius,
+	which is the difference between a point and a tiny square.
+]]
+function Draw.pool(parent: Instance, count: number, name: string, round: boolean): { Frame }
+	local frames: { Frame } = {}
+	for index = 1, count do
+		local frame = Instance.new("Frame")
+		frame.Name = string.format("%s%02d", name, index)
+		frame.AnchorPoint = Vector2.new(0.5, 0.5)
+		frame.BorderSizePixel = 0
+		frame.Visible = false
+		frame.Parent = parent
+		if round then
+			local corner = Instance.new("UICorner")
+			corner.CornerRadius = UDim.new(1, 0)
+			corner.Parent = frame
+		end
+		frames[index] = frame
+	end
+	return frames
+end
+
+--[[
+	Empties a cell between presets.
+
+	Themes are singletons -- only one is ever mounted -- so `unmount` could just
+	destroy the frames it made. It goes through the cell instead so a preset
+	that returns early on an error still leaves nothing behind for the next one
+	to draw on top of.
+]]
+function Draw.clear(cell: Frame)
+	for _, child in cell:GetChildren() do
+		child:Destroy()
+	end
+end
+
+local function fract(value: number): number
+	return value - math.floor(value)
+end
+
+--[[
+	Deterministic noise for a given index.
+
+	Presets that scatter things -- stars, dust, motes -- must scatter them the
+	same way every frame, and `math.random` in a paint loop would make the scene
+	boil. Seeding per element and reading a fixed sequence gives a stable
+	arrangement that still looks unplanned.
+
+	This was `fract(sin(index * 12.9898 + salt * 78.233) * 43758.5453)`, the
+	usual shader one-liner, and it is wrong for the way it is used here. The
+	salt only shifts the PHASE of a single sequence, so two draws for the same
+	index -- a longitude and a latitude, say -- stay correlated: the points fall
+	near a curve instead of filling the space, and at twenty-odd samples two of
+	them land almost exactly on top of each other. Measured over 26 points, the
+	closest pair sat 0.017 apart on a unit sphere where an even spread gives
+	0.6.
+
+	Hoskins' hash mixes the two inputs through each other instead of adding
+	them, which decorrelates the draws.
+]]
+function Draw.hash(index: number, salt: number): number
+	local x = fract(index * 0.1031)
+	local y = fract(salt * 0.1031)
+	local z = fract(index * 0.0973)
+	local mixed = x * (y + 33.33) + y * (z + 33.33) + z * (x + 33.33)
+	return fract((x + mixed + y + mixed) * (z + mixed))
+end
+
+--[[
+	The `index`-th of `count` points spread evenly over a unit sphere.
+
+	For a starfield, "unplanned" is not the requirement -- "no visible clumps
+	and no visible gaps" is, and no hash gives that. The Fibonacci lattice does:
+	walking the golden angle while stepping evenly down the z axis puts the
+	points at a measured centroid offset of 0.004 from the origin, against 0.23
+	for the hash it replaced, which is the difference between a sky and a smear
+	in one corner.
+]]
+function Draw.sphere(index: number, count: number): Vector3
+	local z = 1 - (2 * index - 1) / count
+	local radius = math.sqrt(math.max(0, 1 - z * z))
+	-- The golden angle. Any other turn per step lines the points up into arms.
+	local turn = (index - 1) * math.pi * (3 - math.sqrt(5))
+	return Vector3.new(radius * math.cos(turn), radius * math.sin(turn), z)
+end
+
+return Draw

package/plugin/src/Themes/Lattice.luau

@@ -0,0 +1,304 @@
+--!strict
+--[[
+	Lattice -- the default.
+
+	A turning wireframe solid with a counter-rotating core, over a bar trace of
+	the last forty calls. This is the console's original look, and it stays the
+	default because it is the most legible of the eight: hard edges, one accent
+	colour, nothing moving that is not reporting something.
+
+	The solid is a real projection rather than a canned loop. Vertices rotate in
+	three dimensions and pass through a perspective divide every frame, so near
+	edges are brighter and thicker because they genuinely are nearer, and the
+	shape climbs a ladder -- tetrahedron, octahedron, cube, icosahedron -- as the
+	session gets busier. An idle plugin shows four vertices; a working one shows
+	twelve. The shape itself is the load meter.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+local PHI = (1 + math.sqrt(5)) / 2
+
+type Shape = {
+	name: string,
+	vertices: { Vector3 },
+	edges: { { number } },
+}
+
+--[[
+	Ordered by how busy they look. The session climbs this list as it works, so
+	the shape itself reports load: an idle plugin shows a tetrahedron, a busy one
+	an icosahedron.
+]]
+local SHAPES: { Shape } = {
+	{
+		name = "tetrahedron",
+		vertices = {
+			Vector3.new(1, 1, 1),
+			Vector3.new(1, -1, -1),
+			Vector3.new(-1, 1, -1),
+			Vector3.new(-1, -1, 1),
+		},
+		edges = { { 1, 2 }, { 1, 3 }, { 1, 4 }, { 2, 3 }, { 2, 4 }, { 3, 4 } },
+	},
+	{
+		name = "octahedron",
+		vertices = {
+			Vector3.new(1, 0, 0),
+			Vector3.new(-1, 0, 0),
+			Vector3.new(0, 1, 0),
+			Vector3.new(0, -1, 0),
+			Vector3.new(0, 0, 1),
+			Vector3.new(0, 0, -1),
+		},
+		edges = {
+			{ 1, 3 }, { 1, 4 }, { 1, 5 }, { 1, 6 },
+			{ 2, 3 }, { 2, 4 }, { 2, 5 }, { 2, 6 },
+			{ 3, 5 }, { 5, 4 }, { 4, 6 }, { 6, 3 },
+		},
+	},
+	{
+		name = "cube",
+		vertices = {
+			Vector3.new(-1, -1, -1), Vector3.new(1, -1, -1),
+			Vector3.new(1, 1, -1), Vector3.new(-1, 1, -1),
+			Vector3.new(-1, -1, 1), Vector3.new(1, -1, 1),
+			Vector3.new(1, 1, 1), Vector3.new(-1, 1, 1),
+		},
+		edges = {
+			{ 1, 2 }, { 2, 3 }, { 3, 4 }, { 4, 1 },
+			{ 5, 6 }, { 6, 7 }, { 7, 8 }, { 8, 5 },
+			{ 1, 5 }, { 2, 6 }, { 3, 7 }, { 4, 8 },
+		},
+	},
+	{
+		name = "icosahedron",
+		vertices = {
+			Vector3.new(0, 1, PHI), Vector3.new(0, -1, PHI),
+			Vector3.new(0, 1, -PHI), Vector3.new(0, -1, -PHI),
+			Vector3.new(1, PHI, 0), Vector3.new(-1, PHI, 0),
+			Vector3.new(1, -PHI, 0), Vector3.new(-1, -PHI, 0),
+			Vector3.new(PHI, 0, 1), Vector3.new(PHI, 0, -1),
+			Vector3.new(-PHI, 0, 1), Vector3.new(-PHI, 0, -1),
+		},
+		edges = {
+			{ 1, 2 }, { 1, 5 }, { 1, 6 }, { 1, 9 }, { 1, 11 },
+			{ 2, 7 }, { 2, 8 }, { 2, 9 }, { 2, 11 },
+			{ 3, 4 }, { 3, 5 }, { 3, 6 }, { 3, 10 }, { 3, 12 },
+			{ 4, 7 }, { 4, 8 }, { 4, 10 }, { 4, 12 },
+			{ 5, 6 }, { 5, 9 }, { 5, 10 },
+			{ 6, 11 }, { 6, 12 },
+			{ 7, 8 }, { 7, 9 }, { 7, 10 },
+			{ 8, 11 }, { 8, 12 },
+			{ 9, 10 }, { 11, 12 },
+		},
+	},
+}
+
+local MAX_EDGES = 30
+local MAX_VERTICES = 12
+local FOCAL = 3.4
+
+-- The inner solid, counter-rotating inside the outer one. An octahedron
+-- regardless of what is outside it: it reads as a core rather than as a second
+-- object competing for attention, and its 12 edges are cheap.
+local INNER_SHAPE = 2
+local INNER_SCALE = 0.42
+
+-- The solid's resting radius as a fraction of the cell. At full overshoot the
+-- perspective divide pushes a near vertex to roughly 15px, which still clears
+-- the cell's half-width.
+local BASE_RADIUS = 0.185
+
+local Lattice = {}
+
+Lattice.id = "lattice"
+Lattice.label = "Lattice"
+Lattice.blurb = "Wireframe solid"
+
+Lattice.palette = {
+	-- Violet-tinted near-black. The cast is slight but it stops the panel
+	-- reading as the same grey as every other Studio dock.
+	background = Color3.fromRGB(11, 12, 20),
+	surface = Color3.fromRGB(18, 20, 31),
+	rule = Color3.fromRGB(167, 139, 250),
+	text = Color3.fromRGB(206, 212, 226),
+	dim = Color3.fromRGB(90, 97, 120),
+	green = Color3.fromRGB(110, 231, 168),
+	red = Color3.fromRGB(251, 113, 133),
+	amber = Color3.fromRGB(251, 191, 36),
+	cyan = Color3.fromRGB(103, 232, 249),
+	violet = Color3.fromRGB(167, 139, 250),
+}
+
+local edges: { Frame } = {}
+local innerEdges: { Frame } = {}
+local dots: { Frame } = {}
+
+function Lattice.mount(cell: Frame)
+	edges = Draw.pool(cell, MAX_EDGES, "Edge", false)
+	innerEdges = Draw.pool(cell, #SHAPES[INNER_SHAPE].edges, "Inner", false)
+	-- Built after the edges so the lit corners sit over the strokes they join.
+	dots = Draw.pool(cell, MAX_VERTICES, "Vertex", true)
+end
+
+function Lattice.unmount()
+	edges = {}
+	innerEdges = {}
+	dots = {}
+end
+
+function Lattice.paint(ctx: Theme.Context, _delta: number)
+	local shapeIndex = math.clamp(1 + math.floor(ctx.activity * (#SHAPES - 0.001)), 1, #SHAPES)
+	local shape = SHAPES[shapeIndex]
+	local radius = ctx.size * BASE_RADIUS * ctx.scale
+
+	-- Wobble the axis rather than the panel: shaking the strip would read as a
+	-- glitch, tilting the solid reads as it being knocked.
+	local wobble = if ctx.shake > 0
+		then Vector3.new(
+			math.sin(ctx.clock * 37) * ctx.shake * 0.12,
+			math.cos(ctx.clock * 29) * ctx.shake * 0.12,
+			0
+		)
+		else Vector3.zero
+
+	local projected: { Vector2 } = {}
+	local depths: { number } = {}
+	for index, vertex in shape.vertices do
+		local point, depth = Draw.project(
+			Draw.rotate(vertex, ctx.angle + wobble),
+			FOCAL,
+			radius,
+			ctx.centre
+		)
+		projected[index] = point
+		depths[index] = depth
+	end
+
+	for index = 1, MAX_EDGES do
+		local frame = edges[index]
+		if frame == nil then
+			continue
+		end
+		local edge = shape.edges[index]
+		if edge == nil then
+			frame.Visible = false
+			continue
+		end
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((depths[a] + depths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			frame,
+			projected[a],
+			projected[b],
+			math.max(1, math.floor(1 + depth * 1.6 + ctx.flare * 0.8)),
+			ctx.tint:Lerp(Color3.new(1, 1, 1), depth * 0.35 + ctx.flare * 0.3),
+			math.max(0, 0.84 - depth * 0.74 - ctx.flare * 0.3)
+		)
+	end
+
+	--[[
+		Vertices as points, brighter than the edges they join.
+
+		Wireframes read as flat when every stroke is the same weight. Lighting
+		the corners gives the eye something to track as the solid turns, which is
+		what makes it read as rotating rather than merely flickering.
+	]]
+	for index = 1, MAX_VERTICES do
+		local dot = dots[index]
+		if dot == nil then
+			continue
+		end
+		local point = projected[index]
+		if point == nil then
+			dot.Visible = false
+			continue
+		end
+		local depth = math.clamp((depths[index] + 2) / 4, 0, 1)
+		-- The corners carry the flare. A pulse of light travelling through the
+		-- vertices is what makes a completed call land as an event rather than
+		-- as a bar quietly appearing somewhere off to the right.
+		Draw.dot(
+			dot,
+			point,
+			math.max(2, math.floor(1.5 + depth * 2.5 + ctx.flare * 2.5)),
+			ctx.tint:Lerp(Color3.new(1, 1, 1), 0.25 + depth * 0.5),
+			math.max(0, 0.55 - depth * 0.5 - ctx.flare * 0.45)
+		)
+	end
+
+	--[[
+		A second solid inside the first, turning the other way.
+
+		One rotating outline is a loading spinner. Two, at different rates and
+		opposite directions, read as a mechanism -- and the counter-rotation
+		makes the outer solid's direction obvious, which a lone wireframe hides
+		whenever it passes through a symmetrical angle.
+	]]
+	local inner = SHAPES[INNER_SHAPE]
+	local innerAngle = -ctx.angle * 1.6
+	local innerProjected: { Vector2 } = {}
+	local innerDepths: { number } = {}
+	for index, vertex in inner.vertices do
+		local point, depth = Draw.project(
+			Draw.rotate(vertex, innerAngle),
+			FOCAL,
+			radius * INNER_SCALE,
+			ctx.centre
+		)
+		innerProjected[index] = point
+		innerDepths[index] = depth
+	end
+	for index, frame in innerEdges do
+		local edge = inner.edges[index]
+		if edge == nil then
+			frame.Visible = false
+			continue
+		end
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((innerDepths[a] + innerDepths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			frame,
+			innerProjected[a],
+			innerProjected[b],
+			1,
+			ctx.tint:Lerp(Color3.new(1, 1, 1), 0.5),
+			0.9 - depth * 0.35
+		)
+	end
+end
+
+--[[
+	A still cube, which is the shape people recognise the console by, drawn at a
+	three-quarter angle so all three dimensions are visible at once.
+]]
+function Lattice.swatch(frame: Frame, palette: Theme.Palette)
+	local centre = Vector2.new(20, 12)
+	local pool = Draw.pool(frame, 12, "Edge", false)
+	local shape = SHAPES[3]
+	local angle = Vector3.new(0.5, 0.7, 0)
+
+	local projected: { Vector2 } = {}
+	local depths: { number } = {}
+	for index, vertex in shape.vertices do
+		local point, depth = Draw.project(Draw.rotate(vertex, angle), FOCAL, 5.5, centre)
+		projected[index] = point
+		depths[index] = depth
+	end
+	for index, edge in shape.edges do
+		local a, b = edge[1], edge[2]
+		local depth = math.clamp(((depths[a] + depths[b]) / 2 + 2) / 4, 0, 1)
+		Draw.edge(
+			pool[index],
+			projected[a],
+			projected[b],
+			1,
+			palette.violet:Lerp(Color3.new(1, 1, 1), depth * 0.4),
+			0.75 - depth * 0.6
+		)
+	end
+end
+
+return Lattice