@babylonjs/core 7.3.2 → 7.3.3

package/Materials/effect.d.ts

@@ -13,6 +13,7 @@ import type { InternalTexture } from "../Materials/Textures/internalTexture";
 import type { ThinTexture } from "../Materials/Textures/thinTexture";
 import type { RenderTargetTexture } from "../Materials/Textures/renderTargetTexture";
 import type { PostProcess } from "../PostProcesses/postProcess";
+import type { IPipelineGenerationOptions } from "./effect.functions";
 /**
  * Defines the route to the shader code. The priority is as follows:
  *  * object: `{ vertexSource: "vertex shader code string", fragmentSource: "fragment shader code string" }` for directly passing the shader code
@@ -112,6 +113,10 @@ export interface IEffectCreationOptions {
      * The language the shader is written in (default: GLSL)
      */
     shaderLanguage?: ShaderLanguage;
+    /**
+     * Provide an existing pipeline context to avoid creating a new one
+     */
+    existingPipelineContext?: IPipelineContext;
 }
 /**
  * Effect containing vertex and fragment shader that can be executed on an object.
@@ -210,13 +215,13 @@ export declare class Effect implements IDisposable {
     /** @internal */
     _fragmentSourceCode: string;
     /** @internal */
-    private _vertexSourceCodeBeforeMigration;
+    _vertexSourceCodeBeforeMigration: string;
     /** @internal */
-    private _fragmentSourceCodeBeforeMigration;
+    _fragmentSourceCodeBeforeMigration: string;
     /** @internal */
-    private _rawVertexSourceCode;
+    _rawVertexSourceCode: string;
     /** @internal */
-    private _rawFragmentSourceCode;
+    _rawFragmentSourceCode: string;
     private static _BaseCache;
     private _processingContext;
     private _processCodeAfterIncludes;
@@ -244,7 +249,6 @@ export declare class Effect implements IDisposable {
     constructor(baseName: IShaderPath | string, attributesNamesOrOptions: string[] | IEffectCreationOptions, uniformsNamesOrEngine: string[] | AbstractEngine, samplers?: Nullable<string[]>, engine?: AbstractEngine, defines?: Nullable<string>, fallbacks?: Nullable<IEffectFallbacks>, onCompiled?: Nullable<(effect: Effect) => void>, onError?: Nullable<(effect: Effect, errors: string) => void>, indexParameters?: any, key?: string, shaderLanguage?: ShaderLanguage);
     /** @internal */
     _processShaderCode(shaderProcessor?: Nullable<IShaderProcessor>, keepExistingPipelineContext?: boolean): void;
-    private _useFinalCode;
     /**
      * Unique key for this effect
      */
@@ -335,7 +339,6 @@ export declare class Effect implements IDisposable {
      */
     executeWhenCompiled(func: (effect: Effect) => void): void;
     private _checkIsReady;
-    private _loadShader;
     /**
      * Gets the vertex shader source code of this effect
      * This is the final source code that will be compiled, after all the processing has been done (pre-processing applied, code injection/replacement, etc)
@@ -366,6 +369,7 @@ export declare class Effect implements IDisposable {
      * Gets the fragment shader source code before it has been modified by any processing
      */
     get rawFragmentSourceCode(): string;
+    getPipelineGenerationOptions(): IPipelineGenerationOptions;
     /**
      * Recompiles the webGL program
      * @param vertexSourceCode The source code for the vertex shader.
@@ -375,6 +379,7 @@ export declare class Effect implements IDisposable {
      * @internal
      */
     _rebuildProgram(vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (pipelineContext: IPipelineContext) => void, onError: (message: string) => void): void;
+    private _onRenderingStateCompiled;
     /**
      * Prepares the effect
      * @internal

package/Materials/effect.functions.d.ts

@@ -0,0 +1,86 @@
+import type { ProcessingOptions, ShaderCustomProcessingFunction, ShaderProcessingContext } from "../Engines/Processors/shaderProcessingOptions.js";
+import type { Nullable } from "../types.js";
+import { ShaderLanguage } from "./shaderLanguage";
+import type { WebGLContext } from "../Engines/thinEngine.functions.js";
+import type { AbstractEngine } from "../Engines/abstractEngine.js";
+import type { Effect, IShaderPath } from "./effect";
+import type { IPipelineContext } from "../Engines/IPipelineContext.js";
+/**
+ * Options to be used when creating a pipeline
+ */
+export interface IPipelineGenerationOptions {
+    /**
+     * The definition of the shader content.
+     * Can be either a unified name, name per vertex and frament or the shader code content itself
+     */
+    shaderNameOrContent: string | IShaderPath;
+    /**
+     * Unique key to identify the pipeline.
+     * Note that though not mandatory, it's recommended to provide a key to be able to use the automated pipeline loading system.
+     */
+    key?: string;
+    /**
+     * The list of defines to be used in the shader
+     */
+    defines?: string[];
+    /**
+     * If true, the global defines will be added to the defines array
+     */
+    addGlobalDefines?: boolean;
+    /**
+     * The shader language.
+     * Defaults to the language suiting the platform name (GLSL for WEBGL2, WGSL for WEBGPU)
+     */
+    shaderLanguage?: ShaderLanguage;
+    /**
+     * The name of the platform to be used when processing the shader
+     * defaults to WEBGL2
+     */
+    platformName?: string;
+    /**
+     * extend the processing options when running code processing
+     */
+    extendedProcessingOptions?: Partial<ProcessingOptions>;
+    /**
+     * extend the pipeline generation options
+     */
+    extendedCreatePipelineOptions?: Partial<ICreateAndPreparePipelineContextOptions>;
+}
+/**
+ * @internal
+ */
+export interface ICreateAndPreparePipelineContextOptions {
+    parallelShaderCompile?: {
+        COMPLETION_STATUS_KHR: number;
+    };
+    shaderProcessingContext: Nullable<ShaderProcessingContext>;
+    existingPipelineContext?: Nullable<IPipelineContext>;
+    name?: string;
+    rebuildRebind?: (vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (pipelineContext: IPipelineContext) => void, onError: (message: string) => void) => void;
+    onRenderingStateCompiled?: (pipelineContext?: IPipelineContext) => void;
+    context?: WebGL2RenderingContext | WebGLRenderingContext;
+    createAsRaw?: boolean;
+    vertex: string;
+    fragment: string;
+    defines: Nullable<string>;
+    transformFeedbackVaryings: Nullable<string[]>;
+}
+/**
+ * Get a cached pipeline context
+ * @param name the pipeline name
+ * @param context the context to be used when creating the pipeline
+ * @returns the cached pipeline context if it exists
+ * @internal
+ */
+export declare function getCachedPipeline(name: string, context: WebGLContext): IPipelineContext | undefined;
+/**
+ * @internal
+ */
+export declare function resetCachedPipeline(pipeline: IPipelineContext): void;
+/** @internal */
+export declare function _processShaderCode(processorOptions: ProcessingOptions, baseName: any, processFinalCode?: Nullable<ShaderCustomProcessingFunction>, onFinalCodeReady?: (vertexCode: string, fragmentCode: string) => void, shaderLanguage?: ShaderLanguage, engine?: AbstractEngine, effectContext?: Effect): void;
+/**
+ * Creates and prepares a pipeline context
+ * @internal
+ */
+export declare const createAndPreparePipelineContext: (options: ICreateAndPreparePipelineContextOptions, createPipelineContext: (shaderProcessingContext: Nullable<ShaderProcessingContext>) => IPipelineContext, _preparePipelineContext: (pipelineContext: IPipelineContext, vertexSourceCode: string, fragmentSourceCode: string, createAsRaw: boolean, rawVertexSourceCode: string, rawFragmentSourceCode: string, rebuildRebind: any, defines: Nullable<string>, transformFeedbackVaryings: Nullable<string[]>, key: string) => void) => IPipelineContext;

package/Materials/effect.functions.js

@@ -0,0 +1,185 @@
+import { GetDOMTextContent, IsWindowObjectExist } from "../Misc/domManagement.js";
+import { ShaderLanguage } from "./shaderLanguage.js";
+import { _executeWhenRenderingStateIsCompiled, getStateObject } from "../Engines/thinEngine.functions.js";
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { Logger } from "../Misc/logger.js";
+import { Finalize, Initialize, Process } from "../Engines/Processors/shaderProcessor.js";
+/**
+ * Get a cached pipeline context
+ * @param name the pipeline name
+ * @param context the context to be used when creating the pipeline
+ * @returns the cached pipeline context if it exists
+ * @internal
+ */
+export function getCachedPipeline(name, context) {
+    const stateObject = getStateObject(context);
+    return stateObject.cachedPipelines[name];
+}
+/**
+ * @internal
+ */
+export function resetCachedPipeline(pipeline) {
+    const name = pipeline._name;
+    const context = pipeline.context;
+    if (name && context) {
+        const stateObject = getStateObject(context);
+        const cachedPipeline = stateObject.cachedPipelines[name];
+        cachedPipeline?.dispose();
+        delete stateObject.cachedPipelines[name];
+    }
+}
+/** @internal */
+export function _processShaderCode(processorOptions, baseName, processFinalCode, onFinalCodeReady, shaderLanguage, engine, effectContext) {
+    let vertexSource;
+    let fragmentSource;
+    // const baseName = this.name;
+    const hostDocument = IsWindowObjectExist() ? engine?.getHostDocument() : null;
+    if (typeof baseName === "string") {
+        vertexSource = baseName;
+    }
+    else if (baseName.vertexSource) {
+        vertexSource = "source:" + baseName.vertexSource;
+    }
+    else if (baseName.vertexElement) {
+        vertexSource = hostDocument?.getElementById(baseName.vertexElement) || baseName.vertexElement;
+    }
+    else {
+        vertexSource = baseName.vertex || baseName;
+    }
+    if (typeof baseName === "string") {
+        fragmentSource = baseName;
+    }
+    else if (baseName.fragmentSource) {
+        fragmentSource = "source:" + baseName.fragmentSource;
+    }
+    else if (baseName.fragmentElement) {
+        fragmentSource = hostDocument?.getElementById(baseName.fragmentElement) || baseName.fragmentElement;
+    }
+    else {
+        fragmentSource = baseName.fragment || baseName;
+    }
+    const shaderCodes = [undefined, undefined];
+    const shadersLoaded = () => {
+        if (shaderCodes[0] && shaderCodes[1]) {
+            processorOptions.isFragment = true;
+            const [migratedVertexCode, fragmentCode] = shaderCodes;
+            Process(fragmentCode, processorOptions, (migratedFragmentCode, codeBeforeMigration) => {
+                if (effectContext) {
+                    effectContext._fragmentSourceCodeBeforeMigration = codeBeforeMigration;
+                }
+                if (processFinalCode) {
+                    migratedFragmentCode = processFinalCode("fragment", migratedFragmentCode);
+                }
+                const finalShaders = Finalize(migratedVertexCode, migratedFragmentCode, processorOptions);
+                processorOptions = null;
+                const finalCode = _useFinalCode(finalShaders.vertexCode, finalShaders.fragmentCode, baseName, shaderLanguage);
+                onFinalCodeReady?.(finalCode.vertexSourceCode, finalCode.fragmentSourceCode);
+            }, engine);
+        }
+    };
+    _loadShader(vertexSource, "Vertex", "", (vertexCode) => {
+        Initialize(processorOptions);
+        Process(vertexCode, processorOptions, (migratedVertexCode, codeBeforeMigration) => {
+            if (effectContext) {
+                effectContext._rawVertexSourceCode = vertexCode;
+                effectContext._vertexSourceCodeBeforeMigration = codeBeforeMigration;
+            }
+            if (processFinalCode) {
+                migratedVertexCode = processFinalCode("vertex", migratedVertexCode);
+            }
+            shaderCodes[0] = migratedVertexCode;
+            shadersLoaded();
+        }, engine);
+    }, shaderLanguage);
+    _loadShader(fragmentSource, "Fragment", "Pixel", (fragmentCode) => {
+        if (effectContext) {
+            effectContext._rawFragmentSourceCode = fragmentCode;
+        }
+        shaderCodes[1] = fragmentCode;
+        shadersLoaded();
+    }, shaderLanguage);
+}
+function _loadShader(shader, key, optionalKey, callback, shaderLanguage, _loadFileInjection) {
+    if (typeof HTMLElement !== "undefined") {
+        // DOM element ?
+        if (shader instanceof HTMLElement) {
+            const shaderCode = GetDOMTextContent(shader);
+            callback(shaderCode);
+            return;
+        }
+    }
+    // Direct source ?
+    if (shader.substr(0, 7) === "source:") {
+        callback(shader.substr(7));
+        return;
+    }
+    // Base64 encoded ?
+    if (shader.substr(0, 7) === "base64:") {
+        const shaderBinary = window.atob(shader.substr(7));
+        callback(shaderBinary);
+        return;
+    }
+    const shaderStore = ShaderStore.GetShadersStore(shaderLanguage);
+    // Is in local store ?
+    if (shaderStore[shader + key + "Shader"]) {
+        callback(shaderStore[shader + key + "Shader"]);
+        return;
+    }
+    if (optionalKey && shaderStore[shader + optionalKey + "Shader"]) {
+        callback(shaderStore[shader + optionalKey + "Shader"]);
+        return;
+    }
+    let shaderUrl;
+    if (shader[0] === "." || shader[0] === "/" || shader.indexOf("http") > -1) {
+        shaderUrl = shader;
+    }
+    else {
+        shaderUrl = ShaderStore.GetShadersRepository(shaderLanguage) + shader;
+    }
+    if (!_loadFileInjection) {
+        // we got to this point and loadFile was not injected - throw an error
+        throw new Error("loadFileInjection is not defined");
+    }
+    // Vertex shader
+    _loadFileInjection(shaderUrl + "." + key.toLowerCase() + ".fx", callback);
+}
+function _useFinalCode(migratedVertexCode, migratedFragmentCode, baseName, shaderLanguage) {
+    if (baseName) {
+        const vertex = baseName.vertexElement || baseName.vertex || baseName.spectorName || baseName;
+        const fragment = baseName.fragmentElement || baseName.fragment || baseName.spectorName || baseName;
+        return {
+            vertexSourceCode: (shaderLanguage === ShaderLanguage.WGSL ? "//" : "") + "#define SHADER_NAME vertex:" + vertex + "\n" + migratedVertexCode,
+            fragmentSourceCode: (shaderLanguage === ShaderLanguage.WGSL ? "//" : "") + "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode,
+        };
+    }
+    else {
+        return {
+            vertexSourceCode: migratedVertexCode,
+            fragmentSourceCode: migratedFragmentCode,
+        };
+    }
+}
+/**
+ * Creates and prepares a pipeline context
+ * @internal
+ */
+export const createAndPreparePipelineContext = (options, createPipelineContext, _preparePipelineContext) => {
+    try {
+        const pipelineContext = options.existingPipelineContext || createPipelineContext(options.shaderProcessingContext);
+        pipelineContext._name = options.name;
+        if (options.name && options.context) {
+            const stateObject = getStateObject(options.context);
+            stateObject.cachedPipelines[options.name] = pipelineContext;
+        }
+        _preparePipelineContext(pipelineContext, options.vertex, options.fragment, !!options.createAsRaw, "", "", options.rebuildRebind, options.defines, options.transformFeedbackVaryings, "");
+        _executeWhenRenderingStateIsCompiled(pipelineContext, (context) => {
+            options.onRenderingStateCompiled?.(context);
+        });
+        return pipelineContext;
+    }
+    catch (e) {
+        Logger.Error("Error compiling effect");
+        throw e;
+    }
+};
+//# sourceMappingURL=effect.functions.js.map

package/Materials/effect.functions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.functions.js","sourceRoot":"","sources":["../../../../dev/core/src/Materials/effect.functions.ts"],"names":[],"mappings":"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","sourcesContent":["import type { ProcessingOptions, ShaderCustomProcessingFunction, ShaderProcessingContext } from \"core/Engines/Processors/shaderProcessingOptions\";\r\nimport { GetDOMTextContent, IsWindowObjectExist } from \"core/Misc/domManagement\";\r\nimport type { Nullable } from \"core/types\";\r\nimport { ShaderLanguage } from \"./shaderLanguage\";\r\nimport type { WebGLContext } from \"core/Engines/thinEngine.functions\";\r\nimport { _executeWhenRenderingStateIsCompiled, getStateObject } from \"core/Engines/thinEngine.functions\";\r\nimport { ShaderStore } from \"core/Engines/shaderStore\";\r\nimport type { AbstractEngine } from \"core/Engines/abstractEngine\";\r\nimport type { Effect, IShaderPath } from \"./effect\";\r\nimport type { IPipelineContext } from \"core/Engines/IPipelineContext\";\r\nimport { Logger } from \"core/Misc/logger\";\r\nimport { Finalize, Initialize, Process } from \"core/Engines/Processors/shaderProcessor\";\r\nimport type { _loadFile } from \"core/Engines/abstractEngine.functions\";\r\nimport type { WebGLPipelineContext } from \"core/Engines/WebGL/webGLPipelineContext\";\r\n\r\n/**\r\n * Options to be used when creating a pipeline\r\n */\r\nexport interface IPipelineGenerationOptions {\r\n    /**\r\n     * The definition of the shader content.\r\n     * Can be either a unified name, name per vertex and frament or the shader code content itself\r\n     */\r\n    shaderNameOrContent: string | IShaderPath;\r\n    /**\r\n     * Unique key to identify the pipeline.\r\n     * Note that though not mandatory, it's recommended to provide a key to be able to use the automated pipeline loading system.\r\n     */\r\n    key?: string;\r\n    /**\r\n     * The list of defines to be used in the shader\r\n     */\r\n    defines?: string[];\r\n\r\n    /**\r\n     * If true, the global defines will be added to the defines array\r\n     */\r\n    addGlobalDefines?: boolean;\r\n    /**\r\n     * The shader language.\r\n     * Defaults to the language suiting the platform name (GLSL for WEBGL2, WGSL for WEBGPU)\r\n     */\r\n    shaderLanguage?: ShaderLanguage;\r\n\r\n    /**\r\n     * The name of the platform to be used when processing the shader\r\n     * defaults to WEBGL2\r\n     */\r\n    platformName?: string /* \"WEBGL2\" | \"WEBGL1\" | \"WEBGPU\" */;\r\n\r\n    /**\r\n     * extend the processing options when running code processing\r\n     */\r\n    extendedProcessingOptions?: Partial<ProcessingOptions>;\r\n\r\n    /**\r\n     * extend the pipeline generation options\r\n     */\r\n    extendedCreatePipelineOptions?: Partial<ICreateAndPreparePipelineContextOptions>;\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport interface ICreateAndPreparePipelineContextOptions {\r\n    parallelShaderCompile?: { COMPLETION_STATUS_KHR: number };\r\n    shaderProcessingContext: Nullable<ShaderProcessingContext>;\r\n    existingPipelineContext?: Nullable<IPipelineContext>;\r\n    name?: string;\r\n    rebuildRebind?: (vertexSourceCode: string, fragmentSourceCode: string, onCompiled: (pipelineContext: IPipelineContext) => void, onError: (message: string) => void) => void;\r\n    onRenderingStateCompiled?: (pipelineContext?: IPipelineContext) => void;\r\n    context?: WebGL2RenderingContext | WebGLRenderingContext;\r\n    // preparePipeline options\r\n    createAsRaw?: boolean;\r\n    vertex: string;\r\n    fragment: string;\r\n    defines: Nullable<string>;\r\n    transformFeedbackVaryings: Nullable<string[]>;\r\n}\r\n\r\n/**\r\n * Get a cached pipeline context\r\n * @param name the pipeline name\r\n * @param context the context to be used when creating the pipeline\r\n * @returns the cached pipeline context if it exists\r\n * @internal\r\n */\r\nexport function getCachedPipeline(name: string, context: WebGLContext): IPipelineContext | undefined {\r\n    const stateObject = getStateObject(context);\r\n    return stateObject.cachedPipelines[name];\r\n}\r\n\r\n/**\r\n * @internal\r\n */\r\nexport function resetCachedPipeline(pipeline: IPipelineContext): void {\r\n    const name = pipeline._name;\r\n    const context = (pipeline as WebGLPipelineContext).context;\r\n    if (name && context) {\r\n        const stateObject = getStateObject(context!);\r\n        const cachedPipeline = stateObject.cachedPipelines[name];\r\n        cachedPipeline?.dispose();\r\n        delete stateObject.cachedPipelines[name];\r\n    }\r\n}\r\n\r\n/** @internal */\r\nexport function _processShaderCode(\r\n    processorOptions: ProcessingOptions,\r\n    baseName: any,\r\n    processFinalCode?: Nullable<ShaderCustomProcessingFunction>,\r\n    onFinalCodeReady?: (vertexCode: string, fragmentCode: string) => void,\r\n    shaderLanguage?: ShaderLanguage,\r\n    engine?: AbstractEngine,\r\n    effectContext?: Effect\r\n) {\r\n    let vertexSource: string | HTMLElement | IShaderPath;\r\n    let fragmentSource: string | HTMLElement | IShaderPath;\r\n\r\n    // const baseName = this.name;\r\n    const hostDocument = IsWindowObjectExist() ? engine?.getHostDocument() : null;\r\n\r\n    if (typeof baseName === \"string\") {\r\n        vertexSource = baseName;\r\n    } else if (baseName.vertexSource) {\r\n        vertexSource = \"source:\" + baseName.vertexSource;\r\n    } else if (baseName.vertexElement) {\r\n        vertexSource = hostDocument?.getElementById(baseName.vertexElement) || baseName.vertexElement;\r\n    } else {\r\n        vertexSource = baseName.vertex || baseName;\r\n    }\r\n    if (typeof baseName === \"string\") {\r\n        fragmentSource = baseName;\r\n    } else if (baseName.fragmentSource) {\r\n        fragmentSource = \"source:\" + baseName.fragmentSource;\r\n    } else if (baseName.fragmentElement) {\r\n        fragmentSource = hostDocument?.getElementById(baseName.fragmentElement) || baseName.fragmentElement;\r\n    } else {\r\n        fragmentSource = baseName.fragment || baseName;\r\n    }\r\n\r\n    const shaderCodes: [string | undefined, string | undefined] = [undefined, undefined];\r\n    const shadersLoaded = () => {\r\n        if (shaderCodes[0] && shaderCodes[1]) {\r\n            processorOptions.isFragment = true;\r\n            const [migratedVertexCode, fragmentCode] = shaderCodes;\r\n            Process(\r\n                fragmentCode,\r\n                processorOptions,\r\n                (migratedFragmentCode, codeBeforeMigration) => {\r\n                    if (effectContext) {\r\n                        effectContext._fragmentSourceCodeBeforeMigration = codeBeforeMigration;\r\n                    }\r\n                    if (processFinalCode) {\r\n                        migratedFragmentCode = processFinalCode(\"fragment\", migratedFragmentCode);\r\n                    }\r\n                    const finalShaders = Finalize(migratedVertexCode, migratedFragmentCode, processorOptions);\r\n                    processorOptions = null as any;\r\n                    const finalCode = _useFinalCode(finalShaders.vertexCode, finalShaders.fragmentCode, baseName, shaderLanguage);\r\n                    onFinalCodeReady?.(finalCode.vertexSourceCode, finalCode.fragmentSourceCode);\r\n                },\r\n                engine\r\n            );\r\n        }\r\n    };\r\n    _loadShader(\r\n        vertexSource,\r\n        \"Vertex\",\r\n        \"\",\r\n        (vertexCode) => {\r\n            Initialize(processorOptions);\r\n            Process(\r\n                vertexCode,\r\n                processorOptions,\r\n                (migratedVertexCode, codeBeforeMigration) => {\r\n                    if (effectContext) {\r\n                        effectContext._rawVertexSourceCode = vertexCode;\r\n                        effectContext._vertexSourceCodeBeforeMigration = codeBeforeMigration;\r\n                    }\r\n                    if (processFinalCode) {\r\n                        migratedVertexCode = processFinalCode(\"vertex\", migratedVertexCode);\r\n                    }\r\n                    shaderCodes[0] = migratedVertexCode;\r\n                    shadersLoaded();\r\n                },\r\n                engine\r\n            );\r\n        },\r\n        shaderLanguage\r\n    );\r\n    _loadShader(\r\n        fragmentSource,\r\n        \"Fragment\",\r\n        \"Pixel\",\r\n        (fragmentCode) => {\r\n            if (effectContext) {\r\n                effectContext._rawFragmentSourceCode = fragmentCode;\r\n            }\r\n            shaderCodes[1] = fragmentCode;\r\n            shadersLoaded();\r\n        },\r\n        shaderLanguage\r\n    );\r\n}\r\n\r\nfunction _loadShader(shader: any, key: string, optionalKey: string, callback: (data: any) => void, shaderLanguage?: ShaderLanguage, _loadFileInjection?: typeof _loadFile) {\r\n    if (typeof HTMLElement !== \"undefined\") {\r\n        // DOM element ?\r\n        if (shader instanceof HTMLElement) {\r\n            const shaderCode = GetDOMTextContent(shader);\r\n            callback(shaderCode);\r\n            return;\r\n        }\r\n    }\r\n\r\n    // Direct source ?\r\n    if (shader.substr(0, 7) === \"source:\") {\r\n        callback(shader.substr(7));\r\n        return;\r\n    }\r\n\r\n    // Base64 encoded ?\r\n    if (shader.substr(0, 7) === \"base64:\") {\r\n        const shaderBinary = window.atob(shader.substr(7));\r\n        callback(shaderBinary);\r\n        return;\r\n    }\r\n\r\n    const shaderStore = ShaderStore.GetShadersStore(shaderLanguage);\r\n\r\n    // Is in local store ?\r\n    if (shaderStore[shader + key + \"Shader\"]) {\r\n        callback(shaderStore[shader + key + \"Shader\"]);\r\n        return;\r\n    }\r\n\r\n    if (optionalKey && shaderStore[shader + optionalKey + \"Shader\"]) {\r\n        callback(shaderStore[shader + optionalKey + \"Shader\"]);\r\n        return;\r\n    }\r\n\r\n    let shaderUrl;\r\n\r\n    if (shader[0] === \".\" || shader[0] === \"/\" || shader.indexOf(\"http\") > -1) {\r\n        shaderUrl = shader;\r\n    } else {\r\n        shaderUrl = ShaderStore.GetShadersRepository(shaderLanguage) + shader;\r\n    }\r\n    if (!_loadFileInjection) {\r\n        // we got to this point and loadFile was not injected - throw an error\r\n        throw new Error(\"loadFileInjection is not defined\");\r\n    }\r\n    // Vertex shader\r\n    _loadFileInjection(shaderUrl + \".\" + key.toLowerCase() + \".fx\", callback);\r\n}\r\n\r\nfunction _useFinalCode(migratedVertexCode: string, migratedFragmentCode: string, baseName: any, shaderLanguage?: ShaderLanguage) {\r\n    if (baseName) {\r\n        const vertex = baseName.vertexElement || baseName.vertex || baseName.spectorName || baseName;\r\n        const fragment = baseName.fragmentElement || baseName.fragment || baseName.spectorName || baseName;\r\n\r\n        return {\r\n            vertexSourceCode: (shaderLanguage === ShaderLanguage.WGSL ? \"//\" : \"\") + \"#define SHADER_NAME vertex:\" + vertex + \"\\n\" + migratedVertexCode,\r\n            fragmentSourceCode: (shaderLanguage === ShaderLanguage.WGSL ? \"//\" : \"\") + \"#define SHADER_NAME fragment:\" + fragment + \"\\n\" + migratedFragmentCode,\r\n        };\r\n    } else {\r\n        return {\r\n            vertexSourceCode: migratedVertexCode,\r\n            fragmentSourceCode: migratedFragmentCode,\r\n        };\r\n    }\r\n}\r\n\r\n/**\r\n * Creates and prepares a pipeline context\r\n * @internal\r\n */\r\nexport const createAndPreparePipelineContext = (\r\n    options: ICreateAndPreparePipelineContextOptions,\r\n    createPipelineContext: typeof AbstractEngine.prototype.createPipelineContext,\r\n    _preparePipelineContext: typeof AbstractEngine.prototype._preparePipelineContext\r\n) => {\r\n    try {\r\n        const pipelineContext: IPipelineContext = options.existingPipelineContext || createPipelineContext(options.shaderProcessingContext);\r\n        pipelineContext._name = options.name;\r\n        if (options.name && options.context) {\r\n            const stateObject = getStateObject(options.context);\r\n            stateObject.cachedPipelines[options.name] = pipelineContext;\r\n        }\r\n\r\n        _preparePipelineContext(\r\n            pipelineContext,\r\n            options.vertex,\r\n            options.fragment,\r\n            !!options.createAsRaw,\r\n            \"\",\r\n            \"\",\r\n            options.rebuildRebind,\r\n            options.defines,\r\n            options.transformFeedbackVaryings,\r\n            \"\"\r\n        );\r\n\r\n        _executeWhenRenderingStateIsCompiled(pipelineContext, (context) => {\r\n            options.onRenderingStateCompiled?.(context);\r\n        });\r\n\r\n        return pipelineContext;\r\n    } catch (e) {\r\n        Logger.Error(\"Error compiling effect\");\r\n        throw e;\r\n    }\r\n};\r\n"]}