@onerjs/smart-filters 8.25.0

package/src/blockFoundation/inputBlock.serializer.ts

@@ -0,0 +1,150 @@
+import { InputBlockBase, type InputBlock } from "./inputBlock.js";
+import type { BaseBlock } from "./baseBlock.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import type {
+    BooleanInputBlockData,
+    Color3InputBlockData,
+    Color4InputBlockData,
+    FloatInputBlockData,
+    SerializedInputBlockData,
+    TextureInputBlockData,
+    Vector2InputBlockData,
+} from "./inputBlock.serialization.types.js";
+import type { IBlockSerializerV1 } from "../serialization/v1/smartFilterSerialization.types.js";
+
+/**
+ * Determines which generic type of InputBlock we are trying to serialize and calls the appropriate function
+ * to serialize the specifics for that type of InputBlock
+ * @param inputBlock - The InputBlock to serialize
+ * @returns Serialized data for the InputBlock
+ */
+function SerializeInputBlockData(inputBlock: InputBlockBase): SerializedInputBlockData {
+    switch (inputBlock.type) {
+        case ConnectionPointType.Texture:
+            return SerializeTextureInputBlock(inputBlock as InputBlock<ConnectionPointType.Texture>);
+        case ConnectionPointType.Boolean:
+            return SerializeBooleanInputBlock(inputBlock as InputBlock<ConnectionPointType.Boolean>);
+        case ConnectionPointType.Float:
+            return SerializeFloatInputBlock(inputBlock as InputBlock<ConnectionPointType.Float>);
+        case ConnectionPointType.Color3:
+            return SerializeColor3InputBlock(inputBlock as InputBlock<ConnectionPointType.Color3>);
+        case ConnectionPointType.Color4:
+            return SerializeColor4InputBlock(inputBlock as InputBlock<ConnectionPointType.Color4>);
+        case ConnectionPointType.Vector2:
+            return SerializeVector2InputBlock(inputBlock as InputBlock<ConnectionPointType.Vector2>);
+    }
+}
+
+/**
+ * Generates the serialized data for a Texture InputBlock
+ * @param inputBlock - The Texture InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeTextureInputBlock(inputBlock: InputBlock<ConnectionPointType.Texture>): TextureInputBlockData {
+    const internalTexture = inputBlock.runtimeValue.value?.getInternalTexture();
+    const forcedExtension = internalTexture?._extension ?? null;
+
+    let url = internalTexture?.url ?? null;
+    if (url === "" || !url) {
+        url = inputBlock.editorData?.url ?? null;
+    }
+
+    return {
+        inputType: ConnectionPointType.Texture,
+        url,
+        urlTypeHint: inputBlock.editorData?.urlTypeHint ?? null,
+        flipY: internalTexture?.invertY ?? null,
+        anisotropicFilteringLevel: internalTexture?.anisotropicFilteringLevel ?? null,
+        forcedExtension: forcedExtension !== "" ? forcedExtension : null,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * Generates the serialized data for a Boolean InputBlock
+ * @param inputBlock - The Boolean InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeBooleanInputBlock(inputBlock: InputBlock<ConnectionPointType.Boolean>): BooleanInputBlockData {
+    return {
+        inputType: ConnectionPointType.Boolean,
+        value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * Generates the serialized data for a Float InputBlock
+ * @param inputBlock - The Float InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeFloatInputBlock(inputBlock: InputBlock<ConnectionPointType.Float>): FloatInputBlockData {
+    return {
+        inputType: ConnectionPointType.Float,
+        value: inputBlock.runtimeValue.value,
+        animationType: inputBlock.editorData?.animationType ?? null,
+        valueDeltaPerMs: inputBlock.editorData?.valueDeltaPerMs ?? null,
+        min: inputBlock.editorData?.min ?? null,
+        max: inputBlock.editorData?.max ?? null,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * Generates the serialized data for a Color3 InputBlock
+ * @param inputBlock - The Color3 InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeColor3InputBlock(inputBlock: InputBlock<ConnectionPointType.Color3>): Color3InputBlockData {
+    return {
+        inputType: ConnectionPointType.Color3,
+        value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * Generates the serialized data for a Color4 InputBlock
+ * @param inputBlock - The Color4 InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeColor4InputBlock(inputBlock: InputBlock<ConnectionPointType.Color4>): Color4InputBlockData {
+    return {
+        inputType: ConnectionPointType.Color4,
+        value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * Generates the serialized data for a Vector2 InputBlock
+ * @param inputBlock - The Vector2 InputBlock to serialize
+ * @returns The serialized data for the InputBlock
+ */
+function SerializeVector2InputBlock(inputBlock: InputBlock<ConnectionPointType.Vector2>): Vector2InputBlockData {
+    return {
+        inputType: ConnectionPointType.Vector2,
+        value: inputBlock.runtimeValue.value,
+        appMetadata: inputBlock.appMetadata,
+    };
+}
+
+/**
+ * The V1 serializer for an InputBlock
+ */
+export const InputBlockSerializer: IBlockSerializerV1 = {
+    blockType: InputBlockBase.ClassName,
+    serialize: (block: BaseBlock) => {
+        if (block.blockType !== InputBlockBase.ClassName) {
+            throw new Error("Was asked to serialize an unrecognized block type");
+        }
+        return {
+            name: block.name,
+            uniqueId: block.uniqueId,
+            blockType: InputBlockBase.ClassName,
+            namespace: null,
+            comments: block.comments,
+            data: SerializeInputBlockData(block as unknown as InputBlockBase),
+        };
+    },
+};

package/src/blockFoundation/inputBlock.ts

@@ -0,0 +1,181 @@
+import type { SmartFilter } from "../smartFilter.js";
+import type { ConnectionPointValue } from "../connection/connectionPointType.js";
+import type { RuntimeData } from "../connection/connectionPoint.js";
+import type { ConnectionPointWithDefault } from "../connection/connectionPointWithDefault.js";
+import type { DisableableShaderBlock } from "./disableableShaderBlock.js";
+import { BaseBlock } from "./baseBlock.js";
+import { CreateStrongRef } from "../runtime/strongRef.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import type { Nullable } from "core/types.js";
+
+/**
+ * Type predicate to check if value is a strong ref or a direct value
+ * @param value - The value to check
+ * @returns true if the value is a strong ref, otherwise false
+ */
+function IsRuntimeData<U extends ConnectionPointType>(value: ConnectionPointValue<U> | RuntimeData<U>): value is RuntimeData<U> {
+    return value && (value as RuntimeData<ConnectionPointType>).value !== undefined;
+}
+
+/**
+ * Predicate to check if a block is a texture input block.
+ * @param block - The block to check
+ * @returns true if the block is a texture input block, otherwise false
+ */
+export function IsTextureInputBlock(block: BaseBlock): block is InputBlock<ConnectionPointType.Texture> {
+    return (block as InputBlock<ConnectionPointType.Texture>).type === ConnectionPointType.Texture;
+}
+
+/**
+ * Predicate to check if a block is a disableable block.
+ * @param block - The block to check
+ * @returns true if the block is a disableable block, otherwise false
+ */
+export function IsDisableableShaderBlock(block: BaseBlock): block is DisableableShaderBlock {
+    return (block as DisableableShaderBlock).disabled !== undefined;
+}
+
+/**
+ * This base class exists to provide a type that the serializer can use to represent
+ * any InputBlock without knowing the exact type it is.
+ */
+export abstract class InputBlockBase extends BaseBlock {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "InputBlock";
+
+    /**
+     * The type of the input.
+     */
+    public abstract readonly type: ConnectionPointType;
+}
+
+/**
+ * Describes the editor data that can be stored with an InputBlock of a given type.
+ */
+export type InputBlockEditorData<T extends ConnectionPointType> = T extends ConnectionPointType.Texture
+    ? {
+          /**
+           * The URL of the texture, or default if null.
+           */
+          url: Nullable<string>;
+
+          /**
+           * If supplied, gives a hint as to which type of texture the URL points to.
+           * Default is assumed to be "image"
+           */
+          urlTypeHint: Nullable<"image" | "video">;
+
+          /**
+           * The anisotropic filtering level of the texture, or default if null.
+           */
+          anisotropicFilteringLevel: Nullable<number>;
+
+          /**
+           * Whether the Y axis should be flipped, or default if null.
+           */
+          flipY: Nullable<boolean>;
+
+          /**
+           * The file extension to use, or default if null.
+           */
+          forcedExtension: Nullable<string>;
+      }
+    : T extends ConnectionPointType.Float
+      ? {
+            /**
+             * If supplied, how this should be animated by the editor.  Will not affect runtime behavior.
+             */
+            animationType: Nullable<"time">;
+
+            /**
+             * If supplied, the amount to change the value per millisecond when animating.
+             */
+            valueDeltaPerMs: Nullable<number>;
+
+            /**
+             * The minimum value of the float, used for slider control.
+             */
+            min: Nullable<number>;
+
+            /**
+             * The maximum value of the float, used for slider control.
+             */
+            max: Nullable<number>;
+        }
+      : {};
+
+/**
+ * This represents any inputs used in the graph.
+ *
+ * This is used to provide a way to connect the graph to the outside world.
+ *
+ * The value is dynamically set by the user.
+ */
+export class InputBlock<U extends ConnectionPointType, V = unknown> extends InputBlockBase {
+    /**
+     * The output connection point of the block.
+     */
+    public readonly output: ConnectionPointWithDefault<U>;
+
+    /**
+     * The type of the input.
+     */
+    public readonly type: U;
+
+    /**
+     * Data used by the Editor to store options required for instantiating the block in the Editor.
+     */
+    public editorData: Nullable<InputBlockEditorData<U>> = null;
+
+    /**
+     * Metadata the hosting app wants to track for this input. For example, a hint for what data to
+     * assign to this input, or hints about how to draw dynamic UI to allow users to control this value.
+     */
+    public appMetadata: Nullable<V> = null;
+
+    /**
+     * Gets the current value of the input.
+     */
+    public get runtimeValue(): RuntimeData<U> {
+        return this.output.runtimeData;
+    }
+
+    /**
+     * Sets the current value of the input.
+     */
+    public set runtimeValue(value: RuntimeData<U>) {
+        this.output.runtimeData = value;
+    }
+
+    /**
+     * Creates a new InputBlock.
+     * @param smartFilter - The smart filter to add the block to
+     * @param name - The friendly name of the block
+     * @param type - The type of the input
+     * @param initialValue - The initial value of the input
+     * @remarks the initial value can either be a strong reference or a value
+     */
+    constructor(smartFilter: SmartFilter, name: string, type: U, initialValue: ConnectionPointValue<U> | RuntimeData<U>) {
+        super(smartFilter, name);
+        this.type = type;
+
+        // Creates the output connection point
+        this.output = this._registerOutputWithDefault("output", type, IsRuntimeData(initialValue) ? initialValue : CreateStrongRef(initialValue));
+
+        // Creates a strong reference to the initial value in case a reference has not been provided
+        if (IsRuntimeData(initialValue)) {
+            this.runtimeValue = initialValue;
+        } else {
+            this.runtimeValue = CreateStrongRef(initialValue);
+        }
+    }
+}
+
+/**
+ * Unionized type of all the possible input types.
+ */
+export type AnyInputBlock = {
+    [T in keyof typeof ConnectionPointType]: InputBlock<(typeof ConnectionPointType)[T]>;
+}[keyof typeof ConnectionPointType];

package/src/blockFoundation/outputBlock.ts

@@ -0,0 +1,144 @@
+import type { InitializationData, SmartFilter } from "../smartFilter.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import { BaseBlock } from "./baseBlock.js";
+import { ShaderBinding, ShaderRuntime } from "../runtime/shaderRuntime.js";
+import type { Nullable } from "core/types.js";
+import type { RenderTargetWrapper } from "core/Engines/renderTargetWrapper.js";
+import { RegisterFinalRenderCommand } from "../utils/renderTargetUtils.js";
+import type { RuntimeData } from "../connection/connectionPoint.js";
+import type { Effect } from "core/Materials/effect.js";
+import type { ShaderProgram } from "../utils/shaderCodeUtils.js";
+
+/**
+ * The shader program for the block.
+ */
+const BlockShaderProgram: ShaderProgram = {
+    vertex: undefined,
+    fragment: {
+        uniform: `
+            uniform sampler2D _input_; // main`,
+        mainInputTexture: "_input_",
+        mainFunctionName: "_copy_",
+        functions: [
+            {
+                name: "_copy_",
+                code: `
+                    vec4 _copy_(vec2 vUV) {
+                        return texture2D(_input_, vUV);
+                    }
+
+                    `,
+            },
+        ],
+    },
+};
+
+/**
+ * The uniform names for this shader, to be used in the shader binding so
+ * that the names are always in sync.
+ */
+const Uniforms = {
+    input: "input",
+};
+
+/**
+ * The output block of a smart filter.
+ *
+ * Only the smart filter will internally create and host the output block.
+ * It should not be exported through the main index.ts module.
+ */
+export class OutputBlock extends BaseBlock {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "OutputBlock";
+
+    /**
+     * Input connection point of the output block.
+     * This takes a texture as input.
+     */
+    public readonly input = this._registerInput("input", ConnectionPointType.Texture);
+
+    /**
+     * If supplied, the Smart Filter will render into this RenderTargetWrapper. Otherwise, it renders
+     * into the the canvas or WebGL context the ThinEngine is using for rendering.
+     */
+    public renderTargetWrapper: Nullable<RenderTargetWrapper> = null;
+
+    /**
+     * Create a new output block.
+     * @param smartFilter - The smart filter this block belongs to
+     */
+    constructor(smartFilter: SmartFilter) {
+        super(smartFilter, "output");
+    }
+
+    /**
+     * Prepares all blocks for runtime by traversing the graph.
+     */
+    public override prepareForRuntime(): void {
+        this.visit({}, (block: BaseBlock, _extraData: object) => {
+            if (block !== this) {
+                block.prepareForRuntime();
+            }
+        });
+    }
+
+    /**
+     * Propagates the runtime data for all graph blocks.
+     */
+    public override propagateRuntimeData(): void {
+        this.visit({}, (block: BaseBlock, _extraData: object) => {
+            if (block !== this) {
+                block.propagateRuntimeData();
+            }
+        });
+        this._confirmRuntimeDataSupplied(this.input);
+    }
+
+    /**
+     * Generates the commands needed to execute the block at runtime and gathers promises for initialization work
+     * @param initializationData - The initialization data to use
+     * @param finalOutput - Defines if the block is the final output of the smart filter
+     */
+    public override generateCommandsAndGatherInitPromises(initializationData: InitializationData, finalOutput: boolean): void {
+        // In the case that this OutputBlock is directly connected to a texture InputBlock, we must
+        // use a shader to copy the texture to the render target texture.
+        if (this.input.connectedTo?.ownerBlock.isInput && this.input.runtimeData) {
+            const runtime = initializationData.runtime;
+
+            const shaderBlockRuntime = new ShaderRuntime(runtime.effectRenderer, BlockShaderProgram, new OutputShaderBinding(this.input.runtimeData));
+            initializationData.initializationPromises.push(shaderBlockRuntime.onReadyAsync);
+            runtime.registerResource(shaderBlockRuntime);
+
+            RegisterFinalRenderCommand(this, runtime, this, shaderBlockRuntime);
+
+            super.generateCommandsAndGatherInitPromises(initializationData, finalOutput);
+        }
+    }
+}
+
+/**
+ * Shader binding to use when the OutputBlock is directly connected to a texture InputBlock.
+ */
+class OutputShaderBinding extends ShaderBinding {
+    private readonly _inputTexture: RuntimeData<ConnectionPointType.Texture>;
+
+    /**
+     * Creates a new shader binding instance.
+     * @param inputTexture - defines the input texture to copy
+     */
+    constructor(inputTexture: RuntimeData<ConnectionPointType.Texture>) {
+        super();
+        this._inputTexture = inputTexture;
+    }
+
+    /**
+     * Binds all the required data to the shader when rendering.
+     * @param effect - defines the effect to bind the data to
+     * @internal
+     */
+    public override bind(effect: Effect): void {
+        effect.setTexture(this.getRemappedName(Uniforms.input), this._inputTexture.value);
+    }
+}

package/src/blockFoundation/shaderBlock.ts

@@ -0,0 +1,156 @@
+import type { ThinRenderTargetTexture } from "core/Materials/Textures/thinRenderTargetTexture.js";
+import "core/Engines/Extensions/engine.renderTarget.js";
+
+import type { InitializationData, SmartFilter } from "../smartFilter.js";
+import type { ShaderProgram } from "../utils/shaderCodeUtils.js";
+import type { ShaderBinding } from "../runtime/shaderRuntime.js";
+import type { ConnectionPoint } from "../connection/connectionPoint.js";
+import { ShaderRuntime } from "../runtime/shaderRuntime.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import { CreateCommand } from "../command/command.js";
+import { UndecorateSymbol } from "../utils/shaderCodeUtils.js";
+import { RegisterFinalRenderCommand } from "../utils/renderTargetUtils.js";
+import { BaseBlock } from "./baseBlock.js";
+import { TextureFormat, TextureType, type OutputTextureOptions } from "./textureOptions.js";
+import { EditableInPropertyPage, PropertyTypeForEdition } from "../editorUtils/editableInPropertyPage.js";
+import type { Nullable } from "core/types.js";
+
+const OutputTexturePropertiesGroupName = "OUTPUT TEXTURE PROPERTIES";
+
+/**
+ * This is the base class for all shader blocks.
+ *
+ * It contains the redundant part of wrapping a shader for a full screen pass.
+ *
+ * The only required function to implement is the bind function.
+ */
+export abstract class ShaderBlock extends BaseBlock {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "ShaderBlock";
+
+    /**
+     * Get the class instance that binds all the required data to the shader (effect) when rendering.
+     * It should throw an error if required inputs are missing.
+     * @returns The class instance that binds the data to the effect
+     */
+    public abstract getShaderBinding(): ShaderBinding;
+
+    /**
+     * The shader program (vertex and fragment code) to use to render the block
+     */
+    public static ShaderCode: ShaderProgram;
+
+    /**
+     * The output connection point of the block.
+     */
+    public readonly output = this._registerOutput("output", ConnectionPointType.Texture);
+
+    /**
+     * The options used when creating the texture this block outputs to
+     */
+    @EditableInPropertyPage("Ratio", PropertyTypeForEdition.Float, OutputTexturePropertiesGroupName, {
+        min: 0.1,
+        max: 10.0,
+        notifiers: { rebuild: true },
+        subPropertyName: "ratio",
+    })
+    @EditableInPropertyPage("Format", PropertyTypeForEdition.List, OutputTexturePropertiesGroupName, {
+        notifiers: { rebuild: true },
+        subPropertyName: "format",
+        options: [
+            { label: "R", value: TextureFormat.R },
+            { label: "RG", value: TextureFormat.RG },
+            { label: "RGBA", value: TextureFormat.RGBA },
+        ],
+    })
+    @EditableInPropertyPage("Type", PropertyTypeForEdition.List, OutputTexturePropertiesGroupName, {
+        notifiers: { rebuild: true },
+        subPropertyName: "type",
+        options: [
+            { label: "UByte", value: TextureType.UNSIGNED_BYTE },
+            { label: "Float", value: TextureType.FLOAT },
+            { label: "Half Float", value: TextureType.HALF_FLOAT },
+        ],
+    })
+    public outputTextureOptions: OutputTextureOptions = {
+        ratio: 1,
+        format: TextureFormat.RGBA,
+        type: TextureType.UNSIGNED_BYTE,
+    };
+
+    /**
+     * Disconnects the block from the graph.
+     * @param disconnectedConnections - Stores the connections that have been broken in the process. You can reconnect them later if needed.
+     */
+    public override disconnectFromGraph(disconnectedConnections?: [ConnectionPoint, ConnectionPoint][]): void {
+        const input = this._getConnectionForMainInputTexture();
+
+        for (const endpoint of this.output.endpoints) {
+            disconnectedConnections?.push([endpoint, this.output]);
+            input.connectTo(endpoint);
+        }
+    }
+
+    protected _getConnectionForMainInputTexture(): ConnectionPoint {
+        const mainInputTextureName = this.getShaderProgram().fragment.mainInputTexture;
+        if (!mainInputTextureName) {
+            throw `The block named "${this.name}" does not have a main input texture defined!`;
+        }
+
+        const mainInputTexture = this.findInput(UndecorateSymbol(mainInputTextureName));
+        if (!mainInputTexture || !mainInputTexture.connectedTo) {
+            throw `The main input texture "${mainInputTextureName}" of block named "${this.name}" is not connected!`;
+        }
+
+        return mainInputTexture.connectedTo;
+    }
+
+    /**
+     * Instantiates a new block.
+     * @param smartFilter - Defines the smart filter the block belongs to
+     * @param name - Defines the name of the block
+     * @param disableOptimization - Defines if the block should not be optimized (default: false)
+     */
+    constructor(smartFilter: SmartFilter, name: string, disableOptimization = false) {
+        super(smartFilter, name, disableOptimization);
+    }
+
+    /**
+     * Gets the shader program to use to render the block.
+     * @returns The shader program to use to render the block
+     */
+    public getShaderProgram() {
+        return (this.constructor as typeof ShaderBlock).ShaderCode;
+    }
+
+    /**
+     * Generates the commands needed to execute the block at runtime and gathers promises for initialization work
+     * @param initializationData - The initialization data to use
+     * @param finalOutput - Defines if the block is the final output of the smart filter
+     */
+    public override generateCommandsAndGatherInitPromises(initializationData: InitializationData, finalOutput: boolean): void {
+        const runtime = initializationData.runtime;
+        const shaderBlockRuntime = new ShaderRuntime(runtime.effectRenderer, this.getShaderProgram(), this.getShaderBinding());
+        initializationData.initializationPromises.push(shaderBlockRuntime.onReadyAsync);
+        runtime.registerResource(shaderBlockRuntime);
+
+        if (finalOutput) {
+            RegisterFinalRenderCommand(initializationData.outputBlock, runtime, this, shaderBlockRuntime);
+        } else {
+            const renderTargetTexture = this.output.runtimeData?.value as Nullable<ThinRenderTargetTexture>;
+            if (!renderTargetTexture) {
+                throw new Error(`${this.blockType} did not have a render target texture.`);
+            }
+
+            runtime.registerCommand(
+                CreateCommand(`${this.blockType}.render`, this, () => {
+                    shaderBlockRuntime.renderToTargetTexture(renderTargetTexture);
+                })
+            );
+        }
+
+        super.generateCommandsAndGatherInitPromises(initializationData, finalOutput);
+    }
+}

package/src/blockFoundation/textureOptions.ts

@@ -0,0 +1,57 @@
+/**
+ * The format of a texture - corresponds to the Babylon.js TextureFormat constants
+ */
+export enum TextureFormat {
+    /** Babylon Constants.TEXTUREFORMAT_RGBA */
+    RGBA = 5,
+    /** Babylon Constants.TEXTUREFORMAT_R */
+    R = 6,
+    /** Babylon Constants.TEXTUREFORMAT_RG */
+    RG = 7,
+}
+
+/**
+ * The type of a texture - corresponds to the Babylon.js TextureType constants
+ */
+export enum TextureType {
+    /** Babylon Constants.TEXTURETYPE_UNSIGNED_BYTE */
+    UNSIGNED_BYTE = 0,
+    /** Babylon Constants.TEXTURETYPE_FLOAT */
+    FLOAT = 1,
+    /** Babylon Constants.TEXTURETYPE_HALF_FLOAT */
+    HALF_FLOAT = 2,
+}
+
+// IMPORTANT: Update textureOptionsMatch() if you add more fields to OutputTextureOptions
+/**
+ * Describes the requirements for the output texture of a shader block.
+ */
+export type OutputTextureOptions = {
+    /**
+     * The texture size ratio (output size of this block / size of the Smart Filter output)
+     */
+    ratio: number;
+
+    /**
+     * The format of the texture
+     */
+    format: TextureFormat;
+
+    /**
+     * The type of the texture
+     */
+    type: TextureType;
+};
+
+/**
+ * Compares two OutputTextureOptions to see if they match.
+ * @param a - The first OutputTextureOptions
+ * @param b - The second OutputTextureOptions
+ * @returns True if the two options match, false otherwise
+ */
+export function TextureOptionsMatch(a: OutputTextureOptions | undefined, b: OutputTextureOptions | undefined): boolean {
+    if (a === undefined || b === undefined) {
+        return false;
+    }
+    return a.ratio === b.ratio && a.format === b.format && a.type === b.type;
+}