Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

refactor: update build pipeline and preview template for multi-version Spine

esengineee6aab38c0bf
diff --git a/desktop/src-tauri/src/preview_template.html b/desktop/src-tauri/src/preview_template.html
index cd485aa3a..d73f08413 100644
--- a/desktop/src-tauri/src/preview_template.html
+++ b/desktop/src-tauri/src/preview_template.html
@@ -358,11 +358,22 @@
return { width: canvas.width, height: canvas.height };
}
- const SPINE_WASM_MAP = {
- '3.8': '/wasm/spine38.js',
- '4.1': '/wasm/spine41.js',
- '4.2': '/wasm/spine42.js',
- };
+ function createHttpSpineProvider() {
+ return {
+ async loadJs(version) {
+ const tag = version.replace('.', '');
+ const resp = await fetch('/wasm/spine' + tag + '.js');
+ if (!resp.ok) throw new Error('Failed to fetch spine' + tag + '.js: ' + resp.status);
+ return resp.text();
+ },
+ async loadWasm(version) {
+ const tag = version.replace('.', '');
+ const resp = await fetch('/wasm/spine' + tag + '.wasm');
+ if (!resp.ok) throw new Error('Failed to fetch spine' + tag + '.wasm: ' + resp.status);
+ return resp.arrayBuffer();
+ },
+ };
+ }
function loadUmdScript(url) {
return new Promise((resolve, reject) => {
@@ -414,24 +425,15 @@
const sdk = await withTimeout(import('/sdk/index.js'), 30000, 'SDK import');
window.__esSdk = sdk;
- let spinePlugin = null;
let physicsPlugin = null;
let config = {};
try {
const configResp = await fetch('/.esengine/preview/config.json');
if (configResp.ok) {
config = await configResp.json();
- const spineUrl = config.spineVersion && SPINE_WASM_MAP[config.spineVersion];
- if (spineUrl) {
- step = 'load Spine ' + config.spineVersion;
- updateLoading('Loading Spine ' + config.spineVersion + '...');
- await loadUmdScript(spineUrl);
- const { SpinePlugin } = await import('esengine/spine');
- spinePlugin = new SpinePlugin(spineUrl, window.ESSpineModule);
- }
}
} catch (e) {
- console.warn('Spine module load skipped:', e);
+ console.warn('Config load skipped:', e);
}
if (config.enablePhysics) {
@@ -490,7 +492,8 @@
const previewPlugin = new sdk.PreviewPlugin('/.esengine/preview/scene.json', '/');
const app = sdk.createWebApp(Module, {
- getViewportSize: getCanvasViewportSize
+ getViewportSize: getCanvasViewportSize,
+ spineProvider: createHttpSpineProvider(),
});
if (config.maxDeltaTime !== undefined) app.setMaxDeltaTime(config.maxDeltaTime);
if (config.maxFixedSteps !== undefined) app.setMaxFixedSteps(config.maxFixedSteps);
@@ -499,9 +502,6 @@
sdk.flushPendingSystems(app);
step = 'add plugins';
- if (spinePlugin) {
- app.addPlugin(spinePlugin);
- }
if (physicsPlugin) {
app.addPlugin(physicsPlugin);
}
diff --git a/desktop/src/main.ts b/desktop/src/main.ts
index 908a165a8..7bc299de7 100644
--- a/desktop/src/main.ts
+++ b/desktop/src/main.ts
@@ -71,12 +71,6 @@ async function showLauncher(container: HTMLElement): Promise<void> {
});
}
-const SPINE_WASM_MAP: Record<string, string> = {
- '3.8': '/wasm/spine38.js',
- '4.1': '/wasm/spine41.js',
- '4.2': '/wasm/spine42.js',
-};
-
async function loadPhysicsFactory(editor: Editor): Promise<void> {
try {
const factory = await loadUmdModule('/wasm/physics.js', 'ESPhysicsModule');
@@ -101,33 +95,6 @@ async function openEditor(container: HTMLElement, projectPath: string): Promise<
const config = await loadProjectConfig(projectPath);
await loadPhysicsFactory(editor);
-
- const spineVersion = config?.spineVersion ?? '4.2';
- await loadSpineModule(editor, spineVersion);
-
- editor.onSpineVersionChange((version) => {
- loadSpineModule(editor, version);
- });
-}
-
-async function loadSpineModule(editor: Editor, version: string): Promise<void> {
- const url = SPINE_WASM_MAP[version];
- if (!url) return;
- try {
- const factory = await loadUmdModule(url, 'ESSpineModule');
- const wasmFile = url.replace(/\.js$/, '.wasm');
- const module = await factory({
- locateFile: (path: string) => {
- if (path.endsWith('.wasm')) {
- return wasmFile;
- }
- return path;
- },
- });
- editor.setSpineModule(module, version);
- } catch (e) {
- console.warn(`Failed to load Spine ${version} module:`, e);
- }
}
function loadUmdModule(url: string, globalName: string): Promise<any> {
diff --git a/editor/src/builder/ArtifactBuilder.ts b/editor/src/builder/ArtifactBuilder.ts
index 7e5a57bf2..b34d54efc 100644
--- a/editor/src/builder/ArtifactBuilder.ts
+++ b/editor/src/builder/ArtifactBuilder.ts
@@ -17,7 +17,8 @@ import { getAssetType, toAddressableType } from '../asset/AssetTypes';
import { compileMaterials } from './MaterialCompiler';
import { convertPrefabAssetRefs, deserializePrefab } from '../prefab';
import type { PrefabData } from '../types/PrefabTypes';
-import { toBuildPath, getComponentAssetFieldDescriptors, getComponentDefaults, registerAssetBuildTransform } from 'esengine';
+import { toBuildPath, getComponentAssetFieldDescriptors, getComponentDefaults, registerAssetBuildTransform, getComponentSpineFieldDescriptor } from 'esengine';
+import { SpineManager } from 'esengine/spine';
import { normalizePath, joinPath, isAbsolutePath, getParentDir } from '../utils/path';
import { getEsbuildWasmURL } from '../context/EditorContext';
import { getSettingsValue } from '../settings/SettingsRegistry';
@@ -158,6 +159,8 @@ export async function buildArtifact(
scenes.set(name, data);
}
+ const spineVersions = await scanSpineVersions(fs, projectDir, sceneDataList, assetLibrary);
+
return {
scenes,
assetPaths,
@@ -166,9 +169,62 @@ export async function buildArtifact(
compiledMaterials,
assetLibrary,
atlasInputHash,
+ spineVersions,
};
}
+async function scanSpineVersions(
+ fs: NativeFS,
+ projectDir: string,
+ sceneDataList: Array<{ name: string; data: Record<string, unknown> }>,
+ assetLibrary: AssetLibrary,
+): Promise<Set<string>> {
+ const versions = new Set<string>();
+ const scanned = new Set<string>();
+
+ for (const { data } of sceneDataList) {
+ const entities = data.entities as Array<{
+ components: Array<{ type: string; data: Record<string, unknown> }>;
+ }> | undefined;
+ if (!entities) continue;
+
+ for (const entity of entities) {
+ for (const comp of entity.components || []) {
+ const spineDesc = getComponentSpineFieldDescriptor(comp.type);
+ if (!spineDesc || !comp.data) continue;
+
+ let skelRef = comp.data[spineDesc.skeletonField] as string;
+ if (!skelRef) continue;
+ if (isUUID(skelRef)) {
+ skelRef = assetLibrary.getPath(skelRef) ?? skelRef;
+ }
+ if (scanned.has(skelRef)) continue;
+ scanned.add(skelRef);
+
+ const fullPath = joinPath(projectDir, skelRef);
+ try {
+ const isBinary = skelRef.endsWith('.skel');
+ if (isBinary) {
+ const data = await fs.readBinaryFile(fullPath);
+ if (data) {
+ const ver = SpineManager.detectVersion(data);
+ if (ver) versions.add(ver);
+ }
+ } else {
+ const text = await fs.readFile(fullPath);
+ if (text) {
+ const ver = SpineManager.detectVersionJson(text);
+ if (ver) versions.add(ver);
+ }
+ }
+ } catch { /* skip unreadable skeleton */ }
+ }
+ }
+ }
+
+ return versions;
+}
+
function collectNonAtlasCapableTextures(
sceneDataList: Array<{ name: string; data: Record<string, unknown> }>,
assetLibrary: AssetLibrary,
diff --git a/editor/src/builder/PlatformEmitter.ts b/editor/src/builder/PlatformEmitter.ts
index 6a4b4755f..daed0eeb9 100644
--- a/editor/src/builder/PlatformEmitter.ts
+++ b/editor/src/builder/PlatformEmitter.ts
@@ -20,6 +20,7 @@ export interface BuildArtifact {
compiledMaterials: CompiledMaterial[];
assetLibrary: AssetDatabase;
atlasInputHash?: string;
+ spineVersions: Set<string>;
}
export interface PlatformEmitter {
diff --git a/editor/src/builder/PlayableEmitter.ts b/editor/src/builder/PlayableEmitter.ts
index 806d3501e..22d548829 100644
--- a/editor/src/builder/PlayableEmitter.ts
+++ b/editor/src/builder/PlayableEmitter.ts
@@ -72,17 +72,21 @@ export class PlayableEmitter implements PlatformEmitter {
return { success: false, error: `Startup scene not found: ${startupScene}` };
}
- // 4. Load spine module if needed
+ // 4. Load spine modules if needed
progress.setCurrentTask('Loading modules...', 25);
- let spineJsSource = '';
- let spineWasmBase64 = '';
- if (context.spineVersion && fs.getSpineJs) {
- const spineJs = await fs.getSpineJs(context.spineVersion);
- const spineWasm = await fs.getSpineWasm(context.spineVersion);
+ const spineModules: Array<{ version: string; js: string; wasmBase64: string }> = [];
+ for (const version of artifact.spineVersions) {
+ if (version === '4.2') continue;
+ if (!fs.getSpineJs) continue;
+ const spineJs = await fs.getSpineJs(version);
+ const spineWasm = await fs.getSpineWasm(version);
if (spineJs && spineWasm.length > 0) {
- spineJsSource = spineJs;
- spineWasmBase64 = arrayBufferToBase64(spineWasm);
- progress.log('info', `Spine ${context.spineVersion} module loaded`);
+ spineModules.push({
+ version,
+ js: spineJs,
+ wasmBase64: arrayBufferToBase64(spineWasm),
+ });
+ progress.log('info', `Spine ${version} module loaded`);
}
}
@@ -117,7 +121,7 @@ export class PlayableEmitter implements PlatformEmitter {
progress.setCurrentTask('Assembling HTML...', 50);
const html = this.assembleHTML(
wasmSdk, gameCode, allScenes, startupSceneName, assets,
- spineJsSource, spineWasmBase64,
+ spineModules,
physicsJsSource, physicsWasmBase64,
context, manifestJson
);
@@ -318,7 +322,7 @@ const __plugins = [${pluginList}];
wasmSdk: string, gameCode: string,
allScenes: Array<{ name: string; data: string }>, startupScene: string,
assets: Map<string, string>,
- spineJs: string, spineWasmBase64: string,
+ spineModules: Array<{ version: string; js: string; wasmBase64: string }>,
physicsJs: string, physicsWasmBase64: string,
context: BuildContext, manifestJson: string
): string {
@@ -328,8 +332,17 @@ const __plugins = [${pluginList}];
}
let spineScript = '';
- if (spineJs && spineWasmBase64) {
- spineScript = `<script>\nvar __SPINE_WASM_B64__="${spineWasmBase64}";\n${spineJs}\n</script>`;
+ if (spineModules.length > 0) {
+ const parts = spineModules.map(m => {
+ const tag = m.version.replace('.', '');
+ return `var __SPINE_${tag}_WASM_B64__="${m.wasmBase64}";\nvar __SPINE_${tag}_MODULE__=(function(){${m.js};return ESSpineModule;})();`;
+ });
+ const moduleEntries = spineModules.map(m => {
+ const tag = m.version.replace('.', '');
+ return `"${m.version}":{factory:__SPINE_${tag}_MODULE__,wasmBase64:__SPINE_${tag}_WASM_B64__}`;
+ });
+ parts.push(`var __ES_SPINE_MODULES__={${moduleEntries.join(',')}};`);
+ spineScript = `<script>\n${parts.join('\n')}\n</script>`;
}
let physicsScript = '';
diff --git a/editor/src/builder/WeChatEmitter.ts b/editor/src/builder/WeChatEmitter.ts
index dfde811b0..28b1b4470 100644
--- a/editor/src/builder/WeChatEmitter.ts
+++ b/editor/src/builder/WeChatEmitter.ts
@@ -59,7 +59,7 @@ export class WeChatEmitter implements PlatformEmitter {
// 3. Compile and generate game.js
progress.setPhase('compiling');
progress.setCurrentTask('Compiling scripts...', 0);
- await this.generateGameJs(fs, projectDir, outputDir, context);
+ await this.generateGameJs(fs, projectDir, outputDir, context, artifact);
progress.log('info', 'Generated game.js');
// 4. Write atlas pages
@@ -215,7 +215,8 @@ export class WeChatEmitter implements PlatformEmitter {
fs: NativeFS,
projectDir: string,
outputDir: string,
- context: BuildContext
+ context: BuildContext,
+ artifact: BuildArtifact,
): Promise<void> {
const { imports, hasSrcDir } = await collectUserScriptImports(fs, projectDir);
@@ -244,20 +245,21 @@ export class WeChatEmitter implements PlatformEmitter {
userCode,
firstSceneName,
allSceneNames,
- hasSpine: !!context.spineVersion,
+ spineVersions: [...artifact.spineVersions],
hasPhysics: !!context.enablePhysics,
physicsConfig,
runtimeConfig: context.runtimeConfig,
});
await fs.writeFile(joinPath(outputDir, 'game.js'), gameJs);
- await this.copyWeChatSdk(fs, outputDir, context);
+ await this.copyWeChatSdk(fs, outputDir, context, artifact);
}
private async copyWeChatSdk(
fs: NativeFS,
outputDir: string,
- context: BuildContext
+ context: BuildContext,
+ artifact: BuildArtifact,
): Promise<void> {
const engineJs = await fs.getEngineWxgameJs();
const engineWasm = await fs.getEngineWxgameWasm();
@@ -276,13 +278,14 @@ export class WeChatEmitter implements PlatformEmitter {
await fs.writeFile(joinPath(outputDir, 'sdk.js'), sdkJs);
}
- const spineVersion = context.spineVersion;
- if (spineVersion) {
- const spineJs = await fs.getSpineJs(spineVersion);
- const spineWasm = await fs.getSpineWasm(spineVersion);
+ for (const version of artifact.spineVersions) {
+ if (version === '4.2') continue;
+ const spineJs = await fs.getSpineJs(version);
+ const spineWasm = await fs.getSpineWasm(version);
if (spineJs && spineWasm.length > 0) {
- await fs.writeFile(joinPath(outputDir, 'spine.js'), spineJs);
- await fs.writeBinaryFile(joinPath(outputDir, 'spine.wasm'), spineWasm);
+ const tag = version.replace('.', '');
+ await fs.writeFile(joinPath(outputDir, `spine_${tag}.js`), spineJs);
+ await fs.writeBinaryFile(joinPath(outputDir, `spine_${tag}.wasm`), spineWasm);
}
}
diff --git a/editor/src/builder/templates.ts b/editor/src/builder/templates.ts
index 383e85848..74b7ce183 100644
--- a/editor/src/builder/templates.ts
+++ b/editor/src/builder/templates.ts
@@ -62,7 +62,7 @@ window.fetch=function(u,o){var d=typeof u==='string'&&__PA__[u];return d?_fetch.
await es.initPlayableRuntime({
app:app,module:Module,canvas:c,
assets:__PA__,scenes:__SCENES__,firstScene:'{{STARTUP_SCENE}}',
- spineWasmBase64:typeof __SPINE_WASM_B64__!=='undefined'?__SPINE_WASM_B64__:undefined,
+ spineModules:typeof __ES_SPINE_MODULES__!=='undefined'?__ES_SPINE_MODULES__:undefined,
physicsWasmBase64:typeof __PHYSICS_WASM_B64__!=='undefined'?__PHYSICS_WASM_B64__:undefined,
physicsConfig:{{PHYSICS_CONFIG}},manifest:__MANIFEST__
});
@@ -80,17 +80,27 @@ export interface WeChatGameJsParams {
userCode: string;
firstSceneName: string;
allSceneNames: string[];
- hasSpine: boolean;
+ spineVersions: string[];
hasPhysics: boolean;
physicsConfig: string;
runtimeConfig?: RuntimeBuildConfig;
}
export function generateWeChatGameJs(params: WeChatGameJsParams): string {
- const { userCode, firstSceneName, allSceneNames, hasSpine, hasPhysics, physicsConfig, runtimeConfig } = params;
+ const { userCode, firstSceneName, allSceneNames, spineVersions, hasPhysics, physicsConfig, runtimeConfig } = params;
const runtimeConfigJson = runtimeConfig ? JSON.stringify(runtimeConfig) : 'undefined';
+ const nonNativeVersions = spineVersions.filter(v => v !== '4.2');
+ let spineFactoriesCode = '';
+ if (nonNativeVersions.length > 0) {
+ const entries = nonNativeVersions.map(v => {
+ const tag = v.replace('.', '');
+ return `"${v}": require('./spine_${tag}.js')`;
+ });
+ spineFactoriesCode = `spineFactories: {${entries.join(', ')}},`;
+ }
+
return `
var ESEngineModule = require('./esengine.js');
var SDK = require('./sdk.js');
@@ -106,7 +116,7 @@ ${userCode}
firstScene: ${JSON.stringify(firstSceneName)},
runtimeConfig: ${runtimeConfigJson},
physicsConfig: ${physicsConfig},
- ${hasSpine ? "spineFactory: require('./spine.js')," : ''}
+ ${spineFactoriesCode}
${hasPhysics ? "physicsFactory: require('./physics.js')," : ''}
});
} catch (err) {