@galacean/engine-xr-webxr 0.0.0-experimental-stateMachine.0 → 0.0.0-experimental-1.3-xr.1

package/dist/browser.js

@@ -574,6 +574,7 @@
             this._engine = _engine;
             this._mode = XRSessionMode.None;
             this._state = XRSessionState.None;
+            this._listeners = [];
             // @ts-ignore
             this._rhi = _engine._hardwareRenderer;
             this._raf = requestAnimationFrame.bind(window);
@@ -596,7 +597,7 @@
                 throw new Error("Without session to run.");
             }
             platformSession.start();
-            this._state = XRSessionState.Running;
+            this.state = XRSessionState.Running;
             this._xrManager._onSessionStart();
             if (!engine.isPaused) {
                 engine.pause();
@@ -616,7 +617,7 @@
             rhi._mainFrameBuffer = null;
             rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
             platformSession.stop();
-            this._state = XRSessionState.Paused;
+            this.state = XRSessionState.Paused;
             this._xrManager._onSessionStop();
             if (!engine.isPaused) {
                 engine.pause();
@@ -624,6 +625,22 @@
             }
         };
         /**
+       * Add a listening function for session state changes.
+       * @param listener - The listening function
+       */ _proto.addChangedListener = function addChangedListener(listener) {
+            this._listeners.push(listener);
+        };
+        /**
+       * Remove a listening function of session state changes.
+       * @param listener - The listening function
+       */ _proto.removeChangedListener = function removeChangedListener(listener) {
+            var _this = this, listeners = _this._listeners;
+            var index = listeners.indexOf(listener);
+            if (index >= 0) {
+                listeners.splice(index, 1);
+            }
+        };
+        /**
        * @internal
        */ _proto._initialize = function _initialize(mode, features) {
             var _this = this;
@@ -638,7 +655,7 @@
                 xrManager._platformDevice.requestSession(_this._rhi, mode, platformFeatures).then(function(platformSession) {
                     _this._mode = mode;
                     _this._platformSession = platformSession;
-                    _this._state = XRSessionState.Initialized;
+                    _this.state = XRSessionState.Initialized;
                     platformSession.setSessionExitCallBack(_this._onSessionExit);
                     platformSession.addEventListener();
                     xrManager._onSessionInit();
@@ -687,7 +704,7 @@
             rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
             platformSession.removeEventListener();
             this._platformSession = null;
-            this._state = XRSessionState.None;
+            this.state = XRSessionState.None;
             this._xrManager._onSessionExit();
             if (!engine.isPaused) {
                 engine.pause();
@@ -712,6 +729,15 @@
        * Return the current session state.
        */ function get() {
                     return this._state;
+                },
+                set: /**
+       * @internal
+       */ function set(value) {
+                    this._state = value;
+                    var listeners = this._listeners;
+                    for(var i = 0, n = listeners.length; i < n; i++){
+                        listeners[i](value);
+                    }
                 }
             },
             {
@@ -760,21 +786,23 @@
             if (this.sessionManager._platformSession) {
                 throw new Error("Cannot add feature when the session is initialized.");
             }
-            var _this = this, features = _this._features;
+            if (!this._platformDevice.isSupportedFeature(XRManagerExtended._featureMap.get(type))) {
+                throw new Error("The feature is not supported");
+            }
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
-                var feature = features[i];
-                if (_instanceof1(feature, type)) throw new Error("The feature has been added");
+                if (_instanceof1(features[i], type)) throw new Error("The feature has been added");
             }
-            var feature1 = _construct$1(type, [].concat(this, args));
-            this._features.push(feature1);
-            return feature1;
+            var feature = _construct$1(type, [].concat(this, args));
+            features.push(feature);
+            return feature;
         };
         /**
        * Get feature which match the type.
        * @param type - The type of the feature
        * @returns	The feature which match type
        */ _proto.getFeature = function getFeature(type) {
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 if (_instanceof1(feature, type)) {
@@ -782,19 +810,6 @@
                 }
             }
         };
-        _proto.getFeatures = function getFeatures(type, out) {
-            if (out) {
-                out.length = 0;
-            } else {
-                out = [];
-            }
-            var _this = this, features = _this._features;
-            for(var i = 0, n = features.length; i < n; i--){
-                var feature = features[i];
-                _instanceof1(feature, type) && out.push(feature);
-            }
-            return out;
-        };
         /**
        * Enter XR immersive mode, when you call this method, it will initialize and display the XR virtual world.
        * @param sessionMode - The mode of the session
@@ -814,7 +829,7 @@
                 // 1. Check if this xr mode is supported
                 sessionManager.isSupportedMode(sessionMode).then(function() {
                     // 2. Initialize session
-                    sessionManager._initialize(sessionMode, _this._features).then(function() {
+                    sessionManager._initialize(sessionMode, _this.features).then(function() {
                         autoRun && sessionManager.run();
                         resolve();
                     }, reject);
@@ -835,7 +850,7 @@
         /**
        * @internal
        */ _proto._initialize = function _initialize(engine, xrDevice) {
-            this._features = [];
+            this.features.length = 0;
             this._platformDevice = xrDevice;
             this.sessionManager = new XRSessionManager(this, engine);
             this.inputManager = new XRInputManager(this, engine);
@@ -849,7 +864,7 @@
             sessionManager._onUpdate();
             this.inputManager._onUpdate();
             this.cameraManager._onUpdate();
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 feature.enabled && feature._onUpdate();
@@ -889,7 +904,7 @@
         /**
        * @internal
        */ _proto._onSessionStop = function _onSessionStop() {
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 feature.enabled && feature._onSessionStop();
@@ -898,7 +913,7 @@
         /**
        * @internal
        */ _proto._onSessionInit = function _onSessionInit() {
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 feature.enabled && feature._onSessionInit();
@@ -908,7 +923,7 @@
        * @internal
        */ _proto._onSessionStart = function _onSessionStart() {
             this.cameraManager._onSessionStart();
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 feature.enabled && feature._onSessionStart();
@@ -918,7 +933,7 @@
        * @internal
        */ _proto._onSessionExit = function _onSessionExit() {
             this.cameraManager._onSessionExit();
-            var _this = this, features = _this._features;
+            var features = this.features;
             for(var i = 0, n = features.length; i < n; i++){
                 var feature = features[i];
                 feature.enabled && feature._onSessionExit();
@@ -1057,6 +1072,101 @@
         else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
         return c > 3 && r && Object.defineProperty(target, key, r), r;
     }
+    function __generator(thisArg, body) {
+        var verb = function verb(n) {
+            return function(v) {
+                return step([
+                    n,
+                    v
+                ]);
+            };
+        };
+        var step = function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while(g && (g = 0, op[0] && (_ = 0)), _)try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [
+                    op[0] & 2,
+                    t.value
+                ];
+                switch(op[0]){
+                    case 0:
+                    case 1:
+                        t = op;
+                        break;
+                    case 4:
+                        _.label++;
+                        return {
+                            value: op[1],
+                            done: false
+                        };
+                    case 5:
+                        _.label++;
+                        y = op[1];
+                        op = [
+                            0
+                        ];
+                        continue;
+                    case 7:
+                        op = _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                            _ = 0;
+                            continue;
+                        }
+                        if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                            _.label = op[1];
+                            break;
+                        }
+                        if (op[0] === 6 && _.label < t[1]) {
+                            _.label = t[1];
+                            t = op;
+                            break;
+                        }
+                        if (t && _.label < t[2]) {
+                            _.label = t[2];
+                            _.ops.push(op);
+                            break;
+                        }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop();
+                        continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) {
+                op = [
+                    6,
+                    e
+                ];
+                y = 0;
+            } finally{
+                f = t = 0;
+            }
+            if (op[0] & 5) throw op[1];
+            return {
+                value: op[0] ? op[1] : void 0,
+                done: true
+            };
+        };
+        var _ = {
+            label: 0,
+            sent: function sent() {
+                if (t[0] & 1) throw t[1];
+                return t[1];
+            },
+            trys: [],
+            ops: []
+        }, f, y, t, g;
+        return g = {
+            next: verb(0),
+            "throw": verb(1),
+            "return": verb(2)
+        }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+            return this;
+        }), g;
+    }
     typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
         var e = new Error(message);
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -1411,7 +1521,7 @@
     ], XRHitTest);
     /**
      * The anchor in XR space.
-     */ var XRAnchor = /*#__PURE__*/ function(XRTracked1) {
+     */ var XRAnchor$1 = /*#__PURE__*/ function(XRTracked1) {
         var XRAnchor = function XRAnchor() {
             return XRTracked1.apply(this, arguments);
         };
@@ -1481,7 +1591,7 @@
             this._removeAllRequestTrackings();
         };
         _proto._generateTracked = function _generateTracked() {
-            var anchor = new XRAnchor();
+            var anchor = new XRAnchor$1();
             anchor.id = XRTrackableFeature._uuid++;
             return anchor;
         };
@@ -1574,6 +1684,256 @@
     XRImageTracking = __decorate([
         registerXRFeature(XRFeatureType.ImageTracking)
     ], XRImageTracking);
+    /**
+     *  A reference image is an image to look for in the physical environment.
+     */ var XRReferenceImage = function XRReferenceImage(name, imageSource, physicalWidth) {
+        this.name = name;
+        this.imageSource = imageSource;
+        this.physicalWidth = physicalWidth;
+    };
+    var XRReferenceImageDecoder = /*#__PURE__*/ function() {
+        var XRReferenceImageDecoder = function XRReferenceImageDecoder() {};
+        XRReferenceImageDecoder.decode = function decode(engine, bufferReader) {
+            return new Promise(function(resolve, reject) {
+                var physicalWidth = bufferReader.nextFloat32();
+                bufferReader.nextUint8();
+                var img = new Image();
+                img.onload = function() {
+                    resolve(new XRReferenceImage("", img, physicalWidth));
+                };
+                img.src = URL.createObjectURL(new window.Blob([
+                    bufferReader.nextImagesData(1)[0]
+                ]));
+            });
+        };
+        return XRReferenceImageDecoder;
+    }();
+    XRReferenceImageDecoder = __decorate([
+        engine.decoder("XRReferenceImage")
+    ], XRReferenceImageDecoder);
+    function _extends() {
+        _extends = Object.assign || function assign(target) {
+            for(var i = 1; i < arguments.length; i++){
+                var source = arguments[i];
+                for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+            }
+            return target;
+        };
+        return _extends.apply(this, arguments);
+    }
+    var XRReferenceImageLoader = /*#__PURE__*/ function(Loader1) {
+        var XRReferenceImageLoader = function XRReferenceImageLoader() {
+            return Loader1.apply(this, arguments);
+        };
+        _inherits(XRReferenceImageLoader, Loader1);
+        var _proto = XRReferenceImageLoader.prototype;
+        _proto.load = function load(item, resourceManager) {
+            var _this = this;
+            return new engine.AssetPromise(function(resolve, reject) {
+                _this.request(item.url, _extends({}, item, {
+                    type: "arraybuffer"
+                })).then(function(data) {
+                    engine.decode(data, resourceManager.engine).then(function(referenceImage) {
+                        resolve(referenceImage);
+                    });
+                }).catch(reject);
+            });
+        };
+        return XRReferenceImageLoader;
+    }(engine.Loader);
+    XRReferenceImageLoader = __decorate([
+        engine.resourceLoader("XRReferenceImage", [])
+    ], XRReferenceImageLoader);
+    function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+        try {
+            var info = gen[key](arg);
+            var value = info.value;
+        } catch (error) {
+            reject(error);
+            return;
+        }
+        if (info.done) resolve(value);
+        else Promise.resolve(value).then(_next, _throw);
+    }
+    function _async_to_generator(fn) {
+        return function() {
+            var self = this, args = arguments;
+            return new Promise(function(resolve, reject) {
+                var gen = fn.apply(self, args);
+                function _next(value) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+                }
+                function _throw(err) {
+                    asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+                }
+                _next(undefined);
+            });
+        };
+    }
+    var XRSceneExtendParser = /*#__PURE__*/ function() {
+        var XRSceneExtendParser = function XRSceneExtendParser() {};
+        XRSceneExtendParser.parse = function parse(engine$1, context, data) {
+            return _async_to_generator(function() {
+                var xrManager, xr, origin, camera, leftCamera, rightCamera, features, entityMap, cameraManager, i, n, feature, _;
+                return __generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            xrManager = engine$1.xrManager;
+                            if (!xrManager) {
+                                engine.Logger.error("XRManager is not found in the engine.");
+                                return [
+                                    2
+                                ];
+                            }
+                            xr = data.scene.xr;
+                            origin = xr.origin, camera = xr.camera, leftCamera = xr.leftCamera, rightCamera = xr.rightCamera, features = xr.features;
+                            entityMap = context.entityMap;
+                            origin && (xrManager.origin = entityMap.get(origin));
+                            cameraManager = xrManager.cameraManager;
+                            setCamera(cameraManager, XRTrackedInputDevice.Camera, entityMap.get(camera));
+                            setCamera(cameraManager, XRTrackedInputDevice.LeftCamera, entityMap.get(leftCamera));
+                            setCamera(cameraManager, XRTrackedInputDevice.RightCamera, entityMap.get(rightCamera));
+                            i = 0, n = features.length;
+                            _state.label = 1;
+                        case 1:
+                            if (!(i < n)) return [
+                                3,
+                                9
+                            ];
+                            feature = features[i];
+                            if (!feature.enable) return [
+                                3,
+                                8
+                            ];
+                            _ = feature.type;
+                            switch(_){
+                                case XRFeatureType.ImageTracking:
+                                    return [
+                                        3,
+                                        2
+                                    ];
+                                case XRFeatureType.PlaneTracking:
+                                    return [
+                                        3,
+                                        4
+                                    ];
+                                case XRFeatureType.AnchorTracking:
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                case XRFeatureType.HitTest:
+                                    return [
+                                        3,
+                                        6
+                                    ];
+                            }
+                            return [
+                                3,
+                                7
+                            ];
+                        case 2:
+                            return [
+                                4,
+                                addImageTracking(engine$1, xrManager, feature)
+                            ];
+                        case 3:
+                            _state.sent();
+                            return [
+                                3,
+                                8
+                            ];
+                        case 4:
+                            addPlaneTracking(xrManager, feature);
+                            return [
+                                3,
+                                8
+                            ];
+                        case 5:
+                            addAnchorTracking(xrManager, feature);
+                            return [
+                                3,
+                                8
+                            ];
+                        case 6:
+                            addHitTest(xrManager);
+                            return [
+                                3,
+                                8
+                            ];
+                        case 7:
+                            return [
+                                3,
+                                8
+                            ];
+                        case 8:
+                            i++;
+                            return [
+                                3,
+                                1
+                            ];
+                        case 9:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        };
+        return XRSceneExtendParser;
+    }();
+    XRSceneExtendParser = __decorate([
+        engine.registerSceneExtendParser("XR")
+    ], XRSceneExtendParser);
+    function addImageTracking(engine$1, xrManager, schema) {
+        if (!xrManager.isSupportedFeature(XRImageTracking)) {
+            engine.Logger.error("Image Tracking is not supported.");
+            return;
+        }
+        var promises = [];
+        var images = schema.images;
+        var resourceManager = engine$1.resourceManager;
+        for(var i = 0, n = images.length; i < n; i++){
+            // @ts-ignore
+            promises.push(resourceManager.getResourceByRef(images[i]));
+        }
+        return Promise.all(promises).then(function(xrReferenceImages) {
+            xrManager.addFeature(XRImageTracking, xrReferenceImages);
+        });
+    }
+    function addPlaneTracking(xrManager, schema) {
+        if (!xrManager.isSupportedFeature(XRPlaneTracking)) {
+            engine.Logger.error("Plane Tracking is not supported.");
+            return;
+        }
+        xrManager.addFeature(XRPlaneTracking, schema.detectionMode);
+    }
+    function addAnchorTracking(xrManager, schema) {
+        if (!xrManager.isSupportedFeature(XRAnchorTracking)) {
+            engine.Logger.error("Anchor Tracking is not supported.");
+            return;
+        }
+        var anchorTracking = xrManager.addFeature(XRAnchorTracking);
+        var anchors = schema.anchors;
+        for(var i = 0, n = anchors.length; i < n; i++){
+            var anchor = anchors[i];
+            var position = new engine.Vector3().copyFrom(anchor.position);
+            var rotation = new engine.Quaternion().copyFrom(anchor.rotation);
+            anchorTracking.addAnchor(position, rotation);
+        }
+    }
+    function addHitTest(xrManager, schema) {
+        if (!xrManager.isSupportedFeature(XRHitTest)) {
+            engine.Logger.error("Hit Test is not supported.");
+            return;
+        }
+        xrManager.addFeature(XRHitTest);
+    }
+    function setCamera(cameraManager, device, entity) {
+        var _entity;
+        var camera = (_entity = entity) == null ? void 0 : _entity.getComponent(engine.Camera);
+        camera && cameraManager.attachCamera(device, camera);
+    }
 
     function _is_native_reflect_construct() {
         if (typeof Reflect === "undefined" || !Reflect.construct) return false;
@@ -1739,6 +2099,15 @@
        */ MathUtil.degreeToRadian = function degreeToRadian(d) {
             return d * MathUtil.degreeToRadFactor;
         };
+        /**
+       * Linearly interpolate between two values
+       * @param start - Specify the start of the range in which to interpolate
+       * @param end - Specify the end of the range in which to interpolate
+       * @param t - The blend amount where 0 returns start and 1 end
+       * @returns The result of linear blending between start and end
+       */ MathUtil.lerp = function lerp(start, end, t) {
+            return start + (end - start) * t;
+        };
         return MathUtil;
     }();
     (function() {
@@ -5973,7 +6342,7 @@
             session.removeEventListener("squeeze", onSessionEvent);
             session.removeEventListener("squeezestart", onSessionEvent);
             session.removeEventListener("squeezeend", onSessionEvent);
-            session.addEventListener("end", this._onSessionExit);
+            session.removeEventListener("end", this._onSessionExit);
             this._events.length = 0;
         };
         _proto.resetEvents = function resetEvents() {
@@ -6116,7 +6485,16 @@
             });
         };
         _proto.isSupportedFeature = function isSupportedFeature(type) {
-            return true;
+            switch(type){
+                case XRFeatureType.HitTest:
+                case XRFeatureType.PlaneTracking:
+                    return typeof XRPlane !== "undefined";
+                case XRFeatureType.AnchorTracking:
+                    return typeof XRAnchor !== "undefined";
+                case XRFeatureType.ImageTracking:
+                    // @ts-ignore
+                    return typeof XRImageTrackingResult !== "undefined";
+            }
         };
         _proto.createPlatformFeature = function createPlatformFeature(type) {
             for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){