Zum Inhalt springen

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

Teil 10: Wälder bis zum Horizont

Führe die Wälder über das letzte Mesh hinaus: Mach von jedem Baummodell einmal ein Bild, indem du es in eine Textur zeichnest, und lass für jeden fernen Baum eine Karte mit diesem Bild stehen, einen Kilometer weit. Dahinter nimmt der ferne Boden die Farbe der Kronen an.

Quest-Ziele

  • Einen Baum mit einer Kamera ohne Perspektive in eine Textur zeichnen und das Bild zurücklesen
  • Für jeden fernen Baum eine Karte aufstellen, vier Vertices, die der Shader zur Kamera dreht
  • Eine flache Karte beleuchten, als wäre sie eine Kugel
  • Karten einblenden, wo die Meshes ausblenden
  • Die Kacheln eines ganzen Quadratkilometers pflanzen, die nächsten zuerst
  • Den fernen Boden in der Farbe der Kronen malen, wo kein Baum mehr gezeichnet wird

Die Wälder aus Teil 9 enden 130 m vor der Kamera. Von einem Hügel aus sieht das aus wie ein Garten um dich herum in einem kahlen Land. Mehr Meshes zu zeichnen ist kein Ausweg: Ein Baum hat ein paar tausend Dreiecke, und in einem Wald steht alle paar Meter einer. Aber ein Baum in 300 m Entfernung bedeckt eine Handvoll Pixel. Dafür genügt ein Bild von ihm: eine Karte aus vier Vertices, die den Baum zeigt und immer zur Kamera schaut. So ein Stellvertreter heißt Impostor.

Dieser Teil macht die Bilder, einmal, wenn das Spiel startet. Dann zeichnet der Wald Meshes nur noch bis 95 m, Karten von dort bis zu einem Kilometer, und hinter der letzten Karte nimmt der ferne Boden selbst die Farbe der Kronen an.

Wie weit ein Baum reicht

Ein Bild braucht einen Rahmen, in den der ganze Baum passt. Ein Modell kennt seine Höhe, aber nicht, wie weit seine Krone ausgreift. Das ist der größte Abstand eines seiner Vertices von der Achse des Stamms. In src/trees.ts bekommt TreeModel ein Feld mehr, und meshTree() füllt es, in dem Objekt, das es zurückgibt, gleich nach girth:

src/trees.ts
/** How far the tree reaches from its trunk at most. */
reach: number;

reach: Math.sqrt(positions.reduce((most, x, i) => (i % 3 === 0 ? Math.max(most, x * x + positions[i + 2] ** 2) : most), 0)),

Ein Baum in schlichten Farben

Das Bild darf kein Licht enthalten. Eine Karte dreht sich mit der Kamera, und eine ins Bild gemalte Sonnenseite würde sich mitdrehen: Geh um den Wald herum, und die Sonne schiene dir zu folgen. Also enthält das Bild nur die eigenen Farben des Baums, abgedunkelt durch den Schatten im Inneren seiner Krone aus Teil 8, und beleuchtet wird die Karte erst, wenn sie gezeichnet wird.

Der Shader der Bäume bekommt dafür eine zweite Arbeitsweise, eingeschaltet mit einem #define: Mit PLAIN lässt er das Ausblenden aus Teil 9 weg, das davon abhängt, wo die Kamera ist, und schreibt die Farbe der Textur mal den Schatten und sonst nichts. Ersetze in src/tree.fragment.glsl den Anfang von main(), bis zu der Zeile, die die Sonne ausrechnet:

src/tree.fragment.glsl
void main() {
#ifndef PLAIN
  // A fading tree is drawn with only some of its pixels: fewer the more it has faded.
  if (vFade < 1.0 && vFade <= grain()) discard;
#endif
  float layer = floor(vPaint.z + 0.5);
  vec4 texel = texture(layers, vec3(vPaint.xy, layer));
  // Between the leaves of a spray there is nothing.
  if (texel.a < 0.4) discard;
#ifdef PLAIN
  // For its picture, a tree shows its colors in its own shade, and no light.
  gl_FragColor = vec4(texel.rgb * vPaint.w, 1.0);
  return;
#endif

  vec3 normal = normalize(vNormal);
  float sun = max(dot(normal, -sunDirection), 0.0);

Es gibt jetzt zwei Materialien, das eigene der Bäume und das schlichte, und beide benutzen dasselbe Textur-Array. Darum zieht das Erzeugen der Texturen aus createTreeMaterial() in eine eigene Funktion, und das Material bekommt sie als Argument. Mit plain in seinen Optionen wird es mit dem #define erzeugt. Ersetze src/treeMaterial.ts:

src/treeMaterial.ts
import { Constants, RawTexture2DArray, ShaderMaterial, Texture, Vector2, type Mesh, type Scene } from '@babylonjs/core/pure';
import { LIGHT_UNIFORMS, setLight, type FogOptions } from './material.ts';
import { createMesh } from './meshData.ts';
import fragmentSource from './tree.fragment.glsl?raw';
import vertexSource from './tree.vertex.glsl?raw';
import { TREE_LAYERS, type TreeModel } from './trees.ts';
import { paintTreeLayers, TREE_TEXTURE } from './treeTextures.ts';

/** The trees' textures: the barks and the sprays of leaves, as the layers of one texture array. */
export function createTreeTextures(scene: Scene): RawTexture2DArray {
  const layers = new RawTexture2DArray(
    paintTreeLayers(),
    TREE_TEXTURE,
    TREE_TEXTURE,
    TREE_LAYERS.length,
    Constants.TEXTUREFORMAT_RGBA,
    scene,
    true,
    false,
    Texture.TRILINEAR_SAMPLINGMODE,
  );
  // The bark goes around and up the trunk without an end.
  layers.wrapU = Texture.WRAP_ADDRESSMODE;
  layers.wrapV = Texture.WRAP_ADDRESSMODE;
  return layers;
}

/**
 * The trees' material: bark and leaves from one texture array, lit by the sun and the sky.
 * Trees fade out between `fadeFrom` and `range` meters from the camera. With `plain`, it
 * shows the trees' colors without the light, for their pictures.
 */
export function createTreeMaterial(
  scene: Scene,
  layers: RawTexture2DArray,
  options: FogOptions & { fadeFrom: number; range: number; plain?: boolean },
): ShaderMaterial {
  const material = new ShaderMaterial(
    options.plain ? 'plain trees' : 'trees',
    scene,
    { vertexSource, fragmentSource },
    {
      attributes: ['position', 'normal', 'paint', 'place', 'look'],
      uniforms: ['world', 'viewProjection', ...LIGHT_UNIFORMS, 'firstLeaves', 'treeRange'],
      samplers: ['layers'],
      defines: options.plain ? ['#define PLAIN'] : [],
    },
  );
  material.setTexture('layers', layers);
  setLight(material, options);
  material.setVector2('treeRange', new Vector2(options.fadeFrom, options.range));
  material.setFloat('firstLeaves', TREE_LAYERS.findIndex((name) => name.includes('leaves') || name.includes('needles')));
  // A spray of leaves is seen from both sides.
  material.backFaceCulling = false;
  return material;
}

/** A tree's mesh in the scene. It is drawn once for every instance it is given. */
export function createTreeMesh(scene: Scene, model: TreeModel, material: ShaderMaterial): Mesh {
  const mesh = createMesh(model.species.name, model.mesh, scene);
  mesh.setVerticesData('paint', model.mesh.paints, false, 4);
  mesh.material = material;
  mesh.isPickable = false;
  // Its instances stand anywhere: Babylon.js can't tell from the mesh whether they are in view.
  mesh.alwaysSelectAsActiveMesh = true;
  return mesh;
}

Die Bilder machen

Babylon.js kann in eine Textur zeichnen statt auf den Bildschirm: Eine RenderTargetTexture hat ihre eigene Kamera und ihre eigene Liste von Meshes. Die Kamera für ein Bild hat keine Perspektive. Eine orthografische Kamera zeigt einen Quader der Welt, und der wird auf den Rahmen des Baums eingestellt: so breit wie hoch, der Fuß des Baums in der Mitte der Unterkante. Erstelle src/impostors.ts:

src/impostors.ts
import {
  Camera,
  Color4,
  Constants,
  FreeCamera,
  RawTexture2DArray,
  RenderTargetTexture,
  ShaderMaterial,
  Texture,
  Vector3,
  Vector4,
  type Mesh,
  type Scene,
} from '@babylonjs/core/pure';
import { instanceBuffer } from './chunkPlants.ts';
import fragmentSource from './impostor.fragment.glsl?raw';
import vertexSource from './impostor.vertex.glsl?raw';
import { LIGHT_UNIFORMS, setLight, type FogOptions } from './material.ts';
import { createMesh } from './meshData.ts';
import { bleed } from './plants.ts';
import { createTreeMesh } from './treeMaterial.ts';
import { TREE_FLOATS } from './treeRule.ts';
import type { TreeModel } from './trees.ts';

/** Pixels along each side of a tree's picture. */
const PICTURE = 128;
/** Only the camera that takes the pictures sees this layer. */
const STUDIO = 0x10000000;

/** The side of the square that holds a model's picture, in meters: its foot is the middle of the bottom edge. */
export const frameOf = (model: TreeModel) => Math.max(model.height, model.reach * 2) * 1.04;

/**
 * Takes a picture of every model from the side, and hands them out as the layers of a
 * texture array. `material` is the trees' material in its plain colors, without the light.
 */
export async function takePictures(scene: Scene, models: TreeModel[], material: ShaderMaterial): Promise<RawTexture2DArray> {
  const target = new RenderTargetTexture('pictures', PICTURE, scene, false);
  target.clearColor = new Color4(0, 0, 0, 0);
  // A camera without perspective, far enough away to see the whole tree.
  const camera = new FreeCamera('studio', new Vector3(0, 0, -100), scene);
  camera.mode = Camera.ORTHOGRAPHIC_CAMERA;
  camera.minZ = 1;
  camera.maxZ = 200;
  camera.layerMask = STUDIO;
  target.activeCamera = camera;

  const layers = new Uint8Array(PICTURE * PICTURE * 4 * models.length);
  for (const [layer, model] of models.entries()) {
    // One tree at the world's origin, its foot at the middle of the picture's bottom edge.
    const mesh = createTreeMesh(scene, model, material);
    mesh.layerMask = STUDIO;
    const buffer = instanceBuffer(mesh, new Float32Array([0, 0, 0, 1, 0, 0, 0, 0]));
    const frame = frameOf(model);
    camera.orthoLeft = -frame / 2;
    camera.orthoRight = frame / 2;
    camera.orthoBottom = 0;
    camera.orthoTop = frame;
    // The shader has to be ready, or the picture stays empty.
    await material.forceCompilationAsync(mesh);
    target.renderList = [mesh];
    target.render();
    const pixels = new Uint8Array((await target.readPixels()!).buffer);
    bleed(pixels);
    layers.set(pixels, layer * PICTURE * PICTURE * 4);
    mesh.dispose();
    buffer.dispose();
  }
  camera.dispose();
  target.dispose();
  return new RawTexture2DArray(layers, PICTURE, PICTURE, models.length, Constants.TEXTUREFORMAT_RGBA, scene, true, false, Texture.TRILINEAR_SAMPLINGMODE);
}

/** Where the cards fade in and out again, in meters from the camera. */
export interface CardRange {
  from: number;
  full: number;
  fade: number;
  range: number;
}

/** The material of the cards that stand for far trees: the pictures, lit as if each tree were a ball. */
export function createImpostorMaterial(scene: Scene, pictures: RawTexture2DArray, options: FogOptions & CardRange): ShaderMaterial {
  const material = new ShaderMaterial(
    'impostors',
    scene,
    { vertexSource, fragmentSource },
    {
      attributes: ['position', 'card', 'layer'],
      uniforms: ['viewProjection', ...LIGHT_UNIFORMS, 'cardRange'],
      samplers: ['pictures'],
    },
  );
  material.setTexture('pictures', pictures);
  setLight(material, options);
  material.setVector4('cardRange', new Vector4(options.from, options.full, options.fade, options.range));
  material.backFaceCulling = false;
  return material;
}

/**
 * The cards of a tile's trees, as one mesh: four corners per tree, all at the tree's foot.
 * The shader moves them apart. `skip` says which trees get no card, by their number in the list.
 */
export function createCards(
  scene: Scene,
  trees: Float32Array,
  models: TreeModel[],
  material: ShaderMaterial,
  skip: (tree: number) => boolean = () => false,
): Mesh | null {
  const positions: number[] = [];
  const cards: number[] = [];
  const layers: number[] = [];
  const indices: number[] = [];
  for (let t = 0; t < trees.length; t += TREE_FLOATS) {
    if (skip(t)) continue;
    const model = trees[t + 6];
    const frame = frameOf(models[model]) * trees[t + 3];
    const first = positions.length / 3;
    for (const [u, v] of [[0, 0], [1, 0], [1, 1], [0, 1]]) {
      positions.push(trees[t], trees[t + 1], trees[t + 2]);
      cards.push((u - 0.5) * frame, v * frame, u, v);
      layers.push(model);
    }
    indices.push(first, first + 1, first + 2, first, first + 2, first + 3);
  }
  if (indices.length === 0) return null;
  const count = positions.length / 3;
  const mesh = createMesh('cards', { positions: new Float32Array(positions), normals: new Float32Array(count * 3), indices: new Uint32Array(indices) }, scene);
  mesh.setVerticesData('card', cards, false, 4);
  mesh.setVerticesData('layer', layers, false, 1);
  // The mesh only knows the trees' feet. Its box has to hold the cards too.
  const { minimum, maximum } = mesh.getBoundingInfo();
  mesh.buildBoundingInfo(minimum.subtract(new Vector3(15, 2, 15)), maximum.add(new Vector3(15, 30, 15)));
  mesh.material = material;
  mesh.isPickable = false;
  mesh.freezeWorldMatrix();
  return mesh;
}

takePictures() geht die Modelle eines nach dem anderen durch:

  • Der Baum ist ein Mesh mit einer Instanz, im Ursprung der Welt, im schlichten Material. Er ist einen Moment lang in der Szene, darum bekommt er eine Layer-Maske, die nur die Kamera des Studios hat: Die Kamera des Spiels zeichnet ihn nie, und die des Studios zeichnet nichts anderes.

  • Die Kamera steht 100 m entfernt auf der z-Achse und schaut an ihr entlang. Ihre vier ortho-Zahlen sind die Kanten des Rahmens, aus frameOf(): das Größere aus der Höhe und der doppelten Reichweite, und etwas Luft darum.

  • forceCompilationAsync() wartet, bis der Shader kompiliert ist. Babylon.js kompiliert Shader im Hintergrund und überspringt ein Mesh, dessen Shader nicht bereit ist, und das Bild bliebe leer.

  • render() zeichnet sofort in die Textur, und readPixels() gibt ihre Bytes zurück, Zeile für Zeile von unten nach oben, wie das Textur-Array sie will.

  • bleed() aus Teil 6 gibt den durchsichtigen Pixeln die Durchschnittsfarbe des Baums, damit das Bild keinen dunklen Rand hat, wo es überblendet wird.

Alle Bilder landen als die Ebenen eines Textur-Arrays, in der Reihenfolge der Modelle, mit kleineren Kopien ihrer selbst für die Ferne. Ein Modell wird nur von einer Seite aufgenommen. Bäume sind rund genug dafür, und mit drei Varianten jeder Art in verschiedenen Größen sieht ein ferner Wald nicht gestempelt aus.

createCards() macht die Karten einer Kachel von Bäumen als ein einziges Mesh. Jeder Baum hat vier Vertices, und alle vier haben dieselbe Position: den Fuß des Baums. Was sie unterscheidet, ist das Attribut card: wie weit die Ecke vom Fuß entfernt liegt, nach rechts und nach oben, in Metern, und wo auf dem Bild sie ist. Der Shader schiebt die Ecken auseinander, denn nur der Shader weiß, wo die Kamera ist. Die Hüllbox des Meshes kommt aus den Positionen, die nur die Füße sind, also wird sie von Hand vergrößert: Sonst würde Babylon.js eine Kachel nicht mehr zeichnen, deren Füße aus dem Blick sind, während ihre Kronen noch hineinragen. Das letzte Argument, skip, lässt Bäume aus. Teil 12 braucht es.

Die Shader der Karte

Erstelle src/impostor.vertex.glsl:

src/impostor.vertex.glsl
precision highp float;

// The tree's foot: the same for all four corners of its card.
attribute vec3 position;
// Where the corner lies from the foot, in meters to the right and up, and where on the picture.
attribute vec4 card;
// The picture's layer.
attribute float layer;

uniform mat4 viewProjection;
uniform vec3 cameraPosition;
// Where the cards fade in, and where they fade out again, in meters from the camera.
uniform vec4 cardRange;

varying vec3 vPosition;
varying vec3 vNormal;
varying vec3 vPicture;
varying float vFade;

void main() {
  // The card stands upright and turns about the trunk to face the camera.
  vec3 toCamera = normalize(vec3(cameraPosition.x - position.x, 0.0, cameraPosition.z - position.z));
  vec3 right = vec3(toCamera.z, 0.0, -toCamera.x);
  vPosition = position + right * card.x + vec3(0.0, card.y, 0.0);
  // A flat card would be lit all alike. Its normals bulge instead, as if it were a ball:
  // to the right on its right side, up at its top.
  vNormal = right * (card.z * 2.0 - 1.0) + vec3(0.0, card.w * 1.4 - 0.4, 0.0) + toCamera * 0.6;
  vPicture = vec3(card.zw, layer);
  float away = distance(position.xz, cameraPosition.xz);
  vFade = smoothstep(cardRange.x, cardRange.y, away) * (1.0 - smoothstep(cardRange.z, cardRange.w, away));
  gl_Position = viewProjection * vec4(vPosition, 1.0);
}
  • Die Karte steht aufrecht und dreht sich nur um den Stamm. toCamera ist die waagrechte Richtung vom Fuß zur Kamera, und right steht senkrecht darauf: Die Ecken gehen card.x entlang right und card.y nach oben.

  • Die Normale ist das, woran sich eine Karte verrät. Eine flache Karte hat eine Normale, also würde die Sonne sie überall gleich beleuchten, und ein Wald aus solchen Karten sieht aus wie Pappfiguren. Hier wölben sich die Normalen: nach rechts auf der rechten Hälfte der Karte, nach links auf der linken, nach oben an der Spitze und zur Kamera in der Mitte. Der Fragment-Shader beleuchtet die Karte, als wäre sie eine Kugel, mit einer hellen Seite zur Sonne.

  • vFade steigt über die ersten zwei Zahlen von cardRange von 0 auf 1 und fällt über die letzten zwei wieder auf 0: Die Karten blenden ein, wo die Meshes ausblenden, und am Ende ihrer Reichweite wieder aus.

Erstelle src/impostor.fragment.glsl:

src/impostor.fragment.glsl
precision highp float;
precision highp sampler2DArray;

varying vec3 vPosition;
varying vec3 vNormal;
varying vec3 vPicture;
varying float vFade;

uniform sampler2DArray pictures;
uniform vec3 cameraPosition;
uniform vec3 sunDirection;
uniform vec3 sunColor;
uniform vec3 skyColor;
uniform vec3 groundColor;
uniform vec3 fogColor;
uniform vec2 fogRange;

// A number from 0 to 1 that differs from pixel to pixel, in a pattern too fine to see.
float grain() {
  return fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
}

void main() {
  if (vFade < 1.0 && vFade <= grain()) discard;
  vec4 texel = texture(pictures, vec3(vPicture.xy, floor(vPicture.z + 0.5)));
  if (texel.a < 0.5) discard;

  // The picture holds the tree's colors in its own shade. The sun and the sky light it here.
  vec3 normal = normalize(vNormal);
  float sun = max(dot(normal, -sunDirection), 0.0) * 0.75 + max(dot(normal, sunDirection), 0.0) * 0.25;
  vec3 ambient = mix(mix(groundColor, skyColor, normal.y * 0.5 + 0.5), skyColor, 0.5) * 1.2;
  vec3 lit = texel.rgb * (ambient + sunColor * sun);

  float fog = smoothstep(fogRange.x, fogRange.y, distance(vPosition, cameraPosition));
  gl_FragColor = vec4(mix(lit, fogColor, fog), 1.0);
}

Eine verblassende Karte wird nur mit einem Teil ihrer Pixel gezeichnet, mit demselben grain() wie die Bäume. Dann wird das Bild entlang dem Umriss des Baums ausgeschnitten und beleuchtet wie die Blätter in Teil 8: vor allem von der Sonnenseite, ein wenig von hinten, unter einem hellen Himmel.

Der Wald, nah und fern

Der Wald hält jetzt Kacheln bis zu einem Kilometer, und jede Kachel hat ein Mesh aus Karten. Ersetze src/forest.ts:

src/forest.ts
import type { Buffer, Mesh, Scene, ShaderMaterial, Vector3 } from '@babylonjs/core/pure';
import { instanceBuffer } from './chunkPlants.ts';
import { createCards } from './impostors.ts';
import type { Solid, Surface } from './solids.ts';
import { createTreeMesh } from './treeMaterial.ts';
import { TILE, TREE_FLOATS } from './treeRule.ts';
import type { TreeModel } from './trees.ts';
import type { TileJob, TileResult } from './treeWorker.ts';

/** How far from the camera trees are drawn as meshes, in meters, and where they start to fade out. */
export const TREE_RANGE = 95;
export const TREE_FADE = 80;
/** How far they are drawn as cards, and where those start to fade out. */
export const CARD_RANGE = 1000;
export const CARD_FADE = 850;
/** The trees are sorted out again once the camera has moved this far. */
const STEP = 8;
/** A trunk is solid up to this share of the tree's height, where the crown begins. */
const TRUNK = 0.5;
/** Meters along each side of a cell of a tile's grid, which finds the trees near a point. */
const GRID = 8;

interface Tile {
  /** TREE_FLOATS numbers per tree, or null while the worker plants the tile. */
  trees: Float32Array | null;
  /** Which trees stand in each cell of the grid, as their numbers in the list. */
  grid: Map<number, number[]> | null;
  /** The cards that stand for the tile's trees from afar. */
  cards: Mesh | null;
}

const tileKey = (x: number, z: number) => `${x},${z}`;

/**
 * The trees around the camera. A worker plants them tile by tile, and every model's mesh
 * is drawn once for each tree of its kind that is near enough. Further away, a card with
 * the model's picture stands for each tree. The trunks are solid.
 */
export class Forest implements Solid {
  /** How many trees are drawn. */
  shown = 0;
  private readonly tiles = new Map<string, Tile>();
  private readonly meshes: Mesh[];
  private readonly buffers: (Buffer | null)[];
  private readonly worker = new Worker(new URL('./treeWorker.ts', import.meta.url), { type: 'module' });
  /** Where the camera was when the trees were last sorted out, or null if they must be now. */
  private sorted: { x: number; z: number } | null = null;
  /** The cards' material, once the pictures are taken. */
  private cardMaterial: ShaderMaterial | null = null;
  private readonly scene: Scene;
  private readonly models: TreeModel[];

  constructor(scene: Scene, models: TreeModel[], material: ShaderMaterial) {
    this.scene = scene;
    this.models = models;
    this.meshes = models.map((model) => createTreeMesh(scene, model, material));
    this.buffers = models.map(() => null);
    for (const mesh of this.meshes) mesh.setEnabled(false);
    this.worker.onmessage = (event: MessageEvent<TileResult>) => {
      const tile = this.tiles.get(tileKey(event.data.x, event.data.z));
      // A tile that was dropped while it was planted is not wanted any more.
      if (!tile) return;
      tile.trees = event.data.trees;
      this.sorted = null;
      this.card(tile);
    };
  }

  /** How many trees are drawn as cards. */
  get cards(): number {
    let cards = 0;
    for (const tile of this.tiles.values()) cards += (tile.cards?.getTotalVertices() ?? 0) / 4;
    return cards;
  }

  /** The pictures are taken: from now on, far trees are drawn as cards. */
  showCards(material: ShaderMaterial): void {
    this.cardMaterial = material;
    for (const tile of this.tiles.values()) this.card(tile);
  }

  /** Makes a tile's cards, anew if it had some. */
  private card(tile: Tile): void {
    tile.cards?.dispose();
    tile.cards = null;
    if (tile.trees && this.cardMaterial) tile.cards = createCards(this.scene, tile.trees, this.models, this.cardMaterial);
  }

  /** Once a frame: asks for the tiles in range, drops those far away, and sorts out the trees. */
  update(focus: Vector3): void {
    const reach = Math.ceil(CARD_RANGE / TILE);
    const [centerX, centerZ] = [Math.floor(focus.x / TILE), Math.floor(focus.z / TILE)];
    const wanted: (TileJob & { distance: number })[] = [];
    for (let z = centerZ - reach; z <= centerZ + reach; z += 1) {
      for (let x = centerX - reach; x <= centerX + reach; x += 1) {
        if (!this.tiles.has(tileKey(x, z))) wanted.push({ x, z, distance: Math.hypot(x - centerX, z - centerZ) });
      }
    }
    // The worker plants the tiles in the order it is asked: the nearest first.
    for (const { x, z } of wanted.sort((a, b) => a.distance - b.distance)) {
      this.tiles.set(tileKey(x, z), { trees: null, grid: null, cards: null });
      this.worker.postMessage({ x, z } satisfies TileJob);
    }
    for (const [key, tile] of this.tiles) {
      const [x, z] = key.split(',').map(Number);
      if (Math.max(Math.abs(x - centerX), Math.abs(z - centerZ)) <= reach + 1) continue;
      tile.cards?.dispose();
      this.tiles.delete(key);
    }
    if (!this.sorted || Math.hypot(focus.x - this.sorted.x, focus.z - this.sorted.z) > STEP) this.sort(focus);
  }

  /** Hands every model the trees of its kind that are in range, as its instances. */
  private sort(focus: Vector3): void {
    this.sorted = { x: focus.x, z: focus.z };
    const lists: number[][] = this.models.map(() => []);
    // A little further than they are drawn, for the way to the next sorting.
    const range = TREE_RANGE + STEP;
    for (const { trees } of this.tiles.values()) {
      if (!trees) continue;
      for (let t = 0; t < trees.length; t += TREE_FLOATS) {
        if (Math.hypot(trees[t] - focus.x, trees[t + 2] - focus.z) > range) continue;
        for (let f = 0; f < TREE_FLOATS; f += 1) lists[trees[t + 6]].push(trees[t + f]);
      }
    }
    this.shown = 0;
    lists.forEach((list, model) => {
      this.buffers[model]?.dispose();
      this.buffers[model] = list.length > 0 ? instanceBuffer(this.meshes[model], new Float32Array(list)) : null;
      this.meshes[model].setEnabled(list.length > 0);
      this.shown += list.length / TREE_FLOATS;
    });
  }

  /** The nearest trunk to a point, if one is within `reach` meters. */
  nearest(x: number, y: number, z: number, reach: number): Surface | null {
    let nearest: Surface | null = null;
    // The trees of the cells around the point, each in the tile it lies in: no trunk is
    // thicker than a cell.
    for (let k = -1; k <= 1; k += 1) {
      for (let i = -1; i <= 1; i += 1) {
        const [cellX, cellZ] = [x + i * GRID, z + k * GRID];
        const tile = this.tiles.get(tileKey(Math.floor(cellX / TILE), Math.floor(cellZ / TILE)));
        if (!tile?.trees) continue;
        const { trees } = tile;
        tile.grid ??= gridOf(trees);
        for (const t of tile.grid.get(gridKey(cellX, cellZ)) ?? []) {
          const model = this.models[trees[t + 6]];
          const size = trees[t + 3];
          if (y < trees[t + 1] || y > trees[t + 1] + model.height * size * TRUNK) continue;
          // A trunk is a standing cylinder: the way out of it is level.
          const [dx, dz] = [x - trees[t], z - trees[t + 2]];
          const apart = Math.hypot(dx, dz) || 0.001;
          const distance = apart - model.girth * size;
          if (distance < reach && (!nearest || distance < nearest.distance)) {
            nearest = { distance, normal: [dx / apart, 0, dz / apart] };
          }
        }
      }
    }
    return nearest;
  }
}

const gridKey = (x: number, z: number) => Math.floor(x / GRID) * 65536 + Math.floor(z / GRID);

/** Sorts a tile's trees into the cells of a grid. */
function gridOf(trees: Float32Array): Map<number, number[]> {
  const grid = new Map<number, number[]>();
  for (let t = 0; t < trees.length; t += TREE_FLOATS) {
    const key = gridKey(trees[t], trees[t + 2]);
    if (!grid.has(key)) grid.set(key, []);
    grid.get(key)!.push(t);
  }
  return grid;
}
  • Die Reichweite der Meshes schrumpft von 130 m auf 95 m, mit Ausblenden ab 80 m. Das ist der Lohn: etwa halb so viele Meshes wie zuvor, und ein Wald, der einen Kilometer weit reicht.

  • update() fragt nach den Kacheln innerhalb von CARD_RANGE. Das sind am Anfang ein paar hundert, und der Worker pflanzt sie in der Reihenfolge, in der er gefragt wird, also wird die Liste zuerst sortiert: Die nächsten Kacheln kommen zuerst, und der Wald wächst von der Kamera aus nach außen.

  • card() macht das Karten-Mesh einer Kachel, sobald ihre Bäume da und die Bilder gemacht sind. showCards() wird aufgerufen, wenn die Bilder fertig sind, und macht die Karten aller Kacheln, die vorher kamen.

  • Eine Kachel, die verworfen wird, nimmt ihre Karten mit.

Jeder Baum innerhalb eines Kilometers hat eine Karte, auch die nahen. Deren Karten sind ausgeblendet, sie kosten also ein paar Vertices und keine Pixel, und es muss keine Liste geführt werden, welcher Baum wie gezeichnet wird: Die zwei Shader entscheiden nach der Entfernung.

Die Farbe der Kronen

Ein Kilometer ist noch nicht der Horizont, den die Fernsicht auf 4,5 km legt. Aber dort draußen ist ein Baum kleiner als ein Pixel, und ein Wald ist ein dunkler Fleck auf dem Land. Den kann der ferne Boden selbst malen: Seine Vertices wissen seit Teil 9, wie viel vom Boden Bäume bedecken, als dritte Zahl des Klimas. In src/terrain.fragment.glsl bekommt der Uniform-Block der Fernsicht zwei Konstanten. Ersetze ihn:

src/terrain.fragment.glsl
#ifdef FAR
uniform float nearRadius;
// Where the forests turn from single trees into the color of their crowns, in meters.
const float CANOPY_FROM = 750.0;
const float CANOPY_FULL = 950.0;
#endif

Und wo der Boden unter Bäumen im Schatten liegt, mischt der ferne Boden danach die Farbe der Kronen hinein. Ersetze die zwei Zeilen des Schattens:

src/terrain.fragment.glsl
// Under trees the ground lies in their shade.
  color *= 1.0 - 0.3 * vClimate.z;
#ifdef FAR
  // Beyond the last tree that is drawn, a forest is the color of its crowns.
  float canopy = vClimate.z * smoothstep(CANOPY_FROM, CANOPY_FULL, distance(vPosition.xz, cameraPosition.xz));
  color = mix(color, mapColor * 0.45, canopy);
#endif

Die Farbe ist die des Bioms auf der Karte aus Teil 1, abgedunkelt: dunkelgrün für den Laubwald, ein bläuliches Grün für die Nadelbäume. Sie kommt zwischen 750 m und 950 m herein, etwas bevor die Karten zwischen 850 m und 1000 m ausblenden, sodass sich die Karten in Boden auflösen, der ihre Farbe schon hat.

Zusammensetzen

In eine Textur zu zeichnen und sie zurückzulesen sind zwei weitere Teile von Babylon.js, die registriert werden müssen. Importiere in src/main.ts RegisterRenderTargetTexture, RegisterEnginesExtensionsEngineReadTexture und den Typ ShaderMaterial aus Babylon.js und ergänze nach den Registrierungen für den Staub:

src/main.ts
// For the pictures of the trees: drawing into a texture, and reading it back.
RegisterRenderTargetTexture();
RegisterEnginesExtensionsEngineReadTexture();

Importiere CARD_FADE und CARD_RANGE aus ./forest.ts, createImpostorMaterial und takePictures aus ./impostors.ts und createTreeTextures aus ./treeMaterial.ts. Ersetze dann die zwei Zeilen, die das Material der Bäume und den Wald erzeugen:

src/main.ts
const treeLayers = createTreeTextures(scene);
const treeRange = { fadeFrom: TREE_FADE, range: TREE_RANGE };
const treeMaterial = createTreeMaterial(scene, treeLayers, { ...fog, ...treeRange });
const treeModels = growModels();
const forest = new Forest(scene, treeModels, treeMaterial);
// Further away, a card with its picture stands for each tree. The cards come in where
// the meshes fade out.
const cardRange = { from: TREE_FADE, full: TREE_RANGE, fade: CARD_FADE, range: CARD_RANGE };
let cardMaterial: ShaderMaterial | null = null;
takePictures(scene, treeModels, createTreeMaterial(scene, treeLayers, { ...fog, ...treeRange, plain: true })).then((pictures) => {
  cardMaterial = createImpostorMaterial(scene, pictures, { ...fog, ...cardRange });
  forest.showCards(cardMaterial);
});

Die Texturen werden einmal erzeugt und gehen an beide Materialien. Die Modelle bekommen einen Namen, weil auch die Bilder sie brauchen. takePictures() dauert einen Moment, denn es wartet auf einen Shader und darauf, dass die Grafikkarte die Pixel zurückgibt: Das Spiel wartet nicht darauf. Bis das Promise eingelöst ist, gibt es kein Material für die Karten, und der Wald ist wie in Teil 9, nur kleiner. Dann erscheinen die Karten, alle auf einmal.

Die Reichweite der Karten beginnt, wo die der Meshes endet: from und full sind TREE_FADE und TREE_RANGE der Bäume. Zwischen 80 m und 95 m ist ein Baum ein Mesh, das Pixel verliert, und eine Karte, die welche gewinnt.

Unter Wasser brauchen auch die Karten den Nebel des Wassers, aber ihr Material ist vielleicht noch nicht da. Ersetze in dive() die Schleife:

src/main.ts
for (const lit of [material, farMaterial, blockMaterial, waterMaterial, grassMaterial, plantMaterial, treeMaterial, cardMaterial]) {
  if (lit) setFog(lit, under ? WATER_FOG.color : SKY, under ? WATER_FOG : fog);
}

Und das HUD zählt die Karten: Ergänze in seiner Zeile mit Gras, Pflanzen und Bäumen nach den Bäumen , ${forest.cards} as cards.

Ausprobieren

Drück F und flieg mit E nach oben. Die Wälder ziehen sich über die Hügel, lichten sich auf den Wiesen zu einzelnen Bäumen und enden an der Baumgrenze der Berge, und weit draußen sind sie dunkle Flecken auf dem Land. Flieg tief über einen Wald und beobachte die Bäume vor dir: Irgendwo um 90 m voraus werden aus Karten Meshes, und man muss suchen, um die Stelle zu finden. Drück N, um zum nächsten Biom zu fliegen: Die Kacheln um dich werden zuerst gepflanzt, und der Wald wächst von dort, wo du bist, nach außen.

Von hoch über dem Start: Wälder, Seen und Berge bis zum Horizont. Nur die nächsten Bäume sind Meshes; der Rest sind Karten, und die fernsten Wälder sind die Farbe des Bodens.
Wälder bis zum Horizont. Klick, dann: F fliegt, E hoch, Q runter, Shift schneller. N fliegt zum nächsten Biom, G zeigt die Karte. WASD geht, T gräbt, B baut.
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.