@babylonjs/core 7.3.1 → 7.3.3

package/Materials/effect.js

@@ -1,10 +1,9 @@
 import { Observable } from "../Misc/observable.js";
 
-import { GetDOMTextContent, IsWindowObjectExist } from "../Misc/domManagement.js";
 import { Logger } from "../Misc/logger.js";
-import { ShaderProcessor } from "../Engines/Processors/shaderProcessor.js";
 import { ShaderStore as EngineShaderStore } from "../Engines/shaderStore.js";
 import { ShaderLanguage } from "./shaderLanguage.js";
+import { _processShaderCode, getCachedPipeline, createAndPreparePipelineContext, resetCachedPipeline } from "./effect.functions.js";
 /**
  * Effect containing vertex and fragment shader that can be executed on an object.
  */
@@ -123,6 +122,8 @@ export class Effect {
         this._processFinalCode = null;
         this.name = baseName;
         this._key = key;
+        const pipelineName = this._key.replace(/\r/g, "").replace(/\n/g, "|");
+        let cachedPipeline = undefined;
         if (attributesNamesOrOptions.attributes) {
             const options = attributesNamesOrOptions;
             this._engine = uniformsNamesOrEngine;
@@ -145,6 +146,7 @@ export class Effect {
             }
             this._processFinalCode = options.processFinalCode ?? null;
             this._processCodeAfterIncludes = options.processCodeAfterIncludes ?? undefined;
+            cachedPipeline = options.existingPipelineContext;
         }
         else {
             this._engine = engine;
@@ -159,42 +161,29 @@ export class Effect {
             this._indexParameters = indexParameters;
             this._fallbacks = fallbacks;
         }
+        // Use the cache if we can. For now, WebGL2 only.
+        if (this._engine.shaderPlatformName === "WEBGL2") {
+            cachedPipeline = getCachedPipeline(pipelineName, this._engine._gl) ?? cachedPipeline;
+        }
         this._attributeLocationByName = {};
         this.uniqueId = Effect._UniqueIdSeed++;
-        this._processShaderCode();
-    }
-    /** @internal */
-    _processShaderCode(shaderProcessor = null, keepExistingPipelineContext = false) {
-        let vertexSource;
-        let fragmentSource;
-        const baseName = this.name;
-        const hostDocument = IsWindowObjectExist() ? this._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;
+        if (!cachedPipeline) {
+            this._processShaderCode();
         }
         else {
-            fragmentSource = baseName.fragment || baseName;
+            this._pipelineContext = cachedPipeline;
+            this._pipelineContext.setEngine(this._engine);
+            this._onRenderingStateCompiled(this._pipelineContext);
+            // rebuildRebind for spector
+            if (this._pipelineContext.program) {
+                this._pipelineContext.program.__SPECTOR_rebuildProgram = this._rebuildProgram.bind(this);
+            }
         }
+    }
+    /** @internal */
+    _processShaderCode(shaderProcessor = null, keepExistingPipelineContext = false) {
         this._processingContext = this._engine._getShaderProcessingContext(this._shaderLanguage);
-        let processorOptions = {
+        const processorOptions = {
             defines: this.defines.split("\n"),
             indexParameters: this._indexParameters,
             isFragment: false,
@@ -210,52 +199,11 @@ export class Effect {
             useReverseDepthBuffer: this._engine.useReverseDepthBuffer,
             processCodeAfterIncludes: this._processCodeAfterIncludes,
         };
-        const shaderCodes = [undefined, undefined];
-        const shadersLoaded = () => {
-            if (shaderCodes[0] && shaderCodes[1]) {
-                processorOptions.isFragment = true;
-                const [migratedVertexCode, fragmentCode] = shaderCodes;
-                ShaderProcessor.Process(fragmentCode, processorOptions, (migratedFragmentCode, codeBeforeMigration) => {
-                    this._fragmentSourceCodeBeforeMigration = codeBeforeMigration;
-                    if (this._processFinalCode) {
-                        migratedFragmentCode = this._processFinalCode("fragment", migratedFragmentCode);
-                    }
-                    const finalShaders = ShaderProcessor.Finalize(migratedVertexCode, migratedFragmentCode, processorOptions);
-                    processorOptions = null;
-                    this._useFinalCode(finalShaders.vertexCode, finalShaders.fragmentCode, baseName, keepExistingPipelineContext);
-                }, this._engine);
-            }
-        };
-        this._loadShader(vertexSource, "Vertex", "", (vertexCode) => {
-            ShaderProcessor.Initialize(processorOptions);
-            ShaderProcessor.Process(vertexCode, processorOptions, (migratedVertexCode, codeBeforeMigration) => {
-                this._rawVertexSourceCode = vertexCode;
-                this._vertexSourceCodeBeforeMigration = codeBeforeMigration;
-                if (this._processFinalCode) {
-                    migratedVertexCode = this._processFinalCode("vertex", migratedVertexCode);
-                }
-                shaderCodes[0] = migratedVertexCode;
-                shadersLoaded();
-            }, this._engine);
-        });
-        this._loadShader(fragmentSource, "Fragment", "Pixel", (fragmentCode) => {
-            this._rawFragmentSourceCode = fragmentCode;
-            shaderCodes[1] = fragmentCode;
-            shadersLoaded();
-        });
-    }
-    _useFinalCode(migratedVertexCode, migratedFragmentCode, baseName, keepExistingPipelineContext = false) {
-        if (baseName) {
-            const vertex = baseName.vertexElement || baseName.vertex || baseName.spectorName || baseName;
-            const fragment = baseName.fragmentElement || baseName.fragment || baseName.spectorName || baseName;
-            this._vertexSourceCode = (this._shaderLanguage === ShaderLanguage.WGSL ? "//" : "") + "#define SHADER_NAME vertex:" + vertex + "\n" + migratedVertexCode;
-            this._fragmentSourceCode = (this._shaderLanguage === ShaderLanguage.WGSL ? "//" : "") + "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-        }
-        else {
+        _processShaderCode(processorOptions, this.name, this._processFinalCode, (migratedVertexCode, migratedFragmentCode) => {
             this._vertexSourceCode = migratedVertexCode;
             this._fragmentSourceCode = migratedFragmentCode;
-        }
-        this._prepareEffect(keepExistingPipelineContext);
+            this._prepareEffect(keepExistingPipelineContext);
+        }, this._shaderLanguage, this._engine, this);
     }
     /**
      * Unique key for this effect
@@ -421,46 +369,6 @@ export class Effect {
             this._checkIsReady(previousPipelineContext);
         }, 16);
     }
-    _loadShader(shader, key, optionalKey, callback) {
-        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 = EngineShaderStore.GetShadersStore(this._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 = EngineShaderStore.GetShadersRepository(this._shaderLanguage) + shader;
-        }
-        // Vertex shader
-        this._engine._loadFile(shaderUrl + "." + key.toLowerCase() + ".fx", callback);
-    }
     /**
      * 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)
@@ -507,6 +415,26 @@ export class Effect {
     get rawFragmentSourceCode() {
         return this._rawFragmentSourceCode;
     }
+    getPipelineGenerationOptions() {
+        return {
+            platformName: this._engine.shaderPlatformName,
+            shaderLanguage: this._shaderLanguage,
+            shaderNameOrContent: this.name,
+            key: this._key,
+            defines: this.defines.split("\n"),
+            addGlobalDefines: false,
+            extendedProcessingOptions: {
+                indexParameters: this._indexParameters,
+                isNDCHalfZRange: this._engine.isNDCHalfZRange,
+                useReverseDepthBuffer: this._engine.useReverseDepthBuffer,
+                supportsUniformBuffers: this._engine.supportsUniformBuffers,
+            },
+            extendedCreatePipelineOptions: {
+                transformFeedbackVaryings: this._transformFeedbackVaryings,
+                createAsRaw: !!(this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride),
+            },
+        };
+    }
     /**
      * Recompiles the webGL program
      * @param vertexSourceCode The source code for the vertex shader.
@@ -536,52 +464,65 @@ export class Effect {
         this._fallbacks = null;
         this._prepareEffect();
     }
+    _onRenderingStateCompiled(pipelineContext) {
+        this._pipelineContext = pipelineContext;
+        this._pipelineContext.setEngine(this._engine);
+        this._attributes = [];
+        this._pipelineContext._fillEffectInformation(this, this._uniformBuffersNames, this._uniformsNames, this._uniforms, this._samplerList, this._samplers, this._attributesNames, this._attributes);
+        // Caches attribute locations.
+        if (this._attributesNames) {
+            for (let i = 0; i < this._attributesNames.length; i++) {
+                const name = this._attributesNames[i];
+                this._attributeLocationByName[name] = this._attributes[i];
+            }
+        }
+        this._engine.bindSamplers(this);
+        this._compilationError = "";
+        this._isReady = true;
+        if (this.onCompiled) {
+            this.onCompiled(this);
+        }
+        this.onCompileObservable.notifyObservers(this);
+        this.onCompileObservable.clear();
+        // Unbind mesh reference in fallbacks
+        if (this._fallbacks) {
+            this._fallbacks.unBindMesh();
+        }
+    }
     /**
      * Prepares the effect
      * @internal
      */
     _prepareEffect(keepExistingPipelineContext = false) {
-        const attributesNames = this._attributesNames;
-        const defines = this.defines;
         const previousPipelineContext = this._pipelineContext;
         this._isReady = false;
         try {
+            const overrides = !!(this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride);
+            const defines = overrides ? null : this.defines;
+            const vertex = overrides ? this._vertexSourceCodeOverride : this._vertexSourceCode;
+            const fragment = overrides ? this._fragmentSourceCodeOverride : this._fragmentSourceCode;
             const engine = this._engine;
-            this._pipelineContext = (keepExistingPipelineContext ? previousPipelineContext : undefined) ?? engine.createPipelineContext(this._processingContext);
-            this._pipelineContext._name = this._key.replace(/\r/g, "").replace(/\n/g, "|");
-            const rebuildRebind = (vertexSourceCode, fragmentSourceCode, onCompiled, onError) => this._rebuildProgram(vertexSourceCode, fragmentSourceCode, onCompiled, onError);
-            if (this._vertexSourceCodeOverride && this._fragmentSourceCodeOverride) {
-                engine._preparePipelineContext(this._pipelineContext, this._vertexSourceCodeOverride, this._fragmentSourceCodeOverride, true, this._rawVertexSourceCode, this._rawFragmentSourceCode, rebuildRebind, null, this._transformFeedbackVaryings, this._key);
-            }
-            else {
-                engine._preparePipelineContext(this._pipelineContext, this._vertexSourceCode, this._fragmentSourceCode, false, this._rawVertexSourceCode, this._rawFragmentSourceCode, rebuildRebind, defines, this._transformFeedbackVaryings, this._key);
-            }
-            engine._executeWhenRenderingStateIsCompiled(this._pipelineContext, () => {
-                this._attributes = [];
-                this._pipelineContext._fillEffectInformation(this, this._uniformBuffersNames, this._uniformsNames, this._uniforms, this._samplerList, this._samplers, attributesNames, this._attributes);
-                // Caches attribute locations.
-                if (attributesNames) {
-                    for (let i = 0; i < attributesNames.length; i++) {
-                        const name = attributesNames[i];
-                        this._attributeLocationByName[name] = this._attributes[i];
+            this._pipelineContext = createAndPreparePipelineContext({
+                existingPipelineContext: keepExistingPipelineContext ? previousPipelineContext : null,
+                vertex,
+                fragment,
+                context: engine.shaderPlatformName === "WEBGL2" ? engine._gl : undefined,
+                rebuildRebind: (vertexSourceCode, fragmentSourceCode, onCompiled, onError) => this._rebuildProgram(vertexSourceCode, fragmentSourceCode, onCompiled, onError),
+                defines,
+                transformFeedbackVaryings: this._transformFeedbackVaryings,
+                name: this._key.replace(/\r/g, "").replace(/\n/g, "|"),
+                createAsRaw: overrides,
+                parallelShaderCompile: engine._caps.parallelShaderCompile,
+                shaderProcessingContext: this._processingContext,
+                onRenderingStateCompiled: (pipelineContext) => {
+                    if (previousPipelineContext && !keepExistingPipelineContext) {
+                        this._engine._deletePipelineContext(previousPipelineContext);
                     }
-                }
-                engine.bindSamplers(this);
-                this._compilationError = "";
-                this._isReady = true;
-                if (this.onCompiled) {
-                    this.onCompiled(this);
-                }
-                this.onCompileObservable.notifyObservers(this);
-                this.onCompileObservable.clear();
-                // Unbind mesh reference in fallbacks
-                if (this._fallbacks) {
-                    this._fallbacks.unBindMesh();
-                }
-                if (previousPipelineContext && !keepExistingPipelineContext) {
-                    this.getEngine()._deletePipelineContext(previousPipelineContext);
-                }
-            });
+                    if (pipelineContext) {
+                        this._onRenderingStateCompiled(pipelineContext);
+                    }
+                },
+            }, this._engine.createPipelineContext.bind(this._engine), this._engine._preparePipelineContext.bind(this._engine));
             if (this._pipelineContext.isAsync) {
                 this._checkIsReady(previousPipelineContext);
             }
@@ -1201,7 +1142,7 @@ export class Effect {
      **/
     dispose() {
         if (this._pipelineContext) {
-            this._pipelineContext.dispose();
+            resetCachedPipeline(this._pipelineContext);
         }
         this._engine._releaseEffect(this);
         this._isDisposed = true;