shaders 3.0.447 → 3.0.449

package/dist/core/{FilmGrain-DDhrsw94.js → FilmGrain-B-pZBxiK.js}

@@ -1,23 +1,22 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, n as tgpu } from "./coords-BkIjixe_.js";
-const filmGrainColor = tgpu.fn([
-	d.vec4f,
-	d.vec2f,
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, viewport, strength, bias, animTime) => {
+import { $t as vec2f, At as pow, It as sin, Vt as data_exports, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, in as vec4f, nn as vec3f, nt as std_exports, p as call, wt as fract } from "./edges-BXNBKxSN.js";
+const filmGrainColor = src_default.fn([
+	vec4f,
+	vec2f,
+	vec2f,
+	f32,
+	f32,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, uv, viewport, strength, bias, animTime) => {
 	"use gpu";
 	const pixelCoord = uv.mul(viewport);
-	const noiseInput = __tsover_add(std.dot(pixelCoord, d.vec2f(12.9898, 78.233)), animTime);
-	const noise = std.fract(__tsover_mul(std.sin(noiseInput), 43758.5453));
+	const noiseInput = __tsover_add(dot(pixelCoord, vec2f(12.9898, 78.233)), animTime);
+	const noise = fract(__tsover_mul(sin(noiseInput), 43758.5453));
 	const grain = __tsover_sub(__tsover_mul(noise, 2), 1);
-	const brightness = std.clamp(std.dot(color.xyz, d.vec3f(.2126, .7152, .0722)), 0, 1);
+	const brightness = clamp(dot(color.xyz, vec3f(.2126, .7152, .0722)), 0, 1);
 	const darkness = __tsover_sub(1, brightness);
-	const darkFactor = std.pow(__tsover_add(darkness, 1e-6), bias);
+	const darkFactor = pow(__tsover_add(darkness, 1e-6), bias);
 	const grainIntensity = __tsover_mul(__tsover_mul(grain, darkFactor), __tsover_mul(strength, .1));
-	const grainedColor = color.xyz.add(grainIntensity);
-	return d.vec4f(grainedColor, color.w);
+	return vec4f(color.xyz.add(grainIntensity), color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -252,8 +251,8 @@ const filmGrainColor = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {
@@ -263,7 +262,7 @@ const componentDefinition = {
 	description: "Analog film grain texture overlay, weighted toward darker areas",
 	requiresChild: true,
 	extraFields: { animTime: {
-		schema: d.f32,
+		schema: f32,
 		initial: 0
 	} },
 	props: {

package/dist/core/{FilmStock-BaP2aTLu.js → FilmStock-BJfso8f3.js}

@@ -1,4 +1,6 @@
-import { Bt as ZERO, G as DEFAULT_COMPUTE_WIDTH, Ht as call, J as std, Jt as vec4, Kt as floatE, Tn as d, U as BLUR_MAP_FORMAT, W as DEFAULT_COMPUTE_HEIGHT, X as createGuardedCompute, an as tonemap_exports, cn as unpremultiplyAlpha, in as srgbToLinear, n as tgpu, q as createVariableGaussianBlurCompute, rn as linearToSrgb } from "./coords-BkIjixe_.js";
+import { $t as vec2f, A as tonemap_exports, Ct as floor, Et as max, Gt as textureStorage2d, It as sin, N as unpremultiplyAlpha, O as linearToSrgb, Ot as mix, Vt as data_exports, Wt as texture2d, Xt as struct, _ as floatE, _t as clamp, an as f32, at as textureStore, bt as dot, d as ZERO, et as src_default, in as vec4f, it as textureLoad, k as srgbToLinear, nn as vec3f, nt as std_exports, on as i32, p as call, sn as u32, tn as vec2u, vt as cos, y as vec4 } from "./edges-BXNBKxSN.js";
+import { n as createGuardedCompute } from "./compute-BjeJ0sIA.js";
+import { a as createVariableGaussianBlurCompute, n as DEFAULT_COMPUTE_HEIGHT, r as DEFAULT_COMPUTE_WIDTH, t as BLUR_MAP_FORMAT } from "./blur-tvWOoxKt.js";
 const STOCK_OPTIONS = [
 	{
 		label: "Portrait 400",
@@ -79,14 +81,12 @@ var HAL_TINT = [
 ];
 var HALATION_THRESHOLD = .62;
 var HALATION_FORMAT = "rgba16float";
-const filmStockLutUv = tgpu.fn([d.vec4f, d.f32], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, hi) => {
+const filmStockLutUv = src_default.fn([vec4f, f32], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, hi) => {
 	"use gpu";
-	const enc = linearToSrgb(std.clamp(color.xyz, d.vec3f(0, 0, 0), d.vec3f(1, 1, 1)));
-	const slice = __tsover_mul(enc.z, d.f32(LUT_MAX));
-	const s = std.clamp(__tsover_add(std.floor(slice), hi), d.f32(0), d.f32(LUT_MAX));
-	const u = __tsover_mul(__tsover_add(__tsover_add(__tsover_mul(s, d.f32(LUT_N)), .5), __tsover_mul(enc.x, d.f32(LUT_MAX))), d.f32(INV_ATLAS_W));
-	const v = __tsover_mul(__tsover_add(.5, __tsover_mul(enc.y, d.f32(LUT_MAX))), d.f32(INV_LUT_N));
-	return d.vec2f(u, v);
+	const enc = linearToSrgb(clamp(color.xyz, vec3f(0, 0, 0), vec3f(1, 1, 1)));
+	const slice = __tsover_mul(enc.z, f32(LUT_MAX));
+	const s = clamp(__tsover_add(floor(slice), hi), f32(0), f32(LUT_MAX));
+	return vec2f(__tsover_mul(__tsover_add(__tsover_add(__tsover_mul(s, f32(LUT_N)), .5), __tsover_mul(enc.x, f32(LUT_MAX))), f32(INV_ATLAS_W)), __tsover_mul(__tsover_add(.5, __tsover_mul(enc.y, f32(LUT_MAX))), f32(INV_LUT_N)));
 }), {
 	v: 1,
 	name: void 0,
@@ -340,27 +340,27 @@ const filmStockLutUv = tgpu.fn([d.vec4f, d.f32], d.vec2f)(/* @__PURE__ */ (($) =
 	},
 	externals: () => ({
 		tonemap: tonemap_exports,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		LUT_MAX,
 		LUT_N,
 		INV_ATLAS_W,
 		INV_LUT_N
 	})
 }) && $.f)({})).$name("filmStockLutUv");
-const filmStockLutApply = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f,
-	d.f32
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tapLo, tapHi, strength) => {
+const filmStockLutApply = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f,
+	f32
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((color, tapLo, tapHi, strength) => {
 	"use gpu";
-	const enc = linearToSrgb(std.clamp(color.xyz, d.vec3f(0, 0, 0), d.vec3f(1, 1, 1)));
-	const slice = __tsover_mul(enc.z, d.f32(LUT_MAX));
-	const f = __tsover_sub(slice, std.floor(slice));
-	const graded = srgbToLinear(std.mix(tapLo.xyz, tapHi.xyz, d.vec3f(f, f, f)));
-	const rgb = std.mix(color.xyz, graded, d.vec3f(strength, strength, strength));
-	return d.vec4f(rgb.x, rgb.y, rgb.z, color.w);
+	const enc = linearToSrgb(clamp(color.xyz, vec3f(0, 0, 0), vec3f(1, 1, 1)));
+	const slice = __tsover_mul(enc.z, f32(LUT_MAX));
+	const f = __tsover_sub(slice, floor(slice));
+	const graded = srgbToLinear(mix(tapLo.xyz, tapHi.xyz, vec3f(f, f, f)));
+	const rgb = mix(color.xyz, graded, vec3f(strength, strength, strength));
+	return vec4f(rgb.x, rgb.y, rgb.z, color.w);
 }), {
 	v: 1,
 	name: void 0,
@@ -595,23 +595,23 @@ const filmStockLutApply = tgpu.fn([
 	},
 	externals: () => ({
 		tonemap: tonemap_exports,
-		std,
-		d,
+		std: std_exports,
+		d: data_exports,
 		LUT_MAX
 	})
 }) && $.f)({})).$name("filmStockLutApply");
-const filmStockHalation = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
-	d.vec4f
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((graded, halation, tintStrength) => {
+const filmStockHalation = src_default.fn([
+	vec4f,
+	vec4f,
+	vec4f
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((graded, halation, tintStrength) => {
 	"use gpu";
 	const strength = tintStrength.w;
-	const bloom = std.clamp(halation.xyz.mul(tintStrength.xyz).mul(strength), d.vec3f(0, 0, 0), d.vec3f(1, 1, 1));
-	const one = d.vec3f(1, 1, 1);
+	const bloom = clamp(halation.xyz.mul(tintStrength.xyz).mul(strength), vec3f(0, 0, 0), vec3f(1, 1, 1));
+	const one = vec3f(1, 1, 1);
 	const screened = one.sub(one.sub(graded.xyz).mul(one.sub(bloom)));
 	const a = __tsover_add(graded.w, __tsover_mul(__tsover_mul(halation.w, strength), __tsover_sub(1, graded.w)));
-	return d.vec4f(screened.x, screened.y, screened.z, std.clamp(a, 0, 1));
+	return vec4f(screened.x, screened.y, screened.z, clamp(a, 0, 1));
 }), {
 	v: 1,
 	name: void 0,
@@ -842,26 +842,26 @@ const filmStockHalation = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("filmStockHalation");
-const filmStockWeave = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, weave, t) => {
+const filmStockWeave = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, weave, t) => {
 	"use gpu";
 	const amp = __tsover_mul(weave, .006);
-	const ox = __tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_mul(t, 1.7)), .5), __tsover_mul(std.sin(__tsover_add(__tsover_mul(t, .9), 1.3)), .5)), amp);
-	const oy = __tsover_mul(__tsover_add(__tsover_mul(std.sin(__tsover_add(__tsover_mul(t, 1.3), .7)), .5), __tsover_mul(std.sin(__tsover_mul(t, 2.3)), .5)), amp);
-	const ang = __tsover_mul(__tsover_mul(std.sin(__tsover_mul(t, .6)), weave), .004);
-	const c = std.cos(ang);
-	const s = std.sin(ang);
-	const p = uv.sub(d.vec2f(.5, .5));
+	const ox = __tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_mul(t, 1.7)), .5), __tsover_mul(sin(__tsover_add(__tsover_mul(t, .9), 1.3)), .5)), amp);
+	const oy = __tsover_mul(__tsover_add(__tsover_mul(sin(__tsover_add(__tsover_mul(t, 1.3), .7)), .5), __tsover_mul(sin(__tsover_mul(t, 2.3)), .5)), amp);
+	const ang = __tsover_mul(__tsover_mul(sin(__tsover_mul(t, .6)), weave), .004);
+	const c = cos(ang);
+	const s = sin(ang);
+	const p = uv.sub(vec2f(.5, .5));
 	const rx = __tsover_sub(__tsover_mul(p.x, c), __tsover_mul(p.y, s));
 	const ry = __tsover_add(__tsover_mul(p.x, s), __tsover_mul(p.y, c));
-	return d.vec2f(__tsover_add(__tsover_add(rx, .5), ox), __tsover_add(__tsover_add(ry, .5), oy));
+	return vec2f(__tsover_add(__tsover_add(rx, .5), ox), __tsover_add(__tsover_add(ry, .5), oy));
 }), {
 	v: 1,
 	name: void 0,
@@ -1167,52 +1167,52 @@ const filmStockWeave = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({})).$name("filmStockWeave");
 function halationPrepassParams() {
-	return d.struct({
-		threshold: d.f32,
-		size: d.f32,
-		inputWidth: d.f32,
-		inputHeight: d.f32
+	return struct({
+		threshold: f32,
+		size: f32,
+		inputWidth: f32,
+		inputHeight: f32
 	});
 }
 function buildHalationPrepassGraph(computeWidth, computeHeight) {
 	const Params = halationPrepassParams();
-	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(tgpu.bindGroupLayout({
-		childTexture: { texture: d.texture2d(d.f32) },
-		brightMap: { storageTexture: d.textureStorage2d(HALATION_FORMAT, "write-only") },
-		blurMap: { storageTexture: d.textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
+	const layout = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(src_default.bindGroupLayout({
+		childTexture: { texture: texture2d(f32) },
+		brightMap: { storageTexture: textureStorage2d(HALATION_FORMAT, "write-only") },
+		blurMap: { storageTexture: textureStorage2d(BLUR_MAP_FORMAT, "write-only") },
 		params: { uniform: Params }
 	}), "layout");
 	return {
 		layout,
-		kernel: tgpu.fn([d.u32, d.u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
+		kernel: src_default.fn([u32, u32])(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((cx, cy) => {
 			"use gpu";
 			const p = layout.$.params;
 			const iw = p.inputWidth;
 			const ih = p.inputHeight;
-			const inputWm1 = d.i32(__tsover_sub(iw, 1));
-			const inputHm1 = d.i32(__tsover_sub(ih, 1));
-			let sample = d.vec4f(0, 0, 0, 0);
+			const inputWm1 = i32(__tsover_sub(iw, 1));
+			const inputHm1 = i32(__tsover_sub(ih, 1));
+			let sample = vec4f(0, 0, 0, 0);
 			for (let ty = 0; ty < 4; ty++) for (let tx = 0; tx < 4; tx++) {
-				const su = __tsover_div(__tsover_add(d.f32(cx), __tsover_div(__tsover_add(d.f32(tx), .5), 4)), computeWidth);
-				const sv = __tsover_div(__tsover_add(d.f32(cy), __tsover_div(__tsover_add(d.f32(ty), .5), 4)), computeHeight);
-				const sx = std.clamp(d.i32(__tsover_mul(su, iw)), 0, inputWm1);
-				const sy = std.clamp(d.i32(__tsover_mul(sv, ih)), 0, inputHm1);
-				sample = sample.add(std.textureLoad(layout.$.childTexture, d.vec2u(d.u32(sx), d.u32(sy)), 0));
+				const su = __tsover_div(__tsover_add(f32(cx), __tsover_div(__tsover_add(f32(tx), .5), 4)), computeWidth);
+				const sv = __tsover_div(__tsover_add(f32(cy), __tsover_div(__tsover_add(f32(ty), .5), 4)), computeHeight);
+				const sx = clamp(i32(__tsover_mul(su, iw)), 0, inputWm1);
+				const sy = clamp(i32(__tsover_mul(sv, ih)), 0, inputHm1);
+				sample = sample.add(textureLoad(layout.$.childTexture, vec2u(u32(sx), u32(sy)), 0));
 			}
 			sample = sample.mul(.0625);
 			const threshold = p.threshold;
 			const knee = __tsover_add(__tsover_mul(threshold, .5), 1e-4);
-			const lum = std.dot(sample.xyz, d.vec3f(.2126, .7152, .0722));
-			const soft = std.clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
+			const lum = dot(sample.xyz, vec3f(.2126, .7152, .0722));
+			const soft = clamp(__tsover_add(__tsover_sub(lum, threshold), knee), 0, __tsover_mul(knee, 2));
 			const softCurve = __tsover_div(__tsover_mul(soft, soft), __tsover_mul(knee, 4));
-			const mask = __tsover_div(std.max(softCurve, __tsover_sub(lum, threshold)), std.max(lum, 1e-4));
-			std.textureStore(layout.$.brightMap, d.vec2u(cx, cy), d.vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
-			std.textureStore(layout.$.blurMap, d.vec2u(cx, cy), d.vec4f(p.size, 0, 0, 1));
+			const mask = __tsover_div(max(softCurve, __tsover_sub(lum, threshold)), max(lum, 1e-4));
+			textureStore(layout.$.brightMap, vec2u(cx, cy), vec4f(sample.xyz.mul(mask), __tsover_mul(sample.w, mask)));
+			textureStore(layout.$.blurMap, vec2u(cx, cy), vec4f(p.size, 0, 0, 1));
 		}), {
 			v: 1,
 			name: void 0,
@@ -1815,10 +1815,10 @@ function buildHalationPrepassGraph(computeWidth, computeHeight) {
 			},
 			externals: () => ({
 				layout,
-				d,
+				d: data_exports,
 				computeWidth,
 				computeHeight,
-				std
+				std: std_exports
 			})
 		}) && $.f)({})).$name("filmStockHalationExtract"),
 		Params
@@ -1832,7 +1832,7 @@ const componentDefinition = {
 	requiresRTT: true,
 	requiresChild: true,
 	extraFields: { weaveTime: {
-		schema: d.f32,
+		schema: f32,
 		initial: 0
 	} },
 	props: {

package/dist/core/{Flip-DYuqyJva.js → Flip-Dbwe0zh8.js}

@@ -1,14 +1,12 @@
-import { Bt as ZERO, Ht as call, J as std, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
-import { i as transformBoolean } from "./transformations-t0d2-uSX.js";
-const flipUV = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32
-], d.vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, flipX, flipY) => {
+import { $t as vec2f, N as unpremultiplyAlpha, Vt as data_exports, an as f32, d as ZERO, et as src_default, nt as std_exports, p as call, pt as select } from "./edges-BXNBKxSN.js";
+import { i as transformBoolean } from "./transformations-CsPUHppB.js";
+const flipUV = src_default.fn([
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, flipX, flipY) => {
 	"use gpu";
-	const x = std.select(uv.x, __tsover_sub(1, uv.x), flipX > 0);
-	const y = std.select(uv.y, __tsover_sub(1, uv.y), flipY > 0);
-	return d.vec2f(x, y);
+	return vec2f(select(uv.x, __tsover_sub(1, uv.x), flipX > 0), select(uv.y, __tsover_sub(1, uv.y), flipY > 0));
 }), {
 	v: 1,
 	name: void 0,
@@ -111,8 +109,8 @@ const flipUV = tgpu.fn([
 		"externalNames": ["std", "d"]
 	},
 	externals: () => ({
-		std,
-		d
+		std: std_exports,
+		d: data_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {