Pixel City — top-down procedural city

Math essence

Each grid cell (cx, cy) is hashed to (a, b, c, d). If cx%6==0 or cy%6==0 the cell is a road (gray). Otherwise with probability a > 0.18 a building is placed; its visual height is a noise-driven factor 0.45 + 0.55*(0.6*value_noise + 0.4*value_noise), its colour is one of four warm-cool palette seeds, and lit windows are placed at a stride derived from roof_seed when in night mode. The canvas is rendered at tile resolution and the city pans modulo its tile period for endless flight.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shader_legends/PolygoncityPixelCity/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash_int(x: int, y: int, seed: int) -> int:
    """Deterministic pseudo-random int from grid coordinates."""
    h = (np.int64(x) * np.int64(73856093)) ^ (np.int64(y) * np.int64(19349663)) ^ (np.int64(seed) * np.int64(83492791))
    h = h & np.int64(0xFFFFFFFF)
    h ^= h >> np.int64(13)
    h = (h * np.int64(0x5BD1E995)) & np.int64(0xFFFFFFFF)
    return int(h & np.int64(0x7FFFFFFF))


def _h2(x: int, y: int, seed: int) -> tuple[float, float]:
    h = _hash_int(x, y, seed)
    a = ((h & 0xFFFF) / 65535.0)
    b = (((h >> 16) & 0xFFFF) / 65535.0)
    return a, b


def _value_noise(x: float, y: float, seed: int) -> float:
    xi = int(np.floor(x))
    yi = int(np.floor(y))
    xf = x - xi
    yf = y - yi
    u = xf * xf * (3.0 - 2.0 * xf)
    v = yf * yf * (3.0 - 2.0 * yf)
    n00, _ = _h2(xi, yi, seed)
    n10, _ = _h2(xi + 1, yi, seed)
    n01, _ = _h2(xi, yi + 1, seed)
    n11, _ = _h2(xi + 1, yi + 1, seed)
    nx0 = n00 * (1 - u) + n10 * u
    nx1 = n01 * (1 - u) + n11 * u
    return nx0 * (1 - v) + nx1 * v


class PolygoncityPixelCity:
    """Top-down procedural pixel city — Polygoncity / PixelCity.

    Inspired by Shamus Young's *Pixel City* screensaver (2009) and the
    Shadertoy community's many procedural-city tributes (Polygoncity,
    polygonal/low-poly city packs, Eiffie's Tokyo etc.). Every cell of a
    50×50 grid is classified as either *road* or *building lot* by a
    deterministic checker plus noise. Buildings are coloured boxes with
    a height drawn from a noise field; lit yellow windows are speckled
    on each building face; the camera slowly pans across the city.
    """

    family: ClassVar[str] = "shader_legends"
    sketch: ClassVar[str] = "polygoncitypixelcity"

    _GRID: ClassVar[int] = 50

    def __init__(
        self,
        dim: int = 400,
        cells: int = 50,