drawnui-react 0.1.0-preview.1

package/dist/core/SkiaEffect.d.ts

@@ -0,0 +1,216 @@
+import type { Image, Shader } from "canvaskit-wasm";
+import type { DrawingContext, SkiaControl } from "./SkiaControl";
+import { SkiaValueAnimator } from "./Animators";
+import { type ShaderTileMode, SKRect, Thickness } from "./Types";
+/** C# PostRendererEffectUseBackgroud: how a post-renderer sources its input texture. */
+export type PostRendererEffectUseBackground = "Always" | "Once" | "Never";
+export type SkiaFilterMode = "Linear" | "Nearest";
+export type SkiaMipmapMode = "None" | "Nearest" | "Linear";
+/**
+ * C# CachedTexture: a control's rasterized output and the canvas rect it was rasterized over. Texel (0,0) sits at the
+ * top-left of Bounds (a cache image); a whole-surface snapshot sets `Origin` = the canvas point its texel (0,0) is at,
+ * so the texture shader is translated accordingly. Shaders sample textures in texel space (fragCoord - iOffset).
+ */
+export interface CachedTexture {
+    Image: Image;
+    Bounds: SKRect;
+    Origin?: {
+        X: number;
+        Y: number;
+    };
+}
+/**
+ * Mirrors DrawnUi SkiaEffect: something attached to a control through `VisualEffects`. `Update()` re-renders the
+ * parent (C# invalidates the parent's cache and redraws), `GetEffectMargin` reports what it paints outside the box.
+ */
+export declare class SkiaEffect {
+    /** Set by Attach/Dettach. */
+    Parent?: SkiaControl;
+    Tag?: string;
+    Attach(parent: SkiaControl): void;
+    Dettach(): void;
+    /** Cached resources must be dropped here, not on the next draw (C# contract). */
+    protected OnDisposing(): void;
+    Dispose(): void;
+    /** Effect parameters changed: the parent's cache is re-recorded and the composition redrawn (C# Parent.Update). */
+    Update(): void;
+    /** Extra space in PIXELS painted beyond the parent's DrawingRect. */
+    GetEffectMargin(_scale: number): Thickness;
+    get NeedApply(): boolean;
+}
+/** C# ISkiaGestureProcessor: an effect that receives the parent's gestures before its children; return non-null to consume. */
+export interface ISkiaGestureProcessor {
+    ProcessGestures(args: import("./Gestures").SkiaGesturesParameters, apply: import("./Gestures").GestureEventProcessingInfo): SkiaControl | null;
+}
+/** C# IPostRendererEffect: draws over the parent's output after it was painted / from its cache. */
+export interface IPostRendererEffect {
+    Render(ctx: DrawingContext): void;
+    UseBackground: PostRendererEffectUseBackground;
+    AquiredBackground: boolean;
+    NeedApply: boolean;
+}
+export declare function IsPostRendererEffect(e: SkiaEffect): e is SkiaEffect & IPostRendererEffect;
+/**
+ * Mirrors DrawnUi SkiaShaderEffect: an SkSL fragment shader (`ShaderSource` url or inline `ShaderCode`, optionally
+ * wrapped by a `ShaderTemplate` at `//script-goes-here`) drawn over the parent control with the Shadertoy-style
+ * uniforms `iResolution`, `iImageResolution`, `iTime`, `iOffset`, `iMouse` and the parent's own output as the
+ * `iImage1` texture (`UseBackground` Always / Once / Never, `AutoCreateInputTexture`). Extra uniforms through
+ * `SetUniform`, extra textures by overriding `CreateTexturesUniforms`. Uniforms not declared by the shader are
+ * skipped, declared texture children that are not supplied sample transparent.
+ */
+export declare class SkiaShaderEffect extends SkiaEffect implements IPostRendererEffect {
+    /** Url of the .sksl file (fetched once, compiled once per text). */
+    get ShaderSource(): string;
+    set ShaderSource(v: string);
+    /** Inline SkSL, used when ShaderSource is not set. */
+    get ShaderCode(): string;
+    set ShaderCode(v: string);
+    /** Url of a template .sksl whose `//script-goes-here` is replaced by the shader. */
+    get ShaderTemplate(): string;
+    set ShaderTemplate(v: string);
+    /** Snapshot the surface being drawn (true) or the on-screen one. */
+    UseContext: boolean;
+    /** Create the `iImage1` texture from the parent's output; false for output-only shaders. */
+    AutoCreateInputTexture: boolean;
+    UseBackground: PostRendererEffectUseBackground;
+    AquiredBackground: boolean;
+    BlendMode: string;
+    FilterMode: SkiaFilterMode;
+    MipmapMode: SkiaMipmapMode;
+    /** Tile mode of the input textures. */
+    TileMode: ShaderTileMode;
+    /** Set every Render from the frame time (seconds); can be driven manually. */
+    TimeSeconds: number;
+    /** Shadertoy iMouse.xy, pixels relative to the control. */
+    MouseCurrent: {
+        X: number;
+        Y: number;
+    };
+    /** Shadertoy iMouse.zw: where a drag started, zero = not dragging. */
+    MouseInitial: {
+        X: number;
+        Y: number;
+    };
+    /** Custom uniforms by name (float arrays sized like the SkSL type), merged on top of the standard ones. */
+    readonly Uniforms: Map<string, number[]>;
+    /** Compilation errors land here; without a handler they are logged. */
+    OnCompilationError?: (effect: SkiaShaderEffect, error: string) => void;
+    /** Code as loaded/assembled for the last compile. */
+    LoadedCode: string;
+    private shaderSource;
+    private shaderCode;
+    private shaderTemplate;
+    private compiled?;
+    private compiledKey;
+    private uniformSlots;
+    private uniformFloats;
+    private childNames;
+    private hasNewShader;
+    private compileFailed;
+    private loading?;
+    private loadedSource?;
+    private loadedTemplate?;
+    private textureShader?;
+    private frozen?;
+    private frozenOwned;
+    private paint?;
+    get IsCompiled(): boolean;
+    /** C# NeedApply && IsCompiled; the compile itself is attempted here (sync once the source is loaded) so a fresh effect gets its first chance before the render decides between the plain blit and the shader. */
+    get NeedApply(): boolean;
+    /** Loads (async, once) and compiles (sync) when needed; true when a compiled effect exists. */
+    EnsureCompiled(): boolean;
+    SetUniform(name: string, ...values: number[]): this;
+    ReleaseFrozenSnapshot(): void;
+    private DisposeImage;
+    protected ApplyShaderSource(): void;
+    /** Snapshot of what the parent painted (C# CreateSnapshot): the surface the pixels are on, mapped through its origin. */
+    protected CreateSnapshot(ctx: DrawingContext, destination: SKRect): CachedTexture | undefined;
+    /** C# GetPrimaryTexture: the parent's cache, a frozen snapshot (Once) or nothing (Never). */
+    protected GetPrimaryTexture(_ctx: DrawingContext, _destination: SKRect): CachedTexture | undefined;
+    /** Image → shader with the effect's sampling, translated so texel (0,0) = bounds top-left; cached per image. */
+    protected CreateTextureShader(texture: CachedTexture): Shader;
+    /** Texture children by name (C# CreateTexturesUniforms). Override to add `iImage2` etc. */
+    protected CreateTexturesUniforms(_ctx: DrawingContext, _destination: SKRect, primaryTexture?: Shader): Record<string, Shader | undefined>;
+    /** Standard uniforms + `Uniforms` (C# CreateUniforms). Override, call super and add your own with `Set`. */
+    protected CreateUniforms(destination: SKRect, textureBounds: SKRect | undefined, values: Float32Array): void;
+    /** Writes a uniform by name into the flat float array; undeclared names are skipped like C#. */
+    protected Set(values: Float32Array, name: string, ...v: number[]): void;
+    private static FetchText;
+    /** Fetches ShaderSource / ShaderTemplate when needed; true when the code is ready to compile. */
+    private EnsureLoaded;
+    protected SendError(error: string): void;
+    /** The template wrapping the code; subclasses supply a default (ShaderTransitionEffect). */
+    protected GetTemplate(): string;
+    protected CompileShader(): void;
+    /** Builds this frame's shader (C# CreateShader). */
+    CreateShader(ctx: DrawingContext, source: CachedTexture | undefined): {
+        shader: Shader;
+        children: Shader[];
+    } | undefined;
+    /** IPostRendererEffect: draws the shader over ctx.Destination (C# Render). */
+    Render(ctx: DrawingContext): void;
+    protected OnDisposing(): void;
+}
+/**
+ * Mirrors DrawnUi ShaderDoubleTexturesEffect: two input textures. `iImage1` comes from `ControlFrom`'s cache or a
+ * `PrimarySource` image, `iImage2` from `ControlTo`'s cache or a `SecondarySource` image (both resized to the parent
+ * box like C#), else from the parent as usual.
+ */
+export declare class ShaderDoubleTexturesEffect extends SkiaShaderEffect {
+    get ControlFrom(): SkiaControl | undefined;
+    set ControlFrom(v: SkiaControl | undefined);
+    get ControlTo(): SkiaControl | undefined;
+    set ControlTo(v: SkiaControl | undefined);
+    get PrimarySource(): string;
+    set PrimarySource(v: string);
+    get SecondarySource(): string;
+    set SecondarySource(v: string);
+    private controlFrom?;
+    private controlTo?;
+    private primarySource;
+    private secondarySource;
+    private primaryImage?;
+    private secondaryImage?;
+    private resizedPrimary?;
+    private resizedSecondary?;
+    private secondary?;
+    private LoadTexture;
+    /** C# Resize*LoadedBitmap: the file texture spans the parent box. */
+    private Resized;
+    protected GetPrimaryTexture(ctx: DrawingContext, destination: SKRect): CachedTexture | undefined;
+    /** C# GetSecondaryTexture: ControlTo's cache image or the resized SecondarySource, as a clamped shader. */
+    protected GetSecondaryTexture(ctx: DrawingContext): Shader | undefined;
+    private secondaryImageRef?;
+    protected CreateTexturesUniforms(ctx: DrawingContext, destination: SKRect, primaryTexture?: Shader): Record<string, Shader | undefined>;
+    protected OnDisposing(): void;
+}
+/**
+ * Mirrors DrawnUi ShaderTransitionEffect: `iImage1` = from, `iImage2` = to, plus `progress` (0..1) and `ratio`
+ * (width / height) uniforms; without a ShaderTemplate the gl-transitions adapter `DefaultTemplate` wraps a
+ * `transition(vec2 uv)` function using `getFromColor` / `getToColor`.
+ */
+export declare class ShaderTransitionEffect extends ShaderDoubleTexturesEffect {
+    static readonly DefaultTemplate = "\nuniform float ratio; // width / height\nuniform float progress; // 0.0 - 1.0\nuniform shader iImage1; // Texture\nuniform shader iImage2; // Texture for backside\nuniform float2 iOffset; // Top-left corner of DrawingRect\nuniform float2 iResolution; // Viewport resolution (pixels)\nuniform float2 iImageResolution; // iImage1 resolution (pixels)\nuniform float  iTime; // Shader playback time (s)\nuniform float4 iMouse; // Mouse drag pos=.xy Click pos=.zw (pixels)\n\n//In GLSL, the texture coordinate origin is at the bottom-left corner,\n//whereas in SKSL the origin is at the top-left corner.\n\nvec4 getFromColor(vec2 uv) {\n    vec2 adjustedUV = float2(uv.x, 1.0 - uv.y) * iImageResolution;\n    return iImage1.eval(adjustedUV);\n}\n\nvec4 getToColor(vec2 uv) {\n    vec2 adjustedUV = float2(uv.x, 1.0 - uv.y) * iImageResolution;\n    return iImage2.eval(adjustedUV);\n}\n\n//script-goes-here\n";
+    /** 0 = fully ControlFrom, 1 = fully ControlTo; call Update() after changing. */
+    Progress: number;
+    protected GetTemplate(): string;
+    protected CreateUniforms(destination: SKRect, textureBounds: SKRect | undefined, values: Float32Array): void;
+}
+/**
+ * Mirrors DrawnUi AnimatedShaderEffect: a `progress` 0→1 uniform driven by an animator over `DurationMs`
+ * (2500) plus `iCenter` (normalized). `Play()` restarts, `Completed` fires when it finishes, `Stop()` is silent.
+ */
+export declare class AnimatedShaderEffect extends SkiaShaderEffect {
+    Center: {
+        X: number;
+        Y: number;
+    };
+    DurationMs: number;
+    Progress: number;
+    Completed?: (effect: AnimatedShaderEffect) => void;
+    protected Animator?: SkiaValueAnimator;
+    Play(): void;
+    Stop(): void;
+    protected CreateUniforms(destination: SKRect, textureBounds: SKRect | undefined, values: Float32Array): void;
+    protected OnDisposing(): void;
+}