shaders 3.1.463 → 3.2.464

package/dist/core/std/types.d.ts

@@ -0,0 +1,198 @@
+import { ComponentProps, PropConfig, BoundingBoxDeclaration } from '../types';
+import { Expr, GpuComputeNode, GpuFragmentParams, GpuMapSampleUVs, GpuUvRemap } from '../gpu/contract';
+import { FilterParams } from '../gpu/scaffolds/pointwiseFilter';
+import { RttFilterParams } from '../gpu/scaffolds/rttFilter';
+import { UvMapSource, UvRemapEdgeSource, UvRemapHookParams } from '../gpu/scaffolds/uvRemapShader';
+import { SdfShapeShaderSpec } from '../gpu/scaffolds/sdfShape';
+
+/**
+ * A declarative recompile rule — the std replacement for a `compileTimeWhen` function.
+ * `crosses(v)` recompiles only when the prop value crosses `v` (identity ↔ effect
+ * boundaries that add or remove whole code paths); `recompileWhen(fn)` is the escape for
+ * a genuinely bespoke predicate.
+ */
+export type RecompileRule = {
+    readonly kind: 'crosses';
+    readonly value: number;
+} | {
+    readonly kind: 'custom';
+    readonly predicate: (prev: any, next: any) => boolean;
+};
+/**
+ * A std prop config: the existing `PropConfig` surface (defaults, transforms, ui — the
+ * public surface, unchanged) with the function-valued `compileTimeWhen` escape hatch
+ * replaced by the declarative `recompile` rule.
+ */
+export type StdPropConfig<V> = Omit<PropConfig<V>, 'compileTimeWhen'> & {
+    recompile?: RecompileRule;
+};
+export type StdProps<T extends ComponentProps> = {
+    [K in keyof T]: StdPropConfig<T[K]>;
+};
+/**
+ * A declarative no-op condition. Lowered to the filter scaffolds' `FilterIdentity`, which
+ * owns the map-driver bypass refusal — a prop the rule reads that carries a map driver
+ * disables the bypass automatically.
+ */
+export type IdentityRule = {
+    readonly kind: 'isZero';
+    readonly prop: string;
+} | {
+    readonly kind: 'isValue';
+    readonly prop: string;
+    readonly value: unknown;
+} | {
+    readonly kind: 'allOf';
+    readonly rules: IdentityRule[];
+} | {
+    readonly kind: 'custom';
+    readonly props: string[];
+    readonly when: (values: Record<string, unknown>) => boolean;
+};
+/**
+ * A pointwise filter effect: a pure fn(color, …) over the composed child — straight
+ * alpha, no render-to-texture. The body is a blessed `'use gpu'` fn; `hint` lands in the
+ * emitted WGSL and is part of the shader's snapshot contract.
+ */
+export interface PointwiseEffect {
+    readonly kind: 'pointwise';
+    readonly body?: {
+        fn: unknown;
+        hint: string;
+    } | ((propValues: Record<string, unknown>) => {
+        fn: unknown;
+        hint: string;
+    });
+    /** Pure-Expr alternative to `body`: build the filtered colour directly (`params.childNode`
+     *  is the composed child). Exactly one of `body`/`build` must be given. */
+    readonly build?: (params: FilterParams) => Expr;
+    /** Body args AFTER the child colour (always first). */
+    readonly args?: (params: FilterParams) => Expr[];
+    /** Builder-level tail on the body's result (compile-time colour-space mixes etc.). */
+    readonly compose?: (result: Expr, params: FilterParams) => Expr;
+    /** Per-composition side effects (extraFields drivers). Non-identity path only. */
+    readonly setup?: (params: FilterParams) => void;
+}
+/**
+ * A gather filter effect: samples the child's render-to-texture (neighbour taps, screens,
+ * dithers). Taps are premultiplied; the species appends the unpremultiply tail unless the
+ * build already returns straight alpha. Identity bypasses to a centre sample — never to
+ * the raw child (the species' alpha discipline, owned here, invisible to authors).
+ */
+export interface GatherEffect {
+    readonly kind: 'gather';
+    /** Build the filtered colour from the child texture (`params.texture` / `sampleStraight`). */
+    readonly build: (params: RttFilterParams) => Expr;
+    readonly resultAlpha?: 'premultiplied' | 'straight';
+    readonly setup?: (params: RttFilterParams) => void;
+}
+/** See `filter.ts` — displace the child's sample coordinates by a simulation field. */
+export interface DisplaceByEffectRef {
+    readonly kind: 'displaceBy';
+}
+/**
+ * Fields shared by every std definition. The optional flags are the declarative half of
+ * the engine contract; species may derive some of them (a filter never declares
+ * `requiresChild`), while the custom tier states them explicitly.
+ */
+export interface StdDefinitionBase<T extends ComponentProps> {
+    name: string;
+    category?: string;
+    description?: string;
+    deprecatedNames?: string[];
+    boundingBoxDeclaration?: BoundingBoxDeclaration;
+    props: StdProps<T>;
+    usesPointer?: boolean;
+    acceptsUVContext?: boolean;
+    acceptsOptionalChild?: boolean;
+    blendWithChildren?: boolean;
+    capturesDOM?: boolean;
+    wantsBoundsParams?: boolean;
+    providesUVContextViaCompute?: boolean;
+    naturalSizeKey?: {
+        fromProp: string;
+    } | {
+        fixed: string;
+    };
+    experimental?: ComponentProps;
+    animatedTime?: {
+        speed: string;
+    };
+    extraAnimatedTimes?: Record<string, string>;
+    extraFields?: Record<string, {
+        schema: import('typegpu/data').AnyWgslData;
+        initial: number | number[];
+    }>;
+    /** A compute pass (simulation state, prepasses). Part of the L1 tier. */
+    compute?: GpuComputeNode;
+    /** Custom per-prop map-driver sample UVs (cell-centre sampling). */
+    mapSampleUVs?: GpuMapSampleUVs;
+}
+/** role 'filter' + species 'pointwise' — inline colour filter over the composed child. */
+export interface StdPointwiseFilterDefinition<T extends ComponentProps> extends StdDefinitionBase<T> {
+    role: 'filter';
+    species: 'pointwise';
+    effect: PointwiseEffect | import('./filter').TintTowardEffect;
+    /** Declared no-op condition; the lowering owns bypass + driver guards. */
+    identityWhen?: IdentityRule;
+    /** User-facing missing-child message; omit for silent (returns transparent). */
+    missingChildMessage?: string;
+}
+/** role 'filter' + species 'gather' — samples the child's render-to-texture. */
+export interface StdGatherFilterDefinition<T extends ComponentProps> extends StdDefinitionBase<T> {
+    role: 'filter';
+    species: 'gather';
+    effect: GatherEffect | import('./filter').DisplaceByEffect;
+    identityWhen?: IdentityRule;
+    missingChildMessage?: string;
+}
+/**
+ * role 'warp' — a distortion expressed as ONE coordinate map (screen UV → source UV +
+ * coverage). The lowering emits both engine paths from it — the render-to-texture
+ * fragment and the analytic fold — so they cannot drift.
+ */
+export interface StdWarpDefinition<T extends ComponentProps> extends StdDefinitionBase<T> {
+    role: 'warp';
+    map: UvMapSource;
+    /** Edge handling: `'prop'` (an `edges` prop, default) · a fixed mode · `'none'`. */
+    edges?: UvRemapEdgeSource;
+    /** Reconstruction filter on the texture path. Default `'catmullRom'`. */
+    resample?: 'catmullRom' | 'bilinear';
+    /** Analytic-path identity bail-out (a compute texture that may not exist yet). */
+    uvRemapIdentityWhen?: (params: UvRemapHookParams) => boolean;
+    missingChildMessage?: string;
+}
+/** role 'shape' — an analytic 2D SDF shape (fill + stroke + soften + bounds). */
+export interface StdShapeDefinition {
+    role: 'shape';
+    name: string;
+    description: string;
+    category?: string;
+    shape: Omit<SdfShapeShaderSpec, 'name' | 'description' | 'category'>;
+}
+/**
+ * role 'generator' — a source that paints from coordinates (no child required). `paint`
+ * is the composition builder: the L1 tier for generators whose look is a blessed body fn.
+ */
+export interface StdGeneratorDefinition<T extends ComponentProps> extends StdDefinitionBase<T> {
+    role: 'generator';
+    paint: (params: GpuFragmentParams) => Expr;
+}
+/**
+ * The custom tier — the escape hatch for effects whose composition cannot yet be said in
+ * vocabulary (simulations with bespoke render paths, materials, media, structural nodes).
+ * The declarative half stays declared on the base; the GPU half is quarantined in `gpu:`.
+ */
+export interface StdCustomDefinition<T extends ComponentProps> extends StdDefinitionBase<T> {
+    role: 'simulation' | 'shapeEffect' | 'media' | 'structural' | 'filter' | 'generator' | 'overlay';
+    species: 'custom';
+    requiresRTT?: boolean;
+    requiresChild?: boolean;
+    gpu: {
+        fragment: (params: GpuFragmentParams) => Expr;
+        uvRemap?: GpuUvRemap;
+    };
+}
+/** The std definition union — one member per role/species. */
+export type StdDefinition<T extends ComponentProps> = StdPointwiseFilterDefinition<T> | StdGatherFilterDefinition<T> | StdWarpDefinition<T> | StdShapeDefinition | StdGeneratorDefinition<T> | StdCustomDefinition<T>;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/std/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/std/types.ts"],"names":[],"mappings":"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"}

package/dist/core/std/values.d.ts

@@ -0,0 +1,49 @@
+/**
+ * std — the value graph.
+ *
+ * Nouns and slots reference values through these nodes, never through Exprs or uniforms
+ * directly — the authored file stays strict-literal data, and the lowering (`lower.ts`)
+ * turns nodes into Exprs against the composition params. Phase 0 slice: prop bindings and
+ * scalar-producing nouns with `.times()` composition; the full ScalarInput union
+ * (lengths, signals, field-valued params) lands with later phases.
+ */
+/** A binding to one of the definition's own props. */
+export interface PropRef {
+    readonly kind: 'prop';
+    readonly name: string;
+}
+/** Bind a prop by name. Identity-checked against the definition's props at lowering. */
+export declare function p(name: string): PropRef;
+/** A scalar-valued node: a prop, a product, a scalar-producing noun, or a live signal. */
+export type ScalarSource = PropRef | {
+    readonly kind: 'mul';
+    readonly a: ScalarSource;
+    readonly b: ScalarSource;
+} | {
+    readonly kind: 'radialMask';
+    readonly center: PropRef;
+    readonly radius: PropRef;
+    readonly falloff: PropRef;
+} | {
+    readonly kind: 'signal';
+    readonly build: (params: SignalSlotParams) => import('../gpu/contract').Expr;
+};
+/** What a signal build receives: any slot host has props+uniforms; `ctx` only in fragment hosts. */
+export interface SignalSlotParams {
+    props: import('../gpu/contract').Expr;
+    uniforms: Record<string, import('../gpu/contract').Expr>;
+    ctx?: import('../gpu/contract').GpuFragmentParams['ctx'];
+}
+/**
+ * A scalar value in the authoring surface. Wraps the data node and carries the fluent
+ * combinators (`.times()`); serialization reads `.node`.
+ */
+export declare class Scalar {
+    readonly node: ScalarSource;
+    constructor(node: ScalarSource);
+    /** Multiply by another scalar (a prop or another Scalar). */
+    times(other: Scalar | PropRef): Scalar;
+}
+/** What scalar-typed slots accept. */
+export type ScalarInput = Scalar | PropRef;
+//# sourceMappingURL=values.d.ts.map

package/dist/core/std/values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/std/values.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,sDAAsD;AACtD,MAAM,WAAW,OAAO;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACxB;AAED,wFAAwF;AACxF,wBAAgB,CAAC,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvC;AAED,0FAA0F;AAC1F,MAAM,MAAM,YAAY,GAClB,OAAO,GACP;IAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,CAAA;CAAC,GAC1E;IAAC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAAC,GAC5G;IAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,gBAAgB,KAAK,OAAO,iBAAiB,EAAE,IAAI,CAAA;CAAC,CAAA;AAE7G,oGAAoG;AACpG,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,OAAO,iBAAiB,EAAE,IAAI,CAAA;IACrC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,iBAAiB,EAAE,IAAI,CAAC,CAAA;IACxD,GAAG,CAAC,EAAE,OAAO,iBAAiB,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAA;CAC3D;AAED;;;GAGG;AACH,qBAAa,MAAM;IACH,QAAQ,CAAC,IAAI,EAAE,YAAY;gBAAlB,IAAI,EAAE,YAAY;IAEvC,6DAA6D;IAC7D,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM;CAGzC;AAED,sCAAsC;AACtC,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,OAAO,CAAA"}

package/dist/core/std/warps.d.ts

@@ -0,0 +1,224 @@
+import { UvMapSource } from '../gpu/scaffolds/uvRemapShader';
+import { ArgSpec } from './invoke';
+import { GatherEffect } from './types';
+import { PropRef } from './values';
+
+/**
+ * Reflect content across the line through `center` at `angle` (degrees).
+ *
+ * The reflection body returns a hard 0/1 side selector alongside the reflected coordinate,
+ * so `selectMap` picks per pixel between the original coordinate (near side) and the
+ * reflected one (far side). Selecting COORDINATES and sampling once is pixel-identical to
+ * mixing two sampled colours by the same hard selector, with one texture fetch instead of
+ * two, and both halves go through the same reconstruction filter so the filtering never
+ * changes across the mirror line.
+ */
+export declare function mirrorLine(slots: {
+    center: ArgSpec;
+    angle: ArgSpec;
+}): UvMapSource;
+/**
+ * Mirror content across the canvas axes. `flipX`/`flipY` bind boolean props stored as ±1
+ * uniforms (transformBoolean). The map sends [0,1] onto [0,1], so pair it with
+ * `edges: 'none'` — no lookup can land outside the source.
+ */
+export declare function flip(slots: {
+    flipX: ArgSpec;
+    flipY: ArgSpec;
+}): UvMapSource;
+/**
+ * Bend the ends of the frame toward (or away from) the viewer like a curved display —
+ * the inverse bent-sheet projection, under real perspective. `angle` sets the bend axis in
+ * degrees; `falloff` concentrates the bend toward the ends.
+ */
+export declare function bend(slots: {
+    strength: ArgSpec;
+    falloff: ArgSpec;
+    angle: ArgSpec;
+}): UvMapSource;
+/**
+ * Magnify or pinch content around `center` — positive strength bulges out, negative
+ * pinches in, with `radius`/`falloff` shaping the affected disc.
+ */
+export declare function bulge(slots: {
+    center: ArgSpec;
+    strength: ArgSpec;
+    radius: ArgSpec;
+    falloff: ArgSpec;
+}): UvMapSource;
+/** Rotate and twist content around `center`, with the twist angle growing with distance. */
+export declare function twirl(slots: {
+    center: ArgSpec;
+    intensity: ArgSpec;
+}): UvMapSource;
+/** Fold content into radial mirrored segments around `center` (`angle` in degrees). */
+export declare function kaleidoscope(slots: {
+    center: ArgSpec;
+    segments: ArgSpec;
+    angle: ArgSpec;
+}): UvMapSource;
+/**
+ * Stretch content along a direction (`angle` in degrees) away from `center`, with
+ * `falloff` controlling how sharply the stretch ramps in past the center.
+ */
+export declare function stretch(slots: {
+    center: ArgSpec;
+    strength: ArgSpec;
+    angle: ArgSpec;
+    falloff: ArgSpec;
+}): UvMapSource;
+/**
+ * Displace content along a direction by an animated wave. `waveType` binds a compile-time
+ * prop (sine/triangle/square/sawtooth/bounce): the producer branches once per composition
+ * and only the active waveform body is emitted — no runtime branch. The phase advances by
+ * the definition's animated clock (declare `animatedTime: {speed: 'speed'}`), at half rate.
+ */
+export declare function wave(slots: {
+    strength: ArgSpec;
+    frequency: ArgSpec;
+    angle: ArgSpec;
+    waveType: PropRef;
+}): UvMapSource;
+/**
+ * Convert rectangular coordinates to polar space around `center` (`wrap` scales the
+ * angular range, `radius` the radial one), lerped toward the identity by `intensity` —
+ * 0 leaves the content alone, 1 is the full coordinate-system change. `lerpToIdentity`
+ * blends COORDINATES, not colours, so intermediate values are a genuine partial warp
+ * rather than a cross-fade.
+ */
+export declare function toPolar(slots: {
+    center: ArgSpec;
+    wrap: ArgSpec;
+    radius: ArgSpec;
+    intensity: ArgSpec;
+}): UvMapSource;
+/**
+ * Convert polar coordinates back to rectangular space around `center` (the mirror of
+ * {@link toPolar}), lerped toward the identity by `intensity`.
+ */
+export declare function fromPolar(slots: {
+    center: ArgSpec;
+    scale: ArgSpec;
+    intensity: ArgSpec;
+}): UvMapSource;
+/**
+ * Pin each corner of the content to an arbitrary position — a true square→quad corner-pin
+ * homography, inverted analytically. The body returns a packed `vec3f` (projected
+ * coordinate in `.xy`, front-facing gate in `.z`), so the map returns the COVERAGE form:
+ * the warp role applies coverage to sampled alpha on the fragment path and to the coverage
+ * mask on the analytic path, clipping the folded-back region either way. `amount` blends
+ * each corner toward its neutral rectangle position.
+ */
+export declare function cornerPin(slots: {
+    topLeft: ArgSpec;
+    topRight: ArgSpec;
+    bottomRight: ArgSpec;
+    bottomLeft: ArgSpec;
+    amount: ArgSpec;
+}): UvMapSource;
+/**
+ * Rotate the plane in 3D space with pan and tilt (degrees), `fov` controlling perspective
+ * intensity and `zoom` scaling the sampled area. The map ignores `aspect` — it samples in
+ * raw UV space, unlike the other warps here.
+ */
+export declare function perspective(slots: {
+    center: ArgSpec;
+    pan: ArgSpec;
+    tilt: ArgSpec;
+    fov: ArgSpec;
+    zoom: ArgSpec;
+    offset: ArgSpec;
+}): UvMapSource;
+/**
+ * Concentric rings that each rotate the content by different amounts — per-ring hashed
+ * static + animated rotation, blended between adjacent rings along the shortest angular
+ * path. The ring rotation advances by the definition's animated clock (declare
+ * `animatedTime: {speed: 'speed'}`).
+ */
+export declare function concentricRings(slots: {
+    center: ArgSpec;
+    intensity: ArgSpec;
+    rings: ArgSpec;
+    smoothness: ArgSpec;
+    seed: ArgSpec;
+    speedRandomness: ArgSpec;
+}): UvMapSource;
+/**
+ * Fluid-like distortion with constant smooth motion: three noise layers drifting through a
+ * 3D field, combined and normalised so the flow speed is constant and `strength` is the
+ * only magnitude control. Reads TWO animated clocks — the primary flow drift and the
+ * `evolution` extra clock (declare `animatedTime: {speed: ...}` plus
+ * `extraAnimatedTimes: {evolution: ...}`), each at 1/10 rate. `seed` binds a prop added to
+ * both clocks on the GPU, shifting the noise domain along the drift/evolution axes — a
+ * different static pattern per seed value, even at speed 0.
+ */
+export declare function flowNoise(slots: {
+    strength: ArgSpec;
+    detail: ArgSpec;
+    seed: PropRef;
+}): UvMapSource;
+/**
+ * Slice the content into strips that slide away in alternating directions — the "shredder"
+ * transition. At progress 1 every lookup is out of bounds, so pair it with a fixed
+ * TRANSPARENT edge mode (`edges: 1`): clipping the vacated space is what makes it a wipe.
+ */
+export declare function slicedSlide(slots: {
+    angle: ArgSpec;
+    count: ArgSpec;
+    progress: ArgSpec;
+}): UvMapSource;
+/**
+ * Slice content into parallel bars, each offset independently by a hash for a fractured or
+ * glitch-like look. Each bar drifts at its own hashed rate by the definition's animated
+ * clock (declare `animatedTime: {speed: 'speed'}`).
+ */
+export declare function barOffset(slots: {
+    count: ArgSpec;
+    angle: ArgSpec;
+    intensity: ArgSpec;
+    seed: ArgSpec;
+}): UvMapSource;
+/**
+ * Displace by this node's own compute-generated displacement field, sampled per grid cell:
+ * snap the incoming UV to the centre of its `gridSize` cell, read the displacement texture
+ * there, offset (±0.1 clamp), then edge-handle.
+ *
+ * When the compute texture is absent (GPU-free composition, or before the compute hook has
+ * run) the map substitutes a zero displacement and keeps its structure identical — pair the
+ * definition with `uvRemapIdentityWhen` so the analytic path returns the incoming remap
+ * verbatim in that case instead.
+ */
+export declare function gridCellDisplace(slots: {
+    gridSize: ArgSpec;
+    output: string;
+}): UvMapSource;
+/**
+ * Displace by this node's own compute-generated displacement field, sampled continuously at
+ * the incoming UV and scaled by `intensity` (±0.15 clamp) — the liquid/cloth look. Same
+ * absent-texture handling as {@link gridCellDisplace}: zero displacement here, with
+ * `uvRemapIdentityWhen` covering the analytic path on the definition.
+ */
+export declare function liquidDisplace(slots: {
+    intensity: ArgSpec;
+    output: string;
+}): UvMapSource;
+/**
+ * Distort the child using ANOTHER LAYER's pixels as a displacement map — the classic
+ * Photoshop/AE displacement, driven cross-layer rather than by a procedural field, hence a
+ * gather effect (the source arrives via `getLayerTexture`, the same shared RTT boundary
+ * prop maps use, so the layer renders once even when it's also visible on canvas). An
+ * animated source layer displaces live.
+ *
+ * `source` binds the compile-time layer prop; `channels` picks the applier at composition
+ * (red/green two-axis vs luminance along `angle`); `edges` binds the compile-time edge
+ * mode. No source selected (or an unresolvable id) → a sharp passthrough of the child,
+ * exactly as sampled at the incoming coordinate.
+ */
+export declare function displaceByLayer(slots: {
+    source: PropRef;
+    amount: ArgSpec;
+    channels: PropRef;
+    angle: ArgSpec;
+    edges: PropRef;
+}): GatherEffect;
+//# sourceMappingURL=warps.d.ts.map

package/dist/core/std/warps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warps.d.ts","sourceRoot":"","sources":["../../src/std/warps.ts"],"names":[],"mappings":"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"}