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>
This commit is contained in:
2026-06-16 15:30:58 +08:00
parent cba5105908
commit d393302388
6248 changed files with 17322729 additions and 11036 deletions

View File

@@ -0,0 +1,474 @@
/**
* 用于导入 2d 项目到 3d 项目
*/
'use strict';
// @ts-ignore
import { v4 } from 'node-uuid';
import { nameToId } from './utlis';
import { relative, join, dirname, parse, extname, ParsedPath } from 'path';
// @ts-ignore
import { existsSync, ensureDirSync, copyFileSync, readJSONSync, writeJSONSync, readFileSync, writeFileSync } from 'fs-extra';
import {
migratePlatformSettings,
saveUuid,
getDefaultAssets2D,
getNewUuid,
import2DChunks,
importSubAssets, importProjectAssets,
} from './utlis';
import { UUID_2D_TO_3D, UUID_SKIP_EFFECT, UUID_UI_2D_TO_3D } from "./diff";
import { getConverter } from "../convertor";
export interface MessageInfo {
type: string; // 类型表示需要处理什么资源
json: any; // 实际资源的源数据
}
export abstract class ImporterBase {
public type: string = '';
// 导入到 3d 工程所在磁盘的路径
protected destFsPath: string = '';
protected destMetaFsPath: string = '';
// 2d 源文件所在磁盘的路径
protected sourceFsPath: string = '';
protected pathInfo: ParsedPath | null = null;
protected _2dMeta: any = null;
protected _3dMeta: any = null;
// 2d 源文件转成 3d 源文件,如果不为 null 说明需要保存
// 例如 animation、prefab、scene 之类的源文件
protected _2dTo3dSource: any = null;
// 检查 uuid 是否冲突,如果有就存储起来,后续会用到
async checkUuid(meta: any) {
const assetFsPath = await Editor.Message.request('asset-db', 'query-path', meta.uuid);
if (assetFsPath && assetFsPath !== this.destFsPath) {
const newUuid = v4();
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];
saveUuid(subMeta.uuid, subMeta.rawTextureUuid);
}
}
return meta.uuid;
}
get3DUuid() {
try {
const meta = readJSONSync(this.destMetaFsPath);
return meta.uuid;
}
catch (e) {
return v4();
}
}
public reset() {
this.destFsPath = '';
this.sourceFsPath = '';
this.pathInfo = null;
this._2dMeta = null;
this._3dMeta = null;
this._2dTo3dSource = null;
}
public static getPathInfo(projectRoot: string, sourceFsPath: string) {
let relativePath = relative(projectRoot, sourceFsPath);
if (!relativePath.startsWith('assets')) {
relativePath = join('assets', relativePath);
}
let to = 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 = readJSONSync(sourceFsPath + '.meta');
if (!meta.isPlugin) {
to = to.replace(/.js+$/g, '.ts');
}
}
return {
to: to,
toMeta: to + '.meta',
from: sourceFsPath,
fromMeta: sourceFsPath + '.meta',
pathInfo: parse(sourceFsPath),
};
}
public static isNew(projectRoot: string, sourceFsPath: string) {
try {
if (sourceFsPath.endsWith('assets')) {
return false;
}
const info = ImporterBase.getPathInfo(projectRoot, sourceFsPath);
if (existsSync(info.to) && existsSync(info.toMeta)) {
const _3DMeta = readJSONSync(info.toMeta);
if (_3DMeta.importer === 'directory') {
return false;
}
const _2DMeta = readJSONSync(info.fromMeta);
return _2DMeta.uuid !== _3DMeta.uuid;
}
return true;
}
catch (e) {
return true;
}
}
/*
* 导入前
* 参数一:项目的路径
* 参数二:项目的资源路径
*/
public async beforeImport(projectRoot: string, sourceFsPath: string): Promise<boolean> {
// 重置
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 ? await this.checkUuid(this._2dMeta) : this.get3DUuid();
this._3dMeta = this.createNewMeta(newUuid);
this._3dMeta.uuid = newUuid;
this._2dMeta && importProjectAssets.set(this._2dMeta.uuid, {
type: extname(sourceFsPath),
basePath: sourceFsPath,
outPath: this.destMetaFsPath,
outUuid: this._2dMeta.uuid,
meta: this._2dMeta,
});
return true;
}
public needImport() {
let doImport = true;
if (existsSync(this.destFsPath) && existsSync(this.destMetaFsPath)) {
const meta = 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;
}
/*
* 导入并且进行转换
*/
public async import(main?: any): Promise<boolean> {
return true;
}
/*
* 转换后进行报错跟拷贝源文件的处理
*/
public async afterImport() {
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')) {
writeFileSync(this.destFsPath, this._2dTo3dSource, { encoding: 'utf8' });
}
else {
writeJSONSync(this.destFsPath, this._2dTo3dSource, { spaces: 2 });
}
}
catch (e) { console.error(e); }
}
// console.log('保存:' + this.destFsPath);
this.saveMeta();
}
/*
* 创建新的 meta 对象
*/
public createNewMeta(uuid?: string) {
return {
uuid: uuid || '',
imported: false,
importer: '*',
files: [],
subMetas: {},
userData: {},
ver: '0.0.1',
};
}
/*
* 读取 meta
*/
public read2dMeta(sourceFsPath: string) {
try {
if (!sourceFsPath.endsWith('.meta')) {
sourceFsPath += '.meta';
}
if (!existsSync(sourceFsPath)) {
return null;
}
return readJSONSync(sourceFsPath);
}
catch (e) {
console.error(e);
return null;
}
}
/*
* 拷贝资源 + meta
*/
public copySync(from: string, to?: string) {
try {
if (!existsSync(from)) {
return 0;
}
if (to) {
ensureDirSync(dirname(to));
copyFileSync(from, to);
} else {
ensureDirSync(dirname(this.destFsPath));
copyFileSync(from, this.destFsPath);
}
}
catch (e) {
console.error(e);
}
}
/*
* 保存 meta
*/
public async saveMeta() {
if (!this.destMetaFsPath.endsWith('.meta')) {
this.destMetaFsPath += '.meta';
}
try {
writeJSONSync(this.destMetaFsPath, this._3dMeta, { spaces: 2 });
}
catch (e) {
console.error(e);
}
}
/*
* 保存
*/
public writeFileSync(to: string, data: any) {
try {
writeFileSync(to, data, { encoding: 'utf8' });
}
catch (e) {
console.error(e);
}
}
/*
* 加载源文件类型为 JSON
*/
public readJSONSync(sourceFsPath?: string) {
try {
return readJSONSync(sourceFsPath || this.sourceFsPath);
}
catch (e) {
console.error(e);
return null;
}
}
/*
* 加载源文件
*/
public readFileSync(sourceFsPath?: string) {
try {
return readFileSync(sourceFsPath || this.sourceFsPath, 'utf8');
}
catch (e) {
console.error(e);
return null;
}
}
/*
* 导入缓存纹理设置
*/
public async migratePlatformSettings(platformSettings: any) {
return await migratePlatformSettings(platformSettings);
}
static async getUuid(uuid: string, type?: string) {
if (UUID_2D_TO_3D.has(uuid)) {
return UUID_2D_TO_3D.get(uuid);
}
if (UUID_UI_2D_TO_3D.has(uuid)) {
return UUID_UI_2D_TO_3D.get(uuid);
}
if (UUID_SKIP_EFFECT.has(uuid)) {
console.warn(Editor.I18n.t('plugin-import-2x.effect_warn_tips', {
name: UUID_SKIP_EFFECT.get(uuid) as string,
}));
}
uuid = await ImporterBase.ensureDefaultAssets2DFor3D(uuid);
uuid = getNewUuid(uuid);
if (type && !uuid.includes('@')) {
const id = `@${ImporterBase.getNameByID(type)}`;
if (!uuid.endsWith(id)) {
uuid += id;
}
}
return uuid;
}
static getNewUuid(uuid: string) {
return getNewUuid(uuid);
}
/*
* 通过名字获取 id
*/
static getNameByID(name: string) {
return nameToId(name);
}
/*
* 创建默认资源
*/
static getDefaultAssets2D(uuid: string) {
return getDefaultAssets2D(uuid);
}
/*
* 创建 2d 默认资源
*/
static async ensureDefaultAssets2DFor3D(uuid: string) {
const subAssets = importSubAssets.get(uuid);
if (subAssets) {
uuid = subAssets.baseUuid;
}
else {
const projectAssets = importProjectAssets.get(uuid);
if (projectAssets) {
uuid = projectAssets.outUuid;
}
}
const info = getDefaultAssets2D(uuid);
if (info && info.path) {
// 如果是内置资源与 3d 的一致就直接用 3D 的
if (UUID_UI_2D_TO_3D.has(info.baseUuid)) {
return UUID_UI_2D_TO_3D.get(info.baseUuid);
}
if (UUID_2D_TO_3D.has(info.baseUuid)) {
return UUID_2D_TO_3D.get(info.baseUuid);
}
const defaultAssetsRootPath = join(__dirname, '../../static');
let relativePath = relative(defaultAssetsRootPath, info.path);
if (!relativePath.startsWith('assets')) {
relativePath = join('assets', relativePath);
}
const destFsPath = join(Editor.Project.path, relativePath);
try {
if (!existsSync(destFsPath)) {
if (destFsPath.endsWith('.mtl') || destFsPath.endsWith('.effect')) {
await import2DChunks(false);
}
const converter = getConverter(extname(info.path));
if (converter) {
await converter.beforeImport(defaultAssetsRootPath, info.path);
const isDone = await converter.import();
if (isDone) {
await converter.afterImport();
}
}
const readmePath = join(Editor.Project.path, 'asset', 'migrate-resources', 'README.md');
if (!existsSync(readmePath)) {
ensureDirSync(dirname(readmePath));
writeFileSync(readmePath, readFileSync(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 进行序列化与反序列化
*/
async queryCCClass(engine: any, message: any) {
engine.contentWindow.postMessage(message, '*');
return new Promise((resolve, reject) => {
function onMessageCb(event: any) {
window.removeEventListener("message", onMessageCb, false);
resolve(event.data);
}
window.addEventListener("message", onMessageCb, false);
});
}
replaceScript(name: string) {
try {
const defaultAssetsRootPath = join(__dirname, '../../static/migrate-resources/default-assets-2d/scripts');
const fromFsPath = join(defaultAssetsRootPath, name);
const destFsPath = join(Editor.Project.path, 'assets', 'default-assets-2d', 'scripts', name);
if (!existsSync(destFsPath)) {
ensureDirSync(dirname(destFsPath));
copyFileSync(fromFsPath, destFsPath);
}
const fromMetaPath = fromFsPath + '.meta';
const destMetaFsPath = destFsPath + '.meta';
if (!existsSync(destMetaFsPath)) {
ensureDirSync(dirname(destMetaFsPath));
copyFileSync(fromMetaPath, destMetaFsPath);
}
const meta = readJSONSync(fromMetaPath);
// @ts-ignore
const EditorExtends: any = require('@base/electron-module').require('EditorExtends');
const UuidUtils = EditorExtends.UuidUtils;
return UuidUtils.compressUuid(meta.uuid, false);
}
catch (e) {
console.error(e);
return '';
}
}
//
ensureDefaultSprite2DFor3D(json3D: any) {
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;
}
}