@babylonjs/smart-filters 0.3.16-alpha → 0.4.0-alpha

package/src/optimization/optimizedShaderBlock.ts

@@ -5,15 +5,15 @@ import type { SmartFilter } from "../smartFilter";
 import type { ShaderProgram } from "../utils/shaderCodeUtils";
 import type { RuntimeData } from "../connection/connectionPoint";
 import { ShaderBlock } from "../blocks/shaderBlock.js";
-import { Binding } from "../runtime/shaderRuntime.js";
+import { ShaderBinding } from "../runtime/shaderRuntime.js";
 import { ConnectionPointType } from "../connection/connectionPointType.js";
 
 /**
  * The shader bindings for the OptimizedShader block.
  * @internal
  */
-export class OptimizedShaderBinding extends Binding {
-    private _shaderBindings: Binding[];
+export class OptimizedShaderBinding extends ShaderBinding {
+    private _shaderBindings: ShaderBinding[];
     private _inputTextures: { [name: string]: RuntimeData<ConnectionPointType.Texture> };
 
     /**
@@ -22,7 +22,7 @@ export class OptimizedShaderBinding extends Binding {
      * @param inputTextures - The list of input textures to bind
      */
     constructor(
-        shaderBindings: Binding[],
+        shaderBindings: ShaderBinding[],
         inputTextures: { [name: string]: RuntimeData<ConnectionPointType.Texture> }
     ) {
         super();
@@ -56,7 +56,7 @@ export class OptimizedShaderBinding extends Binding {
  * @internal
  */
 export class OptimizedShaderBlock extends ShaderBlock {
-    private _shaderBindings: Nullable<Binding[]>;
+    private _shaderBindings: Nullable<ShaderBinding[]>;
     private _inputTextures: { [name: string]: RuntimeData<ConnectionPointType.Texture> } = {};
     private _shaderProgram: ShaderProgram;
 
@@ -104,7 +104,7 @@ export class OptimizedShaderBlock extends ShaderBlock {
      * Sets the list of shader bindings to use to render the block.
      * @param shaderBindings - The list of shader bindings to use to render the block
      */
-    public setShaderBindings(shaderBindings: Binding[]): void {
+    public setShaderBindings(shaderBindings: ShaderBinding[]): void {
         this._shaderBindings = shaderBindings;
     }
 
@@ -112,7 +112,7 @@ export class OptimizedShaderBlock extends ShaderBlock {
      * Get the class instance that binds all the required data to the shader (effect) when rendering.
      * @returns The class instance that binds the data to the effect
      */
-    public getShaderBinding(): Binding {
+    public getShaderBinding(): ShaderBinding {
         if (this._shaderBindings === null) {
             throw new Error("Shader bindings not set!");
         }

package/src/optimization/smartFilterOptimizer.ts

@@ -1,7 +1,7 @@
 import type { Nullable } from "@babylonjs/core/types";
 
 import type { ConnectionPoint } from "../connection/connectionPoint";
-import type { Binding } from "../runtime/shaderRuntime";
+import type { ShaderBinding } from "../runtime/shaderRuntime";
 import type { InputBlock } from "../blocks/inputBlock";
 import type { BaseBlock } from "../blocks/baseBlock";
 import { SmartFilter } from "../smartFilter.js";
@@ -9,9 +9,15 @@ import { ConnectionPointType } from "../connection/connectionPointType.js";
 import { ShaderBlock } from "../blocks/shaderBlock.js";
 import { isTextureInputBlock } from "../blocks/inputBlock.js";
 import { OptimizedShaderBlock } from "./optimizedShaderBlock.js";
-import { decorateChar, decorateSymbol, getShaderFragmentCode, undecorateSymbol } from "../utils/shaderCodeUtils.js";
+import {
+    AutoDisableMainInputColorName,
+    decorateChar,
+    decorateSymbol,
+    getShaderFragmentCode,
+    undecorateSymbol,
+} from "../utils/shaderCodeUtils.js";
 import { DependencyGraph } from "./dependencyGraph.js";
-import { DisableableBlock } from "../blocks/disableableBlock.js";
+import { DisableableShaderBlock, BlockDisableStrategy } from "../blocks/disableableShaderBlock.js";
 
 const showDebugData = false;
 
@@ -132,6 +138,9 @@ export class SmartFilterOptimizer {
                 const connectionsToReconnect: [ConnectionPoint, ConnectionPoint][] = [];
 
                 if (this._options.removeDisabledBlocks) {
+                    // Need to propagate runtime data to ensure we can tell if a block is disabled
+                    this._sourceSmartFilter.output.ownerBlock.propagateRuntimeData();
+
                     const alreadyVisitedBlocks = new Set<BaseBlock>();
                     this._disconnectDisabledBlocks(
                         this._sourceSmartFilter.output.connectedTo.ownerBlock,
@@ -203,7 +212,7 @@ export class SmartFilterOptimizer {
             this._disconnectDisabledBlocks(input.connectedTo.ownerBlock, alreadyVisitedBlocks, inputsToReconnect);
         }
 
-        if (block instanceof DisableableBlock && block.disabled.runtimeData.value) {
+        if (block instanceof DisableableShaderBlock && block.disabled.runtimeData.value) {
             block.disconnectFromGraph(inputsToReconnect);
         }
     }
@@ -508,6 +517,14 @@ export class SmartFilterOptimizer {
                     throw `The connection point corresponding to the input named "${samplerName}" in block named "${block.name}" is not connected!`;
                 }
 
+                // If we are using the AutoSample strategy, we must preprocess the code that samples the texture
+                if (
+                    block instanceof DisableableShaderBlock &&
+                    block.blockDisableStrategy === BlockDisableStrategy.AutoSample
+                ) {
+                    code = this._applyAutoSampleStrategy(code, sampler);
+                }
+
                 const parentBlock = input.connectedTo.ownerBlock;
 
                 if (isTextureInputBlock(parentBlock)) {
@@ -629,7 +646,7 @@ export class SmartFilterOptimizer {
         });
 
         // Sets the remapping of the shader variables
-        const blockOwnerToShaderBinding = new Map<ShaderBlock, Binding>();
+        const blockOwnerToShaderBinding = new Map<ShaderBlock, ShaderBinding>();
 
         let codeUniforms = "";
         let codeConsts = "";
@@ -703,4 +720,25 @@ export class SmartFilterOptimizer {
 
         return optimizedBlock;
     }
+
+    /**
+     * If this block used DisableStrategy.AutoSample, find all the sampleTexture calls which just pass the vUV,
+     * skip the first one, and for all others replace with the local variable created by the DisableStrategy.AutoSample
+     *
+     * @param code - The shader code to process
+     * @param sampler - The name of the sampler
+     *
+     * @returns The processed code
+     */
+    private _applyAutoSampleStrategy(code: string, sampler: string): string {
+        let isFirstMatch = true;
+        const rx = new RegExp(`sampleTexture\\s*\\(\\s*${sampler}\\s*,\\s*vUV\\s*\\)`, "g");
+        return code.replace(rx, (match) => {
+            if (isFirstMatch) {
+                isFirstMatch = false;
+                return match;
+            }
+            return decorateSymbol(AutoDisableMainInputColorName);
+        });
+    }
 }

package/src/runtime/shaderRuntime.ts

@@ -7,15 +7,16 @@ import { EffectWrapper } from "@babylonjs/core/Materials/effectRenderer.js";
 import type { IDisposable } from "../IDisposable";
 import type { ShaderProgram } from "../utils/shaderCodeUtils";
 import { createStrongRef, type StrongRef } from "./strongRef.js";
-import type { IDisableableBlock } from "../blocks/disableableBlock";
-import { decorateSymbol, getShaderCreateOptions } from "../utils/shaderCodeUtils.js";
+import type { IDisableableBlock } from "../blocks/disableableShaderBlock";
+import { decorateSymbol, DisableUniform, getShaderCreateOptions } from "../utils/shaderCodeUtils.js";
 
 /**
  * The shader bindings for a ShaderBlock that can't be disabled.
  */
-export abstract class Binding {
+export abstract class ShaderBinding {
     /**
      * Binds all the required data to the shader when rendering.
+     * Overridden by derived classes.
      * @param effect - defines the effect to bind the data to
      * @param width - defines the width of the output
      * @param height - defines the height of the output
@@ -47,7 +48,7 @@ export abstract class Binding {
 /**
  * The shader bindings for a disableable ShaderBlock.
  */
-export abstract class ShaderBinding extends Binding {
+export abstract class DisableableShaderBinding extends ShaderBinding {
     private _disabled: StrongRef<boolean>;
 
     /**
@@ -66,7 +67,7 @@ export abstract class ShaderBinding extends Binding {
      * @param _height - defines the height of the output
      */
     public bind(effect: Effect, _width?: number, _height?: number): void {
-        effect.setBool(this.getRemappedName("disabled"), this._disabled.value);
+        effect.setBool(this.getRemappedName(DisableUniform), this._disabled.value);
     }
 }
 
@@ -88,7 +89,7 @@ export class ShaderRuntime implements IDisposable {
     private readonly _engine: AbstractEngine;
     private readonly _effectRenderer: EffectRenderer;
     private readonly _effectWrapper: EffectWrapper;
-    private readonly _shaderBinding: Binding;
+    private readonly _shaderBinding: ShaderBinding;
 
     /**
      * Creates a new @see ShaderRuntime.
@@ -96,7 +97,7 @@ export class ShaderRuntime implements IDisposable {
      * @param shaderProgram - defines the shader code associated with this runtime
      * @param shaderBinding - defines the shader bindings associated with this runtime
      */
-    constructor(effectRenderer: EffectRenderer, shaderProgram: ShaderProgram, shaderBinding: Binding) {
+    constructor(effectRenderer: EffectRenderer, shaderProgram: ShaderProgram, shaderBinding: ShaderBinding) {
         this._engine = effectRenderer.engine;
         this._effectRenderer = effectRenderer;
         this._shaderBinding = shaderBinding;

package/src/utils/buildTools/shaderConverter.ts

@@ -36,8 +36,7 @@ const ShaderTemplate = `import type { ShaderProgram } from "${TYPE_IMPORT_PATH}"
 export const shaderProgram: ShaderProgram = {
     vertex: ${VERTEX_SHADER},
     fragment: {
-        uniform: \`${UNIFORMS}
-            uniform bool _disabled_;\`,${CONSTS_PROPERTY}
+        uniform: \`${UNIFORMS}\`,${CONSTS_PROPERTY}
         mainInputTexture: "${MAIN_INPUT_NAME}",
         mainFunctionName: "${MAIN_FUNCTION_NAME}",
         functions: [${FUNCTIONS}
@@ -206,7 +205,7 @@ function processFragmentShaderV1(fragmentShader: string): FragmentShaderInfo {
     const mainInputName = mainInputs[0];
 
     // Extract all the functions
-    const { extractedFunctions, mainFunctionName } = extractFunctions(fragmentShaderWithRenamedSymbols, mainInputName);
+    const { extractedFunctions, mainFunctionName } = extractFunctions(fragmentShaderWithRenamedSymbols);
 
     return {
         finalUniforms,
@@ -234,13 +233,9 @@ 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,
-    mainInputName: string
-): {
+function extractFunctions(fragment: string): {
     /**
      * The extracted functions
      */
@@ -276,15 +271,10 @@ function extractFunctions(
             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(body, CodeLinePrefix)
+                    addLinePrefixes(functionBody, CodeLinePrefix)
                 )
             );
             if (isMainFunction) {
@@ -334,6 +324,10 @@ function processFunctionBody(functionBody: string): {
 
     const isMainFunction = functionBody.includes("// main");
 
+    if (isMainFunction) {
+        functionBody = functionBody.replace("// main", "");
+    }
+
     return { functionBody, functionName, isMainFunction };
 }
 

package/src/utils/shaderCodeUtils.ts

@@ -46,7 +46,7 @@ export type ShaderCode = {
     mainFunctionName: string;
 
     /**
-     * The name of the main input texture.
+     * The name of the input texture which is passed through if the block is disabled.
      */
     mainInputTexture?: string;
 
@@ -110,28 +110,41 @@ export type ShaderCreationOptions = {
     onCompiled?: (effect: Effect) => void;
 };
 
+export const AutoDisableMainInputColorName = "autoMainInputColor";
+export const DisableUniform = "disabled";
+
 /**
- * Injects the disable uniform into a shader program.
- * @param shaderProgram - The shader program to inject the disable uniform into.
- * @returns The modified shader program
+ * Injects the disable uniform and adds a check for it at the beginning of the main function
+ * @param shaderProgram - The shader program to inject the disable feature into
  */
-export function injectDisableUniform(shaderProgram: ShaderProgram) {
+export function injectAutoSampleDisableCode(shaderProgram: ShaderProgram) {
     const shaderFragment = shaderProgram.fragment;
 
-    shaderFragment.uniform += "\nuniform bool _disabled_;";
+    // Inject the disable uniform
+    shaderFragment.uniform += `\nuniform bool ${decorateSymbol(DisableUniform)};`;
 
-    for (let i = 0; i < shaderFragment.functions.length; ++i) {
-        const func = shaderFragment.functions[i]!;
-        if (func.name === shaderFragment.mainFunctionName) {
-            func.code = func.code.replace(
-                "{",
-                `{\n    if (_disabled_) return texture2D(${shaderProgram.fragment.mainInputTexture}, vUV);\n`
-            );
-            break;
-        }
+    // Find the main function
+    const mainFunction = shaderFragment.functions.find((f) => f.name === shaderFragment.mainFunctionName);
+    if (!mainFunction) {
+        throw new Error(
+            `Main function not found when trying to inject auto disable into ${shaderFragment.mainFunctionName}`
+        );
+    }
+
+    // Ensure the shader has a main input texture
+    if (!shaderFragment.mainInputTexture) {
+        throw new Error(
+            `Main input texture not found when trying to inject auto disable into ${shaderFragment.mainFunctionName}`
+        );
     }
 
-    return shaderProgram;
+    // Inject the code
+    const autoDisableVariableName = decorateSymbol(AutoDisableMainInputColorName);
+    mainFunction.code = mainFunction.code.replace(
+        "{",
+        `{\n    vec4 ${autoDisableVariableName} = texture2D(${shaderFragment.mainInputTexture}, vUV);\n
+                if (${decorateSymbol(DisableUniform)}) return ${autoDisableVariableName};\n`
+    );
 }
 
 /**

package/dist/blocks/disableableBlock.d.ts

@@ -1,30 +0,0 @@
-import type { SmartFilter } from "../smartFilter";
-import type { ConnectionPoint } from "../connection/connectionPoint";
-import { BaseBlock } from "../blocks/baseBlock.js";
-import { ConnectionPointType } from "../connection/connectionPointType.js";
-/**
- * The interface that describes the disableable block.
- */
-export interface IDisableableBlock {
-    /**
-     * The disabled connection point of the block.
-     */
-    disabled: ConnectionPoint<ConnectionPointType.Boolean>;
-}
-/**
- * A block that can be disabled.
- */
-export declare class DisableableBlock extends BaseBlock implements IDisableableBlock {
-    /**
-     * The disabled connection point of the block.
-     */
-    readonly disabled: import("../connection/connectionPointWithDefault").ConnectionPointWithDefault<ConnectionPointType.Boolean>;
-    /**
-     * Instantiates a new block.
-     * @param smartFilter - Defines the smart filter the block belongs to
-     * @param name - Defines the name of the block
-     * @param disableOptimization - Defines if the block should not be optimized (default: false)
-     */
-    constructor(smartFilter: SmartFilter, name: string, disableOptimization?: boolean);
-}
-//# sourceMappingURL=disableableBlock.d.ts.map

package/dist/blocks/disableableBlock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"disableableBlock.d.ts","sourceRoot":"","sources":["../../src/blocks/disableableBlock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAClD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAErE,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAG3E;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;CAC1D;AAED;;GAEG;AACH,qBAAa,gBAAiB,SAAQ,SAAU,YAAW,iBAAiB;IACxE;;OAEG;IACH,SAAgB,QAAQ,6GAItB;IAEF;;;;;OAKG;gBACS,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,UAAQ;CAGlF"}

package/dist/blocks/disableableBlock.js

@@ -1,22 +0,0 @@
-import { BaseBlock } from "../blocks/baseBlock.js";
-import { ConnectionPointType } from "../connection/connectionPointType.js";
-import { createStrongRef } from "../runtime/strongRef.js";
-/**
- * A block that can be disabled.
- */
-export class DisableableBlock extends BaseBlock {
-    /**
-     * Instantiates a new block.
-     * @param smartFilter - Defines the smart filter the block belongs to
-     * @param name - Defines the name of the block
-     * @param disableOptimization - Defines if the block should not be optimized (default: false)
-     */
-    constructor(smartFilter, name, disableOptimization = false) {
-        super(smartFilter, name, disableOptimization);
-        /**
-         * The disabled connection point of the block.
-         */
-        this.disabled = this._registerOptionalInput("disabled", ConnectionPointType.Boolean, createStrongRef(false));
-    }
-}
-//# sourceMappingURL=disableableBlock.js.map

package/dist/blocks/disableableBlock.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"disableableBlock.js","sourceRoot":"","sources":["../../src/blocks/disableableBlock.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAC3E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAY1D;;GAEG;AACH,MAAM,OAAO,gBAAiB,SAAQ,SAAS;IAU3C;;;;;OAKG;IACH,YAAY,WAAwB,EAAE,IAAY,EAAE,mBAAmB,GAAG,KAAK;QAC3E,KAAK,CAAC,WAAW,EAAE,IAAI,EAAE,mBAAmB,CAAC,CAAC;QAhBlD;;WAEG;QACa,aAAQ,GAAG,IAAI,CAAC,sBAAsB,CAClD,UAAU,EACV,mBAAmB,CAAC,OAAO,EAC3B,eAAe,CAAC,KAAK,CAAC,CACzB,CAAC;IAUF,CAAC;CACJ"}

package/src/blocks/disableableBlock.ts

@@ -1,40 +0,0 @@
-import type { SmartFilter } from "../smartFilter";
-import type { ConnectionPoint } from "../connection/connectionPoint";
-
-import { BaseBlock } from "../blocks/baseBlock.js";
-import { ConnectionPointType } from "../connection/connectionPointType.js";
-import { createStrongRef } from "../runtime/strongRef.js";
-
-/**
- * The interface that describes the disableable block.
- */
-export interface IDisableableBlock {
-    /**
-     * The disabled connection point of the block.
-     */
-    disabled: ConnectionPoint<ConnectionPointType.Boolean>;
-}
-
-/**
- * A block that can be disabled.
- */
-export class DisableableBlock extends BaseBlock implements IDisableableBlock {
-    /**
-     * The disabled connection point of the block.
-     */
-    public readonly disabled = this._registerOptionalInput(
-        "disabled",
-        ConnectionPointType.Boolean,
-        createStrongRef(false)
-    );
-
-    /**
-     * Instantiates a new block.
-     * @param smartFilter - Defines the smart filter the block belongs to
-     * @param name - Defines the name of the block
-     * @param disableOptimization - Defines if the block should not be optimized (default: false)
-     */
-    constructor(smartFilter: SmartFilter, name: string, disableOptimization = false) {
-        super(smartFilter, name, disableOptimization);
-    }
-}