luvcraft/shaders.lisp
A matrix is representation; this is the meaning of the operation it participates in. The four dense rows arrive through the frame ABI, but applying them is a checked map from an affine cell-valued lattice point to homogeneous light clip. A separate checked projection produces the deliberately packed shadow sample tuple used by the fragment stage.
The knobs folded into these shaders. Each is a special this file's source names where it once held a literal; the parser folds the current value in, and the pipeline that folded it rebuilds when it moves (LUVCRAFT/KNOBS.LISP). Turning one is a shader rebuild, not a uniform write, so they are the few literals worth that: the ones art direction keeps asking about.
The sky's own knobs. Everything else about the sky arrives through the frame environment from the day profile; these four are the art direction the profile has no opinion about.
The surface knobs. A block face is one tile of a sixteen-texel atlas and a thousand of them are in view at once, so how far apart two faces of the same material drift, and how the light they return is split between the sun, the sky, and the ground, are the questions art direction actually asks about the world's materials.
What presentation does to the graded image after the filmic curve: the two grading controls every colourist reaches for first, and the lens's own small dispersion. They are folded literals rather than uniform lanes because they are art direction, changed by hand and then left.
Every stage which reads the frame environment declares the same uniform block at binding 2: identical member order and offsets are an ABI requirement, so the member list is written once and spliced at read time.
camera position, w unused
x scale, y scale, z scale, z offset
fog near, fog far, elapsed time, cloudiness
sun direction, day factor
sun colour, angular width
zenith colour, w target height in pixels
horizon colour, w target width in pixels
ambient colour, exposure
fog colour, w shadow diagnostic selector
texel u/v, base bias, slope bias
depth span, world/texel, min/max radius
atlas texel width, remaining lanes reserved
light-space clip x from world position
light-space clip y from world position
light-space depth from world position
light-space homogeneous w
The fragment stage shapes its own normal from where the fragment sits inside its cell, so it needs the world point rather than only the face's flat normal.
Homogeneous clip is a heterogeneous GPU representation: XYZ and W do not constitute one semantic vector quantity.
Projecting either field lowers the shared homogeneous map once. Keeping depth first preserves the established instruction order.
Resolve normalized atlas coordinates at vertex execution time. They are recomputed every draw from the renderer-owned width, but retain the old interpolation and exact half-texel endpoint values.
Four -1/0/1 edge classifications occupy one exact base-three scalar in the vertex stream. Unpack before interpolation; each face supplies the same code at all of its vertices.
The frame uniform block exactly as the vertex specification declares it.
Compile the camera transform and retain expression-to-SSA provenance.
World text is ordinary scene geometry. Its model transform has already placed each glyph quad in world coordinates; this stage applies the same camera view and perspective projection as block surfaces, while preserving the em-space coordinate and current projected pixel scale Slug consumes.
Dynamic dilation, after the reference's vertex stage: the quad grows past the outline by a fixed number of pixels, however large or small the glyph lands on screen, so the pixel filter's half-width is always inside it and no more. A vertex knows its own depth and the frame knows the target's height, which together give the pixel length of each em edge; the corner then slides outward along both edges by the dilation over that length. Em coordinates slide with it, so the outline stays where it was.
The instance record's three spare Z lanes carry the linear ink colour.
Terminal cell backgrounds are analytic world rectangles. The instance carries the exact painted rectangle; the vertex stage inflates the quad by a small margin and hands the fragment stage a rectangle-local coordinate, where the same signed-distance coverage as the GUI round-rects resolves the edge against the screen gradient. They share the text run's frame bind group and premultiplied blending.
Inflate by a fraction of the row height on every side so the antialiased edge has room to fall off outside the exact rectangle.
The terminal is a tube behind glass, drawn as three coplanar rectangles. This vertex stage serves the two outer ones: the phosphor plate beneath the cell backgrounds and glyphs, and the faceplate glass above them. Both want the same rectangle-local coordinate, the same world position for view-dependent shading, and the surface's own frame, so the stage hands down the normalized right and up edges alongside the outward normal. The instance layout stays the cell run's, with the fourth vector carrying the normal, so one vertex buffer description serves every terminal rectangle.
Where the tube's active area stops and its bezel begins is a fact about the panel, not about either material, so both stages ask the same two questions instead of repeating a literal that could drift apart.
The phosphor plate is the back of the tube: what the glyphs are painted on, and what remains when the terminal is blank. It is deliberately not the glass -- reflections belong on the faceplate above the text, where they can actually veil it -- so this stage only answers what the tube emits and how its recess and bezel catch the daylight of the world it hangs in.
Panel-local coordinates normalized to the corners, so the tube's falloff is a property of the picture rather than of its size.
The screen sits behind the bezel, so shade falls in from the lip, and a tube's own glass is brightest through the middle.
A faint idling phosphor: warm enough to read as a lit tube rather than a hole, dim enough to stay black next to any real glyph.
The bezel is matte dark plastic: a lit inner lip where it turns toward the screen, and a slightly brighter outer chamfer.
The faceplate is the glass in front of the picture, drawn last so that
everything it does happens *to* the text rather than behind it. It is the
whole analogue argument of the terminal, and every term in it is one
physical claim about a tube seen through coated glass:
- the raster is a fixed line count belonging to the panel, so it holds
still in the world instead of crawling with the camera, and it fades out before it can alias rather than shimmering at a distance;
- the glass is very slightly convex, expressed only as a bent normal,
so the room wraps around the rim while every glyph stays exactly where the glyph pass drew it -- curvature as light, not as geometry;
- mains hum and a little grain keep the picture from being perfectly
still, at amplitudes chosen to be felt rather than seen.
Premultiplied alpha makes one draw do both halves of that: the alpha lane attenuates the picture underneath (raster, corners, hum, grain) and the colour lane adds what the glass itself sends back (sky, sun, room).
A cubic bulge leaves the middle of the plate flat and turns only the last part of the way to the rim, which is what a real face does and what keeps the reflection from sliding about.
Schlick Fresnel for coated glass: a low floor rising toward grazing, so a frontal view stays dark and an oblique one lights up.
The mirrored view ray samples the same two-colour sky gradient the sky dome draws, so the glass reflects the day it stands in.
A tight glint plus a broad sheen; the bent normal drags both of them into a curved streak near the rim.
The raster: a fixed number of lines across this panel's height, exactly as a tube has a fixed line count whatever its diagonal.
Below two pixels a line cannot be drawn, only aliased, so the raster leaves rather than turning into moire at a distance.
Attenuating the picture is only half of a raster. A tonemapped frame puts bright text on the shoulder of the filmic curve, where a multiply barely moves it, and puts a dark terminal's background near black, where a multiply moves it not at all. So the tube's own idle glow below carries the beam instead: energy-preserving about one, so the raster shapes that glow without lighting it.
A slow bar drifting up the picture and a fast shimmer on top of it: the two ways a tube betrays the mains it is plugged into.
Grain is resampled a couple of dozen times a second rather than every frame, so it reads as emulsion instead of as a frame rate.
The corners of a tube are always darker than its middle, and this is the one such falloff that also reaches the text.
Glass scatters a little of the room forward instead of reflecting all of it, and a tube idles with a little phosphor of its own. Together they lift the black off the floor -- the difference between a screen and a hole in the wall -- and because the corner falloff multiplies them, this is where the shape of the tube actually becomes visible on an otherwise dark terminal.
The phone's screen is not a tube. It is a sheet of flat glass over a dark panel, and everything the wall's faceplate argues about -- raster, hum, grain, the tube's convex bulge and its darker corners -- is exactly what a retina slab does not have. What it has instead is a rounded edge, a Fresnel reflection of the sky it is held under, one tight glint, and, because someone has been holding it, fingerprints: patches of oil that scatter a little of the room forward where clean glass would not. Both stages below share the wall's vertex stage; only the material is the phone's own.
Signed distance from a panel-local point to the rounded glass edge, negative inside. RADIUS is the corner radius in world cells.
The panel behind the glass: black, and lit only by what little the room puts into it. Off, it should read as a dark mirror.
Coated glass: dark seen straight on, a mirror seen at a slant.
Fingerprints. Oil on the glass scatters light forward over a broad lobe where the clean coating would send it away, so the smudges only appear where there is light to scatter -- near the sun's sheen and at a slant to the sky -- and never as paint.
The glass takes nothing away from the picture under it: alpha zero, and only what it sends back is added.
A video screen is the plainest world rectangle luvcraft draws: the same instance record as a terminal cell, but the fragment stage reads a decoded picture instead of computing a material. The picture is the only thing on it, so there is no shading model here at all -- the texture is sRGB and the hardware decode hands the scene target the linear radiance it wants.
The one non-obvious line is the flipped V. A quad corner runs from zero at the bottom to one at the top, and a decoded frame's first row is its top, so a screen that did not flip would play the film upside down.
The scene pass writes raw radiance: exposure and the filmic curve belong to the post chain, so a screen that emits its own picture writes the decoded picture and stops there.
A portal is another game's picture arriving on a wall, and it should read as exactly that: a transmission, not a window and not a movie. The panel is the whole terminal face; the picture sits inside it on a dark matte with the same margin the text grid keeps, so the wall's proportions do not change when the shell becomes a portal. What marks the picture as coming from elsewhere is done to its signal, not to the glass (the faceplate above still supplies raster, hum, and reflections as it does for text):
- the colour channels do not quite converge -- a radial chromatic
fringe, nothing at the centre and a few texels at the corners;
- alternate lines are displaced by a texel or so on a slow beat, a
field interlace that never fully locks;
- a soft sync bar climbs the picture, brighter than the hum bar the
glass adds, so the two are visibly different mechanisms;
- the picture warms up over half a second when the link opens instead
of appearing, and its edge is a thin phosphor line on the matte.
The uniform carries the picture rectangle in panel UV and the moment the link opened; everything else is the frame environment's clock.
picture u0, v0, u1, v1 within the panel
opened-at seconds, texel u, texel v, unused
Panel UV to picture UV; the picture is where both lie in [0,1].
Warm-up: half a second from black to picture.
Field interlace: odd picture lines drift a texel sideways on a slow beat, even lines the other way, never quite locking.
The odd field is a shade dimmer than the even one, so the interlace shows as texture where the weave alone would not.
Chromatic fringe: red and blue pulled apart radially, growing with the square of the distance from the centre.
The sync bar: a soft band climbing the picture every few seconds.
A little vignette of the picture's own, inside the frame.
The matte and its phosphor edge. Distance to the picture edge in panel UV; the edge line is a couple of texels wide and glows a little further into the matte.
VideoToolbox's ordinary bi-planar output is video-range NV12. Sampling the two CVMetalTextures performs no copy; this matrix is the only colour conversion between the decoder surface and the HDR scene target.
--- the shaped surface ------------------------------------------- A block face is flat geometry, but it should not read as a flat material. Two shapings ride on the same face: a bevel that rounds the last sixth of a cell toward its edge, and a per-texel relief read straight out of the atlas the material is already painted in. Both are pure normal perturbation, so no mesh changes.
A block face's own normal selects its two in-plane world axes, so one expression serves all six faces without a branch.
The atlas coordinate and its screen derivative size both shapings. The normal itself is already the central difference of the same procedural relief field that paints the colour atlas.
Texels per pixel: one cell is TILE-TEXELS of them.
Both shapings are sub-block detail, so both have to fade out as soon as they stop resolving on screen; otherwise distant terrain sparkles and shows a lit grid instead of a surface. One measured footprint drives both, at their own scales.
The mesher's edge classification decides what each boundary does. A convex edge rounds the surface over; a concave one fillets it into the inner corner; a flush one -- the middle of an open plain, where the face simply continues into an identically oriented neighbour -- leaves the surface alone. Signs come straight from the vertex lane, so the same ramp expression serves all three.
A round-over is only legible if it is a few pixels wide. Held to a fixed fraction of a cell it dwindles to nothing a short way off, and every block in the middle distance flattens back into a card; grown with the footprint it keeps its shape until it is genuinely too small to resolve. The upper bound stops it from eating the face it is supposed to be an edge of.
An inner corner is a crevice, and a crevice gathers occlusion. Only the filleted edges contribute; a rounded-over outer edge is more exposed than the face it belongs to, not less.
One linear texture read replaces the four height taps formerly used here. The CPU generator clamps those taps within each tile, normalizes the result, and stores the source height in alpha for inspection. Fade the decoded tangent normal back toward the flat face as its texels become sub-pixel.
A real round-over is an arc, not a leaning plane. Adding a scaled tangent to the face normal can only ever reach the arctangent of that scale, so a strong edge needs an implausible scale and still bunches its shading into the last sliver. Rotating the normal through an angle instead sweeps it evenly from the face toward the edge, which is what a fillet of that radius actually does. The guarded denominator matters: over the flat middle of a face the lean is exactly zero, and the angle is zero with it.
--- the weathering ----------------------------------------------- The atlas has one tile per material and the world has thousands of faces per tile, so on its own every grass block is the same card seen again. Three fields fix that and none of them costs a texel: a hash of the cell a face belongs to, constant across that face and different on the next one; value noise over the world point itself, which knows nothing about where faces begin and so drifts across a whole plain the way real ground does; and a grain finer than a cell whose own gradient leans the surface, so the ground is not merely painted unevenly but lit unevenly. The cell is found by stepping half a cell back along the face's own normal, which lands inside the block whichever of the six faces this is. #3AVEKC
Two more taps of the same grain, a step along each of the face's own in-plane axes: their differences are the field's gradient there, which is exactly the tilt a bump of it would give.
Brighter patches are also warmer and duller ones cooler, and a face's own constant drifts its hue as well as its value: a plain of grass wants to be many greens, not one green at many brightnesses.
The grain is a cell-wide feature, so it survives to the distance a cell does rather than the distance a texel does.
--- the micro-surface -------------------------------------------- The atlas normal is this material's own slope at texel scale, and the best evidence available about what happens below a texel: a steep texel is a rough material. When the relief fades out with distance its variance has to go somewhere, and the honest place is the roughness -- Toksvig's argument -- so a highlight keeps its size across the draw distance instead of sharpening into a sparkle on every distant face at once. #2T8CCH
A PCF tap displaced across a receiver plane must compare against that plane's depth at the tap, not the center fragment depth. With the orthographic shadow rows, the analytical UV depth gradient is the face normal expressed in the light basis and scaled by the world-span/depth-span ratio. Its denominator is bounded only near grazing incidence, where direct sun is negligible. This prevents wide kernels from reading the receiver's own slope as an occluder.
A surface turned away from the light has no shadow decision to make: its own geometry already excludes the sun, the receiver plane's depth runs almost parallel to the light so every filter tap lands a large and increasingly ill-conditioned distance away, and the map's answer degenerates into noise. Near noon that is every vertical face in the world at once, which is why the shimmer was worst there. Fading the decision out toward "lit" exactly where it stops meaning anything costs nothing visually -- the same cosine multiplies the direct term to zero -- and gives the specular lobe and the diagnostic a stable value instead of the noise.
The lower edge is where the receiver-plane denominator above starts being clamped: SHADOW-FORWARD is the negated sun, so that dot product is exactly -N-DOT-L, and the clamp engages precisely below 0.05. The two mechanisms therefore hand over rather than overlap, and the clamp never has to carry a visible decision.
The mesh carries normalized raw light readings; every response curve and balance below is an art parameter editable live without remeshing the world.
Lateral skylight gives ambient visibility but not a hard sun beam; the shadow map gates only the direct solar term.
--- the deck's shadow -------------------------------------------- The sky draws a cumulus deck on a plane at a fixed world height, and the ground under it should know. Following the sun up from this point to that plane and asking the very same field the very same coverage question is the whole of it: the deck's own shadow sweeping across the world, which is what keeps a plain at noon from being one flat sheet of light. The threshold is wider than the sky's, because a shadow thrown from that far off is blurred by the sun's own angular width long before it lands. #RSGLTL
Occlusion bites harder than the raw mesh reading: the corner where three blocks meet is what tells the eye these are solid volumes.
--- what is not the sun ------------------------------------------ Everything above a face that is not the sun is still the sky, and the sky is not one colour: a face turned up sees the zenith, a face turned sideways sees the horizon, and a face turned down sees what the ground bounced. One interpolation over the normal's own vertical component is the whole of it, and it is the difference between blocks standing in a world and blocks floating in a grey room. The profile's ambient colour stays in the mixture: it is the art direction's say over light the geometry cannot explain.
A small floor keeps unlit geometry barely readable rather than a void; caves stay dark for the right reason. The ambient term is deliberately weaker, and the sun correspondingly stronger, than a display-referred renderer could afford: the filmic curve on presentation is what brings the sunlit half back down.
--- the microfacet lobe ------------------------------------------ One GGX lobe off the shaped normal, with Smith's height-correlated visibility and a dielectric's Fresnel: blocks are not metal, so four per cent at normal incidence and the whole of it at a grazing one. The roughness above decides everything about its shape, so a polished face and a tufted one differ here without differing anywhere else.
Smith's height-correlated visibility already carries the 1/(4 cos cos) the microfacet specular would otherwise divide by.
The cosine belongs in the specular lobe as much as in the diffuse one: without it a highlight can appear on a face the sun cannot reach, carrying whatever the shadow map happened to say there.
The same sky again, in the direction the surface actually reflects: the sheen that tells a smooth face from a rough one out of the sun, and the one term that makes a block look like it is standing under this weather rather than under a light bulb.
Distant terrain fades into exactly the colour the sky's own ground half arrives at, warmed where the ray runs toward a low sun: the aerial perspective that puts a mile of air between here and the horizon.
Compile the block material and retain its expression-to-SSA provenance.
Lower the readable block material to luv's structured SPIR-V module.
The sky is a fullscreen triangle drawn before block geometry with depth writes disabled. Its vertex stage reconstructs a per-corner view ray from the camera basis; its fragment stage is pure image mathematics over the interpolated ray and the frame environment lanes.
Invert the block vertex projection: clip x,y back to view-space slopes, including its y flip, so the ray agrees with the world. These coordinates are measured from clip-space's zero origin. Representation makes that origin choice explicit and erased: no runtime subtraction is needed to treat either coordinate as a displacement before scaling it back into view space.
Lattice value noise is the whole procedural vocabulary this file needs: a hash of an integer lattice index, trilinear smoothing between its corners, and a few octaves with the domain rotated between them so the cubic grain never reads as a grid. It is written once here and reused by the cloud decks, the star field, the moon's maria, and the weathering that makes one block face differ from the next.
Hash one integer lattice site into the unit interval.
Deliberately trigonometry-free, and deliberately a function of the whole site rather than of a collapsed scalar index. Hashing x + 57y + 113z through a sine makes every plane of constant index share a hash, and at star-field frequencies those planes are plainly visible as streaks across the sky. Folding the site's own components against each other has no preferred direction, and costs less than a sine besides.
Three octaves of value noise; the domain rotates to hide the lattice.
The fold's state carries the rotating sample point and the running sum together, so the noise body is emitted once and executed three times rather than inlined three times.
Four octaves of the same noise: a cloud deck's shape down to its wisps.
A deck's silhouette is decided by the first octave and its edges by the last, so this is the one place in the sky worth paying for a fourth. The weights are the same halving series, renormalized, so the field still spans the unit interval and a coverage threshold means the same thing it does with three.
The Henyey-Greenstein phase function: how much light a haze sends on at COSINE off its original direction, for a medium of the given ASYMMETRY.
One expression replaces the two fitted powers the sky used to brighten around the sun. A phase function's shape is the reason a low sun has a huge soft glow and a high one a tight one: the same medium, the same number, a different angle.
The colour something arbitrarily far away takes, seen along DIRECTION.
Distant terrain and the sky's own ground half must agree exactly, or the edge of the resident world draws itself as a line. They agree by asking this: the profile's fog colour, warmed where the ray runs toward a low sun and brightened by the same haze the sky's halo is made of, so a ridge in the east at dawn glows and one in the west stays cool. #8X33G2
One star per lattice cell of the sky, at a hashed place in its cell.
Value noise raised to a power -- what the star field used to be -- makes smooth blobs the size of its own lattice, and they smear into streaks wherever the interpolation runs along a cell edge. A star is a point, so this hashes the cell to a position, a magnitude, and a twinkling phase, and draws a small gaussian around it. Magnitude is a steep power of its hash: a few bright stars and a great many faint ones, which is the actual distribution overhead.
Keep the star off its cell's boundary so no star is ever cut in half by the next cell's gaussian falling off first.
The sky is image mathematics over a view ray and the frame environment. What it argues is that everything up there is one atmosphere seen at different depths:
- the vertical gradient runs the whole way from horizon to zenith
rather than resolving in the first few degrees, because that is what the optical depth along a ray actually does;
- haze thickens toward the horizon, and the sunrise band it carries
belongs to the sun's own quarter of the compass, not all the way round;
- one Henyey-Greenstein phase function, evaluated at two asymmetries,
is the whole glow around the sun;
- two cloud decks, each a plane at a fixed height, so the ray meets
them farther out the closer it runs to level: thin cirrus far above, and the cumulus sheet whose own shadow, sampled once along the deck toward the sun, gives it a lit face and a dark underside;
- at night, points for stars, a band for the galaxy, and the moon
opposite the sun;
- a compact solar disc pushed well past display white so the lens
chain has something real to bloom.
Everything below the horizon arrives at the exact fog colour distant terrain fades to, so silhouettes meet the sky without a seam, and only then darkens -- gently, because a stronger falloff shows up as a step where the last resident chunk ends. #9SSXDJ records why an HDR path wants a sky with something genuinely bright in it, and #8X33G2 what each of these terms replaced.
One number decides how much of the sky is sunrise: a sun near the horizon warms the haze, the scatter, and the cloud faces together.
The sun's half of the sky, measured on the ground plane: a sunrise band belongs in the east, and the west should stay blue.
--- the atmosphere --------------------------------------------- The vertical gradient is the sky's own colour at depth; a small exponent spreads it across the whole hemisphere instead of resolving it in the first few degrees, which is what an optical depth along the ray actually does.
A sunrise is sunlight that has come the long way through the atmosphere, so the band it paints is the sun's own colour at that hour, laid exactly where the ray runs both low and toward it. Away from the sun's quarter of the compass the sky stays its own colour, which is what keeps the west blue while the east burns.
--- night ------------------------------------------------------
The galaxy is a great circle of the sky, so one fixed axis and the ray's distance from its plane is the whole band.
The moon rides opposite the sun, which puts it up for exactly the hours the sun is not, and always full: the simple sky this world wants, and the one that lights its nights.
The component of the ray across the moon's own direction, in units of its radius: the disc's face, which the maria are painted on.
--- the cloud decks --------------------------------------------
The deck is a plane at a fixed height in the world, not a fixed height above the camera: the ground has to be able to find the same plane along the sun and read the same field there, or the shadows sweeping over it would belong to some other sky. #RSGLTL
Coverage is the profile's cloudiness against the knob; the edge softens toward the horizon, where a deck's detail is far smaller than a pixel and a hard edge could only shimmer.
What lies between this piece of deck and the sun, sampled along the deck itself: the shape's own shadow, and so its lit face.
Silver lining: thin edges facing the sun glow, dense cores do not.
After sunset a deck is lit by the sky alone, so it takes the sky's own colour; a neutral grey at one twentieth reads warm against a night zenith and the eye calls it dust.
A deck recedes into the same haze the sky's own horizon does.
--- the ground half -------------------------------------------- Below the horizon this shader stands in for terrain too far off to be resident, so it must arrive at exactly the colour distant terrain fades to. It may still say where the land is: the ray's own meeting with the ground plane gives a point to sample, and a wide, weak relief over it keeps the lower half from being one flat wall of fog. The relief fades out at the horizon, where the plane runs away faster than a pixel can resolve it.
--- the sun ---------------------------------------------------- The disc is drawn at a few times the sun's true angular radius, the way every game sun is, and deliberately far above display white: the floating point attachment keeps it, the bright pass feeds on it, and the filmic curve rolls it into a hot core instead of a flat clipped patch. For a small angle the cosine threshold of an angular radius is one less half its square.
A star's disc is brightest at its centre; without the limb darkening a sun drawn this large reads as a sticker.
Presentation is where linear scene radiance becomes a display image. The scene attachment is floating point, so a sun disc or a specular glint arrives far above display white; the lens stack composes in that linear space, exposure scales it, and a filmic curve rolls it off. Screen center lies on the framed terminal, so its depth is the focus plane; only farther fragments receive the wide nine-tap blur. The HUD is drawn afterward, already graded, straight onto the presentation image.
The presentation stages share one small uniform block, written once per
frame by luvcraft-post-uniform-data. Member order is an ABI requirement
exactly as it is for the frame environment, so it is written once here.
texel u, texel v, focus blur, exposure
bloom gain, shaft gain, vignette, threshold
sun screen u, v, on-screen weight, diagnostic
chain texel u, v, shaft decay, elapsed time
output texel u, v, reserved, reserved
Narkowicz's fitted ACES curve. Its toe keeps shadows from turning to mud, its shoulder compresses the sun and the crystal glow into a hot core instead of a flat clipped patch, and it desaturates highlights the way film does.
The bloom and light-shaft chain runs on a quarter-resolution pair of floating-point attachments. Bright fragments are extracted once, blurred separably, and then swept radially away from the solar disc; presentation adds both back into linear scene radiance before the filmic curve. Every stage sees the same bind group shape -- source texture, linear sampler, presentation uniforms -- so one layout serves the whole chain, and the stage that reads it is chosen by CLOS role rather than by a mode lane. #IC14P3 records the shape this stack took and where it left its plan.
Four scene taps per chain texel. The chain is a quarter of the frame's width, so a single tap would alias exactly the highlights this pass exists to smear.
The chain works in exposed units, so its contribution stays in step with the scene when exposure moves.
A thirteen-tap gaussian expressed as seven linearly filtered samples: each offset lands between the two texels whose weights it combines. The host runs the pair twice, which convolves the kernel with itself and puts the standing deviation at about four chain texels -- a wide, soft glow rather than a halo tight enough to read as an outline. The two directions are separate roles rather than a uniform lane, so each pipeline is exactly the code it runs.
Crepuscular rays as a screen-space gather: march the blurred bright image toward the solar disc and accumulate what is still lit, attenuating with distance. Terrain that occludes the sun is dark in the bright image, so the rays break into beams around leaves and rooftops for free. The host fades SUN-SCREEN's weight out as the disc leaves the frame.
World-space application panels keep their semantic GPU geometry at native presentation density. Their depth is compared with the deliberately lower-density game depth below, without asking either attachment domain to masquerade as the other.
A lens does not focus every wavelength on the same circle, and the error grows with the distance off axis. Three taps a fraction of a texel apart is the whole of it: nothing at the centre of the frame, a hair of colour at its corners.
A transparent clear has alpha zero, but the strict comparison also keeps the depth clear from becoming a surface in front of sky.
The chain already carries exposed units; the scene does not.
The two grading controls a colourist reaches for first, in the order they belong in: saturation about the image's own luminance, then contrast as a blend toward a smoothstep, which steepens the midtones without ever clipping either end the way a gain about a pivot would.
A restrained corner falloff; the frame should feel photographed, not port-holed.
Eight bits per channel cannot hold a sky gradient: a wide, slowly changing surface crosses a quantization step every few dozen pixels and the eye reads the step as a contour. Interleaved gradient noise, scaled so it is about half a step wherever the image sits on the transfer curve, turns the contour into a grain too fine to see.
The shadow diagnostic is a measurement, not a picture: when the scene pass writes raw visibility instead of radiance, exposure, the filmic curve, the lens chain, the grade, and the vignette would each distort exactly the quantity being measured, so presentation hands the value straight through.
The presentation uniform block exactly as the post stage declares it.
The shadow-map pass renders the same block mesh into stored light-space depth. The block fragment material samples that product with explicit percentage-closer filtering and receiver bias above.
The crosshair is deliberately another tiny mathematical material rather than a magic fixed-function colour. Its positions and ink are dense vertex data, so the shared graph needs no backend-specific vertex-index operation.
The software cursor is one quad carrying a cursor-local coordinate; the arrow itself is a signed distance field the fragment stage evaluates. A pointer is nearly all long diagonals, so triangle soup stairsteps badly at any size, and its silhouette, its outline, its rounded corners and its drop shadow all fall out of thresholds of the one distance.
How wide the pointer's dark border is, in design units.
Chosen against the corner radius rather than on its own: the white body is the silhouette inset by this much, so its corners keep whatever rounding the difference between the two leaves them.
The pointer's visible corners, tip first, in its own design grid.
The tip is the hotspot, so it sits at the origin exactly. Rounding does not move any of these: a corner's arc is tangent to both its edges and reaches back out to the corner itself, which is why this table can be read as the shape you see rather than as a construction for it.
A the tip, and the hotspot B the heel, foot of the vertical left edge C where the tail leaves the head D the tail's outer corner E the tail's inner corner F where the tail rejoins the head G foot of the diagonal right edge
Move every edge of outline inward by radius and meet the corners again.
Growing the distance to this back by radius restores outline with each convex
corner replaced by an arc of that radius. A reflex corner offsets outward
instead and so stays crisp, which is what the notch between head and tail
wants.
Source for the exact signed distance from point to the polygon corners.
The pointer's notch is reflex, so the distance is taken the general way -- nearest point over every edge, sign from a crossing count -- rather than by intersecting half planes, which would quietly shave the notch off.
-1 when a ray from POINT crosses the outline edge between P and Q, else 1.
Multiplying one of these per edge counts the crossings, so the product is negative exactly inside the outline however it winds.
Signed distance from POINT to the pointer, negative inside.
The corners are rounded off by LUVCRAFT-CURSOR-CORNER-RADIUS, which is what
keeps the heel, the shoulder and the tail from reading as the barbs of a fir
tree, and what leaves the white body still curved once its dark outline has
disappeared into a dark background.
One pixel measured in the cursor's own units, so the same source resolves its edges wherever the arrow is scaled to.
A soft shadow down and to the right lifts the arrow off bright sky and pale inventory panels alike without a second silhouette.
The silhouette, and the white body inset from it by the outline. The body keeps whatever rounding the outline width leaves it, so the two widths are chosen together.
The body is not flat white but carries a little light along its length: warm and bright at the tip, where the eye is meant to go, cooling as it falls back into the tail.
Premultiplied: the arrow covers its own share and the shadow only darkens whatever the arrow itself left uncovered.
--------------------------------------------------------------------- The physics bodies as spheres, drawn the honest way.
Every ball, marble, drop, and gobbet is really a sphere in the physics, and here it finally looks like one: each body is a camera-facing quad whose fragments send an exact ray at the analytic sphere -- one closed quadratic, no marching -- and shade the true surface point with the true normal. The instance stream carries the body's centre and radius, its orientation quaternion, an albedo and emission the CPU resolved from the body-kind palette, and the sampled voxel light levels. Patterns are painted in the body's own frame: the fragment carries the world normal back through the quaternion's conjugate, so a ball's band, a beach ball's panels, and a smiley's face all tumble as the body rolls.
The lowering has no fragment-depth output, so the quad cannot write the sphere's own depth. Instead the vertex stage slides the proxy toward the eye by one radius: its depth is then conservatively near for every point on the sphere, and a ball resting in a hollow is not eaten by the terrain in front of its centre plane. The draw itself tests depth without writing it and blends premultiplied, with the CPU handing over instances farthest first.
VECTOR carried into the body's own frame: a turn by SPIN's conjugate.
The physics keeps a unit quaternion (x y z w) purely for the eye. A pattern painted on the body's own axes therefore visibly turns with the body when the world-space surface normal is unspun through the quaternion before the pattern reads it.
The classic ball's pale band: a latitude ring in the pattern frame, so it sweeps visibly over the ball as it rolls.
Six panels meeting at the poles, without an arc tangent.
Three half-planes at sixty degrees classify the pattern-frame longitude: one sector satisfies exactly one of them and its neighbour exactly two, so the count alternates white with colour around the ball, and which pair holds names the colour. A small white cap covers each pole, where every panel converges the way a real beach ball's cap does.
Two eyes and a smile on the pattern frame's +z half, so the face tumbles.
The features are placed by direction from the centre, the same trick the gnome's face uses: a direction does not care what radius the ball was drawn at. The smile is the lower arc of a ring around a point above the mouth, masked to the face's lower half.
The proxy plane slides toward the eye by one radius, stopping short of the eye itself: its interpolated depth is then nearer than any point of the sphere, so the depth test against terrain can only err by letting a hidden ball show through a sliver, not by eating a resting ball at its contact circle.
Exactly the half-extent the silhouette needs from the slid plane, capped so a ball against the eye stays finite.
Fog is measured once at the centre; a body is small enough to take one answer, and the quadratic law matches the terrain's.
The closed-form ray/sphere meeting: no march for a quadric.
The pattern frame: the normal unspun by the body's quaternion.
The block world's light, in miniature: the sampled voxel levels response-curved the same way, the same sun gate, the same dome and torch colours, a wrapped diffuse in place of the flat one.
One soft lobe for rubber, a tight bright one for glass, and a glassy rim only the marble wears.
The same aerial perspective the terrain fades into.
Premultiplied, so a missed fragment leaves no trace of the quad.
(name &key domain-type domain-quantity domain-dimension domain-unit
domain-affine-p sample-type sample-components
coordinate-scale coordinate-offset)How many times its true angular radius the sun's disc is drawn at.
The disc's radiance above display white, which the bloom feeds on.
The direct sun's diffuse intensity on a lit block face.
How far a terminal faceplate's normal bulges toward its rim.
Raster lines across a terminal faceplate's height.
How dark the raster's gaps go, as a fraction of the picture.
The most a faceplate's raster, hum, flicker, and grain may take.
(name (&key label (group :grading) documentation
(class ''scalar-knob)
quantity (type 'single-float)
unit-label minimum maximum step)
place)Define NAME as a knob of CLASS over the setf-able PLACE. PLACE may refer to SESSION, so a knob can live on the session -- its sky clock, its player -- as well as in a special. QUANTITY is a quantity plist as DEFINE-QUANTITY-CONSTANT takes, (:quantity ... :unit ...); it and TYPE make the knob's declaration, which…
How strongly the atmosphere's phase function brightens the sun's quarter.
The profile's cloudiness against art direction; one leaves it alone.
The radiance of a first-magnitude star, above display white.
The full moon's radiance above display white; the bloom feeds on it.
The cumulus deck's world height, which both the sky and the ground read.
How much of the direct sun a cloud takes from the ground beneath it.
How far the procedural weathering moves one face away from the next.
The whole palette's micro-roughness against what its relief implies.
How much of the sun's microfacet lobe a block surface returns.
How much of the ground's own colour a downward face is lit by.
How far the lens splits red from blue at the corners, in texels.
Saturation of the presented image, one being the filmic curve's own.
How far the presented image is pulled toward an S-curve.
(generic-function name specialized-lambda-list options &body body)Define a shader-producing method with ordinary DEFMETHOD identity. Calling the method reparses its small source form so changes to source-level abstractions participate in live rebuilding. Method replacement remains the role/stage identity watched by the MOP; abstraction revisions are tracked separately by live…
(role stage)Return the current durable shader specification for ROLE and STAGE.
Select and reorder vector components by a designator such as :XYZ or :RGB.
Subtraction or unary negation.
The inner product of two vectors.
Name a compatible derived quantity.
Multiplication and scalar scaling.
Addition over compatible quantities.
Expose a quantity's raw representation.
Project a homogeneous map application into its declared sampling product.
Apply a named projective map to a semantic affine point.
Division of two represented quantities.
One descriptor-backed uniform block with ordered, inspectable members.
(specification)(module)The maximum of compatible quantities.
The componentwise square root of a raw value.
State external meaning for a raw value.
(name parameters &body body)Define a reusable typed shader expression with ordinary source syntax. The body is parsed at each call site, so argument types and quantity meanings flow through the same operator protocol as handwritten shader expressions. LET* is lexical inside the function. The definition macro records source; its body does not…
The minimum of compatible quantities.
The componentwise absolute value of a raw value.
Produce dimensionless progress across compatible edges.
Normalize a dimensionless vector.
Interpolate compatible quantities by a scalar amount.
Constrain a quantity between compatible bounds.
Raise a dimensionless value to a dimensionless power.
Hash one integer lattice site into the unit interval. Deliberately trigonometry-free, and deliberately a function of the whole site rather than of a collapsed scalar index. Hashing x + 57y + 113z through a sine makes every plane of constant index share a hash, and at star-field frequencies those planes are plainly…
Signed distance from a panel-local point to the rounded glass edge, negative inside. RADIUS is the corner radius in world cells.
Three octaves of value noise; the domain rotates to hide the lattice. The fold's state carries the rotating sample point and the running sum together, so the noise body is emitted once and executed three times rather than inlined three times.
Sample a two-dimensional texture through a sampler at a UV coordinate.
Compare compatible quantities and produce dimensionless values.
Construct a meaningful literal.
Four octaves of the same noise: a cloud deck's shape down to its wisps. A deck's silhouette is decided by the first octave and its edges by the last, so this is the one place in the sky worth paying for a fourth. The weights are the same halving series, renormalized, so the field still spans the unit interval and a…
The colour something arbitrarily far away takes, seen along DIRECTION. Distant terrain and the sky's own ground half must agree exactly, or the edge of the resident world draws itself as a line. They agree by asking this: the profile's fog colour, warmed where the ray runs toward a low sun and brightened by the same…
(&key (code t))The Henyey-Greenstein phase function: how much light a haze sends on at COSINE off its original direction, for a medium of the given ASYMMETRY. One expression replaces the two fitted powers the sky used to brighten around the sun. A phase function's shape is the reason a low sun has a huge soft glow and a high one a…
One star per lattice cell of the sky, at a hashed place in its cell. Value noise raised to a power -- what the star field used to be -- makes smooth blobs the size of its own lattice, and they smear into streaks wherever the interpolation runs along a cell edge. A star is a point, so this hashes the cell to a…
(session width height
&optional (presentation-width width) (presentation-height height))Pack the presentation environment: texel sizes, lens gains, and the sun. Lane order must match *POST-UNIFORM-MEMBERS* exactly; the construction-time check in LUVCRAFT-POST-UNIFORM-SIZE keeps the two honest.
Test whether one compatible scalar is less than another.
How far the pointer's convex corners are rounded, in design units.
How wide the pointer's dark border is, in design units. Chosen against the corner radius rather than on its own: the white body is the silhouette inset by this much, so its corners keep whatever rounding the difference between the two leaves them.
()The pointer's visible corners, tip first, in its own design grid. The tip is the hotspot, so it sits at the origin exactly. Rounding does not move any of these: a corner's arc is tangent to both its edges and reaches back out to the corner itself, which is why this table can be read as the shape you see rather than…
(name lambda-list &body body)Define NAME as a source-level shader abstraction. The expansion body receives the destructured call operands and returns a raw shader source form made from core operators or other abstractions.
(from to)(outline radius)Move every edge of OUTLINE inward by RADIUS and meet the corners again. Growing the distance to this back by RADIUS restores OUTLINE with each convex corner replaced by an arc of that radius. A reflex corner offsets outward instead and so stays crisp, which is what the notch between head and tail wants.
Test whether two compatible scalars are equal.
The non-negative remainder of integer division.
(point corners)Source for the exact signed distance from POINT to the polygon CORNERS. The pointer's notch is reflex, so the distance is taken the general way -- nearest point over every edge, sign from a crossing count -- rather than by intersecting half planes, which would quietly shave the notch off.
-1 when a ray from POINT crosses the outline edge between P and Q, else 1. Multiplying one of these per edge counts the crossings, so the product is negative exactly inside the outline however it winds.
Signed distance from POINT to the pointer, negative inside. The corners are rounded off by +LUVCRAFT-CURSOR-CORNER-RADIUS+, which is what keeps the heel, the shoulder and the tail from reading as the barbs of a fir tree, and what leaves the white body still curved once its dark outline has disappeared into a dark…
VECTOR carried into the body's own frame: a turn by SPIN's conjugate. The physics keeps a unit quaternion (x y z w) purely for the eye. A pattern painted on the body's own axes therefore visibly turns with the body when the world-space surface normal is unspun through the quaternion before the pattern reads it.
The classic ball's pale band: a latitude ring in the pattern frame, so it sweeps visibly over the ball as it rolls.
Six panels meeting at the poles, without an arc tangent. Three half-planes at sixty degrees classify the pattern-frame longitude: one sector satisfies exactly one of them and its neighbour exactly two, so the count alternates white with colour around the ball, and which pair holds names the colour. A small white cap…
Two eyes and a smile on the pattern frame's +z half, so the face tumbles. The features are placed by direction from the centre, the same trick the gnome's face uses: a direction does not care what radius the ball was drawn at. The smile is the lower arc of a ring around a point above the mouth, masked to the face's…
The atlas has one tile per material and the world has thousands of faces per tile, so #CHUKWD's relief only made every grass block the same card seen again in better light. Three fields now make each face its own, and none of them costs a texel. A hash of the cell a face belongs to is constant across that face…
The block material's specular was one fitted power under a Fresnel weight. It is an ordinary microfacet lobe now --- GGX distribution, Smith's height-correlated visibility in the form that already carries the 1/(4\cos\theta_l\cos\theta_v), Schlick's Fresnel at a dielectric's four per cent --- which would be…
The cumulus deck used to be a plane a fixed distance above the camera, sampled in camera-relative coordinates: clouds at infinity, which is a perfectly good cheat until something on the ground wants to know about them. It is a plane at a fixed height in the world now. The sky finds it along the view ray; the block…
An HDR path only pays for itself if something in the frame is genuinely bright, and a two-colour gradient with a soft disc is not. The sky fragment stage became image mathematics over the view ray and the frame environment: a shaped vertical gradient between the profile's horizon and zenith colours, a warm low band…
#9SSXDJ gave the sky something worth tone mapping. What it drew was still a gradient with weather painted over it, and five of its terms were wrong in the same way: each was a fitted curve standing where a physical argument was available. – The vertical gradient resolved inside the first few degrees above level,…
The plan of #SKHDR is built, and the shape it took is worth recording because two of its decisions were made by the implementation rather than by the plan. The scene attachment is :rgba16-float and every scene-stage pipeline targets it: block surfaces, the sky triangle, world text, the terminal wall's glyph and cell…
The visible block-world materials as typed mathematical specifications.
These shader methods are luvcraft's hot-replaceable source of truth: the live pipelines watch their CLOS role/stage coordinates through MOP dependents and rebuild on redefinition. The crosshair vertex stage at the end is a literal SPIR-V module rather than a mathematical specification.