#!/usr/bin/gawk -f

# reinhard@finalmedia.de
# Thu May 14 11:07:10 AM CEST 2026
# Public Domain

BEGIN {
    # 1. Auflösung festlegen
    W = 320.0; H = 240.0;

    # 2. Voxel-Welt dimensionieren (Grid-Größe)
    GX = 16; GY = 16; GZ = 16;

    # 3. Gitter initialisieren und mit Blöcken füllen
    for(x=0; x<GX; x++)
        for(y=0; y<GY; y++)
            for(z=0; z<GZ; z++)
                grid[x,y,z] = 0;

    # Grauer Boden (y=0)
    for(x=0; x<GX; x++)
        for(z=0; z<GZ; z++)
            grid[x,0,z] = 1;

    # Pyramide bauen (Stufen 1 bis 4)
    for(x=4; x<=11; x++) for(z=4; z<=11; z++) grid[x,1,z] = 2; # Rot
    for(x=5; x<=10; x++) for(z=5; z<=10; z++) grid[x,2,z] = 3; # Grün
    for(x=6; x<=9;  x++) for(z=6; z<=9;  z++) grid[x,3,z] = 4; # Blau
    for(x=7; x<=8;  x++) for(z=7; z<=8;  z++) grid[x,4,z] = 5; # Gelb

    # Schwebende Demo Farb-Blöcke mittels Array-Indizes
    grid[3,4,3]   = 2;
    grid[12,5,12] = 4;
    grid[4,6,11]  = 3;

    # Lichtrichtung (Sonne von schräg oben)
    lX = 0.5; lY = 1.0; lZ = -0.3;
    l_len = sqrt(lX*lX + lY*lY + lZ*lZ);
    lX /= l_len; lY /= l_len; lZ /= l_len;

    # 4. ANIMATIONSSCHLEIFE
    for (frame = 0; frame < 60; frame++) {

        winkel = frame * (6.0 * 3.14159265 / 180.0);

        # Kreisbahn um das Zentrum fahren
        radius = 18.0;
        camX = 7.5 + cos(winkel) * radius;
        camZ = 7.5 + sin(winkel) * radius;
        camY = 11.0;

        lookX = 7.5 - camX; lookY = 2.0 - camY; lookZ = 7.5 - camZ;
        l_look = sqrt(lookX*lookX + lookY*lookY + lookZ*lookZ);
        lookX /= l_look; lookY /= l_look; lookZ /= l_look;

        rightX = lookZ; rightY = 0; rightZ = -lookX;
        l_right = sqrt(rightX*rightX + rightZ*rightZ);
        rightX /= l_right; rightZ /= l_right;

        upX = (lookY * rightZ) - (lookZ * rightY);
        upY = (lookZ * rightX) - (lookX * rightZ);
        upZ = (lookX * rightY) - (lookY * rightX);

        printf "[AWK] Rendere Frame %d/60...\n", frame > "/dev/stderr";

        for (y = 0; y < H; y++) {
            for (x = 0; x < W; x++) {

                fx = (x / W * 2.0 - 1.0) * (W / H);
                fy = (1.0 - y / H * 2.0);

                dx = lookX * 1.2 + rightX * fx + upX * fy;
                dy = lookY * 1.2 + rightY * fx + upY * fy;
                dz = lookZ * 1.2 + rightZ * fx + upZ * fy;

                len = sqrt(dx*dx + dy*dy + dz*dz);
                dx /= len; dy /= len; dz /= len;

                trace_voxel(camX, camY, camZ, dx, dy, dz, x, y, GX, GY, GZ, lX, lY, lZ);
            }
        }
	# 30fps sleep
        printf "s 33333\n";
    }
}

function trace_voxel(ox, oy, oz, dx, dy, dz, screenX, screenY, gX, gY, gZ, lx, ly, lz,   mapX, mapY, mapZ, deltaDistX, deltaDistY, deltaDistZ, signX, signY, signZ, sideDistX, sideDistY, sideDistZ, hit, side, voxelId, r, g, b_val, nx, ny, nz, dot, step, intensity) {

    mapX = int(ox); mapY = int(oy); mapZ = int(oz);

    deltaDistX = (dx == 0) ? 1e9 : string_abs(1.0 / dx);
    deltaDistY = (dy == 0) ? 1e9 : string_abs(1.0 / dy);
    deltaDistZ = (dz == 0) ? 1e9 : string_abs(1.0 / dz);

    if (dx < 0) { signX = -1; sideDistX = (ox - mapX) * deltaDistX; }
    else        { signX = 1;  sideDistX = (mapX + 1.0 - ox) * deltaDistX; }

    if (dy < 0) { signY = -1; sideDistY = (oy - mapY) * deltaDistY; }
    else        { signY = 1;  sideDistY = (mapY + 1.0 - oy) * deltaDistY; }

    if (dz < 0) { signZ = -1; sideDistZ = (oz - mapZ) * deltaDistZ; }
    else        { signZ = 1;  sideDistZ = (mapZ + 1.0 - oz) * deltaDistZ; }

    hit = 0; side = 0; voxelId = 0;

    for (step = 0; step < 120; step++) {
        if (sideDistX < sideDistY && sideDistX < sideDistZ) {
            sideDistX += deltaDistX; mapX += signX; side = 0;
        } else if (sideDistY < sideDistZ) {
            sideDistY += deltaDistY; mapY += signY; side = 1;
        } else {
            sideDistZ += deltaDistZ; mapZ += signZ; side = 2;
        }

        if ((mapX < 0 && signX <= 0) || (mapX >= gX && signX >= 0) || \
            (mapY < 0 && signY <= 0) || (mapY >= gY && signY >= 0) || \
            (mapZ < 0 && signZ <= 0) || (mapZ >= gZ && signZ >= 0)) {
            break;
        }

        if (mapX >= 0 && mapX < gX && mapY >= 0 && mapY < gY && mapZ >= 0 && mapZ < gZ) {
            if (grid[mapX, mapY, mapZ] > 0) {
                hit = 1;
                voxelId = grid[mapX, mapY, mapZ];
                break;
            }
        }
    }

    if (hit == 0) {
        b_val = int(200 + (1.0 - screenY/240.0) * 55);
        g = int(150 + (1.0 - screenY/240.0) * 40);
        printf "p %d %d 100 %d %d\n", screenX, screenY, g, b_val;
        return;
    }

    if (voxelId == 1) { r = 140; g = 140; b_val = 140; }
    if (voxelId == 2) { r = 220; g = 40;  b_val = 40;  }
    if (voxelId == 3) { r = 40;  g = 200; b_val = 40;  }
    if (voxelId == 4) { r = 40;  g = 40;  b_val = 220; }
    if (voxelId == 5) { r = 230; g = 200; b_val = 30;  }

    nx = 0; ny = 0; nz = 0;
    if (side == 0) nx = -signX;
    if (side == 1) ny = -signY;
    if (side == 2) nz = -signZ;

    dot = nx*lx + ny*ly + nz*lz;
    if (dot < 0) dot = 0;

    if (side == 0) dot *= 0.75;
    if (side == 2) dot *= 0.60;
    if (side == 1 && ny < 0) dot *= 0.40;

    intensity = dot * 0.8 + 0.2;
    printf "p %d %d %d %d %d\n", screenX, screenY, int(r*intensity), int(g*intensity), int(b_val*intensity);
}

function string_abs(v) { return (v < 0) ? -v : v; }