shaders 3.0.448 → 3.0.449

package/dist/core/{PagePeel-B6sjmvZ1.js → PagePeel-Coq0hc8R.js}

@@ -1,4 +1,4 @@
-import { Bt as ZERO, Ht as call, J as std, Kt as floatE, Tn as d, cn as unpremultiplyAlpha, n as tgpu } from "./coords-BkIjixe_.js";
+import { $t as vec2f, At as pow, Et as max, Lt as smoothstep, N as unpremultiplyAlpha, Ot as mix, Tt as length, Vt as data_exports, Xt as struct, _ as floatE, _t as clamp, an as f32, bt as dot, d as ZERO, et as src_default, ht as asin, in as vec4f, nt as std_exports, p as call, pt as select, vt as cos, xt as exp, zt as step } from "./edges-BXNBKxSN.js";
 var transformCorner = (value) => {
 	switch (value) {
 		case "top-left": return 0;
@@ -27,72 +27,71 @@ var CORNERS = {
 	}
 };
 var HALF_PI = Math.PI / 2;
-const PagePeelGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(d.struct({
-	curlUV: d.vec2f,
-	curlBright: d.f32,
-	spec: d.f32,
-	flatShade: d.f32,
-	peelAlpha: d.f32,
-	foldBlend: d.f32,
-	showCurl: d.f32
+const PagePeelGeom = /* @__PURE__ */ (globalThis.__TYPEGPU_AUTONAME__ ?? ((a) => a))(struct({
+	curlUV: vec2f,
+	curlBright: f32,
+	spec: f32,
+	flatShade: f32,
+	peelAlpha: f32,
+	foldBlend: f32,
+	showCurl: f32
 }), "PagePeelGeom");
-const pagePeelGeom = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
+const pagePeelGeom = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
 ], PagePeelGeom)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, cornerX, cornerY, oppX, oppY, amount, radius, shading, highlight, highlightSoftness, shadow) => {
 	"use gpu";
-	const pA = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
-	const cornerA = d.vec2f(__tsover_mul(cornerX, aspect), cornerY);
-	const axisVec = d.vec2f(__tsover_mul(oppX, aspect), oppY).sub(cornerA);
-	const L = std.length(axisVec);
+	const pA = vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const cornerA = vec2f(__tsover_mul(cornerX, aspect), cornerY);
+	const axisVec = vec2f(__tsover_mul(oppX, aspect), oppY).sub(cornerA);
+	const L = length(axisVec);
 	const axis = axisVec.mul(__tsover_div(1, L));
-	const t = std.dot(pA.sub(cornerA), axis);
+	const t = dot(pA.sub(cornerA), axis);
 	const peel = __tsover_mul(amount, L);
 	const cFold = peel;
-	const R = std.max(__tsover_mul(radius, L), 1e-4);
+	const R = max(__tsover_mul(radius, L), 1e-4);
 	const thetaMax = __tsover_div(peel, R);
 	const X = __tsover_div(__tsover_sub(t, cFold), R);
-	const Xc = std.clamp(X, 0, 1);
-	const theta = std.asin(Xc);
-	const inBand = __tsover_mul(std.step(0, X), std.step(X, 1));
-	const paper = std.step(theta, thetaMax);
+	const theta = asin(clamp(X, 0, 1));
+	const inBand = __tsover_mul(step(0, X), step(X, 1));
+	const paper = step(theta, thetaMax);
 	const cCurl = __tsover_sub(peel, __tsover_mul(R, theta));
 	const sourceA = pA.add(axis.mul(__tsover_sub(cCurl, t)));
-	const curlUV = d.vec2f(__tsover_div(sourceA.x, aspect), sourceA.y);
-	const curlInBounds = __tsover_mul(__tsover_mul(__tsover_mul(std.step(0, curlUV.x), std.step(curlUV.x, 1)), std.step(0, curlUV.y)), std.step(curlUV.y, 1));
-	const facing = std.cos(theta);
+	const curlUV = vec2f(__tsover_div(sourceA.x, aspect), sourceA.y);
+	const curlInBounds = __tsover_mul(__tsover_mul(__tsover_mul(step(0, curlUV.x), step(curlUV.x, 1)), step(0, curlUV.y)), step(curlUV.y, 1));
+	const facing = cos(theta);
 	const curlBright = __tsover_sub(1, __tsover_mul(shading, facing));
 	const thetaN = __tsover_div(theta, HALF_PI);
-	const specSigma = std.mix(.05, .4, highlightSoftness);
+	const specSigma = mix(.05, .4, highlightSoftness);
 	const specDelta = __tsover_div(__tsover_sub(thetaN, .65), specSigma);
-	const spec = __tsover_mul(std.exp(__tsover_mul(__tsover_mul(specDelta, specDelta), -.5)), highlight);
-	const liftFrac = __tsover_sub(1, std.cos(std.clamp(thetaMax, 0, HALF_PI)));
+	const spec = __tsover_mul(exp(__tsover_mul(__tsover_mul(specDelta, specDelta), -.5)), highlight);
+	const liftFrac = __tsover_sub(1, cos(clamp(thetaMax, 0, HALF_PI)));
 	const lipHeight = __tsover_mul(R, liftFrac);
-	const shadowStrength = __tsover_mul(std.smoothstep(0, .04, amount), std.pow(__tsover_sub(1, amount), .7));
-	const flatReach = std.max(__tsover_add(R, __tsover_mul(lipHeight, .5)), 1e-4);
+	const shadowStrength = __tsover_mul(smoothstep(0, .04, amount), pow(__tsover_sub(1, amount), .7));
+	const flatReach = max(__tsover_add(R, __tsover_mul(lipHeight, .5)), 1e-4);
 	const distPastCrease = __tsover_sub(t, cFold);
-	const flatFall = __tsover_mul(__tsover_mul(std.pow(__tsover_sub(1, std.smoothstep(0, flatReach, distPastCrease)), 2), std.step(0, distPastCrease)), shadowStrength);
+	const flatFall = __tsover_mul(__tsover_mul(pow(__tsover_sub(1, smoothstep(0, flatReach, distPastCrease)), 2), step(0, distPastCrease)), shadowStrength);
 	const flatShade = __tsover_sub(1, __tsover_mul(__tsover_mul(shadow, flatFall), .5));
-	const peelReach = std.max(__tsover_mul(lipHeight, 2.5), 1e-4);
+	const peelReach = max(__tsover_mul(lipHeight, 2.5), 1e-4);
 	const distIntoPeel = __tsover_sub(cFold, t);
-	const peelFall = __tsover_mul(__tsover_mul(__tsover_mul(std.pow(__tsover_sub(1, std.smoothstep(0, peelReach, distIntoPeel)), 1.5), std.step(0, distIntoPeel)), shadowStrength), shadow);
+	const peelFall = __tsover_mul(__tsover_mul(__tsover_mul(pow(__tsover_sub(1, smoothstep(0, peelReach, distIntoPeel)), 1.5), step(0, distIntoPeel)), shadowStrength), shadow);
 	return PagePeelGeom({
 		curlUV,
 		curlBright,
 		spec,
 		flatShade,
 		peelAlpha: __tsover_mul(peelFall, .6),
-		foldBlend: std.smoothstep(__tsover_sub(cFold, .0015), __tsover_add(cFold, .0015), t),
+		foldBlend: smoothstep(__tsover_sub(cFold, .0015), __tsover_add(cFold, .0015), t),
 		showCurl: __tsover_mul(__tsover_mul(inBand, paper), curlInBounds)
 	});
 }), {
@@ -972,24 +971,21 @@ const pagePeelGeom = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
-		std,
+		d: data_exports,
+		std: std_exports,
 		HALF_PI,
 		PagePeelGeom
 	})
 }) && $.f)({}));
-const pagePeelCompose = tgpu.fn([
-	d.vec4f,
-	d.vec4f,
+const pagePeelCompose = src_default.fn([
+	vec4f,
+	vec4f,
 	PagePeelGeom
-], d.vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((curlSample, flatSample, g) => {
+], vec4f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((curlSample, flatSample, g) => {
 	"use gpu";
-	const litRgb = curlSample.xyz.mul(g.curlBright).add(__tsover_mul(g.spec, curlSample.w));
-	const curlColor = d.vec4f(litRgb, curlSample.w);
-	const flatColor = d.vec4f(flatSample.xyz.mul(g.flatShade), flatSample.w);
-	const peeledColor = d.vec4f(0, 0, 0, g.peelAlpha);
-	const base = std.mix(peeledColor, flatColor, d.vec4f(g.foldBlend));
-	return std.select(base, curlColor, g.showCurl > .5);
+	const curlColor = vec4f(curlSample.xyz.mul(g.curlBright).add(__tsover_mul(g.spec, curlSample.w)), curlSample.w);
+	const flatColor = vec4f(flatSample.xyz.mul(g.flatShade), flatSample.w);
+	return select(mix(vec4f(0, 0, 0, g.peelAlpha), flatColor, vec4f(g.foldBlend)), curlColor, g.showCurl > .5);
 }), {
 	v: 1,
 	name: void 0,
@@ -1178,8 +1174,8 @@ const pagePeelCompose = tgpu.fn([
 		"externalNames": ["d", "std"]
 	},
 	externals: () => ({
-		d,
-		std
+		d: data_exports,
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Paper-LfukraJk.js → Paper-CLlhc3fn.js}

@@ -1,21 +1,22 @@
-import { Bt as ZERO, Ht as call, J as std, Jt as vec4, Tn as d, cn as unpremultiplyAlpha, mt as paper12, n as tgpu, nt as curl22, pt as noise_exports } from "./coords-BkIjixe_.js";
-const paperSurface = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32
-], d.vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, grainScale, seed, displacement, roughness) => {
+import { $t as vec2f, N as unpremultiplyAlpha, Vt as data_exports, _t as clamp, an as f32, d as ZERO, et as src_default, nn as vec3f, nt as std_exports, on as i32, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { m as paper12, n as curl22, p as noise_exports } from "./noise-wTSHXgFz.js";
+const paperSurface = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32
+], vec3f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, aspect, grainScale, seed, displacement, roughness) => {
 	"use gpu";
-	const aspectUV = d.vec2f(__tsover_mul(uv.x, aspect), uv.y);
+	const aspectUV = vec2f(__tsover_mul(uv.x, aspect), uv.y);
 	const grainFreq = __tsover_mul(grainScale, 6);
 	const grainUV = aspectUV.mul(grainFreq).add(seed);
 	const disp = curl22(grainUV).mul(displacement).mul(.0025);
 	const displacedUV = uv.add(disp);
-	const grain = paper12(grainUV, d.i32(6));
-	const brightness = std.clamp(__tsover_add(1, __tsover_mul(__tsover_sub(grain, .7), __tsover_mul(roughness, 1.2))), 0, 1.5);
-	return d.vec3f(displacedUV.x, displacedUV.y, brightness);
+	const grain = paper12(grainUV, i32(6));
+	const brightness = clamp(__tsover_add(1, __tsover_mul(__tsover_sub(grain, .7), __tsover_mul(roughness, 1.2))), 0, 1.5);
+	return vec3f(displacedUV.x, displacedUV.y, brightness);
 }), {
 	v: 1,
 	name: void 0,
@@ -233,9 +234,9 @@ const paperSurface = tgpu.fn([
 		]
 	},
 	externals: () => ({
-		d,
+		d: data_exports,
 		noise: noise_exports,
-		std
+		std: std_exports
 	})
 }) && $.f)({}));
 const componentDefinition = {

package/dist/core/{Parallelogram-DBi0yAG3.js → Parallelogram-Be8RQBV7.js}

@@ -1,16 +1,17 @@
-import { C as ShapeMask, F as sdf_exports, Ht as call, I as shapeLocalCoords, Jt as vec4, R as strokeMaskFromSdf, Tn as d, gn as mixColorsVariants, hn as mixColorsLinear, j as parallelogramSdf, n as tgpu } from "./coords-BkIjixe_.js";
-import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-t0d2-uSX.js";
-const parallelogramShape = tgpu.fn([
-	d.vec2f,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.f32,
-	d.vec2f,
-	d.f32
+import { $t as vec2f, H as mixColorsLinear, U as mixColorsVariants, an as f32, et as src_default, p as call, y as vec4 } from "./edges-BXNBKxSN.js";
+import { d as parallelogramSdf, g as shapeLocalCoords, h as sdf_exports, n as ShapeMask, v as strokeMaskFromSdf } from "./sdf-R0EN3EvS.js";
+import { a as transformColor, c as transformPosition, l as transformStrokePosition, o as transformColorSpace, t as colorSpaceOptions } from "./transformations-CsPUHppB.js";
+const parallelogramShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
 ], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, width, height, skew, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
 	"use gpu";
 	const local = shapeLocalCoords(center, rotation, uv, aspect);