libraryextensions/scene/demos/Voxels.xtl

the side of a chunk

the cells of a chunk, 16 cubed

block 0: air

block 1: stone, below the dirt

block 2: dirt, three below the grass

block 3: grass, on top

block 4: sand, where grass would be at or below the water

block 5: water, filling air below its level (not solid)

block 6: wood, a tree's trunk

block 7: leaves, a tree's crown

the blocks' names, in their order

      ᵛˣ⁼u̲se< "Voxels"

      ᵛˣnames
air stone dirt grass sand water wood leaves

a character for each block when a chunk is printed, air first: stone #, dirt %, grass ", sand :, water ~, wood |, leaves *

every cell's x (east), as a vector in the chunk's order (x slowest)

      ᵛˣ⁼u̲se< "Voxels"

      18 t̲ake ᵛˣxs
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

every cell's y (up), in the chunk's order

every cell's z (south), in the chunk's order (z fastest)

      ᵛˣ⁼u̲se< "Voxels"

      18 t̲ake ᵛˣzs
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1

vx:h_ills phase: a 16 by 16 height field (x by z), rolling hills of heights 3 to 12; the phase shifts them

vx:c_hunk h: the chunk on a height field h (x by z): grass on top, three of dirt, stone below; water fills air below 7, and sand replaces grass at or below it; one tree on the hill at (4, 4) when it stands above the water

vx:c_ounts b: how many of each block, air first

x vx:s_ide b: the slice at x, as characters, up at the top

a column value (x by z) at every cell of its column

vx:t_op b: what is seen from above: the highest non-air block of each column (x by z) -- the top's height by a max-reduction down each column, then the block there picked by comparing heights

the cells' coordinates as 16 by 16 by 16 arrays

a solid block is any but air and water

the exposed faces in the six directions -- west, east, down, up, north, south: numbered 0 to 5 -- as a 6 by 4096 Boolean array: a solid cell whose neighbor that way is not solid. The neighbor is a rotation along the axis (the six rotations of the Life idiom) with the plane that wrapped around made air: beyond the border is air.

water's surface: water with air above it, facing up

d r_ows mb: the faces of one direction as 5 rows -- x, y, z of the cell, the direction, the block -- from mb, the mask times 1 + the block (so one array carries both)

vx:f_aces b: every face to draw, one row each -- x y z direction block -- the six directions' exposed faces, then water's surface

vx:c_ount f: how many faces in each direction (west east down up north south); a single block shows one face each way:

      ᵛˣ⁼u̲se< "Voxels"

      one ← 16 16 16 r̲eshape (ᵛˣxs = 8) × (ᵛˣys = 8) × ᵛˣzs = 8

      ᵛˣc̲ount ᵛˣf̲aces one
1 1 1 1 1 1

the corners of each direction's face, from its cell's corner, taken in pairs round the square (1 2, 2 3, 3 4, 4 1): x, y, z, 6 by 8 each

vx:e_dges f: the faces' outlines as segments for scene: 8 points a face (4 edges, 2 points each), n*8 by 3, the chunk centered on the origin and scaled to -1..1

each block's color, red green blue (air first)

vx:c_orners f: each face's four corners in order round it, n*4 by 3, in blocks -- the quads scene draws for the faces

vx:q_uads f: the faces as filled quads for scene, a chunk centered on the origin and scaled to -1..1, like vx:e_dges

value noise, made by linear algebra: random heights on a grid every s blocks, interpolated to n by n -- M G M', M the n by k hat-function weights of each grid line

vx:h_eights n: an n by n height field (x by z), three octaves of value noise -- every 16, 8 and 4 blocks -- from 4 to 29 (seeded)

a world's cells' coordinates, for a shape nx ny nz (x slowest)

vx:t_errain h: the world on a height field h (nx by nz), 32 tall: grass, dirt, stone, water filling air below 14, sand at the shore -- the chunk's rules, over the whole world

t vx:t_ree b: a tree at column t (x z) when it stands on grass: a trunk of 4 and a crown of leaves, placed into b -- only the tree's own cells are worked out (their indexes into b), then set by a membership mask, so a tree costs little in a big block

vx:w_orldFaces b: every face of a world, one row each -- x y z direction block -- as vx:f_aces does for a chunk, the borders of the world air

vx:c_hunkOf f: the chunk of each face (1 up): x, z and y in 16s

ts vx:f_orest b: trees at the columns ts (n by 2: x z), each where it stands on grass -- vx:t_ree folded over them

a grid point's random value, 0 to 1, from its coordinates alone (i by j, any integers): the same point always gets the same value, so any part of an endless world can be made by itself and fits its neighbors

      ᵛˣ⁼u̲se< "Voxels"

      (3 ᵛˣh̲ash 4) = 3 ᵛˣh̲ash 4
1

vx:h_eightsAt x0 z0 n: the heights of the n by n columns from block (x0, z0), x by z, of the endless world: three octaves of value noise (every 32, 16 and 8 blocks), 3 to 29, the sea at 14 -- any square anywhere, always the same

vx:p_atch c: column c (cx cz) of the endless world, 16 by 32 by 16 blocks: made with a border of one block from its neighbors' heights, so its faces at the border hide where a neighbor is solid; trees (two places hashed from the column, kept inside it). A box of its faces (world coordinates, one row each: x y z direction block) and a box of its solid mask (16 by 32 by 16, flat, x slowest)

vx:c_olumnBlocks c: the blocks of column c (cx cz) of the endless world with a border of one from its neighbors, 18 by 32 by 18: the heights, the terrain's rules, two trees placed by hash -- the first of the three parts of making a column (about 12 ms)

vx:c_olumnMask b: the solid mask of a column's own cells (16 by 32 by 16, flat, x slowest), from its blocks

c vx:c_olumnFaces b: the faces of column c's own cells, in world coordinates, one row each (x y z direction block) -- found over the block with its border, so faces against a solid neighbor hide; the second part of making a column