Fix normal material to ignore vertexAlpha and vertex colors

dist/preview release/babylon.max.js

@@ -107329,6 +107329,7 @@ var BABYLON;
                     }
                 }
             };
+            this._cachedAngularSensibility = { angularSensibilityX: null, angularSensibilityY: null, angularSensibility: null };
             this.beforeRender = function () {
                 if (_this._leftController && _this._leftController._activePointer) {
                     _this._castRayAndSelectObject(_this._leftController);
@@ -107481,6 +107482,7 @@ var BABYLON;
             // Create VR cameras
             if (webVROptions.createFallbackVRDeviceOrientationFreeCamera) {
                 this._vrDeviceOrientationCamera = new BABYLON.VRDeviceOrientationFreeCamera("VRDeviceOrientationVRHelper", this._position, this._scene);
+                this._vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
             }
             this._webVRCamera = new BABYLON.WebVRFreeCamera("WebVRHelper", this._position, this._scene, webVROptions);
             this._webVRCamera.useStandingMatrix();
@@ -107903,6 +107905,7 @@ var BABYLON;
                 this._position = this._scene.activeCamera.position.clone();
                 if (this.vrDeviceOrientationCamera) {
                     this.vrDeviceOrientationCamera.rotation = BABYLON.Quaternion.FromRotationMatrix(this._scene.activeCamera.getWorldMatrix().getRotationMatrix()).toEulerAngles();
+                    this.vrDeviceOrientationCamera.angularSensibility = 2000;
                 }
                 if (this.webVRCamera) {
                     var currentYRotation = this.webVRCamera.deviceRotationQuaternion.toEulerAngles().y;
@@ -107913,6 +107916,19 @@ var BABYLON;
                 }
                 // make sure that we return to the last active camera
                 this._existingCamera = this._scene.activeCamera;
+                // Remove and cache angular sensability to avoid camera rotation when in VR
+                if (this._existingCamera.angularSensibilityX) {
+                    this._cachedAngularSensibility.angularSensibilityX = this._existingCamera.angularSensibilityX;
+                    this._existingCamera.angularSensibilityX = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibilityY) {
+                    this._cachedAngularSensibility.angularSensibilityY = this._existingCamera.angularSensibilityY;
+                    this._existingCamera.angularSensibilityY = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibility) {
+                    this._cachedAngularSensibility.angularSensibility = this._existingCamera.angularSensibility;
+                    this._existingCamera.angularSensibility = Number.MAX_VALUE;
+                }
             }
             if (this._webVRrequesting) {
                 return;
@@ -107960,16 +107976,45 @@ var BABYLON;
                 if (this._scene.activeCamera) {
                     this._position = this._scene.activeCamera.position.clone();
                 }
+                if (this.vrDeviceOrientationCamera) {
+                    this.vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
+                }
                 if (this._deviceOrientationCamera) {
                     this._deviceOrientationCamera.position = this._position;
                     this._scene.activeCamera = this._deviceOrientationCamera;
                     if (this._canvas) {
                         this._scene.activeCamera.attachControl(this._canvas);
                     }
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._deviceOrientationCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._deviceOrientationCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._deviceOrientationCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 else if (this._existingCamera) {
                     this._existingCamera.position = this._position;
                     this._scene.activeCamera = this._existingCamera;
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._existingCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._existingCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._existingCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 this.updateButtonVisibility();
                 if (this._interactionsEnabled) {

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

@@ -107296,6 +107296,7 @@ var BABYLON;
                     }
                 }
             };
+            this._cachedAngularSensibility = { angularSensibilityX: null, angularSensibilityY: null, angularSensibility: null };
             this.beforeRender = function () {
                 if (_this._leftController && _this._leftController._activePointer) {
                     _this._castRayAndSelectObject(_this._leftController);
@@ -107448,6 +107449,7 @@ var BABYLON;
             // Create VR cameras
             if (webVROptions.createFallbackVRDeviceOrientationFreeCamera) {
                 this._vrDeviceOrientationCamera = new BABYLON.VRDeviceOrientationFreeCamera("VRDeviceOrientationVRHelper", this._position, this._scene);
+                this._vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
             }
             this._webVRCamera = new BABYLON.WebVRFreeCamera("WebVRHelper", this._position, this._scene, webVROptions);
             this._webVRCamera.useStandingMatrix();
@@ -107870,6 +107872,7 @@ var BABYLON;
                 this._position = this._scene.activeCamera.position.clone();
                 if (this.vrDeviceOrientationCamera) {
                     this.vrDeviceOrientationCamera.rotation = BABYLON.Quaternion.FromRotationMatrix(this._scene.activeCamera.getWorldMatrix().getRotationMatrix()).toEulerAngles();
+                    this.vrDeviceOrientationCamera.angularSensibility = 2000;
                 }
                 if (this.webVRCamera) {
                     var currentYRotation = this.webVRCamera.deviceRotationQuaternion.toEulerAngles().y;
@@ -107880,6 +107883,19 @@ var BABYLON;
                 }
                 // make sure that we return to the last active camera
                 this._existingCamera = this._scene.activeCamera;
+                // Remove and cache angular sensability to avoid camera rotation when in VR
+                if (this._existingCamera.angularSensibilityX) {
+                    this._cachedAngularSensibility.angularSensibilityX = this._existingCamera.angularSensibilityX;
+                    this._existingCamera.angularSensibilityX = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibilityY) {
+                    this._cachedAngularSensibility.angularSensibilityY = this._existingCamera.angularSensibilityY;
+                    this._existingCamera.angularSensibilityY = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibility) {
+                    this._cachedAngularSensibility.angularSensibility = this._existingCamera.angularSensibility;
+                    this._existingCamera.angularSensibility = Number.MAX_VALUE;
+                }
             }
             if (this._webVRrequesting) {
                 return;
@@ -107927,16 +107943,45 @@ var BABYLON;
                 if (this._scene.activeCamera) {
                     this._position = this._scene.activeCamera.position.clone();
                 }
+                if (this.vrDeviceOrientationCamera) {
+                    this.vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
+                }
                 if (this._deviceOrientationCamera) {
                     this._deviceOrientationCamera.position = this._position;
                     this._scene.activeCamera = this._deviceOrientationCamera;
                     if (this._canvas) {
                         this._scene.activeCamera.attachControl(this._canvas);
                     }
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._deviceOrientationCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._deviceOrientationCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._deviceOrientationCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 else if (this._existingCamera) {
                     this._existingCamera.position = this._position;
                     this._scene.activeCamera = this._existingCamera;
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._existingCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._existingCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._existingCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 this.updateButtonVisibility();
                 if (this._interactionsEnabled) {

dist/preview release/es6.js

@@ -107296,6 +107296,7 @@ var BABYLON;
                     }
                 }
             };
+            this._cachedAngularSensibility = { angularSensibilityX: null, angularSensibilityY: null, angularSensibility: null };
             this.beforeRender = function () {
                 if (_this._leftController && _this._leftController._activePointer) {
                     _this._castRayAndSelectObject(_this._leftController);
@@ -107448,6 +107449,7 @@ var BABYLON;
             // Create VR cameras
             if (webVROptions.createFallbackVRDeviceOrientationFreeCamera) {
                 this._vrDeviceOrientationCamera = new BABYLON.VRDeviceOrientationFreeCamera("VRDeviceOrientationVRHelper", this._position, this._scene);
+                this._vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
             }
             this._webVRCamera = new BABYLON.WebVRFreeCamera("WebVRHelper", this._position, this._scene, webVROptions);
             this._webVRCamera.useStandingMatrix();
@@ -107870,6 +107872,7 @@ var BABYLON;
                 this._position = this._scene.activeCamera.position.clone();
                 if (this.vrDeviceOrientationCamera) {
                     this.vrDeviceOrientationCamera.rotation = BABYLON.Quaternion.FromRotationMatrix(this._scene.activeCamera.getWorldMatrix().getRotationMatrix()).toEulerAngles();
+                    this.vrDeviceOrientationCamera.angularSensibility = 2000;
                 }
                 if (this.webVRCamera) {
                     var currentYRotation = this.webVRCamera.deviceRotationQuaternion.toEulerAngles().y;
@@ -107880,6 +107883,19 @@ var BABYLON;
                 }
                 // make sure that we return to the last active camera
                 this._existingCamera = this._scene.activeCamera;
+                // Remove and cache angular sensability to avoid camera rotation when in VR
+                if (this._existingCamera.angularSensibilityX) {
+                    this._cachedAngularSensibility.angularSensibilityX = this._existingCamera.angularSensibilityX;
+                    this._existingCamera.angularSensibilityX = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibilityY) {
+                    this._cachedAngularSensibility.angularSensibilityY = this._existingCamera.angularSensibilityY;
+                    this._existingCamera.angularSensibilityY = Number.MAX_VALUE;
+                }
+                if (this._existingCamera.angularSensibility) {
+                    this._cachedAngularSensibility.angularSensibility = this._existingCamera.angularSensibility;
+                    this._existingCamera.angularSensibility = Number.MAX_VALUE;
+                }
             }
             if (this._webVRrequesting) {
                 return;
@@ -107927,16 +107943,45 @@ var BABYLON;
                 if (this._scene.activeCamera) {
                     this._position = this._scene.activeCamera.position.clone();
                 }
+                if (this.vrDeviceOrientationCamera) {
+                    this.vrDeviceOrientationCamera.angularSensibility = Number.MAX_VALUE;
+                }
                 if (this._deviceOrientationCamera) {
                     this._deviceOrientationCamera.position = this._position;
                     this._scene.activeCamera = this._deviceOrientationCamera;
                     if (this._canvas) {
                         this._scene.activeCamera.attachControl(this._canvas);
                     }
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._deviceOrientationCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._deviceOrientationCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._deviceOrientationCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 else if (this._existingCamera) {
                     this._existingCamera.position = this._position;
                     this._scene.activeCamera = this._existingCamera;
+                    // Restore angular sensibility
+                    if (this._cachedAngularSensibility.angularSensibilityX) {
+                        this._existingCamera.angularSensibilityX = this._cachedAngularSensibility.angularSensibilityX;
+                        this._cachedAngularSensibility.angularSensibilityX = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibilityY) {
+                        this._existingCamera.angularSensibilityY = this._cachedAngularSensibility.angularSensibilityY;
+                        this._cachedAngularSensibility.angularSensibilityY = null;
+                    }
+                    if (this._cachedAngularSensibility.angularSensibility) {
+                        this._existingCamera.angularSensibility = this._cachedAngularSensibility.angularSensibility;
+                        this._cachedAngularSensibility.angularSensibility = null;
+                    }
                 }
                 this.updateButtonVisibility();
                 if (this._interactionsEnabled) {

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

@@ -11,6 +11,7 @@ declare module BABYLON {
         private _renderId;
         constructor(name: string, scene: Scene);
         needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
         isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;

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

@@ -61,6 +61,7 @@ declare module BABYLON {
         private _renderId;
         constructor(name: string, scene: Scene);
         needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
         isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;

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

@@ -66,6 +66,7 @@ declare module BABYLON {
         private _renderId;
         constructor(name: string, scene: Scene);
         needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
         needAlphaTesting(): boolean;
         getAlphaTestTexture(): Nullable<BaseTexture>;
         isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;

materialsLibrary/src/normal/babylon.normalMaterial.ts

@@ -55,8 +55,6 @@ module BABYLON {
         public NORMAL = false;
         public UV1 = false;
         public UV2 = false;
-        public VERTEXCOLOR = false;
-        public VERTEXALPHA = false;
         public NUM_BONE_INFLUENCERS = 0;
         public BonesPerMesh = 0;
         public INSTANCES = false;
@@ -96,6 +94,10 @@ module BABYLON {
             return (this.alpha < 1.0);
         }
 
+        public needAlphaBlendingForMesh(mesh: AbstractMesh): boolean {
+            return this.needAlphaBlending() || (mesh.visibility < 1.0);
+        }
+
         public needAlphaTesting(): boolean {
             return false;
         }
@@ -187,10 +189,6 @@ module BABYLON {
                     attribs.push(VertexBuffer.UV2Kind);
                 }
 
-                if (defines.VERTEXCOLOR) {
-                    attribs.push(VertexBuffer.ColorKind);
-                }
-
                 MaterialHelper.PrepareAttributesForBones(attribs, mesh, defines, fallbacks);
                 MaterialHelper.PrepareAttributesForInstances(attribs, defines);
 

materialsLibrary/src/normal/normal.fragment.fx

@@ -11,10 +11,6 @@ varying vec3 vPositionW;
 varying vec3 vNormalW;
 #endif
 
-#ifdef VERTEXCOLOR
-varying vec4 vColor;
-#endif
-
 // Helper functions
 #include<helperFunctions>
 
@@ -69,10 +65,6 @@ void main(void) {
     baseColor = mix(baseColor, vec4(vNormalW, 1.0), 0.5);
 #endif
 
-#ifdef VERTEXCOLOR
-	baseColor.rgb *= vColor.rgb;
-#endif
-
 	// Normal
 #ifdef NORMAL
 	vec3 normalW = normalize(vNormalW);
@@ -91,11 +83,6 @@ void main(void) {
 #include<lightFragment>[2]
 #include<lightFragment>[3]
 
-
-#ifdef VERTEXALPHA
-	alpha *= vColor.a;
-#endif
-
 	vec3 finalDiffuse = clamp(diffuseBase * diffuseColor, 0.0, 1.0) * baseColor.rgb;
 
 	// Composition

materialsLibrary/src/normal/normal.vertex.fx

@@ -39,11 +39,6 @@ varying vec3 vPositionW;
 varying vec3 vNormalW;
 #endif
 
-#ifdef VERTEXCOLOR
-varying vec4 vColor;
-#endif
-
-
 #include<clipPlaneVertexDeclaration>
 
 #include<fogVertexDeclaration>
@@ -89,11 +84,6 @@ void main(void) {
 #include<fogVertex>
 #include<shadowsVertex>[0..maxSimultaneousLights]
 
-	// Vertex color
-#ifdef VERTEXCOLOR
-	vColor = color;
-#endif
-
 	// Point size
 #ifdef POINTSIZE
 	gl_PointSize = pointSize;