@galacean/effects-plugin-orientation-transformer 0.0.1-alpha.0

package/dist/index.js

@@ -0,0 +1,802 @@
+/*!
+ * Name: @galacean/effects-plugin-orientation-transformer
+ * Description: Galacean Effects player orientation transformer plugin
+ * Author: Ant Group CO., Ltd.
+ * Contributors: 燃然,意绮
+ * Version: v0.0.1-alpha.0
+ */
+
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var effects = require('@galacean/effects');
+
+/******************************************************************************
+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.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+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 CompositionTransformerAcceler = /** @class */ (function () {
+    function CompositionTransformerAcceler(composition) {
+        this.composition = composition;
+        this.targets = {};
+        this.records = {};
+        this.current = {};
+        this.gammaRange = [-89, 89];
+        this.betaRange = [-80, 80];
+    }
+    CompositionTransformerAcceler.prototype.update = function (_a) {
+        var x = _a.x, y = _a.y;
+        this.currentEvent = { x: x, y: y };
+    };
+    CompositionTransformerAcceler.prototype.updateOrientation = function () {
+        var _this = this;
+        var event = this.currentEvent;
+        if (event) {
+            Object.getOwnPropertyNames(this.targets).forEach(function (name) {
+                _this.moveLayer(name, event);
+            });
+        }
+    };
+    CompositionTransformerAcceler.prototype.initComposition = function () {
+        var items = this.composition.items;
+        for (var i = 0; i < items.length; i++) {
+            var item = items[i];
+            var target = this.targets[item.name];
+            if (target) {
+                var position = item.transform.position.slice();
+                var currentPosition = this.current[item.name];
+                this.records[item.name] = {
+                    item: item,
+                    position: position,
+                };
+                if (currentPosition) {
+                    var _a = __read(currentPosition, 3), x = _a[0], y = _a[1], z = _a[2];
+                    item.transform.setPosition(x, y, z);
+                }
+            }
+        }
+    };
+    CompositionTransformerAcceler.prototype.addTarget = function (target) {
+        this.targets[target.name] = target;
+    };
+    CompositionTransformerAcceler.prototype.removeTarget = function (name) {
+        delete this.targets[name];
+        delete this.records[name];
+    };
+    CompositionTransformerAcceler.prototype.moveLayer = function (name, _a) {
+        var _b;
+        var _c;
+        var x = _a.x, y = _a.y;
+        var layer = (_c = this.records[name]) === null || _c === void 0 ? void 0 : _c.item;
+        if (layer) {
+            var initPosition = this.records[name].position;
+            var target = this.targets[name];
+            var beta = clamp(x, this.betaRange), gamma = clamp(y, this.gammaRange);
+            if (target) {
+                var position = [
+                    initPosition[0] + 1.2 * mapRange((beta - this.gammaRange[0]) / (this.gammaRange[1] - this.gammaRange[0]), target.xMin, target.xMax),
+                    initPosition[1] + 1.2 * mapRange((gamma - this.betaRange[0]) / (this.betaRange[1] - this.betaRange[0]), target.yMin, target.yMax),
+                    initPosition[2],
+                ];
+                (_b = layer.transform).setPosition.apply(_b, __spreadArray([], __read(position), false));
+                this.current[name] = position.slice();
+            }
+        }
+    };
+    return CompositionTransformerAcceler;
+}());
+function clamp(x, range) {
+    if (x < range[0]) {
+        return range[0];
+    }
+    else if (x > range[1]) {
+        return range[1];
+    }
+    return x;
+}
+function mapRange(t, min, max) {
+    return min + (max - min) * t;
+}
+
+function getObjectType(obj) {
+    return Object.prototype.toString.call(obj);
+}
+
+/**
+ * 角度限制
+ * @internal
+ * @param angleObj 角度数值对象
+ * @param validRange 角度限制值
+ */
+function angleLimit(angleObj, validRange) {
+    var flagAlpha = true;
+    var flagBeta = true;
+    var flagGamma = true;
+    if (getObjectType(validRange.alpha) === '[object Array]' && validRange.alpha.length >= 2) {
+        var referAlphaA = angleObj.alpha + validRange.alpha[0];
+        var referAlphaB = angleObj.alpha + validRange.alpha[1];
+        referAlphaA = referAlphaA < 0 ? referAlphaA + 360 : referAlphaA;
+        referAlphaB = referAlphaB > 360 ? referAlphaB - 360 : referAlphaB;
+        if (referAlphaA < referAlphaB) {
+            flagAlpha = angleObj.alpha > referAlphaA && angleObj.alpha < referAlphaB;
+        }
+        else {
+            flagAlpha = angleObj.alpha > referAlphaA || angleObj.alpha < referAlphaB;
+        }
+    }
+    if (getObjectType(validRange.beta) === '[object Array]' && validRange.beta.length >= 2) {
+        flagBeta = angleObj.beta >= validRange.beta[0] && angleObj.beta <= validRange.beta[1];
+    }
+    if (getObjectType(validRange.gamma) === '[object Array]' && validRange.gamma.length >= 2) {
+        flagGamma = angleObj.gamma >= validRange.gamma[0] && angleObj.gamma <= validRange.gamma[1];
+    }
+    return flagAlpha && flagBeta && flagGamma;
+}
+
+function deepMerge(target, args) {
+    if (!effects.isObject(target) && !effects.isArray(target)) {
+        return target;
+    }
+    var result = effects.isArray(target) ? __spreadArray([], __read(target), false) : __assign({}, target);
+    var length = arguments.length;
+    for (var index = 1; index < length; index++) {
+        var source = arguments[index] || {};
+        if (effects.isObject(source)) {
+            var prop = void 0;
+            for (prop in source) {
+                if (source.hasOwnProperty(prop)) {
+                    if (effects.isObject(result[prop]) && effects.isObject(source[prop])) {
+                        result[prop] = deepMerge(result[prop], source[prop]);
+                    }
+                    else if (effects.isObject(source[prop])) {
+                        result[prop] = deepMerge(source[prop]);
+                    }
+                    else if (effects.isArray(source[prop])) {
+                        result[prop] = deepMerge(source[prop]);
+                    }
+                    else {
+                        result[prop] = source[prop];
+                    }
+                }
+            }
+            for (prop in result) {
+                if (effects.isObject(result[prop]) &&
+                    result.hasOwnProperty(prop) &&
+                    !source.hasOwnProperty(prop)) {
+                    result[prop] = deepMerge(result[prop]);
+                }
+            }
+        }
+    }
+    if (length === 1) {
+        for (var prop in result) {
+            if (effects.isObject(result[prop]) && result.hasOwnProperty(prop)) {
+                result[prop] = deepMerge(result[prop]);
+            }
+        }
+    }
+    return result;
+}
+
+function isIOS() {
+    var str = navigator.userAgent.toLowerCase();
+    var ver = str.match(/cpu (iphone )?os (.*?) like mac os/);
+    return ver ? parseInt(ver[2], 10) : 0;
+}
+
+/**
+ * 稳定区间
+ */
+var STABLE_RANGE = 3;
+/**
+ * 每次增幅的最大值
+ */
+var MAX_CHANGE = 5;
+/**
+ * 每次增幅的最小值
+ */
+var MIN_CHANGE = 1;
+/**
+ * 数据缓存队列的长度
+ */
+var VALUE_POOL_LENGTH = 5;
+/**
+ * 滤波方法
+ */
+var Filtering = /** @class */ (function () {
+    function Filtering(options) {
+        if (options === void 0) { options = {}; }
+        this.options = options;
+        this.lastValue = 0;
+        this.valuePool = [];
+    }
+    /**
+     * 0deg 左右保持一定的稳定区间 STABLE_RANGE
+     * - 小于 STABLE_RANGE 的算 0
+     * - 大于 STABLE_RANGE 的减去 STABLE_RANGE
+     * @param value - 输入值
+     * @returns
+     */
+    Filtering.prototype.stableFix = function (value) {
+        var stableRange = this.options.stableRange || STABLE_RANGE;
+        if (Math.abs(value) < stableRange) {
+            return 0;
+        }
+        return value > stableRange ? value - stableRange : value + stableRange;
+    };
+    /**
+     * 变幅限制
+     * - 最大变化 MAX_CHANGE
+     * - 最小变化 MIN_CHANGE
+     * @param value
+     * @returns
+     */
+    Filtering.prototype.changeLimit = function (value) {
+        var lastValue = this.lastValue;
+        var result = value;
+        if (Math.abs(value - lastValue) > MAX_CHANGE) {
+            result = lastValue < value ? lastValue + MAX_CHANGE : lastValue - MAX_CHANGE;
+        }
+        if (Math.abs(value - lastValue) < MIN_CHANGE) {
+            result = lastValue;
+        }
+        this.lastValue = result;
+        return result;
+    };
+    Filtering.prototype.linearRegressionMedian = function (value) {
+        // 在队列中装载数据，达到队列阀值长度时开始计算
+        this.valuePool.push(value);
+        var result;
+        if (this.valuePool.length >= VALUE_POOL_LENGTH) {
+            result = getLinearRegressionFixedVal(this.valuePool);
+            this.valuePool.shift();
+        }
+        else {
+            result = this.lastValue;
+        }
+        return result;
+    };
+    return Filtering;
+}());
+// 计算出线性回归参数
+function linearRegression(x, y) {
+    var result = {};
+    var n = y.length;
+    var sumX = 0;
+    var sumY = 0;
+    var sumXY = 0;
+    var sumXX = 0;
+    var sumYY = 0;
+    for (var i = 0; i < y.length; i++) {
+        sumX += x[i];
+        sumY += y[i];
+        sumXY += (x[i] * y[i]);
+        sumXX += (x[i] * x[i]);
+        sumYY += (y[i] * y[i]);
+    }
+    var avgX = sumX / n;
+    var avgY = sumY / n;
+    result['a'] = (sumXY - n * avgX * avgY) / (sumXX - n * avgX * avgX);
+    result['b'] = avgY - result.a * avgX;
+    result['miss'] = Math.pow((n * sumXY - sumX * sumY) / Math.sqrt((n * sumXX - sumX * sumX) * (n * sumYY - sumY * sumY)), 2);
+    return result;
+}
+// 生成线性回归函数 F(x) = ax + b
+function createLinearRegressionFx(values) {
+    var x = [];
+    var y = [];
+    values.forEach(function (item, index) {
+        x.push(index); // 数据是连续的，所以直接取数组下标为 x
+        y.push(item);
+    });
+    var key = linearRegression(x, y);
+    return function (x) {
+        return key.a * x + key.b;
+    };
+}
+// 获取线性回归后的中位数
+function getLinearRegressionFixedVal(valuePool) {
+    var fx = createLinearRegressionFx(valuePool);
+    // 这个迭代修正很重要
+    valuePool = valuePool.map(function (item, index) {
+        return fx(index);
+    });
+    return fx(valuePool.length / 2);
+}
+
+var useJSBridge = isIOS() && typeof window.AlipayJSBridge !== 'undefined';
+var useWindVane = typeof window.WindVane !== 'undefined';
+// 默认参数
+var defaultOptions = {
+    X: true,
+    Y: true,
+    interval: Math.floor(1000 / 30),
+    useRequestAnimationFrame: true,
+    relativeBeta: false,
+    relativeGamma: false,
+    validRange: {
+        alpha: [-60, 60],
+        beta: [-60, 180],
+        gamma: [-89, 89],
+    },
+    stableRange: 3,
+};
+var DeviceOrientation = /** @class */ (function () {
+    function DeviceOrientation(options) {
+        if (options === void 0) { options = {}; }
+        this.lastX = 0;
+        this.lastY = 0;
+        this.prevAcceler = {
+            x: 0,
+            y: 0,
+            z: 0,
+        };
+        this.stoped = false;
+        this.options = deepMerge(defaultOptions, options);
+        var stableRange = this.options.stableRange;
+        this.filterX = new Filtering({ stableRange: stableRange });
+        this.filterY = new Filtering({ stableRange: stableRange });
+    }
+    DeviceOrientation.prototype.watch = function (callback) {
+        var _this = this;
+        if (typeof callback !== 'function') {
+            return;
+        }
+        // 目前只能绑定一个方法，此处可以扩展成一个方法队列
+        if (this.watchListener) {
+            return;
+        }
+        var timefragment = 0; // 时间片计时
+        var nowts = 0; // 当前时间
+        var referGamma = 0; // 初始化角度，作为单独一个用户的空间旋转的参照
+        var referBeta = 0;
+        var alpha;
+        var beta;
+        var gamma;
+        var gammaFixed;
+        var betaFixed;
+        var isInValidDegRange;
+        var x; // 最终输出的 x
+        var y; // 最终输出的 y
+        var handleWatch = function (e) {
+            if (_this.stoped) {
+                return;
+            }
+            alpha = e.alpha; // 垂直于屏幕的轴 0 ~ 360
+            beta = e.beta; // 横向 X 轴 -180 ~ 180
+            gamma = e.gamma; // 纵向 Y 轴 -90 ~ 90
+            if (!referBeta) {
+                referBeta = beta || 0;
+            }
+            if (!referGamma) {
+                referGamma = gamma || 0;
+            }
+            //
+            isInValidDegRange = angleLimit.call(_this, {
+                alpha: alpha,
+                beta: beta,
+                gamma: gamma,
+            }, _this.options.validRange);
+            if (isInValidDegRange) {
+                // 最终结果值
+                if (_this.options.X) {
+                    gammaFixed = gamma - referGamma;
+                    x = _this.options.relativeGamma ? gammaFixed : gamma;
+                    x = _this.filterX.stableFix(x);
+                    x = _this.filterX.changeLimit(x);
+                    x = _this.filterX.linearRegressionMedian(+x);
+                }
+                else {
+                    x = 0;
+                }
+                if (_this.options.Y) {
+                    // beta 相对 referBeta 的角度
+                    betaFixed = beta - referBeta;
+                    y = _this.options.relativeBeta ? betaFixed : beta;
+                    y = _this.filterY.stableFix(y);
+                    y = _this.filterY.changeLimit(y);
+                    y = _this.filterY.linearRegressionMedian(+y);
+                }
+                else {
+                    y = 0;
+                }
+                if (_this.isValid(x, y)) {
+                    if (_this.options.useRequestAnimationFrame) {
+                        window.requestAnimationFrame(function () {
+                            callback(x, y, { alpha: alpha, beta: beta, gamma: gamma });
+                        });
+                    }
+                    else {
+                        callback(x, y, { alpha: alpha, beta: beta, gamma: gamma });
+                    }
+                    _this.lastX = x;
+                    _this.lastY = y;
+                }
+            }
+        };
+        // 针对不同平台绑定不同事件
+        this.stoped = false;
+        if (useWindVane) {
+            switchWindVane(true, this.options.interval);
+            this.watchListener = function (e) {
+                if ('param' in e) {
+                    var _a = e.param, x_1 = _a.x, y_1 = _a.y, z = _a.z;
+                    // 即使手机没动，也会不停触发，所以这里加个判断，值相等则不调用回调
+                    if (x_1 === _this.prevAcceler.x && y_1 === _this.prevAcceler.y && z === _this.prevAcceler.z) {
+                        return;
+                    }
+                    _this.prevAcceler = { x: x_1, y: y_1, z: z };
+                    var evt = {
+                        alpha: +z * 180,
+                        beta: +y_1 * -90,
+                        gamma: +x_1 * 90,
+                    };
+                    handleWatch(evt);
+                }
+            };
+            document.addEventListener('motion.gyro', this.watchListener, false);
+        }
+        else if (useJSBridge) {
+            switchIOSEvent(true, this.options.interval / 1000);
+            this.watchListener = function (e) {
+                if (e && 'data' in e) {
+                    /*
+                    data:
+                    {
+                      data: {
+                        x: 0.0, // gamma -1 ~ 1
+                        y: 0.0, // beta -1 ~ 1
+                        z: 0.0, // alpha
+                      }
+                    }
+                    */
+                    var _a = e.data, x_2 = _a.x, y_2 = _a.y, z = _a.z;
+                    var evt = {
+                        alpha: z * 180,
+                        beta: y_2 * -90,
+                        gamma: x_2 * 90,
+                    };
+                    handleWatch(evt);
+                }
+            };
+            document.addEventListener('accelerometerChange', this.watchListener, false);
+        }
+        else {
+            this.watchListener = function (e) {
+                nowts = new Date().getTime();
+                // 控制时间片
+                if (nowts - timefragment >= _this.options.interval) {
+                    timefragment = nowts;
+                    handleWatch(e);
+                }
+            };
+            window.addEventListener('deviceorientation', this.watchListener, false);
+        }
+    };
+    DeviceOrientation.prototype.unWatch = function () {
+        effects.assertExist(this.watchListener);
+        if (useWindVane) {
+            switchWindVane(false);
+            document.removeEventListener('motion.gyro', this.watchListener);
+        }
+        else if (useJSBridge) {
+            switchIOSEvent(false);
+            document.removeEventListener('accelerometerChange', this.watchListener);
+        }
+        else {
+            window.removeEventListener('deviceorientation', this.watchListener);
+        }
+        this.stoped = true;
+        this.watchListener = undefined;
+    };
+    DeviceOrientation.prototype.pause = function () {
+        this.stoped = true;
+        if (useJSBridge) {
+            switchIOSEvent(false);
+        }
+    };
+    DeviceOrientation.prototype.continue = function () {
+        this.stoped = false;
+        if (useJSBridge) {
+            switchIOSEvent(true, this.options.interval / 1000);
+        }
+    };
+    DeviceOrientation.prototype.isValid = function (x, y) {
+        // 判断是否和上次的值一样，检测有没有变
+        return this.lastX !== x || this.lastY !== y;
+    };
+    return DeviceOrientation;
+}());
+// 开启/关闭 iOS 的陀螺仪监听
+function switchIOSEvent(open, interval) {
+    window.AlipayJSBridge.call('watchShake', {
+        monitorGyroscope: false,
+        monitorAccelerometer: !!open,
+        interval: !open ? 10 : parseFloat(interval.toFixed(3)),
+    }, function () { });
+}
+function switchWindVane(open, interval) {
+    var params = {
+        // 是开启还是关闭陀螺仪的监听
+        on: open,
+        // 陀螺仪事件的时间间隔
+        frequency: interval,
+    };
+    window.WindVane.call('WVMotion', 'listenGyro', params, function (e) {
+        console.info('call WVMotion success');
+    }, function (e) {
+        console.error('call WVMotion failed:' + JSON.stringify(e));
+    });
+}
+
+/**
+ *
+ */
+var OrientationAdapterAcceler = /** @class */ (function () {
+    function OrientationAdapterAcceler() {
+        this.transformers = [];
+        this.connected = false;
+        this.accelerMotion = null;
+        this.validRange = {
+            alpha: [-60, 60],
+            beta: [-80, 80],
+            gamma: [-89, 89], // 左右翻转
+        };
+    }
+    OrientationAdapterAcceler.prototype.connect = function () {
+        var _this = this;
+        if (!this.connected) {
+            this.accelerMotion = new DeviceOrientation({
+                X: true,
+                Y: true,
+                interval: Math.floor(1000 / 60),
+                useRequestAnimationFrame: true,
+                relativeBeta: false,
+                relativeGamma: false,
+                validRange: this.validRange,
+                stableRange: 3, // 稳定区间
+            });
+            this.accelerMotion.watch(function (x, y) {
+                var motion = {
+                    x: x,
+                    y: y,
+                };
+                _this.dispatchMotion(motion);
+            });
+        }
+        this.connected = true;
+    };
+    OrientationAdapterAcceler.prototype.disconnect = function () {
+        if (this.accelerMotion) {
+            this.accelerMotion.unWatch();
+        }
+        this.connected = false;
+    };
+    /**
+     *
+     * @param motion
+     */
+    OrientationAdapterAcceler.prototype.dispatchMotion = function (motion) {
+        this.transformers.forEach(function (t) { return t.update(motion); });
+    };
+    OrientationAdapterAcceler.prototype.addTransformer = function (transformer) {
+        if (!this.transformers.includes(transformer)) {
+            this.transformers.push(transformer);
+        }
+    };
+    OrientationAdapterAcceler.prototype.removeTransformer = function (transformer) {
+        var index = this.transformers.indexOf(transformer);
+        if (index > -1) {
+            this.transformers.splice(index, 1);
+        }
+        return this.transformers.length === 0;
+    };
+    return OrientationAdapterAcceler;
+}());
+var adapter;
+function getAccelerAdapter() {
+    if (!adapter) {
+        adapter = new OrientationAdapterAcceler();
+    }
+    return adapter;
+}
+
+var OrientationPluginLoader = /** @class */ (function (_super) {
+    __extends(OrientationPluginLoader, _super);
+    function OrientationPluginLoader() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this.order = 90;
+        _this.adapter = null;
+        _this.handleConnect = function () {
+            var _a;
+            if (!closeManually) {
+                (_a = _this.adapter) === null || _a === void 0 ? void 0 : _a.connect();
+            }
+        };
+        _this.handleDisconnect = function () {
+            var _a;
+            (_a = _this.adapter) === null || _a === void 0 ? void 0 : _a.disconnect();
+        };
+        return _this;
+    }
+    OrientationPluginLoader.prototype.onCompositionConstructed = function () {
+        var _a;
+        this.adapter = getAdapter();
+        (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.connect();
+        this.bindAccelerDocumentEvent();
+    };
+    OrientationPluginLoader.prototype.onCompositionReset = function (composition) {
+        var _a;
+        var transformer = composition.loaderData.deviceTransformer = new CompositionTransformerAcceler(composition);
+        (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.addTransformer(transformer);
+    };
+    OrientationPluginLoader.prototype.onCompositionUpdate = function (composition) {
+        var transformer = composition.loaderData.deviceTransformer;
+        if (transformer) {
+            transformer.updateOrientation();
+        }
+    };
+    OrientationPluginLoader.prototype.onCompositionDestroyed = function (composition) {
+        var _a, _b;
+        var empty = (_a = this.adapter) === null || _a === void 0 ? void 0 : _a.removeTransformer(composition.loaderData.deviceTransformer);
+        if (empty) {
+            (_b = this.adapter) === null || _b === void 0 ? void 0 : _b.disconnect();
+        }
+    };
+    OrientationPluginLoader.prototype.bindAccelerDocumentEvent = function () {
+        this.unbindAccelerDocumentEvent(); // 保证全局只监听一份
+        document.addEventListener('resume', this.handleConnect, false);
+        document.addEventListener('pause', this.handleDisconnect, false);
+        document.addEventListener('back', this.handleDisconnect, false);
+    };
+    OrientationPluginLoader.prototype.unbindAccelerDocumentEvent = function () {
+        document.removeEventListener('resume', this.handleConnect);
+        document.removeEventListener('pause', this.handleDisconnect);
+        document.removeEventListener('back', this.handleDisconnect);
+    };
+    OrientationPluginLoader.prototype.dispose = function () {
+        getAdapter().disconnect();
+        this.unbindAccelerDocumentEvent();
+    };
+    return OrientationPluginLoader;
+}(effects.AbstractPlugin));
+// 是否是手动关闭，如果是，那么 resume 时不要恢复
+var closeManually = false;
+/**
+ *
+ * @returns
+ */
+function getAdapter() {
+    // 运动感应类型（默认使用加速度，Native 环境使用陀螺仪）
+    return getAccelerAdapter();
+}
+function closeDeviceMotion() {
+    closeManually = true;
+    getAdapter().disconnect();
+}
+function openDeviceMotion() {
+    closeManually = false;
+    getAdapter().connect();
+}
+
+var TransformVFXItem = /** @class */ (function (_super) {
+    __extends(TransformVFXItem, _super);
+    function TransformVFXItem() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Object.defineProperty(TransformVFXItem.prototype, "type", {
+        get: function () {
+            return 'orientation-transformer';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    TransformVFXItem.prototype.onConstructed = function (options) {
+        var targets = options.content.options.targets;
+        if (targets) {
+            this.targets = targets.map(function (t) { return ({
+                name: t.name,
+                xMin: +t.xMin || 0,
+                yMin: +t.yMin || 0,
+                xMax: +t.xMax || 0,
+                yMax: +t.yMax || 0,
+            }); });
+        }
+    };
+    TransformVFXItem.prototype.onItemRemoved = function (composition) {
+        var _a;
+        (_a = this.targets) === null || _a === void 0 ? void 0 : _a.forEach(function (target) { var _a; return (_a = composition.loaderData.deviceTransformer) === null || _a === void 0 ? void 0 : _a.removeTarget(target.name); });
+    };
+    TransformVFXItem.prototype.doCreateContent = function (composition) {
+        var _a;
+        var transformer = composition.loaderData.deviceTransformer;
+        if (transformer) {
+            (_a = this.targets) === null || _a === void 0 ? void 0 : _a.forEach(function (target) { return transformer.addTarget(target); });
+            transformer.initComposition();
+        }
+        return {};
+    };
+    return TransformVFXItem;
+}(effects.VFXItem));
+
+effects.registerPlugin('orientation-transformer', OrientationPluginLoader, TransformVFXItem);
+var version = "0.0.1-alpha.0";
+console.info('[Galacean Effects Plugin Orientation Transformer] version: ' + version);
+
+exports.OrientationAdapterAcceler = OrientationAdapterAcceler;
+exports.closeDeviceMotion = closeDeviceMotion;
+exports.getAdapter = getAdapter;
+exports.openDeviceMotion = openDeviceMotion;
+exports.version = version;
+//# sourceMappingURL=index.js.map