@babylonjs/smart-filters 1.0.12 → 8.18.0

package/src/serialization/smartFilterSerializer.ts

@@ -1,121 +1,110 @@
-import type { SmartFilter } from "../smartFilter";
-import type { BaseBlock } from "../blockFoundation/baseBlock";
-import { inputBlockSerializer } from "../blockFoundation/inputBlock.serializer.js";
-import type { ConnectionPoint } from "../connection/connectionPoint";
-import { defaultBlockSerializer } from "./v1/defaultBlockSerializer.js";
-import { OutputBlock } from "../blockFoundation/outputBlock.js";
-import type {
-    IBlockSerializerV1,
-    ISerializedBlockV1,
-    ISerializedConnectionV1,
-    SerializeBlockV1,
-    SerializedSmartFilterV1,
-} from "./v1/smartFilterSerialization.types";
-import { CustomShaderBlock } from "../blockFoundation/customShaderBlock.js";
-import { CustomAggregateBlock } from "../blockFoundation/customAggregateBlock.js";
-
-/**
- * Determines if two serialized connection points are equivalent to each other
- * @param a - The first connection point to compare
- * @param b - The second connection point to compare
- * @returns True if the connection points are equivalent, false otherwise
- */
-function serializedConnectionPointsEqual(a: ISerializedConnectionV1, b: ISerializedConnectionV1): boolean {
-    return (
-        a.inputBlock === b.inputBlock &&
-        a.inputConnectionPoint === b.inputConnectionPoint &&
-        a.outputBlock === b.outputBlock &&
-        a.outputConnectionPoint === b.outputConnectionPoint
-    );
-}
-
-/**
- * Serializes SmartFilters using the latest SmartFilter serialization version.
- * The caller passes in information necessary to serialize the blocks in the SmartFilter.
- * This allows the caller to provide custom serializers for blocks beyond the core blocks.
- */
-export class SmartFilterSerializer {
-    private readonly _blockSerializers: Map<string, SerializeBlockV1> = new Map();
-
-    /**
-     * Creates a new SmartFilterSerializer
-     * @param blocksUsingDefaultSerialization - A list of the blockType of blocks which can use default serialization (they only have ConnectionPoint properties and no constructor parameters)
-     * @param additionalBlockSerializers - An array of block serializers to use, beyond those for the core blocks
-     */
-    public constructor(blocksUsingDefaultSerialization: string[], additionalBlockSerializers: IBlockSerializerV1[]) {
-        this._blockSerializers.set(inputBlockSerializer.blockType, inputBlockSerializer.serialize);
-        this._blockSerializers.set(OutputBlock.ClassName, defaultBlockSerializer);
-        blocksUsingDefaultSerialization.forEach((block) => {
-            this._blockSerializers.set(block, defaultBlockSerializer);
-        });
-        additionalBlockSerializers.forEach((serializer) =>
-            this._blockSerializers.set(serializer.blockType, serializer.serialize)
-        );
-    }
-
-    /**
-     * Serializes a SmartFilter to a JSON object of the latest version
-     * @param smartFilter - The SmartFilter to serialize
-     * @returns The serialized SmartFilter
-     */
-    public serialize(smartFilter: SmartFilter): SerializedSmartFilterV1 {
-        const connections: ISerializedConnectionV1[] = [];
-
-        const blocks = smartFilter.attachedBlocks.map((block: BaseBlock) => {
-            // Serialize the block itself
-            const blockClassName = block.getClassName();
-            const serializeFn =
-                blockClassName === CustomShaderBlock.ClassName || blockClassName === CustomAggregateBlock.ClassName
-                    ? defaultBlockSerializer
-                    : this._blockSerializers.get(block.blockType);
-            if (!serializeFn) {
-                throw new Error(`No serializer was provided for a block of type ${block.blockType}`);
-            }
-            const serializedBlock: ISerializedBlockV1 = serializeFn(block);
-
-            // Serialize the connections to the inputs
-            block.inputs.forEach((input: ConnectionPoint) => {
-                const connectedTo = input.connectedTo;
-                if (connectedTo) {
-                    const newConnection: ISerializedConnectionV1 = {
-                        inputBlock: block.uniqueId,
-                        inputConnectionPoint: input.name,
-                        outputBlock: connectedTo.ownerBlock.uniqueId,
-                        outputConnectionPoint: connectedTo.name,
-                    };
-                    if (!connections.find((other) => serializedConnectionPointsEqual(newConnection, other))) {
-                        connections.push(newConnection);
-                    }
-                }
-            });
-
-            // Serialize the connections to the outputs
-            block.outputs.forEach((output: ConnectionPoint) => {
-                output.endpoints.forEach((input: ConnectionPoint) => {
-                    const newConnection: ISerializedConnectionV1 = {
-                        inputBlock: input.ownerBlock.uniqueId,
-                        inputConnectionPoint: input.name,
-                        outputBlock: block.uniqueId,
-                        outputConnectionPoint: output.name,
-                    };
-                    if (!connections.find((other) => serializedConnectionPointsEqual(newConnection, other))) {
-                        connections.push(newConnection);
-                    }
-                });
-            });
-
-            return serializedBlock;
-        });
-
-        return {
-            format: "smartFilter",
-            formatVersion: 1,
-            name: smartFilter.name,
-            namespace: smartFilter.namespace,
-            comments: smartFilter.comments,
-            editorData: smartFilter.editorData,
-            blocks,
-            connections,
-        };
-    }
-}
+import type { SmartFilter } from "../smartFilter.js";
+import type { BaseBlock } from "../blockFoundation/baseBlock.js";
+import { InputBlockSerializer } from "../blockFoundation/inputBlock.serializer.js";
+import type { ConnectionPoint } from "../connection/connectionPoint.js";
+import { DefaultBlockSerializer } from "./v1/defaultBlockSerializer.js";
+import { OutputBlock } from "../blockFoundation/outputBlock.js";
+import type { IBlockSerializerV1, ISerializedBlockV1, ISerializedConnectionV1, SerializeBlockV1, SerializedSmartFilterV1 } from "./v1/smartFilterSerialization.types.js";
+import { CustomShaderBlock } from "../blockFoundation/customShaderBlock.js";
+import { CustomAggregateBlock } from "../blockFoundation/customAggregateBlock.js";
+
+/**
+ * Determines if two serialized connection points are equivalent to each other
+ * @param a - The first connection point to compare
+ * @param b - The second connection point to compare
+ * @returns True if the connection points are equivalent, false otherwise
+ */
+function SerializedConnectionPointsEqual(a: ISerializedConnectionV1, b: ISerializedConnectionV1): boolean {
+    return (
+        a.inputBlock === b.inputBlock && a.inputConnectionPoint === b.inputConnectionPoint && a.outputBlock === b.outputBlock && a.outputConnectionPoint === b.outputConnectionPoint
+    );
+}
+
+/**
+ * Serializes SmartFilters using the latest SmartFilter serialization version.
+ * The caller passes in information necessary to serialize the blocks in the SmartFilter.
+ * This allows the caller to provide custom serializers for blocks beyond the core blocks.
+ */
+export class SmartFilterSerializer {
+    private readonly _blockSerializers: Map<string, SerializeBlockV1> = new Map();
+
+    /**
+     * Creates a new SmartFilterSerializer
+     * @param blocksUsingDefaultSerialization - A list of the blockType of blocks which can use default serialization (they only have ConnectionPoint properties and no constructor parameters)
+     * @param additionalBlockSerializers - An array of block serializers to use, beyond those for the core blocks
+     */
+    public constructor(blocksUsingDefaultSerialization: string[], additionalBlockSerializers: IBlockSerializerV1[]) {
+        this._blockSerializers.set(InputBlockSerializer.blockType, InputBlockSerializer.serialize);
+        this._blockSerializers.set(OutputBlock.ClassName, DefaultBlockSerializer);
+        blocksUsingDefaultSerialization.forEach((block) => {
+            this._blockSerializers.set(block, DefaultBlockSerializer);
+        });
+        additionalBlockSerializers.forEach((serializer) => this._blockSerializers.set(serializer.blockType, serializer.serialize));
+    }
+
+    /**
+     * Serializes a SmartFilter to a JSON object of the latest version
+     * @param smartFilter - The SmartFilter to serialize
+     * @returns The serialized SmartFilter
+     */
+    public serialize(smartFilter: SmartFilter): SerializedSmartFilterV1 {
+        const connections: ISerializedConnectionV1[] = [];
+
+        const blocks = smartFilter.attachedBlocks.map((block: BaseBlock) => {
+            // Serialize the block itself
+            const blockClassName = block.getClassName();
+            const serializeFn =
+                blockClassName === CustomShaderBlock.ClassName || blockClassName === CustomAggregateBlock.ClassName
+                    ? DefaultBlockSerializer
+                    : this._blockSerializers.get(block.blockType);
+            if (!serializeFn) {
+                throw new Error(`No serializer was provided for a block of type ${block.blockType}`);
+            }
+            const serializedBlock: ISerializedBlockV1 = serializeFn(block);
+
+            // Serialize the connections to the inputs
+            block.inputs.forEach((input: ConnectionPoint) => {
+                const connectedTo = input.connectedTo;
+                if (connectedTo) {
+                    const newConnection: ISerializedConnectionV1 = {
+                        inputBlock: block.uniqueId,
+                        inputConnectionPoint: input.name,
+                        outputBlock: connectedTo.ownerBlock.uniqueId,
+                        outputConnectionPoint: connectedTo.name,
+                    };
+                    if (!connections.find((other) => SerializedConnectionPointsEqual(newConnection, other))) {
+                        connections.push(newConnection);
+                    }
+                }
+            });
+
+            // Serialize the connections to the outputs
+            block.outputs.forEach((output: ConnectionPoint) => {
+                output.endpoints.forEach((input: ConnectionPoint) => {
+                    const newConnection: ISerializedConnectionV1 = {
+                        inputBlock: input.ownerBlock.uniqueId,
+                        inputConnectionPoint: input.name,
+                        outputBlock: block.uniqueId,
+                        outputConnectionPoint: output.name,
+                    };
+                    if (!connections.find((other) => SerializedConnectionPointsEqual(newConnection, other))) {
+                        connections.push(newConnection);
+                    }
+                });
+            });
+
+            return serializedBlock;
+        });
+
+        return {
+            format: "smartFilter",
+            formatVersion: 1,
+            name: smartFilter.name,
+            namespace: smartFilter.namespace,
+            comments: smartFilter.comments,
+            editorData: smartFilter.editorData,
+            blocks,
+            connections,
+        };
+    }
+}

package/src/serialization/v1/defaultBlockSerializer.ts

@@ -1,19 +1,21 @@
-import type { BaseBlock } from "../../blockFoundation/baseBlock";
-import type { ISerializedBlockV1, SerializeBlockV1 } from "./smartFilterSerialization.types";
-
-/**
- * The default V1 block serializer which can be used for any block that relies only on ConnectionPoints
- * and does not have any constructor parameters or class properties that need to be serialized.
- * @param block - The block to serialize
- * @returns The serialized block
- */
-export const defaultBlockSerializer: SerializeBlockV1 = (block: BaseBlock): ISerializedBlockV1 => {
-    return {
-        name: block.name,
-        uniqueId: block.uniqueId,
-        blockType: block.blockType,
-        namespace: block.namespace,
-        comments: block.comments,
-        data: undefined,
-    };
-};
+import { ShaderBlock } from "../../blockFoundation/shaderBlock.js";
+import type { BaseBlock } from "../../blockFoundation/baseBlock.js";
+import type { ISerializedBlockV1, SerializeBlockV1 } from "./smartFilterSerialization.types.js";
+
+/**
+ * The default V1 block serializer which can be used for any block that relies only on ConnectionPoints
+ * and does not have any constructor parameters or class properties that need to be serialized.
+ * @param block - The block to serialize
+ * @returns The serialized block
+ */
+export const DefaultBlockSerializer: SerializeBlockV1 = (block: BaseBlock): ISerializedBlockV1 => {
+    return {
+        name: block.name,
+        uniqueId: block.uniqueId,
+        blockType: block.blockType,
+        namespace: block.namespace,
+        comments: block.comments,
+        data: undefined,
+        outputTextureOptions: block instanceof ShaderBlock ? block.outputTextureOptions : undefined,
+    };
+};

package/src/serialization/v1/index.ts

@@ -1,2 +1,4 @@
-export * from "./defaultBlockSerializer.js";
-export * from "./smartFilterSerialization.types.js";
+export * from "./defaultBlockSerializer.js";
+// Back compat for when camelCase was used
+export { DefaultBlockSerializer as defaultBlockSerializer } from "./defaultBlockSerializer.js";
+export * from "./smartFilterSerialization.types.js";

package/src/serialization/v1/shaderBlockSerialization.types.ts

@@ -1,85 +1,85 @@
-/**
- * ----------------------------------------------------------------------------
- * Data Types Used For Block Serialization
- * ----------------------------------------------------------------------------
- */
-
-import type { Nullable } from "@babylonjs/core/types";
-import type { AllConnectionPointTypes, ConnectionPointValue } from "../../connection/connectionPointType";
-import type { ShaderProgram } from "../../utils/shaderCodeUtils";
-
-/**
- * The V1 definition of a serialized shader block. This block definition is loaded by a CustomShaderBlock and defines how a
- * blockType works. This should not be confused with an ISerializedBockV1, which is a serialized instance of a block in a
- * serialized SmartFilter graph. It is referenced by blockType in a serialized SmartFilter.
- */
-export type SerializedShaderBlockDefinitionV1 = {
-    /**
-     * Which type of serialized data this is.
-     */
-    format: "shaderBlockDefinition";
-
-    /**
-     * The version of the block definition format (format of the serialized data, not the version of the block definition itself).
-     */
-    formatVersion: 1;
-
-    /**
-     * The type used to refer to the block in serialized SmartFilters and in the editor UI.
-     * The application doing the deserialization will use this to instantiate the correct block definition.
-     * Block types are expected to be unique and their behavior should be semantically equivalent across implementations
-     * (their results must be similar enough that the differences are not perceivable).
-     */
-    blockType: string;
-
-    /**
-     * 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").
-     */
-    namespace: Nullable<string>;
-
-    /**
-     * The shader program for the block.
-     */
-    shaderProgram: ShaderProgram;
-
-    /**
-     * The input connection points of the block.
-     */
-    inputConnectionPoints: SerializedInputConnectionPointV1[];
-
-    /**
-     * If true, the optimizer will not attempt to optimize this block.
-     */
-    disableOptimization: boolean;
-};
-
-/**
- * Possible V1 auto bind values for input connection points.
- */
-export type InputAutoBindV1 = "outputResolution" | "outputAspectRatio";
-
-/**
- * A V1 input connection point of a serialized block definition.
- */
-export type SerializedInputConnectionPointV1<U extends AllConnectionPointTypes = AllConnectionPointTypes> = {
-    /**
-     * The name of the connection point.
-     */
-    name: string;
-
-    /**
-     * The type of the connection point.
-     */
-    type: U;
-
-    /**
-     * The optional default value of the connection point.
-     */
-    defaultValue?: ConnectionPointValue<U>;
-
-    /**
-     * If supplied, the input will be automatically bound to this value, instead of creating an input connection point.
-     */
-    autoBind?: InputAutoBindV1;
-};
+/**
+ * ----------------------------------------------------------------------------
+ * Data Types Used For Block Serialization
+ * ----------------------------------------------------------------------------
+ */
+
+import type { Nullable } from "core/types.js";
+import type { AllConnectionPointTypes, ConnectionPointValue } from "../../connection/connectionPointType.js";
+import type { ShaderProgram } from "../../utils/shaderCodeUtils.js";
+
+/**
+ * The V1 definition of a serialized shader block. This block definition is loaded by a CustomShaderBlock and defines how a
+ * blockType works. This should not be confused with an ISerializedBockV1, which is a serialized instance of a block in a
+ * serialized SmartFilter graph. It is referenced by blockType in a serialized SmartFilter.
+ */
+export type SerializedShaderBlockDefinitionV1 = {
+    /**
+     * Which type of serialized data this is.
+     */
+    format: "shaderBlockDefinition";
+
+    /**
+     * The version of the block definition format (format of the serialized data, not the version of the block definition itself).
+     */
+    formatVersion: 1;
+
+    /**
+     * The type used to refer to the block in serialized SmartFilters and in the editor UI.
+     * The application doing the deserialization will use this to instantiate the correct block definition.
+     * Block types are expected to be unique and their behavior should be semantically equivalent across implementations
+     * (their results must be similar enough that the differences are not perceivable).
+     */
+    blockType: string;
+
+    /**
+     * 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").
+     */
+    namespace: Nullable<string>;
+
+    /**
+     * The shader program for the block.
+     */
+    shaderProgram: ShaderProgram;
+
+    /**
+     * The input connection points of the block.
+     */
+    inputConnectionPoints: SerializedInputConnectionPointV1[];
+
+    /**
+     * If true, the optimizer will not attempt to optimize this block.
+     */
+    disableOptimization: boolean;
+};
+
+/**
+ * Possible V1 auto bind values for input connection points.
+ */
+export type InputAutoBindV1 = "outputResolution" | "outputAspectRatio";
+
+/**
+ * A V1 input connection point of a serialized block definition.
+ */
+export type SerializedInputConnectionPointV1<U extends AllConnectionPointTypes = AllConnectionPointTypes> = {
+    /**
+     * The name of the connection point.
+     */
+    name: string;
+
+    /**
+     * The type of the connection point.
+     */
+    type: U;
+
+    /**
+     * The optional default value of the connection point.
+     */
+    defaultValue?: ConnectionPointValue<U>;
+
+    /**
+     * If supplied, the input will be automatically bound to this value, instead of creating an input connection point.
+     */
+    autoBind?: InputAutoBindV1;
+};