Merge remote-tracking branch 'upstream/master'

dist/preview release/what's new.md

@@ -69,7 +69,7 @@
 - Added `RawCubeTexture` class with RGBD and mipmap support ([bghgary](http://www.github.com/bghgary))
 - Added effect layer per rendering group addressing [Issue 4463](https://github.com/BabylonJS/Babylon.js/issues/4463) ([sebavan](http://www.github.com/sebavan))
 - Added predicate function `targetMask` argument to `scene.beginWeightedAnimation`, `scene.beginAnimation`, `scene.stopAnimation`, and `animatable.stop` to allow for selective application of animations.  ([fmmoret](http://github.com/fmmoret))
-- Oculus GO and GearVR 3dof controllers will now rotate with the user if they turn around in their room ([TrevorDev](https://github.com/TrevorDev))
+- Oculus GO and GearVR 3dof controllers will now rotate with the user's head if they turn around in their room ([TrevorDev](https://github.com/TrevorDev))
 - Added onPoseUpdatedFromDeviceObservable to webVRCamera to detect when the camera's pose has been updated ([TrevorDev](https://github.com/TrevorDev))
 
 ### glTF Loader

serializers/src/glTF/2.0/babylon.glTFExporter.ts

@@ -1168,6 +1168,18 @@ module BABYLON.GLTF2 {
             });
         }
 
+        private getRootNodes(babylonScene: Scene, nodes: TransformNode[], shouldExportTransformNode: (babylonTransformNode: TransformNode) => boolean): TransformNode[] {
+            const rootNodes: TransformNode[] = [];
+            for (let babylonTransformNode of nodes) {
+                if (shouldExportTransformNode(babylonTransformNode)) {
+                    if (babylonTransformNode.parent == null) {
+                        rootNodes.push(babylonTransformNode);
+                    }
+                }
+            }
+            return rootNodes;
+        }
+
         /**
          * Creates a mapping of Node unique id to node index and handles animations
          * @param babylonScene Babylon Scene
@@ -1187,9 +1199,24 @@ module BABYLON.GLTF2 {
             let idleGLTFAnimations: IAnimation[] = [];
             let node: INode;
 
+            let negScaleRootNode: Nullable<TransformNode> = null;
+
+            const rootNodes = this.getRootNodes(babylonScene, nodes, shouldExportTransformNode);
+            if (rootNodes.length === 1) {
+                const node = rootNodes[0];
+                if (node.scaling.equalsToFloats(1,1, -1)) {
+                    this._convertToRightHandedSystem = !this._convertToRightHandedSystem;
+                    negScaleRootNode = node;
+                }  
+            }
+
             for (let babylonTransformNode of nodes) {
                 if (shouldExportTransformNode(babylonTransformNode)) {
                     node = this.createNode(babylonTransformNode, binaryWriter);
+                    if (negScaleRootNode && babylonTransformNode === negScaleRootNode) {
+                        node.scale = [1,1,1];
+                        node.rotation = [0,0,0,1];
+                    }
 
                     this._nodes.push(node);
                     nodeIndex = this._nodes.length - 1;

src/Behaviors/Mesh/babylon.pointerDragBehavior.ts

@@ -7,6 +7,7 @@ module BABYLON {
         private _dragPlane: Mesh;
         private _scene:Scene;
         private _pointerObserver:Nullable<Observer<PointerInfo>>;
+        private _beforeRenderObserver:Nullable<Observer<Scene>>;
         private static _planeScene:Scene;
         /**
          * The maximum tolerated angle between the drag plane and dragging pointer rays to trigger pointer events. Set to 0 to allow any angle (default: 0)
@@ -119,6 +120,7 @@ module BABYLON {
                     PointerDragBehavior._planeScene = this._scene;
                 }else{
                     PointerDragBehavior._planeScene = new BABYLON.Scene(this._scene.getEngine());
+                    PointerDragBehavior._planeScene.detachControl();
                     this._scene.getEngine().scenes.pop();
                 }
             }
@@ -187,7 +189,7 @@ module BABYLON {
                 }
             });
 
-            this._scene.onBeforeRenderObservable.add(()=>{
+            this._beforeRenderObserver = this._scene.onBeforeRenderObservable.add(()=>{
                 if(this._moving && this.moveAttached){
                     // Slowly move mesh to avoid jitter
                     targetPosition.subtractToRef((<Mesh>this._attachedNode).absolutePosition, this._tmpVector);
@@ -294,6 +296,9 @@ module BABYLON {
             if(this._pointerObserver){
                 this._scene.onPointerObservable.remove(this._pointerObserver);
             }
+            if(this._beforeRenderObserver){
+                this._scene.onBeforeRenderObservable.remove(this._beforeRenderObserver);
+            }
         }
     }
 }

src/Cameras/VR/babylon.vrExperienceHelper.ts

@@ -167,7 +167,6 @@ module BABYLON {
 
         public _setLaserPointerParent(mesh:AbstractMesh){
             var makeNotPick = (root: AbstractMesh) => {
-                root.name += " laserPointer";
                 root.isPickable = false;
                 root.getChildMeshes().forEach((c) => {
                     makeNotPick(c);
@@ -931,8 +930,7 @@ module BABYLON {
                 this._raySelectionPredicate = (mesh) => {
                     if (this._isTeleportationFloor(mesh) || (mesh.name.indexOf("gazeTracker") === -1
                         && mesh.name.indexOf("teleportationTarget") === -1
-                        && mesh.name.indexOf("torusTeleportation") === -1
-                        && mesh.name.indexOf("laserPointer") === -1)) {
+                        && mesh.name.indexOf("torusTeleportation") === -1)) {
                         return this.raySelectionPredicate(mesh);
                     }
                     return false;