Flora: grass and flowers for Eventyrland

Research portfolio, 2026-10-01. For the agent who builds it: everything needed is in this directory. Read sections 1, 4 and 5 before touching code; 2 and 3 are the reasons.

• art/: 29 kept images, 7 rejected, 2 mock-ups, 4 texture previews, layers.svg
• textures/gust.png, textures/wash.png and tools/make_textures.py: the two textures the design needs
• prompt-blocks.md, prompts.json: the prompts
• sources.md, notes/: where the findings come from, and what could not be confirmed
• open-questions.md: what Petter decides

Nothing here was run in the game. The shader code is written against the game's files as they were on 2026-10-01 and has not been compiled. Every GPU time for the new design is an estimate; section 4.9 says how each was made.

1. What is drawn today

Read from src/world/grass.ts, grass-fill.ts, flora-cards.ts, wind.ts, tiles/meshes.ts and the stills in a local file and artdir/look2/sheets/.

How. three.js 0.186, the WebGPU renderer, TSL node materials (MeshLambertNodeMaterial). Three layers, each a pool of 20 m chunks refilled round the camera, one instanced draw a chunk:

• Colour: a clump's colour is the terrain colour map at its root (tileColour, per instance on the CPU), times a random 0.85–1.15. The root is that colour × 0.5, the tip × (1.16, 1.16, 1.02).
• Light: the normal is world up for every blade (transformNormalToView(vec3(0, 1, 0))), so grass on a slope is lit as flat ground while the ground under it is lit by its own slope. One shadow tap. Backlit tips glow (0.22).
• Wind: windGust is two sines of the position along the wind (wavelengths 84 m and 203 m, moving at 17–19 m/s), so gusts are soft parallel swells with no front. A gust adds (0.20, 0.19, 0.10) × gust² to the grass and (0.07, 0.07, 0.04) to the ground.
• Her feet: uPusher is read by every grass, flower and reed vertex and never written (docs/perf-review.md 5). It stays at the origin, 999 m down.
• Beyond the fade: the ground: colour map × two luma-only noises (9 m and 47 m) × cloud shade × gust shimmer, with the flower drifts as baked speckles.
• Flowers: eight kinds, a cute and a painterly painting of each, 256 px cells. A card is a whole clump with its leaves. A drift's middle holds 2–3 cards a square metre, all one size ± 15 %.

What it costs (derived by replaying poolOffsets and the keep rule; medium tier):

• About 13 chunk-equivalents of grass in view: 22 000 clumps, 154 000 triangles, 286 000 vertex invocations a frame, 13–17 draws. docs/perf-review.md derives 201 000 on high.
• A chunk is visible until its centre is 45 m away while the fade ends at 30 m, so 15–37 % of the clumps run their vertices and draw nothing (docs/perf-review.md, open point 4).
• A full grass chunk takes 3.44 ms to fill and a flower chunk 2.0 ms on the server; near her the fill ignores its budget (stop = near && urgent < 2 ? Infinity : until), which gave frames of 5 ms for each layer.
• GPU time of the grass alone has never been measured. Two lines in docs/lighting.md give a rough size: one shadow tap instead of five saved 0.05 ms in Chrome on the M3 Pro and was "about 40 %" of the grass's GPU time, so the grass is of the order of 0.1 ms there and 0.3–0.5 ms on the A16 by the ×3 rule. Treat it as a guess until ?hide=grass is measured (section 7).
• cloudShade(p.root.x, p.root.z) sits in colorNode without varying(). Check the generated WGSL: if it runs in the fragment stage, every grass pixel pays a texture read that could be one per vertex.

What is wrong with the picture, from the stills:

1. The grass reads as single spikes. The root at half the tip's value puts a dark and a light stripe on every blade, so a meadow is noise at the blade's scale and has no shapes at the scale of a metre.
2. One green. Nothing changes hue across a field; only the baked map and a little luma noise.
3. The field ends. At 30 m the blades sink into a flat mottled plane.
4. Gusts cannot be seen as shapes: a swell of + 20 % with no edge.
5. The flowers are stickers: one card repeated at one size on an even spacing, each with its own dark leaf rosette in a green that is not the grass's (art/mock-sit-inside.webp, left half).
6. Outside, the painted cards are dark and dull (lupin #454B8F, clover #7F1F36) and the paint pass mutes them further.
7. Nothing answers her.

2. What "painterly and dynamic" looks like

Sources and their limits are in sources.md and notes/painted-meadows-research.md. No craft source was found in which the artists of Amulet, Nordlys or the films describe how they paint grass; the rules below rest on what the sources do say about backgrounds, on landscape-painting teaching, and on the target paintings made here. Lines marked observation are a description of the published art from memory and were not checked against a page.

The rules

Each rule can be checked against a frame.

R1. Masses before blades. A meadow is two or three colour shapes. Blades are drawn only where the grass has an edge against something else: the nearest 3–4 m, the crest of a rise, the rim of a path or a stone. In the middle of a field there is colour and a few brush marks, no blades. Check: in a lit patch of meadow 8–20 m away, the standard deviation of display luma inside a 64 × 64 px window is under 0.035 (measure today's first; the target is at most 60 % of it). From: Gurney, "big shapes first to small shapes last"; Wish, "They tend to paint things with less detail they don't want you to focus on"; Kibuishi's backgrounds, "more implied than realized" (a reviewer's words). Amulet's fields as soft bands with a ragged fringe at the bottom edge and on crests is observation.

R2. A blade's foot is the ground's colour. The darkest thing in a tuft is its foot, and the foot is only a little darker and cooler than the ground beside it: × 0.86 inside, × 0.78 outside, never × 0.5. Light sits at the outer and upper edges. From: Gurney, foliage is "lightest at its outer and upper edges, and darkest at its base or its core".

R3. Vary hue, hold value. Across a lit field the value stays within ± 0.05 display luma; the hue wanders between a warm and a cool version of the zone's green in patches 10–40 m across, with dry, yellowed patches 5–15 m across. Check: sampled every 4 m across a lit field, hue spreads at least 6° inside and 4° outside; luma within ± 0.05. From: Dan Scott on grass (a compressed value range, vary hue and saturation); the target paintings, where sunlit grass measures #BAB240 to #D3C558 inside and #7F794F to #89814B outside: red nearly equal to green, far yellower than the game's #6DB33F.

R4. Four values in a meadow frame. Sky lightest, the lit ground next, slopes and cloud shade next, upright things (trees, the wall, her) darkest. A lit meadow is lighter than any tree beside it. From: Carlson's value planes (via Mitchell Albala). The paint pass's bands agree: lit meadow 0.30–0.35, shade 0.15–0.24.

R5. Light crosses the field as shapes. A cloud shadow is one flat shape with a soft edge, cool, never dark (display luma 0.24 outside, measured #2F4243 in art/target-gust.webp). Use one of Gurney's two schemes: shade near with a patch of light in the middle distance, or a fringe of light near with the shade behind it.

R6. A gust is a band of pale grass with a front. The leading edge is sharp (1–2 m), the tail fades over 15–35 m, bands lie 20–40 m apart and bend with the ground. In the band the grass is lighter by about 0.15 luma and less saturated (#9B9771 against #777141 between the bands), because the blades show their pale sides. Flowers in the band lean, and seeds and petals travel with it. From: art/target-gust.webp. Ghost of Tsushima varies the wind's strength over the land with moving Perlin noise "which is what shows as gusts on large fields" (Rockenbeck). Brightening the grass in a gust is a tutorial convention; no shipped game's source was found for it.

R7. Flowers are masses too. A drift is one kind and one colour, with a ragged edge and a thick middle. "A mass of one shape, not a collection of dots" (Karen Margulis); avoid "polka dot meadows". Inside, drifts are small (3–6 m across) and many; outside, few and big (10–30 m), and at least two thirds of a meadow is open grass on both sides of the wall. Check: no flower kind is spread evenly over a field; the share of meadow ground under flower cards or dabs is at most a third.

R8. Three sizes of flower. Near (to 8 m): a few big simple shapes, in groups of three, one large and two small. Middle (8–40 m): dabs, a hand's width each. Far: a patch of colour with a soft edge, no dots. The same drift is all three as she walks up to it. From: art/target-inside-eye.webp, art/target-far-drifts.webp; Margulis, masses shrink and change colour with distance.

R9. Detail is spent at her feet and on the skyline. The fringe of drawn blades is the nearest 4 m and the crests. Flower cards are hero shapes within 8 m. Nothing else gets detail. From: Frozen II, clearing the ground where the characters are and lighting for their silhouettes; Arcane, detail kept where characters touch the set (80.lv).

R10. The far field is a wash. Beyond the blades: flat colour shapes that follow the land, cooler and lighter with distance, the warm colours dropping out first. From: Wish, "a card that had a colored wash with a bit of texture to it and that would suffice"; Gurney on distance.

R11. No line on grass. Line belongs to figures and silhouettes; grass and flowers are paint. From: Nordlys (the figures' contours stand out "foran de maleriske bakgrunnene"), Amulet (thin single-weight line on characters, painted backgrounds), Wolfwalkers' forest ("The line was almost disappearing in places"), and the rulebook already.

R12. The wall is the change of hand. Inside: soft, blended, round, bright, tidy. Outside: visible strokes, combed by the wind, muted, with flowers as the glow. Near the gates the two meet over a band, as Wolfwalkers' forest edge does ("some of the trees were angular and had more of a thick line"). From: Wolfwalkers (lino-cut town, watercolour forest); The Sea Beast ("controlled gardens are the perfect counter point to the wild nature").

R13. Dusk keeps the colour. At dusk the meadow is three greens (the glow-facing olive, the body, blue-violet hollows), the fringe takes a peach rim, the flowers go a little deeper and the white ones glow. The game's rule (ground luma ≥ 0.2, hue green) stands.

What the games do

Not confirmed: anything on the grass of Genshin Impact, Tears of the Kingdom, Ori, Kena or Tunic (no technical source found); BotW's far-field treatment and bands (community observation only).

3. Techniques for three.js on an A16

The iPad (A16) has a 4-core GPU, 2360 × 1640, and draws the game at pixel ratio 1.35 on 1180 × 820 (1593 × 1107) with 4× MSAA. It is a tile-based deferred renderer: opaque triangles are sorted by the GPU itself, and any shader that discards breaks that for its pixels.

Sources for each row: sources.md. Published numbers for grass on an Apple mobile GPU or in Safari's WebGPU were looked for and not found.

4. The proposal: washes, tufts, dabs and sprays

One system for the whole world. A tuft is a brush mark; a field is the ground's wash showing through tufts of its own colour; flowers come in three sizes; one gust texture moves all of it.

4.1 The numbers at a glance (medium tier, the iPad)

Today: 154 000 triangles, 286 000 vertex invocations, and up to 260 cards a chunk as 4-triangle crosses. The design is triangle-neutral by construction; what it buys is spent on shape (five blades a tuft instead of three, at 62 % of the instances) and paid for by the far chunks' three triangles a tuft.

4.2 Layer 0 and 1: the bake and the ground wash

The ground carries the meadow's colour everywhere, and the blades agree with it.

• One colour function. meadowWash(x, z) in a new pure file src/world/meadow.ts, with a TSL twin:

  Copy

  w        = wash texture at (x, z) / 128 m          // R broad value, G warm/cool, B dry patch, A tuft mottle
  value    = 0.87 + 0.22 · w.r + 0.08 · (A at (x, z) / 9 m − 0.5)
  hue      = mix(COOL, WARM, smoothstep(0.3, 0.7, w.g))     COOL = (0.94, 1.00, 1.05)  WARM = (1.07, 1.00, 0.88)
  dry      = mix(1, (1.12, 1.02, 0.78), 0.35 · w.b)
  ground   = map.rgb · value · mix(1, hue, K) · dry          K = 0.6 inside the wall, 1 outside (wallOutside())

  The ground shader (tiles/meshes.ts groundTint) uses it per pixel in place of today's mottle and broad reads. The grass fill evaluates the same thing in JS at each tuft's root and writes the result into the tuft's root colour, so a blade's foot is the ground's colour to the byte. Preview from above, 128 m across, with one gust and one cloud shadow: art/wash-preview-hjemdalen.webp, -nordalen, -sormarka.

  

• Gust light on the ground. × (1 + (0.12, 0.10, 0.02) · g² · k) with g the gust texture and k rising from 0.6 under the blades to 1.8 beyond the fade (per vertex, by distance), so a band that bends the tufts at her feet carries on across the far field as a band of light (R6, R10).

• The match from above. Seen from above, a meadow shows more foot than tip, so it is darker than its tips. The ground under blades is therefore the foot's colour (× 0.86 or 0.78) within the fade distance, easing to × 1 over the last 8 m of the fade, where the blades sink. Without this the field gets lighter where the grass ends.

• Drifts in the bake. field.ts bakeColor and tools/world/lib/colour.ts already bake speckles. Change: a drift first tints its whole footprint 18 % toward its speckle colour (soft-edged, the drift's own density), then lays the speckles on top. From 100 m a drift is then a patch (R8), not a dotted lawn. World rebuild on deploy.

• Zone colour. The bake's meadow colour per region becomes the body column of section 5's table.

4.3 Layer 2: tufts

tuftGeometry() replaces clumpGeometry() in grass.ts. Metres at height 1 and width 1; aT is the height fraction, aPart 0 on blades, 1 on a stalk, 2 on a head's rim, 3 on a head's middle.

Total 39 vertices. The index buffer holds the far triangles first (9 indices), then the near ones (69): a chunk whose centre is nearer than 24 m draws setDrawRange(9, 69), the rest setDrawRange(0, 9). Far tufts are widened as today (widen = 1/36 a metre) and thinned by today's keep. To verify in three 0.186: that drawRange on an indexed InstancedBufferGeometry limits the indices of every instance on the WebGPU backend; if it does not, give the pool two index buffers and swap with setIndex.

Rule for the paint pass: outside the wall a blade is at most 0.035 m wide at half its height (A: 0.050 × 0.62 × width, so the instance's width is 0.7–1.1 outside; inside, where the pass is off, 0.9–1.3). At the game's 50° lens on the iPad (focal length 879 CSS px) that is under 8 px beyond 3.9 m, which is the pass's test for "too thin for ink".

Instances (grass-fill.ts), four attributes of today plus two:

Seven vertex buffers of WebGPU's eight (position, aT+aPart as one vec2, and five instanced). 44 bytes an instance, 1.3 MB for the pool.

Where tufts grow. As today, plus clumping: a candidate survives with probability c0 + (1 − c0) · smoothstep(0.35, 0.6, noise2(x / 1.7, z / 1.7)), c0 0.45 inside and 0.2 outside, so tufts stand in tussocks about 1.5 m across with the wash showing between them (Frozen II's nested clumps; Ghost of Tsushima's clump cells). Height, per zone and kind of ground: section 5. All blades of a tuft share its height, colour and lean.

Tip colour, on the CPU: tip = mix(root, zoneTip, 0.75), then toward the zone's dry colour by 0.5 · wash.b, then toward straw by tallGrassAt. The map's own variation survives in it.

The shader (replaces the grass block of createGrass; TSL as grass.ts uses it, not compiled):

const aProp: N = attribute('aProp', 'vec4'), aCol: N = attribute('aCol', 'vec4'), aTip: N = attribute('aTip', 'vec4')
const aBloom: N = attribute('aBloom', 'vec4'), tt: N = attribute('aT', 'vec2').x, part: N = attribute('aT', 'vec2').y
const look: N = aProp.w
const p = placeInstance(positionGeometry, aProp.x, aProp.y, tt.mul(tt), aProp.z, fadeEnd - 8, fadeEnd, 0.42, 1 / 36)
mat.positionNode = p.position                      // placeInstance (4.4): the new gust and pushers; it also returns `gust`
// One normal a tuft: the ground's, so a field shades as one surface and follows its slope.
const nx: N = aCol.a.mul(2).sub(1), nz: N = aTip.a.mul(2).sub(1)
mat.normalNode = transformNormalToView(normalize(vec3(nx, float(1).sub(nx.mul(nx)).sub(nz.mul(nz)).max(0.2).sqrt(), nz)))
// Foot = the ground's colour, a little darker; tip = the zone's; in a gust the upper half turns pale.
const footK: N = mix(float(0.86), float(0.78), look)
const gustTip: N = mix(vec3(0.84, 0.91, 0.56), vec3(0.76, 0.78, 0.60), look)      // #D6E88F inside, #C2C89A outside
const g2: N = p.gust.mul(p.gust)
const tip: N = mix(aTip.rgb, gustTip, g2.mul(mix(float(0.45), float(0.7), look)))
const blade: N = mix(aCol.rgb.mul(footK), tip, smoothstep(0.1, 0.9, tt))
// The dab flower: the stalk in the blade's colour, the head's rim the petal colour, its middle a warm eye.
const head: N = mix(aBloom.rgb, vec3(1.0, 0.59, 0.05), smoothstep(2.5, 3.0, part).mul(0.85))
const col: N = mix(blade, head, smoothstep(1.5, 2.0, part))
mat.colorNode = varying(col.mul(cloudShade(p.root.x, p.root.z)))                  // per vertex: no fragment texture read
const back: N = pow(max(dot(normalize(p.root.sub(cameraPosition)), uSunDir), 0), 3)
setEmissive(mat, varying(tip.mul(vec3(uSunLight)).mul(back.mul(tt).mul(p.gust.mul(0.4).add(0.6)).mul(0.22))))

The heads are placed in placeInstance's caller: a rim vertex is moved from the stalk's top by (right · x + up' · y) · aBloom.a · 0.10, with right = normalize(cross(vec3(0, 1, 0), view)) and up' world up leaned a third toward the camera, so a head is a small disc turned to her; aBloom.a = 0 collapses it. Head sizes: 0.06–0.09 m inside (chunky), 0.04–0.06 m outside.

4.4 Wind and her feet (wind.ts)

// The gust field: a 256² texture with fronts (tools/make_textures.py is the reference), 128 m a tile, scrolled downwind.
export const gustData = buildGust()                                   // Uint8Array(256 * 256 * 2): R gust, G flutter
export const gustTexture = new DataTexture(gustData, 256, 256, RGFormat) // RepeatWrapping, LinearFilter, no mipmaps
export const uGustOffset: N = uniform(0)                              // metres the field has travelled; += speed · strength · dt
export const GUST = { tile: 128, speed: 9 }                           // a front passes a spot every ~4.7 s at strength 1

export function windGust(px: N, pz: N): N {
  const along = px.mul(uWindDir.x).add(pz.mul(uWindDir.y)), across = pz.mul(uWindDir.x).sub(px.mul(uWindDir.y))
  return texture(gustTexture, vec2(along.sub(uGustOffset), across).div(GUST.tile)).r
}
/** The same field on the CPU (motes.ts): bilinear in gustData. Keep in step by construction: one array. */
export function windGustAt(px: number, pz: number, _t: number, wx: number, wz: number): number { /* sample gustData */ }

/** Who bends the grass: x, z, radius, strength. Slot 0 her feet, 1 and 2 where she was 0.3 and 0.6 s ago, 3 a companion. */
export const uPushers: N = uniformArray([new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 1, 0)])
export function pushAt(root: N, bend: N): { xz: N; down: N } {
  let xz: N = vec2(0, 0), down: N = float(0)
  for (let i = 0; i < 4; i++) {
    const q: N = uPushers.element(i), away: N = root.xz.sub(q.xy)
    const near: N = float(1).sub(smoothstep(q.z.mul(0.15), q.z, away.length())).mul(q.w)
    xz = xz.add(normalize(away.add(0.001)).mul(near)); down = down.add(near)
  }
  return { xz: xz.mul(bend).mul(0.75), down: down.min(1).mul(bend).mul(0.3) }
}

• windGust keeps its name and signature, so the ground, the water, the drawn trees and the bushes follow the new fronts with no change of their own. In the vertex stage three samples at level 0 (as steep.ts's ring texture already does); the ground and the water read it per pixel as they do today.
• windSway: 0.18 + 1.1 · g² + flutter, the flutter's phase offset by the texture's G so neighbouring tufts are out of step. The front's 1.6 m edge passing at 9 m/s whips a tuft over in 0.18 s; the tail lets it up over 2–4 s.
• createWind advances uGustOffset, sets the region's wind strength (section 5, eased like the grade) and writes the pushers from game.hero.position: radius 1.3 m on foot, 2.2 m at a run or riding; strengths 1, 0.55, 0.25. This fixes the dead uPusher: delete it.
• Flowers take the same push, and their upper half wobbles for as long as a trail slot is near: sin(time · 7 + phase) · 0.03 · h · (pushers 1 and 2). Elf flowers brighten by 1 + 1.5 · near(pusher 0, 4 m).
• Permanent lean: outside, a tuft's tip is offset downwind by lean · height (section 5), so a still frame already shows which way the wind blows (art/tufts-design.webp, bottom row).

4.5 Layer 4: spray cards

• Geometry: one quad, root at the bottom middle, turned to the camera round the vertical, its up leaned a third toward the view's up, as the drawn trees' cards (painted-trees.ts). Half today's triangles and overdraw, and no cross seen from her camera above. Half the cards are mirrored (phase bit).

• Groups of three: an accepted candidate places one card at size 1.0–1.25 and two more within 0.35 m at 0.5–0.75. A drift's middle holds 0.7 groups a square metre (2.1 cards, as today, but grouped). Kinds, sizes and cells: section 6.

• The foot is the grass: the lower 42 % of a card is pulled 75 % toward the ground's colour at its root (kept in aCol), keeping the painting's own light and dark, and its alpha thins toward the bottom. Mock-up, today's card left, the proposal right (a 2D composite made with PIL, not a render):

  

  

  Copy

  // The card's aCol: rgb the ground's colour at its root, a the look (0 inside, 1 outside).
  const look: N = aCol.a, back3: N = pow(max(dot(normalize(p.root.sub(cameraPosition)), uSunDir), 0), 3)
  const tex: N = texture(atlas.flowers, atlasUV(uv(), aProp.y, ATLAS.flowers.cols, ATLAS.flowers.rows))
  const footM: N = float(1).sub(smoothstep(0.0, 0.42, uv().y)).mul(0.75)
  const lum: N = dot(tex.rgb, vec3(0.2126, 0.7152, 0.0722)).div(dot(aCol.rgb, vec3(0.2126, 0.7152, 0.0722)).max(0.02)).clamp(0.75, 1.25)
  const body: N = mix(tex.rgb, aCol.rgb.mul(lum), footM)
  mat.colorNode = body.mul(cloudShade(p.root.x, p.root.z)).mul(p.lit)
  // Alpha kept one pixel wide at any distance (Golus), then alpha-to-coverage as today.
  const a: N = tex.a.mul(float(1).sub(footM.mul(footM).mul(0.55)))
  mat.opacityNode = a.sub(0.5).div(max(fwidth(a), 1e-4)).add(0.5).clamp(0, 1)
  mat.alphaTest = 0.5; mat.alphaToCoverage = true
  // Outside, the blossoms are the frame's accents: a steady lift in the upper part, so the paint pass keeps them.
  setEmissive(mat, tex.rgb.mul(smoothstep(0.35, 0.8, uv().y)).mul(back3.mul(0.3).add(mix(float(0.04), float(0.14), look))))

• Heads nod: above uv.y = 0.5 a card takes windSway × 1.6 (today × 1 through hy²·0.5) and a slow nod, sin(time · 2.1 + phase) · 0.02 · h.

• Fade: whole to 30 m, shrinking (not sinking) to nothing at 40 m. Pool 37 chunks, as today.

• The build (pipeline/flora/build.mjs): mips made so each level keeps the base level's coverage at alpha 0.5 (scale the level's alpha until it does); cells stay 256², the atlas becomes 2048 × 1024 (8 × 4).

4.6 Layer 5: the air

motes.ts already flies pollen, seeds and petals on windGustAt. Reserve 24 of medium's 200: every 0.4 s, for the drift under her or the nearest one within 20 m, spawn one petal in the drift's speckle colour where windGustAt > 0.6; spawn six at once at her feet when pusher 0 enters a drift's core, and dandelion seeds (white) if the kind is dandelion (art/target-interaction.webp).

4.7 The paint pass and the grass

paint.ts is not changed by this design (one optional line, below). What its steps do to grass, and what the grass must therefore be:

Inside the wall the look is 0 and the picture is the grass's own, so everything painterly inside comes from the wash, the tufts' shape and the cards.

4.8 What replaces what, in build order

Each step leaves the game working. Scope in lines changed.

Steps 1–2 change nothing in the art and already make the meadow move. Steps 3–5 are the lift. Step 7 can run on the painter while 3–6 are built; until it lands, today's 16 cards work in the new shader (the foot tint already helps).

Two fixes from docs/perf-review.md belong in step 5:

• The fill near her: const stop = near && urgent < 2 ? t0 + 2.5 : until. A near chunk that is not done in 2.5 ms is published as it is (the stream is in random order, so a part of it is a thin, even fill) and kept in thin for the top-up that already exists. L.fill.start moves inside the budget check.
• Wasted vertices past the fade: far chunks now cost 9 vertices a tuft instead of 13 of 13, which removes most of it; nothing else is needed.

A switch for A/B, as the trees have: ?flora=0 draws today's grass and flowers, ?flora=ab builds both (window.__floraAB(on)), for the stills and measure.mjs --ab flora.

4.9 Budget on the iPad, and what to cut

Estimates. Method: triangle and vertex counts from the tables above; fragment work unchanged per pixel (Lambert, one shadow tap, no texture read in the tuft's fragment stage); M3 Pro time × 3.

If the iPad is over, cut in this order; each is a constant:

1. The gust term of the backlight and the cards' nod (nothing else depends on them).
2. Pusher slots 1–3 (keep her feet).
3. Near chunks at 18 m instead of 24 m (three or four near chunks instead of five: − 25 000 triangles).
4. Dab-flower heads on the low and medium tiers (a second index range without them: − 10 triangles a near tuft, − 50 000 triangles). The cards and the bake still carry the drifts.
5. Tufts a square metre × 0.8, widths × 1.12.
6. The fade at 26 m instead of 30 m.

5. Two sides, seven zones

The same code everywhere. What differs is a row of REGION_FLORA, the look value at each tuft (0 inside the wall, 1 from 36 m outside it, the same LOOK_BLEND the paint pass uses, so the grass changes hand across the same band as the picture does), and the card set.

Zones

Colours are sRGB mid-tones of the albedo, as docs/art-direction.md gives its palettes. body is the meadow's colour in the bake and so a tuft's root; tip, gust and dry as section 4. Heights are a tuft's blade A in metres before the ground-kind factors; tall is the cap in patches of seed grass. Density is tufts a square metre at vegetation 1 (× 0.65 on the iPad). Outside bodies hold 55–70 % of Hjemdalen's saturation, as the rulebook asks; Alvheim's teal is at 72 % and is the exception.

REGION_FLORA is read like REGION_GRADE (world/grade.ts): by region id at the tuft's root in the fill, eased across a border by the look value and the drift of the bake's colour, with Alvheim as a place over Fjellet (LOOK_PLACES' circle).

Kinds of ground, in every zone

These factors exist in grass-fill.ts today; the numbers change as marked.

6. Flower art

Is the painted clump card the right unit? The painted card is right; the clump is not. A clump with its leaf rosette brings its own green and its own shade into a field that already has grass, and repeated at one size it is a sticker. The unit becomes a spray: stems and blossoms, with the grass as its leaves.

Rules for a card (each checkable on the cut-out):

1. Blossoms cover more of the card's solid pixels than stems and leaves do.
2. A stem is at least 4 px wide in the 256 px cell (1.6 % of the cell). The first round's stems were 6–8 px at 1024 and vanished in the mips (art/rejected/card-inside-lupin-v1.webp).
3. Three to six stems of uneven height from one point at the bottom middle; one leans out.
4. No leaf rosette, no dark leaves. Any leaf is in the zone's tip colour and sits in the lower 42 %, which the shader tints.
5. Three values on a blossom: light, middle and a coloured shade (violet-blue inside, teal outside). Nothing under 0.2 luma.
6. Outside, blossoms are at least 0.55 display luma and leaning right (the game mirrors half and the wind does the rest).
7. Lit from above, no cast shadow, plain light grey behind, as FRAME_FLOWER asks today.

The two looks, as painted here:

Single cards, which is how the pipeline paints them:

Inside	Outside

On hosted Krea v2 (Venice's krea-v2-large, which may differ from the Mac's Krea 2) the same blocks give a flatter, bolder card, closer to the outside look than gpt-image's:

The set: 32 cells of 256², one 2048 × 1024 atlas, rows 0–1 inside, rows 2–3 outside. h is the card's height in metres at size 1; a group is one card at 1.0–1.25 and two at 0.5–0.75.

Red clover, buttercup, daisy, forget-me-not, wood anemone and wood sorrel also exist as dab flowers (petal colour, warm eye): #DF4A6A, #FFC405, #FDFCF7, #78B2F5, #FDFCF7, #F5EFD1; outside gold #F6BE43, harebell #8A8CF0, cream #F5EFD1.

Cushion plants (thrift, moss campion) keep their mound of leaves: they stand on sand and rock. Their foot tint is off (aCol white). The elf cards are painted without their halo; the glow is the shader's (emissive × uGlow) and the bloom's.

The prompts are in prompt-blocks.md. Sample of the special kinds: art/cards-special-sheet.webp.

No model was meshed. Flowers are thin and mesh badly, and nothing in this proposal needs a 3D plant: cushions and hummocks are the ground's clumps and cards.

7. Test plan

Stills, before and after, day (13:00) and dusk (19:42), her eye (1.25 m) and her camera, in one page with ?flora=ab, on the Mac's GPU. Extend scripts/flower-shots.mjs; its spots stay so the sheets compare with 2026-09-30's.

Measured on the stills (a small script over the JPEGs, as dusk-shots.mjs writes ground.json):

Frame cost (the Mac, WebKit, medium, under the GPU lock):

• node scripts/perf/measure.mjs webkit m1|m2|m3 --ab flora --freeze --seconds 30: GPU busy median and mean, new minus old. Pass: ≤ + 0.15 ms mean on the M3. Also l1 and l3 (flying low, where chunks stream).
• The grass's own cost, once, before the work starts: m3 with and without ?hide=grass,flowers in two runs.
• ?fps: + 0 pipelines in play at every spot, day and dusk. The tuft and card materials exist at boot; nothing new compiles.
• ?stats: triangles and draws in m3 against the table in 4.1.
• CPU: a full chunk's fill in Node on the server (today 3.44 ms grass, 2.0 ms flowers): ≤ 3 ms and ≤ 1.5 ms. Walking with the CPU slowed × 3 (feel.mjs --cpu 3): no frame where grass or flowers takes over 3 ms.
• Tests: tests/flora-cards.test.mjs (groups, sizes, cells), a new tests/meadow.test.mjs (the wash's JS and the table), tests/wind.test.mjs (the gust's JS twin against the texture's bytes).

On the iPad: ?fps in meadow, nordalen and blomsterenga, with and without ?flora=0; the worst frame of 10 s while running through a drift; whether dynamic resolution steps down.

8. Where this departs from docs/art-direction.md and docs/flora.md