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

package/dist/browser.js

@@ -526,6 +526,7 @@
             this._engine = _engine;
             this._mode = exports.XRSessionMode.None;
             this._state = exports.XRSessionState.None;
+            this._listeners = [];
             // @ts-ignore
             this._rhi = _engine._hardwareRenderer;
             this._raf = requestAnimationFrame.bind(window);
@@ -548,7 +549,7 @@
                 throw new Error("Without session to run.");
             }
             platformSession.start();
-            this._state = exports.XRSessionState.Running;
+            this.state = exports.XRSessionState.Running;
             this._xrManager._onSessionStart();
             if (!engine.isPaused) {
                 engine.pause();
@@ -568,7 +569,7 @@
             rhi._mainFrameBuffer = null;
             rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
             platformSession.stop();
-            this._state = exports.XRSessionState.Paused;
+            this.state = exports.XRSessionState.Paused;
             this._xrManager._onSessionStop();
             if (!engine.isPaused) {
                 engine.pause();
@@ -576,6 +577,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;
@@ -590,7 +607,7 @@
                 xrManager._platformDevice.requestSession(_this._rhi, mode, platformFeatures).then(function(platformSession) {
                     _this._mode = mode;
                     _this._platformSession = platformSession;
-                    _this._state = exports.XRSessionState.Initialized;
+                    _this.state = exports.XRSessionState.Initialized;
                     platformSession.setSessionExitCallBack(_this._onSessionExit);
                     platformSession.addEventListener();
                     xrManager._onSessionInit();
@@ -639,7 +656,7 @@
             rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
             platformSession.removeEventListener();
             this._platformSession = null;
-            this._state = exports.XRSessionState.None;
+            this.state = exports.XRSessionState.None;
             this._xrManager._onSessionExit();
             if (!engine.isPaused) {
                 engine.pause();
@@ -664,6 +681,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);
+                    }
                 }
             },
             {
@@ -713,21 +739,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 (_instanceof(feature, type)) throw new Error("The feature has been added");
+                if (_instanceof(features[i], type)) throw new Error("The feature has been added");
             }
-            var feature1 = _construct(type, [].concat(this, args));
-            this._features.push(feature1);
-            return feature1;
+            var feature = _construct(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 (_instanceof(feature, type)) {
@@ -735,19 +763,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];
-                _instanceof(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
@@ -767,7 +782,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);
@@ -788,7 +803,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);
@@ -802,7 +817,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();
@@ -842,7 +857,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();
@@ -851,7 +866,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();
@@ -861,7 +876,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();
@@ -871,7 +886,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();
@@ -1017,6 +1032,34 @@
       return c > 3 && r && Object.defineProperty(target, key, r), r;
     }
 
+    function __generator(thisArg, body) {
+      var _ = { label: 0, sent: function() { 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;
+      function verb(n) { return function (v) { return step([n, v]); }; }
+      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 };
+      }
+    }
+
     typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
       var e = new Error(message);
       return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
@@ -1559,6 +1602,260 @@
         this.physicalWidth = physicalWidth;
     };
 
+    exports.XRReferenceImageDecoder = /*#__PURE__*/ function() {
+        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;
+    }();
+    exports.XRReferenceImageDecoder = __decorate([
+        engine.decoder("XRReferenceImage")
+    ], exports.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);
+    }
+
+    exports.XRReferenceImageLoader = /*#__PURE__*/ function(Loader1) {
+        _inherits(XRReferenceImageLoader, Loader1);
+        function XRReferenceImageLoader() {
+            return Loader1.apply(this, arguments);
+        }
+        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);
+    exports.XRReferenceImageLoader = __decorate([
+        engine.resourceLoader("XRReferenceImage", [])
+    ], exports.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);
+            });
+        };
+    }
+
+    exports.XRSceneExtendParser = /*#__PURE__*/ function() {
+        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, exports.XRTrackedInputDevice.Camera, entityMap.get(camera));
+                            setCamera(cameraManager, exports.XRTrackedInputDevice.LeftCamera, entityMap.get(leftCamera));
+                            setCamera(cameraManager, exports.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 exports.XRFeatureType.ImageTracking:
+                                    return [
+                                        3,
+                                        2
+                                    ];
+                                case exports.XRFeatureType.PlaneTracking:
+                                    return [
+                                        3,
+                                        4
+                                    ];
+                                case exports.XRFeatureType.AnchorTracking:
+                                    return [
+                                        3,
+                                        5
+                                    ];
+                                case exports.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;
+    }();
+    exports.XRSceneExtendParser = __decorate([
+        engine.registerSceneExtendParser("XR")
+    ], exports.XRSceneExtendParser);
+    function addImageTracking(engine$1, xrManager, schema) {
+        if (!xrManager.isSupportedFeature(exports.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(exports.XRImageTracking, xrReferenceImages);
+        });
+    }
+    function addPlaneTracking(xrManager, schema) {
+        if (!xrManager.isSupportedFeature(exports.XRPlaneTracking)) {
+            engine.Logger.error("Plane Tracking is not supported.");
+            return;
+        }
+        xrManager.addFeature(exports.XRPlaneTracking, schema.detectionMode);
+    }
+    function addAnchorTracking(xrManager, schema) {
+        if (!xrManager.isSupportedFeature(exports.XRAnchorTracking)) {
+            engine.Logger.error("Anchor Tracking is not supported.");
+            return;
+        }
+        var anchorTracking = xrManager.addFeature(exports.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(exports.XRHitTest)) {
+            engine.Logger.error("Hit Test is not supported.");
+            return;
+        }
+        xrManager.addFeature(exports.XRHitTest);
+    }
+    function setCamera(cameraManager, device, entity) {
+        var _entity;
+        var camera = (_entity = entity) == null ? void 0 : _entity.getComponent(engine.Camera);
+        camera && cameraManager.attachCamera(device, camera);
+    }
+
     exports.XRAnchor = XRAnchor;
     exports.XRCamera = XRCamera;
     exports.XRCameraManager = XRCameraManager;