shaders 3.0.453 → 3.1.455

package/dist/core/cells-CM9mfnTr.js

@@ -0,0 +1,1042 @@
+import { At as max, Bt as sin, Dt as floor, Gt as data_exports, Ot as fract, St as cos, at as std_exports, en as struct, gt as select, pn as __export, rn as vec2f, rt as src_default, un as f32, wt as dot } from "./edges-CD7gCAto.js";
+import { a as SQRT3 } from "./constants-DoOzbl5b.js";
+import { n as flooredMod2 } from "./geom-90G-d_hc.js";
+var cells_exports = /* @__PURE__ */ __export({
+	CellTile: () => CellTile,
+	HexCell: () => HexCell,
+	cellCentreUV: () => cellCentreUV,
+	cellCentreUVRotated: () => cellCentreUVRotated,
+	cellHash: () => cellHash,
+	hexTiling: () => hexTiling,
+	rowSpeedHash: () => rowSpeedHash,
+	rowSpeedMultiplier: () => rowSpeedMultiplier,
+	squareTiling: () => squareTiling,
+	triLattice: () => triLattice,
+	variationFactor: () => variationFactor
+});
+var TWO_OVER_SQRT3 = 2 / Math.sqrt(3);
+const CellTile = struct({
+	cell: vec2f,
+	local: vec2f
+}).$name("CellTile");
+const squareTiling = src_default.fn([vec2f], CellTile)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	return CellTile({
+		cell: floor(p),
+		local: fract(p)
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [[10, [
+			6,
+			"CellTile",
+			[[104, {
+				"cell": [
+					6,
+					[
+						7,
+						"std",
+						"floor"
+					],
+					["p"]
+				],
+				"local": [
+					6,
+					[
+						7,
+						"std",
+						"fract"
+					],
+					["p"]
+				]
+			}]]
+		]]]],
+		"externalNames": ["CellTile", "std"]
+	},
+	externals: () => ({
+		CellTile,
+		std: std_exports
+	})
+}) && $.f)({}));
+const HexCell = struct({
+	gv: vec2f,
+	id: vec2f
+}).$name("HexCell");
+const hexTiling = src_default.fn([vec2f, vec2f], HexCell)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p, s) => {
+	"use gpu";
+	const sh = s.mul(.5);
+	const a = flooredMod2(p, s).sub(sh);
+	const b = flooredMod2(p.sub(sh), s).sub(sh);
+	const gv = select(b, a, dot(a, a) < dot(b, b));
+	return HexCell({
+		gv,
+		id: p.sub(gv)
+	});
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}, {
+			"type": "i",
+			"name": "s"
+		}],
+		"body": [0, [
+			[
+				13,
+				"sh",
+				[
+					6,
+					[
+						7,
+						"s",
+						"mul"
+					],
+					[[5, "0.5"]]
+				]
+			],
+			[
+				13,
+				"a",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"flooredMod2",
+							["p", "s"]
+						],
+						"sub"
+					],
+					["sh"]
+				]
+			],
+			[
+				13,
+				"b",
+				[
+					6,
+					[
+						7,
+						[
+							6,
+							"flooredMod2",
+							[[
+								6,
+								[
+									7,
+									"p",
+									"sub"
+								],
+								["sh"]
+							], "s"]
+						],
+						"sub"
+					],
+					["sh"]
+				]
+			],
+			[
+				13,
+				"gv",
+				[
+					6,
+					[
+						7,
+						"std",
+						"select"
+					],
+					[
+						"b",
+						"a",
+						[
+							1,
+							[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["a", "a"]
+							],
+							"<",
+							[
+								6,
+								[
+									7,
+									"std",
+									"dot"
+								],
+								["b", "b"]
+							]
+						]
+					]
+				]
+			],
+			[10, [
+				6,
+				"HexCell",
+				[[104, {
+					"gv": "gv",
+					"id": [
+						6,
+						[
+							7,
+							"p",
+							"sub"
+						],
+						["gv"]
+					]
+				}]]
+			]]
+		]],
+		"externalNames": [
+			"flooredMod2",
+			"std",
+			"HexCell"
+		]
+	},
+	externals: () => ({
+		flooredMod2,
+		std: std_exports,
+		HexCell
+	})
+}) && $.f)({}));
+const triLattice = src_default.fn([vec2f], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((p) => {
+	"use gpu";
+	return vec2f(__tsover_sub(p.x, __tsover_div(p.y, SQRT3)), __tsover_mul(p.y, TWO_OVER_SQRT3));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "p"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"d",
+				"vec2f"
+			],
+			[[
+				1,
+				[
+					7,
+					"p",
+					"x"
+				],
+				"-",
+				[
+					1,
+					[
+						7,
+						"p",
+						"y"
+					],
+					"/",
+					"SQRT3"
+				]
+			], [
+				1,
+				[
+					7,
+					"p",
+					"y"
+				],
+				"*",
+				"TWO_OVER_SQRT3"
+			]]
+		]]]],
+		"externalNames": [
+			"d",
+			"SQRT3",
+			"TWO_OVER_SQRT3"
+		]
+	},
+	externals: () => ({
+		d: data_exports,
+		SQRT3,
+		TWO_OVER_SQRT3
+	})
+}) && $.f)({}));
+const cellCentreUV = src_default.fn([
+	vec2f,
+	vec2f,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells) => {
+	"use gpu";
+	const aspect = __tsover_div(viewport.x, max(viewport.y, 1e-6));
+	const correctedX = __tsover_mul(uv.x, aspect);
+	const correctedY = __tsover_sub(1, uv.y);
+	const cellCenterCorrectedX = __tsover_div(__tsover_add(floor(__tsover_mul(correctedX, cells)), .5), cells);
+	const cellCenterCorrectedY = __tsover_div(__tsover_add(floor(__tsover_mul(correctedY, cells)), .5), cells);
+	return vec2f(__tsover_div(cellCenterCorrectedX, aspect), __tsover_sub(1, cellCenterCorrectedY));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "cells"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"viewport",
+							"y"
+						], [5, "0.000001"]]
+					]
+				]
+			],
+			[
+				13,
+				"correctedX",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"correctedY",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"uv",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"cellCenterCorrectedX",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"correctedX",
+								"*",
+								"cells"
+							]]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"cells"
+				]
+			],
+			[
+				13,
+				"cellCenterCorrectedY",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"correctedY",
+								"*",
+								"cells"
+							]]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"cells"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					"cellCenterCorrectedX",
+					"/",
+					"aspect"
+				], [
+					1,
+					[5, "1"],
+					"-",
+					"cellCenterCorrectedY"
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const cellCentreUVRotated = src_default.fn([
+	vec2f,
+	vec2f,
+	f32,
+	f32
+], vec2f)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((uv, viewport, cells, rotationRad) => {
+	"use gpu";
+	const aspect = __tsover_div(viewport.x, max(viewport.y, 1e-6));
+	const correctedX = __tsover_mul(uv.x, aspect);
+	const correctedY = __tsover_sub(1, uv.y);
+	const cosR = cos(rotationRad);
+	const sinR = sin(rotationRad);
+	const centerX = __tsover_mul(aspect, .5);
+	const centerY = .5;
+	const cx = __tsover_sub(correctedX, centerX);
+	const cy = __tsover_sub(correctedY, centerY);
+	const rotX = __tsover_add(__tsover_sub(__tsover_mul(cx, cosR), __tsover_mul(cy, sinR)), centerX);
+	const rotY = __tsover_add(__tsover_add(__tsover_mul(cx, sinR), __tsover_mul(cy, cosR)), centerY);
+	const cellRX = __tsover_div(__tsover_add(floor(__tsover_mul(rotX, cells)), .5), cells);
+	const cellRY = __tsover_div(__tsover_add(floor(__tsover_mul(rotY, cells)), .5), cells);
+	const ccx = __tsover_sub(cellRX, centerX);
+	const ccy = __tsover_sub(cellRY, centerY);
+	const unrotX = __tsover_add(__tsover_add(__tsover_mul(ccx, cosR), __tsover_mul(ccy, sinR)), centerX);
+	const unrotY = __tsover_add(__tsover_add(__tsover_mul(ccx, -sinR), __tsover_mul(ccy, cosR)), centerY);
+	return vec2f(__tsover_div(unrotX, aspect), __tsover_sub(1, unrotY));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [
+			{
+				"type": "i",
+				"name": "uv"
+			},
+			{
+				"type": "i",
+				"name": "viewport"
+			},
+			{
+				"type": "i",
+				"name": "cells"
+			},
+			{
+				"type": "i",
+				"name": "rotationRad"
+			}
+		],
+		"body": [0, [
+			[
+				13,
+				"aspect",
+				[
+					1,
+					[
+						7,
+						"viewport",
+						"x"
+					],
+					"/",
+					[
+						6,
+						[
+							7,
+							"std",
+							"max"
+						],
+						[[
+							7,
+							"viewport",
+							"y"
+						], [5, "0.000001"]]
+					]
+				]
+			],
+			[
+				13,
+				"correctedX",
+				[
+					1,
+					[
+						7,
+						"uv",
+						"x"
+					],
+					"*",
+					"aspect"
+				]
+			],
+			[
+				13,
+				"correctedY",
+				[
+					1,
+					[5, "1"],
+					"-",
+					[
+						7,
+						"uv",
+						"y"
+					]
+				]
+			],
+			[
+				13,
+				"cosR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"cos"
+					],
+					["rotationRad"]
+				]
+			],
+			[
+				13,
+				"sinR",
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					["rotationRad"]
+				]
+			],
+			[
+				13,
+				"centerX",
+				[
+					1,
+					"aspect",
+					"*",
+					[5, "0.5"]
+				]
+			],
+			[
+				13,
+				"centerY",
+				[5, "0.5"]
+			],
+			[
+				13,
+				"cx",
+				[
+					1,
+					"correctedX",
+					"-",
+					"centerX"
+				]
+			],
+			[
+				13,
+				"cy",
+				[
+					1,
+					"correctedY",
+					"-",
+					"centerY"
+				]
+			],
+			[
+				13,
+				"rotX",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"cx",
+							"*",
+							"cosR"
+						],
+						"-",
+						[
+							1,
+							"cy",
+							"*",
+							"sinR"
+						]
+					],
+					"+",
+					"centerX"
+				]
+			],
+			[
+				13,
+				"rotY",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"cx",
+							"*",
+							"sinR"
+						],
+						"+",
+						[
+							1,
+							"cy",
+							"*",
+							"cosR"
+						]
+					],
+					"+",
+					"centerY"
+				]
+			],
+			[
+				13,
+				"cellRX",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"rotX",
+								"*",
+								"cells"
+							]]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"cells"
+				]
+			],
+			[
+				13,
+				"cellRY",
+				[
+					1,
+					[
+						1,
+						[
+							6,
+							[
+								7,
+								"std",
+								"floor"
+							],
+							[[
+								1,
+								"rotY",
+								"*",
+								"cells"
+							]]
+						],
+						"+",
+						[5, "0.5"]
+					],
+					"/",
+					"cells"
+				]
+			],
+			[
+				13,
+				"ccx",
+				[
+					1,
+					"cellRX",
+					"-",
+					"centerX"
+				]
+			],
+			[
+				13,
+				"ccy",
+				[
+					1,
+					"cellRY",
+					"-",
+					"centerY"
+				]
+			],
+			[
+				13,
+				"unrotX",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"ccx",
+							"*",
+							"cosR"
+						],
+						"+",
+						[
+							1,
+							"ccy",
+							"*",
+							"sinR"
+						]
+					],
+					"+",
+					"centerX"
+				]
+			],
+			[
+				13,
+				"unrotY",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"ccx",
+							"*",
+							[
+								4,
+								"-",
+								"sinR"
+							]
+						],
+						"+",
+						[
+							1,
+							"ccy",
+							"*",
+							"cosR"
+						]
+					],
+					"+",
+					"centerY"
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"d",
+					"vec2f"
+				],
+				[[
+					1,
+					"unrotX",
+					"/",
+					"aspect"
+				], [
+					1,
+					[5, "1"],
+					"-",
+					"unrotY"
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const cellHash = src_default.fn([vec2f], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((id) => {
+	"use gpu";
+	const q0 = fract(id.mul(vec2f(123.34, 345.45)));
+	const q1 = q0.add(dot(q0, q0.add(34.345)));
+	return fract(__tsover_mul(q1.x, q1.y));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "id"
+		}],
+		"body": [0, [
+			[
+				13,
+				"q0",
+				[
+					6,
+					[
+						7,
+						"std",
+						"fract"
+					],
+					[[
+						6,
+						[
+							7,
+							"id",
+							"mul"
+						],
+						[[
+							6,
+							[
+								7,
+								"d",
+								"vec2f"
+							],
+							[[5, "123.34"], [5, "345.45"]]
+						]]
+					]]
+				]
+			],
+			[
+				13,
+				"q1",
+				[
+					6,
+					[
+						7,
+						"q0",
+						"add"
+					],
+					[[
+						6,
+						[
+							7,
+							"std",
+							"dot"
+						],
+						["q0", [
+							6,
+							[
+								7,
+								"q0",
+								"add"
+							],
+							[[5, "34.345"]]
+						]]
+					]]
+				]
+			],
+			[10, [
+				6,
+				[
+					7,
+					"std",
+					"fract"
+				],
+				[[
+					1,
+					[
+						7,
+						"q1",
+						"x"
+					],
+					"*",
+					[
+						7,
+						"q1",
+						"y"
+					]
+				]]
+			]]
+		]],
+		"externalNames": ["std", "d"]
+	},
+	externals: () => ({
+		std: std_exports,
+		d: data_exports
+	})
+}) && $.f)({}));
+const rowSpeedHash = src_default.fn([f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((row) => {
+	"use gpu";
+	return fract(__tsover_mul(sin(__tsover_mul(row, 127.1)), 43758.5453));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "row"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"fract"
+			],
+			[[
+				1,
+				[
+					6,
+					[
+						7,
+						"std",
+						"sin"
+					],
+					[[
+						1,
+						"row",
+						"*",
+						[5, "127.1"]
+					]]
+				],
+				"*",
+				[5, "43758.5453"]
+			]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+const rowSpeedMultiplier = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rowHash, variance) => {
+	"use gpu";
+	return __tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rowHash, .5), 4), variance));
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rowHash"
+		}, {
+			"type": "i",
+			"name": "variance"
+		}],
+		"body": [0, [[10, [
+			1,
+			[5, "1"],
+			"+",
+			[
+				1,
+				[
+					1,
+					[
+						1,
+						"rowHash",
+						"-",
+						[5, "0.5"]
+					],
+					"*",
+					[5, "4"]
+				],
+				"*",
+				"variance"
+			]
+		]]]],
+		"externalNames": []
+	},
+	externals: () => ({})
+}) && $.f)({}));
+const variationFactor = src_default.fn([f32, f32], f32)(/* @__PURE__ */ (($) => (globalThis.__TYPEGPU_META__ ??= /* @__PURE__ */ new WeakMap()).set($.f = ((rand, variation) => {
+	"use gpu";
+	return max(__tsover_add(1, __tsover_mul(__tsover_mul(__tsover_sub(rand, .5), 2), variation)), 0);
+}), {
+	v: 1,
+	name: void 0,
+	ast: {
+		"params": [{
+			"type": "i",
+			"name": "rand"
+		}, {
+			"type": "i",
+			"name": "variation"
+		}],
+		"body": [0, [[10, [
+			6,
+			[
+				7,
+				"std",
+				"max"
+			],
+			[[
+				1,
+				[5, "1"],
+				"+",
+				[
+					1,
+					[
+						1,
+						[
+							1,
+							"rand",
+							"-",
+							[5, "0.5"]
+						],
+						"*",
+						[5, "2"]
+					],
+					"*",
+					"variation"
+				]
+			], [5, "0"]]
+		]]]],
+		"externalNames": ["std"]
+	},
+	externals: () => ({ std: std_exports })
+}) && $.f)({}));
+export { cells_exports as n, cellCentreUV as t };