framefields 2.11.0 → 2.12.0

package/dist/{dist-CWLLnigL.mjs → dist-B-OPY7Cs.mjs}

@@ -16643,6 +16643,10 @@ async function acquireDevice(opts) {
 	if (adapter.limits && Number.isInteger(adapter.limits.maxTextureDimension2D)) requiredLimits.maxTextureDimension2D = Math.min(8192, adapter.limits.maxTextureDimension2D);
 	if (adapter.limits && Number.isInteger(adapter.limits.maxStorageBuffersPerShaderStage)) requiredLimits.maxStorageBuffersPerShaderStage = Math.min(16, adapter.limits.maxStorageBuffersPerShaderStage);
 	if (adapter.limits && Number.isInteger(adapter.limits.maxStorageBuffersPerPipelineLayout)) requiredLimits.maxStorageBuffersPerPipelineLayout = Math.min(16, adapter.limits.maxStorageBuffersPerPipelineLayout);
+	for (const limit of ["maxStorageBufferBindingSize", "maxBufferSize"]) {
+		const max = adapter.limits?.[limit];
+		if (Number.isFinite(max)) requiredLimits[limit] = max;
+	}
 	return adapter.requestDevice({
 		requiredFeatures,
 		requiredLimits
@@ -26511,6 +26515,50 @@ async function drawSignalNode(ctx, encoder, pass, props) {
 	pass.setBindGroup(1, bindGroup1);
 	pass.draw(4);
 }
+/**
+* Target pixels per local unit along the axis `m` stretches most: what a
+* raster drawn under `m` needs per unit to stay sharp, and what one target
+* pixel is in local units (its inverse).
+*/
+function transformScale(m) {
+	return Math.max(Math.hypot(m.a, m.b), Math.hypot(m.c, m.d));
+}
+var TransformStack = class {
+	stack = [new DOMMatrix()];
+	push(matrix) {
+		const next = this.stack[this.stack.length - 1].multiply(matrix);
+		this.stack.push(next);
+	}
+	pop() {
+		if (this.stack.length > 1) this.stack.pop();
+	}
+	getCurrent() {
+		return this.stack[this.stack.length - 1];
+	}
+	packIntoBuffer(bufferData, opacity, surfaceWidth, surfaceHeight, localOverride, customParam) {
+		let m = this.getCurrent();
+		if (localOverride) m = m.multiply(localOverride);
+		bufferData[0] = m.a;
+		bufferData[1] = m.b;
+		bufferData[2] = 0;
+		bufferData[3] = 0;
+		bufferData[4] = m.c;
+		bufferData[5] = m.d;
+		bufferData[6] = 0;
+		bufferData[7] = 0;
+		bufferData[8] = m.e;
+		bufferData[9] = m.f;
+		bufferData[10] = 1;
+		bufferData[11] = 0;
+		bufferData[12] = opacity;
+		bufferData[13] = surfaceWidth;
+		bufferData[14] = surfaceHeight;
+		bufferData[15] = customParam ?? 0;
+	}
+	destroy() {
+		this.stack = [new DOMMatrix()];
+	}
+};
 var SvgLoader = class {
 	cache = /* @__PURE__ */ new Map();
 	async load(src, width, height, isHeadless) {
@@ -26583,8 +26631,10 @@ var SvgLoader = class {
 };
 const svgLoader = new SvgLoader();
 async function drawSvgNode(ctx, pass, props) {
-	const resolvedWidth = Math.max(1, Math.ceil(props.dstRect.width));
-	const resolvedHeight = Math.max(1, Math.ceil(props.dstRect.height));
+	const m = ctx.renderer.getCurrentTransform();
+	const k = transformScale(props.matrix ? m.multiply(props.matrix) : m);
+	const resolvedWidth = Math.max(1, Math.ceil(props.dstRect.width * k));
+	const resolvedHeight = Math.max(1, Math.ceil(props.dstRect.height * k));
 	const cacheKey = `${props.src}-${resolvedWidth}-${resolvedHeight}`;
 	let tex = textureCache.acquire(cacheKey);
 	if (!tex) try {
@@ -27389,6 +27439,8 @@ fn sampleSlugCoverage(sampleUV: vec2<f32>, g: SlugGlyph, pixelsPerEm: vec2<f32>)
 // pixel footprint in glyph uv, |d/dx| + |d/dy| (fwidth): the caller takes it in
 // uniform control flow. On a turned or foreshortened glyph it is wider than one
 // pixel along an axis, so that axis gets the soft ramp a box filter gives.
+// A blur of blurAmount px averages coverage over a grid reaching 0.3 of it
+// each way, blurTaps taps per side past the centre.
 fn shadeSlugGlyph(
 	uv: vec2<f32>,
 	fw: vec2<f32>,
@@ -27397,6 +27449,7 @@ fn shadeSlugGlyph(
 	color: vec4<f32>,
 	opacity: f32,
 	blurAmount: f32,
+	blurTaps: f32,
 	chromaticShift: f32,
 	dissolveProgress: f32,
 ) -> vec4<f32> {
@@ -27429,14 +27482,15 @@ fn shadeSlugGlyph(
 
 	var slugAlpha = 0.0;
 	if (blurAmount > 0.01) {
-		let step = fw * blurAmount * 0.3;
-		for (var y_offset = -1.0; y_offset <= 1.0; y_offset = y_offset + 1.0) {
-			for (var x_offset = -1.0; x_offset <= 1.0; x_offset = x_offset + 1.0) {
+		let step = fw * blurAmount * 0.3 / blurTaps;
+		for (var y_offset = -blurTaps; y_offset <= blurTaps; y_offset = y_offset + 1.0) {
+			for (var x_offset = -blurTaps; x_offset <= blurTaps; x_offset = x_offset + 1.0) {
 				let offset = vec2<f32>(x_offset, y_offset) * step;
 				slugAlpha = slugAlpha + sampleSlugCoverage(uv + offset, g, pixelsPerEm);
 			}
 		}
-		slugAlpha = slugAlpha / 9.0;
+		let side = 2.0 * blurTaps + 1.0;
+		slugAlpha = slugAlpha / (side * side);
 	} else {
 		slugAlpha = sampleSlugCoverage(uv, g, pixelsPerEm);
 	}
@@ -27472,6 +27526,7 @@ struct VSOut {
 	@location(7) @interpolate(flat) chromaticShift : f32,
 	@location(8) @interpolate(flat) dissolveProgress : f32,
 	@location(9) @interpolate(flat) vfxParam : f32,
+	@location(10) @interpolate(flat) blurTaps : f32,
 };
 
 var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
@@ -27505,7 +27560,11 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 	let transform2 = mat2x2<f32>(u.transformCol0.xy, u.transformCol1.xy);
 	let pixelsPerUnit = sqrt(max(abs(determinant(transform2)), 1e-8));
 	let halfSize = max(abs(aScaleBias.xy * scale_mult), vec2<f32>(1e-4));
-	let grow = vec2<f32>(1.0) + (1.0 / pixelsPerUnit) / halfSize;
+	// A blurred glyph keeps a unit around it however many pixels a unit
+	// spans: its blur spills that far at one pixel per unit.
+	let blurred = aExtraParams.x > 0.01;
+	let dilation = select(1.0, max(1.0, pixelsPerUnit), blurred) / pixelsPerUnit;
+	let grow = vec2<f32>(1.0) + dilation / halfSize;
 	let uv = vec2<f32>(
 		quad_pos.x * grow.x * 0.5 + 0.5,
 		1.0 - (quad_pos.y * grow.y * 0.5 + 0.5),
@@ -27539,7 +27598,11 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 	out.bandMax = vec2<u32>(aBandMaxTexCoords.xy);
 	out.bandsTexCoords = vec2<u32>(aBandMaxTexCoords.zw);
 	out.color = aColor;
-	out.blurAmount = aExtraParams.x;
+	// Blur is in local units, like every other length here; the fragment
+	// stage spreads its taps in pixels, as far apart as at one pixel per
+	// unit (more of them as a unit spans more pixels, up to 4).
+	out.blurAmount = aExtraParams.x * pixelsPerUnit;
+	out.blurTaps = clamp(ceil(pixelsPerUnit - 1e-3), 1.0, 4.0);
 	out.chromaticShift = aExtraParams.y;
 	out.dissolveProgress = aExtraParams.z;
 	out.vfxParam = aExtraParams.w;
@@ -27558,6 +27621,7 @@ var<private> pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
 		in.color,
 		u.params.x,
 		in.blurAmount,
+		in.blurTaps,
 		in.chromaticShift,
 		in.dissolveProgress,
 	);
@@ -29610,42 +29674,6 @@ var SolidPipeline = class {
 		this.uniformBindGroupCache.destroy();
 	}
 };
-var TransformStack = class {
-	stack = [new DOMMatrix()];
-	push(matrix) {
-		const next = this.stack[this.stack.length - 1].multiply(matrix);
-		this.stack.push(next);
-	}
-	pop() {
-		if (this.stack.length > 1) this.stack.pop();
-	}
-	getCurrent() {
-		return this.stack[this.stack.length - 1];
-	}
-	packIntoBuffer(bufferData, opacity, surfaceWidth, surfaceHeight, localOverride, customParam) {
-		let m = this.getCurrent();
-		if (localOverride) m = m.multiply(localOverride);
-		bufferData[0] = m.a;
-		bufferData[1] = m.b;
-		bufferData[2] = 0;
-		bufferData[3] = 0;
-		bufferData[4] = m.c;
-		bufferData[5] = m.d;
-		bufferData[6] = 0;
-		bufferData[7] = 0;
-		bufferData[8] = m.e;
-		bufferData[9] = m.f;
-		bufferData[10] = 1;
-		bufferData[11] = 0;
-		bufferData[12] = opacity;
-		bufferData[13] = surfaceWidth;
-		bufferData[14] = surfaceHeight;
-		bufferData[15] = customParam ?? 0;
-	}
-	destroy() {
-		this.stack = [new DOMMatrix()];
-	}
-};
 function premultiplyClearColor(color) {
 	if (Array.isArray(color)) {
 		const a$1 = color[3] ?? 1;
@@ -29796,10 +29824,14 @@ var Renderer2D = class {
 				this.drawShapeFill(pass, tris, fill, bounds, opts);
 				if ((!stroke || !stroke.width || stroke.width <= 0) && (fill.type ?? "solid") === "solid" && fill.color) {
 					const svgPath = buildShapeSvgPath(config$1);
-					if (svgPath) this.drawPath(pass, svgPath, fill.color, 1, {
-						...opts,
-						strokeLineCap: "round"
-					});
+					if (svgPath) {
+						const m = this.transformStack.getCurrent();
+						const hairline = 1 / transformScale(opts?.transform ? m.multiply(opts.transform) : m);
+						this.drawPath(pass, svgPath, fill.color, hairline, {
+							...opts,
+							strokeLineCap: "round"
+						});
+					}
 				}
 			}
 		}
@@ -32848,6 +32880,9 @@ fn fs_mrt_bloom(in: VertexOutput, @builtin(front_facing) isFront: bool) -> MrtBl
 */
 const quad3dWgsl = `
 ${lighting3dWgsl}
+// Grid cells either side a relief's normals span.
+const RELIEF_NORMAL_CELLS : f32 = 4.0;
+
 struct ModelUniforms {
     modelMatrix    : mat4x4<f32>,
     normalMatrix   : mat4x4<f32>,
@@ -32858,11 +32893,15 @@ struct ModelUniforms {
     materialParams : vec4<f32>, // x = shininess, y = specularIntensity, z = ambientIntensity, w = materialMode (0=unlit, 1=lit)
     pbr            : vec4<f32>, // x = roughness (<0 = default), y = metallic
     emissive       : vec4<f32>, // rgb = sRGB emissive color, w = strength
+    relief         : vec4<f32>, // x = amount (px), y = on, w = grid cells per side
+    reliefRect     : vec4<f32>, // xy = where the layer's box starts in reliefTex (0..1), zw = its size
+    reliefEye      : vec4<f32>, // xyz = the eye the surface keeps its look from (the default camera)
 };
 
 @group(0) @binding(0) var<uniform> cam    : CameraUniforms;
 @group(1) @binding(0) var<uniform> model  : ModelUniforms;
-${matte3dWgsl(1, 1)}@group(2) @binding(0) var texSampler      : sampler;
+${matte3dWgsl(1, 1)}@group(1) @binding(2) var reliefTex : texture_2d<f32>;
+@group(2) @binding(0) var texSampler      : sampler;
 @group(2) @binding(1) var mainTex         : texture_2d<f32>;
 ${lightsBindingsWgsl}
 
@@ -32881,13 +32920,48 @@ struct VertexOutput {
     @location(4)       localPos    : vec2<f32>,
 };
 
+// Relief: the layer's plane pushed toward the eye by the brightness of a
+// second picture, so a flat quad becomes a surface (see DrawQuad3DOpts.relief).
+fn reliefAt(uv: vec2<f32>) -> f32 {
+    let dims = vec2<f32>(textureDimensions(reliefTex));
+    let p = (model.reliefRect.xy + clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0)) * model.reliefRect.zw) * dims - 0.5;
+    let i = floor(p);
+    let f = p - i;
+    // Texels of the layer's own box only: past its edge the relief was never drawn.
+    let lo = max(floor(model.reliefRect.xy * dims), vec2<f32>(0.0));
+    let hi = min(ceil((model.reliefRect.xy + model.reliefRect.zw) * dims) - 1.0, dims - 1.0);
+    let a = textureLoad(reliefTex, vec2<i32>(clamp(i, lo, hi)), 0).rgb;
+    let b = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(1.0, 0.0), lo, hi)), 0).rgb;
+    let c = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(0.0, 1.0), lo, hi)), 0).rgb;
+    let d = textureLoad(reliefTex, vec2<i32>(clamp(i + vec2<f32>(1.0, 1.0), lo, hi)), 0).rgb;
+    let rgb = mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+    return dot(rgb, vec3<f32>(0.2126, 0.7152, 0.0722));
+}
+
+// The plane's front: the side the default camera sees.
+fn reliefFront() -> vec3<f32> {
+    return normalize((model.normalMatrix * vec4<f32>(0.0, 0.0, -1.0, 0.0)).xyz);
+}
+
+// A point of the plane lifted by its relief along the ray to the eye, so from
+// the eye it lands on the same pixel as the flat picture.
+fn reliefPoint(local: vec2<f32>, uv: vec2<f32>) -> vec3<f32> {
+    let flat = (model.modelMatrix * vec4<f32>(local, 0.0, 1.0)).xyz;
+    let n = reliefFront();
+    let h = model.relief.x * reliefAt(uv);
+    let toEye = model.reliefEye.xyz - flat;
+    let along = dot(toEye, n);
+    return select(flat + n * h, flat + toEye * (h / along), along > 1.0);
+}
+
 @vertex
 fn vs_main(in: VertexInput) -> VertexOutput {
     var out: VertexOutput;
     
     let hasDimensions = model.dimensions.x > 0.0 && model.dimensions.y > 0.0;
+    let hasRelief = model.relief.y > 0.5;
     var pad = 0.0;
-    if (hasDimensions) {
+    if (hasDimensions && !hasRelief) {
         let viewPos = cam.viewMatrix * model.modelMatrix * vec4<f32>(0.0, 0.0, 0.0, 1.0);
         let viewDepth = max(abs(viewPos.z), 0.1);
         let projScale = max(cam.projMatrix[1][1], 0.001);
@@ -32897,12 +32971,28 @@ fn vs_main(in: VertexInput) -> VertexOutput {
     let scalePad = select(vec2<f32>(1.0), 1.0 + vec2<f32>(2.0 * pad) / model.dimensions.xy, hasDimensions);
     
     let paddedPos = vec3<f32>(in.position.xy * scalePad, in.position.z);
-    let worldPos4 = model.modelMatrix * vec4<f32>(paddedPos, 1.0);
-    out.worldPos = worldPos4.xyz;
+    var worldPos4 = model.modelMatrix * vec4<f32>(paddedPos, 1.0);
     
     // Normal transformed by 3x3 normal matrix
     let norm4 = model.normalMatrix * vec4<f32>(in.normal, 0.0);
     out.worldNormal = normalize(norm4.xyz);
+    if (hasRelief) {
+        let p = reliefPoint(in.position.xy, in.uv);
+        // Central differences a few cells wide: an 8-bit height map steps every
+        // level, and normals from adjacent cells would light those steps as rings.
+        let e = RELIEF_NORMAL_CELLS / max(model.relief.w, 1.0);
+        let dx = vec2<f32>(e, 0.0);
+        let dy = vec2<f32>(0.0, e);
+        let tx = reliefPoint(in.position.xy + dx, in.uv + dx) - reliefPoint(in.position.xy - dx, in.uv - dx);
+        let ty = reliefPoint(in.position.xy + dy, in.uv + dy) - reliefPoint(in.position.xy - dy, in.uv - dy);
+        var nrm = normalize(cross(tx, ty));
+        if (dot(nrm, reliefFront()) < 0.0) {
+            nrm = -nrm;
+        }
+        worldPos4 = vec4<f32>(p, 1.0);
+        out.worldNormal = nrm;
+    }
+    out.worldPos = worldPos4.xyz;
     
     out.clipPos = cam.viewProjMatrix * worldPos4;
     
@@ -33138,6 +33228,10 @@ function createLightsLayout(device, label = "Lights3DLayout") {
 		]
 	});
 }
+/** Grid cells per side of a relief surface. */
+const RELIEF_GRID = 512;
+/** Floats in the quad's model uniform: transform, colors, params, material, surface, then relief. */
+const MODEL_FLOATS = 52 + SURFACE_PARAMS_FLOATS + 12;
 /** [shininess, specularIntensity, ambientIntensity, materialMode] as the 3D shaders' lighting reads them. */
 function packMaterialParams(data) {
 	return [
@@ -33161,10 +33255,12 @@ var Quad3DPipeline = class {
 	modelPool;
 	vertexBuffer;
 	indexBuffer;
-	modelData = new Float32Array(52 + SURFACE_PARAMS_FLOATS);
+	/** The relief grid, built on first use. */
+	reliefGrid;
+	modelData = new Float32Array(MODEL_FLOATS);
 	constructor(device, format, depthFormat = "depth24plus", sampleCount = 1) {
 		this.device = device;
-		this.modelPool = new BufferPool((52 + SURFACE_PARAMS_FLOATS) * 4, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
+		this.modelPool = new BufferPool(MODEL_FLOATS * 4, GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST);
 		const module$1 = device.createShaderModule({
 			label: "quad3d.wgsl",
 			code: quad3dWgsl
@@ -33179,11 +33275,19 @@ var Quad3DPipeline = class {
 		});
 		this.modelLayout = device.createBindGroupLayout({
 			label: "Quad3DModelLayout",
-			entries: [{
-				binding: 0,
-				visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
-				buffer: { type: "uniform" }
-			}, matteLayoutEntry(1)]
+			entries: [
+				{
+					binding: 0,
+					visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+					buffer: { type: "uniform" }
+				},
+				matteLayoutEntry(1),
+				{
+					binding: 2,
+					visibility: GPUShaderStage.VERTEX,
+					texture: { sampleType: "float" }
+				}
+			]
 		});
 		this.textureLayout = device.createBindGroupLayout({
 			label: "Quad3DTextureLayout",
@@ -33350,18 +33454,110 @@ var Quad3DPipeline = class {
 		this.modelData[47] = data.textureExtent?.[1] ?? 0;
 		this.modelData.set(packMaterialParams(data), 48);
 		packSurfaceParams(data, this.modelData, 52);
+		const relief = data.relief;
+		const r = 52 + SURFACE_PARAMS_FLOATS;
+		this.modelData.set(relief ? [
+			relief.amount,
+			1,
+			0,
+			RELIEF_GRID
+		] : [
+			0,
+			0,
+			0,
+			0
+		], r);
+		this.modelData.set(relief?.uvRect ?? [
+			0,
+			0,
+			1,
+			1
+		], r + 4);
+		this.modelData.set([...relief?.eye ?? [
+			0,
+			0,
+			0
+		], 0], r + 8);
 		const modelBuffer = this.modelPool.getBuffer(this.device, this.modelData);
 		return this.device.createBindGroup({
 			layout: this.modelLayout,
-			entries: [{
-				binding: 0,
-				resource: { buffer: modelBuffer }
-			}, {
-				binding: 1,
-				resource: data.matte?.createView() ?? fullCoverageView(this.device)
-			}]
+			entries: [
+				{
+					binding: 0,
+					resource: { buffer: modelBuffer }
+				},
+				{
+					binding: 1,
+					resource: data.matte?.createView() ?? fullCoverageView(this.device)
+				},
+				{
+					binding: 2,
+					resource: data.relief?.texture.createView() ?? fullCoverageView(this.device)
+				}
+			]
 		});
 	}
+	/** Binds the geometry for `data` and draws it: the quad, or the relief grid. */
+	drawGeometry(pass, data) {
+		if (!data.relief) {
+			pass.setVertexBuffer(0, this.vertexBuffer);
+			pass.setIndexBuffer(this.indexBuffer, "uint16");
+			pass.drawIndexed(6);
+			return;
+		}
+		this.reliefGrid ??= this.createReliefGrid();
+		pass.setVertexBuffer(0, this.reliefGrid.vertices);
+		pass.setIndexBuffer(this.reliefGrid.indices, "uint32");
+		pass.drawIndexed(this.reliefGrid.count);
+	}
+	/** A RELIEF_GRID² grid over the unit quad, laid out like the quad's vertices. */
+	createReliefGrid() {
+		const side = RELIEF_GRID + 1;
+		const vertices = new Float32Array(side * side * 8);
+		for (let j = 0; j < side; j++) for (let i = 0; i < side; i++) {
+			const u = i / RELIEF_GRID;
+			const v = j / RELIEF_GRID;
+			vertices.set([
+				u - .5,
+				v - .5,
+				0,
+				u,
+				v,
+				0,
+				0,
+				-1
+			], (j * side + i) * 8);
+		}
+		const indices = new Uint32Array(RELIEF_GRID * RELIEF_GRID * 6);
+		let k = 0;
+		for (let j = 0; j < RELIEF_GRID; j++) for (let i = 0; i < RELIEF_GRID; i++) {
+			const a = j * side + i;
+			indices.set([
+				a,
+				a + 1,
+				a + side + 1,
+				a,
+				a + side + 1,
+				a + side
+			], k);
+			k += 6;
+		}
+		const upload = (data, usage) => {
+			const buffer = this.device.createBuffer({
+				size: data.byteLength,
+				usage: usage | GPUBufferUsage.COPY_DST,
+				mappedAtCreation: true
+			});
+			new data.constructor(buffer.getMappedRange()).set(data);
+			buffer.unmap();
+			return buffer;
+		};
+		return {
+			vertices: upload(vertices, GPUBufferUsage.VERTEX),
+			indices: upload(indices, GPUBufferUsage.INDEX),
+			count: indices.length
+		};
+	}
 	textureBindGroup(texture, sampler) {
 		return this.device.createBindGroup({
 			layout: this.textureLayout,
@@ -33382,9 +33578,7 @@ var Quad3DPipeline = class {
 		pass.setBindGroup(1, modelBindGroup);
 		pass.setBindGroup(2, textureBindGroup);
 		pass.setBindGroup(3, lightsBindGroup);
-		pass.setVertexBuffer(0, this.vertexBuffer);
-		pass.setIndexBuffer(this.indexBuffer, "uint16");
-		pass.drawIndexed(6);
+		this.drawGeometry(pass, data);
 	}
 	/** Draws the quad into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
 	drawShadow(pass, lightCameraBindGroup, texture, sampler, data) {
@@ -33392,14 +33586,14 @@ var Quad3DPipeline = class {
 		pass.setBindGroup(0, lightCameraBindGroup);
 		pass.setBindGroup(1, this.packModel(data));
 		pass.setBindGroup(2, this.textureBindGroup(texture, sampler));
-		pass.setVertexBuffer(0, this.vertexBuffer);
-		pass.setIndexBuffer(this.indexBuffer, "uint16");
-		pass.drawIndexed(6);
+		this.drawGeometry(pass, data);
 	}
 	destroy() {
 		this.modelPool.destroy();
 		this.vertexBuffer.destroy();
 		this.indexBuffer.destroy();
+		this.reliefGrid?.vertices.destroy();
+		this.reliefGrid?.indices.destroy();
 	}
 };
 var Mesh3DPipeline = class {
@@ -38047,6 +38241,7 @@ fn shadeText(in : VSOut, fw : vec2<f32>) -> TextFragment {
 		in.color,
 		model.params.x,
 		in.fx.x,
+		1.0,
 		in.fx.y,
 		in.fx.z,
 	);
@@ -39634,7 +39829,8 @@ var Renderer3D = class {
 				height: c.opts.height,
 				textureExtent: c.opts.textureExtent,
 				opacity: c.opts.opacity,
-				colorTint: c.opts.colorTint
+				colorTint: c.opts.colorTint,
+				relief: c.opts.relief
 			});
 		}
 		pass.end();
@@ -39898,7 +40094,8 @@ var Renderer3D = class {
 			metallic,
 			emissive: opts.emissive,
 			emissiveIntensity: opts.emissiveIntensity,
-			matte: opts.matte
+			matte: opts.matte,
+			relief: opts.relief
 		}, useMrt, this.passWritesHdr);
 	}
 	/** T(pos) * Rz * Ry * Rx * S, or the draw's precomputed model matrix. */
@@ -41377,5 +41574,5 @@ var NodeSurfaceProvider = class {
 if (typeof globalThis !== "undefined") globalThis.__GATEWAI_DELAYS__ = globalThis.__GATEWAI_DELAYS__ || /* @__PURE__ */ new Set();
 
 //#endregion
-export { probeVideoSize as $, TextCursorStyleSchema as $t, emojiGraphemes as A, evaluateVolumetricFormation as An, ChromaticGlitchConfigSchema as At, jointMatrices as B, waveToCubicBeziers as Bn, LongShadowConfigSchema as Bt, drawGifNode as C, evaluateCubicBezierDerivative as Cn, AdvancedTextAnimatorBuilder as Ct, drawSignalNode as D, evaluateSkewMatrix as Dn, AnimatableGlyphPropsSchema as Dt, drawParagraphNode as E, evaluateSelectorCombination as En, AnchorPresetSchema as Et, getPrimitiveGeometry as F, parseSvgPathToCubicBeziers as Fn, ExtendedGlyphPropertiesSchema as Ft, measureMaxCaptionHeight as G, SelectorUnitsSchema as Gt, loadModel3D as H, SelectorBasedOnSchema as Ht, getRegisteredFontSource as I, sampleAudioSpectrumScale as In, GlyphAnchorGroupingSchema as It, parseFBX as J, Spatial3DPropertiesSchema as Jt, mediaDecoderCache as K, SignalRegistry as Kt, getRenderer2D as L, sampleCurveGeometry as Ln, GlyphAnchorPointSchema as Lt, fitSpansToText as M, generatePathSegments as Mn, DynamicStrokePropertiesSchema as Mt, generateExtrudedTextGeometry as N, getScramblePool as Nn, EnhancedTextNodeSchema as Nt, drawSvgNode as O, evaluateSpringProgress as On, AudioSignalComputePipeline as Ot, getHeadlessFontPath as P, getShuffledOrder as Pn, ExpressionSelectorSchema as Pt, poseNodes as Q, TextCursorConfigSchema as Qt, initHeadlessWebGPU as R, samplePathChainGeometry as Rn, KineticMarqueeConfigSchema as Rt, drawCaptionNode as S, evaluateCubicBezier as Sn, AETextAnimatorSchema as St, drawLottieNode as T, evaluateMarqueeOffset as Tn, AnchorGroupingSchema as Tt, loadOBJ as U, SelectorModeSchema as Ut, loadFBX as V, ParticleDissolveConfigSchema as Vt, lutStore as W, SelectorShapeSchema as Wt, parseOBJ as X, TextAnchorConfigSchema as Xt, parseMTL as Y, SpringPhysicsSchema as Yt, parseSvgPathToSegments as Z, TextAnimatorBuilder as Zt, buildShapeSvgPath as _, computeLineLeadingDisplacement as _n, Path3D as _t, GlassPipeline as a, TextSelectorSchema as an, spansText as at, colorMatrixWgsl as b, distanceToCurveParameter as bn, parseColorToRgb as bt, Renderer2D as c, TypewriterAnimatorSchema as cn, trackAudioPitch as ct, ScreenSpaceRelightPipeline as d, Vec2Schema as dn, Camera3D as dt, TextPathBuilder as en, registerHeadlessFont as et, ShadowPipeline as f, VolumetricFormationConfigSchema as fn, ENVIRONMENT_PRESETS as ft, WebGPUAudioProcessor as g, computeAnchorPivotOffset as gn, Matrix4Math as gt, SlugPipeline as h, buildWGSLSignalFn as hn, MAX_LIGHTS as ht, EffectPipeline as i, TextScrambleConfigSchema as in, shaderStore as it, ensureDevice as j, generateArcLengthLUT as jn, CubicBezierSegmentSchema as jt, drawVideoNode as k, evaluateTypewriterState as kn, AudioSpectrumTypographySchema as kt, Renderer3D as l, TypingCadenceSchema as ln, GetFontAssetUrl as lt, SlugGeometry as m, buildPathLUT as mn, Light3D as mt, AudioLatentTrackCache as n, TextPathSourceSchema as nn, sampleMorphWeights as nt, MotionBlurPipeline as o, TextSignalSelectorSchema as on, srtLoader as ot, SlugFontCache as p, VolumetricFormationModeSchema as pn, LIGHT_UNIFORM_SIZE_BYTES as pt, parseColor as q, SkewPropertiesSchema as qt, AudioMeshDeformPipeline as r, TextRangeSelectorSchema as rn, setRegisteredFontSource as rt, NodeSurfaceProvider as s, TextWigglySelectorSchema as sn, textureCache as st, AudioLatentEngine as t, TextPathOptionsSchema as tn, resolveTextSpans as tt, SSAOPipeline as u, VariableFontAxesSchema as un, resolveMediaSourceUrl as ut, clearAllVideoCache as v, computeRangeSelectorWeight as vn, Vector3Math as vt, drawImageNode as w, evaluateExpressionSelector as wn, AdvancedTextAnimatorSchema as wt, describeGpu as x, ellipseToCubicBeziers as xn, resolveEnvironment as xt, clearHeadlessFonts as y, deterministicWigglyNoise as yn, linearRgb as yt, inputStore as z, signalRegistry as zn, LineSpacingDynamicsSchema as zt };
-//# sourceMappingURL=dist-CWLLnigL.mjs.map
+export { probeVideoSize as $, TextCursorConfigSchema as $t, emojiGraphemes as A, evaluateTypewriterState as An, AudioSpectrumTypographySchema as At, jointMatrices as B, signalRegistry as Bn, LineSpacingDynamicsSchema as Bt, drawGifNode as C, evaluateCubicBezier as Cn, AETextAnimatorSchema as Ct, drawSignalNode as D, evaluateSelectorCombination as Dn, AnchorPresetSchema as Dt, drawParagraphNode as E, evaluateMarqueeOffset as En, AnchorGroupingSchema as Et, getPrimitiveGeometry as F, getShuffledOrder as Fn, ExpressionSelectorSchema as Ft, measureMaxCaptionHeight as G, SelectorShapeSchema as Gt, loadModel3D as H, ParticleDissolveConfigSchema as Ht, getRegisteredFontSource as I, parseSvgPathToCubicBeziers as In, ExtendedGlyphPropertiesSchema as It, parseFBX as J, SkewPropertiesSchema as Jt, mediaDecoderCache as K, SelectorUnitsSchema as Kt, getRenderer2D as L, sampleAudioSpectrumScale as Ln, GlyphAnchorGroupingSchema as Lt, fitSpansToText as M, generateArcLengthLUT as Mn, CubicBezierSegmentSchema as Mt, generateExtrudedTextGeometry as N, generatePathSegments as Nn, DynamicStrokePropertiesSchema as Nt, drawSvgNode as O, evaluateSkewMatrix as On, AnimatableGlyphPropsSchema as Ot, getHeadlessFontPath as P, getScramblePool as Pn, EnhancedTextNodeSchema as Pt, poseNodes as Q, TextAnimatorBuilder as Qt, initHeadlessWebGPU as R, sampleCurveGeometry as Rn, GlyphAnchorPointSchema as Rt, drawCaptionNode as S, ellipseToCubicBeziers as Sn, resolveEnvironment as St, drawLottieNode as T, evaluateExpressionSelector as Tn, AdvancedTextAnimatorSchema as Tt, loadOBJ as U, SelectorBasedOnSchema as Ut, loadFBX as V, waveToCubicBeziers as Vn, LongShadowConfigSchema as Vt, lutStore as W, SelectorModeSchema as Wt, parseOBJ as X, SpringPhysicsSchema as Xt, parseMTL as Y, Spatial3DPropertiesSchema as Yt, parseSvgPathToSegments as Z, TextAnchorConfigSchema as Zt, buildShapeSvgPath as _, computeAnchorPivotOffset as _n, Matrix4Math as _t, GlassPipeline as a, TextScrambleConfigSchema as an, spansText as at, colorMatrixWgsl as b, deterministicWigglyNoise as bn, linearRgb as bt, Renderer2D as c, TextWigglySelectorSchema as cn, trackAudioPitch as ct, ScreenSpaceRelightPipeline as d, VariableFontAxesSchema as dn, resolveMediaSourceUrl as dt, TextCursorStyleSchema as en, registerHeadlessFont as et, ShadowPipeline as f, Vec2Schema as fn, Camera3D as ft, WebGPUAudioProcessor as g, buildWGSLSignalFn as gn, MAX_LIGHTS as gt, SlugPipeline as h, buildPathLUT as hn, Light3D as ht, EffectPipeline as i, TextRangeSelectorSchema as in, shaderStore as it, ensureDevice as j, evaluateVolumetricFormation as jn, ChromaticGlitchConfigSchema as jt, drawVideoNode as k, evaluateSpringProgress as kn, AudioSignalComputePipeline as kt, Renderer3D as l, TypewriterAnimatorSchema as ln, transformScale as lt, SlugGeometry as m, VolumetricFormationModeSchema as mn, LIGHT_UNIFORM_SIZE_BYTES as mt, AudioLatentTrackCache as n, TextPathOptionsSchema as nn, sampleMorphWeights as nt, MotionBlurPipeline as o, TextSelectorSchema as on, srtLoader as ot, SlugFontCache as p, VolumetricFormationConfigSchema as pn, ENVIRONMENT_PRESETS as pt, parseColor as q, SignalRegistry as qt, AudioMeshDeformPipeline as r, TextPathSourceSchema as rn, setRegisteredFontSource as rt, NodeSurfaceProvider as s, TextSignalSelectorSchema as sn, textureCache as st, AudioLatentEngine as t, TextPathBuilder as tn, resolveTextSpans as tt, SSAOPipeline as u, TypingCadenceSchema as un, GetFontAssetUrl as ut, clearAllVideoCache as v, computeLineLeadingDisplacement as vn, Path3D as vt, drawImageNode as w, evaluateCubicBezierDerivative as wn, AdvancedTextAnimatorBuilder as wt, describeGpu as x, distanceToCurveParameter as xn, parseColorToRgb as xt, clearHeadlessFonts as y, computeRangeSelectorWeight as yn, Vector3Math as yt, inputStore as z, samplePathChainGeometry as zn, KineticMarqueeConfigSchema as zt };
+//# sourceMappingURL=dist-B-OPY7Cs.mjs.map