@babylonjs/smart-filters 0.4.3-alpha → 0.6.0-alpha

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

@@ -0,0 +1,63 @@
+/**
+ * ----------------------------------------------------------------------------
+ * Data Types Used For Block Serialization
+ * ----------------------------------------------------------------------------
+ */
+
+import type { AllConnectionPointTypes, ConnectionPointValue } from "../../connection/connectionPointType";
+import type { ShaderProgram } from "../../utils/shaderCodeUtils";
+
+/**
+ * The V1 definition of a serialized block. A 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 SerializedBlockDefinitionV1 = {
+    /**
+     * 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 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;
+};
+
+/**
+ * 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>;
+};

package/src/serialization/v1/defaultBlockSerializer.ts

@@ -1,5 +1,5 @@
 import type { BaseBlock } from "../../blocks/baseBlock";
-import type { ISerializedBlockV1, SerializeBlockV1 } from "./serialization.types";
+import type { ISerializedBlockV1, SerializeBlockV1 } from "./smartFilterSerialization.types";
 
 /**
  * The default V1 block serializer which can be used for any block that relies only on ConnectionPoints
@@ -11,7 +11,7 @@ export const defaultBlockSerializer: SerializeBlockV1 = (block: BaseBlock): ISer
     return {
         name: block.name,
         uniqueId: block.uniqueId,
-        className: block.getClassName(),
+        blockType: block.blockType,
         comments: block.comments,
         data: undefined,
     };

package/src/serialization/v1/index.ts

@@ -1,2 +1,2 @@
 export * from "./defaultBlockSerializer.js";
-export * from "./serialization.types.js";
+export * from "./smartFilterSerialization.types.js";

package/src/serialization/v1/{serialization.types.ts → smartFilterSerialization.types.ts}

@@ -14,8 +14,8 @@ import type { IEditorData } from "@babylonjs/shared-ui-components/nodeGraphSyste
  * V1 Serialized Smart Filter
  */
 export type SerializedSmartFilterV1 = {
-    /** The version of the serialized data */
-    version: 1;
+    /** The format version of the serialized data (not the version of the SmartFilter itself).*/
+    formatVersion: 1;
 
     /** The SmartFilter name */
     name: string;
@@ -34,7 +34,8 @@ export type SerializedSmartFilterV1 = {
 };
 
 /**
- * V1 Serialized Block
+ * V1 format of a block in a serialized Smart Filter.
+ * Not to be confused with a SerializedBlockDefinitionV1 which serializes the definition of a CustomShaderBlock.
  */
 export interface ISerializedBlockV1 {
     /** The name of the block */
@@ -43,8 +44,8 @@ export interface ISerializedBlockV1 {
     /** The unique ID of the block - correlates with the ID in the editorData for block position, etc. */
     uniqueId: number;
 
-    /** The class name of the block */
-    className: string;
+    /** The blockType of the block - used to determine how to instantiate the block during deserialization */
+    blockType: string;
 
     /** The comments for the block */
     comments: Nullable<string>;
@@ -82,13 +83,13 @@ export interface ISerializedConnectionV1 {
 export type SerializeBlockV1 = (block: BaseBlock) => ISerializedBlockV1;
 
 /**
- * A V1 block serializer
+ * A V1 serializer for blocks in a SmartFilter
  */
 export interface IBlockSerializerV1 {
-    /** The className of the block that this serializer can serialize */
-    className: string;
+    /** The blockType of the block that this serializer can serialize */
+    blockType: string;
 
-    /** The function that serializes the block */
+    /** The function that serializes the block in the Smart Filter */
     serialize: SerializeBlockV1;
 }
 
@@ -99,7 +100,7 @@ export interface IBlockSerializerV1 {
  */
 
 /**
- * A function that deserializes a block from a V1 serialized block object
+ * A function that deserializes a V1 block in a SmartFilter
  */
 export type DeserializeBlockV1 = (
     smartFilter: SmartFilter,

package/src/utils/buildTools/buildShaders.ts

@@ -5,7 +5,7 @@
  * @example node buildShaders.js <shaderPath> <importPath>
  */
 
-import { convertShaders } from "./shaderConverter.js";
+import { convertShaders } from "./convertShaderForHardcodedBlock.js";
 
 const externalArguments = process.argv.slice(2);
 if (externalArguments.length >= 2 && externalArguments[0] && externalArguments[1]) {

package/src/utils/buildTools/convertShaderForHardcodedBlock.ts

@@ -0,0 +1,149 @@
+import * as fs from "fs";
+import * as path from "path";
+import { parseFragmentShader } from "./shaderConverter.js";
+
+const TYPE_IMPORT_PATH = "@TYPE_IMPORT_PATH@";
+const VERTEX_SHADER = "@VERTEX_SHADER@";
+const UNIFORMS = "@UNIFORMS@";
+const CONSTS_VALUE = "@CONSTS@";
+const CONSTS_PROPERTY = "@CONSTS_PROPERTY@";
+const MAIN_INPUT_NAME = "@MAIN_INPUT_NAME@";
+const MAIN_FUNCTION_NAME = "@MAIN_FUNCTION_NAME@";
+const FUNCTIONS = "@FUNCTIONS@";
+const FUNCTION_NAME = "@FUNCTION_NAME@";
+const FUNCTION_CODE = "@FUNCTION_CODE@";
+const UNIFORM_NAMES = "@UNIFORM_NAMES@";
+
+const ConstsTemplate = `
+        const: \`${CONSTS_VALUE}\`,`;
+
+const FunctionTemplate = `
+            {
+                name: "${FUNCTION_NAME}",
+                code: \`
+${FUNCTION_CODE}
+                    \`,
+            },`;
+
+const CodeLinePrefix = "                    ";
+const UniformLinePrefix = "            ";
+const ConstLinePrefix = "            ";
+
+const ShaderTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}";
+
+/**
+ * The shader program for the block.
+ */
+export const shaderProgram: ShaderProgram = {
+    vertex: ${VERTEX_SHADER},
+    fragment: {
+        uniform: \`${UNIFORMS}\`,${CONSTS_PROPERTY}
+        mainInputTexture: "${MAIN_INPUT_NAME}",
+        mainFunctionName: "${MAIN_FUNCTION_NAME}",
+        functions: [${FUNCTIONS}
+        ],
+    },
+};
+
+/**
+ * The uniform names for this shader, to be used in the shader binding so
+ * that the names are always in sync.
+ */
+export const uniforms = {
+${UNIFORM_NAMES}
+};
+`;
+
+const UniformNameLinePrefix = "    ";
+
+/**
+ * Converts a single shader to a .ts file which can be imported by a hardcoded block
+ * @param fragmentShaderPath - The path to the fragment file for the shader
+ * @param importPath - The path to import the ShaderProgram type from
+ */
+export function convertShaderForHardcodedBlock(fragmentShaderPath: string, importPath: string): void {
+    console.log(`Processing fragment shader: ${fragmentShaderPath}`);
+
+    // See if there is a corresponding vertex shader
+    let vertexShader: string | undefined = undefined;
+    const vertexShaderPath = fragmentShaderPath.replace(".fragment.glsl", ".vertex.glsl");
+    if (fs.existsSync(vertexShaderPath)) {
+        vertexShader = fs.readFileSync(vertexShaderPath, "utf8");
+    }
+    if (vertexShader) {
+        console.log("Found vertex shader");
+    }
+
+    // Read the fragment shader
+    const fragmentShader = fs.readFileSync(fragmentShaderPath, "utf8");
+    const fragmentShaderInfo = parseFragmentShader(fragmentShader);
+
+    // Write the shader TS file
+    const shaderFile = fragmentShaderPath.replace(".fragment.glsl", ".shader.ts");
+    const functionsSection: string[] = [];
+    for (const shaderFunction of fragmentShaderInfo.shaderCode.functions) {
+        functionsSection.push(
+            FunctionTemplate.replace(FUNCTION_NAME, shaderFunction.name).replace(
+                FUNCTION_CODE,
+                addLinePrefixes(shaderFunction.code, CodeLinePrefix)
+            )
+        );
+    }
+    const finalContents = ShaderTemplate.replace(VERTEX_SHADER, vertexShader ? `\`${vertexShader}\`` : "undefined")
+        .replace(TYPE_IMPORT_PATH, importPath)
+        .replace(UNIFORMS, "\n" + addLinePrefixes(fragmentShaderInfo.shaderCode.uniform || "", UniformLinePrefix))
+        .replace(MAIN_FUNCTION_NAME, fragmentShaderInfo.shaderCode.mainFunctionName)
+        .replace(MAIN_INPUT_NAME, fragmentShaderInfo.shaderCode.mainInputTexture || '""')
+        .replace(
+            CONSTS_PROPERTY,
+            fragmentShaderInfo.shaderCode.const
+                ? ConstsTemplate.replace(
+                      CONSTS_VALUE,
+                      addLinePrefixes(fragmentShaderInfo.shaderCode.const, ConstLinePrefix)
+                  )
+                : ""
+        )
+        .replace(FUNCTIONS, functionsSection.join(""))
+        .replace(
+            UNIFORM_NAMES,
+            addLinePrefixes(
+                fragmentShaderInfo.uniforms.map((u) => `${u.name}: "${u.name}",`).join("\n"),
+                UniformNameLinePrefix
+            )
+        );
+
+    fs.writeFileSync(shaderFile, finalContents);
+}
+
+/**
+ * Converts .fragment.glsl and vertex.glsl file pairs into .shader.ts files which export a ShaderProgram object.
+ * @param shaderPath - The path to the .glsl files to convert.
+ * @param importPath - The path to import the ShaderProgram type from.
+ */
+export function convertShaders(shaderPath: string, importPath: string) {
+    // Get all files in the path
+    const allFiles = fs.readdirSync(shaderPath, { withFileTypes: true, recursive: true });
+
+    // Find all fragment shaders (excluding the template)
+    const fragmentShaderFiles = allFiles.filter(
+        (file) => file.isFile() && file.name.endsWith(".fragment.glsl") && !file.name.endsWith("template.fragment.glsl")
+    );
+
+    // Convert all shaders
+    for (const fragmentShaderFile of fragmentShaderFiles) {
+        convertShaderForHardcodedBlock(path.join(fragmentShaderFile.path, fragmentShaderFile.name), importPath);
+    }
+}
+
+/**
+ * Prefixes each line in the input
+ * @param input - The input string
+ * @param prefix - The prefix to add to each line
+ * @returns The input with each line prefixed
+ */
+function addLinePrefixes(input: string, prefix: string): string {
+    return input
+        .split("\n")
+        .map((line) => prefix + line)
+        .join("\n");
+}

package/src/utils/buildTools/shaderCode.types.ts

@@ -0,0 +1,49 @@
+/**
+ * Describes a shader function.
+ */
+export type ShaderFunction = {
+    /**
+     * The name of the function.
+     */
+    name: string;
+
+    /**
+     * The code of the function.
+     */
+    code: string;
+};
+
+/**
+ * Describes a shader code.
+ */
+export type ShaderCode = {
+    /**
+     * The declaration of the const variables.
+     */
+    const?: string;
+
+    /**
+     * The declaration of the uniform variables.
+     */
+    uniform?: string;
+
+    /**
+     * The declaration of the uniform variables that should be common for all ShaderBlock instances using this shader code.
+     */
+    uniformSingle?: string;
+
+    /**
+     * The name of the main function.
+     */
+    mainFunctionName: string;
+
+    /**
+     * The name of the input texture which is passed through if the block is disabled.
+     */
+    mainInputTexture?: string;
+
+    /**
+     * The list of functions used in the shader.
+     */
+    functions: ShaderFunction[];
+};