shaders 3.0.453 → 3.1.455

package/dist/core/Cross-DQIgZt-C.js

@@ -0,0 +1,188 @@
+import { rn as vec2f, rt as src_default, un as f32 } from "./edges-CD7gCAto.js";
+import { C as defineSdfShapeShader } from "./porters-DUtQounc.js";
+import { C as sdf_exports, E as strokeMaskFromSdf, a as ShapeMask, p as crossSdf, w as shapeLocalCoords } from "./device-B0ZwBfOg.js";
+const crossShape = src_default.fn([
+	vec2f,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	f32,
+	vec2f,
+	f32
+], ShapeMask)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((center, radius, thickness, rounding, rotation, softness, strokeThickness, strokePosition, uv, aspect) => {
+	"use gpu";
+	const local = shapeLocalCoords(center, rotation, uv, aspect);
+	return strokeMaskFromSdf(crossSdf(local.x, local.y, radius, thickness, rounding), softness, strokeThickness, strokePosition);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "center"
+			},
+			{
+				"type": "i",
+				"name": "radius"
+			},
+			{
+				"type": "i",
+				"name": "thickness"
+			},
+			{
+				"type": "i",
+				"name": "rounding"
+			},
+			{
+				"type": "i",
+				"name": "rotation"
+			},
+			{
+				"type": "i",
+				"name": "softness"
+			},
+			{
+				"type": "i",
+				"name": "strokeThickness"
+			},
+			{
+				"type": "i",
+				"name": "strokePosition"
+			},
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "aspect"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"local",
+				[
+					6,
+					[
+						7,
+						"sdf",
+						"shapeLocalCoords"
+					],
+					[
+						"center",
+						"rotation",
+						"uv",
+						"aspect"
+					]
+				]
+			],
+			[
+				13,
+				"dist",
+				[
+					6,
+					[
+						7,
+						"sdf",
+						"crossSdf"
+					],
+					[
+						[
+							7,
+							"local",
+							"x"
+						],
+						[
+							7,
+							"local",
+							"y"
+						],
+						"radius",
+						"thickness",
+						"rounding"
+					]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"sdf",
+					"strokeMaskFromSdf"
+				],
+				[
+					"dist",
+					"softness",
+					"strokeThickness",
+					"strokePosition"
+				]
+			]]
+		]],
+		"externalNames": ["sdf"]
+	},
+	externals: () => ({ sdf: sdf_exports })
+}) && $.f)({}));
+const componentDefinition = defineSdfShapeShader({
+	name: "Cross",
+	description: "Plus / cross shape with adjustable arm length, width, and rounding",
+	shapeFn: crossShape,
+	shapeFnName: "crossShape",
+	bodyArgs: [
+		"radius",
+		"thickness",
+		"rounding",
+		"rotation"
+	],
+	colorDescription: "Fill color of the cross",
+	centerDescription: "Center position of the cross",
+	rotationDescription: "Rotation in degrees (45° turns a plus into an ×)",
+	bounds: { size: {
+		width: "radius",
+		height: "radius"
+	} },
+	shapeProps: {
+		radius: {
+			default: .35,
+			description: "Arm half-length — distance from center to the end of each arm",
+			ui: {
+				type: "range",
+				min: 0,
+				max: 1,
+				step: .01,
+				label: "Arm Length",
+				group: "Shape"
+			}
+		},
+		thickness: {
+			default: .08,
+			description: "Arm half-width — controls how wide each arm is",
+			ui: {
+				type: "range",
+				min: .01,
+				max: .5,
+				step: .005,
+				label: "Arm Width",
+				group: "Shape"
+			}
+		},
+		rounding: {
+			default: 0,
+			description: "Corner rounding — rounds the arm ends and concave corners",
+			ui: {
+				type: "range",
+				min: 0,
+				max: .2,
+				step: .005,
+				label: "Rounding",
+				group: "Shape"
+			}
+		}
+	}
+});
+var Cross_default = componentDefinition;
+export { componentDefinition as n, crossShape as r, Cross_default as t };

package/dist/core/{Crystal-DN2WgBrm.js → Crystal-B9DIgDD7.js}

@@ -1,16 +1,19 @@
-import { At as max, Bt as sin, Dt as floor, Gt as data_exports, Ht as sqrt, It as reflect, Lt as refract, Mt as mix, Nt as normalize, Ot as fract, P as blend_exports, Pt as pow, St as cos, Vt as smoothstep, _t as abs, b as vec4, cn as vec4f, d as ZERO, en as struct, gt as select, it as std_exports, jt as min, ln as f32, m as call, nt as src_default, on as vec3f, rn as vec2f, v as floatE, wt as dot, xt as clamp, yt as atan2 } from "./edges-B7Yet3LV.js";
-import { f as mxWorleyNoiseFloat2Pub, p as noise_exports } from "./noise-B-PI7JUx.js";
-import { h as sdf_exports } from "./sdf-B8rPE1PG.js";
-import { f as sdf3d_exports, n as shapeEffectBoundingBoxDeclaration, t as resolveShapeType } from "./shapeEffectBounds-Svfd_R5a.js";
-import { n as glass_exports } from "./glass-CNFJB2On.js";
-import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-C7gn_5rF.js";
+import { At as max, Bt as sin, Dt as floor, F as blend_exports, Gt as data_exports, Ht as sqrt, It as reflect, Lt as refract, Mt as mix, Nt as normalize, Ot as fract, Pt as pow, St as cos, Vt as smoothstep, _t as abs, at as std_exports, cn as vec4f, en as struct, f as ZERO, gt as select, h as call, jt as min, on as vec3f, rn as vec2f, rt as src_default, un as f32, wt as dot, x as vec4, xt as clamp, y as floatE, yt as atan2 } from "./edges-CD7gCAto.js";
+import { i as PI$1, s as TWO_PI$1, t as DEG_TO_RAD$1 } from "./constants-DoOzbl5b.js";
+import { f as mxWorleyNoiseFloat2Pub, p as noise_exports } from "./noise-Bd6IGS0W.js";
+import { C as sdf_exports } from "./device-B0ZwBfOg.js";
+import { n as lighting_exports } from "./lighting-D3jc6qOc.js";
+import { i as shapeEffectBoundingBoxDeclaration, n as sdf3d_exports } from "./sdf3d-CP87OlsQ.js";
+import { n as glass_exports } from "./glass-D8xs_kIG.js";
+import { a as transformColor, c as transformPosition, i as transformBoolean } from "./transformations-B-zNWNdd.js";
 var { sdfSpaceUV, offsetUV } = glass_exports;
+var { volumetricNormal, fieldGradient, patternCoords, insideMask } = lighting_exports;
 var { unpremultiplyAlpha } = blend_exports;
-var { createSvgSdfSampler, createAnalyticSdfSampler, driveAnalyticSubProps, ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
-var { createVolumetricFieldComputeNode, buildVolumetricFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS, is3dShapeType, isVolumetricShapeType } = sdf3d_exports;
-var DEG_TO_RAD = .017453292519943295;
-var PI = Math.PI;
-var TWO_PI = 6.283185307179586;
+var { ANALYTIC_SDF_EXTRA_FIELDS } = sdf_exports;
+var { createVolumetricFieldComputeNode, resolveShapeFieldSampler, VOLUMETRIC_FIELD_EXTRA_FIELDS } = sdf3d_exports;
+var DEG_TO_RAD = DEG_TO_RAD$1;
+var PI = PI$1;
+var TWO_PI = TWO_PI$1;
 var DEFAULT_SHAPE_CONFIG = JSON.stringify({
 	type: "polygonSDF",
 	radius: .35,
@@ -249,9 +252,10 @@ const crystalTrace = src_default.fn([
 	const sdfRaw = surf0.x;
 	const sdf = __tsover_div(sdfRaw, scale);
 	const EPS = .01;
-	const gradX = __tsover_div(__tsover_sub(surfX.x, sdfRaw), EPS);
-	const gradY = __tsover_div(__tsover_sub(surfY.x, sdfRaw), EPS);
-	const rb1 = clamp(__tsover_mul(__tsover_div(__tsover_mul(sdf, -1), sharp), 32), 0, 1);
+	const grad = fieldGradient(surf0, surfX, surfY, EPS);
+	const gradX = grad.x;
+	const gradY = grad.y;
+	const rb1 = insideMask(sdf, sharp, pxH, 1.5);
 	const lightRad = __tsover_mul(lightAngle, DEG_TO_RAD);
 	const lx = __tsover_add(cos(lightRad), __tsover_mul(__tsover_sub(centerPosX, .5), 3));
 	const ly = __tsover_add(sin(lightRad), __tsover_mul(__tsover_sub(centerPosY, .5), 3));
@@ -265,15 +269,16 @@ const crystalTrace = src_default.fn([
 	const refrScale = __tsover_mul(refraction, .15);
 	const haloOffX = __tsover_div(__tsover_mul(__tsover_mul(__tsover_mul(gradX, -1), refrScale), outerWarp), aspect);
 	const haloOffY = __tsover_mul(__tsover_mul(__tsover_mul(gradY, -1), refrScale), outerWarp);
-	const pdx = select(__tsover_sub(sdfUV.x, .5), surf0.y, volumetric > .5);
-	const pdy = select(__tsover_sub(sdfUV.y, .5), surf0.z, volumetric > .5);
+	const pat = patternCoords(sdfUV, surf0, volumetric);
+	const pdx = pat.x;
+	const pdy = pat.y;
 	const sAngle = __tsover_div(TWO_PI, facets);
 	const fUv = crystalKaleidoFold(__tsover_add(pdx, .5), __tsover_add(pdy, .5), sAngle);
 	const crystalRNorm = __tsover_div(sqrt(__tsover_add(__tsover_mul(pdx, pdx), __tsover_mul(pdy, pdy))), .35);
 	const tableMask = __tsover_sub(1, smoothstep(.22, .32, crystalRNorm));
 	const radialDensity = __tsover_add(1, __tsover_mul(clamp(crystalRNorm, 0, 1), .6));
 	const tableSuppress = __tsover_sub(1, __tsover_mul(tableMask, .9));
-	const nSurfVol = normalize(vec3f(clamp(__tsover_div(__tsover_sub(surfX.w, surf0.w), EPS), -4, 4), clamp(__tsover_div(__tsover_sub(surfY.w, surf0.w), EPS), -4, 4), -1));
+	const nSurfVol = volumetricNormal(surf0, surfX, surfY, EPS, 4);
 	const bevelSlope = __tsover_mul(__tsover_mul(__tsover_sub(1, smoothstep(0, 1, depthNorm)), 1.7), __tsover_sub(1, tableMask));
 	const nSurf = select(normalize(vec3f(__tsover_mul(gradX, bevelSlope), __tsover_mul(gradY, bevelSlope), -1)), nSurfVol, volumetric > .5);
 	const cosView = clamp(__tsover_mul(nSurf.z, -1), 0, 1);
@@ -648,40 +653,34 @@ const crystalTrace = src_default.fn([
 			],
 			[
 				13,
-				"gradX",
+				"grad",
 				[
-					1,
+					6,
+					"fieldGradient",
 					[
-						1,
-						[
-							7,
-							"surfX",
-							"x"
-						],
-						"-",
-						"sdfRaw"
-					],
-					"/",
-					"EPS"
+						"surf0",
+						"surfX",
+						"surfY",
+						"EPS"
+					]
+				]
+			],
+			[
+				13,
+				"gradX",
+				[
+					7,
+					"grad",
+					"x"
 				]
 			],
 			[
 				13,
 				"gradY",
 				[
-					1,
-					[
-						1,
-						[
-							7,
-							"surfY",
-							"x"
-						],
-						"-",
-						"sdfRaw"
-					],
-					"/",
-					"EPS"
+					7,
+					"grad",
+					"y"
 				]
 			],
 			[
@@ -689,34 +688,12 @@ const crystalTrace = src_default.fn([
 				"rb1",
 				[
 					6,
+					"insideMask",
 					[
-						7,
-						"std",
-						"clamp"
-					],
-					[
-						[
-							1,
-							[
-								1,
-								[
-									1,
-									"sdf",
-									"*",
-									[
-										4,
-										"-",
-										[5, "1"]
-									]
-								],
-								"/",
-								"sharp"
-							],
-							"*",
-							[5, "32"]
-						],
-						[5, "0"],
-						[5, "1"]
+						"sdf",
+						"sharp",
+						"pxH",
+						[5, "1.5"]
 					]
 				]
 			],
@@ -1039,72 +1016,33 @@ const crystalTrace = src_default.fn([
 			],
 			[
 				13,
-				"pdx",
+				"pat",
 				[
 					6,
+					"patternCoords",
 					[
-						7,
-						"std",
-						"select"
-					],
-					[
-						[
-							1,
-							[
-								7,
-								"sdfUV",
-								"x"
-							],
-							"-",
-							[5, "0.5"]
-						],
-						[
-							7,
-							"surf0",
-							"y"
-						],
-						[
-							1,
-							"volumetric",
-							">",
-							[5, "0.5"]
-						]
+						"sdfUV",
+						"surf0",
+						"volumetric"
 					]
 				]
 			],
+			[
+				13,
+				"pdx",
+				[
+					7,
+					"pat",
+					"x"
+				]
+			],
 			[
 				13,
 				"pdy",
 				[
-					6,
-					[
-						7,
-						"std",
-						"select"
-					],
-					[
-						[
-							1,
-							[
-								7,
-								"sdfUV",
-								"y"
-							],
-							"-",
-							[5, "0.5"]
-						],
-						[
-							7,
-							"surf0",
-							"z"
-						],
-						[
-							1,
-							"volumetric",
-							">",
-							[5, "0.5"]
-						]
-					]
+					7,
+					"pat",
+					"y"
 				]
 			],
 			[
@@ -1239,111 +1177,19 @@ const crystalTrace = src_default.fn([
 			],
 			[
 				13,
-				"ddx",
+				"nSurfVol",
 				[
 					6,
+					"volumetricNormal",
 					[
-						7,
-						"std",
-						"clamp"
-					],
-					[
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"surfX",
-									"w"
-								],
-								"-",
-								[
-									7,
-									"surf0",
-									"w"
-								]
-							],
-							"/",
-							"EPS"
-						],
-						[
-							4,
-							"-",
-							[5, "4"]
-						],
+						"surf0",
+						"surfX",
+						"surfY",
+						"EPS",
 						[5, "4"]
 					]
 				]
 			],
-			[
-				13,
-				"ddy",
-				[
-					6,
-					[
-						7,
-						"std",
-						"clamp"
-					],
-					[
-						[
-							1,
-							[
-								1,
-								[
-									7,
-									"surfY",
-									"w"
-								],
-								"-",
-								[
-									7,
-									"surf0",
-									"w"
-								]
-							],
-							"/",
-							"EPS"
-						],
-						[
-							4,
-							"-",
-							[5, "4"]
-						],
-						[5, "4"]
-					]
-				]
-			],
-			[
-				13,
-				"nSurfVol",
-				[
-					6,
-					[
-						7,
-						"std",
-						"normalize"
-					],
-					[[
-						6,
-						[
-							7,
-							"d",
-							"vec3f"
-						],
-						[
-							"ddx",
-							"ddy",
-							[
-								4,
-								"-",
-								[5, "1"]
-							]
-						]
-					]]
-				]
-			],
 			[
 				13,
 				"bevelSlope",
@@ -4089,20 +3935,28 @@ const crystalTrace = src_default.fn([
 		]],
 		"externalNames": [
 			"std",
+			"fieldGradient",
+			"insideMask",
 			"DEG_TO_RAD",
 			"d",
+			"patternCoords",
 			"TWO_PI",
 			"crystalKaleidoFold",
+			"volumetricNormal",
 			"noise",
 			"CrystalTrace"
 		]
 	},
 	externals: () => ({
 		std: std_exports,
+		fieldGradient,
+		insideMask,
 		DEG_TO_RAD,
 		d: data_exports,
+		patternCoords,
 		TWO_PI,
 		crystalKaleidoFold,
+		volumetricNormal,
 		noise: noise_exports,
 		CrystalTrace
 	})
@@ -4919,47 +4773,12 @@ const componentDefinition = {
 			description: "Active SDF shape type"
 		}
 	},
-	compute: (params) => {
-		const vf = createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "triplanar");
-		return vf ? {
-			outputs: vf.outputs,
-			getComputeNodes: (fp) => vf.getComputeNodes(fp)
-		} : null;
-	},
+	compute: (params) => createVolumetricFieldComputeNode(params, () => params.getCpuValue("shape"), "triplanar"),
 	fragment: (params) => {
-		const { childNode, computeOutputs, convertToTexture, uniforms, propValues, ctx, getCpuValue } = params;
+		const { childNode, convertToTexture, uniforms, propValues, ctx } = params;
 		if (!childNode) return ZERO;
 		const childTexture = convertToTexture(childNode);
-		let sampler;
-		let gradSampler;
-		let volumetric = false;
-		const fieldTex = computeOutputs?.volumetricFieldTexture;
-		if (fieldTex) {
-			const s = buildVolumetricFieldSampler(fieldTex, {
-				originX: uniforms._vfOriginX,
-				originY: uniforms._vfOriginY,
-				spanX: uniforms._vfSpanX,
-				spanY: uniforms._vfSpanY,
-				activeResF: uniforms._vfActiveRes,
-				rBound: uniforms._vfRBound
-			});
-			sampler = s.volumetricFieldSampler;
-			gradSampler = s.volumetricFieldSamplerFast;
-			volumetric = true;
-		} else {
-			const shapeSdfUrl = propValues.shapeSdfUrl || "";
-			const shapeType = propValues.shapeType || "";
-			if (shapeSdfUrl) {
-				sampler = createSvgSdfSampler(params, shapeSdfUrl);
-				gradSampler = sampler;
-				volumetric = isVolumetricShapeType(shapeType);
-			} else {
-				const st = resolveShapeType(shapeType, getCpuValue("shape"));
-				sampler = createAnalyticSdfSampler(st, driveAnalyticSubProps(params, () => getCpuValue("shape")), "triplanar");
-				gradSampler = sampler;
-				volumetric = is3dShapeType(st);
-			}
-		}
+		const { sampler, gradSampler, volumetric } = resolveShapeFieldSampler(params, { patternMode: "triplanar" });
 		const sdfUV = call(sdfSpaceUV, "sdfSpaceUV", [
 			uniforms.center,
 			uniforms.scale,