@babylonjs/smart-filters 1.0.12 → 8.18.0

package/src/utils/buildTools/convertGlslIntoShaderProgram.ts

@@ -1,172 +1,173 @@
-import * as fs from "fs";
-import { Logger } from "@babylonjs/core/Misc/logger.js";
-import { parseFragmentShader, type FragmentShaderInfo } 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_PARAMS = "@FUNCTION_PARAMS@";
-const FUNCTION_CODE = "@FUNCTION_CODE@";
-const UNIFORM_NAMES = "@UNIFORM_NAMES@";
-const EXPORT = "@EXPORT_SHADER_PROGRAM@";
-const IMPORTS = "@IMPORT@";
-
-const ConstsTemplate = `
-        const: \`${CONSTS_VALUE}\`,`;
-
-const FunctionTemplate = `
-            {
-                name: "${FUNCTION_NAME}",
-                code: \`
-${FUNCTION_CODE}
-                    \`,
-                params: "${FUNCTION_PARAMS}",
-            },`;
-
-const CodeLinePrefix = "                    ";
-const UniformLinePrefix = "            ";
-const ConstLinePrefix = "            ";
-
-const ImportTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}";`;
-const ShaderTemplate = `${IMPORTS}
-
-/**
- * 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 exports a ShaderProgram 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 convertGlslIntoShaderProgram(fragmentShaderPath: string, importPath: string): void {
-    const { shaderProgramCode } = extractShaderProgramFromGlsl(fragmentShaderPath, importPath, true, true);
-    const shaderFile = fragmentShaderPath.replace(".glsl", ".ts");
-    fs.writeFileSync(shaderFile, shaderProgramCode);
-}
-
-/**
- * Extracts the shader program from a glsl file(s) and returns it as a string which can be written to a .ts file
- * @param fragmentShaderPath - The path to the fragment file for the shader
- * @param importPath - The path to import the ShaderProgram type from
- * @param exportObjects - Whether to export the shaderProgram and uniforms objects
- * @param includeImports - Whether to include the imports in the output
- * @returns The string to write to the .ts file
- */
-export function extractShaderProgramFromGlsl(
-    fragmentShaderPath: string,
-    importPath: string,
-    exportObjects: boolean,
-    includeImports: boolean
-): {
-    /**
-     * The shader program code
-     */
-    shaderProgramCode: string;
-
-    /**
-     * The FragmentShaderInfo
-     */
-    fragmentShaderInfo: FragmentShaderInfo;
-} {
-    // See if there is a corresponding vertex shader
-    let vertexShader: string | undefined = undefined;
-    let extensionToFind: string;
-    if (fragmentShaderPath.endsWith(".block.glsl")) {
-        extensionToFind = ".block.glsl";
-    } else if (fragmentShaderPath.endsWith(".fragment.glsl")) {
-        extensionToFind = ".fragment.glsl";
-    } else {
-        throw new Error("The shader file must end with .fragment.glsl or .block.glsl");
-    }
-    const vertexShaderPath = fragmentShaderPath.replace(extensionToFind, ".vertex.glsl");
-    if (fs.existsSync(vertexShaderPath)) {
-        vertexShader = fs.readFileSync(vertexShaderPath, "utf8");
-    }
-    if (vertexShader) {
-        Logger.Log("Found vertex shader");
-    }
-
-    // Read the fragment shader
-    const fragmentShader = fs.readFileSync(fragmentShaderPath, "utf8");
-    const fragmentShaderInfo = parseFragmentShader(fragmentShader);
-
-    // Generate the shader program code
-    const functionsSection: string[] = [];
-    for (const shaderFunction of fragmentShaderInfo.shaderCode.functions) {
-        functionsSection.push(
-            FunctionTemplate.replace(FUNCTION_NAME, shaderFunction.name)
-                .replace(FUNCTION_PARAMS, shaderFunction.params || "")
-                .replace(FUNCTION_CODE, addLinePrefixes(shaderFunction.code, CodeLinePrefix))
-        );
-    }
-    const imports = includeImports ? ImportTemplate.replace(TYPE_IMPORT_PATH, importPath) : "";
-    const finalContents = ShaderTemplate.replace(VERTEX_SHADER, vertexShader ? `\`${vertexShader}\`` : "undefined")
-        .replace(IMPORTS, imports)
-        .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
-            )
-        )
-        .replace(new RegExp(EXPORT, "g"), exportObjects ? "export " : "");
-
-    return {
-        shaderProgramCode: finalContents,
-        fragmentShaderInfo,
-    };
-}
-
-/**
- * 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");
-}
+import * as fs from "fs";
+import { Logger } from "core/Misc/logger.js";
+import { ParseFragmentShader, type FragmentShaderInfo } from "./shaderConverter.js";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const TYPE_IMPORT_PATH = "@TYPE_IMPORT_PATH@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const VERTEX_SHADER = "@VERTEX_SHADER@";
+const UNIFORMS = "@UNIFORMS@";
+const CONSTS_VALUE = "@CONSTS@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+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_PARAMS = "@FUNCTION_PARAMS@";
+const FUNCTION_CODE = "@FUNCTION_CODE@";
+const UNIFORM_NAMES = "@UNIFORM_NAMES@";
+const EXPORT = "@EXPORT_SHADER_PROGRAM@";
+const IMPORTS = "@IMPORT@";
+
+const ConstsTemplate = `
+        const: \`${CONSTS_VALUE}\`,`;
+
+const FunctionTemplate = `
+            {
+                name: "${FUNCTION_NAME}",
+                code: \`
+${FUNCTION_CODE}
+                    \`,
+                params: "${FUNCTION_PARAMS}",
+            },`;
+
+const CodeLinePrefix = "                    ";
+const UniformLinePrefix = "            ";
+const ConstLinePrefix = "            ";
+
+const ImportTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}";`;
+const ShaderTemplate = `${IMPORTS}
+
+/**
+ * The shader program for the block.
+ */
+const BlockShaderProgram: 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.
+ */
+const Uniforms = {
+${UNIFORM_NAMES}
+};
+
+${EXPORT}`;
+
+const UniformNameLinePrefix = "    ";
+
+/**
+ * Converts a single shader to a .ts file which exports a ShaderProgram 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 Smart Filters core from
+ */
+export function ConvertGlslIntoShaderProgram(fragmentShaderPath: string, importPath: string): void {
+    const { shaderProgramCode } = ExtractShaderProgramFromGlsl(fragmentShaderPath, importPath, true, true);
+    const shaderFile = fragmentShaderPath.replace(".glsl", ".ts");
+    fs.writeFileSync(shaderFile, shaderProgramCode);
+}
+
+/**
+ * Extracts the shader program from a glsl file(s) and returns it as a string which can be written to a .ts file
+ * @param fragmentShaderPath - The path to the fragment file for the shader
+ * @param smartFiltersCorePath - The path to import the Smart Filters core from
+ * @param exportObjects - Whether to export the shaderProgram and uniforms objects
+ * @param includeImports - Whether to include the imports in the output
+ * @returns The string to write to the .ts file
+ */
+export function ExtractShaderProgramFromGlsl(
+    fragmentShaderPath: string,
+    smartFiltersCorePath: string,
+    exportObjects: boolean,
+    includeImports: boolean
+): {
+    /**
+     * The shader program code
+     */
+    shaderProgramCode: string;
+
+    /**
+     * The FragmentShaderInfo
+     */
+    fragmentShaderInfo: FragmentShaderInfo;
+} {
+    // See if there is a corresponding vertex shader
+    let vertexShader: string | undefined = undefined;
+    let extensionToFind: string;
+    if (fragmentShaderPath.endsWith(".block.glsl")) {
+        extensionToFind = ".block.glsl";
+    } else if (fragmentShaderPath.endsWith(".fragment.glsl")) {
+        extensionToFind = ".fragment.glsl";
+    } else {
+        throw new Error("The shader file must end with .fragment.glsl or .block.glsl");
+    }
+    const vertexShaderPath = fragmentShaderPath.replace(extensionToFind, ".vertex.glsl");
+    if (fs.existsSync(vertexShaderPath)) {
+        vertexShader = fs.readFileSync(vertexShaderPath, "utf8");
+    }
+    if (vertexShader) {
+        Logger.Log("Found vertex shader");
+    }
+
+    // Read the fragment shader
+    const fragmentShader = fs.readFileSync(fragmentShaderPath, "utf8");
+    const fragmentShaderInfo = ParseFragmentShader(fragmentShader);
+
+    // Generate the shader program code
+    const functionsSection: string[] = [];
+    for (const shaderFunction of fragmentShaderInfo.shaderCode.functions) {
+        functionsSection.push(
+            FunctionTemplate.replace(FUNCTION_NAME, shaderFunction.name)
+                .replace(FUNCTION_PARAMS, shaderFunction.params || "")
+                .replace(FUNCTION_CODE, AddLinePrefixes(shaderFunction.code, CodeLinePrefix))
+        );
+    }
+    const imports = includeImports ? ImportTemplate.replace(TYPE_IMPORT_PATH, smartFiltersCorePath) : "";
+    const finalContents = ShaderTemplate.replace(VERTEX_SHADER, vertexShader ? `\`${vertexShader}\`` : "undefined")
+        .replace(IMPORTS, imports)
+        .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))
+        .replace(
+            new RegExp(EXPORT, "g"),
+            exportObjects
+                ? `export { BlockShaderProgram, Uniforms };
+// Back compat for when camelCase was used
+export { BlockShaderProgram as shaderProgram, Uniforms as uniforms };
+`
+                : ""
+        );
+
+    return {
+        shaderProgramCode: finalContents,
+        fragmentShaderInfo,
+    };
+}
+
+/**
+ * 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/convertShaders.ts

@@ -1,43 +1,65 @@
-import * as fs from "fs";
-import * as path from "path";
-import { Logger } from "@babylonjs/core/Misc/logger.js";
-import { convertGlslIntoShaderProgram } from "./convertGlslIntoShaderProgram.js";
-import { convertGlslIntoBlock } from "./convertGlslIntoBlock.js";
-
-/**
- * Converts all GLSL files in a path into blocks for use in the build system.
- * @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 shaders (files with .fragment.glsl or .block.glsl extensions)
-    const shaderFiles = allFiles.filter(
-        (file) => file.isFile() && (file.name.endsWith(".fragment.glsl") || file.name.endsWith(".block.glsl"))
-    );
-
-    // Convert all shaders
-    for (const shaderFile of shaderFiles) {
-        const fullPathAndFileName = path.join(shaderFile.path, shaderFile.name);
-        convertShader(fullPathAndFileName, importPath);
-    }
-}
-
-/**
- * Converts a single GLSL file into a block class or a ShaderProgram for use in the build system.
- * @param fullPathAndFileName - The full path and file name of the .glsl file to convert.
- * @param importPath - The path to import the ShaderProgram type from.
- */
-export function convertShader(fullPathAndFileName: string, importPath: string): void {
-    Logger.Log(`\nProcessing shader: ${fullPathAndFileName}`);
-
-    if (fullPathAndFileName.endsWith(".fragment.glsl")) {
-        Logger.Log("Generating a .ts file that exports a ShaderProgram.");
-        convertGlslIntoShaderProgram(fullPathAndFileName, importPath);
-    } else if (fullPathAndFileName.endsWith(".block.glsl")) {
-        Logger.Log("Generating a .ts file that exports the block as a class.");
-        convertGlslIntoBlock(fullPathAndFileName, importPath);
-    }
-}
+import * as fs from "fs";
+import * as path from "path";
+import { Logger } from "core/Misc/logger.js";
+import { ConvertGlslIntoShaderProgram } from "./convertGlslIntoShaderProgram.js";
+import { ConvertGlslIntoBlock } from "./convertGlslIntoBlock.js";
+
+/**
+ * Converts all GLSL files in a path into blocks for use in the build system.
+ * @param shaderPath - The path to the .glsl files to convert, or a single .glsl file.
+ * @param smartFiltersCorePath - The path to import the Smart Filters core from.
+ * @param babylonCorePath - The path to import the Babylon core from (optional).
+
+ */
+export function ConvertShaders(shaderPath: string, smartFiltersCorePath: string, babylonCorePath?: string) {
+    const stats = fs.statSync(shaderPath);
+
+    let shaderFiles: fs.Dirent[];
+
+    if (stats.isFile()) {
+        // If it's a file, create a Dirent-like object for consistency
+        const fileName = path.basename(shaderPath);
+        const dirPath = path.dirname(shaderPath);
+        shaderFiles = [
+            {
+                name: fileName,
+                path: dirPath,
+                isFile: () => true,
+                isDirectory: () => false,
+            } as fs.Dirent,
+        ];
+    } else if (stats.isDirectory()) {
+        // Get all files in the directory
+        const allFiles = fs.readdirSync(shaderPath, { withFileTypes: true, recursive: true });
+
+        // Find all shaders (files with .fragment.glsl or .block.glsl extensions)
+        shaderFiles = allFiles.filter((file) => file.isFile() && (file.name.endsWith(".fragment.glsl") || file.name.endsWith(".block.glsl")));
+    } else {
+        Logger.Log(`Error: ${shaderPath} is neither a file nor a directory.`);
+        return;
+    }
+
+    // Convert all shaders
+    for (const shaderFile of shaderFiles) {
+        const fullPathAndFileName = path.join(shaderFile.path, shaderFile.name);
+        ConvertShader(fullPathAndFileName, smartFiltersCorePath, babylonCorePath);
+    }
+}
+
+/**
+ * Converts a single GLSL file into a block class or a ShaderProgram for use in the build system.
+ * @param fullPathAndFileName - The full path and file name of the .glsl file to convert.
+ * @param smartFiltersCorePath - The path to import the Smart Filters core from.
+ * @param babylonCorePath - The path to import the Babylon core from (optional).
+ */
+export function ConvertShader(fullPathAndFileName: string, smartFiltersCorePath: string, babylonCorePath?: string): void {
+    Logger.Log(`\nProcessing shader: ${fullPathAndFileName}`);
+
+    if (fullPathAndFileName.endsWith(".fragment.glsl")) {
+        Logger.Log("Generating a .ts file that exports a ShaderProgram.");
+        ConvertGlslIntoShaderProgram(fullPathAndFileName, smartFiltersCorePath);
+    } else if (fullPathAndFileName.endsWith(".block.glsl")) {
+        Logger.Log("Generating a .ts file that exports the block as a class.");
+        ConvertGlslIntoBlock(fullPathAndFileName, smartFiltersCorePath, babylonCorePath);
+    }
+}

package/src/utils/buildTools/recordVersionNumber.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */
+import * as fs from "fs";
+
+const PackageText = fs.readFileSync("package.json");
+const PackageJSON = JSON.parse(PackageText.toString());
+
+const PackageName = PackageJSON.name;
+console.log("Processing package:", PackageName);
+console.log("Current package.json version:", PackageJSON.version);
+
+// Write out to version.ts
+const VersionTsText = `/**
+ * The version of the SmartFilter core. During publish, this file is overwritten by recordVersionNumber.ts with the same version that is used for the NPM publish.
+ */
+export const SmartFilterCoreVersion = "${PackageJSON.version}";\n`;
+fs.writeFileSync("src/version.ts", VersionTsText);
+console.log("Wrote version.ts with version:", PackageJSON.version);