Animated FBM Nebula with Chromatic Aberration

Math essence

For each of 5 octaves k: rotate (x, y) by 0.4 t + 0.7 k, sample fbm(rotated * base_scale * step^k, 4 octaves), accumulate with weight 1 / (1 + 0.7 k). Compute the field three times for R, G, B with per-channel rotation/translation offsets of size chroma_strength. palette = IQ_cosine_palette(avg + palette_offset). final = palette * pow(tint, 0.6) + stars + background * (1 - brightness).

Parameters

Reference

First 60 lines of reference.py. Full source: library_external/shader_legends_3/AshleyGAnimNebula/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:
    x = np.asarray(x, dtype=np.int64)
    y = np.asarray(y, dtype=np.int64)
    p = (x * np.int64(374761393) + y * np.int64(668265263) + np.int64(seed)) & np.int64(0xFFFFFFFF)
    p = (p ^ (p >> np.int64(13))) * np.int64(1274126177) & np.int64(0xFFFFFFFF)
    p = p ^ (p >> np.int64(16))
    return (p & np.int64(0xFFFFFFFF)).astype(np.float32) / np.float32(0xFFFFFFFF)


def _value_noise_2d(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)
    u = xf * xf * (3.0 - 2.0 * xf)
    v = yf * yf * (3.0 - 2.0 * yf)
    n00 = _hash21(xi, yi + seed, 0)
    n10 = _hash21(xi + 1, yi + seed, 0)
    n01 = _hash21(xi, yi + 1 + seed, 0)
    n11 = _hash21(xi + 1, yi + 1 + seed, 0)
    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, 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_2d(x * freq, y * freq, seed + k * 17)
        norm = norm + amp
        amp = amp * np.float32(gain)
        freq = freq * np.float32(lac)
    return total / max(norm, 1e-6)


def _rot2d(x: np.ndarray, y: np.ndarray, ang: float) -> tuple[np.ndarray, np.ndarray]:
    c = np.cos(ang)
    s = np.sin(ang)
    return c * x - s * y, s * x + c * y


class AshleyGAnimNebula:
    """Animated Nebula — Ashley G. (Shadertoy user 'ashleyg').

    Ashley G's *Nebula* is a chromatic-aberration-on-FBM shader that
    produces a slowly rotating, multi-coloured cosmic gas cloud.
    The recipe:

    1. **Five FBM layers** at different scales, each rotated by a
       different angle that varies with time.  The layers are