@xifu/shader-graph-glsl 0.1.0

package/dist/editor/index.d.ts

@@ -0,0 +1,2703 @@
+import { Box2, BufferGeometry } from 'three';
+import { S as ShaderConfig } from '../ShaderConfig-RGrO5cST.js';
+export { U as UniformMeta, a as UniformValue, b as UniformValues } from '../ShaderConfig-RGrO5cST.js';
+
+declare class Events {
+    handlers: {};
+    constructor(handlers: {});
+}
+interface EventsTypes$2 {
+    warn: string | Error;
+    error: string | Error;
+    componentregister: Component$1;
+    destroy: void;
+}
+
+declare class Emitter<EventTypes> {
+    events: {
+        [key: string]: Function[];
+    };
+    silent: boolean;
+    constructor(events: Events | Emitter<EventTypes>);
+    on<K extends keyof EventTypes>(names: K | K[], handler: (args: EventTypes[K]) => void | unknown): () => void;
+    trigger<K extends keyof EventTypes>(name: K, params?: EventTypes[K] | {}): boolean;
+    bind(name: string): void;
+    exist(name: string): boolean;
+    removeEvents(): void;
+}
+
+interface Plugin {
+    name: string;
+    install: (context: any, options?: any) => void;
+}
+type PluginParams<T extends Plugin> = T['install'] extends (arg1: unknown, arg2: infer U) => void ? U : void;
+
+declare class Context$1<EventsTypes> extends Emitter<EventsTypes & EventsTypes$2> {
+    id: string;
+    plugins: Map<string, unknown>;
+    components: Map<string, Component$1>;
+    constructor(id: string, events: Events);
+    use<T extends Plugin, O extends PluginParams<T>>(plugin: T, options?: O): void;
+    register(component: Component$1): void;
+    destroy(): void;
+}
+
+interface ConnectionData {
+    node: number;
+    data: unknown;
+}
+type InputConnectionData = ConnectionData & {
+    output: string;
+};
+type OutputConnectionData = ConnectionData & {
+    input: string;
+};
+interface InputData {
+    connections: InputConnectionData[];
+}
+interface OutputData {
+    connections: OutputConnectionData[];
+}
+interface InputsData {
+    [key: string]: InputData;
+}
+interface OutputsData {
+    [key: string]: OutputData;
+}
+interface NodeData {
+    id: number;
+    name: string;
+    inputs: InputsData;
+    outputs: OutputsData;
+    blocks: NodeData[];
+    data: {
+        [key: string]: unknown;
+    };
+    position: [number, number];
+    contextId?: number;
+}
+interface NodesData {
+    [id: string]: NodeData;
+}
+interface Data {
+    id: string;
+    nodes: NodesData;
+}
+interface WorkerInputs {
+    [key: string]: unknown[];
+}
+interface WorkerOutputs {
+    [key: string]: unknown;
+}
+
+interface EventsTypes$1 {
+}
+
+interface EngineNode extends NodeData {
+    busy: boolean;
+    unlockPool: (() => void)[];
+    outputData: WorkerOutputs;
+}
+declare class Engine extends Context$1<EventsTypes$1> {
+    args: unknown[];
+    data: Data | null;
+    state: number;
+    forwarded: Set<unknown>;
+    onAbort: () => void;
+    constructor(id: string);
+    clone(): Engine;
+    throwError(message: string, data?: unknown): Promise<string>;
+    private processStart;
+    private processDone;
+    abort(): Promise<void>;
+    private lock;
+    unlock(node: EngineNode): void;
+    private extractInputData;
+    private processWorker;
+    private processNode;
+    private forwardProcess;
+    copy(data: Data): Data;
+    validate(data: Data): Promise<string | true>;
+    private processStartNode;
+    private processUnreachable;
+    process<T extends unknown[]>(data: Data, startId?: number | string | null, ...args: T): Promise<"success" | "aborted" | undefined>;
+}
+
+declare abstract class Component$1 {
+    name: string;
+    data: unknown;
+    engine: Engine | null;
+    constructor(name: string);
+    abstract worker(node: NodeData, inputs: WorkerInputs, outputs: WorkerOutputs, ...args: unknown[]): void;
+}
+
+declare class Control {
+    key: string;
+    data: unknown;
+    parent: Node | Input | null;
+    props?: any;
+    render?: string;
+    component?: any;
+    constructor(key: string);
+    getNode(): Node;
+    getData(key: string): unknown;
+    putData(key: string, data: unknown): void;
+    setNodeValue(prefix: string, data: any): void;
+    update: (cb?: () => void) => void;
+}
+
+declare class Socket {
+    name: string;
+    data: unknown;
+    compatible: Socket[];
+    constructor(name: string, data?: {});
+    combineWith(socket: Socket): void;
+    compatibleWith(socket: Socket): boolean;
+}
+
+declare class IO {
+    type: 'input' | 'output';
+    node: Node | null;
+    multipleConnections: boolean;
+    connections: Connection[];
+    key: string;
+    name: string;
+    socket: Socket;
+    constructor(key: string, name: string, socket: Socket, multiConns: boolean);
+    removeConnection(connection: Connection): void;
+    removeConnections(): void;
+}
+
+declare class Input extends IO {
+    type: "input";
+    control: Control | null;
+    constructor(key: string, title: string, socket: Socket, multiConns?: boolean);
+    hasConnection(): boolean;
+    addConnection(connection: Connection): void;
+    addControl(control: Control): this;
+    showControl(): boolean;
+    toJSON(): InputData;
+}
+
+declare class Output extends IO {
+    type: "output";
+    constructor(key: string, title: string, socket: Socket, multiConns?: boolean);
+    hasConnection(): boolean;
+    connectTo(input: Input): Connection;
+    connectedTo(input: Input): boolean;
+    toJSON(): OutputData;
+}
+
+interface Transform {
+    k: number;
+    x: number;
+    y: number;
+}
+interface Mouse {
+    x: number;
+    y: number;
+}
+type ZoomSource = 'wheel' | 'touch' | 'dblclick';
+declare class Area extends Emitter<EventsTypes> {
+    editor: EditorView;
+    el: HTMLElement;
+    container: HTMLElement;
+    selectRectEl: HTMLDivElement;
+    transform: Transform;
+    mouse: Mouse;
+    private _startPosition;
+    private _zoom;
+    private _drag;
+    private _dragMode?;
+    private _startSelect?;
+    private _selectBox;
+    constructor(container: HTMLElement, editor: EditorView);
+    update(): void;
+    pointermove: (e: PointerEvent) => void;
+    onStart: (e: PointerEvent) => void;
+    onTranslate: (dx: number, dy: number, e: PointerEvent) => void;
+    onEnd: (e: PointerEvent) => void;
+    onZoom: (delta: number, ox: number, oy: number, source: ZoomSource) => void;
+    updateSelectRect(e: PointerEvent): void;
+    convertToGraphSpace(screenSpace: [number, number]): [number, number];
+    translate(x: number, y: number): void;
+    zoom(zoom: number, ox: number | undefined, oy: number | undefined, source: ZoomSource): void;
+    appendChild(el: HTMLElement): void;
+    removeChild(el: HTMLElement): void;
+}
+
+declare class ControlView extends Emitter<EventsTypes> {
+    el: HTMLElement;
+    control: Control;
+    constructor(el: HTMLElement, control: Control, emitter: Emitter<EventsTypes>);
+    onRebind(): void;
+    dispose(): void;
+}
+
+declare class Drag {
+    private onTranslate;
+    private onStart;
+    private onDrag;
+    pointerStart: [number, number] | null;
+    el: HTMLElement;
+    destroy: () => void;
+    constructor(el: HTMLElement, onTranslate?: (_x: number, _y: number, _e: PointerEvent) => void, onStart?: (_e: PointerEvent) => void, onDrag?: (_e: PointerEvent) => void);
+    down: (e: PointerEvent) => void;
+    move: (e: PointerEvent) => void;
+    up: (e: PointerEvent) => void;
+}
+
+declare class SocketView extends Emitter<EventsTypes> {
+    el: HTMLElement;
+    type: string;
+    io: IO;
+    node: Node;
+    constructor(el: HTMLElement, type: string, io: IO, node: Node, emitter: Emitter<EventsTypes>);
+    onRebind(): void;
+    getPosition({ position }: {
+        position: number[];
+    }, nodeViewEl: HTMLElement): [number, number];
+    dispose(): void;
+}
+
+declare class BlockView extends Emitter<EventsTypes> {
+    node: Node;
+    component: Component$1;
+    sockets: Map<IO, SocketView>;
+    controls: Map<Control, ControlView>;
+    el: HTMLElement;
+    contextView: NodeView;
+    disposeListener: () => void;
+    drag: Drag;
+    dragInfo?: {
+        centerYs: number[];
+        siblings: Element[];
+        nextIndex: number;
+    };
+    constructor(el: HTMLElement, node: Node, component: Component$1, contextView: NodeView);
+    onRebind(el?: HTMLElement, force?: boolean): void;
+    clearSockets(): void;
+    bindSocket: (el: HTMLElement, type: string, io: IO) => void;
+    bindControl: (el: HTMLElement, control: Control) => void;
+    hasSocket(io: IO): boolean;
+    getSocketPosition(io: IO): [number, number];
+    onSelect: (e: MouseEvent) => void;
+    onStart: () => void;
+    onTranslate: (dx: number, dy: number, e: PointerEvent) => void;
+    onDragEnd: (e: PointerEvent) => void;
+    dispose: () => void;
+}
+
+declare class NodeView extends Emitter<EventsTypes> {
+    editorView: EditorView;
+    node: Node;
+    component: Component$1;
+    components: Map<string, Component$1>;
+    sockets: Map<IO, SocketView>;
+    controls: Map<Control, ControlView>;
+    blocks: Map<Node, BlockView>;
+    el: HTMLElement;
+    protected _startPosition: number[];
+    protected _drag: Drag;
+    resizeObserver: ResizeObserver;
+    disposeContextMenu: () => void;
+    boundingBox: Box2;
+    disposeMouseEnter: () => void;
+    disposeMouseLeave: () => void;
+    constructor(node: Node, component: Component$1, editorView: EditorView, components: Map<string, Component$1>);
+    updateBox(): void;
+    clearSockets(): void;
+    bindSocket: (el: HTMLElement, type: string, io: IO) => void;
+    bindControl: (el: HTMLElement, control: Control) => void;
+    bindBlock: (el: HTMLElement, node: Node) => void;
+    hasSocket(io: IO): boolean;
+    getSocketPosition(io: IO): [number, number];
+    onSelect: (e: MouseEvent) => void;
+    onStart: () => void;
+    onTranslate: (dx: number, dy: number) => void;
+    onDrag: (dx: number, dy: number) => void;
+    translate(x: number, y: number): void;
+    update(): void;
+    dispose(): void;
+}
+
+declare class Selected {
+    editor: NodeEditor;
+    list: Node[];
+    copyed?: NodeData[];
+    copyedBox: Box2;
+    constructor(editor: NodeEditor);
+    add(item: Node, accumulate?: boolean): void;
+    clear(): void;
+    remove(item: Node): void;
+    contains(item: Node): boolean;
+    each(callback: (n: Node, index: number) => void): void;
+    copy(): void;
+}
+
+declare class NodeEditor extends Context$1<EventsTypes> {
+    nodes: Node[];
+    selected: Selected;
+    view: EditorView;
+    constructor(id: string, container: HTMLElement);
+    addNode(node: Node): void;
+    removeNode(node: Node): void;
+    addBlock(contextNode: Node, node: Node, ...other: any[]): void;
+    connect(output: Output, input: Input, data?: unknown, handelError?: boolean): void;
+    removeConnection(connection: Connection): void;
+    selectNode(node: Node, accumulate?: boolean, fromRectSelect?: boolean): void;
+    unselect(): void;
+    getComponent(name: string): Component;
+    register(component: Component): void;
+    createNode(name: string, data?: any): Promise<Node>;
+    clear(): void;
+    toJSON(): Data;
+    beforeImport(json: Data): boolean;
+    afterImport(): boolean;
+    buildNode(nodeData: NodeData): Promise<Node>;
+    fromJSON(json: Data): Promise<boolean>;
+}
+
+declare class EditorView extends Emitter<EventsTypes> {
+    editor: NodeEditor;
+    container: HTMLElement;
+    components: Map<string, Component$1>;
+    nodes: Map<Node, NodeView>;
+    connections: Map<Connection, ConnectionView>;
+    area: Area;
+    areaRoot: HTMLDivElement;
+    constructor(container: HTMLElement, components: Map<string, Component$1>, editor: NodeEditor);
+    addNode(node: Node): void;
+    removeNode(node: Node, update?: boolean): void;
+    addConnection(connection: Connection): void;
+    removeConnection(connection: Connection): void;
+    updateConnections({ node }: {
+        node: Node;
+    }): void;
+    resize(): void;
+    click: (e: Event) => void;
+    dispose: () => void;
+}
+
+interface EventsTypes extends EventsTypes$2 {
+    componentregister: Component;
+    nodecreate: Node;
+    nodecreated: Node;
+    noderemove: Node;
+    noderemoved: Node;
+    connectioncreate: {
+        input: Input;
+        output: Output;
+    };
+    connectioncreated: Connection;
+    connectionremove: Connection;
+    connectionremoved: Connection;
+    translatenode: {
+        node: Node;
+        dx: number;
+        dy: number;
+    };
+    nodetranslate: {
+        node: Node;
+        x: number;
+        y: number;
+    };
+    nodetranslated: {
+        node: Node;
+        prev: [number, number];
+    };
+    nodedraged: Node;
+    nodedragged: Node;
+    selectnode: {
+        node: Node;
+        accumulate: boolean;
+    };
+    multiselectnode: {
+        node: Node;
+        accumulate: boolean;
+        e: MouseEvent;
+    };
+    nodeselect: Node;
+    nodeselected: Node;
+    nodeunselectall: void;
+    nodemouseenter: Node;
+    nodemouseleave: Node;
+    rendernode: {
+        el: HTMLElement;
+        node: Node;
+        view: NodeView;
+        component: Component;
+        bindSocket: Function;
+        bindControl: Function;
+        bindBlock?: Function;
+        callback?: () => void;
+    };
+    disposenode: {
+        el: HTMLElement;
+    };
+    rendersocket: {
+        el: HTMLElement;
+        input?: Input;
+        output?: Output;
+        socket: Socket;
+    };
+    disposesocket: {
+        el: HTMLElement;
+    };
+    rendercontrol: {
+        el: HTMLElement;
+        control: Control;
+        callback?: () => void;
+    };
+    renderconnection: {
+        el: HTMLElement;
+        connection: Connection;
+        points: number[];
+    };
+    updateconnection: {
+        el: HTMLElement;
+        connection: Connection;
+        points: number[];
+        updateColor?: boolean;
+    };
+    disposeconnection: {
+        el: HTMLElement;
+        connection: Connection;
+    };
+    keydown: KeyboardEvent;
+    keyup: KeyboardEvent;
+    translate: {
+        transform: Transform;
+        x: number;
+        y: number;
+    };
+    translated: void;
+    zoom: {
+        transform: Transform;
+        zoom: number;
+        source: ZoomSource;
+    };
+    zoomed: {
+        source: ZoomSource;
+    };
+    click: {
+        e: Event;
+        container: HTMLElement;
+    };
+    mousemove: Mouse;
+    contextmenu: {
+        e: MouseEvent;
+        view?: EditorView;
+        node?: Node;
+        connection?: Connection;
+    };
+    import: Data;
+    export: Data;
+    process: void;
+    clear: void;
+}
+
+interface INodeView {
+    getSocketPosition(io: IO): [number, number];
+    hasSocket(io: IO): boolean;
+}
+declare class ConnectionView extends Emitter<EventsTypes> {
+    connection: Connection;
+    inputNode: INodeView;
+    outputNode: INodeView;
+    el: HTMLElement;
+    constructor(connection: Connection, inputNode: INodeView, outputNode: INodeView, emitter: Emitter<EventsTypes>);
+    getPoints(): number[];
+    update(updateColor?: boolean): void;
+    dispose(): void;
+}
+
+declare class Connection {
+    output: Output;
+    input: Input;
+    data: unknown;
+    view?: ConnectionView;
+    constructor(output: Output, input: Input);
+    remove(): void;
+}
+
+declare class Node {
+    name: string;
+    id: number;
+    position: [number, number];
+    inputs: Map<string, Input>;
+    outputs: Map<string, Output>;
+    controls: Map<string, Control>;
+    blocks: Array<Node>;
+    data: {
+        [key: string]: unknown;
+    };
+    meta: {
+        hovering?: boolean;
+    } & {
+        [key: string]: unknown;
+    };
+    contextNode?: Node;
+    static latestId: number;
+    dataChanged: boolean;
+    constructor(name: string);
+    get changed(): boolean;
+    resetChanged(): void;
+    _add<T extends {
+        key: string;
+    } & Record<string, any>>(list: Map<string, T>, item: T, prop: string): void;
+    addControl(control: Control): this;
+    removeControl(control: Control): void;
+    addInput(input: Input): this;
+    removeInput(input: Input): void;
+    addOutput(output: Output): this;
+    removeOutput(output: Output): void;
+    addBlock(node: Node): this;
+    setMeta(meta: {
+        [key: string]: unknown;
+    }): this;
+    getConnections(): Connection[];
+    getInputConnections(): Connection[];
+    update(cb?: () => void): void;
+    get label(): string;
+    getValue(prefix: string): any;
+    setValue(prefix: string, value: any): void;
+    getValueType(prefix: string): string;
+    setValueType(prefix: string, type: string): void;
+    getValueName(prefix: string): string;
+    setValueName(prefix: string, name: string): void;
+    getValueUsage(prefix: string): string;
+    setValueUsage(prefix: string, name: string): void;
+    removeValue(prefix: string): void;
+    initValueType(prefix: string, value: any, type?: string, name?: string, usage?: string): void;
+    isContext(): unknown;
+    static incrementId(): number;
+    static resetId(): void;
+    toJSON(): NodeData;
+    static fromJSON(json: NodeData): Node;
+    dispose(): void;
+}
+
+declare abstract class Component extends Component$1 {
+    editor: NodeEditor | null;
+    data: unknown;
+    render?: string;
+    component?: any;
+    constructor(name: string);
+    onRegister(editor: NodeEditor): void;
+    abstract builder(node: Node): Promise<void>;
+    build(node: Node, json?: any): Promise<Node>;
+    createNode(data?: {}): Promise<Node>;
+    worker(node: any, inputs: any, outputs: any): void;
+}
+
+type GraphData = Data;
+declare enum ValueType {
+    float = "float",
+    vec2 = "vec2",
+    vec3 = "vec3",
+    vec4 = "vec4",
+    mat4 = "mat4",
+    mat3 = "mat3",
+    mat2 = "mat2",
+    texture2d = "texture2d",
+    sampler = "sampler",
+    gradient = "gradient",
+    vertex = "vertex",
+    string = "string",
+    bool = "bool"
+}
+declare enum ValueUsage {
+    Color = "color"
+}
+type VectorValueType = ValueType.float | ValueType.vec2 | ValueType.vec3 | ValueType.vec4;
+type NodeValueCfg = {
+    dataKey: string;
+    options?: string[];
+    labelWidth?: string;
+    itemWidth?: string;
+    itemHeight?: string;
+    textarea?: boolean;
+    asset?: {
+        type: ValueType;
+    };
+    excludes?: {
+        [value: string]: string[];
+    };
+    onChange?(node: ReteNode, value: any, editor: NodeEditor): boolean;
+};
+type NodeListCfg = {
+    list: any[];
+    Item: any;
+    onAdd(list: any[]): any;
+    onDel(item: any): void;
+    onChange?(node: ReteNode, value: any, editor: NodeEditor): boolean;
+};
+interface ReteNode extends Node {
+    data: {
+        expanded: boolean;
+        preview: boolean;
+        previewType?: '2d' | '3d';
+        [k: string]: any;
+    };
+    meta: {
+        undeleteable?: boolean;
+        uncloneable?: boolean;
+        previewDisabled: boolean;
+        category: string;
+        keywords?: string[];
+        label?: string;
+        nodeCfgs?: {
+            [label: string]: NodeValueCfg | NodeListCfg;
+        };
+        highlight?: boolean;
+        internalIO?: string[];
+        [k: string]: any;
+    };
+}
+type ReteContextNode = ExtendReteNode<string, {}, {
+    blockComponents: string[];
+    isContext: true;
+}>;
+interface ExtendReteNode<Name extends string, Data = {}, Meta = {}> extends ReteNode {
+    name: Name;
+    data: ReteNode['data'] & Data;
+    meta: ReteNode['meta'] & Meta;
+}
+interface ExtendReteContext<Name extends string, Data = {}, Meta = {}> extends ReteContextNode {
+    name: Name;
+    data: ReteContextNode['data'] & Data;
+    meta: ReteContextNode['meta'] & Meta;
+}
+type ValueTypeEdit = undefined | ValueUsage.Color;
+interface ParameterData {
+    type: ValueType;
+    name: string;
+    defalutValue: any;
+    exposed: boolean;
+    editing?: boolean;
+    typeEdit?: ValueTypeEdit;
+}
+type AssetValue = {
+    id: string;
+    label: string;
+} | undefined;
+declare const SpaceOptions$1: readonly ["object", "view", "world", "tangent"];
+type SpaceValue$1 = ArrayElement<typeof SpaceOptions$1>;
+declare const UVOptions: readonly ["UV0"];
+type UVValue = ArrayElement<typeof UVOptions>;
+type SamplerValue = {
+    filter: 'linear' | 'point' | 'trilinear';
+    warp: 'repeat' | 'clamp' | 'mirror';
+};
+type ValueOf<T> = T[keyof T];
+type MaybePromise<T> = T | Promise<T>;
+type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+declare const ScreenPositionModeOptions: readonly ["default", "raw", "center", "tiled"];
+type ScreenPositionModeValue = ArrayElement<typeof ScreenPositionModeOptions>;
+
+declare module '../rete/core/events' {
+    interface EventsTypes {
+        rendercustom: {
+            render: string;
+            component: any;
+            view: {
+                props: any;
+                el: HTMLElement;
+                update: (cb?: () => void) => void | Promise<void>;
+            };
+            callback?: () => void;
+        };
+    }
+}
+
+type SettingValueCfgs = {
+    [k: string]: {
+        options?: string[];
+        list?: ListItem;
+        labelWidth?: string;
+        constant?: boolean;
+        textarea?: boolean;
+        asset?: {
+            type: ValueType;
+        };
+        excludes?: {
+            [value: string]: string[];
+        };
+    };
+};
+type ListItem = {
+    onAdd(list: any[]): any;
+    onDel(item: any): void;
+    onChange?(node: ReteNode, value: any, editor: NodeEditor): void;
+    Item: any;
+};
+
+interface PopupViewProps {
+    editor: NodeEditor;
+    view: PopupView<any>;
+}
+declare class PopupView<Props extends PopupViewProps> {
+    editor: NodeEditor;
+    component: any;
+    el: HTMLDivElement;
+    props: Props;
+    showing: boolean;
+    constructor(editor: NodeEditor, component: any, className?: string);
+    show(props?: Partial<Omit<Props, 'editor' | 'view'>>): void;
+    hide: () => void;
+    setShowState(show: boolean): void;
+    toggle: () => void;
+    _setPopupShow(show: boolean): void;
+    update(): void;
+    dispose(): void;
+}
+
+interface PopupNodeAddProps extends PopupViewProps {
+    x?: number;
+    y?: number;
+    scope?: 'node' | 'context' | 'node-io-pick';
+    contextNode?: Node;
+    io?: IO;
+}
+
+interface BlackBoardProps {
+    editor: NodeEditor;
+    view: BlackBoardView;
+    data: Array<ParameterData>;
+    visiable?: boolean;
+    subtitle?: string;
+}
+declare class BlackBoardView extends PopupView<BlackBoardProps> {
+    editor: NodeEditor;
+    data: BlackBoardProps['data'];
+    parameterComponetnName: string;
+    constructor(editor: NodeEditor, data: BlackBoardProps['data'], parameterComponetnName: string, subtitle?: string);
+    fromJSON(data: Array<ParameterData>): void;
+    toJSON(): Array<ParameterData>;
+    addParameter(type: ValueType, editing?: boolean, typeEdit?: ValueTypeEdit, customName?: string): void;
+    setParameter(name: string, data: Partial<ParameterData>): boolean;
+    delParameter(name: string): void;
+    cloneParameter(name: string): void;
+}
+
+interface MainPreviewProps extends PopupViewProps {
+}
+declare class MainPreviewView extends PopupView<MainPreviewProps> {
+    constructor(editor: NodeEditor);
+}
+
+type Setting = {
+    [k: string]: any;
+};
+interface InspectorProps extends PopupViewProps {
+    setting: Setting;
+    view: InspectorView;
+    graphSettingValueCfgs: SettingValueCfgs;
+}
+declare class InspectorView extends PopupView<InspectorProps> {
+    setting: Setting;
+    constructor(editor: NodeEditor, graphSettingValueCfgs: SettingValueCfgs);
+    fromJSON(setting: Setting): void;
+    toJSON(): Setting;
+    setSetting(name: string, value: any): void;
+}
+
+declare module '../rete/core/events' {
+    interface EventsTypes {
+        hidecontextmenu: void;
+        showcontextmenu: void;
+        showpopupadd: PopupNodeAddProps;
+    }
+}
+
+declare module '../../rete/core/events' {
+    interface EventsTypes {
+        connectionpath: {
+            points: number[];
+            connection: Connection;
+            d: string;
+        };
+        connectiondrop: Input | Output;
+        connectionpick: Input | Output;
+        connectionselected: Connection;
+        resetconnection: void;
+    }
+}
+
+declare module '../../rete/core/events' {
+    interface EventsTypes {
+        previewclientcreate: {
+            canvas: HTMLDivElement;
+            node?: ReteNode;
+            type?: '2d' | '3d';
+            enable?: boolean;
+        };
+        previewclientremove: {
+            canvas: HTMLDivElement;
+        };
+        previewclientupdate: {
+            canvas: HTMLDivElement;
+            type?: '2d' | '3d';
+            enable?: boolean;
+        };
+        previewsettingupdate: {
+            geometry: string;
+        };
+        previewcopyshader: {
+            node: ReteNode;
+            callback: (data?: {
+                fragCode: string;
+                vertCode: string;
+            }) => void;
+        };
+        previewcustommesh: (geometry?: BufferGeometry) => void;
+    }
+}
+
+declare module '../../src/rete/core/events' {
+    interface EventsTypes {
+        assetparse: {
+            asset: AssetValue;
+            type: ValueType;
+            callback: (src: string) => void;
+        };
+        assetselect: {
+            type: ValueType;
+            callback: (asset: AssetValue) => void;
+        };
+    }
+}
+
+declare module '../rete/core/events' {
+    interface EventsTypes {
+        imported: void;
+        settingupdated: {
+            name: string;
+            value: any;
+            setting: SGSetting;
+        };
+    }
+}
+declare class ShaderGraphEditor$1 extends NodeEditor {
+    blackboardView: BlackBoardView;
+    mainPreviewView: MainPreviewView;
+    compiler: ShaderGraphCompiler;
+    inspectorView: InspectorView;
+    clearing: boolean;
+    editing: 'ShaderGraph' | 'SubGraph';
+    subGraphProvider?: SubGraphProvider;
+    disposables: Array<() => void>;
+    constructor(id: string, container: HTMLElement);
+    private initEvents;
+    setSubGraphProvider(provider: SubGraphProvider): void;
+    initShaderGraphNodes(): Promise<void>;
+    initSubGraphNodes(): Promise<void>;
+    addBlock(contextNode: Node, node: Node, com?: RCBlock): void;
+    clear(silent?: boolean): void;
+    fromJSON(json: ShaderGraphData): Promise<boolean>;
+    toJSON(): ShaderGraphData;
+    afterImport(): boolean;
+    dispose(): void;
+}
+
+declare abstract class GraphCompiler {
+    fnName: 'compileSG';
+    graphData: GraphData;
+    nodesCompilation: Map<number, any>;
+    todo: Set<number>;
+    done: Set<number>;
+    ready: Set<number>;
+    changed: [Set<number>, Set<number>];
+    components: Map<string, RC>;
+    constructor(fnName: 'compileSG');
+    register(component: RC, force?: boolean): void;
+    varId: number;
+    get nextVarId(): number;
+    loopCheck(): boolean;
+    compileNode: (nodeId: number) => Promise<void>;
+    compile(graphData: GraphData): Promise<any>;
+}
+
+type SGNodeOutput = MaybePromise<{
+    outputs: {
+        [outputName: string]: string;
+    };
+    code: string;
+} | void>;
+type ContextMap = {
+    [contextKey: string]: {
+        varName: string;
+        code: string;
+        index?: number;
+    };
+};
+type ContextItem = ValueOf<ContextMap>;
+type ResourceMap<T> = {
+    [contextKey: string]: T | undefined;
+};
+type ResourceItem = ValueOf<ResourceMap<AssetValue | SamplerValue>>;
+type VarNameMap = {
+    [contextKey: string]: {
+        vertName: string;
+        fragName: string;
+        varName: string;
+    };
+};
+type Context = ReturnType<typeof initContext>;
+type ContextKeys = keyof Context;
+declare const initContext: () => {
+    uniforms: ContextMap;
+    attributes: ContextMap;
+    varyings: ContextMap;
+    defines: ContextMap;
+    bindings: ContextMap;
+    vertShared: ContextMap;
+    fragShared: ContextMap;
+    autoVaryings: ContextMap;
+};
+type Resource = ReturnType<typeof initResource>;
+declare const initResource: () => {
+    texture: ResourceMap<AssetValue>;
+    sampler: ResourceMap<SamplerValue>;
+};
+type CodeFn = (varName: string, index: number) => string;
+type NodeName = {
+    name: string;
+};
+type UniformMap = {
+    [contextKey: string]: {
+        name: string;
+        type: string;
+    };
+};
+type BindingMap = {
+    [contextKey: string]: {
+        name: string;
+        type: string;
+        index: number;
+    };
+};
+interface SGCompilation {
+    setting: ShaderGraphData['setting'];
+    parameters: ParameterData[];
+    resource: Resource;
+    uniformMap: UniformMap;
+    bindingMap: BindingMap;
+    vertCode: string;
+    fragCode: string;
+}
+
+/**
+ * 编译顺序
+ * frag: fragShared -> fragBody -> fragHead
+ * vert: vertShared -> autoVaryings -> vertBody -> vertHead
+ */
+declare class ShaderGraphCompiler extends GraphCompiler {
+    graphData: ShaderGraphData;
+    context: Context;
+    resource: Resource;
+    varNameMap: VarNameMap;
+    nodesCompilation: Map<number, Awaited<SGNodeOutput>>;
+    compilation?: SGCompilation;
+    previewContext?: {
+        id: number;
+        baseColorBlock: BaseColorBlock;
+        fragmentRC: FragmentRC;
+        getNodeData: <T extends SGNodes>(rc: RC) => Promise<SGNodeData<T>>;
+    };
+    subGraphProvider?: SubGraphProvider;
+    constructor();
+    initBuiltinContext(): void;
+    setSubGraphProvider(provider: SubGraphProvider): void;
+    setParameter(node: SGNodeData<ReteParameterNode>): string;
+    setVarNameMap(node: NodeName, key: string, vertName: string, fragName: string, varName?: string): string;
+    setResource(type: keyof typeof this.resource, node: NodeName, key: string, item?: ResourceItem): void;
+    setAutoVaryings(node: NodeName, key: string, varyingVar: string, vertVar: string): string;
+    setContext(type: ContextKeys, node: NodeName, key: string, item: ContextItem): string;
+    setContext(type: ContextKeys, node: NodeName, key: string, codeFn: CodeFn): string;
+    getContext(type: ContextKeys, node: SGNodeData<SGNodes>, key: string): ContextItem | undefined;
+    getContextKey(node: NodeName, key: string): string;
+    getCode(nodeId: number): string;
+    /** 为裸露赋值添加 GLSL 类型声明 */
+    private fixCodeDecl;
+    collectNodeInputCode(nodeId: number, output?: string[], self?: boolean): string[];
+    /** 重排 只支持vec1234 */
+    getVarSwizzle(inVar: string, inType: ValueType, swizzle: string): string;
+    /** 读取分量 只支持vec1234 */
+    getVarChannel(varName: string, inType: ValueType, channel: 'r' | 'g' | 'b' | 'a' | 'x' | 'y' | 'z' | 'w'): string;
+    /** 类型转换 只支持vec1234 mat234 */
+    typeConvert(varName: string | undefined, inType: ValueType, outType: ValueType): string | undefined;
+    getInputType(node: SGNodeData<SGNodes>, inputKey: string): ValueType;
+    getInputVarConverted(node: SGNodeData<SGNodes>, inputKey: string): string;
+    getInputVarConverted(node: SGNodeData<SGNodes>, inputKey: string, fallback: false): string | undefined;
+    getInputVarConvertedArray(node: SGNodeData<SGNodes>, keys: string[]): string[];
+    getInputVar(node: SGNodeData<SGNodes>, inputKey: string): string;
+    getInputVar(node: SGNodeData<SGNodes>, inputKey: string, fallback: false): string | undefined;
+    getTypeClass(type: ValueType): string;
+    getOutVarName(node: Pick<SGNodeData<SGNodes>, 'data' | 'name'>, key: string, name?: string): string;
+    getContextVarName(node: NodeName, key: string): string;
+    compileValue(value: any, type: ValueType, usage?: ValueUsage): string;
+    compileNodeValue(node: SGNodeData<SGNodes>, key: string): string;
+    compileHeadCode(body: string, scope: 'vert' | 'frag'): string;
+    /** 检查代码中是否使用了导数函数 */
+    static hasDerivatives(code: string): boolean;
+    getLinkedVaryingNodes(nodeId: number, output?: Array<SGNodeData<ReteVaryingNode>>): Array<SGNodeData<ReteVaryingNode>>;
+    linkBlocks(blocks: Array<SGNodeData<SGNodes>>, ignoreFirstLine?: boolean): string;
+    getAutoVaryingsCode(fragCode: string): string;
+    prependVertSharedCode(vertBody: string): string;
+    prependFragSharedCode(fragBody: string): string;
+    doVarMap(body: string, scope: 'vert' | 'frag'): string;
+    prependSharedCode(body: string, scope: 'fragShared' | 'vertShared'): string;
+    getUniformMap(): UniformMap;
+    getBindingMap(): BindingMap;
+    /** 编辑器使用, 需要compile执行后方可使用 */
+    compilePreview(node: ReteNode): Promise<SGCompilation>;
+    compile(graphData: ShaderGraphData): Promise<SGCompilation>;
+    compileSubGraphPreview(subGraphData: ShaderGraphData): Promise<SGCompilation>;
+    compileSubGraph(subGraphData: ShaderGraphData): Promise<SubGraphCompiler>;
+    superCompile(graphData: ShaderGraphData): Promise<any>;
+    dispose(): void;
+}
+declare class SubGraphCompiler extends ShaderGraphCompiler {
+    sgCompiler: ShaderGraphCompiler;
+    constructor(sgCompiler: ShaderGraphCompiler);
+    setParameter(node: SGNodeData<ReteParameterNode>): string;
+    compileSubGraph(subGraphData: ShaderGraphData): Promise<SubGraphCompiler>;
+}
+
+declare abstract class RC extends Component {
+    data: {
+        component?: any;
+    };
+    nodeLayout: ReteNode;
+    constructor(name: string);
+    abstract initNode(node: Node): void | Promise<void>;
+    compileSG?(compiler: ShaderGraphCompiler, node: SGNodeData<SGNodes>): MaybePromise<SGNodeOutput>;
+}
+declare abstract class RCBlock extends RC {
+    onAddToContextNode?(contextNode: Node, blockNode: Node): void;
+}
+
+type ReteAddNode = ExtendReteNode<'Add', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSubtractNode = ExtendReteNode<'Subtract', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteDivideNode = ExtendReteNode<'Divide', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type RetePowerNode = ExtendReteNode<'Power', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSquareRootNode = ExtendReteNode<'SquareRoot', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteMultiplyNode = ExtendReteNode<'Multiply', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSineNode = ExtendReteNode<'Sine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteCosineNode = ExtendReteNode<'Cosine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteArccosineNode = ExtendReteNode<'Arccosine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteArcsineNode = ExtendReteNode<'Arcsine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteArctangentNode = ExtendReteNode<'Arctangent', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteArctangent2Node = ExtendReteNode<'Arctangent2', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteHyperbolicCosineNode = ExtendReteNode<'HyperbolicCosine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteHyperbolicSineNode = ExtendReteNode<'HyperbolicSine', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteHyperbolicTangentNode = ExtendReteNode<'HyperbolicTangent', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteDegreesToRadiansNode = ExtendReteNode<'DegreesToRadians', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteRadiansToDegreesNode = ExtendReteNode<'RadiansToDegrees', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteTangentNode = ExtendReteNode<'Tangent', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteAbsoluteNode = ExtendReteNode<'Absolute', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteExponentialNode = ExtendReteNode<'Exponential', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteLengthNode = ExtendReteNode<'Length', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteLogNode = ExtendReteNode<'Log', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteModuloNode = ExtendReteNode<'Modulo', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteNegateNode = ExtendReteNode<'Negate', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteNormalizeNode = ExtendReteNode<'Normalize', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type RetePosterizeNode = ExtendReteNode<'Posterize', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    stepsValue: number | number[];
+    stepsValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteReciprocalNode = ExtendReteNode<'Reciprocal', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteReciprocalSquareRootNode = ExtendReteNode<'ReciprocalSquareRoot', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteDDXNode = ExtendReteNode<'DDX', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteDDYNode = ExtendReteNode<'DDY', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteDDXYNode = ExtendReteNode<'DDXY', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteLerpNode = ExtendReteNode<'Lerp', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    tValue: number | number[];
+    tValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSmoothstepNode = ExtendReteNode<'Smoothstep', {
+    edge1Value: number | number[];
+    edge1ValueType: ValueType;
+    edge2Value: number | number[];
+    edge2ValueType: ValueType;
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteInverseLerpNode = ExtendReteNode<'InverseLerp', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    tValue: number | number[];
+    tValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteClampNode = ExtendReteNode<'Clamp', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    minValue: number | number[];
+    minValueType: ValueType;
+    maxValue: number | number[];
+    maxValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteFractionNode = ExtendReteNode<'Fraction', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteMinimumNode = ExtendReteNode<'Minimum', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteMaximumNode = ExtendReteNode<'Maximum', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteOneMinusNode = ExtendReteNode<'OneMinus', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteRemapNode = ExtendReteNode<'Remap', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    inMinMaxValue: number[];
+    inMinMaxValueType: ValueType.vec2;
+    outMinMaxValue: number[];
+    outMinMaxValueType: ValueType.vec2;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSaturateNode = ExtendReteNode<'Saturate', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteRandomRangeNode = ExtendReteNode<'RandomRange', {
+    seedValue: number | number[];
+    seedValueType: ValueType;
+    minValue: number | number[];
+    minValueType: ValueType;
+    maxValue: number | number[];
+    maxValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteCeilingNode = ExtendReteNode<'Ceiling', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteFloorNode = ExtendReteNode<'Floor', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteRoundNode = ExtendReteNode<'Round', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSignNode = ExtendReteNode<'Sign', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteTruncateNode = ExtendReteNode<'Truncate', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteStepNode = ExtendReteNode<'Step', {
+    edgeValue: number | number[];
+    edgeValueType: ValueType;
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteCrossProductNode = ExtendReteNode<'CrossProduct', {
+    aValue: number[];
+    aValueType: ValueType.vec3;
+    bValue: number[];
+    bValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteDistanceNode = ExtendReteNode<'Distance', {
+    aValue: number | number[];
+    aValueType: VectorValueType;
+    bValue: number | number[];
+    bValueType: VectorValueType;
+    outValue: number[];
+    outValueType: ValueType.float;
+}>;
+
+type ReteDotProductNode = ExtendReteNode<'DotProduct', {
+    aValue: number | number[];
+    aValueType: VectorValueType;
+    bValue: number | number[];
+    bValueType: VectorValueType;
+    outValue: number[];
+    outValueType: ValueType.float;
+}>;
+
+type ReteFresnelEffectNode = ExtendReteNode<'FresnelEffect', {
+    normalValue: number | number[];
+    normalValueType: ValueType;
+    viewDirValue: number | number[];
+    viewDirValueType: ValueType;
+    powerValue: number | number[];
+    powerValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteProjectionNode = ExtendReteNode<'Projection', {
+    aValue: number | number[];
+    aValueType: ValueType;
+    bValue: number | number[];
+    bValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteReflectionNode = ExtendReteNode<'Reflection', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    normalValue: number | number[];
+    normalValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteRotateAboutAxisNode = ExtendReteNode<'RotateAboutAxis', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    axisValue: number[];
+    axisValueType: ValueType.vec3;
+    roateValue: number;
+    roateValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    unitValue: 'degrees' | 'radians';
+}>;
+
+type ReteSphereMaskNode = ExtendReteNode<'SphereMask', {
+    coordsValue: number | number[];
+    coordsValueType: VectorValueType;
+    centerValue: number | number[];
+    centerValueType: VectorValueType;
+    radiusValue: number;
+    radiusValueType: ValueType.float;
+    hardnessValue: number;
+    hardnessValueType: ValueType.float;
+    outValue: number | number[];
+    outValueType: VectorValueType;
+}>;
+
+declare const TypeOptions: readonly ["position", "direction"];
+declare const SpaceOptions: readonly ["object", "view", "world", "tangent"];
+type TypeValue$2 = ArrayElement<typeof TypeOptions>;
+type SpaceValue = ArrayElement<typeof SpaceOptions>;
+type ReteTransformNode = ExtendReteNode<'Transform', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    typeValue: TypeValue$2;
+    typeValueType: ValueType.string;
+    inSpaceValue: SpaceValue;
+    inSpaceValueType: ValueType.string;
+    outSpaceValue: SpaceValue;
+    outSpaceValueType: ValueType.string;
+}>;
+
+type ReteRefractNode = ExtendReteNode<'Refract', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    normalValue: number | number[];
+    normalValueType: ValueType;
+    etaValue: number;
+    etaValueType: ValueType.float;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteNoiseSineWaveNode = ExtendReteNode<'NoiseSineWave', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    minMaxValue: number[];
+    minMaxValueType: ValueType.vec2;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSquareWaveNode = ExtendReteNode<'SquareWave', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteSawtoothWaveNode = ExtendReteNode<'SawtoothWave', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteTriangleWaveNode = ExtendReteNode<'TriangleWave', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteFloatNode = ExtendReteNode<'Float', {
+    xValue: number;
+    xValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteVec2Node = ExtendReteNode<'Vector 2', {
+    xValue: number;
+    xValueType: ValueType.float;
+    yValue: number;
+    yValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteVec3Node = ExtendReteNode<'Vector 3', {
+    xValue: number;
+    xValueType: ValueType.float;
+    yValue: number;
+    yValueType: ValueType.float;
+    zValue: number;
+    zValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteVec4Node = ExtendReteNode<'Vector 4', {
+    xValue: number;
+    xValueType: ValueType.float;
+    yValue: number;
+    yValueType: ValueType.float;
+    zValue: number;
+    zValueType: ValueType.float;
+    wValue: number;
+    wValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec4;
+    [k: string]: any;
+}>;
+
+type ReteColorNode = ExtendReteNode<'Color', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    outValueUsage: ValueUsage.Color;
+}>;
+
+declare const Options$1: readonly ["PI", "TAU", "PHI", "E", "SQRT2", "PI_HALF"];
+type TypeValue$1 = ArrayElement<typeof Options$1>;
+type ReteConstantNode = ExtendReteNode<'Constant', {
+    typeValue: TypeValue$1;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteTimeNode = ExtendReteNode<'Time', {
+    timeValue: number;
+    timeValueType: ValueType.float;
+    sinTimeValue: number;
+    sinTimeValueType: ValueType.float;
+    cosTimeValue: number;
+    cosTimeValueType: ValueType.float;
+    deltaTimeValue: number;
+    deltaTimeValueType: ValueType.float;
+    smoothDeltaValue: number;
+    smoothDeltaValueType: ValueType.float;
+}>;
+
+declare module '../../rete/core/events' {
+    interface EventsTypes {
+        parameterchange: {
+            name: string;
+            outValue: any;
+            outValueType: ValueType;
+            outValueUsage?: ValueUsage;
+            outValueName: string;
+            exposed: boolean;
+        };
+        parameterdelete: {
+            name: string;
+        };
+    }
+}
+type ReteParameterNode = ExtendReteNode<'Parameter', {
+    outValue: any;
+    outValueType: ValueType;
+    outValueUsage?: ValueUsage;
+    outValueName: string;
+}>;
+
+declare module '../../rete/core/events' {
+    interface EventsTypes {
+        varyingchange: {
+            name: string;
+            outValueName: string;
+        };
+    }
+}
+type ReteVaryingNode = ExtendReteNode<'Varying', {
+    outValue: number[];
+    outValueType: ValueType.vec4;
+    outValueName: string;
+}>;
+
+type ReteTexture2DAssetNode = ExtendReteNode<'Texture2DAsset', {
+    outValue: AssetValue;
+    outValueType: ValueType.texture2d;
+}>;
+
+type ReteSampleTexture2DNode = ExtendReteNode<'SampleTexture2D', {
+    rgbaValue: number[];
+    rgbaValueType: ValueType.vec4;
+    rValue: number;
+    rValueType: ValueType.float;
+    gValue: number;
+    gValueType: ValueType.float;
+    bValue: number;
+    bValueType: ValueType.float;
+    aValue: number;
+    aValueType: ValueType.float;
+    textureValue: AssetValue;
+    textureValueType: ValueType.texture2d;
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3';
+    uvValueType: ValueType.vec2;
+    typeValue: 'default' | 'normal';
+    spaceValue: 'object' | 'tangent';
+    texColorSpaceValue: 'sRGB' | 'Linear';
+    texColorSpaceValueType: ValueType.string;
+}>;
+
+type ReteTexelSizeNode = ExtendReteNode<'TexelSize', {
+    textureValue: AssetValue;
+    textureValueType: ValueType.texture2d;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+}>;
+
+type ReteSamplerStateNode = ExtendReteNode<'SamplerState', {
+    outValue: SamplerValue;
+    outValueType: ValueType.sampler;
+}>;
+
+type ReteUVNode = ExtendReteNode<'UV', {
+    outValue: number[];
+    outValueType: ValueType.vec2;
+    channelValue: 'UV0' | 'UV1' | 'UV2' | 'UV3';
+}>;
+
+type ReteNormalNode = ExtendReteNode<'Normal', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+type RetePositionNode = ExtendReteNode<'Position', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+type ReteViewVectorNode = ExtendReteNode<'ViewVector', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+type ReteViewDirectionNode = ExtendReteNode<'ViewDirection', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+type ReteScreenPositionNode = ExtendReteNode<'ScreenPosition', {
+    outValue: number[];
+    outValueType: ValueType.vec4;
+    modeValue: ScreenPositionModeValue;
+}>;
+
+type ReteTangentVectorNode = ExtendReteNode<'TangentVector', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+type ReteBiTangentVectorNode = ExtendReteNode<'BiTangentVector', {
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    spaceValue: SpaceValue$1;
+}>;
+
+declare const Options: readonly ["Model", "View", "Proj", "ViewProj", "ModelView", "I_Model", "I_View", "I_Proj", "I_ViewProj", "I_ModelView", "IT_Model", "IT_ModelView"];
+type TypeValue = ArrayElement<typeof Options>;
+type ReteTransformationMatrixNode = ExtendReteNode<'TransformationMatrix', {
+    typeValue: TypeValue;
+    outValue: number[];
+    outValueType: ValueType.mat4;
+}>;
+
+type ReteMatrix4x4Node = ExtendReteNode<'Matrix4x4', {
+    outValue: number[];
+    outValueType: ValueType.mat4;
+}>;
+
+type ReteMatrix3x3Node = ExtendReteNode<'Matrix3x3', {
+    outValue: number[];
+    outValueType: ValueType.mat3;
+}>;
+
+type ReteMatrix2x2Node = ExtendReteNode<'Matrix2x2', {
+    outValue: number[];
+    outValueType: ValueType.mat2;
+}>;
+
+type ReteCameraNode = ExtendReteNode<'Camera', {
+    positionValue: number[];
+    positionValueType: ValueType.vec3;
+    directinoValue: number[];
+    directinoValueType: ValueType.vec3;
+    orthographicValue: number;
+    orthographicValueType: ValueType.float;
+    nearPlaneValue: number;
+    nearPlaneValueType: ValueType.float;
+    farPlaneValue: number;
+    farPlaneValueType: ValueType.float;
+    zBufferSignValue: number;
+    zBufferSignValueType: ValueType.float;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+}>;
+
+type ReteObjectNode = ExtendReteNode<'Object', {
+    positionValue: number[];
+    positionValueType: ValueType.vec3;
+    sinTimeValue: number[];
+    sinTimeValueType: ValueType.vec3;
+}>;
+
+type ReteScreenNode = ExtendReteNode<'Screen', {
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+}>;
+
+type ReteSceneColorNode = ExtendReteNode<'SceneColor', {
+    uvValue: ScreenPositionModeValue | number[];
+    uvValueType: ValueType.vec4;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+declare const ModeOptions$2: readonly ["linear01", "raw", "eye"];
+type ModeValue = ArrayElement<typeof ModeOptions$2>;
+type ReteSceneDepthNode = ExtendReteNode<'SceneDepth', {
+    uvValue: ScreenPositionModeValue | number[];
+    uvValueType: ValueType.vec4;
+    outValue: number;
+    outValueType: ValueType.float;
+    modeValue: ModeValue;
+    modeValueType: ValueType.string;
+}>;
+
+type ReteFragmentContext = ExtendReteContext<'Fragment', {
+    vertValue: 0;
+    vertValueType: ValueType.vertex;
+}>;
+declare class FragmentRC extends RC {
+    static Name: string;
+    constructor();
+    initNode(node: ReteFragmentContext): Promise<void>;
+    builder(node: ReteFragmentContext): Promise<void>;
+    compileSG(compiler: ShaderGraphCompiler, node: SGNodeData<ReteFragmentContext>): SGNodeOutput;
+}
+
+type ReteVertexContext = ExtendReteContext<'Vertex', {
+    vertValue: 0;
+    vertValueType: ValueType.vertex;
+}>;
+
+type ReteOutputNode = ExtendReteContext<'Output', {
+    [k: `fnIn${string}Value`]: any;
+    [k: `fnIn${string}Type`]: ValueType;
+}>;
+
+type ReteNormalBlock = ExtendReteNode<'NormalBlock', {
+    normalValue: number[];
+    normalValueType: ValueType.vec3;
+}>;
+
+type RetePositionBlock = ExtendReteNode<'PositionBlock', {
+    positionValue: number[];
+    positionValueType: ValueType.vec3;
+}>;
+
+type ReteTangentBlock = ExtendReteNode<'TangentBlock', {
+    tangentValue: number[];
+    tangentValueType: ValueType.vec3;
+}>;
+
+type ReteCustomInterpolatorBlock = ExtendReteNode<'CustomInterpolatorBlock', {
+    varyingValue: number[];
+    varyingValueType: ValueType.vec3;
+    varyingValueName: string;
+}>;
+
+type ReteBaseColorBlock = ExtendReteNode<'BaseColorBlock', {
+    baseColorValue: number[];
+    baseColorValueType: ValueType.vec3;
+    baseColorValueUsage: ValueUsage;
+}>;
+declare class BaseColorBlock extends RCBlock {
+    static Name: string;
+    constructor();
+    initNode(node: ReteBaseColorBlock): Promise<void>;
+    builder(node: ReteBaseColorBlock): Promise<void>;
+    compileSG(compiler: ShaderGraphCompiler, node: SGNodeData<ReteBaseColorBlock>): SGNodeOutput;
+}
+
+type ReteSmoothnessBlock = ExtendReteNode<'SmoothnessBlock', {
+    smoothnessValue: number;
+    smoothnessValueType: ValueType.float;
+}>;
+
+type ReteMetallicBlock = ExtendReteNode<'MetallicBlock', {
+    metallicValue: number;
+    metallicValueType: ValueType.float;
+}>;
+
+type ReteAOBlock = ExtendReteNode<'AOBlock', {
+    aoValue: number;
+    aoValueType: ValueType.float;
+}>;
+
+type ReteEmissionBlock = ExtendReteNode<'EmissionBlock', {
+    emissionValue: number[];
+    emissionValueType: ValueType.vec3;
+    emissionValueUsage: ValueUsage;
+}>;
+
+type ReteNormalTSBlock = ExtendReteNode<'NormalTSBlock', {
+    normalValue: number[];
+    normalValueType: ValueType.vec3;
+}>;
+
+type ReteAlphaBlock = ExtendReteNode<'AlphaBlock', {
+    alphaValue: number;
+    alphaValueType: ValueType.float;
+}>;
+
+type ReteAlphaClipBlock = ExtendReteNode<'AlphaClipBlock', {
+    alphaValue: number;
+    alphaValueType: ValueType.float;
+}>;
+
+type ReteCoatMaskBlock = ExtendReteNode<'CoatMaskBlock', {
+    CoatMaskValue: number;
+    CoatMaskValueType: ValueType.float;
+}>;
+
+type ReteCoatSmoothnessBlock = ExtendReteNode<'CoatSmoothnessBlock', {
+    CoatsmoothnessValue: number;
+    CoatsmoothnessValueType: ValueType.float;
+}>;
+
+type ReteChannelMixerNode = ExtendReteNode<'ChannelMixer', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    rValue: number[];
+    rValueType: ValueType.vec3;
+    gValue: number[];
+    gValueType: ValueType.vec3;
+    bValue: number[];
+    bValueType: ValueType.vec3;
+}>;
+
+type ReteContrastNode = ExtendReteNode<'Contrast', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    contrastValue: number;
+    contrastValueType: ValueType.float;
+}>;
+
+type ReteHueNode = ExtendReteNode<'Hue', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    offsetValue: number;
+    offsetValueType: ValueType.float;
+    rangeValue: 'degrees' | 'radians';
+}>;
+
+type ReteReplaceColorNode = ExtendReteNode<'ReplaceColor', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    rangeValue: number;
+    rangeValueType: ValueType.float;
+    fuzzinessValue: number;
+    fuzzinessValueType: ValueType.float;
+    fromValue: number[];
+    fromValueType: ValueType.vec3;
+    fromValueUsage: ValueUsage;
+    toValue: number[];
+    toValueType: ValueType.vec3;
+    toValueUsage: ValueUsage;
+}>;
+
+type ReteSaturationNode = ExtendReteNode<'Saturation', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    saturationValue: number;
+    saturationValueType: ValueType.float;
+}>;
+
+type ReteWhiteBalanceNode = ExtendReteNode<'WhiteBalance', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    tintValue: number;
+    tintValueType: ValueType.float;
+    temperatureValue: number;
+    temperatureValueType: ValueType.float;
+}>;
+
+type ReteInvertColorsNode = ExtendReteNode<'InvertColors', {
+    inValue: number | number[];
+    inValueType: VectorValueType;
+    outValue: number | number[];
+    outValueType: VectorValueType;
+    invertRValue: boolean;
+    invertGValue: boolean;
+    invertBValue: boolean;
+    invertAValue: boolean;
+}>;
+
+declare const ModeOptions$1: readonly ["Burn", "Darken", "Difference", "Dodge", "Divide", "Exclusion", "HardLight", "HardMix", "Lighten", "LinearBurn", "LinearDodge", "LinearLight", "LinearLightAddSub", "Multiply", "Negation", "Overlay", "PinLight", "Screen", "SoftLight", "Subtract", "VividLight", "Overwrite"];
+type ModeValueType = ArrayElement<typeof ModeOptions$1>;
+type ReteBlendNode = ExtendReteNode<'Blend', {
+    baseValue: number | number[];
+    baseValueType: ValueType;
+    blendValue: number | number[];
+    blendValueType: ValueType;
+    opacityValue: number;
+    opacityValueType: ValueType.float;
+    outValue: number | number[];
+    outValueType: ValueType;
+    modeValue: ModeValueType;
+}>;
+
+declare const ColorSpaceOptions: readonly ["sRGB", "Linear", "HSV"];
+type ColorSpace = ArrayElement<typeof ColorSpaceOptions>;
+type ReteColorSpaceConversionNode = ExtendReteNode<'ColorSpaceConversion', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    fromValue: ColorSpace;
+    fromValueType: ValueType.string;
+    toValue: ColorSpace;
+    toValueType: ValueType.string;
+}>;
+
+type ReteColorMaskNode = ExtendReteNode<'ColorMask', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    maskColorValue: number;
+    maskColorValueType: ValueType.vec3;
+    maskColorValueUsage: ValueUsage;
+    rangeValue: number;
+    rangeValueType: ValueType.float;
+    fuzzinessValue: number;
+    fuzzinessValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteNormalFromTextureNode = ExtendReteNode<'NormalFromTexture', {
+    textureValue: AssetValue;
+    textureValueType: ValueType.texture2d;
+    uvValue: UVValue;
+    uvValueType: ValueType.vec2;
+    offsetValue: number;
+    offsetValueType: ValueType.float;
+    strengthValue: number;
+    strengthValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+declare const ModeOptions: readonly ["default", "reoriented"];
+type Mode = ArrayElement<typeof ModeOptions>;
+type ReteNormalBlendNode = ExtendReteNode<'NormalBlend', {
+    aValue: number[];
+    aValueType: ValueType.vec3;
+    bValue: number[];
+    bValueType: ValueType.vec3;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+    modeValue: Mode;
+    modeValueType: ValueType.string;
+}>;
+
+type ReteNormalReconstructZNode = ExtendReteNode<'NormalReconstructZ', {
+    inValue: number[];
+    inValueType: ValueType.vec2;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteNormalStrengthNode = ExtendReteNode<'NormalStrength', {
+    inValue: number[];
+    inValueType: ValueType.vec3;
+    strengthValue: number;
+    strengthValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteCombineNode = ExtendReteNode<'Combine', {
+    rValue: number;
+    rValueType: ValueType.float;
+    gValue: number;
+    gValueType: ValueType.float;
+    bValue: number;
+    bValueType: ValueType.float;
+    aValue: number;
+    aValueType: ValueType.float;
+    rgbaValue: number[];
+    rgbaValueType: ValueType.vec4;
+    rgbValue: number[];
+    rgbValueType: ValueType.vec3;
+    rgValue: number[];
+    rgValueType: ValueType.vec2;
+}>;
+
+type ReteSplitNode = ExtendReteNode<'Split', {
+    inValue: number | number[];
+    inValueType: VectorValueType;
+    rValue: number;
+    rValueType: ValueType.float;
+    gValue: number;
+    gValueType: ValueType.float;
+    bValue: number;
+    bValueType: ValueType.float;
+    aValue: number;
+    aValueType: ValueType.float;
+}>;
+
+type ReteSwizzleNode = ExtendReteNode<'Swizzle', {
+    inValue: number | number[];
+    inValueType: VectorValueType;
+    outValue: number | number[];
+    outValueType: VectorValueType;
+    swizzleValue: string;
+}>;
+
+type ReteFlipNode = ExtendReteNode<'Flip', {
+    inValue: number | number[];
+    inValueType: VectorValueType;
+    outValue: number | number[];
+    outValueType: VectorValueType;
+    flipXValue: boolean;
+    flipYValue: boolean;
+    flipZValue: boolean;
+    flipWValue: boolean;
+}>;
+
+type ReteCheckerboardNode = ExtendReteNode<'Checkerboard', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    colorAValue: number[];
+    colorAValueType: ValueType.vec3;
+    colorAValueUsage: ValueUsage.Color;
+    colorBValue: number[];
+    colorBValueType: ValueType.vec3;
+    colorBValueUsage: ValueUsage.Color;
+    frequencyValue: number[];
+    frequencyValueType: ValueType.vec2;
+    outValue: number[];
+    outValueType: ValueType.vec3;
+}>;
+
+type ReteGradientNoiseNode = ExtendReteNode<'GradientNoise', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    scaleValue: number;
+    scaleValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteSimpleNoiseNode = ExtendReteNode<'SimpleNoise', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    scaleValue: number;
+    scaleValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteVoronoiNode = ExtendReteNode<'Voronoi', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    angleOffsetValue: number;
+    angleOffsetValueType: ValueType.float;
+    cellDensityValue: number;
+    cellDensityValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+    cellsValue: number;
+    cellsValueType: ValueType.float;
+}>;
+
+type ReteEllipseNode = ExtendReteNode<'Ellipse', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type RetePolygonNode = ExtendReteNode<'Polygon', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    sidesValue: number;
+    sidesValueType: ValueType.float;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteRectangleNode = ExtendReteNode<'Rectangle', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteRoundedPolygonNode = ExtendReteNode<'RoundedPolygon', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    sidesValue: number;
+    sidesValueType: ValueType.float;
+    roundnessValue: number;
+    roundnessValueType: ValueType.float;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type ReteRoundedRectangleNode = ExtendReteNode<'RoundedRectangle', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    radiusValue: number;
+    radiusValueType: ValueType.float;
+    outValue: number;
+    outValueType: ValueType.float;
+}>;
+
+type RetePreviewNode = ExtendReteNode<'Preview', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+}>;
+
+type ReteCustomFunctionNode = ExtendReteNode<'CustomFunction', {
+    typeValue: 'file' | 'string' | 'code';
+    typeValueType: ValueType.string;
+    nameValue: string;
+    nameValueType: ValueType.string;
+    bodyValue: string;
+    bodyValueType: ValueType.string;
+    fileValue: AssetValue;
+    fileValueType: ValueType.string;
+    codeValue: string;
+    codeValueType: ValueType.string;
+    editingCodeValue: boolean;
+    editingCodeValueType: ValueType.bool;
+    [k: `fnIn${string}Value`]: any;
+    [k: `fnIn${string}Type`]: ValueType;
+    [k: `fnOut${string}Value`]: any;
+    [k: `fnOut${string}Type`]: ValueType;
+}>;
+
+type ReteSubGraphNode = ExtendReteNode<'SubGraph', {
+    assetValue: AssetValue;
+    assetValueType: 'subgraph';
+}>;
+
+type RetePreviewNumberNode = ExtendReteNode<'PreviewNumber', {
+    inValue: number | number[];
+    inValueType: VectorValueType;
+    outValue: number | number[];
+    outValueType: VectorValueType;
+}>;
+
+type ReteVariableDefNode = ExtendReteNode<'VariableDef', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+    nameValue: string;
+    nameValueType: ValueType.string;
+}>;
+declare module '../../rete/core/events' {
+    interface EventsTypes {
+        variablerefchange: {
+            node: ReteVariableDefNode;
+            nextName: string;
+        };
+    }
+}
+
+type ReteVariableRefNode = ExtendReteNode<'VariableRef', {
+    inValue: number | number[];
+    inValueType: ValueType;
+    outValue: number | number[];
+    outValueType: ValueType;
+    outValueName: string;
+    defNodeIdValue: string;
+    defNodeIdValueType: ValueType.string;
+}>;
+
+type ReteTilingAndOffsetNode = ExtendReteNode<'TilingAndOffset', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    tilingValue: number;
+    tilingValueType: ValueType.vec2;
+    offsetValue: number;
+    offsetValueType: ValueType.vec2;
+    outValue: number;
+    outValueType: ValueType.vec2;
+}>;
+
+type RetePolarCoordinatesNode = ExtendReteNode<'PolarCoordinates', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    centerValue: number[];
+    centerValueType: ValueType.vec2;
+    radialScaleValue: number;
+    radialScaleValueType: ValueType.float;
+    lengthScaleValue: number;
+    lengthScaleValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteTwirlNode = ExtendReteNode<'Twirl', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    centerValue: number[];
+    centerValueType: ValueType.vec2;
+    strengthValue: number;
+    strengthValueType: ValueType.vec2;
+    offsetValue: number[];
+    offsetValueType: ValueType.vec2;
+    outValue: number;
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteRotateNode = ExtendReteNode<'Rotate', {
+    uvValue: 'UV0' | 'UV1' | 'UV2' | 'UV3' | number[];
+    uvValueType: ValueType.vec2;
+    centerValue: number[];
+    centerValueType: ValueType.vec2;
+    rotationValue: number;
+    rotationValueType: ValueType.float;
+    unitValue: 'radians' | 'degrees';
+    unitValueType: ValueType.string;
+    outValue: number;
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteFlipBookNode = ExtendReteNode<'FlipBook', {
+    uvValue: UVValue | number[];
+    uvValueType: ValueType.vec2;
+    widthValue: number;
+    widthValueType: ValueType.float;
+    heightValue: number;
+    heightValueType: ValueType.float;
+    tileValue: number;
+    tileValueType: ValueType.float;
+    invertXValue: boolean;
+    invertYValue: boolean;
+    outValue: number;
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteRadialShearNode = ExtendReteNode<'RadialShear', {
+    uvValue: UVValue | number[];
+    uvValueType: ValueType.vec2;
+    centerValue: number[];
+    centerValueType: ValueType.vec2;
+    strengthValue: number[];
+    strengthValueType: ValueType.vec2;
+    offsetValue: number[];
+    offsetValueType: ValueType.vec2;
+    outValue: number[];
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteSpherizeNode = ExtendReteNode<'Spherize', {
+    uvValue: UVValue | number[];
+    uvValueType: ValueType.vec2;
+    centerValue: number[];
+    centerValueType: ValueType.vec2;
+    strengthValue: number[];
+    strengthValueType: ValueType.vec2;
+    offsetValue: number[];
+    offsetValueType: ValueType.vec2;
+    outValue: number[];
+    outValueType: ValueType.vec2;
+}>;
+
+type ReteTriplanarNode = ExtendReteNode<'Triplanar', {
+    textureValue: AssetValue;
+    textureValueType: ValueType.texture2d;
+    positionValue: number[];
+    positionValueType: ValueType.vec3;
+    normalValue: number[];
+    normalValueType: ValueType.vec3;
+    tileValue: number;
+    tileValueType: ValueType.float;
+    blendValue: number;
+    blendValueType: ValueType.float;
+    outValue: number[];
+    outValueType: ValueType.vec4;
+    typeValue: 'default';
+}>;
+
+type SGBlock = ReteCustomInterpolatorBlock | ReteNormalBlock | ReteTangentBlock | RetePositionBlock | ReteAOBlock | ReteBaseColorBlock | ReteEmissionBlock | ReteSmoothnessBlock | ReteNormalTSBlock | ReteMetallicBlock | ReteAlphaClipBlock | ReteAlphaBlock | ReteCoatSmoothnessBlock | ReteCoatMaskBlock;
+type SGContext = ReteVertexContext | ReteFragmentContext;
+type SGNodes = SGContext | SGBlock | ReteOutputNode | ReteVaryingNode | ReteParameterNode | ReteColorNode | ReteTimeNode | ReteConstantNode | ReteFloatNode | ReteVec2Node | ReteVec3Node | ReteVec4Node | ReteTexture2DAssetNode | ReteSampleTexture2DNode | ReteTexelSizeNode | ReteSamplerStateNode | ReteUVNode | ReteNormalNode | RetePositionNode | ReteViewVectorNode | ReteViewDirectionNode | ReteScreenPositionNode | ReteTangentVectorNode | ReteBiTangentVectorNode | ReteTransformationMatrixNode | ReteMatrix4x4Node | ReteMatrix3x3Node | ReteMatrix2x2Node | ReteCameraNode | ReteObjectNode | ReteScreenNode | ReteSceneColorNode | ReteSceneDepthNode | ReteSubtractNode | ReteDivideNode | ReteAddNode | RetePowerNode | ReteSquareRootNode | ReteMultiplyNode | ReteTangentNode | ReteRadiansToDegreesNode | ReteDegreesToRadiansNode | ReteHyperbolicTangentNode | ReteHyperbolicSineNode | ReteHyperbolicCosineNode | ReteArctangent2Node | ReteArctangentNode | ReteArcsineNode | ReteArccosineNode | ReteCosineNode | ReteSineNode | ReteExponentialNode | ReteLengthNode | ReteLogNode | ReteModuloNode | ReteNegateNode | ReteNormalizeNode | RetePosterizeNode | ReteReciprocalNode | ReteReciprocalSquareRootNode | ReteAbsoluteNode | ReteDDXNode | ReteDDYNode | ReteDDXYNode | ReteInverseLerpNode | ReteSmoothstepNode | ReteLerpNode | ReteClampNode | ReteMinimumNode | ReteMaximumNode | ReteOneMinusNode | ReteSaturateNode | ReteRemapNode | ReteRandomRangeNode | ReteFractionNode | ReteFloorNode | ReteRoundNode | ReteSignNode | ReteTruncateNode | ReteStepNode | ReteCeilingNode | ReteDistanceNode | ReteDotProductNode | ReteFresnelEffectNode | ReteProjectionNode | ReteReflectionNode | ReteRotateAboutAxisNode | ReteSphereMaskNode | ReteCrossProductNode | ReteTransformNode | ReteRefractNode | ReteNoiseSineWaveNode | ReteSawtoothWaveNode | ReteTriangleWaveNode | ReteSquareWaveNode | ReteCombineNode | ReteSwizzleNode | ReteFlipNode | ReteSplitNode | ReteCheckerboardNode | ReteGradientNoiseNode | ReteSimpleNoiseNode | ReteVoronoiNode | ReteEllipseNode | RetePolygonNode | ReteRectangleNode | ReteRoundedPolygonNode | ReteRoundedRectangleNode | ReteCustomFunctionNode | ReteSubGraphNode | RetePreviewNode | RetePreviewNumberNode | ReteVariableDefNode | ReteVariableRefNode | ReteChannelMixerNode | ReteContrastNode | ReteHueNode | ReteReplaceColorNode | ReteSaturationNode | ReteWhiteBalanceNode | ReteInvertColorsNode | ReteColorMaskNode | ReteNormalFromTextureNode | ReteNormalBlendNode | ReteNormalReconstructZNode | ReteNormalStrengthNode | ReteColorSpaceConversionNode | ReteBlendNode | ReteTilingAndOffsetNode | RetePolarCoordinatesNode | ReteRotateNode | ReteTwirlNode | ReteFlipBookNode | ReteRadialShearNode | ReteSpherizeNode | ReteTriplanarNode;
+interface SGNodeData<Node extends Node> extends NodeData {
+    name: Node['name'];
+    data: NodeData['data'] & Node['data'];
+    blocks: SGNodeData<SGBlock>[];
+}
+interface SGNodesData {
+    [id: string]: SGNodeData<SGNodes>;
+}
+interface SGSetting {
+    template: 'lit' | 'unlit' | 'subgraph';
+    precision: 'single' | 'float';
+    allowMaterialOverride: boolean;
+    surfaceType: 'opaque' | 'transparent';
+    blendingMode: 'alpha' | 'premultiply' | 'additive' | 'multiply';
+    renderFace: 'front' | 'back' | 'both';
+    depthWrite: 'auto' | 'enable' | 'disable';
+    depthTest: 'never' | 'less' | 'equal' | 'l equal' | 'greater' | 'not equal' | 'g equal' | 'always';
+    alphaClipping: boolean;
+    castShadows: boolean;
+    clearCoat: boolean;
+}
+interface ShaderGraphData extends GraphData {
+    type: 'ShaderGraph' | 'SubGraph';
+    version: string;
+    UIState: {
+        showMainPreview?: boolean;
+        showBlackBoard?: boolean;
+        showInspector?: boolean;
+    };
+    setting: SGSetting;
+    parameters: Array<ParameterData>;
+    nodes: SGNodesData;
+}
+declare const SGSettingValueCfgs: SettingValueCfgs;
+
+interface SubGraphProvider {
+    getList(): MaybePromise<Array<AssetValue>>;
+    getGraphData(asset: AssetValue): MaybePromise<ShaderGraphData>;
+}
+
+/** 编辑器选项 */
+interface EditorOptions {
+    /** 是否自动初始化基本节点 (默认 true) */
+    autoInit?: boolean;
+    /** 是否显示预览面板 (默认 true) */
+    showPreview?: boolean;
+    /** 子图提供者 */
+    subGraphProvider?: SubGraphProvider;
+    /** 自动编译 (默认 true) */
+    autoCompile?: boolean;
+}
+/** 编辑器事件映射 */
+interface EditorEventMap {
+    /** 图发生变化时触发 */
+    change: () => void;
+    /** 编译完成时触发 */
+    compiled: (config: ShaderConfig) => void;
+    /** 设置更新时触发 */
+    settingUpdate: (name: string, value: any) => void;
+    /** 图被导入时触发 */
+    imported: () => void;
+    /** 编辑器就绪时触发 */
+    ready: () => void;
+}
+/** 编辑器插件 */
+interface EditorPlugin {
+    /** 插件名称 */
+    name: string;
+    /** 安装钩子 */
+    install?: (editor: ShaderGraphEditor) => void;
+    /** 初始化钩子 */
+    init?: (editor: ShaderGraphEditor) => void;
+}
+/**
+ * ShaderGraphEditor 主类
+ *
+ * ## 特性
+ * - 可视化节点编辑 (Rete.js)
+ * - 支持 Unlit / Lit / SubGraph 模板
+ * - 实时预览
+ * - 参数面板 (Inspector)
+ * - 黑板视图 (Blackboard)
+ * - 子图支持
+ * - 编译导出 ShaderConfig
+ */
+declare class ShaderGraphEditor {
+    /** 内部编辑器实例 */
+    readonly inner: ShaderGraphEditor$1;
+    /** 选项 */
+    readonly options: Required<EditorOptions>;
+    private _ready;
+    private _readyPromise;
+    private _resolveReady;
+    private eventHandlers;
+    /**
+     * 构造编辑器
+     *
+     * @param container - 编辑器挂载的 DOM 容器
+     * @param options   - 编辑器选项
+     *
+     * @example
+     * ```ts
+     * const editor = new ShaderGraphEditor(
+     *   document.getElementById('editor')!,
+     *   { showPreview: true }
+     * );
+     * await editor.createGraph();
+     * ```
+     */
+    constructor(container: HTMLElement, options?: EditorOptions);
+    /**
+     * 编辑器是否已就绪
+     */
+    get ready(): boolean;
+    /**
+     * 等待编辑器就绪
+     */
+    get readyPromise(): Promise<void>;
+    private bindInternalEvents;
+    /**
+     * 创建新的着色器图
+     *
+     * 初始化 ShaderGraph 的所有必要节点 (Vertex Context, Fragment Context, 默认 Block 等)。
+     *
+     * @example
+     * ```ts
+     * await editor.createGraph();
+     * ```
+     */
+    createGraph(): Promise<void>;
+    /**
+     * 创建新的子图
+     *
+     * @example
+     * ```ts
+     * await editor.createSubGraph();
+     * ```
+     */
+    createSubGraph(): Promise<void>;
+    /**
+     * 从 JSON 加载图数据
+     *
+     * @param data - 图数据 (editor.save() 的产物)
+     *
+     * @example
+     * ```ts
+     * const data = editor.save();
+     * localStorage.setItem('graph', JSON.stringify(data));
+     *
+     * // 恢复
+     * const saved = JSON.parse(localStorage.getItem('graph')!);
+     * editor.load(saved);
+     * ```
+     */
+    load(data: ShaderGraphData): void;
+    /**
+     * 导出图为 JSON
+     *
+     * @returns 图数据
+     */
+    save(): ShaderGraphData;
+    /**
+     * 清空编辑器
+     *
+     * 移除所有节点和连线。
+     */
+    clear(): void;
+    /**
+     * 编译图为 ShaderConfig
+     *
+     * 返回的 ShaderConfig 可直接用于 ShaderGraphRuntime。
+     *
+     * @returns 着色器配置
+     *
+     * @example
+     * ```ts
+     * const config = await editor.compile();
+     * runtime.load(config);
+     * ```
+     */
+    compile(): Promise<ShaderConfig>;
+    /**
+     * 切换黑板视图 (参数列表)
+     */
+    toggleBlackboard(): void;
+    /**
+     * 切换主预览面板
+     */
+    togglePreview(): void;
+    /**
+     * 切换属性面板
+     */
+    toggleInspector(): void;
+    /**
+     * 监听编辑器事件
+     *
+     * @param event   - 事件名
+     * @param handler - 处理函数
+     *
+     * @example
+     * ```ts
+     * editor.on('change', () => console.log('graph changed'));
+     * editor.on('compiled', (config) => console.log(config));
+     * ```
+     */
+    on<K extends keyof EditorEventMap>(event: K, handler: EditorEventMap[K]): void;
+    /**
+     * 移除事件监听
+     */
+    off<K extends keyof EditorEventMap>(event: K, handler: EditorEventMap[K]): void;
+    private emit;
+    /**
+     * 使用插件
+     *
+     * @param plugin  - 插件
+     * @param options - 插件选项
+     *
+     * @example
+     * ```ts
+     * editor.use({
+     *   name: 'my-plugin',
+     *   init: (editor) => { console.log('plugin loaded'); }
+     * });
+     * ```
+     */
+    use(plugin: EditorPlugin, options?: any): void;
+    /**
+     * 释放编辑器资源
+     *
+     * 清理 DOM、事件监听、取消编译任务。
+     */
+    dispose(): void;
+}
+
+export { type EditorEventMap, type EditorOptions, type EditorPlugin, type ShaderGraphData as GraphData, type SGNodeData, type SGNodes, type SGSetting, SGSettingValueCfgs, ShaderConfig, ShaderGraphEditor, type SubGraphProvider };