@onerjs/smart-filters 8.25.0

package/src/utils/buildTools/convertGlslIntoShaderProgram.ts

@@ -0,0 +1,173 @@
+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

@@ -0,0 +1,65 @@
+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,24 @@
+/* eslint-disable no-console */
+import * as fs from "fs";
+import * as path from "path";
+
+// Get package.json path from command line argument or default to current directory
+const packageJsonDirectory = process.argv[2] || ".";
+const packageJsonFullPath = path.resolve(path.join(packageJsonDirectory, "package.json"));
+
+console.log("Reading package.json from:", packageJsonFullPath);
+
+const PackageText = fs.readFileSync(packageJsonFullPath);
+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);

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

@@ -0,0 +1,59 @@
+/**
+ * Describes a shader function.
+ */
+export type ShaderFunction = {
+    /**
+     * The name of the function.
+     */
+    name: string;
+
+    /**
+     * The code of the function.
+     */
+    code: string;
+
+    /**
+     * The parameters of the function.
+     */
+    params?: 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[];
+
+    /**
+     * The declaration of define statements.
+     */
+    defines?: string[];
+};