shaders 3.0.447 → 3.0.449

package/dist/core/{Shatter-BYaxMvyd.js → Shatter-CWf3HtjN.js}

@@ -1,5 +1,7 @@
-import { At as applyEdgeHandlingExpr, Bt as ZERO, H as toHalfFloat, Ht as call, J as std, Kt as floatE, Tn as d, X as createGuardedCompute, Z as createStateBuffer, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { s as transformEdges } from "./transformations-t0d2-uSX.js";
+import { $t as vec2f, Gt as textureStorage2d, Lt as smoothstep, N as unpremultiplyAlpha, Tt as length, Ut as arrayOf, Vt as data_exports, Xt as struct, _ as floatE, an as f32, at as textureStore, d as ZERO, et as src_default, in as vec4f, kt as normalize, nn as vec3f, nt as std_exports, p as call, sn as u32, t as applyEdgeHandlingExpr, tn as vec2u } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute, r as createStateBuffer } from "./compute-BjeJ0sIA.js";
+import { t as toHalfFloat } from "./dataEncoding-CEmpiitu.js";
+import { s as transformEdges } from "./transformations-CsPUHppB.js";
 var seededRandom = (seed) => {
 	const x = Math.sin(seed) * 1e4;
 	return x - Math.floor(x);
@@ -8,21 +10,21 @@ var SHARD_COUNT = 16;
 var VORONOI_SIZE = 1024;
 var VORONOI_FORMAT = "rgba16float";
 var DATA_WIDTH = SHARD_COUNT * 4;
-var voronoiLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
+var voronoiLayout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
 	cellPos: {
-		storage: d.arrayOf(d.f32, SHARD_COUNT * 2),
+		storage: arrayOf(f32, SHARD_COUNT * 2),
 		access: "readonly"
 	},
-	voronoiTex: { storageTexture: d.textureStorage2d(VORONOI_FORMAT, "write-only") }
+	voronoiTex: { storageTexture: textureStorage2d(VORONOI_FORMAT, "write-only") }
 }), "voronoiLayout");
-const voronoiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+const voronoiKernel = src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 	"use gpu";
-	const u = __tsover_div(__tsover_add(d.f32(cx), .5), VORONOI_SIZE);
-	const v = __tsover_div(__tsover_add(d.f32(cy), .5), VORONOI_SIZE);
-	let d1 = d.f32(99999);
-	let d2 = d.f32(99999);
-	let idx1 = d.f32(0);
-	let idx2 = d.f32(0);
+	const u = __tsover_div(__tsover_add(f32(cx), .5), VORONOI_SIZE);
+	const v = __tsover_div(__tsover_add(f32(cy), .5), VORONOI_SIZE);
+	let d1 = f32(99999);
+	let d2 = f32(99999);
+	let idx1 = f32(0);
+	let idx2 = f32(0);
 	for (let i = 0; i < SHARD_COUNT; i++) {
 		const cellX = voronoiLayout.$.cellPos[__tsover_mul(i, 2)];
 		const cellY = voronoiLayout.$.cellPos[__tsover_add(__tsover_mul(i, 2), 1)];
@@ -33,13 +35,13 @@ const voronoiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 			d2 = d1;
 			idx2 = idx1;
 			d1 = distSq;
-			idx1 = d.f32(i);
+			idx1 = f32(i);
 		} else if (distSq < d2) {
 			d2 = distSq;
-			idx2 = d.f32(i);
+			idx2 = f32(i);
 		}
 	}
-	std.textureStore(voronoiLayout.$.voronoiTex, d.vec2u(cx, cy), d.vec4f(idx1, idx2, 0, 0));
+	textureStore(voronoiLayout.$.voronoiTex, vec2u(cx, cy), vec4f(idx1, idx2, 0, 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -383,16 +385,16 @@ const voronoiKernel = tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThi
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		VORONOI_SIZE,
 		SHARD_COUNT,
 		voronoiLayout,
-		std
+		std: std_exports
 	})
 }) && $.f)({})).$name("shatterVoronoi");
-const cellDataUV = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx, field) => {
+const cellDataUV = src_default.fn([f32, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((idx, field) => {
 	"use gpu";
-	return d.vec2f(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(idx, 4), field), .5), DATA_WIDTH), .5);
+	return vec2f(__tsover_div(__tsover_add(__tsover_add(__tsover_mul(idx, 4), field), .5), DATA_WIDTH), .5);
 }), {
 	v: 1,
 	name: void 0,
@@ -436,42 +438,42 @@ const cellDataUV = tgpu.fn([d.f32, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (glo
 		"externalNames": ["d", "DATA_WIDTH"]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		DATA_WIDTH
 	})
 }) && $.f)({}));
-const ShatterGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	crackIntensity: d.f32,
-	edgeNormal: d.vec2f,
-	displacedUV: d.vec2f,
-	disp: d.vec2f
+const ShatterGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	crackIntensity: f32,
+	edgeNormal: vec2f,
+	displacedUV: vec2f,
+	disp: vec2f
 }), "ShatterGeom");
-const shatterGeom = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
+const shatterGeom = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
 ], ShatterGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, nPosX, nPosY, sPosX, sPosY, dispX, dispY, crackWidth) => {
 	"use gpu";
-	const nearestPos = d.vec2f(nPosX, nPosY);
-	const secondPos = d.vec2f(sPosX, sPosY);
-	const disp = d.vec2f(dispX, dispY);
-	const minDist1 = std.length(uv.sub(nearestPos));
-	const minDist2 = std.length(uv.sub(secondPos));
-	const displacementMag = std.length(disp);
+	const nearestPos = vec2f(nPosX, nPosY);
+	const secondPos = vec2f(sPosX, sPosY);
+	const disp = vec2f(dispX, dispY);
+	const minDist1 = length(uv.sub(nearestPos));
+	const minDist2 = length(uv.sub(secondPos));
+	const displacementMag = length(disp);
 	const edgeDiff = __tsover_sub(minDist2, minDist1);
 	const crackThreshold = __tsover_mul(crackWidth, .005);
-	const baseCrackIntensity = __tsover_sub(1, std.smoothstep(0, crackThreshold, edgeDiff));
-	const displacementFactor = std.smoothstep(0, .01, displacementMag);
+	const baseCrackIntensity = __tsover_sub(1, smoothstep(0, crackThreshold, edgeDiff));
+	const displacementFactor = smoothstep(0, .01, displacementMag);
 	const crackIntensity = __tsover_mul(baseCrackIntensity, displacementFactor);
-	const toNearest = std.normalize(uv.sub(nearestPos));
+	const toNearest = normalize(uv.sub(nearestPos));
 	return ShatterGeom({
 		crackIntensity,
-		edgeNormal: d.vec2f(__tsover_mul(toNearest.y, -1), toNearest.x),
+		edgeNormal: vec2f(__tsover_mul(toNearest.y, -1), toNearest.x),
 		displacedUV: uv.sub(disp),
 		disp
 	});
@@ -759,19 +761,19 @@ const shatterGeom = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		ShatterGeom
 	})
 }) && $.f)({}));
-const shatterRefractUV = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((displacedUV, edgeNormal, crackIntensity, refractionStrength, chromaticSplit, channel) => {
+const shatterRefractUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((displacedUV, edgeNormal, crackIntensity, refractionStrength, chromaticSplit, channel) => {
 	"use gpu";
 	const refractionOffset = edgeNormal.mul(__tsover_mul(refractionStrength, .01));
 	const chromaticOffset = __tsover_mul(chromaticSplit, .005);
@@ -890,28 +892,27 @@ const shatterRefractUV = tgpu.fn([
 	},
 	externals: () => ({})
 }) && $.f)({}));
-const shatterCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32,
-	d.vec2f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normalColor, rFinal, gFinal, bFinal, crackIntensity, disp, shardLighting) => {
+const shatterCompose = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	vec4f,
+	f32,
+	vec2f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((normalColor, rFinal, gFinal, bFinal, crackIntensity, disp, shardLighting) => {
 	"use gpu";
-	const refractedRGB = d.vec3f(rFinal.x, gFinal.y, bFinal.z);
+	const refractedRGB = vec3f(rFinal.x, gFinal.y, bFinal.z);
 	const shadedRGB = normalColor.xyz.mul(__tsover_sub(1, crackIntensity)).add(refractedRGB.mul(crackIntensity));
-	const displacementLength = std.length(disp);
+	const displacementLength = length(disp);
 	const tiltX = __tsover_div(disp.x, __tsover_add(displacementLength, .001));
 	const tiltY = __tsover_div(disp.y, __tsover_add(displacementLength, .001));
-	const lightDir3D = std.normalize(d.vec2f(.3, .6));
+	const lightDir3D = normalize(vec2f(.3, .6));
 	const normalDot = __tsover_add(__tsover_mul(tiltX, lightDir3D.x), __tsover_mul(tiltY, lightDir3D.y));
 	const lightingFactor = __tsover_add(1, __tsover_mul(normalDot, shardLighting));
-	const lightingIntensity = std.smoothstep(0, .02, displacementLength);
+	const lightingIntensity = smoothstep(0, .02, displacementLength);
 	const finalLighting = __tsover_add(1, __tsover_mul(__tsover_sub(lightingFactor, 1), lightingIntensity));
-	const finalRGB = shadedRGB.mul(finalLighting);
-	return d.vec4f(finalRGB, normalColor.w);
+	return vec4f(shadedRGB.mul(finalLighting), normalColor.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -1196,8 +1197,8 @@ const shatterCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -1339,7 +1340,7 @@ const componentDefinition = {
 		const { gpu, registerComputeTexture, getCpuValue, onCleanup } = params;
 		const root = gpu?.root;
 		if (!root) return null;
-		const cellPos = createStateBuffer(root, d.f32, SHARD_COUNT * 2);
+		const cellPos = createStateBuffer(root, f32, SHARD_COUNT * 2);
 		const voronoiTex = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(root.createTexture({
 			size: [VORONOI_SIZE, VORONOI_SIZE],
 			format: VORONOI_FORMAT

package/dist/core/{SimplexNoise-C2vmRzgy.js → SimplexNoise-DpZ2jtdk.js}

@@ -1,21 +1,23 @@
-import { $ as mixStopsOrColorsExpr, Ht as call, J as std, Tn as d, dt as mxNoiseFloat3, n as tgpu, pt as noise_exports } from "./coords-BkIjixe_.js";
-import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-import { h as colorStopsPropConfig, t as animatedTime } from "./porters-BmU6G9TR.js";
-const simplexNoiseField = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, contrast, balance, animTime) => {
+import { $t as vec2f, Vt as data_exports, _t as clamp, an as f32, et as src_default, nn as vec3f, nt as std_exports, p as call, xt as exp } from "./edges-BXNBKxSN.js";
+import { h as colorStopsPropConfig, t as animatedTime } from "./porters-DBK1Aipq.js";
+import { d as mxNoiseFloat3, p as noise_exports } from "./noise-wTSHXgFz.js";
+import { t as mixStopsOrColorsExpr } from "./noiseColor-CPakiKNF.js";
+import { a as transformColor, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const simplexNoiseField = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, scale, seed, contrast, balance, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
-	const pos = d.vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(std.exp(scale)).add(seed);
-	const n = mxNoiseFloat3(d.vec3f(pos.x, pos.y, __tsover_mul(animTime, .5)));
+	const pos = vec2f(__tsover_mul(uv.x, aspect), uv.y).mul(exp(scale)).add(seed);
+	const n = mxNoiseFloat3(vec3f(pos.x, pos.y, __tsover_mul(animTime, .5)));
 	const adjusted = __tsover_add(__tsover_mul(n, __tsover_add(contrast, 1)), balance);
-	const k = std.clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
+	const k = clamp(__tsover_add(__tsover_mul(adjusted, .5), .5), 0, 1);
 	return __tsover_sub(1, k);
 }), {
 	v: 1,
@@ -224,8 +226,8 @@ const simplexNoiseField = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		noise: noise_exports
 	})
 }) && $.f)({}));

package/dist/core/{SineWave-BGAJyGFr.js → SineWave-CZuksvHn.js}

@@ -1,19 +1,19 @@
-import { Ht as call, J as std, Jt as vec4, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-t0d2-uSX.js";
-import { t as animatedTime } from "./porters-BmU6G9TR.js";
+import { $t as vec2f, It as sin, Lt as smoothstep, an as f32, et as src_default, mt as abs, nt as std_exports, p as call, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { t as animatedTime } from "./porters-DBK1Aipq.js";
+import { a as transformColor, c as transformPosition, r as transformAngle } from "./transformations-CsPUHppB.js";
 var DEG_TO_RAD = Math.PI / 180;
 var TAU = Math.PI * 2;
-const sineWaveMask = tgpu.fn([
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, position, frequency, amplitude, thickness, softness, animTime) => {
+const sineWaveMask = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, angle, position, frequency, amplitude, thickness, softness, animTime) => {
 	"use gpu";
 	const aspect = __tsover_div(viewport.x, viewport.y);
 	const aspectCorrectedX = __tsover_mul(uv.x, aspect);
@@ -22,16 +22,16 @@ const sineWaveMask = tgpu.fn([
 	const centeredX = __tsover_sub(aspectCorrectedX, centerX);
 	const centeredY = __tsover_sub(uv.y, centerY);
 	const angleRad = __tsover_mul(angle, DEG_TO_RAD);
-	const cosAngle = std.cos(angleRad);
-	const sinAngle = std.sin(angleRad);
+	const cosAngle = cos(angleRad);
+	const sinAngle = sin(angleRad);
 	const rotatedX = __tsover_sub(__tsover_mul(centeredX, cosAngle), __tsover_mul(centeredY, sinAngle));
 	const rotatedY = __tsover_add(__tsover_mul(centeredX, sinAngle), __tsover_mul(centeredY, cosAngle));
 	const waveInput = __tsover_add(__tsover_mul(__tsover_mul(rotatedX, frequency), TAU), animTime);
-	const sineWave = __tsover_mul(std.sin(waveInput), amplitude);
-	const distanceFromWave = std.abs(__tsover_sub(rotatedY, sineWave));
+	const sineWave = __tsover_mul(sin(waveInput), amplitude);
+	const distanceFromWave = abs(__tsover_sub(rotatedY, sineWave));
 	const halfThickness = __tsover_mul(thickness, .5);
 	const halfSoftness = __tsover_mul(softness, .5);
-	return __tsover_sub(1, std.smoothstep(__tsover_sub(halfThickness, halfSoftness), __tsover_add(halfThickness, halfSoftness), distanceFromWave));
+	return __tsover_sub(1, smoothstep(__tsover_sub(halfThickness, halfSoftness), __tsover_add(halfThickness, halfSoftness), distanceFromWave));
 }), {
 	v: 1,
 	name: void 0,
@@ -348,7 +348,7 @@ const sineWaveMask = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		std,
+		std: std_exports,
 		TAU
 	})
 }) && $.f)({}));

package/dist/core/{SliceWipe-BOcCk5Se.js → SliceWipe-BwL2D3HR.js}

@@ -1,26 +1,26 @@
-import { At as applyEdgeHandlingExpr, Bt as ZERO, Ht as call, J as std, Tn as d, cn as unpremultiplyAlpha, jt as composeEdgeRemapExpr, n as tgpu } from "./coords-BkIjixe_.js";
+import { $t as vec2f, Ct as floor, Et as max, It as sin, N as unpremultiplyAlpha, Vt as data_exports, an as f32, bt as dot, d as ZERO, et as src_default, mt as abs, n as composeEdgeRemapExpr, nt as std_exports, p as call, t as applyEdgeHandlingExpr, vt as cos, wt as fract } from "./edges-BXNBKxSN.js";
 var DEG_TO_RAD = Math.PI / 180;
-const sliceWipeUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg, sliceCount, progress) => {
+const sliceWipeUV = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, angleDeg, sliceCount, progress) => {
 	"use gpu";
 	const a = __tsover_mul(angleDeg, DEG_TO_RAD);
-	const dir = d.vec2f(std.cos(a), std.sin(a));
-	const p = d.vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
-	const grad = std.dot(p, dir);
-	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, std.abs(dir.x)), std.abs(dir.y)));
+	const dir = vec2f(cos(a), sin(a));
+	const p = vec2f(__tsover_mul(__tsover_sub(uv.x, .5), aspect), __tsover_sub(uv.y, .5));
+	const grad = dot(p, dir);
+	const ext = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, abs(dir.x)), abs(dir.y)));
 	const t = __tsover_add(__tsover_div(grad, __tsover_mul(2, ext)), .5);
-	const idx = std.floor(__tsover_mul(t, std.max(sliceCount, 1)));
-	const sign = __tsover_sub(__tsover_mul(std.fract(__tsover_mul(idx, .5)), 4), 1);
-	const perp = d.vec2f(-dir.y, dir.x);
-	const extPerp = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, std.abs(dir.y)), std.abs(dir.x)));
+	const idx = floor(__tsover_mul(t, max(sliceCount, 1)));
+	const sign = __tsover_sub(__tsover_mul(fract(__tsover_mul(idx, .5)), 4), 1);
+	const perp = vec2f(-dir.y, dir.x);
+	const extPerp = __tsover_mul(.5, __tsover_add(__tsover_mul(aspect, abs(dir.y)), abs(dir.x)));
 	const slide = __tsover_mul(__tsover_mul(progress, __tsover_mul(2.02, extPerp)), sign);
 	const q = p.add(perp.mul(slide));
-	return d.vec2f(__tsover_add(__tsover_div(q.x, aspect), .5), __tsover_add(q.y, .5));
+	return vec2f(__tsover_add(__tsover_div(q.x, aspect), .5), __tsover_add(q.y, .5));
 }), {
 	v: 1,
 	name: void 0,
@@ -405,8 +405,8 @@ const sliceWipeUV = tgpu.fn([
 	},
 	externals: () => ({
 		DEG_TO_RAD,
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {