Integrating latest PRs

src/Animations/babylon.animation.ts

@@ -42,10 +42,10 @@
             if (easingFunction !== undefined) {
                 animation.setEasingFunction(easingFunction);
             }
-            
+
             mesh.animations.push(animation);
 
-            return mesh.getScene().beginAnimation(mesh, 0, totalFrame,(animation.loopMode === 1));
+            return mesh.getScene().beginAnimation(mesh, 0, totalFrame, (animation.loopMode === 1));
 
         }
 
@@ -156,7 +156,7 @@
                 }
             }
 
-            for (var key = startKey; key < this._keys.length ; key++) {
+            for (var key = startKey; key < this._keys.length; key++) {
                 if (this._keys[key + 1].frame >= currentFrame) {
 
                     var startValue = this._getKeyValue(this._keys[key].value);
@@ -227,7 +227,7 @@
                             switch (loopMode) {
                                 case Animation.ANIMATIONLOOPMODE_CYCLE:
                                 case Animation.ANIMATIONLOOPMODE_CONSTANT:
-                                   // return this.matrixInterpolateFunction(startValue, endValue, gradient);
+                                // return this.matrixInterpolateFunction(startValue, endValue, gradient);
                                 case Animation.ANIMATIONLOOPMODE_RELATIVE:
                                     return startValue;
                             }
@@ -414,3 +414,4 @@
         }
     }
 } 
+

src/Cameras/babylon.followCamera.js

@@ -85,3 +85,4 @@ var BABYLON;
     })(BABYLON.TargetCamera);
     BABYLON.ArcFollowCamera = ArcFollowCamera;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.followCamera.js.map

src/Cameras/babylon.followCamera.ts

@@ -1,22 +1,22 @@
 module BABYLON {
     export class FollowCamera extends TargetCamera {
 
-        public radius:number = 12;
-        public rotationOffset:number = 0;
-        public heightOffset:number = 4;
-        public cameraAcceleration:number = 0.05;
-        public maxCameraSpeed:number = 20;
-        public target:AbstractMesh;
-
-        constructor(name:string, position:Vector3, scene:Scene) {
+        public radius: number = 12;
+        public rotationOffset: number = 0;
+        public heightOffset: number = 4;
+        public cameraAcceleration: number = 0.05;
+        public maxCameraSpeed: number = 20;
+        public target: AbstractMesh;
+
+        constructor(name: string, position: Vector3, scene: Scene) {
             super(name, position, scene);
         }
 
-        private getRadians(degrees):number {
+        private getRadians(degrees): number {
             return degrees * Math.PI / 180;
         }
 
-        private follow(cameraTarget:AbstractMesh) {
+        private follow(cameraTarget: AbstractMesh) {
             if (!cameraTarget)
                 return;
 
@@ -29,15 +29,15 @@
                 yRotation = cameraTarget.rotation.y;
             }
             var radians = this.getRadians(this.rotationOffset) + yRotation;
-            var targetX:number = cameraTarget.position.x + Math.sin(radians) * this.radius;
+            var targetX: number = cameraTarget.position.x + Math.sin(radians) * this.radius;
 
-            var targetZ:number = cameraTarget.position.z + Math.cos(radians) * this.radius;
-            var dx:number = targetX - this.position.x;
-            var dy:number = (cameraTarget.position.y + this.heightOffset) - this.position.y;
-            var dz:number = (targetZ) - this.position.z;
-            var vx:number = dx * this.cameraAcceleration * 2;//this is set to .05
-            var vy:number = dy * this.cameraAcceleration;
-            var vz:number = dz * this.cameraAcceleration * 2;
+            var targetZ: number = cameraTarget.position.z + Math.cos(radians) * this.radius;
+            var dx: number = targetX - this.position.x;
+            var dy: number = (cameraTarget.position.y + this.heightOffset) - this.position.y;
+            var dz: number = (targetZ) - this.position.z;
+            var vx: number = dx * this.cameraAcceleration * 2;//this is set to .05
+            var vy: number = dy * this.cameraAcceleration;
+            var vz: number = dz * this.cameraAcceleration * 2;
 
             if (vx > this.maxCameraSpeed || vx < -this.maxCameraSpeed) {
                 vx = vx < 1 ? -this.maxCameraSpeed : this.maxCameraSpeed;
@@ -55,7 +55,7 @@
             this.setTarget(cameraTarget.position);
         }
 
-        public _checkInputs():void {
+        public _checkInputs(): void {
             super._checkInputs();
             this.follow(this.target);
         }
@@ -63,14 +63,14 @@
 
     export class ArcFollowCamera extends TargetCamera {
 
-        private _cartesianCoordinates:Vector3 = Vector3.Zero();
+        private _cartesianCoordinates: Vector3 = Vector3.Zero();
 
-        constructor(name:string, public alpha:number, public beta:number, public radius:number, public target:AbstractMesh, scene:Scene) {
+        constructor(name: string, public alpha: number, public beta: number, public radius: number, public target: AbstractMesh, scene: Scene) {
             super(name, Vector3.Zero(), scene);
             this.follow();
         }
 
-        private follow():void {
+        private follow(): void {
             this._cartesianCoordinates.x = this.radius * Math.cos(this.alpha) * Math.cos(this.beta);
             this._cartesianCoordinates.y = this.radius * Math.sin(this.beta);
             this._cartesianCoordinates.z = this.radius * Math.sin(this.alpha) * Math.cos(this.beta);
@@ -79,10 +79,11 @@
             this.setTarget(this.target.position);
         }
 
-        public _checkInputs():void {
+        public _checkInputs(): void {
             super._checkInputs();
             this.follow();
         }
     }
 }
 
+

src/Collisions/babylon.collisionCoordinator.js

@@ -44,7 +44,7 @@ var BABYLON;
                 };
                 var message = {
                     payload: payload,
-                    taskType: 1 /* UPDATE */
+                    taskType: WorkerTaskType.UPDATE
                 };
                 var serializable = [];
                 for (var id in payload.updatedGeometries) {
@@ -63,13 +63,13 @@ var BABYLON;
             };
             this._onMessageFromWorker = function (e) {
                 var returnData = e.data;
-                if (returnData.error != 0 /* SUCCESS */) {
+                if (returnData.error != WorkerReplyType.SUCCESS) {
                     //TODO what errors can be returned from the worker?
                     BABYLON.Tools.Warn("error returned from worker!");
                     return;
                 }
                 switch (returnData.taskType) {
-                    case 0 /* INIT */:
+                    case WorkerTaskType.INIT:
                         _this._init = true;
                         //Update the worked with ALL of the scene's current state
                         _this._scene.meshes.forEach(function (mesh) {
@@ -79,10 +79,10 @@ var BABYLON;
                             _this.onGeometryAdded(geometry);
                         });
                         break;
-                    case 1 /* UPDATE */:
+                    case WorkerTaskType.UPDATE:
                         _this._runningUpdated--;
                         break;
-                    case 2 /* COLLIDE */:
+                    case WorkerTaskType.COLLIDE:
                         _this._runningCollisionTask = false;
                         var returnPayload = returnData.payload;
                         if (!_this._collisionsCallbackArray[returnPayload.collisionId])
@@ -122,7 +122,7 @@ var BABYLON;
             };
             var message = {
                 payload: payload,
-                taskType: 2 /* COLLIDE */
+                taskType: WorkerTaskType.COLLIDE
             };
             this._worker.postMessage(message);
         };
@@ -134,7 +134,7 @@ var BABYLON;
             this._worker.onmessage = this._onMessageFromWorker;
             var message = {
                 payload: {},
-                taskType: 0 /* INIT */
+                taskType: WorkerTaskType.INIT
             };
             this._worker.postMessage(message);
         };
@@ -232,18 +232,12 @@ var BABYLON;
             //Legacy need no destruction method.
         };
         //No update in legacy mode
-        CollisionCoordinatorLegacy.prototype.onMeshAdded = function (mesh) {
-        };
-        CollisionCoordinatorLegacy.prototype.onMeshUpdated = function (mesh) {
-        };
-        CollisionCoordinatorLegacy.prototype.onMeshRemoved = function (mesh) {
-        };
-        CollisionCoordinatorLegacy.prototype.onGeometryAdded = function (geometry) {
-        };
-        CollisionCoordinatorLegacy.prototype.onGeometryUpdated = function (geometry) {
-        };
-        CollisionCoordinatorLegacy.prototype.onGeometryDeleted = function (geometry) {
-        };
+        CollisionCoordinatorLegacy.prototype.onMeshAdded = function (mesh) { };
+        CollisionCoordinatorLegacy.prototype.onMeshUpdated = function (mesh) { };
+        CollisionCoordinatorLegacy.prototype.onMeshRemoved = function (mesh) { };
+        CollisionCoordinatorLegacy.prototype.onGeometryAdded = function (geometry) { };
+        CollisionCoordinatorLegacy.prototype.onGeometryUpdated = function (geometry) { };
+        CollisionCoordinatorLegacy.prototype.onGeometryDeleted = function (geometry) { };
         CollisionCoordinatorLegacy.prototype._collideWithWorld = function (position, velocity, collider, maximumRetry, finalPosition, excludedMesh) {
             if (excludedMesh === void 0) { excludedMesh = null; }
             var closeDistance = BABYLON.Engine.CollisionsEpsilon * 10.0;
@@ -252,6 +246,7 @@ var BABYLON;
                 return;
             }
             collider._initialize(position, velocity, closeDistance);
+            // Check all meshes
             for (var index = 0; index < this._scene.meshes.length; index++) {
                 var mesh = this._scene.meshes[index];
                 if (mesh.isEnabled() && mesh.checkCollisions && mesh.subMeshes && mesh !== excludedMesh) {

src/Collisions/babylon.collisionCoordinator.ts

@@ -414,3 +414,4 @@ module BABYLON {
         }
     }
 }
+

src/Loading/Plugins/babylon.babylonFileLoader.js

@@ -18,20 +18,23 @@ var BABYLON;
             return colors;
         };
         var loadCubeTexture = function (rootUrl, parsedTexture, scene) {
-            var texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene);
-            texture.name = parsedTexture.name;
-            texture.hasAlpha = parsedTexture.hasAlpha;
-            texture.level = parsedTexture.level;
-            texture.coordinatesMode = parsedTexture.coordinatesMode;
+            var texture = null;
+            if ((parsedTexture.name || parsedTexture.extensions) && !parsedTexture.isRenderTarget) {
+                texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene, parsedTexture.extensions);
+                texture.name = parsedTexture.name;
+                texture.hasAlpha = parsedTexture.hasAlpha;
+                texture.level = parsedTexture.level;
+                texture.coordinatesMode = parsedTexture.coordinatesMode;
+            }
             return texture;
         };
         var loadTexture = function (rootUrl, parsedTexture, scene) {
-            if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
-                return null;
-            }
             if (parsedTexture.isCube) {
                 return loadCubeTexture(rootUrl, parsedTexture, scene);
             }
+            if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
+                return null;
+            }
             var texture;
             if (parsedTexture.mirrorPlane) {
                 texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);

src/Loading/Plugins/babylon.babylonFileLoader.ts

@@ -1720,3 +1720,4 @@
         }
     });
 }
+

src/Mesh/babylon.mesh.js

@@ -1425,7 +1425,6 @@ var BABYLON;
                         rotated = BABYLON.Vector3.TransformCoordinates(normal, rotationMatrix).scaleInPlace(rad).add(path[i]);
                         circlePath.push(rotated);
                     }
-                    circlePath.push(circlePath[0]);
                     circlePaths[index] = circlePath;
                     index++;
                 }

src/Mesh/babylon.mesh.ts

@@ -1654,7 +1654,7 @@
                         rotationMatrix = Matrix.RotationAxis(tangents[i], step * t);
                         rotated = Vector3.TransformCoordinates(normal, rotationMatrix).scaleInPlace(rad).add(path[i]);
                         circlePath.push(rotated);
-                    }
+                    }                    
                     circlePaths[index] = circlePath;
                     index++;
                 }

src/Mesh/babylon.mesh.vertexData.js

@@ -312,7 +312,7 @@ var BABYLON;
             var vTotalDistance = []; //  vTotalDistance[i] : total distance between points i of first and last path from pathArray
             var minlg; // minimal length among all paths from pathArray
             var lg = []; // array of path lengths : nb of vertex per path
-            var idx = []; // array of path indexes : index of each path (first vertex) in positions array
+            var idx = []; // array of positions path indexes : index of each path (first vertex) in positions array
             var p; // path iterator
             var i; // point iterator
             var j; // point iterator
@@ -328,15 +328,16 @@ var BABYLON;
             }
             // positions and horizontal distances (u)
             var idc = 0;
-            minlg = pathArray[0].length;
+            minlg = (closePath) ? pathArray[0].length + 1 : pathArray[0].length;
             for (p = 0; p < pathArray.length; p++) {
                 uTotalDistance[p] = 0;
                 us[p] = [0];
                 var path = pathArray[p];
+                if (closePath) {
+                    path.push(path[0]);
+                }
                 var l = path.length;
                 minlg = (minlg < l) ? minlg : l;
-                lg[p] = l;
-                idx[p] = idc;
                 j = 0;
                 while (j < l) {
                     positions.push(path[j].x, path[j].y, path[j].z);
@@ -348,11 +349,8 @@ var BABYLON;
                     }
                     j++;
                 }
-                if (closePath) {
-                    vectlg = path[0].subtract(path[j - 1]).length();
-                    dist = vectlg + uTotalDistance[p];
-                    uTotalDistance[p] = dist;
-                }
+                lg[p] = l;
+                idx[p] = idc;
                 idc += l;
             }
             // vertical distances (v)
@@ -377,7 +375,7 @@ var BABYLON;
                     vTotalDistance[i] = dist;
                 }
             }
-            // uvs
+            // uvs            
             var u;
             var v;
             for (p = 0; p < pathArray.length; p++) {
@@ -395,26 +393,12 @@ var BABYLON;
             var min = (l1 < l2) ? l1 : l2; // current path stop index
             var shft = idx[1] - idx[0]; // shift 
             var path1nb = closeArray ? lg.length : lg.length - 1; // number of path1 to iterate	
-            var t1; // two consecutive triangles, so 4 points : point1
-            var t2; // point2
-            var t3; // point3
-            var t4; // point4
             while (pi <= min && p < path1nb) {
                 // draw two triangles between path1 (p1) and path2 (p2) : (p1.pi, p2.pi, p1.pi+1) and (p2.pi+1, p1.pi+1, p2.pi) clockwise
-                t1 = pi;
-                t2 = pi + shft;
-                t3 = pi + 1;
-                t4 = pi + shft + 1;
                 indices.push(pi, pi + shft, pi + 1);
                 indices.push(pi + shft + 1, pi + 1, pi + shft);
                 pi += 1;
                 if (pi === min) {
-                    if (closePath) {
-                        indices.push(pi, pi + shft, idx[p]);
-                        indices.push(idx[p] + shft, idx[p], pi + shft);
-                        t3 = idx[p];
-                        t4 = idx[p] + shft;
-                    }
                     p++;
                     if (p === lg.length - 1) {
                         shft = idx[0] - idx[p];
@@ -432,6 +416,25 @@ var BABYLON;
             }
             // normals
             VertexData.ComputeNormals(positions, indices, normals);
+            if (closePath) {
+                var indexFirst = 0;
+                var indexLast = 0;
+                for (p = 0; p < pathArray.length; p++) {
+                    indexFirst = idx[p] * 3;
+                    if (p + 1 < pathArray.length) {
+                        indexLast = (idx[p + 1] - 1) * 3;
+                    }
+                    else {
+                        indexLast = normals.length - 3;
+                    }
+                    normals[indexFirst] = (normals[indexFirst] + normals[indexLast]) * 0.5;
+                    normals[indexFirst + 1] = (normals[indexFirst + 1] + normals[indexLast + 1]) * 0.5;
+                    normals[indexFirst + 2] = (normals[indexFirst + 2] + normals[indexLast + 2]) * 0.5;
+                    normals[indexLast] = normals[indexFirst];
+                    normals[indexLast + 1] = normals[indexFirst + 1];
+                    normals[indexLast + 2] = normals[indexFirst + 2];
+                }
+            }
             // sides
             VertexData._ComputeSides(sideOrientation, positions, indices, normals, uvs);
             // Result

src/Mesh/babylon.mesh.vertexData.ts

@@ -438,7 +438,7 @@
                     }
                     j++;
                 }
-                 
+
                 lg[p] = l;
                 idx[p] = idc;
                 idc += l;
@@ -514,10 +514,10 @@
 
             // normals
             VertexData.ComputeNormals(positions, indices, normals);
-            
+
             if (closePath) {
                 var indexFirst: number = 0;
-                var indexLast: number = 0; 
+                var indexLast: number = 0;
                 for (p = 0; p < pathArray.length; p++) {
                     indexFirst = idx[p] * 3;
                     if (p + 1 < pathArray.length) {
@@ -1436,4 +1436,4 @@
             }
         }
     }
-} 
+} 

src/Shaders/legacydefault.fragment.fx

@@ -429,8 +429,10 @@ void main(void) {
 	shadow = 1.;
 #endif
 	diffuseBase += info[0] * shadow;
+#ifdef SPECULARTERM
 	specularBase += info[1] * shadow;
 #endif
+#endif
 
 #ifdef LIGHT1
 #ifndef SPECULARTERM
@@ -455,8 +457,10 @@ void main(void) {
 	shadow = 1.;
 #endif
 	diffuseBase += info[0] * shadow;
+#ifdef SPECULARTERM
 	specularBase += info[1] * shadow;
 #endif
+#endif
 
 #ifdef LIGHT2
 #ifndef SPECULARTERM
@@ -481,8 +485,10 @@ void main(void) {
 	shadow = 1.;
 #endif
 	diffuseBase += info[0] * shadow;
+#ifdef SPECULARTERM
 	specularBase += info[1] * shadow;
 #endif
+#endif
 
 #ifdef LIGHT3
 #ifndef SPECULARTERM

src/Tools/babylon.sceneSerializer.js

@@ -744,6 +744,7 @@ var BABYLON;
             var serializationObject = {};
             toSerialize = (toSerialize instanceof Array) ? toSerialize : [toSerialize];
             if (withParents) {
+                //deliberate for loop! not for each, appended should be processed as well.
                 for (var i = 0; i < toSerialize.length; ++i) {
                     if (toSerialize[i].parent) {
                         toSerialize.push(toSerialize[i].parent);
@@ -759,3 +760,4 @@ var BABYLON;
     })();
     BABYLON.SceneSerializer = SceneSerializer;
 })(BABYLON || (BABYLON = {}));
+//# sourceMappingURL=babylon.sceneSerializer.js.map

src/Tools/babylon.sceneSerializer.ts

@@ -741,7 +741,7 @@
         return serializationObject;
     };
 
-    var finalizeSingleMesh = function (mesh: Mesh, serializationObject : any) {
+    var finalizeSingleMesh = function (mesh: Mesh, serializationObject: any) {
         //only works if the mesh is already loaded
         if (mesh.delayLoadState === Engine.DELAYLOADSTATE_LOADED || mesh.delayLoadState === Engine.DELAYLOADSTATE_NONE) {
             //serialize material
@@ -903,7 +903,7 @@
             return serializationObject;
         }
 
-        public static SerializeMesh(toSerialize: any /* Mesh || Mesh[] */, withParents : boolean = false): any {
+        public static SerializeMesh(toSerialize: any /* Mesh || Mesh[] */, withParents: boolean = false): any {
             var serializationObject: any = {};
 
             toSerialize = (toSerialize instanceof Array) ? toSerialize : [toSerialize];
@@ -926,3 +926,4 @@
     }
 }
 
+