insomni 0.2.0-alpha.0

package/dist/root-CHradZKM.mjs

@@ -0,0 +1,30 @@
+import tgpu from "typegpu";
+//#region src/core/root.ts
+const ROOT_CACHE = /* @__PURE__ */ new WeakMap();
+function isRoot(value) {
+	return typeof value === "object" && value !== null && "device" in value && "configureContext" in value && "createBuffer" in value;
+}
+function getOrCreateRoot(device) {
+	let root = ROOT_CACHE.get(device);
+	if (!root) {
+		root = tgpu.initFromDevice({ device });
+		ROOT_CACHE.set(device, root);
+	}
+	return root;
+}
+function resolveRoot(owner) {
+	if (isRoot(owner)) {
+		ROOT_CACHE.set(owner.device, owner);
+		return owner;
+	}
+	if (typeof owner === "object" && owner !== null && "device" in owner) {
+		if (owner.root) {
+			ROOT_CACHE.set(owner.device, owner.root);
+			return owner.root;
+		}
+		return getOrCreateRoot(owner.device);
+	}
+	return getOrCreateRoot(owner);
+}
+//#endregion
+export { resolveRoot as n, getOrCreateRoot as t };

package/dist/shape-DfZP9Jdk.mjs

@@ -0,0 +1,349 @@
+//#region src/text/shape.ts
+const SPACE_CP = 32;
+const LF_CP = 10;
+const HIGH_SURROGATE_START = 55296;
+/**
+* Shape `text` starting at world-space origin (x, y).
+*
+* Origin convention: y is the *top* of the first line. Subsequent lines are
+* below (higher y).
+*/
+function shapeText(text, font, atlas, x, y, options) {
+	const { fontSize, align = "left", maxWidth, lineHeight = fontSize * 1.2, simple = false } = options;
+	if (simple) return shapeSingleLine(text, font, atlas, x, y, fontSize, align, lineHeight, false);
+	if (align === "left" && maxWidth === void 0 && text.indexOf("\n") < 0) return shapeSingleLine(text, font, atlas, x, y, fontSize, "left", lineHeight, true);
+	const hardLines = text.split("\n");
+	const lines = [];
+	for (const hl of hardLines) {
+		if (maxWidth === void 0) {
+			lines.push(hl);
+			continue;
+		}
+		wrapLine(hl, font, atlas, fontSize, maxWidth, lines);
+	}
+	const glyphs = [];
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX_ = -Infinity;
+	let maxY_ = -Infinity;
+	let maxLineWidth = 0;
+	for (let li = 0; li < lines.length; li++) {
+		const line = lines[li];
+		if (line.length === 0) continue;
+		const lineWidth = measureLineWidth(line, font, atlas, fontSize, false);
+		if (lineWidth > maxLineWidth) maxLineWidth = lineWidth;
+		let cursorX = x;
+		if (align === "center") cursorX = x - lineWidth / 2;
+		else if (align === "right") cursorX = x - lineWidth;
+		const lineTopY = y + li * lineHeight;
+		let prevCp = -1;
+		for (const ch of line) {
+			const cp = ch.codePointAt(0);
+			const g = atlas.getGlyph(cp);
+			if (!g) {
+				prevCp = cp;
+				continue;
+			}
+			if (prevCp >= 0) cursorX += font.getKerning(prevCp, cp) * fontSize;
+			if (g.width > 0 && g.height > 0) {
+				const wx = cursorX + g.bearingX * fontSize;
+				const wy = lineTopY + (font.ascender - g.bearingY) * fontSize;
+				const ww = g.width * fontSize;
+				const wh = g.height * fontSize;
+				glyphs.push({
+					glyph: g,
+					worldX: wx,
+					worldY: wy,
+					worldW: ww,
+					worldH: wh
+				});
+				if (wx < minX) minX = wx;
+				if (wy < minY) minY = wy;
+				if (wx + ww > maxX_) maxX_ = wx + ww;
+				if (wy + wh > maxY_) maxY_ = wy + wh;
+			}
+			cursorX += g.advance * fontSize;
+			prevCp = cp;
+		}
+	}
+	const totalHeight = lines.length * lineHeight;
+	if (!isFinite(minX)) return {
+		glyphs,
+		bbox: {
+			minX: x,
+			minY: y,
+			maxX: x,
+			maxY: y + totalHeight
+		},
+		height: totalHeight,
+		lineCount: lines.length,
+		maxLineWidth
+	};
+	return {
+		glyphs,
+		bbox: {
+			minX,
+			minY,
+			maxX: maxX_,
+			maxY: maxY_
+		},
+		height: totalHeight,
+		lineCount: lines.length,
+		maxLineWidth
+	};
+}
+/**
+* Single-pass single-line shaper. One walk over the chars: places glyphs and
+* tracks the running max-x in the same loop, so there's no pre-measure pass.
+*
+* `kerning=false` skips the kerning lookup entirely (simple mode).
+*/
+function shapeSingleLine(text, font, atlas, x, y, fontSize, align, lineHeight, kerning) {
+	const glyphs = [];
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX_ = -Infinity;
+	let maxY_ = -Infinity;
+	let cursor = 0;
+	let prevCp = -1;
+	const len = text.length;
+	for (let i = 0; i < len; i++) {
+		let cp = text.charCodeAt(i);
+		if (cp >= HIGH_SURROGATE_START) {
+			cp = text.codePointAt(i);
+			if (cp > 65535) i++;
+		}
+		const g = atlas.getGlyph(cp);
+		if (!g) {
+			prevCp = cp;
+			continue;
+		}
+		if (kerning && prevCp >= 0) cursor += font.getKerning(prevCp, cp) * fontSize;
+		if (g.width > 0 && g.height > 0) {
+			const wx = cursor + g.bearingX * fontSize;
+			const wy = y + (font.ascender - g.bearingY) * fontSize;
+			const ww = g.width * fontSize;
+			const wh = g.height * fontSize;
+			glyphs.push({
+				glyph: g,
+				worldX: wx,
+				worldY: wy,
+				worldW: ww,
+				worldH: wh
+			});
+			if (wx < minX) minX = wx;
+			if (wy < minY) minY = wy;
+			if (wx + ww > maxX_) maxX_ = wx + ww;
+			if (wy + wh > maxY_) maxY_ = wy + wh;
+		}
+		cursor += g.advance * fontSize;
+		prevCp = cp;
+	}
+	const lineWidth = cursor;
+	let shift = x;
+	if (align === "center") shift = x - lineWidth / 2;
+	else if (align === "right") shift = x - lineWidth;
+	if (shift !== 0) {
+		for (let k = 0; k < glyphs.length; k++) glyphs[k].worldX += shift;
+		minX += shift;
+		maxX_ += shift;
+	}
+	if (!isFinite(minX)) return {
+		glyphs,
+		bbox: {
+			minX: x,
+			minY: y,
+			maxX: x,
+			maxY: y + lineHeight
+		},
+		height: lineHeight,
+		lineCount: 1,
+		maxLineWidth: lineWidth
+	};
+	return {
+		glyphs,
+		bbox: {
+			minX,
+			minY,
+			maxX: maxX_,
+			maxY: maxY_
+		},
+		height: lineHeight,
+		lineCount: 1,
+		maxLineWidth: lineWidth
+	};
+}
+const TEXT_INSTANCE_FLOATS_LOCAL = 10;
+/**
+* Single-line shaper that writes glyph floats directly into the caller's
+* instance Float32Array. Skips the ShapedGlyph[] intermediate entirely — the
+* caller is expected to write `blockId` into slots 8/9 of each instance after
+* style interning.
+*
+* `out` must have room for at least `text.length * TEXT_INSTANCE_FLOATS`
+* floats past `floatOffset`.
+*/
+function shapeAndPackSingleLine(text, font, atlas, x, y, fontSize, align, kerning, lineHeight, out, floatOffset) {
+	let off = floatOffset;
+	let cursor = 0;
+	let prevCp = -1;
+	let minX = Infinity;
+	let minY = Infinity;
+	let maxX_ = -Infinity;
+	let maxY_ = -Infinity;
+	let written = 0;
+	const len = text.length;
+	const baseY = y + font.ascender * fontSize;
+	for (let i = 0; i < len; i++) {
+		let cp = text.charCodeAt(i);
+		if (cp >= HIGH_SURROGATE_START) {
+			cp = text.codePointAt(i);
+			if (cp > 65535) i++;
+		}
+		const g = atlas.getGlyph(cp);
+		if (!g) {
+			prevCp = cp;
+			continue;
+		}
+		if (kerning && prevCp >= 0) cursor += font.getKerning(prevCp, cp) * fontSize;
+		const gw = g.width;
+		const gh = g.height;
+		if (gw > 0 && gh > 0) {
+			const wx = cursor + g.bearingX * fontSize;
+			const wy = baseY - g.bearingY * fontSize;
+			const ww = gw * fontSize;
+			const wh = gh * fontSize;
+			out[off] = wx;
+			out[off + 1] = wy;
+			out[off + 2] = ww;
+			out[off + 3] = wh;
+			out[off + 4] = g.uvMinX;
+			out[off + 5] = g.uvMinY;
+			out[off + 6] = g.uvMaxX;
+			out[off + 7] = g.uvMaxY;
+			off += TEXT_INSTANCE_FLOATS_LOCAL;
+			written++;
+			if (wx < minX) minX = wx;
+			if (wy < minY) minY = wy;
+			if (wx + ww > maxX_) maxX_ = wx + ww;
+			if (wy + wh > maxY_) maxY_ = wy + wh;
+		}
+		cursor += g.advance * fontSize;
+		prevCp = cp;
+	}
+	let shift = x;
+	if (align === "center") shift = x - cursor / 2;
+	else if (align === "right") shift = x - cursor;
+	if (shift !== 0 && written > 0) {
+		let p = floatOffset;
+		for (let k = 0; k < written; k++) {
+			out[p] += shift;
+			p += TEXT_INSTANCE_FLOATS_LOCAL;
+		}
+		minX += shift;
+		maxX_ += shift;
+	}
+	if (written === 0) return {
+		glyphCount: 0,
+		minX: x,
+		minY: y,
+		maxX: x,
+		maxY: y + lineHeight,
+		lineWidth: cursor,
+		lineHeight
+	};
+	return {
+		glyphCount: written,
+		minX,
+		minY,
+		maxX: maxX_,
+		maxY: maxY_,
+		lineWidth: cursor,
+		lineHeight
+	};
+}
+/**
+* Measure-only fast path. Walks advances + (optional) kerning without
+* allocating any glyph objects or computing positions. Returns the laid-out
+* width of a single line.
+*/
+function measureBlockWidth(text, font, atlas, fontSize, simple = false) {
+	let max = 0;
+	let lineStart = 0;
+	const len = text.length;
+	for (let i = 0; i <= len; i++) if (i === len || text.charCodeAt(i) === LF_CP) {
+		if (i > lineStart) {
+			const w = measureLineRange(text, lineStart, i, font, atlas, fontSize, !simple);
+			if (w > max) max = w;
+		}
+		lineStart = i + 1;
+	}
+	return max;
+}
+function measureLineWidth(line, font, atlas, fontSize, simple) {
+	return measureLineRange(line, 0, line.length, font, atlas, fontSize, !simple);
+}
+function measureLineRange(s, start, end, font, atlas, fontSize, kerning) {
+	let w = 0;
+	let prevCp = -1;
+	for (let i = start; i < end; i++) {
+		let cp = s.charCodeAt(i);
+		if (cp >= HIGH_SURROGATE_START) {
+			cp = s.codePointAt(i);
+			if (cp > 65535) i++;
+		}
+		const g = atlas.getGlyph(cp);
+		if (!g) {
+			prevCp = cp;
+			continue;
+		}
+		if (kerning && prevCp >= 0) w += font.getKerning(prevCp, cp) * fontSize;
+		w += g.advance * fontSize;
+		prevCp = cp;
+	}
+	return w;
+}
+/**
+* Greedy whitespace-based wrapping. Pushes wrapped lines into `out`.
+* Single words longer than `maxWidth` are placed on their own line uncut.
+*/
+function wrapLine(line, font, atlas, fontSize, maxWidth, out) {
+	if (line.length === 0) {
+		out.push("");
+		return;
+	}
+	const tokens = [];
+	let i = 0;
+	while (i < line.length) {
+		let j = i;
+		while (j < line.length && line.charCodeAt(j) === SPACE_CP) j++;
+		if (j > i) tokens.push({
+			text: line.slice(i, j),
+			width: 0
+		});
+		const wordStart = j;
+		while (j < line.length && line.charCodeAt(j) !== SPACE_CP) j++;
+		if (j > wordStart) tokens.push({
+			text: line.slice(wordStart, j),
+			width: 0
+		});
+		i = j;
+	}
+	for (const t of tokens) t.width = measureLineWidth(t.text, font, atlas, fontSize, false);
+	let buf = "";
+	let bufW = 0;
+	for (const t of tokens) {
+		if (buf.length === 0 && t.text.charCodeAt(0) === SPACE_CP) continue;
+		if (bufW + t.width > maxWidth && buf.length > 0) {
+			out.push(buf);
+			buf = "";
+			bufW = 0;
+			if (t.text.charCodeAt(0) === SPACE_CP) continue;
+		}
+		buf += t.text;
+		bufW += t.width;
+	}
+	if (buf.length > 0) out.push(buf);
+}
+//#endregion
+export { shapeAndPackSingleLine as n, shapeText as r, measureBlockWidth as t };