@onerjs/smart-filters 8.25.0

package/src/runtime/index.ts

@@ -0,0 +1,8 @@
+export { type StrongRef } from "./strongRef.js";
+export { CreateStrongRef } from "./strongRef.js";
+// Back compat for when camelCase was used
+export { CreateStrongRef as createStrongRef } from "./strongRef.js";
+export { DisableableShaderBinding, ShaderBinding, ShaderRuntime } from "./shaderRuntime.js";
+export { type SmartFilterRuntime } from "./smartFilterRuntime.js";
+export { InternalSmartFilterRuntime } from "./smartFilterRuntime.js";
+export { RenderTargetGenerator } from "./renderTargetGenerator.js";

package/src/runtime/renderTargetGenerator.ts

@@ -0,0 +1,222 @@
+import type { ThinTexture } from "core/Materials/Textures/thinTexture.js";
+import type { Nullable } from "core/types.js";
+import { ThinRenderTargetTexture } from "core/Materials/Textures/thinRenderTargetTexture.js";
+import type { RenderTargetCreationOptions } from "core/Materials/Textures/textureCreationOptions.js";
+
+import type { BaseBlock } from "../blockFoundation/baseBlock.js";
+import type { InitializationData, SmartFilter } from "../smartFilter.js";
+import type { InternalSmartFilterRuntime } from "./smartFilterRuntime.js";
+import { ShaderBlock } from "../blockFoundation/shaderBlock.js";
+import { CreateStrongRef } from "./strongRef.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import type { OutputTextureOptions } from "../blockFoundation/textureOptions.js";
+import { GetBlockOutputTextureSize } from "../utils/textureUtils.js";
+
+/**
+ * @internal
+ */
+interface IRefCountedTexture {
+    /**
+     * The texture.
+     */
+    texture: ThinTexture;
+
+    /**
+     * The reference count.
+     */
+    refCount: number;
+}
+
+/**
+ * The render target generator is responsible for creating and assigning render targets to ShaderBlocks.
+ */
+export class RenderTargetGenerator {
+    private _optimize: boolean;
+    private _renderTargetPool: Map<string, Set<IRefCountedTexture>>;
+    private _textureOptionsHashCache = new Map<ShaderBlock, string>();
+
+    private _numTargetsCreated;
+
+    /**
+     * Creates a new render target generator.
+     * @param optimize - If true, the render target generator will try to reuse render targets as much as possible.
+     */
+    constructor(optimize = true) {
+        this._optimize = optimize;
+        this._renderTargetPool = new Map();
+        this._numTargetsCreated = 0;
+    }
+
+    /**
+     * Returns the number of render targets created by the process
+     */
+    public get numTargetsCreated() {
+        return this._numTargetsCreated;
+    }
+
+    /**
+     * Sets the output textures for the ShaderBlocks of the smart filter.
+     * @param smartFilter - The smart filter to generate the render targets for.
+     * @param initializationData - The initialization data to use.
+     */
+    public setOutputTextures(smartFilter: SmartFilter, initializationData: InitializationData) {
+        smartFilter.output.ownerBlock.visit(initializationData, (block: BaseBlock, initializationData: InitializationData) => {
+            if (!(block instanceof ShaderBlock)) {
+                return;
+            }
+
+            let refCountedTexture: Nullable<IRefCountedTexture> = null;
+            const textureOptionsHash = this._getTextureOptionsHash(block);
+
+            // We assign a texture to the output of the block only if this is not the last block in the chain,
+            // i.e. not the block connected to the smart output block (in which case the output of the block is to the canvas and not a texture).
+            if (!block.output.endpoints.some((cp) => cp.ownerBlock === smartFilter.output.ownerBlock)) {
+                refCountedTexture = this._getTexture(initializationData.runtime, block.outputTextureOptions, textureOptionsHash, smartFilter);
+
+                if (!block.output.runtimeData) {
+                    const runtimeOutput = CreateStrongRef(refCountedTexture.texture);
+                    block.output.runtimeData = runtimeOutput;
+                } else {
+                    block.output.runtimeData.value = refCountedTexture.texture;
+                }
+            }
+
+            if (this._optimize) {
+                if (refCountedTexture !== null) {
+                    for (const output of block.outputs) {
+                        output.endpoints.forEach((endpoint) => {
+                            if (endpoint.connectedTo) {
+                                refCountedTexture!.refCount++;
+                            }
+                        });
+                    }
+                }
+
+                for (const input of block.inputs) {
+                    if (!input.connectedTo || input.connectedTo.type !== ConnectionPointType.Texture) {
+                        continue;
+                    }
+                    const connectedBlock = input.connectedTo.ownerBlock;
+                    if (connectedBlock instanceof ShaderBlock && connectedBlock.output.runtimeData && connectedBlock.output.runtimeData.value) {
+                        this._releaseTexture(connectedBlock.output.runtimeData.value, this._getTextureOptionsHash(connectedBlock));
+                    }
+                }
+            }
+        });
+        this._renderTargetPool.clear();
+        this._textureOptionsHashCache.clear();
+    }
+
+    private _findAvailableTexture(textureOptionsHash: string): Nullable<IRefCountedTexture> {
+        const refCountedTextures = this._renderTargetPool.get(textureOptionsHash);
+        if (!refCountedTextures) {
+            return null;
+        }
+
+        for (const refCountedTexture of refCountedTextures) {
+            if (refCountedTexture.refCount === 0) {
+                return refCountedTexture;
+            }
+        }
+
+        return null;
+    }
+
+    private _getTexture(runtime: InternalSmartFilterRuntime, textureOptions: OutputTextureOptions, textureOptionsHash: string, smartFilter: SmartFilter): IRefCountedTexture {
+        if (!this._optimize) {
+            this._numTargetsCreated++;
+            return {
+                texture: this._createTexture(runtime, smartFilter, textureOptions),
+                refCount: 0,
+            };
+        }
+
+        let refCountedTextures = this._renderTargetPool.get(textureOptionsHash);
+        if (!refCountedTextures) {
+            refCountedTextures = new Set();
+            this._renderTargetPool.set(textureOptionsHash, refCountedTextures);
+        }
+
+        let refCountedTexture = this._findAvailableTexture(textureOptionsHash);
+        if (!refCountedTexture) {
+            refCountedTexture = {
+                texture: this._createTexture(runtime, smartFilter, textureOptions),
+                refCount: 0,
+            };
+            refCountedTextures.add(refCountedTexture);
+            this._numTargetsCreated++;
+        }
+
+        return refCountedTexture;
+    }
+
+    private _releaseTexture(texture: ThinTexture, textureOptionsHash: string) {
+        if (!this._optimize) {
+            return;
+        }
+
+        const refCountedTextures = this._renderTargetPool.get(textureOptionsHash);
+        if (!refCountedTextures) {
+            throw new Error(`_releaseTexture: Trying to release a texture from a non existing pool ${textureOptionsHash}!`);
+        }
+
+        for (const refCountedTexture of refCountedTextures) {
+            if (refCountedTexture.texture === texture) {
+                refCountedTexture.refCount--;
+                return;
+            }
+        }
+
+        throw new Error(`_releaseTexture: Can't find the texture in the pool ${textureOptionsHash}!`);
+    }
+
+    /**
+     * Creates an offscreen texture to hold on the result of the block rendering.
+     * @param runtime - The current runtime we create the texture for
+     * @param smartFilter - The smart filter the texture is created for
+     * @param textureOptions - The options to use to create the texture
+     * @returns The render target texture
+     */
+    private _createTexture(runtime: InternalSmartFilterRuntime, smartFilter: SmartFilter, textureOptions: OutputTextureOptions): ThinRenderTargetTexture {
+        const engine = runtime.engine;
+
+        // We are only rendering full screen post process without depth or stencil information
+        const setup: RenderTargetCreationOptions = {
+            generateDepthBuffer: false,
+            generateStencilBuffer: false,
+            generateMipMaps: false,
+            samplingMode: 2, // Babylon Constants.TEXTURE_LINEAR_LINEAR,
+            format: textureOptions.format,
+            type: textureOptions.type,
+        };
+
+        // Get the smartFilter output size - either from the output block's renderTargetTexture or the engine's render size
+        const size = GetBlockOutputTextureSize(smartFilter, engine, textureOptions);
+
+        // Creates frame buffers for effects
+        const finalRenderTarget = new ThinRenderTargetTexture(engine, size, setup);
+        runtime.registerResource(finalRenderTarget);
+
+        // Babylon Constants.TEXTURE_CLAMP_ADDRESSMODE; NPOT Friendly
+        finalRenderTarget.wrapU = 0;
+        finalRenderTarget.wrapV = 0;
+
+        finalRenderTarget.anisotropicFilteringLevel = 1;
+
+        return finalRenderTarget;
+    }
+
+    /**
+     * Gets a textureOptionsHash for a block, using a cache to avoid recomputing it.
+     * @param block - The block to get the texture options hash for
+     * @returns The texture options hash for the block
+     */
+    private _getTextureOptionsHash(block: ShaderBlock): string {
+        let textureOptionsHash = this._textureOptionsHashCache.get(block);
+        if (textureOptionsHash === undefined) {
+            textureOptionsHash = JSON.stringify(block.outputTextureOptions);
+            this._textureOptionsHashCache.set(block, textureOptionsHash);
+        }
+        return textureOptionsHash;
+    }
+}

package/src/runtime/shaderRuntime.ts

@@ -0,0 +1,174 @@
+import type { EffectRenderer } from "core/Materials/effectRenderer.js";
+import type { RenderTargetWrapper } from "core/Engines/renderTargetWrapper.js";
+import type { AbstractEngine } from "core/Engines/abstractEngine.js";
+import type { Effect } from "core/Materials/effect.js";
+import { EffectWrapper } from "core/Materials/effectRenderer.js";
+import type { ThinRenderTargetTexture } from "core/Materials/Textures/thinRenderTargetTexture.js";
+
+import type { IDisposable } from "../IDisposable.js";
+import type { ShaderProgram } from "../utils/shaderCodeUtils.js";
+import { CreateStrongRef, type StrongRef } from "./strongRef.js";
+import type { IDisableableBlock } from "../blockFoundation/disableableShaderBlock.js";
+import { DecorateSymbol, DisableUniform, GetShaderCreateOptions } from "../utils/shaderCodeUtils.js";
+import type { OutputBlock } from "../blockFoundation/outputBlock.js";
+
+/**
+ * The shader bindings for a ShaderBlock that can't be disabled.
+ */
+export abstract class ShaderBinding {
+    /**
+     * Binds all the required data to the shader when rendering.
+     * Overridden by derived classes.
+     * @param effect - defines the effect to bind the data to
+     * @param width - defines the width of the output
+     * @param height - defines the height of the output
+     */
+    public abstract bind(effect: Effect, width?: number, height?: number): void;
+
+    private _remappedShaderVariables: { [key: string]: string } = {};
+
+    /**
+     * Gets the remapped shader variable name.
+     * @param variableName - The variable name
+     * @returns The remapped variable name
+     */
+    public getRemappedName(variableName: string) {
+        variableName = DecorateSymbol(variableName);
+        return this._remappedShaderVariables[variableName] ?? variableName;
+    }
+
+    /**
+     * Sets the remapped shader variables.
+     * @param variableName - defines the variable name to remap
+     * @param remappedName - defines the remapped name
+     */
+    public addShaderVariableRemapping(variableName: string, remappedName: string) {
+        this._remappedShaderVariables[variableName] = remappedName;
+    }
+}
+
+/**
+ * The shader bindings for a disableable ShaderBlock.
+ */
+export abstract class DisableableShaderBinding extends ShaderBinding {
+    private _disabled: StrongRef<boolean>;
+
+    /**
+     * Construct a ShaderBinding instance.
+     * @param parentBlock - The parent block
+     */
+    constructor(parentBlock: IDisableableBlock) {
+        super();
+        this._disabled = parentBlock.disabled?.runtimeData || CreateStrongRef(false);
+    }
+
+    /**
+     * Binds all the required data to the shader when rendering.
+     * @param effect - defines the effect to bind the data to
+     * @param _width - defines the width of the output
+     * @param _height - defines the height of the output
+     */
+    public bind(effect: Effect, _width?: number, _height?: number): void {
+        effect.setBool(this.getRemappedName(DisableUniform), this._disabled.value);
+    }
+}
+
+/**
+ * The shader runtime is the base for any runtime associated with a @see ShaderBlock.
+ *
+ * It encapsulates the basic needs to render a full screen effect mainly the effect wrapper holding on the shader program.
+ *
+ * It is able to either render to a texture or directly to the main canvas.
+ *
+ * It also manages the disposal of the effect wrapper.
+ */
+export class ShaderRuntime implements IDisposable {
+    /**
+     * Promise that resolves when the effect is ready to be used.
+     */
+    public readonly onReadyAsync: Promise<void>;
+
+    private readonly _engine: AbstractEngine;
+    private readonly _effectRenderer: EffectRenderer;
+    private readonly _effectWrapper: EffectWrapper;
+    private readonly _shaderBinding: ShaderBinding;
+
+    /**
+     * Creates a new @see ShaderRuntime.
+     * @param effectRenderer - defines the effect renderer to use to render the full screen effect
+     * @param shaderProgram - defines the shader code associated with this runtime
+     * @param shaderBinding - defines the shader bindings associated with this runtime
+     */
+    constructor(effectRenderer: EffectRenderer, shaderProgram: ShaderProgram, shaderBinding: ShaderBinding) {
+        this._engine = effectRenderer.engine;
+        this._effectRenderer = effectRenderer;
+        this._shaderBinding = shaderBinding;
+        this._effectWrapper = new EffectWrapper({
+            engine: this._engine,
+            ...GetShaderCreateOptions(shaderProgram),
+        });
+
+        // Wraps the effect readiness in a promise to expose it as a public property.
+        this.onReadyAsync = new Promise<void>((resolve, reject) => {
+            this._effectWrapper.effect.executeWhenCompiled(() => {
+                resolve();
+            });
+
+            this._effectWrapper.effect.onErrorObservable.addOnce((error) => {
+                // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
+                reject(error);
+            });
+        });
+    }
+
+    /**
+     * Renders the full screen effect into a render target.
+     * @param outputBlock - The output block to render to - assumes it has a .renderTargetWrapper
+     */
+    public renderToTargetWrapper(outputBlock: OutputBlock): void {
+        this._renderToTargetWrapper(outputBlock.renderTargetWrapper!);
+    }
+
+    /**
+     * Renders the full screen effect into a texture.
+     * @param renderTargetTexture - The render target texture to render into
+     */
+    public renderToTargetTexture(renderTargetTexture: ThinRenderTargetTexture): void {
+        const renderTargetWrapper = renderTargetTexture.renderTarget;
+        if (renderTargetWrapper) {
+            this._renderToTargetWrapper(renderTargetWrapper);
+        }
+    }
+
+    private _renderToTargetWrapper(renderTargetWrapper: RenderTargetWrapper): void {
+        this._engine.bindFramebuffer(renderTargetWrapper);
+        this._draw(renderTargetWrapper.width, renderTargetWrapper.height);
+        this._engine.unBindFramebuffer(renderTargetWrapper);
+    }
+
+    /**
+     * Renders the full screen effect into the main canvas.
+     */
+    public renderToCanvas(): void {
+        this._effectRenderer.setViewport();
+        this._draw(this._engine.getRenderWidth(), this._engine.getRenderHeight());
+    }
+
+    /**
+     * "Draws" the full screen effect into the currently bound output.
+     * @param width - defines the width of the output
+     * @param height - defines the height of the output
+     */
+    private _draw(width: number, height: number): void {
+        this._effectRenderer.applyEffectWrapper(this._effectWrapper);
+        this._shaderBinding.bind(this._effectWrapper.effect, width, height);
+        this._effectRenderer.draw();
+    }
+
+    /**
+     * Disposes the runtime resources.
+     */
+    public dispose(): void {
+        this._effectWrapper.dispose();
+    }
+}

package/src/runtime/smartFilterRuntime.ts

@@ -0,0 +1,112 @@
+import { EffectRenderer } from "core/Materials/effectRenderer.js";
+import type { ThinEngine } from "core/Engines/thinEngine.js";
+import { CommandBuffer } from "../command/commandBuffer.js";
+import type { IDisposable } from "../IDisposable.js";
+import type { Command } from "../command/command.js";
+
+/**
+ * A runtime is a snapshot of a smart filter containing all the
+ * required data to render it as well as the entire command buffer.
+ */
+export type SmartFilterRuntime = {
+    /**
+     * The command buffer containing all the commands to execute during a frame.
+     */
+    readonly commandBuffer: Readonly<CommandBuffer>;
+
+    /**
+     * Renders one frame of the smart filter.
+     */
+    render(): void;
+
+    /**
+     * Dispose the runtime and all its associated resources
+     */
+    dispose(): void;
+};
+
+/**
+ * The internal runtime implementation exposing more information than @see SmartFilterRuntime.
+ * This is used internally to render the smart filter.
+ *
+ * It is not fully exposed publicly to prevent any misuse of the runtime.
+ */
+export class InternalSmartFilterRuntime implements SmartFilterRuntime {
+    /**
+     * The engine used by the smart filter.
+     */
+    public readonly engine: ThinEngine;
+
+    /**
+     * The effect renderer used by the smart filter.
+     */
+    public readonly effectRenderer: EffectRenderer;
+
+    /**
+     * The command buffer containing all the commands to execute during a frame.
+     */
+    public readonly commandBuffer: CommandBuffer;
+
+    private readonly _resources: IDisposable[];
+
+    /**
+     * Instantiates a new smart filter runtime for one given engine.
+     * @param engine - the engine to use to render the smart filter
+     */
+    constructor(engine: ThinEngine) {
+        this.engine = engine;
+
+        this._resources = [];
+
+        this.commandBuffer = new CommandBuffer();
+
+        this.effectRenderer = new EffectRenderer(engine);
+        this.registerResource(this.effectRenderer);
+    }
+
+    /**
+     * Register a resource to be disposed when the runtime is disposed.
+     * @param resource - defines the resource to dispose once the runtime is disposed
+     */
+    public registerResource(resource: IDisposable): void {
+        this._resources.push(resource);
+    }
+
+    /**
+     * Registers a command to be executed during the render loop.
+     * @param command - defines the command to execute
+     */
+    public registerCommand(command: Command): void {
+        this.commandBuffer.push(command);
+    }
+
+    /**
+     * Renders the smart filter.
+     * This function will execute all the commands contained int the command buffer.
+     */
+    public render(): void {
+        try {
+            const depthTest = this.engine.depthCullingState.depthTest;
+            const stencilTest = this.engine.stencilState.stencilTest;
+
+            this.commandBuffer.execute();
+
+            // EffectRenderer.applyEffectWrapper(), which is called by ShaderRuntime._draw(),
+            // sets the depth/stencil state, so we need to restore it.
+            this.engine.depthCullingState.depthTest = depthTest;
+            this.engine.stencilState.stencilTest = stencilTest;
+        } catch (e) {
+            // eslint-disable-next-line no-debugger
+            debugger;
+        }
+    }
+
+    /**
+     * Dispose the runtime and all its associated resources
+     */
+    public dispose(): void {
+        for (const resource of this._resources) {
+            resource.dispose();
+        }
+    }
+}

package/src/runtime/strongRef.ts

@@ -0,0 +1,18 @@
+/**
+ * This describes a strong reference to any data type.
+ */
+export type StrongRef<T> = {
+    /**
+     * The value of the strong reference.
+     */
+    value: T;
+};
+
+/**
+ * Create a strong reference to the given value.
+ * @param value - the value to wrap in a strong reference
+ * @returns the strong reference containing the value
+ */
+export function CreateStrongRef<T>(value: T): StrongRef<T> {
+    return { value };
+}

package/src/serialization/importCustomBlockDefinition.ts

@@ -0,0 +1,86 @@
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import { HasGlslHeader, ParseFragmentShader } from "../utils/buildTools/shaderConverter.js";
+import type { SerializedBlockDefinition } from "./serializedBlockDefinition.js";
+import type { SerializedShaderBlockDefinition } from "./serializedShaderBlockDefinition.js";
+import type { InputAutoBindV1, SerializedInputConnectionPointV1 } from "./v1/shaderBlockSerialization.types.js";
+
+/**
+ * Imports a serialized custom block definition. Supports either serialized CustomShaderBlock definitions or
+ * CustomAggregateBlock definitions. Can throw an exception if the serialized data is invalid.
+ *
+ * CustomShaderBlock definitions can be supplied either as serialized SerializedBlockDefinition object
+ * or a glsl shader with the required annotations (see readme.md for details).
+ *
+ * CustomAggregateBlock definitions must be supplied as serialized SerializedBlockDefinition object.
+ *
+ * @param serializedData - The serialized data
+ * @returns The serialized block definition
+ */
+export function ImportCustomBlockDefinition(serializedData: string): SerializedBlockDefinition {
+    if (HasGlslHeader(serializedData)) {
+        return ImportAnnotatedGlsl(serializedData);
+    } else {
+        // Assume this is a serialized JSON object
+        const blockDefinition = JSON.parse(serializedData);
+
+        // Some old SmartFilters didn't have a format property - default to smartFilter if missing
+        if (blockDefinition.format === undefined) {
+            blockDefinition.format = "smartFilter";
+        }
+
+        // SmartFilters can be serialized without a blockType
+        // By convention, we use the SmartFilter name as the blockType when importing them as SerializedBlockDefinitions
+        if (blockDefinition.format === "smartFilter" && blockDefinition.name && !blockDefinition.blockType) {
+            blockDefinition.blockType = blockDefinition.name;
+        }
+
+        // Validation
+        if (!blockDefinition.blockType) {
+            throw new Error("Could not find a blockType");
+        }
+
+        return blockDefinition;
+    }
+}
+
+/**
+ * Converts a fragment shader .glsl file to an SerializedBlockDefinition instance for use
+ * as a CustomShaderBlock. The .glsl file must contain certain annotations to be imported.
+ * See readme.md for more information.
+ * @param fragmentShader - The contents of the .glsl fragment shader file
+ * @returns The serialized block definition
+ */
+function ImportAnnotatedGlsl(fragmentShader: string): SerializedShaderBlockDefinition {
+    const fragmentShaderInfo = ParseFragmentShader(fragmentShader);
+
+    if (!fragmentShaderInfo.blockType) {
+        throw new Error("blockType must be defined");
+    }
+
+    // Calculate the input connection points
+    const inputConnectionPoints: SerializedInputConnectionPointV1[] = [];
+    for (const uniform of fragmentShaderInfo.uniforms) {
+        // Add to input connection point list
+        const inputConnectionPoint: SerializedInputConnectionPointV1 = {
+            name: uniform.name,
+            type: uniform.type,
+            autoBind: uniform.properties?.autoBind as InputAutoBindV1,
+        };
+        if (inputConnectionPoint.type !== ConnectionPointType.Texture && uniform.properties?.default !== undefined) {
+            inputConnectionPoint.defaultValue = uniform.properties.default;
+        }
+        inputConnectionPoints.push(inputConnectionPoint);
+    }
+
+    return {
+        format: "shaderBlockDefinition",
+        formatVersion: 1,
+        blockType: fragmentShaderInfo.blockType,
+        namespace: fragmentShaderInfo.namespace,
+        shaderProgram: {
+            fragment: fragmentShaderInfo.shaderCode,
+        },
+        inputConnectionPoints,
+        disableOptimization: !!fragmentShaderInfo.disableOptimization,
+    };
+}

package/src/serialization/index.ts

@@ -0,0 +1,10 @@
+/* eslint-disable import/no-internal-modules */
+export * from "./v1/index.js";
+export * from "./serializedSmartFilter.js";
+export * from "./smartFilterDeserializer.js";
+export * from "./smartFilterSerializer.js";
+export * from "./serializedShaderBlockDefinition.js";
+export * from "./serializedBlockDefinition.js";
+export * from "./importCustomBlockDefinition.js";
+// Back compat for when camelCase was used
+export { ImportCustomBlockDefinition as importCustomBlockDefinition } from "./importCustomBlockDefinition.js";

package/src/serialization/serializedBlockDefinition.ts

@@ -0,0 +1,12 @@
+import type { SerializedShaderBlockDefinition } from "./serializedShaderBlockDefinition.js";
+import type { SerializedSmartFilter } from "./serializedSmartFilter.js";
+
+/**
+ * Type that represents any type of serialized block definition - shader or aggregate.
+ */
+export type SerializedBlockDefinition = (SerializedShaderBlockDefinition | SerializedSmartFilter) & {
+    /**
+     * The type of block this is.
+     */
+    blockType: string;
+};

package/src/serialization/serializedShaderBlockDefinition.ts

@@ -0,0 +1,7 @@
+import type { SerializedShaderBlockDefinitionV1 } from "./v1/shaderBlockSerialization.types.js";
+
+/**
+ * Type union of all versions of serialized SmartFilter block definitions
+ * A block definition is an object which is used to create a CustomShaderBlock instance.
+ */
+export type SerializedShaderBlockDefinition = SerializedShaderBlockDefinitionV1;

package/src/serialization/serializedSmartFilter.ts

@@ -0,0 +1,6 @@
+import type { SerializedSmartFilterV1 } from "./v1/smartFilterSerialization.types.js";
+
+/**
+ * Type union of all versions of serialized SmartFilters
+ */
+export type SerializedSmartFilter = SerializedSmartFilterV1;