@el4cteo/rbx-studio-mcp 0.3.1 → 0.3.6

package/plugin/src/Themes/Aurora.luau

@@ -0,0 +1,161 @@
+--!strict
+--[[
+	Aurora -- load as an amplitude.
+
+	A curtain of vertical rays whose height follows a travelling wave. The wave
+	is always there; what the session changes is how violent it is. Idle, it is
+	a shallow ripple you have to look at to notice. Under load it becomes a
+	curtain that fills the cell. Nothing here counts or ranks anything, which is
+	the point: it answers "how hard is this working" continuously, where Lattice
+	answers it in four steps and Orbit in six.
+
+	Two waves at different rates are summed rather than one, because a single
+	sine is a loading bar lying on its side -- the interference is what makes it
+	read as something physical rather than as an animation on a loop.
+
+	Colour runs green at the base to violet at the tips, which is the actual
+	emission order of a real aurora and, more usefully here, means the height of
+	a ray is legible from its colour alone at four pixels wide.
+]]
+
+local Draw = require(script.Parent.Draw)
+local Theme = require(script.Parent.Theme)
+
+local RAYS = 15
+
+local Aurora = {}
+
+Aurora.id = "aurora"
+Aurora.label = "Aurora"
+Aurora.blurb = "Rising curtain"
+
+Aurora.palette = {
+	background = Color3.fromRGB(9, 14, 28),
+	surface = Color3.fromRGB(16, 23, 44),
+	rule = Color3.fromRGB(108, 226, 178),
+	text = Color3.fromRGB(206, 220, 238),
+	dim = Color3.fromRGB(86, 100, 130),
+	green = Color3.fromRGB(108, 232, 172),
+	red = Color3.fromRGB(246, 126, 146),
+	amber = Color3.fromRGB(244, 196, 128),
+	cyan = Color3.fromRGB(114, 214, 236),
+	violet = Color3.fromRGB(162, 146, 240),
+}
+
+local rays: { Frame } = {}
+
+--[[
+	Accumulated wave phase, rather than wall time times a rate.
+
+	`ctx.clock * 1.6 * pace` looks harmless and is not: `pace` drops to 0.35 the
+	moment the session goes quiet, and multiplying a clock in the thousands by a
+	rate that changes RESHAPES the whole curtain in one frame -- the same class
+	of fault as Void's disc, just rarer, because this rate only moves twice per
+	idle cycle instead of every frame. Integrating it means going quiet slows the
+	curtain, which is what was meant.
+]]
+local phase = 0
+
+function Aurora.mount(cell: Frame)
+	rays = {}
+	for index = 1, RAYS do
+		local ray = Instance.new("Frame")
+		ray.Name = string.format("Ray%02d", index)
+		-- Anchored at the bottom so height grows upward from a fixed baseline,
+		-- which is what makes the curtain rise rather than expand about its
+		-- middle.
+		ray.AnchorPoint = Vector2.new(0.5, 1)
+		ray.BorderSizePixel = 0
+		ray.Parent = cell
+		local corner = Instance.new("UICorner")
+		corner.CornerRadius = UDim.new(0, 1)
+		corner.Parent = ray
+		rays[index] = ray
+	end
+end
+
+function Aurora.unmount()
+	phase = 0
+	rays = {}
+end
+
+function Aurora.paint(ctx: Theme.Context, delta: number)
+	local width = ctx.size
+	local spacing = width / (RAYS + 1)
+
+	--[[
+		The floor is what keeps an idle panel alive.
+
+		Amplitude driven purely by activity would flatten the curtain to nothing
+		between commands, and a flat line is indistinguishable from a plugin
+		that has crashed. A tenth of the range is always moving.
+	]]
+	local amplitude = 0.1 + math.clamp(ctx.activity, 0, 1) * 0.62 + ctx.energy * 0.16
+	local pace = if ctx.quiet > 20 then 0.35 else 1
+	phase += delta * pace
+
+	for index = 1, RAYS do
+		local ray = rays[index]
+		if ray == nil then
+			continue
+		end
+		local across = index / RAYS
+
+		-- Two travelling waves, incommensurate rates. Their beat is slow enough
+		-- that the curtain visibly reshapes over several seconds instead of
+		-- repeating on a cycle the eye can learn.
+		local wave = math.sin(across * 5.2 - phase * 1.6)
+			+ 0.6 * math.sin(across * 2.7 + phase * 0.9)
+		local normalised = (wave + 1.6) / 3.2
+
+		local height = math.max(2, math.floor(width * (0.12 + normalised * amplitude) * ctx.scale))
+		local reach = math.clamp(height / width, 0, 1)
+
+		ray.Size = UDim2.fromOffset(3, height)
+		ray.Position = UDim2.fromOffset(spacing * index, width - 2)
+		-- Green low, violet high: the ray's own height is readable from its
+		-- colour, which a three-pixel column badly needs.
+		ray.BackgroundColor3 = ctx.palette.green
+			:Lerp(ctx.palette.violet, reach)
+			:Lerp(Color3.new(1, 1, 1), ctx.flare * 0.45)
+		ray.BackgroundTransparency = math.clamp(0.74 - reach * 0.45 - ctx.flare * 0.3, 0, 1)
+	end
+end
+
+--[[
+	The trace as a continuation of the curtain: same rays, same colour rule, but
+	their heights are history rather than a wave.
+]]
+function Aurora.paintSlot(slot: Theme.Slot, ctx: Theme.Context)
+	local frame = slot.frame
+	local recency = 1 - slot.age
+	local height = math.max(2, math.floor(2 + slot.weight * 21))
+
+	frame.AnchorPoint = Vector2.new(0.5, 1)
+	frame.Size = UDim2.fromOffset(3, height)
+	frame.Position = UDim2.new(frame.Position.X.Scale, frame.Position.X.Offset, 1, 0)
+	frame.BackgroundColor3 = if slot.ok
+		then ctx.palette.green:Lerp(ctx.palette.violet, slot.weight)
+		else ctx.palette.red
+	frame.BackgroundTransparency = math.clamp(0.66 - recency * 0.56, 0, 1)
+	frame.Rotation = 0
+end
+
+function Aurora.swatch(frame: Frame, palette: Theme.Palette)
+	for index = 1, 12 do
+		local ray = Instance.new("Frame")
+		ray.AnchorPoint = Vector2.new(0.5, 1)
+		ray.BorderSizePixel = 0
+		local across = index / 12
+		local wave = math.sin(across * 5.2) + 0.6 * math.sin(across * 2.7)
+		local reach = (wave + 1.6) / 3.2
+		local height = math.max(2, math.floor(4 + reach * 17))
+		ray.Size = UDim2.fromOffset(2, height)
+		ray.Position = UDim2.fromOffset(3 + index * 3, 23)
+		ray.BackgroundColor3 = palette.green:Lerp(palette.violet, reach)
+		ray.BackgroundTransparency = 0.35
+		ray.Parent = frame
+	end
+end
+
+return Aurora

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