@galacean/engine-xr 0.0.0-experimental-1.2-xr.0 → 0.0.0-experimental-1.3-xr.2

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,13 +549,12 @@
                 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();
                 engine.resume();
             }
-            engine.dispatch("XRSessionStart");
         };
         /**
        * Stop the session.
@@ -569,13 +569,28 @@
             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();
                 engine.resume();
             }
-            engine.dispatch("XRSessionStop");
+        };
+        /**
+       * 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
@@ -592,12 +607,11 @@
                 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();
                     resolve();
-                    _this._engine.dispatch("XRSessionInit");
                 }, reject);
             });
         };
@@ -630,14 +644,11 @@
         /**
        * @internal
        */ _proto._exit = function _exit() {
-            var _this = this;
-            var _this1 = this, platformSession = _this1._platformSession;
+            var _this = this, platformSession = _this._platformSession;
             if (!platformSession) {
                 return Promise.reject("Without session to stop.");
             }
-            return platformSession.end().then(function() {
-                _this._engine.dispatch("XRSessionExit");
-            });
+            return platformSession.end();
         };
         _proto._onSessionExit = function _onSessionExit() {
             var _this = this, rhi = _this._rhi, platformSession = _this._platformSession, engine = _this._engine;
@@ -645,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();
@@ -670,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);
+                    }
                 }
             },
             {
@@ -719,15 +739,15 @@
             if (this.sessionManager._platformSession) {
                 throw new Error("Cannot add feature when the session is initialized.");
             }
-            var _this = this, features = _this._features; _this._platformDevice;
             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++){
                 if (_instanceof(features[i], type)) throw new Error("The feature has been added");
             }
             var feature = _construct(type, [].concat(this, args));
-            this._features.push(feature);
+            features.push(feature);
             return feature;
         };
         /**
@@ -735,7 +755,7 @@
        * @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)) {
@@ -743,19 +763,6 @@
                 }
             }
         };
-        _proto.getFeatures = function getFeatures(out) {
-            var _this = this, features = _this._features;
-            var length = features.length;
-            if (out) {
-                out.length = length;
-            } else {
-                out = new Array(length);
-            }
-            for(var i = 0; i < length; i--){
-                out[i] = features[i];
-            }
-            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
@@ -775,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);
@@ -796,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);
@@ -810,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();
@@ -850,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();
@@ -859,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();
@@ -869,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();
@@ -879,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();
@@ -987,10 +994,75 @@
     }();
 
     /**
-     * The base class of XR tracked object.
-     */ var XRTracked = function XRTracked() {
-        /** The pose of the trackable in XR space. */ this.pose = new XRPose();
-        /** The tracking state of the trackable. */ this.state = exports.XRTrackingState.NotTracking;
+     * Enum for the types of hit test that can be performed.
+     * Note: currently only supports plane.
+     */ exports.TrackableType = void 0;
+    (function(TrackableType) {
+        TrackableType[TrackableType[/** Tracked plane. */ "Plane"] = 0x1] = "Plane";
+        TrackableType[TrackableType[/** All tracked objects. */ "All"] = 0x1] = "All";
+    })(exports.TrackableType || (exports.TrackableType = {}));
+
+    /**
+     * XR hit result.
+     * It is the detection result returned by using XR HitTest feature.
+     */ var XRHitResult = function XRHitResult() {
+        /** The position of the hit point. */ this.point = new engine.Vector3();
+        /** The normal of the hit point. */ this.normal = new engine.Vector3();
+    };
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+
+    function __decorate(decorators, target, key, desc) {
+      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+      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 _ = { 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;
     };
 
     exports.XRFeatureType = void 0;
@@ -1146,50 +1218,6 @@
         XRTrackableFeature._uuid = 0;
     })();
 
-    /**
-     * Enum for the types of hit test that can be performed.
-     * Note: currently only supports plane.
-     */ exports.TrackableType = void 0;
-    (function(TrackableType) {
-        TrackableType[TrackableType[/** Tracked plane. */ "Plane"] = 0x1] = "Plane";
-        TrackableType[TrackableType[/** All tracked objects. */ "All"] = 0x1] = "All";
-    })(exports.TrackableType || (exports.TrackableType = {}));
-
-    /**
-     * XR hit result.
-     * It is the detection result returned by using XR HitTest feature.
-     */ var XRHitResult = function XRHitResult() {
-        /** The position of the hit point. */ this.point = new engine.Vector3();
-        /** The normal of the hit point. */ this.normal = new engine.Vector3();
-    };
-
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __decorate(decorators, target, key, desc) {
-      var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-      if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-      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;
-    }
-
-    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-      var e = new Error(message);
-      return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-    };
-
     /**
      * Enumerates modes of plane in XR.
      */ exports.XRPlaneMode = void 0;
@@ -1220,6 +1248,13 @@
         return XRRequestPlane;
     }(XRRequestTracking);
 
+    /**
+     * The base class of XR tracked object.
+     */ var XRTracked = function XRTracked() {
+        /** The pose of the trackable in XR space. */ this.pose = new XRPose();
+        /** The tracking state of the trackable. */ this.state = exports.XRTrackingState.NotTracking;
+    };
+
     /**
      * The tracked plane in XR space.
      */ var XRTrackedPlane = /*#__PURE__*/ function(XRTracked1) {
@@ -1567,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;
@@ -1577,8 +1866,6 @@
     exports.XRPose = XRPose;
     exports.XRReferenceImage = XRReferenceImage;
     exports.XRSessionManager = XRSessionManager;
-    exports.XRTrackableFeature = XRTrackableFeature;
-    exports.XRTracked = XRTracked;
     exports.XRTrackedImage = XRTrackedImage;
     exports.XRTrackedPlane = XRTrackedPlane;