← labopen bamboo · 竹径 →

Bamboo · 竹径

A run through a wild moso bamboo grove on an endless mountainside, drawn as a lit picture with ink on it: held close to the eye, giving out to the page.

Running

The chase

chase=fox, chase=runner or chase=stir: something crosses your way, a little ahead. Stay with it as long as you can. Catching it isn't promised. A runner or a stir comes and goes; a fox never does: there's one, in the grove from the start, behind you and off to a side, and it stays in your world all the while.

Where it has passed, the grove keeps moving a moment: the culms it brushed, the canopy it went through, still swaying and settling. You can follow it by that even with the sound off. Its footfalls are louder on stone, and its landings thud.

Contact has some give (chase.ts), and it's what you can actually perceive:

The end comes once it's well away (or long gone), or when it has let you come up to it. You slow, the grove settles, and a quiet line says so ("the fox has gone", "the fox let you come close"); no score. A while later, something else crosses your way.

With auto, the run chases it by itself, steering only by what it has perceived. pose=walk|trot|gallop|gather|bound|contact|absorb|listen|lie with still holds the body just ahead, side on (posed= metres away), to see how it's made. node cells/lab/devtools/bamboo-fox.mjs puts the sheet's six (trot, gather, bound, contact, absorb, listen) above the same six held in the grove, in devtools/bamboo/gates/fox.jpg. node cells/lab/devtools/bamboo-chase.mjs [seeds] runs situations on land laid by hand:

It then runs chases on the mountain against a pursuer that knows only what it has perceived, checking every presence's movement is honest over every second and every step.

What you meet

Mostly the grove. But now and then:

In three minutes of running the run covers about a kilometre at a mean of 4.4 to 5.7 m/s (the mountain's steep), on a trail for a few per cent of it (node cells/lab/devtools/bamboo-run.mjs [seconds] [seed] checks that it never runs through a culm, never stalls for long, and keeps up its pace, and counts its moves and landings). It runs in fixed steps of 1/120 s, so the pace and the landings are the same however fast the frames come. node cells/lab/devtools/bamboo-crown.mjs takes one crown three ways, the same approach each time and only your input different: still going straight on (a running bound: a brief touch, the pace carried through), turned in the air toward a crown off to the side (a redirect: the foot takes the weight, the turn goes with the stance, the speed absorbed and pushed out on the new way onto that crown), and let go in the air (a settle: down on the crown and stopped there, no launch after). node cells/lab/devtools/bamboo-ridge.mjs runs the cliff tops a playtest found janky (seed 1, near -710, -414, straight on without turning, for 15 s): it must keep a mean above 4.5 m/s, never stall, and bound at least four times in its first four seconds. node cells/lab/devtools/bamboo-flow.mjs [seeds] audits what the rock offers a runner: round ten crests per seed it grids the footing at 0.2 m into tops (level surfaces clear of the ground, joined across steps a runner runs over), runnable ones (a stance 0.8 m across fits), slivers (none fits), links (a bound between two runnable tops) and lines (three tops linked keeping about one way). Today about 86% of the tops' area is runnable and there are about 14 lines per window; the slivers left are mostly strips along the lip between a column's tiers and along tops' edges. The rock's carving leaves every shelf, shoulder and joint step a stance deep (0.8 m) or not at all, and a climb goes only onto a top that deep (never up a fin to sail off its far side), clearing the lip it lands over rather than the highest tier behind it. node cells/lab/devtools/bamboo-course.mjs runs it straight at things laid by hand: a root and a stone, a broad boulder, a chain of stones, three drops (a moderate one, a big one onto open ground, a big one into culms), a bowed culm, a narrow gap, terraces stepping up and a diagonal chain of offset stones. It checks that each one changes the body, as the list above says, and that your way is still yours at the end. It checks the feet too:

It prints, for each course, how early each landing was read, each load against its demand, each support, the body's travel and the efforts its feet were met with.

The mountain

Long steep-sided ridges and the valleys between (half the hillside steeper than one in three), endless (where a rim or a rock face bars the way ahead, you're held there till you turn): built where you are and a little way round, 32 m at a time, as you run, and let go behind you. The same seed is the same mountain wherever you go.

The rock

Where the rock breaks through, it's built as rock (rock.ts), not drawn onto a slope.

The geology is one field across the mountain, varying smoothly (never by cells):

Every block takes its up from the bedding and its tier heights from the planes that cross it. So bedding runs on from one mass to the next, offset a little where a column has slumped. A fallen fragment is a piece of the tier it came from, with the same proportions and bedding, toppled.

An escarpment stands where a cliff band breaks through.

Out on the slope there are two kinds:

A block is a prism stood on its bedding over its own outline: a rectangle with some of its corners broken off, so four to eight sides, its faces cut obliquely where a corner went. Its top is drawn in and dropped toward the faces it's broken to, so it's a top in facets, not one plane. It's chamfered round its top edge (the worn edge). Its faces are flat, each lit as one plane: a face's normal is the face's own (a quad's, from its diagonals), never its triangles', so a face whose corners are nudged off one plane doesn't light as two facets. A tier is fractured, not stacked. Each tier's mass is split by recursion along what rock breaks on (carve()):

Some faces are left whole, so the breaks read against them. The crest breaks into shoulders and steps, not one blade.

Into the drawing, feature by feature. The rock doesn't fade along one line across the frame. The paper is the stone's own bare face, so each part of it gives way in its own manner and at its own place:

Where the land's own cut is rock, it breaks the same way, in patches, never in level bars.

Which lines are drawn is decided by the structure, never by chance; chance only varies how each is laid (its breaks, length, weight). A crest or lip, a foot and a deep joint are always drawn. A top's side is drawn where the mass ends against nothing (its silhouette) or steps up or down more than 0.45 m from the one beside it, never between two level tops. A block's front corner is drawn only where the mass turns against the air. The hatching on a side turned from the sun is only on a side plane seen edge-on (a recess's side, a flank), never ruled across a broad face. The ground's cut follows its own outline, and its ink is its own edges, each known for what it is: crest, side, joint, foot. Nothing grows under rock, and a cleft's floor is scree, not moss.

Everything agrees on the same faces:

The checks: node cells/lab/devtools/bamboo-rock.mjs [seed] [chunks] checks that every system agrees:

Under it, the run leaps a cleft to the top across it, won't drop onto a ledge it couldn't leave, turns right round at a dead end, and if held a while lowers itself down a face. ?clay&grove=0 shows the forms alone.

The grove

How it's drawn

Three passes, after Labyrinth's, and the land's own strokes laid in the world:

The grove

Moso is a running bamboo: its culms come up one by one along rhizomes under the floor, so a stand is a few crooked lines of them, a culm every half metre to two, now and then two close together, the parent stoutest and its offspring along the run less so, with open floor between the runs. Young shoots of the last year or two stand thin and short among the rest (with the papery sheaths they grew in still on their low nodes); a culm's height goes with its girth; now and then a giant stands beside a trail. Most stand near straight, some lean, a few lean hard, mostly down the hill or out into a gap, and a stand leans a little together; every culm's top bows over under its leaves, the leaners most. Its branches come off the nodes of its crown side to side, rising and arching out, the lower ones longer and flatter, and its leaves hang in bunches along their outer half and at their ends, with a tuft at the tip. Each blade is its own: its angle off the twig, its length, curl and droop, and its turn along its length, so one shows its face to the light and the next its edge. Only some blades get an ink edge, and only on one side. Close to, a node is two rings (the sheath's scar, the branch ridge above it) with the pale powder band under it, a dark scar where a branch was below the crown, fine lines down the culm, moss and soil at its foot.

The light

The sun's light is real where it can be: the culms', stones' and steps' shadows from a shadow map near you; the land's own shadows (a cliff, a ridge, a bank shading the slope under it) and how much of the sky each point of the ground sees (its hollows, the foot of a bank) baked with each piece of the land as it's laid, by marching toward the sun and round the horizon over its heights, and darker again where it meets a stone, a step or a culm's foot. The shade under the canopy is real too. The leaves cast it: each spray's blades go into the same shadow map as the culms, the steps and the boulders, so near you the light on the floor is the true shadow of what hangs overhead, moving as the leaves move. Beyond the map's reach, each piece of land knows how much leaf is over each metre of its ground (from where its sprays really hang). There, the light is broken into flecks only as much as that cover closes, and the sky's light under a closed stand is dimmer than in a clearing. Each material has its own relief, drawn in the shader as a height in its own lie (its normal tipped by how the height changes across the screen, so it needs no maps or tangents) with the dark of its creases: the litter's leaves as thin blades lying one on another with the soil dark in the gaps; a bank's clods with cracks between and grooves down it where the rain runs; rock's bedding, ledge over ledge, each undercut dark, and its fractures; a stone's pitting and a crack or two; a step's tooling; a culm's node ridge, the groove above it and the fine grooves down it; a leaf's midrib. Every rise is spread over a few pixels wherever it's seen from, and the finest fade first, so nothing flickers. No fine relief tips a surface more than about 35°: a jump in a height across a pixel isn't a cliff, and its slope would be a dark dash. The bare floor is never flat either: a broad swell, lumps of earth, pebbles proud of it and, down a trail, the ruts feet have worn; and a boulder has broad weathered facets and chips as well as its pits. Its height darkens its own hollows and lifts its crowns, in the sun and in the shade alike, so it reads under the canopy too. Each describes one surface. The litter's colour, relief and creases share one measure of how much it covers, so a trail's worn middle is bare earth to the light as well as to the eye. A boulder's crack is a single field in the stone's own body: the ink draws it, the light finds it as a crease, and its dark gathers there. Each feature fades by the footprint of its own coordinates, so a steep face loses its detail as soon as the level does. relief (with the light, 0–8, 3 by default) sets how strong it all is.

The layers

How it's drawn is a stack of layers laid from the paper up, after Labyrinth's print, each with its own dials, and none moving another (client/bamboo/layers.ts):

A reach is a multiple of that measure, on a log scale from ×0.25 to ×4: under 1 leaves every edge of the frame to the paper; over 1 lets that layer run out to the frame. No mark ever comes or goes at once: each thing has its own amount of ink, never switched on or off. It's laid as a brush lays it, its length first, then its weight: a culm drawn up from its foot, a land stroke out from its middle (a broken line as one line with breaks in it, all its runs sharing one pick), a blade out from its stem, a stone from its middle to its sides. As the ink thins, things go out over their own short stretches of the reach, so there are fewer of them; as it fades, all of them go paler too. An outline where two kinds meet takes the stronger side's weight, so it never breaks into dots. The paper isn't a mask feathered over the picture: a culm, a spray, a stone, a stroke is left out whole, by its own pick, only where none of its layers reach it, and what's gone hides nothing behind it. Along a culm, an internode at a time, its colour gives way, then its light, then its ink; the ground goes leaf by fallen leaf, its edge dragged dry across the slope as a brush leaves it, and is never left out: past its layers it's the paper.

The house setting draws with the brush's hand (open and swell up) over the land's light as a pale wash. The path has its own marks (strokes.ts): broken tread lines where feet have gone, and what lies on it, twigs and fallen leaves as small curved commas, thicker toward its edges. Beside the route now and then stands a giant culm, stouter than the rest, the drawing's anchor: never a secondary stroke, its shaded side firm.

The 墨 button (bottom right) opens the palette: a slot for each layer, the one touched open with its sliders (a mark where the house setting has it; double-tap a name to put it back), and under page, the starts: house (the default), picture (every layer whole, out to the frame), drawing (no colour; the light on the paper; the ink), ink (the ink alone, out to the frame), page (all of it taken to the paper). Four more draw the same ink with different hands, at a reach that carries the grove: contour, brush, litho and wash (the brush's lines over pale washes of the land's light). The address keeps every dial that differs from the house, so a setting can be passed on.

Judged against the board

The look was found by image generation first (devtools/bamboo/explore.md: three rounds of prompts and what each taught). The reference frames are found on the mountain by what they need (?ref=a, the foot of a stair; ?ref=b, a trail with a fall beside it; ?ref=c, in the grove off the trails; ?ref=cliff, a rim; ?ref=run, mid-stride), and node cells/lab/devtools/bamboo-fidelity.mjs draws a, b and c and puts each beside its target. The views are made with node cells/lab/views.mjs bamboo.

The gates

The look is now hill-climbed against five target studies (devtools/bamboo/targets/, and gates.md there for what each is judged by: the contour run, culm scale, ink reach, the stair, a gust), in gates: 0, geometry and composition in plain colour with no marks; 1, the drawing alone, which must still carry the route and the bank; 2, the board as it's shown; 3, motion and finish. node cells/lab/devtools/bamboo-gates.mjs [gate…] draws each target beside its pinned scene (?cam=, never found afresh) three ways: picture, ink only, board.

Addresses

Every picture (12)

The run

Things you meet

How far it’s drawn

Looks