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

package/dist/serialization/v1/{serialization.types.d.ts → smartFilterSerialization.types.d.ts}

@@ -12,8 +12,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;
     /** The SmartFilter comments */
@@ -26,15 +26,16 @@ export type SerializedSmartFilterV1 = {
     connections: ISerializedConnectionV1[];
 };
 /**
- * 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 */
     name: string;
     /** 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>;
     /** Block specific serialized data */
@@ -63,12 +64,12 @@ 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 function that serializes the block */
+    /** The blockType of the block that this serializer can serialize */
+    blockType: string;
+    /** The function that serializes the block in the Smart Filter */
     serialize: SerializeBlockV1;
 }
 /**
@@ -77,11 +78,11 @@ 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, serializedBlock: ISerializedBlockV1, engine: ThinEngine) => Promise<BaseBlock>;
 /**
  * A function that optionally deserializes a block from a V1 serialized block object, returning null if it cannot
  */
 export type OptionalBlockDeserializerV1 = (smartFilter: SmartFilter, serializedBlock: ISerializedBlockV1, engine: ThinEngine) => Promise<Nullable<BaseBlock>>;
-//# sourceMappingURL=serialization.types.d.ts.map
+//# sourceMappingURL=smartFilterSerialization.types.d.ts.map

package/dist/serialization/v1/smartFilterSerialization.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartFilterSerialization.types.d.ts","sourceRoot":"","sources":["../../../src/serialization/v1/smartFilterSerialization.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gFAAgF,CAAC;AAElH;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAClC,4FAA4F;IAC5F,aAAa,EAAE,CAAC,CAAC;IAEjB,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IAEb,+BAA+B;IAC/B,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE3B,0CAA0C;IAC1C,UAAU,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC;IAElC,4BAA4B;IAC5B,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAE7B,iCAAiC;IACjC,WAAW,EAAE,uBAAuB,EAAE,CAAC;CAC1C,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAC/B,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;IAEb,qGAAqG;IACrG,QAAQ,EAAE,MAAM,CAAC;IAEjB,yGAAyG;IACzG,SAAS,EAAE,MAAM,CAAC;IAElB,iCAAiC;IACjC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAE3B,qCAAqC;IACrC,IAAI,EAAE,GAAG,CAAC;CACb;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IAEpB,yDAAyD;IACzD,qBAAqB,EAAE,MAAM,CAAC;IAE9B,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAC;IAEnB,wDAAwD;IACxD,oBAAoB,EAAE,MAAM,CAAC;CAChC;AAED;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,SAAS,KAAK,kBAAkB,CAAC;AAExE;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAC/B,oEAAoE;IACpE,SAAS,EAAE,MAAM,CAAC;IAElB,iEAAiE;IACjE,SAAS,EAAE,gBAAgB,CAAC;CAC/B;AAED;;;;GAIG;AAEH;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC7B,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,kBAAkB,EACnC,MAAM,EAAE,UAAU,KACjB,OAAO,CAAC,SAAS,CAAC,CAAC;AAExB;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,CACtC,WAAW,EAAE,WAAW,EACxB,eAAe,EAAE,kBAAkB,EACnC,MAAM,EAAE,UAAU,KACjB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC"}

package/dist/serialization/v1/smartFilterSerialization.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=smartFilterSerialization.types.js.map

package/dist/serialization/v1/smartFilterSerialization.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smartFilterSerialization.types.js","sourceRoot":"","sources":["../../../src/serialization/v1/smartFilterSerialization.types.ts"],"names":[],"mappings":""}

package/dist/utils/buildTools/buildShaders.js

@@ -4,7 +4,7 @@
  * @param importPath - The path to import the converted shaders
  * @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]) {
     convertShaders(externalArguments[0], externalArguments[1]);

package/dist/utils/buildTools/buildShaders.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildShaders.js","sourceRoot":"","sources":["../../../src/utils/buildTools/buildShaders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD,MAAM,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAChD,IAAI,iBAAiB,CAAC,MAAM,IAAI,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAChF,cAAc,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/D,CAAC"}
+{"version":3,"file":"buildShaders.js","sourceRoot":"","sources":["../../../src/utils/buildTools/buildShaders.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qCAAqC,CAAC;AAErE,MAAM,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AAChD,IAAI,iBAAiB,CAAC,MAAM,IAAI,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC;IAChF,cAAc,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC/D,CAAC"}

package/dist/utils/buildTools/convertShaderForHardcodedBlock.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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 declare function convertShaderForHardcodedBlock(fragmentShaderPath: string, importPath: string): void;
+/**
+ * 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 declare function convertShaders(shaderPath: string, importPath: string): void;
+//# sourceMappingURL=convertShaderForHardcodedBlock.d.ts.map

package/dist/utils/buildTools/convertShaderForHardcodedBlock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertShaderForHardcodedBlock.d.ts","sourceRoot":"","sources":["../../../src/utils/buildTools/convertShaderForHardcodedBlock.ts"],"names":[],"mappings":"AA0DA;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,kBAAkB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAoDnG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAapE"}

package/dist/utils/buildTools/convertShaderForHardcodedBlock.js

@@ -0,0 +1,116 @@
+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, importPath) {
+    console.log(`Processing fragment shader: ${fragmentShaderPath}`);
+    // See if there is a corresponding vertex shader
+    let vertexShader = 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 = [];
+    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, importPath) {
+    // 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, prefix) {
+    return input
+        .split("\n")
+        .map((line) => prefix + line)
+        .join("\n");
+}
+//# sourceMappingURL=convertShaderForHardcodedBlock.js.map

package/dist/utils/buildTools/convertShaderForHardcodedBlock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"convertShaderForHardcodedBlock.js","sourceRoot":"","sources":["../../../src/utils/buildTools/convertShaderForHardcodedBlock.ts"],"names":[],"mappings":"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"}

package/dist/utils/buildTools/shaderCode.types.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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[];
+};
+//# sourceMappingURL=shaderCode.types.d.ts.map

package/dist/utils/buildTools/shaderCode.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaderCode.types.d.ts","sourceRoot":"","sources":["../../../src/utils/buildTools/shaderCode.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IACzB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;OAEG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;OAEG;IACH,SAAS,EAAE,cAAc,EAAE,CAAC;CAC/B,CAAC"}

package/dist/utils/buildTools/shaderCode.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shaderCode.types.js.map

package/dist/utils/buildTools/shaderCode.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shaderCode.types.js","sourceRoot":"","sources":["../../../src/utils/buildTools/shaderCode.types.ts"],"names":[],"mappings":""}

package/dist/utils/buildTools/shaderConverter.d.ts

@@ -1,13 +1,61 @@
+import type { ShaderCode } from "./shaderCode.types";
 /**
- * Converts a single shader
- * @param fragmentShaderPath - The path to the fragment file for the shader
- * @param importPath - The path to import the ShaderProgram type from
+ * Describes the supported metadata properties for a uniform
  */
-export declare function convertShader(fragmentShaderPath: string, importPath: string): void;
+export type UniformMetadataProperties = {
+    /**
+     * If supplied, the default value to use for the corresponding input connection point
+     */
+    default?: any;
+};
 /**
- * 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.
+ * Describes a uniform in a shader
  */
-export declare function convertShaders(shaderPath: string, importPath: string): void;
+export type UniformMetadata = {
+    /**
+     * The original name of the uniform (not renamed)
+     */
+    name: string;
+    /**
+     * The type string of the uniform
+     */
+    type: string;
+    /**
+     * Optional properties of the uniform
+     */
+    properties?: UniformMetadataProperties;
+};
+/**
+ * Information about a fragment shader
+ */
+export type FragmentShaderInfo = {
+    /**
+     * If supplied, the blockType to use for the block
+     */
+    blockType?: string;
+    /**
+     * If true, optimization should be disabled for this shader
+     */
+    disableOptimization?: boolean;
+    /**
+     * The shader code
+     */
+    shaderCode: ShaderCode;
+    /**
+     * The set of uniforms
+     */
+    uniforms: UniformMetadata[];
+};
+/**
+ * Parses a fragment shader
+ * @param fragmentShader - The fragment shader to process
+ * @returns The processed fragment shader
+ */
+export declare function parseFragmentShader(fragmentShader: string): FragmentShaderInfo;
+/**
+ * Determines if a fragment shader has the GLSL header required for parsing
+ * @param fragmentShader - The fragment shader to check
+ * @returns True if the fragment shader has the GLSL header
+ */
+export declare function hasGlslHeader(fragmentShader: string): boolean;
 //# sourceMappingURL=shaderConverter.d.ts.map

package/dist/utils/buildTools/shaderConverter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shaderConverter.d.ts","sourceRoot":"","sources":["../../../src/utils/buildTools/shaderConverter.ts"],"names":[],"mappings":"AA2DA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,kBAAkB,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CA2DlF;AAoPD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,QAapE"}
+{"version":3,"file":"shaderConverter.d.ts","sourceRoot":"","sources":["../../../src/utils/buildTools/shaderConverter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,oBAAoB,CAAC;AAIrE;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACpC;;OAEG;IACH,OAAO,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,UAAU,CAAC,EAAE,yBAAyB,CAAC;CAC1C,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC7B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAE9B;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IAEvB;;OAEG;IACH,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC/B,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,kBAAkB,CAsG9E;AAiMD;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAE7D"}

package/dist/utils/buildTools/shaderConverter.js

@@ -1,128 +1,62 @@
-import * as fs from "fs";
-import * as path from "path";
-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 = "    ";
 const GetFunctionNamesRegEx = /\S*\w+\s+(\w+)\s*\(/g;
 /**
- * Converts a single shader
- * @param fragmentShaderPath - The path to the fragment file for the shader
- * @param importPath - The path to import the ShaderProgram type from
- */
-export function convertShader(fragmentShaderPath, importPath) {
-    console.log(`Processing fragment shader: ${fragmentShaderPath}`);
-    // See if there is a corresponding vertex shader
-    let vertexShader = 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");
-    // Version check
-    const versionsFound = [...fragmentShader.matchAll(/\/\/\s+\[Smart Filter Shader Version\]\s*=\s*(\d+)/g)].map((match) => match[1]);
-    let version = 1;
-    if (versionsFound.length === 1 && versionsFound[0]) {
-        version = parseInt(versionsFound[0]);
-    }
-    console.log(`Shader version: ${version}`);
-    let fragmentShaderInfo;
-    switch (version) {
-        case 1:
-            {
-                fragmentShaderInfo = processFragmentShaderV1(fragmentShader);
-            }
-            break;
-        default: {
-            throw new Error(`Unsupported shader version: ${version}`);
-        }
-    }
-    // Write the shader TS file
-    const shaderFile = fragmentShaderPath.replace(".fragment.glsl", ".shader.ts");
-    const finalContents = ShaderTemplate.replace(VERTEX_SHADER, vertexShader ? `\`${vertexShader}\`` : "undefined")
-        .replace(TYPE_IMPORT_PATH, importPath)
-        .replace(UNIFORMS, "\n" + addLinePrefixes(fragmentShaderInfo.finalUniforms.join("\n"), UniformLinePrefix))
-        .replace(MAIN_FUNCTION_NAME, fragmentShaderInfo.mainFunctionName)
-        .replace(MAIN_INPUT_NAME, fragmentShaderInfo.mainInputName)
-        .replace(CONSTS_PROPERTY, fragmentShaderInfo.finalConsts.length > 0
-        ? ConstsTemplate.replace(CONSTS_VALUE, addLinePrefixes(fragmentShaderInfo.finalConsts.join("\n"), ConstLinePrefix))
-        : "")
-        .replace(FUNCTIONS, fragmentShaderInfo.extractedFunctions.join(""))
-        .replace(UNIFORM_NAMES, addLinePrefixes(fragmentShaderInfo.uniformNames.join("\n"), UniformNameLinePrefix));
-    fs.writeFileSync(shaderFile, finalContents);
-}
-/**
- * Processes a fragment shader
+ * Parses a fragment shader
  * @param fragmentShader - The fragment shader to process
  * @returns The processed fragment shader
  */
-function processFragmentShaderV1(fragmentShader) {
+export function parseFragmentShader(fragmentShader) {
+    const { header, fragmentShaderWithoutHeader } = readHeader(fragmentShader);
+    fragmentShader = fragmentShaderWithoutHeader;
+    const blockType = (header === null || header === void 0 ? void 0 : header[SmartFilterBlockTypeKey]) || undefined;
+    // Read the uniforms
+    const uniforms = [];
+    const uniformRegExp = new RegExp(/(\/\/\s*\{.*\}\n)?(uniform .*)/gm);
+    const uniformGroups = fragmentShader.matchAll(uniformRegExp);
+    for (const matches of uniformGroups) {
+        const annotationJSON = matches[1];
+        const uniformLine = matches[2];
+        if (!uniformLine) {
+            throw new Error("Uniform line not found");
+        }
+        const uniformLineMatches = new RegExp(/^uniform\s+(\w+)\s+(\w+)\s*;?/gm).exec(uniformLine);
+        if (!uniformLineMatches || uniformLineMatches.length < 3) {
+            throw new Error(`Uniforms must have a type and a name: '${uniformLine}'`);
+        }
+        const uniformTypeString = uniformLineMatches[1];
+        const uniformName = uniformLineMatches[2];
+        if (!uniformTypeString) {
+            throw new Error(`Uniforms must have a type: '${uniformLine}'`);
+        }
+        if (!uniformName) {
+            throw new Error(`Uniforms must have a name: '${uniformLine}'`);
+        }
+        uniforms.push({
+            name: uniformName,
+            type: uniformTypeString,
+            properties: annotationJSON ? JSON.parse(annotationJSON.replace("//", "").trim()) : undefined,
+        });
+        if (annotationJSON) {
+            // Strip out any annotation so it isn't mistaken for function bodies
+            fragmentShader = fragmentShader.replace(annotationJSON, "");
+        }
+    }
     const fragmentShaderWithNoFunctionBodies = removeFunctionBodies(fragmentShader);
     // Collect uniform, const, and function names which need to be decorated
     // eslint-disable-next-line prettier/prettier
-    const uniforms = [...fragmentShader.matchAll(/\S*uniform.*\s(\w*);/g)].map((match) => match[1]);
+    const uniformNames = uniforms.map((uniform) => uniform.name);
     console.log(`Uniforms found: ${JSON.stringify(uniforms)}`);
     const consts = [...fragmentShader.matchAll(/\S*const\s+\w*\s+(\w*)\s*=.*;/g)].map((match) => match[1]);
     console.log(`Consts found: ${JSON.stringify(consts)}`);
     const functionNames = [...fragmentShaderWithNoFunctionBodies.matchAll(GetFunctionNamesRegEx)].map((match) => match[1]);
     console.log(`Functions found: ${JSON.stringify(functionNames)}`);
     // Decorate the uniforms, consts, and functions
-    const symbolsToDecorate = [...uniforms, ...consts, ...functionNames];
+    const symbolsToDecorate = [...uniformNames, ...consts, ...functionNames];
     let fragmentShaderWithRenamedSymbols = fragmentShader;
     for (const symbol of symbolsToDecorate) {
         const regex = new RegExp(`(?<=\\W+)${symbol}(?=\\W+)`, "gs");
         fragmentShaderWithRenamedSymbols = fragmentShaderWithRenamedSymbols.replace(regex, `_${symbol}_`);
     }
     console.log(`${symbolsToDecorate.length} symbol(s) renamed`);
-    const uniformNames = uniforms.map((uniform) => `${uniform}: "${uniform}",`);
     // Extract all the uniforms
     const finalUniforms = [...fragmentShaderWithRenamedSymbols.matchAll(/^\s*(uniform\s.*)/gm)].map((match) => match[1]);
     // Extract all the consts
@@ -132,29 +66,24 @@ function processFragmentShaderV1(fragmentShader) {
     if (mainInputs.length !== 1 || !mainInputs[0]) {
         throw new Error("Exactly one main input must be defined in the shader");
     }
-    const mainInputName = mainInputs[0];
+    const mainInputTexture = mainInputs[0];
     // Extract all the functions
     const { extractedFunctions, mainFunctionName } = extractFunctions(fragmentShaderWithRenamedSymbols);
-    return {
-        finalUniforms,
+    const shaderCode = {
+        uniform: finalUniforms.join("\n"),
         mainFunctionName,
-        mainInputName,
-        finalConsts,
-        extractedFunctions,
-        uniformNames,
+        mainInputTexture,
+        functions: extractedFunctions,
+    };
+    if (finalConsts.length > 0) {
+        shaderCode.const = finalConsts.join("\n");
+    }
+    return {
+        blockType,
+        shaderCode,
+        uniforms,
+        disableOptimization: !!(header === null || header === void 0 ? void 0 : header.disableOptimizer),
     };
-}
-/**
- * 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, prefix) {
-    return input
-        .split("\n")
-        .map((line) => prefix + line)
-        .join("\n");
 }
 /**
  * Extracts all the functions from the shader
@@ -186,7 +115,10 @@ function extractFunctions(fragment) {
         if (inFunction && depth === 0) {
             inFunction = false;
             const { functionBody, functionName, isMainFunction } = processFunctionBody(currentFunction);
-            extractedFunctions.push(FunctionTemplate.replace(FUNCTION_NAME, functionName).replace(FUNCTION_CODE, addLinePrefixes(functionBody, CodeLinePrefix)));
+            extractedFunctions.push({
+                name: functionName,
+                code: functionBody,
+            });
             if (isMainFunction) {
                 if (mainFunctionName) {
                     throw new Error("Multiple main functions found in shader code");
@@ -251,20 +183,38 @@ function removeFunctionBodies(input) {
     }
     return output;
 }
+const SmartFilterBlockTypeKey = "smartFilterBlockType";
 /**
- * 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.
+ * Reads the GlslHeader from the shader code
+ * @param fragmentShader - The shader code to read
+ * @returns - The GlslHeader if found, otherwise null
  */
-export function convertShaders(shaderPath, importPath) {
-    // 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) {
-        convertShader(path.join(fragmentShaderFile.path, fragmentShaderFile.name), importPath);
+function readHeader(fragmentShader) {
+    const singleLineHeaderMatch = new RegExp(/^\/\/\s*(\{.*\})/gm).exec(fragmentShader);
+    if (singleLineHeaderMatch && singleLineHeaderMatch[1]) {
+        return {
+            header: JSON.parse(singleLineHeaderMatch[1].trim()),
+            fragmentShaderWithoutHeader: fragmentShader.replace(singleLineHeaderMatch[0], ""),
+        };
     }
+    const multiLineHeaderMatch = new RegExp("^\\/\\*(.*)\\*\\/", "gs").exec(fragmentShader);
+    if (multiLineHeaderMatch && multiLineHeaderMatch[1]) {
+        return {
+            header: JSON.parse(multiLineHeaderMatch[1].trim()),
+            fragmentShaderWithoutHeader: fragmentShader.replace(multiLineHeaderMatch[0], ""),
+        };
+    }
+    return {
+        header: null,
+        fragmentShaderWithoutHeader: fragmentShader,
+    };
+}
+/**
+ * Determines if a fragment shader has the GLSL header required for parsing
+ * @param fragmentShader - The fragment shader to check
+ * @returns True if the fragment shader has the GLSL header
+ */
+export function hasGlslHeader(fragmentShader) {
+    return fragmentShader.indexOf(SmartFilterBlockTypeKey) !== -1;
 }
-// TODO: simple copy from shader file to .ts, get it to build (including import trick)
 //# sourceMappingURL=shaderConverter.js.map