@aura3d/rendering 1.0.6

package/src/VoxelWorldFixtures.ts

@@ -0,0 +1,280 @@
+export type VoxelFixtureBlockType =
+  | "air"
+  | "stone"
+  | "dirt"
+  | "grass"
+  | "sand"
+  | "water"
+  | "wood"
+  | "leaves"
+  | "glass"
+  | "coal-ore"
+  | "iron-ore"
+  | "gold-ore"
+  | "diamond-ore"
+  | "bedrock"
+  | "cobblestone"
+  | "planks"
+  | "brick"
+  | "snow"
+  | "ice"
+  | "lava";
+
+export type VoxelFixtureLod = "near" | "mid" | "far" | "culled";
+
+export interface VoxelFixtureOptions {
+  readonly seed?: number;
+  readonly chunkSize?: number;
+  readonly viewDistance?: number;
+  readonly cameraChunkX?: number;
+  readonly cameraChunkZ?: number;
+}
+
+export interface VoxelBlockDescriptor {
+  readonly type: VoxelFixtureBlockType;
+  readonly color: readonly [number, number, number, number];
+  readonly hardness: number;
+  readonly toolRequired: string | null;
+  readonly drops: VoxelFixtureBlockType | null;
+  readonly sound: string;
+  readonly animated: boolean;
+  readonly lightLevel: number;
+  readonly transparent: boolean;
+  readonly solid: boolean;
+}
+
+export interface VoxelVisibleBlock {
+  readonly id: string;
+  readonly type: VoxelFixtureBlockType;
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly lod: VoxelFixtureLod;
+}
+
+export interface VoxelWorldFixture {
+  readonly id: "external-parity-old-branch-voxel-world-fixture";
+  readonly source: "origin-master-voxel-world-adapted";
+  readonly seed: number;
+  readonly chunkSize: number;
+  readonly viewDistance: number;
+  readonly registry: readonly VoxelBlockDescriptor[];
+  readonly blockTypeCount: number;
+  readonly solidBlockTypes: number;
+  readonly transparentBlockTypes: number;
+  readonly animatedBlockTypes: number;
+  readonly emittingBlockTypes: number;
+  readonly chunkQueueSize: number;
+  readonly generatingChunks: number;
+  readonly meshingChunks: number;
+  readonly lodCounts: Record<VoxelFixtureLod, number>;
+  readonly blockCounts: Partial<Record<VoxelFixtureBlockType, number>>;
+  readonly visibleBlocks: readonly VoxelVisibleBlock[];
+  readonly visibleFaceEstimate: number;
+  readonly memoryBytes: number;
+  readonly hash: string;
+  readonly claimBoundary: string;
+}
+
+const registry: readonly VoxelBlockDescriptor[] = [
+  block("air", [0, 0, 0, 0], 0, null, null, "none", false, 0, true, false),
+  block("stone", [0.5, 0.5, 0.5, 1], 1.5, "pickaxe", "cobblestone", "stone", false, 0, false, true),
+  block("dirt", [0.4, 0.25, 0.15, 1], 0.5, null, "dirt", "dirt", false, 0, false, true),
+  block("grass", [0.3, 0.7, 0.3, 1], 0.6, null, "dirt", "grass", false, 0, false, true),
+  block("sand", [0.9, 0.85, 0.6, 1], 0.5, null, "sand", "sand", false, 0, false, true),
+  block("water", [0.15, 0.4, 0.8, 0.6], 100, null, null, "water", true, 0, true, false),
+  block("wood", [0.4, 0.25, 0.1, 1], 2, "axe", "wood", "wood", false, 0, false, true),
+  block("leaves", [0.2, 0.6, 0.2, 0.9], 0.2, null, null, "grass", false, 0, true, true),
+  block("glass", [0.7, 0.9, 1, 0.3], 0.3, null, "glass", "glass", false, 0, true, true),
+  block("coal-ore", [0.12, 0.12, 0.12, 1], 3, "pickaxe", "coal-ore", "stone", false, 0, false, true),
+  block("iron-ore", [0.72, 0.5, 0.34, 1], 3, "pickaxe", "iron-ore", "stone", false, 0, false, true),
+  block("gold-ore", [1, 0.78, 0.2, 1], 3, "pickaxe", "gold-ore", "stone", false, 0, false, true),
+  block("diamond-ore", [0.2, 0.85, 1, 1], 3, "pickaxe", "diamond-ore", "stone", false, 0, false, true),
+  block("bedrock", [0.05, 0.05, 0.06, 1], 1000, null, null, "stone", false, 0, false, true),
+  block("cobblestone", [0.38, 0.38, 0.38, 1], 2, "pickaxe", "cobblestone", "stone", false, 0, false, true),
+  block("planks", [0.64, 0.42, 0.2, 1], 2, "axe", "planks", "wood", false, 0, false, true),
+  block("brick", [0.62, 0.24, 0.18, 1], 2, "pickaxe", "brick", "stone", false, 0, false, true),
+  block("snow", [0.92, 0.96, 1, 1], 0.2, null, "snow", "snow", false, 0, false, true),
+  block("ice", [0.64, 0.88, 1, 0.72], 0.5, null, "ice", "glass", false, 0, true, true),
+  block("lava", [1, 0.28, 0.02, 0.95], 100, null, null, "lava", true, 12, true, false)
+];
+
+export function sampleVoxelWorldFixture(options: VoxelFixtureOptions = {}): VoxelWorldFixture {
+  const seed = integer(options.seed ?? 0x3d2025, "seed");
+  const chunkSize = integer(options.chunkSize ?? 16, "chunkSize");
+  if (chunkSize < 8 || chunkSize > 64) throw new RangeError("Voxel fixture chunkSize must be between 8 and 64.");
+  const viewDistance = integer(options.viewDistance ?? 4, "viewDistance");
+  if (viewDistance < 1 || viewDistance > 16) throw new RangeError("Voxel fixture viewDistance must be between 1 and 16.");
+  const cameraChunkX = Math.trunc(options.cameraChunkX ?? 0);
+  const cameraChunkZ = Math.trunc(options.cameraChunkZ ?? 0);
+  const blockCounts: Partial<Record<VoxelFixtureBlockType, number>> = {};
+  const visibleBlocks: VoxelVisibleBlock[] = [];
+  let visibleFaceEstimate = 0;
+
+  for (let x = 0; x < chunkSize; x += 1) {
+    for (let z = 0; z < chunkSize; z += 1) {
+      const worldX = cameraChunkX * chunkSize + x;
+      const worldZ = cameraChunkZ * chunkSize + z;
+      const height = terrainHeight(worldX, worldZ, seed, chunkSize);
+      const surface = surfaceBlock(worldX, worldZ, seed, height, chunkSize);
+      addCount(blockCounts, "bedrock", 1);
+      addCount(blockCounts, "stone", Math.max(0, height - 4));
+      addCount(blockCounts, "dirt", 3);
+      addCount(blockCounts, surface, 1);
+      if (height < chunkSize * 0.38) addCount(blockCounts, "water", Math.ceil(chunkSize * 0.38 - height));
+      if (noise(worldX * 0.19 + 31, worldZ * 0.19 - 17, seed) > 0.9) addCount(blockCounts, oreBlock(height), 1);
+      if (surface === "grass" && noise(worldX * 0.13 + 1000, worldZ * 0.13 + 1000, seed) > 0.88) {
+        addCount(blockCounts, "wood", 3);
+        addCount(blockCounts, "leaves", 6);
+      }
+      visibleFaceEstimate += 4 + Math.round(Math.abs(height - chunkSize * 0.5) * 0.8);
+      if (visibleBlocks.length < 28 && (x + z) % 3 === 0) {
+        const distance = Math.hypot(x - chunkSize / 2, z - chunkSize / 2) / chunkSize * viewDistance;
+        visibleBlocks.push({
+          id: `voxel-${x}-${z}`,
+          type: surface,
+          x: Number(((x / chunkSize - 0.5) * 2.3).toFixed(4)),
+          y: Number(((height / chunkSize) * 0.72 - 0.64).toFixed(4)),
+          z: Number(((z / chunkSize - 0.5) * 0.44 - 0.22).toFixed(4)),
+          lod: lodForDistance(distance)
+        });
+      }
+    }
+  }
+
+  const lodCounts = chunkLodCounts(viewDistance);
+  const chunkQueueSize = Object.values(lodCounts).reduce((sum, count) => sum + count, 0);
+  const memoryBytes = chunkQueueSize * chunkSize * chunkSize * chunkSize * 2;
+  return {
+    id: "external-parity-old-branch-voxel-world-fixture",
+    source: "origin-master-voxel-world-adapted",
+    seed,
+    chunkSize,
+    viewDistance,
+    registry,
+    blockTypeCount: registry.length,
+    solidBlockTypes: registry.filter((entry) => entry.solid).length,
+    transparentBlockTypes: registry.filter((entry) => entry.transparent).length,
+    animatedBlockTypes: registry.filter((entry) => entry.animated).length,
+    emittingBlockTypes: registry.filter((entry) => entry.lightLevel > 0).length,
+    chunkQueueSize,
+    generatingChunks: Math.min(2, chunkQueueSize),
+    meshingChunks: Math.min(3, chunkQueueSize),
+    lodCounts,
+    blockCounts,
+    visibleBlocks,
+    visibleFaceEstimate,
+    memoryBytes,
+    hash: hashVoxel(seed, chunkSize, viewDistance, blockCounts, lodCounts, visibleFaceEstimate),
+    claimBoundary: "Deterministic block registry, chunk queue, terrain columns, LOD buckets, and visible block markers adapted from the old voxel-world example; this is not a production voxel engine, mesh builder, collision system, multiplayer sandbox, or Minecraft parity claim."
+  };
+}
+
+function block(
+  type: VoxelFixtureBlockType,
+  color: readonly [number, number, number, number],
+  hardness: number,
+  toolRequired: string | null,
+  drops: VoxelFixtureBlockType | null,
+  sound: string,
+  animated: boolean,
+  lightLevel: number,
+  transparent: boolean,
+  solid: boolean
+): VoxelBlockDescriptor {
+  return { type, color, hardness, toolRequired, drops, sound, animated, lightLevel, transparent, solid };
+}
+
+function terrainHeight(x: number, z: number, seed: number, chunkSize: number): number {
+  const base = noise(x * 0.08, z * 0.08, seed);
+  const detail = noise(x * 0.21 + 11, z * 0.21 - 7, seed) * 0.32;
+  return Math.max(3, Math.min(chunkSize - 2, Math.round(chunkSize * (0.34 + base * 0.34 + detail))));
+}
+
+function surfaceBlock(x: number, z: number, seed: number, height: number, chunkSize: number): VoxelFixtureBlockType {
+  if (height < chunkSize * 0.38) return "sand";
+  if (height > chunkSize * 0.78) return noise(x * 0.13, z * 0.13, seed) > 0.45 ? "snow" : "stone";
+  const biome = noise(x * 0.05 - 20, z * 0.05 + 30, seed);
+  if (biome < 0.18) return "sand";
+  if (biome > 0.82) return "stone";
+  return "grass";
+}
+
+function oreBlock(height: number): VoxelFixtureBlockType {
+  if (height < 6) return "diamond-ore";
+  if (height < 9) return "gold-ore";
+  if (height < 12) return "iron-ore";
+  return "coal-ore";
+}
+
+function lodForDistance(distance: number): VoxelFixtureLod {
+  if (distance <= 1.25) return "near";
+  if (distance <= 2.5) return "mid";
+  if (distance <= 4) return "far";
+  return "culled";
+}
+
+function chunkLodCounts(viewDistance: number): Record<VoxelFixtureLod, number> {
+  const counts: Record<VoxelFixtureLod, number> = { near: 0, mid: 0, far: 0, culled: 0 };
+  const unloadDistance = viewDistance * 1.5;
+  for (let x = -viewDistance; x <= viewDistance; x += 1) {
+    for (let z = -viewDistance; z <= viewDistance; z += 1) {
+      const distance = Math.hypot(x, z);
+      if (distance <= viewDistance) counts[lodForDistance(distance)] += 1;
+      else if (distance <= unloadDistance) counts.culled += 1;
+    }
+  }
+  return counts;
+}
+
+function addCount(counts: Partial<Record<VoxelFixtureBlockType, number>>, type: VoxelFixtureBlockType, count: number): void {
+  counts[type] = (counts[type] ?? 0) + count;
+}
+
+function noise(x: number, z: number, seed: number): number {
+  const xi = Math.floor(x);
+  const zi = Math.floor(z);
+  const xf = x - xi;
+  const zf = z - zi;
+  const top = lerp(hash(xi, zi, seed), hash(xi + 1, zi, seed), smoothstep(xf));
+  const bottom = lerp(hash(xi, zi + 1, seed), hash(xi + 1, zi + 1, seed), smoothstep(xf));
+  return lerp(top, bottom, smoothstep(zf));
+}
+
+function hash(x: number, z: number, seed: number): number {
+  let value = Math.imul(x, 374761393) + Math.imul(z, 668265263) + seed;
+  value = Math.imul(value ^ (value >>> 13), 1274126177);
+  return ((value ^ (value >>> 16)) >>> 0) / 4294967296;
+}
+
+function hashVoxel(
+  seed: number,
+  chunkSize: number,
+  viewDistance: number,
+  blockCounts: Partial<Record<VoxelFixtureBlockType, number>>,
+  lodCounts: Record<VoxelFixtureLod, number>,
+  visibleFaceEstimate: number
+): string {
+  let value = 0x811c9dc5;
+  for (const entry of [seed, chunkSize, viewDistance, visibleFaceEstimate, ...Object.values(blockCounts), ...Object.values(lodCounts)]) {
+    const scaled = Math.round((entry ?? 0) * 10);
+    value ^= scaled & 0xff;
+    value = Math.imul(value, 0x01000193) >>> 0;
+    value ^= (scaled >>> 8) & 0xff;
+    value = Math.imul(value, 0x01000193) >>> 0;
+  }
+  return value.toString(16).padStart(8, "0");
+}
+
+function integer(value: number, label: string): number {
+  if (!Number.isInteger(value)) throw new RangeError(`Voxel fixture ${label} must be an integer.`);
+  return value;
+}
+
+function lerp(left: number, right: number, t: number): number {
+  return left + (right - left) * t;
+}
+
+function smoothstep(value: number): number {
+  return value * value * (3 - 2 * value);
+}

package/src/WeatherFixtures.ts

@@ -0,0 +1,223 @@
+export type WeatherFixtureType = "clear" | "cloudy" | "rain" | "heavy-rain" | "thunderstorm" | "snow";
+
+export interface WeatherFixtureOptions {
+  readonly type?: WeatherFixtureType;
+  readonly elapsedSeconds?: number;
+  readonly seed?: number;
+  readonly cameraX?: number;
+  readonly cameraZ?: number;
+  readonly maxVisualDrops?: number;
+}
+
+export interface WeatherVisualDrop {
+  readonly x: number;
+  readonly y: number;
+  readonly z: number;
+  readonly length: number;
+  readonly alpha: number;
+}
+
+export interface WeatherPuddlePatch {
+  readonly x: number;
+  readonly z: number;
+  readonly radius: number;
+  readonly depth: number;
+}
+
+export interface WeatherFixtureSample {
+  readonly type: WeatherFixtureType;
+  readonly cloudCoverage: number;
+  readonly fogDensity: number;
+  readonly rainIntensity: number;
+  readonly snowIntensity: number;
+  readonly windSpeed: number;
+  readonly windDirectionX: number;
+  readonly windDirectionZ: number;
+  readonly lightningFrequency: number;
+  readonly visibleDropCount: number;
+  readonly splashCount: number;
+  readonly puddleDepth: number;
+  readonly wetness: number;
+  readonly ambientIntensity: number;
+  readonly visibilityMeters: number;
+  readonly visualDrops: readonly WeatherVisualDrop[];
+  readonly puddlePatches: readonly WeatherPuddlePatch[];
+  readonly hash: string;
+  readonly source: "origin-master-weather-system-adapted";
+  readonly claimBoundary: string;
+}
+
+export function sampleWeatherFixture(options: WeatherFixtureOptions = {}): WeatherFixtureSample {
+  const type = options.type ?? "rain";
+  const preset = weatherPreset(type);
+  const elapsedSeconds = Math.max(0, finite(options.elapsedSeconds ?? 1, "elapsedSeconds"));
+  const seed = Math.floor(options.seed ?? 0x5ea50a);
+  if (!Number.isInteger(seed)) {
+    throw new RangeError("Weather fixture seed must be an integer.");
+  }
+  const cameraX = finite(options.cameraX ?? 0, "cameraX");
+  const cameraZ = finite(options.cameraZ ?? 0, "cameraZ");
+  const windGust = (seeded01(seed + Math.floor(elapsedSeconds * 17)) * 2 - 1) * preset.windGustiness;
+  const windSpeed = Math.max(0, preset.windSpeed * (1 + windGust));
+  const weatherLoad = preset.rainIntensity + preset.snowIntensity;
+  const visibleDropCount = Math.round(weatherLoad * 420 + windSpeed * 8 + Math.abs(cameraX + cameraZ) * 3);
+  const splashCount = Math.round(preset.rainIntensity * elapsedSeconds * 180);
+  const puddleDepth = clamp(preset.rainIntensity * elapsedSeconds * 0.018 + preset.wetnessRate * 0.08, 0, 1);
+  const wetness = clamp(preset.wetnessRate + puddleDepth * 0.45, 0, 1);
+  const visualDrops = sampleVisualDrops({
+    count: Math.min(Math.max(0, Math.floor(options.maxVisualDrops ?? 36)), visibleDropCount),
+    seed,
+    elapsedSeconds,
+    cameraX,
+    cameraZ,
+    intensity: weatherLoad,
+    windSpeed
+  });
+  const puddlePatches = samplePuddlePatches({
+    count: preset.rainIntensity > 0 ? Math.max(1, Math.min(8, Math.round(preset.rainIntensity * 8))) : 0,
+    seed,
+    cameraX,
+    cameraZ,
+    depth: puddleDepth
+  });
+  const hash = hashWeather([
+    preset.cloudCoverage,
+    preset.fogDensity,
+    preset.rainIntensity,
+    preset.snowIntensity,
+    windSpeed,
+    visibleDropCount,
+    splashCount,
+    puddleDepth,
+    wetness,
+    preset.visibility,
+    visualDrops.length,
+    puddlePatches.length
+  ]);
+  return {
+    type,
+    cloudCoverage: preset.cloudCoverage,
+    fogDensity: preset.fogDensity,
+    rainIntensity: preset.rainIntensity,
+    snowIntensity: preset.snowIntensity,
+    windSpeed: Number(windSpeed.toFixed(4)),
+    windDirectionX: preset.windDirectionX,
+    windDirectionZ: preset.windDirectionZ,
+    lightningFrequency: preset.lightningFrequency,
+    visibleDropCount,
+    splashCount,
+    puddleDepth: Number(puddleDepth.toFixed(4)),
+    wetness: Number(wetness.toFixed(4)),
+    ambientIntensity: preset.ambientIntensity,
+    visibilityMeters: preset.visibility,
+    visualDrops,
+    puddlePatches,
+    hash,
+    source: "origin-master-weather-system-adapted",
+    claimBoundary: "Deterministic weather, wind, rain/snow particle-count, splash, puddle, wetness, fog, and cloud telemetry adapted from the old weather system; this is bounded scene evidence, not volumetric clouds, full precipitation rendering, atmospheric scattering, or weather simulation parity."
+  };
+}
+
+function weatherPreset(type: WeatherFixtureType): {
+  readonly cloudCoverage: number;
+  readonly fogDensity: number;
+  readonly rainIntensity: number;
+  readonly snowIntensity: number;
+  readonly windSpeed: number;
+  readonly windDirectionX: number;
+  readonly windDirectionZ: number;
+  readonly windGustiness: number;
+  readonly lightningFrequency: number;
+  readonly ambientIntensity: number;
+  readonly wetnessRate: number;
+  readonly visibility: number;
+} {
+  switch (type) {
+    case "clear":
+      return { cloudCoverage: 0.1, fogDensity: 0, rainIntensity: 0, snowIntensity: 0, windSpeed: 2, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.1, lightningFrequency: 0, ambientIntensity: 0.8, wetnessRate: 0, visibility: 50_000 };
+    case "cloudy":
+      return { cloudCoverage: 0.85, fogDensity: 0.1, rainIntensity: 0, snowIntensity: 0, windSpeed: 5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.3, lightningFrequency: 0, ambientIntensity: 0.6, wetnessRate: 0, visibility: 20_000 };
+    case "heavy-rain":
+      return { cloudCoverage: 1, fogDensity: 0.3, rainIntensity: 0.9, snowIntensity: 0, windSpeed: 9, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.5, lightningFrequency: 1.5, ambientIntensity: 0.4, wetnessRate: 0.9, visibility: 5_000 };
+    case "thunderstorm":
+      return { cloudCoverage: 1, fogDensity: 0.35, rainIntensity: 1, snowIntensity: 0, windSpeed: 12, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.7, lightningFrequency: 3, ambientIntensity: 0.35, wetnessRate: 1, visibility: 3_000 };
+    case "snow":
+      return { cloudCoverage: 0.95, fogDensity: 0.2, rainIntensity: 0, snowIntensity: 0.6, windSpeed: 5.5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.35, lightningFrequency: 0, ambientIntensity: 0.6, wetnessRate: 0.2, visibility: 8_000 };
+    case "rain":
+      return { cloudCoverage: 0.9, fogDensity: 0.2, rainIntensity: 0.6, snowIntensity: 0, windSpeed: 6.5, windDirectionX: 1, windDirectionZ: 0, windGustiness: 0.4, lightningFrequency: 0.5, ambientIntensity: 0.5, wetnessRate: 0.6, visibility: 10_000 };
+  }
+}
+
+function hashWeather(values: readonly number[]): string {
+  let hash = 0x811c9dc5;
+  for (const value of values) {
+    const scaled = Math.round(value * 10_000);
+    hash ^= scaled & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+    hash ^= (scaled >>> 8) & 0xff;
+    hash = Math.imul(hash, 0x01000193) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+
+function sampleVisualDrops(options: {
+  readonly count: number;
+  readonly seed: number;
+  readonly elapsedSeconds: number;
+  readonly cameraX: number;
+  readonly cameraZ: number;
+  readonly intensity: number;
+  readonly windSpeed: number;
+}): readonly WeatherVisualDrop[] {
+  return Array.from({ length: options.count }, (_, index): WeatherVisualDrop => {
+    const lane = seeded01(options.seed + index * 97);
+    const fall = (seeded01(options.seed ^ (index * 131)) + options.elapsedSeconds * (0.42 + options.intensity * 0.18)) % 1;
+    const x = options.cameraX - 1.25 + lane * 2.5 + Math.sin(options.elapsedSeconds * 1.7 + index) * 0.025;
+    const z = options.cameraZ - 0.38 + seeded01(options.seed + index * 53) * 0.76;
+    const y = 0.78 - fall * 1.38;
+    return {
+      x: Number(x.toFixed(4)),
+      y: Number(y.toFixed(4)),
+      z: Number(z.toFixed(4)),
+      length: Number((0.055 + options.intensity * 0.055 + options.windSpeed * 0.003).toFixed(4)),
+      alpha: Number((0.28 + options.intensity * 0.36).toFixed(4))
+    };
+  });
+}
+
+function samplePuddlePatches(options: {
+  readonly count: number;
+  readonly seed: number;
+  readonly cameraX: number;
+  readonly cameraZ: number;
+  readonly depth: number;
+}): readonly WeatherPuddlePatch[] {
+  return Array.from({ length: options.count }, (_, index): WeatherPuddlePatch => {
+    const x = options.cameraX - 1.08 + seeded01(options.seed + index * 19) * 2.16;
+    const z = options.cameraZ - 0.32 + seeded01(options.seed + index * 47) * 0.64;
+    const radius = 0.035 + seeded01(options.seed ^ (index * 83)) * 0.05 + options.depth * 0.08;
+    return {
+      x: Number(x.toFixed(4)),
+      z: Number(z.toFixed(4)),
+      radius: Number(radius.toFixed(4)),
+      depth: Number(options.depth.toFixed(4))
+    };
+  });
+}
+
+function seeded01(seed: number): number {
+  let value = seed >>> 0;
+  value ^= value << 13;
+  value ^= value >>> 17;
+  value ^= value << 5;
+  return ((value >>> 0) % 10_000) / 10_000;
+}
+
+function finite(value: number, label: string): number {
+  if (!Number.isFinite(value)) throw new RangeError(`Weather fixture ${label} must be finite.`);
+  return value;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}