Add support for ReflectionOverAlpha in stdMat

src/Cameras/babylon.arcRotateCamera.js

@@ -70,6 +70,9 @@ var BABYLON;
                 var sina = Math.sin(_this.alpha);
                 var cosb = Math.cos(_this.beta);
                 var sinb = Math.sin(_this.beta);
+                if (sinb === 0) {
+                    sinb = 0.0001;
+                }
                 var target = _this._getTargetPosition();
                 target.addToRef(new BABYLON.Vector3(_this.radius * cosa * sinb, _this.radius * cosb, _this.radius * sina * sinb), _this._newPosition);
                 _this.position.copyFrom(_this._newPosition);

src/Cameras/babylon.arcRotateCamera.ts

@@ -581,6 +581,11 @@
             var sina = Math.sin(this.alpha);
             var cosb = Math.cos(this.beta);
             var sinb = Math.sin(this.beta);
+
+            if (sinb === 0) {
+                sinb = 0.0001;
+            }
+
             var target = this._getTargetPosition();
             target.addToRef(new Vector3(this.radius * cosa * sinb, this.radius * cosb, this.radius * sina * sinb), this._newPosition);
             this.position.copyFrom(this._newPosition);

src/Materials/babylon.standardMaterial.js

@@ -91,6 +91,7 @@ var BABYLON;
             this.LOGARITHMICDEPTH = false;
             this.REFRACTION = false;
             this.REFRACTIONMAP_3D = false;
+            this.REFLECTIONOVERALPHA = false;
             this._keys = Object.keys(this);
         }
         return StandardMaterialDefines;
@@ -110,6 +111,7 @@ var BABYLON;
             this.linkEmissiveWithDiffuse = false;
             this.useReflectionFresnelFromSpecular = false;
             this.useSpecularOverAlpha = false;
+            this.useReflectionOverAlpha = false;
             this.disableLighting = false;
             this.roughness = 0;
             this.indexOfRefraction = 0.98;
@@ -228,6 +230,9 @@ var BABYLON;
                         if (this.roughness > 0) {
                             this._defines.ROUGHNESS = true;
                         }
+                        if (this.useReflectionOverAlpha) {
+                            this._defines.REFLECTIONOVERALPHA = true;
+                        }
                         if (this.reflectionTexture.coordinatesMode === BABYLON.Texture.INVCUBIC_MODE) {
                             this._defines.INVERTCUBICMAP = true;
                         }
@@ -326,9 +331,6 @@ var BABYLON;
             if (this.linkEmissiveWithDiffuse) {
                 this._defines.LINKEMISSIVEWITHDIFFUSE = true;
             }
-            if (this.useReflectionFresnelFromSpecular) {
-                this._defines.REFLECTIONFRESNELFROMSPECULAR = true;
-            }
             if (this.useLogarithmicDepth) {
                 this._defines.LOGARITHMICDEPTH = true;
             }
@@ -358,6 +360,9 @@ var BABYLON;
                     }
                     if (this.reflectionFresnelParameters && this.reflectionFresnelParameters.isEnabled) {
                         this._defines.REFLECTIONFRESNEL = true;
+                        if (this.useReflectionFresnelFromSpecular) {
+                            this._defines.REFLECTIONFRESNELFROMSPECULAR = true;
+                        }
                     }
                     if (this.refractionFresnelParameters && this.refractionFresnelParameters.isEnabled) {
                         this._defines.REFRACTIONFRESNEL = true;
@@ -738,6 +743,7 @@ var BABYLON;
             newStandardMaterial.useGlossinessFromSpecularMapAlpha = this.useGlossinessFromSpecularMapAlpha;
             newStandardMaterial.useReflectionFresnelFromSpecular = this.useReflectionFresnelFromSpecular;
             newStandardMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            newStandardMaterial.useReflectionOverAlpha = this.useReflectionOverAlpha;
             newStandardMaterial.roughness = this.roughness;
             newStandardMaterial.indexOfRefraction = this.indexOfRefraction;
             newStandardMaterial.invertRefractionY = this.invertRefractionY;
@@ -769,6 +775,8 @@ var BABYLON;
             serializationObject.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
             serializationObject.indexOfRefraction = this.indexOfRefraction;
             serializationObject.invertRefractionY = this.invertRefractionY;
+            serializationObject.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            serializationObject.useReflectionOverAlpha = this.useReflectionOverAlpha;
             if (this.diffuseTexture) {
                 serializationObject.diffuseTexture = this.diffuseTexture.serialize();
             }
@@ -825,6 +833,8 @@ var BABYLON;
             material.useEmissiveAsIllumination = source.useEmissiveAsIllumination;
             material.indexOfRefraction = source.indexOfRefraction;
             material.invertRefractionY = source.invertRefractionY;
+            material.useSpecularOverAlpha = source.useSpecularOverAlpha;
+            material.useReflectionOverAlpha = source.useReflectionOverAlpha;
             material.alpha = source.alpha;
             material.id = source.id;
             if (source.disableDepthWrite) {

src/Materials/babylon.standardMaterial.ts

@@ -82,6 +82,7 @@
         public LOGARITHMICDEPTH = false;
         public REFRACTION = false;
         public REFRACTIONMAP_3D = false;
+        public REFLECTIONOVERALPHA = false;
 
         constructor() {
             super();
@@ -110,6 +111,7 @@
         public linkEmissiveWithDiffuse = false;
         public useReflectionFresnelFromSpecular = false;
         public useSpecularOverAlpha = false;
+        public useReflectionOverAlpha = false;
         public disableLighting = false;
 
         public roughness = 0;
@@ -265,6 +267,10 @@
                             this._defines.ROUGHNESS = true;
                         }
 
+                        if (this.useReflectionOverAlpha) {
+                            this._defines.REFLECTIONOVERALPHA = true;
+                        }
+
                         if (this.reflectionTexture.coordinatesMode === Texture.INVCUBIC_MODE) {
                             this._defines.INVERTCUBICMAP = true;
                         }
@@ -372,10 +378,6 @@
                 this._defines.LINKEMISSIVEWITHDIFFUSE = true;
             }
 
-            if (this.useReflectionFresnelFromSpecular) {
-                this._defines.REFLECTIONFRESNELFROMSPECULAR = true;
-            }
-
             if (this.useLogarithmicDepth) {
                 this._defines.LOGARITHMICDEPTH = true;
             }
@@ -412,6 +414,10 @@
 
                     if (this.reflectionFresnelParameters && this.reflectionFresnelParameters.isEnabled) {
                         this._defines.REFLECTIONFRESNEL = true;
+
+                        if (this.useReflectionFresnelFromSpecular) {
+                            this._defines.REFLECTIONFRESNELFROMSPECULAR = true;
+                        }
                     }
 
                     if (this.refractionFresnelParameters && this.refractionFresnelParameters.isEnabled) {
@@ -896,6 +902,7 @@
             newStandardMaterial.useGlossinessFromSpecularMapAlpha = this.useGlossinessFromSpecularMapAlpha;
             newStandardMaterial.useReflectionFresnelFromSpecular = this.useReflectionFresnelFromSpecular;
             newStandardMaterial.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            newStandardMaterial.useReflectionOverAlpha = this.useReflectionOverAlpha;
             newStandardMaterial.roughness = this.roughness;
             newStandardMaterial.indexOfRefraction = this.indexOfRefraction;
             newStandardMaterial.invertRefractionY = this.invertRefractionY;
@@ -931,6 +938,8 @@
             serializationObject.useEmissiveAsIllumination = this.useEmissiveAsIllumination;
             serializationObject.indexOfRefraction = this.indexOfRefraction;
             serializationObject.invertRefractionY = this.invertRefractionY;
+            serializationObject.useSpecularOverAlpha = this.useSpecularOverAlpha;
+            serializationObject.useReflectionOverAlpha = this.useReflectionOverAlpha;
 
             if (this.diffuseTexture) {
                 serializationObject.diffuseTexture = this.diffuseTexture.serialize();
@@ -1017,6 +1026,8 @@
             material.useEmissiveAsIllumination = source.useEmissiveAsIllumination;
             material.indexOfRefraction = source.indexOfRefraction;
             material.invertRefractionY = source.invertRefractionY;
+            material.useSpecularOverAlpha = source.useSpecularOverAlpha;
+            material.useReflectionOverAlpha = source.useReflectionOverAlpha;
 
             material.alpha = source.alpha;
 

src/Mesh/babylon.mesh.vertexData.js

@@ -914,6 +914,27 @@ var BABYLON;
             vertexData.uvs = uvs;
             return vertexData;
         };
+        VertexData.CreateLineSystem = function (options) {
+            var indices = [];
+            var positions = [];
+            var lines = options.lines;
+            var idx = 0;
+            for (var l = 0; l < lines.length; l++) {
+                var points = lines[l];
+                for (var index = 0; index < points.length; index++) {
+                    positions.push(points[index].x, points[index].y, points[index].z);
+                    if (index > 0) {
+                        indices.push(idx - 1);
+                        indices.push(idx);
+                    }
+                    idx++;
+                }
+            }
+            var vertexData = new VertexData();
+            vertexData.indices = indices;
+            vertexData.positions = positions;
+            return vertexData;
+        };
         VertexData.CreateLines = function (options) {
             var indices = [];
             var positions = [];

src/Mesh/babylon.mesh.vertexData.ts

@@ -1106,31 +1106,31 @@
 
             return vertexData;
         }
-        
-        public static CreateLineSystem(options: {lines: Vector3[][]}): VertexData {
+
+        public static CreateLineSystem(options: { lines: Vector3[][] }): VertexData {
             var indices = [];
             var positions = [];
             var lines = options.lines;
             var idx = 0;
-            
+
             for (var l = 0; l < lines.length; l++) {
                 var points = lines[l];
                 for (var index = 0; index < points.length; index++) {
                     positions.push(points[index].x, points[index].y, points[index].z);
-                    
+
                     if (index > 0) {
                         indices.push(idx - 1);
                         indices.push(idx);
                     }
-                    idx ++;
-                }               
+                    idx++;
+                }
             }
             var vertexData = new VertexData();
             vertexData.indices = indices;
             vertexData.positions = positions;
             return vertexData;
         }
-        
+
         public static CreateLines(options: { points: Vector3[] }): VertexData {
             var indices = [];
             var positions = [];
@@ -2189,4 +2189,3 @@
         }
     }
 }
-

src/Mesh/babylon.meshBuilder.js

@@ -126,6 +126,31 @@ var BABYLON;
             vertexData.applyToMesh(torusKnot, options.updatable);
             return torusKnot;
         };
+        MeshBuilder.CreateLineSystem = function (name, options, scene) {
+            var instance = options.instance;
+            var lines = options.lines;
+            if (instance) {
+                var positionFunction = function (positions) {
+                    var i = 0;
+                    for (var l = 0; l < lines.length; l++) {
+                        var points = lines[l];
+                        for (var p = 0; p < points.length; p++) {
+                            positions[i] = points[p].x;
+                            positions[i + 1] = points[p].y;
+                            positions[i + 2] = points[p].z;
+                            i += 3;
+                        }
+                    }
+                };
+                instance.updateMeshPositions(positionFunction, false);
+                return instance;
+            }
+            // line system creation
+            var lineSystem = new BABYLON.LinesMesh(name, scene);
+            var vertexData = BABYLON.VertexData.CreateLineSystem(options);
+            vertexData.applyToMesh(lineSystem, options.updatable);
+            return lineSystem;
+        };
         MeshBuilder.CreateLines = function (name, options, scene) {
             var instance = options.instance;
             var points = options.points;

src/Mesh/babylon.meshBuilder.ts

@@ -151,11 +151,11 @@
 
             return torusKnot;
         }
-        
-        public static CreateLineSystem(name: string, options: {lines: Vector3[][], updatable: boolean, instance?: LinesMesh}, scene: Scene): LinesMesh {
+
+        public static CreateLineSystem(name: string, options: { lines: Vector3[][], updatable: boolean, instance?: LinesMesh }, scene: Scene): LinesMesh {
             var instance = options.instance;
             var lines = options.lines;
-            
+
             if (instance) { // lines update
                 var positionFunction = positions => {
                     var i = 0;
@@ -844,4 +844,3 @@
         }
     }
 }
-

src/Shaders/default.fragment.fx

@@ -369,6 +369,10 @@ void main(void) {
 	alpha = clamp(alpha + dot(finalSpecular, vec3(0.3, 0.59, 0.11)), 0., 1.);
 #endif
 
+#ifdef REFLECTIONOVERALPHA
+	alpha = clamp(alpha + dot(reflectionColor, vec3(0.3, 0.59, 0.11)), 0., 1.);
+#endif
+
 	// Composition
 #ifdef EMISSIVEASILLUMINATION
 	vec4 color = vec4(clamp(finalDiffuse * baseAmbientColor + finalSpecular + reflectionColor + emissiveColor + refractionColor, 0.0, 1.0), alpha);