Complete Cocos Creator port with level bundles, themes, and tooling.

Adds level prefabs, theme assets, audio, extensions, and deployment scripts for the Unity WebGL migration.

Co-authored-by: Cursor <cursoragent@cursor.com>

extensions/plugin-import-2x/dist/convertor/anim.js

@@ -0,0 +1,302 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnimImporter = void 0;
+const base_1 = require("../common/base");
+const AnimationClip_1 = require("../components/AnimationClip");
+class AnimImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'anim';
+    }
+    // 合并 commonTarget
+    mergersCommonTarget(key, curve, commonTargets, pathKey) {
+        const commonTarget = {
+            modifiers: [],
+        };
+        pathKey && commonTarget.modifiers.push(pathKey);
+        if (key === 'x' || key === 'y' || key === 'z') {
+            commonTarget.modifiers.push('position');
+            const idx = commonTargets.findIndex((target) => {
+                return JSON.stringify(target.modifiers) === JSON.stringify(commonTarget.modifiers);
+            });
+            if (idx === -1) {
+                curve.commonTarget = commonTargets.length;
+                commonTargets.push(commonTarget);
+            }
+            else {
+                curve.commonTarget = idx;
+            }
+            curve.modifiers.push(this.getModifier(key));
+        }
+        else if (key === 'scaleX' || key === 'scaleY' || key === 'scaleZ') {
+            commonTarget.modifiers.push('scale');
+            const idx = commonTargets.findIndex((target) => {
+                return JSON.stringify(target.modifiers) === JSON.stringify(commonTarget.modifiers);
+            });
+            if (idx === -1) {
+                curve.commonTarget = commonTargets.length;
+                commonTargets.push(commonTarget);
+            }
+            else {
+                curve.commonTarget = idx;
+            }
+            curve.modifiers.push(this.getModifier(key));
+        }
+        else {
+            pathKey && curve.modifiers.push(pathKey);
+            curve.modifiers.push(this.getModifier(key));
+        }
+    }
+    // 转换 Modifier
+    getModifier(key) {
+        if (key === 'angle' || key === 'rotation') {
+            return 'eulerAngles';
+        }
+        else if (key === 'scaleX') {
+            return 'x';
+        }
+        else if (key === 'scaleY') {
+            return 'y';
+        }
+        else if (key === 'scaleZ') {
+            return 'z';
+        }
+        else if (key === 'top' || key === 'bottom' ||
+            key === 'left' || key === 'right' ||
+            key === 'horizontalCenter' ||
+            key === 'verticalCenter') {
+            return 'editor' + key.substring(0, 1).toLocaleUpperCase() + key.substring(key.length, 1);
+        }
+        return key;
+    }
+    // 转换 value 数值
+    getValue(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (key === 'angle' || key === 'rotation') {
+                return {
+                    __type__: "cc.Vec3",
+                    x: 0,
+                    y: 0,
+                    z: value !== undefined ? value : 0,
+                };
+            }
+            else if (key === 'scale') {
+                return {
+                    __type__: "cc.Vec3",
+                    x: value.x !== undefined ? value.x : 1,
+                    y: value.y !== undefined ? value.y : 1,
+                    z: value.z !== undefined ? value.z : 1,
+                };
+            }
+            else if (key === 'position') {
+                return {
+                    __type__: "cc.Vec3",
+                    x: value[0] !== undefined ? value[0] : 0,
+                    y: value[1] !== undefined ? value[1] : 0,
+                    z: 0,
+                };
+            }
+            if (value && value.__uuid__) {
+                if (key === 'spriteFrame' || key === 'texture') {
+                    value = yield base_1.ImporterBase.getUuid(value.__uuid__, key);
+                }
+                else {
+                    value = yield base_1.ImporterBase.getUuid(value.__uuid__);
+                }
+                return {
+                    __uuid__: value
+                };
+            }
+            return value;
+        });
+    }
+    getPropsForCurveData(props, animationClipOrArray, pathKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const animationClip = Array.isArray(animationClipOrArray) ? animationClipOrArray[0] : animationClipOrArray;
+            for (const key in props) {
+                const prop = props[key];
+                const frames = [];
+                const values = [];
+                const curve = {
+                    modifiers: [],
+                    data: {
+                        keys: animationClip._keys.length,
+                        values: values,
+                        easingMethods: {},
+                    },
+                };
+                if (key === 'opacity') {
+                    const component = {
+                        __type__: "cc.animation.ComponentPath",
+                        component: 'cc.UIOpacity',
+                    };
+                    pathKey && curve.modifiers.push(pathKey);
+                    curve.modifiers.push({
+                        __id__: animationClipOrArray.length,
+                    });
+                    curve.modifiers.push(this.getModifier(key));
+                    animationClipOrArray.push(component);
+                }
+                else if (key === 'width' || key === 'height') {
+                    const component = {
+                        __type__: "cc.animation.ComponentPath",
+                        component: 'cc.UITransform',
+                    };
+                    let compIdx = animationClipOrArray.findIndex((item) => {
+                        return item.__type__ === component.__type__ && item.component === component.component;
+                    });
+                    if (compIdx === -1) {
+                        compIdx = animationClipOrArray.length;
+                        animationClipOrArray.push(component);
+                    }
+                    const commonTarget = {
+                        modifiers: [],
+                    };
+                    pathKey && commonTarget.modifiers.push(pathKey);
+                    commonTarget.modifiers.push({
+                        __id__: compIdx,
+                    });
+                    commonTarget.modifiers.push('contentSize');
+                    let idx = animationClip._commonTargets.findIndex((target) => {
+                        return JSON.stringify(target.modifiers) === JSON.stringify(commonTarget.modifiers);
+                    });
+                    if (idx === -1) {
+                        idx = animationClip._commonTargets.length;
+                        animationClip._commonTargets.push(commonTarget);
+                    }
+                    curve.commonTarget = idx;
+                    curve.modifiers.push(this.getModifier(key));
+                }
+                else {
+                    this.mergersCommonTarget(key, curve, animationClip._commonTargets, pathKey);
+                }
+                for (let k = 0; k < prop.length; k++) {
+                    const item = prop[k];
+                    frames.push(item.frame);
+                    const value = yield this.getValue(key, item.value);
+                    curve.data.values.push(value);
+                    if (item.curve) {
+                        curve.data.easingMethods[k] = item.curve;
+                    }
+                }
+                animationClip._keys.push(frames);
+                animationClip._curves.push(curve);
+            }
+            return animationClipOrArray.length > 1 ? animationClipOrArray : animationClip;
+        });
+    }
+    getCurveDataForComps(comps, animationClipArray, pathKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const key in comps) {
+                // component
+                const comp = comps[key];
+                const component = {
+                    __type__: "cc.animation.ComponentPath",
+                    component: key,
+                };
+                for (const propKey in comp) {
+                    // component 内部属性
+                    const props = comp[propKey];
+                    const frames = [];
+                    const values = [];
+                    const curve = {
+                        modifiers: [],
+                        data: {
+                            keys: animationClipArray[0]._keys.length,
+                            values: values,
+                            easingMethods: {},
+                        },
+                    };
+                    pathKey && curve.modifiers.push(pathKey);
+                    curve.modifiers.push({
+                        // 下标从 1 开始
+                        __id__: animationClipArray.length,
+                    });
+                    curve.modifiers.push(this.getModifier(propKey));
+                    for (let k = 0; k < props.length; k++) {
+                        const prop = props[k];
+                        frames.push(prop.frame);
+                        const value = yield this.getValue(propKey, prop.value);
+                        curve.data.values.push(value);
+                        if (prop.curve) {
+                            curve.data.easingMethods[k] = prop.curve;
+                        }
+                    }
+                    animationClipArray[0]._keys.push(frames);
+                    animationClipArray[0]._curves.push(curve);
+                }
+                animationClipArray.push(component);
+            }
+            return animationClipArray;
+        });
+    }
+    getCurveDataForPaths(paths, animationClipArray) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const path in paths) {
+                const hierarchyPaths = {
+                    "__type__": "cc.animation.HierarchyPath",
+                    "path": path,
+                };
+                animationClipArray.push(hierarchyPaths);
+                const data = paths[path];
+                if (data.props) {
+                    animationClipArray = yield this.getPropsForCurveData(data.props, animationClipArray, {
+                        "__id__": animationClipArray.length - 1,
+                    });
+                }
+                if (data.comps) {
+                    const __id__ = animationClipArray.findIndex(item => {
+                        return item.path === path;
+                    });
+                    animationClipArray = yield this.getCurveDataForComps(data.comps, animationClipArray, {
+                        "__id__": __id__,
+                    });
+                }
+            }
+            return animationClipArray;
+        });
+    }
+    getCurveData(curveData, animationClip) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (curveData.props) {
+                animationClip = Array.isArray(animationClip) ? animationClip : [animationClip];
+                animationClip = yield this.getPropsForCurveData(curveData.props, animationClip);
+            }
+            if (curveData.comps) {
+                animationClip = Array.isArray(animationClip) ? animationClip : [animationClip];
+                animationClip = yield this.getCurveDataForComps(curveData.comps, animationClip);
+            }
+            if (curveData.paths) {
+                animationClip = Array.isArray(animationClip) ? animationClip : [animationClip];
+                animationClip = yield this.getCurveDataForPaths(curveData.paths, animationClip);
+            }
+            return animationClip;
+        });
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const anim2D = this.readJSONSync();
+            const animationClip = AnimationClip_1.AnimationClip.create();
+            animationClip._name = anim2D._name;
+            animationClip.sample = anim2D.sample;
+            animationClip.speed = anim2D.speed;
+            animationClip.wrapMode = anim2D.wrapMode;
+            animationClip.events = anim2D.events;
+            animationClip._duration = anim2D._duration;
+            this._2dTo3dSource = yield this.getCurveData(anim2D.curveData, animationClip);
+            this._3dMeta.ver = '1.0.6';
+            this._3dMeta.importer = "animation-clip";
+            return true;
+        });
+    }
+}
+exports.AnimImporter = AnimImporter;

extensions/plugin-import-2x/dist/convertor/atlas.js

@@ -0,0 +1,25 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtlasImporter = void 0;
+const base_1 = require("../common/base");
+class AtlasImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.AtlasImporter = AtlasImporter;

extensions/plugin-import-2x/dist/convertor/audio.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioImporter = void 0;
+const base_1 = require("../common/base");
+class AudioImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = "audio-clip";
+            return true;
+        });
+    }
+}
+exports.AudioImporter = AudioImporter;

extensions/plugin-import-2x/dist/convertor/bin.js

@@ -0,0 +1,25 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinImporter = void 0;
+const base_1 = require("../common/base");
+class BinImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.BinImporter = BinImporter;

extensions/plugin-import-2x/dist/convertor/dbbin.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbbinImporter = void 0;
+const base_1 = require("../common/base");
+class DbbinImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'dragonbones';
+            return true;
+        });
+    }
+}
+exports.DbbinImporter = DbbinImporter;

extensions/plugin-import-2x/dist/convertor/effect.js

@@ -0,0 +1,79 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+const path_1 = require("path");
+// @ts-ignore
+const fs_extra_1 = require("fs-extra");
+class EffectImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'effect';
+    }
+    import(main) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let effect = this.readFileSync();
+            if (effect) {
+                effect = this._replaceKeyword(effect);
+                effect = this._replace(effect);
+            }
+            this._2dTo3dSource = effect;
+            this._3dMeta.ver = '1.3.7';
+            this._3dMeta.importer = "effect";
+            console.warn(Editor.I18n.t('plugin-import-2x.effect_tips', { name: (0, path_1.basename)(this.destFsPath), uuid: this._3dMeta.uuid }));
+            return true;
+        });
+    }
+    _replaceKeyword(effect) {
+        effect = effect.replace(/texture:/g, 'mainTexture:');
+        effect = effect.replace(/texture;/g, 'mainTexture;');
+        effect = effect.replace(/texture,/g, 'mainTexture,');
+        effect = effect.replace(/vs/g, 'unlit-vs');
+        effect = effect.replace(/fs/g, 'unlit-fs');
+        return effect;
+    }
+    _replace(effect) {
+        const includes = effect.match(/#include +[<]([^>]+)[>]/g) || [];
+        for (const include of includes) {
+            const results = include.match(/(?<=#include <)(.*)(?=>)/g);
+            if (results && results[0]) {
+                const value = results[0];
+                const info = utlis_1.chunksCacheBy2D.get(value);
+                if (info) {
+                    // this._writeChunksSync(info.from, info.to);
+                    effect = effect.replace(include, include);
+                }
+            }
+        }
+        return effect;
+    }
+    _writeChunksSync(from, to) {
+        const content = this.readFileSync(from);
+        if (content) {
+            const includes = content.match(/#include +[<]([^>]+)[>]/g) || [];
+            for (const include of includes) {
+                const results = include.match(/(?<=#include <)(.*)(?=>)/g);
+                if (results && results[0]) {
+                    const value = results[0];
+                    const info = utlis_1.chunksCacheBy2D.get(value);
+                    if (info) {
+                        this._writeChunksSync(info.from, info.to);
+                    }
+                }
+            }
+            (0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(to));
+            this.writeFileSync(to, content);
+        }
+    }
+}
+exports.EffectImporter = EffectImporter;

extensions/plugin-import-2x/dist/convertor/fbx.js

@@ -0,0 +1,84 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FbxImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+const path_1 = require("path");
+class FbxImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'fbx';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._2dMeta) {
+                return true;
+            }
+            this._3dMeta.ver = '2.0.8';
+            this._3dMeta.importer = 'fbx';
+            this._3dMeta.userData.imageMetas = [];
+            this._3dMeta.userData.legacyFbxImporter = true;
+            this._3dMeta.userData.disableMeshSplit = true;
+            this._3dMeta.uuid = this._2dMeta.uuid;
+            const subMetas = [];
+            for (let key in this._2dMeta.subMetas) {
+                const subMeta2D = this._2dMeta.subMetas[key];
+                const isMult = (0, utlis_1.isFbxMultKey)(this._2dMeta.subMetas, key);
+                key = (0, utlis_1.getFBXSubMetaNewName)(this.destFsPath, key, isMult);
+                const name = base_1.ImporterBase.getNameByID(key);
+                const newUuid = `${this._2dMeta.uuid}@${name}`;
+                subMetas.push({
+                    key: key,
+                    name: name,
+                    uuid: newUuid,
+                });
+                utlis_1.importSubAssets.set(subMeta2D.uuid, {
+                    baseUuid: this._2dMeta.uuid,
+                    uuid: newUuid,
+                    meta: subMeta2D,
+                });
+            }
+            const metaContent = JSON.stringify(this._2dMeta.subMetas);
+            let uuids = metaContent.match(/(?<=uuid":")([a-zA-Z0-9-]+)(?=")/g) || [];
+            uuids = uuids.concat(metaContent.match(/(?<=__uuid__":")([a-zA-Z0-9-]+)(?=")/g) || []);
+            let useSprites = [];
+            for (let uuid of uuids) {
+                const asset = utlis_1.importProjectAssets.get(uuid);
+                const meta = asset && asset.meta;
+                if (meta && (meta.type === 'sprite' || meta.type === 'raw')) {
+                    if (!useSprites.find(item => item && item.uuid === uuid)) {
+                        useSprites.push({
+                            uuid: uuid,
+                            name: (0, path_1.basename)(asset.basePath),
+                        });
+                    }
+                }
+            }
+            if (useSprites.length > 0) {
+                let textureAssetsStr = '';
+                for (let useSprite of useSprites) {
+                    textureAssetsStr += `${useSprite.name} {asset(${useSprite.uuid})}`;
+                }
+                console.warn(Editor.I18n.t('plugin-import-2x.fbx_tips', {
+                    fbxName: (0, path_1.basename)(this.destFsPath) || '',
+                    fbxUuid: this._3dMeta.uuid,
+                    textureAssets: textureAssetsStr,
+                }));
+            }
+            if (subMetas.length > 0) {
+                utlis_1.replaceFbxUuidMap.set(this.destMetaFsPath, subMetas);
+            }
+            return true;
+        });
+    }
+}
+exports.FbxImporter = FbxImporter;

extensions/plugin-import-2x/dist/convertor/fire.js

@@ -0,0 +1,43 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FireImporter = void 0;
+const base_1 = require("../common/base");
+const Canvas_1 = require("../components/Canvas");
+const MigrateManager_1 = require("../components/MigrateManager");
+const TrailModule_1 = require("../components/TrailModule");
+class FireImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'fire';
+    }
+    import() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.1.26';
+            this._3dMeta.importer = "scene";
+            const json2D = this.readJSONSync();
+            const json3D = new Array(json2D.length);
+            for (let i = 0; i < json2D.length; ++i) {
+                yield MigrateManager_1.MigrateManager.migrate(i, json2D, json3D);
+            }
+            // 插入 Canvas
+            yield Canvas_1.Canvas.updateCameraComponent(json3D, json2D);
+            yield Canvas_1.Canvas.insert(json3D);
+            yield Canvas_1.Canvas.checkDesignResolution(json3D, (_a = this.pathInfo) === null || _a === void 0 ? void 0 : _a.name);
+            TrailModule_1.TrailModule.setParticleSystem(json3D);
+            this.ensureDefaultSprite2DFor3D(json3D);
+            this._2dTo3dSource = json3D;
+            return true;
+        });
+    }
+}
+exports.FireImporter = FireImporter;

extensions/plugin-import-2x/dist/convertor/fnt.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BitmapImporter = void 0;
+const base_1 = require("../common/base");
+class BitmapImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = "bitmap-font";
+            return true;
+        });
+    }
+}
+exports.BitmapImporter = BitmapImporter;

extensions/plugin-import-2x/dist/convertor/gltf.js

@@ -0,0 +1,30 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GltfImporter = void 0;
+const base_1 = require("../common/base");
+class GltfImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '2.0.8';
+            this._3dMeta.importer = 'gltf';
+            this._3dMeta.userData.imageMetas = [];
+            this._3dMeta.userData.legacyFbxImporter = false;
+            this._3dMeta.userData.disableMeshSplit = true;
+            return true;
+        });
+    }
+}
+exports.GltfImporter = GltfImporter;

extensions/plugin-import-2x/dist/convertor/image.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+class ImageImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'image';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._2dMeta) {
+                return true;
+            }
+            this._3dMeta.ver = '1.0.13';
+            this._3dMeta.importer = 'image';
+            // copy base asset and meta
+            const userData = this._3dMeta.userData;
+            if (this._2dMeta.type === 'sprite') {
+                userData.type = 'sprite-frame';
+                // texture
+                const textureMeta = this.createNewMeta();
+                textureMeta.importer = 'texture';
+                const textureID = base_1.ImporterBase.getNameByID('texture');
+                const filterMode = this._2dMeta['filterMode'];
+                // @ts-ignore
+                textureMeta.userData['minfilter'] = filterMode === 'point' ? 'nearest' : 'linear';
+                // @ts-ignore
+                textureMeta.userData['magfilter'] = filterMode === 'point' ? 'nearest' : 'linear';
+                const wrapMode = this._2dMeta['wrapMode'];
+                // @ts-ignore
+                textureMeta.userData['wrapModeS'] = textureMeta.userData['wrapModeT'] = wrapMode === 'clamp' ? 'clamp-to-edge' : wrapMode;
+                //
+                const genMipmaps = this._2dMeta['genMipmaps'];
+                let mipfilter = 'none';
+                if (genMipmaps) {
+                    mipfilter = (filterMode === 'bilinear' || filterMode === 'point') ? 'nearest' : 'linear';
+                }
+                // @ts-ignore
+                textureMeta.userData['mipfilter'] = mipfilter;
+                this._3dMeta.subMetas[textureID] = textureMeta;
+                // sprite frame
+                const spriteFrameMeta = this.createNewMeta();
+                const _2dSubMeta = this._2dMeta.subMetas[this.pathInfo.name];
+                for (const key in _2dSubMeta) {
+                    if (key === 'ver' || key === 'uuid' ||
+                        key === 'subMetas' || key === 'rawTextureUuid') {
+                        continue;
+                    }
+                    else {
+                        // @ts-ignore
+                        spriteFrameMeta.userData[key] = _2dSubMeta[key];
+                    }
+                }
+                spriteFrameMeta.importer = 'sprite-frame';
+                // @ts-ignore
+                spriteFrameMeta.userData.imageUuidOrDatabaseUri = `${this._3dMeta.uuid}@${textureID}`;
+                //
+                const spriteFrameID = base_1.ImporterBase.getNameByID('spriteFrame');
+                this._3dMeta.subMetas[spriteFrameID] = spriteFrameMeta;
+            }
+            else {
+                userData.type = 'raw';
+            }
+            // 是否开启缓存
+            const compressSettings = yield this.migratePlatformSettings(this._2dMeta.platformSettings);
+            if (compressSettings) {
+                userData.compressSettings = compressSettings;
+            }
+            this._3dMeta.userData = userData;
+            //
+            if (this._2dMeta.type === 'sprite') {
+                for (const key in this._2dMeta.subMetas) {
+                    const subMeta = this._2dMeta.subMetas[key];
+                    if (subMeta) {
+                        utlis_1.importSubAssets.set(subMeta.uuid, {
+                            baseUuid: this._2dMeta.uuid,
+                            uuid: `${this._2dMeta.uuid}@${base_1.ImporterBase.getNameByID('spriteFrame')}`,
+                        });
+                    }
+                }
+            }
+            else if (this._2dMeta.type === 'raw') {
+                utlis_1.importSubAssets.set(this._2dMeta.uuid, {
+                    baseUuid: this._2dMeta.uuid,
+                    uuid: `${this._2dMeta.uuid}@${base_1.ImporterBase.getNameByID('texture')}`,
+                });
+            }
+            return true;
+        });
+    }
+}
+exports.ImageImporter = ImageImporter;

extensions/plugin-import-2x/dist/convertor/index.js

@@ -0,0 +1,110 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConverter = exports.getConverter = exports.bubbleSort = exports.converterMap = void 0;
+const utlis_1 = require("../common/utlis");
+const diff_1 = require("../common/diff");
+const image_1 = require("./image");
+const fnt_1 = require("./fnt");
+const text_1 = require("./text");
+const audio_1 = require("./audio");
+const plist_1 = require("./plist");
+const json_1 = require("./json");
+const tmx_1 = require("./tmx");
+const mtl_1 = require("./mtl");
+const fbx_1 = require("./fbx");
+const ttf_1 = require("./ttf");
+const pac_1 = require("./pac");
+const anim_1 = require("./anim");
+const fire_1 = require("./fire");
+const prefab_1 = require("./prefab");
+const js_1 = require("./js");
+const ts_1 = require("./ts");
+const tsx_1 = require("./tsx");
+const bin_1 = require("./bin");
+const dbbin_1 = require("./dbbin");
+const effect_1 = require("./effect");
+const gltf_1 = require("./gltf");
+const label_atlas_1 = require("./label-atlas");
+const atlas_1 = require("./atlas");
+const sac_1 = require("./sac");
+const pmtl_1 = require("./pmtl");
+const skel_1 = require("./skel");
+const skeleton_1 = require("./skeleton");
+const video_1 = require("./video");
+const path_1 = require("path");
+// 存储需要转换的列表
+const keys = [];
+exports.converterMap = new Map();
+function register(Importer, extnames) {
+    extnames.forEach(extname => {
+        if (!keys.includes(extname)) {
+            keys.push(extname);
+        }
+        exports.converterMap.set(extname, new Importer());
+    });
+}
+function initConvert() {
+    keys.length = 0;
+    exports.converterMap.clear();
+}
+/**
+ * 排序
+ * @param {object} tree
+ */
+function bubbleSort(tree) {
+    let i, j, stop;
+    const len = tree.length;
+    for (i = 0; i < len; i++) {
+        for (j = 0, stop = len - i; j < stop - 1; j++) {
+            const a = tree[j], b = tree[j + 1];
+            const aIndex = keys.indexOf((0, path_1.extname)(a.detail.value));
+            const bIndex = keys.indexOf((0, path_1.extname)(b.detail.value));
+            if (aIndex > bIndex) {
+                const temp = tree[j];
+                tree[j] = tree[j + 1];
+                tree[j + 1] = temp;
+            }
+        }
+    }
+    return tree;
+}
+exports.bubbleSort = bubbleSort;
+function getConverter(exatname) {
+    return exports.converterMap.get(exatname);
+}
+exports.getConverter = getConverter;
+function registerConverter() {
+    initConvert();
+    (0, diff_1.initDiff)();
+    (0, utlis_1.init2DChunks)();
+    register(image_1.ImageImporter, ['.png', '.jpg', '.jpeg', '.webp']); // 完成
+    register(text_1.TextImporter, ['.pem', '.txt', '.html', '.htm', '.xml', '.css', '.less', '.scss', '.styl', '.stylus', '.yaml', '.ini', '.csv', '.proto', '.md', '.markdown']); // 完成
+    register(audio_1.AudioImporter, ['.mp3', '.wav', '.ogg', '.aac', '.pcm', '.m4a']); // 完成
+    register(video_1.VideoImporter, ['.mp4']); // 完成
+    register(ttf_1.TTFFontImporter, ['.ttf']); // 完成
+    register(fnt_1.BitmapImporter, ['.fnt']); // 完成
+    register(bin_1.BinImporter, ['.bin']); // 完成
+    register(dbbin_1.DbbinImporter, ['.dbbin']); // 完成
+    register(sac_1.SacImporter, ['.sac']); // 完成
+    register(json_1.JSONImporter, ['.json']); // 完成
+    register(atlas_1.AtlasImporter, ['.atlas']); // 完成
+    register(pmtl_1.PhysicsMaterialImporter, ['.pmtl']);
+    register(gltf_1.GltfImporter, ['.gltf']); // 完成
+    register(skel_1.SkelImporter, ['.skel']);
+    register(skeleton_1.SkeletonImporter, ['.skeleton']);
+    register(tsx_1.TsxImporter, ['.tsx']); // 完成
+    register(tmx_1.TmxImporter, ['.tmx']); // 完成
+    register(fbx_1.FbxImporter, ['.fbx', '.FBX']); // 完成
+    register(plist_1.PlistImporter, ['.plist']); // 完成
+    register(pac_1.AutoAtlasImporter, ['.pac']); // 完成
+    register(label_atlas_1.LabelAtlasImporter, ['.labelatlas']); // 完成
+    register(effect_1.EffectImporter, ['.effect']);
+    register(mtl_1.MaterialImporter, ['.mtl']);
+    register(anim_1.AnimImporter, ['.anim']);
+    register(prefab_1.PrefabImporter, ['.prefab']);
+    register(fire_1.FireImporter, ['.fire']);
+    // 代码最后导入
+    register(js_1.JSImporter, ['.js']); // 完成
+    register(ts_1.TSImporter, ['.ts']); // 完成
+}
+exports.registerConverter = registerConverter;

extensions/plugin-import-2x/dist/convertor/js.js

@@ -0,0 +1,112 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+const parseCode_1 = require("../common/parseCode");
+class JSImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'script';
+    }
+    beforeImport(projectRoot, sourceFsPath) {
+        const _super = Object.create(null, {
+            beforeImport: { get: () => super.beforeImport }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const skip = utlis_1.SKIPS_SCRIPT.find(value => {
+                return sourceFsPath.endsWith(value);
+            });
+            if (skip) {
+                return false;
+            }
+            return yield _super.beforeImport.call(this, projectRoot, sourceFsPath);
+        });
+    }
+    import(main) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '4.0.21';
+            this._3dMeta.importer = 'javascript';
+            let name = this.pathInfo.name;
+            // 类名只保留字母
+            name = utlis_1.scriptName.getValidClassName(name);
+            const baseCode = this.readFileSync();
+            if (baseCode) {
+                let needParse = false;
+                let commentCode = '';
+                baseCode.trim().split('\n').forEach((line) => {
+                    commentCode += '// ' + line + `\n`;
+                    if (line.includes('cc.Class(')) {
+                        needParse = true;
+                    }
+                });
+                let code = '';
+                if (this._2dMeta && this._2dMeta.isPlugin) {
+                    this._3dMeta.userData = {
+                        isPlugin: this._2dMeta.isPlugin,
+                        loadPluginInWeb: this._2dMeta.loadPluginInWeb,
+                        loadPluginInNative: this._2dMeta.loadPluginInNative,
+                        loadPluginInEditor: this._2dMeta.loadPluginInEditor,
+                        importAsPlugin: this._2dMeta.isPlugin,
+                    };
+                }
+                else {
+                    if (needParse) {
+                        const data = yield (0, parseCode_1.parseJSCode)(this.sourceFsPath, name);
+                        code += data.topNote;
+                        if (baseCode.includes('cc.Class(')) {
+                            const classInfo = yield this.queryCCClass(main.$.engine2D, {
+                                type: 'js',
+                                path: this.destFsPath,
+                                name: name,
+                                code: baseCode,
+                                classCount: 1,
+                                ccKeys: data.ccKeys,
+                                importCodeMap: data.importCodeMap,
+                                otherCodeMap: data.otherCodeMap,
+                                classCodeMap: data.classCodeMap,
+                                endCodeMap: data.endCodeMap,
+                                replaceScriptList: utlis_1.replaceScriptList,
+                            });
+                            if (classInfo) {
+                                if (name !== classInfo.name) {
+                                    console.warn(Editor.I18n.t('plugin-import-2x.script_rename_tips', {
+                                        old: name,
+                                        new: classInfo.name
+                                    }));
+                                }
+                                (0, utlis_1.updateReplaceScriptList)(classInfo.replaceScriptList);
+                                code += classInfo.classCode;
+                            }
+                        }
+                        else {
+                            console.warn(Editor.I18n.t('plugin-import-2x.skip_script_warn', {
+                                name: this.pathInfo.name,
+                            }));
+                        }
+                        code += `/**\n`;
+                        code += ` * ${Editor.I18n.t('plugin-import-2x.plugin_js_tips')}\n`;
+                        code += ` */\n`;
+                        code += commentCode;
+                        this._2dTo3dSource = code;
+                    }
+                    else {
+                        this._2dTo3dSource = baseCode;
+                    }
+                    utlis_1.scriptList.set(this.pathInfo.name, this.destFsPath);
+                }
+            }
+            return true;
+        });
+    }
+}
+exports.JSImporter = JSImporter;

extensions/plugin-import-2x/dist/convertor/json.js

@@ -0,0 +1,107 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONImporter = void 0;
+const base_1 = require("../common/base");
+class JSONImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const isSpine = this.validateSpine();
+            if (isSpine) {
+                this._3dMeta.ver = '1.2.3';
+                this._3dMeta.importer = 'spine-data';
+            }
+            else if (this.validateDragonBones()) {
+                this._3dMeta.ver = '1.0.0';
+                this._3dMeta.importer = 'dragonbones';
+            }
+            else if (this.validateDragonBonesAtlasAsset()) {
+                this._3dMeta.ver = '1.0.0';
+                this._3dMeta.importer = 'dragonbones-atlas';
+            }
+            else {
+                this._3dMeta.ver = '1.0.0';
+                this._3dMeta.importer = 'json';
+            }
+            return true;
+        });
+    }
+    validateDragonBonesAtlasAsset() {
+        let json;
+        const text = this.readFileSync(this.sourceFsPath);
+        try {
+            if (text) {
+                json = JSON.parse(text);
+            }
+        }
+        catch (e) {
+            return false;
+        }
+        return typeof json.imagePath === 'string' && Array.isArray(json.SubTexture);
+    }
+    validateDragonBones() {
+        var json;
+        if (this.sourceFsPath.endsWith('.json')) {
+            const text = this.readFileSync(this.sourceFsPath);
+            try {
+                if (text) {
+                    json = JSON.parse(text);
+                }
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        else {
+            const bin = this.readFileSync(this.sourceFsPath);
+            try {
+                // @ts-expect-error
+                json = dragonBones.BinaryDataParser.getInstance().parseDragonBonesData(bin.buffer);
+            }
+            catch (e) {
+                return false;
+            }
+        }
+        return Array.isArray(json.armature) || !!json.armatures;
+    }
+    validateSpine() {
+        if (this.sourceFsPath.endsWith('.skel')) {
+            return true;
+        }
+        let json;
+        const text = this.readFileSync(this.sourceFsPath);
+        if (text) {
+            const fastTest = text.slice(0, 30);
+            const maybe = (fastTest.indexOf('slots') > 0 ||
+                fastTest.indexOf('skins') > 0 ||
+                fastTest.indexOf('events') > 0 ||
+                fastTest.indexOf('animations') > 0 ||
+                fastTest.indexOf('bones') > 0 ||
+                fastTest.indexOf('skeleton') > 0 ||
+                fastTest.indexOf('"ik"') > 0);
+            if (maybe) {
+                try {
+                    json = JSON.parse(text);
+                }
+                catch (e) {
+                    return false;
+                }
+                return Array.isArray(json.bones);
+            }
+        }
+        return false;
+    }
+}
+exports.JSONImporter = JSONImporter;

extensions/plugin-import-2x/dist/convertor/label-atlas.js

@@ -0,0 +1,36 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LabelAtlasImporter = void 0;
+const base_1 = require("../common/base");
+class LabelAtlasImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'label-atlas';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._2dMeta) {
+                return true;
+            }
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'label-atlas';
+            const userData = this._3dMeta.userData;
+            userData.itemWidth = this._2dMeta.itemWidth;
+            userData.itemHeight = this._2dMeta.itemHeight;
+            userData.startChar = this._2dMeta.startChar;
+            userData.spriteFrameUuid = `${this._2dMeta.rawTextureUuid}@${base_1.ImporterBase.getNameByID('spriteFrame')}`;
+            userData.fontSize = this._2dMeta.fontSize;
+            return true;
+        });
+    }
+}
+exports.LabelAtlasImporter = LabelAtlasImporter;

extensions/plugin-import-2x/dist/convertor/mtl.js

@@ -0,0 +1,29 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaterialImporter = void 0;
+const base_1 = require("../common/base");
+const Material_1 = require("../components/Material");
+class MaterialImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.9';
+            this._3dMeta.importer = 'material';
+            this._2dTo3dSource = yield Material_1.Material.migrate(this.readJSONSync());
+            return true;
+        });
+    }
+}
+exports.MaterialImporter = MaterialImporter;

extensions/plugin-import-2x/dist/convertor/pac.js

@@ -0,0 +1,54 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AutoAtlasImporter = void 0;
+const base_1 = require("../common/base");
+// 2d 自动图集已有的数据
+const KEYS = [
+    'maxWidth',
+    'maxHeight',
+    'padding',
+    'allowRotation',
+    'forceSquared',
+    'powerOfTwo',
+    'algorithm',
+    'format',
+    'quality',
+    'contourBleed',
+    'paddingBleed',
+    'filterUnused',
+];
+class AutoAtlasImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'pac';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._2dMeta) {
+                return true;
+            }
+            this._3dMeta.ver = '1.0.5';
+            this._3dMeta.importer = 'auto-atlas';
+            for (const key in this._2dMeta) {
+                if (KEYS.includes(key)) {
+                    this._3dMeta.userData[key] = this._2dMeta[key];
+                }
+            }
+            const compressSettings = yield this.migratePlatformSettings(this._2dMeta.platformSettings);
+            if (compressSettings) {
+                this._3dMeta.userData.compressSettings = compressSettings;
+            }
+            return true;
+        });
+    }
+}
+exports.AutoAtlasImporter = AutoAtlasImporter;

extensions/plugin-import-2x/dist/convertor/plist.js

@@ -0,0 +1,136 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlistImporter = void 0;
+const base_1 = require("../common/base");
+// @ts-ignore
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+const utlis_1 = require("../common/utlis");
+const plist = require('plist');
+class PlistImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'plist';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._2dMeta) {
+                return true;
+            }
+            if (this._2dMeta.type === 'Texture Packer') {
+                this._3dMeta.ver = '1.0.6';
+                this._3dMeta.importer = 'sprite-atlas';
+                return this.importTexturePacker();
+            }
+            else {
+                this._3dMeta.ver = '1.0.2';
+                this._3dMeta.importer = 'particle';
+                return this.importParticle();
+            }
+        });
+    }
+    importTexturePacker() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let userData = this._3dMeta.userData;
+                const file = yield (0, fs_extra_1.readFile)(this.sourceFsPath, 'utf8');
+                const data = plist.parse(file);
+                userData.atlasTextureName = data.metadata.realTextureFileName;
+                userData.format = data.metadata.format;
+                userData.textureUuid = `${this._2dMeta.rawTextureUuid}@${base_1.ImporterBase.getNameByID('texture')}`;
+                userData = this._3dMeta.userData;
+                //
+                for (const key in data.frames) {
+                    const _2dSubMeta = this._2dMeta.subMetas[key];
+                    const id = base_1.ImporterBase.getNameByID((0, path_1.parse)(key).name);
+                    const subMeta = this.createNewMeta();
+                    subMeta.importer = "sprite-frame";
+                    for (const key in _2dSubMeta) {
+                        switch (key) {
+                            case 'ver':
+                            case 'uuid':
+                            case 'subMetas':
+                            case 'spriteType':
+                                // continue
+                                break;
+                            case 'rawTextureUuid':
+                                // @ts-ignore
+                                subMeta.userData.atlasUuid = _2dSubMeta[key];
+                                break;
+                            default:
+                                // @ts-ignore
+                                subMeta.userData[key] = _2dSubMeta[key];
+                                break;
+                        }
+                    }
+                    // @ts-ignore
+                    subMeta.imageUuidOrDatabaseUri = userData.textureUuid;
+                    this._3dMeta.subMetas[id] = subMeta;
+                    // 存储
+                    for (let key in this._2dMeta.subMetas) {
+                        const subMeta = this._2dMeta.subMetas[key];
+                        if (subMeta) {
+                            key = (0, path_1.basename)(key, (0, path_1.extname)(key));
+                            utlis_1.importSubAssets.set(subMeta.uuid, {
+                                baseUuid: this._2dMeta.uuid,
+                                uuid: `${this._2dMeta.uuid}@${base_1.ImporterBase.getNameByID(key)}`,
+                            });
+                        }
+                    }
+                    // 修改 plist 依赖图片类型设置为 texture
+                    const image = utlis_1.importProjectAssets.get(this._2dMeta.rawTextureUuid);
+                    if (image) {
+                        const meta = this.readJSONSync(image.outPath);
+                        if (meta.userData.type !== 'texture') {
+                            meta.userData.type = 'texture';
+                            (0, fs_extra_1.writeJSONSync)(image.outPath, meta, { spaces: 2 });
+                        }
+                    }
+                }
+                return true;
+            }
+            catch (e) {
+                console.error(e);
+                return false;
+            }
+        });
+    }
+    importParticle() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const file = yield (0, fs_extra_1.readFile)(this.sourceFsPath, 'utf8');
+                const data = plist.parse(file);
+                if (data.spriteFrameUuid) {
+                    data.spriteFrameUuid = yield base_1.ImporterBase.getUuid(data.spriteFrameUuid, 'spriteFrame');
+                }
+                else if (data.textureUuid) {
+                    // textureUuid 转成 spriteFrameUuid
+                    data.spriteFrameUuid = yield base_1.ImporterBase.getUuid(data.textureUuid, 'spriteFrame');
+                    delete data.textureUuid;
+                }
+                if (data.blendFuncSource) {
+                    data.blendFuncSource = (0, utlis_1.getBlendFactor2DTo3D)(data.blendFuncSource);
+                }
+                if (data.blendFuncDestination) {
+                    data.blendFuncDestination = (0, utlis_1.getBlendFactor2DTo3D)(data.blendFuncDestination);
+                }
+                this._2dTo3dSource = plist.build(data);
+                return true;
+            }
+            catch (e) {
+                console.log(e);
+                return false;
+            }
+        });
+    }
+}
+exports.PlistImporter = PlistImporter;

extensions/plugin-import-2x/dist/convertor/pmtl.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PhysicsMaterialImporter = void 0;
+const base_1 = require("../common/base");
+class PhysicsMaterialImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'physics-material';
+            return true;
+        });
+    }
+}
+exports.PhysicsMaterialImporter = PhysicsMaterialImporter;

extensions/plugin-import-2x/dist/convertor/prefab.js

@@ -0,0 +1,51 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrefabImporter = void 0;
+const base_1 = require("../common/base");
+const MigrateManager_1 = require("../components/MigrateManager");
+const TrailModule_1 = require("../components/TrailModule");
+function getOptimizationPolicy(value) {
+    switch (value) {
+        case 'AUTO':
+            return 0;
+        case 'SINGLE_INSTANCE':
+            return 1;
+        case 'MULTI_INSTANCE':
+            return 2;
+    }
+}
+class PrefabImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'prefab';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.1.26';
+            this._3dMeta.importer = "prefab";
+            const json2D = this.readJSONSync();
+            const json3D = new Array(json2D.length);
+            for (let i = 0; i < json2D.length; ++i) {
+                const obj = yield MigrateManager_1.MigrateManager.migrate(i, json2D, json3D);
+                if (obj.__type__ === 'cc.Prefab') {
+                    obj.optimizationPolicy = getOptimizationPolicy(this._2dMeta.optimizationPolicy);
+                    obj.asyncLoadAssets = this._2dMeta.asyncLoadAssets;
+                }
+            }
+            TrailModule_1.TrailModule.setParticleSystem(json3D);
+            this.ensureDefaultSprite2DFor3D(json3D);
+            this._2dTo3dSource = json3D;
+            return true;
+        });
+    }
+}
+exports.PrefabImporter = PrefabImporter;

extensions/plugin-import-2x/dist/convertor/sac.js

@@ -0,0 +1,25 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SacImporter = void 0;
+const base_1 = require("../common/base");
+class SacImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.SacImporter = SacImporter;

extensions/plugin-import-2x/dist/convertor/skel.js

@@ -0,0 +1,25 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkelImporter = void 0;
+const base_1 = require("../common/base");
+class SkelImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.SkelImporter = SkelImporter;

extensions/plugin-import-2x/dist/convertor/skeleton.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkeletonImporter = void 0;
+const base_1 = require("../common/base");
+class SkeletonImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'instantiation-skeleton';
+            return true;
+        });
+    }
+}
+exports.SkeletonImporter = SkeletonImporter;

extensions/plugin-import-2x/dist/convertor/text.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextImporter = void 0;
+const base_1 = require("../common/base");
+class TextImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'text';
+            return true;
+        });
+    }
+}
+exports.TextImporter = TextImporter;

extensions/plugin-import-2x/dist/convertor/tmx.js

@@ -0,0 +1,55 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TmxImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+// @ts-ignore
+const fs_extra_1 = require("fs-extra");
+const IMAGE_EXNAME = ['.png', '.jpg', '.jpeg', '.webp'];
+class TmxImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'tmx';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = 'tiled-map';
+            const tmxFileData = this.readFileSync();
+            if (tmxFileData) {
+                const imageFullPaths = (yield (0, utlis_1.searchTmxDependImages)(this.sourceFsPath, tmxFileData)) || [];
+                const images = [];
+                imageFullPaths.forEach((imagePath) => {
+                    utlis_1.importProjectAssets.forEach((value) => {
+                        if (IMAGE_EXNAME.includes(value.type)) {
+                            if (value.basePath === imagePath) {
+                                images.push(value);
+                                return;
+                            }
+                        }
+                    });
+                });
+                images.forEach(info => {
+                    const meta = this.readJSONSync(info.outPath);
+                    if (meta) {
+                        if (meta.userData.type !== 'sprite-frame') {
+                            meta.userData.type = 'sprite-frame';
+                            (0, fs_extra_1.writeJSONSync)(info.outPath, meta, { spaces: 2 });
+                        }
+                    }
+                });
+            }
+            return true;
+        });
+    }
+}
+exports.TmxImporter = TmxImporter;

extensions/plugin-import-2x/dist/convertor/ts.js

@@ -0,0 +1,63 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSImporter = void 0;
+const base_1 = require("../common/base");
+const utlis_1 = require("../common/utlis");
+const parseCode_1 = require("../common/parseCode");
+class TSImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'script';
+    }
+    import(main) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._3dMeta.ver = '4.0.21';
+                this._3dMeta.importer = 'typescript';
+                let name = this.pathInfo.name;
+                // 类名只保留字母
+                name = utlis_1.scriptName.getValidClassName(name);
+                let code = this.readFileSync();
+                if (code) {
+                    let needParse = false;
+                    let commentCode = '';
+                    code.trim().split('\n').forEach((line) => {
+                        commentCode += '// ' + line + `\n`;
+                        if (line.includes('export default class ') ||
+                            line.includes('export class ') ||
+                            line.includes('@ccclass')) {
+                            needParse = true;
+                        }
+                    });
+                    if (needParse) {
+                        const data = yield (0, parseCode_1.parseTSCode)(name, this.sourceFsPath);
+                        this._2dTo3dSource = data.content;
+                        this._2dTo3dSource += `/**\n`;
+                        this._2dTo3dSource += ` * ${Editor.I18n.t('plugin-import-2x.plugin_js_tips')}\n`;
+                        this._2dTo3dSource += ` */\n`;
+                        this._2dTo3dSource += commentCode;
+                    }
+                    else {
+                        this._2dTo3dSource = code;
+                    }
+                    utlis_1.scriptList.set(name, this.destFsPath);
+                }
+                return true;
+            }
+            catch (e) {
+                console.error(e + ',\n this file path: ' + this.sourceFsPath);
+                return false;
+            }
+        });
+    }
+}
+exports.TSImporter = TSImporter;

extensions/plugin-import-2x/dist/convertor/tsx.js

@@ -0,0 +1,25 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TsxImporter = void 0;
+const base_1 = require("../common/base");
+class TsxImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.TsxImporter = TsxImporter;

extensions/plugin-import-2x/dist/convertor/ttf.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TTFFontImporter = void 0;
+const base_1 = require("../common/base");
+class TTFFontImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = "ttf-font";
+            return true;
+        });
+    }
+}
+exports.TTFFontImporter = TTFFontImporter;

extensions/plugin-import-2x/dist/convertor/video.js

@@ -0,0 +1,27 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VideoImporter = void 0;
+const base_1 = require("../common/base");
+class VideoImporter extends base_1.ImporterBase {
+    constructor() {
+        super(...arguments);
+        this.type = 'base';
+    }
+    import() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._3dMeta.ver = '1.0.0';
+            this._3dMeta.importer = "video-clip";
+            return true;
+        });
+    }
+}
+exports.VideoImporter = VideoImporter;