fixing protected, adding interface for options

Tools/Gulp/config.json

@@ -16,7 +16,7 @@
                 "pointLight", "directionalLight", "spotLight", "animations", "actions", "sprites", "picking", "collisions",
                 "particles", "solidParticles", "additionalMeshes", "meshBuilder", "audio", "additionalTextures", "shadows",
                 "loader", "userData", "offline", "fresnel", "multiMaterial", "touchCamera", "procedural", "gamepad",
-                "additionalCameras", "postProcesses", "renderingPipeline", "additionalRenderingPipeline", "depthRenderer", "geometryRenderer", "additionalPostProcesses",
+                "additionalCameras", "postProcesses", "renderingPipeline", "additionalRenderingPipeline", "depthRenderer", "geometryBufferRenderer", "additionalPostProcesses",
                 "bones", "hdr", "polygonMesh", "csg", "lensFlares", "physics", "textureFormats", "debug", "morphTargets",
                 "colorCurves", "octrees", "simd", "vr", "virtualJoystick", "optimizations", "highlights", "assetsManager",
                 "mapTexture", "dynamicFloatArray", "serialization", "probes", "layer"
@@ -530,10 +530,10 @@
                 "bonesVertex"
             ]
         },
-        "geometryRenderer" : 
+        "geometryBufferRenderer" : 
         {
             "files": [
-                "../../src/Rendering/babylon.geometryRenderer.js"
+                "../../src/Rendering/babylon.geometryBufferRenderer.js"
             ],
             "dependUpon" : [
                 "core"

src/Materials/Textures/babylon.multiRenderTarget.ts

@@ -1,19 +1,25 @@
 module BABYLON {
+    export interface IMultiRenderTargetOptions {
+        generateMipMaps: boolean,
+        types: number[],
+        samplingModes: number[],
+        generateDepthBuffer: boolean,
+        generateStencilBuffer: boolean,
+        generateDepthTexture: boolean,
+        textureCount: number
+    };
     export class MultiRenderTarget extends RenderTargetTexture {
 
         private _webGLTextures: WebGLTexture[];
         private _textures: Texture[];
         private _count: number;
 
-        protected _multiRenderTargetOptions: {
-            generateMipMaps: boolean,
-            types: number[],
-            samplingModes: number[],
-            generateDepthBuffer: boolean,
-            generateStencilBuffer: boolean,
-            generateDepthTexture: boolean,
-            textureCount: number
-        };
+        public get isSupported(): boolean {
+            var engine = this.getScene().getEngine();
+            return engine.webGLVersion > 1 || engine.getCaps().drawBuffersExtension;
+        }
+
+        private _multiRenderTargetOptions: IMultiRenderTargetOptions;
 
         public get textures(): Texture[] {
             return this._textures;

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -49,7 +49,7 @@
         */
         public onAfterUnbindObservable = new Observable<RenderTargetTexture>();
 
-        protected _onAfterUnbindObserver: Observer<RenderTargetTexture>;
+        private _onAfterUnbindObserver: Observer<RenderTargetTexture>;
         public set onAfterUnbind(callback: () => void) {
             if (this._onAfterUnbindObserver) {
                 this.onAfterUnbindObservable.remove(this._onAfterUnbindObserver);
@@ -63,7 +63,7 @@
         */
         public onBeforeRenderObservable = new Observable<number>();
 
-        protected _onBeforeRenderObserver: Observer<number>;
+        private _onBeforeRenderObserver: Observer<number>;
         public set onBeforeRender(callback: (faceIndex: number) => void) {
             if (this._onBeforeRenderObserver) {
                 this.onBeforeRenderObservable.remove(this._onBeforeRenderObserver);
@@ -77,7 +77,7 @@
         */
         public onAfterRenderObservable = new Observable<number>();
 
-        protected _onAfterRenderObserver: Observer<number>;
+        private _onAfterRenderObserver: Observer<number>;
         public set onAfterRender(callback: (faceIndex: number) => void) {
             if (this._onAfterRenderObserver) {
                 this.onAfterRenderObservable.remove(this._onAfterRenderObserver);
@@ -91,7 +91,7 @@
         */
         public onClearObservable = new Observable<Engine>();
 
-        protected _onClearObserver: Observer<Engine>;
+        private _onClearObserver: Observer<Engine>;
         public set onClear(callback: (Engine: Engine) => void) {
             if (this._onClearObserver) {
                 this.onClearObservable.remove(this._onClearObserver);

src/PostProcess/babylon.ssao2RenderingPipeline.ts

@@ -53,14 +53,35 @@
         * Number of samples used for the SSAO calculations. Default value is 8
         * @type {number}
         */
-        @serialize()
+        @serialize("samples")
         private _samples: number = 8;
 
+        public set samples(n: number) {
+            this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
+
+            this._samples = n;
+            for (var i = 0; i < this._scene.cameras.length; i++) {
+                var camera = this._scene.cameras[i];
+                this._ssaoPostProcess.dispose(camera);
+            }
+
+            this._createSSAOPostProcess(this._ratio.ssaoRatio);
+            this.addEffect(new PostProcessRenderEffect(this._scene.getEngine(), this.SSAOBlurHRenderEffect, () => { return this._blurHPostProcess; }, true));
+            this.addEffect(new PostProcessRenderEffect(this._scene.getEngine(), this.SSAOBlurVRenderEffect, () => { return this._blurVPostProcess; }, true));
+
+            if (this._cameras)
+                this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
+        }
+
+        public get samples(): number {
+            return this._samples;
+        }
+
         /**
         * Are we using bilateral blur ?
         * @type {boolean}
         */
-        @serialize()
+        @serialize("expensiveBlur")
         private _expensiveBlur: boolean = true;
         public set expensiveBlur(b: boolean) {
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
@@ -84,28 +105,6 @@
             return this._expensiveBlur;
         }
 
-
-        public set samples(n: number) {
-            this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
-
-            this._samples = n;
-            for (var i = 0; i < this._scene.cameras.length; i++) {
-                var camera = this._scene.cameras[i];
-                this._ssaoPostProcess.dispose(camera);
-            }
-
-            this._createSSAOPostProcess(this._ratio.ssaoRatio);
-            this.addEffect(new PostProcessRenderEffect(this._scene.getEngine(), this.SSAOBlurHRenderEffect, () => { return this._blurHPostProcess; }, true));
-            this.addEffect(new PostProcessRenderEffect(this._scene.getEngine(), this.SSAOBlurVRenderEffect, () => { return this._blurVPostProcess; }, true));
-
-            if (this._cameras)
-                this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
-        }
-
-        public get samples(): number {
-            return this._samples;
-        }
-
         /**
         * The radius around the analyzed pixel used by the SSAO post-process. Default value is 2.0
         * @type {number}
@@ -158,8 +157,8 @@
 
             // Set up assets
             this._createRandomTexture();
-            this._depthTexture = scene.enableGeometryRenderer().getGBuffer().depthTexture; 
-            this._normalTexture = scene.enableGeometryRenderer().getGBuffer().textures[1];
+            this._depthTexture = scene.enableGeometryBufferRenderer().getGBuffer().depthTexture; 
+            this._normalTexture = scene.enableGeometryBufferRenderer().getGBuffer().textures[1];
 
             this._originalColorPostProcess = new PassPostProcess("SSAOOriginalSceneColor", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false);
             this._createSSAOPostProcess(1.0);
@@ -184,7 +183,7 @@
         /**
          * Removes the internal pipeline assets and detatches the pipeline from the scene cameras
          */
-        public dispose(disableGeometryRenderer: boolean = false): void {
+        public dispose(disableGeometryBufferRenderer: boolean = false): void {
             for (var i = 0; i < this._scene.cameras.length; i++) {
                 var camera = this._scene.cameras[i];
 
@@ -197,8 +196,8 @@
 
             this._randomTexture.dispose();
 
-            if (disableGeometryRenderer)
-                this._scene.disableGeometryRenderer();
+            if (disableGeometryBufferRenderer)
+                this._scene.disableGeometryBufferRenderer();
 
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._scene.cameras);
 

src/Rendering/babylon.geometryRenderer.ts

@@ -1,5 +1,5 @@
 module BABYLON {
-    export class GeometryRenderer {
+    export class GeometryBufferRenderer {
         private _scene: Scene;
         private _multiRenderTarget: MultiRenderTarget;
         private _effect: Effect;
@@ -11,6 +11,10 @@ module BABYLON {
 
         private _cachedDefines: string;
 
+        public set renderList(meshes: Mesh[]) {
+            this._multiRenderTarget.renderList = meshes;
+        }
+
         constructor(scene: Scene, ratio: number = 1) {
             this._scene = scene;
             var engine = scene.getEngine();
@@ -86,7 +90,11 @@ module BABYLON {
                 }
             };
 
-            this._multiRenderTarget.renderList = scene.getActiveMeshes().data;
+        }
+
+        public get isSupported(): boolean {
+            var engine = this._scene.getEngine();
+            return (engine.webGLVersion > 1) || engine.getCaps().drawBuffersExtension;
         }
 
         public isReady(subMesh: SubMesh, useInstances: boolean): boolean {

src/babylon.scene.ts

@@ -711,7 +711,7 @@
         private _debugLayer: DebugLayer;
 
         private _depthRenderer: DepthRenderer;
-        private _geometryRenderer: GeometryRenderer;
+        private _geometryBufferRenderer: GeometryBufferRenderer;
 
         private _uniqueIdCounter = 0;
 
@@ -2941,8 +2941,8 @@
             }
 
             // Geometry renderer
-            if (this._geometryRenderer) {
-                this._renderTargets.push(this._geometryRenderer.getGBuffer());
+            if (this._geometryBufferRenderer) {
+                this._renderTargets.push(this._geometryBufferRenderer.getGBuffer());
             }
 
             // RenderPipeline
@@ -3139,23 +3139,23 @@
             this._depthRenderer = null;
         }
 
-        public enableGeometryRenderer(ratio: number = 1): GeometryRenderer {
-            if (this._geometryRenderer) {
-                return this._geometryRenderer;
+        public enableGeometryBufferRenderer(ratio: number = 1): GeometryBufferRenderer {
+            if (this._geometryBufferRenderer) {
+                return this._geometryBufferRenderer;
             }
 
-            this._geometryRenderer = new GeometryRenderer(this, ratio);
+            this._geometryBufferRenderer = new GeometryBufferRenderer(this, ratio);
 
-            return this._geometryRenderer;
+            return this._geometryBufferRenderer;
         }
 
-        public disableGeometryRenderer(): void {
-            if (!this._geometryRenderer) {
+        public disableGeometryBufferRenderer(): void {
+            if (!this._geometryBufferRenderer) {
                 return;
             }
 
-            this._geometryRenderer.dispose();
-            this._geometryRenderer = null;
+            this._geometryBufferRenderer.dispose();
+            this._geometryBufferRenderer = null;
         }
 
         public freezeMaterials(): void {