fixed bone.setYawPitchRoll

src/Bones/babylon.bone.ts

@@ -169,7 +169,7 @@
         public scale (x: number, y: number, z: number, scaleChildren = false) {
 	
             var locMat = this.getLocalMatrix();
-            
+    
             var origLocMat = BABYLON.Tmp.Matrix[0];
             origLocMat.copyFrom(locMat);
             
@@ -178,17 +178,14 @@
             origLocMatInv.invert();
             
             var scaleMat = BABYLON.Tmp.Matrix[2];
-            BABYLON.Matrix.FromValuesToRef(x, 0, 0, 0,
-                                            0, y, 0, 0,
-                                            0, 0, z, 0,
-                                            0, 0, 0, 1, scaleMat);
-                                                
-            this._scaleMatrix.multiplyToRef(scaleMat, this._scaleMatrix);
             
+            BABYLON.Matrix.FromValuesToRef(x, 0, 0, 0, 0, y, 0, 0, 0, 0, z, 0, 0, 0, 0, 1, scaleMat);
+            
+            this._scaleMatrix.multiplyToRef(scaleMat, this._scaleMatrix);
             this._scaleVector.x *= x;
             this._scaleVector.y *= y;
             this._scaleVector.z *= z;
-                    
+            
             locMat.multiplyToRef(origLocMatInv, locMat);
             locMat.multiplyToRef(scaleMat, locMat);
             locMat.multiplyToRef(origLocMat, locMat);
@@ -203,28 +200,28 @@
             
             var len = this.children.length;
             
-            for (var i = 0; i < len; i++){
-                
+            for (var i = 0; i < len; i++) {
                 var parentAbsMat = this.children[i]._parent.getAbsoluteTransform();
-                
                 this.children[i].getLocalMatrix().multiplyToRef(parentAbsMat, this.children[i].getAbsoluteTransform());
-            
             }
             
-            if (this.children[0] && !scaleChildren) {
-
-                scaleMat.invert();
-
-                var cm = this.children[0].getLocalMatrix();
-
+            scaleMat.invert();
+            
+            if (this.children[0]) {
+                var child = this.children[0];
+                var cm = child.getLocalMatrix();
                 cm.multiplyToRef(scaleMat, cm);
-                
-                var lm = this.children[0].getLocalMatrix();
-                    
+                var lm = child.getLocalMatrix();
                 lm.m[12] *= this._scaleVector.x;
                 lm.m[13] *= this._scaleVector.y;
                 lm.m[14] *= this._scaleVector.z;
-
+            }
+            
+            if (scaleChildren) {
+                for (var i = 0; i < len; i++) {
+                    this.children[i].scale(x, y, z, scaleChildren);
+                    
+                }
             }
             
             this.markAsDirty();
@@ -233,20 +230,39 @@
 
         public setYawPitchRoll (yaw: number, pitch: number, roll: number, space = BABYLON.Space.LOCAL, mesh: BABYLON.AbstractMesh = null): void {
 	
-            var rmat = BABYLON.Tmp.Matrix[0];
-
-            BABYLON.Matrix.RotationYawPitchRollToRef(yaw, pitch, roll, rmat);
+            var rotMat = BABYLON.Tmp.Matrix[0];
+            BABYLON.Matrix.RotationYawPitchRollToRef(yaw, pitch, roll, rotMat);
             
             var rotMatInv = BABYLON.Tmp.Matrix[1];
-
-            rotMatInv.copyFrom(this._rotationMatrix);
-            rotMatInv.invert();
             
-            rotMatInv.multiplyToRef(rmat, rmat);
+            if (space == BABYLON.Space.WORLD) {
+                
+                rotMatInv.copyFrom(this.getAbsoluteTransform());
+                
+                if (mesh) {
+                    rotMatInv.multiplyToRef(mesh.getWorldMatrix(), rotMatInv);
+                }
+                
+                rotMatInv.invert();
+                
+                var scaleMatrix = BABYLON.Tmp.Matrix[2];
+                scaleMatrix.copyFrom(this._scaleMatrix);
+                scaleMatrix.m[0] *= -1;
+                
+                rotMatInv.multiplyToRef(scaleMatrix, rotMatInv);
+                rotMatInv.multiplyToRef(rotMat, rotMat);
 
-            this._rotateWithMatrix(rmat, space, mesh);
+            } else {
+
+                rotMatInv.copyFrom(this._rotationMatrix);
+                rotMatInv.invert();
+                rotMatInv.multiplyToRef(rotMat, rotMat);
+
+            }
+            
+            this._rotateWithMatrix(rotMat, space, mesh);
             
-        };
+        }
 
         public rotate (axis: BABYLON.Vector3, amount: number, space = BABYLON.Space.LOCAL, mesh: BABYLON.AbstractMesh = null): void {
             
@@ -264,77 +280,61 @@
         private _rotateWithMatrix (rmat:BABYLON.Matrix, space = BABYLON.Space.LOCAL, mesh: BABYLON.AbstractMesh = null): void {
 
             var lmat = this.getLocalMatrix();
-            
             var lx = lmat.m[12];
             var ly = lmat.m[13];
             var lz = lmat.m[14];
-            
-            var parent = this.getParent();
 
+            var parent = this.getParent();
             var parentScale = BABYLON.Tmp.Matrix[3];
             var parentScaleInv = BABYLON.Tmp.Matrix[4];
 
             this._rotationMatrix.multiplyToRef(rmat, this._rotationMatrix);
-            
+
             if (parent) {
-                
                 if (space == BABYLON.Space.WORLD) {
-                    
                     if (mesh) {
                         parentScale.copyFrom(mesh.getWorldMatrix());
                         parent.getAbsoluteTransform().multiplyToRef(parentScale, parentScale);
                     } else {
                         parentScale.copyFrom(parent.getAbsoluteTransform());
                     }
-                    
                 } else {
-                    
                     parentScale = parent._scaleMatrix;
-                    
                 }
 
                 parentScaleInv.copyFrom(parentScale);
                 parentScaleInv.invert();
-                
                 lmat.multiplyToRef(parentScale, lmat);
                 lmat.multiplyToRef(rmat, lmat);
                 lmat.multiplyToRef(parentScaleInv, lmat);
-                
+
             } else {
-                
                 if (space == BABYLON.Space.WORLD && mesh) {
-
                     parentScale.copyFrom(mesh.getWorldMatrix());
-
                     parentScaleInv.copyFrom(parentScale);
                     parentScaleInv.invert();
-                    
                     lmat.multiplyToRef(parentScale, lmat);
                     lmat.multiplyToRef(rmat, lmat);
                     lmat.multiplyToRef(parentScaleInv, lmat);
-                    
                 } else {
-                    
                     lmat.multiplyToRef(rmat, lmat);
-
                 }
-
             }
-            
+
             lmat.m[12] = lx;
             lmat.m[13] = ly;
             lmat.m[14] = lz;
-            
+
             if (parent) {
                 var parentAbsMat = this._parent.getAbsoluteTransform();
                 lmat.multiplyToRef(parentAbsMat, this.getAbsoluteTransform());
             } else {
                 this.getAbsoluteTransform().copyFrom(lmat);
             }
-            
+
             var len = this.children.length;
-            
-            for (var i = 0; i < len; i++){
+
+            for (var i = 0; i < len; i++) {
                 var parentAbsMat = this.children[i]._parent.getAbsoluteTransform();
                 this.children[i].getLocalMatrix().multiplyToRef(parentAbsMat, this.children[i].getAbsoluteTransform());
             }