Zum Inhalt springen

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

Teil 1: Klima und Biome

Gib der Voxel-Welt ein Klima: Temperatur und Feuchte aus Rauschen, sechs Biome als Punkte in einem Klimadiagramm, weiche Grenzen dazwischen, kältere Biome die Berge hinauf, eine Karte, die den Boden in den Farben der Biome malt, und eine Taste, die dich zum nächsten Biom fliegt.

Quest-Ziele

  • Wissen, was diese Serie dem Voxel-Terrain und den Blöcken hinzufügt
  • Ein Klima aus zwei Rauschen machen, mit Grenzen, die ausfransen
  • Ein Klima in die Gewichte von sechs Biomen umrechnen
  • Das Klima an den Shader schicken und die Gewichte pro Pixel ausrechnen
  • Den Boden als Karte malen und von Biom zu Biom fliegen

Die Serie über glattes Voxel-Terrain hat eine Welt aus Hügeln, Bergen und Höhlen gebaut, und die Serie über das Bauen hat Blöcke daraufgesetzt. Aber wohin du auch gehst, die Welt ist dieselbe Wiese. Diese dritte Serie macht sie von Ort zu Ort verschieden und lässt etwas auf ihr wachsen: Biome mit eigenem Boden und eigener Form des Landes, ein Meer mit Seen und Stränden, Gras, Blumen, Farne und Schilf, Bäume, die aus ein paar Zahlen wachsen, Wälder bis zum Horizont, Wind in alldem, und eine Axt.

Sie beginnt dort, wo die Bau-Serie aufgehört hat. Kopier das fertige Projekt aus deren Teil 10 in einen neuen Ordner: Alles darin bleibt, auch die Blöcke, der Meißel und die fallenden Stücke. Dieser erste Teil gibt der Welt ein Klima und sechs Biome und zeigt sie als Karte, die auf den Boden gemalt ist. Noch wächst nichts, und der Boden behält seine Texturen: Die kommen in Teil 2.

Eigene Zufallszahlen

Das Klima braucht Zufallszahlen mit Startwert, wie das Terrain, und ab Teil 3 fragt das Terrain das Klima, wie es das Land formen soll. Zwei Dateien, die einander importieren, machen Ärger, also zieht seededRandom() aus src/terrain.ts in eine Datei, die beide importieren können. Erstelle src/random.ts:

src/random.ts
/** Numbers that look random but are the same for the same seed (mulberry32). */
export function seededRandom(seed: number): () => number {
  return () => {
    seed = (seed + 0x6d2b79f5) | 0;
    let t = Math.imul(seed ^ (seed >>> 15), seed | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

Lösch die Funktion aus src/terrain.ts und importiere sie dort stattdessen: import { seededRandom } from './random.ts';. Auch in src/textures.ts liest der Import jetzt aus './random.ts'.

Ein Klima aus Rauschen

Ein Biom ist eine Art von Land: eine Wüste, ein Wald, eine Tundra. Was entscheidet, welches ein Ort ist? In der echten Welt vor allem zweierlei: wie warm es ist und wie viel Regen fällt. Also bekommt die Welt für jeden Ort zwei Zahlen, eine Temperatur und eine Feuchte, beide von 0 bis 1 und beide aus Rauschen, das sich langsam ändert: über einen Kilometer oder zwei, nicht über einen Hügel.

Die Biome sind dann Punkte in einem Klimadiagramm, mit der Temperatur auf der einen Achse und der Feuchte auf der anderen. Die Tundra sitzt am kalten Ende, die Wüste in der heißen, trockenen Ecke, der Laubwald dort, wo es mild und nass ist. Ein Ort gehört zu dem Biom, dessen Punkt seinem eigenen Klima am nächsten liegt. Diese eine Regel ergibt eine Welt, die Sinn hat: Eine Wüste grenzt nie an eine Tundra, weil im Diagramm andere Biome dazwischen liegen und das Rauschen nicht springen kann.

Erstelle src/climate.ts:

src/climate.ts
import { createNoise2D } from 'simplex-noise';
import { seededRandom } from './random.ts';

// Noises of their own, so that the terrain's noise stays as it was.
const random = seededRandom(20261118);
const temperatureNoise = createNoise2D(random);
const moistureNoise = createNoise2D(random);
const borderNoise = createNoise2D(random);

/** Meters over which the noise of the temperature and of the moisture repeats its ups and downs. */
const TEMPERATURE_SCALE = 3000;
const MOISTURE_SCALE = 2200;
/** How much colder it gets per meter above the sea, on the scale from 0 to 1. */
export const COOLING = 0.004;

/** The climate of a place: 0 is the coldest or driest, 1 the hottest or wettest. */
export interface Climate {
  temperature: number;
  moisture: number;
}

/** Noise of about -0.8 … 0.8 as a number from 0 to 1. */
const toScale = (noise: number) => Math.min(Math.max(noise * 0.62 + 0.5, 0), 1);

/** The climate at sea level at (x, z). */
export function climateAt(x: number, z: number): Climate {
  // A finer noise frays the borders, which would be smooth curves without it.
  const frayX = borderNoise(x / 320, z / 320) * 0.07 + borderNoise(x / 90 + 50, z / 90) * 0.025;
  const frayZ = borderNoise(x / 320 - 80, z / 320 + 30) * 0.07 + borderNoise(x / 90, z / 90 - 50) * 0.025;
  // The numbers added to x and z move the noise, so that the start lies in a meadow
  // with every other biome within a kilometer.
  return {
    temperature: toScale(temperatureNoise(x / TEMPERATURE_SCALE + 8.41, z / TEMPERATURE_SCALE - 17.98) + frayX),
    moisture: toScale(moistureNoise(x / MOISTURE_SCALE - 16.56, z / MOISTURE_SCALE + 16.32) + frayZ),
  };
}

/** How much colder a place `height` meters above the sea is. */
export function cooling(height: number): number {
  return Math.max(height, 0) * COOLING;
}

/**
 * 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.
 */
export const BIOMES = [
  { name: 'Meadow', temperature: 0.5, moisture: 0.4, color: '#7fae3c' },
  { name: 'Broadleaf forest', temperature: 0.52, moisture: 0.76, color: '#3c7a2a' },
  { name: 'Conifer forest', temperature: 0.3, moisture: 0.62, color: '#28584a' },
  { name: 'Tundra', temperature: 0.1, moisture: 0.45, color: '#c3ccd6' },
  { name: 'Savanna', temperature: 0.76, moisture: 0.5, color: '#c9a545' },
  { name: 'Desert', temperature: 0.86, moisture: 0.14, color: '#e8bd7c' },
] as const;

export const BIOME_COUNT = BIOMES.length;
/** The biomes by name, as their numbers in the list. */
export const Biome = { meadow: 0, broadleaf: 1, conifer: 2, tundra: 3, savanna: 4, desert: 5 } as const;

/** How far past a border, in climate, a biome still mixes with its neighbor. */
export const BLEND = 0.07;

/**
 * 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[]): 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;
}

/** The biome with the largest weight. */
export function mainBiome(weights: Float32Array | number[]): number {
  let main = 0;
  for (let i = 1; i < BIOME_COUNT; i += 1) if (weights[i] > weights[main]) main = i;
  return main;
}

/** The weights of the biomes at a place `height` meters above the sea. */
export function biomesAt(x: number, height: number, z: number, weights: Float32Array | number[]): void {
  const { temperature, moisture } = climateAt(x, z);
  biomeWeights(temperature - cooling(height), moisture, weights);
}
  • Die drei Rauschen kommen aus einem Zufallsgenerator mit eigenem Startwert. Der Generator des Terrains wird nicht angerührt, also sind die Hügel genau dort, wo sie waren.

  • climateAt() liest die beiden langsamen Rauschen. Ihre Grenzen wären glatte Kurven, die wie mit dem Zirkel gezogen aussehen. Also wird vorher ein drittes, feineres Rauschen addiert, einmal mit 320 m und einmal mit 90 m: Es franst die Grenzen aus.

  • Die Zahlen, die zu x und z addiert werden, verschieben nur das Rauschen. Sie sind so gewählt, dass der Start in einer Wiese liegt und jedes andere Biom weniger als einen Kilometer entfernt ist.

  • cooling() macht es kälter, je höher ein Ort liegt: um 0,4 pro hundert Meter. Der Berg einer Wiese wird auf dem Weg nach oben zu Nadelwald und am Gipfel zu Tundra, ohne eine Regel für Berge.

  • BIOMES ist das Diagramm. Jedes Biom hat außerdem eine Farbe für die Karte.

Gewichte statt eines Bioms

Wäre jeder Ort einfach sein nächstes Biom, wären die Grenzen Linien: Gras auf der einen Seite, Sand auf der anderen. biomeWeights() gibt stattdessen jedem Biom ein Gewicht. Die Funktion misst, wie weit das Klima vom Punkt jedes Bioms entfernt ist. Das nächste Biom bekommt einen Anteil von 1. Ein anderes Biom bekommt nur dann einen Anteil, wenn es weniger als BLEND weiter entfernt ist als das nächste: je näher am Gleichstand, desto größer der Anteil. Die Anteile werden quadriert, was den Anfang der Mischung abrundet, und durch ihre Summe geteilt, sodass die Gewichte zusammen immer 1 ergeben.

Tief in einem Biom ist ein Gewicht 1, und die anderen sind 0. In einem schmalen Streifen entlang einer Grenze teilen sich zwei Biome den Ort, und wo drei zusammentreffen, sind es drei. biomesAt() fasst beide Schritte für einen Ort in einer Höhe zusammen, und mainBiome() wählt das größte Gewicht.

Das Klima geht an den Shader

Der Boden wird im Fragment-Shader gefärbt, also muss der Shader die Biome jedes Pixels kennen. Die sechs Gewichte ließen sich für jeden Vertex ausrechnen und mitschicken. Aber Gewichte mischen sich zwischen Vertices schlecht: Sie bleiben lange bei 0 und steigen dann innerhalb weniger Meter, und wo das Mesh grob ist, wie in der Fernsicht mit ihren Vertices im Abstand von hundert Metern, würde eine Grenze über ein ganzes Dreieck verschmieren. Das Klima selbst ist glatt. Also trägt jeder Vertex nur sein Klima, zwei Zahlen, die Grafikkarte mischt sie über das Dreieck, und der Shader rechnet daraus die Gewichte für jedes Pixel aus. Die Grenzen sind in jeder Entfernung scharf, und das Mesh bekommt zwei Zahlen pro Vertex statt sechs.

Zuerst die Chunks. Importiere in src/chunks.ts climateAt aus './climate.ts' und ersetze das Interface ChunkMesh:

src/chunks.ts
/**
 * A chunk's mesh, with how far below the ground each vertex lies, how much sky it sees,
 * and the climate at it: temperature and moisture, two numbers per vertex.
 */
export interface ChunkMesh extends MeshData {
  depths: Float32Array;
  light: Float32Array;
  climates: Float32Array;
}

Das Klima wird dort gelesen, wo die Tiefe jedes Vertex ausgerechnet wird. Ersetze in buildChunk() alles vom Kommentar über die Meter unter dem Boden bis zum Ende der Funktion:

src/chunks.ts
// Meters below the generated ground, for the material: soil first, then rock. And the
// climate, for the biome.
const { positions } = mesh;
const depths = new Float32Array(positions.length / 3);
const climates = new Float32Array(depths.length * 2);
for (let i = 0; i < depths.length; i += 1) {
  const x = origin.x + positions[i * 3];
  const y = origin.y + positions[i * 3 + 1];
  const z = origin.z + positions[i * 3 + 2];
  depths[i] = surfaceHeight(x, z) - y;
  const { temperature, moisture } = climateAt(x, z);
  climates.set([temperature, moisture], i * 2);
}
const vertexLight = lightAt(light!, origin, mesh.positions, mesh.normals);
return { mesh: { ...mesh, depths, light: vertexLight, climates }, light: keepLight ? light : null };

Das ist das Klima auf Meereshöhe. Die Abkühlung mit der Höhe bleibt dem Shader überlassen, der die Höhe jedes Pixels kennt. Das neue Array muss wie die anderen vom Worker zur Seite reisen. Ersetze in src/chunkWorker.ts die Liste der Puffer, die übergeben werden:

src/chunkWorker.ts
const transfer: Transferable[] = mesh
  ? [mesh.positions, mesh.normals, mesh.indices, mesh.depths, mesh.light, mesh.climates].map((array) => array.buffer)
  : [];

Und das Mesh bekommt es als Attribut. Ergänze in src/world.ts, in createChunkMesh(), nach der Zeile für das Licht: mesh.setVerticesData('climate', data.climates, false, 2);

Die Fernsicht ist auch Boden und zeigt viel mehr von der Welt als die Chunks. Importiere in src/farWorker.ts climateAt und ergänze nach FarJob einen Typ für ihr Mesh:

src/farWorker.ts
/** The far ground's mesh, with the climate at each vertex. */
export interface FarMesh extends MeshData {
  climates: Float32Array;
}

Ersetze die Schleife, die die Positionen erzeugt:

src/farWorker.ts
const positions = new Float32Array(RINGS * SEGMENTS * 3);
const climates = new Float32Array(RINGS * SEGMENTS * 2);
for (let ring = 0; ring < RINGS; ring += 1) {
  const radius = INNER * growth ** ring;
  for (let segment = 0; segment < SEGMENTS; segment += 1) {
    const angle = (segment / SEGMENTS) * Math.PI * 2;
    const px = Math.cos(angle) * radius;
    const pz = Math.sin(angle) * radius;
    positions.set([px, surfaceHeight(x + px, z + pz) - SINK, pz], (ring * SEGMENTS + segment) * 3);
    const { temperature, moisture } = climateAt(x + px, z + pz);
    climates.set([temperature, moisture], (ring * SEGMENTS + segment) * 2);
  }
}

Und die letzten beiden Zeilen des Workers, die das Mesh schicken:

src/farWorker.ts
const mesh: FarMesh = { positions, normals, indices, climates };
self.postMessage(mesh, { transfer: [positions.buffer, normals.buffer, indices.buffer, climates.buffer] });

In src/farView.ts ist das Mesh, das ankommt, jetzt ein FarMesh: Importiere diesen Typ aus './farWorker.ts' statt MeshData aus './meshData.ts' und verwende ihn in MessageEvent<FarMesh> und als Typ dessen, was show() nimmt. In show() folgt das Klima auf das Licht:

src/farView.ts
mesh.setVerticesData('light', new Float32Array(count).fill(1), false, 1);
mesh.setVerticesData('climate', data.climates, false, 2);

Das Material

Der Shader braucht das Diagramm: das Klima jedes Bioms und seine Farbe. Beides geht als Arrays von Uniforms hinein, sodass die Liste der Biome an einer Stelle bleibt, in climate.ts. Ein drittes Uniform schaltet die Karte ein. Importiere in src/material.ts BIOMES aus './climate.ts' und ersetze createTerrainMaterial():

src/material.ts
/** The terrain's material: painted textures, projected from three sides, and lit. */
export function createTerrainMaterial(
  scene: Scene,
  textures: RawTexture2DArray,
  options: TerrainOptions,
): ShaderMaterial {
  const far = options.nearRadius !== undefined;
  const material = new ShaderMaterial(
    far ? 'far terrain' : 'terrain',
    scene,
    { vertexSource, fragmentSource },
    {
      attributes: ['position', 'normal', 'depth', 'light', 'climate'],
      uniforms: ['world', 'viewProjection', ...LIGHT_UNIFORMS, 'nearRadius', 'biomeClimates', 'biomeColors', 'mapView'],
      samplers: ['layers'],
      defines: far ? ['#define FAR'] : [],
    },
  );
  material.setTexture('layers', textures);
  setLight(material, options);
  // The biomes: the climate each is at home in, and its color on the map.
  material.setArray2('biomeClimates', BIOMES.flatMap((biome) => [biome.temperature, biome.moisture]));
  material.setArray3('biomeColors', BIOMES.flatMap((biome) => Color3.FromHexString(biome.color).asArray()));
  material.setFloat('mapView', 1);
  if (far) material.setFloat('nearRadius', options.nearRadius!);
  return material;
}

setArray2() und setArray3() nehmen eine flache Liste von Zahlen, zwei oder drei pro Biom. Das Attribut climate ist neu in der Liste der Attribute, die drei Uniforms in der Liste der Uniforms. Der Vertex-Shader reicht das Klima weiter. Ersetze src/terrain.vertex.glsl:

src/terrain.vertex.glsl
precision highp float;

attribute vec3 position;
attribute vec3 normal;
attribute float depth;
attribute float light;
attribute vec2 climate;

uniform mat4 world;
uniform mat4 viewProjection;

varying vec3 vPosition;
varying vec3 vNormal;
varying float vDepth;
varying float vLight;
varying vec2 vClimate;

void main() {
  vec4 worldPosition = world * vec4(position, 1.0);
  vPosition = worldPosition.xyz;
  // Chunks are only moved, never turned or scaled, so the normal stays as it is.
  vNormal = normal;
  vDepth = depth;
  vLight = light;
  vClimate = climate;
  gl_Position = viewProjection * worldPosition;
}

Gewichte pro Pixel

Ergänze in src/terrain.fragment.glsl nach den anderen Varyings varying vec2 vClimate;. Nach den Uniforms kommen die Biome:

src/terrain.fragment.glsl
// The biomes, as in climate.ts: the climate each is at home in, and its map color.
const int BIOMES = 6;
const float BLEND = 0.07;
const float COOLING = 0.004;
uniform vec2 biomeClimates[BIOMES];
uniform vec3 biomeColors[BIOMES];
// 1 paints the ground in the colors of the map.
uniform float mapView;

BLEND und COOLING sind noch einmal die Konstanten aus climate.ts: Der Shader und die Seite müssen sich einig sein, sonst würde das HUD ein Biom nennen, während der Boden ein anderes zeigt. Auch die Funktion ist dieselbe, in GLSL geschrieben. Füge sie vor main() ein:

src/terrain.fragment.glsl
// How much of each biome a climate is, as biomeWeights() in climate.ts works it out.
void biomeWeights(vec2 climate, out float weights[BIOMES]) {
  float nearest = 10.0;
  for (int i = 0; i < BIOMES; i += 1) {
    weights[i] = distance(climate, biomeClimates[i]);
    nearest = min(nearest, weights[i]);
  }
  float sum = 0.0;
  for (int i = 0; i < BIOMES; i += 1) {
    float share = max(1.0 - (weights[i] - nearest) / BLEND, 0.0);
    weights[i] = share * share;
    sum += weights[i];
  }
  for (int i = 0; i < BIOMES; i += 1) weights[i] /= sum;
}

In main(), nach der Zeile, die den Schnee einmischt, erfährt das Pixel seine Biome und nimmt die Farbe der Karte an:

src/terrain.fragment.glsl
// The biomes of this spot, from its climate: the higher up, the colder.
float biomes[BIOMES];
biomeWeights(vec2(vClimate.x - max(vPosition.y, 0.0) * COOLING, vClimate.y), biomes);
vec3 mapColor = vec3(0.0);
for (int i = 0; i < BIOMES; i += 1) mapColor += biomeColors[i] * biomes[i];
// On the map, the textures only shade the color a little.
color = mix(color, mapColor * (0.5 + color.g), mapView);

Die Temperatur sinkt mit der eigenen Höhe des Pixels, und aus den Gewichten wird eine Farbe: die Farbe jedes Bioms mal sein Gewicht. Die Textur darunter wird nicht weggeworfen: Ihr Grünkanal schattiert die Karte noch ein wenig, sodass der Boden seine Körnung behält. Mit mapView auf 0 sieht der Boden aus wie zuvor.

Von Biom zu Biom

Die Biome sind einen Kilometer oder zwei groß. Um sie alle ohne langen Fußmarsch zu sehen, fliegt eine Taste die Kamera zum nächsten. Das braucht eine Suche: den nächsten Ort, der gut innerhalb eines bestimmten Bioms liegt. Erstelle src/travel.ts:

src/travel.ts
import { BIOME_COUNT, biomesAt } from './climate.ts';
import { surfaceHeight } from './terrain.ts';

/** How far the search for a biome goes, and how far apart the places it tries are, in meters. */
const FARTHEST = 6000;
const STEP = 100;
/** A place counts only if the biome also holds this far around it. */
const AROUND = 120;

/**
 * The nearest place to (x, z) that lies well inside a biome: tried on rings around the
 * point, each STEP further out than the one before.
 */
export function findBiome(biome: number, x: number, z: number): { x: number; z: number } | null {
  const weights = new Float32Array(BIOME_COUNT);
  const holds = (px: number, pz: number) => {
    biomesAt(px, surfaceHeight(px, pz), pz, weights);
    return weights[biome] > 0.98;
  };
  for (let radius = STEP; radius <= FARTHEST; radius += STEP) {
    const steps = Math.ceil((radius * 2 * Math.PI) / STEP);
    for (let step = 0; step < steps; step += 1) {
      const angle = (step / steps) * Math.PI * 2;
      const px = x + Math.cos(angle) * radius;
      const pz = z + Math.sin(angle) * radius;
      if (!holds(px, pz)) continue;
      if (holds(px + AROUND, pz) && holds(px - AROUND, pz) && holds(px, pz + AROUND) && holds(px, pz - AROUND)) {
        return { x: px, z: pz };
      }
    }
  }
  return null;
}

Die Suche probiert Orte auf Ringen um die Kamera, 100 m voneinander entfernt, jeder Ring 100 m weiter außen. Ein Ort zählt, wenn das Biom dort fast das ganze Gewicht hat, auf der Höhe des Bodens, und auch 120 m nach jeder Seite: Eine schmale Zunge eines Bioms ist kein Ort für einen Besuch. Der erste gefundene Ort ist der nächste.

Alles zusammensetzen

Importiere in src/main.ts BIOME_COUNT, BIOMES, biomesAt und mainBiome aus './climate.ts' sowie findBiome aus './travel.ts'. Das Material der Fernsicht bekommt einen Namen, denn die Karte schaltet beide Materialien. Ersetze die Zeile, die die Fernsicht erzeugt:

src/main.ts
const farMaterial = createTerrainMaterial(scene, textures, { ...fog, nearRadius });
const farView = new FarView(scene, farMaterial);

Ergänze nach der Zeile let mode: 'walk' | 'fly' = 'walk';:

src/main.ts
// The biome where the camera is, and the map that paints the ground in the biomes' colors.
const biomes = new Float32Array(BIOME_COUNT);
let biome = 0;
let mapView = true;

/** Flies to the nearest place of the biome after the one the camera is in. */
function travel(): void {
  const next = (biome + 1) % BIOME_COUNT;
  const place = findBiome(next, camera.position.x, camera.position.z);
  if (!place) return;
  mode = 'fly';
  camera.position.set(place.x, surfaceHeight(place.x, place.z) + 30, place.z);
}

travel() sucht das Biom nach dem, in dem die Kamera ist, und setzt die fliegende Kamera dort 30 m über den Boden. Zwei Tasten kommen in den keydown-Handler, nach der für den Mesher:

src/main.ts
if (event.code === 'KeyG') {
  mapView = !mapView;
  for (const ground of [material, farMaterial]) ground.setFloat('mapView', mapView ? 1 : 0);
}
if (event.code === 'KeyN') travel();

In jedem Frame wird das Biom unter der Kamera ausgerechnet, auf der Höhe des Bodens dort. In der Render-Schleife, nach der Zeile, die die Position der Kamera in x, y und z liest:

src/main.ts
biomesAt(x, surfaceHeight(x, z), z, biomes);
biome = mainBiome(biomes);

Das HUD nennt es, in einer Zeile nach den Koordinaten: `Biome: ${BIOMES[biome].name}\n` +. In index.html wird der Titel zu Voxel biomes, und die Hilfe nennt die beiden neuen Tasten:

index.html
<div id="help">
  Click to look around · WASD walk, Shift run, Space jump · F fly (Q/E down/up) · B blocks:
  left break, right place, wheel or 1–6 material, , . size · C chisel: left cut, right sharp, R round or slope ·
  T terrain: left dig, right build, wheel size · M mesher · G map of the biomes · N fly to the next biome
</div>

Ausprobieren

Die Demo beginnt mit eingeschalteter Karte: Die Wiese um dich ist hellgrün. Drück F zum Fliegen, steig mit E auf und schau dich um. Das Dunkelgrün ist Laubwald, das Blaugrün Nadelwald, das blasse Grau Tundra, das Ocker Savanne und die helle Sandfarbe Wüste. Schau einen Berg an: Sein Fuß hat die Farbe des Landes um ihn herum, und weiter oben wird er zu Nadelwald und Tundra, weil es dort kälter ist. Drück ein paar Mal N: Jeder Druck fliegt dich zum nächsten Ort des nächsten Bioms, und das HUD nennt es. Flieg tief an einer Grenze entlang und sieh, wie sie ausfranst. G schaltet die Karte aus, und der Boden ist überall der alte: Die Biome sind bisher nur Farben.

Hoch über dem Start, mit eingeschalteter Karte: die Wiese hellgrün, Wälder dunkelgrün und blaugrün, Tundra grau, Savanne und Wüste in Ocker und Sand. Die Berge werden zum Gipfel hin kälter.
Die Biome als Karte auf dem Boden. Klick, dann: F fliegt (Q/E runter/hoch, Shift schneller), N fliegt zum nächsten Biom, G schaltet die Karte ein und aus. Alles aus der Bau-Serie funktioniert weiterhin.
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.