multirendertarget now is child class of rendertarget

src/Materials/Textures/babylon.multiRenderTarget.ts

@@ -1,31 +1,9 @@
 module BABYLON {
-    export class MultiRenderTarget {
-
-        public getScene(): Scene {
-            return this._scene;
-        }
+    export class MultiRenderTarget extends RenderTargetTexture {
 
         private _webGLTextures: WebGLTexture[];
         private _textures: Texture[];
         private _count: number;
-        private _scene: Scene;
-        private _renderingManager: RenderingManager;
-        private _doNotChangeAspectRatio: boolean;
-        private _size: number;
-
-        /**
-        * An event triggered after the texture clear
-        * @type {BABYLON.Observable}
-        */
-        public onClearObservable = new Observable<Engine>();
-
-        private _onClearObserver: Observer<Engine>;
-        public set onClear(callback: (Engine: Engine) => void) {
-            if (this._onClearObserver) {
-                this.onClearObservable.remove(this._onClearObserver);
-            }
-            this._onClearObserver = this.onClearObservable.add(callback);
-        }
 
         public get textures(): Texture[] {
             return this._textures;
@@ -35,34 +13,46 @@ module BABYLON {
             return this._textures[this._textures.length - 1];
         }
 
-        private _shouldRender(): boolean {
-            return true;
-        }
-
         public customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void;
 
         constructor(name: string, size: any, count: number, scene: Scene, options?: any) {
             options = options || {};
 
-            var generateMipMaps = options.generateMipMaps ? options.generateMipMaps[0] : false;
+            var generateMipMaps = options.generateMipMaps ? options.generateMipMaps : false;
             var generateDepthTexture = options.generateDepthTexture ? options.generateDepthTexture : false;
             var doNotChangeAspectRatio = options.doNotChangeAspectRatio === undefined ? true : options.doNotChangeAspectRatio;
-            var type = options.types ? options.types[0] : Engine.TEXTURETYPE_FLOAT;
-            var samplingMode = options.samplingModes ? options.samplingModes[0] : Texture.TRILINEAR_SAMPLINGMODE;
+
+            super(name, size, scene, generateMipMaps, doNotChangeAspectRatio);
+
+            var types = [];
+            var samplingModes = [];
+
+            for (var i = 0; i < count; i++) {
+                if (options.types && options.types[i]) {
+                    types.push(options.types[i]);
+                } else {
+                    types.push(Engine.TEXTURETYPE_FLOAT);
+                }
+
+                if (options.samplingModes && options.samplingModes[i]) {
+                    samplingModes.push(options.samplingModes[i]);
+                } else {
+                    samplingModes.push(Texture.TRILINEAR_SAMPLINGMODE);
+                }
+            }
+
             var generateDepthBuffer = options.generateDepthBuffer === undefined ? true : options.generateDepthBuffer;
             var generateStencilBuffer = options.generateStencilBuffer === undefined ? false : options.generateStencilBuffer;
 
             this._count = count;
-            this._scene = scene;
-            this._doNotChangeAspectRatio = doNotChangeAspectRatio;
             this._size = size;
             this._webGLTextures = scene.getEngine().createMultipleRenderTarget(size, {
-                samplingMode: samplingMode,
+                samplingModes: samplingModes,
                 generateMipMaps: generateMipMaps,
                 generateDepthBuffer: generateDepthBuffer,
                 generateStencilBuffer: generateStencilBuffer,
                 generateDepthTexture: generateDepthTexture,
-                type: type,
+                types: types,
                 textureCount: count
             });
 
@@ -72,9 +62,20 @@ module BABYLON {
                 texture._texture = this._webGLTextures[i];
                 this._textures.push(texture);
             }
+        }
 
-            // Rendering groups
-            this._renderingManager = new RenderingManager(scene);
+        public get samples(): number {
+            return this._samples;
+        }
+
+        public set samples(value: number) {
+            if (this._samples === value) {
+                return;
+            }
+            
+            for (var i = 0 ; i < this._webGLTextures.length; i++) {
+                this._samples = this.getScene().getEngine().updateRenderTargetTextureSampleCount(this._webGLTextures[i], value);
+            }
         }
 
         public render(useCameraPostProcess?: boolean, dumpForDebug?: boolean) {
@@ -150,20 +151,14 @@ module BABYLON {
 
 
         public dispose(): void {
-            // Animations
-            this.getScene().stopAnimation(this);
-
-            // Remove from scene
-            this._scene._removePendingData(this);
-
             for (var i = this._webGLTextures.length - 1; i >= 0; i--) {
                 if (this._webGLTextures[i] !== undefined) {
-                    this._scene.getEngine().releaseInternalTexture(this._webGLTextures[i]);
+                    this.getScene().getEngine().releaseInternalTexture(this._webGLTextures[i]);
                     this._webGLTextures.splice(i, 1);
                 }
             }
-        }
-
 
+            super.dispose();
+        }
     }
 }

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -41,7 +41,7 @@
         */
         public onAfterUnbindObservable = new Observable<RenderTargetTexture>();
 
-        private _onAfterUnbindObserver: Observer<RenderTargetTexture>;
+        protected _onAfterUnbindObserver: Observer<RenderTargetTexture>;
         public set onAfterUnbind(callback: () => void) {
             if (this._onAfterUnbindObserver) {
                 this.onAfterUnbindObservable.remove(this._onAfterUnbindObserver);
@@ -55,7 +55,7 @@
         */
         public onBeforeRenderObservable = new Observable<number>();
 
-        private _onBeforeRenderObserver: Observer<number>;
+        protected _onBeforeRenderObserver: Observer<number>;
         public set onBeforeRender(callback: (faceIndex: number) => void) {
             if (this._onBeforeRenderObserver) {
                 this.onBeforeRenderObservable.remove(this._onBeforeRenderObserver);
@@ -69,7 +69,7 @@
         */
         public onAfterRenderObservable = new Observable<number>();
 
-        private _onAfterRenderObserver: Observer<number>;
+        protected _onAfterRenderObserver: Observer<number>;
         public set onAfterRender(callback: (faceIndex: number) => void) {
             if (this._onAfterRenderObserver) {
                 this.onAfterRenderObservable.remove(this._onAfterRenderObserver);
@@ -83,7 +83,7 @@
         */
         public onClearObservable = new Observable<Engine>();
 
-        private _onClearObserver: Observer<Engine>;
+        protected _onClearObserver: Observer<Engine>;
         public set onClear(callback: (Engine: Engine) => void) {
             if (this._onClearObserver) {
                 this.onClearObservable.remove(this._onClearObserver);
@@ -91,15 +91,15 @@
             this._onClearObserver = this.onClearObservable.add(callback);
         }
 
-        private _size: number;
+        protected _size: number;
         public _generateMipMaps: boolean;
-        private _renderingManager: RenderingManager;
+        protected _renderingManager: RenderingManager;
         public _waitingRenderList: string[];
-        private _doNotChangeAspectRatio: boolean;
-        private _currentRefreshId = -1;
-        private _refreshRate = 1;
-        private _textureMatrix: Matrix;
-        private _samples = 1;
+        protected _doNotChangeAspectRatio: boolean;
+        protected _currentRefreshId = -1;
+        protected _refreshRate = 1;
+        protected _textureMatrix: Matrix;
+        protected _samples = 1;
         protected _renderTargetOptions: {
             generateMipMaps: boolean,
             type: number,
@@ -108,7 +108,7 @@
             generateStencilBuffer: boolean
         };
 
-        constructor(name: string, size: any, scene: Scene, generateMipMaps?: boolean, doNotChangeAspectRatio: boolean = true, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, public isCube = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, generateDepthBuffer = true, generateStencilBuffer = false) {
+        constructor(name: string, size: any, scene: Scene, generateMipMaps?: boolean, doNotChangeAspectRatio: boolean = true, type: number = Engine.TEXTURETYPE_UNSIGNED_INT, public isCube = false, samplingMode = Texture.TRILINEAR_SAMPLINGMODE, generateDepthBuffer = true, generateStencilBuffer = false, isMulti = false) {
             super(null, scene, !generateMipMaps);
 
             this.name = name;
@@ -117,6 +117,13 @@
             this._generateMipMaps = generateMipMaps;
             this._doNotChangeAspectRatio = doNotChangeAspectRatio;
 
+            // Rendering groups
+            this._renderingManager = new RenderingManager(scene);
+
+            if (isMulti) {
+                return;
+            }
+
             this._renderTargetOptions = {
                 generateMipMaps: generateMipMaps,
                 type: type,
@@ -138,8 +145,6 @@
                 this._texture = scene.getEngine().createRenderTargetTexture(size, this._renderTargetOptions);
             }
 
-            // Rendering groups
-            this._renderingManager = new RenderingManager(scene);
         }
 
         public get samples(): number {
@@ -464,5 +469,9 @@
 
             return serializationObject;
         }
+
+        public dispose(): void {
+            super.dispose();
+        }
     }
 }

src/Rendering/babylon.geometryRenderer.ts

@@ -16,7 +16,7 @@ module BABYLON {
             var engine = scene.getEngine();
 
             // Render target
-            this._multiRenderTarget = new MultiRenderTarget("gBuffer", { width: engine.getRenderWidth(), height: engine.getRenderHeight() }, 2, this._scene, { generateMipMaps : [true], generateDepthTexture: true });
+            this._multiRenderTarget = new MultiRenderTarget("gBuffer", { width: engine.getRenderWidth(), height: engine.getRenderHeight() }, 2, this._scene, { generateMipMaps : true, generateDepthTexture: true });
             // set default depth value to 1.0 (far away)
             this._multiRenderTarget.onClearObservable.add((engine: Engine) => {
                 engine.clear(new Color4(1.0, 1.0, 1.0, 1.0), true, true, true);
@@ -84,11 +84,6 @@ module BABYLON {
             var mesh = subMesh.getMesh();
             var scene = mesh.getScene();
 
-            // if (mesh.isVerticesDataPresent(VertexBuffer.UVKind)) {
-            //     attribs.push(VertexBuffer.UVKind);
-            //     defines.push("#define UV1");
-            // }
-
             // Get correct effect      
             var join = defines.join("\n");
             if (this._cachedDefines !== join) {

src/babylon.engine.ts

@@ -2643,8 +2643,11 @@
             var generateDepthTexture = false;
             var textureCount = 1;
 
-            var type = Engine.TEXTURETYPE_UNSIGNED_INT;
-            var samplingMode = Texture.TRILINEAR_SAMPLINGMODE;
+            var defaultType = Engine.TEXTURETYPE_UNSIGNED_INT;
+            var defaultSamplingMode = Texture.TRILINEAR_SAMPLINGMODE;
+
+            var types = [], samplingModes = [];
+
             if (options !== undefined) {
                 generateMipMaps = options.generateMipMaps;
                 generateDepthBuffer = options.generateDepthBuffer === undefined ? true : options.generateDepthBuffer;
@@ -2652,18 +2655,13 @@
                 generateDepthTexture = options.generateDepthTexture;
                 textureCount = options.textureCount || 1;
 
-                type = options.type === undefined ? type : options.type;
-                if (options.samplingMode !== undefined) {
-                    samplingMode = options.samplingMode;
-                }
-                if (type === Engine.TEXTURETYPE_FLOAT && !this._caps.textureFloatLinearFiltering) {
-                    // if floating point linear (gl.FLOAT) then force to NEAREST_SAMPLINGMODE
-                    samplingMode = Texture.NEAREST_SAMPLINGMODE;
+                if (options.types) {
+                    types = options.types;
                 }
-                else if (type === Engine.TEXTURETYPE_HALF_FLOAT && !this._caps.textureHalfFloatLinearFiltering) {
-                    // if floating point linear (HALF_FLOAT) then force to NEAREST_SAMPLINGMODE
-                    samplingMode = Texture.NEAREST_SAMPLINGMODE;
+                if (options.samplingModes) {
+                    samplingModes = options.samplingModes;
                 }
+
             }
             var gl = this._gl;
             // Create the framebuffer
@@ -2680,18 +2678,31 @@
 
             var width = size.width || size;
             var height = size.height || size;
-            var filters = getSamplingParameters(samplingMode, generateMipMaps, gl);
             
             var textures = [];
             var attachments = []
-            if (type === Engine.TEXTURETYPE_FLOAT && !this._caps.textureFloat) {
-                type = Engine.TEXTURETYPE_UNSIGNED_INT;
-                Tools.Warn("Float textures are not supported. Render target forced to TEXTURETYPE_UNSIGNED_BYTE type");
-            }
 
             var depthStencilBuffer = this._setupFramebufferDepthAttachments(generateStencilBuffer, generateDepthBuffer, width, height);
 
             for (var i = 0; i < textureCount; i++) {
+                var samplingMode = samplingModes[i] || defaultSamplingMode;
+                var type = types[i] || defaultType;
+
+                if (type === Engine.TEXTURETYPE_FLOAT && !this._caps.textureFloatLinearFiltering) {
+                    // if floating point linear (gl.FLOAT) then force to NEAREST_SAMPLINGMODE
+                    samplingMode = Texture.NEAREST_SAMPLINGMODE;
+                }
+                else if (type === Engine.TEXTURETYPE_HALF_FLOAT && !this._caps.textureHalfFloatLinearFiltering) {
+                    // if floating point linear (HALF_FLOAT) then force to NEAREST_SAMPLINGMODE
+                    samplingMode = Texture.NEAREST_SAMPLINGMODE;
+                }
+
+                var filters = getSamplingParameters(samplingMode, generateMipMaps, gl);
+                if (type === Engine.TEXTURETYPE_FLOAT && !this._caps.textureFloat) {
+                    type = Engine.TEXTURETYPE_UNSIGNED_INT;
+                    Tools.Warn("Float textures are not supported. Render target forced to TEXTURETYPE_UNSIGNED_BYTE type");
+                }
+
                 var texture = gl.createTexture();
                 var attachment = gl["COLOR_ATTACHMENT" + i];
                 textures.push(texture);