Merge remote-tracking branch 'refs/remotes/BabylonJS/master' into Particle2

# Conflicts:
#	dist/preview release/babylon.d.ts
#	dist/preview release/babylon.js
#	dist/preview release/babylon.worker.js

Tools/Gulp/package.json

@@ -44,16 +44,14 @@
         "ts-loader": "^2.3.7",
         "typescript": "^2.6.2",
         "webpack-stream": "^4.0.0",
-
         "karma": "^2.0.0",
         "karma-chrome-launcher": "^2.2.0",
         "karma-sauce-launcher": "^1.2.0",
-
         "mocha": "^4.0.1",
         "chai": "^4.1.2",
         "sinon": "^4.1.3",
         "karma-mocha": "^1.3.0",
-        "karma-chai":"^0.1.0",
+        "karma-chai": "^0.1.0",
         "karma-sinon": "^1.0.5"
     },
     "scripts": {

dist/preview release/babylon.max.js

@@ -13585,7 +13585,7 @@ var BABYLON;
          */
         TransformNode.prototype._getWorldMatrixDeterminant = function () {
             if (this._currentRenderId !== this.getScene().getRenderId()) {
-                this._worldMatrixDeterminant = this.computeWorldMatrix().determinant();
+                this.computeWorldMatrix();
             }
             return this._worldMatrixDeterminant;
         };
@@ -14233,6 +14233,8 @@ var BABYLON;
             if (!this._poseMatrix) {
                 this._poseMatrix = BABYLON.Matrix.Invert(this._worldMatrix);
             }
+            // Cache the determinant
+            this._worldMatrixDeterminant = this._worldMatrix.determinant();
             return this._worldMatrix;
         };
         TransformNode.prototype._afterComputeWorldMatrix = function () {

dist/preview release/customConfigurations/minimalGLTFViewer/babylon.max.js

@@ -13585,7 +13585,7 @@ var BABYLON;
          */
         TransformNode.prototype._getWorldMatrixDeterminant = function () {
             if (this._currentRenderId !== this.getScene().getRenderId()) {
-                this._worldMatrixDeterminant = this.computeWorldMatrix().determinant();
+                this.computeWorldMatrix();
             }
             return this._worldMatrixDeterminant;
         };
@@ -14233,6 +14233,8 @@ var BABYLON;
             if (!this._poseMatrix) {
                 this._poseMatrix = BABYLON.Matrix.Invert(this._worldMatrix);
             }
+            // Cache the determinant
+            this._worldMatrixDeterminant = this._worldMatrix.determinant();
             return this._worldMatrix;
         };
         TransformNode.prototype._afterComputeWorldMatrix = function () {

src/Mesh/babylon.transformNode.ts

@@ -119,7 +119,7 @@ module BABYLON {
          */
         protected _getWorldMatrixDeterminant(): number {
             if (this._currentRenderId !== this.getScene().getRenderId()) {
-                this._worldMatrixDeterminant = this.computeWorldMatrix().determinant();
+                this.computeWorldMatrix();
             }
             return this._worldMatrixDeterminant;
         }
@@ -835,6 +835,9 @@ module BABYLON {
                 this._poseMatrix = Matrix.Invert(this._worldMatrix);
             }
 
+            // Cache the determinant
+            this._worldMatrixDeterminant = this._worldMatrix.determinant();
+
             return this._worldMatrix;
         }
 

src/Particles/babylon.boxParticleEmitter.ts

@@ -1,22 +1,52 @@
 module BABYLON {
     export class BoxParticleEmitter implements IParticleEmitterType {
+
+        public get direction1(): Vector3 {
+            return this._particleSystem.direction1;
+        }
+        public set direction1(value: Vector3) {
+            this._particleSystem.direction1 = value;
+        }
+
+        public get direction2(): Vector3 {
+            return this._particleSystem.direction2;
+        }
+        public set direction2(value: Vector3) {
+            this._particleSystem.direction2 = value;
+        }
+
+        public get minEmitBox(): Vector3 {
+            return this._particleSystem.minEmitBox;
+        }
+        public set minEmitBox(value: Vector3) {
+            this._particleSystem.minEmitBox = value;
+        }
+
+        public get maxEmitBox(): Vector3 {
+            return this._particleSystem.maxEmitBox;
+        }
+        public set maxEmitBox(value: Vector3) {
+            this._particleSystem.maxEmitBox = value;
+        }
+        
         // to be updated like the rest of emitters when breaking changes.
-        constructor(private particleSystem: ParticleSystem) {
+        // all property should be come public variables and passed through constructor.
+        constructor(private _particleSystem: ParticleSystem) {
 
         }
 
         startDirectionFunction(emitPower: number, worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle): void {
-            var randX = ParticleSystem.randomNumber(this.particleSystem.direction1.x, this.particleSystem.direction2.x);
-            var randY = ParticleSystem.randomNumber(this.particleSystem.direction1.y, this.particleSystem.direction2.y);
-            var randZ = ParticleSystem.randomNumber(this.particleSystem.direction1.z, this.particleSystem.direction2.z);
+            var randX = ParticleSystem.randomNumber(this.direction1.x, this.direction2.x);
+            var randY = ParticleSystem.randomNumber(this.direction1.y, this.direction2.y);
+            var randZ = ParticleSystem.randomNumber(this.direction1.z, this.direction2.z);
 
             Vector3.TransformNormalFromFloatsToRef(randX * emitPower, randY * emitPower, randZ * emitPower, worldMatrix, directionToUpdate);
         }
 
         startPositionFunction(worldMatrix: Matrix, positionToUpdate: Vector3, particle: Particle): void {
-            var randX = ParticleSystem.randomNumber(this.particleSystem.minEmitBox.x, this.particleSystem.maxEmitBox.x);
-            var randY = ParticleSystem.randomNumber(this.particleSystem.minEmitBox.y, this.particleSystem.maxEmitBox.y);
-            var randZ = ParticleSystem.randomNumber(this.particleSystem.minEmitBox.z, this.particleSystem.maxEmitBox.z);
+            var randX = ParticleSystem.randomNumber(this.minEmitBox.x, this.maxEmitBox.x);
+            var randY = ParticleSystem.randomNumber(this.minEmitBox.y, this.maxEmitBox.y);
+            var randZ = ParticleSystem.randomNumber(this.minEmitBox.z, this.maxEmitBox.z);
 
             Vector3.TransformCoordinatesFromFloatsToRef(randX, randY, randZ, worldMatrix, positionToUpdate);
         }

src/Particles/babylon.coneParticleEmitter.ts

@@ -1,6 +1,6 @@
 module BABYLON {
     export class ConeParticleEmitter implements IParticleEmitterType {
-        constructor(private radius: number, private angle: number) {
+        constructor(public radius: number, public angle: number) {
         }
 
         startDirectionFunction(emitPower: number, worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle): void {

src/Particles/babylon.particleSystem.ts

@@ -2,7 +2,7 @@
     export interface IParticleSystem {
         id: string;
         name: string;
-        emitter: Nullable<AbstractMesh | Vector3>; 
+        emitter: Nullable<AbstractMesh | Vector3>;
         renderingGroupId: number;
         layerMask: number;
         isStarted(): boolean;
@@ -83,7 +83,9 @@
         public color2 = new Color4(1.0, 1.0, 1.0, 1.0);
         public colorDead = new Color4(0, 0, 0, 1.0);
         public textureMask = new Color4(1.0, 1.0, 1.0, 1.0);
-        private _particleEmitterType: IParticleEmitterType;
+        public particleEmitterType: IParticleEmitterType;
+        public startDirectionFunction: (emitPower: number, worldMatrix: Matrix, directionToUpdate: Vector3, particle: Particle) => void;
+        public startPositionFunction: (worldMatrix: Matrix, positionToUpdate: Vector3, particle: Particle) => void;
 
         private particles = new Array<Particle>();
 
@@ -161,7 +163,7 @@
             this._vertexBuffers["options"] = options;
 
             // Default behaviors
-            this._particleEmitterType = new BoxParticleEmitter(this);
+            this.particleEmitterType = new BoxParticleEmitter(this);
 
             this.updateFunction = (particles: Particle[]): void => {
                 for (var index = 0; index < particles.length; index++) {
@@ -322,9 +324,19 @@
 
                 var emitPower = ParticleSystem.randomNumber(this.minEmitPower, this.maxEmitPower);
 
-                this._particleEmitterType.startPositionFunction(worldMatrix, particle.position, particle);
+                if (this.startDirectionFunction) {
+                    this.startDirectionFunction(emitPower, worldMatrix, particle.direction, particle);
+                }
+                else {
+                    this.particleEmitterType.startDirectionFunction(emitPower, worldMatrix, particle.direction, particle);
+                }
 
-                this._particleEmitterType.startDirectionFunction(emitPower, worldMatrix, particle.direction, particle);
+                if (this.startPositionFunction) {
+                    this.startPositionFunction(worldMatrix, particle.position, particle);
+                }
+                else {
+                    this.particleEmitterType.startPositionFunction(worldMatrix, particle.position, particle);
+                }
 
                 particle.lifeTime = ParticleSystem.randomNumber(this.minLifeTime, this.maxLifeTime);
 
@@ -569,24 +581,32 @@
         }
 
         public createSphereEmitter(radius = 1) {
-            this._particleEmitterType = new SphereParticleEmitter(radius);
+            var particleEmitter = new SphereParticleEmitter(radius);
+            this.particleEmitterType = particleEmitter;
+            return particleEmitter;
         }
 
         public createDirectedSphereEmitter(radius = 1, direction1 = new Vector3(0, 1.0, 0), direction2 = new Vector3(0, 1.0, 0)) {
-            this._particleEmitterType = new SphereDirectedParticleEmitter(radius, direction1, direction2);
+            var particleEmitter = new SphereDirectedParticleEmitter(radius, direction1, direction2)
+            this.particleEmitterType = particleEmitter;
+            return particleEmitter;
         }
 
         public createConeEmitter(radius = 1, angle = Math.PI / 4) {
-            this._particleEmitterType = new ConeParticleEmitter(radius, angle);
+            var particleEmitter = new ConeParticleEmitter(radius, angle);
+            this.particleEmitterType = particleEmitter;
+            return particleEmitter;
         }
 
         // this method need to be changed when breaking changes to match the sphere and cone methods and properties direction1,2 and minEmitBox,maxEmitBox to be removed from the system.
         public createBoxEmitter(direction1: Vector3, direction2: Vector3, minEmitBox: Vector3, maxEmitBox: Vector3) {
+            var particleEmitter = new BoxParticleEmitter(this);
             this.direction1 = direction1;
             this.direction2 = direction2;
             this.minEmitBox = minEmitBox;
             this.maxEmitBox = maxEmitBox;
-            this._particleEmitterType = new BoxParticleEmitter(this);
+            this.particleEmitterType = particleEmitter;
+            return particleEmitter;
         }
 
         public static randomNumber = (min: number, max: number): number => {

src/Particles/babylon.sphereParticleEmitter.ts

@@ -1,6 +1,6 @@
 module BABYLON {
     export class SphereParticleEmitter implements IParticleEmitterType {
-        constructor(private radius: number) {
+        constructor(public radius: number) {
 
         }
 
@@ -21,7 +21,7 @@ module BABYLON {
     }
 
     export class SphereDirectedParticleEmitter extends SphereParticleEmitter {
-        constructor(radius: number, private direction1: Vector3, private direction2: Vector3) {
+        constructor(radius: number, public direction1: Vector3, public direction2: Vector3) {
             super(radius);
         }
 

tests/validation/config.json

@@ -176,8 +176,7 @@
     },
     {
       "title": "Normals",
-      "scriptToRun": "/Demos/Normals/index.js",
-      "functionToCall": "createScene",
+      "playgroundId": "#WXKLLJ#2",
       "referenceImage": "normals.png"
     },
     {