ShaderNode reuse

src/Engines/Processors/shaderProcessingOptions.ts

@@ -2,7 +2,7 @@ import { IShaderProcessor } from './iShaderProcessor';
 
 /** @hidden */
 export interface ProcessingOptions {
-    defines: string;
+    defines: string[];
     indexParameters: any;
     isFragment: boolean;
     shouldUseHighPrecisionShader: boolean;

src/Engines/Processors/shaderProcessor.ts

@@ -203,13 +203,29 @@ export class ShaderProcessor {
         cursor.lineIndex = -1;
         cursor.lines = sourceCode.split("\n");
 
-        // Decompose
+        // Decompose (We keep it in 2 steps so it is easier to maintain and perf hit is insignificant)
         this._MoveCursor(cursor, rootNode);
 
         // Recompose
         return rootNode.process(preprocessors, options);
     }
 
+    private static _PreparePreProcessors(options: ProcessingOptions): { [key: string]: string } {
+        let defines = options.defines;
+        let preprocessors: { [key: string]: string } = {};
+
+        for (var define of defines) {
+            let keyValue = define.replace("#define", "").replace(";", "").trim();
+            let split = keyValue.split(" ");
+            preprocessors[split[0]] = split.length > 1 ? split[1] : "";
+        }
+
+        preprocessors["GL_ES"] = "true";
+        preprocessors["__VERSION__"] = options.version;
+
+        return preprocessors;
+    }
+
     private static _ProcessShaderConversion(sourceCode: string, options: ProcessingOptions): string {
 
         var preparedSourceCode = this._ProcessPrecision(sourceCode, options);
@@ -223,26 +239,18 @@ export class ShaderProcessor {
             return preparedSourceCode.replace("#version 300 es", "");
         }
 
-        let defines = options.defines.split("\n");
-
-        let preprocessors: { [key: string]: string } = {};
+        let defines = options.defines;
 
-        for (var define of defines) {
-            let keyValue = define.replace("#define", "").replace(";", "").trim();
-            let split = keyValue.split(" ");
-            preprocessors[split[0]] = split.length > 1 ? split[1] : "";
-        }
-
-        preprocessors["GL_ES"] = "true";
-        preprocessors["__VERSION__"] = options.version;
+        let preprocessors = this._PreparePreProcessors(options);
 
+        // General pre processing
         if (options.processor.preProcessor) {
             preparedSourceCode = options.processor.preProcessor(preparedSourceCode, defines, options.isFragment);
         }
 
         preparedSourceCode = this._EvaluatePreProcessors(preparedSourceCode, preprocessors, options);
 
-        // Add multiview setup to top of file when defined
+        // Post processing
         if (options.processor.postProcessor) {
             preparedSourceCode = options.processor.postProcessor(preparedSourceCode, defines, options.isFragment);
         }

src/Materials/effect.ts

@@ -349,7 +349,7 @@ export class Effect implements IDisposable {
         }
 
         let processorOptions = {
-            defines: this.defines,
+            defines: this.defines.split("\n"),
             indexParameters: this._indexParameters,
             isFragment: false,
             shouldUseHighPrecisionShader: this._engine._shouldUseHighPrecisionShader,
@@ -357,31 +357,36 @@ export class Effect implements IDisposable {
             supportsUniformBuffers: this._engine.supportsUniformBuffers,
             shadersRepository: Effect.ShadersRepository,
             includesShadersStore: Effect.IncludesShadersStore,
-            version: (this._engine.webGLVersion * 100).toString()
+            version: (this._engine.webGLVersion * 100).toString(),
         };
 
+
         this._loadVertexShader(vertexSource, (vertexCode) => {
             this._loadFragmentShader(fragmentSource, (fragmentCode) => {
                 ShaderProcessor.Process(vertexCode, processorOptions, (migratedVertexCode) => {
                     processorOptions.isFragment = true;
                     ShaderProcessor.Process(fragmentCode, processorOptions, (migratedFragmentCode) => {
-                        if (baseName) {
-                            var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                            var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-
-                            this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + migratedVertexCode;
-                            this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                        } else {
-                            this._vertexSourceCode = migratedVertexCode;
-                            this._fragmentSourceCode = migratedFragmentCode;
-                        }
-                        this._prepareEffect();
+                        this._useFinalCode(migratedVertexCode, migratedFragmentCode, baseName);
                     });
                 });
             });
         });
     }
 
+    private _useFinalCode(migratedVertexCode: string, migratedFragmentCode: string, baseName: any) {
+        if (baseName) {
+            var vertex = baseName.vertexElement || baseName.vertex || baseName;
+            var fragment = baseName.fragmentElement || baseName.fragment || baseName;
+
+            this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + migratedVertexCode;
+            this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
+        } else {
+            this._vertexSourceCode = migratedVertexCode;
+            this._fragmentSourceCode = migratedFragmentCode;
+        }
+        this._prepareEffect();
+    }
+
     /**
      * Unique key for this effect
      */