@galacean/engine-xr 1.2.0-alpha.0

package/dist/module.js

@@ -0,0 +1,1555 @@
+import { CameraType, Matrix, CameraClearFlags, Vector3, Quaternion, Rect, XRManager, Ray, Plane, Vector2 } from '@galacean/engine';
+
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+
+        return o;
+    };
+
+    return _set_prototype_of(o, p);
+}
+
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
+}
+
+function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+
+        if ("value" in descriptor) descriptor.writable = true;
+
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+
+    return Constructor;
+}
+
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+
+    subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } });
+
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else return left instanceof right;
+}
+
+/**
+ * Enumerates some input devices that can be tracked.(including status, posture and other information)
+ */ var XRTrackedInputDevice;
+(function(XRTrackedInputDevice) {
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Controller */ "Controller"] = 0] = "Controller";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Left controller */ "LeftController"] = 1] = "LeftController";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Right controller */ "RightController"] = 2] = "RightController";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Camera */ "Camera"] = 3] = "Camera";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Left camera */ "LeftCamera"] = 4] = "LeftCamera";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Right camera */ "RightCamera"] = 5] = "RightCamera";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Head */ "LeftHand"] = 6] = "LeftHand";
+    XRTrackedInputDevice[XRTrackedInputDevice[/** Right hand */ "RightHand"] = 7] = "RightHand";
+})(XRTrackedInputDevice || (XRTrackedInputDevice = {}));
+
+/**
+ * The state of an XRSession.
+ */ var XRSessionState;
+(function(XRSessionState) {
+    XRSessionState[XRSessionState[/** Not initialized. */ "None"] = 0] = "None";
+    XRSessionState[XRSessionState[/** Initialized but not started. */ "Initialized"] = 1] = "Initialized";
+    XRSessionState[XRSessionState[/** Running. */ "Running"] = 2] = "Running";
+    XRSessionState[XRSessionState[/** Paused. */ "Paused"] = 3] = "Paused";
+})(XRSessionState || (XRSessionState = {}));
+
+/**
+ * The manager of XR camera.
+ */ var XRCameraManager = /*#__PURE__*/ function() {
+    function XRCameraManager(_xrManager) {
+        this._xrManager = _xrManager;
+    }
+    var _proto = XRCameraManager.prototype;
+    /**
+   * Attach the camera to the specified input type(Camera, LeftCamera or RightCamera).
+   * The camera entity need to be moved to the XROrigin entity.
+   * @param type - The input type
+   * @param camera - The camera to be attached
+   */ _proto.attachCamera = function attachCamera(type, camera) {
+        var xrCamera = this._xrManager.inputManager.getTrackedDevice(type);
+        var preCamera = xrCamera._camera;
+        if (preCamera !== camera) {
+            // @ts-ignore
+            preCamera && (preCamera._cameraType = CameraType.Normal);
+            switch(type){
+                case XRTrackedInputDevice.Camera:
+                    // @ts-ignore
+                    camera._cameraType = CameraType.XRCenterCamera;
+                    break;
+                case XRTrackedInputDevice.LeftCamera:
+                    // @ts-ignore
+                    camera._cameraType = CameraType.XRLeftCamera;
+                    break;
+                case XRTrackedInputDevice.RightCamera:
+                    // @ts-ignore
+                    camera._cameraType = CameraType.XRRightCamera;
+                    break;
+            }
+            xrCamera._camera = camera;
+        }
+    };
+    /**
+   * Detach the camera from the specified input type.
+   * @param type - The input type
+   * @returns The camera that was detached
+   */ _proto.detachCamera = function detachCamera(type) {
+        var xrCamera = this._xrManager.inputManager.getTrackedDevice(type);
+        var preCamera = xrCamera._camera;
+        // @ts-ignore
+        preCamera && (preCamera._cameraType = CameraType.Normal);
+        xrCamera._camera = null;
+        return preCamera;
+    };
+    /**
+   * @internal
+   */ _proto._onSessionStart = function _onSessionStart() {};
+    /**
+   * @internal
+   */ _proto._onUpdate = function _onUpdate() {
+        var _this__xrManager_inputManager = this._xrManager.inputManager, cameras = _this__xrManager_inputManager._cameras;
+        for(var i = 0, n = cameras.length; i < n; i++){
+            var cameraDevice = cameras[i];
+            var camera = cameraDevice._camera;
+            if (!camera) continue;
+            // sync position and rotation
+            var transform = camera.entity.transform;
+            var pose = cameraDevice.pose;
+            transform.position = pose.position;
+            transform.rotationQuaternion = pose.rotation;
+            // sync viewport
+            var viewport = camera.viewport;
+            var _cameraDevice_viewport = cameraDevice.viewport, x = _cameraDevice_viewport.x, y = _cameraDevice_viewport.y, width = _cameraDevice_viewport.width, height = _cameraDevice_viewport.height;
+            if (!(x === viewport.x && y === viewport.y && width === viewport.z && height === viewport.w)) {
+                camera.viewport = viewport.set(x, y, width, height);
+            }
+            // sync project matrix
+            if (!Matrix.equals(camera.projectionMatrix, cameraDevice.projectionMatrix)) {
+                camera.projectionMatrix = cameraDevice.projectionMatrix;
+            }
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onSessionExit = function _onSessionExit() {};
+    /**
+   * @internal
+   */ _proto._getCameraClearFlagsMask = function _getCameraClearFlagsMask(cameraType) {
+        if (cameraType === CameraType.XRCenterCamera) {
+            if (this._xrManager.sessionManager.state === XRSessionState.Running) {
+                return CameraClearFlags.Color;
+            } else {
+                return CameraClearFlags.None;
+            }
+        } else {
+            return CameraClearFlags.None;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onDestroy = function _onDestroy() {};
+    _create_class(XRCameraManager, [
+        {
+            key: "fixedFoveation",
+            get: /**
+   * The fixed foveation of the camera.
+   */ function get() {
+                var _this__xrManager_sessionManager = this._xrManager.sessionManager, platformSession = _this__xrManager_sessionManager._platformSession;
+                if (platformSession) {
+                    return platformSession.getFixedFoveation();
+                } else {
+                    throw new Error("XR session is not available.");
+                }
+            },
+            set: function set(value) {
+                var _this__xrManager_sessionManager = this._xrManager.sessionManager, platformSession = _this__xrManager_sessionManager._platformSession;
+                if (platformSession) {
+                    platformSession.setFixedFoveation(value);
+                } else {
+                    throw new Error("XR session is not available.");
+                }
+            }
+        }
+    ]);
+    return XRCameraManager;
+}();
+
+/**
+ * Data for describing pose in the XR space.
+ */ var XRPose = function XRPose() {
+    /** The position of the pose in XR space. */ this.position = new Vector3();
+    /** The rotation of the pose in XR space. */ this.rotation = new Quaternion();
+    /** The matrix of the pose in XR space. */ this.matrix = new Matrix();
+    /** The inverse matrix of the pose in XR space. */ this.inverseMatrix = new Matrix();
+};
+
+/**
+ * Enum for XR tracking state.
+ */ var XRTrackingState;
+(function(XRTrackingState) {
+    XRTrackingState[XRTrackingState[/** Not tracking */ "NotTracking"] = 0] = "NotTracking";
+    XRTrackingState[XRTrackingState[/** Tracking */ "Tracking"] = 1] = "Tracking";
+    XRTrackingState[XRTrackingState[/** Lost track */ "TrackingLost"] = 2] = "TrackingLost";
+})(XRTrackingState || (XRTrackingState = {}));
+
+var XRInput = function XRInput(type) {
+    this.type = type;
+    this./** The tracking state of xr input. */ trackingState = XRTrackingState.NotTracking;
+};
+
+/**
+ * The XR camera.
+ */ var XRCamera = /*#__PURE__*/ function(XRInput1) {
+    _inherits(XRCamera, XRInput1);
+    function XRCamera() {
+        var _this;
+        _this = XRInput1.apply(this, arguments) || this;
+        /** The pose of the camera in XR space. */ _this.pose = new XRPose();
+        /** The viewport of the camera. */ _this.viewport = new Rect();
+        /** The projection matrix of the camera. */ _this.projectionMatrix = new Matrix();
+        return _this;
+    }
+    return XRCamera;
+}(XRInput);
+
+/**
+ * Enum for XR input button.
+ */ var XRInputButton;
+(function(XRInputButton) {
+    XRInputButton[XRInputButton[/** None */ "None"] = 0x0] = "None";
+    XRInputButton[XRInputButton[/** Select */ "Select"] = 0x1] = "Select";
+    XRInputButton[XRInputButton[/** Select */ "Trigger"] = 0x1] = "Trigger";
+    XRInputButton[XRInputButton[/** Squeeze */ "Squeeze"] = 0x2] = "Squeeze";
+    XRInputButton[XRInputButton[/** TouchPad */ "TouchPad"] = 0x4] = "TouchPad";
+    XRInputButton[XRInputButton[/** A */ "AButton"] = 0x8] = "AButton";
+    XRInputButton[XRInputButton[/** B */ "BButton"] = 0x10] = "BButton";
+})(XRInputButton || (XRInputButton = {}));
+
+/**
+ * The XR controller.
+ */ var XRController = /*#__PURE__*/ function(XRInput1) {
+    _inherits(XRController, XRInput1);
+    function XRController() {
+        var _this;
+        _this = XRInput1.apply(this, arguments) || this;
+        /** The grip space pose of the controller in XR space. */ _this.gripPose = new XRPose();
+        /** The target ray space pose of the controller in XR space. */ _this.targetRayPose = new XRPose();
+        /** The currently pressed buttons of this controller. */ _this.pressedButtons = XRInputButton.None;
+        /** Record button lifted. */ _this.down = XRInputButton.None;
+        /** Record button pressed. */ _this.up = XRInputButton.None;
+        return _this;
+    }
+    var _proto = XRController.prototype;
+    /**
+   *
+   * Returns whether the button is pressed.
+   * @param button - The button to check
+   * @returns Whether the button is pressed
+   */ _proto.isButtonDown = function isButtonDown(button) {
+        return (this.down & button) !== 0;
+    };
+    /**
+   * Returns whether the button is lifted.
+   * @param button - The button to check
+   * @returns Whether the button is lifted
+   */ _proto.isButtonUp = function isButtonUp(button) {
+        return (this.up & button) !== 0;
+    };
+    /**
+   * Returns whether the button is held down.
+   * @param button - The button to check
+   * @returns Whether the button is held down
+   */ _proto.isButtonHeldDown = function isButtonHeldDown(button) {
+        return (this.pressedButtons & button) !== 0;
+    };
+    return XRController;
+}(XRInput);
+
+var XRInputEventType;
+(function(XRInputEventType) {
+    XRInputEventType[XRInputEventType["SelectStart"] = 0] = "SelectStart";
+    XRInputEventType[XRInputEventType["Select"] = 1] = "Select";
+    XRInputEventType[XRInputEventType["SelectEnd"] = 2] = "SelectEnd";
+    XRInputEventType[XRInputEventType["SqueezeStart"] = 3] = "SqueezeStart";
+    XRInputEventType[XRInputEventType["Squeeze"] = 4] = "Squeeze";
+    XRInputEventType[XRInputEventType["SqueezeEnd"] = 5] = "SqueezeEnd";
+})(XRInputEventType || (XRInputEventType = {}));
+
+var XRTargetRayMode;
+(function(XRTargetRayMode) {
+    XRTargetRayMode[XRTargetRayMode["Gaze"] = 0] = "Gaze";
+    XRTargetRayMode[XRTargetRayMode["TrackedPointer"] = 1] = "TrackedPointer";
+    XRTargetRayMode[XRTargetRayMode["Screen"] = 2] = "Screen";
+})(XRTargetRayMode || (XRTargetRayMode = {}));
+
+/**
+ * The manager of XR input.
+ */ var XRInputManager = /*#__PURE__*/ function() {
+    function XRInputManager(_xrManager, _engine) {
+        this._xrManager = _xrManager;
+        this._engine = _engine;
+        this./** @internal */ _cameras = [];
+        this./** @internal */ _controllers = [];
+        this._added = [];
+        this._removed = [];
+        this._trackedDevices = [];
+        this._statusSnapshot = [];
+        this._listeners = [];
+        var _this = this, trackedDevices = _this._trackedDevices, controllers = _this._controllers, cameras = _this._cameras;
+        for(var i = 0; i < 6; i++){
+            switch(i){
+                case XRTrackedInputDevice.Camera:
+                case XRTrackedInputDevice.LeftCamera:
+                case XRTrackedInputDevice.RightCamera:
+                    cameras.push(trackedDevices[i] = new XRCamera(i));
+                    break;
+                case XRTrackedInputDevice.Controller:
+                case XRTrackedInputDevice.LeftController:
+                case XRTrackedInputDevice.RightController:
+                    controllers.push(trackedDevices[i] = new XRController(i));
+                    break;
+            }
+        }
+        this._statusSnapshot.fill(XRTrackingState.NotTracking, 0, trackedDevices.length);
+    }
+    var _proto = XRInputManager.prototype;
+    /**
+   * Returns the tracked device instance.
+   * @param type - The tracked input device type
+   * @returns The input instance
+   */ _proto.getTrackedDevice = function getTrackedDevice(type) {
+        return this._trackedDevices[type];
+    };
+    /**
+   * Add a listener for tracked device changes.
+   * @param listener - The listener to add
+   */ _proto.addTrackedDeviceChangedListener = function addTrackedDeviceChangedListener(listener) {
+        this._listeners.push(listener);
+    };
+    /**
+   * Remove a listener of tracked device changes.
+   * @param listener - The listener to remove
+   */ _proto.removeTrackedDeviceChangedListener = function removeTrackedDeviceChangedListener(listener) {
+        var _this = this, listeners = _this._listeners;
+        var index = listeners.indexOf(listener);
+        if (index >= 0) {
+            listeners.splice(index, 1);
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onUpdate = function _onUpdate() {
+        var _this = this, added = _this._added, removed = _this._removed, listeners = _this._listeners, statusSnapshot = _this._statusSnapshot;
+        var _this1 = this, trackedDevices = _this1._trackedDevices, controllers = _this1._controllers;
+        // Reset data
+        added.length = removed.length = 0;
+        for(var i = 0, n = controllers.length; i < n; i++){
+            var controller = controllers[i];
+            controller.down = controller.up = 0;
+        }
+        // Handle events and update tracked devices
+        var _this__xrManager_sessionManager = this._xrManager.sessionManager, platformSession = _this__xrManager_sessionManager._platformSession;
+        var platformEvents = platformSession.events;
+        for(var i1 = 0, n1 = platformEvents.length; i1 < n1; i1++){
+            this._handleEvent(platformEvents[i1]);
+        }
+        platformSession.resetEvents();
+        platformSession.frame.updateInputs(trackedDevices);
+        for(var i2 = 0, n2 = trackedDevices.length; i2 < n2; i2++){
+            var input = trackedDevices[i2];
+            if (!input) continue;
+            var nowState = input.trackingState;
+            if (statusSnapshot[i2] === XRTrackingState.Tracking) {
+                if (nowState !== XRTrackingState.Tracking) {
+                    removed.push(input);
+                }
+            } else {
+                if (nowState === XRTrackingState.Tracking) {
+                    added.push(input);
+                }
+            }
+            statusSnapshot[i2] = nowState;
+        }
+        // Dispatch change event
+        if (added.length > 0 || removed.length > 0) {
+            for(var i3 = 0, n3 = listeners.length; i3 < n3; i3++){
+                listeners[i3](added, removed);
+            }
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onDestroy = function _onDestroy() {
+        this._listeners.length = 0;
+    };
+    _proto._handleEvent = function _handleEvent(event) {
+        var input = this._trackedDevices[event.input];
+        switch(event.targetRayMode){
+            case XRTargetRayMode.TrackedPointer:
+                switch(event.type){
+                    case XRInputEventType.SelectStart:
+                        input.down |= XRInputButton.Select;
+                        input.pressedButtons |= XRInputButton.Select;
+                        break;
+                    case XRInputEventType.SelectEnd:
+                        input.up |= XRInputButton.Select;
+                        input.pressedButtons &= ~XRInputButton.Select;
+                        break;
+                    case XRInputEventType.SqueezeStart:
+                        input.down |= XRInputButton.Squeeze;
+                        input.pressedButtons |= XRInputButton.Squeeze;
+                        break;
+                    case XRInputEventType.SqueezeEnd:
+                        input.up |= XRInputButton.Squeeze;
+                        input.pressedButtons &= ~XRInputButton.Squeeze;
+                        break;
+                }
+                break;
+            case XRTargetRayMode.Screen:
+                // @ts-ignore
+                var canvas = this._engine.canvas._webCanvas;
+                var clientWidth = canvas.clientWidth, clientHeight = canvas.clientHeight;
+                var clientX = clientWidth * (event.x + 1) * 0.5;
+                var clientY = clientHeight * (event.y + 1) * 0.5;
+                switch(event.type){
+                    case XRInputEventType.SelectStart:
+                        canvas.dispatchEvent(this._makeUpPointerEvent("pointerdown", event.id, clientX, clientY));
+                        break;
+                    case XRInputEventType.Select:
+                        canvas.dispatchEvent(this._makeUpPointerEvent("pointermove", event.id, clientX, clientY));
+                        break;
+                    case XRInputEventType.SelectEnd:
+                        canvas.dispatchEvent(this._makeUpPointerEvent("pointerup", event.id, clientX, clientY));
+                        canvas.dispatchEvent(this._makeUpPointerEvent("pointerleave", event.id, clientX, clientY));
+                        break;
+                }
+                break;
+        }
+    };
+    _proto._makeUpPointerEvent = function _makeUpPointerEvent(type, pointerId, clientX, clientY) {
+        var eventInitDict = {
+            pointerId: pointerId,
+            clientX: clientX,
+            clientY: clientY
+        };
+        switch(type){
+            case "pointerdown":
+                eventInitDict.button = 0;
+                eventInitDict.buttons = 1;
+                break;
+            case "pointermove":
+                eventInitDict.button = -1;
+                eventInitDict.buttons = 1;
+                break;
+            case "pointerup":
+                eventInitDict.button = 0;
+                eventInitDict.buttons = 0;
+                break;
+            case "pointerleave":
+                eventInitDict.button = 0;
+                eventInitDict.buttons = 0;
+                break;
+        }
+        return new PointerEvent(type, eventInitDict);
+    };
+    return XRInputManager;
+}();
+
+/**
+ * The type of XR session.
+ */ var XRSessionMode;
+(function(XRSessionMode) {
+    XRSessionMode[XRSessionMode["None"] = 0] = "None";
+    XRSessionMode[XRSessionMode["AR"] = 1] = "AR";
+    XRSessionMode[XRSessionMode["VR"] = 2] = "VR";
+})(XRSessionMode || (XRSessionMode = {}));
+
+/**
+ * XRSessionManager manages the life cycle of XR sessions.
+ */ var XRSessionManager = /*#__PURE__*/ function() {
+    function XRSessionManager(_xrManager, _engine) {
+        this._xrManager = _xrManager;
+        this._engine = _engine;
+        this._mode = XRSessionMode.None;
+        this._state = XRSessionState.None;
+        // @ts-ignore
+        this._rhi = _engine._hardwareRenderer;
+        this._raf = requestAnimationFrame.bind(window);
+        this._caf = cancelAnimationFrame.bind(window);
+        this._onSessionExit = this._onSessionExit.bind(this);
+    }
+    var _proto = XRSessionManager.prototype;
+    /**
+   * Check if the specified mode is supported.
+   * @param mode - The mode to check
+   * @returns A promise that resolves if the mode is supported, otherwise rejects
+   */ _proto.isSupportedMode = function isSupportedMode(mode) {
+        return this._xrManager._platformDevice.isSupportedSessionMode(mode);
+    };
+    /**
+   * Run the session.
+   */ _proto.run = function run() {
+        var _this = this, platformSession = _this._platformSession, engine = _this._engine;
+        if (!platformSession) {
+            throw new Error("Without session to run.");
+        }
+        platformSession.start();
+        this._state = XRSessionState.Running;
+        this._xrManager._onSessionStart();
+        if (!engine.isPaused) {
+            engine.pause();
+            engine.resume();
+        }
+    };
+    /**
+   * Stop the session.
+   */ _proto.stop = function stop() {
+        var _this = this, platformSession = _this._platformSession, engine = _this._engine, rhi = _this._rhi;
+        if (!platformSession) {
+            throw new Error("Without session to stop.");
+        }
+        if (this._state !== XRSessionState.Running) {
+            throw new Error("Session is not running.");
+        }
+        rhi._mainFrameBuffer = null;
+        rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
+        platformSession.stop();
+        this._state = XRSessionState.Paused;
+        this._xrManager._onSessionStop();
+        if (!engine.isPaused) {
+            engine.pause();
+            engine.resume();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._initialize = function _initialize(mode, features) {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            var xrManager = _this._xrManager;
+            // Initialize all features
+            var platformFeatures = [];
+            for(var i = 0, n = features.length; i < n; i++){
+                var _features_i = features[i], platformFeature = _features_i._platformFeature;
+                platformFeature && platformFeatures.push(platformFeature);
+            }
+            xrManager._platformDevice.requestSession(_this._rhi, mode, platformFeatures).then(function(platformSession) {
+                _this._mode = mode;
+                _this._platformSession = platformSession;
+                _this._state = XRSessionState.Initialized;
+                platformSession.setSessionExitCallBack(_this._onSessionExit);
+                platformSession.addEventListener();
+                xrManager._onSessionInit();
+                resolve();
+            }, reject);
+        });
+    };
+    /**
+   * @internal
+   */ _proto._onUpdate = function _onUpdate() {
+        var _this = this, rhi = _this._rhi, platformSession = _this._platformSession;
+        rhi._mainFrameBuffer = platformSession.framebuffer;
+        rhi._mainFrameWidth = platformSession.framebufferWidth;
+        rhi._mainFrameHeight = platformSession.framebufferHeight;
+    };
+    /**
+   * @internal
+   */ _proto._getRequestAnimationFrame = function _getRequestAnimationFrame() {
+        if (this._state === XRSessionState.Running) {
+            return this._platformSession.requestAnimationFrame;
+        } else {
+            return this._raf;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._getCancelAnimationFrame = function _getCancelAnimationFrame() {
+        if (this._state === XRSessionState.Running) {
+            return this._platformSession.cancelAnimationFrame;
+        } else {
+            return this._caf;
+        }
+    };
+    /**
+   * @internal
+   */ _proto._exit = function _exit() {
+        var _this = this, platformSession = _this._platformSession;
+        if (!platformSession) {
+            return Promise.reject("Without session to stop.");
+        }
+        return platformSession.end();
+    };
+    _proto._onSessionExit = function _onSessionExit() {
+        var _this = this, rhi = _this._rhi, platformSession = _this._platformSession, engine = _this._engine;
+        rhi._mainFrameBuffer = null;
+        rhi._mainFrameWidth = rhi._mainFrameHeight = 0;
+        platformSession.removeEventListener();
+        this._platformSession = null;
+        this._state = XRSessionState.None;
+        this._xrManager._onSessionExit();
+        if (!engine.isPaused) {
+            engine.pause();
+            engine.resume();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onDestroy = function _onDestroy() {};
+    _create_class(XRSessionManager, [
+        {
+            key: "mode",
+            get: /**
+   * The current session mode( AR or VR ).
+   */ function get() {
+                return this._mode;
+            }
+        },
+        {
+            key: "state",
+            get: /**
+   * Return the current session state.
+   */ function get() {
+                return this._state;
+            }
+        },
+        {
+            key: "supportedFrameRate",
+            get: /**
+   * Return a list of supported frame rates.(only available in-session)
+   */ function get() {
+                return this._platformSession.supportedFrameRates;
+            }
+        },
+        {
+            key: "frameRate",
+            get: /**
+   * Return the current frame rate as reported by the device.
+   */ function get() {
+                return this._platformSession.frameRate;
+            }
+        }
+    ]);
+    return XRSessionManager;
+}();
+
+/**
+ * XRManager is the entry point of the XR system.
+ */ var XRManagerExtended = /*#__PURE__*/ function(XRManager1) {
+    _inherits(XRManagerExtended, XRManager1);
+    function XRManagerExtended() {
+        return XRManager1.apply(this, arguments);
+    }
+    var _proto = XRManagerExtended.prototype;
+    /**
+   * Check if the specified feature is supported.
+   * @param type - The type of the feature
+   * @returns If the feature is supported
+   */ _proto.isSupportedFeature = function isSupportedFeature(feature) {
+        return this._platformDevice.isSupportedFeature(XRManagerExtended._featureMap.get(feature));
+    };
+    /**
+   * Add feature based on the xr feature type.
+   * @param type - The type of the feature
+   * @param args - The constructor params of the feature
+   * @returns The feature which has been added
+   */ _proto.addFeature = function addFeature(type) {
+        for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+            args[_key - 1] = arguments[_key];
+        }
+        if (this.sessionManager._platformSession) {
+            throw new Error("Cannot add feature when the session is initialized.");
+        }
+        var _this = this, 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");
+        }
+        var feature1 = _construct(type, [].concat(this, args));
+        this._features.push(feature1);
+        return feature1;
+    };
+    /**
+   * 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;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            if (_instanceof(feature, type)) {
+                return feature;
+            }
+        }
+    };
+    _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
+   * @param autoRun - Whether to automatically run the session, when `autoRun` is set to true, xr will start working immediately after initialization. Otherwise, you need to call `sessionManager.run` later to work.
+   * @returns A promise that resolves if the XR virtual world is entered, otherwise rejects
+   */ _proto.enterXR = function enterXR(sessionMode, autoRun) {
+        if (autoRun === void 0) autoRun = true;
+        var _this = this;
+        var sessionManager = this.sessionManager;
+        if (sessionManager._platformSession) {
+            throw new Error("Please exit XR immersive mode first.");
+        }
+        if (!this._origin) {
+            throw new Error("Please set origin before enter XR.");
+        }
+        return new Promise(function(resolve, reject) {
+            // 1. Check if this xr mode is supported
+            sessionManager.isSupportedMode(sessionMode).then(function() {
+                // 2. Initialize session
+                sessionManager._initialize(sessionMode, _this._features).then(function() {
+                    autoRun && sessionManager.run();
+                    resolve();
+                }, reject);
+            }, reject);
+        });
+    };
+    /**
+   * Exit XR immersive mode, when you call this method, it will destroy the XR virtual world.
+   * @returns A promise that resolves if the XR virtual world is destroyed, otherwise rejects
+   */ _proto.exitXR = function exitXR() {
+        var _this = this;
+        return new Promise(function(resolve, reject) {
+            _this.sessionManager._exit().then(function() {
+                resolve();
+            }, reject);
+        });
+    };
+    /**
+   * @internal
+   */ _proto._initialize = function _initialize(engine, xrDevice) {
+        this._features = [];
+        this._platformDevice = xrDevice;
+        this.sessionManager = new XRSessionManager(this, engine);
+        this.inputManager = new XRInputManager(this, engine);
+        this.cameraManager = new XRCameraManager(this);
+    };
+    /**
+   * @internal
+   */ _proto._update = function _update() {
+        var sessionManager = this.sessionManager;
+        if (sessionManager.state !== XRSessionState.Running) return;
+        sessionManager._onUpdate();
+        this.inputManager._onUpdate();
+        this.cameraManager._onUpdate();
+        var _this = this, features = _this._features;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            feature.enabled && feature._onUpdate();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._destroy = function _destroy() {
+        var _this = this;
+        if (this.sessionManager._platformSession) {
+            this.exitXR().then(function() {
+                _this.sessionManager._onDestroy();
+                _this.inputManager._onDestroy();
+                _this.cameraManager._onDestroy();
+            });
+        } else {
+            this.sessionManager._onDestroy();
+            this.inputManager._onDestroy();
+            this.cameraManager._onDestroy();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._getRequestAnimationFrame = function _getRequestAnimationFrame() {
+        return this.sessionManager._getRequestAnimationFrame();
+    };
+    /**
+   * @internal
+   */ _proto._getCancelAnimationFrame = function _getCancelAnimationFrame() {
+        return this.sessionManager._getCancelAnimationFrame();
+    };
+    /**
+   * @internal
+   */ _proto._getCameraClearFlagsMask = function _getCameraClearFlagsMask(type) {
+        return this.cameraManager._getCameraClearFlagsMask(type);
+    };
+    /**
+   * @internal
+   */ _proto._onSessionStop = function _onSessionStop() {
+        var _this = this, features = _this._features;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            feature.enabled && feature._onSessionStop();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onSessionInit = function _onSessionInit() {
+        var _this = this, features = _this._features;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            feature.enabled && feature._onSessionInit();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onSessionStart = function _onSessionStart() {
+        this.cameraManager._onSessionStart();
+        var _this = this, features = _this._features;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            feature.enabled && feature._onSessionStart();
+        }
+    };
+    /**
+   * @internal
+   */ _proto._onSessionExit = function _onSessionExit() {
+        this.cameraManager._onSessionExit();
+        var _this = this, features = _this._features;
+        for(var i = 0, n = features.length; i < n; i++){
+            var feature = features[i];
+            feature.enabled && feature._onSessionExit();
+            feature._onDestroy();
+        }
+        features.length = 0;
+    };
+    _create_class(XRManagerExtended, [
+        {
+            key: "origin",
+            get: /**
+   * The current origin of XR space.
+   * @remarks The connection point between the virtual world and the real world ( XR Space )
+   */ function get() {
+                return this._origin;
+            },
+            set: function set(value) {
+                if (this.sessionManager._platformSession) {
+                    throw new Error("Cannot set origin when the session is initialized.");
+                }
+                this._origin = value;
+            }
+        }
+    ]);
+    return XRManagerExtended;
+}(XRManager);
+(function() {
+    /** @internal */ XRManagerExtended._featureMap = new Map();
+})();
+/**
+ * @internal
+ */ function registerXRFeature(type) {
+    return function(feature) {
+        XRManagerExtended._featureMap.set(feature, type);
+    };
+}
+// 实现混入的函数
+function ApplyMixins(derivedCtor, baseCtors) {
+    baseCtors.forEach(function(baseCtor) {
+        Object.getOwnPropertyNames(baseCtor.prototype).forEach(function(name) {
+            Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
+        });
+    });
+}
+ApplyMixins(XRManager, [
+    XRManagerExtended
+]);
+
+/**
+ * The base class of XR feature manager.
+ */ var XRFeature = /*#__PURE__*/ function() {
+    function XRFeature(_xrManager, _type) {
+        for(var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++){
+            args[_key - 2] = arguments[_key];
+        }
+        var _xrManager__platformDevice;
+        this._xrManager = _xrManager;
+        this._type = _type;
+        this._enabled = true;
+        this._platformFeature = (_xrManager__platformDevice = _xrManager._platformDevice).createPlatformFeature.apply(_xrManager__platformDevice, [].concat(_type, args));
+        this._onEnable();
+    }
+    var _proto = XRFeature.prototype;
+    /**
+   * @internal
+   */ _proto._onEnable = function _onEnable() {};
+    /**
+   * @internal
+   */ _proto._onDisable = function _onDisable() {};
+    /**
+   * @internal
+   */ _proto._onUpdate = function _onUpdate() {};
+    /**
+   * @internal
+   */ _proto._onSessionInit = function _onSessionInit() {};
+    /**
+   * @internal
+   */ _proto._onSessionStart = function _onSessionStart() {};
+    /**
+   * @internal
+   */ _proto._onSessionStop = function _onSessionStop() {};
+    /**
+   * @internal
+   */ _proto._onSessionExit = function _onSessionExit() {};
+    /**
+   * @internal
+   */ _proto._onDestroy = function _onDestroy() {};
+    _create_class(XRFeature, [
+        {
+            key: "enabled",
+            get: /**
+   * Returns whether the feature is enabled.
+   */ function get() {
+                return this._enabled;
+            },
+            set: function set(value) {
+                if (this.enabled !== value) {
+                    this._enabled = value;
+                    value ? this._onEnable() : this._onDisable();
+                }
+            }
+        }
+    ]);
+    return XRFeature;
+}();
+
+/**
+ * Enum for the types of hit test that can be performed.
+ * Note: currently only supports plane.
+ */ var TrackableType;
+(function(TrackableType) {
+    TrackableType[TrackableType[/** Tracked plane. */ "Plane"] = 0x1] = "Plane";
+    TrackableType[TrackableType[/** All tracked objects. */ "All"] = 0x1] = "All";
+})(TrackableType || (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 Vector3();
+    /** The normal of the hit point. */ this.normal = new 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;
+};
+
+var XRFeatureType;
+(function(XRFeatureType) {
+    XRFeatureType[XRFeatureType["AnchorTracking"] = 0] = "AnchorTracking";
+    XRFeatureType[XRFeatureType["ImageTracking"] = 1] = "ImageTracking";
+    XRFeatureType[XRFeatureType["PlaneTracking"] = 2] = "PlaneTracking";
+    XRFeatureType[XRFeatureType["HitTest"] = 3] = "HitTest";
+})(XRFeatureType || (XRFeatureType = {}));
+
+var XRRequestTrackingState;
+(function(XRRequestTrackingState) {
+    XRRequestTrackingState[XRRequestTrackingState["None"] = 0] = "None";
+    XRRequestTrackingState[XRRequestTrackingState["Submitted"] = 1] = "Submitted";
+    XRRequestTrackingState[XRRequestTrackingState["Resolved"] = 2] = "Resolved";
+    XRRequestTrackingState[XRRequestTrackingState["Rejected"] = 3] = "Rejected";
+    XRRequestTrackingState[XRRequestTrackingState["Destroyed"] = 4] = "Destroyed";
+    XRRequestTrackingState[XRRequestTrackingState["WaitingDestroy"] = 5] = "WaitingDestroy";
+})(XRRequestTrackingState || (XRRequestTrackingState = {}));
+
+/**
+ * The base class of XR trackable manager.
+ */ var XRTrackableFeature = /*#__PURE__*/ function(XRFeature1) {
+    _inherits(XRTrackableFeature, XRFeature1);
+    function XRTrackableFeature() {
+        var _this;
+        _this = XRFeature1.apply(this, arguments) || this;
+        _this._requestTrackings = [];
+        _this._tracked = [];
+        _this._added = [];
+        _this._updated = [];
+        _this._removed = [];
+        _this._statusSnapshot = {};
+        _this._listeners = [];
+        return _this;
+    }
+    var _proto = XRTrackableFeature.prototype;
+    /**
+   * Add a listening function for tracked object changes.
+   * @param listener - The listening function
+   */ _proto.addChangedListener = function addChangedListener(listener) {
+        this._listeners.push(listener);
+    };
+    /**
+   * Remove a listening function of tracked object 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);
+        }
+    };
+    _proto._onUpdate = function _onUpdate() {
+        var _this__xrManager_sessionManager = this._xrManager.sessionManager, platformSession = _this__xrManager_sessionManager._platformSession;
+        var platformFrame = platformSession.frame;
+        var _this = this, platformFeature = _this._platformFeature, listeners = _this._listeners, requestTrackings = _this._requestTrackings, statusSnapshot = _this._statusSnapshot, allTracked = _this._tracked, added = _this._added, updated = _this._updated, removed = _this._removed;
+        if (!platformFrame || !requestTrackings.length) {
+            return;
+        }
+        if (!platformFeature.checkAvailable(platformSession, platformFrame, requestTrackings)) {
+            return;
+        }
+        added.length = updated.length = removed.length = 0;
+        platformFeature.getTrackedResult(platformSession, platformFrame, requestTrackings, this._generateTracked);
+        for(var i = 0, n = requestTrackings.length; i < n; i++){
+            var requestTracking = requestTrackings[i];
+            switch(requestTracking.state){
+                case XRRequestTrackingState.Destroyed:
+                    var destroyedTracked = requestTracking.tracked;
+                    for(var j = 0, n1 = destroyedTracked.length; j < n1; j++){
+                        var tracked = destroyedTracked[j];
+                        var trackId = tracked.id;
+                        if (statusSnapshot[trackId] === XRTrackingState.Tracking) {
+                            removed.push(tracked);
+                            allTracked.splice(allTracked.indexOf(tracked), 1);
+                        }
+                        statusSnapshot[trackId] = XRTrackingState.NotTracking;
+                    }
+                    break;
+                case XRRequestTrackingState.Resolved:
+                    var tracked1 = requestTracking.tracked;
+                    for(var j1 = 0, n2 = tracked1.length; j1 < n2; j1++){
+                        var trackedObject = tracked1[j1];
+                        var trackId1 = trackedObject.id;
+                        if (trackedObject.state === XRTrackingState.Tracking) {
+                            if (statusSnapshot[trackId1] === XRTrackingState.Tracking) {
+                                updated.push(trackedObject);
+                            } else {
+                                added.push(trackedObject);
+                                statusSnapshot[trackId1] = XRTrackingState.Tracking;
+                                allTracked.push(trackedObject);
+                            }
+                        } else {
+                            if (statusSnapshot[trackId1] === XRTrackingState.Tracking) {
+                                removed.push(trackedObject);
+                                allTracked.splice(allTracked.indexOf(trackedObject), 1);
+                            }
+                            statusSnapshot[trackId1] = trackedObject.state;
+                        }
+                    }
+                    break;
+            }
+        }
+        for(var i1 = requestTrackings.length - 1; i1 >= 0; i1--){
+            requestTrackings[i1].state === XRRequestTrackingState.Destroyed && requestTrackings.splice(i1, 1);
+        }
+        if (added.length > 0 || updated.length > 0 || removed.length > 0) {
+            for(var i2 = 0, n3 = listeners.length; i2 < n3; i2++){
+                listeners[i2](added, updated, removed);
+            }
+        }
+    };
+    _proto._onSessionStop = function _onSessionStop() {
+        this._added.length = this._updated.length = this._removed.length = 0;
+    };
+    _proto._onSessionExit = function _onSessionExit() {
+        // prettier-ignore
+        this._requestTrackings.length = this._tracked.length = this._added.length = this._updated.length = this._removed.length = 0;
+    };
+    _proto._onDestroy = function _onDestroy() {
+        // prettier-ignore
+        this._requestTrackings.length = this._tracked.length = this._added.length = this._updated.length = this._removed.length = 0;
+    };
+    _proto._addRequestTracking = function _addRequestTracking(requestTracking) {
+        var _this = this, platformFeature = _this._platformFeature;
+        if (this._xrManager.sessionManager._platformSession && !platformFeature.canModifyRequestTrackingAfterInit) {
+            throw new Error(XRFeatureType[this._type] + " request tracking cannot be modified after initialization.");
+        }
+        this._requestTrackings.push(requestTracking);
+        platformFeature.onAddRequestTracking(requestTracking);
+    };
+    _proto._removeRequestTracking = function _removeRequestTracking(requestTracking) {
+        var _this = this, platformFeature = _this._platformFeature;
+        if (this._xrManager.sessionManager._platformSession && !platformFeature.canModifyRequestTrackingAfterInit) {
+            throw new Error(XRFeatureType[this._type] + " request tracking cannot be modified after initialization.");
+        }
+        platformFeature.onDelRequestTracking(requestTracking);
+    };
+    _proto._removeAllRequestTrackings = function _removeAllRequestTrackings() {
+        var _this = this, platformFeature = _this._platformFeature;
+        if (this._xrManager.sessionManager._platformSession && !platformFeature.canModifyRequestTrackingAfterInit) {
+            throw new Error(XRFeatureType[this._type] + " request tracking cannot be modified after initialization.");
+        }
+        var _this1 = this, requestTrackings = _this1._requestTrackings;
+        for(var i = 0, n = requestTrackings.length; i < n; i++){
+            platformFeature.onDelRequestTracking(requestTrackings[i]);
+        }
+    };
+    return XRTrackableFeature;
+}(XRFeature);
+(function() {
+    XRTrackableFeature._uuid = 0;
+})();
+
+/**
+ * Enumerates modes of plane in XR.
+ */ var XRPlaneMode;
+(function(XRPlaneMode) {
+    XRPlaneMode[XRPlaneMode[/** None. */ "None"] = 0] = "None";
+    XRPlaneMode[XRPlaneMode[/** Horizontal */ "Horizontal"] = 1] = "Horizontal";
+    XRPlaneMode[XRPlaneMode[/** Vertical */ "Vertical"] = 2] = "Vertical";
+    XRPlaneMode[XRPlaneMode[/** Includes horizontal and vertical. */ "EveryThing"] = 3] = "EveryThing";
+})(XRPlaneMode || (XRPlaneMode = {}));
+
+/**
+ * @internal
+ */ var XRRequestTracking = function XRRequestTracking() {
+    /** The status of the current request tracking. */ this.state = XRRequestTrackingState.None;
+    /** Tracked instances, make up from the tracking data returned by Session. */ this.tracked = [];
+};
+
+/**
+ * The request plane in XR space.
+ */ var XRRequestPlane = /*#__PURE__*/ function(XRRequestTracking1) {
+    _inherits(XRRequestPlane, XRRequestTracking1);
+    function XRRequestPlane(detectionMode) {
+        var _this;
+        _this = XRRequestTracking1.call(this) || this;
+        _this.detectionMode = detectionMode;
+        return _this;
+    }
+    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 = XRTrackingState.NotTracking;
+};
+
+/**
+ * The tracked plane in XR space.
+ */ var XRTrackedPlane = /*#__PURE__*/ function(XRTracked1) {
+    _inherits(XRTrackedPlane, XRTracked1);
+    function XRTrackedPlane() {
+        var _this;
+        _this = XRTracked1.apply(this, arguments) || this;
+        /** The points that make up this plane.
+   *  Note: These points are in the plane coordinate system,
+   *  and their Y coordinates are all zero.
+   */ _this.polygon = [];
+        /**
+   * Whether this frame changes the attributes of the plane.
+   * Note: Includes `polygon` but no `pose`.
+   */ _this.attributesDirty = false;
+        return _this;
+    }
+    return XRTrackedPlane;
+}(XRTracked);
+
+var XRPlaneTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
+    _inherits(XRPlaneTracking, XRTrackableFeature1);
+    function XRPlaneTracking(xrManager, detectionMode) {
+        if (detectionMode === void 0) detectionMode = XRPlaneMode.EveryThing;
+        var _this;
+        _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.PlaneTracking, detectionMode) || this;
+        _this._addRequestTracking(new XRRequestPlane(detectionMode));
+        return _this;
+    }
+    var _proto = XRPlaneTracking.prototype;
+    _proto._generateTracked = function _generateTracked() {
+        var plane = new XRTrackedPlane();
+        plane.id = XRTrackableFeature._uuid++;
+        return plane;
+    };
+    _create_class(XRPlaneTracking, [
+        {
+            key: "detectionMode",
+            get: /**
+   * The plane detection mode.
+   */ function get() {
+                return this._requestTrackings[0].detectionMode;
+            }
+        },
+        {
+            key: "trackedPlanes",
+            get: /**
+   * The tracked planes.
+   */ function get() {
+                return this._tracked;
+            }
+        }
+    ]);
+    return XRPlaneTracking;
+}(XRTrackableFeature);
+XRPlaneTracking = __decorate([
+    registerXRFeature(XRFeatureType.PlaneTracking)
+], XRPlaneTracking);
+
+var XRHitTest = /*#__PURE__*/ function(XRFeature1) {
+    _inherits(XRHitTest, XRFeature1);
+    function XRHitTest(xrManager) {
+        var _this;
+        _this = XRFeature1.call(this, xrManager, XRFeatureType.HitTest) || this;
+        _this._tempRay = new Ray();
+        _this._tempPlane = new Plane();
+        _this._tempVec2 = new Vector2();
+        _this._tempVec30 = new Vector3();
+        _this._tempVec31 = new Vector3();
+        _this._tempVec32 = new Vector3();
+        _this._tempVec33 = new Vector3();
+        _this._tempVec34 = new Vector3();
+        _this._tempVec35 = new Vector3();
+        return _this;
+    }
+    var _proto = XRHitTest.prototype;
+    /**
+   * Hit test.
+   * @param ray - The ray to test
+   * @param type - The type of hit test
+   * @returns The hit result
+   */ _proto.hitTest = function hitTest(ray, type) {
+        var result = [];
+        if (type & TrackableType.Plane) {
+            this._hitTestPlane(ray, result);
+        }
+        return result;
+    };
+    /**
+   * Screen hit test.
+   * @param x - The x coordinate of the screen point
+   * @param y - The y coordinate of the screen point
+   * @param type - The type of hit test
+   * @returns The hit result
+   */ _proto.screenHitTest = function screenHitTest(x, y, type) {
+        var _this = this, xrManager = _this._xrManager;
+        if (xrManager.sessionManager.mode !== XRSessionMode.AR) {
+            throw new Error("Only AR mode supports using screen ray hit test.");
+        }
+        var _xrManager_inputManager_getTrackedDevice = xrManager.inputManager.getTrackedDevice(XRTrackedInputDevice.Camera), camera = _xrManager_inputManager_getTrackedDevice._camera;
+        if (!camera) {
+            throw new Error("No camera available.");
+        }
+        var ray = camera.screenPointToRay(this._tempVec2.set(x, y), this._tempRay);
+        return this.hitTest(ray, type);
+    };
+    _proto._hitTestPlane = function _hitTestPlane(ray, result) {
+        var planeManager = this._xrManager.getFeature(XRPlaneTracking);
+        if (!planeManager || !planeManager.enabled) {
+            throw new Error("The plane estimation function needs to be turned on for plane hit test.");
+        }
+        var _this = this, plane = _this._tempPlane, normal = _this._tempVec30, hitPoint = _this._tempVec31, hitPointInPlane = _this._tempVec32;
+        var trackedPlanes = planeManager.trackedPlanes;
+        for(var i = 0, n = trackedPlanes.length; i < n; i++){
+            var trackedPlane = trackedPlanes[i];
+            normal.set(0, 1, 0).transformNormal(trackedPlane.pose.matrix);
+            plane.normal.copyFrom(normal);
+            plane.distance = -Vector3.dot(normal, trackedPlane.pose.position);
+            var distance = ray.intersectPlane(plane);
+            if (distance >= 0) {
+                ray.getPoint(distance, hitPoint);
+                Vector3.transformToVec3(hitPoint, trackedPlane.pose.inverseMatrix, hitPointInPlane);
+                // Check if the hit position is within the plane boundary.
+                if (this._checkPointerWithinPlane(hitPointInPlane, trackedPlane)) {
+                    var hitResult = new XRHitResult();
+                    hitResult.point.copyFrom(hitPoint);
+                    hitResult.normal.copyFrom(normal);
+                    hitResult.distance = distance;
+                    hitResult.trackedObject = trackedPlane;
+                    hitResult.trackableType = TrackableType.Plane;
+                    result.push(hitResult);
+                }
+            }
+        }
+    };
+    _proto._checkPointerWithinPlane = function _checkPointerWithinPlane(pointer, plane) {
+        var _this = this, preToCur = _this._tempVec33, preToPointer = _this._tempVec34, cross = _this._tempVec35;
+        var polygon = plane.polygon;
+        var length = polygon.length;
+        var prePoint = polygon[length - 1];
+        var side = 0;
+        for(var i = 0; i < length; i++){
+            var curPoint = polygon[i];
+            Vector3.subtract(curPoint, prePoint, preToCur);
+            Vector3.subtract(pointer, prePoint, preToPointer);
+            Vector3.cross(preToCur, preToPointer, cross);
+            var y = cross.y;
+            if (side === 0) {
+                if (y > 0) {
+                    side = 1;
+                } else if (y < 0) {
+                    side = -1;
+                }
+            } else {
+                if (y > 0 && side < 0 || y < 0 && side > 0) {
+                    return false;
+                }
+            }
+            prePoint = curPoint;
+        }
+        return true;
+    };
+    return XRHitTest;
+}(XRFeature);
+XRHitTest = __decorate([
+    registerXRFeature(XRFeatureType.HitTest)
+], XRHitTest);
+
+/**
+ * The anchor in XR space.
+ */ var XRAnchor = /*#__PURE__*/ function(XRTracked1) {
+    _inherits(XRAnchor, XRTracked1);
+    function XRAnchor() {
+        return XRTracked1.apply(this, arguments);
+    }
+    return XRAnchor;
+}(XRTracked);
+
+/**
+ * The request anchor in XR space.
+ */ var XRRequestAnchor = /*#__PURE__*/ function(XRRequestTracking1) {
+    _inherits(XRRequestAnchor, XRRequestTracking1);
+    function XRRequestAnchor(position, rotation) {
+        var _this;
+        _this = XRRequestTracking1.call(this) || this;
+        _this.position = position;
+        _this.rotation = rotation;
+        return _this;
+    }
+    return XRRequestAnchor;
+}(XRRequestTracking);
+
+var XRAnchorTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
+    _inherits(XRAnchorTracking, XRTrackableFeature1);
+    function XRAnchorTracking(xrManager) {
+        var _this;
+        _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.AnchorTracking) || this;
+        _this._anchors = [];
+        return _this;
+    }
+    var _proto = XRAnchorTracking.prototype;
+    /**
+   * Add a anchor in XR space.
+   * @param anchor - The anchor to be added
+   */ _proto.addAnchor = function addAnchor(position, rotation) {
+        if (!this._enabled) {
+            throw new Error("Cannot add an anchor from a disabled anchor manager.");
+        }
+        var _this = this, anchors = _this._anchors;
+        var requestAnchor = new XRRequestAnchor(position, rotation);
+        var xrAnchor = this._generateTracked();
+        requestAnchor.tracked[0] = xrAnchor;
+        this._addRequestTracking(requestAnchor);
+        anchors.push(xrAnchor);
+        return xrAnchor;
+    };
+    /**
+   * Remove a anchor in XR space.
+   * @param anchor - The anchor to be removed
+   */ _proto.removeAnchor = function removeAnchor(anchor) {
+        if (!this._enabled) {
+            throw new Error("Cannot remove an anchor from a disabled anchor manager.");
+        }
+        var _this = this, requestTrackings = _this._requestTrackings, anchors = _this._anchors;
+        for(var i = 0, n = requestTrackings.length; i < n; i++){
+            var requestAnchor = requestTrackings[i];
+            if (requestAnchor.tracked[0] === anchor) {
+                this._removeRequestTracking(requestAnchor);
+                break;
+            }
+        }
+        anchors.splice(anchors.indexOf(anchor), 1);
+    };
+    /**
+   * Remove all tracking anchors.
+   */ _proto.clearAnchors = function clearAnchors() {
+        if (!this._enabled) {
+            throw new Error("Cannot remove anchors from a disabled anchor manager.");
+        }
+        this._removeAllRequestTrackings();
+    };
+    _proto._generateTracked = function _generateTracked() {
+        var anchor = new XRAnchor();
+        anchor.id = XRTrackableFeature._uuid++;
+        return anchor;
+    };
+    _create_class(XRAnchorTracking, [
+        {
+            key: "trackingAnchors",
+            get: /**
+   * The anchors to tracking.
+   */ function get() {
+                return this._anchors;
+            }
+        },
+        {
+            key: "trackedAnchors",
+            get: /**
+   * The tracked anchors.
+   */ function get() {
+                return this._tracked;
+            }
+        }
+    ]);
+    return XRAnchorTracking;
+}(XRTrackableFeature);
+XRAnchorTracking = __decorate([
+    registerXRFeature(XRFeatureType.AnchorTracking)
+], XRAnchorTracking);
+
+/**
+ * The request image in XR space.
+ */ var XRRequestImage = /*#__PURE__*/ function(XRRequestTracking1) {
+    _inherits(XRRequestImage, XRRequestTracking1);
+    function XRRequestImage(image) {
+        var _this;
+        _this = XRRequestTracking1.call(this) || this;
+        _this.image = image;
+        return _this;
+    }
+    return XRRequestImage;
+}(XRRequestTracking);
+
+/**
+ * A tracked image in XR space.
+ */ var XRTrackedImage = /*#__PURE__*/ function(XRTracked1) {
+    _inherits(XRTrackedImage, XRTracked1);
+    function XRTrackedImage() {
+        return XRTracked1.apply(this, arguments);
+    }
+    return XRTrackedImage;
+}(XRTracked);
+
+var XRImageTracking = /*#__PURE__*/ function(XRTrackableFeature1) {
+    _inherits(XRImageTracking, XRTrackableFeature1);
+    function XRImageTracking(xrManager, trackingImages) {
+        var _this;
+        _this = XRTrackableFeature1.call(this, xrManager, XRFeatureType.ImageTracking, trackingImages) || this;
+        _this._trackingImages = trackingImages;
+        var imageLength = trackingImages ? trackingImages.length : 0;
+        if (imageLength > 0) {
+            for(var i = 0, n = trackingImages.length; i < n; i++){
+                _this._addRequestTracking(new XRRequestImage(trackingImages[i]));
+            }
+        } else {
+            console.warn("No image to be tracked.");
+        }
+        return _this;
+    }
+    var _proto = XRImageTracking.prototype;
+    _proto._generateTracked = function _generateTracked() {
+        var image = new XRTrackedImage();
+        image.id = XRTrackableFeature._uuid++;
+        return image;
+    };
+    _create_class(XRImageTracking, [
+        {
+            key: "trackingImages",
+            get: /**
+   * The image to tracking.
+   */ function get() {
+                return this._trackingImages;
+            }
+        },
+        {
+            key: "trackedImages",
+            get: /**
+   * The tracked images.
+   */ function get() {
+                return this._tracked;
+            }
+        }
+    ]);
+    return XRImageTracking;
+}(XRTrackableFeature);
+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;
+};
+
+export { TrackableType, XRAnchor, XRAnchorTracking, XRCamera, XRCameraManager, XRController, XRFeature, XRFeatureType, XRHitResult, XRHitTest, XRImageTracking, XRInputButton, XRInputEventType, XRInputManager, XRPlaneMode, XRPlaneTracking, XRPose, XRReferenceImage, XRRequestTrackingState, XRSessionManager, XRSessionMode, XRSessionState, XRTargetRayMode, XRTrackedImage, XRTrackedInputDevice, XRTrackedPlane, XRTrackingState };
+//# sourceMappingURL=module.js.map