Zum Inhalt springen

Biome und Vegetation auf Voxel-Terrain in Babylon.js · Teil 3 von 12 der Serie

Teil 3: Die Form des Landes

Lass die Biome das Land formen: jedes eine Zeile von Zahlen für Ebenen, Hügel, Berge, Felskuppen und Dünen, gemischt, wo Biome sich treffen, sodass die Savanne flach liegt, die Wüste in Dünen rollt und die Tundra eine Hochebene ist, während der Start bleibt, wie er war.

Quest-Ziele

  • Die Form eines Bioms mit fünf Zahlen beschreiben
  • Die Zahlen der Biome mischen, nicht ihre Höhen
  • Wissen, warum die Form das Klima auf Meereshöhe nutzt
  • Kuppen und Dünen aus Rauschen machen
  • Den Boden um den Start genau so lassen, wie er war

Die Biome haben jetzt ihren eigenen Boden, aber das Land darunter ist überall dasselbe: die Hügel und Berge der Terrain-Serie. Eine Wüste auf sanften grünen Hügeln, die eben gelb sind, ist keine Wüste. Dieser Teil lässt jedes Biom sein Land formen: die Savanne tief und flach, mit Felsen, die darin stehen, die Wüste in Dünen, den Nadelwald zerklüftet, die Tundra als Hochebene unter den höchsten Bergen.

Eine Zeile von Zahlen

Die Höhe des Bodens an einem Ort setzt sich in src/terrain.ts aus ein paar Teilen zusammen: einer Grundhöhe, dazu Hügel aus geschichtetem Rauschen mal 40, dazu Bergkämme mal 150. Diese drei Zahlen sind die Form des Landes, und mehr muss ein Biom nicht ändern. Also bekommt jedes Biom eine Zeile von Zahlen, in Metern: die Höhe seiner Ebenen und wie hoch seine Hügel und seine Berge steigen. Zwei weitere Teile sind neu: Kuppen, steile Buckel aus Fels, und Dünen. Ersetze in src/climate.ts die Liste der Biome:

src/climate.ts
/**
 * The biomes, each with the climate it is at home in and a color for the map. A place
 * belongs to the biome whose climate is nearest to its own. `ground` is the texture that
 * covers its ground, and `tint` colors its soil and rock. `shape` holds the numbers that
 * shape its ground, in meters: see Shape.
 */
export const BIOMES = [
  {
    name: 'Meadow', temperature: 0.5, moisture: 0.4, color: '#7fae3c', ground: 'grass', tint: '#ffffff',
    shape: { base: 12, hills: 40, mountains: 150, knolls: 0, dunes: 0 },
  },
  {
    name: 'Broadleaf forest', temperature: 0.52, moisture: 0.76, color: '#3c7a2a', ground: 'litter', tint: '#f2f0e6',
    shape: { base: 14, hills: 46, mountains: 150, knolls: 0, dunes: 0 },
  },
  {
    name: 'Conifer forest', temperature: 0.3, moisture: 0.62, color: '#28584a', ground: 'needles', tint: '#e6e8f2',
    shape: { base: 20, hills: 55, mountains: 170, knolls: 10, dunes: 0 },
  },
  {
    name: 'Tundra', temperature: 0.1, moisture: 0.45, color: '#c3ccd6', ground: 'moss', tint: '#dfe6f5',
    shape: { base: 24, hills: 20, mountains: 190, knolls: 5, dunes: 0 },
  },
  {
    name: 'Savanna', temperature: 0.76, moisture: 0.5, color: '#c9a545', ground: 'straw', tint: '#ffd9b0',
    shape: { base: 7, hills: 12, mountains: 40, knolls: 22, dunes: 0 },
  },
  {
    name: 'Desert', temperature: 0.86, moisture: 0.14, color: '#e8bd7c', ground: 'sand', tint: '#ffc08a',
    shape: { base: 9, hills: 14, mountains: 70, knolls: 30, dunes: 9 },
  },
] as const;

Die Zeile der Wiese enthält genau die Zahlen, die in terrain.ts standen: 12, 40 und 150. Der Laubwald ist etwas hügeliger, der Nadelwald noch mehr und mit Kuppen, die Tundra liegt hoch und fast eben zwischen den höchsten Bergen. Die Savanne ist tief und flach, mit Kuppen von 22 m, und die Wüste hat Dünen von 9 m und Kuppen von 30 m, die als Felstürme in ihr stehen.

Formen mischen

Wo zwei Biome sich treffen, müssen sich auch ihre Formen treffen. Eine Höhe pro Biom auszurechnen und die Höhen zu mischen, hieße für jede Spalte nahe einer Grenze das ganze Rauschen von beiden. Es ist billiger und einfacher, die Zahlen nach den Gewichten der Biome zu mischen und dann eine Höhe aus der gemischten Zeile auszurechnen. Zwischen Savanne und Wiese steigt die Grundhöhe von 7 m auf 12 m, die Hügel wachsen von 12 m auf 40 m, und die Kuppen schrumpfen auf nichts.

Zweierlei ist anders als bei den Gewichten der Bedeckung. Erstens ist der Streifen, in dem sich zwei Biome mischen, breiter: Eine Bedeckung kann innerhalb weniger Schritte wechseln, aber Berge, die auf der einen Seite 150 m und auf der anderen 40 m hoch steigen, würden dort in einer Wand enden. Zweitens sind die Gewichte die des Klimas auf Meereshöhe. Das Klima der Bedeckung wird mit der Höhe kälter. Die Form kann die Höhe nicht nutzen: Die Höhe ist das, wofür sie da ist. Das passt auch zur Welt. Ein Berg in einer Wiese ist geformt wie der Berg einer Wiese, was immer auf seinem Gipfel wächst.

In src/climate.ts bekommt die Mischung eine zweite Breite. Ersetze die Konstante BLEND:

src/climate.ts
/** How far past a border, in climate, a biome still mixes with its neighbor. */
export const BLEND = 0.07;
/** The same for the shape of the ground: it changes over a wider strip than the cover. */
const SHAPE_BLEND = 0.12;

biomeWeights() nimmt die Breite als Parameter, und zwar die der Bedeckung, wenn nichts angegeben ist. Ersetze die Funktion:

src/climate.ts
/**
 * How much of each biome a climate is: 1 for the only biome deep inside it, shared out
 * near a border, and always 1 in sum. The weights are written into `weights`.
 */
export function biomeWeights(
  temperature: number,
  moisture: number,
  weights: Float32Array | number[],
  blend = BLEND,
): void {
  let nearest = Infinity;
  for (let i = 0; i < BIOME_COUNT; i += 1) {
    const distance = Math.hypot(temperature - BIOMES[i].temperature, moisture - BIOMES[i].moisture);
    weights[i] = distance;
    nearest = Math.min(nearest, distance);
  }
  // A biome counts for as much as it is closer than `blend` beyond the nearest one.
  let sum = 0;
  for (let i = 0; i < BIOME_COUNT; i += 1) {
    const share = Math.max(1 - (weights[i] - nearest) / blend, 0);
    weights[i] = share * share;
    sum += weights[i];
  }
  for (let i = 0; i < BIOME_COUNT; i += 1) weights[i] /= sum;
}

Und am Ende der Datei die Form eines Ortes:

src/climate.ts
/**
 * The numbers that shape a biome's ground, in meters: the height of its plains, how high
 * its hills, its mountains, its rocky knolls and its dunes rise.
 */
export interface Shape {
  base: number;
  hills: number;
  mountains: number;
  knolls: number;
  dunes: number;
}

const shapeWeights = new Float32Array(BIOME_COUNT);

/**
 * The shape of the ground at (x, z), written into `shape`: every biome's numbers, by the
 * biome's weight in the climate at sea level. The height can't count here: it is what the
 * shape is for.
 */
export function shapeAt(x: number, z: number, shape: Shape): void {
  const { temperature, moisture } = climateAt(x, z);
  biomeWeights(temperature, moisture, shapeWeights, SHAPE_BLEND);
  shape.base = shape.hills = shape.mountains = shape.knolls = shape.dunes = 0;
  for (let i = 0; i < BIOME_COUNT; i += 1) {
    const weight = shapeWeights[i];
    if (weight === 0) continue;
    const own = BIOMES[i].shape;
    shape.base += own.base * weight;
    shape.hills += own.hills * weight;
    shape.mountains += own.mountains * weight;
    shape.knolls += own.knolls * weight;
    shape.dunes += own.dunes * weight;
  }
}

shapeAt() wird für jede Spalte jedes Chunks aufgerufen, schreibt also in ein Objekt, das sie bekommt, statt ein neues zu erzeugen, und überspringt die Biome ohne Gewicht: fast immer alle bis auf eines.

Kuppen und Dünen

Importiere in src/terrain.ts die Form: import { shapeAt, type Shape } from './climate.ts';. Ersetze dann alles vom Kommentar darüber, dass das Gitter eine ganze Spalte erfragt, bis zum Ende von column():

src/terrain.ts
/** Rocky knolls, from 0 to 1: steep bumps where a noise is high, flat ground elsewhere. */
function knolls(x: number, z: number): number {
  const noise = noise2(x / 120 + 300, z / 120 - 200);
  return (Math.max(noise - 0.45, 0) / 0.55) ** 1.5;
}

/**
 * Dunes, from 0 to 1: the noise is stretched along z, so its waves run across x like the
 * dunes across the wind. Where it crosses 0 is a crest, and a second noise bends the crests.
 */
function dunes(x: number, z: number): number {
  const bend = noise2(x / 350 + 70, z / 350) * 1.2;
  return (1 - Math.abs(noise2(x / 80 + bend, z / 240 - 40))) ** 2;
}

// The grid asks for a whole column before the next one, so the last column's
// numbers are kept.
let columnX = Number.NaN;
let columnZ = Number.NaN;
let columnHeight = 0;
let columnMountains = 0;
const shape: Shape = { base: 0, hills: 0, mountains: 0, knolls: 0, dunes: 0 };

function column(x: number, z: number): void {
  if (x === columnX && z === columnZ) return;
  columnX = x;
  columnZ = z;
  columnMountains = mountains(x, z);
  // How high everything rises here is up to the biomes.
  shapeAt(x, z, shape);
  // Rolling hills everywhere, and ridges where the land is mountainous: high where the
  // noise is near 0. The small number in the hypot rounds the crest off.
  const hills = layered2(x / 400, z / 400, 5) * shape.hills;
  const ridge = Math.max(1 - Math.hypot(layered2(x / 500 - 20, z / 500 + 90, 4) * 1.6, 0.15), 0);
  columnHeight = shape.base + hills + columnMountains * ridge ** 3 * shape.mountains;
  // The noise for knolls and dunes is only worked out where a biome has them.
  if (shape.knolls > 0) columnHeight += knolls(x, z) * shape.knolls;
  if (shape.dunes > 0) columnHeight += dunes(x, z) * shape.dunes;
}
  • knolls() schneidet ein Rauschen bei 0,45 ab. Darunter, also im größten Teil des Landes, ergibt sie 0, und der Boden bleibt, wie er ist. Darüber steigt ein Buckel, zum Gipfel hin steiler. Steilen Boden malt der Shader als Fels, in der Tönung des Bioms, also sind die Kuppen ohne weiteren Code nackter Fels.

  • dunes() liest ein Rauschen, das entlang z dreimal länger gestreckt ist als entlang x. Eins minus sein Betrag ist dort am höchsten, wo das Rauschen 0 kreuzt: Diese Linien sind die Kämme, und sie verlaufen meist entlang z. Das Quadrieren macht die Kämme scharf und die Mulden weit. Ein zweites, langsames Rauschen verschiebt das erste entlang x, was die Kämme verbiegt.

  • column() fragt nach der Form und verwendet ihre Zahlen dort, wo die festen standen. Das Rauschen für Kuppen und Dünen wird nur ausgerechnet, wo ein Biom welche hat.

Beide neuen Teile lesen das eigene 2D-Rauschen des Terrains, an Stellen weit weg von denen, die die Hügel nutzen. Aus den Zufallszahlen des Terrains wird kein neues Rauschen erzeugt, also bleiben die Hügel selbst unberührt.

Was gleich bleibt

In der Wiese ist die gemischte Zeile die Zeile der Wiese, und die enthält die alten Zahlen: Die Höhe kommt gleich heraus, bis auf die letzte Stelle. Der Start liegt in einer Wiese, und die Zahlen, die in Teil 1 das Rauschen des Klimas verschieben, sind so gewählt, dass um den Start nicht einmal die breitere Mischung der Form ein anderes Biom erreicht. Was immer dort in der Bau-Serie gebaut wurde, steht auf demselben Boden.

Sonst braucht nichts eine Änderung. Die Chunks, die Fernsicht, das Licht, das Gehen und die Suche nach einem Biom fragen alle terrain.ts nach dem Boden. Der Preis ist Zeit: Jede Spalte fragt jetzt zuerst nach dem Klima, was die Arbeit für die Höhe einer Spalte etwa verdoppelt. Das 3D-Rauschen für Überhänge und Höhlen kostet immer noch weit mehr.

Ausprobieren

Drück N, bis das HUD Desert anzeigt, und schau dich um: Dünen in langen Kämmen und Türme aus rotem Fels dazwischen. Lande mit F und geh eine Düne hinauf. Flieg weiter in die Savanne: flach bis zum Horizont, mit Kuppen zum Klettern. Die Tundra ist eine hohe, fast ebene Fläche, und der Nadelwald ist das raueste Land zum Durchqueren. Schalte mit G die Karte ein und flieg an einer Grenze entlang: Die Bedeckung wechselt an der Linie, die Höhe über einen breiteren Streifen. Dann geh zurück zum Start. Das Beispielgebäude steht, wo es stand.

Die Savanne: tiefes, flaches Land, in dem Kuppen aus nacktem Fels stehen.
Die Form des Landes. Klick, dann: N fliegt zum nächsten Biom, F landet und fliegt (Q/E runter/hoch), G zeigt die Karte. T gräbt und baut Terrain, B setzt Blöcke.
In neuem Tab öffnen

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.