Hex Grid Tiling — axial-coord tessellation with fBM-filled cells

Math essence

For each pixel p: re-coordinate into u = x/s, v = y/(s*sqrt(3)). Try both grid origins (offset by 0.5) and pick the cell whose centre is nearest. Get axial cell id (q, r). Look up hash21 -> hue and saturation; look up fbm at the local hex position * noise_scale + t -> interior noise. Hex boundary is computed analytically as max(|lq|, |lr|, 0.5*(|lq+lr|)) for an antialiased edge.

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shader_legends_2/HexGridTiling/reference.py

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash21(x: np.ndarray, y: np.ndarray) -> np.ndarray:
    """1-component hash on integer (x,y) -> [0,1)."""
    p = 127.1 * x + 311.7 * y
    return (np.sin(p) * 43758.5453123 - np.floor(np.sin(p) * 43758.5453123)).astype(np.float32)


def _value_noise(x: np.ndarray, y: np.ndarray, seed: int) -> np.ndarray:
    xi = np.floor(x).astype(np.int64)
    yi = np.floor(y).astype(np.int64)
    xf = (x - xi).astype(np.float32)
    yf = (y - yi).astype(np.float32)
    sx = float((seed * 17) & 0xFFFFF)
    sy = float((seed * 31) & 0xFFFFF)
    u = xf * xf * (3.0 - 2.0 * xf)
    v = yf * yf * (3.0 - 2.0 * yf)
    n00 = _hash21(xi.astype(np.float32) + sx, yi.astype(np.float32) + sy)
    n10 = _hash21(xi.astype(np.float32) + 1.0 + sx, yi.astype(np.float32) + sy)
    n01 = _hash21(xi.astype(np.float32) + sx, yi.astype(np.float32) + 1.0 + sy)
    n11 = _hash21(xi.astype(np.float32) + 1.0 + sx, yi.astype(np.float32) + 1.0 + sy)
    nx0 = n00 * (1.0 - u) + n10 * u
    nx1 = n01 * (1.0 - u) + n11 * u
    return nx0 * (1.0 - v) + nx1 * v


def _fbm(x: np.ndarray, y: np.ndarray, seed: int, octaves: int = 4) -> np.ndarray:
    f = 1.0
    a = 1.0
    total = np.zeros_like(x, dtype=np.float32)
    norm = 0.0
    for k in range(octaves):
        total += a * _value_noise(x * f + 31.0 * k, y * f - 17.0 * k, seed + k)
        norm += a
        f *= 2.0
        a *= 0.55
    return total / max(norm, 1e-6)


class HexGridTiling:
    """Hex-grid tiling with fBM-filled cells — Inigo Quilez / Shane.

    A hexagonal grid is the canonical 6-fold-symmetric alternative
    to the square-grid hash tiling.  The classic trick (Inigo Quilez
    https://iquilezles.org/articles/distance/ ; Shane *Hexagon*
    https://www.shadertoy.com/view/Xljczw) is to first re-coordinate
    the pixel to a skewed frame, snap to the nearest of two
    interleaved square-lattice offsets, then convert the cell id
    into *axial* hex coordinates (q, r):

        q = (2/3 * x),  r = (-1/3 * x + sqrt(3)/3 * y)
        cells in row y : floor(q), shifted by (r & 1)

    Once we have the (q, r) of the pixel's containing hex, we look
    up a per-tile (hash21-driven) base colour and add fBM noise