genshin-engine 4.0.0 → 4.1.1

package/dist/terrainWorker-DZ04cA3m.js

@@ -0,0 +1,520 @@
+import { Color, MathUtils } from "three";
+//#region src/random/createSeededRandom.ts
+const createSeededRandom = (seed) => {
+	let state = seed;
+	return () => {
+		state = state + 1831565813 >>> 0;
+		let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+		mixed ^= mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed);
+		return ((mixed ^ mixed >>> 14) >>> 0) / 2 ** 32;
+	};
+};
+//#endregion
+//#region src/models/terrain/GroundLayer.ts
+let GroundLayer = /* @__PURE__ */ function(GroundLayer) {
+	GroundLayer["Earth"] = "Earth";
+	GroundLayer["Grass"] = "Grass";
+	GroundLayer["Path"] = "Path";
+	GroundLayer["Rock"] = "Rock";
+	GroundLayer["Sand"] = "Sand";
+	GroundLayer["Snow"] = "Snow";
+	return GroundLayer;
+}({});
+const GroundLayers = Object.values(GroundLayer);
+//#endregion
+//#region src/models/terrain/TerrainFeatureKind.ts
+let TerrainFeatureKind = /* @__PURE__ */ function(TerrainFeatureKind) {
+	TerrainFeatureKind["Cliff"] = "cliff";
+	TerrainFeatureKind["Plateau"] = "plateau";
+	TerrainFeatureKind["Ridge"] = "ridge";
+	return TerrainFeatureKind;
+}({});
+//#endregion
+//#region src/noise/createSimplexNoise.ts
+const SKEW = (Math.sqrt(3) - 1) / 2;
+const UNSKEW = (3 - Math.sqrt(3)) / 6;
+const GRADIENTS_X = [
+	1,
+	-1,
+	1,
+	-1,
+	1,
+	-1,
+	0,
+	0
+];
+const GRADIENTS_Y = [
+	1,
+	1,
+	-1,
+	-1,
+	0,
+	0,
+	1,
+	-1
+];
+const NOISE_SCALE = 70;
+const getCornerContribution = (gradientIndex, offsetX, offsetY) => {
+	const falloff = .5 - offsetX * offsetX - offsetY * offsetY;
+	if (falloff < 0) return 0;
+	const gradient = gradientIndex & 7;
+	return falloff ** 4 * ((GRADIENTS_X[gradient] ?? 0) * offsetX + (GRADIENTS_Y[gradient] ?? 0) * offsetY);
+};
+const createSimplexNoise = (seed) => {
+	const random = createSeededRandom(seed);
+	const table = Uint8Array.from({ length: 256 }, (_value, index) => index);
+	for (let index = table.length - 1; index > 0; index--) {
+		const swapIndex = Math.floor(random() * (index + 1));
+		[table[index], table[swapIndex]] = [table[swapIndex] ?? 0, table[index] ?? 0];
+	}
+	const permutation = Uint8Array.from({ length: 512 }, (_value, index) => table[index & 255] ?? 0);
+	return (x, y) => {
+		const skew = (x + y) * SKEW;
+		const cellX = Math.floor(x + skew);
+		const cellY = Math.floor(y + skew);
+		const unskew = (cellX + cellY) * UNSKEW;
+		const offsetX = x - cellX + unskew;
+		const offsetY = y - cellY + unskew;
+		const middleX = offsetX > offsetY ? 1 : 0;
+		const middleY = 1 - middleX;
+		const tableX = cellX & 255;
+		const tableY = cellY & 255;
+		return NOISE_SCALE * (getCornerContribution(permutation[tableX + (permutation[tableY] ?? 0)] ?? 0, offsetX, offsetY) + getCornerContribution(permutation[tableX + middleX + (permutation[tableY + middleY] ?? 0)] ?? 0, offsetX - middleX + UNSKEW, offsetY - middleY + UNSKEW) + getCornerContribution(permutation[tableX + 1 + (permutation[tableY + 1] ?? 0)] ?? 0, offsetX - 1 + 2 * UNSKEW, offsetY - 1 + 2 * UNSKEW));
+	};
+};
+//#endregion
+//#region src/terrain/constants.ts
+const TILE_INDEX_OFFSET = 2 ** 19;
+const TILE_INDEX_SPAN = 2 ** 20;
+const TERRAIN_LAYER = 1;
+const TERRAIN_RING_INITIAL_TILE_COUNT = 64;
+const TERRAIN_CELL_SIZE = 64;
+const GAUSSIAN_REACH_WIDTHS = 3;
+const TERRAIN_HEIGHT_PADDING = 2;
+//#endregion
+//#region src/terrain/getTerrainTileLevel.ts
+const getTerrainTileLevel = (key) => Math.floor(key / TILE_INDEX_SPAN / TILE_INDEX_SPAN);
+//#endregion
+//#region src/terrain/measureSegment.ts
+const measurement = /* @__PURE__ */ new Float64Array(2);
+const measureSegment = ({ endX, endZ, startX, startZ }, x, z) => {
+	const directionX = endX - startX;
+	const directionZ = endZ - startZ;
+	const length = Math.hypot(directionX, directionZ);
+	const offsetX = x - startX;
+	const offsetZ = z - startZ;
+	const along = (offsetX * directionX + offsetZ * directionZ) / length;
+	measurement[0] = (directionX * offsetZ - directionZ * offsetX) / length;
+	measurement[1] = Math.max(0, -along, along - length);
+	return measurement;
+};
+//#endregion
+//#region src/terrain/getCliffBlend.ts
+const getCliffBlend = (feature, x, z) => {
+	const measurement = measureSegment(feature, x, z);
+	const across = measurement[0] ?? 0;
+	const beyond = measurement[1] ?? 0;
+	const { falloff, width } = feature;
+	return MathUtils.smoothstep(across, -falloff, falloff) * (1 - MathUtils.smoothstep(across, width, width + falloff)) * (1 - MathUtils.smoothstep(beyond, 0, falloff));
+};
+//#endregion
+//#region src/terrain/getPlateauBlend.ts
+const getPlateauBlend = (feature, x, z) => {
+	const { falloff, radius, x: centreX, z: centreZ } = feature;
+	return 1 - MathUtils.smoothstep(Math.hypot(x - centreX, z - centreZ), radius, radius + falloff);
+};
+//#endregion
+//#region src/terrain/getRidgeBlend.ts
+const getRidgeBlend = (feature, x, z) => {
+	const measurement = measureSegment(feature, x, z);
+	const across = measurement[0] ?? 0;
+	const beyond = measurement[1] ?? 0;
+	const { width } = feature;
+	return Math.exp(-(across ** 2 + beyond ** 2) / (2 * width * width));
+};
+//#endregion
+//#region src/terrain/TerrainFeatureKindBlendMap.ts
+const TerrainFeatureKindBlendMap = {
+	["cliff"]: getCliffBlend,
+	["plateau"]: getPlateauBlend,
+	["ridge"]: getRidgeBlend
+};
+//#endregion
+//#region src/terrain/blendGridNodes.ts
+const blendGridNodes = (values, sizeX, sizeZ, column, row) => {
+	const left = Math.floor(column);
+	const near = Math.floor(row);
+	const right = Math.min(left + 1, sizeX - 1);
+	const far = Math.min(near + 1, sizeZ - 1);
+	const across = column - left;
+	const along = row - near;
+	return ((values[near * sizeX + left] ?? 0) * (1 - across) + (values[near * sizeX + right] ?? 0) * across) * (1 - along) + ((values[far * sizeX + left] ?? 0) * (1 - across) + (values[far * sizeX + right] ?? 0) * across) * along;
+};
+//#endregion
+//#region src/terrain/getTerrainTileColumn.ts
+const getTerrainTileColumn = (key) => key % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
+//#endregion
+//#region src/terrain/getTerrainTileRow.ts
+const getTerrainTileRow = (key) => Math.floor(key / TILE_INDEX_SPAN) % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
+//#endregion
+//#region src/terrain/computeTerrainTile.ts
+const writeNormal = (normals, offset, heights, paddedIndex, paddedSide, reach, step) => {
+	const height = heights[paddedIndex] ?? 0;
+	const normalX = (heights[paddedIndex - reach] ?? height) - (heights[paddedIndex + reach] ?? height);
+	const normalY = 2 * reach * step;
+	const normalZ = (heights[paddedIndex - reach * paddedSide] ?? height) - (heights[paddedIndex + reach * paddedSide] ?? height);
+	const length = Math.hypot(normalX, normalY, normalZ);
+	normals[offset] = normalX / length;
+	normals[offset + 1] = normalY / length;
+	normals[offset + 2] = normalZ / length;
+	return normalY / length;
+};
+const computeTerrainTile = ({ cellsPerSide, finestTileSize, getHeight, key, writeColor }) => {
+	const level = getTerrainTileLevel(key);
+	const size = finestTileSize * 2 ** level;
+	const step = size / cellsPerSide;
+	const left = getTerrainTileColumn(key) * size;
+	const back = getTerrainTileRow(key) * size;
+	const side = cellsPerSide + 1;
+	const paddedSide = side + 4;
+	const heights = new Float32Array(paddedSide * paddedSide);
+	for (let row = 0; row < paddedSide; row++) for (let column = 0; column < paddedSide; column++) heights[row * paddedSide + column] = getHeight(left + (column - 2) * step, back + (row - 2) * step);
+	const vertexCount = side * side;
+	const positions = new Float32Array(vertexCount * 3);
+	const normals = new Float32Array(vertexCount * 3);
+	const colors = new Float32Array(vertexCount * 3);
+	const coarsePositions = new Float32Array(vertexCount * 4);
+	const coarseNormals = new Float32Array(vertexCount * 3);
+	const coarseColors = new Float32Array(vertexCount * 3);
+	for (let row = 0; row < side; row++) for (let column = 0; column < side; column++) {
+		const paddedIndex = (row + 2) * paddedSide + column + 2;
+		const height = heights[paddedIndex] ?? 0;
+		const index = row * side + column;
+		const offset = index * 3;
+		const x = column * step;
+		const z = row * step;
+		positions[offset] = x;
+		positions[offset + 1] = height;
+		positions[offset + 2] = z;
+		writeColor(colors, offset, height, 1 - writeNormal(normals, offset, heights, paddedIndex, paddedSide, 1, step), left + x, back + z);
+		const coarseColumn = column - column % 2;
+		const coarseRow = row - row % 2;
+		const coarseOffset = index * 4;
+		coarsePositions[coarseOffset] = coarseColumn * step;
+		coarsePositions[coarseOffset + 1] = heights[(coarseRow + 2) * paddedSide + coarseColumn + 2] ?? height;
+		coarsePositions[coarseOffset + 2] = coarseRow * step;
+		coarsePositions[coarseOffset + 3] = level;
+		if (coarseColumn !== column || coarseRow !== row) {
+			const evenOffset = (coarseRow * side + coarseColumn) * 3;
+			for (let component = 0; component < 3; component++) {
+				coarseNormals[offset + component] = coarseNormals[evenOffset + component] ?? 0;
+				coarseColors[offset + component] = coarseColors[evenOffset + component] ?? 0;
+			}
+			continue;
+		}
+		writeColor(coarseColors, offset, height, 1 - writeNormal(coarseNormals, offset, heights, paddedIndex, paddedSide, 2, step), left + x, back + z);
+	}
+	return {
+		coarseColors,
+		coarseNormals,
+		coarsePositions,
+		colors,
+		key,
+		normals,
+		positions
+	};
+};
+//#endregion
+//#region src/terrain/fileByCell.ts
+const NO_ITEMS = [];
+const toCellKey = (column, row) => `${column},${row}`;
+const fileByCell = (items, getBounds) => {
+	const cellItemsMap = /* @__PURE__ */ new Map();
+	for (const item of items) {
+		const { maxX, maxZ, minX, minZ } = getBounds(item);
+		for (let column = Math.floor(minX / 64); column <= Math.floor(maxX / 64); column++) for (let row = Math.floor(minZ / 64); row <= Math.floor(maxZ / 64); row++) {
+			const key = toCellKey(column, row);
+			const cellItems = cellItemsMap.get(key);
+			if (cellItems) cellItems.push(item);
+			else cellItemsMap.set(key, [item]);
+		}
+	}
+	return (x, z) => cellItemsMap.get(toCellKey(Math.floor(x / 64), Math.floor(z / 64))) ?? NO_ITEMS;
+};
+//#endregion
+//#region src/terrain/getGaussianHillBlend.ts
+const getGaussianHillBlend = ({ width, x: hillX, z: hillZ }, x, z) => {
+	const reach = 3 * width;
+	const acrossX = x - hillX;
+	const acrossZ = z - hillZ;
+	if (Math.abs(acrossX) > reach || Math.abs(acrossZ) > reach) return 0;
+	return Math.exp(-(acrossX ** 2 + acrossZ ** 2) / (2 * width * width));
+};
+//#endregion
+//#region src/terrain/createGaussianHillsHeight.ts
+const createGaussianHillsHeight = ({ base, hills }) => {
+	const getHills = fileByCell(hills, ({ width, x, z }) => {
+		const reach = 3 * width;
+		return {
+			maxX: x + reach,
+			maxZ: z + reach,
+			minX: x - reach,
+			minZ: z - reach
+		};
+	});
+	return (x, z) => {
+		let total = base;
+		for (const hill of getHills(x, z)) total += hill.height * getGaussianHillBlend(hill, x, z);
+		return total;
+	};
+};
+//#endregion
+//#region src/terrain/getSegmentBounds.ts
+const getSegmentBounds = (startX, startZ, endX, endZ, reach) => ({
+	maxX: Math.max(startX, endX) + reach,
+	maxZ: Math.max(startZ, endZ) + reach,
+	minX: Math.min(startX, endX) - reach,
+	minZ: Math.min(startZ, endZ) - reach
+});
+//#endregion
+//#region src/terrain/sampleGroundLayerField.ts
+const sampleGroundLayerField = ({ cellSize, layers, origin, size }, x, z, weights) => {
+	const sizeX = size[0] ?? 1;
+	const sizeZ = size[1] ?? 1;
+	const column = Math.min(Math.max((x - (origin[0] ?? 0)) / cellSize, 0), sizeX - 1);
+	const row = Math.min(Math.max((z - (origin[1] ?? 0)) / cellSize, 0), sizeZ - 1);
+	let total = 0;
+	for (const layer of GroundLayers) {
+		const shares = layers[layer];
+		const share = shares === void 0 ? 0 : blendGridNodes(shares, sizeX, sizeZ, column, row);
+		weights[layer] = share;
+		total += share;
+	}
+	if (total === 0) {
+		weights["Grass"] = 1;
+		return;
+	}
+	for (const layer of GroundLayers) weights[layer] /= total;
+};
+//#endregion
+//#region src/terrain/createGroundLayerWeights.ts
+const getBandAmount = ({ end, start }, value) => end >= start ? MathUtils.smoothstep(value, start, end) : 1 - MathUtils.smoothstep(value, end, start);
+const layOver = (weights, layer, amount) => {
+	if (amount === 0) return;
+	for (const groundLayer of GroundLayers) weights[groundLayer] *= 1 - amount;
+	weights[layer] += amount;
+};
+const createGroundLayerWeights = ({ earthSlope, layerField, pathFalloff, paths, rockSlope, sandHeight, snowHeight }) => {
+	const weights = {
+		["Earth"]: 0,
+		["Grass"]: 0,
+		["Path"]: 0,
+		["Rock"]: 0,
+		["Sand"]: 0,
+		["Snow"]: 0
+	};
+	const getPaths = fileByCell(paths, ({ endX, endZ, startX, startZ, width }) => getSegmentBounds(startX, startZ, endX, endZ, width / 2 + pathFalloff));
+	return (height, slope, x, z) => {
+		if (layerField) sampleGroundLayerField(layerField, x, z, weights);
+		else {
+			for (const groundLayer of GroundLayers) weights[groundLayer] = 0;
+			weights["Grass"] = 1;
+		}
+		if (earthSlope) layOver(weights, "Earth", getBandAmount(earthSlope, slope));
+		if (sandHeight) layOver(weights, "Sand", getBandAmount(sandHeight, height));
+		if (snowHeight) layOver(weights, "Snow", getBandAmount(snowHeight, height));
+		let pathAmount = 0;
+		for (const path of getPaths(x, z)) {
+			const measurement = measureSegment(path, x, z);
+			const halfWidth = path.width / 2;
+			const distance = Math.hypot(measurement[0] ?? 0, measurement[1] ?? 0);
+			pathAmount = Math.max(pathAmount, 1 - MathUtils.smoothstep(distance, halfWidth, halfWidth + pathFalloff));
+		}
+		layOver(weights, "Path", pathAmount);
+		if (rockSlope) layOver(weights, "Rock", getBandAmount(rockSlope, slope));
+		return weights;
+	};
+};
+//#endregion
+//#region src/terrain/createGroundPaintColor.ts
+const createGroundPaintColor = (groundPaint, seed) => {
+	const { layerColors, patchScale } = groundPaint;
+	const getWeights = createGroundLayerWeights(groundPaint);
+	const noise = createSimplexNoise(seed);
+	const linearLayerColors = GroundLayers.map((layer) => ({
+		color: new Color(layerColors[layer].color),
+		layer,
+		patchColor: new Color(layerColors[layer].patchColor)
+	}));
+	const layerColor = new Color();
+	return (colors, offset, height, slope, x, z) => {
+		const weights = getWeights(height, slope, x, z);
+		const patch = (noise(x / patchScale, z / patchScale) + 1) / 2;
+		let red = 0;
+		let green = 0;
+		let blue = 0;
+		for (const { color, layer, patchColor } of linearLayerColors) {
+			const weight = weights[layer];
+			if (weight === 0) continue;
+			layerColor.lerpColors(color, patchColor, patch);
+			red += layerColor.r * weight;
+			green += layerColor.g * weight;
+			blue += layerColor.b * weight;
+		}
+		colors[offset] = red;
+		colors[offset + 1] = green;
+		colors[offset + 2] = blue;
+	};
+};
+//#endregion
+//#region src/terrain/sampleTerrainResidualFade.ts
+const sampleTerrainResidualFade = ({ cellSize, clearings, origin, size, weights }, x, z) => {
+	const sizeX = size[0] ?? 1;
+	const sizeZ = size[1] ?? 1;
+	const column = (x - (origin[0] ?? 0)) / cellSize;
+	const row = (z - (origin[1] ?? 0)) / cellSize;
+	if (column < 0 || row < 0 || column > sizeX - 1 || row > sizeZ - 1) return 0;
+	let weight = blendGridNodes(weights, sizeX, sizeZ, column, row);
+	for (const { falloff, radius, x: centreX, z: centreZ } of clearings) weight *= MathUtils.smoothstep(Math.hypot(x - centreX, z - centreZ), radius, radius + falloff);
+	return weight;
+};
+//#endregion
+//#region src/terrain/createResidualHeight.ts
+const createResidualHeight = ({ amplitude, fade, octaves, scale, seed }) => {
+	const noise = createSimplexNoise(seed);
+	return (x, z) => {
+		const weight = fade ? sampleTerrainResidualFade(fade, x, z) : 1;
+		if (weight === 0) return 0;
+		let total = 0;
+		let octaveAmplitude = amplitude;
+		let frequency = 1 / scale;
+		for (let octave = 0; octave < octaves; octave++) {
+			total += octaveAmplitude * noise(x * frequency, z * frequency);
+			octaveAmplitude /= 2;
+			frequency *= 2;
+		}
+		return weight * total;
+	};
+};
+//#endregion
+//#region src/terrain/getTerrainFeatureBounds.ts
+const TerrainFeatureKindBoundsMap = {
+	["cliff"]: (feature) => {
+		const { endX, endZ, falloff, startX, startZ, width } = feature;
+		return getSegmentBounds(startX, startZ, endX, endZ, width + falloff);
+	},
+	["plateau"]: (feature) => {
+		const { falloff, radius, x, z } = feature;
+		const reach = radius + falloff;
+		return {
+			maxX: x + reach,
+			maxZ: z + reach,
+			minX: x - reach,
+			minZ: z - reach
+		};
+	},
+	["ridge"]: (feature) => {
+		const { endX, endZ, startX, startZ, width } = feature;
+		return getSegmentBounds(startX, startZ, endX, endZ, 3 * width);
+	}
+};
+const getTerrainFeatureBounds = (feature) => TerrainFeatureKindBoundsMap[feature.kind](feature);
+//#endregion
+//#region src/terrain/createTerrainFeaturesBlend.ts
+const createTerrainFeaturesBlend = (features) => {
+	const getFeatures = fileByCell(features, getTerrainFeatureBounds);
+	return (x, z) => {
+		let blend = 0;
+		for (const feature of getFeatures(x, z)) blend = Math.max(blend, TerrainFeatureKindBlendMap[feature.kind](feature, x, z));
+		return blend;
+	};
+};
+//#endregion
+//#region src/terrain/createTerrainFeaturesHeight.ts
+const createTerrainFeaturesHeight = (features) => {
+	const getFeatures = fileByCell(features, getTerrainFeatureBounds);
+	return (x, z) => {
+		let total = 0;
+		for (const feature of getFeatures(x, z)) total += feature.height * TerrainFeatureKindBlendMap[feature.kind](feature, x, z);
+		return total;
+	};
+};
+//#endregion
+//#region src/terrain/getTerrainShapeLevel.ts
+const getTerrainShapeLevel = ({ base, hills }, baseUnder) => {
+	if (hills.length === 0) return void 0;
+	let minX = Infinity;
+	let maxX = -Infinity;
+	let minZ = Infinity;
+	let maxZ = -Infinity;
+	let maxWidth = 0;
+	for (const { width, x, z } of hills) {
+		minX = Math.min(minX, x);
+		maxX = Math.max(maxX, x);
+		minZ = Math.min(minZ, z);
+		maxZ = Math.max(maxZ, z);
+		maxWidth = Math.max(maxWidth, width);
+	}
+	return {
+		falloff: 3 * maxWidth,
+		height: base - baseUnder,
+		kind: "plateau",
+		radius: Math.hypot(maxX - minX, maxZ - minZ) / 2,
+		x: (minX + maxX) / 2,
+		z: (minZ + maxZ) / 2
+	};
+};
+//#endregion
+//#region src/terrain/createTerrainShapeHeight.ts
+const createTerrainShapeHeight = (shape, ...overlays) => {
+	const shapes = [shape, ...overlays];
+	const features = shapes.flatMap((layer) => layer.features ?? []);
+	const levels = overlays.flatMap((overlay) => getTerrainShapeLevel(overlay, shape.base) ?? []);
+	const getHillsHeight = createGaussianHillsHeight({
+		base: shape.base,
+		hills: shapes.flatMap(({ hills }) => hills)
+	});
+	const getFeaturesHeight = createTerrainFeaturesHeight([...features, ...levels]);
+	const residualHeights = shapes.flatMap(({ residual }) => residual ? [createResidualHeight(residual)] : []);
+	if (residualHeights.length === 0) return (x, z) => getHillsHeight(x, z) + getFeaturesHeight(x, z);
+	const getFeaturesBlend = createTerrainFeaturesBlend(features);
+	return (x, z) => {
+		const residualShare = 1 - getFeaturesBlend(x, z);
+		let residualHeight = 0;
+		if (residualShare > 0) for (const getResidualHeight of residualHeights) residualHeight += residualShare * getResidualHeight(x, z);
+		return getHillsHeight(x, z) + getFeaturesHeight(x, z) + residualHeight;
+	};
+};
+//#endregion
+//#region src/vegetation/computeScatterPoints.ts
+const CELL_SIZE_PER_SPACING = 1 / Math.SQRT2;
+const CELL_REACH = Math.ceil(Math.SQRT2);
+const checkIsCrowded = (cells, cellsPerSide, points, spacing, column, row, x, z) => {
+	for (let neighbourRow = Math.max(0, row - CELL_REACH); neighbourRow <= Math.min(cellsPerSide - 1, row + CELL_REACH); neighbourRow++) for (let neighbourColumn = Math.max(0, column - CELL_REACH); neighbourColumn <= Math.min(cellsPerSide - 1, column + CELL_REACH); neighbourColumn++) {
+		const pointIndex = cells[neighbourRow * cellsPerSide + neighbourColumn] ?? -1;
+		if (pointIndex === -1) continue;
+		const distanceX = (points[pointIndex * 2] ?? 0) - x;
+		const distanceZ = (points[pointIndex * 2 + 1] ?? 0) - z;
+		if (distanceX * distanceX + distanceZ * distanceZ < spacing * spacing) return true;
+	}
+	return false;
+};
+const computeScatterPoints = ({ candidateCount, checkIsAccepted, seed, size, spacing }) => {
+	const random = createSeededRandom(seed);
+	const cellSize = spacing * CELL_SIZE_PER_SPACING;
+	const cellsPerSide = Math.ceil(size / cellSize);
+	const cells = new Int32Array(cellsPerSide * cellsPerSide).fill(-1);
+	const points = [];
+	for (let candidate = 0; candidate < candidateCount; candidate++) {
+		const x = random() * size;
+		const z = random() * size;
+		const column = Math.floor(x / cellSize);
+		const row = Math.floor(z / cellSize);
+		if (!checkIsAccepted(x, z) || checkIsCrowded(cells, cellsPerSide, points, spacing, column, row, x, z)) continue;
+		cells[row * cellsPerSide + column] = points.length / 2;
+		points.push(x, z);
+	}
+	return Float32Array.from(points);
+};
+//#endregion
+export { TERRAIN_RING_INITIAL_TILE_COUNT as A, getCliffBlend as C, TERRAIN_CELL_SIZE as D, GAUSSIAN_REACH_WIDTHS as E, GroundLayer as F, GroundLayers as I, createSeededRandom as L, TILE_INDEX_SPAN as M, createSimplexNoise as N, TERRAIN_HEIGHT_PADDING as O, TerrainFeatureKind as P, getPlateauBlend as S, getTerrainTileLevel as T, getTerrainTileRow as _, createTerrainFeaturesBlend as a, TerrainFeatureKindBlendMap as b, sampleTerrainResidualFade as c, sampleGroundLayerField as d, getSegmentBounds as f, computeTerrainTile as g, fileByCell as h, createTerrainFeaturesHeight as i, TILE_INDEX_OFFSET as j, TERRAIN_LAYER as k, createGroundPaintColor as l, getGaussianHillBlend as m, createTerrainShapeHeight as n, getTerrainFeatureBounds as o, createGaussianHillsHeight as p, getTerrainShapeLevel as r, createResidualHeight as s, computeScatterPoints as t, createGroundLayerWeights as u, getTerrainTileColumn as v, measureSegment as w, getRidgeBlend as x, blendGridNodes as y };

package/dist/terrainWorker.d.ts

@@ -0,0 +1,2 @@
+import { E as GroundLayers, T as GroundLayer, a as createTerrainShapeHeight, c as computeTerrainTile, i as getTerrainTileColumn, l as createSeededRandom, n as getTerrainTileRow, o as createGroundPaintColor, r as getTerrainTileLevel, s as createGroundLayerWeights, t as computeScatterPoints } from "./terrainWorker-CLOYYKT1.js";
+export { GroundLayer, GroundLayers, computeScatterPoints, computeTerrainTile, createGroundLayerWeights, createGroundPaintColor, createSeededRandom, createTerrainShapeHeight, getTerrainTileColumn, getTerrainTileLevel, getTerrainTileRow };

package/dist/terrainWorker.js

@@ -0,0 +1 @@
+export { F as GroundLayer, I as GroundLayers, t as computeScatterPoints, g as computeTerrainTile, u as createGroundLayerWeights, l as createGroundPaintColor, L as createSeededRandom, n as createTerrainShapeHeight, v as getTerrainTileColumn, T as getTerrainTileLevel, _ as getTerrainTileRow } from "./terrainWorker-DZ04cA3m.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genshin-engine",
-  "version": "4.0.0",
+  "version": "4.1.1",
   "description": "An anime-style open-world engine for the browser on three.js WebGPU — toon materials, outlines, post-processing, streamed terrain, parametric world kits and a Web Audio synthesizer, as plain TypeScript and TSL modules.",
   "keywords": [
     "anime",
@@ -36,6 +36,7 @@
   },
   "exports": {
     ".": "./dist/index.js",
+    "./terrainWorker": "./dist/terrainWorker.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -51,19 +52,22 @@
     "test": "vitest",
     "typecheck": "tsc"
   },
+  "dependencies": {
+    "three-mesh-bvh": "^0.9.16"
+  },
   "devDependencies": {
     "@arethetypeswrong/core": "^0.18.5",
-    "@esposter/configuration": "4.0.0",
-    "@esposter/shared-node": "4.0.0",
-    "@types/node": "^26.6.4",
+    "@esposter/configuration": "4.1.1",
+    "@esposter/shared-node": "4.1.1",
+    "@types/node": "^26.6.5",
     "@types/three": "^0.186.0",
     "publint": "^0.3.25",
-    "tsdown": "^0.23.0",
-    "vite": "^8.3.3",
-    "vitest": "^5.0.3"
+    "tsdown": "^0.23.1",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.4"
   },
   "peerDependencies": {
     "three": "^0.186.1"
   },
-  "gitHead": "7667bc8c9a2b4e9dcacd6b845ee8cc9951250ae7"
+  "gitHead": "47b7795ab557d7731aa60588d0b9d1cdff243328"
 }