@chris.araneo/cassette-canvas 0.0.0-stage → 0.2.0

package/dist/lib/index.js

@@ -0,0 +1,816 @@
+import { P, match } from "ts-pattern";
+import { pipe } from "remeda";
+import { clamp, filter, find, flatMap, floor, fromPairs, inRange, isInteger, isUndefined, map, mapValues, parseInt, range, round, split, words } from "lodash-es";
+// libs/common/src/effects/run-effect.ts
+/**
+* Calls `effect` with `value`, then returns `value`. Use it to run a side
+* effect as a step in a `pipe`: `(scene) => runEffect(scene, draw)`.
+*/
+const runEffect = (value, effect) => match(effect(value)).otherwise(() => value);
+// libs/engine/src/crt/consts.ts
+const GLOW_STRENGTH = .6;
+const GLOW_THRESHOLD = .45;
+const SCANLINE_DEPTH = .09;
+const GRAIN_AMOUNT = .015;
+const SURFACE_AMOUNT = .0125;
+const POSITION_ATTRIBUTE = "a_position";
+const FULL_SCREEN_TRIANGLE = Object.freeze([
+	-1,
+	-1,
+	3,
+	-1,
+	-1,
+	3
+]);
+const CRT_UNIFORM_NAMES = Object.freeze({
+	frame: "u_frame",
+	frameSize: "u_frameSize",
+	canvasSize: "u_canvasSize",
+	pixelSize: "u_pixelSize",
+	time: "u_time"
+});
+const CRT_CONTEXT_ATTRIBUTES = Object.freeze({
+	alpha: true,
+	antialias: false,
+	depth: false,
+	stencil: false,
+	premultipliedAlpha: true,
+	preserveDrawingBuffer: false
+});
+// libs/engine/src/crt/internal/draw-crt-triangle.ts
+const VALUES_PER_CORNER = 2;
+const CORNER_COUNT = 3;
+const drawCrtTriangle = (context, { vertices }) => pipe(context, (gl) => runEffect(gl, () => gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight)), (gl) => runEffect(gl, () => gl.bindBuffer(gl.ARRAY_BUFFER, vertices)), (gl) => runEffect(gl, () => gl.enableVertexAttribArray(0)), (gl) => runEffect(gl, () => gl.vertexAttribPointer(0, VALUES_PER_CORNER, gl.FLOAT, false, 0, 0)), (gl) => gl.drawArrays(gl.TRIANGLES, 0, CORNER_COUNT));
+// libs/engine/src/crt/internal/patch-crt-texture.ts
+const patchCrtTexture = (context, { texture }, { bytes, width, height }) => pipe(context, (gl) => runEffect(gl, () => gl.bindTexture(gl.TEXTURE_2D, texture)), (gl) => runEffect(gl, () => gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength))));
+// libs/engine/src/crt/internal/patch-crt-uniforms.ts
+const FRAME_TEXTURE_UNIT = 0;
+const patchCrtUniforms = (context, { program, uniforms }, { width, height, pixelSize }, time) => pipe(context, (gl) => runEffect(gl, () => gl.useProgram(program)), (gl) => runEffect(gl, () => gl.uniform1i(uniforms.frame, FRAME_TEXTURE_UNIT)), (gl) => runEffect(gl, () => gl.uniform2f(uniforms.frameSize, width, height)), (gl) => runEffect(gl, () => gl.uniform2f(uniforms.canvasSize, gl.drawingBufferWidth, gl.drawingBufferHeight)), (gl) => runEffect(gl, () => gl.uniform1f(uniforms.pixelSize, pixelSize)), (gl) => runEffect(gl, () => gl.uniform1f(uniforms.time, time)));
+// libs/engine/src/crt/draw-crt.ts
+/**
+* Draws a frame on the canvas with the monitor effect:
+*
+* - each logical pixel becomes a sharp `pixelSize` square;
+* - bright pixels glow up to 2 canvas pixels outward;
+* - each pixel row has a darker scanline at its bottom;
+* - film grain (animated by `time`, in milliseconds) and a fixed surface
+*   texture are added on top.
+*
+* The effect uses full RGB color, not the palette.
+*/
+const drawCrt = (context, crt, picture, time) => pipe(context, (gl) => runEffect(gl, () => patchCrtTexture(gl, crt, picture)), (gl) => runEffect(gl, () => patchCrtUniforms(gl, crt, picture, time)), (gl) => drawCrtTriangle(gl, crt));
+// libs/engine/src/palette/consts.ts
+/** The number of base colors in a palette. */
+const COLOR_COUNT = 16;
+/** The number of shades of each color that sprites and backgrounds use. */
+const SHADE_COUNT = 8;
+/**
+* The shade that shows a base color exactly as given. Lower shades are
+* darker, higher shades are lighter.
+*/
+const BASE_SHADE = 4;
+/**
+* The number of shades of each color that lighting uses. The finer scale
+* lets light fade in smaller steps than sprite shades.
+*/
+const EXTENDED_SHADE_COUNT = 32;
+/** The number of extended shades in one sprite shade. */
+const EXTENDED_SHADES_PER_SHADE = 4;
+/** The pixel value that draws nothing. Whatever is below shows through. */
+const TRANSPARENT = -1;
+const BLACK = Object.freeze({
+	red: 0,
+	green: 0,
+	blue: 0
+});
+const WHITE = Object.freeze({
+	red: 255,
+	green: 255,
+	blue: 255
+});
+// libs/engine/src/lighting/consts.ts
+/**
+* How many extended shades one doubling of light moves a pixel: one sprite
+* shade per doubling. Lights add up as light and are read off this scale
+* afterwards, so every doubling costs the same number of shades, the way the
+* eye sees brightness.
+*/
+const EXTENDED_SHADES_PER_STOP = 4;
+/**
+* The most light can move a pixel, in extended shades. A whole ramp in
+* either direction is more than any pixel needs: every pixel stops at the
+* darkest or the lightest extended shade well before this.
+*/
+const MAX_SHADE_OFFSET = 32;
+const MIN_EXPOSURE = 2 ** (-32 / EXTENDED_SHADES_PER_STOP);
+const MAX_EXPOSURE = 2 ** (MAX_SHADE_OFFSET / EXTENDED_SHADES_PER_STOP);
+/**
+* How much of the light at a pixel comes from each side of the pixel ahead
+* of it, toward the light, rather than all of it from that one pixel. It
+* gives every shadow a penumbra: its edge ramps from full light to full
+* shadow over two pixels instead of stepping down in one, the way an edge
+* looks under a light that is not a single point.
+*
+* Only the edge softens. What blocks a light still blocks it, so the heart
+* of a shadow stays as dark as ever, and a shadow never fades out with
+* distance. 0 gives the hard edges of a point source, and 0.25 spreads the
+* ramp evenly, which is as soft as three pixels go.
+*/
+const SHADOW_SOFTNESS = .25;
+// libs/engine/src/lighting/internal/compute-falloff.ts
+const computeWindow = (squaredReach) => 1 - squaredReach * squaredReach;
+/**
+* Returns the share of a light that reaches a point: 1 at its center, 0 at
+* its radius. `squaredReach` is the distance to the light as a share of the
+* radius, squared, from 0 at the center to 1 at the radius. Squared, because
+* then the caller needs no square root, and this runs once per lit pixel.
+*
+* The share thins out with distance the way light spreads out in the world,
+* and a window closes it off smoothly at the radius, so a light leaves a
+* bright core and a long dim halo instead of a flat disc with a visible rim.
+* Callers keep to the center and the radius; a share past 1 means nothing.
+*/
+const computeFalloff = (squaredReach) => computeWindow(squaredReach) ** 2 / (1 + 8 * squaredReach);
+// libs/engine/src/lighting/internal/to-exposure.ts
+/**
+* Returns the amount of light that shows a pixel `shades` extended shades
+* from its authored color. `toExposure(0)` is `REFERENCE_EXPOSURE`, and every
+* `EXTENDED_SHADES_PER_STOP` shades up double it.
+*
+* Ambient light and light intensities are written in extended shades because
+* that is what you see on screen. This turns one of them back into the amount
+* of light behind it, which is what adds up.
+*/
+const toExposure = (shades) => 2 ** (shades / EXTENDED_SHADES_PER_STOP);
+// libs/engine/src/lighting/internal/compute-light-exposure.ts
+const SHARE_AHEAD = 1 - 2 * SHADOW_SOFTNESS;
+/**
+* Returns how much light one light adds to every pixel. The values are
+* amounts of light, not extended shades, because that is what adds up:
+* `computeShadeOffsets` sums the amounts and reads the shades off them.
+*
+* At its center the light adds as much light as its intensity stands for,
+* which thins out to nothing at its radius. Sprites that cast shadows block
+* it, and the edge of a shadow ramps down over two pixels rather than
+* stepping down in one. A negative intensity takes light away instead.
+*/
+const computeLightExposure = ({ width, height, occluders }, light) => {
+	const exposures = new Float32Array(width * height);
+	const visible = new Uint8Array(width * height);
+	const lightRow = Math.floor(light.row);
+	const lightColumn = Math.floor(light.column);
+	const reach = Math.ceil(light.radius);
+	const squaredRadius = light.radius * light.radius;
+	const emission = toExposure(light.intensity) - 1;
+	const firstRing = Math.max(0, -lightRow, lightRow - (height - 1), -lightColumn, lightColumn - (width - 1));
+	for (let ring = firstRing; ring <= reach; ring += 1) {
+		const top = Math.max(-ring, -lightRow);
+		const bottom = Math.min(ring, height - 1 - lightRow);
+		const sideReach = ring - 1;
+		for (let rowOffset = top; rowOffset <= bottom; rowOffset += 1) {
+			const isEdgeRow = rowOffset === -ring || rowOffset === ring;
+			const left = isEdgeRow ? Math.max(-ring, -lightColumn) : -ring;
+			const right = isEdgeRow ? Math.min(ring, width - 1 - lightColumn) : ring;
+			const step = isEdgeRow ? 1 : 2 * ring;
+			for (let columnOffset = left; columnOffset <= right; columnOffset += step) {
+				const row = lightRow + rowOffset;
+				const column = lightColumn + columnOffset;
+				if (column < 0 || column >= width) continue;
+				const parentRowOffset = Math.round(rowOffset * sideReach / ring);
+				const parentColumnOffset = Math.round(columnOffset * sideReach / ring);
+				const parentRow = lightRow + parentRowOffset;
+				const parentColumn = lightColumn + parentColumnOffset;
+				const parentIndex = parentRow * width + parentColumn;
+				const hasParent = ring >= 2 && parentRow >= 0 && parentRow < height && parentColumn >= 0 && parentColumn < width;
+				const litAhead = !hasParent || visible[parentIndex] === 1 && occluders[parentIndex] !== 1 ? 1 : 0;
+				const runsAlongRow = Math.abs(parentRowOffset) >= Math.abs(parentColumnOffset);
+				const sideStep = runsAlongRow ? 1 : width;
+				const sideOffset = runsAlongRow ? parentColumnOffset : parentRowOffset;
+				const sidePlace = runsAlongRow ? parentColumn : parentRow;
+				const sideLimit = runsAlongRow ? width : height;
+				const lowIndex = parentIndex - sideStep;
+				const highIndex = parentIndex + sideStep;
+				const litLow = hasParent && sideOffset > -sideReach && sidePlace > 0 ? visible[lowIndex] === 1 && occluders[lowIndex] !== 1 ? 1 : 0 : litAhead;
+				const litHigh = hasParent && sideOffset < sideReach && sidePlace < sideLimit - 1 ? visible[highIndex] === 1 && occluders[highIndex] !== 1 ? 1 : 0 : litAhead;
+				const share = SHARE_AHEAD * litAhead + SHADOW_SOFTNESS * (litLow + litHigh);
+				const index = row * width + column;
+				const squaredDistance = rowOffset * rowOffset + columnOffset * columnOffset;
+				visible[index] = litAhead;
+				if (share > 0 && squaredDistance < squaredRadius) exposures[index] = emission * share * computeFalloff(squaredDistance / squaredRadius);
+			}
+		}
+	}
+	return exposures;
+};
+// libs/engine/src/lighting/internal/to-shade-offset.ts
+/**
+* Returns how many extended shades an amount of light moves a pixel from its
+* authored color. This undoes `toExposure`: `REFERENCE_EXPOSURE` gives 0,
+* twice as much light gives `EXTENDED_SHADES_PER_STOP` more shades, and half
+* as much gives that many fewer. Light beyond what a pixel can show stops at
+* the ends of the scale.
+*
+* Because every doubling costs the same number of shades, a scene that is
+* already bright barely shows one more lamp, while the same lamp in the dark
+* shows in full. That is how the eye reads brightness, and it is why lights
+* no longer stack up into white.
+*
+* It clamps with `Math.min` and `Math.max` rather than `clamp`, because it
+* runs once per lit pixel.
+*/
+const toShadeOffset = (exposure) => EXTENDED_SHADES_PER_STOP * Math.log2(Math.min(MAX_EXPOSURE, Math.max(MIN_EXPOSURE, exposure)));
+// libs/engine/src/lighting/internal/compute-shade-offsets.ts
+/**
+* Adds up the ambient light and every light that reaches a pixel, then reads
+* off how many extended shades that much light moves the pixel.
+*
+* The amounts of light are added, not the shades. Two lamps on one spot are
+* twice the light, which is one shade step more than one lamp, not twice as
+* many shade steps, and a lamp in daylight hardly tells at all. That is why
+* a lit scene keeps its shading instead of washing out to white.
+*/
+const computeShadeOffsets = ({ ambient, width, height }, exposures) => {
+	const offsets = new Float64Array(Math.max(0, width * height));
+	const ambientExposure = toExposure(ambient);
+	for (const exposure of exposures) for (let index = 0; index < offsets.length; index += 1) offsets[index] = (offsets[index] ?? 0) + (exposure[index] ?? 0);
+	for (let index = 0; index < offsets.length; index += 1) {
+		const light = offsets[index] ?? 0;
+		offsets[index] = light === 0 ? ambient : toShadeOffset(ambientExposure + light);
+	}
+	return offsets;
+};
+// libs/engine/src/lighting/compute-light-levels.ts
+/**
+* Returns how many extended shades the light moves every pixel, row by row
+* from the top left.
+*
+* Lights are combined the way light behaves, not the way numbers add. Each
+* light and the ambient light are turned into amounts of light, those amounts
+* are added together, and the shade is read off the total on a scale where
+* every doubling of light is worth `EXTENDED_SHADES_PER_STOP` shades. So one
+* light on an unlit scene moves a pixel by exactly its intensity, while a
+* second light of the same intensity adds only one more step, and a lamp in
+* bright daylight barely shows. Nothing stacks up into flat white.
+*/
+const computeLightLevels = (lighting) => computeShadeOffsets(lighting, map(lighting.lights, (light) => computeLightExposure(lighting, light)));
+// libs/engine/src/frame/internal/compute-frame-light.ts
+const computeFrameLight = ({ pixels, lighting }) => ({
+	pixels,
+	levels: computeLightLevels(lighting)
+});
+// libs/engine/src/palette/internal/is-index.ts
+const isIndex = (index, size) => isInteger(index) && inRange(index, size);
+// libs/engine/src/palette/to-extended-pixel.ts
+/**
+* Returns the extended pixel for a color (0 to 15) and an extended shade
+* (0 to 31): `color * 32 + extendedShade`. Lit frames hold extended pixels,
+* and the palette is keyed by them.
+*
+* Sprite shade `s` is extended shade `4 * s + 1`. Extended shades 0, 30 and
+* 31 are outside the sprite shades; only light reaches them. Returns
+* `TRANSPARENT` for out-of-range input.
+*/
+const toExtendedPixel = (color, extendedShade) => match(isIndex(color, 16) && isIndex(extendedShade, 32)).with(true, () => color * 32 + extendedShade).otherwise(() => -1);
+// libs/engine/src/palette/to-pixel.ts
+/**
+* Returns the pixel value for a color (0 to 15) and a shade (0 to 7):
+* `toPixel(3, 5)` is `0x35`. Returns `TRANSPARENT` for out-of-range input.
+*/
+const toPixel = (color, shade) => match(isIndex(color, 16) && isIndex(shade, 8)).with(true, () => color * 16 + shade).otherwise(() => -1);
+// libs/engine/src/palette/internal/to-extended-shade.ts
+const toExtendedShade = (shade) => 1 + shade * 4;
+// libs/engine/src/palette/internal/create-shade-ramps.ts
+const createColorEntries = (color, pixels) => map(range(8), (shade) => [toPixel(color, shade), {
+	pixels,
+	extendedShade: toExtendedShade(shade)
+}]);
+const createShadeRamps = () => fromPairs(flatMap(range(16), (color) => createColorEntries(color, map(range(32), (extendedShade) => toExtendedPixel(color, extendedShade)))));
+// libs/engine/src/palette/internal/shade-ramps.ts
+const SHADE_RAMPS = Object.freeze(createShadeRamps());
+// libs/engine/src/palette/is-pixel.ts
+/**
+* Returns `true` if the number is a pixel the palette can draw: a color from
+* 0 to 15 in the high hex digit and a shade from 0 to 7 in the low hex digit.
+* Returns `false` for `TRANSPARENT` and all other values.
+*/
+const isPixel = (pixel) => !isUndefined(SHADE_RAMPS[pixel]);
+// libs/engine/src/frame/internal/compute-frame-pixels.ts
+const SHADOW_CASTER = 1;
+const computeFramePixels = ({ screen, spriteSize, width, height }) => {
+	const size = Math.max(0, width * height);
+	const pixels = new Int16Array(size).fill(isPixel(screen.background) ? screen.background : -1);
+	const occluders = new Uint8Array(size);
+	const spritePixelCount = spriteSize * spriteSize;
+	for (const { sprite, row, column, castsShadow } of screen.sprites) {
+		const top = Math.floor(row);
+		const left = Math.floor(column);
+		const count = Math.min(sprite.length, spritePixelCount);
+		for (let index = 0; index < count; index += 1) {
+			const pixel = sprite[index] ?? -1;
+			const pixelRow = top + Math.floor(index / spriteSize);
+			const pixelColumn = left + index % spriteSize;
+			if (pixelRow >= 0 && pixelRow < height && pixelColumn >= 0 && pixelColumn < width && isPixel(pixel)) {
+				const place = pixelRow * width + pixelColumn;
+				pixels[place] = pixel;
+				if (castsShadow) occluders[place] = SHADOW_CASTER;
+			}
+		}
+	}
+	return {
+		pixels,
+		lighting: {
+			ambient: screen.ambient,
+			lights: screen.lights,
+			width,
+			height,
+			occluders
+		}
+	};
+};
+// libs/engine/src/palette/to-lit-pixels.ts
+const toLitPixels = (pixels, shadeOffsets) => {
+	const litPixels = new Array(pixels.length);
+	for (let index = 0; index < pixels.length; index += 1) {
+		const ramp = SHADE_RAMPS[pixels[index] ?? -1];
+		const extendedShade = Math.round((ramp?.extendedShade ?? 0) + (shadeOffsets[index] ?? 0));
+		litPixels[index] = ramp?.pixels[Math.min(31, Math.max(0, extendedShade))] ?? -1;
+	}
+	return litPixels;
+};
+// libs/engine/src/frame/internal/patch-frame-shades.ts
+const patchFrameShades = ({ pixels, levels }) => toLitPixels(pixels, levels);
+// libs/engine/src/frame/compute-frame.ts
+/**
+* Turns a screen into a frame of `width * height` extended pixels:
+*
+* 1. Fills the frame with the background.
+* 2. Draws the sprites in order. Transparent pixels are skipped, and parts
+*    outside the frame are cut off.
+* 3. Lights every pixel: moves it along its 32-shade scale by the ambient
+*    light plus each light that reaches it. Sprites that cast shadows block
+*    light.
+*
+* With ambient 0 and no lights, every pixel keeps its authored color.
+*/
+const computeFrame = (screen, spriteSize, width, height) => pipe({
+	screen,
+	spriteSize,
+	width,
+	height
+}, computeFramePixels, computeFrameLight, patchFrameShades);
+// libs/engine/src/display/internal/to-frame-bytes.ts
+const BYTES_PER_PIXEL = 4;
+const RED_OFFSET = 0;
+const GREEN_OFFSET = 1;
+const BLUE_OFFSET = 2;
+const ALPHA_OFFSET = 3;
+const toFrameBytes = (frame, palette) => {
+	const bytes = new Uint8ClampedArray(frame.length * BYTES_PER_PIXEL);
+	for (let index = 0; index < frame.length; index += 1) {
+		const rgb = palette[frame[index] ?? -1];
+		if (rgb !== void 0) {
+			const offset = index * BYTES_PER_PIXEL;
+			bytes[offset + RED_OFFSET] = rgb.red;
+			bytes[offset + GREEN_OFFSET] = rgb.green;
+			bytes[offset + BLUE_OFFSET] = rgb.blue;
+			bytes[offset + ALPHA_OFFSET] = 255;
+		}
+	}
+	return bytes;
+};
+// libs/engine/src/display/draw-screen.ts
+/**
+* Draws the screen on the canvas. It composes and lights the frame, then
+* draws it with the monitor effect. `time` is the current time in
+* milliseconds, for example the `requestAnimationFrame` timestamp. It
+* animates the film grain. Returns the same display.
+*/
+const drawScreen = (display, screen, time) => pipe(computeFrame(screen, display.spriteSize, display.width, display.height), (frame) => toFrameBytes(frame, display.palette), (bytes) => runEffect(display, ({ context, crt, width, height, pixelSize }) => drawCrt(context, crt, {
+	bytes,
+	width,
+	height,
+	pixelSize
+}, time)));
+// libs/engine/src/crt/internal/find-crt-uniforms.ts
+const { nonNullable: nonNullable$9 } = P;
+const findCrtUniforms = (context, program) => match(mapValues(CRT_UNIFORM_NAMES, (name) => context.getUniformLocation(program, name) ?? void 0)).with({
+	frame: nonNullable$9,
+	frameSize: nonNullable$9,
+	canvasSize: nonNullable$9,
+	pixelSize: nonNullable$9,
+	time: nonNullable$9
+}, (uniforms) => uniforms).otherwise(() => void 0);
+// libs/engine/src/crt/internal/format-glsl-float.ts
+const GLSL_FLOAT_DIGITS = 4;
+const formatGlslFloat = (value) => value.toFixed(GLSL_FLOAT_DIGITS);
+// libs/engine/src/crt/internal/fragment-shader-source.ts
+const FRAGMENT_SHADER_SOURCE = `
+#ifdef GL_FRAGMENT_PRECISION_HIGH
+precision highp float;
+#else
+precision mediump float;
+#endif
+
+uniform sampler2D ${CRT_UNIFORM_NAMES.frame};
+uniform vec2 ${CRT_UNIFORM_NAMES.frameSize};
+uniform vec2 ${CRT_UNIFORM_NAMES.canvasSize};
+uniform float ${CRT_UNIFORM_NAMES.pixelSize};
+uniform float ${CRT_UNIFORM_NAMES.time};
+
+const float GLOW_STRENGTH = ${formatGlslFloat(GLOW_STRENGTH)};
+const float GLOW_THRESHOLD = ${formatGlslFloat(GLOW_THRESHOLD)};
+const int GLOW_REACH = 2;
+const float SCANLINE_DEPTH = ${formatGlslFloat(SCANLINE_DEPTH)};
+const float GRAIN_AMOUNT = ${formatGlslFloat(GRAIN_AMOUNT)};
+const float GRAIN_RATE = ${formatGlslFloat(24)};
+const float SURFACE_AMOUNT = ${formatGlslFloat(SURFACE_AMOUNT)};
+const float SURFACE_SCALE = ${formatGlslFloat(3)};
+const vec3 LUMINANCE = vec3(0.299, 0.587, 0.114);
+
+vec4 sampleFrame(vec2 position) {
+  vec2 logical = floor(position / ${CRT_UNIFORM_NAMES.pixelSize});
+
+  if (logical.x < 0.0 || logical.y < 0.0
+      || logical.x >= ${CRT_UNIFORM_NAMES.frameSize}.x
+      || logical.y >= ${CRT_UNIFORM_NAMES.frameSize}.y) {
+    return vec4(0.0);
+  }
+
+  return texture2D(
+    ${CRT_UNIFORM_NAMES.frame},
+    (logical + 0.5) / ${CRT_UNIFORM_NAMES.frameSize}
+  );
+}
+
+float hash(vec2 point) {
+  vec3 mixed = fract(vec3(point.xyx) * 0.1031);
+  mixed += dot(mixed, mixed.yzx + 33.33);
+  return fract((mixed.x + mixed.y) * mixed.z);
+}
+
+float valueNoise(vec2 point) {
+  vec2 cell = floor(point);
+  vec2 blend = fract(point);
+  blend = blend * blend * (3.0 - 2.0 * blend);
+
+  return mix(
+    mix(hash(cell), hash(cell + vec2(1.0, 0.0)), blend.x),
+    mix(hash(cell + vec2(0.0, 1.0)), hash(cell + vec2(1.0, 1.0)), blend.x),
+    blend.y
+  );
+}
+
+vec3 computeBright(vec3 color) {
+  return color * smoothstep(GLOW_THRESHOLD, 1.0, dot(color, LUMINANCE));
+}
+
+vec3 computeGlow(vec2 position, vec3 base) {
+  vec3 glow = vec3(0.0);
+  float total = 0.0;
+
+  for (int row = -GLOW_REACH; row <= GLOW_REACH; row++) {
+    for (int column = -GLOW_REACH; column <= GLOW_REACH; column++) {
+      vec2 offset = vec2(float(column), float(row));
+      float reach = length(offset);
+
+      if (reach > float(GLOW_REACH)) {
+        continue;
+      }
+
+      float weight = 1.0 - reach / (float(GLOW_REACH) + 1.0);
+
+      glow += computeBright(sampleFrame(position + offset).rgb) * weight;
+      total += weight;
+    }
+  }
+
+  return max(glow / total - computeBright(base), 0.0);
+}
+
+float computeScanline(vec2 position) {
+  float period = max(${CRT_UNIFORM_NAMES.pixelSize}, 2.0);
+  float phase = (mod(floor(position.y), period) + 0.5) / period;
+
+  return 1.0 - SCANLINE_DEPTH * smoothstep(0.4, 1.0, phase);
+}
+
+float computeGrain(vec2 position) {
+  float grainFrame = floor(${CRT_UNIFORM_NAMES.time} * GRAIN_RATE / 1000.0);
+  vec2 shift = fract(vec2(grainFrame * 0.6180339, grainFrame * 0.3819660))
+    * 1024.0;
+
+  return (hash(position + shift) - 0.5) * GRAIN_AMOUNT;
+}
+
+float computeSurface(vec2 position) {
+  return (valueNoise(position / SURFACE_SCALE) - 0.5) * SURFACE_AMOUNT;
+}
+
+void main() {
+  vec2 position = vec2(
+    gl_FragCoord.x,
+    ${CRT_UNIFORM_NAMES.canvasSize}.y - gl_FragCoord.y
+  );
+  vec4 base = sampleFrame(position);
+  vec3 color = (base.rgb + computeGlow(position, base.rgb) * GLOW_STRENGTH)
+    * computeScanline(position)
+    * (1.0 + computeSurface(position))
+    + computeGrain(position) * base.a;
+
+  color = clamp(color, 0.0, 1.0);
+
+  gl_FragColor = vec4(color, max(base.a, max(color.r, max(color.g, color.b))));
+}
+`;
+// libs/engine/src/crt/internal/try-create-shader.ts
+const { nonNullable: nonNullable$8 } = P;
+const tryCompileShader = (context, shader, source) => pipe(shader, (created) => runEffect(created, (target) => context.shaderSource(target, source)), (sourced) => runEffect(sourced, (target) => context.compileShader(target)), (compiled) => match(context.getShaderParameter(compiled, context.COMPILE_STATUS)).with(true, () => compiled).otherwise(() => void 0));
+const tryCreateShader = (context, type, source) => match(context.createShader(type)).with(nonNullable$8, (shader) => tryCompileShader(context, shader, source)).otherwise(() => void 0);
+// libs/engine/src/crt/internal/try-link-program.ts
+const tryLinkProgram = (context, program, vertexShader, fragmentShader) => pipe(program, (created) => runEffect(created, (target) => context.attachShader(target, vertexShader)), (attached) => runEffect(attached, (target) => context.attachShader(target, fragmentShader)), (attached) => runEffect(attached, (target) => context.bindAttribLocation(target, 0, POSITION_ATTRIBUTE)), (bound) => runEffect(bound, (target) => context.linkProgram(target)), (linked) => match(context.getProgramParameter(linked, context.LINK_STATUS)).with(true, () => linked).otherwise(() => void 0));
+// libs/engine/src/crt/internal/vertex-shader-source.ts
+const VERTEX_SHADER_SOURCE = `
+attribute vec2 ${POSITION_ATTRIBUTE};
+
+void main() {
+  gl_Position = vec4(${POSITION_ATTRIBUTE}, 0.0, 1.0);
+}
+`;
+// libs/engine/src/crt/internal/try-create-program.ts
+const { nonNullable: nonNullable$7 } = P;
+const tryCreateProgram = (context) => match({
+	program: context.createProgram(),
+	vertexShader: tryCreateShader(context, context.VERTEX_SHADER, VERTEX_SHADER_SOURCE),
+	fragmentShader: tryCreateShader(context, context.FRAGMENT_SHADER, FRAGMENT_SHADER_SOURCE)
+}).with({
+	program: nonNullable$7,
+	vertexShader: nonNullable$7,
+	fragmentShader: nonNullable$7
+}, ({ program, vertexShader, fragmentShader }) => tryLinkProgram(context, program, vertexShader, fragmentShader)).otherwise(() => void 0);
+// libs/engine/src/crt/internal/try-create-texture.ts
+const { nonNullable: nonNullable$6 } = P;
+const patchTextureSampling = (context, texture) => pipe(texture, (created) => runEffect(created, (target) => context.bindTexture(context.TEXTURE_2D, target)), (bound) => runEffect(bound, () => context.texParameteri(context.TEXTURE_2D, context.TEXTURE_MIN_FILTER, context.NEAREST)), (bound) => runEffect(bound, () => context.texParameteri(context.TEXTURE_2D, context.TEXTURE_MAG_FILTER, context.NEAREST)), (bound) => runEffect(bound, () => context.texParameteri(context.TEXTURE_2D, context.TEXTURE_WRAP_S, context.CLAMP_TO_EDGE)), (bound) => runEffect(bound, () => context.texParameteri(context.TEXTURE_2D, context.TEXTURE_WRAP_T, context.CLAMP_TO_EDGE)));
+const tryCreateTexture = (context) => match(context.createTexture()).with(nonNullable$6, (texture) => patchTextureSampling(context, texture)).otherwise(() => void 0);
+// libs/engine/src/crt/internal/try-create-vertices.ts
+const { nonNullable: nonNullable$5 } = P;
+const patchVertices = (context, vertices) => pipe(vertices, (created) => runEffect(created, (target) => context.bindBuffer(context.ARRAY_BUFFER, target)), (bound) => runEffect(bound, () => context.bufferData(context.ARRAY_BUFFER, new Float32Array(FULL_SCREEN_TRIANGLE), context.STATIC_DRAW)));
+const tryCreateVertices = (context) => match(context.createBuffer()).with(nonNullable$5, (vertices) => patchVertices(context, vertices)).otherwise(() => void 0);
+// libs/engine/src/crt/try-create-crt.ts
+const { nonNullable: nonNullable$4 } = P;
+const createCrtDraft = (context, program) => ({
+	program,
+	texture: tryCreateTexture(context),
+	vertices: tryCreateVertices(context),
+	uniforms: match(program).with(nonNullable$4, (linked) => findCrtUniforms(context, linked)).otherwise(() => void 0)
+});
+const tryToCrt = (draft) => match(draft).with({
+	program: nonNullable$4,
+	texture: nonNullable$4,
+	vertices: nonNullable$4,
+	uniforms: nonNullable$4
+}, (crt) => crt).otherwise(() => void 0);
+/**
+* Sets up the monitor effect on a WebGL context: the shader program, the
+* texture that holds the frame, and a triangle that covers the canvas.
+* Returns `undefined` if there is no context or any step fails.
+*/
+const tryCreateCrt = (context) => match(context).with(nonNullable$4, (ready) => tryToCrt(createCrtDraft(ready, tryCreateProgram(ready)))).otherwise(() => void 0);
+// libs/engine/src/palette/internal/compute-rgb-mix.ts
+const computeChannelMix = (channel, target, amount) => round(channel + (target - channel) * amount);
+const computeRgbMix = (color, target, amount) => ({
+	red: computeChannelMix(color.red, target.red, amount),
+	green: computeChannelMix(color.green, target.green, amount),
+	blue: computeChannelMix(color.blue, target.blue, amount)
+});
+// libs/engine/src/palette/internal/compute-extended-shade.ts
+const { number: number$1 } = P;
+const EXTENDED_BASE_SHADE = toExtendedShade(4);
+const DARKEN_STEP = 1 / 20;
+const LIGHTEN_STEP = 1 / 16;
+const computeExtendedShade = (base, extendedShade) => match(extendedShade).with(number$1.lt(EXTENDED_BASE_SHADE), (darker) => computeRgbMix(base, BLACK, (EXTENDED_BASE_SHADE - darker) * DARKEN_STEP)).with(number$1.gt(EXTENDED_BASE_SHADE), (lighter) => computeRgbMix(base, WHITE, (lighter - EXTENDED_BASE_SHADE) * LIGHTEN_STEP)).otherwise(() => base);
+// libs/engine/src/palette/internal/create-palette-entries.ts
+const createPaletteEntries = (base, color) => map(range(32), (extendedShade) => [toExtendedPixel(color, extendedShade), computeExtendedShade(base, extendedShade)]);
+// libs/engine/src/palette/internal/split-hex-rgb.ts
+const HEX_CHANNEL_PATTERN = /[\da-f]{2}/gi;
+const HEX_RADIX = 16;
+const splitHexRgb = (color) => pipe(words(color, HEX_CHANNEL_PATTERN), (channels) => map(channels, (channel) => parseInt(channel, HEX_RADIX)), ([red = 0, green = 0, blue = 0]) => ({
+	red,
+	green,
+	blue
+}));
+// libs/engine/src/palette/internal/to-rgb.ts
+const { string } = P;
+const HEX_COLOR_PATTERN = /^#[\da-f]{6}$/i;
+const toRgb = (color) => match(color).with(string.regex(HEX_COLOR_PATTERN), splitHexRgb).otherwise(() => BLACK);
+// libs/engine/src/palette/create-palette.ts
+/**
+* Expands the 16 base colors into 512 colors: 32 extended shades per color,
+* keyed by extended pixel.
+*
+* Sprite shade `s` is extended shade `4 * s + 1`. Shade `BASE_SHADE` is the
+* base color itself. Darker shades are mixed with black, lighter shades with
+* white. Only light reaches the extended shades between and beyond the
+* sprite shades. A color that is not in `#rrggbb` form is read as black.
+*/
+const createPalette = (colors) => pipe(map(colors, toRgb), (bases) => flatMap(bases, createPaletteEntries), (entries) => fromPairs(entries));
+// libs/engine/src/display/internal/compute-display-size.ts
+const computeDisplaySize = (canvas, pixelSize) => ({
+	width: floor(canvas.width / pixelSize),
+	height: floor(canvas.height / pixelSize)
+});
+// libs/engine/src/display/internal/try-to-display.ts
+const { nonNullable: nonNullable$3, number } = P;
+const POSITIVE_INTEGER = number.int().positive();
+const tryToDisplay = (draft) => match(draft).with({
+	context: nonNullable$3,
+	crt: nonNullable$3,
+	pixelSize: POSITIVE_INTEGER,
+	spriteSize: POSITIVE_INTEGER,
+	width: POSITIVE_INTEGER,
+	height: POSITIVE_INTEGER
+}, (display) => display).otherwise(() => void 0);
+// libs/engine/src/display/try-create-display.ts
+/**
+* Creates a display on the canvas.
+*
+* - `colors`: the 16 base colors.
+* - `pixelSize`: the width and height of one logical pixel, in canvas pixels.
+* - `spriteSize`: the width and height of every sprite, in logical pixels.
+*
+* The screen size in logical pixels is the canvas size divided by
+* `pixelSize`. The display draws with WebGL, and the monitor effect is
+* always on.
+*
+* Returns `undefined` if the canvas has no WebGL context, the monitor effect
+* cannot be set up, a size is not a positive whole number, or the canvas is
+* smaller than one logical pixel.
+*/
+const tryCreateDisplay = (canvas, { colors, pixelSize, spriteSize }) => pipe({
+	context: canvas.getContext("webgl", CRT_CONTEXT_ATTRIBUTES) ?? void 0,
+	size: computeDisplaySize(canvas, pixelSize)
+}, ({ context, size }) => ({
+	context,
+	crt: tryCreateCrt(context),
+	palette: createPalette(colors),
+	pixelSize,
+	spriteSize,
+	width: size.width,
+	height: size.height
+}), tryToDisplay);
+// libs/engine/src/palette/to-lit-pixel.ts
+const { nonNullable: nonNullable$2 } = P;
+/**
+* Returns the extended pixel that a pixel shows under light. The color stays
+* the same. The shade moves `shadeOffset` extended shades up or down
+* (4 extended shades = 1 sprite shade). The result is rounded and stops at
+* the darkest and lightest extended shade. `toLitPixel(pixel, 0)` returns
+* the authored color. Returns `TRANSPARENT` for `TRANSPARENT` and for any
+* value that is not a pixel.
+*/
+const toLitPixel = (pixel, shadeOffset) => match(SHADE_RAMPS[pixel]).with(nonNullable$2, ({ pixels, extendedShade }) => pixels[clamp(round(extendedShade + shadeOffset), 0, 31)] ?? -1).otherwise(() => -1);
+// libs/engine/src/screen/internal/filter-other-lights.ts
+const filterOtherLights = (lights, id) => filter(lights, (light) => light.id !== id);
+// libs/engine/src/screen/add-light.ts
+/**
+* Adds a light to the screen. If a light with the same id exists, it is
+* replaced. Returns a new screen.
+*/
+const addLight = (screen, id, { row, column, radius, intensity }) => ({
+	...screen,
+	lights: [...filterOtherLights(screen.lights, id), {
+		id,
+		row,
+		column,
+		radius,
+		intensity
+	}]
+});
+// libs/engine/src/screen/internal/filter-other-sprites.ts
+const filterOtherSprites = (sprites, id) => filter(sprites, (placement) => placement.id !== id);
+// libs/engine/src/screen/add-sprite.ts
+/**
+* Adds a sprite on top of the other sprites. `row` and `column` set its
+* top-left pixel. If a sprite with the same id exists, it is removed first.
+* The new sprite does not cast a shadow; to change that, call
+* `patchSprite(screen, id, { castsShadow: true })`. Returns a new screen.
+*/
+const addSprite = (screen, id, sprite, row, column) => ({
+	...screen,
+	sprites: [...filterOtherSprites(screen.sprites, id), {
+		id,
+		sprite,
+		row,
+		column,
+		castsShadow: false
+	}]
+});
+// libs/engine/src/screen/create-screen.ts
+/**
+* Creates an empty screen, with no sprites and no lights, filled with
+* `background`. `ambient` shifts every pixel by that many extended shades
+* (4 extended shades = 1 sprite shade). For example, a night scene could
+* use -16.
+*/
+const createScreen = (background = -1, ambient = 0) => ({
+	background,
+	ambient,
+	sprites: [],
+	lights: []
+});
+// libs/engine/src/screen/find-light.ts
+/** Returns the light with the id, or `undefined` if there is none. */
+const findLight = (screen, id) => find(screen.lights, (light) => light.id === id);
+// libs/engine/src/screen/find-sprite.ts
+/** Returns the sprite with the id, or `undefined` if there is none. */
+const findSprite = (screen, id) => find(screen.sprites, (placement) => placement.id === id);
+// libs/engine/src/screen/patch-ambient.ts
+/**
+* Sets the ambient light: how many extended shades every pixel moves up
+* (positive) or down (negative) before lights are added. Change it over time
+* to fade between day and night. Returns a new screen.
+*/
+const patchAmbient = (screen, ambient) => ({
+	...screen,
+	ambient
+});
+// libs/engine/src/screen/internal/patch-matching-light.ts
+const patchMatchingLight = (light, id, changes) => match(light.id === id).with(true, () => ({
+	id,
+	row: changes.row ?? light.row,
+	column: changes.column ?? light.column,
+	radius: changes.radius ?? light.radius,
+	intensity: changes.intensity ?? light.intensity
+})).otherwise(() => light);
+// libs/engine/src/screen/patch-light.ts
+/**
+* Changes a light's `row`, `column`, `radius` or `intensity`. Fields you
+* leave out keep their values. Returns a new screen. If no light has the id,
+* nothing changes.
+*/
+const patchLight = (screen, id, changes) => ({
+	...screen,
+	lights: map(screen.lights, (light) => patchMatchingLight(light, id, changes))
+});
+// libs/engine/src/screen/patch-light-by-offset.ts
+const { nonNullable: nonNullable$1 } = P;
+/**
+* Moves a light `rowOffset` pixels down and `columnOffset` pixels right.
+* Negative values move it up and left. Returns a new screen. If no light has
+* the id, nothing changes.
+*/
+const patchLightByOffset = (screen, id, rowOffset, columnOffset) => match(findLight(screen, id)).with(nonNullable$1, ({ row, column }) => patchLight(screen, id, {
+	row: row + rowOffset,
+	column: column + columnOffset
+})).otherwise(() => screen);
+// libs/engine/src/screen/internal/patch-sprite-placement.ts
+const patchSpritePlacement = (placement, id, changes) => match(placement.id === id).with(true, () => ({
+	id,
+	sprite: changes.sprite ?? placement.sprite,
+	row: changes.row ?? placement.row,
+	column: changes.column ?? placement.column,
+	castsShadow: changes.castsShadow ?? placement.castsShadow
+})).otherwise(() => placement);
+// libs/engine/src/screen/patch-sprite.ts
+/**
+* Changes a sprite's `sprite` (for animation), `row`, `column` or
+* `castsShadow`. Fields you leave out keep their values. The sprite keeps its
+* place in the drawing order. Returns a new screen. If no sprite has the id,
+* nothing changes.
+*/
+const patchSprite = (screen, id, changes) => ({
+	...screen,
+	sprites: map(screen.sprites, (placement) => patchSpritePlacement(placement, id, changes))
+});
+// libs/engine/src/screen/patch-sprite-by-offset.ts
+const { nonNullable } = P;
+/**
+* Moves a sprite `rowOffset` pixels down and `columnOffset` pixels right.
+* Negative values move it up and left. Returns a new screen. If no sprite
+* has the id, nothing changes.
+*/
+const patchSpriteByOffset = (screen, id, rowOffset, columnOffset) => match(findSprite(screen, id)).with(nonNullable, ({ row, column }) => patchSprite(screen, id, {
+	row: row + rowOffset,
+	column: column + columnOffset
+})).otherwise(() => screen);
+// libs/engine/src/screen/remove-light.ts
+/** Removes the light with the id. Returns a new screen. */
+const removeLight = (screen, id) => ({
+	...screen,
+	lights: filterOtherLights(screen.lights, id)
+});
+// libs/engine/src/screen/remove-sprite.ts
+/** Removes the sprite with the id. Returns a new screen. */
+const removeSprite = (screen, id) => ({
+	...screen,
+	sprites: filterOtherSprites(screen.sprites, id)
+});
+// libs/engine/src/screen/to-sprite.ts
+/**
+* Builds a sprite from text art: one string per row, one character per
+* pixel. Each character is looked up in `legend`. Characters that are not in
+* the legend become transparent.
+*/
+const toSprite = (rows, legend) => flatMap(rows, (row) => map(split(row, ""), (symbol) => legend[symbol] ?? -1));
+export { BASE_SHADE, COLOR_COUNT, EXTENDED_SHADES_PER_SHADE, EXTENDED_SHADE_COUNT, SHADE_COUNT, TRANSPARENT, addLight, addSprite, computeFrame, createPalette, createScreen, drawScreen, findLight, findSprite, isPixel, patchAmbient, patchLight, patchLightByOffset, patchSprite, patchSpriteByOffset, removeLight, removeSprite, toExtendedPixel, toLitPixel, toPixel, toSprite, tryCreateDisplay };
+
+//# sourceMappingURL=index.js.map