insomni 0.2.0-alpha.0

package/dist/viewport.mjs

@@ -0,0 +1,274 @@
+import { n as createFrame } from "./frame-mHNdKRpF.mjs";
+//#region src/viewport.ts
+function resolveAxisMargin(spec) {
+	if (spec === void 0) return {
+		x: 0,
+		y: 0
+	};
+	if (typeof spec === "number") return {
+		x: spec,
+		y: spec
+	};
+	return {
+		x: spec.x ?? 0,
+		y: spec.y ?? 0
+	};
+}
+function resolveMargins(opts) {
+	return {
+		overshoot: resolveAxisMargin(opts.overshoot),
+		drift: resolveAxisMargin(opts.drift)
+	};
+}
+/**
+* Shift the visible range along one axis so the content range stays in (or
+* near) view. Returns the delta to apply to the visible endpoints.
+*/
+function clampOffset(s0, V, c0, L, overshoot, drift) {
+	const offset = s0 - c0;
+	let lo;
+	let hi;
+	if (V < L) {
+		const m = Math.abs(overshoot) * V;
+		lo = -m;
+		hi = L - V + m;
+	} else {
+		const m = Math.abs(drift) * V;
+		lo = L - V - m;
+		hi = m;
+	}
+	if (offset < lo) return lo - offset;
+	if (offset > hi) return hi - offset;
+	return 0;
+}
+function clampCameraState(state) {
+	const bounds = state.panBounds;
+	if (!bounds) return false;
+	const z = state.camera.zoom;
+	if (!Number.isFinite(z) || z <= 0) return false;
+	const fw = state.frame.width;
+	const fh = state.frame.height;
+	const Vx = fw / z;
+	const Vy = fh / z;
+	const c = bounds.content;
+	const m = bounds.margins;
+	let changed = false;
+	if (Vx > 0) {
+		const dx = clampOffset(state.camera.x - Vx / 2, Vx, c.x, c.width, m.overshoot.x, m.drift.x);
+		if (dx !== 0) {
+			state.camera.x += dx;
+			changed = true;
+		}
+	}
+	if (Vy > 0) {
+		const dy = clampOffset(state.camera.y - Vy / 2, Vy, c.y, c.height, m.overshoot.y, m.drift.y);
+		if (dy !== 0) {
+			state.camera.y += dy;
+			changed = true;
+		}
+	}
+	return changed;
+}
+function createViewport(options) {
+	const frame = options.frame;
+	const parent = options.parent ?? null;
+	const init = options.camera ?? {};
+	const camera = {
+		x: init.x ?? 0,
+		y: init.y ?? 0,
+		zoom: init.zoom ?? 1,
+		rotation: init.rotation ?? 0
+	};
+	const state = {
+		mode: "camera",
+		frame,
+		parent,
+		listeners: /* @__PURE__ */ new Set(),
+		notifying: false,
+		clipRect: {
+			x: frame.x,
+			y: frame.y,
+			width: frame.width,
+			height: frame.height
+		},
+		camera,
+		baseCamera: { ...camera },
+		panBounds: options.panBounds ? {
+			content: options.panBounds.content,
+			margins: resolveMargins(options.panBounds)
+		} : null
+	};
+	clampCameraState(state);
+	state.baseCamera.x = state.camera.x;
+	state.baseCamera.y = state.camera.y;
+	const notify = () => notifyListeners(state);
+	return {
+		mode: "camera",
+		get frame() {
+			return state.frame;
+		},
+		get absoluteFrame() {
+			return absoluteFrame(state);
+		},
+		get parent() {
+			return state.parent;
+		},
+		get clipRect() {
+			return refreshClipRect(state);
+		},
+		get camera() {
+			return { ...state.camera };
+		},
+		panBy(dxPx, dyPx) {
+			if (dxPx === 0 && dyPx === 0) return;
+			const z = state.camera.zoom;
+			if (z === 0) return;
+			state.camera.x -= dxPx / z;
+			state.camera.y -= dyPx / z;
+			clampCameraState(state);
+			notify();
+		},
+		zoomAt(anchorSx, anchorSy, factor) {
+			const fx = typeof factor === "number" ? factor : factor.x ?? 1;
+			const fy = typeof factor === "number" ? factor : factor.y ?? 1;
+			const factorValue = fx === fy ? fx : Math.sqrt(fx * fy);
+			if (!Number.isFinite(factorValue) || factorValue <= 0 || factorValue === 1) return;
+			const abs = absoluteFrame(state);
+			const lx = anchorSx - abs.x;
+			const ly = anchorSy - abs.y;
+			const px = lx - abs.width / 2;
+			const py = ly - abs.height / 2;
+			const curZoom = state.camera.zoom;
+			const newZoom = curZoom * factorValue;
+			if (newZoom === curZoom) return;
+			const dz = 1 / curZoom - 1 / newZoom;
+			state.camera.x += px * dz;
+			state.camera.y += py * dz;
+			state.camera.zoom = newZoom;
+			clampCameraState(state);
+			notify();
+		},
+		reset() {
+			const b = state.baseCamera;
+			const c = state.camera;
+			if (c.x === b.x && c.y === b.y && c.zoom === b.zoom && c.rotation === b.rotation) return;
+			c.x = b.x;
+			c.y = b.y;
+			c.zoom = b.zoom;
+			c.rotation = b.rotation;
+			notify();
+		},
+		setFrame(nextFrame) {
+			if (sameFrame(state.frame, nextFrame)) {
+				state.frame = nextFrame;
+				return;
+			}
+			state.frame = nextFrame;
+			refreshClipRect(state);
+			clampCameraState(state);
+			notify();
+		},
+		setCamera(next) {
+			const c = state.camera;
+			const nx = next.x ?? c.x;
+			const ny = next.y ?? c.y;
+			const nz = next.zoom ?? c.zoom;
+			const nr = next.rotation ?? c.rotation;
+			if (nx === c.x && ny === c.y && nz === c.zoom && nr === c.rotation) return;
+			c.x = nx;
+			c.y = ny;
+			c.zoom = nz;
+			c.rotation = nr;
+			clampCameraState(state);
+			notify();
+		},
+		jumpCamera(next) {
+			this.setCamera(next);
+		},
+		screenToWorld(sx, sy) {
+			const abs = absoluteFrame(state);
+			const z = state.camera.zoom || 1;
+			const px = sx - (abs.x + abs.width / 2);
+			const py = sy - (abs.y + abs.height / 2);
+			return {
+				x: px / z + state.camera.x,
+				y: py / z + state.camera.y
+			};
+		},
+		worldToScreen(wx, wy) {
+			const abs = absoluteFrame(state);
+			const z = state.camera.zoom || 1;
+			return {
+				x: (wx - state.camera.x) * z + abs.x + abs.width / 2,
+				y: (wy - state.camera.y) * z + abs.y + abs.height / 2
+			};
+		},
+		setPanBounds(panBounds) {
+			state.panBounds = panBounds ? {
+				content: panBounds.content,
+				margins: resolveMargins(panBounds)
+			} : null;
+			if (clampCameraState(state)) notify();
+		},
+		onChange(cb) {
+			state.listeners.add(cb);
+			return () => {
+				state.listeners.delete(cb);
+			};
+		},
+		_state: state
+	};
+}
+function absoluteFrame(state) {
+	if (!state.parent) return state.frame;
+	const parentAbs = state.parent.absoluteFrame;
+	if (parentAbs.x === 0 && parentAbs.y === 0) return state.frame;
+	return createFrame({
+		x: state.frame.x + parentAbs.x,
+		y: state.frame.y + parentAbs.y,
+		width: state.frame.width,
+		height: state.frame.height
+	});
+}
+function refreshClipRect(state) {
+	const abs = absoluteFrame(state);
+	const rect = state.clipRect;
+	rect.x = abs.x;
+	rect.y = abs.y;
+	rect.width = abs.width;
+	rect.height = abs.height;
+	return rect;
+}
+function notifyListeners(state) {
+	if (state.notifying) return;
+	state.notifying = true;
+	try {
+		for (const cb of state.listeners) cb();
+	} finally {
+		state.notifying = false;
+	}
+}
+function sameFrame(a, b) {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;
+}
+/**
+* Compute the world-space AABB visible within the camera viewport's frame
+* (or a sub-rect of it). Useful for hit-testing and manual culling logic —
+* `Renderer2D` applies render-time cull automatically.
+*
+* Rotation is ignored — the returned rect is the non-rotated AABB, which is
+* a conservative over-approximation when the camera is rotated.
+*/
+function worldCullBounds(viewport, rect) {
+	const r = rect ?? viewport.absoluteFrame;
+	const tl = viewport.screenToWorld(r.x, r.y);
+	const br = viewport.screenToWorld(r.x + r.width, r.y + r.height);
+	return {
+		x: Math.min(tl.x, br.x),
+		y: Math.min(tl.y, br.y),
+		width: Math.abs(br.x - tl.x),
+		height: Math.abs(br.y - tl.y)
+	};
+}
+//#endregion
+export { createViewport, worldCullBounds };

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "insomni",
+  "version": "0.2.0-alpha.0",
+  "description": "A WebGPU rendering engine.",
+  "license": "GPL-3.0",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./advanced": {
+      "types": "./dist/advanced.d.mts",
+      "default": "./dist/advanced.mjs"
+    },
+    "./internal": {
+      "types": "./dist/internal.d.mts",
+      "default": "./dist/internal.mjs"
+    },
+    "./particles": {
+      "types": "./dist/particles.d.mts",
+      "default": "./dist/particles.mjs"
+    },
+    "./reactivity": {
+      "types": "./dist/reactivity.d.mts",
+      "default": "./dist/reactivity.mjs"
+    },
+    "./spatial": {
+      "types": "./dist/spatial.d.mts",
+      "default": "./dist/spatial.mjs"
+    },
+    "./text-ttf": {
+      "types": "./dist/text-ttf.d.mts",
+      "default": "./dist/text-ttf.mjs"
+    },
+    "./viewport": {
+      "types": "./dist/viewport.d.mts",
+      "default": "./dist/viewport.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@chenglou/pretext": "^0.0.5",
+    "@dirtytalk/engine": "^0.0.3",
+    "@dirtytalk/spatial": "^0.0.3",
+    "earcut": "^2.2.4",
+    "typegpu": "^0.10.2",
+    "insomni-msdf-text": "0.1.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/earcut": "^2.1.4",
+    "@vitest/browser-playwright": "^4.0.0",
+    "playwright": "^1.56.0",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.23"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "test:browser": "vp test -c vite.browser-test.config.ts",
+    "check": "vp check"
+  }
+}