@vvfx/sdk 0.2.8 → 0.2.10

package/dist/service/UndoRedo.js

@@ -0,0 +1,79 @@
+/**
+ * 通用撤销重做类，支持任意数据类型
+ */
+export class GizmoUndoRedo {
+    // 下标
+    index = -1;
+    // 操作记录
+    operations = [];
+    get canUndo() {
+        return this.index > -1;
+    }
+    get canRedo() {
+        return this.index < this.operations.length - 1;
+    }
+    push(operation) {
+        this.index++;
+        this.operations[this.index] = operation;
+        // 将 operation 列表后面的内容清理掉
+        this.operations.length = this.index + 1;
+    }
+    undo() {
+        if (this.index < 0) {
+            return;
+        }
+        const result = this.operations[this.index];
+        this.index--;
+        return result;
+    }
+    redo() {
+        if (this.index >= this.operations.length - 1) {
+            return;
+        }
+        this.index++;
+        return this.operations[this.index];
+    }
+    clear() {
+        this.operations = [];
+        this.index = -1;
+    }
+}
+export class UndoRedo {
+    // 下标
+    index = -1;
+    // 操作记录
+    operations = [];
+    get canUndo() {
+        return this.index > -1;
+    }
+    get canRedo() {
+        return this.index < this.operations.length - 1;
+    }
+    // 存储变更前的数据
+    oldData;
+    push(operation) {
+        this.index++;
+        this.operations[this.index] = operation;
+        // 将 operation 列表后面的内容清理掉
+        this.operations.length = this.index + 1;
+    }
+    undo() {
+        if (this.index < 0) {
+            return;
+        }
+        const result = this.operations[this.index];
+        this.index--;
+        return result;
+    }
+    redo() {
+        if (this.index >= this.operations.length - 1) {
+            return;
+        }
+        this.index++;
+        return this.operations[this.index];
+    }
+    clear() {
+        this.operations = [];
+        this.index = -1;
+    }
+}

package/dist/shared/index.d.ts

@@ -1 +1,2 @@
 export * from './player';
+export * from './spec';

package/dist/shared/index.js

@@ -0,0 +1,2 @@
+export * from './player';
+export * from './spec';

package/dist/shared/player.d.ts

@@ -1,5 +1,5 @@
 import '@galacean/effects';
-export { spec, VFXItem, Player, math, Composition, type Region, EventEmitter, assertExist, SpriteComponent, TextComponent, Texture, generateGUID, version as PlayerVersion } from '@galacean/effects';
+export { VFXItem, Player, math, Composition, type Region, EventEmitter, assertExist, SpriteComponent, TextComponent, Texture, generateGUID, version as PlayerVersion } from '@galacean/effects';
 import '@galacean/effects-plugin-rich-text';
 export { RichTextComponent } from '@galacean/effects-plugin-rich-text';
 import '@galacean/effects-plugin-model';

package/dist/shared/player.js

@@ -0,0 +1,9 @@
+import '@galacean/effects';
+export { VFXItem, Player, math, Composition, EventEmitter, assertExist, SpriteComponent, TextComponent, Texture, generateGUID, version as PlayerVersion } from '@galacean/effects';
+import '@galacean/effects-plugin-rich-text';
+export { RichTextComponent } from '@galacean/effects-plugin-rich-text';
+import '@galacean/effects-plugin-model';
+import '@galacean/effects-plugin-multimedia';
+export { VideoComponent } from '@galacean/effects-plugin-multimedia';
+import '@galacean/effects-plugin-spine';
+import '@galacean/effects-plugin-ffd';

package/dist/shared/spec.d.ts

@@ -0,0 +1 @@
+export { spec } from '@galacean/effects';

package/dist/shared/spec.js

@@ -0,0 +1 @@
+export { spec } from '@galacean/effects';

package/dist/size-adapte/index.js

@@ -0,0 +1 @@
+export * from './size-adapt';

package/dist/size-adapte/size-adapt.js

@@ -0,0 +1,395 @@
+import { Box2, Matrix4, Vector2, Vector3 } from '../math';
+import { SDK } from '../sdk';
+import { Player, spec } from '../shared';
+import { clearPlayerAssets } from '../exporter/utils';
+import { SafeConstraint } from '../utils/types';
+/**
+ * @description 尺寸适配工具
+ */
+export class SizeAdapt {
+    /**
+     * @description 尺寸适配播放器
+     */
+    _player;
+    /**
+     * @description 尺寸播放器容器
+     */
+    _container;
+    /**
+     * @description 视图大小
+     */
+    size = [0, 0];
+    constructor() {
+        this._container = document.createElement('canvas');
+        this._player = new Player({
+            canvas: this._container,
+            manualRender: true,
+        });
+    }
+    async adjustment(scene, tick, originSize, viewSize, safeArea, direction) {
+        if (!SDK.config.sizeAdaptConfig.enabled) {
+            console.warn('Size adapt is not opened, use #SDK.setConfig() open this feature.');
+            return scene;
+        }
+        this._player ??= new Player({
+            canvas: this._container,
+            manualRender: true,
+        });
+        safeArea ??= [0, 0, 0, 0];
+        direction ??= originSize[0] < originSize[1] ? 'y' : 'x';
+        this.size = [...viewSize];
+        this._container.width = this.size[0];
+        this._container.height = this.size[1];
+        clearPlayerAssets(this._player);
+        this._player.resize();
+        const loadScene = JSON.parse(JSON.stringify(scene));
+        await this._player.loadScene(loadScene, {
+            reusable: true,
+            autoplay: false,
+        });
+        this._player.gotoAndStop(tick);
+        const composition = this._player.getCompositions()[0];
+        if (composition) {
+            const [viewWidth, viewHeight] = viewSize;
+            const originRatio = originSize[0] / originSize[1];
+            const viewRatio = viewWidth / viewHeight;
+            if (originRatio > viewRatio) {
+                this.keepDistribute(scene, composition, viewRatio / originRatio, viewSize);
+            }
+            const [safeTop, safeBottom, safeLeft, safeRight] = safeArea;
+            const width = viewWidth - safeLeft - safeRight;
+            const height = viewHeight - safeTop - safeBottom;
+            const translation = [(safeLeft - safeRight) / 2, (safeTop - safeBottom) / 2];
+            const originViewBox = new Box2().setFromCenterAndSize(new Vector2(viewWidth, viewHeight).divide(2), new Vector2(viewWidth, viewHeight));
+            const resultViewBox = new Box2().setFromCenterAndSize(new Vector2(viewWidth, viewHeight).divide(2).add(new Vector2(...translation)), new Vector2(width, height));
+            // 纵向吸附自适应规则
+            this.keepAdsorption('topAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+            this.keepAdsorption('bottomAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+            // 横向吸附自适应规则
+            this.keepAdsorption('leftAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+            this.keepAdsorption('rightAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+            // 中心自适应规则
+            this.keepAdsorption('centerAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+            this.keepDoubleAdsorption('bottomCenterAdsorption', scene, composition, translation, originViewBox, resultViewBox, direction);
+        }
+        return scene;
+    }
+    // 根据宽高比变化，保持物体垂直排布
+    keepDistribute(scene, composition, ratio, viewSize) {
+        const translateByPixel = (item, x, y) => {
+            const { z } = item.transform.getWorldPosition();
+            const { x: rx, y: ry } = composition.camera.getInverseVPRatio(z);
+            item.transform.translate(2 * x * rx / viewSize[0], -2 * y * ry / viewSize[1], 0);
+        };
+        const projectPoint = (point) => {
+            const vpMatrix = new Matrix4().copyFrom(composition.camera.getViewProjectionMatrix());
+            const viewPoint = new Vector2().copyFrom(point.applyMatrix(vpMatrix).toVector2()).toViewCoordinate(viewSize[0], viewSize[1]);
+            return viewPoint;
+        };
+        // 根据ratio以及当前的视图宽高模拟原视图中位置
+        ['topAdsorption', 'centerAdsorption', 'bottomAdsorption'].forEach((type) => {
+            //@ts-expect-error type to fix
+            const targetItems = composition.items.filter(item => item.name.split('-')[0]?.toLocaleUpperCase() === SafeConstraint[type] && !item.parentId);
+            targetItems.forEach(item => {
+                const childrenItems = composition.items.filter(i => i.parentId === item.getInstanceId());
+                const checkBoxItem = childrenItems.find(item => item.name === 'check-area');
+                const startCheckBox = checkBoxItem
+                    ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                    : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+                const startPosition = item.transform.position.clone();
+                const itemCenter = startCheckBox.getCenter();
+                const viewCenter = new Vector2(...viewSize.map(n => n / 2));
+                const currentDistance = itemCenter.y - viewCenter.y;
+                const resultDistance = currentDistance / ratio;
+                const shift = resultDistance - currentDistance;
+                translateByPixel(item, 0, shift);
+                item.transform.updateLocalMatrix();
+                const resultPosition = item.transform.position.clone();
+                const translationShift = resultPosition.subtract(startPosition).toArray();
+                this.transformSceneItem(scene, item.getInstanceId(), 'position', translationShift);
+            });
+        });
+    }
+    keepAdsorption(type, scene, composition, translation, originViewBox, resultViewBox, adsorptionDirection) {
+        const { x: originWidth, y: originHeight } = originViewBox.getSize();
+        const translateByPixel = (item, x, y) => {
+            const { z } = item.transform.getWorldPosition();
+            const { x: rx, y: ry } = composition.camera.getInverseVPRatio(z);
+            item.transform.translate(2 * x * rx / originWidth, -2 * y * ry / originHeight, 0);
+        };
+        const projectPoint = (point) => {
+            const vpMatrix = new Matrix4().copyFrom(composition.camera.getViewProjectionMatrix());
+            const viewPoint = new Vector2().copyFrom(point.applyMatrix(vpMatrix).toVector2()).toViewCoordinate(originWidth, originHeight);
+            return viewPoint;
+        };
+        const keyWord = SafeConstraint[type];
+        const targetItems = composition.items.filter(item => item.name.split('-')[0]?.toLocaleUpperCase() === keyWord && !item.parentId);
+        targetItems.forEach(item => {
+            const childrenItems = composition.items.filter(i => i.parentId === item.getInstanceId());
+            const checkBoxItem = childrenItems.find(item => item.name === 'check-area');
+            const startPosition = item.transform.position.clone();
+            const direction = ['leftAdsorption', 'rightAdsorption'].includes(type) ? 'x' : 'y';
+            const directionScale = ['leftAdsorption', 'topAdsorption'].includes(type) ? 1 : -1;
+            const constraint = ['leftAdsorption', 'topAdsorption'].includes(type) ? 'min' : 'max';
+            const ratioConstraint = ['leftAdsorption', 'topAdsorption'].includes(type) ? 'max' : 'min';
+            const ratioConstraintEnabled = item.name.split('-').length === 3;
+            const ratioConstraintValue = Number(item.name.split('-')[1]);
+            const ratioShift = new Vector2();
+            const scaleShift = [1, 1];
+            // 场景自适应规则 - 跟随出血区位移与缩放
+            const startCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            translateByPixel(item, ...translation);
+            const scaleDirection = adsorptionDirection === 'y' ? 'x' : 'y';
+            if (startCheckBox.getSize()[scaleDirection] > resultViewBox.getSize()[scaleDirection]) {
+                scaleShift[0] = resultViewBox.getSize()[scaleDirection] / startCheckBox.getSize()[scaleDirection];
+                scaleShift[1] = resultViewBox.getSize()[scaleDirection] / startCheckBox.getSize()[scaleDirection];
+                item.scale(...scaleShift, 1);
+            }
+            item.transform.updateLocalMatrix();
+            // 包含约束 - 确保元素位于安全区
+            const afterBaseCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            const constraintOffset = new Vector2();
+            if (!resultViewBox.containsBox(afterBaseCheckBox)) {
+                const { min: afterBaseCheckBoxMin, max: afterBaseCheckBoxMax } = afterBaseCheckBox;
+                const { min: resultViewBoxMin, max: resultViewBoxMax } = resultViewBox;
+                constraintOffset.x += afterBaseCheckBoxMin.x < resultViewBoxMin.x ? resultViewBoxMin.x - afterBaseCheckBoxMin.x : 0;
+                constraintOffset.x += afterBaseCheckBoxMax.x > resultViewBoxMax.x ? resultViewBoxMax.x - afterBaseCheckBoxMax.x : 0;
+                constraintOffset.y += afterBaseCheckBoxMin.y < resultViewBoxMin.y ? resultViewBoxMin.y - afterBaseCheckBoxMin.y : 0;
+                constraintOffset.y += afterBaseCheckBoxMax.y > resultViewBoxMax.y ? resultViewBoxMax.y - afterBaseCheckBoxMax.y : 0;
+                translateByPixel(item, ...constraintOffset.toArray());
+                item.transform.updateLocalMatrix();
+            }
+            // 比例约束 - 确保元素占比满足比例约束
+            const afterContainCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            if (!Number.isNaN(ratioConstraintValue) && ratioConstraintEnabled) {
+                if (type !== 'centerAdsorption') {
+                    const scaleConstraintDistance = Math.abs(afterContainCheckBox[ratioConstraint][direction] - resultViewBox[constraint][direction]);
+                    const scaleDistance = resultViewBox.getSize()[direction] * ratioConstraintValue;
+                    if (scaleConstraintDistance > scaleDistance) {
+                        ratioShift[direction] = (scaleDistance - scaleConstraintDistance) * directionScale;
+                        translateByPixel(item, ...ratioShift.toArray());
+                        item.transform.updateLocalMatrix();
+                    }
+                }
+                else {
+                    const size = afterContainCheckBox.getSize()[adsorptionDirection];
+                    const viewSize = resultViewBox.getSize()[adsorptionDirection];
+                    if (size / viewSize > ratioConstraintValue) {
+                        const ratioResultSize = viewSize * ratioConstraintValue;
+                        const ratioScaleShift = ratioResultSize / size;
+                        item.scale(ratioScaleShift, ratioScaleShift, 1);
+                        scaleShift[0] *= ratioScaleShift;
+                        scaleShift[1] *= ratioScaleShift;
+                    }
+                }
+            }
+            // 压板遮挡规则 - 确保元素不被压板遮挡
+            const currentCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            const topItems = composition.items.filter(item => item.name.split('-')[0]?.toLocaleUpperCase() === 'T' && !item.parentId);
+            const topBox = new Box2();
+            topItems.forEach(topItem => {
+                const topChildrenItems = composition.items.filter(i => i.parentId === topItem.getInstanceId());
+                const topCheckBoxItem = topChildrenItems.find(item => item.name === 'check-area');
+                const topCheckBox = topCheckBoxItem
+                    ? this.getViewBoxByHeadlessPlayerItem(topCheckBoxItem, [], projectPoint)
+                    : this.getViewBoxByHeadlessPlayerItem(topItem, topChildrenItems, projectPoint);
+                topBox.union(topCheckBox);
+            });
+            if (!topBox.isEmpty() && topBox.max.y > currentCheckBox.min.y) {
+                if (type === 'centerAdsorption') {
+                    const centerShift = topBox.max.y - currentCheckBox.min.y;
+                    translateByPixel(item, 0, centerShift);
+                    item.transform.updateLocalMatrix();
+                }
+                else if (['leftAdsorption', 'rightAdsorption'].includes(type)) {
+                    const sideBoxY = currentCheckBox.getSize().y;
+                    const noPlateY = resultViewBox.getSize().y - (topBox.max.y - resultViewBox.min.y);
+                    let sideShift = topBox.max.y - currentCheckBox.min.y;
+                    if (sideBoxY > noPlateY) {
+                        const sideScale = noPlateY / sideBoxY;
+                        scaleShift[0] *= sideScale;
+                        scaleShift[1] *= sideScale;
+                        item.scale(sideScale, sideScale, 1);
+                        item.transform.updateLocalMatrix();
+                        sideShift -= (sideBoxY - noPlateY) / 2;
+                    }
+                    translateByPixel(item, 0, sideShift);
+                    item.transform.updateLocalMatrix();
+                }
+            }
+            const resultPosition = item.transform.position.clone();
+            const translationShift = resultPosition.subtract(startPosition).toArray();
+            this.transformSceneItem(scene, item.getInstanceId(), 'position', translationShift);
+            this.transformSceneItem(scene, item.getInstanceId(), 'scale', scaleShift);
+        });
+    }
+    keepDoubleAdsorption(type, scene, composition, translation, originViewBox, resultViewBox, adsorptionDirection) {
+        const { x: originWidth, y: originHeight } = originViewBox.getSize();
+        const translateByPixel = (item, x, y) => {
+            const { z } = item.transform.getWorldPosition();
+            const { x: rx, y: ry } = composition.camera.getInverseVPRatio(z);
+            item.transform.translate(2 * x * rx / originWidth, -2 * y * ry / originHeight, 0);
+        };
+        const projectPoint = (point) => {
+            const vpMatrix = new Matrix4().copyFrom(composition.camera.getViewProjectionMatrix());
+            const viewPoint = new Vector2().copyFrom(point.applyMatrix(vpMatrix).toVector2()).toViewCoordinate(originWidth, originHeight);
+            return viewPoint;
+        };
+        const keyWord = SafeConstraint[type];
+        const targetItems = composition.items.filter(item => item.name.split('-')[0]?.toLocaleUpperCase() === keyWord && !item.parentId);
+        targetItems.forEach(item => {
+            const childrenItems = composition.items.filter(i => i.parentId === item.getInstanceId());
+            const checkBoxItem = childrenItems.find(item => item.name === 'check-area');
+            const startPosition = item.transform.position.clone();
+            const ratioConstraintEnabled = item.name.split('-').length === 3;
+            const ratioConstraintValue = Number(item.name.split('-')[1]);
+            const scaleShift = [1, 1];
+            const startCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            translateByPixel(item, ...translation);
+            const scaleDirection = adsorptionDirection === 'y' ? 'x' : 'y';
+            if (startCheckBox.getSize()[scaleDirection] > resultViewBox.getSize()[scaleDirection]) {
+                scaleShift[0] = resultViewBox.getSize()[scaleDirection] / startCheckBox.getSize()[scaleDirection];
+                scaleShift[1] = resultViewBox.getSize()[scaleDirection] / startCheckBox.getSize()[scaleDirection];
+                item.scale(...scaleShift, 1);
+            }
+            item.transform.updateLocalMatrix();
+            // 元素元素在包围盒内
+            const checkBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            if (!Number.isNaN(ratioConstraintValue) && ratioConstraintEnabled) {
+                const size = checkBox.getSize()[scaleDirection];
+                const viewSize = resultViewBox.getSize()[scaleDirection];
+                if (size / viewSize > ratioConstraintValue) {
+                    const ratioResultSize = viewSize * ratioConstraintValue;
+                    const ratioScaleShift = ratioResultSize / size;
+                    item.scale(ratioScaleShift, ratioScaleShift, 1);
+                    scaleShift[0] *= ratioScaleShift;
+                    scaleShift[1] *= ratioScaleShift;
+                }
+            }
+            // 强制吸底
+            const ratioCheckBox = checkBoxItem
+                ? this.getViewBoxByHeadlessPlayerItem(checkBoxItem, [], projectPoint)
+                : this.getViewBoxByHeadlessPlayerItem(item, childrenItems, projectPoint);
+            const constraintOffset = new Vector2();
+            if (!resultViewBox.containsBox(ratioCheckBox)) {
+                const { min: checkBoxMin, max: checkBoxMax } = ratioCheckBox;
+                const { min: viewBoxMin, max: viewBoxMax } = resultViewBox;
+                constraintOffset.x += checkBoxMin.x < viewBoxMin.x ? viewBoxMin.x - checkBoxMin.x : 0;
+                constraintOffset.x += checkBoxMax.x > viewBoxMax.x ? viewBoxMax.x - checkBoxMax.x : 0;
+                constraintOffset.y += checkBoxMin.y < viewBoxMin.y ? viewBoxMin.y - checkBoxMin.y : 0;
+                constraintOffset.y += checkBoxMax.y > viewBoxMax.y ? viewBoxMax.y - checkBoxMax.y : 0;
+                // 根据比例修改缩放值，可以让元素位置更加均衡，后续有需要的时候可加
+                // constraintOffset.multiply(scaleShift[0])
+                translateByPixel(item, ...constraintOffset.toArray());
+                item.transform.updateLocalMatrix();
+            }
+            const resultPosition = item.transform.position.clone();
+            const translationShift = resultPosition.subtract(startPosition).toArray();
+            this.transformSceneItem(scene, item.getInstanceId(), 'position', translationShift);
+            this.transformSceneItem(scene, item.getInstanceId(), 'scale', scaleShift);
+        });
+    }
+    getViewBoxByHeadlessPlayerItem(targetItem, childrenItem, projectPoint) {
+        const box = new Box2();
+        const { transform, composition } = targetItem;
+        switch (targetItem.type) {
+            case spec.ItemType.sprite:
+            case spec.ItemType.plugin:
+            case spec.ItemType.video:
+            case spec.ItemType.richtext:
+            case spec.ItemType.text:
+            case spec.ItemType.shape: {
+                transform.setValid(true);
+                transform.updateLocalMatrix();
+                const { size } = transform;
+                const compositionMatrix = new Matrix4().copyFrom(composition?.transform.getWorldMatrix() ?? new Matrix4()).invert();
+                const itemWorldMatrix = compositionMatrix.multiply(transform.getWorldMatrix());
+                const { x, y } = size.clone().divide(2);
+                const corner1 = new Vector3(x, y, 0).applyMatrix(itemWorldMatrix);
+                const corner2 = new Vector3(x, -y, 0).applyMatrix(itemWorldMatrix);
+                const corner3 = new Vector3(-x, -y, 0).applyMatrix(itemWorldMatrix);
+                const corner4 = new Vector3(-x, y, 0).applyMatrix(itemWorldMatrix);
+                const viewCorner1 = projectPoint(corner1).round(2);
+                const viewCorner2 = projectPoint(corner2).round(2);
+                const viewCorner3 = projectPoint(corner3).round(2);
+                const viewCorner4 = projectPoint(corner4).round(2);
+                box.setFromVec2Array([viewCorner1, viewCorner2, viewCorner3, viewCorner4]);
+                const childBoxes = childrenItem?.map(item => {
+                    const childItems = composition?.items.filter(i => i.parentId === item.getInstanceId()) ?? [];
+                    const childBox = this.getViewBoxByHeadlessPlayerItem(item, childItems, projectPoint);
+                    return childBox;
+                });
+                if (childBoxes) {
+                    childBoxes.map(b => box.union(b));
+                }
+                break;
+            }
+            case spec.ItemType.null: {
+                const childBoxes = childrenItem?.map(item => {
+                    const childItems = composition?.items.filter(i => i.parentId === item.getInstanceId()) ?? [];
+                    const childBox = this.getViewBoxByHeadlessPlayerItem(item, childItems, projectPoint);
+                    return childBox;
+                });
+                if (childBoxes) {
+                    childBoxes.map(b => box.union(b));
+                }
+                break;
+            }
+            default: {
+                break;
+            }
+        }
+        return box;
+    }
+    transformSceneItem(scene, itemId, propertyName, propertyValue) {
+        const item = scene.items.find(i => i.id === itemId);
+        switch (propertyName) {
+            case 'position': {
+                const value = propertyValue;
+                if (Array.isArray(propertyValue) && value.length === 3) {
+                    if (item?.transform) {
+                        item.transform.position.x += value[0];
+                        item.transform.position.y += value[1];
+                        item.transform.position.z += value[2];
+                    }
+                }
+                break;
+            }
+            case 'rotation': {
+                if (Array.isArray(propertyValue) && propertyValue.length === 3) {
+                    const value = propertyValue;
+                    if (item?.transform) {
+                        item.transform.eulerHint.x += value[0];
+                        item.transform.eulerHint.y += value[1];
+                        item.transform.eulerHint.z += value[2];
+                    }
+                }
+                break;
+            }
+            case 'scale': {
+                if (Array.isArray(propertyValue) && propertyValue.length === 2) {
+                    if (item?.transform) {
+                        item.transform.scale.x *= propertyValue[0];
+                        item.transform.scale.y *= propertyValue[1];
+                    }
+                }
+                break;
+            }
+        }
+    }
+    dispose() {
+        this._player?.dispose();
+    }
+}

package/dist/types.d.ts

@@ -1,9 +1,13 @@
-import type { spec } from './shared';
+/**
+ * 只导出类型和枚举
+ */
+import type { spec } from './shared/spec';
 import { SizeAdaptDirection } from './size-adapte';
 import type { ExportMediaItemOptions } from './exporter';
 import { SDKItemType } from './sdk-item/types';
 import { SDKItem } from './sdk-item';
 import { GlobalLayoutMode } from './utils';
+export { SDKItemType };
 export type BaseItemProperty = {
     position: [number, number];
     rotation: [number, number, number];

package/dist/types.js

@@ -0,0 +1,17 @@
+import { SDKItemType } from './sdk-item/types';
+export { SDKItemType };
+/**
+ * @description Frame 画板元素布局模式
+ */
+export var FrameLayoutMode;
+(function (FrameLayoutMode) {
+    FrameLayoutMode["AUTO"] = "auto";
+    FrameLayoutMode["FREE"] = "free";
+})(FrameLayoutMode || (FrameLayoutMode = {}));
+export var ItemOrderAction;
+(function (ItemOrderAction) {
+    ItemOrderAction[ItemOrderAction["BringToFront"] = 0] = "BringToFront";
+    ItemOrderAction[ItemOrderAction["SendToBack"] = 1] = "SendToBack";
+    ItemOrderAction[ItemOrderAction["BringForward"] = 2] = "BringForward";
+    ItemOrderAction[ItemOrderAction["SendBackward"] = 3] = "SendBackward";
+})(ItemOrderAction || (ItemOrderAction = {}));