Fix #3997

dist/preview release/babylon.max.js

@@ -20304,6 +20304,23 @@ var BABYLON;
         Camera.prototype.isActiveMesh = function (mesh) {
             return (this._activeMeshes.indexOf(mesh) !== -1);
         };
+        /**
+         * Is this camera ready to be used/rendered
+         * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+         * @return true if the camera is ready
+         */
+        Camera.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            if (completeCheck) {
+                for (var _i = 0, _a = this._postProcesses; _i < _a.length; _i++) {
+                    var pp = _a[_i];
+                    if (pp && !pp.isReady()) {
+                        return;
+                    }
+                }
+            }
+            return _super.prototype.isReady.call(this, completeCheck);
+        };
         //Cache
         Camera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
@@ -23274,9 +23291,23 @@ var BABYLON;
                     }
                 }
             }
+            // Post-processes
+            if (this.activeCameras && this.activeCameras.length > 0) {
+                for (var _d = 0, _e = this.activeCameras; _d < _e.length; _d++) {
+                    var camera = _e[_d];
+                    if (!camera.isReady(true)) {
+                        return false;
+                    }
+                }
+            }
+            else if (this.activeCamera) {
+                if (!this.activeCamera.isReady(true)) {
+                    return false;
+                }
+            }
             // Particles
-            for (var _d = 0, _e = this.particleSystems; _d < _e.length; _d++) {
-                var particleSystem = _e[_d];
+            for (var _f = 0, _g = this.particleSystems; _f < _g.length; _f++) {
+                var particleSystem = _g[_f];
                 if (!particleSystem.isReady()) {
                     return false;
                 }

dist/preview release/es6.js

@@ -20276,6 +20276,23 @@ var BABYLON;
         Camera.prototype.isActiveMesh = function (mesh) {
             return (this._activeMeshes.indexOf(mesh) !== -1);
         };
+        /**
+         * Is this camera ready to be used/rendered
+         * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+         * @return true if the camera is ready
+         */
+        Camera.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            if (completeCheck) {
+                for (var _i = 0, _a = this._postProcesses; _i < _a.length; _i++) {
+                    var pp = _a[_i];
+                    if (pp && !pp.isReady()) {
+                        return;
+                    }
+                }
+            }
+            return _super.prototype.isReady.call(this, completeCheck);
+        };
         //Cache
         Camera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
@@ -23246,9 +23263,23 @@ var BABYLON;
                     }
                 }
             }
+            // Post-processes
+            if (this.activeCameras && this.activeCameras.length > 0) {
+                for (var _d = 0, _e = this.activeCameras; _d < _e.length; _d++) {
+                    var camera = _e[_d];
+                    if (!camera.isReady(true)) {
+                        return false;
+                    }
+                }
+            }
+            else if (this.activeCamera) {
+                if (!this.activeCamera.isReady(true)) {
+                    return false;
+                }
+            }
             // Particles
-            for (var _d = 0, _e = this.particleSystems; _d < _e.length; _d++) {
-                var particleSystem = _e[_d];
+            for (var _f = 0, _g = this.particleSystems; _f < _g.length; _f++) {
+                var particleSystem = _g[_f];
                 if (!particleSystem.isReady()) {
                     return false;
                 }

dist/preview release/viewer/babylon.viewer.max.js

@@ -20392,6 +20392,23 @@ var BABYLON;
         Camera.prototype.isActiveMesh = function (mesh) {
             return (this._activeMeshes.indexOf(mesh) !== -1);
         };
+        /**
+         * Is this camera ready to be used/rendered
+         * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+         * @return true if the camera is ready
+         */
+        Camera.prototype.isReady = function (completeCheck) {
+            if (completeCheck === void 0) { completeCheck = false; }
+            if (completeCheck) {
+                for (var _i = 0, _a = this._postProcesses; _i < _a.length; _i++) {
+                    var pp = _a[_i];
+                    if (pp && !pp.isReady()) {
+                        return;
+                    }
+                }
+            }
+            return _super.prototype.isReady.call(this, completeCheck);
+        };
         //Cache
         Camera.prototype._initCache = function () {
             _super.prototype._initCache.call(this);
@@ -23362,9 +23379,23 @@ var BABYLON;
                     }
                 }
             }
+            // Post-processes
+            if (this.activeCameras && this.activeCameras.length > 0) {
+                for (var _d = 0, _e = this.activeCameras; _d < _e.length; _d++) {
+                    var camera = _e[_d];
+                    if (!camera.isReady(true)) {
+                        return false;
+                    }
+                }
+            }
+            else if (this.activeCamera) {
+                if (!this.activeCamera.isReady(true)) {
+                    return false;
+                }
+            }
             // Particles
-            for (var _d = 0, _e = this.particleSystems; _d < _e.length; _d++) {
-                var particleSystem = _e[_d];
+            for (var _f = 0, _g = this.particleSystems; _f < _g.length; _f++) {
+                var particleSystem = _g[_f];
                 if (!particleSystem.isReady()) {
                     return false;
                 }

src/Cameras/babylon.camera.ts

@@ -252,6 +252,22 @@
             return (this._activeMeshes.indexOf(mesh) !== -1);
         }
 
+        /**
+         * Is this camera ready to be used/rendered
+         * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+         * @return true if the camera is ready
+         */
+        public isReady(completeCheck = false): boolean {
+            if (completeCheck) {
+                for (var pp of this._postProcesses) {
+                    if (pp && !pp.isReady()) {
+                        return
+                    }
+                }
+            }
+            return super.isReady(completeCheck);
+        }
+
         //Cache
         public _initCache() {
             super._initCache();

src/babylon.scene.ts

@@ -1956,6 +1956,19 @@
                 }
             }
 
+            // Post-processes
+            if (this.activeCameras && this.activeCameras.length > 0) {
+                for (var camera of this.activeCameras) {
+                    if (!camera.isReady(true)) {
+                        return false;
+                    }
+                }
+            } else if (this.activeCamera) {
+                if (!this.activeCamera.isReady(true)) {
+                    return false;
+                }
+            }
+
             // Particles
             for (var particleSystem of this.particleSystems) {
                 if (!particleSystem.isReady()) {

tests/validation/config.json

@@ -263,7 +263,7 @@
     {
       "title": "Enable disable post process",
       "playgroundId": "#1VI6WV#19",
-      "renderCount": 20,
+      "renderCount": 50,
       "referenceImage": "enableDisablePostProcess.png"
     },
     {