shaders 3.1.463 → 3.2.464

package/dist/core/cells-C-mOgwV1.js

@@ -1,943 +0,0 @@
-import { Dt as sin, Mt as vec2f, _t as max, dt as dot, et as typegpu_default, hn as __export, ht as fract, lt as cos, mt as floor, qt as struct, rt as select, sn as f32 } from "./edges-CV-BHMpI.js";
-import { a as SQRT3 } from "./constants-BKlzQFdJ.js";
-import { n as flooredMod2 } from "./geom-BS390xIn.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 = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [[10, [
-			6,
-			"CellTile",
-			[[104, {
-				"cell": [
-					6,
-					"std.floor",
-					["p"]
-				],
-				"local": [
-					6,
-					"std.fract",
-					["p"]
-				]
-			}]]
-		]]]]
-	},
-	externals: {
-		"CellTile": () => CellTile,
-		"std.floor": () => floor,
-		"std.fract": () => fract
-	}
-}) && $.f)({}));
-const HexCell = struct({
-	gv: vec2f,
-	id: vec2f
-}).$name("HexCell");
-const hexTiling = typegpu_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: 2,
-	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,
-					"std.select",
-					[
-						"b",
-						"a",
-						[
-							1,
-							[
-								6,
-								"std.dot",
-								["a", "a"]
-							],
-							"<",
-							[
-								6,
-								"std.dot",
-								["b", "b"]
-							]
-						]
-					]
-				]
-			],
-			[10, [
-				6,
-				"HexCell",
-				[[104, {
-					"gv": "gv",
-					"id": [
-						6,
-						[
-							7,
-							"p",
-							"sub"
-						],
-						["gv"]
-					]
-				}]]
-			]]
-		]]
-	},
-	externals: {
-		"flooredMod2": () => flooredMod2,
-		"std.select": () => select,
-		"std.dot": () => dot,
-		"HexCell": () => HexCell
-	}
-}) && $.f)({}));
-const triLattice = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "p"
-		}],
-		"body": [0, [[10, [
-			6,
-			"d.vec2f",
-			[[
-				1,
-				[
-					7,
-					"p",
-					"x"
-				],
-				"-",
-				[
-					1,
-					[
-						7,
-						"p",
-						"y"
-					],
-					"/",
-					"SQRT3"
-				]
-			], [
-				1,
-				[
-					7,
-					"p",
-					"y"
-				],
-				"*",
-				"TWO_OVER_SQRT3"
-			]]
-		]]]]
-	},
-	externals: {
-		"d.vec2f": () => vec2f,
-		"SQRT3": () => SQRT3,
-		"TWO_OVER_SQRT3": () => TWO_OVER_SQRT3
-	}
-}) && $.f)({}));
-const cellCentreUV = typegpu_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: 2,
-	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,
-						"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,
-							"std.floor",
-							[[
-								1,
-								"correctedX",
-								"*",
-								"cells"
-							]]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"cells"
-				]
-			],
-			[
-				13,
-				"cellCenterCorrectedY",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"std.floor",
-							[[
-								1,
-								"correctedY",
-								"*",
-								"cells"
-							]]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"cells"
-				]
-			],
-			[10, [
-				6,
-				"d.vec2f",
-				[[
-					1,
-					"cellCenterCorrectedX",
-					"/",
-					"aspect"
-				], [
-					1,
-					[5, "1"],
-					"-",
-					"cellCenterCorrectedY"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const cellCentreUVRotated = typegpu_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: 2,
-	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,
-						"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,
-					"std.cos",
-					["rotationRad"]
-				]
-			],
-			[
-				13,
-				"sinR",
-				[
-					6,
-					"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,
-							"std.floor",
-							[[
-								1,
-								"rotX",
-								"*",
-								"cells"
-							]]
-						],
-						"+",
-						[5, "0.5"]
-					],
-					"/",
-					"cells"
-				]
-			],
-			[
-				13,
-				"cellRY",
-				[
-					1,
-					[
-						1,
-						[
-							6,
-							"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,
-				"d.vec2f",
-				[[
-					1,
-					"unrotX",
-					"/",
-					"aspect"
-				], [
-					1,
-					[5, "1"],
-					"-",
-					"unrotY"
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.max": () => max,
-		"std.cos": () => cos,
-		"std.sin": () => sin,
-		"std.floor": () => floor,
-		"d.vec2f": () => vec2f
-	}
-}) && $.f)({}));
-const cellHash = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "id"
-		}],
-		"body": [0, [
-			[
-				13,
-				"q0",
-				[
-					6,
-					"std.fract",
-					[[
-						6,
-						[
-							7,
-							"id",
-							"mul"
-						],
-						[[
-							6,
-							"d.vec2f",
-							[[5, "123.34"], [5, "345.45"]]
-						]]
-					]]
-				]
-			],
-			[
-				13,
-				"q1",
-				[
-					6,
-					[
-						7,
-						"q0",
-						"add"
-					],
-					[[
-						6,
-						"std.dot",
-						["q0", [
-							6,
-							[
-								7,
-								"q0",
-								"add"
-							],
-							[[5, "34.345"]]
-						]]
-					]]
-				]
-			],
-			[10, [
-				6,
-				"std.fract",
-				[[
-					1,
-					[
-						7,
-						"q1",
-						"x"
-					],
-					"*",
-					[
-						7,
-						"q1",
-						"y"
-					]
-				]]
-			]]
-		]]
-	},
-	externals: {
-		"std.fract": () => fract,
-		"d.vec2f": () => vec2f,
-		"std.dot": () => dot
-	}
-}) && $.f)({}));
-const rowSpeedHash = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "row"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.fract",
-			[[
-				1,
-				[
-					6,
-					"std.sin",
-					[[
-						1,
-						"row",
-						"*",
-						[5, "127.1"]
-					]]
-				],
-				"*",
-				[5, "43758.5453"]
-			]]
-		]]]]
-	},
-	externals: {
-		"std.fract": () => fract,
-		"std.sin": () => sin
-	}
-}) && $.f)({}));
-const rowSpeedMultiplier = typegpu_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: 2,
-	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"
-			]
-		]]]]
-	},
-	externals: {}
-}) && $.f)({}));
-const variationFactor = typegpu_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: 2,
-	name: void 0,
-	ast: {
-		"params": [{
-			"type": "i",
-			"name": "rand"
-		}, {
-			"type": "i",
-			"name": "variation"
-		}],
-		"body": [0, [[10, [
-			6,
-			"std.max",
-			[[
-				1,
-				[5, "1"],
-				"+",
-				[
-					1,
-					[
-						1,
-						[
-							1,
-							"rand",
-							"-",
-							[5, "0.5"]
-						],
-						"*",
-						[5, "2"]
-					],
-					"*",
-					"variation"
-				]
-			], [5, "0"]]
-		]]]]
-	},
-	externals: { "std.max": () => max }
-}) && $.f)({}));
-export { cells_exports as n, cellCentreUV as t };