Enum GeneratorConfig 

pub enum GeneratorConfig {
    Curve {
        family: CurveFamily,
    },
    LSystem {
        axiom: String,
        rules: Vec<(char, String)>,
        angle_deg: f32,
        max_depth: u32,
        seed: u64,
    },
    Star {
        order: u32,
        contact_angle_deg: f32,
        rings: Vec<RingSpec>,
    },
    Particles {
        family: AttractorFamily,
        morph_to: Option<IfsFigure>,
        density: f32,
        tuple_path: Option<(u32, u32)>,
    },
    Spectrum {
        elements: usize,
        layout: SpectrumLayout,
        easing: Easing,
    },
    WarpMesh {
        mesh: (u32, u32),
        milk: Option<Box<MilkBundle>>,
        salt: u32,
    },
    Path {
        shape: Option<PathShape>,
        morph_to: Option<PathShape>,
    },
}

Declarative structural config a scene consumes once at preset load (ADR-0007): not expressions — the family / grammar / tiling the sampler or generator builds from. Delivered through the optional Scene::configure hook, off the hot path. This is the shared structural-config enum for every scene that has one: the line scenes’ curve/L-system/star variants, plus the compute-particle attractor family (Plan 0016) — it lives here rather than in lines/ so lines never has to name a particles type (Plan 0031 Phase 6).

Variants

Curve

A parametric curve: which family to sample.

Fields

family: CurveFamily

The curve family (Maurer rose, …).

LSystem

An L-system: a grammar the generator expands and turtle-walks at load, caching one segment buffer per depth.

Fields

axiom: String

The starting string.

rules: Vec<(char, String)>

Production rules (predecessor, successor).

angle_deg: f32

Turn angle in degrees for +/-.

max_depth: u32

Iterations to precompute (1..=max_depth), clamped to lines::MAX_LSYSTEM_DEPTH at load.

seed: u64

Reserved seed for future stochastic rules; deterministic today.

Star

A Hankin star pattern: an n-fold star rosette built at load, with a few contact-angle variants a beat can switch between — and, since ADR-0079, an optional ring ornament drawn inside it.

Fields

order: u32

Star order n (from the tiling), e.g. 6 or 12. 0 means no interlace at all (tiling = "none"), which the loader accepts only alongside a non-empty rings roster — the ornament drawn alone.

contact_angle_deg: f32

Contact angle in degrees; variants are precomputed around it.

rings: Vec<RingSpec>

The [generator] rings roster (ADR-0079): concentric rings of repeated motifs filling the interior the rosette leaves hollow. Empty — the default, and what an absent rings key means — is exactly the pre-Plan-0065 scene.

Particles

A GPU compute-particle attractor (Plan 0016): which strange-attractor map the compute step iterates. Not a line scene — reuses this shared enum so the family rides the existing configure hook (no new trait method).

Fields

family: AttractorFamily

The attractor family (De Jong, Clifford, Thomas, Lorenz, or one of the IFS figures).

morph_to: Option<IfsFigure>

The figure the bindable morph param travels towards (ADR-0075), from [particles] morph_to. None — the default — pins the figure, so morph is inert.

IFS-only, and validated as such at load: morph_to on a map family is a load error rather than a silent no-op, because the author asked for something the engine cannot do.

density: f32

Fraction of the tier’s particle budget actually drawn (ADR-0069), validated at load into MIN_PARTICLE_DENSITY..=1.0. Structural, not bindable: an eased integer count would re-decide the picture every frame. 1.0 is the whole budget and the default.

tuple_path: Option<(u32, u32)>

The tuple path the bindable morph param walks along on a map family (ADR-0093), as (from, to) roster indices from [particles] tuple_from / tuple_to. None — the default — means there is no path and morph is inert, exactly as morph_to does for the IFS.

Both ends are structural on purpose. The walk’s framing is measured across it at load, which is thousands of map iterations; a path whose near end came from the per-frame tuple param would have to re-measure inside the frame loop every time that param moved.

Map-family-only, and validated as such at load — the IFS reaches its own figure-to-figure travel through morph_to instead, and a tuple path on an IFS is a load error rather than a silent no-op.

Spectrum

The spectrum readout’s [spectrum] table (Plan 0034 / ADR-0036): how many elements the frequency axis is divided into, how they are laid out, and how fast each one follows its band. All three are structure rather than expression — they are fixed for as long as the preset is loaded — so they ride the existing configure hook like every other declarative config.

Fields

elements: usize

Element count, validated at load into 2..=SPECTRUM_BINS.

layout: SpectrumLayout

Which figure the elements form.

easing: Easing

Per-element temporal easing in seconds, applied on the injected real dt — the same Easing the [smoothing] table uses, deliberately reused rather than a second vocabulary (ADR-0035).

WarpMesh

The warp mesh’s [mesh] table (Plan 0100 / ADR-0113): the grid, in cells, that the per-vertex program is evaluated over.

Structural for [curve] family’s reason — the vertex and index buffers are built from it, so an eased grid would rebuild them mid-frame — and clamped to the tier at both consumers rather than at load, since the loader does not know which tier will render the preset (warp_mesh::clamp_grid).

Fields

mesh: (u32, u32)

Requested cells, (x, y), validated at load into MIN_MESH..=MAX_MESH.

milk: Option<Box<MilkBundle>>

The compiled EEL2 programs a converted preset carries, from a [milk] table (Plan 0100 Phase 2 / ADR-0113). None — a hand-authored warp_mesh preset — drives the mesh from the ordinary [params] and [per_vertex] bindings instead, and executes no VM at all.

Boxed because it is much the largest thing this enum carries and every other variant would pay for it by value.

salt: u32

The salt the bundle’s rand() draws under (ADR-0051).

The preset’s pinned_salt, always — its declared numeric seed, or 0 where it declared seed = "random". So a bundle is a pure function of its inputs in the live app as well as in the harness, which is stronger than ADR-0051 requires and costs nothing: per-run variety is opt-in through seed = "random", and no converted preset declares one. A hand-written bundle that does gets the pinned behaviour, and that is stated rather than discovered.

Path

The shape field’s [path] table (ADR-0107): an authored silhouette, as a closed contour parsed once at load from inline SVG path data.

The one variant here carrying geometry rather than a selector or a size. It rides configure for the reason every other structural table does — it is fixed for as long as the preset is loaded — and a shape_field preset declaring no table gets None and draws the closed marks roster exactly as it did before paths existed.

Fields

shape: Option<PathShape>

The contour, normalized into [-1, 1] and resampled to the arity [path] samples asked for. None — a shape_field preset that declares no table — is what makes this config always Some: it is handed over on every preset switch precisely so configure runs and clears the outgoing preset’s contour, the same reason the attractor’s and the spectrum’s configs are unconditional.

morph_to: Option<PathShape>

The silhouette the bindable morph param travels towards, from [path] morph_to. None — the default — pins the figure, so morph is inert, exactly as the attractor’s own morph_to does.

Already aligned to shape at load: same arity, same winding, and the cyclic start that minimises total displacement (ADR-0107). The render layer interpolates the two point lists and re-derives none of that, which is what keeps an O(N^2) search off the frame.

Implementations

impl GeneratorConfig

pub fn element_count(&self) -> usize

How many elements a per-element binding should be evaluated for under this config, or 0 when the system has no per-element surface (Plan 0034 Phase 4). Read once at preset load to size the render layer’s scratch.

The count lives here rather than on Scene because it is preset data: it comes off the [spectrum] table, not out of the scene’s state, and the renderer already holds the preset.

Trait Implementations

impl Clone for GeneratorConfig

fn clone(&self) -> GeneratorConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GeneratorConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.