@galacean/effects-plugin-model 0.0.1-alpha.0

package/README.md

@@ -0,0 +1,26 @@
+# Galacean Effects Model Plugin
+
+## 本地开发
+
+### 开始开发
+
+``` bash
+# demo & test
+pnpm --filter @galacean/effects-plugin-model dev
+# demo & test (legacy)
+pnpm --filter @galacean/effects-plugin-model preview
+```
+
+> 浏览器打开：http://localhost:8081/demo/index.html
+
+##### WebGL1 环境
+
+> 浏览器打开：http://localhost:8081/demo/index.html?webgl=1
+
+### 单测
+
+``` bash
+# 同上
+```
+
+> 浏览器打开：http://localhost:8081/test/index.html

package/dist/gesture/controller.d.ts

@@ -0,0 +1,95 @@
+/**
+ * 鼠标和键盘控制的封装，主要用于Demo测试。
+ * 不可以打包导出，因为有移动端触控的第三方依赖
+ */
+import type { Composition } from '@galacean/effects';
+import type { CameraGestureHandler } from './protocol';
+import 'hammerjs';
+export declare enum MouseButtonType {
+    left = 1,
+    middle = 4,
+    right = 2
+}
+export declare enum InputActionType {
+    none = 0,
+    moveXYPlane = 1,
+    moveZAxis = 2,
+    rotateCamera = 3,
+    rotatePoint = 4
+}
+export interface InputControllerOptions {
+    cameraID: string;
+    sceneRadius: number;
+    moveSpeed?: number;
+    rotateSpeed?: number;
+    comp: Composition;
+    canvas: HTMLCanvasElement;
+}
+/**
+ * 鼠标和键盘输入控制器
+ */
+export declare class InputController {
+    cameraID: string;
+    sceneRadius: number;
+    moveSpeed: number;
+    rotateSpeed: number;
+    comp?: Composition;
+    canvas?: HTMLCanvasElement;
+    gesture?: CameraGestureHandler;
+    hammer?: HammerManager;
+    keyDownListener?: (e: KeyboardEvent) => any;
+    mouseUpListener?: (e: MouseEvent) => any;
+    mouseDownListener?: (e: MouseEvent) => any;
+    mouseMoveListener?: (e: MouseEvent) => any;
+    mouseLeaveListener?: (e: MouseEvent) => any;
+    mouseWheelListener?: (e: WheelEvent) => any;
+    isMouseDown: boolean;
+    isMoveBegin: boolean;
+    currentAction: InputActionType;
+    /**
+     * 相机控制事件的回调，包括开始、持续和结束三种事件
+     */
+    private beginEventCallback?;
+    private moveEventCallback?;
+    private endEventCallback?;
+    initial(options: InputControllerOptions): void;
+    setBeginEventCallback(cb: (eventName: string) => any): void;
+    setMoveEventCallback(cb: (eventName: string) => any): void;
+    setEndEventCallback(cb: (eventName: string) => any): void;
+    /**
+     * 注册鼠标回调事件，只有在PC上才会注册，手机上不会注册
+     *
+     * @param owner 输入控制器对象
+     */
+    private registerMouseEvent;
+    private registerKeyboardEvent;
+    /**
+     * 注册触控回调事件，只在手机上才会注册，PC上不会注册
+     *
+     * @param owner 输入控制器对象
+     */
+    private registerTouchEvent;
+    /**
+     * 相机开始事件的回调
+     *
+     * @param eventName 事件名称
+     */
+    private launchBeginEventCallback;
+    /**
+     * 相机持续事件的回调
+     *
+     * @param eventName 事件名称
+     */
+    private launchMoveEventCallback;
+    /**
+     * 相机结束事件的回调
+     *
+     * @param eventName 事件名称
+     */
+    private launchEndEventCallback;
+    dispose(): void;
+    getMouseMoveSpeed(): number;
+    getKeyMoveSpeed(): number;
+    getRotateSpeed(): number;
+    getWheelMoveSpeed(): number;
+}

package/dist/gesture/index.d.ts

@@ -0,0 +1,38 @@
+import type { Composition, CameraOptions, spec } from '@galacean/effects';
+import { Transform } from '@galacean/effects';
+import type { CameraGestureHandler, CameraKeyEvent } from './protocol';
+import { CameraGestureType } from './protocol';
+import type { ModelVFXItem } from '../plugin/model-vfx-item';
+export declare class CameraGestureHandlerImp implements CameraGestureHandler {
+    private composition;
+    private cameraTransform;
+    private cameraCoordiante;
+    private startParams;
+    constructor(composition: Composition);
+    getItem(): ModelVFXItem | undefined;
+    getCurrentTarget(): string;
+    getCurrentType(): CameraGestureType;
+    onKeyEvent(event: CameraKeyEvent): CameraOptions;
+    onXYMoveBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    onXYMoving(x: number, y: number, speed?: number): CameraOptions;
+    onXYMoveEnd(): void;
+    onZMoveBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    onZMoving(x: number, y: number, speed: number): CameraOptions;
+    onZMoveEnd(): void;
+    onRotateBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    onRotating(x: number, y: number, speed?: number): CameraOptions;
+    onRotateEnd(): void;
+    onRotatePointBegin(x: number, y: number, width: number, height: number, point: spec.vec3, cameraID: string): CameraOptions;
+    onRotatingPoint(x: number, y: number, speed?: number): CameraOptions;
+    onRotatePointEnd(): void;
+    moveTo(cameraID: string, position: spec.vec3): void;
+    rotateTo(cameraID: string, quat: spec.vec4): void;
+    onFocusPoint(cameraID: string, point: spec.vec3, distance?: number): void;
+    getCameraTransform(): Transform;
+    private initKeyEvent;
+    private startGesture;
+    private moveGesture;
+    private endGesture;
+    private updateCameraTransform;
+}
+export * from './protocol';

package/dist/gesture/protocol.d.ts

@@ -0,0 +1,143 @@
+import type { CameraOptions, spec } from '@galacean/effects';
+export interface CameraGestureHandler {
+    getCurrentTarget(): string;
+    getCurrentType(): CameraGestureType;
+    /**
+     * 通过按键事件对相机进行平移
+     * @param event - 键盘事件信息
+     * @returns 当前的相机参数
+     */
+    onKeyEvent(event: CameraKeyEvent): CameraOptions;
+    /**
+     * 在 XY 方向上平移相机开始函数，在鼠标按下时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param width - 当前画布的宽度
+     * @param height - 当前画布的高度
+     * @param cameraID - 要控制的相机 item id
+     * @returns 当前的相机参数
+     */
+    onXYMoveBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    /**
+     * 在 XY 方向上平移相机开始函数，在鼠标按下拖拽时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param speed - 移动速度，默认是 0.015
+     * @returns 更新后的相机参数
+     */
+    onXYMoving(x: number, y: number, speed?: number): CameraOptions;
+    /**
+     * 结束在 XY 方向上平移相机
+     */
+    onXYMoveEnd(): void;
+    /**
+     * 在 Z 方向上平移相机开始函数，类似缩放 3D 模型，在鼠标按下时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param width - 当前画布的宽度
+     * @param height - 当前画布的高度
+     * @param cameraID - 要控制的相机 item id
+     * @returns 当前的相机参数
+     */
+    onZMoveBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    /**
+     * 在 Z 方向上平移相机开始函数，类似缩放 3D 模型，在鼠标按下拖拽时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param speed - 移动速度，默认是 0.015
+     * @returns 更新后的相机参数
+     */
+    onZMoving(x: number, y: number, speed?: number): CameraOptions;
+    /**
+     * 结束在 Z 方向上平移相机
+     */
+    onZMoveEnd(): void;
+    /**
+     * 相机的自旋转，就是镜头漫游的效果，在鼠标按下时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param width - 当前画布的宽度
+     * @param height - 当前画布的高度
+     * @param cameraID - 要控制的相机 item id
+     * @returns 当前的相机参数
+     */
+    onRotateBegin(x: number, y: number, width: number, height: number, cameraID: string): CameraOptions;
+    /**
+     * 相机的自旋转，在鼠标按下拖拽时调用
+     * @param x - 鼠标在 x坐标上的值
+     * @param y - 鼠标在y坐标上的值
+     * @param speed - 移动速度，默认是 1
+     * @returns 更新后的相机参数
+     */
+    onRotating(x: number, y: number, speed?: number): CameraOptions;
+    /**
+     * 相机的自旋转
+     */
+    onRotateEnd(): void;
+    /**
+     * 相机绕某个点旋转，就是拖拽模型的效果，在鼠标按下时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param width - 当前画布的宽度
+     * @param height - 当前画布的高度
+     * @param cameraID - 要控制的相机 item id
+     * @returns 当前的相机参数
+     */
+    onRotatePointBegin(x: number, y: number, width: number, height: number, point: spec.vec3, cameraID: string): CameraOptions;
+    /**
+     * 相机绕某个点旋转，在鼠标按下拖拽时调用
+     * @param x - 鼠标在 x 坐标上的值
+     * @param y - 鼠标在 y 坐标上的值
+     * @param speed - 移动速度，默认是 1
+     * @returns 更新后的相机参数
+     */
+    onRotatingPoint(x: number, y: number, speed?: number): CameraOptions;
+    /**
+     * 相机绕某个点旋转
+     */
+    onRotatePointEnd(): void;
+    /**
+     * 相机移动到指定点
+     * @param cameraID -相机 ID
+     * @param position - 指定位置
+     */
+    moveTo(cameraID: string, position: spec.vec3): void;
+    /**
+     * 相机旋转到指定方向
+     * @param cameraID - 相机ID
+     * @param quat - 指定旋转
+     */
+    rotateTo(cameraID: string, quat: spec.vec4): void;
+    /**
+     * 相机对中心点进行聚焦，先从当前位置 LookAt 过去，然后移到距离中心点给定距离（默认是 5）的位置
+     * @param cameraID - 相机 ID
+     * @param point - 聚焦的中心点
+     * @param distance - 聚焦的距离，默认是 5
+     */
+    onFocusPoint(cameraID: string, point: spec.vec3, distance?: number): void;
+}
+export declare enum CameraGestureType {
+    none = 0,
+    translate = 1,
+    rotate_focus = 2,
+    rotate_self = 3,
+    scale = 4
+}
+export interface CameraGestureHandlerParams {
+    type: CameraGestureType;
+    mouseEvent: boolean;
+    clientX: number;
+    clientY: number;
+    clientWidth: number;
+    clientHeight: number;
+    target: string;
+    focusPoint?: spec.vec3;
+    speed?: number;
+}
+export interface CameraKeyEvent {
+    cameraID: string;
+    xAxis?: -1 | 1;
+    yAxis?: -1 | 1;
+    zAxis?: -1 | 1;
+    speed?: number;
+}

package/dist/gltf/index.d.ts

@@ -0,0 +1,3 @@
+export * from './loader-helper';
+export * from './loader-impl';
+export * from './protocol';

package/dist/gltf/loader-ext.d.ts

@@ -0,0 +1,53 @@
+import type { GLTFResources } from '@vvfx/resource-detection';
+import type { Player, spec } from '@galacean/effects';
+import type { LoadSceneOptions, LoadSceneResult } from './protocol';
+import { LoaderImpl } from './loader-impl';
+export declare class LoaderImplEx extends LoaderImpl {
+    loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
+    /**
+     * 检查序列化和反序列逻辑，排查渲染场景中渲染正常和编辑器中渲染错误的问题。
+     * 针对Image、Texture、Material、Mesh、Scene、Animation和IBL的检查。
+     *
+     * @param res 加载的GLTF场景资源
+     */
+    checkSerializer(res: GLTFResources): Promise<void>;
+}
+export interface LoadGLTFSceneOptions {
+    url: string;
+    player: Player;
+    playAnimation?: number | string;
+    camera?: {
+        position?: spec.vec3;
+        rotation?: spec.vec3;
+    };
+}
+export declare function loadGLTFScene(options: LoadGLTFSceneOptions): Promise<{
+    compositionId: number;
+    requires: never[];
+    compositions: {
+        name: string;
+        id: number;
+        duration: number;
+        endBehavior: number;
+        camera: {
+            fov: number;
+            far: number;
+            near: number;
+            position: number[];
+            clipMode: number;
+        };
+        items: spec.BaseItem[];
+        meta: {
+            previewSize: number[];
+        };
+    }[];
+    gltf: never[];
+    images: never[];
+    version: string;
+    shapes: never[];
+    plugins: string[];
+    type: string;
+    _imgs: {
+        '1': never[];
+    };
+}>;

package/dist/gltf/loader-helper.d.ts

@@ -0,0 +1,18 @@
+import type { spec } from '@galacean/effects';
+import type { BaseTransform as Transform } from '../index';
+import { Vector3, Matrix4, Quaternion, Euler } from '../math';
+export declare class LoaderHelper {
+    static getTransformFromMat4(mat: Matrix4): Transform;
+    static getMarsTransformFromMat4(mat: Matrix4): Transform;
+    static getTransformFromTranslation(t: Vector3): Transform;
+    static getTransformFromDirection(d: Vector3): Transform;
+    static getMarsTransformFromDirection(d: Vector3): Transform;
+    static getTransformFromTransDir(t: Vector3, d: Vector3): Transform;
+    static getMarsTransformFromTransDir(t: Vector3, d: Vector3): Transform;
+    static getEulerFromQuat(q: Quaternion): [number, number, number];
+    static getQuatFromEuler(e: Euler): [number, number, number, number];
+    static toPlayerColor3(color: spec.vec3): spec.vec3;
+    static toPlayerColor4(color: spec.vec4): spec.vec4;
+    static scaleTo255(val: number): number;
+    static scaleTo1(val: number): number;
+}

package/dist/gltf/loader-impl.d.ts

@@ -0,0 +1,84 @@
+import type { Texture, Engine } from '@galacean/effects';
+import { spec, Geometry } from '@galacean/effects';
+import type { Loader, LoaderOptions, SkyboxType, LoadSceneOptions, LoadSceneResult } from './protocol';
+import type { MarsAnimationOptions, MarsCameraOptions, MarsMaterialOptions, MarsLightOptions, MarsSkyboxOptions, MarsTreeOptions } from '../index';
+import type { GLTFImage, GLTFMaterial, GLTFTexture, GLTFScene, GLTFPrimitive, GLTFTextureInfo, GLTFLight, GLTFCamera, GLTFAnimation, GLTFImageBasedLight } from '@vvfx/resource-detection';
+import { PSkyboxType } from '../runtime/skybox';
+import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
+export declare function getDefaultMarsGLTFLoader(engine: Engine, options?: LoaderOptions): Loader;
+export declare function setDefaultMarsGLTFLoader(loader: Loader): void;
+export declare class LoaderImpl implements Loader {
+    private _sceneOptions;
+    private _loaderOptions;
+    private _gltfScene;
+    private _gltfSkins;
+    private _gltfMeshs;
+    private _gltfLights;
+    private _gltfCameras;
+    private _gltfImages;
+    private _gltfTextures;
+    private _gltfMaterials;
+    private _gltfAnimations;
+    private _gltfImageBasedLights;
+    private _textureManager?;
+    private _skyboxOptions?;
+    engine: Engine;
+    initial(engine: Engine, options?: LoaderOptions): void;
+    processLight(lights: GLTFLight[], fromGLTFToMars: boolean): void;
+    processCamera(cameras: GLTFCamera[], fromGLTFToMars: boolean): void;
+    processMaterial(materials: GLTFMaterial[], fromGLTFToMars: boolean): void;
+    createTreeOptions(scene: GLTFScene): MarsTreeOptions;
+    createAnimations(animations: GLTFAnimation[]): MarsAnimationOptions[];
+    createGeometry(primitive: GLTFPrimitive, hasSkinAnim: boolean): Geometry;
+    createMaterial(material: GLTFMaterial): MarsMaterialOptions;
+    createTexture2D(image: GLTFImage, texture: GLTFTexture, isBaseColor: boolean): Promise<Texture>;
+    createTextureCube(cubeImages: CubeImage[], level0Size?: number): Promise<Texture>;
+    createSkybox(ibl: GLTFImageBasedLight): Promise<MarsSkyboxOptions>;
+    createDefaultSkybox(typeName: SkyboxType): Promise<MarsSkyboxOptions>;
+    scaleColorVal(val: number, fromGLTFToMars: boolean): number;
+    scaleColorVec(vec: number[], fromGLTFToMars: boolean): number[];
+    loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
+    private _preprocess;
+    tryAddTexture2D(matIndex: number, texInfo: GLTFTextureInfo | undefined, isBaseColor: boolean): Promise<void> | undefined;
+    getTexture2D(matIndex: number, texInfo: GLTFTextureInfo | undefined, isBaseColor: boolean, noWarning?: boolean): Texture | undefined;
+    private _gltfData2PlayerData;
+    private _createItemTree;
+    private _createItemMesh;
+    private _createItemLight;
+    private _createItemCamera;
+    private _createItemSkybox;
+    private _computeSceneAABB;
+    createLightOptions(light: GLTFLight): MarsLightOptions;
+    createCameraOptions(camera: GLTFCamera): MarsCameraOptions | undefined;
+    private _clear;
+    /**
+     * 按照传入的动画播放参数，计算需要播放的动画索引
+     *
+     * @param treeOptions 节点树属性，需要初始化animations列表。
+     * @returns 返回计算的动画索引，-1表示没有动画需要播放，-88888888表示播放所有动画。
+     */
+    getPlayAnimationIndex(treeOptions: MarsTreeOptions): number;
+    isPlayAnimation(): boolean;
+    isPlayAllAnimation(): boolean;
+    getRemarkString(): string;
+    isTiny3dMode(): boolean;
+    getTextureManager(): TextureManager;
+    getItemDuration(): number;
+    getItemEndBehavior(): spec.ItemEndBehavior;
+    getSkyboxType(): PSkyboxType | undefined;
+    isSkyboxVis(): boolean;
+    ignoreSkybox(): boolean;
+    isEnvironmentTest(): boolean;
+}
+declare class TextureManager {
+    private _owner;
+    private _gltfImages;
+    private _gltfTextures;
+    private _textureMap;
+    constructor(owner: LoaderImpl);
+    initial(gltfImages: GLTFImage[], gltfTextures: GLTFTexture[]): void;
+    dispose(): void;
+    addTexture(matIndex: number, texIndex: number, tex: Texture, isBaseColor: boolean): void;
+    getTexture(matIndex: number, texIndex: number, isBaseColor: boolean): Texture | undefined;
+}
+export {};

package/dist/gltf/protocol.d.ts

@@ -0,0 +1,90 @@
+import type { GLTFMaterial, GLTFPrimitive, GLTFLight, GLTFScene, GLTFImage, GLTFTexture, GLTFCamera, GLTFAnimation, GLTFImageBasedLight } from '@vvfx/resource-detection';
+import type { CubeImage } from '@vvfx/resource-detection/dist/src/gltf-tools/gltf-image-based-light';
+import type { GLTFResources } from '@vvfx/resource-detection/dist/src/gltf-tools';
+import type { spec, Renderer, Texture, Geometry } from '@galacean/effects';
+import type { MarsAnimationOptions, MarsMaterialOptions, MarsSkyboxOptions, MarsTreeOptions, MarsItemModelBase } from '../index';
+/**
+ * glTF 场景文件加载选项，主要用于 Demo 测试或外部测试调用
+ */
+export interface LoadSceneOptions {
+    gltf: {
+        /**
+         * 场景数据的备注，可能是url或者二进制数组
+         */
+        remark?: string | Uint8Array;
+        /**
+         * 场景资源，可能是url、二进制数组或者加载后的资源
+         */
+        resource: string | Uint8Array | GLTFResources;
+        /**
+         * 兼容模式，目前只支持tiny3d
+         */
+        compatibleMode?: 'gltf' | 'tiny3d' | 'oasis';
+        /**
+         * 检查ResourceDetection序列化和反序列逻辑
+         */
+        checkSerializer?: boolean;
+        /**
+         * 天空盒类型，目前只支持'NFT'和'FARM'
+         */
+        skyboxType?: string;
+        /**
+         * 是否显示背景天空盒
+         */
+        skyboxVis?: boolean;
+        /**
+         * 是否忽略自带天空盒
+         */
+        ignoreSkybox?: boolean;
+    };
+    mars: {
+        /**
+         * Mars Renderer
+         */
+        renderer?: Renderer;
+        /**
+         * 播放时间，单位秒
+         */
+        duration?: number;
+        /**
+         * 结束行为
+         */
+        endBehavior?: spec.ItemEndBehavior;
+        /**
+         * 播放动画索引或名称
+         */
+        playAnimation?: number | string;
+        /**
+         * 是否播放全部动画
+         */
+        playAllAnimation?: boolean;
+    };
+}
+export interface LoadSceneResult {
+    source: string;
+    items: MarsItemModelBase[];
+    sceneAABB: {
+        min: spec.vec3;
+        max: spec.vec3;
+    };
+}
+export interface LoaderOptions {
+    compatibleMode?: 'gltf' | 'tiny3d' | 'oasis';
+}
+export type SkyboxType = 'NFT' | 'FARM';
+export interface Loader {
+    loadScene(options: LoadSceneOptions): Promise<LoadSceneResult>;
+    processLight(lights: GLTFLight[], fromGLTFToMars: boolean): void;
+    processCamera(cameras: GLTFCamera[], fromGLTFToMars: boolean): void;
+    processMaterial(materials: GLTFMaterial[], fromGLTFToMars: boolean): void;
+    createTreeOptions(scene: GLTFScene): MarsTreeOptions;
+    createAnimations(animations: GLTFAnimation[]): MarsAnimationOptions[];
+    createGeometry(primitive: GLTFPrimitive, hasSkinAnim: boolean): Geometry;
+    createMaterial(material: GLTFMaterial): MarsMaterialOptions;
+    createTexture2D(images: GLTFImage, textures: GLTFTexture, isBaseColor: boolean): Promise<Texture>;
+    createTextureCube(cubeImages: CubeImage[], level0Size?: number): Promise<Texture>;
+    createSkybox(ibl: GLTFImageBasedLight): Promise<MarsSkyboxOptions>;
+    createDefaultSkybox(typeName: SkyboxType): Promise<MarsSkyboxOptions>;
+    scaleColorVal(val: number, fromGLTFToMars: boolean): number;
+    scaleColorVec(vec: number[], fromGLTFToMars: boolean): number[];
+}

package/dist/helper/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../gltf/loader-ext';
+export * from '../gesture/controller';

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+import type { spec } from '@galacean/effects';
+export declare const version: string;
+export type BaseTransform = spec.BaseItemTransform;
+export type MarsItemModelBase = spec.BaseItem;
+export type MarsItemCamera = spec.ModelCameraItem;
+export type MarsItemLight = spec.ModelLightItem;
+export type MarsTextureTransform = spec.ModelTextureTransform;
+export type MarsItemBoundingBox = spec.ModelItemBoundingBox;
+export type MarsItemBoundingSphere = spec.ModelItemBoundingSphere;
+export type MarsItemBounding = spec.ModelItemBounding;
+export type MarsCameraOptions = spec.ModelCameraOptions;
+export type MarsLightBaseOptions = spec.ModelLightBaseOptions;
+export type MarsLightPointOptions = spec.ModelLightPointOptions;
+export type MarsLightSpotOptions = spec.ModelLightSpotOptions;
+export type MarsLightDirOptions = spec.ModelLightDirOptions;
+export type MarsAmbientOptions = spec.ModelAmbientLightOptions;
+export type MarsLightOptions = spec.ModelLightOptions;
+export type MarsItemMesh = spec.ModelMeshItem<'studio'>;
+export type MarsItemSkybox = spec.ModelSkyboxItem<'studio'>;
+export type MarsItemTree = spec.ModelTreeItem<'studio'>;
+export type MarsMeshOptions = spec.ModelMeshOptions<'studio'>;
+export type MarsSkinOptions = spec.SkinOptions<'studio'>;
+export type MarsPrimitiveOptions = spec.PrimitiveOptions<'studio'>;
+export type MarsMaterialUnlitOptions = spec.MaterialUnlitOptions<'studio'>;
+export type MarsMaterialPBROptions = spec.MaterialPBROptions<'studio'>;
+export type MarsMaterialHariOptions = spec.MaterialHairOptions<'studio'>;
+export type MarsMaterialOptions = spec.MaterialOptions<'studio'>;
+export type MarsSkyboxOptions = spec.SkyboxOptions<'studio'>;
+export type MarsTreeOptions = spec.ModelTreeOptions<'studio'>;
+export type MarsTreeContent = spec.ModelTreeContent<'studio'>;
+export type MarsAnimTrackOptions = spec.ModelAnimTrackOptions<'studio'>;
+export type MarsAnimationOptions = spec.ModelAnimationOptions<'studio'>;
+export * from './gesture';
+export * from './gltf';
+export * from './math';
+export * from './plugin';
+export * from './runtime';
+export * from './utility';