interactive-bg 0.0.0-stage → 0.1.0

package/dist/styles/topo/contours.cjs

@@ -0,0 +1,83 @@
+// src/styles/topo/contours.ts
+/**
+* Marching squares over a regular grid of samples.
+*
+* `field` holds `cols * rows` samples in row-major order, spaced `cellSize`
+* apart. Contour lines are traced at every multiple of `step`; each segment is
+* passed to `emit` together with its integer level index (threshold / step).
+*/
+function traceContours(field, cols, rows, cellSize, step, emit) {
+	if (step <= 0) return;
+	for (let j = 0; j < rows - 1; j++) {
+		const y0 = j * cellSize;
+		const y1 = y0 + cellSize;
+		for (let i = 0; i < cols - 1; i++) {
+			const idx = j * cols + i;
+			const a = field[idx];
+			const b = field[idx + 1];
+			const c = field[idx + cols + 1];
+			const d = field[idx + cols];
+			const min = Math.min(a, b, c, d);
+			const max = Math.max(a, b, c, d);
+			const first = Math.ceil(min / step);
+			const last = Math.floor(max / step);
+			if (first > last) continue;
+			const x0 = i * cellSize;
+			const x1 = x0 + cellSize;
+			for (let level = first; level <= last; level++) {
+				const t = level * step;
+				const code = (a >= t ? 8 : 0) | (b >= t ? 4 : 0) | (c >= t ? 2 : 0) | (d >= t ? 1 : 0);
+				if (code === 0 || code === 15) continue;
+				const topX = x0 + cellSize * frac(t, a, b);
+				const rightY = y0 + cellSize * frac(t, b, c);
+				const bottomX = x0 + cellSize * frac(t, d, c);
+				const leftY = y0 + cellSize * frac(t, a, d);
+				switch (code) {
+					case 1:
+					case 14:
+						emit(x0, leftY, bottomX, y1, level);
+						break;
+					case 2:
+					case 13:
+						emit(bottomX, y1, x1, rightY, level);
+						break;
+					case 3:
+					case 12:
+						emit(x0, leftY, x1, rightY, level);
+						break;
+					case 4:
+					case 11:
+						emit(topX, y0, x1, rightY, level);
+						break;
+					case 6:
+					case 9:
+						emit(topX, y0, bottomX, y1, level);
+						break;
+					case 7:
+					case 8:
+						emit(x0, leftY, topX, y0, level);
+						break;
+					case 5:
+					case 10: {
+						const centreAbove = (a + b + c + d) / 4 >= t;
+						if (code === 5 === centreAbove) {
+							emit(x0, leftY, topX, y0, level);
+							emit(bottomX, y1, x1, rightY, level);
+						} else {
+							emit(topX, y0, x1, rightY, level);
+							emit(x0, leftY, bottomX, y1, level);
+						}
+						break;
+					}
+				}
+			}
+		}
+	}
+}
+function frac(t, from, to) {
+	const d = to - from;
+	return d === 0 ? .5 : (t - from) / d;
+}
+exports.traceContours = traceContours;
+
+//# sourceMappingURL=contours.cjs.map

package/dist/styles/topo/contours.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contours.cjs","names":[],"sources":["../../../src/styles/topo/contours.ts"],"sourcesContent":["export type SegmentSink = (\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number,\n  level: number,\n) => void;\n\n/**\n * Marching squares over a regular grid of samples.\n *\n * `field` holds `cols * rows` samples in row-major order, spaced `cellSize`\n * apart. Contour lines are traced at every multiple of `step`; each segment is\n * passed to `emit` together with its integer level index (threshold / step).\n */\nexport function traceContours(\n  field: ArrayLike<number>,\n  cols: number,\n  rows: number,\n  cellSize: number,\n  step: number,\n  emit: SegmentSink,\n): void {\n  if (step <= 0) return;\n\n  for (let j = 0; j < rows - 1; j++) {\n    const y0 = j * cellSize;\n    const y1 = y0 + cellSize;\n    for (let i = 0; i < cols - 1; i++) {\n      const idx = j * cols + i;\n      // a ── b\n      // │    │\n      // d ── c\n      const a = field[idx];\n      const b = field[idx + 1];\n      const c = field[idx + cols + 1];\n      const d = field[idx + cols];\n\n      const min = Math.min(a, b, c, d);\n      const max = Math.max(a, b, c, d);\n      const first = Math.ceil(min / step);\n      const last = Math.floor(max / step);\n      if (first > last) continue;\n\n      const x0 = i * cellSize;\n      const x1 = x0 + cellSize;\n\n      for (let level = first; level <= last; level++) {\n        const t = level * step;\n        const code =\n          (a >= t ? 8 : 0) | (b >= t ? 4 : 0) | (c >= t ? 2 : 0) | (d >= t ? 1 : 0);\n        if (code === 0 || code === 15) continue;\n\n        // Crossing points on each edge (only valid when that edge is crossed).\n        const topX = x0 + cellSize * frac(t, a, b);\n        const rightY = y0 + cellSize * frac(t, b, c);\n        const bottomX = x0 + cellSize * frac(t, d, c);\n        const leftY = y0 + cellSize * frac(t, a, d);\n\n        switch (code) {\n          case 1:\n          case 14:\n            emit(x0, leftY, bottomX, y1, level);\n            break;\n          case 2:\n          case 13:\n            emit(bottomX, y1, x1, rightY, level);\n            break;\n          case 3:\n          case 12:\n            emit(x0, leftY, x1, rightY, level);\n            break;\n          case 4:\n          case 11:\n            emit(topX, y0, x1, rightY, level);\n            break;\n          case 6:\n          case 9:\n            emit(topX, y0, bottomX, y1, level);\n            break;\n          case 7:\n          case 8:\n            emit(x0, leftY, topX, y0, level);\n            break;\n          case 5:\n          case 10: {\n            // Saddle: disambiguate with the cell centre.\n            const centreAbove = (a + b + c + d) / 4 >= t;\n            const isolateAC = (code === 5) === centreAbove;\n            if (isolateAC) {\n              emit(x0, leftY, topX, y0, level);\n              emit(bottomX, y1, x1, rightY, level);\n            } else {\n              emit(topX, y0, x1, rightY, level);\n              emit(x0, leftY, bottomX, y1, level);\n            }\n            break;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction frac(t: number, from: number, to: number): number {\n  const d = to - from;\n  return d === 0 ? 0.5 : (t - from) / d;\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,cACd,OACA,MACA,MACA,UACA,MACA,MACM;CACN,IAAI,QAAQ,GAAG;CAEf,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK;EACjC,MAAM,KAAK,IAAI;EACf,MAAM,KAAK,KAAK;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK;GACjC,MAAM,MAAM,IAAI,OAAO;GAIvB,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI,MAAM,MAAM;GACtB,MAAM,IAAI,MAAM,MAAM,OAAO;GAC7B,MAAM,IAAI,MAAM,MAAM;GAEtB,MAAM,MAAM,KAAK,IAAI,GAAG,GAAG,GAAG,CAAC;GAC/B,MAAM,MAAM,KAAK,IAAI,GAAG,GAAG,GAAG,CAAC;GAC/B,MAAM,QAAQ,KAAK,KAAK,MAAM,IAAI;GAClC,MAAM,OAAO,KAAK,MAAM,MAAM,IAAI;GAClC,IAAI,QAAQ,MAAM;GAElB,MAAM,KAAK,IAAI;GACf,MAAM,KAAK,KAAK;GAEhB,KAAK,IAAI,QAAQ,OAAO,SAAS,MAAM,SAAS;IAC9C,MAAM,IAAI,QAAQ;IAClB,MAAM,QACH,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI;IACzE,IAAI,SAAS,KAAK,SAAS,IAAI;IAG/B,MAAM,OAAO,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IACzC,MAAM,SAAS,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAC3C,MAAM,UAAU,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAC5C,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAE1C,QAAQ,MAAR;KACE,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,SAAS,IAAI,KAAK;MAClC;KACF,KAAK;KACL,KAAK;MACH,KAAK,SAAS,IAAI,IAAI,QAAQ,KAAK;MACnC;KACF,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,IAAI,QAAQ,KAAK;MACjC;KACF,KAAK;KACL,KAAK;MACH,KAAK,MAAM,IAAI,IAAI,QAAQ,KAAK;MAChC;KACF,KAAK;KACL,KAAK;MACH,KAAK,MAAM,IAAI,SAAS,IAAI,KAAK;MACjC;KACF,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,MAAM,IAAI,KAAK;MAC/B;KACF,KAAK;KACL,KAAK,IAAI;MAEP,MAAM,eAAe,IAAI,IAAI,IAAI,KAAK,KAAK;MAE3C,IADmB,SAAS,MAAO,aACpB;OACb,KAAK,IAAI,OAAO,MAAM,IAAI,KAAK;OAC/B,KAAK,SAAS,IAAI,IAAI,QAAQ,KAAK;MACrC,OAAO;OACL,KAAK,MAAM,IAAI,IAAI,QAAQ,KAAK;OAChC,KAAK,IAAI,OAAO,SAAS,IAAI,KAAK;MACpC;MACA;KACF;IACF;GACF;EACF;CACF;AACF;AAEA,SAAS,KAAK,GAAW,MAAc,IAAoB;CACzD,MAAM,IAAI,KAAK;CACf,OAAO,MAAM,IAAI,MAAO,IAAI,QAAQ;AACtC"}

package/dist/styles/topo/contours.d.cts

@@ -0,0 +1,9 @@
+export type SegmentSink = (x1: number, y1: number, x2: number, y2: number, level: number) => void;
+/**
+ * Marching squares over a regular grid of samples.
+ *
+ * `field` holds `cols * rows` samples in row-major order, spaced `cellSize`
+ * apart. Contour lines are traced at every multiple of `step`; each segment is
+ * passed to `emit` together with its integer level index (threshold / step).
+ */
+export declare function traceContours(field: ArrayLike<number>, cols: number, rows: number, cellSize: number, step: number, emit: SegmentSink): void;

package/dist/styles/topo/contours.d.ts

@@ -0,0 +1,9 @@
+export type SegmentSink = (x1: number, y1: number, x2: number, y2: number, level: number) => void;
+/**
+ * Marching squares over a regular grid of samples.
+ *
+ * `field` holds `cols * rows` samples in row-major order, spaced `cellSize`
+ * apart. Contour lines are traced at every multiple of `step`; each segment is
+ * passed to `emit` together with its integer level index (threshold / step).
+ */
+export declare function traceContours(field: ArrayLike<number>, cols: number, rows: number, cellSize: number, step: number, emit: SegmentSink): void;

package/dist/styles/topo/contours.js

@@ -0,0 +1,83 @@
+// src/styles/topo/contours.ts
+/**
+* Marching squares over a regular grid of samples.
+*
+* `field` holds `cols * rows` samples in row-major order, spaced `cellSize`
+* apart. Contour lines are traced at every multiple of `step`; each segment is
+* passed to `emit` together with its integer level index (threshold / step).
+*/
+function traceContours(field, cols, rows, cellSize, step, emit) {
+	if (step <= 0) return;
+	for (let j = 0; j < rows - 1; j++) {
+		const y0 = j * cellSize;
+		const y1 = y0 + cellSize;
+		for (let i = 0; i < cols - 1; i++) {
+			const idx = j * cols + i;
+			const a = field[idx];
+			const b = field[idx + 1];
+			const c = field[idx + cols + 1];
+			const d = field[idx + cols];
+			const min = Math.min(a, b, c, d);
+			const max = Math.max(a, b, c, d);
+			const first = Math.ceil(min / step);
+			const last = Math.floor(max / step);
+			if (first > last) continue;
+			const x0 = i * cellSize;
+			const x1 = x0 + cellSize;
+			for (let level = first; level <= last; level++) {
+				const t = level * step;
+				const code = (a >= t ? 8 : 0) | (b >= t ? 4 : 0) | (c >= t ? 2 : 0) | (d >= t ? 1 : 0);
+				if (code === 0 || code === 15) continue;
+				const topX = x0 + cellSize * frac(t, a, b);
+				const rightY = y0 + cellSize * frac(t, b, c);
+				const bottomX = x0 + cellSize * frac(t, d, c);
+				const leftY = y0 + cellSize * frac(t, a, d);
+				switch (code) {
+					case 1:
+					case 14:
+						emit(x0, leftY, bottomX, y1, level);
+						break;
+					case 2:
+					case 13:
+						emit(bottomX, y1, x1, rightY, level);
+						break;
+					case 3:
+					case 12:
+						emit(x0, leftY, x1, rightY, level);
+						break;
+					case 4:
+					case 11:
+						emit(topX, y0, x1, rightY, level);
+						break;
+					case 6:
+					case 9:
+						emit(topX, y0, bottomX, y1, level);
+						break;
+					case 7:
+					case 8:
+						emit(x0, leftY, topX, y0, level);
+						break;
+					case 5:
+					case 10: {
+						const centreAbove = (a + b + c + d) / 4 >= t;
+						if (code === 5 === centreAbove) {
+							emit(x0, leftY, topX, y0, level);
+							emit(bottomX, y1, x1, rightY, level);
+						} else {
+							emit(topX, y0, x1, rightY, level);
+							emit(x0, leftY, bottomX, y1, level);
+						}
+						break;
+					}
+				}
+			}
+		}
+	}
+}
+function frac(t, from, to) {
+	const d = to - from;
+	return d === 0 ? .5 : (t - from) / d;
+}
+export { traceContours };
+
+//# sourceMappingURL=contours.js.map

package/dist/styles/topo/contours.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contours.js","names":[],"sources":["../../../src/styles/topo/contours.ts"],"sourcesContent":["export type SegmentSink = (\n  x1: number,\n  y1: number,\n  x2: number,\n  y2: number,\n  level: number,\n) => void;\n\n/**\n * Marching squares over a regular grid of samples.\n *\n * `field` holds `cols * rows` samples in row-major order, spaced `cellSize`\n * apart. Contour lines are traced at every multiple of `step`; each segment is\n * passed to `emit` together with its integer level index (threshold / step).\n */\nexport function traceContours(\n  field: ArrayLike<number>,\n  cols: number,\n  rows: number,\n  cellSize: number,\n  step: number,\n  emit: SegmentSink,\n): void {\n  if (step <= 0) return;\n\n  for (let j = 0; j < rows - 1; j++) {\n    const y0 = j * cellSize;\n    const y1 = y0 + cellSize;\n    for (let i = 0; i < cols - 1; i++) {\n      const idx = j * cols + i;\n      // a ── b\n      // │    │\n      // d ── c\n      const a = field[idx];\n      const b = field[idx + 1];\n      const c = field[idx + cols + 1];\n      const d = field[idx + cols];\n\n      const min = Math.min(a, b, c, d);\n      const max = Math.max(a, b, c, d);\n      const first = Math.ceil(min / step);\n      const last = Math.floor(max / step);\n      if (first > last) continue;\n\n      const x0 = i * cellSize;\n      const x1 = x0 + cellSize;\n\n      for (let level = first; level <= last; level++) {\n        const t = level * step;\n        const code =\n          (a >= t ? 8 : 0) | (b >= t ? 4 : 0) | (c >= t ? 2 : 0) | (d >= t ? 1 : 0);\n        if (code === 0 || code === 15) continue;\n\n        // Crossing points on each edge (only valid when that edge is crossed).\n        const topX = x0 + cellSize * frac(t, a, b);\n        const rightY = y0 + cellSize * frac(t, b, c);\n        const bottomX = x0 + cellSize * frac(t, d, c);\n        const leftY = y0 + cellSize * frac(t, a, d);\n\n        switch (code) {\n          case 1:\n          case 14:\n            emit(x0, leftY, bottomX, y1, level);\n            break;\n          case 2:\n          case 13:\n            emit(bottomX, y1, x1, rightY, level);\n            break;\n          case 3:\n          case 12:\n            emit(x0, leftY, x1, rightY, level);\n            break;\n          case 4:\n          case 11:\n            emit(topX, y0, x1, rightY, level);\n            break;\n          case 6:\n          case 9:\n            emit(topX, y0, bottomX, y1, level);\n            break;\n          case 7:\n          case 8:\n            emit(x0, leftY, topX, y0, level);\n            break;\n          case 5:\n          case 10: {\n            // Saddle: disambiguate with the cell centre.\n            const centreAbove = (a + b + c + d) / 4 >= t;\n            const isolateAC = (code === 5) === centreAbove;\n            if (isolateAC) {\n              emit(x0, leftY, topX, y0, level);\n              emit(bottomX, y1, x1, rightY, level);\n            } else {\n              emit(topX, y0, x1, rightY, level);\n              emit(x0, leftY, bottomX, y1, level);\n            }\n            break;\n          }\n        }\n      }\n    }\n  }\n}\n\nfunction frac(t: number, from: number, to: number): number {\n  const d = to - from;\n  return d === 0 ? 0.5 : (t - from) / d;\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,cACd,OACA,MACA,MACA,UACA,MACA,MACM;CACN,IAAI,QAAQ,GAAG;CAEf,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK;EACjC,MAAM,KAAK,IAAI;EACf,MAAM,KAAK,KAAK;EAChB,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,GAAG,KAAK;GACjC,MAAM,MAAM,IAAI,OAAO;GAIvB,MAAM,IAAI,MAAM;GAChB,MAAM,IAAI,MAAM,MAAM;GACtB,MAAM,IAAI,MAAM,MAAM,OAAO;GAC7B,MAAM,IAAI,MAAM,MAAM;GAEtB,MAAM,MAAM,KAAK,IAAI,GAAG,GAAG,GAAG,CAAC;GAC/B,MAAM,MAAM,KAAK,IAAI,GAAG,GAAG,GAAG,CAAC;GAC/B,MAAM,QAAQ,KAAK,KAAK,MAAM,IAAI;GAClC,MAAM,OAAO,KAAK,MAAM,MAAM,IAAI;GAClC,IAAI,QAAQ,MAAM;GAElB,MAAM,KAAK,IAAI;GACf,MAAM,KAAK,KAAK;GAEhB,KAAK,IAAI,QAAQ,OAAO,SAAS,MAAM,SAAS;IAC9C,MAAM,IAAI,QAAQ;IAClB,MAAM,QACH,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI,MAAM,KAAK,IAAI,IAAI;IACzE,IAAI,SAAS,KAAK,SAAS,IAAI;IAG/B,MAAM,OAAO,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IACzC,MAAM,SAAS,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAC3C,MAAM,UAAU,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAC5C,MAAM,QAAQ,KAAK,WAAW,KAAK,GAAG,GAAG,CAAC;IAE1C,QAAQ,MAAR;KACE,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,SAAS,IAAI,KAAK;MAClC;KACF,KAAK;KACL,KAAK;MACH,KAAK,SAAS,IAAI,IAAI,QAAQ,KAAK;MACnC;KACF,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,IAAI,QAAQ,KAAK;MACjC;KACF,KAAK;KACL,KAAK;MACH,KAAK,MAAM,IAAI,IAAI,QAAQ,KAAK;MAChC;KACF,KAAK;KACL,KAAK;MACH,KAAK,MAAM,IAAI,SAAS,IAAI,KAAK;MACjC;KACF,KAAK;KACL,KAAK;MACH,KAAK,IAAI,OAAO,MAAM,IAAI,KAAK;MAC/B;KACF,KAAK;KACL,KAAK,IAAI;MAEP,MAAM,eAAe,IAAI,IAAI,IAAI,KAAK,KAAK;MAE3C,IADmB,SAAS,MAAO,aACpB;OACb,KAAK,IAAI,OAAO,MAAM,IAAI,KAAK;OAC/B,KAAK,SAAS,IAAI,IAAI,QAAQ,KAAK;MACrC,OAAO;OACL,KAAK,MAAM,IAAI,IAAI,QAAQ,KAAK;OAChC,KAAK,IAAI,OAAO,SAAS,IAAI,KAAK;MACpC;MACA;KACF;IACF;GACF;EACF;CACF;AACF;AAEA,SAAS,KAAK,GAAW,MAAc,IAAoB;CACzD,MAAM,IAAI,KAAK;CACf,OAAO,MAAM,IAAI,MAAO,IAAI,QAAQ;AACtC"}

package/dist/styles/topo/definition.cjs

@@ -0,0 +1,13 @@
+// src/styles/topo/definition.ts
+/**
+* Animated topographic contour lines. The terrain drifts slowly and rises
+* (or, with a negative `pointerStrength`, sinks) under the pointer.
+*/
+var topoStyle = {
+	name: "topo",
+	defaults: require("./options.cjs").topoDefaults,
+	animates: (options) => options.speed !== 0
+};
+exports.topoStyle = topoStyle;
+
+//# sourceMappingURL=definition.cjs.map

package/dist/styles/topo/definition.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.cjs","names":["topoDefaults"],"sources":["../../../src/styles/topo/definition.ts"],"sourcesContent":["import type { StyleBase } from '../../core/style';\nimport { topoDefaults, type TopoOptions } from './options';\n\n/**\n * Animated topographic contour lines. The terrain drifts slowly and rises\n * (or, with a negative `pointerStrength`, sinks) under the pointer.\n */\nexport const topoStyle: StyleBase<TopoOptions> = {\n  name: 'topo',\n  defaults: topoDefaults,\n  animates: (options) => options.speed !== 0,\n};\n"],"mappings":";;;;;AAOA,IAAa,YAAoC;CAC/C,MAAM;CACN,U,uBAAUA,CAAAA,CAAAA;CACV,WAAW,YAAY,QAAQ,UAAU;AAC3C"}

package/dist/styles/topo/definition.d.cts

@@ -0,0 +1,7 @@
+import type { StyleBase } from '../../core/style.cjs';
+import { type TopoOptions } from './options.cjs';
+/**
+ * Animated topographic contour lines. The terrain drifts slowly and rises
+ * (or, with a negative `pointerStrength`, sinks) under the pointer.
+ */
+export declare const topoStyle: StyleBase<TopoOptions>;

package/dist/styles/topo/definition.d.ts

@@ -0,0 +1,7 @@
+import type { StyleBase } from '../../core/style.js';
+import { type TopoOptions } from './options.js';
+/**
+ * Animated topographic contour lines. The terrain drifts slowly and rises
+ * (or, with a negative `pointerStrength`, sinks) under the pointer.
+ */
+export declare const topoStyle: StyleBase<TopoOptions>;

package/dist/styles/topo/definition.js

@@ -0,0 +1,14 @@
+import { topoDefaults } from "./options.js";
+// src/styles/topo/definition.ts
+/**
+* Animated topographic contour lines. The terrain drifts slowly and rises
+* (or, with a negative `pointerStrength`, sinks) under the pointer.
+*/
+var topoStyle = {
+	name: "topo",
+	defaults: topoDefaults,
+	animates: (options) => options.speed !== 0
+};
+export { topoStyle };
+
+//# sourceMappingURL=definition.js.map

package/dist/styles/topo/definition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.js","names":[],"sources":["../../../src/styles/topo/definition.ts"],"sourcesContent":["import type { StyleBase } from '../../core/style';\nimport { topoDefaults, type TopoOptions } from './options';\n\n/**\n * Animated topographic contour lines. The terrain drifts slowly and rises\n * (or, with a negative `pointerStrength`, sinks) under the pointer.\n */\nexport const topoStyle: StyleBase<TopoOptions> = {\n  name: 'topo',\n  defaults: topoDefaults,\n  animates: (options) => options.speed !== 0,\n};\n"],"mappings":";;;;;;AAOA,IAAa,YAAoC;CAC/C,MAAM;CACN,UAAU;CACV,WAAW,YAAY,QAAQ,UAAU;AAC3C"}

package/dist/styles/topo/field.cjs

@@ -0,0 +1,118 @@
+const require_noise = require("../../shared/noise.cjs");
+// src/styles/topo/field.ts
+/** Noise-time distance between sampled keyframes; frames in between are blended. */
+var KEY_DT = .02;
+/**
+* The terrain height field, sampled on a grid `cellSize` pixels apart.
+*
+* Sampling noise for every grid point is the most expensive step, but the
+* terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart
+* (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.
+* The keyframe after B is built a few rows per frame to avoid spikes.
+*/
+function createKeyframeField(initial) {
+	let params = initial;
+	let noise = require_noise.createNoise3D(params.seed);
+	let norm = 2 - 2 ** (1 - params.octaves);
+	let width = 0;
+	let height = 0;
+	let cols = 0;
+	let rows = 0;
+	let keyA = /* @__PURE__ */ new Float32Array(0);
+	let keyB = /* @__PURE__ */ new Float32Array(0);
+	let keyNext = /* @__PURE__ */ new Float32Array(0);
+	let keyTime = 0;
+	let keyNextRows = 0;
+	let valid = false;
+	let version = 0;
+	function allocate() {
+		const nextCols = Math.ceil(width / params.cellSize) + 1;
+		const nextRows = Math.ceil(height / params.cellSize) + 1;
+		if (nextCols === cols && nextRows === rows) return;
+		cols = nextCols;
+		rows = nextRows;
+		keyA = new Float32Array(cols * rows);
+		keyB = new Float32Array(cols * rows);
+		keyNext = new Float32Array(cols * rows);
+		valid = false;
+	}
+	function sampleRows(target, t, fromRow, toRow) {
+		const { cellSize, octaves, scale } = params;
+		for (let j = fromRow; j < toRow; j++) {
+			const y = j * cellSize;
+			for (let i = 0; i < cols; i++) {
+				const x = i * cellSize;
+				let value = 0;
+				for (let o = 0, amp = 1, freq = scale; o < octaves; o++, amp *= .5, freq *= 2) value += amp * noise(x * freq, y * freq, t + o * 17.3);
+				target[j * cols + i] = value / norm;
+			}
+		}
+	}
+	return {
+		get cols() {
+			return cols;
+		},
+		get rows() {
+			return rows;
+		},
+		get keyA() {
+			return keyA;
+		},
+		get keyB() {
+			return keyB;
+		},
+		get version() {
+			return version;
+		},
+		configure(next) {
+			const prev = params;
+			if (next.seed === prev.seed && next.scale === prev.scale && next.octaves === prev.octaves && next.cellSize === prev.cellSize) return;
+			params = {
+				seed: next.seed,
+				scale: next.scale,
+				octaves: next.octaves,
+				cellSize: next.cellSize
+			};
+			if (next.seed !== prev.seed) noise = require_noise.createNoise3D(next.seed);
+			norm = 2 - 2 ** (1 - next.octaves);
+			allocate();
+			valid = false;
+		},
+		resize(nextWidth, nextHeight) {
+			width = nextWidth;
+			height = nextHeight;
+			allocate();
+		},
+		advance(time) {
+			if (!valid || time < keyTime || time >= keyTime + 2 * KEY_DT) {
+				keyTime = time;
+				sampleRows(keyA, keyTime, 0, rows);
+				sampleRows(keyB, keyTime + KEY_DT, 0, rows);
+				keyNextRows = 0;
+				valid = true;
+				version++;
+			}
+			if (time >= keyTime + KEY_DT) {
+				sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, rows);
+				[keyA, keyB, keyNext] = [
+					keyB,
+					keyNext,
+					keyA
+				];
+				keyTime += KEY_DT;
+				keyNextRows = 0;
+				version++;
+			}
+			const progress = (time - keyTime) / KEY_DT;
+			const wanted = Math.min(rows, Math.ceil(rows * progress / .8));
+			if (wanted > keyNextRows) {
+				sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, wanted);
+				keyNextRows = wanted;
+			}
+			return progress;
+		}
+	};
+}
+exports.createKeyframeField = createKeyframeField;
+
+//# sourceMappingURL=field.cjs.map

package/dist/styles/topo/field.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.cjs","names":["createNoise3D"],"sources":["../../../src/styles/topo/field.ts"],"sourcesContent":["import { createNoise3D, type Noise3D } from '../../shared/noise';\nimport type { ResolvedTopoOptions } from './options';\n\n/** Noise-time distance between sampled keyframes; frames in between are blended. */\nconst KEY_DT = 0.02;\n\nexport type FieldParams = Pick<ResolvedTopoOptions, 'seed' | 'scale' | 'octaves' | 'cellSize'>;\n\nexport interface KeyframeField {\n  readonly cols: number;\n  readonly rows: number;\n  /** The terrain at time `t` is `keyA + (keyB - keyA) * blend`, see `advance()`. */\n  readonly keyA: Float32Array;\n  readonly keyB: Float32Array;\n  /** Changes whenever the contents of `keyA` / `keyB` change. */\n  readonly version: number;\n  /** Apply new parameters; resamples only if something actually changed. */\n  configure(params: FieldParams): void;\n  /** Size of the area to cover, in CSS pixels. */\n  resize(width: number, height: number): void;\n  /** Bring the keyframes up to `time` and return the blend factor between them. */\n  advance(time: number): number;\n}\n\n/**\n * The terrain height field, sampled on a grid `cellSize` pixels apart.\n *\n * Sampling noise for every grid point is the most expensive step, but the\n * terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart\n * (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.\n * The keyframe after B is built a few rows per frame to avoid spikes.\n */\nexport function createKeyframeField(initial: FieldParams): KeyframeField {\n  let params = initial;\n  let noise: Noise3D = createNoise3D(params.seed);\n  // Sum of octave amplitudes (1 + 1/2 + 1/4 + …), to normalise the result to [-1, 1].\n  let norm = 2 - 2 ** (1 - params.octaves);\n\n  let width = 0;\n  let height = 0;\n  let cols = 0;\n  let rows = 0;\n  let keyA = new Float32Array(0);\n  let keyB = new Float32Array(0);\n  let keyNext = new Float32Array(0);\n  let keyTime = 0;\n  let keyNextRows = 0;\n  let valid = false;\n  let version = 0;\n\n  function allocate(): void {\n    const nextCols = Math.ceil(width / params.cellSize) + 1;\n    const nextRows = Math.ceil(height / params.cellSize) + 1;\n    if (nextCols === cols && nextRows === rows) return;\n    cols = nextCols;\n    rows = nextRows;\n    keyA = new Float32Array(cols * rows);\n    keyB = new Float32Array(cols * rows);\n    keyNext = new Float32Array(cols * rows);\n    valid = false;\n  }\n\n  function sampleRows(target: Float32Array, t: number, fromRow: number, toRow: number): void {\n    const { cellSize, octaves, scale } = params;\n    for (let j = fromRow; j < toRow; j++) {\n      const y = j * cellSize;\n      for (let i = 0; i < cols; i++) {\n        const x = i * cellSize;\n        let value = 0;\n        for (let o = 0, amp = 1, freq = scale; o < octaves; o++, amp *= 0.5, freq *= 2) {\n          value += amp * noise(x * freq, y * freq, t + o * 17.3);\n        }\n        target[j * cols + i] = value / norm;\n      }\n    }\n  }\n\n  return {\n    get cols() {\n      return cols;\n    },\n    get rows() {\n      return rows;\n    },\n    get keyA() {\n      return keyA;\n    },\n    get keyB() {\n      return keyB;\n    },\n    get version() {\n      return version;\n    },\n\n    configure(next) {\n      const prev = params;\n      if (\n        next.seed === prev.seed &&\n        next.scale === prev.scale &&\n        next.octaves === prev.octaves &&\n        next.cellSize === prev.cellSize\n      ) {\n        return;\n      }\n      params = { seed: next.seed, scale: next.scale, octaves: next.octaves, cellSize: next.cellSize };\n      if (next.seed !== prev.seed) noise = createNoise3D(next.seed);\n      norm = 2 - 2 ** (1 - next.octaves);\n      allocate();\n      valid = false;\n    },\n\n    resize(nextWidth, nextHeight) {\n      width = nextWidth;\n      height = nextHeight;\n      allocate();\n    },\n\n    advance(time) {\n      if (!valid || time < keyTime || time >= keyTime + 2 * KEY_DT) {\n        keyTime = time;\n        sampleRows(keyA, keyTime, 0, rows);\n        sampleRows(keyB, keyTime + KEY_DT, 0, rows);\n        keyNextRows = 0;\n        valid = true;\n        version++;\n      }\n      if (time >= keyTime + KEY_DT) {\n        sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, rows);\n        [keyA, keyB, keyNext] = [keyB, keyNext, keyA];\n        keyTime += KEY_DT;\n        keyNextRows = 0;\n        version++;\n      }\n      // Spread the next keyframe over the first 80% of the interval.\n      const progress = (time - keyTime) / KEY_DT;\n      const wanted = Math.min(rows, Math.ceil((rows * progress) / 0.8));\n      if (wanted > keyNextRows) {\n        sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, wanted);\n        keyNextRows = wanted;\n      }\n      return progress;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/styles/topo/field.d.cts

@@ -0,0 +1,26 @@
+import type { ResolvedTopoOptions } from './options.cjs';
+export type FieldParams = Pick<ResolvedTopoOptions, 'seed' | 'scale' | 'octaves' | 'cellSize'>;
+export interface KeyframeField {
+    readonly cols: number;
+    readonly rows: number;
+    /** The terrain at time `t` is `keyA + (keyB - keyA) * blend`, see `advance()`. */
+    readonly keyA: Float32Array;
+    readonly keyB: Float32Array;
+    /** Changes whenever the contents of `keyA` / `keyB` change. */
+    readonly version: number;
+    /** Apply new parameters; resamples only if something actually changed. */
+    configure(params: FieldParams): void;
+    /** Size of the area to cover, in CSS pixels. */
+    resize(width: number, height: number): void;
+    /** Bring the keyframes up to `time` and return the blend factor between them. */
+    advance(time: number): number;
+}
+/**
+ * The terrain height field, sampled on a grid `cellSize` pixels apart.
+ *
+ * Sampling noise for every grid point is the most expensive step, but the
+ * terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart
+ * (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.
+ * The keyframe after B is built a few rows per frame to avoid spikes.
+ */
+export declare function createKeyframeField(initial: FieldParams): KeyframeField;

package/dist/styles/topo/field.d.ts

@@ -0,0 +1,26 @@
+import type { ResolvedTopoOptions } from './options.js';
+export type FieldParams = Pick<ResolvedTopoOptions, 'seed' | 'scale' | 'octaves' | 'cellSize'>;
+export interface KeyframeField {
+    readonly cols: number;
+    readonly rows: number;
+    /** The terrain at time `t` is `keyA + (keyB - keyA) * blend`, see `advance()`. */
+    readonly keyA: Float32Array;
+    readonly keyB: Float32Array;
+    /** Changes whenever the contents of `keyA` / `keyB` change. */
+    readonly version: number;
+    /** Apply new parameters; resamples only if something actually changed. */
+    configure(params: FieldParams): void;
+    /** Size of the area to cover, in CSS pixels. */
+    resize(width: number, height: number): void;
+    /** Bring the keyframes up to `time` and return the blend factor between them. */
+    advance(time: number): number;
+}
+/**
+ * The terrain height field, sampled on a grid `cellSize` pixels apart.
+ *
+ * Sampling noise for every grid point is the most expensive step, but the
+ * terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart
+ * (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.
+ * The keyframe after B is built a few rows per frame to avoid spikes.
+ */
+export declare function createKeyframeField(initial: FieldParams): KeyframeField;

package/dist/styles/topo/field.js

@@ -0,0 +1,118 @@
+import { createNoise3D } from "../../shared/noise.js";
+// src/styles/topo/field.ts
+/** Noise-time distance between sampled keyframes; frames in between are blended. */
+var KEY_DT = .02;
+/**
+* The terrain height field, sampled on a grid `cellSize` pixels apart.
+*
+* Sampling noise for every grid point is the most expensive step, but the
+* terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart
+* (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.
+* The keyframe after B is built a few rows per frame to avoid spikes.
+*/
+function createKeyframeField(initial) {
+	let params = initial;
+	let noise = createNoise3D(params.seed);
+	let norm = 2 - 2 ** (1 - params.octaves);
+	let width = 0;
+	let height = 0;
+	let cols = 0;
+	let rows = 0;
+	let keyA = /* @__PURE__ */ new Float32Array(0);
+	let keyB = /* @__PURE__ */ new Float32Array(0);
+	let keyNext = /* @__PURE__ */ new Float32Array(0);
+	let keyTime = 0;
+	let keyNextRows = 0;
+	let valid = false;
+	let version = 0;
+	function allocate() {
+		const nextCols = Math.ceil(width / params.cellSize) + 1;
+		const nextRows = Math.ceil(height / params.cellSize) + 1;
+		if (nextCols === cols && nextRows === rows) return;
+		cols = nextCols;
+		rows = nextRows;
+		keyA = new Float32Array(cols * rows);
+		keyB = new Float32Array(cols * rows);
+		keyNext = new Float32Array(cols * rows);
+		valid = false;
+	}
+	function sampleRows(target, t, fromRow, toRow) {
+		const { cellSize, octaves, scale } = params;
+		for (let j = fromRow; j < toRow; j++) {
+			const y = j * cellSize;
+			for (let i = 0; i < cols; i++) {
+				const x = i * cellSize;
+				let value = 0;
+				for (let o = 0, amp = 1, freq = scale; o < octaves; o++, amp *= .5, freq *= 2) value += amp * noise(x * freq, y * freq, t + o * 17.3);
+				target[j * cols + i] = value / norm;
+			}
+		}
+	}
+	return {
+		get cols() {
+			return cols;
+		},
+		get rows() {
+			return rows;
+		},
+		get keyA() {
+			return keyA;
+		},
+		get keyB() {
+			return keyB;
+		},
+		get version() {
+			return version;
+		},
+		configure(next) {
+			const prev = params;
+			if (next.seed === prev.seed && next.scale === prev.scale && next.octaves === prev.octaves && next.cellSize === prev.cellSize) return;
+			params = {
+				seed: next.seed,
+				scale: next.scale,
+				octaves: next.octaves,
+				cellSize: next.cellSize
+			};
+			if (next.seed !== prev.seed) noise = createNoise3D(next.seed);
+			norm = 2 - 2 ** (1 - next.octaves);
+			allocate();
+			valid = false;
+		},
+		resize(nextWidth, nextHeight) {
+			width = nextWidth;
+			height = nextHeight;
+			allocate();
+		},
+		advance(time) {
+			if (!valid || time < keyTime || time >= keyTime + 2 * KEY_DT) {
+				keyTime = time;
+				sampleRows(keyA, keyTime, 0, rows);
+				sampleRows(keyB, keyTime + KEY_DT, 0, rows);
+				keyNextRows = 0;
+				valid = true;
+				version++;
+			}
+			if (time >= keyTime + KEY_DT) {
+				sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, rows);
+				[keyA, keyB, keyNext] = [
+					keyB,
+					keyNext,
+					keyA
+				];
+				keyTime += KEY_DT;
+				keyNextRows = 0;
+				version++;
+			}
+			const progress = (time - keyTime) / KEY_DT;
+			const wanted = Math.min(rows, Math.ceil(rows * progress / .8));
+			if (wanted > keyNextRows) {
+				sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, wanted);
+				keyNextRows = wanted;
+			}
+			return progress;
+		}
+	};
+}
+export { createKeyframeField };
+
+//# sourceMappingURL=field.js.map

package/dist/styles/topo/field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.js","names":[],"sources":["../../../src/styles/topo/field.ts"],"sourcesContent":["import { createNoise3D, type Noise3D } from '../../shared/noise';\nimport type { ResolvedTopoOptions } from './options';\n\n/** Noise-time distance between sampled keyframes; frames in between are blended. */\nconst KEY_DT = 0.02;\n\nexport type FieldParams = Pick<ResolvedTopoOptions, 'seed' | 'scale' | 'octaves' | 'cellSize'>;\n\nexport interface KeyframeField {\n  readonly cols: number;\n  readonly rows: number;\n  /** The terrain at time `t` is `keyA + (keyB - keyA) * blend`, see `advance()`. */\n  readonly keyA: Float32Array;\n  readonly keyB: Float32Array;\n  /** Changes whenever the contents of `keyA` / `keyB` change. */\n  readonly version: number;\n  /** Apply new parameters; resamples only if something actually changed. */\n  configure(params: FieldParams): void;\n  /** Size of the area to cover, in CSS pixels. */\n  resize(width: number, height: number): void;\n  /** Bring the keyframes up to `time` and return the blend factor between them. */\n  advance(time: number): number;\n}\n\n/**\n * The terrain height field, sampled on a grid `cellSize` pixels apart.\n *\n * Sampling noise for every grid point is the most expensive step, but the\n * terrain changes slowly. So noise is only sampled at keyframes KEY_DT apart\n * (A at `keyTime`, B at `keyTime + KEY_DT`) and every frame blends between them.\n * The keyframe after B is built a few rows per frame to avoid spikes.\n */\nexport function createKeyframeField(initial: FieldParams): KeyframeField {\n  let params = initial;\n  let noise: Noise3D = createNoise3D(params.seed);\n  // Sum of octave amplitudes (1 + 1/2 + 1/4 + …), to normalise the result to [-1, 1].\n  let norm = 2 - 2 ** (1 - params.octaves);\n\n  let width = 0;\n  let height = 0;\n  let cols = 0;\n  let rows = 0;\n  let keyA = new Float32Array(0);\n  let keyB = new Float32Array(0);\n  let keyNext = new Float32Array(0);\n  let keyTime = 0;\n  let keyNextRows = 0;\n  let valid = false;\n  let version = 0;\n\n  function allocate(): void {\n    const nextCols = Math.ceil(width / params.cellSize) + 1;\n    const nextRows = Math.ceil(height / params.cellSize) + 1;\n    if (nextCols === cols && nextRows === rows) return;\n    cols = nextCols;\n    rows = nextRows;\n    keyA = new Float32Array(cols * rows);\n    keyB = new Float32Array(cols * rows);\n    keyNext = new Float32Array(cols * rows);\n    valid = false;\n  }\n\n  function sampleRows(target: Float32Array, t: number, fromRow: number, toRow: number): void {\n    const { cellSize, octaves, scale } = params;\n    for (let j = fromRow; j < toRow; j++) {\n      const y = j * cellSize;\n      for (let i = 0; i < cols; i++) {\n        const x = i * cellSize;\n        let value = 0;\n        for (let o = 0, amp = 1, freq = scale; o < octaves; o++, amp *= 0.5, freq *= 2) {\n          value += amp * noise(x * freq, y * freq, t + o * 17.3);\n        }\n        target[j * cols + i] = value / norm;\n      }\n    }\n  }\n\n  return {\n    get cols() {\n      return cols;\n    },\n    get rows() {\n      return rows;\n    },\n    get keyA() {\n      return keyA;\n    },\n    get keyB() {\n      return keyB;\n    },\n    get version() {\n      return version;\n    },\n\n    configure(next) {\n      const prev = params;\n      if (\n        next.seed === prev.seed &&\n        next.scale === prev.scale &&\n        next.octaves === prev.octaves &&\n        next.cellSize === prev.cellSize\n      ) {\n        return;\n      }\n      params = { seed: next.seed, scale: next.scale, octaves: next.octaves, cellSize: next.cellSize };\n      if (next.seed !== prev.seed) noise = createNoise3D(next.seed);\n      norm = 2 - 2 ** (1 - next.octaves);\n      allocate();\n      valid = false;\n    },\n\n    resize(nextWidth, nextHeight) {\n      width = nextWidth;\n      height = nextHeight;\n      allocate();\n    },\n\n    advance(time) {\n      if (!valid || time < keyTime || time >= keyTime + 2 * KEY_DT) {\n        keyTime = time;\n        sampleRows(keyA, keyTime, 0, rows);\n        sampleRows(keyB, keyTime + KEY_DT, 0, rows);\n        keyNextRows = 0;\n        valid = true;\n        version++;\n      }\n      if (time >= keyTime + KEY_DT) {\n        sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, rows);\n        [keyA, keyB, keyNext] = [keyB, keyNext, keyA];\n        keyTime += KEY_DT;\n        keyNextRows = 0;\n        version++;\n      }\n      // Spread the next keyframe over the first 80% of the interval.\n      const progress = (time - keyTime) / KEY_DT;\n      const wanted = Math.min(rows, Math.ceil((rows * progress) / 0.8));\n      if (wanted > keyNextRows) {\n        sampleRows(keyNext, keyTime + 2 * KEY_DT, keyNextRows, wanted);\n        keyNextRows = wanted;\n      }\n      return progress;\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/styles/topo/options.cjs

@@ -0,0 +1,39 @@
+// src/styles/topo/options.ts
+var topoDefaults = Object.freeze({
+	lineColor: "#5b6576",
+	majorLineColor: "#7dd3a8",
+	lineOpacity: .5,
+	lineWidth: 1,
+	majorLineWidth: 1.75,
+	majorEvery: 5,
+	levels: 12,
+	scale: .0025,
+	octaves: 2,
+	speed: .025,
+	resolution: 6,
+	seed: 1332056948,
+	pointerRadius: 100,
+	pointerStrength: .35
+});
+function resolveTopoOptions(options) {
+	return {
+		lineColor: options.lineColor,
+		majorLineColor: options.majorLineColor ?? options.lineColor,
+		lineOpacity: Math.min(1, Math.max(0, options.lineOpacity)),
+		lineWidth: Math.max(.1, options.lineWidth),
+		majorLineWidth: Math.max(.1, options.majorLineWidth),
+		majorEvery: Math.max(0, Math.round(options.majorEvery)),
+		levelStep: 2 / Math.max(1, options.levels),
+		cellSize: Math.max(2, options.resolution),
+		octaves: Math.max(1, Math.round(options.octaves)),
+		scale: options.scale,
+		speed: Math.abs(options.speed),
+		seed: options.seed,
+		pointerRadius: Math.max(1, options.pointerRadius),
+		pointerStrength: options.pointerStrength
+	};
+}
+exports.resolveTopoOptions = resolveTopoOptions;
+exports.topoDefaults = topoDefaults;
+
+//# sourceMappingURL=options.cjs.map

package/dist/styles/topo/options.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.cjs","names":[],"sources":["../../../src/styles/topo/options.ts"],"sourcesContent":["export interface TopoOptions {\n  /** Stroke colour of regular contour lines. Any CSS colour. */\n  lineColor: string;\n  /** Stroke colour of every `majorEvery`-th (\"index\") line. Defaults to `lineColor`. */\n  majorLineColor?: string;\n  /** Opacity of all lines, from `0` (invisible) to `1` (opaque). Multiplies any alpha in the colours. */\n  lineOpacity: number;\n  /** Width of regular lines, in CSS pixels. */\n  lineWidth: number;\n  /** Width of index lines, in CSS pixels. */\n  majorLineWidth: number;\n  /** Every n-th contour is drawn as an index line. `0` disables index lines. */\n  majorEvery: number;\n  /** Number of contour levels across the full elevation range. More = denser lines. */\n  levels: number;\n  /** Noise frequency per CSS pixel. Smaller = larger, smoother landforms. */\n  scale: number;\n  /** Noise octaves. More = more detailed, rougher terrain (and more CPU). */\n  octaves: number;\n  /** How fast the terrain morphs, in noise units per second. `0` = static. */\n  speed: number;\n  /** Size of a sampling cell in CSS pixels. Smaller = smoother lines, more CPU. */\n  resolution: number;\n  /** Seed for the terrain. Same seed, same landscape. Pass a random number for a different one on every load. */\n  seed: number;\n  /** Radius of the pointer's influence, in CSS pixels. */\n  pointerRadius: number;\n  /** Height of the bump under the pointer. Negative values dig a crater. */\n  pointerStrength: number;\n}\n\nexport const topoDefaults: Readonly<TopoOptions> = Object.freeze({\n  lineColor: '#5b6576',\n  majorLineColor: '#7dd3a8',\n  lineOpacity: 0.5,\n  lineWidth: 1,\n  majorLineWidth: 1.75,\n  majorEvery: 5,\n  levels: 12,\n  scale: 0.0025,\n  octaves: 2,\n  speed: 0.025,\n  resolution: 6,\n  seed: 1332056948,\n  pointerRadius: 100,\n  pointerStrength: 0.35,\n});\n\n/** Options after clamping and deriving: what the field and the renderers consume. */\nexport interface ResolvedTopoOptions {\n  lineColor: string;\n  majorLineColor: string;\n  lineOpacity: number;\n  lineWidth: number;\n  majorLineWidth: number;\n  /** Integer; `0` = no index lines. */\n  majorEvery: number;\n  /** Height difference between neighbouring contour levels. */\n  levelStep: number;\n  /** Grid spacing of the height field, in CSS pixels. */\n  cellSize: number;\n  octaves: number;\n  scale: number;\n  speed: number;\n  seed: number;\n  pointerRadius: number;\n  pointerStrength: number;\n}\n\nexport function resolveTopoOptions(options: TopoOptions): ResolvedTopoOptions {\n  return {\n    lineColor: options.lineColor,\n    majorLineColor: options.majorLineColor ?? options.lineColor,\n    lineOpacity: Math.min(1, Math.max(0, options.lineOpacity)),\n    lineWidth: Math.max(0.1, options.lineWidth),\n    majorLineWidth: Math.max(0.1, options.majorLineWidth),\n    majorEvery: Math.max(0, Math.round(options.majorEvery)),\n    // The height field spans roughly [-1, 1], so the levels cover a range of 2.\n    levelStep: 2 / Math.max(1, options.levels),\n    cellSize: Math.max(2, options.resolution),\n    octaves: Math.max(1, Math.round(options.octaves)),\n    scale: options.scale,\n    // The keyframes only step forwards in time; morphing backwards looks the same, so use the magnitude.\n    speed: Math.abs(options.speed),\n    seed: options.seed,\n    pointerRadius: Math.max(1, options.pointerRadius),\n    pointerStrength: options.pointerStrength,\n  };\n}\n"],"mappings":";AA+BA,IAAa,eAAsC,OAAO,OAAO;CAC/D,WAAW;CACX,gBAAgB;CAChB,aAAa;CACb,WAAW;CACX,gBAAgB;CAChB,YAAY;CACZ,QAAQ;CACR,OAAO;CACP,SAAS;CACT,OAAO;CACP,YAAY;CACZ,MAAM;CACN,eAAe;CACf,iBAAiB;AACnB,CAAC;AAuBD,SAAgB,mBAAmB,SAA2C;CAC5E,OAAO;EACL,WAAW,QAAQ;EACnB,gBAAgB,QAAQ,kBAAkB,QAAQ;EAClD,aAAa,KAAK,IAAI,GAAG,KAAK,IAAI,GAAG,QAAQ,WAAW,CAAC;EACzD,WAAW,KAAK,IAAI,IAAK,QAAQ,SAAS;EAC1C,gBAAgB,KAAK,IAAI,IAAK,QAAQ,cAAc;EACpD,YAAY,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,UAAU,CAAC;EAEtD,WAAW,IAAI,KAAK,IAAI,GAAG,QAAQ,MAAM;EACzC,UAAU,KAAK,IAAI,GAAG,QAAQ,UAAU;EACxC,SAAS,KAAK,IAAI,GAAG,KAAK,MAAM,QAAQ,OAAO,CAAC;EAChD,OAAO,QAAQ;EAEf,OAAO,KAAK,IAAI,QAAQ,KAAK;EAC7B,MAAM,QAAQ;EACd,eAAe,KAAK,IAAI,GAAG,QAAQ,aAAa;EAChD,iBAAiB,QAAQ;CAC3B;AACF"}