@onerjs/smart-filters 8.25.0

package/src/smartFilter.ts

@@ -0,0 +1,255 @@
+import type { ThinEngine } from "core/Engines/thinEngine.js";
+import type { Nullable } from "core/types.js";
+import type { SmartFilterRuntime } from "./runtime/smartFilterRuntime.js";
+import type { BaseBlock } from "./blockFoundation/baseBlock.js";
+import type { ConnectionPointType } from "./connection/connectionPointType.js";
+import type { ConnectionPoint } from "./connection/connectionPoint.js";
+import { OutputBlock } from "./blockFoundation/outputBlock.js";
+import { InternalSmartFilterRuntime } from "./runtime/smartFilterRuntime.js";
+import { RenderTargetGenerator } from "./runtime/renderTargetGenerator.js";
+import { AggregateBlock } from "./blockFoundation/aggregateBlock.js";
+import type { IEditorData } from "shared-ui-components/nodeGraphSystem/interfaces/nodeLocationInfo.js";
+import type { IDisposable } from "./IDisposable.js";
+import { ShaderBlock } from "./blockFoundation/shaderBlock.js";
+import type { ThinRenderTargetTexture } from "core/Materials/Textures/thinRenderTargetTexture.js";
+import { GetBlockOutputTextureSize } from "./utils/textureUtils.js";
+
+/**
+ * How long to wait for shader compilation and texture loading to complete before erroring out.
+ */
+const InitializationTimeout = 10000;
+
+/**
+ * Data passed to the initialize function of the blocks.
+ */
+export type InitializationData = {
+    /**
+     * The current smart filter runtime the block is being initialized for.
+     */
+    readonly runtime: InternalSmartFilterRuntime;
+
+    /**
+     * The output block of the smart filter.
+     * This is used to determine if a block is linked to the output block so that we can prevent an
+     * extra render pass.
+     */
+    readonly outputBlock: OutputBlock;
+
+    /**
+     * The list of promises to wait for during the initialization step.
+     */
+    readonly initializationPromises: Promise<void>[];
+
+    /**
+     * Resources that need to be disposed when the runtime is disposed.
+     */
+    readonly disposableResources: IDisposable[];
+};
+
+/**
+ * The smart filter class is the main class of the smart filter module.
+ *
+ * It is responsible for managing a graph of smart filter blocks.
+ *
+ * It is also responsible for creating the runtime associated to the current state of the filter.
+ */
+export class SmartFilter {
+    /**
+     * The friendly name of the smart filter.
+     */
+    public readonly name: string;
+
+    /**
+     * The namespace of the smart filter.
+     */
+    public readonly namespace: Nullable<string>;
+
+    /**
+     * The smart filter output (input connection point of the output block...).
+     *
+     * This is where the smart filter final block should be connected to in order to be visible on screen.
+     */
+    public readonly output: ConnectionPoint<ConnectionPointType.Texture>;
+
+    /**
+     * The output block of the smart filter.
+     */
+    public readonly outputBlock: OutputBlock;
+
+    /**
+     * User defined comments to describe the current smart filter.
+     */
+    public comments: Nullable<string> = null;
+
+    /**
+     * Data used by the smart filter editor.
+     */
+    public editorData: Nullable<IEditorData> = null;
+
+    private readonly _attachedBlocks: Array<BaseBlock>;
+    /**
+     * Creates a new instance of a @see SmartFilter.
+     * @param name - The friendly name of the smart filter
+     * @param namespace - The namespace of the smart filter
+     */
+    constructor(name: string, namespace: Nullable<string> = null) {
+        this.name = name;
+        this.namespace = namespace;
+
+        this._attachedBlocks = new Array<BaseBlock>();
+        this.outputBlock = new OutputBlock(this);
+        this.output = this.outputBlock.input;
+    }
+
+    /**
+     * @returns the list of blocks attached to the smart filter.
+     */
+    public get attachedBlocks(): ReadonlyArray<BaseBlock> {
+        return this._attachedBlocks;
+    }
+
+    /**
+     * @returns The current class name of the smart filter.
+     */
+    public getClassName(): string {
+        return "SmartFilter";
+    }
+
+    /**
+     * Registers a block to be part of this smart filter.
+     * @param block - The block to register on the smart filter
+     * @throws if the block is already registered on another smart filter
+     * @remarks This function will not register the block if it is already registered on the smart filter.
+     */
+    public registerBlock(block: BaseBlock): void {
+        // It is impossible to attach a block from another filter
+        if (block.smartFilter !== this) {
+            throw new Error("Block is not part of this smart filter");
+        }
+
+        // No need to attach a block several times
+        if (this._attachedBlocks.indexOf(block) !== -1) {
+            return;
+        }
+
+        // Add the block to the list of attached blocks
+        this._attachedBlocks.push(block);
+    }
+
+    /**
+     * Removes the block from the smart filter.
+     * @param block - The block to remove from the smart filter
+     * @remarks This function will disconnect the block on removal.
+     * This Output block cannot be removed.
+     */
+    public removeBlock(block: BaseBlock): void {
+        const attachedBlockIndex = this._attachedBlocks.indexOf(block);
+
+        // The block can only be removed if it is not the output block
+        // and if it is attached to the smart filter
+        if (attachedBlockIndex > -1 && !block.isOutput) {
+            // Disconnects all the connections of the block
+            block.disconnect();
+
+            // Removes the block from the list of attached blocks
+            this._attachedBlocks.splice(attachedBlockIndex, 1);
+        }
+    }
+
+    private _generateCommandsAndGatherInitPromises(initializationData: InitializationData): void {
+        const outputBlock = this.outputBlock;
+
+        outputBlock.visit(initializationData, (block: BaseBlock, initializationData: InitializationData) => {
+            block.generateCommandsAndGatherInitPromises(initializationData, outputBlock.input.connectedTo?.ownerBlock === block);
+        });
+    }
+
+    /**
+     * Create a new runtime for the current state of the smart filter.
+     * @param engine - The Babylon.js engine to use for the runtime
+     * @param renderTargetGenerator - The render target generator to use to generate the RTTs for the shader blocks. If not provided, a default one will be created.
+     * @returns the runtime that can be used to render the smart filter
+     */
+    public async createRuntimeAsync(engine: ThinEngine, renderTargetGenerator?: RenderTargetGenerator): Promise<SmartFilterRuntime> {
+        const runtime = new InternalSmartFilterRuntime(engine);
+
+        const initializationData: InitializationData = {
+            runtime,
+            outputBlock: this.outputBlock,
+            initializationPromises: [],
+            disposableResources: [],
+        };
+
+        this._workWithAggregateFreeGraph(() => {
+            this.outputBlock.prepareForRuntime();
+
+            renderTargetGenerator = renderTargetGenerator ?? new RenderTargetGenerator(false);
+            renderTargetGenerator.setOutputTextures(this, initializationData);
+
+            this.outputBlock.propagateRuntimeData();
+
+            this._generateCommandsAndGatherInitPromises(initializationData);
+        });
+
+        // Wait for all the blocks to be initialized
+        if (initializationData.initializationPromises.length > 0) {
+            const timeoutPromise = new Promise((resolve) => setTimeout(resolve, InitializationTimeout, true));
+            // eslint-disable-next-line github/no-then
+            const initializationPromises = Promise.all(initializationData.initializationPromises).then(() => false);
+            const timedOut = await Promise.race([initializationPromises, timeoutPromise]);
+            if (timedOut) {
+                throw new Error("Initialization promises timed out");
+            }
+        }
+
+        // Register the resources to dispose when the runtime is disposed
+        initializationData.disposableResources.forEach((resource) => runtime.registerResource(resource));
+
+        return runtime;
+    }
+
+    /**
+     * Resizes any intermediate textures according to the new size of the render target
+     * @param engine - The engine used to render the smart filter
+     */
+    public resize(engine: ThinEngine): void {
+        this._workWithAggregateFreeGraph(() => {
+            this.outputBlock.visit({}, (block: BaseBlock) => {
+                if (!(block instanceof ShaderBlock)) {
+                    return;
+                }
+
+                if (block.output.runtimeData?.value) {
+                    const size = GetBlockOutputTextureSize(this, engine, block.outputTextureOptions);
+                    (block.output.runtimeData.value as ThinRenderTargetTexture).resize(size);
+                }
+            });
+        });
+    }
+
+    /**
+     * @internal
+     * Merges all aggregate blocks into the smart filter graph, executes the passed-in work, then restores the aggregate blocks.
+     * @param work - The work to execute with the aggregate blocks merged
+     */
+    public _workWithAggregateFreeGraph(work: () => void): void {
+        const mergedAggregateBlocks: AggregateBlock[] = [];
+
+        // Merge all aggregate blocks
+        this.outputBlock.visit({}, (block: BaseBlock, _extraData: object) => {
+            if (block instanceof AggregateBlock) {
+                block._mergeIntoSmartFilter(mergedAggregateBlocks);
+            }
+        });
+
+        try {
+            // Do the passed in work
+            work();
+        } finally {
+            // Restore all aggregate blocks, even if work throws
+            for (const block of mergedAggregateBlocks) {
+                block._unmergeFromSmartFilter();
+            }
+        }
+    }
+}

package/src/utils/buildTools/buildShaders.ts

@@ -0,0 +1,14 @@
+/**
+ * Builds all .glsl files under <shaderPath>.
+ * @param shaderPath - The path to the shaders to watch
+ * @param smartFiltersCorePath - The path to import the Smart Filters core from
+ * @param babylonCorePath - The path to import the Babylon core from (optional)
+ * @example node buildShaders.js <shaderPath> @babylonjs/smart-filters
+ */
+
+import { ConvertShaders } from "./convertShaders.js";
+
+const ExternalArguments = process.argv.slice(2);
+if (ExternalArguments.length >= 2 && ExternalArguments[0] && ExternalArguments[1]) {
+    ConvertShaders(ExternalArguments[0], ExternalArguments[1], ExternalArguments[2]);
+}

package/src/utils/buildTools/convertGlslIntoBlock.ts

@@ -0,0 +1,370 @@
+import * as fs from "fs";
+import { ExtractShaderProgramFromGlsl } from "./convertGlslIntoShaderProgram.js";
+import { ConnectionPointType } from "../../connection/connectionPointType.js";
+import { BlockDisableStrategy } from "../../blockFoundation/disableableShaderBlock.js";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const EXTRA_IMPORTS = "@EXTRA_IMPORTS@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BABYLON_CORE_PATH = "@BABYLON_CORE_PATH@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SMART_FILTER_CORE_IMPORT = "@SMART_FILTER_CORE_IMPORT@";
+const SHADER_PROGRAM = "@SHADER_PROGRAM@";
+const BLOCK_NAME = "@BLOCK_NAME@";
+const NAMESPACE = "@NAMESPACE@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const SHADER_BINDING_PRIVATE_VARIABLES = "@SHADER_BINDING_PRIVATE_VARIABLES@";
+const CAMEL_CASE_UNIFORM = "@CAMEL_CASE_UNIFORM@";
+const CONNECTION_POINT_TYPE = "@CONNECTION_POINT_TYPE@";
+const CONNECTION_POINT_DEFAULT_VALUE = "@CONNECTION_POINT_DEFAULT_VALUE@";
+const SHADER_BINDING_EXTENDS = "@SHADER_BINDING_EXTENDS@";
+const SHADER_BINDING_CTOR_DOCSTRING_PARAMS = "@SHADER_BINDING_CTOR_DOCSTRING_PARAMS@";
+const SHADER_BINDING_CTOR_PARAMS = "@SHADER_CTOR_PARAMS@";
+const SHADER_BINDING_SUPER_PARAMS = "@SHADER_BINDING_SUPER_PARAMS@";
+const SHADER_BINDING_CTOR = "@SHADER_BINDING_CTOR@";
+const SHADER_BINDING_BIND = "@SHADER_BINDING_BIND@";
+const SHADER_BLOCK_EXTENDS = "@SHADER_BLOCK_EXTENDS@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BLOCK_INPUT_PROPERTIES = "@BLOCK_INPUT_PROPERTIES@";
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const BLOCK_DISABLE_OPTIMIZATION = "@BLOCK_DISABLE_OPTIMIZATION@";
+const BLOCK_DISABLE_STRATEGY = "@BLOCK_DISABLE_STRATEGY@";
+const BLOCK_GET_SHADER_BINDING_VARS = "@BLOCK_SHADER_BINDING_BIND_VARS@";
+const BLOCK_GET_SHADER_PARAM_LIST = "@BLOCK_GET_SHADER_PARAM_LIST@";
+const EFFECT_SETTER = "@EFFECT_SETTER@";
+const EFFECT_VALUE = "@EFFECT_VALUE@";
+const EXTRA_BIND_DOCSTRING = "@EXTRA_BIND_DOCSTRING@";
+const EXTRA_BIND_PARAMS = "@EXTRA_BIND_PARAMS@";
+
+const ShaderBindingPrivateVariablesTemplate = `    private readonly _${CAMEL_CASE_UNIFORM}: RuntimeData<ConnectionPointType.${CONNECTION_POINT_TYPE}>;`;
+const ShaderBindingCtorDocstringParams = `     * @param ${CAMEL_CASE_UNIFORM} - The ${CAMEL_CASE_UNIFORM} runtime value`;
+const ShaderBindingCtorParams = `        ${CAMEL_CASE_UNIFORM}: RuntimeData<ConnectionPointType.${CONNECTION_POINT_TYPE}>`;
+const ShaderBindingCtor = `        this._${CAMEL_CASE_UNIFORM} = ${CAMEL_CASE_UNIFORM};`;
+const ShaderBindingBind = `        effect.${EFFECT_SETTER}(this.getRemappedName(Uniforms.${CAMEL_CASE_UNIFORM}), ${EFFECT_VALUE});`;
+const ShaderBindingBindRegularValue = `this._${CAMEL_CASE_UNIFORM}.value`;
+
+const BlockInputProperty = `    /**
+     * The ${CAMEL_CASE_UNIFORM} connection point.
+     */
+    public readonly ${CAMEL_CASE_UNIFORM} = this._registerInput(Uniforms.${CAMEL_CASE_UNIFORM}, ConnectionPointType.${CONNECTION_POINT_TYPE});
+`;
+const BlockInputOptionalProperty = `    /**
+    /**
+     * The ${CAMEL_CASE_UNIFORM} connection point.
+     */
+    public readonly ${CAMEL_CASE_UNIFORM} = this._registerOptionalInput(
+        "${CAMEL_CASE_UNIFORM}",
+        ConnectionPointType.${CONNECTION_POINT_TYPE},
+        createStrongRef(${CONNECTION_POINT_DEFAULT_VALUE})
+    );
+`;
+const BlockGetShaderBindingVars = `        const ${CAMEL_CASE_UNIFORM} = this._confirmRuntimeDataSupplied(this.${CAMEL_CASE_UNIFORM});`;
+
+const FileTemplate = `/* eslint-disable prettier/prettier */
+// ************************************************************
+// Note: this file is auto-generated, do not modify it directly
+// ************************************************************
+
+// It was generated by convertGlslIntoBlock() from
+// an annotated .glsl file. Modify the .glsl file to make changes
+// to the block. This file will get overwritten when the build
+// is run or during a watch when the .glsl file is updated.
+
+import type { Effect } from "${BABYLON_CORE_PATH}/Materials/effect.js";
+
+import {
+    ${SHADER_BINDING_EXTENDS},
+    type RuntimeData,
+    ConnectionPointType,
+    type SmartFilter,
+    ${SHADER_BLOCK_EXTENDS},
+    type ShaderProgram,
+${EXTRA_IMPORTS}} from "${SMART_FILTER_CORE_IMPORT}";${SHADER_PROGRAM}
+/**
+ * The shader binding for the ${BLOCK_NAME}, used by the runtime
+ */
+class ${BLOCK_NAME}ShaderBinding extends ${SHADER_BINDING_EXTENDS} {
+${SHADER_BINDING_PRIVATE_VARIABLES}
+
+    /**
+     * Creates a new shader binding instance for the block.
+${SHADER_BINDING_CTOR_DOCSTRING_PARAMS}
+     */
+    constructor(
+${SHADER_BINDING_CTOR_PARAMS}
+    ) {
+        super(${SHADER_BINDING_SUPER_PARAMS});
+${SHADER_BINDING_CTOR}
+    }
+
+    /**
+     * Binds all the required data to the shader when rendering.
+     * @param effect - defines the effect to bind the data to${EXTRA_BIND_DOCSTRING}
+     */
+    public override bind(effect: Effect${EXTRA_BIND_PARAMS}): void {
+${SHADER_BINDING_BIND}
+    }
+}
+
+/**
+ * The implementation of the ${BLOCK_NAME}
+ */
+export class ${BLOCK_NAME} extends ${SHADER_BLOCK_EXTENDS} {
+    /**
+     * The class name of the block.
+     */
+    public static override ClassName = "${BLOCK_NAME}";
+
+    /**
+     * The namespace of the block.
+     */
+    public static override Namespace = "${NAMESPACE}";
+
+${BLOCK_INPUT_PROPERTIES}
+    /**
+     * The shader program (vertex and fragment code) to use to render the block
+     */
+    public static override ShaderCode = BlockShaderProgram;
+
+    /**
+     * Instantiates a new ${BLOCK_NAME}.
+     * @param smartFilter - The smart filter this block belongs to
+     * @param name - The friendly name of the block
+     */
+    constructor(smartFilter: SmartFilter, name: string) {
+        super(smartFilter, name, ${BLOCK_DISABLE_OPTIMIZATION}${BLOCK_DISABLE_STRATEGY});
+    }
+
+    /**
+     * 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(): ${SHADER_BINDING_EXTENDS} {
+${BLOCK_GET_SHADER_BINDING_VARS}
+
+        return new ${BLOCK_NAME}ShaderBinding(${BLOCK_GET_SHADER_PARAM_LIST});
+    }
+}
+
+`;
+
+/**
+ * Converts a single shader to a .ts file which exports a Smart Filter block
+ * @param fragmentShaderPath - The path to the fragment file for the shader
+ * @param smartFiltersCorePath - The path to import the Smart Filters core from
+ * @param babylonCorePath - The path to import the Babylon core from (optional)
+
+ */
+export function ConvertGlslIntoBlock(fragmentShaderPath: string, smartFiltersCorePath: string, babylonCorePath?: string): void {
+    const extraImports: string[] = [];
+
+    const { shaderProgramCode, fragmentShaderInfo } = ExtractShaderProgramFromGlsl(fragmentShaderPath, smartFiltersCorePath, false, false);
+
+    // Validation
+    if (!fragmentShaderInfo.blockType) {
+        throw new Error("The glsl file must contain a header comment with a smartFilterBlockType value");
+    }
+
+    // Generate shader binding private variables
+    const shaderBindingPrivateVariables = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind
+                ? null
+                : ShaderBindingPrivateVariablesTemplate.replace(CAMEL_CASE_UNIFORM, uniform.name).replace(CONNECTION_POINT_TYPE, GetConnectionPointTypeString(uniform.type));
+        })
+        .filter((line) => line !== null);
+
+    // Generate the shader binding constructor docstring params
+    const shaderBindingCtorDocstringParams = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind ? null : ShaderBindingCtorDocstringParams.replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name);
+        })
+        .filter((param) => param !== null);
+
+    // Generate the shader binding constructor params
+    const shaderBindingCtorParams = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind
+                ? null
+                : ShaderBindingCtorParams.replace(CAMEL_CASE_UNIFORM, uniform.name).replace(CONNECTION_POINT_TYPE, GetConnectionPointTypeString(uniform.type));
+        })
+        .filter((param) => param !== null);
+
+    // Generate the shader binding constructor
+    const shaderBindingCtor = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind ? null : ShaderBindingCtor.replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name);
+        })
+        .filter((line) => line !== null);
+
+    // Generate the shader binding bind
+    let needWidthHeightParams = false;
+    const shaderBindingBind = fragmentShaderInfo.uniforms.map((uniform) => {
+        let effectValue: string;
+        let effectSetter = GetEffectSetter(uniform.type);
+
+        switch (uniform.properties?.autoBind) {
+            case "outputResolution":
+                {
+                    effectValue = "width, height";
+                    effectSetter = "setFloat2";
+                    needWidthHeightParams = true;
+                }
+                break;
+            case "outputAspectRatio":
+                {
+                    effectValue = "width / height, height / width";
+                    effectSetter = "setFloat2";
+                    needWidthHeightParams = true;
+                }
+                break;
+            default:
+                effectValue = ShaderBindingBindRegularValue;
+        }
+        return ShaderBindingBind.replace(EFFECT_VALUE, effectValue).replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name).replace(EFFECT_SETTER, effectSetter);
+    });
+
+    // Add extra params to the bind method if needed
+    let extraBindParams = "";
+    let extraBindDocstring = "";
+    if (needWidthHeightParams) {
+        extraBindDocstring = `
+     * @param width - defines the width of the output
+     * @param height - defines the height of the output`;
+        extraBindParams = `, width: number, height: number`;
+    }
+
+    // Generate the block input properties
+    const blockInputProperties = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            if (uniform.properties?.autoBind) {
+                return null;
+            } else if (uniform.properties?.default !== undefined) {
+                if (extraImports.indexOf("    createStrongRef") === -1) {
+                    extraImports.push("    createStrongRef");
+                }
+                return BlockInputOptionalProperty.replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name)
+                    .replace(CONNECTION_POINT_TYPE, GetConnectionPointTypeString(uniform.type))
+                    .replace(CONNECTION_POINT_DEFAULT_VALUE, uniform.properties.default);
+            } else {
+                return BlockInputProperty.replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name).replace(CONNECTION_POINT_TYPE, GetConnectionPointTypeString(uniform.type));
+            }
+        })
+        .filter((property) => property !== null);
+
+    // Generate the block get shader binding vars
+    const blockGetShaderBindingVars = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind ? null : BlockGetShaderBindingVars.replace(new RegExp(CAMEL_CASE_UNIFORM, "g"), uniform.name);
+        })
+        .filter((line) => line !== null);
+
+    // Handle the disable optimization flag
+    const disableOptimization = fragmentShaderInfo.disableOptimization === true ? "true" : "false";
+
+    // Generate the block get shader param list
+    const blockGetShaderParamList = fragmentShaderInfo.uniforms
+        .map((uniform) => {
+            return uniform.properties?.autoBind ? null : uniform.name;
+        })
+        .filter((param) => param !== null);
+
+    // Decide if this is a disableable block or not
+    let shaderBlockExtends = "ShaderBlock";
+    let shaderBindingExtends = "ShaderBinding";
+    let blockDisableStrategy = "";
+    let shaderBindingSuperParams = "";
+    if (fragmentShaderInfo.blockDisableStrategy) {
+        shaderBlockExtends = "DisableableShaderBlock";
+        shaderBindingExtends = "DisableableShaderBinding";
+        blockDisableStrategy = `, BlockDisableStrategy.${BlockDisableStrategy[fragmentShaderInfo.blockDisableStrategy]}`;
+        shaderBindingSuperParams = "parentBlock";
+
+        shaderBindingCtorDocstringParams.unshift("     * @param parentBlock - IDisableableBlock");
+        shaderBindingCtorParams.unshift("        parentBlock: IDisableableBlock");
+        blockGetShaderParamList.unshift("this");
+
+        extraImports.push("    type IDisableableBlock");
+        extraImports.push("    BlockDisableStrategy");
+
+        shaderBindingBind.unshift("        super.bind(effect);");
+    }
+
+    // Additional validation
+    if (fragmentShaderInfo.blockDisableStrategy !== undefined && fragmentShaderInfo.blockDisableStrategy !== BlockDisableStrategy.Manual) {
+        if (fragmentShaderInfo.uniforms.findIndex((uniform) => uniform.name === "disabled") !== -1) {
+            throw new Error("A block that uses a BlockDisableStrategy other than Manual should not declare its own 'disabled' uniform");
+        }
+    }
+
+    // Generate final contents
+    const finalContents = FileTemplate.replace(SHADER_PROGRAM, shaderProgramCode)
+        .replace(EXTRA_IMPORTS, extraImports.join(",\n"))
+        .replace(BABYLON_CORE_PATH, babylonCorePath || "@babylonjs/core")
+        .replace(SMART_FILTER_CORE_IMPORT, smartFiltersCorePath)
+        .replace(new RegExp(BLOCK_NAME, "g"), fragmentShaderInfo.blockType)
+        .replace(NAMESPACE, fragmentShaderInfo.namespace || "Other")
+        .replace(new RegExp(SHADER_BINDING_EXTENDS, "g"), shaderBindingExtends)
+        .replace(SHADER_BINDING_PRIVATE_VARIABLES, shaderBindingPrivateVariables.join("\n"))
+        .replace(SHADER_BINDING_CTOR_DOCSTRING_PARAMS, shaderBindingCtorDocstringParams.join("\n"))
+        .replace(SHADER_BINDING_CTOR_PARAMS, shaderBindingCtorParams.join(",\n"))
+        .replace(SHADER_BINDING_CTOR, shaderBindingCtor.join("\n"))
+        .replace(SHADER_BINDING_SUPER_PARAMS, shaderBindingSuperParams)
+        .replace(SHADER_BINDING_BIND, shaderBindingBind.join("\n"))
+        .replace(EXTRA_BIND_DOCSTRING, extraBindDocstring)
+        .replace(EXTRA_BIND_PARAMS, extraBindParams)
+        .replace(new RegExp(SHADER_BLOCK_EXTENDS, "g"), shaderBlockExtends)
+        .replace(BLOCK_INPUT_PROPERTIES, blockInputProperties.join("\n"))
+        .replace(BLOCK_DISABLE_OPTIMIZATION, disableOptimization)
+        .replace(BLOCK_DISABLE_STRATEGY, blockDisableStrategy)
+        .replace(BLOCK_GET_SHADER_BINDING_VARS, blockGetShaderBindingVars.join("\n"))
+        .replace(BLOCK_GET_SHADER_PARAM_LIST, blockGetShaderParamList.join(","));
+
+    // Write the block class TS file
+    const outputFullPathAndFileName = fragmentShaderPath.replace(".glsl", ".ts");
+    fs.writeFileSync(outputFullPathAndFileName, finalContents);
+}
+
+/**
+ * Get the string representation of a connection point type
+ * @param type - The connection point type
+ * @returns - The string representation of the connection point type
+ */
+function GetConnectionPointTypeString(type: ConnectionPointType): string {
+    switch (type) {
+        case ConnectionPointType.Float:
+            return "Float";
+        case ConnectionPointType.Texture:
+            return "Texture";
+        case ConnectionPointType.Color3:
+            return "Color3";
+        case ConnectionPointType.Color4:
+            return "Color4";
+        case ConnectionPointType.Vector2:
+            return "Vector2";
+        case ConnectionPointType.Boolean:
+            return "Boolean";
+    }
+}
+
+/**
+ * Get the effect setter for a connection point type
+ * @param type - The connection point type
+ * @returns - The effect setter for the connection point type
+ */
+function GetEffectSetter(type: ConnectionPointType): string {
+    switch (type) {
+        case ConnectionPointType.Float:
+            return "setFloat";
+        case ConnectionPointType.Texture:
+            return "setTexture";
+        case ConnectionPointType.Color3:
+            return "setColor3";
+        case ConnectionPointType.Color4:
+            return "setDirectColor4";
+        case ConnectionPointType.Vector2:
+            return "setVector2";
+        case ConnectionPointType.Boolean:
+            return "setBool";
+    }
+}