@onerjs/smart-filters 8.25.0

package/license.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Babylon.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "@onerjs/smart-filters",
+    "version": "8.25.0",
+    "description": "Babylon.js Smart Filter core",
+    "keywords": [
+        "video",
+        "composition",
+        "3D",
+        "2D",
+        "javascript",
+        "html5",
+        "webgl",
+        "webgl2",
+        "webgpu",
+        "babylon"
+    ],
+    "license": "MIT",
+    "readme": "README.md",
+    "main": "dist/index",
+    "module": "dist/index",
+    "esnext": "dist/index",
+    "types": "dist/index",
+    "type": "module",
+    "sideEffects": [
+        "./dist/utils/buildTools/**"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/BabylonJS/Babylon.js.git"
+    },
+    "files": [
+        "dist",
+        "src",
+        "license.md",
+        "readme.md"
+    ],
+    "scripts": {
+        "build": "npm run clean && npm run copySrc && npm run compile",
+        "clean": "rimraf dist && rimraf src && rimraf *.tsbuildinfo -g && rimraf \"./**/*.!(cmd|md|json|build.json|lts.json|tasks.json|cjs)\" -g",
+        "copySrc": "node -e \"require('fs').cpSync('../../../dev/smartFilters/src', './src', { recursive: true })\"",
+        "compile": "node src/utils/buildTools/recordVersionNumber.js && tsc -b tsconfig.build.json",
+        "postcompile": "build-tools -c add-js-to-es6"
+    },
+    "devDependencies": {
+        "@dev/build-tools": "^1.0.0",
+        "@dev/core": "^1.0.0",
+        "@dev/shared-ui-components": "1.0.0"
+    },
+    "peerDependencies": {
+        "@onerjs/core": "^7.47.3 || ^8.0.1"
+    }
+}

package/readme.md

@@ -0,0 +1,9 @@
+# Babylon.js Smart Filters
+
+## Core
+
+A Smart Filter is a node based description of effects to apply on various inputs in order to create a visual output on a canvas element or specified render target.
+
+The main usage is for video processing and composition but it could be easily reused for picture edition or procedural creation.
+
+See the full documentation at [doc.babylonjs.com](https://doc.babylonjs.com/features/featuresDeepDive/smartFilters/)

package/src/IDisposable.ts

@@ -0,0 +1,9 @@
+/**
+ * Define an interface for all classes that will hold resources
+ */
+export interface IDisposable {
+    /**
+     * Releases all held resources
+     */
+    dispose(): void;
+}

package/src/blockFoundation/aggregateBlock.ts

@@ -0,0 +1,148 @@
+import type { Nullable } from "core/types.js";
+import type { ConnectionPoint, RuntimeData } from "../connection/connectionPoint.js";
+import type { ConnectionPointType } from "../connection/connectionPointType.js";
+
+import { BaseBlock } from "./baseBlock.js";
+
+/**
+ * The aggregate block class is the base class for all blocks that be created from other blocks.
+ *
+ * It is responsible for managing a hidden chain of smart filter blocks in order and expose them through
+ * its own connection points.
+ *
+ * The internal state is basically a filter itself.
+ */
+export abstract class AggregateBlock extends BaseBlock {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "AggregateBlock";
+
+    /**
+     * The list of relationships between the internal graph output and the outside ones.
+     */
+    private readonly _aggregatedOutputs: [ConnectionPoint, ConnectionPoint][] = [];
+
+    /**
+     * The list of relationships between the internal graph inputs and the outside ones.
+     */
+    private readonly _aggregatedInputs: [ConnectionPoint[], ConnectionPoint][] = [];
+
+    /**
+     * Do not override prepareForRuntime for aggregate blocks. It is not supported.
+     */
+    public override prepareForRuntime(): never {
+        throw new Error("Aggregate blocks should not be prepared for runtime.");
+    }
+
+    /**
+     * @internal
+     * Merges the internal graph into the SmartFilter
+     */
+    public _mergeIntoSmartFilter(mergedAggregateBlocks: AggregateBlock[]): void {
+        // Rewire output connections
+        for (const [internalConnectionPoint, externalConnectionPoint] of this._aggregatedOutputs) {
+            const endpointsToConnectTo = externalConnectionPoint.endpoints.slice();
+            externalConnectionPoint.disconnectAllEndpoints();
+            for (const endpoint of endpointsToConnectTo) {
+                internalConnectionPoint.connectTo(endpoint);
+            }
+        }
+
+        // Rewire input connections
+        for (const [internalConnectionPoints, externalConnectionPoint] of this._aggregatedInputs) {
+            const connectedToExternalConnectionPoint = externalConnectionPoint.connectedTo;
+            if (connectedToExternalConnectionPoint) {
+                connectedToExternalConnectionPoint.disconnectFrom(externalConnectionPoint);
+                for (const internalConnectionPoint of internalConnectionPoints) {
+                    connectedToExternalConnectionPoint.connectTo(internalConnectionPoint);
+                }
+            } else {
+                // If the external connection point is not connected to anything but has a default value,
+                // pass that default value along to the internal connection points it is associated with
+                const defaultValue = externalConnectionPoint.runtimeData;
+                if (defaultValue !== null) {
+                    for (const internalConnectionPoint of internalConnectionPoints) {
+                        internalConnectionPoint.runtimeData = defaultValue;
+                    }
+                }
+            }
+        }
+
+        // Tell any internal aggregate blocks to merge
+        // Must be done after the inputs and outputs were merged at our level, or the internal aggregate block may not be wired up to anything
+        for (const aggregateOutput of this._aggregatedOutputs) {
+            const internalConnectionPoint = aggregateOutput[0];
+            internalConnectionPoint.ownerBlock.visit({}, (block: BaseBlock, _extraData: object) => {
+                if (block instanceof AggregateBlock) {
+                    block._mergeIntoSmartFilter(mergedAggregateBlocks);
+                }
+            });
+        }
+
+        // Add ourselves to the list of merged aggregate blocks
+        mergedAggregateBlocks.push(this);
+    }
+
+    /**
+     * @internal
+     * Undoes a previous mergeIntoSmartFilter call.
+     */
+    public _unmergeFromSmartFilter(): void {
+        for (const [internalConnectionPoint, externalConnectionPoint] of this._aggregatedOutputs) {
+            const endpointsToConnectTo = internalConnectionPoint.endpoints.slice();
+            internalConnectionPoint.disconnectAllEndpoints();
+            for (const endpoint of endpointsToConnectTo) {
+                externalConnectionPoint.connectTo(endpoint);
+            }
+        }
+
+        for (const [internalConnectionPoints, externalConnectionPoint] of this._aggregatedInputs) {
+            if (internalConnectionPoints[0]) {
+                const connectedToInternalConnectionPoint = internalConnectionPoints[0].connectedTo;
+                if (connectedToInternalConnectionPoint) {
+                    for (const internalConnectionPoint of internalConnectionPoints) {
+                        connectedToInternalConnectionPoint.disconnectFrom(internalConnectionPoint);
+                    }
+                    connectedToInternalConnectionPoint.connectTo(externalConnectionPoint);
+                }
+            }
+        }
+    }
+
+    /**
+     * Registers an input connection from the internal graph as an input of the aggregated graph.
+     * @param name - The name of the exposed input connection point
+     * @param internalConnectionPoints - The input connection points in the inner graph to wire up to the new subfilter input
+     * @param defaultValue - The default value to use for the input connection point
+     * @returns the connection point referencing the input block
+     */
+    protected _registerSubfilterInput<U extends ConnectionPointType>(
+        name: string,
+        internalConnectionPoints: ConnectionPoint<U>[],
+        defaultValue: Nullable<RuntimeData<U>> = null
+    ): ConnectionPoint<U> {
+        const type = internalConnectionPoints[0]?.type;
+        if (type === undefined) {
+            throw new Error("Cannot register an input connection point with no internal connection points");
+        }
+        const externalInputConnectionPoint = this._registerInput(name, type, defaultValue);
+
+        this._aggregatedInputs.push([internalConnectionPoints, externalInputConnectionPoint]);
+
+        return externalInputConnectionPoint;
+    }
+
+    /**
+     * Registers an output connection point from the internal graph as an output of the aggregated graph.
+     * @param name - The name of the exposed output connection point
+     * @param internalConnectionPoint - The output connection point in the inner graph to expose as an output on the aggregate block
+     * @returns the connection point referencing the output connection point
+     */
+    protected _registerSubfilterOutput<U extends ConnectionPointType>(name: string, internalConnectionPoint: ConnectionPoint<U>): ConnectionPoint<U> {
+        const externalOutputConnectionPoint = this._registerOutput(name, internalConnectionPoint.type);
+
+        this._aggregatedOutputs.push([internalConnectionPoint, externalOutputConnectionPoint]);
+        return externalOutputConnectionPoint;
+    }
+}

package/src/blockFoundation/baseBlock.ts

@@ -0,0 +1,339 @@
+import type { Nullable } from "core/types.js";
+import { ConnectionPointType, type ConnectionPointValue } from "../connection/connectionPointType.js";
+import type { InitializationData, SmartFilter } from "../smartFilter.js";
+import type { ICommandOwner } from "../command/command.js";
+import { ConnectionPoint, type RuntimeData } from "../connection/connectionPoint.js";
+import { ConnectionPointWithDefault } from "../connection/connectionPointWithDefault.js";
+import { ConnectionPointDirection } from "../connection/connectionPointDirection.js";
+import { UniqueIdGenerator } from "../utils/uniqueIdGenerator.js";
+
+/**
+ * Defines a callback function that is triggered when visiting a block,
+ * It also carries over extra data preventing the need to use global variables or closures.
+ */
+export type BlockVisitor<T extends object> = (block: BaseBlock, extraData: T) => void;
+
+/**
+ * This class represents the base class for all smart filter blocks.
+ *
+ * It defines the basic structure of a smart filter block and provides the base implementation for
+ * managing the connection points.
+ *
+ * It enforces common behavior for all smart filter blocks.
+ */
+export abstract class BaseBlock implements ICommandOwner {
+    protected static _AlreadyVisitedBlocks = new Set<BaseBlock>();
+
+    /**
+     * The class name of the block.
+     */
+    public static ClassName = "BaseBlock";
+
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public static Namespace: Nullable<string> = null;
+
+    /**
+     * The smart filter the block belongs to.
+     */
+    public readonly smartFilter: SmartFilter;
+
+    /**
+     * Global unique id of the block (This is unique for the current session).
+     */
+    public uniqueId: number;
+
+    /**
+     * The name of the block. This is used to identify the block in the smart filter or in debug.
+     */
+    public readonly name: string;
+
+    /**
+     * The type of the block - used when serializing / deserializing the block, and in the editor.
+     * For programmatically created blocks, this should be the class name of the block.
+     * For custom blocks, this is specified in the block definition.
+     */
+    public get blockType(): string {
+        return this.getClassName();
+    }
+
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public get namespace(): Nullable<string> {
+        // Note that we use a static property instead of doing this.constructor.name to avoid problems with minifiers that would change the name of the class
+        return (this.constructor as typeof BaseBlock).Namespace;
+    }
+
+    /**
+     * User provided comments about the block. It can be used to document the block.
+     */
+    public comments: Nullable<string> = null;
+
+    private readonly _inputs: ConnectionPoint[] = [];
+    private readonly _outputs: ConnectionPoint[] = [];
+
+    /**
+     * 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 is optimizable or not
+     */
+    constructor(
+        smartFilter: SmartFilter,
+        name: string,
+        public readonly disableOptimization = false
+    ) {
+        this.uniqueId = UniqueIdGenerator.UniqueId;
+        this.name = name;
+        this.smartFilter = smartFilter;
+
+        // Register the block in the smart filter
+        smartFilter.registerBlock(this);
+    }
+
+    /**
+     * Returns the inputs connection points of the current block.
+     */
+    public get inputs(): ReadonlyArray<ConnectionPoint> {
+        return this._inputs;
+    }
+
+    /**
+     * Returns the outputs connection points of the current block.
+     */
+    public get outputs(): ReadonlyArray<ConnectionPoint> {
+        return this._outputs;
+    }
+
+    /**
+     * Returns if the block is an input block.
+     */
+    public get isInput(): boolean {
+        return this._inputs.length === 0;
+    }
+
+    /**
+     * Returns if the block is an output block.
+     */
+    public get isOutput(): boolean {
+        return this._outputs.length === 0;
+    }
+
+    /**
+     * @returns the class name of the block
+     */
+    public getClassName(): string {
+        // Note that we use a static property instead of doing this.constructor.name to avoid problems with minifiers that would change the name of the class
+        return (this.constructor as typeof BaseBlock).ClassName;
+    }
+
+    /**
+     * Checks if the block is an "ancestor" of another giving block.
+     * @param block - Defines the block to check against
+     * @returns True if the block is an ancestor of the given block, otherwise false
+     */
+    public isAnAncestorOf(block: BaseBlock): boolean {
+        for (const output of this._outputs) {
+            if (!output.endpoints.length) {
+                continue;
+            }
+
+            for (const endpoint of output.endpoints) {
+                if (endpoint.ownerBlock === block) {
+                    return true;
+                }
+                if (endpoint.ownerBlock.isAnAncestorOf(block)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    protected _visitInputs<T extends object>(extraData: T, callback: BlockVisitor<T>, alreadyVisited: Set<BaseBlock>): void {
+        for (const input of this.inputs) {
+            if (!input.connectedTo) {
+                continue;
+            }
+
+            const block = input.connectedTo.ownerBlock;
+
+            block.visit(extraData, callback, alreadyVisited);
+        }
+    }
+
+    /**
+     * Visits the block and its inputs recursively.
+     * When starting from the smart filter output block, this will visit all the blocks in the smart filter.
+     * Note that it's a depth first visit: the callback is called on the block AFTER visiting its inputs.
+     * @param extraData - The extra data to pass to the callback
+     * @param callback - The callback to call on each block
+     * @param alreadyVisitedBlocks  - Defines the set of blocks already visited (if not provided, a new set will be created)
+     */
+    public visit<T extends object>(extraData: T, callback: BlockVisitor<T>, alreadyVisitedBlocks?: Set<BaseBlock>): void {
+        if (!alreadyVisitedBlocks) {
+            alreadyVisitedBlocks = BaseBlock._AlreadyVisitedBlocks;
+            alreadyVisitedBlocks.clear();
+        }
+
+        if (!alreadyVisitedBlocks.has(this)) {
+            alreadyVisitedBlocks.add(this);
+
+            this._visitInputs(extraData, callback, alreadyVisitedBlocks);
+
+            callback(this, extraData);
+        }
+    }
+
+    /**
+     * Finds the input connection point with the given name.
+     * @param name - Name of the input to find
+     * @returns The connection point with the given name or null if not found
+     */
+    public findInput<U extends ConnectionPointType>(name: string): Nullable<ConnectionPoint<U>> {
+        for (const input of this._inputs) {
+            if (input.name === name) {
+                return input as ConnectionPoint<U>;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 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 disconnectFromGraph(_disconnectedConnections?: [ConnectionPoint, ConnectionPoint][]): void {}
+
+    /**
+     * Prepares the block for runtime.
+     * This is called by the smart filter just before creating the smart filter runtime, and by the optimizer.
+     */
+    public prepareForRuntime(): void {}
+
+    /**
+     * Propagates the runtime data - telling all outputs to propagate their runtime data forward through the graph
+     */
+    public propagateRuntimeData(): void {
+        for (const output of this._outputs) {
+            output.propagateRuntimeData();
+        }
+    }
+
+    /**
+     * 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 generateCommandsAndGatherInitPromises(initializationData: InitializationData, _finalOutput: boolean): void {
+        // Check if any inputs are Textures which aren't yet ready, and if so, ensure init waits for them to be ready
+        for (const input of this._inputs) {
+            if (input.type === ConnectionPointType.Texture) {
+                const texture = input.runtimeData?.value as ConnectionPointValue<ConnectionPointType.Texture>;
+                if (texture && !texture.isReady()) {
+                    const internalTexture = texture.getInternalTexture();
+                    if (internalTexture) {
+                        const textureReadyPromise = new Promise<void>((resolve, reject) => {
+                            internalTexture.onLoadedObservable.add(() => {
+                                resolve();
+                            });
+                            internalTexture.onErrorObservable.add((error) => {
+                                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                                reject(error);
+                            });
+                        });
+                        initializationData.initializationPromises.push(textureReadyPromise);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Disconnects all the inputs and outputs from the Block.
+     */
+    public disconnect(): void {
+        // Detach inputs
+        for (const input of this._inputs) {
+            input.connectedTo?.disconnectFrom(input);
+        }
+
+        // Detach outputs
+        for (const output of this._outputs) {
+            output.disconnectAllEndpoints();
+        }
+    }
+
+    /**
+     * Registers a new input connection point in the block which must have a connection before the graph can be used.
+     * @param name - Defines the name of the input connection point
+     * @param type - Defines the type of the input connection point
+     * @param defaultValue - Defines the optional default value of the input connection point to use if not connection is made
+     * @returns The new ConnectionPoint
+     * @internal
+     */
+    public _registerInput<U extends ConnectionPointType>(name: string, type: U, defaultValue: Nullable<RuntimeData<U>> = null): ConnectionPoint<U> {
+        const input = new ConnectionPoint(name, this, type, ConnectionPointDirection.Input, defaultValue);
+        this._inputs.push(input);
+        return input;
+    }
+
+    /**
+     * Registers a new input connection point in the block which doesn't require a connection because it has a default value.
+     * @param name - Defines the name of the input connection point
+     * @param type - Defines the type of the input connection point
+     * @param defaultValue - Defines the default value to use if nothing is connected to this connection point
+     * @returns The new ConnectionPointWithDefault
+     * @internal
+     */
+    public _registerOptionalInput<U extends ConnectionPointType>(name: string, type: U, defaultValue: RuntimeData<U>): ConnectionPointWithDefault<U> {
+        const input = new ConnectionPointWithDefault(name, this, type, ConnectionPointDirection.Input, defaultValue);
+        this._inputs.push(input);
+        return input;
+    }
+
+    /**
+     * Registers a new output connection point in the block.
+     * @param name - Defines the name of the output connection point
+     * @param type - Defines the type of the output connection point
+     * @returns The new output connection point
+     * @internal
+     */
+    public _registerOutput<U extends ConnectionPointType>(name: string, type: U): ConnectionPoint<U> {
+        const output = new ConnectionPoint(name, this, type, ConnectionPointDirection.Output);
+        this._outputs.push(output);
+        return output;
+    }
+
+    /**
+     * Registers a new output connection point in the block that always has runtimeData because it has a default value and doesn't allow it to be overwritten with null.
+     * @param name - Defines the name of the output connection point
+     * @param type - Defines the type of the output connection point
+     * @param initialValue - Defines the initial value of the output connection point
+     * @returns The new output connection point with a default value
+     * @internal
+     */
+    public _registerOutputWithDefault<U extends ConnectionPointType>(name: string, type: U, initialValue: RuntimeData<U>): ConnectionPointWithDefault<U> {
+        const output = new ConnectionPointWithDefault(name, this, type, ConnectionPointDirection.Output, initialValue);
+        this._outputs.push(output);
+        return output;
+    }
+
+    /**
+     * Gets the required RuntimeData for the given input, throwing with a clear message if it is null
+     * @param input - The input to get the runtime data for
+     * @returns The runtimeData or throws if it was undefined
+     */
+    protected _confirmRuntimeDataSupplied<U extends ConnectionPointType = ConnectionPointType>(input: ConnectionPoint<U>): RuntimeData<U> {
+        if (!input.runtimeData) {
+            throw new Error(`The ${ConnectionPointType[input.type]} input named "${input.name}" is missing for the ${this.getClassName()} named "${this.name}"`);
+        }
+        return input.runtimeData;
+    }
+}

package/src/blockFoundation/customAggregateBlock.ts

@@ -0,0 +1,88 @@
+/* eslint-disable import/no-internal-modules */
+import type { ThinEngine } from "core/Engines/thinEngine.js";
+import type { SmartFilterDeserializer, SerializedBlockDefinition } from "../serialization/index.js";
+import type { SmartFilter } from "../smartFilter.js";
+import { AggregateBlock } from "./aggregateBlock.js";
+import type { BaseBlock } from "./baseBlock.js";
+import type { Nullable } from "core/types.js";
+
+/**
+ * Loads a serialized Smart Filter into a block which can be used in another SmartFilter.
+ */
+export class CustomAggregateBlock extends AggregateBlock {
+    /**
+     * Creates a new CustomAggregateBlock
+     * @param smartFilter - The Smart Filter to create the block for
+     * @param engine - The ThinEngine to use
+     * @param name - The friendly name of the block
+     * @param serializedSmartFilter - The serialized SmartFilter to load into the block
+     * @param smartFilterDeserializer - The deserializer to use
+     * @returns A promise that resolves to the new CustomAggregateBlock
+     */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    public static async Create(
+        smartFilter: SmartFilter,
+        engine: ThinEngine,
+        name: string,
+        serializedSmartFilter: SerializedBlockDefinition,
+        smartFilterDeserializer: SmartFilterDeserializer
+    ): Promise<BaseBlock> {
+        const innerSmartFilter = await smartFilterDeserializer.deserialize(engine, serializedSmartFilter);
+        return new CustomAggregateBlock(smartFilter, name, serializedSmartFilter.blockType, serializedSmartFilter.namespace, innerSmartFilter, false);
+    }
+
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "CustomAggregateBlock";
+
+    private readonly _blockType: string;
+    private readonly _namespace: Nullable<string>;
+
+    /**
+     * The type of the block - used when serializing / deserializing the block, and in the editor.
+     */
+    public override get blockType(): string {
+        return this._blockType;
+    }
+
+    /**
+     * The namespace of the block, which is used to reduce name collisions between blocks and also to group blocks in the editor UI.
+     * By convention, sub namespaces are separated by a period (e.g. "Babylon.Demo.Effects").
+     */
+    public override get namespace(): Nullable<string> {
+        return this._namespace;
+    }
+
+    private constructor(smartFilter: SmartFilter, name: string, blockType: string, namespace: Nullable<string>, innerSmartFilter: SmartFilter, disableOptimization: boolean) {
+        super(smartFilter, name, disableOptimization);
+
+        this._blockType = blockType;
+        this._namespace = namespace;
+
+        const attachedBlocks = innerSmartFilter.attachedBlocks;
+        for (let index = 0; index < attachedBlocks.length; index++) {
+            const block = attachedBlocks[index];
+            if (block && block.isInput && block.outputs[0]) {
+                // If this input block is connected to anything (has any endpoints), create an input connection point for it
+                if (block.outputs[0].endpoints.length > 0) {
+                    this._registerSubfilterInput(block.name, block.outputs[0].endpoints.slice(), block.outputs[0].runtimeData ?? null);
+                }
+
+                // Remove this input block from the Smart Filter graph - this will reset the runtimeData to the
+                // default for that connection point (which may be null)
+                innerSmartFilter.removeBlock(block);
+                index--;
+            }
+        }
+
+        if (!innerSmartFilter.output.connectedTo) {
+            throw new Error("The inner smart filter must have an output connected to something");
+        }
+
+        this._registerSubfilterOutput("output", innerSmartFilter.output.connectedTo);
+
+        // Disconnect the inner Smart Filter output from the inner Smart Filter
+        innerSmartFilter.output.connectedTo.disconnectFrom(innerSmartFilter.output);
+    }
+}