Recursive Spherical Displacement Wireframe

Math essence

For each 3D point p on the unit sphere, with theta = arccos(p.y) and phi = atan2(p.z, p.x), the displacement is r := 1 + amp_k * (0.5 + 0.5 * sin(N_k * theta + phase_t) * cos(M_k * phi + phase_t)). Apply this for k=1,2,3 in succession with decreasing amps, rotate the result by (0.4 t, 0.6 t, 0.3 t), then orthographically project. The wireframe samples n_lat latitude circles and n_lon meridian polylines; surface dots come from uniformly-spaced (theta, phi) draws.

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash21(x: np.ndarray, y: np.ndarray, seed: int) -> np.ndarray:
    """Deterministic 2D hash → [0, 1)."""
    x = np.asarray(x, dtype=np.int64)
    y = np.asarray(y, dtype=np.int64)
    h = (x * np.int64(374761393) + y * np.int64(668265263) + np.int64(seed)) & np.int64(0xFFFFFFFF)
    h = (h ^ (h >> np.int64(13))) * np.int64(1274126177) & np.int64(0xFFFFFFFF)
    h = h ^ (h >> np.int64(16))
    return (h & np.int64(0xFFFFFFFF)).astype(np.float32) / np.float32(0xFFFFFFFF)


class IQDisplacementSphere:
    """Recursive spherical displacement — Iñigo Quilez (Shadertoy).

    IQ's classic *displacement* shader (Shadertoy) is a deceptively
    short program: a single sphere is recursively *displaced* by
    other smaller spheres on its surface, then those smaller
    spheres are again displaced, and so on, producing a wireframe
    of nested spherical "growths" that looks like a sea-urchin or
    a virus.  The math essence is:

    1. start with a base point on the unit sphere,
    2. apply ``displacement = amp * sin(N * theta) * cos(M * phi)``,
    3. rotate the result by a time-varying Euler triple,
    4. project to 2D with simple orthographic projection.

    The shader has no texture sampling, no fBM, and no lighting.
    Its richness comes entirely from the recursive spherical
    geometry.  This implementation flattens the recursion into a
    single nested series of polar displacements: three
    *generations* of ``amp * sin(N * theta) * cos(M * phi)`` of
    decreasing amplitude, rendered as a wireframe of latitude
    lines + dots, with an optional second concentric wireframe
    that adds the "sphere on a sphere" look.
    """

    family: ClassVar[str] = "shader_legends_3"
    sketch: ClassVar[str] = "iqdisplacementsphere"

    def __init__(
        self,
        dim: int = 400,
        n_lat: int = 28,
        n_lon: int = 56,
        n1: int = 4,
        n2: int = 3,
        n3: int = 5,
        amp1: float = 0.18,
        amp2: float = 0.10,
        amp3: float = 0.05,
        radius: float = 0.40,
        rotate_speed: float = 0.18,
        dot_density: float = 0.18,
        line_color: tuple[float, float, float] = (0.45, 0.85, 1.00),