IQ Domain Warping — fbm composed with itself at 2/3 levels

Math essence

p = (x, y)*scale + 0.3*t. qx, qy = fbm(p_x, p_y), fbm(p_x + 5.2, p_y + 1.3). If depth>=2: r_x, r_y = fbm(p + 4*q_x, p + 4*q_y + ...); if depth>=3: s_x, s_y = fbm(p + 4*r_x, p + 4*r_y + ...). Final sample = fbm(p + 4*r/s, ...) mapped through a + b*cos(2pi*(c*(h + palette_offset) + d)).

Parameters

Reference

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

from __future__ import annotations

from typing import ClassVar

import numpy as np


def _hash21(x: np.ndarray, y: np.ndarray) -> np.ndarray:
    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 IQDomainWarping:
    """Domain Warping — Inigo Quilez (https://iquilezles.org/articles/warp/).

    Domain warping is Quilez's elegant trick to break out of the
    "looks like noise" cliché.  You feed a noise function *itself*
    as input coordinates:

        q  = fbm(p + fbm(p))
        r  = fbm(p + 4*q + fbm(p + 4*q))
        v  = fbm(p + 4*r)

    Each warp level stretches, folds, and curls the field into
    organic shapes that no noise primitive can produce on its own.
    Increasing warp depth produces increasingly
    painterly/flame-like output; the canonical 3-warp chain (an "fbm
    of fbm of fbm") gives IQ's classic *warped fractal noise* look.