Add color to ShadowOnlyMaterial

dist/preview release/babylon.max.js

@@ -65380,10 +65380,6 @@ var BABYLON;
             if (format === void 0) { format = BABYLON.Engine.TEXTUREFORMAT_RGBA; }
             var _this = _super.call(this, null, scene, !generateMipMaps) || this;
             _this.isCube = isCube;
-            /**
-            * Use this list to define the list of mesh you want to render.
-            */
-            _this.renderList = new Array();
             _this.renderParticles = true;
             _this.renderSprites = false;
             _this.coordinatesMode = BABYLON.Texture.PROJECTION_MODE;
@@ -65421,6 +65417,7 @@ var BABYLON;
             if (!scene) {
                 return _this;
             }
+            _this.renderList = new Array();
             _this._engine = scene.getEngine();
             _this.name = name;
             _this.isRenderTarget = true;
@@ -65479,6 +65476,45 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(RenderTargetTexture.prototype, "renderList", {
+            /**
+            * Use this list to define the list of mesh you want to render.
+            */
+            get: function () {
+                return this._renderList;
+            },
+            set: function (value) {
+                this._renderList = value;
+                if (this._renderList) {
+                    this._hookArray(this._renderList);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderTargetTexture.prototype._hookArray = function (array) {
+            var _this = this;
+            var oldPush = array.push;
+            array.push = function () {
+                var items = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    items[_i] = arguments[_i];
+                }
+                var result = oldPush.apply(array, items);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return result;
+            };
+            var oldSplice = array.splice;
+            array.splice = function (index, deleteCount) {
+                var deleted = oldSplice.apply(array, [index, deleteCount]);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return deleted;
+            };
+        };
         Object.defineProperty(RenderTargetTexture.prototype, "onAfterUnbind", {
             set: function (callback) {
                 if (this._onAfterUnbindObserver) {

dist/preview release/babylon.no-module.max.js

@@ -65347,10 +65347,6 @@ var BABYLON;
             if (format === void 0) { format = BABYLON.Engine.TEXTUREFORMAT_RGBA; }
             var _this = _super.call(this, null, scene, !generateMipMaps) || this;
             _this.isCube = isCube;
-            /**
-            * Use this list to define the list of mesh you want to render.
-            */
-            _this.renderList = new Array();
             _this.renderParticles = true;
             _this.renderSprites = false;
             _this.coordinatesMode = BABYLON.Texture.PROJECTION_MODE;
@@ -65388,6 +65384,7 @@ var BABYLON;
             if (!scene) {
                 return _this;
             }
+            _this.renderList = new Array();
             _this._engine = scene.getEngine();
             _this.name = name;
             _this.isRenderTarget = true;
@@ -65446,6 +65443,45 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(RenderTargetTexture.prototype, "renderList", {
+            /**
+            * Use this list to define the list of mesh you want to render.
+            */
+            get: function () {
+                return this._renderList;
+            },
+            set: function (value) {
+                this._renderList = value;
+                if (this._renderList) {
+                    this._hookArray(this._renderList);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderTargetTexture.prototype._hookArray = function (array) {
+            var _this = this;
+            var oldPush = array.push;
+            array.push = function () {
+                var items = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    items[_i] = arguments[_i];
+                }
+                var result = oldPush.apply(array, items);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return result;
+            };
+            var oldSplice = array.splice;
+            array.splice = function (index, deleteCount) {
+                var deleted = oldSplice.apply(array, [index, deleteCount]);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return deleted;
+            };
+        };
         Object.defineProperty(RenderTargetTexture.prototype, "onAfterUnbind", {
             set: function (callback) {
                 if (this._onAfterUnbindObserver) {

dist/preview release/es6.js

@@ -65347,10 +65347,6 @@ var BABYLON;
             if (format === void 0) { format = BABYLON.Engine.TEXTUREFORMAT_RGBA; }
             var _this = _super.call(this, null, scene, !generateMipMaps) || this;
             _this.isCube = isCube;
-            /**
-            * Use this list to define the list of mesh you want to render.
-            */
-            _this.renderList = new Array();
             _this.renderParticles = true;
             _this.renderSprites = false;
             _this.coordinatesMode = BABYLON.Texture.PROJECTION_MODE;
@@ -65388,6 +65384,7 @@ var BABYLON;
             if (!scene) {
                 return _this;
             }
+            _this.renderList = new Array();
             _this._engine = scene.getEngine();
             _this.name = name;
             _this.isRenderTarget = true;
@@ -65446,6 +65443,45 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(RenderTargetTexture.prototype, "renderList", {
+            /**
+            * Use this list to define the list of mesh you want to render.
+            */
+            get: function () {
+                return this._renderList;
+            },
+            set: function (value) {
+                this._renderList = value;
+                if (this._renderList) {
+                    this._hookArray(this._renderList);
+                }
+            },
+            enumerable: true,
+            configurable: true
+        });
+        RenderTargetTexture.prototype._hookArray = function (array) {
+            var _this = this;
+            var oldPush = array.push;
+            array.push = function () {
+                var items = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    items[_i] = arguments[_i];
+                }
+                var result = oldPush.apply(array, items);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return result;
+            };
+            var oldSplice = array.splice;
+            array.splice = function (index, deleteCount) {
+                var deleted = oldSplice.apply(array, [index, deleteCount]);
+                _this.getScene().meshes.forEach(function (mesh) {
+                    mesh._markSubMeshesAsLightDirty();
+                });
+                return deleted;
+            };
+        };
         Object.defineProperty(RenderTargetTexture.prototype, "onAfterUnbind", {
             set: function (callback) {
                 if (this._onAfterUnbindObserver) {

dist/preview release/materialsLibrary/babylon.shadowOnlyMaterial.d.ts

@@ -4,6 +4,7 @@ declare module BABYLON {
         private _renderId;
         private _activeLight;
         constructor(name: string, scene: Scene);
+        shadowColor: Color3;
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;

dist/preview release/materialsLibrary/babylonjs.materials.d.ts

@@ -4,6 +4,7 @@ declare module BABYLON {
         private _renderId;
         private _activeLight;
         constructor(name: string, scene: Scene);
+        shadowColor: Color3;
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;

dist/preview release/materialsLibrary/babylonjs.materials.module.d.ts

@@ -9,6 +9,7 @@ declare module BABYLON {
         private _renderId;
         private _activeLight;
         constructor(name: string, scene: Scene);
+        shadowColor: Color3;
         needAlphaBlending(): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;

materialsLibrary/src/shadowOnly/babylon.shadowOnlyMaterial.ts

@@ -24,6 +24,8 @@ module BABYLON {
             super(name, scene);
         }
 
+        public shadowColor = BABYLON.Color3.Black();
+
         public needAlphaBlending(): boolean {
             return true;
         }
@@ -126,7 +128,7 @@ module BABYLON {
                 var shaderName = "shadowOnly";
                 var join = defines.toString();
                 var uniforms = ["world", "view", "viewProjection", "vEyePosition", "vLightsType",
-                    "vFogInfos", "vFogColor", "pointSize", "alpha",
+                    "vFogInfos", "vFogColor", "pointSize", "alpha", "shadowColor",
                     "mBones",
                     "vClipPlane"
                 ];
@@ -196,6 +198,7 @@ module BABYLON {
                 }
 
                 this._activeEffect.setFloat("alpha", this.alpha);
+                this._activeEffect.setColor3("shadowColor", this.shadowColor);
 
                 MaterialHelper.BindEyePosition(effect, scene);
             }

materialsLibrary/src/shadowOnly/shadowOnly.fragment.fx

@@ -3,6 +3,7 @@
 // Constants
 uniform vec3 vEyePosition;
 uniform float alpha;
+uniform vec3 shadowColor;
 
 // Input
 varying vec3 vPositionW;
@@ -46,7 +47,7 @@ void main(void) {
 #include<lightFragment>[0..1]
 
 	// Composition
-	vec4 color = vec4(0., 0., 0., (1.0 - clamp(shadow, 0., 1.)) * alpha);
+	vec4 color = vec4(shadowColor, (1.0 - clamp(shadow, 0., 1.)) * alpha);
 
 #include<fogFragment>
 

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -22,10 +22,46 @@
         */
         public renderListPredicate: (AbstractMesh: AbstractMesh) => boolean;
 
+        private _renderList: Nullable<Array<AbstractMesh>>;
         /**
         * Use this list to define the list of mesh you want to render.
         */
-        public renderList: Nullable<Array<AbstractMesh>> = new Array<AbstractMesh>();
+        public get renderList(): Nullable<Array<AbstractMesh>> {
+            return this._renderList;
+        }
+ 
+        public set renderList(value: Nullable<Array<AbstractMesh>>) {
+            this._renderList = value;
+
+            if (this._renderList) {
+                this._hookArray(this._renderList);
+            }
+        }
+
+        private _hookArray(array: AbstractMesh[]): void {
+            var oldPush = array.push;
+            array.push = (...items: AbstractMesh[]) => {
+                var result = oldPush.apply(array, items);
+                
+                this.getScene()!.meshes.forEach(mesh => {
+                    mesh._markSubMeshesAsLightDirty();
+                })
+
+                return result;
+            }
+
+            var oldSplice = array.splice;
+            array.splice = (index: number, deleteCount?: number) => {
+                var deleted = oldSplice.apply(array, [index, deleteCount]);
+
+                this.getScene()!.meshes.forEach(mesh => {
+                    mesh._markSubMeshesAsLightDirty();
+                })
+
+                return deleted;
+            }
+        }
+
         public renderParticles = true;
         public renderSprites = false;
         public coordinatesMode = Texture.PROJECTION_MODE;
@@ -182,6 +218,7 @@
                 return;
             }
 
+            this.renderList = new Array<AbstractMesh>();
             this._engine = scene.getEngine();
             this.name = name;
             this.isRenderTarget = true;

tests/validation/config.json

@@ -2,6 +2,11 @@
   "root": "https://rawgit.com/BabylonJS/Website/master",
   "tests": [  
     {
+      "title": "ShadowOnlyMaterial",
+      "playgroundId": "#1KF7V1#18",
+      "referenceImage": "shadowOnlyMaterial.png"
+    },     
+    {
       "title": "Gizmos",
       "playgroundId": "#8GY6J8#48",
       "renderCount": 50,