# TundraShape
The ground of a planned tundra as pure functions of the plan: eval(plan, x, z) answers height, surface and zone; height, surface, zone, top (the lake's ice sheet counted) and land. Snow fills over rolling land to the snow depth, frost-shattered rock pokes through, the wind carves sastrugi, and the lake basin, coast, ice shelf cliff, glacier and pressure ridges are cut in. The Tundra's TerrainStream streams from it; TundraSite and TundraScatter ask it.
# TundraRender
Draws a tundra's placed props as hardware-instanced draws, one per prop part per level of detail, re-sorting every instance into its level by distance from the camera as it moves, with draw bands per arcticProps category (ice, snow, rock, structure, remains, plant) scaled by quality. Adapted from forestKit's ForestRender (MIT) so arcticKit does not need forestKit installed. TundraBuilder calls it; only drawing changes with distance, colliders never move.
# TundraScatter
Places every prop of a planned tundra: jittered grids with rules by surface and zone (dwarf willow, cottongrass, moss, flowers, boulders, rock piles, drifts, sastrugi), plus pressure ridge slabs and rubble, the ice shelf cliff and brash ice in the lead, seracs at the glacier front, driftwood and bones on the shore, bamboo flag stakes along the route and each stop's props. place(plan) answers the list, fingerprint(list) an 8 digit hex code (equal codes, equal tundras), counts(list).
# TundraTypes
The five landscapes arcticKit builds, as recipes: lakeBasin, iceShelfCoast, pressureField, openTundra and glacierFront. A recipe names the relief, rock and scrub amounts, wind strength, the lake, coast, ice shelf, glacier, where pressure ridges run and the lookout headland. TundraTypes.get(name), valid(name), NAMES and the DENSITY scale. TundraLayout reads it.
# ArcticLook
The world-wide arctic look, shared by every player: `get()` answers `realistic`, `painted`, `cartoon`, `lowpoly` or `pixel` (realistic until someone sets another), `set(look)` changes it for every peer and every late joiner, and `onChanged(fn)` calls `fn(look)` on each change and returns a disconnect function. `ArcticMaterials.get(surface)` with no look follows it. The state is one synced entity carrying `ArcticLookState`, created on demand by the first `set`; a peer that does not own it asks the owner over a message channel.
# TundraBuilder
Builds, restyles and tears down a tundra from code: build(opts) answers a handle with plan, site, ground, instances, stats (fingerprint, counts, colliders, phases), ready, :update(), :setLook(look), :setQuality(q) and :destroy(). Also planFor(opts) and spawnFor(opts), which never build anything and are safe in a scene's build.luau. The Tundra component calls it.
# arcticKit
A whole walkable high-Arctic tundra for your world, in one component. Wide snowfields of fresh powder, wind-packed crust and carved sastrugi; a frozen lake where you look down through clear black ice in some places and walk on white cracked ice in others; an ice shelf ending in a sheer layered cliff over an open lead in the sea ice, with rifts behind its edge; crevasses you can look down into, their snow cornice lips overhanging blue ice walls that drop into a blue-black depth, across glacier tongues and in pressure-field sea ice (the ground is really cut under each one, and snow ramps at their ends let anyone who falls in walk out); crack networks and pressure cracks lying on the lake ice; jumbled pressure ridges; frost-shattered rock, lichen boulders and low tundra scrub with dwarf willow, cottongrass, moss hummocks and little arctic flowers poking through the snow; an inuksuk, a research hut with a spinning weather mast, a sled, fuel drums, expedition flags and survey pennants flying downwind at the camp, the stops and the lookout, whale bones and driftwood; and a marked walking route with stops, its snow trodden into boot prints and sled tracks, with wet slush along the lake shores and the lead's edge and frozen gravel round the rock and on the lookout. It comes with polar time of day (a low pink morning, a pale low noon, a long blue dusk and night), four kinds of northern lights, five kinds of cold weather up to a full blizzard, and wind, blizzard, lake ice and footstep sound that follow the time, the weather and where you stand.
Size, snow depth, scatter density and seed are each one setting, and every player builds exactly the same tundra from the same seed, on desktop and in the browser: the same things in the same places, and you bump into them in the same places.
## Drop a tundra into your world
Paste this into an empty world (the editor's run box, or inside `content()` of a scene's `build.luau`):
```luau
entity.spawn("Tundra").component.add("arcticKit.Tundra", {
size = 512, snowDepth = 0.6, density = "normal", seed = 7,
landscape = "lakeBasin", look = "realistic",
})
entity.spawn("ArcticAtmosphere").component.add("arcticKit.ArcticAtmosphere", {
time = "noon", aurora = "curtains", weather = "clear",
})
```
The ground streams in around you within a second or two and the props a moment later. A starter floor the new world came with (a flat slab named `ground` or `floor`) is hidden while the tundra stands, so it never shows at the horizon or under the clear ice, and shown again if the tundra is removed. Nothing is baked or saved: the ground, the props and their colliders are computed from the settings on every machine. Press play and the scene's player spawns are stood at the head of the route (turn that off with `moveSpawns = false`).
## What you set
| Setting | Values | What it does |
|---|---|---|
| `size` | 192 to 1536 (m) | the side of the walkable square; the ground carries on beyond it to the horizon |
| `snowDepth` | 0 to 2.5 (m) | 0 is bare summer tundra (moss, scrub, flowers), 0.6 a spring cover, 1.5 deep winter with only rock tips showing |
| `density` | sparse, light, normal, dense, lush | how thick the rocks, plants, drifts and ice are scattered |
| `seed` | any whole number | each seed is a different tundra, the same seed always the same one |
| `landscape` | lakeBasin, iceShelfCoast, pressureField, openTundra, glacierFront | the kind of place |
| `look` | realistic, painted, cartoon, lowpoly, pixel | the art style of every surface and prop, for the whole world |
| `route` | true / false | the marked route and its stops |
| `quality` | 0.3 to 2 | how far props draw (the browser caps it at 0.65); nothing a player touches moves or goes away |
| `moveSpawns` | true / false | stand the scene's player spawns at the head of the route |
| `targetFps` | number (60) | frame rate each machine holds in play: when frames run long the render scale steps down (upscaled, floor 0.75 desktop / 0.6 browser) and comes back when there is headroom; a step that buys no time (a CPU-bound machine) is taken back. Visual only, nothing moves. 0 turns it off |
The five landscapes:
- **lakeBasin**: a big frozen lake in a ring of low hills, pressure cracks across its ice, a rocky lookout hill.
- **iceShelfCoast**: land to the south, a frozen lake inland, pressure ridges where the floating shelf grinds the land, the shelf's sheer cliff over an open lead and sea ice to the north, a rocky headland lookout.
- **pressureField**: a field of sea ice crushed into ridges and rubble, a low shore and a rock headland.
- **openTundra**: rolling hills of moss and scrub, frozen ponds, boulder fields and moraine ridges.
- **glacierFront**: a glacier tongue coming down from the north to a blue calving front on a frozen lake, with moraines and erratics.
## Time of day, northern lights and weather
```luau
local Atmos = require("arcticKit.Atmos")
Atmos.setTime("dusk") -- morning | noon | dusk | night, for every player
Atmos.setAurora("storm") -- curtains | storm | crown | quietArc | off
Atmos.setWeather("blizzard") -- clear | groundBlow | whiteout | diamondDust | iceFog | blizzard
print(Atmos.getTime(), Atmos.getAurora(), Atmos.getWeather())
```
Every player sees the same sky: time runs on worldClockKit's shared clock and the aurora and weather are synced, so a player who joins later gets them too. The scene keeps one clock: ArcticAtmosphere uses a WorldClock the scene already has, and creates one only when there is none, never a second one while worldClockKit is still loading.
## Switch the look of the whole world
```luau
require("arcticKit.Look").set("pixel") -- or set the Tundra's look field
```
Ground, lake ice, sea and every prop restyle in place; nothing moves.
## Ask the ground
```luau
local site = require("arcticKit.TundraSite").active()
local Shape = require("arcticKit.TundraShape")
local plan = entity.find("Tundra").component.get("arcticKit.Tundra"):plan()
local x, z = 0, 0 -- any ground point, for example a player's position
site:heightAt(x, z) -- the top a foot meets (the lake's ice counted)
site:surfaceAt(x, z) -- freshPowder, windCrust, sastrugi, blackIce, whiteIce, frostRock, ... (the classification the scatter reads)
Shape.dressed(plan, x, z) -- as drawn and heard: adds troddenSnow (route, camp), slush (lake and pond rims, lead edge), frozenGravel (rock fringe, lookout)
site:footstepAt(x, z) -- freshSnow, crust, ice, rock, scrub
site:zoneAt(x, z) -- tundra, lake, shelf, ridge, rock, sea, glacier
site:stop("lookout") -- world position of a stop on the route
```
`entity.find("Tundra").component.get("arcticKit.Tundra"):stats().fingerprint` is a short code over every placement: equal codes on two machines mean equal tundras.
## What is inside
- **Tundra** (component) and **TundraBuilder** (module): build, restyle and tear down a tundra; `TundraBuilder.build(opts)` from code, `planFor(opts)` and `spawnFor(opts)` without building.
- **TundraTypes**, **TundraLayout**, **TundraShape**, **TundraScatter**, **TundraSite**, **TundraRender**, **Noise**: the five recipes, the plan (lake, coast, shelf, glacier, ridges, route, stops), the ground as pure functions, the placement, the ground questions, the instanced drawing with levels of detail, and deterministic noise.
- **Look** and **Props** (modules): the world look (arcticMaterials' `ArcticLook`) and the prop catalog (arcticProps' `ArcticProps`) under the kit's own name, so `require("arcticKit.Look")` and `require("arcticKit.Props")` resolve in any world that installed arcticKit.
- **ArcticAtmosphere** (component), **Atmos**, **Aurora**, **Weather**, **Ambience**, **Footsteps**: the polar sky and light on worldClockKit's clock, the northern lights, the cold weathers, the ambience on soundstage, and footsteps by the ground under each walker.
- Guides: **How do I add an arctic tundra with snow, ice, a frozen lake and northern lights to my world** and **Example: a frozen lake crossing in a blizzard, a small arctic expedition game from an empty world**. Tests: `tests/`.
It installs **arcticProps** (the props), **arcticMaterials** (the surfaces) and **worldClockKit** (which brings soundstage).
## Every player, the same tundra
The plan, the ground heights and every placement come from integer-hash noise and plain arithmetic (no `math.noise`, no trigonometry in any decision), which IEEE doubles compute identically on every machine, so the desktop engine and the browser engine stand the same ground, the same props and the same colliders. The ground is a `TerrainStream` fed by that function, so it collides wherever any player walks. Time, aurora and weather are shared state; footsteps are soundstage's, heard from every walker.
## Set it up step by step
`arcticKit.setupTundra` is a workflow that walks you through it in stages: drop the tundra in, choose a look, set the time of day, the weather and the northern lights, place the route, then walk it in play. Each stage hands over the exact code for that step and checks what it built before the next one starts.
zero workflow start --name setupTundra --args '{"landscape":"lakeBasin","look":"painted","time":"dusk","weather":"blizzard"}'
Every argument is optional; `setupTundra.workflow/workflow.yaml` lists them with their defaults.
## In the browser
The browser builds exactly the same tundra (same places, same props, same colliders) and draws it lighter: props draw nearer (`quality` capped at 0.65), shadows of small props end sooner and the shadow pages refresh 30 times a second, the ground streams with a smaller per-frame budget once it is all drawn, and `targetFps` lowers the render scale further when frames run long. `require("arcticKit.TundraBuilder").webProfile = true` gives a desktop the same light profile (`false` turns it off in the browser, `nil` follows the platform).
With the light profile the browser runs at about 40 ms a frame (about 25 fps), measured in the browser on the showcase scene (it was about 61 ms before this profile). That is the engine's browser frame cost (#19390), not the tundra's: the same scene draws in well under half that time on a desktop. See Known limits.
The ground stands as quickly in the browser as on a desktop. Every ground sample is computed once and kept, a background task computes the tiles nearest the spawn first (every sample near it, every fourth further out, the spacing the distant levels of detail draw at), and while tiles are still to stand the stream gets a loading budget (10 ms a frame in the browser, 4 on a desktop) that drops back to the light steady one once every tile is drawn. `entity.find("Tundra").component.get("arcticKit.Tundra"):stats().groundTiles` says how many tiles are drawn.
The build runs as a system task, which the engine never holds for a pause or a change of mode, so a slow machine finishes it however long its frames or mesh loads take, and a finished tundra stays finished. It is built again only if the build task fails outright, at most three times, and the log says why.
## Known limits
- #19390: frame rate in the browser. With the light profile the tundra runs at about 40 ms a frame (about 25 fps) in the browser, measured on the showcase scene; the desktop holds a much higher rate on the same scene.
- #23712: the size of TerrainStream's ground textures is fixed by the engine, so ground detail up close is limited.
- #23672: the terrain guide does not cover writing computed heights; arcticKit streams them through `TerrainStream:setSource`.
## Trodden snow, slush and frozen gravel
The ground is drawn in two passes. `TundraShape.eval` classifies it (snow, rock, moss, ice, lake bed) and the heights, colliders and scatter read only that, so they never change. `TundraShape.dressed` then draws three surfaces over it: trodden snow along the route (a band about 2.5 to 3 m wide) and round the camp, slush on the wet rim of every lake and pond and along the far edge of the sea-ice lead, and frozen gravel on the fringe of rock outcrops and over the lookout's crown. Footsteps follow the drawn ground (`site:footstepAt`): trodden snow crunches like crust, slush sounds like soft snow, gravel like stone. A TerrainStream tile draws at most eight surfaces, so `TundraBuilder.tileBudget` counts each 128 m tile once and, where one would name more, lets moss, scrub and the rarest layers give way to what they stand on (the path and the shore last); every landscape at seed 7 stays within eight.
# arcticMaterials
Every surface a high-Arctic tundra and ice world needs, in five looks, behind one call: snow, wind crust and sastrugi, glacier ice, layered shelf ice, clear black lake ice you see down through, cracked white lake ice, sea ice and open sea water, frost-shattered rock, tundra moss and scrub, boot-trodden path snow, shore slush and frozen gravel for the ground; lichen rock, snow-capped rock, serac ice, driftwood, bone, a red research hut (panels, roof, lit window), a rusty fuel drum, mast steel, sled wood, canvas and rope for objects; dwarf willow, cottongrass, arctic flowers, moss cushions and sedge for plants. Every look of every surface is a material this package ships, and every one multiplies vertex colour into its albedo, so props can bake tint, rust and strata per vertex.
```luau
local AM = require("arcticMaterials.ArcticMaterials")
local lake = entity.spawn("black ice")
lake.component.add("Model", { model = "cube", material = AM.get("blackIce") })
lake.localScale = { 12, 0.2, 12 }
local boulder = entity.spawn("lichen boulder")
boulder.component.add("Model", { model = "sphere", material = AM.get("lichenRock") })
boulder.localPosition = { 2, 1.2, 0 }
boulder.localScale = { 2.4, 1.8, 2.2 }
local serac = entity.spawn("serac")
serac.component.add("Model", { model = "cube", material = AM.get("iceSerac", { look = "cartoon" }) })
serac.localPosition = { -3, 1.5, -2 }
serac.localScale = { 1.5, 3, 1.5 }
```
To drop a whole tundra (terrain painted with these surfaces, props, sky and weather), install arcticKit and use its one-liner:
```luau
entity.spawn("Tundra").component.add("arcticKit.Tundra", { size = 512, seed = 7 })
```
## API
```luau
local AM = require("arcticMaterials.ArcticMaterials")
AM.LOOKS -- { "realistic", "painted", "cartoon", "lowpoly", "pixel" }
AM.surfaces() -- every surface name
AM.get(surface, { look? }) -- a material, never nil; no look = the world look
AM.terrainLayer(surface, look?) -- { albedo, normal, mask, tint, tiling, color } for TerrainStream `layers`
AM.TERRAIN -- the ground surfaces a terrain paints
AM.footstep(surface) -- "freshSnow" | "crust" | "ice" | "rock" | "scrub" (troddenSnow crust, slush freshSnow, frozenGravel rock)
AM.ATLAS.arcticFlowers -- { cols = 2, rows = 2, cells = { purpleSaxifrage = {0,0}, arcticPoppy = {1,0}, mossCampion = {0,1}, mountainAvens = {1,1} } }
AM.color(surface), AM.group(surface), AM.tileSize(surface), AM.usesUV(surface), AM.source(surface, opts)
local Look = require("arcticMaterials.ArcticLook")
Look.get() -- the world look, "realistic" until someone sets another
Look.set("pixel") -- every player sees it, late joiners too
local stop = Look.onChanged(function(look) end); stop()
```
The world look lives on one synced entity (`arcticMaterials look`, an `ArcticLookState` component), created on demand by the first `set`. A player who does not own it asks the owner over a message channel, so a set on any peer reaches all of them.
Atlas cells: a mesh's 0..1 UVs map into a cell as u' = (col + u) / cols, v' = (row + v) / rows, row 0 at the top. Each cell is opaque petal colour filling the whole cell (the plants are small opaque parts, not alpha cards).
Placement: ground, rock, ice and object surfaces place their maps by world position in metres (triplanar; image-up is world +Y on the sides, so firn strata stay level on any cliff), so prop UVs do not matter. `willowLeaves`, `cottongrass`, `arcticFlowers` and `sedge` read the mesh's UVs (`AM.usesUV`), and sway in the wind by vertex alpha.
## Surfaces
Shipped = baked here from a generated picture. Borrowed = the maps come from an installed collection, drawn through this package's shader (so the vertex colour contract holds in every look).
### Ground (16): what the tundra is made of, and what TerrainStream can draw
| Surface | Group | Maps | What it is |
|---|---|---|---|
| `freshPowder` | ground | borrowed: Terra Firma freshSnow | soft new powder snow |
| `windCrust` | ground | shipped | hard wind slab with scallops |
| `sastrugi` | ground | shipped | wind-carved snow ridges, blue grooves |
| `blueIce` | ground | shipped | cyan glacier ice with bubble streaks |
| `firnLayers` | ground | shipped | ice shelf face, level white and cyan strata |
| `blackIce` | ground | shipped (+ lakeBed seen below) | clear black lake ice, stones and bubbles below |
| `whiteIce` | ground | shipped | white lake ice with branching cracks |
| `seaIce` | ground | shipped | snow-covered pack ice |
| `seaWater` | ground | shipped (procedural) | dark cold sea water, slow drifting ripples |
| `frostRock` | ground | shipped | felsenmeer: angular frost-split slabs and grit |
| `tundraMoss` | ground | shipped | olive and rust moss, reindeer lichen |
| `tundraScrub` | ground | shipped | dwarf willow, sedge, crowberry, gravel |
| `lakeBed` | ground | shipped | dark stones in silt |
| `troddenSnow` | ground | shipped | packed grey-blue path snow, overlapping boot prints, sled runner marks |
| `slush` | ground | shipped | wet half-melted grey-blue snow, glossy, meltwater standing in the hollows |
| `frozenGravel` | ground | shipped | frost-heaved grey and brown gravel and pebbles locked in ice, snow dust |
### Objects (14): rock and ice for props, and the materials the camp props are built from
The hut, drums, mast, sled, tent, rope, window and outline ink are prop materials, listed here because the props use them in every look; they are not ground choices.
| Surface | Group | Maps | What it is |
|---|---|---|---|
| `lichenRock` | object | shipped | granite with orange and pale green lichen |
| `snowCapRock` | object | shipped (frostRock maps) | rock with snow on every up-facing part |
| `iceSerac` | object | shipped (blueIce maps) | serac and pressure-block ice, snow on top |
| `driftwood` | object | borrowed: Heartwood driftwood | sea-bleached wood |
| `bone` | object | borrowed: Scale and Feather bone | weathered whale bone, antler |
| `hutPanel` | object | shipped | red painted insulated panels |
| `hutRoof` | object | shipped | grey corrugated steel |
| `drumSteel` | object | shipped | faded red fuel drum, rust streaks |
| `mastSteel` | object | shipped | galvanised steel |
| `sledWood` | object | borrowed: Heartwood oakBoard | oiled oak slats |
| `canvas` | object | shipped | khaki canvas |
| `rope` | object | shipped | hemp rope |
| `hutWindow` | object | none (flat) | warm lit window glass, glows |
| `ink` | object | none (flat, unlit) | near-black outline ink for inverted hulls |
### Plants (5)
| Surface | Group | Maps | What it is |
|---|---|---|---|
| `willowLeaves` | plant | shipped | dwarf willow leaves |
| `cottongrass` | plant | shipped | white seed-head fluff |
| `arcticFlowers` | plant | shipped (2 x 2 atlas) | saxifrage, poppy, moss campion, mountain avens |
| `mossCushion` | plant | shipped (tundraMoss maps) | green moss hummock |
| `sedge` | plant | shipped | olive to straw sedge blades |
## In the shared material library
`arctic.materialCollection` files every surface in every look with materialLibraryKit, and it is written to sit beside the other packs without touching them:
- Every id carries the `arctic_` prefix (`arctic_bone`, `arctic_driftwood_lowpoly`, `arctic_troddenSnow_painted`). The library hands a bare id to the first collection that names it, so `bone` stays the organic pack's and `driftwood` the woods pack's.
- Styles are the library's own: realistic as `realistic`, painted and lowpoly as `stylised`, cartoon as `toon`, pixel as `pixel`. The look's own name stays in each entry's tags, so `tag = "lowpoly"` still finds the low-poly set.
- Every entry is filed under its own category, `arctic`, the way the forest and animated packs keep theirs, so the shared `ground` and `organic` rings of the swatch gallery stay the ground and organic packs' own. Whether a surface is ground, an object or a plant is in its tags: `Materials.list({ category = "arctic", tag = "ground" })`.
- The arcticMaterials test suite checks it: no library problem from or caused by the arctic collection, every id prefixed, every style allowed, no bare id taken over.
## Looks
All five looks of a surface draw with the package's one shader, `arcticSurface`, from the same maps, so a stylised world costs no extra texture memory on Models:
- **realistic**: physically based, with the engine's lighting. Black ice adds a fake-depth layer: the lake bed is drawn 1.2 m below along the refracted view ray, absorbed by the ice it crosses, with bubbles hanging at a third of the depth, under a glossy surface.
- **painted**: the colour read softened into brush patches, saturation lifted, tones gently stepped, light wrapped round the form with cool shadows.
- **cartoon**: hard flat tones, light cut into two bands, a pale rim.
- **lowpoly**: one flat colour per surface (the mean of its albedo, `AM.color`), faceted by each triangle's own normal.
- **pixel**: the maps point-sampled at 32 texels per repeat (16 on plant parts), banded light, a stepped palette.
Terrain layers are shaded by TerrainStream itself, so for the ground the looks are baked: realistic and painted paint the surface's own maps, cartoon and pixel paint a baked toon (`<surface>_toon_albedo`) or pixel (`<surface>_pixel_albedo`) albedo over the same normal and mask, and lowpoly paints the flat colour.
The `ArcticSurfaces` scene in this package shows every surface in every look, a row per surface.
## Texture memory
110 textures, all UASTC with mips (BC7 on the GPU, about 1 byte per texel): 72 at 1024 px and 38 at 512 px. Everything resident is about 114 MB. A world in the realistic look loads about 70 MB (albedo and normal 1024, mask 512 per surface; small objects and plant parts at 512); the cartoon or pixel terrain adds about 22 MB of baked terrain albedos for that look only. Every terrain layer, in every look, is 1024 px albedo and normal and 512 px mask, because TerrainStream packs all layers into one texture array whose slices must share a size and format.
## Making and changing
`ArcticRecipes` holds every surface's data (maps, scale in metres, colour, roughness, snow, ice depth, glow, sway) and how each look reads the maps. `ArcticBuild.buildAll()` writes the 175 material files, `ArcticMaterialsTable` and the `arctic.materialCollection` list from it. `ArcticBaker.bake(name, spec)` turns a generated picture (kept on the baking machine in `local/arcticSources/`) into albedo, normal and mask maps; `bakeLooks` makes the terrain's toon and pixel albedos; `bakeWater` makes the sea water procedurally. The source picture prompts are `PROMPT_LEAD` plus a top-down, evenly lit, seamless ground description; trodden snow, slush and frozen gravel (baked 2026-11-07) used: trodden snow "packed, slightly grey-blue path snow covered in many overlapping boot footprints with crisp tread patterns, a pair of faint shallow sled runner grooves, small kicked-up lumps of loose snow"; slush "grey-blue water-soaked snow breaking down into translucent icy slush, shallow pools of standing meltwater in the hollows with a glossy wet sheen, soft lumps of wet snow and thin floating ice crusts"; frozen gravel "mixed grey and brown angular gravel and rounded pebbles from one to six centimetres, clear and milky ice filling the gaps, a light dusting of dry snow in the hollows, small frost cracks". Tests: `tests/arcticMaterials.testSuite`.
## Known limits
- Black ice depth is a fake, not a refraction of the scene: the deep layer assumes a level surface, fades out on steep faces and is drawn in the realistic look only (the stylised looks show dark glossy ice).
- Solid surfaces are placed by world position, so a prop that moves at runtime would slide through its texture. Everything in arcticProps stands still; use a plant surface (mesh UVs) for anything that has to move with its texture.
- TerrainStream shades terrain layers with its own shader: painted, cartoon and pixel ground are baked albedos, not the live stylised lighting the same surface gets on a Model, and lowpoly ground is a flat tint without facets.
- Material colour properties written into `mat.yaml` by hand did not reach the material (scalars did): `renderer.material.describe` reported the shader's default `[1, 1, 1, 1]`. The files are written through `asset.create`, which works, so rebuild with `ArcticBuild.buildAll()` rather than editing them by hand.