/*
 * vectordesert - an infinite wire-mesh vector desert flythrough
 *
 * A retro "vector graphics" landscape: vast wireframe plains, occasional
 * vector mountain ranges, and saguaro cacti built entirely out of square
 * wire-mesh frames. Everything (terrain included) is drawn as square
 * wireframe loops.
 *
 * Controls and settings are documented in README.md and printed at startup.
 */

#include <GLFW/glfw3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdint.h>
#include <ctype.h>
#include <math.h>

#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

/* ------------------------------------------------------------------ */
/* tiny vector math                                                    */
/* ------------------------------------------------------------------ */
typedef struct { float x, y, z; } V3;

static V3 v3(float x, float y, float z){ V3 r={x,y,z}; return r; }
static V3 add(V3 a, V3 b){ return v3(a.x+b.x, a.y+b.y, a.z+b.z); }
static V3 sub(V3 a, V3 b){ return v3(a.x-b.x, a.y-b.y, a.z-b.z); }
static V3 scl(V3 a, float s){ return v3(a.x*s, a.y*s, a.z*s); }
static V3 cross3(V3 a, V3 b){
    return v3(a.y*b.z - a.z*b.y,
              a.z*b.x - a.x*b.z,
              a.x*b.y - a.y*b.x);
}
static float dot3(V3 a, V3 b){ return a.x*b.x + a.y*b.y + a.z*b.z; }
static float len3(V3 a){ return sqrtf(a.x*a.x + a.y*a.y + a.z*a.z); }
static V3 norm3(V3 a){ float l=len3(a); if(l<1e-6f) return v3(0,1,0); return scl(a,1.0f/l); }

/* rotate v around unit axis by angle (Rodrigues) */
static V3 rotateAround(V3 v, V3 axis, float ang){
    float c = cosf(ang), s = sinf(ang);
    V3 t1 = scl(v, c);
    V3 t2 = scl(cross3(axis, v), s);
    V3 t3 = scl(axis, dot3(axis, v) * (1.0f - c));
    return add(add(t1, t2), t3);
}

static float clampf(float v, float lo, float hi){ return v<lo?lo:(v>hi?hi:v); }
static float lerpf(float a, float b, float t){ return a + (b-a)*t; }
static float smoothstepf(float e0, float e1, float x){
    float t = clampf((x-e0)/(e1-e0), 0.0f, 1.0f);
    return t*t*(3.0f-2.0f*t);
}

/* ------------------------------------------------------------------ */
/* hashing + value noise                                               */
/* ------------------------------------------------------------------ */
static uint32_t hashi(int x, int y){
    uint32_t h = (uint32_t)(x*374761393) + (uint32_t)(y*668265263);
    h = (h ^ (h >> 13)) * 1274126177u;
    h ^= h >> 16;
    return h;
}
static float hashf(int x, int y){
    return (hashi(x,y) & 0xffffffu) / (float)0xffffff;
}

static float valnoise(float x, float y){
    int xi = (int)floorf(x), yi = (int)floorf(y);
    float xf = x - xi, yf = y - yi;
    float v00 = hashf(xi,   yi);
    float v10 = hashf(xi+1, yi);
    float v01 = hashf(xi,   yi+1);
    float v11 = hashf(xi+1, yi+1);
    float u = xf*xf*(3.0f-2.0f*xf);
    float v = yf*yf*(3.0f-2.0f*yf);
    return lerpf(lerpf(v00, v10, u), lerpf(v01, v11, u), v);
}

/* fractal brownian motion in [0,1] */
static float fbm(float x, float y, int oct){
    float sum = 0.0f, amp = 0.5f, norm = 0.0f;
    for(int i=0;i<oct;i++){
        sum  += amp * valnoise(x, y);
        norm += amp;
        x *= 2.0f; y *= 2.0f; amp *= 0.5f;
    }
    return sum / norm;
}

/* ------------------------------------------------------------------ */
/* user settings                                                       */
/* ------------------------------------------------------------------ */
typedef struct {
    float terrainHue;      /* 0..1 */
    float mountainFreq;    /* how often ranges appear (scale)          */
    float mountainRough;   /* 0 = smooth domes .. 1 = jagged peaks     */
    float mountainMinH;    /* height of the low parts of a range       */
    float mountainMaxH;    /* height of the tallest peaks              */
    float cactusFreq;      /* 0..1 probability a cell holds a cactus   */
    float cactusSizeVar;   /* 0..1 random size spread                  */
    float cactusMinSize;   /* smallest allowed cactus height           */
    float cactusMaxSize;   /* largest allowed cactus height            */
    float cactusHue;       /* 0..1 */
    int   maxArms;         /* arms on the largest cacti                */
} Settings;

static Settings S = {
    .terrainHue   = 0.075f,   /* desert orange/tan */
    .mountainFreq = 1.0f,
    .mountainRough= 0.5f,
    .mountainMinH = 6.0f,
    .mountainMaxH = 26.0f,
    .cactusFreq   = 0.35f,
    .cactusSizeVar= 0.55f,
    .cactusMinSize= 4.0f,
    .cactusMaxSize= 12.0f,
    .cactusHue    = 0.33f,    /* green */
    .maxArms      = 5,
};

#define ARM_LIMIT 12

/* ------------------------------------------------------------------ */
/* terrain                                                             */
/* ------------------------------------------------------------------ */
static float terrainHeight(float x, float z){
    /* The default state of the world is a near-flat desert plain with only
     * very gentle undulation. */
    float plains = (fbm(x*0.02f, z*0.02f, 3) - 0.5f) * 2.0f;

    /* Mountain ranges are coherent low-frequency blobs at a *fixed* spatial
     * scale (so a range stays a sensibly sized range). The user's
     * mountainFreq controls how much of the plain those ranges cover, i.e.
     * how frequently the plain is interrupted: higher freq -> lower
     * threshold -> ranges appear more often. */
    float mask = valnoise(x*0.006f, z*0.006f);
    float thr  = clampf(0.80f - 0.11f*S.mountainFreq, 0.35f, 0.86f);
    float mountainMask = smoothstepf(thr, thr+0.10f, mask);
    if(mountainMask <= 0.0f) return plains;

    /* Base frequency scaled by range height keeps slopes proportional for
     * short and tall ranges alike (no-op at the default max height). */
    float bf = 0.05f * (26.0f / fmaxf(S.mountainMaxH, 1.0f));

    /* Accumulate a ridged multifractal. The first octave is the broad mass;
     * the remaining octaves add higher-frequency jagged detail riding on the
     * existing crests. */
    float freq=bf, amp=0.5f, sum=0.0f, norm=0.0f, weight=1.0f, mass=0.0f;
    for(int i=0;i<6;i++){
        float n = 1.0f - fabsf(2.0f*valnoise(x*freq, z*freq) - 1.0f);
        n *= n;
        if(i==0) mass = n;            /* broad base shape                   */
        n *= weight;                  /* detail only rides on existing ridge*/
        weight = clampf(n*2.5f, 0.0f, 1.0f);
        sum  += n*amp;
        norm += amp;
        freq *= 2.0f; amp *= 0.5f;
    }
    float jagged = clampf(sum / norm, 0.0f, 1.0f);

    /* A mesa: saturate the broad mass so its top clamps to a flat plateau
     * with steeper sides. */
    float mesa = clampf((mass - 0.25f) * 3.2f, 0.0f, 1.0f);

    /* mountainRough morphs flat-topped mesas (0) into jagged peaks (1) */
    float ridge = lerpf(mesa, jagged, S.mountainRough);

    /* ridge (0..1) maps the range between the user's min and max heights */
    float body = lerpf(S.mountainMinH, S.mountainMaxH, ridge);
    return plains + mountainMask * body;
}

/* ------------------------------------------------------------------ */
/* color: HSV -> RGB                                                   */
/* ------------------------------------------------------------------ */
static V3 hsv2rgb(float h, float s, float v){
    h = h - floorf(h);
    float i = floorf(h*6.0f);
    float f = h*6.0f - i;
    float p = v*(1.0f-s);
    float q = v*(1.0f-s*f);
    float t = v*(1.0f-s*(1.0f-f));
    switch(((int)i)%6){
        case 0: return v3(v,t,p);
        case 1: return v3(q,v,p);
        case 2: return v3(p,v,t);
        case 3: return v3(p,q,v);
        case 4: return v3(t,p,v);
        default:return v3(v,p,q);
    }
}

/* ------------------------------------------------------------------ */
/* camera matrices (no GLU dependency)                                 */
/* ------------------------------------------------------------------ */
static void perspectiveGL(float fovyDeg, float aspect, float znear, float zfar){
    float fH = tanf(fovyDeg * (float)M_PI / 360.0f) * znear;
    float fW = fH * aspect;
    glFrustum(-fW, fW, -fH, fH, znear, zfar);
}

static void lookAtGL(V3 eye, V3 center, V3 up){
    V3 f = norm3(sub(center, eye));
    V3 s = norm3(cross3(f, up));
    V3 u = cross3(s, f);
    float m[16] = {
        s.x,  u.x, -f.x, 0.0f,
        s.y,  u.y, -f.y, 0.0f,
        s.z,  u.z, -f.z, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f
    };
    glMultMatrixf(m);
    glTranslatef(-eye.x, -eye.y, -eye.z);
}

/* ------------------------------------------------------------------ */
/* fog (distance fade)                                                 */
/* ------------------------------------------------------------------ */
static V3 camPos;
static float g_viewRadius = 128.0f;   /* rendering distance (runtime)   */
#define FOG_NEAR 18.0f

/* fog reaches full opacity a little inside the draw radius so the mesh
 * edge fades into the sky instead of popping */
static float fogFarDist(void){
    float f = g_viewRadius - 8.0f;
    return f < FOG_NEAR + 5.0f ? FOG_NEAR + 5.0f : f;
}

/* ------------------------------------------------------------------ */
/* line batch: collect every wireframe segment into one vertex+colour  */
/* array so a whole frame's geometry ships in a single glDrawArrays.   */
/* Distance fade is done by hardware fog, not per-vertex on the CPU.   */
/* ------------------------------------------------------------------ */
typedef struct { float *v; float *c; int n, cap; } Batch;

static void batchEnsure(Batch *b, int extra){
    if(b->n + extra <= b->cap) return;
    int nc = b->cap ? b->cap : 8192;
    while(nc < b->n + extra) nc *= 2;
    b->v = (float*)realloc(b->v, (size_t)nc*3*sizeof(float));
    b->c = (float*)realloc(b->c, (size_t)nc*3*sizeof(float));
    b->cap = nc;
}
static inline void batchVert(Batch *b, float x, float y, float z, const V3 *col){
    int i = b->n++;
    b->v[i*3]=x; b->v[i*3+1]=y; b->v[i*3+2]=z;
    b->c[i*3]=col->x; b->c[i*3+1]=col->y; b->c[i*3+2]=col->z;
}
static inline void batchSeg(Batch *b, V3 a, V3 q, const V3 *col){
    batchEnsure(b, 2);
    batchVert(b, a.x,a.y,a.z, col);
    batchVert(b, q.x,q.y,q.z, col);
}
static void batchDraw(const Batch *b){
    if(b->n <= 0) return;
    glEnableClientState(GL_VERTEX_ARRAY);
    glEnableClientState(GL_COLOR_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, b->v);
    glColorPointer(3, GL_FLOAT, 0, b->c);
    glDrawArrays(GL_LINES, 0, b->n);
    glDisableClientState(GL_COLOR_ARRAY);
    glDisableClientState(GL_VERTEX_ARRAY);
}

/* ------------------------------------------------------------------ */
/* vector stroke font (for the HUD)                                    */
/* Each glyph is a set of line segments on a 0..4 (x) by 0..6 (y) grid */
/* ------------------------------------------------------------------ */
#define GLY(name) static const float name[] =
GLY(gA){0,0,2,6, 2,6,4,0, 1,2,3,2};
GLY(gB){0,0,0,6, 0,6,3,6, 0,3,3,3, 0,0,3,0, 3,6,3,3, 3,3,3,0};
GLY(gC){4,6,1,6, 1,6,0,5, 0,5,0,1, 0,1,1,0, 1,0,4,0};
GLY(gD){0,0,0,6, 0,6,2,6, 2,6,4,4, 4,4,4,2, 4,2,2,0, 2,0,0,0};
GLY(gE){4,6,0,6, 0,6,0,0, 0,0,4,0, 0,3,3,3};
GLY(gF){4,6,0,6, 0,6,0,0, 0,3,3,3};
GLY(gG){4,6,1,6, 1,6,0,5, 0,5,0,1, 0,1,1,0, 1,0,4,0, 4,0,4,3, 4,3,2,3};
GLY(gH){0,0,0,6, 4,0,4,6, 0,3,4,3};
GLY(gI){1,6,3,6, 2,6,2,0, 1,0,3,0};
GLY(gJ){4,6,4,1, 4,1,3,0, 3,0,1,0, 1,0,0,1};
GLY(gK){0,0,0,6, 4,6,0,3, 0,3,4,0};
GLY(gL){0,6,0,0, 0,0,4,0};
GLY(gM){0,0,0,6, 0,6,2,3, 2,3,4,6, 4,6,4,0};
GLY(gN){0,0,0,6, 0,6,4,0, 4,0,4,6};
GLY(gO){1,0,3,0, 3,0,4,2, 4,2,4,4, 4,4,3,6, 3,6,1,6, 1,6,0,4, 0,4,0,2, 0,2,1,0};
GLY(gP){0,0,0,6, 0,6,3,6, 3,6,3,3, 3,3,0,3};
GLY(gQ){1,0,3,0, 3,0,4,2, 4,2,4,4, 4,4,3,6, 3,6,1,6, 1,6,0,4, 0,4,0,2, 0,2,1,0, 2,2,4,0};
GLY(gR){0,0,0,6, 0,6,3,6, 3,6,3,3, 3,3,0,3, 0,3,4,0};
GLY(gS){4,5,3,6, 3,6,1,6, 1,6,0,5, 0,5,1,3, 1,3,3,3, 3,3,4,1, 4,1,3,0, 3,0,1,0, 1,0,0,1};
GLY(gT){0,6,4,6, 2,6,2,0};
GLY(gU){0,6,0,1, 0,1,1,0, 1,0,3,0, 3,0,4,1, 4,1,4,6};
GLY(gV){0,6,2,0, 2,0,4,6};
GLY(gW){0,6,1,0, 1,0,2,4, 2,4,3,0, 3,0,4,6};
GLY(gX){0,0,4,6, 0,6,4,0};
GLY(gY){0,6,2,3, 4,6,2,3, 2,3,2,0};
GLY(gZ){0,6,4,6, 4,6,0,0, 0,0,4,0};
GLY(g0){1,0,3,0, 3,0,4,2, 4,2,4,4, 4,4,3,6, 3,6,1,6, 1,6,0,4, 0,4,0,2, 0,2,1,0, 0,1,4,5};
GLY(g1){1,4,2,6, 2,6,2,0, 1,0,3,0};
GLY(g2){0,5,1,6, 1,6,3,6, 3,6,4,5, 4,5,4,4, 4,4,0,0, 0,0,4,0};
GLY(g3){0,6,3,6, 3,6,4,5, 4,5,3,3, 2,3,3,3, 3,3,4,2, 4,2,3,0, 3,0,1,0, 1,0,0,1};
GLY(g4){3,0,3,6, 3,6,0,2, 0,2,4,2};
GLY(g5){4,6,0,6, 0,6,0,3, 0,3,3,3, 3,3,4,2, 4,2,4,1, 4,1,3,0, 3,0,1,0, 1,0,0,1};
GLY(g6){4,5,3,6, 3,6,1,6, 1,6,0,4, 0,4,0,1, 0,1,1,0, 1,0,3,0, 3,0,4,1, 4,1,4,2, 4,2,3,3, 3,3,0,3};
GLY(g7){0,6,4,6, 4,6,1,0};
GLY(g8){1,3,3,3, 1,3,0,4, 0,4,0,5, 0,5,1,6, 1,6,3,6, 3,6,4,5, 4,5,4,4, 4,4,3,3, 3,3,4,2, 4,2,4,1, 4,1,3,0, 3,0,1,0, 1,0,0,1, 0,1,0,2, 0,2,1,3};
GLY(g9){0,1,1,0, 1,0,3,0, 3,0,4,2, 4,2,4,5, 4,5,3,6, 3,6,1,6, 1,6,0,5, 0,5,0,4, 0,4,1,3, 1,3,4,3};
GLY(gDot){2,0,2,1};
GLY(gDash){1,3,3,3};
GLY(gColon){2,1,2,2, 2,3,2,4};
GLY(gPct){0,0,4,6, 0,5,1,4, 3,2,4,1};
GLY(gSlash){0,0,4,6};
GLY(gLBrk){3,6,1,6, 1,6,1,0, 1,0,3,0};
GLY(gRBrk){1,6,3,6, 3,6,3,0, 3,0,1,0};
GLY(gEq){0,2,4,2, 0,4,4,4};
GLY(gComma){2,1,1,-1};
#undef GLY

/* returns number of segments and sets *out to the segment array */
static int glyphFor(char c, const float **out){
    #define R(arr) do{ *out = arr; return (int)(sizeof(arr)/(4*sizeof(float))); }while(0)
    switch(c){
        case 'A': R(gA); case 'B': R(gB); case 'C': R(gC); case 'D': R(gD);
        case 'E': R(gE); case 'F': R(gF); case 'G': R(gG); case 'H': R(gH);
        case 'I': R(gI); case 'J': R(gJ); case 'K': R(gK); case 'L': R(gL);
        case 'M': R(gM); case 'N': R(gN); case 'O': R(gO); case 'P': R(gP);
        case 'Q': R(gQ); case 'R': R(gR); case 'S': R(gS); case 'T': R(gT);
        case 'U': R(gU); case 'V': R(gV); case 'W': R(gW); case 'X': R(gX);
        case 'Y': R(gY); case 'Z': R(gZ);
        case '0': R(g0); case '1': R(g1); case '2': R(g2); case '3': R(g3);
        case '4': R(g4); case '5': R(g5); case '6': R(g6); case '7': R(g7);
        case '8': R(g8); case '9': R(g9);
        case '.': R(gDot); case '-': R(gDash); case ':': R(gColon);
        case '%': R(gPct); case '/': R(gSlash); case '[': R(gLBrk);
        case ']': R(gRBrk); case '=': R(gEq); case ',': R(gComma);
        default: *out = NULL; return 0;   /* space / unknown */
    }
    #undef R
}

/* draw a string; (x,y) is the top-left of the text cell, in pixels */
static void drawText(const char *s, float x, float y, float sc){
    float pen = x;
    for(const char *p=s; *p; ++p){
        char c = (char)toupper((unsigned char)*p);
        const float *g; int n = glyphFor(c, &g);
        if(n){
            glBegin(GL_LINES);
            for(int i=0;i<n;i++){
                glVertex2f(pen + g[i*4+0]*sc, y + (6.0f - g[i*4+1])*sc);
                glVertex2f(pen + g[i*4+2]*sc, y + (6.0f - g[i*4+3])*sc);
            }
            glEnd();
        }
        pen += 5.0f*sc;
    }
}

/* ------------------------------------------------------------------ */
/* heads-up display                                                    */
/* ------------------------------------------------------------------ */
static void drawHUD(int fbw, int fbh, float alpha){
    float sc = fbh / 240.0f;
    if(sc < 2.0f) sc = 2.0f;
    float lineH = 9.0f * sc;
    float x = 4.0f * sc;
    float y = 4.0f * sc;

    /* 2D overlay, no depth */
    glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity();
    glOrtho(0.0, fbw, fbh, 0.0, -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);  glPushMatrix(); glLoadIdentity();
    glDisable(GL_DEPTH_TEST);
    glDisable(GL_FOG);

    char buf[64];

    /* title */
    glColor4f(0.95f, 0.85f, 0.35f, alpha);
    drawText("VECTOR DESERT", x, y, sc*1.1f);
    y += lineH*1.6f;

    glColor4f(0.55f, 1.0f, 0.75f, alpha);
    #define LINE(...) do{ snprintf(buf,sizeof(buf),__VA_ARGS__); \
                          drawText(buf, x, y, sc); y += lineH; }while(0)
    LINE("1/2  TERRAIN HUE   %.2f", S.terrainHue);
    LINE("3/4  MTN FREQ      %.2f", S.mountainFreq);
    LINE(",/.  MTN ROUGH     %.2f", S.mountainRough);
    LINE("T/Y  MTN MIN H     %.0f", S.mountainMinH);
    LINE("U/I  MTN MAX H     %.0f", S.mountainMaxH);
    LINE("5/6  CACTUS FREQ   %.2f", S.cactusFreq);
    LINE("7/8  SIZE VAR      %.2f", S.cactusSizeVar);
    LINE("J/K  MIN SIZE      %.1f", S.cactusMinSize);
    LINE("N/M  MAX SIZE      %.1f", S.cactusMaxSize);
    LINE("9/0  CACTUS HUE    %.2f", S.cactusHue);
    LINE("-/=  MAX ARMS      %d",   S.maxArms);
    LINE("[/]  RENDER DIST   %.0f", g_viewRadius);
    #undef LINE

    /* camera + window controls footer */
    y += lineH*0.5f;
    glColor4f(0.45f, 0.70f, 0.85f, alpha);
    drawText("WASD MOVE  ARROWS PAN  PGUP/DN ALT  F FULL", x, y, sc*0.85f);

    glEnable(GL_FOG);
    glEnable(GL_DEPTH_TEST);
    glMatrixMode(GL_PROJECTION); glPopMatrix();
    glMatrixMode(GL_MODELVIEW);  glPopMatrix();
}

/* ------------------------------------------------------------------ */
/* drawing: square wire-mesh tube                                      */
/* ------------------------------------------------------------------ */
static void perpBasis(V3 n, V3 *u, V3 *v){
    V3 a = (fabsf(n.y) < 0.99f) ? v3(0,1,0) : v3(1,0,0);
    *u = norm3(cross3(a, n));
    *v = cross3(n, *u);
}

/* Draw a wire-mesh tube with a (ribbed) circular cross-section that follows
 * an arbitrary centerline. The cross-section frame is parallel-transported
 * along the path so it never twists, which lets arms curve smoothly. The
 * polygonal rings read as the vertical ribs/flutes of a saguaro. */
#define MAX_PTS  64
#define MAX_SIDES 16

static void appendTube(Batch *b, const V3 *pts, const float *rad, int n,
                       int sides, const V3 *col){
    if(n < 2) return;
    if(sides > MAX_SIDES) sides = MAX_SIDES;
    if(sides < 3) sides = 3;

    V3 prevDir = norm3(sub(pts[1], pts[0]));
    V3 u, v; perpBasis(prevDir, &u, &v);

    V3 prevRing[MAX_SIDES];

    for(int i=0;i<n;i++){
        /* tangent at this point */
        V3 d;
        if(i==0)        d = norm3(sub(pts[1], pts[0]));
        else if(i==n-1) d = norm3(sub(pts[i], pts[i-1]));
        else            d = norm3(sub(pts[i+1], pts[i-1]));

        /* parallel-transport the frame from prevDir to d */
        if(i>0){
            V3 ax = cross3(prevDir, d);
            float s = len3(ax);
            if(s > 1e-5f){
                ax = scl(ax, 1.0f/s);
                float ang = atan2f(s, dot3(prevDir, d));
                u = rotateAround(u, ax, ang);
                v = rotateAround(v, ax, ang);
            }
        }
        prevDir = d;

        /* build the ring */
        V3 ring[MAX_SIDES];
        for(int k=0;k<sides;k++){
            float a = 2.0f*(float)M_PI * k / sides;
            V3 off = add(scl(u, cosf(a)*rad[i]), scl(v, sinf(a)*rad[i]));
            ring[k] = add(pts[i], off);
        }

        batchEnsure(b, sides*4);
        for(int k=0;k<sides;k++)                       /* ring loop */
            batchSeg(b, ring[k], ring[(k+1)%sides], col);
        if(i>0)                                        /* longitudinal ribs */
            for(int k=0;k<sides;k++)
                batchSeg(b, prevRing[k], ring[k], col);
        for(int k=0;k<sides;k++) prevRing[k] = ring[k];
    }
}

/* ------------------------------------------------------------------ */
/* cactus                                                              */
/* ------------------------------------------------------------------ */
/* one saguaro arm: starts on the trunk surface, curves outward through a
 * quarter circle, then rises straight up to a rounded tip. */
static void appendArm(Batch *b, V3 attach, V3 dir, V3 up, float bendR,
                      float upLen, float ra, const V3 *col, int sides){
    V3 pts[MAX_PTS];
    float rad[MAX_PTS];
    int n = 0;

    const int nb = 6;                 /* points along the bend */
    for(int j=0;j<=nb;j++){
        float a = (float)j/nb * (float)M_PI*0.5f;
        V3 p = add(attach, add(scl(dir, sinf(a)*bendR),
                               scl(up, (1.0f-cosf(a))*bendR)));
        pts[n] = p; rad[n] = ra; n++;
    }
    /* straight vertical section */
    V3 bendTop = pts[n-1];
    const int nu = 5;
    for(int j=1;j<=nu;j++){
        float t = (float)j/nu;
        pts[n] = add(bendTop, scl(up, upLen*t));
        /* taper to a rounded tip */
        rad[n] = ra * (t < 0.8f ? 1.0f : lerpf(1.0f, 0.18f, (t-0.8f)/0.2f));
        n++;
    }
    appendTube(b, pts, rad, n, sides, col);
}

/* build one saguaro into the batch. `dist` is its distance from the camera,
 * used to drop ring facets (level of detail) on far-off cacti. */
static void buildCactus(Batch *b, float wx, float wz, float dist){
    /* deterministic per-cell randomness */
    int cx = (int)floorf(wx);
    int cz = (int)floorf(wz);
    uint32_t hh = hashi(cx*3, cz*7);

    float r0 = ((hh        ) & 0xffff) / (float)0xffff;

    /* size: variation spreads around the midpoint of the user's min/max
     * bounds, so the result is always constrained to [minSize, maxSize]. */
    float mid    = (S.cactusMinSize + S.cactusMaxSize) * 0.5f;
    float spread = (S.cactusMaxSize - S.cactusMinSize) * 0.5f * S.cactusSizeVar;
    float minH   = mid - spread;
    float maxH   = mid + spread;
    float H      = lerpf(minH, maxH, r0);

    /* normalized size -> arm count. smaller = fewer, larger = more. */
    float tsize = (maxH - minH > 1e-3f) ? (H - minH)/(maxH - minH) : 0.5f;
    int arms = (int)lroundf(tsize * S.maxArms);
    if(arms < 0) arms = 0;
    if(arms > S.maxArms) arms = S.maxArms;
    if(arms > ARM_LIMIT) arms = ARM_LIMIT;

    float ground = terrainHeight(wx, wz);
    V3 base = v3(wx, ground, wz);
    V3 up   = v3(0,1,0);
    float rt = 0.35f + 0.03f*H;          /* slender trunk */
    V3 col = hsv2rgb(S.cactusHue, 0.7f, 0.9f);

    /* level of detail by distance */
    int   tSides = (dist < 90.0f) ? 10 : (dist < 160.0f ? 7 : 5);
    int   aSides = (dist < 90.0f) ?  8 : 5;
    float rscale = (dist < 90.0f) ? 1.0f : (dist < 160.0f ? 0.6f : 0.4f);

    /* trunk: tapered fluted column with a rounded dome at the top */
    V3 tpts[MAX_PTS];
    float trad[MAX_PTS];
    int nT = (int)(H*rscale) + (rscale < 1.0f ? 3 : 6);
    if(nT < 3) nT = 3;
    if(nT > MAX_PTS) nT = MAX_PTS;
    for(int i=0;i<nT;i++){
        float t = (float)i/(nT-1);
        tpts[i] = add(base, scl(up, t*H));
        float r = rt * (1.0f - 0.20f*t);             /* gentle taper */
        if(t > 0.92f)                                 /* dome the very top */
            r *= sqrtf(clampf(1.0f - powf((t-0.92f)/0.08f, 2.0f), 0.0f, 1.0f));
        trad[i] = fmaxf(r, 0.02f);
    }
    appendTube(b, tpts, trad, nT, tSides, &col);

    /* arms: spread around the trunk, attaching in the mid/upper region */
    for(int i=0;i<arms;i++){
        uint32_t ah = hashi(cx*13 + i*101, cz*17 - i*53);
        float a0 = ((ah        ) & 0xffff)/(float)0xffff;
        float a1 = ((ah >> 10  ) & 0xffff)/(float)0xffff;

        float angle = (i * (2.0f*(float)M_PI / (arms>0?arms:1))) + a0*0.8f;
        V3 dir = v3(cosf(angle), 0.0f, sinf(angle));

        float hf   = lerpf(0.35f, 0.62f, a1);         /* attach height frac */
        float yh   = H*hf;
        float rAtt = rt * (1.0f - 0.20f*hf);          /* trunk radius there */
        V3 attach  = add(base, add(scl(up, yh), scl(dir, rAtt*0.7f)));

        float ra    = rt * 0.62f;
        float bendR = H * 0.10f;
        float upLen = H * (0.28f + 0.18f*a0) * (1.0f - hf*0.4f);

        appendArm(b, attach, dir, up, bendR, upLen, ra, &col, aSides);
    }
}

/* ------------------------------------------------------------------ */
/* terrain + scene rendering                                           */
/* ------------------------------------------------------------------ */
#define CELL          2.5f    /* finest terrain quad size                  */
#define CACTUS_CELL   3.0f
#define TERRAIN_CELLS 360     /* budget: max cells across the view diameter*/

/* Cached scene geometry. The terrain and cactus meshes are rebuilt only
 * when a relevant setting changes or the camera leaves the region the
 * cache covers; every other frame is just two glDrawArrays calls. */
static Batch gTerr, gCacti;

static struct {
    bool  ok;
    float cx, cz, radius, hueT, mFreq, mRough, mMinH, mMaxH, margin;
} tk;                          /* terrain cache key */
static struct {
    bool  ok;
    float cx, cz, radius, freq, sizeVar, minS, maxS, hue, margin;
    int   arms;
} ck;                          /* cactus cache key */

/* terrain LOD: cell size grows with the rendering distance so the cell
 * count (and therefore the work) stays bounded no matter how far we draw */
static float terrainCell(void){
    return fmaxf(CELL, (2.0f*g_viewRadius)/(float)TERRAIN_CELLS);
}

static void buildTerrain(float cx, float cz, float margin){
    gTerr.n = 0;
    float cell = terrainCell();
    float reach = fogFarDist() + margin + 2.0f*cell;  /* world half-extent */
    int   nx   = (int)ceilf((2.0f*reach)/cell) + 1;
    if(nx > 700) nx = 700;                            /* hard safety cap */
    float ox = floorf((cx - reach)/cell)*cell;
    float oz = floorf((cz - reach)/cell)*cell;
    float cull = fogFarDist() + margin + cell;        /* emit within here  */
    float cull2 = cull*cull;

    /* one height + colour per grid vertex, computed once and shared by the
     * (up to) four edges that touch it -- no redundant terrainHeight calls */
    static float *hgt=NULL,*cr=NULL,*cg=NULL,*cb=NULL; static int hcap=0;
    int nv = nx*nx;
    if(nv > hcap){
        hcap = nv;
        hgt = (float*)realloc(hgt, (size_t)nv*sizeof(float));
        cr  = (float*)realloc(cr,  (size_t)nv*sizeof(float));
        cg  = (float*)realloc(cg,  (size_t)nv*sizeof(float));
        cb  = (float*)realloc(cb,  (size_t)nv*sizeof(float));
    }
    for(int j=0;j<nx;j++){
        float z = oz + j*cell;
        for(int i=0;i<nx;i++){
            float x = ox + i*cell;
            float h = terrainHeight(x, z);
            int id = j*nx + i;
            hgt[id] = h;
            float bright = 0.30f + clampf(h/fmaxf(1.0f,S.mountainMaxH), 0.0f, 1.0f)*0.55f;
            V3 col = hsv2rgb(S.terrainHue, 0.55f, bright);
            cr[id]=col.x; cg[id]=col.y; cb[id]=col.z;
        }
    }
    /* emit shared grid edges (east + north neighbour of each vertex) */
    for(int j=0;j<nx;j++){
        float z = oz + j*cell;
        for(int i=0;i<nx;i++){
            float x = ox + i*cell;
            float dx = x-cx, dz = z-cz;
            if(dx*dx + dz*dz > cull2) continue;
            int id = j*nx + i;
            V3 c = v3(cr[id],cg[id],cb[id]);
            if(i < nx-1){
                int e = id+1;
                batchEnsure(&gTerr, 2);
                batchVert(&gTerr, x, hgt[id], z, &c);
                V3 ce = v3(cr[e],cg[e],cb[e]);
                batchVert(&gTerr, x+cell, hgt[e], z, &ce);
            }
            if(j < nx-1){
                int nn = id+nx;
                batchEnsure(&gTerr, 2);
                batchVert(&gTerr, x, hgt[id], z, &c);
                V3 cn = v3(cr[nn],cg[nn],cb[nn]);
                batchVert(&gTerr, x, hgt[nn], z+cell, &cn);
            }
        }
    }
}

static void buildCacti(float cx, float cz, float margin){
    gCacti.n = 0;
    float reach = g_viewRadius + margin;   /* cacti reach as far as terrain */
    float reach2 = reach*reach;
    float ox = floorf((cx - reach)/CACTUS_CELL)*CACTUS_CELL;
    float oz = floorf((cz - reach)/CACTUS_CELL)*CACTUS_CELL;
    float xe = cx + reach, ze = cz + reach;

    for(float z=oz; z<=ze; z+=CACTUS_CELL){
        for(float x=ox; x<=xe; x+=CACTUS_CELL){
            int gx=(int)floorf(x/CACTUS_CELL), gz=(int)floorf(z/CACTUS_CELL);
            float place = hashf(gx*991+7, gz*787+13);
            if(place >= S.cactusFreq) continue;

            float jx = (hashf(gx*5+1, gz*9+2)-0.5f) * CACTUS_CELL*0.7f;
            float jz = (hashf(gx*11+3, gz*3+4)-0.5f) * CACTUS_CELL*0.7f;
            float wx = (gx+0.5f)*CACTUS_CELL + jx;
            float wz = (gz+0.5f)*CACTUS_CELL + jz;

            float dx = wx-cx, dz = wz-cz;
            float d2 = dx*dx + dz*dz;
            if(d2 > reach2) continue;
            buildCactus(&gCacti, wx, wz, sqrtf(d2));
        }
    }
}

/* rebuild whichever caches are stale, then leave them ready to draw */
static void ensureCaches(void){
    float tmargin = fmaxf(24.0f, g_viewRadius*0.18f);
    float dxt = camPos.x - tk.cx, dzt = camPos.z - tk.cz;
    if(!tk.ok || dxt*dxt+dzt*dzt > (tmargin*0.9f)*(tmargin*0.9f) ||
       tk.radius!=g_viewRadius || tk.hueT!=S.terrainHue ||
       tk.mFreq!=S.mountainFreq || tk.mRough!=S.mountainRough ||
       tk.mMinH!=S.mountainMinH || tk.mMaxH!=S.mountainMaxH){
        buildTerrain(camPos.x, camPos.z, tmargin);
        tk.ok=true; tk.cx=camPos.x; tk.cz=camPos.z; tk.radius=g_viewRadius;
        tk.hueT=S.terrainHue; tk.mFreq=S.mountainFreq; tk.mRough=S.mountainRough;
        tk.mMinH=S.mountainMinH; tk.mMaxH=S.mountainMaxH;
        tk.margin=tmargin;
    }

    float cmargin = fmaxf(16.0f, g_viewRadius*0.12f);
    float dxc = camPos.x - ck.cx, dzc = camPos.z - ck.cz;
    if(!ck.ok || dxc*dxc+dzc*dzc > (cmargin*0.9f)*(cmargin*0.9f) ||
       ck.radius!=g_viewRadius ||
       ck.freq!=S.cactusFreq || ck.sizeVar!=S.cactusSizeVar ||
       ck.minS!=S.cactusMinSize || ck.maxS!=S.cactusMaxSize ||
       ck.hue!=S.cactusHue || ck.arms!=S.maxArms){
        buildCacti(camPos.x, camPos.z, cmargin);
        ck.ok=true; ck.cx=camPos.x; ck.cz=camPos.z; ck.radius=g_viewRadius;
        ck.freq=S.cactusFreq; ck.sizeVar=S.cactusSizeVar;
        ck.minS=S.cactusMinSize; ck.maxS=S.cactusMaxSize;
        ck.hue=S.cactusHue; ck.arms=S.maxArms;
    }
}

/* ------------------------------------------------------------------ */
/* settings printout + key handling                                    */
/* ------------------------------------------------------------------ */
static void printSettings(void){
    printf("\rterrainHue=%.3f mtnFreq=%.2f mtnRough=%.2f mtnH=%.0f-%.0f "
           "cactusFreq=%.2f sizeVar=%.2f size=%.1f-%.1f cactusHue=%.3f "
           "maxArms=%d rDist=%.0f   ",
           S.terrainHue, S.mountainFreq, S.mountainRough,
           S.mountainMinH, S.mountainMaxH, S.cactusFreq,
           S.cactusSizeVar, S.cactusMinSize, S.cactusMaxSize,
           S.cactusHue, S.maxArms, g_viewRadius);
    fflush(stdout);
}

static bool  g_fullscreen = false;
static int   g_winX=80, g_winY=80, g_winW=1280, g_winH=720;

/* free-fly camera state */
static float camYaw   = 0.0f;     /* 0 looks toward -z */
static float camPitch = -0.18f;   /* slightly downward */
static V3    camVel;              /* persistent world-space velocity (W/S) */
static double g_lastInput = 0.0;  /* time of last keypress (for HUD fade)  */

static void toggleFullscreen(GLFWwindow *w){
    g_fullscreen = !g_fullscreen;
    if(g_fullscreen){
        glfwGetWindowPos(w, &g_winX, &g_winY);
        glfwGetWindowSize(w, &g_winW, &g_winH);
        GLFWmonitor *m = glfwGetPrimaryMonitor();
        const GLFWvidmode *vm = glfwGetVideoMode(m);
        glfwSetWindowMonitor(w, m, 0, 0, vm->width, vm->height, vm->refreshRate);
    } else {
        glfwSetWindowMonitor(w, NULL, g_winX, g_winY, g_winW, g_winH, 0);
    }
}

static void keyCB(GLFWwindow *w, int key, int sc, int action, int mods){
    (void)sc; (void)mods;
    if(action != GLFW_PRESS && action != GLFW_REPEAT) return;
    g_lastInput = glfwGetTime();
    switch(key){
        case GLFW_KEY_ESCAPE: glfwSetWindowShouldClose(w, GLFW_TRUE); break;
        case GLFW_KEY_F:      if(action==GLFW_PRESS) toggleFullscreen(w); break;

        case GLFW_KEY_1: S.terrainHue   = fmodf(S.terrainHue-0.01f+1.0f,1.0f); printSettings(); break;
        case GLFW_KEY_2: S.terrainHue   = fmodf(S.terrainHue+0.01f,1.0f);      printSettings(); break;
        case GLFW_KEY_3: S.mountainFreq = clampf(S.mountainFreq-0.05f,0.2f,4.0f);printSettings(); break;
        case GLFW_KEY_4: S.mountainFreq = clampf(S.mountainFreq+0.05f,0.2f,4.0f);printSettings(); break;
        case GLFW_KEY_5: S.cactusFreq   = clampf(S.cactusFreq-0.02f,0.0f,1.0f); printSettings(); break;
        case GLFW_KEY_6: S.cactusFreq   = clampf(S.cactusFreq+0.02f,0.0f,1.0f); printSettings(); break;
        case GLFW_KEY_7: S.cactusSizeVar= clampf(S.cactusSizeVar-0.02f,0.0f,0.95f);printSettings(); break;
        case GLFW_KEY_8: S.cactusSizeVar= clampf(S.cactusSizeVar+0.02f,0.0f,0.95f);printSettings(); break;
        case GLFW_KEY_9: S.cactusHue    = fmodf(S.cactusHue-0.01f+1.0f,1.0f);  printSettings(); break;
        case GLFW_KEY_0: S.cactusHue    = fmodf(S.cactusHue+0.01f,1.0f);       printSettings(); break;
        case GLFW_KEY_MINUS: if(S.maxArms>0) S.maxArms--; printSettings(); break;
        case GLFW_KEY_EQUAL: if(S.maxArms<ARM_LIMIT) S.maxArms++; printSettings(); break;
        case GLFW_KEY_LEFT_BRACKET:  g_viewRadius = clampf(g_viewRadius-16.0f, 40.0f, 960.0f); printSettings(); break;
        case GLFW_KEY_RIGHT_BRACKET: g_viewRadius = clampf(g_viewRadius+16.0f, 40.0f, 960.0f); printSettings(); break;
        case GLFW_KEY_COMMA:  S.mountainRough = clampf(S.mountainRough-0.05f,0.0f,1.0f); printSettings(); break;
        case GLFW_KEY_PERIOD: S.mountainRough = clampf(S.mountainRough+0.05f,0.0f,1.0f); printSettings(); break;
        case GLFW_KEY_T: S.mountainMinH = clampf(S.mountainMinH-1.0f, 0.0f, S.mountainMaxH); printSettings(); break;
        case GLFW_KEY_Y: S.mountainMinH = clampf(S.mountainMinH+1.0f, 0.0f, S.mountainMaxH); printSettings(); break;
        case GLFW_KEY_U: S.mountainMaxH = clampf(S.mountainMaxH-1.0f, S.mountainMinH, 80.0f); printSettings(); break;
        case GLFW_KEY_I: S.mountainMaxH = clampf(S.mountainMaxH+1.0f, S.mountainMinH, 80.0f); printSettings(); break;
        case GLFW_KEY_J: S.cactusMinSize = clampf(S.cactusMinSize-0.5f, 1.0f, S.cactusMaxSize); printSettings(); break;
        case GLFW_KEY_K: S.cactusMinSize = clampf(S.cactusMinSize+0.5f, 1.0f, S.cactusMaxSize); printSettings(); break;
        case GLFW_KEY_N: S.cactusMaxSize = clampf(S.cactusMaxSize-0.5f, S.cactusMinSize, 30.0f); printSettings(); break;
        case GLFW_KEY_M: S.cactusMaxSize = clampf(S.cactusMaxSize+0.5f, S.cactusMinSize, 30.0f); printSettings(); break;
        default: break;
    }
}

static void fbSizeCB(GLFWwindow *w, int width, int height){
    (void)w;
    glViewport(0, 0, width, height);
}

/* ------------------------------------------------------------------ */
/* command line                                                        */
/* ------------------------------------------------------------------ */
static bool argval(const char *arg, const char *key, float *out){
    size_t n = strlen(key);
    if(strncmp(arg, key, n)==0 && arg[n]=='='){
        *out = (float)atof(arg+n+1);
        return true;
    }
    return false;
}

static void usage(const char *prog){
    printf("usage: %s [--fullscreen] [options]\n", prog);
    printf("  --terrain-hue=0..1     --mountain-freq=0.2..4\n");
    printf("  --mountain-rough=0..1\n");
    printf("  --mountain-min-height=0..80  --mountain-max-height=0..80\n");
    printf("  --cactus-freq=0..1\n");
    printf("  --cactus-size-var=0..0.95  --cactus-hue=0..1\n");
    printf("  --cactus-min-size=1..30    --cactus-max-size=1..30\n");
    printf("  --max-arms=0..%d\n", ARM_LIMIT);
}

int main(int argc, char **argv){
    bool startFull = false;
    float fv;
    for(int i=1;i<argc;i++){
        if(strcmp(argv[i],"--fullscreen")==0) startFull = true;
        else if(strcmp(argv[i],"--help")==0 || strcmp(argv[i],"-h")==0){ usage(argv[0]); return 0; }
        else if(argval(argv[i],"--terrain-hue",&fv))     S.terrainHue   = clampf(fv,0,1);
        else if(argval(argv[i],"--mountain-freq",&fv))   S.mountainFreq = clampf(fv,0.2f,4.0f);
        else if(argval(argv[i],"--mountain-rough",&fv))  S.mountainRough= clampf(fv,0.0f,1.0f);
        else if(argval(argv[i],"--mountain-min-height",&fv)) S.mountainMinH= clampf(fv,0.0f,80.0f);
        else if(argval(argv[i],"--mountain-max-height",&fv)) S.mountainMaxH= clampf(fv,0.0f,80.0f);
        else if(argval(argv[i],"--cactus-freq",&fv))     S.cactusFreq   = clampf(fv,0,1);
        else if(argval(argv[i],"--cactus-size-var",&fv)) S.cactusSizeVar= clampf(fv,0,0.95f);
        else if(argval(argv[i],"--cactus-min-size",&fv)) S.cactusMinSize= clampf(fv,1.0f,30.0f);
        else if(argval(argv[i],"--cactus-max-size",&fv)) S.cactusMaxSize= clampf(fv,1.0f,30.0f);
        else if(argval(argv[i],"--cactus-hue",&fv))      S.cactusHue    = clampf(fv,0,1);
        else if(argval(argv[i],"--max-arms",&fv))        S.maxArms      = (int)clampf(fv,0,ARM_LIMIT);
        else { fprintf(stderr,"unknown arg: %s\n", argv[i]); usage(argv[0]); return 1; }
    }
    if(S.cactusMinSize > S.cactusMaxSize){
        float t = S.cactusMinSize; S.cactusMinSize = S.cactusMaxSize; S.cactusMaxSize = t;
    }
    if(S.mountainMinH > S.mountainMaxH){
        float t = S.mountainMinH; S.mountainMinH = S.mountainMaxH; S.mountainMaxH = t;
    }

    if(!glfwInit()){ fprintf(stderr,"glfwInit failed\n"); return 1; }

    GLFWmonitor *mon = NULL;
    int cw = g_winW, ch = g_winH;
    if(startFull){
        mon = glfwGetPrimaryMonitor();
        const GLFWvidmode *vm = glfwGetVideoMode(mon);
        cw = vm->width; ch = vm->height;
        g_fullscreen = true;
    }

    GLFWwindow *win = glfwCreateWindow(cw, ch, "vectordesert", mon, NULL);
    if(!win){ fprintf(stderr,"window creation failed\n"); glfwTerminate(); return 1; }
    glfwMakeContextCurrent(win);
    glfwSwapInterval(1);
    glfwSetKeyCallback(win, keyCB);
    glfwSetFramebufferSizeCallback(win, fbSizeCB);

    printf("vectordesert -- wire-mesh vector desert flythrough\n");
    printf("move: W/S throttle  A/D strafe  PageUp/Dn altitude  arrows pan\n");
    printf("keys: 1/2 terrainHue  3/4 mtnFreq  ,/. mtnRough  T/Y U/I mtnH\n");
    printf("      5/6 cactusFreq  7/8 sizeVar  J/K minSize  N/M maxSize\n");
    printf("      9/0 cactusHue  -/= maxArms  [ ] renderDist  F full  ESC quit\n\n");
    printSettings();
    printf("\n");

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LINE_SMOOTH);
    glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    glLineWidth(1.0f);

    /* hardware linear fog fades distant geometry into the sky -- far cheaper
     * than computing a per-vertex fade on the CPU, and it lets the scene
     * geometry stay in static cached vertex arrays */
    GLfloat fogcol[4] = { 0.03f, 0.02f, 0.06f, 1.0f };
    glEnable(GL_FOG);
    glFogi(GL_FOG_MODE, GL_LINEAR);
    glFogfv(GL_FOG_COLOR, fogcol);
    glHint(GL_FOG_HINT, GL_NICEST);

    double t0 = glfwGetTime();
    g_lastInput = t0;                 /* HUD starts visible, then fades */
    camPos = v3(0.0f, 14.0f, 0.0f);
    const float moveSpeed = 28.0f;   /* WASD / strafe units per second */
    const float climbSpeed= 22.0f;   /* PageUp / PageDown              */
    const float panSpeed  = 1.4f;    /* arrow-key turn rate (rad/s)    */

    while(!glfwWindowShouldClose(win)){
        double t1 = glfwGetTime();
        float dt = (float)(t1 - t0);
        t0 = t1;

        /* arrow keys pan the view */
        if(glfwGetKey(win, GLFW_KEY_LEFT)  == GLFW_PRESS) camYaw   -= panSpeed*dt;
        if(glfwGetKey(win, GLFW_KEY_RIGHT) == GLFW_PRESS) camYaw   += panSpeed*dt;
        if(glfwGetKey(win, GLFW_KEY_UP)    == GLFW_PRESS) camPitch += panSpeed*dt;
        if(glfwGetKey(win, GLFW_KEY_DOWN)  == GLFW_PRESS) camPitch -= panSpeed*dt;
        camPitch = clampf(camPitch, -1.45f, 1.45f);

        /* view direction from yaw/pitch (yaw 0 -> -z) */
        V3 fwd = v3(sinf(camYaw)*cosf(camPitch),
                    sinf(camPitch),
                   -cosf(camYaw)*cosf(camPitch));
        V3 hfwd  = norm3(v3(fwd.x, 0.0f, fwd.z));     /* ground-plane forward */
        V3 right = norm3(cross3(fwd, v3(0,1,0)));

        /* W/S are a throttle: they add thrust along the current heading to a
         * persistent world-space velocity that holds when released. Because
         * the velocity lives in world space, panning the view with the arrow
         * keys does not change the direction of travel. */
        const float accel = 22.0f, maxSpeed = 90.0f;
        if(glfwGetKey(win, GLFW_KEY_W) == GLFW_PRESS) camVel = add(camVel, scl(hfwd,  accel*dt));
        if(glfwGetKey(win, GLFW_KEY_S) == GLFW_PRESS) camVel = add(camVel, scl(hfwd, -accel*dt));
        float sp = len3(camVel);
        if(sp > maxSpeed) camVel = scl(camVel, maxSpeed/sp);
        camPos = add(camPos, scl(camVel, dt));

        /* A/D strafe; PageUp/Down change altitude */
        if(glfwGetKey(win, GLFW_KEY_D) == GLFW_PRESS) camPos = add(camPos, scl(right, moveSpeed*dt));
        if(glfwGetKey(win, GLFW_KEY_A) == GLFW_PRESS) camPos = add(camPos, scl(right,-moveSpeed*dt));
        if(glfwGetKey(win, GLFW_KEY_PAGE_UP)   == GLFW_PRESS) camPos.y += climbSpeed*dt;
        if(glfwGetKey(win, GLFW_KEY_PAGE_DOWN) == GLFW_PRESS) camPos.y -= climbSpeed*dt;

        /* never sink below the terrain */
        float floorY = terrainHeight(camPos.x, camPos.z) + 2.0f;
        if(camPos.y < floorY) camPos.y = floorY;

        V3 target = add(camPos, fwd);

        int fbw, fbh;
        glfwGetFramebufferSize(win, &fbw, &fbh);
        float aspect = (fbh>0) ? (float)fbw/(float)fbh : 1.0f;

        glClearColor(0.03f, 0.02f, 0.06f, 1.0f);  /* dusk desert sky */
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        perspectiveGL(60.0f, aspect, 0.5f, g_viewRadius + 50.0f);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        lookAtGL(camPos, target, v3(0,1,0));

        /* distance fade tracks the rendering distance */
        glFogf(GL_FOG_START, FOG_NEAR);
        glFogf(GL_FOG_END,   fogFarDist());

        ensureCaches();
        batchDraw(&gTerr);
        batchDraw(&gCacti);

        /* HUD: fully visible, then fades after 10s without a keypress */
        double idle = glfwGetTime() - g_lastInput;
        float hudAlpha = (idle < 10.0)
                       ? 1.0f
                       : clampf(1.0f - (float)(idle-10.0)/1.5f, 0.0f, 1.0f);
        if(hudAlpha > 0.001f) drawHUD(fbw, fbh, hudAlpha);

        glfwSwapBuffers(win);
        glfwPollEvents();
    }

    printf("\n");
    glfwDestroyWindow(win);
    glfwTerminate();
    return 0;
}