@babylonjs/smart-filters 0.2.0-alpha → 0.3.1-alpha

package/dist/utils/uniqueIdGenerator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueIdGenerator.d.ts","sourceRoot":"","sources":["../../src/utils/uniqueIdGenerator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,iBAAiB;IAC1B;;OAEG;IACH,OAAc,aAAa,SAAK;IAEhC;;OAEG;IACH,WAAkB,QAAQ,WAIzB;IAED;;;OAGG;WACW,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;CAK5D"}

package/dist/utils/uniqueIdGenerator.js

@@ -0,0 +1,27 @@
+/**
+ * Helper class used to generate IDs unique to the current session
+ */
+export class UniqueIdGenerator {
+    /**
+     * Gets a unique (relatively to the current session) Id
+     */
+    static get UniqueId() {
+        const result = this._NextUniqueId;
+        this._NextUniqueId++;
+        return result;
+    }
+    /**
+     * Ensures future generated IDs are greater than the specified value
+     * @param minimum - The minimum value that future generated IDs should be greater than
+     */
+    static EnsureIdsGreaterThan(minimum) {
+        if (this._NextUniqueId <= minimum) {
+            this._NextUniqueId = minimum + 1;
+        }
+    }
+}
+/**
+ * The next unique ID to be returned
+ */
+UniqueIdGenerator._NextUniqueId = 1;
+//# sourceMappingURL=uniqueIdGenerator.js.map

package/dist/utils/uniqueIdGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniqueIdGenerator.js","sourceRoot":"","sources":["../../src/utils/uniqueIdGenerator.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,OAAO,iBAAiB;IAM1B;;OAEG;IACI,MAAM,KAAK,QAAQ;QACtB,MAAM,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC;QAClC,IAAI,CAAC,aAAa,EAAE,CAAC;QACrB,OAAO,MAAM,CAAC;IAClB,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,oBAAoB,CAAC,OAAe;QAC9C,IAAI,IAAI,CAAC,aAAa,IAAI,OAAO,EAAE,CAAC;YAChC,IAAI,CAAC,aAAa,GAAG,OAAO,GAAG,CAAC,CAAC;QACrC,CAAC;IACL,CAAC;;AAtBD;;GAEG;AACW,+BAAa,GAAG,CAAC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@babylonjs/smart-filters",
-    "version": "0.2.0-alpha",
-    "description": "Babylon.js Smart Filter core and common block library",
+    "version": "0.3.1-alpha",
+    "description": "Babylon.js Smart Filter core",
     "author": {
         "name": "Sebastien VANDENBERGHE"
     },
@@ -24,7 +24,9 @@
     "esnext": "dist/index",
     "types": "dist/index",
     "type": "module",
-    "sideEffects": false,
+    "sideEffects": [
+        "./dist/utils/buildTools/**"
+    ],
     "repository": {
         "type": "git",
         "url": "git+https://github.com/BabylonJS/SmartFilters.git"
@@ -36,9 +38,12 @@
         "readme.md"
     ],
     "scripts": {
-        "clean": "rimraf dist && rimraf tsconfig.build.tsbuildinfo",
-        "versionUp": "node tools/versionUp.js",
-        "build": "tsc -p ./tsconfig.build.json",
+        "clean": "rimraf dist && rimraf buildTools && rimraf tsconfig.build.tsbuildinfo && rimraf ../../tsconfig.buildTools.build.tsbuildinfo",
+        "preparePublish": "node buildTools/versionUp.js --alpha",
+        "build": "npm run build:buildTools && npm run build:runTools && npm run build:core",
+        "build:core": "tsc -p ./tsconfig.build.json",
+        "build:buildTools": "tsc -p ./tsconfig.buildTools.build.json",
+        "build:runTools": "node buildTools/shaderConverter.js ./src/blocks ../utils/shaderCodeUtils",
         "watch": "tsc -p ./tsconfig.build.json --watch",
         "test": "echo \"Error: run test from the root of the monorepo\" && exit 1"
     },

package/readme.md

@@ -163,3 +163,15 @@ The overall system is trying at best to follow 3 simple rules:
 -   Be CPU efficient: for instance, we are trying to be branchless in most of our commands and we try to keep the number of commands as low as possible.
 -   Be memory efficient: no commands should allocate memory as it could trigger some garbage collection at the expense of frame loss.
 -   Be GPU efficient: the graph and texture optimizers minimize the number of "passes" required to render an image and the GPU resources used by the graph.
+
+## Requirements for GLSL code
+
+To be imported into blocks, the following requirements must be met by .glsl files:
+
+1. There must be a sampler2D uniform designed as the main input texture (the one to be passed along) if this block is disabled. It must have a comment on its line like this:
+   `// main`
+1. There must be a single main function which takes in a vec2 named vUV and returns a vec4, and it must have a comment on its line like this:
+   `// main`
+1. Any uniforms which should have the same value across all instances of the same block should have a comment on its line like this:
+   `// single`
+1. Functions must be declared with the open { on the same line as the function name

package/src/blocks/baseBlock.ts

@@ -1,12 +1,11 @@
 import type { Nullable } from "@babylonjs/core/types";
-import { UniqueIdGenerator } from "@babylonjs/core/Misc/uniqueIdGenerator.js";
-
 import { ConnectionPointType, type ConnectionPointValue } from "../connection/connectionPointType.js";
 import type { InitializationData, SmartFilter } from "../smartFilter";
 import type { ICommandOwner } from "../command/command";
 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,
@@ -38,7 +37,7 @@ export abstract class BaseBlock implements ICommandOwner {
     /**
      * Global unique id of the block (This is unique for the current session).
      */
-    public readonly uniqueId: number;
+    public uniqueId: number;
 
     /**
      * The name of the block. This is used to identify the block in the smart filter or in debug.

package/src/blocks/copyBlock.fragment.glsl

@@ -0,0 +1,5 @@
+uniform sampler2D input; // main
+
+vec4 copy(vec2 vUV) { // main
+    return texture2D(input, vUV);
+}

package/src/blocks/copyBlock.shader.ts

@@ -0,0 +1,36 @@
+import type { ShaderProgram } from "../utils/shaderCodeUtils";
+
+/**
+ * The shader program for the block.
+ */
+export const shaderProgram: ShaderProgram = {
+    vertex: undefined,
+    fragment: {
+        uniform: `
+            uniform sampler2D _input_; // main
+            uniform bool _disabled_;`,
+        mainInputTexture: "_input_",
+        mainFunctionName: "_copy_",
+        functions: [
+            {
+                name: "_copy_",
+                code: `
+                    vec4 _copy_(vec2 vUV) {
+                        if (_disabled_) return texture2D(_input_, vUV);
+                     // main
+                        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.
+ */
+export const uniforms = {
+    input: "input",
+};

package/src/blocks/copyBlock.ts

@@ -1,32 +1,11 @@
 import type { Effect } from "@babylonjs/core/Materials/effect";
 
-import type { ShaderProgram } from "../utils/shaderCodeUtils";
 import type { SmartFilter } from "../smartFilter";
 import { ConnectionPointType } from "../connection/connectionPointType.js";
 import { ShaderBlock } from "./shaderBlock.js";
 import { ShaderBinding } from "../runtime/shaderRuntime.js";
 import type { RuntimeData } from "../connection/connectionPoint";
-
-const shaderProgram: ShaderProgram = {
-    fragment: {
-        uniform: `
-            uniform sampler2D _input_;
-        `,
-
-        mainFunctionName: "_copy_",
-
-        functions: [
-            {
-                name: "_copy_",
-                code: `
-                    vec4 _copy_(vec2 vUV) {
-                        return texture2D(_input_, vUV);
-                    }
-                `,
-            },
-        ],
-    },
-};
+import { shaderProgram, uniforms } from "./copyBlock.shader.js";
 
 /**
  * The shader bindings for the Copy block.
@@ -50,7 +29,7 @@ export class CopyShaderBinding extends ShaderBinding {
      * @internal
      */
     public override bind(effect: Effect): void {
-        effect.setTexture(this.getRemappedName("input"), this._inputTexture.value);
+        effect.setTexture(this.getRemappedName(uniforms.input), this._inputTexture.value);
     }
 }
 
@@ -59,7 +38,7 @@ export class CopyShaderBinding extends ShaderBinding {
  *
  * This might be helpful to duplicate a texture if necessary.
  *
- * It simply takes a texture as input and outputs it to another texture or the main canvas.
+ * It simply takes a texture as input and outputs it to another texture or to the main canvas.
  */
 export class CopyBlock extends ShaderBlock {
     /**
@@ -91,11 +70,7 @@ export class CopyBlock extends ShaderBlock {
      * @returns The class instance that binds the data to the effect
      */
     public getShaderBinding(): ShaderBinding {
-        const input = this.input.runtimeData;
-
-        if (!input) {
-            throw new Error(`The input texture is missing for the CopyBlock named ${this.name}`);
-        }
+        const input = this._confirmRuntimeDataSupplied(this.input);
 
         return new CopyShaderBinding(this, input);
     }

package/src/blocks/inputBlock.deserializer.ts

@@ -0,0 +1,60 @@
+import { InputBlock } from "./inputBlock.js";
+import type { SerializedInputBlockData } from "./inputBlock.serialization.types.js";
+import { ConnectionPointType } from "../connection/connectionPointType.js";
+import type { SmartFilter } from "../smartFilter.js";
+import type { ISerializedBlockV1 } from "../serialization/v1/serialization.types.js";
+import { createImageTexture } from "../utils/textureLoaders.js";
+import type { ThinEngine } from "@babylonjs/core/Engines/thinEngine.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { ThinTexture } from "@babylonjs/core/Materials/Textures/thinTexture.js";
+/**
+ * V1 Input Block Deserializer
+ * @param smartFilter - The SmartFilter to deserialize the block into
+ * @param serializedBlock - The serialized block data
+ * @param engine - The ThinEngine to use for loading textures
+ * @returns A deserialized InputBlock
+ */
+export function inputBlockDeserializer(
+    smartFilter: SmartFilter,
+    serializedBlock: ISerializedBlockV1,
+    engine: ThinEngine
+) {
+    const blockData = serializedBlock.data as SerializedInputBlockData;
+
+    switch (blockData.inputType) {
+        case ConnectionPointType.Boolean:
+            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Boolean, blockData.value);
+        case ConnectionPointType.Float:
+            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Float, blockData.value);
+        case ConnectionPointType.Texture: {
+            // If information necessary to load an image was serialized, load the image
+            const texture: Nullable<ThinTexture> = blockData.url
+                ? createImageTexture(engine, blockData.url, blockData.flipY)
+                : null;
+            if (texture && blockData.anisotropicFilteringLevel !== null) {
+                texture.anisotropicFilteringLevel = blockData.anisotropicFilteringLevel;
+            }
+
+            // Create the input block
+            const inputBlock = new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Texture, texture);
+
+            // If editor data was serialized, set it on the deserialized block
+            inputBlock.editorData = {
+                url: blockData.url,
+                anisotropicFilteringLevel: blockData.anisotropicFilteringLevel,
+                flipY: blockData.flipY,
+                forcedExtension: blockData.forcedExtension,
+            };
+
+            return inputBlock;
+        }
+        case ConnectionPointType.Color3:
+            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Color3, blockData.value);
+        case ConnectionPointType.Color4:
+            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Color4, blockData.value);
+        case ConnectionPointType.Vector2:
+            return new InputBlock(smartFilter, serializedBlock.name, ConnectionPointType.Vector2, blockData.value);
+    }
+
+    throw new Error("Could not deserialize input block, unknown input type");
+}

package/src/blocks/inputBlock.serialization.types.ts

@@ -0,0 +1,95 @@
+import type { Nullable } from "@babylonjs/core/types.js";
+import type { ConnectionPointType } from "../connection/connectionPointType.js";
+import type { IColor3Like, IColor4Like, IVector2Like } from "@babylonjs/core/Maths/math.like.js";
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Texture inputs
+ */
+export type TextureInputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Texture;
+
+    /** The URL, if available, of the texture */
+    url: Nullable<string>;
+
+    /**
+     * Defines the anisotropic level to use, or default if null
+     */
+    anisotropicFilteringLevel: Nullable<number>;
+
+    /**
+     * Indicates if 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>;
+};
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Boolean inputs
+ */
+export type BooleanInputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Boolean;
+
+    /** The value of the input block */
+    value: boolean;
+};
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Float inputs
+ */
+export type FloatInputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Float;
+
+    /** The value of the input block */
+    value: number;
+};
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Color3 inputs
+ */
+export type Color3InputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Color3;
+
+    /** The value of the input block */
+    value: IColor3Like;
+};
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Color4 inputs
+ */
+export type Color4InputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Color4;
+
+    /** The value of the input block */
+    value: IColor4Like;
+};
+
+/**
+ * The data for an InputBlock for ConnectionPointType.Vector2 inputs
+ */
+export type Vector2InputBlockData = {
+    /** The type of the input block */
+    inputType: ConnectionPointType.Vector2;
+
+    /** The value of the input block */
+    value: IVector2Like;
+};
+
+/**
+ * Type union of all possible InputBlock data types
+ */
+export type SerializedInputBlockData =
+    | TextureInputBlockData
+    | BooleanInputBlockData
+    | FloatInputBlockData
+    | Color3InputBlockData
+    | Color4InputBlockData
+    | Vector2InputBlockData;

package/src/blocks/inputBlock.serializer.ts

@@ -0,0 +1,132 @@
+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";
+import type { IBlockSerializerV1 } from "../serialization/v1/serialization.types";
+
+/**
+ * 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;
+    return {
+        inputType: ConnectionPointType.Texture,
+        url: internalTexture?.url ?? null,
+        flipY: internalTexture?.invertY ?? null,
+        anisotropicFilteringLevel: internalTexture?.anisotropicFilteringLevel ?? null,
+        forcedExtension: forcedExtension !== "" ? forcedExtension : null,
+    };
+}
+
+/**
+ * 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,
+    };
+}
+
+/**
+ * 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,
+    };
+}
+
+/**
+ * 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,
+    };
+}
+
+/**
+ * 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,
+    };
+}
+
+/**
+ * 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,
+    };
+}
+
+/**
+ * The V1 serializer for an InputBlock
+ */
+export const inputBlockSerializer: IBlockSerializerV1 = {
+    className: InputBlockBase.ClassName,
+    serialize: (block: BaseBlock) => {
+        if (block.getClassName() !== InputBlockBase.ClassName) {
+            throw new Error("Was asked to serialize an unrecognized block type");
+        }
+        return {
+            name: block.name,
+            uniqueId: block.uniqueId,
+            className: InputBlockBase.ClassName,
+            comments: block.comments,
+            data: serializeInputBlockData(block as unknown as InputBlockBase),
+        };
+    },
+};

package/src/blocks/inputBlock.ts

@@ -6,6 +6,7 @@ import type { DisableableBlock } from "./disableableBlock";
 import { BaseBlock } from "../blocks/baseBlock.js";
 import { createStrongRef } from "../runtime/strongRef.js";
 import { ConnectionPointType } from "../connection/connectionPointType.js";
+import type { Nullable } from "@babylonjs/core/types";
 
 /**
  * Type predicate to check if value is a strong ref or a direct value
@@ -15,7 +16,7 @@ import { ConnectionPointType } from "../connection/connectionPointType.js";
 function isRuntimeData<U extends ConnectionPointType>(
     value: ConnectionPointValue<U> | RuntimeData<U>
 ): value is RuntimeData<U> {
-    return (value as RuntimeData<ConnectionPointType>).value !== undefined;
+    return value && (value as RuntimeData<ConnectionPointType>).value !== undefined;
 }
 
 /**
@@ -37,18 +38,56 @@ export function isDisableableBlock(block: BaseBlock): block is DisableableBlock
 }
 
 /**
- * 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.
+ * 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 class InputBlock<U extends ConnectionPointType> extends BaseBlock {
+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>;
+
+          /**
+           * 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>;
+      }
+    : {};
+
+/**
+ * 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> extends InputBlockBase {
     /**
      * The output connection point of the block.
      */
@@ -59,6 +98,11 @@ export class InputBlock<U extends ConnectionPointType> extends BaseBlock {
      */
     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;
+
     /**
      * Gets the current value of the input.
      */

package/src/index.ts

@@ -17,7 +17,7 @@ export { ConnectionPoint } from "./connection/connectionPoint.js";
 export { type RuntimeData } from "./connection/connectionPoint.js";
 
 export { BaseBlock } from "./blocks/baseBlock.js";
-export { InputBlock } from "./blocks/inputBlock.js";
+export { InputBlock, type InputBlockEditorData } from "./blocks/inputBlock.js";
 export { type AnyInputBlock } from "./blocks/inputBlock.js";
 export { ShaderBlock } from "./blocks/shaderBlock.js";
 export { AggregateBlock } from "./blocks/aggregateBlock.js";
@@ -34,3 +34,4 @@ export { SmartFilter } from "./smartFilter.js";
 
 export { SmartFilterOptimizer } from "./optimization/smartFilterOptimizer.js";
 export * from "./utils/textureLoaders.js";
+export * from "./serialization/index.js";

package/src/serialization/index.ts

@@ -0,0 +1,4 @@
+export * from "./v1/index.js";
+export * from "./serializedSmartFilter.js";
+export * from "./smartFilterDeserializer.js";
+export * from "./smartFilterSerializer.js";

package/src/serialization/serializedSmartFilter.ts

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