刘宇飞
d393302388
Adds level prefabs, theme assets, audio, extensions, and deployment scripts for the Unity WebGL migration. Co-authored-by: Cursor <cursoragent@cursor.com>
469 lines
17 KiB
JavaScript
469 lines
17 KiB
JavaScript
/**
|
|
* 用于导入 2d 项目到 3d 项目
|
|
*/
|
|
'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.ImporterBase = void 0;
|
|
// @ts-ignore
|
|
const node_uuid_1 = require("node-uuid");
|
|
const utlis_1 = require("./utlis");
|
|
const path_1 = require("path");
|
|
// @ts-ignore
|
|
const fs_extra_1 = require("fs-extra");
|
|
const utlis_2 = require("./utlis");
|
|
const diff_1 = require("./diff");
|
|
const convertor_1 = require("../convertor");
|
|
class ImporterBase {
|
|
constructor() {
|
|
this.type = '';
|
|
// 导入到 3d 工程所在磁盘的路径
|
|
this.destFsPath = '';
|
|
this.destMetaFsPath = '';
|
|
// 2d 源文件所在磁盘的路径
|
|
this.sourceFsPath = '';
|
|
this.pathInfo = null;
|
|
this._2dMeta = null;
|
|
this._3dMeta = null;
|
|
// 2d 源文件转成 3d 源文件，如果不为 null 说明需要保存
|
|
// 例如 animation、prefab、scene 之类的源文件
|
|
this._2dTo3dSource = null;
|
|
}
|
|
// 检查 uuid 是否冲突，如果有就存储起来，后续会用到
|
|
checkUuid(meta) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const assetFsPath = yield Editor.Message.request('asset-db', 'query-path', meta.uuid);
|
|
if (assetFsPath && assetFsPath !== this.destFsPath) {
|
|
const newUuid = (0, node_uuid_1.v4)();
|
|
(0, utlis_2.saveUuid)(meta.uuid, newUuid);
|
|
return newUuid;
|
|
}
|
|
// 存放 sprite frame uuid 对应的 texture uuid
|
|
if (meta.type === 'sprite' && meta.subMetas) {
|
|
for (const key in meta.subMetas) {
|
|
const subMeta = meta.subMetas[key];
|
|
(0, utlis_2.saveUuid)(subMeta.uuid, subMeta.rawTextureUuid);
|
|
}
|
|
}
|
|
return meta.uuid;
|
|
});
|
|
}
|
|
get3DUuid() {
|
|
try {
|
|
const meta = (0, fs_extra_1.readJSONSync)(this.destMetaFsPath);
|
|
return meta.uuid;
|
|
}
|
|
catch (e) {
|
|
return (0, node_uuid_1.v4)();
|
|
}
|
|
}
|
|
reset() {
|
|
this.destFsPath = '';
|
|
this.sourceFsPath = '';
|
|
this.pathInfo = null;
|
|
this._2dMeta = null;
|
|
this._3dMeta = null;
|
|
this._2dTo3dSource = null;
|
|
}
|
|
static getPathInfo(projectRoot, sourceFsPath) {
|
|
let relativePath = (0, path_1.relative)(projectRoot, sourceFsPath);
|
|
if (!relativePath.startsWith('assets')) {
|
|
relativePath = (0, path_1.join)('assets', relativePath);
|
|
}
|
|
let to = (0, path_1.join)(Editor.Project.path, relativePath);
|
|
// 改后缀名 .fire to .scene;
|
|
if (to.endsWith('.fire')) {
|
|
to = to.replace(/.fire+$/g, '.scene');
|
|
}
|
|
else if (to.endsWith('.js')) {
|
|
const meta = (0, fs_extra_1.readJSONSync)(sourceFsPath + '.meta');
|
|
if (!meta.isPlugin) {
|
|
to = to.replace(/.js+$/g, '.ts');
|
|
}
|
|
}
|
|
return {
|
|
to: to,
|
|
toMeta: to + '.meta',
|
|
from: sourceFsPath,
|
|
fromMeta: sourceFsPath + '.meta',
|
|
pathInfo: (0, path_1.parse)(sourceFsPath),
|
|
};
|
|
}
|
|
static isNew(projectRoot, sourceFsPath) {
|
|
try {
|
|
if (sourceFsPath.endsWith('assets')) {
|
|
return false;
|
|
}
|
|
const info = ImporterBase.getPathInfo(projectRoot, sourceFsPath);
|
|
if ((0, fs_extra_1.existsSync)(info.to) && (0, fs_extra_1.existsSync)(info.toMeta)) {
|
|
const _3DMeta = (0, fs_extra_1.readJSONSync)(info.toMeta);
|
|
if (_3DMeta.importer === 'directory') {
|
|
return false;
|
|
}
|
|
const _2DMeta = (0, fs_extra_1.readJSONSync)(info.fromMeta);
|
|
return _2DMeta.uuid !== _3DMeta.uuid;
|
|
}
|
|
return true;
|
|
}
|
|
catch (e) {
|
|
return true;
|
|
}
|
|
}
|
|
/*
|
|
* 导入前
|
|
* 参数一：项目的路径
|
|
* 参数二：项目的资源路径
|
|
*/
|
|
beforeImport(projectRoot, sourceFsPath) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
// 重置
|
|
this.reset();
|
|
//
|
|
this.sourceFsPath = sourceFsPath;
|
|
const info = ImporterBase.getPathInfo(projectRoot, sourceFsPath);
|
|
this.destFsPath = info.to;
|
|
this.destMetaFsPath = info.toMeta;
|
|
this.pathInfo = info.pathInfo;
|
|
// update asset meta
|
|
this._2dMeta = this.read2dMeta(sourceFsPath);
|
|
// 检查 uuid 是否冲突
|
|
const newUuid = this._2dMeta ? yield this.checkUuid(this._2dMeta) : this.get3DUuid();
|
|
this._3dMeta = this.createNewMeta(newUuid);
|
|
this._3dMeta.uuid = newUuid;
|
|
this._2dMeta && utlis_2.importProjectAssets.set(this._2dMeta.uuid, {
|
|
type: (0, path_1.extname)(sourceFsPath),
|
|
basePath: sourceFsPath,
|
|
outPath: this.destMetaFsPath,
|
|
outUuid: this._2dMeta.uuid,
|
|
meta: this._2dMeta,
|
|
});
|
|
return true;
|
|
});
|
|
}
|
|
needImport() {
|
|
let doImport = true;
|
|
if ((0, fs_extra_1.existsSync)(this.destFsPath) && (0, fs_extra_1.existsSync)(this.destMetaFsPath)) {
|
|
const meta = (0, fs_extra_1.readJSONSync)(this.destMetaFsPath);
|
|
doImport = this._3dMeta.uuid !== meta.uuid;
|
|
}
|
|
if (doImport) {
|
|
// console.log(Editor.I18n.t('plugin-import-2x.import_log', {
|
|
// path: this.sourceFsPath,
|
|
// }));
|
|
}
|
|
return doImport;
|
|
}
|
|
/*
|
|
* 导入并且进行转换
|
|
*/
|
|
import(main) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return true;
|
|
});
|
|
}
|
|
/*
|
|
* 转换后进行报错跟拷贝源文件的处理
|
|
*/
|
|
afterImport() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
this.copySync(this.sourceFsPath);
|
|
if (this._2dTo3dSource) {
|
|
try {
|
|
if (this.destFsPath.endsWith('.ts') ||
|
|
this.destFsPath.endsWith('.js') ||
|
|
this.destFsPath.endsWith('.plist') ||
|
|
this.destFsPath.endsWith('.effect')) {
|
|
(0, fs_extra_1.writeFileSync)(this.destFsPath, this._2dTo3dSource, { encoding: 'utf8' });
|
|
}
|
|
else {
|
|
(0, fs_extra_1.writeJSONSync)(this.destFsPath, this._2dTo3dSource, { spaces: 2 });
|
|
}
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
// console.log('保存：' + this.destFsPath);
|
|
this.saveMeta();
|
|
});
|
|
}
|
|
/*
|
|
* 创建新的 meta 对象
|
|
*/
|
|
createNewMeta(uuid) {
|
|
return {
|
|
uuid: uuid || '',
|
|
imported: false,
|
|
importer: '*',
|
|
files: [],
|
|
subMetas: {},
|
|
userData: {},
|
|
ver: '0.0.1',
|
|
};
|
|
}
|
|
/*
|
|
* 读取 meta
|
|
*/
|
|
read2dMeta(sourceFsPath) {
|
|
try {
|
|
if (!sourceFsPath.endsWith('.meta')) {
|
|
sourceFsPath += '.meta';
|
|
}
|
|
if (!(0, fs_extra_1.existsSync)(sourceFsPath)) {
|
|
return null;
|
|
}
|
|
return (0, fs_extra_1.readJSONSync)(sourceFsPath);
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
return null;
|
|
}
|
|
}
|
|
/*
|
|
* 拷贝资源 + meta
|
|
*/
|
|
copySync(from, to) {
|
|
try {
|
|
if (!(0, fs_extra_1.existsSync)(from)) {
|
|
return 0;
|
|
}
|
|
if (to) {
|
|
(0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(to));
|
|
(0, fs_extra_1.copyFileSync)(from, to);
|
|
}
|
|
else {
|
|
(0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(this.destFsPath));
|
|
(0, fs_extra_1.copyFileSync)(from, this.destFsPath);
|
|
}
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
/*
|
|
* 保存 meta
|
|
*/
|
|
saveMeta() {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (!this.destMetaFsPath.endsWith('.meta')) {
|
|
this.destMetaFsPath += '.meta';
|
|
}
|
|
try {
|
|
(0, fs_extra_1.writeJSONSync)(this.destMetaFsPath, this._3dMeta, { spaces: 2 });
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
});
|
|
}
|
|
/*
|
|
* 保存
|
|
*/
|
|
writeFileSync(to, data) {
|
|
try {
|
|
(0, fs_extra_1.writeFileSync)(to, data, { encoding: 'utf8' });
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
/*
|
|
* 加载源文件类型为 JSON
|
|
*/
|
|
readJSONSync(sourceFsPath) {
|
|
try {
|
|
return (0, fs_extra_1.readJSONSync)(sourceFsPath || this.sourceFsPath);
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
return null;
|
|
}
|
|
}
|
|
/*
|
|
* 加载源文件
|
|
*/
|
|
readFileSync(sourceFsPath) {
|
|
try {
|
|
return (0, fs_extra_1.readFileSync)(sourceFsPath || this.sourceFsPath, 'utf8');
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
return null;
|
|
}
|
|
}
|
|
/*
|
|
* 导入缓存纹理设置
|
|
*/
|
|
migratePlatformSettings(platformSettings) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
return yield (0, utlis_2.migratePlatformSettings)(platformSettings);
|
|
});
|
|
}
|
|
static getUuid(uuid, type) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
if (diff_1.UUID_2D_TO_3D.has(uuid)) {
|
|
return diff_1.UUID_2D_TO_3D.get(uuid);
|
|
}
|
|
if (diff_1.UUID_UI_2D_TO_3D.has(uuid)) {
|
|
return diff_1.UUID_UI_2D_TO_3D.get(uuid);
|
|
}
|
|
if (diff_1.UUID_SKIP_EFFECT.has(uuid)) {
|
|
console.warn(Editor.I18n.t('plugin-import-2x.effect_warn_tips', {
|
|
name: diff_1.UUID_SKIP_EFFECT.get(uuid),
|
|
}));
|
|
}
|
|
uuid = yield ImporterBase.ensureDefaultAssets2DFor3D(uuid);
|
|
uuid = (0, utlis_2.getNewUuid)(uuid);
|
|
if (type && !uuid.includes('@')) {
|
|
const id = `@${ImporterBase.getNameByID(type)}`;
|
|
if (!uuid.endsWith(id)) {
|
|
uuid += id;
|
|
}
|
|
}
|
|
return uuid;
|
|
});
|
|
}
|
|
static getNewUuid(uuid) {
|
|
return (0, utlis_2.getNewUuid)(uuid);
|
|
}
|
|
/*
|
|
* 通过名字获取 id
|
|
*/
|
|
static getNameByID(name) {
|
|
return (0, utlis_1.nameToId)(name);
|
|
}
|
|
/*
|
|
* 创建默认资源
|
|
*/
|
|
static getDefaultAssets2D(uuid) {
|
|
return (0, utlis_2.getDefaultAssets2D)(uuid);
|
|
}
|
|
/*
|
|
* 创建 2d 默认资源
|
|
*/
|
|
static ensureDefaultAssets2DFor3D(uuid) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
const subAssets = utlis_2.importSubAssets.get(uuid);
|
|
if (subAssets) {
|
|
uuid = subAssets.baseUuid;
|
|
}
|
|
else {
|
|
const projectAssets = utlis_2.importProjectAssets.get(uuid);
|
|
if (projectAssets) {
|
|
uuid = projectAssets.outUuid;
|
|
}
|
|
}
|
|
const info = (0, utlis_2.getDefaultAssets2D)(uuid);
|
|
if (info && info.path) {
|
|
// 如果是内置资源与 3d 的一致就直接用 3D 的
|
|
if (diff_1.UUID_UI_2D_TO_3D.has(info.baseUuid)) {
|
|
return diff_1.UUID_UI_2D_TO_3D.get(info.baseUuid);
|
|
}
|
|
if (diff_1.UUID_2D_TO_3D.has(info.baseUuid)) {
|
|
return diff_1.UUID_2D_TO_3D.get(info.baseUuid);
|
|
}
|
|
const defaultAssetsRootPath = (0, path_1.join)(__dirname, '../../static');
|
|
let relativePath = (0, path_1.relative)(defaultAssetsRootPath, info.path);
|
|
if (!relativePath.startsWith('assets')) {
|
|
relativePath = (0, path_1.join)('assets', relativePath);
|
|
}
|
|
const destFsPath = (0, path_1.join)(Editor.Project.path, relativePath);
|
|
try {
|
|
if (!(0, fs_extra_1.existsSync)(destFsPath)) {
|
|
if (destFsPath.endsWith('.mtl') || destFsPath.endsWith('.effect')) {
|
|
yield (0, utlis_2.import2DChunks)(false);
|
|
}
|
|
const converter = (0, convertor_1.getConverter)((0, path_1.extname)(info.path));
|
|
if (converter) {
|
|
yield converter.beforeImport(defaultAssetsRootPath, info.path);
|
|
const isDone = yield converter.import();
|
|
if (isDone) {
|
|
yield converter.afterImport();
|
|
}
|
|
}
|
|
const readmePath = (0, path_1.join)(Editor.Project.path, 'asset', 'migrate-resources', 'README.md');
|
|
if (!(0, fs_extra_1.existsSync)(readmePath)) {
|
|
(0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(readmePath));
|
|
(0, fs_extra_1.writeFileSync)(readmePath, (0, fs_extra_1.readFileSync)((0, path_1.join)(defaultAssetsRootPath, 'migrate-resources', 'README.md'), { encoding: 'utf8' }));
|
|
}
|
|
}
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
if (subAssets) {
|
|
return subAssets.uuid;
|
|
}
|
|
return info.baseUuid;
|
|
}
|
|
if (subAssets) {
|
|
return subAssets.uuid;
|
|
}
|
|
return uuid;
|
|
});
|
|
}
|
|
/*
|
|
* 通过 engine 进行序列化与反序列化
|
|
*/
|
|
queryCCClass(engine, message) {
|
|
return __awaiter(this, void 0, void 0, function* () {
|
|
engine.contentWindow.postMessage(message, '*');
|
|
return new Promise((resolve, reject) => {
|
|
function onMessageCb(event) {
|
|
window.removeEventListener("message", onMessageCb, false);
|
|
resolve(event.data);
|
|
}
|
|
window.addEventListener("message", onMessageCb, false);
|
|
});
|
|
});
|
|
}
|
|
replaceScript(name) {
|
|
try {
|
|
const defaultAssetsRootPath = (0, path_1.join)(__dirname, '../../static/migrate-resources/default-assets-2d/scripts');
|
|
const fromFsPath = (0, path_1.join)(defaultAssetsRootPath, name);
|
|
const destFsPath = (0, path_1.join)(Editor.Project.path, 'assets', 'default-assets-2d', 'scripts', name);
|
|
if (!(0, fs_extra_1.existsSync)(destFsPath)) {
|
|
(0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(destFsPath));
|
|
(0, fs_extra_1.copyFileSync)(fromFsPath, destFsPath);
|
|
}
|
|
const fromMetaPath = fromFsPath + '.meta';
|
|
const destMetaFsPath = destFsPath + '.meta';
|
|
if (!(0, fs_extra_1.existsSync)(destMetaFsPath)) {
|
|
(0, fs_extra_1.ensureDirSync)((0, path_1.dirname)(destMetaFsPath));
|
|
(0, fs_extra_1.copyFileSync)(fromMetaPath, destMetaFsPath);
|
|
}
|
|
const meta = (0, fs_extra_1.readJSONSync)(fromMetaPath);
|
|
// @ts-ignore
|
|
const EditorExtends = require('@base/electron-module').require('EditorExtends');
|
|
const UuidUtils = EditorExtends.UuidUtils;
|
|
return UuidUtils.compressUuid(meta.uuid, false);
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
return '';
|
|
}
|
|
}
|
|
//
|
|
ensureDefaultSprite2DFor3D(json3D) {
|
|
for (const key in json3D) {
|
|
const item = json3D[key];
|
|
if (item.__type__ === 'cc.StudioComponent') {
|
|
item.__type__ = this.replaceScript('studio-component.ts');
|
|
}
|
|
else if (item.__type__ === 'cc.StudioWidget') {
|
|
item.__type__ = this.replaceScript('studio-widget.ts');
|
|
}
|
|
}
|
|
return json3D;
|
|
}
|
|
}
|
|
exports.ImporterBase = ImporterBase;
|