Zum Inhalt springen

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

Teil 11: Wind

Bring alles, was wächst, mit einem Wind in Bewegung: Böen, die als Wellen über das Land ziehen, einmal in GLSL geschrieben, von vier Vertex-Shadern geteilt. Gras biegt sich, Blumen nicken, Bäume neigen sich, wippen und flattern, ferne Karten wiegen sich mit, und ein Rauschen macht ihn hörbar.

Quest-Ziele

  • Böen als Wellen schreiben, die mit dem Wind ziehen
  • Ein Stück GLSL zwischen mehreren Shadern teilen
  • Gras und Pflanzen danach biegen, wie hoch ein Vertex ist
  • Einen Baum im Vertex-Shader neigen, seine Äste wippen und seine Blätter zittern lassen
  • Die fernen Karten im Takt mit den Meshes halten
  • Das Geräusch des Winds aus gefiltertem Rauschen machen

Die Welt aus Teil 10 ist voller Pflanzen, und keine davon bewegt sich. Dieser Teil bringt den Wind. Simuliert wird dafür nichts: Jeder Vertex jedes Halms, jeder Blume, jedes Baums und jeder Karte wird im Vertex-Shader ein wenig verschoben, von einer Funktion dessen, wo die Pflanze steht und wie spät es ist. Die Grafikkarte rechnet das in jedem Frame für alle aus, und die Seite tut nichts, als den Shadern die Zeit zu sagen.

Böen

Wind, der alles gleich schöbe, sähe aus, als wackelte die Kamera. Was eine Wiese windig aussehen lässt, ist, dass der Wind in Böen kommt: Ein Fleck Gras verneigt sich, und die Verneigung läuft weiter über das Feld. Eine Böe ist eine Welle, die mit dem Wind zieht. Erstelle src/wind.glsl:

src/wind.glsl
// The seconds since the start, and the wind: which way it blows along the ground, in x
// and y, and how hard, from 0 to 1, in z.
uniform float time;
uniform vec3 wind;

// How hard the wind blows at a place right now, from 0 to 1. Gusts are waves that travel
// with the wind: a long one that bends as it goes, and a short one on top.
float gust(vec2 place) {
  float along = dot(place, wind.xy);
  float across = dot(place, vec2(-wind.y, wind.x));
  float swell = sin(along * 0.05 - time * 0.9 + sin(across * 0.03) * 2.0) * 0.5 + 0.5;
  float ripple = sin(along * 0.31 - time * 2.3 + across * 0.17) * 0.5 + 0.5;
  return (swell * 0.7 + ripple * 0.3) * wind.z;
}

// How far the wind pushes something that stands at `place`, in meters per meter of its
// height: a lean with the wind, and a flutter of its own, which `phase` keeps from being
// the same for everything.
vec3 push(vec2 place, float phase) {
  float flutter = sin(time * 3.1 + phase * 6.2832) * 0.25;
  return vec3(wind.x, 0.0, wind.y) * gust(place) * (1.0 + flutter);
}
  • gust() misst einen Ort zuerst entlang des Winds und quer dazu. Ein Sinus von along minus der Zeit ist eine Reihe von Wellenfronten, die mit dem Wind ziehen. Die Dünung (swell) ist die lange Welle: eine Front etwa alle 125 m, mit 18 m/s unterwegs. Der Sinus von across darin biegt die Fronten, damit sie nicht als gerade Linien über das Land ziehen.

  • Das Kräuseln (ripple) ist eine kurze Welle darauf, eine Front alle 20 m, langsamer und schräg. Zusammen geben sie einem Ort alle paar Sekunden einen starken Zug und dazwischen einen kleinen.

  • push() macht aus der Böe einen Schub entlang des Winds. Das Flattern lässt eine Pflanze zusätzlich zu ihrer Neigung ein wenig hin und her schwingen, und phase verhindert, dass zwei Pflanzen nebeneinander im Takt schwingen.

Was push() zurückgibt, sind Meter Schub pro Meter Höhe. Jeder Shader entscheidet, was er damit tut.

Ein Wind für vier Shader

Vier Vertex-Shader brauchen diese Funktionen: der des Grases, der der Pflanzen, der der Bäume und der der Karten. Sie viermal zu kopieren hieße, vier Stellen ändern zu müssen. GLSL kann keine Datei einbinden, aber die Shader sind Strings, bevor sie Babylon.js erreichen, und einen String kann man in einen String setzen. Jeder Shader bekommt eine Zeile #include<wind>, und eine kleine Funktion ersetzt diese Zeile durch die Datei. Erstelle src/wind.ts:

src/wind.ts
import { Vector3, type ShaderMaterial } from '@babylonjs/core/pure';
import source from './wind.glsl?raw';

/** Which way the wind blows, along x and z. */
const DIRECTION = [0.8, 0.6];

/** Puts the wind's uniforms and functions into a shader, in place of its line `#include<wind>`. */
export const withWind = (shader: string) => shader.replace('#include<wind>', source);

/** The names of the wind's uniforms, for the list a material is made with. */
export const WIND_UNIFORMS = ['time', 'wind'];

/** How hard the wind blows at `seconds`, from 0 to 1: it rises and falls over minutes. */
export function windStrength(seconds: number): number {
  return 0.45 + 0.25 * Math.sin(seconds * 0.07) + 0.15 * Math.sin(seconds * 0.023 + 2);
}

/** Tells materials the time and the wind. */
export function setWind(materials: (ShaderMaterial | null)[], seconds: number): void {
  const wind = new Vector3(DIRECTION[0], DIRECTION[1], windStrength(seconds));
  for (const material of materials) {
    material?.setFloat('time', seconds);
    material?.setVector3('wind', wind);
  }
}

/** How hard the wind blows at a place at `seconds`: gust() of wind.glsl, for the sound. */
export function gustAt(x: number, z: number, seconds: number): number {
  const along = x * DIRECTION[0] + z * DIRECTION[1];
  const across = -x * DIRECTION[1] + z * DIRECTION[0];
  const swell = Math.sin(along * 0.05 - seconds * 0.9 + Math.sin(across * 0.03) * 2) * 0.5 + 0.5;
  const ripple = Math.sin(along * 0.31 - seconds * 2.3 + across * 0.17) * 0.5 + 0.5;
  return (swell * 0.7 + ripple * 0.3) * windStrength(seconds);
}
  • withWind() ist diese Funktion: Jedes Material reicht seinen Vertex-Shader durch sie.

  • windStrength() lässt den Wind an- und abschwellen: Zwei langsame Sinusse, einer über anderthalb Minuten und einer über viereinhalb, halten ihn zwischen einem Hauch und einer steifen Brise.

  • setWind() sagt einer Liste von Materialien die Zeit und den Wind, einmal pro Frame.

  • gustAt() ist noch einmal gust(), in TypeScript: Das Geräusch muss wissen, wie stark es dort weht, wo die Kamera ist.

Gras

Ein Halm ist an seiner Wurzel fest und an seiner Spitze frei, und er biegt sich umso mehr, je weiter oben er ist. Der Shader weiß schon, wie weit oben ein Vertex ist: blade.x, 0 an der Wurzel und 1 an der Spitze. Quadriert lässt das die untere Hälfte des Halms fast ruhig und biegt die Spitze. Ein gebogener Halm ist außerdem niedriger als ein gerader, also geht der Vertex um einen Teil dessen nach unten, was er zur Seite geht: Sonst würde sich das Gras im Wind strecken, statt sich zu verneigen. Ersetze src/grass.vertex.glsl:

src/grass.vertex.glsl
precision highp float;

// A vertex of the tuft, and where along its blade it is: x from 0 at the root to 1 at
// the tip, y the blade's own shade.
attribute vec3 position;
attribute vec2 blade;
// The tuft, one for every instance: its place from the chunk's corner and its size,
// then its turn, its light, its tone and a random number.
attribute vec4 place;
attribute vec4 look;

uniform mat4 world;
uniform mat4 viewProjection;
uniform vec3 cameraPosition;
// Where the grass starts to shrink away, and where it is gone, in meters from the camera.
uniform vec2 grassRange;

#include<wind>

varying vec3 vPosition;
varying vec2 vBlade;
varying float vLight;
varying float vTone;

void main() {
  vec3 root = (world * vec4(place.xyz, 1.0)).xyz;
  // Toward the edge of its range the grass shrinks into the ground.
  float size = place.w * (1.0 - smoothstep(grassRange.x, grassRange.y, distance(root, cameraPosition)));
  float c = cos(look.x);
  float s = sin(look.x);
  vec3 turned = vec3(position.x * c - position.z * s, position.y, position.x * s + position.z * c);
  vPosition = root + turned * size;
  // The wind bends a blade more the higher up it is, and a bent blade is lower.
  float bend = blade.x * blade.x * size;
  vec3 pushed = push(root.xz, look.w) * bend * 0.8;
  vPosition += pushed - vec3(0.0, length(pushed) * 0.4, 0.0);
  vBlade = blade;
  vLight = look.y;
  vTone = look.z;
  gl_Position = viewProjection * vec4(vPosition, 1.0);
}

Die Zufallszahl des Büschels, look.w, ist die Phase seines Flatterns. Importiere in src/grass.ts WIND_UNIFORMS und withWind aus ./wind.ts. In createGrassMaterial() geht der Vertex-Shader durch withWind(), und die Uniforms des Winds kommen in die Liste. Ersetze den Aufruf, der das Material erzeugt:

src/grass.ts
const material = new ShaderMaterial(
  'grass',
  scene,
  { vertexSource: withWind(vertexSource), fragmentSource },
  {
    attributes: ['position', 'blade', 'place', 'look'],
    uniforms: ['world', 'viewProjection', ...LIGHT_UNIFORMS, ...WIND_UNIFORMS, 'grassRange', 'lushRoot', 'lushTip', 'dryRoot', 'dryTip'],
  },
);

Pflanzen

Die kleinen Pflanzen sind Karten, und eine Karte hat keine Halme, aber sie hat uv.y: 0 am Boden und 1 am oberen Rand des Sprites. Ergänze in src/plant.vertex.glsl die Zeile #include<wind> nach dem Uniform plantRange und ersetze die Zeile, die vPosition setzt:

src/plant.vertex.glsl
vPosition = root + turned * size;
// The wind moves the top of a plant, not its foot.
vPosition += push(root.xz, look.w) * uv.y * uv.y * size * 0.35;

Ein Farn bewegt sich weniger als Gras derselben Höhe: Sein Schub wird mit 0,35 skaliert, der des Grases mit 0,8. Mach in src/plants.ts dieselben drei Änderungen wie beim Gras: den Import, vertexSource: withWind(vertexSource) in createPlantMaterial() und ...WIND_UNIFORMS in der Liste der Uniforms nach ...LIGHT_UNIFORMS.

Bäume

Ein Baum bewegt sich auf drei Arten zugleich, und der Shader unterscheidet sie nach dem, was er über einen Vertex weiß:

  • Der ganze Baum neigt sich mit dem Wind, umso mehr, je weiter oben: nach der Höhe des Vertex, quadriert, wie beim Gras. Der Fuß des Stamms bleibt, wo er ist.

  • Die Äste wippen auf und ab, umso mehr, je weiter außen: nach dem Abstand des Vertex von der Achse des Stamms. Auch die Phase des Sinus wächst mit diesem Abstand, sodass sich ein Ast wie eine Peitsche bewegt, nicht wie ein Brett.

  • Die Blätter flattern: nur Vertices, deren Texturebene eine von Blättern ist, jeder ein paar Zentimeter in seine eigene Richtung und in seinem eigenen Tempo.

Alle drei wachsen mit der Stärke der Böe am Baum, und look.w, die Zufallszahl des Baums, versetzt sie gegen den Baum daneben. Ersetze src/tree.vertex.glsl:

src/tree.vertex.glsl
precision highp float;

attribute vec3 position;
attribute vec3 normal;
// Where on its texture the vertex is, the texture's layer, and the vertex's shade.
attribute vec4 paint;
// The tree, one for every instance: its place and its size, then its turn and three
// numbers of its own.
attribute vec4 place;
attribute vec4 look;

uniform mat4 world;
uniform mat4 viewProjection;
uniform vec3 cameraPosition;
// Where the trees start to fade out, and where they are gone, in meters from the camera.
uniform vec2 treeRange;
// The number of the first layer that holds leaves.
uniform float firstLeaves;

#include<wind>

varying vec3 vPosition;
varying vec3 vNormal;
varying vec4 vPaint;
varying float vFade;

void main() {
  // Turned about its trunk, sized, and put in its place.
  float c = cos(look.x);
  float s = sin(look.x);
  mat3 turn = mat3(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c);
  vec3 local = turn * position * place.w;
  // The wind leans the whole tree, more the higher up, bobs its limbs, more the further
  // out, and shakes its leaves. No two trees move in step: look.w differs.
  vec3 blown = push(place.xz, look.w);
  float height = local.y * 0.07;
  float out_ = length(local.xz);
  local += blown * height * height * 0.6;
  local.y += sin(time * 1.7 + look.w * 40.0 + out_) * out_ * 0.03 * length(blown);
  if (paint.z >= firstLeaves - 0.5) {
    local += sin(time * vec3(5.3, 4.1, 4.7) + position.yzx * 3.0 + look.w * 20.0) * 0.05 * length(blown);
  }
  vec4 worldPosition = world * vec4(place.xyz + local, 1.0);
  vPosition = worldPosition.xyz;
  vNormal = mat3(world) * (turn * normal);
  vPaint = paint;
  // The whole tree fades as one: by how far its foot is from the camera.
  vec3 foot = (world * vec4(place.xyz, 1.0)).xyz;
  vFade = 1.0 - smoothstep(treeRange.x, treeRange.y, distance(foot.xz, cameraPosition.xz));
  gl_Position = viewProjection * worldPosition;
}

Das Uniform firstLeaves, das der Fragment-Shader seit Teil 8 hat, ist jetzt auch im Vertex-Shader deklariert: Das Material setzt es einmal für beide. Mach in src/treeMaterial.ts wieder die drei Änderungen: den Import, vertexSource: withWind(vertexSource) und ...WIND_UNIFORMS nach ...LIGHT_UNIFORMS.

Das schlichte Material, mit dem die Bilder aus Teil 10 gemacht werden, entsteht in derselben Funktion und bekommt den Code des Winds auch. Aber niemand sagt ihm die Zeit oder den Wind, und ein Uniform, das nie gesetzt wurde, ist 0: Für ihre Bilder stehen die Bäume still.

Karten

Wenn sich die Meshes wiegten und die Karten nicht, sähe man die Linie 90 m vor der Kamera, an der das eine zum anderen wird, sofort. Eine Karte kann ihre Äste nicht wippen und ihre Blätter nicht zittern lassen, aber sie kann sich neigen. Ergänze in src/impostor.vertex.glsl die Zeile #include<wind> nach dem Uniform cardRange und ersetze die Zeile, die vPosition setzt:

src/impostor.vertex.glsl
vPosition = position + right * card.x + vec3(0.0, card.y, 0.0);
// The top of the card sways as the tree's top does.
float height = card.y * 0.07;
vPosition += push(position.xz, layer * 0.37 + position.x * 0.13) * height * height * 0.6;

Die Neigung ist die des Baum-Shaders, Zahl für Zahl: derselbe Anteil der Höhe, quadriert, mal dieselben 0,6. Eine Karte hat keine eigene Zufallszahl, also wird die Phase aus ihrer Ebene und ihrem Ort gemacht. Mach in src/impostors.ts die drei Änderungen in createImpostorMaterial().

Das Geräusch des Winds

Die Bau-Serie hat ihre dumpfen Schläge und ihr Knacken aus einer Sekunde weißem Rauschen gemacht. Wind ist auch dieses Rauschen, ohne Ende gespielt, von dem nur die mittleren Tonhöhen durchgelassen werden, und lauter, wenn eine Böe vorbeizieht. Ergänze in src/sounds.ts ein Feld der Klasse Sounds: private windGain: GainNode | null = null;. Ergänze in start() nach der Schleife, die das Rauschen füllt:

src/sounds.ts
// The wind: the noise in a loop, with only its middle pitches let through.
const source = this.context.createBufferSource();
source.buffer = this.noise;
source.loop = true;
const filter = this.context.createBiquadFilter();
filter.type = 'bandpass';
filter.frequency.value = 350;
filter.Q.value = 0.4;
this.windGain = this.context.createGain();
this.windGain.gain.value = 0;
source.connect(filter).connect(this.windGain).connect(this.context.destination);
source.start();

Die Quelle spielt den Buffer in einer Schleife. Der Bandpass um 350 Hz, mit einem niedrigen Q, das ihn breit macht, macht aus dem Zischen ein Rauschen wie von Wind. Die Lautstärke beginnt bei 0: Der Wind ist still, bis jemand sagt, wie stark er weht. Ergänze die Methode, die das tut:

src/sounds.ts
/** Makes the wind as loud as it blows at the camera right now, from 0 to 1. */
wind(strength: number): void {
  // Not at once: the loudness follows over a third of a second.
  this.windGain?.gain.setTargetAtTime(strength * 0.25, this.context!.currentTime, 0.3);
}

setTargetAtTime() bewegt die Lautstärke über eine Drittelsekunde zu ihrem neuen Wert. Von einem Frame zum nächsten gesetzt, würde sie knistern.

Zusammensetzen

Importiere in src/main.ts gustAt und setWind aus ./wind.ts. Ersetze in der Funktion des Frames die Zeile, die dem Wasser die Zeit sagt:

src/main.ts
const seconds = performance.now() / 1000;
waterMaterial.setFloat('time', seconds);
// The same wind for everything that grows, and its sound where the camera is.
setWind([grassMaterial, plantMaterial, treeMaterial, cardMaterial], seconds);
sounds.wind(gustAt(camera.position.x, camera.position.z, seconds));

Das Material der Karten steht in der Liste, obwohl es null ist, bis die Bilder gemacht sind: setWind() überspringt, was noch nicht da ist. Das Geräusch ist so laut wie die Böe an der Kamera: Du hörst eine Böe ankommen, wenn sich das Gras um dich verneigt.

Ausprobieren

Stell dich auf die Wiese und schau über sie: Die Böen kommen als Wellen im Gras über den Hügel, ziehen an dir vorbei und laufen weiter. Warte eine Minute oder zwei: Der Wind lässt nach, bis das Gras nur noch zittert, und frischt dann wieder auf. Geh unter eine Eiche und schau hinauf in ihre Krone, wo die Äste wippen und die Blätter zittern. Flieg dann mit F nach oben und schau einen Wald von fern an: Dieselben Wellen laufen über die Karten. Drück N, um das hohe Gras der Savanne im Wind zu sehen, wo es am besten zur Geltung kommt.

Wind. Klick, dann: Stell dich ins Gras und sieh den Böen zu, mit Ton. WASD geht, F fliegt (Q/E runter/hoch), N fliegt zum nächsten Biom, G zeigt die Karte.
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.