Experiment with noise

Author: marek-hanzal

packages/@derivean/terrain/src/utils/withColorMap.ts

@@ -1,19 +1,7 @@
 /** @format */
 
 import type { Tile } from "@derivean/chunk";
-import { HSLA, hslaToRgba, type Color } from "@derivean/utils";
-
-/**
- * Color definitions for different land types
- * Using HSLA as it's easier to make color transitions
- */
-const COLOR_MAP = {
-	mountain: HSLA([0, 0, 35, 1]), // Gray mountains
-	platau: HSLA([30, 60, 70, 1]), // Brownish plateaus
-	valley: HSLA([115, 50, 32, 1]), // Dark green valleys
-	hill: HSLA([85, 65, 50, 1]), // Lighter green hills
-	plain: HSLA([60, 70, 75, 1]), // Yellowish plains
-};
+import { HSLA, hslaToRgba, mapNoiseToColor, type Color } from "@derivean/utils";
 
 export namespace withColorMap {
 	export interface Props {
@@ -22,61 +10,18 @@ export namespace withColorMap {
 }
 
 /**
- * Maps noise values to HSLA/RGBA colors based on the strength of each land type
- * Blends colors based on the relative strength of each land type
+ * Maps a noise value to an RGBA color based on the provided color map
+ * Currently uses heightmap as the primary source for color mapping
  */
 export const withColorMap = ({ tile }: withColorMap.Props): Color.RGBA => {
-	// Extract land properties
-	const { mountain, platau, valley, hill, plain } = tile.land;
-
-	// Map each noise value to a normalized weight (0 to 1)
-	// First, convert from -1,1 range to 0,1 range
-	const mountainWeight = (mountain + 1) / 2;
-	const platauWeight = (platau + 1) / 2;
-	const valleyWeight = (valley + 1) / 2;
-	const hillWeight = (hill + 1) / 2;
-	const plainWeight = (plain + 1) / 2;
-
-	// Calculate total weight to normalize
-	const totalWeight = mountainWeight + platauWeight + valleyWeight + hillWeight + plainWeight;
-
-	// Guard against division by zero
-	if (totalWeight === 0) {
-		return hslaToRgba(HSLA([0, 0, 50, 1])); // Default gray if all weights are zero
-	}
-
-	// Initialize color components for weighted average
-	let h = 0;
-	let s = 0;
-	let l = 0;
-
-	// Add weighted contribution from each land type
-	h += COLOR_MAP.mountain.color[0] * mountainWeight;
-	h += COLOR_MAP.platau.color[0] * platauWeight;
-	h += COLOR_MAP.valley.color[0] * valleyWeight;
-	h += COLOR_MAP.hill.color[0] * hillWeight;
-	h += COLOR_MAP.plain.color[0] * plainWeight;
-
-	s += COLOR_MAP.mountain.color[1] * mountainWeight;
-	s += COLOR_MAP.platau.color[1] * platauWeight;
-	s += COLOR_MAP.valley.color[1] * valleyWeight;
-	s += COLOR_MAP.hill.color[1] * hillWeight;
-	s += COLOR_MAP.plain.color[1] * plainWeight;
-
-	l += COLOR_MAP.mountain.color[2] * mountainWeight;
-	l += COLOR_MAP.platau.color[2] * platauWeight;
-	l += COLOR_MAP.valley.color[2] * valleyWeight;
-	l += COLOR_MAP.hill.color[2] * hillWeight;
-	l += COLOR_MAP.plain.color[2] * plainWeight;
-
-	// Normalize by dividing by total weight
-	h /= totalWeight;
-	s /= totalWeight;
-	l /= totalWeight;
+	const color = HSLA([0, 0, 0, 1]);
 
-	// Create the final blended HSLA color
-	const blendedColor = HSLA([h, s, l, 1]);
+	return hslaToRgba(
+		mapNoiseToColor(tile.biome.deep_ocean, {
+			min: HSLA([220, 100, 30, 1]),
+			max: HSLA([200, 80, 60, 1]),
+		}),
+	);
 
-	// Convert to RGBA and return
-	return hslaToRgba(blendedColor);
+	// return hslaToRgba(color);
 };

packages/@derivean/utils/src/index.ts

@@ -46,6 +46,8 @@ export { TagSchema } from "./schema/tag/TagSchema";
 export { UserSchema } from "./schema/UserSchema";
 export { type UserType } from "./type/UserType";
 export { type XZ } from "./type/XZ";
+export { mapNoiseToColor } from "./utils/mapNoiseToColor";
+export { noiseToGrayscale } from "./utils/noiseToGrayscale";
 export { smoothstep } from "./utils/smoothstep";
 export { toWebp64 } from "./utils/toWebp64";
 export { withUse } from "./utils/withUse";

packages/@derivean/utils/src/utils/mapNoiseToColor.ts

@@ -0,0 +1,46 @@
+/** @format */
+
+import { HSLA, type Color } from "@derivean/utils";
+
+/**
+ * Maps a noise value (-1 to 1) to an HSLA color within the specified range
+ *
+ * @param noise The input noise value, should be between -1 and 1
+ * @param colorRange An object containing min and max HSLA colors
+ * @returns An HSLA color interpolated based on the noise value
+ */
+export interface ColorRange {
+	min: Color.HSLA;
+	max: Color.HSLA;
+}
+
+export function mapNoiseToColor(noise: number, colorRange: ColorRange): Color.HSLA {
+	// Ensure the noise value is clamped between -1 and 1
+	const clampedNoise = Math.max(-1, Math.min(1, noise));
+
+	// Convert noise from [-1, 1] to [0, 1] for interpolation
+	const t = (clampedNoise + 1) / 2;
+
+	// Extract color components
+	const [minH, minS, minL, minA] = colorRange.min.color;
+	const [maxH, maxS, maxL, maxA] = colorRange.max.color;
+
+	// Handle hue interpolation specially (since it's circular)
+	let hueDiff = maxH - minH;
+
+	// Take the shortest path around the color wheel
+	if (Math.abs(hueDiff) > 180) {
+		if (hueDiff > 0) {
+			hueDiff -= 360;
+		} else {
+			hueDiff += 360;
+		}
+	}
+
+	const h = (minH + hueDiff * t + 360) % 360;
+	const s = minS + (maxS - minS) * t;
+	const l = minL + (maxL - minL) * t;
+	const a = minA + (maxA - minA) * t;
+
+	return HSLA([h, s, l, a]);
+}

packages/@derivean/utils/src/utils/noiseToGrayscale.ts

@@ -0,0 +1,23 @@
+/** @format */
+
+import { RGBA, type Color } from "../color/Color";
+
+/**
+ * Converts a noise value (-1 to 1) to a grayscale RGBA color
+ *
+ * @param noise Noise value from -1 to 1
+ * @returns RGBA color with full opacity (alpha = 255)
+ */
+export function noiseToGrayscale(noise: number): Color.RGBA {
+	// Clamp the noise value to ensure it's within -1 to 1
+	const clampedNoise = Math.max(-1, Math.min(1, noise));
+
+	// Map the noise from [-1, 1] to [0, 1]
+	const normalizedNoise = (clampedNoise + 1) / 2;
+
+	// Map the normalized noise to 0-255 range
+	const colorValue = Math.round(normalizedNoise * 255);
+
+	// Return grayscale RGBA (all RGB channels have the same value)
+	return RGBA([colorValue, colorValue, colorValue, 255]);
+}