Biome und Vegetation auf Voxel-Terrain in Babylon.js · Teil 4 von 12 der Serie
Teil 4: Wasser
Füll das tiefe Land mit Wasser: ein Meeresspiegel, ein Ozean, in den der Boden absinkt, Seen in den Senken, eine Wasserfläche aus Ringen mit Wellen, gespiegeltem Himmel und Schaum, Strände aus Sand, eine Spielfigur, die schwimmt, und Nebel unter Wasser.
Biome und Vegetation auf Voxel-Terrain in Babylon.jsTeil 4 von 12
Auf dieser Seite
Quest-Ziele
- Dem Terrain einen Meeresspiegel, einen Ozean und Seen geben
- Höhlen unter dem Meer geschlossen halten und festlegen, wo Wasser steht
- Das Wasser als flaches Mesh aus Ringen bauen, das seine Tiefe kennt
- Einen Wasser-Shader mit Wellen, gespiegeltem Himmel, Glitzern und Schaum schreiben
- Strände und nasse Ufer im Shader des Terrains malen
- Die Spielfigur schwimmen lassen und die Sicht unter Wasser ausblenden
Das Land hat jetzt sechs Biome und eigene Formen, aber es ist trocken von einem Horizont zum anderen. Dieser Teil bringt Wasser: einen Meeresspiegel, einen Ozean, in den der Boden absinkt, Seen, wo die Hügel eine Senke lassen, Strände, eine Oberfläche mit Wellen, die den Himmel spiegelt, eine Spielfigur, die schwimmt, und Nebel unter Wasser.
Eines tut dieses Wasser nicht: fließen. Es steht dort, wo der Boden unter dem Meeresspiegel erzeugt wurde, und sonst nirgends. Das ist eine Regel, nach der das Terrain, die Shader und die Spielfigur fragen können, ohne dass jemand über irgendetwas Buch führt, und sie reicht erstaunlich weit: Ein Loch, am Strand gegraben, füllt sich mit Wasser, und eine Höhle tief unter einem Hügel bleibt trocken.
Das Meer im Terrain
Das Meer liegt auf Höhe 0. Das allein ergibt Seen: Wo immer das Land aus Teil 3 zwischen seinen Hügeln unter 0 sinkt, ist jetzt Wasser. Für ein richtiges Meer sagt ein weiteres Rauschen, wie sehr ein Ort offene See ist. Es ist 3,5 km breit, Meere und Kontinente sind also groß, und ein Smoothstep macht daraus eine Zahl, die an Land genau 0 ist, weit draußen 1 und entlang der Küste etwas dazwischen. Ergänze in src/terrain.ts über dem Kommentar zu den gemerkten Zahlen der Säule:
/** The height of the sea: ground below it lies under water. */
export const SEA = 0;
/** How deep the open sea is, in meters. */
const SEA_DEPTH = 45;
/** How much a place is open sea: 0 on land, 1 far out, and the coast in between. */
function ocean(x: number, z: number): number {
return smoothstep(0.35, 0.55, noise2(x / 3500 + 1.05, z / 3500 + 9.93));
}Die Zahlen, die zu x und z addiert werden, verschieben das Rauschen, wie beim Klima: Der Start liegt weit im Land, und die nächste offene See ist einige hundert Meter entfernt. Am Ende von column() sinkt der Boden:
// Out at sea the ground sinks to the sea's floor, which keeps a fifth of its ups and downs.
const sea = ocean(x, z);
if (sea > 0) columnHeight += (columnHeight * 0.2 - SEA_DEPTH - columnHeight) * sea;Weit draußen landet der Boden 45 m unter dem Meer, mit einem Fünftel der Hügel, die er hatte. An der Küste ist er auf dem Weg dorthin, was ein Ufer ergibt, das ins Wasser abfällt. Und weil der Smoothstep an Land genau 0 ist, ändert sich dort nichts: Der Boden um den Start ist noch der Boden der früheren Serien.
Höhlen unter dem Meer
Manche Höhlen brechen durch die Oberfläche. An Land ist das ein Eingang. Unter dem Meer wäre es ein Loch im Meeresboden mit Luft darunter, denn dieses Wasser fließt nicht. Unter dem Meer bleiben die Höhlen also nahe der Oberfläche geschlossen. Ersetze in density() die Zeilen der Höhlen:
// Caves: tunnels along the lines where two noises are both 0. Near the surface they
// narrow, so that only some of them break through. Under water none does: the top
// 10 m of the sea's floor stay shut, since the water wouldn't run into a cave.
const a = noise3(x / 100, y / 50, z / 100);
const b = noise3(x / 100 + 43.7, y / 50 - 11.3, z / 100 + 7.9);
const shut = smoothstep(SEA + 4, SEA, columnHeight);
const cave = (Math.hypot(a, b) - 0.09) * 50 + Math.max(4 - d, 0) * 0.6 + Math.max(10 - d, 0) * 2 * shut;
return Math.min(d, cave);shut ist 0, wo der Boden mehr als 4 m über dem Meer liegt, und 1, wo er darunter liegt. Es erhöht die Dichte der Höhle nahe der Oberfläche, um 20 ganz oben und um nichts mehr ab 10 m Tiefe, und das ist mehr, als irgendein Tunnel wegnimmt. Tiefer unten sind die Höhlen, wie sie waren.
Wo das Wasser steht
Die Regel vom Anfang dieses Teils, als Funktion. Ergänze am Ende von src/terrain.ts:
/** How far up a shore the water still stands in a hole dug there, in meters. */
export const SHORE = 1.5;
/**
* The height of the water at (x, z): the sea's, where the generated ground lies below it
* or just above, and none further inland, so that a cave below the sea's level stays dry.
*/
export function waterLevel(x: number, z: number): number {
return surfaceHeight(x, z) < SEA + SHORE ? SEA : -Infinity;
}Das Wasser steht, wo der erzeugte Boden unter dem Meer liegt oder weniger als 1,5 m darüber. Der erzeugte Boden, nicht der, den du gegraben hast: Er lässt sich überall ausrechnen, in einem Worker oder auf der Seite, ohne die Edits zu kennen. Die 1,5 m sind das Ufer. Dort ist das Wasser schon unter dem Sand, also hat ein Loch, das du am Strand gräbst, Wasser. Weiter im Land gibt es keines, und eine Höhle unter dem Meeresspiegel bleibt trocken. Der Preis: Auch ein Kanal, von einem See ins Land gegraben, bleibt jenseits dieses Streifens trocken.
Eine Fläche aus Ringen
Die Oberfläche des Wassers ist flach, ihr Mesh könnte also ein großes Quadrat sein. Aber der Shader wird wissen wollen, wie tief das Wasser an jedem Punkt ist, und das muss von den Vertices des Meshs kommen: Es braucht viele nahe der Kamera und wenige weit weg. Die Fernsicht der Terrain-Serie baut genau das schon, Ringe um die Kamera, die mit der Entfernung breiter werden. Also baut der Worker der Fernsicht auch das Wasser: dieselben Ringe, flach, und von der Kamera an statt erst ab 150 m.
Der Code, der die Ringe des Bodens gemacht hat, wird zu einer Funktion für eine beliebige Liste von Radien. Ersetze src/farWorker.ts:
import { climateAt } from './climate.ts';
import type { MeshData } from './meshData.ts';
import { SEA, surfaceHeight } from './terrain.ts';
/** The ground's rings go from INNER to OUTER meters around the center, each further one wider. */
export const INNER = 150;
export const OUTER = 4500;
const RINGS = 128;
const SEGMENTS = 256;
/** The far ground lies this much lower, so that the chunks win where both are drawn. */
const SINK = 1;
/** The water's rings start at the center: one point, then rings from WATER_INNER meters out. */
const WATER_RINGS = 96;
const WATER_INNER = 3;
export interface FarJob {
x: number;
z: number;
}
/** The far ground's mesh, with the climate at each vertex. */
export interface FarMesh extends MeshData {
climates: Float32Array;
}
/** The water's mesh, with how deep the water is at each vertex: below 0 over land. */
export interface WaterMesh extends MeshData {
depths: Float32Array;
}
export interface FarResult {
ground: FarMesh;
water: WaterMesh;
}
/** Radii from `inner` to OUTER, each a constant factor larger than the one before. */
function growing(inner: number, count: number): number[] {
const growth = (OUTER / inner) ** (1 / (count - 1));
return Array.from({ length: count }, (_, ring) => inner * growth ** ring);
}
/**
* A mesh of rings with the given radii around its own origin. `each` is called for every
* vertex with its place and its number, and returns its height.
*/
function ringMesh(radii: number[], each: (px: number, pz: number, vertex: number) => number): MeshData {
const rings = radii.length;
const positions = new Float32Array(rings * SEGMENTS * 3);
for (let ring = 0; ring < rings; ring += 1) {
for (let segment = 0; segment < SEGMENTS; segment += 1) {
const angle = (segment / SEGMENTS) * Math.PI * 2;
const px = Math.cos(angle) * radii[ring];
const pz = Math.sin(angle) * radii[ring];
const vertex = ring * SEGMENTS + segment;
positions.set([px, each(px, pz, vertex), pz], vertex * 3);
}
}
// Normals from the neighbors: across the ring outwards, and along it.
const at = (ring: number, segment: number, axis: number) =>
positions[(Math.min(Math.max(ring, 0), rings - 1) * SEGMENTS + ((segment + SEGMENTS) % SEGMENTS)) * 3 + axis];
const normals = new Float32Array(positions.length);
for (let ring = 0; ring < rings; ring += 1) {
for (let segment = 0; segment < SEGMENTS; segment += 1) {
const out = [0, 1, 2].map((axis) => at(ring + 1, segment, axis) - at(ring - 1, segment, axis));
const along = [0, 1, 2].map((axis) => at(ring, segment + 1, axis) - at(ring, segment - 1, axis));
// The cross product of the two, turned to point up.
let nx = out[1] * along[2] - out[2] * along[1];
let ny = out[2] * along[0] - out[0] * along[2];
let nz = out[0] * along[1] - out[1] * along[0];
if (ny < 0) [nx, ny, nz] = [-nx, -ny, -nz];
// A ring of radius 0 is one point, with no direction along it: straight up then.
const length = Math.hypot(nx, ny, nz);
normals.set(length > 0 ? [nx / length, ny / length, nz / length] : [0, 1, 0], (ring * SEGMENTS + segment) * 3);
}
}
// Two triangles between each ring and the next, segment by segment, split along the
// shorter diagonal as in the surface nets: the triangles then follow the ridges.
const distance = (a: number, b: number) =>
Math.hypot(
positions[a * 3] - positions[b * 3],
positions[a * 3 + 1] - positions[b * 3 + 1],
positions[a * 3 + 2] - positions[b * 3 + 2],
);
const indices = new Uint32Array((rings - 1) * SEGMENTS * 6);
let i = 0;
for (let ring = 0; ring < rings - 1; ring += 1) {
for (let segment = 0; segment < SEGMENTS; segment += 1) {
const a = ring * SEGMENTS + segment;
const b = ring * SEGMENTS + ((segment + 1) % SEGMENTS);
const c = a + SEGMENTS;
const d = b + SEGMENTS;
if (distance(a, d) <= distance(b, c)) indices.set([a, d, b, a, c, d], i);
else indices.set([a, c, b, b, c, d], i);
i += 6;
}
}
return { positions, normals, indices };
}
/** The far ground and the water around (x, z), positions from that point. */
self.onmessage = (event: MessageEvent<FarJob>) => {
const { x, z } = event.data;
// The ground: a heightfield of the generated heights.
const climates = new Float32Array(RINGS * SEGMENTS * 2);
const ground: FarMesh = {
...ringMesh(growing(INNER, RINGS), (px, pz, vertex) => {
const { temperature, moisture } = climateAt(x + px, z + pz);
climates.set([temperature, moisture], vertex * 2);
return surfaceHeight(x + px, z + pz) - SINK;
}),
climates,
};
// The water: a flat sheet at the height of the sea, which knows how deep it is.
const depths = new Float32Array(WATER_RINGS * SEGMENTS);
const water: WaterMesh = {
...ringMesh([0, ...growing(WATER_INNER, WATER_RINGS - 1)], (px, pz, vertex) => {
depths[vertex] = SEA - surfaceHeight(x + px, z + pz);
return SEA;
}),
depths,
};
const result: FarResult = { ground, water };
const arrays = [ground.positions, ground.normals, ground.indices, climates, water.positions, water.normals, water.indices, depths];
self.postMessage(result, { transfer: arrays.map((array) => array.buffer) });
};growing()macht Radien, von denen jeder um einen festen Faktor größer ist als der davor: die des Bodens, von 150 m bis zum Horizont, wie bisher.ringMesh()ist der alte Code, für die Radien, die er bekommt.eachgibt die Höhe eines Vertex zurück und bekommt dessen Nummer, damit der Aufrufer eigene Arrays füllen kann: die Klimata des Bodens, die Tiefen des Wassers.Der erste Ring des Wassers hat den Radius 0: Alle seine Vertices sind ein Punkt, die Mitte der Fläche. So ein Ring hat keine Richtung entlang seines Umfangs, also zeigen seine Normalen gerade nach oben.
Die Tiefe eines Vertex ist die Höhe des Meers minus die des erzeugten Bodens: über 0 im Wasser, unter 0 über Land.
Beide Meshes gehen in einer Nachricht zurück, sie zeigen also immer denselben Ort.
Die Fernsicht zeigt beide und zieht beide mit. Ersetze src/farView.ts:
import type { Material, Mesh, Scene, Vector3 } from '@babylonjs/core/pure';
import type { FarJob, FarResult } from './farWorker.ts';
import { createMesh } from './meshData.ts';
/** The far view moves along in steps of this many meters, and is built again each time. */
const STEP = 64;
/**
* The ground beyond the chunks, to the horizon: a heightfield of the generated heights.
* And the water, from the camera to the horizon, which is flat anyway.
*/
export class FarView {
private ground: Mesh | null = null;
private water: Mesh | null = null;
private center: FarJob | null = null;
private building: FarJob | null = null;
private readonly worker = new Worker(new URL('./farWorker.ts', import.meta.url), { type: 'module' });
private readonly scene: Scene;
private readonly material: Material;
private readonly waterMaterial: Material;
constructor(scene: Scene, material: Material, waterMaterial: Material) {
this.scene = scene;
this.material = material;
this.waterMaterial = waterMaterial;
this.worker.onmessage = (event: MessageEvent<FarResult>) => this.show(event.data);
}
get vertices(): number {
return this.ground?.getTotalVertices() ?? 0;
}
/** Once a frame: builds the far view again when the camera has moved a step. */
update(focus: Vector3): void {
const x = Math.round(focus.x / STEP) * STEP;
const z = Math.round(focus.z / STEP) * STEP;
if (this.building || (this.center?.x === x && this.center.z === z)) return;
this.building = { x, z };
this.worker.postMessage(this.building);
}
private show(data: FarResult): void {
this.ground?.dispose();
this.water?.dispose();
const ground = createMesh('far view', data.ground, this.scene);
// The far ground is all surface, under the open sky.
const count = data.ground.positions.length / 3;
ground.setVerticesData('depth', new Float32Array(count), false, 1);
ground.setVerticesData('light', new Float32Array(count).fill(1), false, 1);
ground.setVerticesData('climate', data.ground.climates, false, 2);
ground.material = this.material;
this.ground = ground;
const water = createMesh('water', data.water, this.scene);
water.setVerticesData('depth', data.water.depths, false, 1);
water.material = this.waterMaterial;
this.water = water;
for (const mesh of [ground, water]) {
mesh.position.set(this.building!.x, 0, this.building!.z);
mesh.isPickable = false;
mesh.freezeWorldMatrix();
}
this.center = this.building;
this.building = null;
}
}Der Shader des Wassers
Der Vertex-Shader reicht nur die Position und die Tiefe weiter. Erstelle src/water.vertex.glsl:
precision highp float;
attribute vec3 position;
attribute float depth;
uniform mat4 world;
uniform mat4 viewProjection;
varying vec3 vPosition;
varying float vDepth;
void main() {
vec4 worldPosition = world * vec4(position, 1.0);
vPosition = worldPosition.xyz;
vDepth = depth;
gl_Position = viewProjection * worldPosition;
}Wasser-Shader lesen gewöhnlich die Tiefe der Szene, um herauszufinden, wie viel Wasser zwischen der Oberfläche und dem Boden dahinter liegt, und das braucht einen zweiten Durchgang durch die Szene. Dieser hier bekommt die Tiefe mit dem Mesh, zwischen den Vertices gemischt, und braucht keinen solchen Durchgang. Es ist die Tiefe über dem erzeugten Boden, nicht über dem, was du gegraben hast, und das reicht. Erstelle src/water.fragment.glsl:
precision highp float;
varying vec3 vPosition;
varying float vDepth;
uniform vec3 cameraPosition;
uniform vec3 sunDirection;
uniform vec3 sunColor;
uniform vec3 skyColor;
uniform vec3 fogColor;
uniform vec2 fogRange;
uniform float time;
// How far up a shore the sheet of water reaches under the ground, as SHORE in terrain.ts.
const float SHORE = 1.5;
// Nearer than this, the sheet is cut away over land: caves below the sea stay dry.
const float CUT_RANGE = 300.0;
const vec3 SHALLOW = vec3(0.25, 0.62, 0.6);
const vec3 DEEP = vec3(0.04, 0.2, 0.36);
// The slope of the waves at a point: a few sine waves that run different ways.
vec2 waves(vec2 p) {
vec2 slope = vec2(0.0);
slope += vec2(0.8, 0.6) * cos(dot(p, vec2(0.8, 0.6)) * 0.9 + time * 1.4) * 0.05;
slope += vec2(-0.5, 0.86) * cos(dot(p, vec2(-0.5, 0.86)) * 1.7 + time * 1.9) * 0.04;
slope += vec2(0.3, -0.95) * cos(dot(p, vec2(0.3, -0.95)) * 3.1 + time * 2.6) * 0.03;
slope += vec2(-0.9, -0.4) * cos(dot(p, vec2(-0.9, -0.4)) * 0.23 + time * 0.7) * 0.03;
return slope;
}
void main() {
vec3 toCamera = cameraPosition - vPosition;
float distanceToCamera = length(toCamera);
if (vDepth < -SHORE && distanceToCamera < CUT_RANGE) discard;
toCamera /= distanceToCamera;
// Far away the waves are smaller than a pixel: they fade out, and the sea lies flat.
vec2 slope = waves(vPosition.xz) * (1.0 - smoothstep(60.0, 400.0, distanceToCamera));
vec3 normal = normalize(vec3(-slope.x, 1.0, -slope.y));
// Seen from below, the surface faces down.
if (toCamera.y < 0.0) normal = -normal;
// The water's own color, darker the deeper it is, and the sky it mirrors: more of the
// sky the flatter the look at it.
float depth = max(vDepth, 0.0);
vec3 body = mix(SHALLOW, DEEP, smoothstep(0.0, 9.0, depth)) * (skyColor + sunColor * 0.6);
float mirror = 0.03 + 0.97 * pow(1.0 - max(dot(normal, toCamera), 0.0), 5.0);
vec3 color = mix(body, fogColor, mirror);
// The sun glints where the surface mirrors it into the eye.
vec3 halfway = normalize(toCamera - sunDirection);
color += sunColor * pow(max(dot(normal, halfway), 0.0), 300.0);
// Foam where the water is ankle deep, in bands that run up the shore.
float foam = (1.0 - smoothstep(0.0, 0.35, depth)) * (0.6 + 0.4 * sin(depth * 30.0 + time * 2.0 + vPosition.x * 0.7));
color = mix(color, vec3(1.0), clamp(foam, 0.0, 1.0) * 0.7);
// Shallow water is clear, deep water is not, and a flat look sees only the mirror.
float alpha = max(mix(0.5, 0.94, smoothstep(0.0, 6.0, depth)), mirror);
// At the very edge it thins out to nothing.
alpha *= smoothstep(-0.05, 0.15, vDepth + foam * 0.1);
float fog = smoothstep(fogRange.x, fogRange.y, distanceToCamera);
gl_FragColor = vec4(mix(color, fogColor, fog), alpha);
}Über Land wird die Fläche weggeschnitten, um dieselben 1,5 m wie in
waterLevel(): Das hält sie aus Höhlen und Gruben heraus. Aber nur innerhalb von 300 m. Weiter draußen sind die Ringe zu breit, um einen kleinen See von seinen Ufern zu unterscheiden, und der Boden verdeckt die Fläche ohnehin, wo er höher ist.waves()addiert vier Sinuswellen, die in verschiedene Richtungen laufen, und gibt die Neigung der Oberfläche zurück, aus der die Normale wird. Ab 60 m verblassen die Wellen, und bei 400 m liegt das Meer flach: Wellen, kleiner als ein Pixel, würden nur flimmern.Die eigene Farbe des Wassers geht über 9 m Tiefe von einem hellen Grünblau zu einem dunklen Blau. Wie viel vom Himmel es spiegelt, hängt vom Winkel ab: 3 % beim Blick gerade nach unten, alles bei flachem Blick. Die Farbe des Himmels ist die des Nebels.
Die Sonne glitzert, wo die Oberfläche sie ins Auge spiegelt: Der Vektor auf halbem Weg, hoch potenziert, macht kleine helle Flecken auf den Wellen.
Wo das Wasser weniger als 35 cm tief ist, liegt Schaum, in Bändern, die das Ufer hinaufziehen.
Flaches Wasser ist halb durchsichtig, tiefes fast gar nicht, und ganz am Rand dünnt die Fläche zu nichts aus, sodass sie ohne harte Linie auf den Sand trifft.
Von unten gesehen wird die Normale umgedreht.
Das Material wird über das gemischt, was dahinter liegt, und ist von beiden Seiten zu sehen. Erstelle src/water.ts:
import { ShaderMaterial, type Scene } from '@babylonjs/core/pure';
import { LIGHT_UNIFORMS, setLight, type FogOptions } from './material.ts';
import fragmentSource from './water.fragment.glsl?raw';
import vertexSource from './water.vertex.glsl?raw';
/** The water's material: see-through, with waves that move with the `time` it is given. */
export function createWaterMaterial(scene: Scene, options: FogOptions): ShaderMaterial {
const material = new ShaderMaterial(
'water',
scene,
{ vertexSource, fragmentSource },
{
attributes: ['position', 'depth'],
uniforms: ['world', 'viewProjection', ...LIGHT_UNIFORMS, 'time'],
// Drawn after everything solid, and blended over it.
needAlphaBlending: true,
},
);
setLight(material, options);
material.setFloat('time', 0);
// The surface is also seen from below.
material.backFaceCulling = false;
return material;
}Nebel, der sich ändern kann
Unter Wasser wird die Sicht nach wenigen Metern enden. Dafür muss der Nebel eines Materials später neu gesetzt werden können. In src/material.ts werden die zwei Zeilen am Ende von setLight(), die den Nebel setzen, zu einer eigenen Funktion. Ersetze sie und die schließende Klammer:
setFog(material, SKY, options);
}
/** Sets the fog: its color, and where it starts and ends. */
export function setFog(material: ShaderMaterial, color: Color3, options: FogOptions): void {
material.setColor3('fogColor', color);
material.setVector2('fogRange', new Vector2(options.fogStart, options.fogEnd));
}Strände
Der Meeresboden und seine Ufer sind Sand, in jedem Biom. Der Shader des Terrains kann ohne neues Attribut sagen, wo das ist: vDepth ist, wie weit ein Punkt unter dem erzeugten Boden liegt, also ist die Höhe des Punkts plus vDepth die Höhe dieses Bodens. Ergänze in src/terrain.fragment.glsl zwei Konstanten nach SNOW:
const float SAND = 8.0;
// The height of the sea, as in terrain.ts.
const float SEA = 0.0;Nach der Schleife über die Biome, bevor die Farbe der Erde nachgeschlagen wird, übernimmt der Sand von den Decken der Biome:
// The sea's floor and its shore are sand, whatever the biome: where the ground was
// generated below the sea or just above it.
float ground = vPosition.y + vDepth;
float beach = 1.0 - smoothstep(SEA + 1.0, SEA + 2.5, ground);
if (cover > 0.0 && beach > 0.0) covered = mix(covered, triplanar(SAND, blend), beach);Der Sand ist von 1 m über dem Meer abwärts ganz da und verblasst bis 2,5 m hinauf. Und die Zeile, die den Schnee einmischt, bekommt Gesellschaft. Ersetze sie:
// No snow under water, and the shore is dark where the waves wet it.
snow *= smoothstep(SEA, SEA + 0.5, vPosition.y);
if (snow > 0.0) color = mix(color, triplanar(SNOW, blend), snow);
color *= mix(1.0, 0.65, beach * (1.0 - smoothstep(SEA + 0.1, SEA + 0.6, vPosition.y)));Die Fernsicht nutzt denselben Shader, also sind auch die fernen Ufer Sand.
Schwimmen
Die Spielfigur taucht nicht, sie treibt: In Wasser, das bis zum Kinn reicht, wird der Körper nach oben getragen, bis die Augen knapp über der Oberfläche sind, und bewegt sich langsamer. Importiere in src/player.ts waterLevel aus ./terrain.ts und ergänze die Konstanten:
const SWIM_SPEED = 3;
/** In water deeper than this the body floats, the eyes just above the surface. */
const FLOAT_DEPTH = 1.45;
/** How hard the water pushes a body up per meter it is too deep, and how much it slows it. */
const BUOYANCY = 14;
const DRAG = 5;Die Klasse bekommt nach grounded ein Feld swimming = false;. Ersetze in update() die Zeile, die das Tempo wählt:
// In water that reaches the chin, the body floats and swims.
const depth = waterLevel(this.position.x, this.position.z) - this.position.y;
this.swimming = depth > FLOAT_DEPTH;
const speed = this.swimming ? SWIM_SPEED : input.pressed('ShiftLeft') ? RUN_SPEED : WALK_SPEED;Und ersetze die Zeilen des Sprungs und der Schwerkraft:
if (this.swimming) {
// The water carries the body up to where it floats, and slows its rise and fall.
this.velocity.y += ((depth - FLOAT_DEPTH) * BUOYANCY - this.velocity.y * DRAG) * dt;
} else {
if (this.grounded && input.pressed('Space')) {
this.velocity.y = JUMP_SPEED;
this.grounded = false;
}
if (!this.grounded) this.velocity.y -= GRAVITY * dt;
}Das Wasser ist eine Feder mit Bremse: Es drückt umso stärker nach oben, je tiefer der Körper unter der Stelle ist, an der er treibt, und bremst, was immer der Körper an Tempo hat, nach oben wie nach unten. Ohne die Bremse würde die Spielfigur ewig auf und ab wippen. Ein Sprung von einer Klippe endet ein paar Meter unter Wasser, und der Körper kommt wieder hoch. Hinausgehen funktioniert von selbst: Wo der Boden ansteigt, trägt er die Füße.
Nicht ins Meer
Die Taste N soll nicht aufs Meer hinausfliegen. Importiere in src/travel.ts SEA aus ./terrain.ts und ersetze holds:
const holds = (px: number, pz: number) => {
const height = surfaceHeight(px, pz);
biomesAt(px, height, pz, weights);
// On dry land.
return weights[biome] > 0.98 && height > SEA + 2;
};Die Seite
Importiere in src/main.ts Color3 aus Babylon.js, setFog aus ./material.ts, waterLevel aus ./terrain.ts und createWaterMaterial aus ./water.ts. Die Fernsicht bekommt das Material des Wassers. Ersetze die Zeile, die sie erzeugt:
const waterMaterial = createWaterMaterial(scene, fog);
const farView = new FarView(scene, farMaterial, waterMaterial);Unter Wasser verblasst alles binnen 35 m in die Farbe des Wassers, und auch der Himmel hat diese Farbe. Ergänze vor travel():
// Under water, everything fades into the water's color within a few meters.
const WATER_FOG = { color: Color3.FromHexString('#1c5a72'), fogStart: 0, fogEnd: 35 };
let underWater = false;
/** Sets the fog of everything for a camera above or below the water. */
function dive(under: boolean): void {
underWater = under;
for (const lit of [material, farMaterial, blockMaterial, waterMaterial]) {
setFog(lit, under ? WATER_FOG.color : SKY, under ? WATER_FOG : fog);
}
scene.clearColor = (under ? WATER_FOG.color : SKY).toColor4();
}Einmal pro Frame bekommt das Wasser die Zeit für seine Wellen, und der Nebel wird umgeschaltet, wenn die Kamera durch die Oberfläche geht. Nach farView.update():
waterMaterial.setFloat('time', performance.now() / 1000);
const under = camera.position.y < waterLevel(camera.position.x, camera.position.z);
if (under !== underWater) dive(under);Und das HUD sagt, wenn die Spielfigur schwimmt. Ersetze in seiner zweiten Zeile den Teil fürs Gehen durch (player.swimming ? 'Swimming' : player.grounded ? 'Walking' : 'In the air').
Ausprobieren
Das nächste Wasser ist ein See etwa 200 m hinter dir: Dreh dich um und lauf, oder flieg mit F, um ihn von oben zu sehen. Geh den Strand hinunter ins Wasser. Der Sand ist dunkel, wo die Wellen ihn nass machen, der Schaum zieht das Ufer hinauf, und wenn dir das Wasser bis zum Kinn reicht, treibst du. Wechsle mit T zum Terrain-Werkzeug und grab ein Loch am Strand: Es steht Wasser darin. Grab eines etwas weiter oben auf der Wiese: Es bleibt trocken. Flieg dann und bring die Kamera unter die Oberfläche: Die Sicht zieht sich zu, und die Wasserfläche ist über dir.
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.
