Sebastien Vandenberghe 7 лет назад
Родитель
Сommit
6194ef9fef
30 измененных файлов с 44158 добавлено и 44443 удалено
  1. 17262 17266
      Playground/babylon.d.txt
  2. 10510 10514
      dist/preview release/babylon.d.ts
  3. 52 52
      dist/preview release/babylon.js
  4. 110 154
      dist/preview release/babylon.max.js
  5. 53 53
      dist/preview release/babylon.worker.js
  6. 15466 15470
      dist/preview release/customConfigurations/minimalGLTFViewer/babylon.d.ts
  7. 54 54
      dist/preview release/customConfigurations/minimalGLTFViewer/babylon.js
  8. 111 155
      dist/preview release/customConfigurations/minimalGLTFViewer/babylon.max.js
  9. 111 155
      dist/preview release/customConfigurations/minimalGLTFViewer/es6.js
  10. 110 154
      dist/preview release/es6.js
  11. 4 4
      dist/preview release/gui/babylon.gui.min.js
  12. 4 4
      dist/preview release/inspector/babylon.inspector.bundle.js
  13. 3 3
      dist/preview release/inspector/babylon.inspector.min.js
  14. 2 2
      dist/preview release/loaders/babylon.glTF1FileLoader.min.js
  15. 2 2
      dist/preview release/loaders/babylon.glTF2FileLoader.min.js
  16. 3 3
      dist/preview release/loaders/babylon.glTFFileLoader.min.js
  17. 1 1
      dist/preview release/loaders/babylon.objFileLoader.min.js
  18. 3 3
      dist/preview release/loaders/babylonjs.loaders.min.js
  19. 1 1
      dist/preview release/materialsLibrary/babylon.customMaterial.min.js
  20. 1 1
      dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.min.js
  21. 1 1
      dist/preview release/materialsLibrary/babylon.waterMaterial.min.js
  22. 3 3
      dist/preview release/materialsLibrary/babylonjs.materials.min.js
  23. 1 1
      dist/preview release/postProcessesLibrary/babylon.asciiArtPostProcess.min.js
  24. 1 1
      dist/preview release/postProcessesLibrary/babylon.digitalRainPostProcess.min.js
  25. 1 1
      dist/preview release/postProcessesLibrary/babylonjs.postProcess.min.js
  26. 1 1
      dist/preview release/serializers/babylon.glTF2Serializer.min.js
  27. 1 1
      dist/preview release/serializers/babylonjs.serializers.min.js
  28. 60 60
      dist/preview release/viewer/babylon.viewer.js
  29. 111 155
      dist/preview release/viewer/babylon.viewer.max.js
  30. 115 168
      src/Materials/babylon.effect.ts

Разница между файлами не показана из-за своего большого размера
+ 17262 - 17266
Playground/babylon.d.txt


Разница между файлами не показана из-за своего большого размера
+ 10510 - 10514
dist/preview release/babylon.d.ts


Разница между файлами не показана из-за своего большого размера
+ 52 - 52
dist/preview release/babylon.js


+ 110 - 154
dist/preview release/babylon.max.js

@@ -221,10 +221,6 @@ var BABYLON;
                 this._fallbacks = fallbacks;
             }
             this.uniqueId = Effect._uniqueIdSeed++;
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
             var vertexSource;
             var fragmentSource;
             if (baseName.vertexElement) {
@@ -245,71 +241,30 @@ var BABYLON;
             else {
                 fragmentSource = baseName.fragment || baseName;
             }
-            var finalVertexCode;
-            this._loadVertexShaderAsync(vertexSource)
-                .then(function (vertexCode) {
-                return _this._processIncludesAsync(vertexCode);
-            })
-                .then(function (vertexCodeWithIncludes) {
-                finalVertexCode = _this._processShaderConversion(vertexCodeWithIncludes, false);
-                return _this._loadFragmentShaderAsync(fragmentSource);
-            })
-                .then(function (fragmentCode) {
-                return _this._processIncludesAsync(fragmentCode);
-            })
-                .then(function (fragmentCodeWithIncludes) {
-                var migratedFragmentCode = _this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-                    _this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    _this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                }
-                else {
-                    _this._vertexSourceCode = finalVertexCode;
-                    _this._fragmentSourceCode = migratedFragmentCode;
-                }
-                _this._setInCache(baseName);
-                _this._prepareEffect();
+            this._loadVertexShader(vertexSource, function (vertexCode) {
+                _this._processIncludes(vertexCode, function (vertexCodeWithIncludes) {
+                    _this._processShaderConversion(vertexCodeWithIncludes, false, function (migratedVertexCode) {
+                        _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
+                            _this._processIncludes(fragmentCode, function (fragmentCodeWithIncludes) {
+                                _this._processShaderConversion(fragmentCodeWithIncludes, true, function (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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
-        Effect.prototype._getSourceCacheKey = function (baseName) {
-            var cacheKey = baseName;
-            if (this._indexParameters) {
-                for (var key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key;
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-            return cacheKey;
-        };
-        Effect.prototype._getFromCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            var sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        };
-        Effect.prototype._setInCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        };
         Object.defineProperty(Effect.prototype, "key", {
             /**
              * Unique key for this effect
@@ -416,22 +371,25 @@ var BABYLON;
             });
         };
         /** @ignore */
-        Effect.prototype._loadVertexShaderAsync = function (vertex) {
+        Effect.prototype._loadVertexShader = function (vertex, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = BABYLON.Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
             var vertexShaderUrl;
             if (vertex[0] === "." || vertex[0] === "/" || vertex.indexOf("http") > -1) {
@@ -441,28 +399,32 @@ var BABYLON;
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
         /** @ignore */
-        Effect.prototype._loadFragmentShaderAsync = function (fragment) {
+        Effect.prototype._loadFragmentShader = function (fragment, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = BABYLON.Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
             var fragmentShaderUrl;
             if (fragment[0] === "." || fragment[0] === "/" || fragment.indexOf("http") > -1) {
@@ -472,7 +434,7 @@ var BABYLON;
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
         Effect.prototype._dumpShadersSource = function (vertexCode, fragmentCode, defines) {
             // Rebuild shaders source code
@@ -501,14 +463,16 @@ var BABYLON;
             }
         };
         ;
-        Effect.prototype._processShaderConversion = function (sourceCode, isFragment) {
+        Effect.prototype._processShaderConversion = function (sourceCode, isFragment, callback) {
             var preparedSourceCode = this._processPrecision(sourceCode);
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
             // Remove extensions 
@@ -532,86 +496,80 @@ var BABYLON;
                 result = result.replace(/gl_FragData/g, "glFragData");
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
-            return result;
+            callback(result);
         };
-        Effect.prototype._processIncludesAsync = function (sourceCode) {
+        Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            return new Promise(function (resolve, reject) {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
-                var returnValue = sourceCode;
-                while (match != null) {
-                    var includeFile = match[1];
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (_this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
-                    }
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
-                                includeContent = includeContent.replace(source, dest);
-                            }
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
+            var returnValue = new String(sourceCode);
+            while (match != null) {
+                var includeFile = match[1];
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
+                    }
+                    includeFile = includeFile + "Declaration";
+                }
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
+                            includeContent = includeContent.replace(source, dest);
                         }
-                        if (match[4]) {
-                            var indexString = match[5];
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = _this._indexParameters[indexSplits[1]];
-                                }
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!_this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
+                    }
+                    if (match[4]) {
+                        var indexString = match[5];
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
                             }
-                            else {
-                                if (!_this._engine.supportsUniformBuffers) {
+                            for (var i = minIndex; i < maxIndex; i++) {
+                                if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
                         }
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    }
-                    else {
-                        var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-                        _this._engine._loadFileAsync(includeShaderUrl)
-                            .then(function (fileContent) {
-                            Effect.IncludesShadersStore[includeFile] = fileContent;
-                            return _this._processIncludesAsync(returnValue);
-                        })
-                            .then(function (returnValue) {
-                            resolve(returnValue);
-                        });
-                        return;
+                        else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
+                        }
                     }
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
                 }
-                resolve(returnValue);
-            });
+                else {
+                    var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+                    this._engine._loadFile(includeShaderUrl, function (fileContent) {
+                        Effect.IncludesShadersStore[includeFile] = fileContent;
+                        _this._processIncludes(returnValue, callback);
+                    });
+                    return;
+                }
+                match = regex.exec(sourceCode);
+            }
+            callback(returnValue);
         };
         Effect.prototype._processPrecision = function (source) {
             if (source.indexOf("precision highp float") === -1) {
@@ -803,8 +761,7 @@ var BABYLON;
             this._engine.setTextureArray(this._samplers.indexOf(channel), this.getUniform(channel), textures);
         };
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -812,7 +769,8 @@ var BABYLON;
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1264,8 +1222,6 @@ var BABYLON;
         };
         Effect._uniqueIdSeed = 0;
         Effect._baseCache = {};
-        Effect._sourceCache = {};
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */

Разница между файлами не показана из-за своего большого размера
+ 53 - 53
dist/preview release/babylon.worker.js


Разница между файлами не показана из-за своего большого размера
+ 15466 - 15470
dist/preview release/customConfigurations/minimalGLTFViewer/babylon.d.ts


Разница между файлами не показана из-за своего большого размера
+ 54 - 54
dist/preview release/customConfigurations/minimalGLTFViewer/babylon.js


+ 111 - 155
dist/preview release/customConfigurations/minimalGLTFViewer/babylon.max.js

@@ -221,10 +221,6 @@ var BABYLON;
                 this._fallbacks = fallbacks;
             }
             this.uniqueId = Effect._uniqueIdSeed++;
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
             var vertexSource;
             var fragmentSource;
             if (baseName.vertexElement) {
@@ -245,71 +241,30 @@ var BABYLON;
             else {
                 fragmentSource = baseName.fragment || baseName;
             }
-            var finalVertexCode;
-            this._loadVertexShaderAsync(vertexSource)
-                .then(function (vertexCode) {
-                return _this._processIncludesAsync(vertexCode);
-            })
-                .then(function (vertexCodeWithIncludes) {
-                finalVertexCode = _this._processShaderConversion(vertexCodeWithIncludes, false);
-                return _this._loadFragmentShaderAsync(fragmentSource);
-            })
-                .then(function (fragmentCode) {
-                return _this._processIncludesAsync(fragmentCode);
-            })
-                .then(function (fragmentCodeWithIncludes) {
-                var migratedFragmentCode = _this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-                    _this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    _this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                }
-                else {
-                    _this._vertexSourceCode = finalVertexCode;
-                    _this._fragmentSourceCode = migratedFragmentCode;
-                }
-                _this._setInCache(baseName);
-                _this._prepareEffect();
+            this._loadVertexShader(vertexSource, function (vertexCode) {
+                _this._processIncludes(vertexCode, function (vertexCodeWithIncludes) {
+                    _this._processShaderConversion(vertexCodeWithIncludes, false, function (migratedVertexCode) {
+                        _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
+                            _this._processIncludes(fragmentCode, function (fragmentCodeWithIncludes) {
+                                _this._processShaderConversion(fragmentCodeWithIncludes, true, function (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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
-        Effect.prototype._getSourceCacheKey = function (baseName) {
-            var cacheKey = baseName;
-            if (this._indexParameters) {
-                for (var key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key;
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-            return cacheKey;
-        };
-        Effect.prototype._getFromCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            var sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        };
-        Effect.prototype._setInCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        };
         Object.defineProperty(Effect.prototype, "key", {
             /**
              * Unique key for this effect
@@ -416,22 +371,25 @@ var BABYLON;
             });
         };
         /** @ignore */
-        Effect.prototype._loadVertexShaderAsync = function (vertex) {
+        Effect.prototype._loadVertexShader = function (vertex, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = BABYLON.Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
             var vertexShaderUrl;
             if (vertex[0] === "." || vertex[0] === "/" || vertex.indexOf("http") > -1) {
@@ -441,28 +399,32 @@ var BABYLON;
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
         /** @ignore */
-        Effect.prototype._loadFragmentShaderAsync = function (fragment) {
+        Effect.prototype._loadFragmentShader = function (fragment, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = BABYLON.Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
             var fragmentShaderUrl;
             if (fragment[0] === "." || fragment[0] === "/" || fragment.indexOf("http") > -1) {
@@ -472,7 +434,7 @@ var BABYLON;
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
         Effect.prototype._dumpShadersSource = function (vertexCode, fragmentCode, defines) {
             // Rebuild shaders source code
@@ -501,14 +463,16 @@ var BABYLON;
             }
         };
         ;
-        Effect.prototype._processShaderConversion = function (sourceCode, isFragment) {
+        Effect.prototype._processShaderConversion = function (sourceCode, isFragment, callback) {
             var preparedSourceCode = this._processPrecision(sourceCode);
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
             // Remove extensions 
@@ -532,86 +496,80 @@ var BABYLON;
                 result = result.replace(/gl_FragData/g, "glFragData");
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
-            return result;
+            callback(result);
         };
-        Effect.prototype._processIncludesAsync = function (sourceCode) {
+        Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            return new Promise(function (resolve, reject) {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
-                var returnValue = sourceCode;
-                while (match != null) {
-                    var includeFile = match[1];
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (_this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
-                    }
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
-                                includeContent = includeContent.replace(source, dest);
-                            }
-                        }
-                        if (match[4]) {
-                            var indexString = match[5];
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = _this._indexParameters[indexSplits[1]];
-                                }
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!_this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
+            var returnValue = new String(sourceCode);
+            while (match != null) {
+                var includeFile = match[1];
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
+                    }
+                    includeFile = includeFile + "Declaration";
+                }
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
+                            includeContent = includeContent.replace(source, dest);
+                        }
+                    }
+                    if (match[4]) {
+                        var indexString = match[5];
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
                             }
-                            else {
-                                if (!_this._engine.supportsUniformBuffers) {
+                            for (var i = minIndex; i < maxIndex; i++) {
+                                if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
                         }
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    }
-                    else {
-                        var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-                        _this._engine._loadFileAsync(includeShaderUrl)
-                            .then(function (fileContent) {
-                            Effect.IncludesShadersStore[includeFile] = fileContent;
-                            return _this._processIncludesAsync(returnValue);
-                        })
-                            .then(function (returnValue) {
-                            resolve(returnValue);
-                        });
-                        return;
+                        else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
+                        }
                     }
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
                 }
-                resolve(returnValue);
-            });
+                else {
+                    var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+                    this._engine._loadFile(includeShaderUrl, function (fileContent) {
+                        Effect.IncludesShadersStore[includeFile] = fileContent;
+                        _this._processIncludes(returnValue, callback);
+                    });
+                    return;
+                }
+                match = regex.exec(sourceCode);
+            }
+            callback(returnValue);
         };
         Effect.prototype._processPrecision = function (source) {
             if (source.indexOf("precision highp float") === -1) {
@@ -803,8 +761,7 @@ var BABYLON;
             this._engine.setTextureArray(this._samplers.indexOf(channel), this.getUniform(channel), textures);
         };
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -812,7 +769,8 @@ var BABYLON;
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1264,8 +1222,6 @@ var BABYLON;
         };
         Effect._uniqueIdSeed = 0;
         Effect._baseCache = {};
-        Effect._sourceCache = {};
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */

+ 111 - 155
dist/preview release/customConfigurations/minimalGLTFViewer/es6.js

@@ -193,10 +193,6 @@ var BABYLON;
                 this._fallbacks = fallbacks;
             }
             this.uniqueId = Effect._uniqueIdSeed++;
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
             var vertexSource;
             var fragmentSource;
             if (baseName.vertexElement) {
@@ -217,71 +213,30 @@ var BABYLON;
             else {
                 fragmentSource = baseName.fragment || baseName;
             }
-            var finalVertexCode;
-            this._loadVertexShaderAsync(vertexSource)
-                .then(function (vertexCode) {
-                return _this._processIncludesAsync(vertexCode);
-            })
-                .then(function (vertexCodeWithIncludes) {
-                finalVertexCode = _this._processShaderConversion(vertexCodeWithIncludes, false);
-                return _this._loadFragmentShaderAsync(fragmentSource);
-            })
-                .then(function (fragmentCode) {
-                return _this._processIncludesAsync(fragmentCode);
-            })
-                .then(function (fragmentCodeWithIncludes) {
-                var migratedFragmentCode = _this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-                    _this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    _this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                }
-                else {
-                    _this._vertexSourceCode = finalVertexCode;
-                    _this._fragmentSourceCode = migratedFragmentCode;
-                }
-                _this._setInCache(baseName);
-                _this._prepareEffect();
+            this._loadVertexShader(vertexSource, function (vertexCode) {
+                _this._processIncludes(vertexCode, function (vertexCodeWithIncludes) {
+                    _this._processShaderConversion(vertexCodeWithIncludes, false, function (migratedVertexCode) {
+                        _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
+                            _this._processIncludes(fragmentCode, function (fragmentCodeWithIncludes) {
+                                _this._processShaderConversion(fragmentCodeWithIncludes, true, function (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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
-        Effect.prototype._getSourceCacheKey = function (baseName) {
-            var cacheKey = baseName;
-            if (this._indexParameters) {
-                for (var key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key;
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-            return cacheKey;
-        };
-        Effect.prototype._getFromCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            var sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        };
-        Effect.prototype._setInCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        };
         Object.defineProperty(Effect.prototype, "key", {
             /**
              * Unique key for this effect
@@ -388,22 +343,25 @@ var BABYLON;
             });
         };
         /** @ignore */
-        Effect.prototype._loadVertexShaderAsync = function (vertex) {
+        Effect.prototype._loadVertexShader = function (vertex, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = BABYLON.Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
             var vertexShaderUrl;
             if (vertex[0] === "." || vertex[0] === "/" || vertex.indexOf("http") > -1) {
@@ -413,28 +371,32 @@ var BABYLON;
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
         /** @ignore */
-        Effect.prototype._loadFragmentShaderAsync = function (fragment) {
+        Effect.prototype._loadFragmentShader = function (fragment, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = BABYLON.Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
             var fragmentShaderUrl;
             if (fragment[0] === "." || fragment[0] === "/" || fragment.indexOf("http") > -1) {
@@ -444,7 +406,7 @@ var BABYLON;
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
         Effect.prototype._dumpShadersSource = function (vertexCode, fragmentCode, defines) {
             // Rebuild shaders source code
@@ -473,14 +435,16 @@ var BABYLON;
             }
         };
         ;
-        Effect.prototype._processShaderConversion = function (sourceCode, isFragment) {
+        Effect.prototype._processShaderConversion = function (sourceCode, isFragment, callback) {
             var preparedSourceCode = this._processPrecision(sourceCode);
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
             // Remove extensions 
@@ -504,86 +468,80 @@ var BABYLON;
                 result = result.replace(/gl_FragData/g, "glFragData");
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
-            return result;
+            callback(result);
         };
-        Effect.prototype._processIncludesAsync = function (sourceCode) {
+        Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            return new Promise(function (resolve, reject) {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
-                var returnValue = sourceCode;
-                while (match != null) {
-                    var includeFile = match[1];
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (_this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
-                    }
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
-                                includeContent = includeContent.replace(source, dest);
-                            }
-                        }
-                        if (match[4]) {
-                            var indexString = match[5];
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = _this._indexParameters[indexSplits[1]];
-                                }
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!_this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
+            var returnValue = new String(sourceCode);
+            while (match != null) {
+                var includeFile = match[1];
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
+                    }
+                    includeFile = includeFile + "Declaration";
+                }
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
+                            includeContent = includeContent.replace(source, dest);
+                        }
+                    }
+                    if (match[4]) {
+                        var indexString = match[5];
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
                             }
-                            else {
-                                if (!_this._engine.supportsUniformBuffers) {
+                            for (var i = minIndex; i < maxIndex; i++) {
+                                if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
                         }
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    }
-                    else {
-                        var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-                        _this._engine._loadFileAsync(includeShaderUrl)
-                            .then(function (fileContent) {
-                            Effect.IncludesShadersStore[includeFile] = fileContent;
-                            return _this._processIncludesAsync(returnValue);
-                        })
-                            .then(function (returnValue) {
-                            resolve(returnValue);
-                        });
-                        return;
+                        else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
+                        }
                     }
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
                 }
-                resolve(returnValue);
-            });
+                else {
+                    var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+                    this._engine._loadFile(includeShaderUrl, function (fileContent) {
+                        Effect.IncludesShadersStore[includeFile] = fileContent;
+                        _this._processIncludes(returnValue, callback);
+                    });
+                    return;
+                }
+                match = regex.exec(sourceCode);
+            }
+            callback(returnValue);
         };
         Effect.prototype._processPrecision = function (source) {
             if (source.indexOf("precision highp float") === -1) {
@@ -775,8 +733,7 @@ var BABYLON;
             this._engine.setTextureArray(this._samplers.indexOf(channel), this.getUniform(channel), textures);
         };
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -784,7 +741,8 @@ var BABYLON;
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1236,8 +1194,6 @@ var BABYLON;
         };
         Effect._uniqueIdSeed = 0;
         Effect._baseCache = {};
-        Effect._sourceCache = {};
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */

+ 110 - 154
dist/preview release/es6.js

@@ -193,10 +193,6 @@ var BABYLON;
                 this._fallbacks = fallbacks;
             }
             this.uniqueId = Effect._uniqueIdSeed++;
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
             var vertexSource;
             var fragmentSource;
             if (baseName.vertexElement) {
@@ -217,71 +213,30 @@ var BABYLON;
             else {
                 fragmentSource = baseName.fragment || baseName;
             }
-            var finalVertexCode;
-            this._loadVertexShaderAsync(vertexSource)
-                .then(function (vertexCode) {
-                return _this._processIncludesAsync(vertexCode);
-            })
-                .then(function (vertexCodeWithIncludes) {
-                finalVertexCode = _this._processShaderConversion(vertexCodeWithIncludes, false);
-                return _this._loadFragmentShaderAsync(fragmentSource);
-            })
-                .then(function (fragmentCode) {
-                return _this._processIncludesAsync(fragmentCode);
-            })
-                .then(function (fragmentCodeWithIncludes) {
-                var migratedFragmentCode = _this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-                    _this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    _this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                }
-                else {
-                    _this._vertexSourceCode = finalVertexCode;
-                    _this._fragmentSourceCode = migratedFragmentCode;
-                }
-                _this._setInCache(baseName);
-                _this._prepareEffect();
+            this._loadVertexShader(vertexSource, function (vertexCode) {
+                _this._processIncludes(vertexCode, function (vertexCodeWithIncludes) {
+                    _this._processShaderConversion(vertexCodeWithIncludes, false, function (migratedVertexCode) {
+                        _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
+                            _this._processIncludes(fragmentCode, function (fragmentCodeWithIncludes) {
+                                _this._processShaderConversion(fragmentCodeWithIncludes, true, function (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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
-        Effect.prototype._getSourceCacheKey = function (baseName) {
-            var cacheKey = baseName;
-            if (this._indexParameters) {
-                for (var key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key;
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-            return cacheKey;
-        };
-        Effect.prototype._getFromCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            var sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        };
-        Effect.prototype._setInCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        };
         Object.defineProperty(Effect.prototype, "key", {
             /**
              * Unique key for this effect
@@ -388,22 +343,25 @@ var BABYLON;
             });
         };
         /** @ignore */
-        Effect.prototype._loadVertexShaderAsync = function (vertex) {
+        Effect.prototype._loadVertexShader = function (vertex, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = BABYLON.Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
             var vertexShaderUrl;
             if (vertex[0] === "." || vertex[0] === "/" || vertex.indexOf("http") > -1) {
@@ -413,28 +371,32 @@ var BABYLON;
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
         /** @ignore */
-        Effect.prototype._loadFragmentShaderAsync = function (fragment) {
+        Effect.prototype._loadFragmentShader = function (fragment, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = BABYLON.Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
             var fragmentShaderUrl;
             if (fragment[0] === "." || fragment[0] === "/" || fragment.indexOf("http") > -1) {
@@ -444,7 +406,7 @@ var BABYLON;
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
         Effect.prototype._dumpShadersSource = function (vertexCode, fragmentCode, defines) {
             // Rebuild shaders source code
@@ -473,14 +435,16 @@ var BABYLON;
             }
         };
         ;
-        Effect.prototype._processShaderConversion = function (sourceCode, isFragment) {
+        Effect.prototype._processShaderConversion = function (sourceCode, isFragment, callback) {
             var preparedSourceCode = this._processPrecision(sourceCode);
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
             // Remove extensions 
@@ -504,86 +468,80 @@ var BABYLON;
                 result = result.replace(/gl_FragData/g, "glFragData");
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
-            return result;
+            callback(result);
         };
-        Effect.prototype._processIncludesAsync = function (sourceCode) {
+        Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            return new Promise(function (resolve, reject) {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
-                var returnValue = sourceCode;
-                while (match != null) {
-                    var includeFile = match[1];
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (_this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
-                    }
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
-                                includeContent = includeContent.replace(source, dest);
-                            }
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
+            var returnValue = new String(sourceCode);
+            while (match != null) {
+                var includeFile = match[1];
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
+                    }
+                    includeFile = includeFile + "Declaration";
+                }
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
+                            includeContent = includeContent.replace(source, dest);
                         }
-                        if (match[4]) {
-                            var indexString = match[5];
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = _this._indexParameters[indexSplits[1]];
-                                }
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!_this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
+                    }
+                    if (match[4]) {
+                        var indexString = match[5];
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
                             }
-                            else {
-                                if (!_this._engine.supportsUniformBuffers) {
+                            for (var i = minIndex; i < maxIndex; i++) {
+                                if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
                         }
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    }
-                    else {
-                        var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-                        _this._engine._loadFileAsync(includeShaderUrl)
-                            .then(function (fileContent) {
-                            Effect.IncludesShadersStore[includeFile] = fileContent;
-                            return _this._processIncludesAsync(returnValue);
-                        })
-                            .then(function (returnValue) {
-                            resolve(returnValue);
-                        });
-                        return;
+                        else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
+                        }
                     }
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
                 }
-                resolve(returnValue);
-            });
+                else {
+                    var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+                    this._engine._loadFile(includeShaderUrl, function (fileContent) {
+                        Effect.IncludesShadersStore[includeFile] = fileContent;
+                        _this._processIncludes(returnValue, callback);
+                    });
+                    return;
+                }
+                match = regex.exec(sourceCode);
+            }
+            callback(returnValue);
         };
         Effect.prototype._processPrecision = function (source) {
             if (source.indexOf("precision highp float") === -1) {
@@ -775,8 +733,7 @@ var BABYLON;
             this._engine.setTextureArray(this._samplers.indexOf(channel), this.getUniform(channel), textures);
         };
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -784,7 +741,8 @@ var BABYLON;
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1236,8 +1194,6 @@ var BABYLON;
         };
         Effect._uniqueIdSeed = 0;
         Effect._baseCache = {};
-        Effect._sourceCache = {};
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */

Разница между файлами не показана из-за своего большого размера
+ 4 - 4
dist/preview release/gui/babylon.gui.min.js


Разница между файлами не показана из-за своего большого размера
+ 4 - 4
dist/preview release/inspector/babylon.inspector.bundle.js


Разница между файлами не показана из-за своего большого размера
+ 3 - 3
dist/preview release/inspector/babylon.inspector.min.js


Разница между файлами не показана из-за своего большого размера
+ 2 - 2
dist/preview release/loaders/babylon.glTF1FileLoader.min.js


Разница между файлами не показана из-за своего большого размера
+ 2 - 2
dist/preview release/loaders/babylon.glTF2FileLoader.min.js


Разница между файлами не показана из-за своего большого размера
+ 3 - 3
dist/preview release/loaders/babylon.glTFFileLoader.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/loaders/babylon.objFileLoader.min.js


Разница между файлами не показана из-за своего большого размера
+ 3 - 3
dist/preview release/loaders/babylonjs.loaders.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/materialsLibrary/babylon.customMaterial.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/materialsLibrary/babylon.waterMaterial.min.js


Разница между файлами не показана из-за своего большого размера
+ 3 - 3
dist/preview release/materialsLibrary/babylonjs.materials.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/postProcessesLibrary/babylon.asciiArtPostProcess.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/postProcessesLibrary/babylon.digitalRainPostProcess.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/postProcessesLibrary/babylonjs.postProcess.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/serializers/babylon.glTF2Serializer.min.js


Разница между файлами не показана из-за своего большого размера
+ 1 - 1
dist/preview release/serializers/babylonjs.serializers.min.js


Разница между файлами не показана из-за своего большого размера
+ 60 - 60
dist/preview release/viewer/babylon.viewer.js


+ 111 - 155
dist/preview release/viewer/babylon.viewer.max.js

@@ -309,10 +309,6 @@ var BABYLON;
                 this._fallbacks = fallbacks;
             }
             this.uniqueId = Effect._uniqueIdSeed++;
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
             var vertexSource;
             var fragmentSource;
             if (baseName.vertexElement) {
@@ -333,71 +329,30 @@ var BABYLON;
             else {
                 fragmentSource = baseName.fragment || baseName;
             }
-            var finalVertexCode;
-            this._loadVertexShaderAsync(vertexSource)
-                .then(function (vertexCode) {
-                return _this._processIncludesAsync(vertexCode);
-            })
-                .then(function (vertexCodeWithIncludes) {
-                finalVertexCode = _this._processShaderConversion(vertexCodeWithIncludes, false);
-                return _this._loadFragmentShaderAsync(fragmentSource);
-            })
-                .then(function (fragmentCode) {
-                return _this._processIncludesAsync(fragmentCode);
-            })
-                .then(function (fragmentCodeWithIncludes) {
-                var migratedFragmentCode = _this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-                    _this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    _this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                }
-                else {
-                    _this._vertexSourceCode = finalVertexCode;
-                    _this._fragmentSourceCode = migratedFragmentCode;
-                }
-                _this._setInCache(baseName);
-                _this._prepareEffect();
+            this._loadVertexShader(vertexSource, function (vertexCode) {
+                _this._processIncludes(vertexCode, function (vertexCodeWithIncludes) {
+                    _this._processShaderConversion(vertexCodeWithIncludes, false, function (migratedVertexCode) {
+                        _this._loadFragmentShader(fragmentSource, function (fragmentCode) {
+                            _this._processIncludes(fragmentCode, function (fragmentCodeWithIncludes) {
+                                _this._processShaderConversion(fragmentCodeWithIncludes, true, function (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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
-        Effect.prototype._getSourceCacheKey = function (baseName) {
-            var cacheKey = baseName;
-            if (this._indexParameters) {
-                for (var key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key;
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-            return cacheKey;
-        };
-        Effect.prototype._getFromCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            var sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        };
-        Effect.prototype._setInCache = function (baseName) {
-            if (typeof baseName !== "string") {
-                return;
-            }
-            var cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        };
         Object.defineProperty(Effect.prototype, "key", {
             /**
              * Unique key for this effect
@@ -504,22 +459,25 @@ var BABYLON;
             });
         };
         /** @ignore */
-        Effect.prototype._loadVertexShaderAsync = function (vertex) {
+        Effect.prototype._loadVertexShader = function (vertex, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = BABYLON.Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
             var vertexShaderUrl;
             if (vertex[0] === "." || vertex[0] === "/" || vertex.indexOf("http") > -1) {
@@ -529,28 +487,32 @@ var BABYLON;
                 vertexShaderUrl = BABYLON.Engine.ShadersRepository + vertex;
             }
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         };
         /** @ignore */
-        Effect.prototype._loadFragmentShaderAsync = function (fragment) {
+        Effect.prototype._loadFragmentShader = function (fragment, callback) {
             if (BABYLON.Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = BABYLON.Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
             var fragmentShaderUrl;
             if (fragment[0] === "." || fragment[0] === "/" || fragment.indexOf("http") > -1) {
@@ -560,7 +522,7 @@ var BABYLON;
                 fragmentShaderUrl = BABYLON.Engine.ShadersRepository + fragment;
             }
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         };
         Effect.prototype._dumpShadersSource = function (vertexCode, fragmentCode, defines) {
             // Rebuild shaders source code
@@ -589,14 +551,16 @@ var BABYLON;
             }
         };
         ;
-        Effect.prototype._processShaderConversion = function (sourceCode, isFragment) {
+        Effect.prototype._processShaderConversion = function (sourceCode, isFragment, callback) {
             var preparedSourceCode = this._processPrecision(sourceCode);
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
             // Remove extensions 
@@ -620,86 +584,80 @@ var BABYLON;
                 result = result.replace(/gl_FragData/g, "glFragData");
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
-            return result;
+            callback(result);
         };
-        Effect.prototype._processIncludesAsync = function (sourceCode) {
+        Effect.prototype._processIncludes = function (sourceCode, callback) {
             var _this = this;
-            return new Promise(function (resolve, reject) {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
-                var returnValue = sourceCode;
-                while (match != null) {
-                    var includeFile = match[1];
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (_this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
-                    }
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
-                                includeContent = includeContent.replace(source, dest);
-                            }
-                        }
-                        if (match[4]) {
-                            var indexString = match[5];
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = _this._indexParameters[indexSplits[1]];
-                                }
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!_this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
+            var returnValue = new String(sourceCode);
+            while (match != null) {
+                var includeFile = match[1];
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
+                    }
+                    includeFile = includeFile + "Declaration";
+                }
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
+                            includeContent = includeContent.replace(source, dest);
+                        }
+                    }
+                    if (match[4]) {
+                        var indexString = match[5];
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
                             }
-                            else {
-                                if (!_this._engine.supportsUniformBuffers) {
+                            for (var i = minIndex; i < maxIndex; i++) {
+                                if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
                         }
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    }
-                    else {
-                        var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-                        _this._engine._loadFileAsync(includeShaderUrl)
-                            .then(function (fileContent) {
-                            Effect.IncludesShadersStore[includeFile] = fileContent;
-                            return _this._processIncludesAsync(returnValue);
-                        })
-                            .then(function (returnValue) {
-                            resolve(returnValue);
-                        });
-                        return;
+                        else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, function (str, p1) {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
+                        }
                     }
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
                 }
-                resolve(returnValue);
-            });
+                else {
+                    var includeShaderUrl = BABYLON.Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+                    this._engine._loadFile(includeShaderUrl, function (fileContent) {
+                        Effect.IncludesShadersStore[includeFile] = fileContent;
+                        _this._processIncludes(returnValue, callback);
+                    });
+                    return;
+                }
+                match = regex.exec(sourceCode);
+            }
+            callback(returnValue);
         };
         Effect.prototype._processPrecision = function (source) {
             if (source.indexOf("precision highp float") === -1) {
@@ -891,8 +849,7 @@ var BABYLON;
             this._engine.setTextureArray(this._samplers.indexOf(channel), this.getUniform(channel), textures);
         };
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -900,7 +857,8 @@ var BABYLON;
             this._engine.setTextureFromPostProcess(this._samplers.indexOf(channel), postProcess);
         };
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1352,8 +1310,6 @@ var BABYLON;
         };
         Effect._uniqueIdSeed = 0;
         Effect._baseCache = {};
-        Effect._sourceCache = {};
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */

+ 115 - 168
src/Materials/babylon.effect.ts

@@ -1,6 +1,6 @@
 module BABYLON {
     /**
-	 * EffectFallbacks can be used to add fallbacks (properties to disable) to certain properties when desired to improve performance.
+     * EffectFallbacks can be used to add fallbacks (properties to disable) to certain properties when desired to improve performance.
      * (Eg. Start at high quality with reflection and fog, if fps is low, remove reflection, if still low remove fog)
      */
     export class EffectFallbacks {
@@ -116,7 +116,7 @@
     }
 
     /**
-	 * Options to be used when creating an effect.
+     * Options to be used when creating an effect.
      */
     export class EffectCreationOptions {
         /**
@@ -227,7 +227,6 @@
         private _vertexSourceCodeOverride: string;
         private _fragmentSourceCodeOverride: string;
         private _transformFeedbackVaryings: Nullable<string[]>;
-
         /**
          * Compiled shader to webGL program.
          */
@@ -288,11 +287,6 @@
 
             this.uniqueId = Effect._uniqueIdSeed++;
 
-            if (this._getFromCache(baseName)) {
-                this._prepareEffect();
-                return;
-            }
-
             var vertexSource: any;
             var fragmentSource: any;
 
@@ -316,83 +310,31 @@
                 fragmentSource = baseName.fragment || baseName;
             }
 
-            let finalVertexCode: string;
-
-            this._loadVertexShaderAsync(vertexSource)
-            .then((vertexCode) => {
-                return this._processIncludesAsync(vertexCode);
-            })
-            .then((vertexCodeWithIncludes) => {
-                finalVertexCode = this._processShaderConversion(vertexCodeWithIncludes, false);
-                return this._loadFragmentShaderAsync(fragmentSource);
-            })
-            .then((fragmentCode) => {
-                return this._processIncludesAsync(fragmentCode);
-            })
-            .then((fragmentCodeWithIncludes) => {
-                let migratedFragmentCode = this._processShaderConversion(fragmentCodeWithIncludes, true);
-                if (baseName) {
-                    var vertex = baseName.vertexElement || baseName.vertex || baseName;
-                    var fragment = baseName.fragmentElement || baseName.fragment || baseName;
-
-                    this._vertexSourceCode = "#define SHADER_NAME vertex:" + vertex + "\n" + finalVertexCode;
-                    this._fragmentSourceCode = "#define SHADER_NAME fragment:" + fragment + "\n" + migratedFragmentCode;
-                } else {
-                    this._vertexSourceCode = finalVertexCode;
-                    this._fragmentSourceCode = migratedFragmentCode;
-                }
-
-                this._setInCache(baseName);
-                this._prepareEffect(); 
+            this._loadVertexShader(vertexSource, vertexCode => {
+                this._processIncludes(vertexCode, vertexCodeWithIncludes => {
+                    this._processShaderConversion(vertexCodeWithIncludes, false, migratedVertexCode => {
+                        this._loadFragmentShader(fragmentSource, (fragmentCode) => {
+                            this._processIncludes(fragmentCode, fragmentCodeWithIncludes => {
+                                this._processShaderConversion(fragmentCodeWithIncludes, true, 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();
+                                });
+                            });
+                        });
+                    });
+                });
             });
         }
 
-        private static _sourceCache: { [baseName: string]: { vertex: string, fragment: string } } = { };
-
-        private _getSourceCacheKey(baseName: string): string {
-            let cacheKey: string = baseName;
-            if (this._indexParameters) {
-                for (let key in this._indexParameters) {
-                    if (this._indexParameters.hasOwnProperty(key)) {
-                        cacheKey += "|";
-                        cacheKey += key
-                        cacheKey += "_";
-                        cacheKey += this._indexParameters[key];
-                    }
-                }
-            }
-
-            return cacheKey;
-        }
-
-        private _getFromCache(baseName: string): boolean {
-            if (typeof baseName !== "string") {
-                return false;
-            }
-
-            let cacheKey = this._getSourceCacheKey(baseName);
-            let sources = Effect._sourceCache[cacheKey];
-            if (!sources) {
-                return false;
-            }
-
-            this._vertexSourceCode = sources.vertex;
-            this._fragmentSourceCode = sources.fragment;
-            return true;
-        }
-
-        private _setInCache(baseName: string): void {
-            if (typeof baseName !== "string") {
-                return;
-            }
-
-            let cacheKey = this._getSourceCacheKey(baseName);
-            Effect._sourceCache[cacheKey] = {
-                vertex: this._vertexSourceCode,
-                fragment: this._fragmentSourceCode
-            };
-        }
-
         /**
          * Unique key for this effect
          */
@@ -423,6 +365,7 @@
         public getProgram(): WebGLProgram {
             return this._program;
         }
+
         /**
          * The set of names of attribute variables for the shader.
          * @returns An array of attribute names.
@@ -509,24 +452,27 @@
         }
 
         /** @ignore */
-        public _loadVertexShaderAsync(vertex: any): Promise<any> {
+        public _loadVertexShader(vertex: any, callback: (data: any) => void): void {
             if (Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (vertex instanceof HTMLElement) {
                     var vertexCode = Tools.GetDOMTextContent(vertex);
-                    return Promise.resolve(vertexCode);
+                    callback(vertexCode);
+                    return;
                 }
             }
 
             // Base64 encoded ?
             if (vertex.substr(0, 7) === "base64:") {
                 var vertexBinary = window.atob(vertex.substr(7));
-                return Promise.resolve(vertexBinary);
+                callback(vertexBinary);
+                return;
             }
 
             // Is in local store ?
             if (Effect.ShadersStore[vertex + "VertexShader"]) {
-                return Promise.resolve(Effect.ShadersStore[vertex + "VertexShader"]);
+                callback(Effect.ShadersStore[vertex + "VertexShader"]);
+                return;
             }
 
             var vertexShaderUrl;
@@ -538,32 +484,36 @@
             }
 
             // Vertex shader
-            return this._engine._loadFileAsync(vertexShaderUrl + ".vertex.fx");
+            this._engine._loadFile(vertexShaderUrl + ".vertex.fx", callback);
         }
 
         /** @ignore */
-        public _loadFragmentShaderAsync(fragment: any): Promise<any>  {
+        public _loadFragmentShader(fragment: any, callback: (data: any) => void): void {
             if (Tools.IsWindowObjectExist()) {
                 // DOM element ?
                 if (fragment instanceof HTMLElement) {
                     var fragmentCode = Tools.GetDOMTextContent(fragment);
-                    return Promise.resolve(fragmentCode);
+                    callback(fragmentCode);
+                    return;
                 }
             }
 
             // Base64 encoded ?
             if (fragment.substr(0, 7) === "base64:") {
                 var fragmentBinary = window.atob(fragment.substr(7));
-                return Promise.resolve(fragmentBinary);
+                callback(fragmentBinary);
+                return;
             }
 
             // Is in local store ?
             if (Effect.ShadersStore[fragment + "PixelShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "PixelShader"]);
+                callback(Effect.ShadersStore[fragment + "PixelShader"]);
+                return;
             }
 
             if (Effect.ShadersStore[fragment + "FragmentShader"]) {
-                return Promise.resolve(Effect.ShadersStore[fragment + "FragmentShader"]);
+                callback(Effect.ShadersStore[fragment + "FragmentShader"]);
+                return;
             }
 
             var fragmentShaderUrl;
@@ -575,7 +525,7 @@
             }
 
             // Fragment shader
-            return this._engine._loadFileAsync(fragmentShaderUrl + ".fragment.fx");
+            this._engine._loadFile(fragmentShaderUrl + ".fragment.fx", callback);
         }
 
         private _dumpShadersSource(vertexCode: string, fragmentCode: string, defines: string): void {
@@ -607,16 +557,19 @@
             }
         };
 
-        private _processShaderConversion(sourceCode: string, isFragment: boolean): any {
+        private _processShaderConversion(sourceCode: string, isFragment: boolean, callback: (data: any) => void): void {
+
             var preparedSourceCode = this._processPrecision(sourceCode);
 
             if (this._engine.webGLVersion == 1) {
-                return preparedSourceCode;
+                callback(preparedSourceCode);
+                return;
             }
 
             // Already converted
             if (preparedSourceCode.indexOf("#version 3") !== -1) {
-                return preparedSourceCode.replace("#version 300 es", "");
+                callback(preparedSourceCode.replace("#version 300 es", ""));
+                return;
             }
 
             var hasDrawBuffersExtension = preparedSourceCode.search(/#extension.+GL_EXT_draw_buffers.+require/) !== -1;
@@ -645,97 +598,92 @@
                 result = result.replace(/void\s+?main\s*\(/g, (hasDrawBuffersExtension ? "" : "out vec4 glFragColor;\n") + "void main(");
             }
 
-            return result;
+            callback(result);
         }
 
-        private _processIncludesAsync(sourceCode: string): Promise<any> {
-            return new Promise((resolve, reject) => {
-                var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
-                var match = regex.exec(sourceCode);
+        private _processIncludes(sourceCode: string, callback: (data: any) => void): void {
+            var regex = /#include<(.+)>(\((.*)\))*(\[(.*)\])*/g;
+            var match = regex.exec(sourceCode);
 
-                var returnValue = sourceCode;
+            var returnValue = new String(sourceCode);
 
-                while (match != null) {
-                    var includeFile = match[1];
+            while (match != null) {
+                var includeFile = match[1];
 
-                    // Uniform declaration
-                    if (includeFile.indexOf("__decl__") !== -1) {
-                        includeFile = includeFile.replace(/__decl__/, "");
-                        if (this._engine.supportsUniformBuffers) {
-                            includeFile = includeFile.replace(/Vertex/, "Ubo");
-                            includeFile = includeFile.replace(/Fragment/, "Ubo");
-                        }
-                        includeFile = includeFile + "Declaration";
+                // Uniform declaration
+                if (includeFile.indexOf("__decl__") !== -1) {
+                    includeFile = includeFile.replace(/__decl__/, "");
+                    if (this._engine.supportsUniformBuffers) {
+                        includeFile = includeFile.replace(/Vertex/, "Ubo");
+                        includeFile = includeFile.replace(/Fragment/, "Ubo");
                     }
+                    includeFile = includeFile + "Declaration";
+                }
 
-                    if (Effect.IncludesShadersStore[includeFile]) {
-                        // Substitution
-                        var includeContent = Effect.IncludesShadersStore[includeFile];
-                        if (match[2]) {
-                            var splits = match[3].split(",");
+                if (Effect.IncludesShadersStore[includeFile]) {
+                    // Substitution
+                    var includeContent = Effect.IncludesShadersStore[includeFile];
+                    if (match[2]) {
+                        var splits = match[3].split(",");
 
-                            for (var index = 0; index < splits.length; index += 2) {
-                                var source = new RegExp(splits[index], "g");
-                                var dest = splits[index + 1];
+                        for (var index = 0; index < splits.length; index += 2) {
+                            var source = new RegExp(splits[index], "g");
+                            var dest = splits[index + 1];
 
-                                includeContent = includeContent.replace(source, dest);
-                            }
+                            includeContent = includeContent.replace(source, dest);
                         }
+                    }
 
-                        if (match[4]) {
-                            var indexString = match[5];
+                    if (match[4]) {
+                        var indexString = match[5];
 
-                            if (indexString.indexOf("..") !== -1) {
-                                var indexSplits = indexString.split("..");
-                                var minIndex = parseInt(indexSplits[0]);
-                                var maxIndex = parseInt(indexSplits[1]);
-                                var sourceIncludeContent = includeContent.slice(0);
-                                includeContent = "";
+                        if (indexString.indexOf("..") !== -1) {
+                            var indexSplits = indexString.split("..");
+                            var minIndex = parseInt(indexSplits[0]);
+                            var maxIndex = parseInt(indexSplits[1]);
+                            var sourceIncludeContent = includeContent.slice(0);
+                            includeContent = "";
 
-                                if (isNaN(maxIndex)) {
-                                    maxIndex = this._indexParameters[indexSplits[1]];
-                                }
+                            if (isNaN(maxIndex)) {
+                                maxIndex = this._indexParameters[indexSplits[1]];
+                            }
 
-                                for (var i = minIndex; i < maxIndex; i++) {
-                                    if (!this._engine.supportsUniformBuffers) {
-                                        // Ubo replacement
-                                        sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, (str: string, p1: string) => {
-                                            return p1 + "{X}";
-                                        });
-                                    }
-                                    includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
-                                }
-                            } else {
+                            for (var i = minIndex; i < maxIndex; i++) {
                                 if (!this._engine.supportsUniformBuffers) {
                                     // Ubo replacement
-                                    includeContent = includeContent.replace(/light\{X\}.(\w*)/g, (str: string, p1: string) => {
+                                    sourceIncludeContent = sourceIncludeContent.replace(/light\{X\}.(\w*)/g, (str: string, p1: string) => {
                                         return p1 + "{X}";
                                     });
                                 }
-                                includeContent = includeContent.replace(/\{X\}/g, indexString);
+                                includeContent += sourceIncludeContent.replace(/\{X\}/g, i.toString()) + "\n";
                             }
+                        } else {
+                            if (!this._engine.supportsUniformBuffers) {
+                                // Ubo replacement
+                                includeContent = includeContent.replace(/light\{X\}.(\w*)/g, (str: string, p1: string) => {
+                                    return p1 + "{X}";
+                                });
+                            }
+                            includeContent = includeContent.replace(/\{X\}/g, indexString);
                         }
-
-                        // Replace
-                        returnValue = returnValue.replace(match[0], includeContent);
-                    } else {
-                        var includeShaderUrl = Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
-
-                        this._engine._loadFileAsync(includeShaderUrl)
-                            .then((fileContent) => {
-                                Effect.IncludesShadersStore[includeFile] = fileContent as string;
-                                return this._processIncludesAsync(returnValue);
-                            })
-                            .then((returnValue) => {
-                                resolve(returnValue);
-                            });
-                        return;
                     }
 
-                    match = regex.exec(sourceCode);
+                    // Replace
+                    returnValue = returnValue.replace(match[0], includeContent);
+                } else {
+                    var includeShaderUrl = Engine.ShadersRepository + "ShadersInclude/" + includeFile + ".fx";
+
+                    this._engine._loadFile(includeShaderUrl, (fileContent) => {
+                        Effect.IncludesShadersStore[includeFile] = fileContent as string;
+                        this._processIncludes(<string>returnValue, callback);
+                    });
+                    return;
                 }
-                resolve(returnValue);
-            });            
+
+                match = regex.exec(sourceCode);
+            }
+
+            callback(returnValue);
         }
 
         private _processPrecision(source: string): string {
@@ -947,8 +895,7 @@
         }
 
         /**
-         * (Warning! setTextureFromPostProcessOutput may be desired instead)
-         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
+         * Sets a texture to be the input of the specified post process. (To use the output, pass in the next post process in the pipeline)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the input texture from.
          */
@@ -957,7 +904,8 @@
         }
 
         /**
-         * Sets the output texture of the passed in post process to be input of this effect.
+         * (Warning! setTextureFromPostProcessOutput may be desired instead)
+         * Sets the input texture of the passed in post process to be input of this effect. (To use the output of the passed in post process use setTextureFromPostProcessOutput)
          * @param channel Name of the sampler variable.
          * @param postProcess Post process to get the output texture from.
          */
@@ -1470,7 +1418,6 @@
             return this;
         }
 
-        // Statics
         /**
          * Store of each shader (The can be looked up using effect.key)
          */
@@ -1487,4 +1434,4 @@
             Effect._baseCache = {};
         }
     }
-} 
+}