@babylonjs/smart-filters 0.3.0-alpha → 0.3.1-alpha

package/src/utils/buildTools/shaderConverter.ts

@@ -36,7 +36,8 @@ const ShaderTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}"
 export const shaderProgram: ShaderProgram = {
     vertex: ${VERTEX_SHADER},
     fragment: {
-        uniform: \`${UNIFORMS}\`,${CONSTS_PROPERTY}
+        uniform: \`${UNIFORMS}
+            uniform bool _disabled_;\`,${CONSTS_PROPERTY}
         mainInputTexture: "${MAIN_INPUT_NAME}",
         mainFunctionName: "${MAIN_FUNCTION_NAME}",
         functions: [${FUNCTIONS}
@@ -195,9 +196,6 @@ function processFragmentShaderV1(fragmentShader: string): FragmentShaderInfo {
     // Extract all the consts
     const finalConsts = [...fragmentShaderWithRenamedSymbols.matchAll(/^\s*(const\s.*)/gm)].map((match) => match[1]);
 
-    // Extract all the functions
-    const { extractedFunctions, mainFunctionName } = extractFunctions(fragmentShaderWithRenamedSymbols);
-
     // Find the main input
     const mainInputs = [...fragmentShaderWithRenamedSymbols.matchAll(/\S*uniform.*\s(\w*);\s*\/\/\s*main/gm)].map(
         (match) => match[1]
@@ -207,6 +205,9 @@ function processFragmentShaderV1(fragmentShader: string): FragmentShaderInfo {
     }
     const mainInputName = mainInputs[0];
 
+    // Extract all the functions
+    const { extractedFunctions, mainFunctionName } = extractFunctions(fragmentShaderWithRenamedSymbols, mainInputName);
+
     return {
         finalUniforms,
         mainFunctionName,
@@ -233,9 +234,13 @@ function addLinePrefixes(input: string, prefix: string): string {
 /**
  * Extracts all the functions from the shader
  * @param fragment - The shader code to process
+ * @param mainInputName - The name of the main input
  * @returns A list of functions
  */
-function extractFunctions(fragment: string): {
+function extractFunctions(
+    fragment: string,
+    mainInputName: string
+): {
     /**
      * The extracted functions
      */
@@ -270,10 +275,16 @@ function extractFunctions(fragment: string): {
         if (inFunction && depth === 0) {
             inFunction = false;
             const { functionBody, functionName, isMainFunction } = processFunctionBody(currentFunction);
+
+            let body = functionBody;
+            if (isMainFunction) {
+                body = functionBody.replace("{", `{\n    if (_disabled_) return texture2D(${mainInputName}, vUV);\n`);
+            }
+
             extractedFunctions.push(
                 FunctionTemplate.replace(FUNCTION_NAME, functionName).replace(
                     FUNCTION_CODE,
-                    addLinePrefixes(functionBody, CodeLinePrefix)
+                    addLinePrefixes(body, CodeLinePrefix)
                 )
             );
             if (isMainFunction) {

package/src/utils/buildTools/versionUp.ts

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import { exec, type ExecException } from "child_process";
+import { compareVersions, determineVersion, getNpmVersion, type VersionType } from "./determineVersion.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+
+const alpha = process.argv.includes("--alpha");
+const packageText = fs.readFileSync("package.json");
+const packageJSON = JSON.parse(packageText.toString());
+
+const packageName = packageJSON.name;
+console.log("Processing package:", packageName);
+console.log("Alpha flag:", alpha);
+console.log("Current package.json version:", packageJSON.version);
+
+/**
+ * Queries the NPM registry for the specified version type
+ * @param versionType - The type of version to query
+ * @param callback - The callback to call with the NPM version
+ */
+function queryNpmFeed(versionType: VersionType, callback: (npmVersion: Nullable<string>) => void) {
+    exec(`npm view ${packageName} dist-tags.${versionType}`, (err: Nullable<ExecException>, stdout) => {
+        let npmVersion = getNpmVersion(versionType, err, stdout);
+        if (npmVersion !== null) {
+            npmVersion = npmVersion.trim();
+            console.log(`NPM Registry ${versionType} version:`, npmVersion);
+        }
+        callback(npmVersion);
+    });
+}
+
+queryNpmFeed("preview", (npmPreviewVersion) => {
+    queryNpmFeed("latest", (npmLatestVersion) => {
+        let highestNpmVersion: Nullable<string> = npmLatestVersion;
+        if (npmPreviewVersion && (!highestNpmVersion || compareVersions(npmPreviewVersion, highestNpmVersion) === 1)) {
+            highestNpmVersion = npmPreviewVersion;
+        }
+
+        console.log("Highest NPM Registry version:", highestNpmVersion);
+
+        const versionToUse = determineVersion(highestNpmVersion, packageJSON.version, alpha);
+
+        console.log("Version to use:", versionToUse);
+
+        if (packageJSON.version !== versionToUse) {
+            packageJSON.version = versionToUse;
+            fs.writeFileSync("package.json", JSON.stringify(packageJSON, null, 4));
+            console.log("Version updated in package.json");
+        } else {
+            console.log("No need to update package.json");
+        }
+    });
+});

package/src/utils/textureLoaders.ts

@@ -1,5 +1,6 @@
 import { ThinTexture } from "@babylonjs/core/Materials/Textures/thinTexture.js";
 import { type ThinEngine } from "@babylonjs/core/Engines/thinEngine.js";
+import type { Nullable } from "@babylonjs/core/types";
 
 /**
  * Helper that takes in a URL to an image and returns a ThinTexture
@@ -15,14 +16,14 @@ import { type ThinEngine } from "@babylonjs/core/Engines/thinEngine.js";
 export function createImageTexture(
     engine: ThinEngine,
     url: string,
-    flipY: boolean = true,
+    flipY: Nullable<boolean> = null,
     samplingMode: number | undefined = undefined,
     forcedExtension: string | null = null
 ): ThinTexture {
     const internalTexture = engine.createTexture(
         url,
         true,
-        flipY,
+        flipY ?? true,
         null,
         samplingMode,
         null,