shaders 3.0.453 → 3.1.455

package/dist/core/compute-Ax-p6Ubc.js

@@ -1,31 +0,0 @@
-import { qt as arrayOf } from "./edges-B7Yet3LV.js";
-function wrapGuarded(guarded, size) {
-	return {
-		guarded,
-		with(bindGroup) {
-			return wrapGuarded(guarded.with(bindGroup), size);
-		},
-		dispatch() {
-			if (!size) throw new Error("[gpu] KitComputePipeline.dispatch(): no pre-bound size — pass opts.size to createGuardedCompute or call dispatchThreads(...) directly");
-			guarded.dispatchThreads(...size);
-		},
-		dispatchThreads(...threads) {
-			guarded.dispatchThreads(...threads);
-		}
-	};
-}
-function createGuardedCompute(root, callback, opts = {}) {
-	let guarded = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createGuardedComputePipeline(callback), "guarded");
-	if (opts.bindGroup) guarded = guarded.with(opts.bindGroup);
-	return wrapGuarded(guarded, opts.size);
-}
-function createComputeDispatcher(root) {
-	return { dispatch(steps) {
-		for (const step of steps) if (typeof step === "function") step();
-		else step.dispatch();
-	} };
-}
-function createStateBuffer(root, schema, count) {
-	return (/* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createBuffer(arrayOf(schema, count)), "buffer")).$usage("storage");
-}
-export { createGuardedCompute as n, createStateBuffer as r, createComputeDispatcher as t };

package/dist/core/dataEncoding-CEmpiitu.js

@@ -1,24 +0,0 @@
-var _f32Scratch = new Float32Array(1);
-var _i32Scratch = new Int32Array(_f32Scratch.buffer);
-function toHalfFloat(val) {
-	_f32Scratch[0] = Math.max(-65504, Math.min(65504, val));
-	const x = _i32Scratch[0];
-	let bits = x >> 16 & 32768;
-	let m = x >> 12 & 2047;
-	const e = x >> 23 & 255;
-	if (e < 103) return bits;
-	if (e > 142) {
-		bits |= 31744;
-		bits |= (e === 255 ? 0 : 1) && x & 8388607;
-		return bits;
-	}
-	if (e < 113) {
-		m |= 2048;
-		bits |= (m >> 114 - e) + (m >> 113 - e & 1);
-		return bits;
-	}
-	bits |= e - 112 << 10 | m >> 1;
-	bits += m & 1;
-	return bits;
-}
-export { toHalfFloat as t };

package/dist/core/device-BODv_4aH.js

@@ -1,10 +0,0 @@
-function isMobileGpuViewport() {
-	if (typeof window === "undefined") return false;
-	const coarse = !!(window.matchMedia && window.matchMedia("(pointer: coarse)").matches);
-	const cssLong = Math.max(window.innerWidth || 0, window.innerHeight || 0);
-	return coarse && cssLong > 0 && cssLong <= 1366;
-}
-function maxPixelRatioForDevice() {
-	return isMobileGpuViewport() ? 1.5 : 2;
-}
-export { maxPixelRatioForDevice as n, isMobileGpuViewport as t };

package/dist/core/gpu/kit/effects/prism.d.ts

@@ -1,111 +0,0 @@
-import { d } from '../index';
-import { Expr, GpuFragmentParams } from '../../contract';
-
-/**
- * Config uniform keys the prism builder reads. `center`/`scale`/
- * `rotation` + the beam/fan/body appearance props are read on the GPU via `params.uniforms.<key>`;
- * `shape`/`beamAngle`/`beamOffset`/`beamLength`/`refraction`/`dispersion`/`bounces` are read on the
- * CPU via `params.getCpuValue(<key>)` for the per-frame trace.
- */
-export interface PrismEffectUniforms {
-    center: unknown;
-    scale: unknown;
-    rotation: unknown;
-    shape: unknown;
-    refraction: unknown;
-    dispersion: unknown;
-    bounces: unknown;
-    beamAngle: unknown;
-    beamOffset: unknown;
-    beamWidth: unknown;
-    beamLength: unknown;
-    beamIntensity: unknown;
-    beamColor: unknown;
-    internalGlow: unknown;
-    fanIntensity: unknown;
-    saturation: unknown;
-    separation: unknown;
-    fanFalloff: unknown;
-    bodyColor: unknown;
-    bodyOpacity: unknown;
-    rimIntensity: unknown;
-}
-/**
- * The synthetic `extraFields` the trace writes and the fragment reads. The parent's shader
- * definition declares `extraFields: prismTraceExtraFields`. The 12 traced scalars are packed:
- *   uEntry  = (entryA.x, entryA.y, entryB.x, entryB.y)   uEntryActive = 0/1
- *   uSeg0..3 = (a.x, a.y, b.x, b.y) per internal segment  uSegW = (w0, w1, w2, w3)
- *   uExit   = (exitPos.x, exitPos.y, exitDir.x, exitDir.y)
- *   uFan    = (thetaRed, thetaViolet, fanSpread, fanActive)
- *   uShape  = (sides, radius, shapePhi, 0)
- */
-export declare const prismTraceExtraFields: {
-    readonly uEntry: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
-    };
-    readonly uEntryActive: {
-        readonly schema: d.F32;
-        readonly initial: 0;
-    };
-    readonly uSeg0: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
-    };
-    readonly uSeg1: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
-    };
-    readonly uSeg2: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
-    };
-    readonly uSeg3: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 0.5, 0.5];
-    };
-    readonly uSegW: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0, 0, 0, 0];
-    };
-    readonly uExit: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0.5, 0.5, 1, 0];
-    };
-    readonly uFan: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [0, 0, 0, 0];
-    };
-    readonly uShape: {
-        readonly schema: d.Vec4f;
-        readonly initial: readonly [3, 0.3, 0, 0];
-    };
-};
-/** Distance from p to segment a→b plus the parametric t along it. Returns `vec2(dist, t)`. Pure. */
-export declare const prismSegDistT: import('typegpu').TgpuFn<(p: d.Vec2f, a: d.Vec2f, b: d.Vec2f) => d.Vec2f>;
-/** Gaussian cross-section glow: `exp((d/half)² · −2.5)`. Pure — CPU-golden-testable. */
-export declare const prismGauss: import('typegpu').TgpuFn<(dd: d.F32, half: d.F32) => d.F32>;
-/**
- * Spectral colour: smooth wavelength→RGB (no magenta wraparound). `t = 0` → deep red (700nm),
- * `t = 1` → violet (400nm). Gaussian bumps (squared via mul, never pow — NaN for a negative base on
- * the GPU); the small red lobe in the violet band makes violet read as violet. Pure —
- * CPU-golden-testable. (`std.mix(700, 400, t)` is an all-integer mix → the endpoints are `d.f32`-
- * wrapped so it types f32, not i32.)
- */
-export declare const prismSpectral: import('typegpu').TgpuFn<(t: d.F32) => d.Vec3f>;
-/**
- * The full per-pixel prism shade: incoming beam glow + 4 internal-segment glows + spectral exit fan
- * + glassy polygon body. `p` is the field-space position; all traced geometry arrives PACKED (see
- * `prismTraceExtraFields`) and the appearance uniforms follow. Returns `vec4(accum, cover)` (emitted
- * light + coverage). Resolve-goldenable (the sub-fns carry the goldens).
- */
-export declare const prismShade: import('typegpu').TgpuFn<(p: d.Vec2f, uEntry: d.Vec4f, uEntryActive: d.F32, uSeg0: d.Vec4f, uSeg1: d.Vec4f, uSeg2: d.Vec4f, uSeg3: d.Vec4f, uSegW: d.Vec4f, uExit: d.Vec4f, uFan: d.Vec4f, uShape: d.Vec4f, beamWidth: d.F32, beamColor: d.Vec3f, beamIntensity: d.F32, internalGlow: d.F32, fanIntensity: d.F32, saturation: d.F32, separation: d.F32, fanFalloff: d.F32, bodyColor: d.Vec3f, bodyOpacity: d.F32, rimIntensity: d.F32) => d.Vec4f>;
-/**
- * Apply the Prism spectral generator. Composition-time Expr builder — see the file header for the
- * notes. A luminous transparent-interior generator (no child): RGB is emitted light, alpha is
- * coverage; composite over a dark background with `screen` / `linearDodge`.
- *
- * REQUIRES the parent's shader definition to declare `extraFields: prismTraceExtraFields`.
- */
-export declare function applyPrismEffect(params: GpuFragmentParams): Expr;
-//# sourceMappingURL=prism.d.ts.map

package/dist/core/gpu/kit/effects/prism.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"prism.d.ts","sourceRoot":"","sources":["../../../../src/gpu/kit/effects/prism.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAO,CAAC,EAAM,MAAM,UAAU,CAAA;AAErC,OAAO,KAAK,EAAC,IAAI,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAA;AAI3D;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;IAClE,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;IAC1D,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;IAChF,aAAa,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;IACjE,YAAY,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;IACpF,SAAS,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,OAAO,CAAC;IAAC,YAAY,EAAE,OAAO,CAAA;CAClE;AAMD;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWxB,CAAA;AA+HV,oGAAoG;AACpG,eAAO,MAAM,aAAa,2EAOxB,CAAA;AAEF,wFAAwF;AACxF,eAAO,MAAM,UAAU,6DAIrB,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,iDAWxB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,qbAyFjB,CAAA;AAMN;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,iBAAiB,GAAG,IAAI,CA8GhE"}

package/dist/core/naturalSize-BPCi_I-Z.js

@@ -1,24 +0,0 @@
-var registry = /* @__PURE__ */ new Map();
-var listeners = /* @__PURE__ */ new Set();
-function registerNaturalSize(key, width, height) {
-	if (!key || !(width > 0) || !(height > 0)) return;
-	const prev = registry.get(key);
-	if (prev && prev.width === width && prev.height === height) return;
-	registry.set(key, {
-		width,
-		height
-	});
-	for (const fn of listeners) try {
-		fn();
-	} catch {}
-}
-function getNaturalSize(key) {
-	return registry.get(key) ?? null;
-}
-function onNaturalSizeChange(fn) {
-	listeners.add(fn);
-	return () => {
-		listeners.delete(fn);
-	};
-}
-export { onNaturalSizeChange as n, registerNaturalSize as r, getNaturalSize as t };

package/dist/core/noiseColor-BQAO-Rjk.js

@@ -1,103 +0,0 @@
-import { G as mixColorsVariants, W as mixColorsLinear, it as std_exports, ln as f32, m as call, nt as src_default, v as floatE, xt as clamp } from "./edges-B7Yet3LV.js";
-import { S as mixColorStopsRuntime } from "./porters-D_xmIPz2.js";
-const noiseToneKColor = src_default.fn([
-	f32,
-	f32,
-	f32
-], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((noise01, contrast, balance) => {
-	"use gpu";
-	const k = clamp(__tsover_add(__tsover_add(__tsover_mul(__tsover_sub(noise01, .5), __tsover_add(contrast, 1)), .5), balance), 0, 1);
-	return __tsover_sub(1, k);
-}), {
-	v: 1,
-	name: void 0,
-	ast: {
-		"params": [
-			{
-				"type": "i",
-				"name": "noise01"
-			},
-			{
-				"type": "i",
-				"name": "contrast"
-			},
-			{
-				"type": "i",
-				"name": "balance"
-			}
-		],
-		"body": [0, [[
-			13,
-			"k",
-			[
-				6,
-				[
-					7,
-					"std",
-					"clamp"
-				],
-				[
-					[
-						1,
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"noise01",
-									"-",
-									[5, "0.5"]
-								],
-								"*",
-								[
-									1,
-									"contrast",
-									"+",
-									[5, "1"]
-								]
-							],
-							"+",
-							[5, "0.5"]
-						],
-						"+",
-						"balance"
-					],
-					[5, "0"],
-					[5, "1"]
-				]
-			]
-		], [10, [
-			1,
-			[5, "1"],
-			"-",
-			"k"
-		]]]],
-		"externalNames": ["std"]
-	},
-	externals: () => ({ std: std_exports })
-}) && $.f)({}));
-function mixStopsOrColorsExpr(params, t) {
-	const { uniforms, propValues } = params;
-	const colorSpaceMode = propValues.colorSpace ?? 0;
-	if ((propValues.stopCount ?? 0) > 1) return mixColorStopsRuntime(t, {
-		colorsArray: uniforms.colorsArray,
-		positionsArray: uniforms.positionsArray,
-		convertedColorsArray: uniforms.convertedColorsArray,
-		stopCount: uniforms.stopCount
-	}, colorSpaceMode);
-	return call(mixColorsVariants[colorSpaceMode] ?? mixColorsLinear, "mixColors", [
-		uniforms.colorA,
-		uniforms.colorB,
-		t
-	]);
-}
-function toneAndColorExpr(params, noise01) {
-	const { uniforms } = params;
-	return mixStopsOrColorsExpr(params, call(noiseToneKColor, "noiseToneKColor", [
-		noise01,
-		uniforms.contrast ?? floatE(0),
-		uniforms.balance ?? floatE(0)
-	]));
-}
-export { toneAndColorExpr as n, mixStopsOrColorsExpr as t };