Biome und Vegetation auf Voxel-Terrain in Babylon.js · Teil 2 von 12 der Serie
Teil 2: Boden für jedes Biom
Gib jedem Biom seinen eigenen Boden: fünf weitere in Code gemalte Texturen, von Laubstreu bis Sand, im Shader nach den Gewichten der Biome gemischt, eine Tönung für Erde und Fels jedes Bioms, und Schnee, der dort liegt, wo es kalt ist, statt über einer festen Höhe.
Biome und Vegetation auf Voxel-Terrain in Babylon.jsTeil 2 von 12
Auf dieser Seite
Quest-Ziele
- Fünf weitere Bodentexturen in Code malen und helle Farben am Überlaufen hindern
- Dem Shader sagen, welche Textur jedes Biom bedeckt
- Bedeckung und Tönung der Biome nach ihren Gewichten mischen
- Schnee nach der Temperatur fallen lassen, mit fleckigem Rand
Teil 1 hat jedem Ort die Gewichte von sechs Biomen gegeben und sie als Karte gemalt. Jetzt wählen die Gewichte den Boden selbst. Jedes Biom bekommt eine Textur, die seinen Boden dort bedeckt, wo die Wiese Gras hat: Laubstreu im Laubwald, Nadeln und Moos unter Nadelbäumen, niedrige olivgrüne Pflanzen in der Tundra, Stroh in der Savanne, Sand in der Wüste. Seine Erde und sein Fels bekommen eine Tönung. Und der Schnee, der bisher über 105 m liegt, wo immer das ist, folgt der Temperatur.
Farben, die überlaufen
Die neuen Texturen sind heller als die alten, und das bringt einen Fehler in einem Helfer der Terrain-Serie zum Vorschein. shade() multipliziert eine Farbe, und ein helles Strohgelb, um ein Drittel heller gemacht, hat mehr als 255 Rot. Die Texturen werden in ein Array aus Bytes gemalt, und ein Byte, das 266 bekommt, bleibt nicht bei 255 stehen: Es fängt wieder bei 0 an und enthält 10. Das Gelb verliert sein Rot und wird grün. Ersetze in src/textures.ts shade:
// Not above 255: a byte that overflows starts again at 0, which turns bright straw green.
export const shade = (color: Rgb, amount: number): Rgb => color.map((c) => Math.min(c * (1 + amount), 255)) as Rgb;Fünf weitere Texturen
Das Textur-Array bekommt fünf weitere Schichten. In src/textures.ts wird die Liste zu export const LAYERS = ['grass', 'soil', 'rock', 'snow', 'litter', 'needles', 'moss', 'straw', 'sand'] as const;. Die ersten vier behalten ihre Nummern, also findet der Shader Erde, Fels und Schnee dort, wo sie waren. Die Maler brauchen eigene Rauschen. Ergänze in PAINTERS nach snowPatches:
const litterPatches = layeredNoise(4, 8, 16);
const leaves = tilingNoise(40);
const needlePatches = layeredNoise(4, 8, 32);
const needles = tilingNoise(128, 24);
const mossPatches = layeredNoise(4, 8, 16, 32);
const lichen = tilingNoise(24);
const strawPatches = layeredNoise(4, 8, 16);
const stalks = tilingNoise(128, 16);
const sandPatches = layeredNoise(4, 8, 64);
const ripples = tilingNoise(3);Und die Maler selbst, nach dem für snow:
// The floor of a broadleaf forest: dark green, with last year's leaves on it.
litter: (u, v) => {
const color = mix(hex('#3a5a26'), hex('#5c5a2c'), litterPatches(u, v) + 0.5);
const leaf = leaves(u, v);
return leaf > 0.45 ? mix(color, hex('#96703a'), (leaf - 0.45) * 4) : shade(color, blades(u, v) * 0.4);
},
// Under conifers: brown needles, all lying one way, and cushions of moss.
needles: (u, v) => {
const color = shade(mix(hex('#4f3a26'), hex('#6e5334'), needlePatches(u, v) + 0.5), needles(u, v) * 0.35);
const moss = needlePatches(v, u);
return moss > 0.12 ? mix(color, hex('#4d6d33'), Math.min((moss - 0.12) * 6, 0.85)) : color;
},
// Tundra: low, olive plants, pale lichen and a few stones.
moss: (u, v) => {
const color = mix(hex('#5d6238'), hex('#8a8250'), mossPatches(u, v) + 0.5);
const spot = lichen(u, v);
if (spot > 0.5) return mix(color, hex('#c2c4a4'), (spot - 0.5) * 3);
return pebbles(v, u) > 0.6 ? hex('#7d7a80') : color;
},
// Savanna: dry stalks, with the earth showing through.
straw: (u, v) => {
const patch = strawPatches(u, v);
const color = shade(mix(hex('#a48a42'), hex('#cdb561'), patch + 0.5), stalks(u, v) * 0.4);
return patch < -0.22 ? mix(color, hex('#8f6b43'), Math.min((-0.22 - patch) * 6, 0.8)) : color;
},
// Sand, with ripples the wind made: stripes across the texture, bent by noise.
sand: (u, v) => {
const color = mix(hex('#d6b477'), hex('#ecd29a'), sandPatches(u, v) + 0.5);
return shade(color, Math.sin((v * 14 + ripples(u, v) * 1.5) * Math.PI * 2) * 0.05);
},Sie nutzen die Tricks der ersten vier, mit ein paar neuen:
Litter, die Laubstreu, ist fleckig dunkelgrün und vom Rauschen der Grashalme schattiert. Wo ein zweites Rauschen hoch ist, liegt ein braunes Blatt.
Needles, die Nadeln, sind von einem Rauschen schattiert, das 128 Zellen breit und nur 24 hoch ist: Seine Flecken sind Striche, die alle in eine Richtung liegen. Die Moospolster lesen das Rauschen der Flecken noch einmal mit vertauschtem u und v, was ein zweites Muster umsonst ergibt.
Moss, der Boden der Tundra, hat blasse Flechtenflecken und ein paar Steine aus dem Kieselrauschen der Erde.
Straw, das Stroh, ist wie die Nadeln von Halmen schattiert, und wo seine Flecken am dunkelsten sind, scheint die Erde durch.
Sand hat Rippeln: eine Sinuswelle die Textur hinauf, 14-mal, von einem groben Rauschen verbogen. Eine ganze Zahl von Wellen, damit die Textur weiter nahtlos kachelt.
Was jedes Biom bedeckt
Die Biome sagen, welche Schicht ihre ist. Ersetze in src/climate.ts die Liste der Biome:
/**
* The biomes, each with the climate it is at home in and a color for the map. A place
* belongs to the biome whose climate is nearest to its own. `ground` is the texture that
* covers its ground, and `tint` colors its soil and rock.
*/
export const BIOMES = [
{ name: 'Meadow', temperature: 0.5, moisture: 0.4, color: '#7fae3c', ground: 'grass', tint: '#ffffff' },
{ name: 'Broadleaf forest', temperature: 0.52, moisture: 0.76, color: '#3c7a2a', ground: 'litter', tint: '#f2f0e6' },
{ name: 'Conifer forest', temperature: 0.3, moisture: 0.62, color: '#28584a', ground: 'needles', tint: '#e6e8f2' },
{ name: 'Tundra', temperature: 0.1, moisture: 0.45, color: '#c3ccd6', ground: 'moss', tint: '#dfe6f5' },
{ name: 'Savanna', temperature: 0.76, moisture: 0.5, color: '#c9a545', ground: 'straw', tint: '#ffd9b0' },
{ name: 'Desert', temperature: 0.86, moisture: 0.14, color: '#e8bd7c', ground: 'sand', tint: '#ffc08a' },
] as const;Die Tönungen sind fast weiß: Sie werden mit den Farben der Erde und des Felsens multipliziert. Die der Savanne und der Wüste sind warm, was grauen Fels rötlich und braune Erde sandig macht; die der kalten Biome sind ein wenig blau. Eine Felstextur genügt für alle sechs.
Der Shader bekommt beides als Uniforms, wie die Kartenfarben. Ergänze in src/material.ts 'biomeGrounds' und 'biomeTints' in der Liste der Uniforms in createTerrainMaterial() und ersetze die Zeilen, die die Uniforms der Biome setzen:
// 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()));
// What covers each biome's ground, as the number of its layer, and the tint of its rock.
material.setFloats('biomeGrounds', BIOMES.map((biome) => LAYERS.indexOf(biome.ground)));
material.setArray3('biomeTints', BIOMES.flatMap((biome) => Color3.FromHexString(biome.tint).asArray()));
material.setFloat('mapView', 0);Eine Schicht geht als ihre Nummer in LAYERS an den Shader, und die Karte ist von nun an aus. Auch in src/main.ts beginnt sie ausgeschaltet: let mapView = false;.
Den Boden mischen
Ergänze in src/terrain.fragment.glsl nach dem Uniform biomeColors:
// The layer that covers each biome's ground, and the tint of its soil and rock.
uniform float biomeGrounds[BIOMES];
uniform vec3 biomeTints[BIOMES];Die Schicht für Gras hat keine Konstante mehr: Sie ist die Bedeckung der Wiese und kommt wie die anderen durch das Uniform herein. Ersetze die vier Konstanten der Schichten:
// The layers of the texture array that every biome shares.
const float SOIL = 1.0;
const float ROCK = 2.0;
const float SNOW = 3.0;
// Below this temperature snow lies, and this much colder it covers everything.
const float SNOW_LINE = 0.12;
const float SNOW_BAND = 0.07;Ersetze in main() alles vom Kommentar über Gras auf sanften Hängen bis zu der Zeile, die die Karte einmischt, beide eingeschlossen:
// The biomes of this spot, from its climate: the higher up, the colder.
float temperature = vClimate.x - max(vPosition.y, 0.0) * COOLING;
float biomes[BIOMES];
biomeWeights(vec2(temperature, vClimate.y), biomes);
// Each biome's cover on gentle slopes at the surface, rock on steep ones and deeper
// down, soil between them. Where biomes meet, their covers and tints blend.
float flat_ = normal.y;
float cover = smoothstep(0.7, 0.85, flat_) * (1.0 - smoothstep(0.5, 2.0, vDepth));
float rock = max(1.0 - smoothstep(0.45, 0.7, flat_), smoothstep(3.0, 6.0, vDepth));
vec3 covered = vec3(0.0);
vec3 tint = vec3(0.0);
vec3 mapColor = vec3(0.0);
for (int i = 0; i < BIOMES; i += 1) {
if (biomes[i] <= 0.0) continue;
if (cover > 0.0) covered += triplanar(biomeGrounds[i], blend) * biomes[i];
tint += biomeTints[i] * biomes[i];
mapColor += biomeColors[i] * biomes[i];
}
vec3 color = triplanar(SOIL, blend) * tint;
if (cover > 0.0) color = mix(color, covered, cover);
if (rock > 0.0) color = mix(color, triplanar(ROCK, blend) * tint, rock);
// Snow where it is cold, on ground flat enough to hold it. The rock's texture,
// stretched over 150 m, makes its edge patchy.
float patches = (texture(layers, vec3(vPosition.xz / 150.0, ROCK)).r - 0.5) * 0.2;
float snow = smoothstep(SNOW_LINE, SNOW_LINE - SNOW_BAND, temperature + patches) * smoothstep(0.55, 0.75, flat_);
if (snow > 0.0) color = mix(color, triplanar(SNOW, blend), snow);
// On the map, the textures only shade the color a little.
color = mix(color, mapColor * (0.5 + color.g), mapView);Die Gewichte werden jetzt zuerst ausgerechnet, weil alles von ihnen abhängt.
coverist, wasgrasswar: sanfte Hänge an der Oberfläche. Was dort liegt, ist die Schicht jedes Bioms mal sein Gewicht. Ein Biom ohne Gewicht wird übersprungen, also liest der Shader tief in einem Biom eine Textur, wie bisher, und nur in den Streifen entlang der Grenzen zwei oder drei.Die Tönung wird genauso gemischt und färbt die Erde und den Fels.
Der Schnee liegt dort, wo die Temperatur, von der Höhe abgekühlt, unter
SNOW_LINEist, und bedecktSNOW_BANDdarunter alles. Ein gerader Rand sähe gemalt aus, also verschiebt ein Rauschen die Grenze ein wenig: das Rot der Felstextur, mit einer Wiederholung pro 150 m gelesen, was einen weiteren Zugriff kostet und keine neue Textur.Die Karte kommt zuletzt und funktioniert weiterhin.
Auf einem Berg in der Wiese beginnt der Schnee etwa hundert Meter weiter oben, wie bisher. In der Savanne beginnt er viel höher, und die kalte Mitte der Tundra ist bis in die Ebene hinunter weiß. Die Fernsicht braucht gar keine Änderung: Sie nutzt denselben Shader und dieselben Attribute, also ist auch das Land bis zum Horizont nach seinen Biomen gefärbt.
Ausprobieren
Flieg mit N von Biom zu Biom und schau dir den Boden von jedem an: den dunklen Boden des Laubwalds mit seinen Blättern, die Nadeln und das Moos, die Tundra mit Schneeflecken, das Stroh, den Sand. Lande mit F und geh über eine Grenze: Ein Boden geht innerhalb weniger Schritte in den anderen über. Such einen steilen Hang in der Wüste und einen in der Tundra und vergleich ihren Fels. Steig mit E auf und schau auf den Schnee der Berge: Er reicht tiefer hinunter, wo das Land kalt ist. G zeigt weiterhin die Karte, um nachzusehen, welches Biom welches ist.
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.
