genshin-engine 4.3.3 → 4.4.0

package/dist/terrainWorker-Bgj3rmZs.js

@@ -1,490 +0,0 @@
-import { Color, MathUtils } from "three";
-// 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;
-	};
-};
-// 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);
-// src/models/terrain/TerrainFeatureKind.ts
-let TerrainFeatureKind = /* @__PURE__ */ function(TerrainFeatureKind) {
-	TerrainFeatureKind["Cliff"] = "cliff";
-	TerrainFeatureKind["Plateau"] = "plateau";
-	TerrainFeatureKind["Ridge"] = "ridge";
-	return TerrainFeatureKind;
-}({});
-// 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));
-	};
-};
-// 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;
-// src/terrain/getTerrainTileLevel.ts
-const getTerrainTileLevel = (key) => Math.floor(key / TILE_INDEX_SPAN / TILE_INDEX_SPAN);
-// 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;
-};
-// 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));
-};
-// 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);
-};
-// 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));
-};
-// src/terrain/TerrainFeatureKindBlendMap.ts
-const TerrainFeatureKindBlendMap = {
-	["cliff"]: getCliffBlend,
-	["plateau"]: getPlateauBlend,
-	["ridge"]: getRidgeBlend
-};
-// 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;
-};
-// src/terrain/getTerrainTileColumn.ts
-const getTerrainTileColumn = (key) => key % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
-// src/terrain/getTerrainTileRow.ts
-const getTerrainTileRow = (key) => Math.floor(key / TILE_INDEX_SPAN) % TILE_INDEX_SPAN - TILE_INDEX_OFFSET;
-// 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
-	};
-};
-// 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;
-};
-// 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));
-};
-// 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;
-	};
-};
-// 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
-});
-// 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;
-};
-// 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;
-	};
-};
-// 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;
-	};
-};
-// 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;
-};
-// 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;
-	};
-};
-// 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);
-// 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;
-	};
-};
-// 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;
-	};
-};
-// 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
-	};
-};
-// 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;
-	};
-};
-// 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);
-};
-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-BjxpqdfH.d.ts

@@ -1,147 +0,0 @@
-declare enum TerrainFeatureKind {
-  Cliff = "cliff",
-  Plateau = "plateau",
-  Ridge = "ridge"
-}
-interface CliffFeature {
-  endX: number;
-  endZ: number;
-  falloff: number;
-  height: number;
-  kind: TerrainFeatureKind.Cliff;
-  startX: number;
-  startZ: number;
-  width: number;
-}
-interface GaussianHill {
-  height: number;
-  width: number;
-  x: number;
-  z: number;
-}
-interface GaussianHills {
-  base: number;
-  hills: GaussianHill[];
-}
-interface GroundBand {
-  end: number;
-  start: number;
-}
-declare enum GroundLayer {
-  Earth = "Earth",
-  Grass = "Grass",
-  Path = "Path",
-  Rock = "Rock",
-  Sand = "Sand",
-  Snow = "Snow"
-}
-declare const GroundLayers: readonly GroundLayer[];
-interface GroundLayerColors {
-  color: number;
-  patchColor: number;
-}
-interface GroundLayerField {
-  cellSize: number;
-  layers: Partial<Record<GroundLayer, readonly number[]>>;
-  origin: readonly number[];
-  size: readonly number[];
-}
-interface GroundPathSegment {
-  endX: number;
-  endZ: number;
-  startX: number;
-  startZ: number;
-  width: number;
-}
-interface GroundPaint {
-  earthSlope?: GroundBand;
-  layerColors: Record<GroundLayer, GroundLayerColors>;
-  layerField?: GroundLayerField;
-  patchScale: number;
-  pathFalloff: number;
-  paths: GroundPathSegment[];
-  rockSlope?: GroundBand;
-  sandHeight?: GroundBand;
-  snowHeight?: GroundBand;
-}
-interface PlateauFeature {
-  falloff: number;
-  height: number;
-  kind: TerrainFeatureKind.Plateau;
-  radius: number;
-  x: number;
-  z: number;
-}
-interface RidgeFeature {
-  endX: number;
-  endZ: number;
-  height: number;
-  kind: TerrainFeatureKind.Ridge;
-  startX: number;
-  startZ: number;
-  width: number;
-}
-type TerrainFeature = CliffFeature | PlateauFeature | RidgeFeature;
-interface TerrainOptions {
-  cellsPerSide: number;
-  finestRange: number;
-  finestTileSize: number;
-  levelCount: number;
-  maxHeight: number;
-  minHeight: number;
-}
-interface TerrainResidualClearing {
-  falloff: number;
-  radius: number;
-  x: number;
-  z: number;
-}
-interface TerrainResidualFade {
-  cellSize: number;
-  clearings: readonly TerrainResidualClearing[];
-  origin: readonly number[];
-  size: readonly number[];
-  weights: readonly number[];
-}
-interface TerrainResidual {
-  amplitude: number;
-  fade?: TerrainResidualFade;
-  octaves: number;
-  scale: number;
-  seed: number;
-}
-interface TerrainTile {
-  coarseColors: Float32Array;
-  coarseNormals: Float32Array;
-  coarsePositions: Float32Array;
-  colors: Float32Array;
-  key: number;
-  normals: Float32Array;
-  positions: Float32Array;
-}
-interface TerrainShape extends GaussianHills {
-  features?: TerrainFeature[];
-  residual?: TerrainResidual;
-}
-interface TerrainTileOptions extends Pick<TerrainOptions, "cellsPerSide" | "finestTileSize"> {
-  getHeight: (x: number, z: number) => number;
-  key: number;
-  writeColor: (colors: Float32Array, offset: number, height: number, slope: number, x: number, z: number) => void;
-}
-interface ScatterOptions {
-  candidateCount: number;
-  checkIsAccepted: (x: number, z: number) => boolean;
-  seed: number;
-  size: number;
-  spacing: number;
-}
-declare const createSeededRandom: (seed: number) => (() => number);
-declare const computeTerrainTile: ({ cellsPerSide, finestTileSize, getHeight, key, writeColor }: TerrainTileOptions) => TerrainTile;
-declare const createGroundLayerWeights: ({ earthSlope, layerField, pathFalloff, paths, rockSlope, sandHeight, snowHeight }: Pick<GroundPaint, "earthSlope" | "layerField" | "pathFalloff" | "paths" | "rockSlope" | "sandHeight" | "snowHeight">) => ((height: number, slope: number, x: number, z: number) => Readonly<Record<GroundLayer, number>>);
-declare const createGroundPaintColor: (groundPaint: GroundPaint, seed: number) => TerrainTileOptions["writeColor"];
-declare const createTerrainShapeHeight: (shape: TerrainShape, ...overlays: TerrainShape[]) => ((x: number, z: number) => number);
-declare const getTerrainTileColumn: (key: number) => number;
-declare const getTerrainTileLevel: (key: number) => number;
-declare const getTerrainTileRow: (key: number) => number;
-declare const computeScatterPoints: ({ candidateCount, checkIsAccepted, seed, size, spacing }: ScatterOptions) => Float32Array;
-export { CliffFeature as A, GroundLayerField as C, GroundBand as D, GroundLayers as E, GaussianHills as O, GroundPathSegment as S, GroundLayer as T, TerrainOptions as _, createTerrainShapeHeight as a, PlateauFeature as b, computeTerrainTile as c, TerrainTileOptions as d, TerrainShape as f, TerrainResidualClearing as g, TerrainResidualFade as h, getTerrainTileColumn as i, TerrainFeatureKind as j, GaussianHill as k, createSeededRandom as l, TerrainResidual as m, getTerrainTileRow as n, createGroundPaintColor as o, TerrainTile as p, getTerrainTileLevel as r, createGroundLayerWeights as s, computeScatterPoints as t, ScatterOptions as u, TerrainFeature as v, GroundLayerColors as w, GroundPaint as x, RidgeFeature as y };

package/dist/terrainWorker.d.ts

@@ -1,2 +0,0 @@
-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-BjxpqdfH.js";
-export { GroundLayer, GroundLayers, computeScatterPoints, computeTerrainTile, createGroundLayerWeights, createGroundPaintColor, createSeededRandom, createTerrainShapeHeight, getTerrainTileColumn, getTerrainTileLevel, getTerrainTileRow };

package/dist/terrainWorker.js

@@ -1 +0,0 @@
-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-Bgj3rmZs.js";