Hash-driven Procedural City Skyline

Math essence

For each column c: h(c, t) = fbm_1d(c * building_freq + drift * t, 4 octaves); top_c = ground - h * height_max. For each pixel (x, y) with y <= top_c paint facade = facade_color * (0.5 + 0.6 * (top_c - y) / height_max) * (0.85 + 0.30 * hash11(c, seed)). For each window cell (col // (ww+pad), row // (wh+pad)) whose hash > lit_threshold, paint window_color with a per-window warm jitter. A small 5x5 box-blur bloom around lit windows adds the light-leak glow.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shader_legends_3/DaveHoskinsHashCity/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash11(x: np.ndarray, seed: int) -> np.ndarray:
    """Dave Hoskins's single-component integer hash, returns float in [0, 1)."""
    p = np.int64(x) * np.int64(374761393) + np.int64(seed) * np.int64(668265263)
    p = p & np.int64(0xFFFFFFFF)
    p = (p ^ (p >> np.int64(13))) * np.int64(1274126177)
    p = p & np.int64(0xFFFFFFFF)
    p = p ^ (p >> np.int64(16))
    return (p & np.int64(0xFFFFFFFF)).astype(np.float32) / np.float32(0xFFFFFFFF)


def _hash12(x: np.ndarray, y: np.ndarray, seed: int) -> np.ndarray:
    """Dave Hoskins-style 2D hash → [0, 1)."""
    p = np.int64(x) * np.int64(374761393) + np.int64(y) * np.int64(668265263) + np.int64(seed)
    p = p & np.int64(0xFFFFFFFF)
    p = (p ^ (p >> np.int64(13))) * np.int64(1274126177)
    p = p & np.int64(0xFFFFFFFF)
    p = p ^ (p >> np.int64(16))
    return (p & np.int64(0xFFFFFFFF)).astype(np.float32) / np.float32(0xFFFFFFFF)


def _value_noise_1d(x: np.ndarray, seed: int) -> np.ndarray:
    """Bilinearly smoothed 1D value noise from a deterministic hash."""
    xi = np.floor(x).astype(np.int64)
    xf = (x - xi).astype(np.float32)
    u = xf * xf * (3.0 - 2.0 * xf)
    n0 = _hash11(xi, seed)
    n1 = _hash11(xi + 1, seed)
    return n0 * (1.0 - u) + n1 * u


def _fbm_1d(x: np.ndarray, octaves: int, seed: int, lac: float = 2.0, gain: float = 0.5) -> np.ndarray:
    total = np.zeros_like(x, dtype=np.float32)
    amp = np.float32(1.0)
    freq = np.float32(1.0)
    norm = np.float32(0.0)
    for k in range(octaves):
        total = total + amp * _value_noise_1d(x * freq, seed + k * 17)
        norm = norm + amp
        amp = amp * np.float32(gain)
        freq = freq * np.float32(lac)
    return total / max(norm, 1e-6)


class DaveHoskinsHashCity:
    """Hash-driven procedural city skyline — Dave Hoskins (Shadertoy).

    Dave Hoskins's *City* shader (Shadertoy) is a single line of GLSL
    that turns a per-column 1D noise sample into a building height,
    and then walks down the building drawing lit windows whose on/off
    state is decided by another hash of the column-and-row integer
    pair.  It is the canonical example of "small-hash, big-picture"
    shader work: every pixel of the cityscape comes from < 20 lines
    of code yet reads as a recognisable skyline at night.