More integration for Shadow Poisson sampling

Babylon/Culling/babylon.boundingBox.js

@@ -156,4 +156,4 @@
     })();
     BABYLON.BoundingBox = BoundingBox;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.BoundingBox.js.map
+//# sourceMappingURL=babylon.boundingBox.js.map

Babylon/Lights/Shadows/babylon.shadowGenerator.js

@@ -4,8 +4,7 @@
         function ShadowGenerator(mapSize, light) {
             var _this = this;
             // Members
-            this.useVarianceShadowMap = true;
-            this.usePoissonSampling = false;
+            this.filter = ShadowGenerator.FILTER_VARIANCESHADOWMAP;
             this._darkness = 0;
             this._transparencyShadow = false;
             this._viewMatrix = BABYLON.Matrix.Zero();
@@ -106,6 +105,53 @@
                 }
             };
         }
+        Object.defineProperty(ShadowGenerator, "FILTER_NONE", {
+            // Static
+            get: function () {
+                return ShadowGenerator._FILTER_NONE;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ShadowGenerator, "FILTER_VARIANCESHADOWMAP", {
+            get: function () {
+                return ShadowGenerator._FILTER_VARIANCESHADOWMAP;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ShadowGenerator, "FILTER_POISSONSAMPLING", {
+            get: function () {
+                return ShadowGenerator._FILTER_POISSONSAMPLING;
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ShadowGenerator.prototype, "useVarianceShadowMap", {
+            get: function () {
+                return this.filter === ShadowGenerator.FILTER_VARIANCESHADOWMAP;
+            },
+            set: function (value) {
+                this.filter = (value ? ShadowGenerator.FILTER_VARIANCESHADOWMAP : ShadowGenerator.FILTER_NONE);
+            },
+            enumerable: true,
+            configurable: true
+        });
+
+        Object.defineProperty(ShadowGenerator.prototype, "usePoissonSampling", {
+            get: function () {
+                return this.filter === ShadowGenerator.FILTER_POISSONSAMPLING;
+            },
+            set: function (value) {
+                this.filter = (value ? ShadowGenerator.FILTER_POISSONSAMPLING : ShadowGenerator.FILTER_NONE);
+            },
+            enumerable: true,
+            configurable: true
+        });
+
         ShadowGenerator.prototype.isReady = function (mesh, useInstances) {
             var defines = [];
 
@@ -207,6 +253,9 @@
         ShadowGenerator.prototype.dispose = function () {
             this._shadowMap.dispose();
         };
+        ShadowGenerator._FILTER_NONE = 0;
+        ShadowGenerator._FILTER_VARIANCESHADOWMAP = 1;
+        ShadowGenerator._FILTER_POISSONSAMPLING = 2;
         return ShadowGenerator;
     })();
     BABYLON.ShadowGenerator = ShadowGenerator;

Babylon/Lights/Shadows/babylon.shadowGenerator.ts

@@ -1,8 +1,38 @@
 module BABYLON {
     export class ShadowGenerator {
+        private static _FILTER_NONE = 0;
+        private static _FILTER_VARIANCESHADOWMAP = 1;
+        private static _FILTER_POISSONSAMPLING = 2;
+
+        // Static
+        public static get FILTER_NONE(): number {
+            return ShadowGenerator._FILTER_NONE;
+        }
+
+        public static get FILTER_VARIANCESHADOWMAP(): number {
+            return ShadowGenerator._FILTER_VARIANCESHADOWMAP;
+        }
+
+        public static get FILTER_POISSONSAMPLING(): number {
+            return ShadowGenerator._FILTER_POISSONSAMPLING;
+        }
+
         // Members
-        public useVarianceShadowMap = true;
-        public usePoissonSampling = false;
+        public filter = ShadowGenerator.FILTER_VARIANCESHADOWMAP;
+
+        public get useVarianceShadowMap(): boolean {
+            return this.filter === ShadowGenerator.FILTER_VARIANCESHADOWMAP;
+        }
+        public set useVarianceShadowMap(value: boolean) {
+            this.filter = (value ? ShadowGenerator.FILTER_VARIANCESHADOWMAP : ShadowGenerator.FILTER_NONE);
+        }
+
+        public get usePoissonSampling(): boolean {
+            return this.filter === ShadowGenerator.FILTER_POISSONSAMPLING;
+        }
+        public set usePoissonSampling(value: boolean) {
+            this.filter = (value ? ShadowGenerator.FILTER_POISSONSAMPLING : ShadowGenerator.FILTER_NONE);
+        }
 
         private _light: DirectionalLight;
         private _scene: Scene;

Babylon/Loading/Plugins/babylon.babylonFileLoader.js

@@ -224,8 +224,12 @@ var BABYLON = BABYLON || {};
             shadowGenerator.getShadowMap().renderList.push(mesh);
         }
 
-        shadowGenerator.useVarianceShadowMap = parsedShadowGenerator.useVarianceShadowMap;
-
+        if (parsedShadowGenerator.usePoissonSampling) {
+            shadowGenerator.usePoissonSampling = true;
+        } else {
+            shadowGenerator.useVarianceShadowMap = parsedShadowGenerator.useVarianceShadowMap;
+        }
+        
         return shadowGenerator;
     };
 

Babylon/Mesh/babylon.InstancedMesh.js

@@ -163,4 +163,4 @@ var BABYLON;
     })(BABYLON.AbstractMesh);
     BABYLON.InstancedMesh = InstancedMesh;
 })(BABYLON || (BABYLON = {}));
-//# sourceMappingURL=babylon.InstancedMesh.js.map
+//# sourceMappingURL=babylon.instancedMesh.js.map

Babylon/Shaders/default.fragment.fx

@@ -213,17 +213,17 @@ float computeShadowWithPCF(vec4 vPositionFromLight, sampler2D shadowSampler)
 
 	float visibility = 1.;
 
-    vec2 poissonDisk[4];
-	poissonDisk[0] = vec2( -0.94201624, -0.39906216 );
-	poissonDisk[1] = vec2( 0.94558609, -0.76890725 );
-	poissonDisk[2] = vec2( -0.094184101, -0.92938870 );
-	poissonDisk[3] = vec2( 0.34495938, 0.29387760 );
+	vec2 poissonDisk[4];
+	poissonDisk[0] = vec2(-0.94201624, -0.39906216);
+	poissonDisk[1] = vec2(0.94558609, -0.76890725);
+	poissonDisk[2] = vec2(-0.094184101, -0.92938870);
+	poissonDisk[3] = vec2(0.34495938, 0.29387760);
 
 	// Poisson Sampling
-	for (int i=0;i<4;i++){
-	   	if ( unpack(texture2D( shadowSampler, uv + poissonDisk[i]/1500.0 ))  <  depth.z ){
-	    	visibility -= 0.2;
-	  	}
+	for (int i = 0; i<4; i++){
+		if (unpack(texture2D(shadowSampler, uv + poissonDisk[i] / 1500.0))  <  depth.z){
+			visibility -= 0.2;
+		}
 	}
 	return visibility;
 }
@@ -353,7 +353,7 @@ lightingInfo computeLighting(vec3 viewDirectionW, vec3 vNormal, vec4 lightData,
 	{
 		vec3 direction = lightData.xyz - vPositionW;
 
-		attenuation =  max(0., 1.0 - length(direction) / range);
+		attenuation = max(0., 1.0 - length(direction) / range);
 		lightVectorW = normalize(direction);
 	}
 	else
@@ -496,11 +496,11 @@ void main(void) {
 #ifdef SHADOWVSM0
 	shadow = computeShadowWithVSM(vPositionFromLight0, shadowSampler0);
 #else
-#ifdef SHADOWPCF0
-	shadow = computeShadowWithPCF(vPositionFromLight0, shadowSampler0);
-#else
-	shadow = computeShadow(vPositionFromLight0, shadowSampler0, darkness0);
-#endif
+	#ifdef SHADOWPCF0
+		shadow = computeShadowWithPCF(vPositionFromLight0, shadowSampler0);
+	#else
+		shadow = computeShadow(vPositionFromLight0, shadowSampler0, darkness0);
+	#endif
 #endif
 #else
 	shadow = 1.;
@@ -523,11 +523,11 @@ void main(void) {
 #ifdef SHADOWVSM1
 	shadow = computeShadowWithVSM(vPositionFromLight1, shadowSampler1);
 #else
-#ifdef SHADOWPCF1
-	shadow = computeShadowWithPCF(vPositionFromLight1, shadowSampler1);
-#else
-	shadow = computeShadow(vPositionFromLight1, shadowSampler1, darkness1);
-#endif
+	#ifdef SHADOWPCF1
+		shadow = computeShadowWithPCF(vPositionFromLight1, shadowSampler1);
+	#else
+		shadow = computeShadow(vPositionFromLight1, shadowSampler1, darkness1);
+	#endif
 #endif
 #else
 	shadow = 1.;
@@ -550,11 +550,11 @@ void main(void) {
 #ifdef SHADOWVSM2
 	shadow = computeShadowWithVSM(vPositionFromLight2, shadowSampler2);
 #else
-#ifdef SHADOWPCF2
-	shadow = computeShadowWithPCF(vPositionFromLight2, shadowSampler2);
-#else
-	shadow = computeShadow(vPositionFromLight2, shadowSampler2, darkness2);
-#endif	
+	#ifdef SHADOWPCF2
+		shadow = computeShadowWithPCF(vPositionFromLight2, shadowSampler2);
+	#else
+		shadow = computeShadow(vPositionFromLight2, shadowSampler2, darkness2);
+	#endif	
 #endif	
 #else
 	shadow = 1.;
@@ -577,11 +577,11 @@ void main(void) {
 #ifdef SHADOWVSM3
 	shadow = computeShadowWithVSM(vPositionFromLight3, shadowSampler3);
 #else
-#ifdef SHADOWPCF3
-	shadow = computeShadowWithPCF(vPositionFromLight3, shadowSampler3);
-#else
-	shadow = computeShadow(vPositionFromLight3, shadowSampler3, darkness3);
-#endif	
+	#ifdef SHADOWPCF3
+		shadow = computeShadowWithPCF(vPositionFromLight3, shadowSampler3);
+	#else
+		shadow = computeShadow(vPositionFromLight3, shadowSampler3, darkness3);
+	#endif	
 #endif	
 #else
 	shadow = 1.;

Babylon/Tools/babylon.sceneSerializer.js

@@ -347,6 +347,7 @@
         serializationObject.lightId = light.id;
         serializationObject.mapSize = shadowGenerator.getShadowMap().getRenderSize();
         serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;
+        serializationObject.usePoissonSampling = shadowGenerator.usePoissonSampling;
 
         serializationObject.renderList = [];
         for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {

Babylon/Tools/babylon.sceneSerializer.ts

@@ -348,6 +348,7 @@
         serializationObject.lightId = light.id;
         serializationObject.mapSize = shadowGenerator.getShadowMap().getRenderSize();
         serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;
+        serializationObject.usePoissonSampling = shadowGenerator.usePoissonSampling;
 
         serializationObject.renderList = [];
         for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {

Babylon/babylon.scene.js

@@ -8,6 +8,7 @@
             this.clearColor = new BABYLON.Color3(0.2, 0.2, 0.3);
             this.ambientColor = new BABYLON.Color3(0, 0, 0);
             this.forceWireframe = false;
+            this.cameraToUseForPointers = null;
             // Fog
             this.fogMode = BABYLON.Scene.FOGMODE_NONE;
             this.fogColor = new BABYLON.Color3(0.2, 0.2, 0.3);

Babylon/babylon.scene.ts

@@ -29,7 +29,7 @@
         private _onPointerMove: (evt: PointerEvent) => void;
         private _onPointerDown: (evt: PointerEvent) => void;
         public onPointerDown: (evt: PointerEvent, pickInfo: PickingInfo) => void;
-        public cameraToUseForPointers: Camera; // Define this parameter if you are using multiple cameras and you want to specify which one should be used for pointer position
+        public cameraToUseForPointers: Camera = null; // Define this parameter if you are using multiple cameras and you want to specify which one should be used for pointer position
         private _pointerX: number;
         private _pointerY: number;
         private _meshUnderPointer: AbstractMesh;