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.

feat: add modular engine compilation with toolchain management

esengine76feb0857951
diff --git a/.github/workflows/release-desktop.yml b/.github/workflows/release-desktop.yml
index acdf84379..5bca97a5d 100644
--- a/.github/workflows/release-desktop.yml
+++ b/.github/workflows/release-desktop.yml
@@ -65,6 +65,9 @@ jobs:
- name: Build engine and sync to desktop
run: node build-tools/cli.js build -t all
+ - name: Package engine source for toolchain
+ run: node build-tools/cli.js toolchain
+
- name: Build workspace packages
run: pnpm --filter ./sdk build && pnpm --filter ./editor build
diff --git a/.gitignore b/.gitignore
index 7f1230738..3a1266c2c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -78,3 +78,7 @@ Testing/
CTestTestfile.cmake
coverage/
design/
+
+# Toolchain (downloaded by build-tools/toolchain/package.js)
+desktop/src-tauri/toolchain/
+!desktop/src-tauri/toolchain/.gitkeep
diff --git a/CMakeLists.txt b/CMakeLists.txt
index f5c88d516..12e77f9c7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -11,6 +11,11 @@ option(ES_BUILD_TESTS "Build tests" ON)
option(ES_BUILD_SINGLE_FILE "Build single-file SDK (WASM inlined)" OFF)
option(ES_ENABLE_SPINE "Enable Spine animation support" ON)
option(ES_ENABLE_BOX2D "Enable Box2D physics support" OFF)
+option(ES_ENABLE_TILEMAP "Enable Tilemap support" ON)
+option(ES_ENABLE_PARTICLES "Enable Particle system" ON)
+option(ES_ENABLE_TIMELINE "Enable Timeline animation" ON)
+option(ES_ENABLE_POSTPROCESS "Enable Post-processing pipeline" ON)
+option(ES_ENABLE_BITMAP_TEXT "Enable Bitmap text rendering" ON)
option(ES_BUILD_MAIN_MODULE "Build as MAIN_MODULE for dynamic linking" OFF)
option(ES_BUILD_SIDE_MODULE "Build side modules for dynamic linking" OFF)
@@ -46,7 +51,6 @@ set(ESENGINE_SOURCES
src/esengine/renderer/RenderTarget.cpp
src/esengine/renderer/ImmediateDraw.cpp
src/esengine/renderer/CustomGeometry.cpp
- src/esengine/renderer/PostProcessPipeline.cpp
src/esengine/renderer/StateTracker.cpp
src/esengine/renderer/TransientBufferPool.cpp
src/esengine/renderer/DrawList.cpp
@@ -54,19 +58,43 @@ set(ESENGINE_SOURCES
src/esengine/renderer/plugins/UIElementPlugin.cpp
src/esengine/renderer/plugins/TextPlugin.cpp
src/esengine/renderer/plugins/ShapePlugin.cpp
- src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
- src/esengine/renderer/plugins/ParticlePlugin.cpp
- src/esengine/text/BitmapFont.cpp
src/esengine/platform/input/Input.cpp
src/esengine/platform/PathResolver.cpp
src/esengine/animation/TweenSystem.cpp
- src/esengine/animation/TimelineSystem.cpp
- src/esengine/particle/Particle.cpp
- src/esengine/particle/ParticleSystem.cpp
- src/esengine/tilemap/TilemapSystem.cpp
- src/esengine/tilemap/TiledMapLoader.cpp
)
+if(ES_ENABLE_POSTPROCESS)
+ list(APPEND ESENGINE_SOURCES
+ src/esengine/renderer/PostProcessPipeline.cpp
+ )
+endif()
+
+if(ES_ENABLE_TILEMAP)
+ list(APPEND ESENGINE_SOURCES
+ src/esengine/renderer/plugins/TilemapRenderPlugin.cpp
+ src/esengine/tilemap/TilemapSystem.cpp
+ src/esengine/tilemap/TiledMapLoader.cpp
+ )
+endif()
+
+if(ES_ENABLE_PARTICLES)
+ list(APPEND ESENGINE_SOURCES
+ src/esengine/renderer/plugins/ParticlePlugin.cpp
+ src/esengine/particle/Particle.cpp
+ src/esengine/particle/ParticleSystem.cpp
+ )
+endif()
+
+if(ES_ENABLE_TIMELINE)
+ list(APPEND ESENGINE_SOURCES
+ src/esengine/animation/TimelineSystem.cpp
+ )
+endif()
+
+ list(APPEND ESENGINE_SOURCES
+ src/esengine/text/BitmapFont.cpp
+ )
+
if(ES_ENABLE_SPINE)
list(APPEND ESENGINE_SOURCES
src/esengine/spine/SpineExtension.cpp
@@ -98,7 +126,6 @@ set(ESENGINE_HEADERS
src/esengine/ecs/components/Common.hpp
src/esengine/ecs/components/SpineAnimation.hpp
src/esengine/ecs/components/BitmapText.hpp
- src/esengine/text/BitmapFont.hpp
src/esengine/math/Math.hpp
src/esengine/resource/Handle.hpp
src/esengine/resource/ResourcePool.hpp
@@ -118,7 +145,6 @@ set(ESENGINE_HEADERS
src/esengine/renderer/ImmediateDraw.hpp
src/esengine/renderer/BlendMode.hpp
src/esengine/renderer/CustomGeometry.hpp
- src/esengine/renderer/PostProcessPipeline.hpp
src/esengine/renderer/StateTracker.hpp
src/esengine/renderer/TransientBufferPool.hpp
src/esengine/renderer/DrawCommand.hpp
@@ -129,9 +155,7 @@ set(ESENGINE_HEADERS
src/esengine/renderer/plugins/UIElementPlugin.hpp
src/esengine/renderer/plugins/TextPlugin.hpp
src/esengine/renderer/plugins/ShapePlugin.hpp
- src/esengine/renderer/plugins/TilemapRenderPlugin.hpp
src/esengine/renderer/plugins/SpinePlugin.hpp
- src/esengine/renderer/plugins/ParticlePlugin.hpp
src/esengine/platform/Platform.hpp
src/esengine/platform/FileSystem.hpp
src/esengine/platform/input/Input.hpp
@@ -143,12 +167,40 @@ set(ESENGINE_HEADERS
src/esengine/animation/TweenData.hpp
src/esengine/animation/EasingFunctions.hpp
src/esengine/animation/TweenSystem.hpp
- src/esengine/animation/TimelineData.hpp
- src/esengine/animation/TimelineSystem.hpp
- src/esengine/tilemap/TilemapSystem.hpp
- src/esengine/tilemap/TiledMapLoader.hpp
)
+if(ES_ENABLE_POSTPROCESS)
+ list(APPEND ESENGINE_HEADERS
+ src/esengine/renderer/PostProcessPipeline.hpp
+ )
+endif()
+
+if(ES_ENABLE_TILEMAP)
+ list(APPEND ESENGINE_HEADERS
+ src/esengine/renderer/plugins/TilemapRenderPlugin.hpp
+ src/esengine/tilemap/TilemapSystem.hpp
+ src/esengine/tilemap/TiledMapLoader.hpp
+ )
+endif()
+
+if(ES_ENABLE_PARTICLES)
+ list(APPEND ESENGINE_HEADERS
+ src/esengine/renderer/plugins/ParticlePlugin.hpp
+ src/esengine/particle/ParticleSystem.hpp
+ )
+endif()
+
+if(ES_ENABLE_TIMELINE)
+ list(APPEND ESENGINE_HEADERS
+ src/esengine/animation/TimelineData.hpp
+ src/esengine/animation/TimelineSystem.hpp
+ )
+endif()
+
+ list(APPEND ESENGINE_HEADERS
+ src/esengine/text/BitmapFont.hpp
+ )
+
if(ES_ENABLE_SPINE)
list(APPEND ESENGINE_HEADERS
src/esengine/spine/SpineExtension.hpp
@@ -232,7 +284,28 @@ target_include_directories(esengine
${CMAKE_CURRENT_SOURCE_DIR}/third_party/stb
)
-target_link_libraries(esengine PUBLIC glm cute_tiled)
+target_link_libraries(esengine PUBLIC glm)
+
+if(ES_ENABLE_TILEMAP)
+ target_link_libraries(esengine PUBLIC cute_tiled)
+ target_compile_definitions(esengine PUBLIC ES_ENABLE_TILEMAP)
+endif()
+
+if(ES_ENABLE_PARTICLES)
+ target_compile_definitions(esengine PUBLIC ES_ENABLE_PARTICLES)
+endif()
+
+if(ES_ENABLE_TIMELINE)
+ target_compile_definitions(esengine PUBLIC ES_ENABLE_TIMELINE)
+endif()
+
+if(ES_ENABLE_POSTPROCESS)
+ target_compile_definitions(esengine PUBLIC ES_ENABLE_POSTPROCESS)
+endif()
+
+if(ES_ENABLE_BITMAP_TEXT)
+ target_compile_definitions(esengine PUBLIC ES_ENABLE_BITMAP_TEXT)
+endif()
if(ES_ENABLE_SPINE)
target_link_libraries(esengine PUBLIC spine-cpp)
@@ -262,17 +335,26 @@ esengine_set_strict_warnings(esengine)
# =============================================================================
if(ES_BUILD_WEB OR ES_BUILD_WXGAME)
- add_executable(esengine_sdk
+ set(SDK_BINDING_SOURCES
src/esengine/bindings/WebSDKEntry.cpp
src/esengine/bindings/EngineContext.cpp
src/esengine/bindings/ResourceManagerBindings.cpp
src/esengine/bindings/RendererBindings.cpp
src/esengine/bindings/ImmediateDrawBindings.cpp
src/esengine/bindings/GeometryBindings.cpp
- src/esengine/bindings/PostProcessBindings.cpp
- src/esengine/bindings/TilemapBindings.cpp
- src/esengine/bindings/TimelineBindings.cpp
- ${GENERATED_WEB_BINDINGS})
+ ${GENERATED_WEB_BINDINGS}
+ )
+ if(ES_ENABLE_POSTPROCESS)
+ list(APPEND SDK_BINDING_SOURCES src/esengine/bindings/PostProcessBindings.cpp)
+ endif()
+ if(ES_ENABLE_TILEMAP)
+ list(APPEND SDK_BINDING_SOURCES src/esengine/bindings/TilemapBindings.cpp)
+ endif()
+ if(ES_ENABLE_TIMELINE)
+ list(APPEND SDK_BINDING_SOURCES src/esengine/bindings/TimelineBindings.cpp)
+ endif()
+
+ add_executable(esengine_sdk ${SDK_BINDING_SOURCES})
target_link_libraries(esengine_sdk PRIVATE esengine)
es_apply_sdk_settings(esengine_sdk)
@@ -283,16 +365,7 @@ if(ES_BUILD_WEB OR ES_BUILD_WXGAME)
# Single-file SDK (WASM inlined as Base64, for playable ads)
if(ES_BUILD_SINGLE_FILE)
- add_executable(esengine_single
- src/esengine/bindings/WebSDKEntry.cpp
- src/esengine/bindings/EngineContext.cpp
- src/esengine/bindings/ResourceManagerBindings.cpp
- src/esengine/bindings/RendererBindings.cpp
- src/esengine/bindings/ImmediateDrawBindings.cpp
- src/esengine/bindings/GeometryBindings.cpp
- src/esengine/bindings/PostProcessBindings.cpp
- src/esengine/bindings/TilemapBindings.cpp
- ${GENERATED_WEB_BINDINGS})
+ add_executable(esengine_single ${SDK_BINDING_SOURCES})
target_link_libraries(esengine_single PRIVATE esengine)
es_apply_single_file_settings(esengine_single)
@@ -380,16 +453,7 @@ html,body{width:100%;height:100%;overflow:hidden;background:#1a1a1a}
# WeChat MiniGame SDK (CommonJS compatible)
if(ES_BUILD_WXGAME)
- add_executable(esengine_wxgame
- src/esengine/bindings/WebSDKEntry.cpp
- src/esengine/bindings/EngineContext.cpp
- src/esengine/bindings/ResourceManagerBindings.cpp
- src/esengine/bindings/RendererBindings.cpp
- src/esengine/bindings/ImmediateDrawBindings.cpp
- src/esengine/bindings/GeometryBindings.cpp
- src/esengine/bindings/PostProcessBindings.cpp
- src/esengine/bindings/TilemapBindings.cpp
- ${GENERATED_WEB_BINDINGS})
+ add_executable(esengine_wxgame ${SDK_BINDING_SOURCES})
target_link_libraries(esengine_wxgame PRIVATE esengine)
es_apply_wxgame_sdk_settings(esengine_wxgame)
@@ -478,16 +542,7 @@ html,body{width:100%;height:100%;overflow:hidden;background:#1a1a1a}
# Main module SDK (MAIN_MODULE=2, supports loading side modules)
if(ES_BUILD_MAIN_MODULE)
- add_executable(esengine_sdk_main
- src/esengine/bindings/WebSDKEntry.cpp
- src/esengine/bindings/EngineContext.cpp
- src/esengine/bindings/ResourceManagerBindings.cpp
- src/esengine/bindings/RendererBindings.cpp
- src/esengine/bindings/ImmediateDrawBindings.cpp
- src/esengine/bindings/GeometryBindings.cpp
- src/esengine/bindings/PostProcessBindings.cpp
- src/esengine/bindings/TilemapBindings.cpp
- ${GENERATED_WEB_BINDINGS})
+ add_executable(esengine_sdk_main ${SDK_BINDING_SOURCES})
target_link_libraries(esengine_sdk_main PRIVATE esengine)
es_apply_main_module_settings(esengine_sdk_main)
set_target_properties(esengine_sdk_main PROPERTIES
@@ -496,16 +551,7 @@ html,body{width:100%;height:100%;overflow:hidden;background:#1a1a1a}
)
if(ES_BUILD_WXGAME)
- add_executable(esengine_wxgame_main
- src/esengine/bindings/WebSDKEntry.cpp
- src/esengine/bindings/EngineContext.cpp
- src/esengine/bindings/ResourceManagerBindings.cpp
- src/esengine/bindings/RendererBindings.cpp
- src/esengine/bindings/ImmediateDrawBindings.cpp
- src/esengine/bindings/GeometryBindings.cpp
- src/esengine/bindings/PostProcessBindings.cpp
- src/esengine/bindings/TilemapBindings.cpp
- ${GENERATED_WEB_BINDINGS})
+ add_executable(esengine_wxgame_main ${SDK_BINDING_SOURCES})
target_link_libraries(esengine_wxgame_main PRIVATE esengine)
es_apply_wxgame_main_module_settings(esengine_wxgame_main)
set_target_properties(esengine_wxgame_main PROPERTIES
diff --git a/build-tools/cli.js b/build-tools/cli.js
index 4277d0781..560a35934 100644
--- a/build-tools/cli.js
+++ b/build-tools/cli.js
@@ -202,4 +202,18 @@ program
logger.printTime(Date.now() - startTime);
});
+program
+ .command('toolchain')
+ .description('Package local emsdk + cmake into Tauri resources for bundling')
+ .option('--no-strip', 'Skip stripping unnecessary files')
+ .option('--no-archive', 'Skip creating tar.gz archive')
+ .action(async (options) => {
+ const args = [import.meta.dirname + '/toolchain/package.js'];
+ if (!options.strip) args.push('--no-strip');
+ if (!options.archive) args.push('--no-archive');
+
+ const { execSync } = await import('child_process');
+ execSync(`node ${args.join(' ')}`, { stdio: 'inherit', cwd: config.paths.root });
+ });
+
program.parse();
diff --git a/build-tools/toolchain/package.js b/build-tools/toolchain/package.js
new file mode 100644
index 000000000..560055263
--- /dev/null
+++ b/build-tools/toolchain/package.js
@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Copies engine C++ source into Tauri resources for editor bundling.
+ *
+ * Usage: node package.js
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { mkdir, rm, cp, readdir, stat, writeFile } from 'fs/promises';
+
+const ROOT_DIR = path.resolve(import.meta.dirname, '../..');
+const OUTPUT_DIR = path.join(ROOT_DIR, 'desktop/src-tauri/toolchain');
+
+function log(msg) {
+ console.log(`[toolchain] ${msg}`);
+}
+
+async function dirSize(dirPath) {
+ let total = 0;
+ const entries = await readdir(dirPath, { withFileTypes: true, recursive: true });
+ for (const entry of entries) {
+ if (entry.isFile()) {
+ const fullPath = path.join(entry.parentPath || entry.path, entry.name);
+ const s = await stat(fullPath).catch(() => null);
+ if (s) total += s.size;
+ }
+ }
+ return total;
+}
+
+function formatSize(bytes) {
+ if (bytes > 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+ return `${(bytes / 1024).toFixed(1)} KB`;
+}
+
+async function main() {
+ log('Packaging engine source for editor bundling');
+
+ const engineSrcDir = path.join(OUTPUT_DIR, 'engine-src');
+ if (fs.existsSync(engineSrcDir)) {
+ await rm(engineSrcDir, { recursive: true, force: true });
+ }
+ await mkdir(engineSrcDir, { recursive: true });
+
+ // CMakeLists.txt
+ await cp(path.join(ROOT_DIR, 'CMakeLists.txt'), path.join(engineSrcDir, 'CMakeLists.txt'));
+
+ // cmake/ modules
+ await cp(path.join(ROOT_DIR, 'cmake'), path.join(engineSrcDir, 'cmake'), { recursive: true });
+ log(' copied: cmake/');
+
+ // tools/ (EHT code generator)
+ await cp(path.join(ROOT_DIR, 'tools'), path.join(engineSrcDir, 'tools'), { recursive: true });
+ log(' copied: tools/');
+
+ // src/esengine/
+ await mkdir(path.join(engineSrcDir, 'src'), { recursive: true });
+ await cp(path.join(ROOT_DIR, 'src/esengine'), path.join(engineSrcDir, 'src/esengine'), { recursive: true });
+ log(' copied: src/esengine/');
+
+ // third_party/
+ await mkdir(path.join(engineSrcDir, 'third_party'), { recursive: true });
+ const thirdPartyCmake = path.join(ROOT_DIR, 'third_party', 'CMakeLists.txt');
+ if (fs.existsSync(thirdPartyCmake)) {
+ await cp(thirdPartyCmake, path.join(engineSrcDir, 'third_party', 'CMakeLists.txt'));
+ }
+ const thirdPartyDirs = [
+ 'glm', 'cute_tiled', 'stb',
+ 'spine-runtimes-3.8', 'spine-runtimes-4.1', 'spine-runtimes-4.2',
+ 'nlohmann',
+ ];
+ for (const dir of thirdPartyDirs) {
+ const srcDir = path.join(ROOT_DIR, 'third_party', dir);
+ if (fs.existsSync(srcDir)) {
+ await cp(srcDir, path.join(engineSrcDir, 'third_party', dir), { recursive: true });
+ log(` copied: third_party/${dir}`);
+ }
+ }
+
+ const size = await dirSize(engineSrcDir);
+ log(`\nDone! Engine source: ${formatSize(size)}`);
+ log(`Output: ${engineSrcDir}`);
+}
+
+main().catch(err => {
+ console.error(`[toolchain] ERROR: ${err.message}`);
+ process.exit(1);
+});
diff --git a/desktop/src-tauri/src/compiler.rs b/desktop/src-tauri/src/compiler.rs
new file mode 100644
index 000000000..af3e50c19
--- /dev/null
+++ b/desktop/src-tauri/src/compiler.rs
@@ -0,0 +1,785 @@
+//! Toolchain management and WASM compilation.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use tauri::{AppHandle, Emitter, Manager};
+use tokio::io::{AsyncBufReadExt, BufReader};
+use tokio::process::Command;
+
+// =============================================================================
+// Types
+// =============================================================================
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ToolchainStatus {
+ pub installed: bool,
+ pub emsdk_path: Option<String>,
+ pub emscripten_version: Option<String>,
+ pub emscripten_ok: bool,
+ pub cmake_found: bool,
+ pub cmake_version: Option<String>,
+ pub cmake_ok: bool,
+ pub python_found: bool,
+ pub python_version: Option<String>,
+ pub python_ok: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FeatureFlags {
+ pub tilemap: bool,
+ pub particles: bool,
+ pub timeline: bool,
+ pub postprocess: bool,
+ pub bitmap_text: bool,
+ pub spine: bool,
+}
+
+impl Default for FeatureFlags {
+ fn default() -> Self {
+ Self {
+ tilemap: true,
+ particles: true,
+ timeline: true,
+ postprocess: true,
+ bitmap_text: true,
+ spine: true,
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompileOptions {
+ pub features: FeatureFlags,
+ pub target: String,
+ pub debug: bool,
+ pub optimization: String,
+}
+
+impl Default for CompileOptions {
+ fn default() -> Self {
+ Self {
+ features: FeatureFlags::default(),
+ target: "web".to_string(),
+ debug: false,
+ optimization: "-O2".to_string(),
+ }
+ }
+}
+
+#[derive(Clone, Serialize)]
+struct CompileProgress {
+ stage: String,
+ message: String,
+ progress: f32,
+}
+
+#[derive(Serialize)]
+pub struct CompileResult {
+ pub success: bool,
+ pub wasm_path: Option<String>,
+ pub js_path: Option<String>,
+ pub wasm_size: Option<u64>,
+ pub error: Option<String>,
+ pub cache_key: String,
+}
+
+const EMSDK_VERSION: &str = "5.0.0";
+const EMSDK_GIT_URL: &str = "https://github.com/emscripten-core/emsdk.git";
+
+const MIN_EMSCRIPTEN_VERSION: &str = "5.0.0";
+const MIN_CMAKE_VERSION: &str = "3.16";
+const MIN_PYTHON_VERSION: &str = "3.0";
+
+fn version_ge(actual: &str, required: &str) -> bool {
+ let parse = |s: &str| -> Vec<u32> {
+ s.split('.')
+ .filter_map(|p| p.trim().parse::<u32>().ok())
+ .collect()
+ };
+ let a = parse(actual);
+ let r = parse(required);
+ for i in 0..r.len() {
+ let av = a.get(i).copied().unwrap_or(0);
+ let rv = r[i];
+ if av > rv { return true; }
+ if av < rv { return false; }
+ }
+ true
+}
+
+// =============================================================================
+// Toolchain settings persistence
+// =============================================================================
+
+fn toolchain_config_path(app: &AppHandle) -> PathBuf {
+ app.path()
+ .app_data_dir()
+ .unwrap_or_else(|_| PathBuf::from("."))
+ .join("toolchain.json")
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+struct ToolchainConfig {
+ emsdk_path: Option<String>,
+}
+
+fn load_config(app: &AppHandle) -> ToolchainConfig {
+ let path = toolchain_config_path(app);
+ std::fs::read_to_string(&path)
+ .ok()
+ .and_then(|s| serde_json::from_str(&s).ok())
+ .unwrap_or_default()
+}
+
+fn save_config(app: &AppHandle, config: &ToolchainConfig) -> Result<(), String> {
+ let path = toolchain_config_path(app);
+ if let Some(parent) = path.parent() {
+ std::fs::create_dir_all(parent).map_err(|e| e.to_string())?;
+ }
+ let json = serde_json::to_string_pretty(config).map_err(|e| e.to_string())?;
+ std::fs::write(&path, json).map_err(|e| e.to_string())
+}
+
+// =============================================================================
+// Toolchain discovery
+// =============================================================================
+
+fn find_emcc_in_emsdk(emsdk_path: &Path) -> Option<PathBuf> {
+ let emcc = emsdk_path.join("upstream/emscripten/emcc");
+ if emcc.exists() {
+ return Some(emcc);
+ }
+ let emcc_bat = emsdk_path.join("upstream/emscripten/emcc.bat");
+ if emcc_bat.exists() {
+ return Some(emcc_bat);
+ }
+ None
+}
+
+fn validate_emsdk(emsdk_path: &Path) -> bool {
+ find_emcc_in_emsdk(emsdk_path).is_some()
+}
+
+fn get_emcc_version(emsdk_path: &Path) -> Option<String> {
+ let emcc = find_emcc_in_emsdk(emsdk_path)?;
+ let output = std::process::Command::new(&emcc)
+ .arg("--version")
+ .env("EMSDK", emsdk_path)
+ .env(
+ "EM_CONFIG",
+ emsdk_path.join(".emscripten"),
+ )
+ .output()
+ .ok()?;
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let re_version = stdout
+ .lines()
+ .find_map(|line| {
+ line.split_whitespace()
+ .find(|w| w.chars().next().map_or(false, |c| c.is_ascii_digit()))
+ })
+ .map(|s| s.trim_end_matches(|c: char| !c.is_ascii_digit() && c != '.').to_string());
+ re_version
+}
+
+fn find_cmake() -> Option<(PathBuf, String)> {
+ let cmake = if cfg!(windows) { "cmake.exe" } else { "cmake" };
+ let output = std::process::Command::new(cmake)
+ .arg("--version")
+ .output()
+ .ok()?;
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let version = stdout
+ .lines()
+ .next()?
+ .split_whitespace()
+ .last()?
+ .to_string();
+
+ let path = which_sync(cmake)?;
+ Some((path, version))
+}
+
+fn find_python() -> Option<(PathBuf, String)> {
+ for bin in &["python3", "python"] {
+ let output = std::process::Command::new(bin)
+ .arg("--version")
+ .output()
+ .ok();
+ if let Some(out) = output {
+ if out.status.success() {
+ let stdout = String::from_utf8_lossy(&out.stdout);
+ let stderr = String::from_utf8_lossy(&out.stderr);
+ let text = if stdout.contains("Python") { stdout } else { stderr };
+ let version = text
+ .trim()
+ .strip_prefix("Python ")
+ .unwrap_or(text.trim())
+ .to_string();
+ if let Some(path) = which_sync(bin) {
+ return Some((path, version));
+ }
+ }
+ }
+ }
+ None
+}
+
+fn which_sync(bin: &str) -> Option<PathBuf> {
+ let cmd = if cfg!(windows) { "where" } else { "which" };
+ let output = std::process::Command::new(cmd)
+ .arg(bin)
+ .output()
+ .ok()?;
+ let stdout = String::from_utf8_lossy(&output.stdout);
+ let path = stdout.lines().next()?.trim();
+ if path.is_empty() {
+ None
+ } else {
+ Some(PathBuf::from(path))
+ }
+}
+
+fn resolve_engine_src(app: &AppHandle) -> Result<PathBuf, String> {
+ // Bundled engine source in resources
+ let resource_dir = app
+ .path()
+ .resource_dir()
+ .map_err(|e| format!("Failed to resolve resource dir: {}", e))?;
+
+ let engine_src = resource_dir.join("toolchain/engine-src");
+ if engine_src.exists() {
+ return Ok(engine_src);
+ }
+
+ // Dev mode fallback
+ let dev_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+ .parent()
+ .and_then(|p| p.parent())
+ .map(|root| root.join("desktop/src-tauri/toolchain/engine-src"));
+
+ if let Some(path) = dev_path {
+ if path.exists() {
+ return Ok(path);
+ }
+ }
+
+ Err("Engine source not found. Rebuild the editor.".to_string())
+}
+
+fn auto_detect_emsdk(app: &AppHandle) -> Option<PathBuf> {
+ // 1. Find emcc via PATH, derive emsdk root (emcc lives at <emsdk>/upstream/emscripten/emcc)
+ let emcc_bin = if cfg!(windows) { "emcc.bat" } else { "emcc" };
+ if let Some(emcc_path) = which_sync(emcc_bin) {
+ if let Some(emsdk_root) = emcc_path.parent()
+ .and_then(|p| p.parent())
+ .and_then(|p| p.parent())
+ {
+ if validate_emsdk(emsdk_root) {
+ return Some(emsdk_root.to_path_buf());
+ }
+ }
+ }
+
+ // 2. EMSDK environment variable
+ if let Ok(emsdk_env) = std::env::var("EMSDK") {
+ let path = PathBuf::from(&emsdk_env);
+ if validate_emsdk(&path) {
+ return Some(path);
+ }
+ }
+
+ // 3. Our own install location (from "Install emsdk" button)
+ let own_install = default_emsdk_install_path(app);
+ if validate_emsdk(&own_install) {
+ return Some(own_install);
+ }
+
+ None
+}
+
+fn default_emsdk_install_path(app: &AppHandle) -> PathBuf {
+ app.path()
+ .app_data_dir()
+ .unwrap_or_else(|_| PathBuf::from("."))
+ .join("emsdk")
+}
+
+// =============================================================================
+// Tauri commands
+// =============================================================================
+
+#[tauri::command]
+pub fn get_toolchain_status(app: AppHandle) -> ToolchainStatus {
+ let mut config = load_config(&app);
+
+ let (emsdk_path, emscripten_version) = config
+ .emsdk_path
+ .as_ref()
+ .and_then(|p| {
+ let path = PathBuf::from(p);
+ if validate_emsdk(&path) {
+ let version = get_emcc_version(&path);
+ Some((Some(p.clone()), version))
+ } else {
+ None
+ }
+ })
+ .or_else(|| {
+ let detected = auto_detect_emsdk(&app)?;
+ let version = get_emcc_version(&detected);
+ let path_str = detected.to_string_lossy().to_string();
+
+ config.emsdk_path = Some(path_str.clone());
+ let _ = save_config(&app, &config);
+
+ Some((Some(path_str), version))
+ })
+ .unwrap_or((None, None));
+
+ let (cmake_found, cmake_version) = find_cmake()
+ .map(|(_, v)| (true, Some(v)))
+ .unwrap_or((false, None));
+
+ let (python_found, python_version) = find_python()
+ .map(|(_, v)| (true, Some(v)))
+ .unwrap_or((false, None));
+
+ let emscripten_ok = emscripten_version
+ .as_deref()
+ .map_or(false, |v| version_ge(v, MIN_EMSCRIPTEN_VERSION));
+ let cmake_ok = cmake_version
+ .as_deref()
+ .map_or(false, |v| version_ge(v, MIN_CMAKE_VERSION));
+ let python_ok = python_version
+ .as_deref()
+ .map_or(false, |v| version_ge(v, MIN_PYTHON_VERSION));
+
+ ToolchainStatus {
+ installed: emscripten_ok && cmake_ok && python_ok,
+ emsdk_path,
+ emscripten_version,
+ emscripten_ok,
+ cmake_found,
+ cmake_version,
+ cmake_ok,
+ python_found,
+ python_version,
+ python_ok,
+ }
+}
+
+#[tauri::command]
+pub fn set_emsdk_path(app: AppHandle, path: String) -> Result<ToolchainStatus, String> {
+ let emsdk_path = PathBuf::from(&path);
+ if !validate_emsdk(&emsdk_path) {
+ return Err(format!(
+ "Invalid emsdk directory: emcc not found at {}/upstream/emscripten/emcc",
+ path
+ ));
+ }
+
+ let mut config = load_config(&app);
+ config.emsdk_path = Some(path);
+ save_config(&app, &config)?;
+
+ Ok(get_toolchain_status(app))
+}
+
+#[tauri::command]
+pub async fn install_emsdk(app: AppHandle) -> Result<ToolchainStatus, String> {
+ let install_dir = default_emsdk_install_path(&app);
+ let install_dir_str = install_dir.to_string_lossy().to_string();
+
+ emit_progress(&app, "download", "Cloning emsdk...", 0.1);
+
+ // Clone emsdk
+ if install_dir.exists() {
+ std::fs::remove_dir_all(&install_dir).map_err(|e| e.to_string())?;
+ }
+
+ run_command_streamed(
+ &app,
+ "git",
+ &[
+ "clone".to_string(),
+ "--depth".to_string(),
+ "1".to_string(),
+ EMSDK_GIT_URL.to_string(),
+ install_dir_str.clone(),
+ ],
+ &std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")),
+ &HashMap::new(),
+ )
+ .await?;
+
+ // Install + activate
+ emit_progress(&app, "install", "Installing Emscripten...", 0.3);
+
+ let emsdk_bin = if cfg!(windows) {
+ install_dir.join("emsdk.bat")
+ } else {
+ install_dir.join("emsdk")
+ };
+ let emsdk_str = emsdk_bin.to_string_lossy().to_string();
+
+ run_command_streamed(
+ &app,
+ &emsdk_str,
+ &["install".to_string(), EMSDK_VERSION.to_string()],
+ &install_dir,
+ &HashMap::new(),
+ )
+ .await?;
+
+ emit_progress(&app, "activate", "Activating Emscripten...", 0.7);
+
+ run_command_streamed(
+ &app,
+ &emsdk_str,
+ &["activate".to_string(), EMSDK_VERSION.to_string()],
+ &install_dir,
+ &HashMap::new(),
+ )
+ .await?;
+
+ emit_progress(&app, "complete", "emsdk installed!", 1.0);
+
+ // Save path
+ let mut config = load_config(&app);
+ config.emsdk_path = Some(install_dir_str);
+ save_config(&app, &config)?;
+
+ Ok(get_toolchain_status(app))
+}
+
+#[tauri::command]
+pub async fn compile_wasm(
+ app: AppHandle,
+ options: CompileOptions,
+) -> Result<CompileResult, String> {
+ let config = load_config(&app);
+ let emsdk_path = config
+ .emsdk_path
+ .ok_or("emsdk not configured. Set the path or install it first.")?;
+ let emsdk_dir = PathBuf::from(&emsdk_path);
+
+ if !validate_emsdk(&emsdk_dir) {
+ return Err(format!("Invalid emsdk at: {}", emsdk_path));
+ }
+
+ let engine_src = resolve_engine_src(&app)?;
+ let cache_key = compute_cache_key(&options);
+
+ // Build directory
+ let build_base = app
+ .path()
+ .app_data_dir()
+ .map_err(|e| e.to_string())?
+ .join("build-cache");
+ let build_dir = build_base.join(&cache_key);
+ std::fs::create_dir_all(&build_dir).map_err(|e| e.to_string())?;
+
+ // Check cache
+ let wasm_output = if options.target == "playable" {
+ build_dir.join("sdk/esengine.single.js")
+ } else {
+ build_dir.join("sdk/esengine-core.wasm")
+ };
+
+ if wasm_output.exists() {
+ emit_progress(&app, "complete", "Using cached build", 1.0);
+ return Ok(make_result(true, &build_dir, &cache_key, &options.target));
+ }
+
+ let env_vars = build_env_vars(&emsdk_dir);
+
+ // Configure
+ emit_progress(&app, "configure", "Configuring CMake...", 0.1);
+
+ let emcmake = emsdk_dir.join("upstream/emscripten/emcmake");
+ let mut cmake_args = vec!["cmake".to_string()];
+ cmake_args.extend(build_cmake_flags(&options));
+ cmake_args.push(engine_src.to_string_lossy().to_string());
+
+ run_command_streamed(
+ &app,
+ emcmake.to_string_lossy().as_ref(),
+ &cmake_args,
+ &build_dir,
+ &env_vars,
+ )
+ .await?;
+
+ // Build
+ emit_progress(&app, "compile", "Compiling C++ to WASM...", 0.3);
+
+ let build_target = match options.target.as_str() {
+ "wechat" => "esengine_wxgame",
+ "playable" => "esengine_single",
+ _ => "esengine_sdk",
+ };
+
+ run_command_streamed(
+ &app,
+ "cmake",
+ &[
+ "--build".to_string(),
+ ".".to_string(),
+ "-j".to_string(),
+ num_cpus().to_string(),
+ "--target".to_string(),
+ build_target.to_string(),
+ ],
+ &build_dir,
+ &env_vars,
+ )
+ .await?;
+
+ // Optimize
+ if !options.debug {
+ emit_progress(&app, "optimize", "Optimizing WASM...", 0.8);
+
+ let wasm_opt = if cfg!(windows) {
+ emsdk_dir.join("upstream/bin/wasm-opt.exe")
+ } else {
+ emsdk_dir.join("upstream/bin/wasm-opt")
+ };
+ let wasm_file = build_dir.join("sdk/esengine-core.wasm");
+
+ if wasm_opt.exists() && wasm_file.exists() {
+ let wasm_path = wasm_file.to_string_lossy().to_string();
+ let _ = run_command_streamed(
+ &app,
+ wasm_opt.to_string_lossy().as_ref(),
+ &[
+ options.optimization.clone(),
+ "--enable-bulk-memory".to_string(),
+ "--enable-nontrapping-float-to-int".to_string(),
+ "-o".to_string(),
+ wasm_path.clone(),
+ wasm_path,
+ ],
+ &build_dir,
+ &env_vars,
+ )
+ .await;
+ }
+ }
+
+ emit_progress(&app, "complete", "Build complete!", 1.0);
+
+ Ok(make_result(true, &build_dir, &cache_key, &options.target))
+}
+
+#[tauri::command]
+pub fn clear_build_cache(app: AppHandle) -> Result<(), String> {
+ let cache_dir = app
+ .path()
+ .app_data_dir()
+ .map_err(|e| e.to_string())?
+ .join("build-cache");
+ if cache_dir.exists() {
+ std::fs::remove_dir_all(&cache_dir).map_err(|e| e.to_string())?;
+ }
+ Ok(())
+}
+
+// =============================================================================
+// Helpers
+// =============================================================================
+
+fn make_result(success: bool, build_dir: &Path, cache_key: &str, target: &str) -> CompileResult {
+ let (js_name, wasm_name) = if target == "playable" {
+ ("sdk/esengine.single.js", None)
+ } else {
+ ("sdk/esengine-core.js", Some("sdk/esengine-core.wasm"))
+ };
+
+ let js_path = build_dir.join(js_name);
+ let wasm_path = wasm_name.map(|n| build_dir.join(n));
+
+ let size_path = wasm_path.as_ref().unwrap_or(&js_path);
+ let wasm_size = std::fs::metadata(size_path).map(|m| m.len()).ok();
+
+ CompileResult {
+ success,
+ js_path: js_path.exists().then(|| js_path.to_string_lossy().to_string()),
+ wasm_path: wasm_path.and_then(|p| {
+ p.exists().then(|| p.to_string_lossy().to_string())
+ }),
+ wasm_size,
+ error: None,
+ cache_key: cache_key.to_string(),
+ }
+}
+
+fn compute_cache_key(options: &CompileOptions) -> String {
+ use std::collections::hash_map::DefaultHasher;
+ use std::hash::{Hash, Hasher};
+
+ let mut hasher = DefaultHasher::new();
+ let f = &options.features;
+ f.tilemap.hash(&mut hasher);
+ f.particles.hash(&mut hasher);
+ f.timeline.hash(&mut hasher);
+ f.postprocess.hash(&mut hasher);
+ f.bitmap_text.hash(&mut hasher);
+ f.spine.hash(&mut hasher);
+ options.target.hash(&mut hasher);
+ options.debug.hash(&mut hasher);
+ options.optimization.hash(&mut hasher);
+ format!("{:016x}", hasher.finish())
+}
+
+fn build_cmake_flags(options: &CompileOptions) -> Vec<String> {
+ let mut flags = vec![
+ format!(
+ "-DCMAKE_BUILD_TYPE={}",
+ if options.debug { "Debug" } else { "Release" }
+ ),
+ "-DES_BUILD_WEB=ON".to_string(),
+ "-DES_BUILD_TESTS=OFF".to_string(),
+ ];
+
+ let feature_map = [
+ ("ES_ENABLE_TILEMAP", options.features.tilemap),
+ ("ES_ENABLE_PARTICLES", options.features.particles),
+ ("ES_ENABLE_TIMELINE", options.features.timeline),
+ ("ES_ENABLE_POSTPROCESS", options.features.postprocess),
+ ("ES_ENABLE_BITMAP_TEXT", options.features.bitmap_text),
+ ("ES_ENABLE_SPINE", options.features.spine),
+ ];
+
+ for (flag, enabled) in feature_map {
+ flags.push(format!("-D{}={}", flag, if enabled { "ON" } else { "OFF" }));
+ }
+
+ if !options.debug {
+ flags.push(format!("-DCMAKE_C_FLAGS={}", options.optimization));
+ flags.push(format!("-DCMAKE_CXX_FLAGS={}", options.optimization));
+ flags.push("-DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON".to_string());
+ }
+
+ match options.target.as_str() {
+ "wechat" => {
+ flags.retain(|f| f != "-DES_BUILD_WEB=ON");
+ flags.push("-DES_BUILD_WXGAME=ON".to_string());
+ }
+ "playable" => {
+ flags.push("-DES_BUILD_SINGLE_FILE=ON".to_string());
+ }
+ _ => {}
+ }
+
+ flags
+}
+
+fn build_env_vars(emsdk_dir: &Path) -> HashMap<String, String> {
+ let mut env = HashMap::new();
+
+ let upstream_dir = emsdk_dir.join("upstream");
+ let emscripten_dir = upstream_dir.join("emscripten");
+
+ env.insert("EMSDK".to_string(), emsdk_dir.to_string_lossy().to_string());
+ env.insert(
+ "EM_CONFIG".to_string(),
+ emsdk_dir.join(".emscripten").to_string_lossy().to_string(),
+ );
+
+ let path_sep = if cfg!(windows) { ";" } else { ":" };
+ let system_path = std::env::var("PATH").unwrap_or_default();
+ let new_path = [
+ emscripten_dir.to_string_lossy().to_string(),
+ upstream_dir.join("bin").to_string_lossy().to_string(),
+ system_path,
+ ]
+ .join(path_sep);
+
+ env.insert("PATH".to_string(), new_path);
+ env
+}
+
+fn emit_progress(app: &AppHandle, stage: &str, message: &str, progress: f32) {
+ let _ = app.emit(
+ "compile-progress",
+ CompileProgress {
+ stage: stage.to_string(),
+ message: message.to_string(),
+ progress,
+ },
+ );
+}
+
+async fn run_command_streamed(
+ app: &AppHandle,
+ cmd: &str,
+ args: &[String],
+ cwd: &Path,
+ env: &HashMap<String, String>,
+) -> Result<(), String> {
+ let mut command = Command::new(cmd);
+ command
+ .args(args)
+ .current_dir(cwd)
+ .envs(env)
+ .stdout(std::process::Stdio::piped())
+ .stderr(std::process::Stdio::piped());
+
+ let mut child = command.spawn().map_err(|e| {
+ format!("Failed to spawn {}: {} (cwd: {})", cmd, e, cwd.display())
+ })?;
+
+ let stdout = child.stdout.take().ok_or("No stdout")?;
+ let stderr = child.stderr.take().ok_or("No stderr")?;
+
+ let app_out = app.clone();
+ let stdout_handle = tokio::spawn(async move {
+ let reader = BufReader::new(stdout);
+ let mut lines = reader.lines();
+ while let Ok(Some(line)) = lines.next_line().await {
+ let _ = app_out.emit(
+ "compile-output",
+ super::CommandOutput {
+ stream: "stdout".to_string(),
+ data: line,
+ },
+ );
+ }
+ });
+
+ let app_err = app.clone();
+ let stderr_handle = tokio::spawn(async move {
+ let reader = BufReader::new(stderr);
+ let mut lines = reader.lines();
+ while let Ok(Some(line)) = lines.next_line().await {
+ let _ = app_err.emit(
+ "compile-output",
+ super::CommandOutput {
+ stream: "stderr".to_string(),
+ data: line,
+ },
+ );
+ }
+ });
+
+ let _ = tokio::join!(stdout_handle, stderr_handle);
+
+ let status = child.wait().await.map_err(|e| e.to_string())?;
+ if !status.success() {
+ return Err(format!(
+ "Command failed: {} (exit code: {})",
+ cmd,
+ status.code().unwrap_or(-1)
+ ));
+ }
+
+ Ok(())
+}
+
+fn num_cpus() -> usize {
+ std::thread::available_parallelism()
+ .map(|n| n.get())
+ .unwrap_or(4)
+}
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index ca93a61d2..567ba6ace 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -1,5 +1,6 @@
//! ESEngine Editor Library
+mod compiler;
mod embedded_assets;
mod preview_server;
@@ -300,6 +301,11 @@ pub fn run() {
get_embedded_asset,
check_update,
install_update,
+ compiler::get_toolchain_status,
+ compiler::set_emsdk_path,
+ compiler::install_emsdk,
+ compiler::compile_wasm,
+ compiler::clear_build_cache,
])
.on_window_event(|window, event| {
if let tauri::WindowEvent::Destroyed = event {
diff --git a/desktop/src-tauri/tauri.conf.json b/desktop/src-tauri/tauri.conf.json
index bbd6cc519..df574e9a8 100644
--- a/desktop/src-tauri/tauri.conf.json
+++ b/desktop/src-tauri/tauri.conf.json
@@ -60,6 +60,9 @@
"icons/icon.icns",
"icons/icon.ico"
],
+ "resources": {
+ "toolchain/": "toolchain/"
+ },
"windows": {
"wix": null,
"nsis": null
diff --git a/editor/src/builder/BuildService.ts b/editor/src/builder/BuildService.ts
index d54bc5240..57b86deef 100644
--- a/editor/src/builder/BuildService.ts
+++ b/editor/src/builder/BuildService.ts
@@ -3,7 +3,8 @@
* @brief Build service for compiling and packaging projects
*/
-import type { BuildConfig } from '../types/BuildTypes';
+import type { BuildConfig, EngineModules } from '../types/BuildTypes';
+import { createDefaultEngineModules } from '../types/BuildTypes';
import type { SpineVersion } from '../types/ProjectTypes';
import type { PlatformEmitter } from './PlatformEmitter';
import { buildArtifact } from './ArtifactBuilder';
@@ -50,6 +51,11 @@ export interface RuntimeBuildConfig {
assetFailureCooldown?: number;
}
+export interface CustomWasmPaths {
+ jsPath?: string;
+ wasmPath?: string;
+}
+
export interface BuildContext {
projectPath: string;
config: BuildConfig;
@@ -62,6 +68,7 @@ export interface BuildContext {
runtimeConfig?: RuntimeBuildConfig;
progress?: BuildProgressReporter;
cache?: BuildCache;
+ customWasm?: CustomWasmPaths;
}
export interface BuildOptions {
@@ -153,6 +160,28 @@ export class BuildService {
};
}
+ if (config.engineModules && !isAllModulesEnabled(config.engineModules)) {
+ progress.setPhase('compiling');
+ progress.setCurrentTask('Compiling custom WASM...', 0);
+ progress.log('info', 'Custom engine modules detected, compiling WASM...');
+
+ const compileResult = await compileCustomWasm(config);
+ if (!compileResult.success) {
+ progress.fail(compileResult.error || 'WASM compilation failed');
+ return {
+ success: false,
+ error: compileResult.error || 'WASM compilation failed',
+ duration: Date.now() - startTime,
+ };
+ }
+
+ context.customWasm = {
+ jsPath: compileResult.jsPath,
+ wasmPath: compileResult.wasmPath,
+ };
+ progress.log('info', `Custom WASM compiled (${formatSize(compileResult.wasmSize)})`);
+ }
+
const hooks = config.hooks ?? [];
const outputPath = config.playableSettings?.outputPath
?? config.wechatSettings?.outputDir
@@ -268,3 +297,65 @@ export class BuildService {
}
}
}
+
+// =============================================================================
+// Custom WASM compilation
+// =============================================================================
+
+interface CompileWasmResult {
+ success: boolean;
+ jsPath?: string;
+ wasmPath?: string;
+ wasmSize?: number;
+ error?: string;
+}
+
+function isAllModulesEnabled(modules: EngineModules): boolean {
+ const defaults = createDefaultEngineModules();
+ return (Object.keys(defaults) as Array<keyof EngineModules>).every(
+ key => modules[key] !== false
+ );
+}
+
+async function compileCustomWasm(config: BuildConfig): Promise<CompileWasmResult> {
+ const { invoke } = await import('@tauri-apps/api/core');
+
+ const modules = config.engineModules ?? createDefaultEngineModules();
+ const target = config.platform === 'wechat' ? 'wechat' : 'playable';
+
+ const result = await invoke<{
+ success: boolean;
+ wasm_path: string | null;
+ js_path: string | null;
+ wasm_size: number | null;
+ error: string | null;
+ }>('compile_wasm', {
+ options: {
+ features: {
+ tilemap: modules.tilemap,
+ particles: modules.particles,
+ timeline: modules.timeline,
+ postprocess: modules.postprocess,
+ bitmap_text: modules.bitmapText,
+ spine: modules.spine,
+ },
+ target,
+ debug: config.defines.includes('DEBUG'),
+ optimization: '-O2',
+ },
+ });
+
+ return {
+ success: result.success,
+ jsPath: result.js_path ?? undefined,
+ wasmPath: result.wasm_path ?? undefined,
+ wasmSize: result.wasm_size ?? undefined,
+ error: result.error ?? undefined,
+ };
+}
+
+function formatSize(bytes?: number): string {
+ if (bytes == null) return 'unknown';
+ if (bytes > 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+ return `${(bytes / 1024).toFixed(1)} KB`;
+}
diff --git a/editor/src/builder/BuildSettingsDialog.ts b/editor/src/builder/BuildSettingsDialog.ts
index 876bafef8..72db8e9c3 100644
--- a/editor/src/builder/BuildSettingsDialog.ts
+++ b/editor/src/builder/BuildSettingsDialog.ts
@@ -8,14 +8,18 @@ import {
type BuildPlatform,
type BuildConfig,
type BuildSettings,
+ type EngineModules,
PLATFORMS,
+ ENGINE_MODULE_INFO,
createDefaultBuildConfig,
createDefaultBuildSettings,
+ createDefaultEngineModules,
} from '../types/BuildTypes';
import { getEditorContext } from '../context/EditorContext';
import { getEditorStore } from '../store';
-import { type BuildResult } from './BuildService';
-import { showProgressToast, dismissToast, showToast } from '../ui/Toast';
+import { type BuildResult, type BuildOptions } from './BuildService';
+import { BuildProgressReporter } from './BuildProgress';
+import { showProgressToast, dismissToast, showToast, showSuccessToast, showErrorToast, updateToast } from '../ui/Toast';
import { BuildHistory, formatBuildTime, formatBuildDuration, getBuildStatusIcon, type BuildHistoryEntry } from './BuildHistory';
import { BuildConfigService, initBuildConfigService } from './BuildConfigService';
import { downloadConfigsAsFile, uploadConfigsFromFile } from './BuildConfigIO';
@@ -32,7 +36,7 @@ import type { BuildHook, BuildHookPhase, BuildHookType, CopyFilesConfig, RunComm
export interface BuildSettingsDialogOptions {
projectPath: string;
- onBuild: (config: BuildConfig) => Promise<BuildResult>;
+ onBuild: (config: BuildConfig, options?: BuildOptions) => Promise<BuildResult>;
onClose: () => void;
}
@@ -71,6 +75,7 @@ export class BuildSettingsDialog {
this.render();
this.setupEvents();
+ this.checkToolchainStatus();
}
dispose(): void {
@@ -212,8 +217,10 @@ export class BuildSettingsDialog {
<div class="es-build-data-section">
${this.renderScenesSection(config)}
${this.renderDefinesSection(config)}
+ ${this.renderEngineModulesSection(config)}
</div>
<div class="es-build-settings-section">
+ ${this.renderToolchainSection()}
${this.renderPlatformSettings(config)}
${this.renderHooksSection(config)}
</div>
@@ -582,6 +589,107 @@ export class BuildSettingsDialog {
`;
}
+ private renderEngineModulesSection(config: BuildConfig): string {
+ const isExpanded = this.expandedSections_.has('engine-modules');
+ const modules = config.engineModules ?? createDefaultEngineModules();
+ const enabledCount = Object.values(modules).filter(Boolean).length;
+ const totalCount = Object.keys(ENGINE_MODULE_INFO).length;
+
+ const modulesHtml = (Object.entries(ENGINE_MODULE_INFO) as [keyof EngineModules, { name: string; description: string }][])
+ .map(([key, info]) => `
+ <div class="es-build-module-item">
+ <label>
+ <input type="checkbox" data-module="${key}" ${modules[key] ? 'checked' : ''}>
+ <span class="es-build-module-name">${info.name}</span>
+ </label>
+ <span class="es-build-module-desc">${info.description}</span>
+ </div>
+ `).join('');
+
+ return `
+ <div class="es-build-collapse ${isExpanded ? 'es-expanded' : ''}" data-section="engine-modules">
+ <div class="es-build-collapse-header">
+ ${isExpanded ? icons.chevronDown(12) : icons.chevronRight(12)}
+ <span>Engine Modules</span>
+ <span class="es-build-collapse-count">${enabledCount}/${totalCount}</span>
+ </div>
+ <div class="es-build-collapse-content">
+ <div class="es-build-module-list">
+ <div class="es-build-module-item es-build-module-core">
+ <label>
+ <input type="checkbox" checked disabled>
+ <span class="es-build-module-name">Core</span>
+ </label>
+ <span class="es-build-module-desc">ECS, Renderer, Sprite, Text</span>
+ </div>
+ ${modulesHtml}
+ </div>
+ </div>
+ </div>
+ `;
+ }
+
+ private renderToolchainSection(): string {
+ const isExpanded = this.expandedSections_.has('toolchain');
+ const s = this.toolchainStatus_;
+
+ let statusBadge: string;
+ let infoHtml: string;
+
+ if (this.toolchainError_) {
+ statusBadge = '';
+ infoHtml = '<span class="es-build-module-desc">Not available in browser mode</span>';
+ } else if (!s) {
+ statusBadge = '';
+ infoHtml = '<span class="es-build-module-desc">Detecting...</span>';
+ } else if (s.installed) {
+ statusBadge = '<span class="es-build-toolchain-badge es-ready">Ready</span>';
+ infoHtml = this.renderToolchainRows(s);
+ } else {
+ statusBadge = '<span class="es-build-toolchain-badge es-not-ready">Not ready</span>';
+ infoHtml = this.renderToolchainRows(s);
+ }
+
+ return `
+ <div class="es-build-collapse ${isExpanded ? 'es-expanded' : ''}" data-section="toolchain">
+ <div class="es-build-collapse-header">
+ ${isExpanded ? icons.chevronDown(12) : icons.chevronRight(12)}
+ <span>Toolchain (emsdk)</span>
+ ${statusBadge}
+ </div>
+ <div class="es-build-collapse-content">
+ <div class="es-build-toolchain-info">
+ ${infoHtml}
+ </div>
+ <div class="es-build-toolchain-actions">
+ <button class="es-btn" data-action="browse-emsdk">
+ ${icons.folder(12)} Select emsdk
+ </button>
+ <button class="es-btn" data-action="install-emsdk">
+ ${icons.download(12)} Install emsdk
+ </button>
+ </div>
+ </div>
+ </div>
+ `;
+ }
+
+ private renderToolchainRows(s: NonNullable<typeof this.toolchainStatus_>): string {
+ const row = (label: string, value: string | null, ok: boolean, minVersion?: string) => {
+ const cls = ok ? '' : ' es-warning';
+ let display = value ?? 'not found';
+ if (value && !ok && minVersion) {
+ display += ` (requires >= ${minVersion})`;
+ }
+ return `<div class="es-build-toolchain-row${cls}">${label}: ${display}</div>`;
+ };
+ return [
+ row('Emscripten', s.emscripten_version ?? (s.emsdk_path ? 'unknown' : null), s.emscripten_ok, '5.0.0'),
+ row('CMake', s.cmake_version, s.cmake_ok, '3.16'),
+ row('Python', s.python_version, s.python_ok, '3.0'),
+ ].join('');
+ }
+
private getPlatformName(platform: BuildPlatform): string {
return PLATFORMS.find(p => p.id === platform)?.name ?? platform;
}
@@ -631,10 +739,16 @@ export class BuildSettingsDialog {
if (section) {
if (this.expandedSections_.has(section)) {
this.expandedSections_.delete(section);
+ collapse.classList.remove('es-expanded');
} else {
this.expandedSections_.add(section);
+ collapse.classList.add('es-expanded');
+ }
+ const chevron = collapseHeader.querySelector('svg');
+ if (chevron) {
+ const expanded = this.expandedSections_.has(section);
+ chevron.outerHTML = expanded ? icons.chevronDown(12) : icons.chevronRight(12);
}
- this.render();
}
return;
}
@@ -872,6 +986,14 @@ export class BuildSettingsDialog {
case 'browse-output':
this.browseFile('playable-output', 'HTML File', ['html']);
break;
+
+ case 'browse-emsdk':
+ this.handleBrowseEmsdk();
+ break;
+
+ case 'install-emsdk':
+ this.handleInstallEmsdk();
+ break;
}
}
@@ -932,9 +1054,96 @@ export class BuildSettingsDialog {
}
}
+ // Engine module checkboxes
+ const moduleKey = (target as HTMLElement).dataset?.module as keyof EngineModules | undefined;
+ if (moduleKey && moduleKey in ENGINE_MODULE_INFO) {
+ if (!config.engineModules) {
+ config.engineModules = createDefaultEngineModules();
+ }
+ config.engineModules[moduleKey] = (target as HTMLInputElement).checked;
+ }
+
this.saveSettings();
}
+ private async checkToolchainStatus(): Promise<void> {
+ try {
+ const { invoke } = await import('@tauri-apps/api/core');
+ this.toolchainStatus_ = await invoke('get_toolchain_status');
+ this.toolchainError_ = false;
+ } catch {
+ this.toolchainStatus_ = null;
+ this.toolchainError_ = true;
+ }
+ this.updateToolchainUI();
+ }
+
+ private updateToolchainUI(): void {
+ const section = this.overlay_?.querySelector('[data-section="toolchain"]');
+ if (!section) return;
+
+ const s = this.toolchainStatus_;
+ const header = section.querySelector('.es-build-collapse-header');
+ const badgeEl = section.querySelector('.es-build-toolchain-badge');
+ const infoEl = section.querySelector('.es-build-toolchain-info');
+
+ if (this.toolchainError_) {
+ if (badgeEl) badgeEl.remove();
+ if (infoEl) infoEl.innerHTML = '<span class="es-build-module-desc">Not available in browser mode</span>';
+ return;
+ }
+
+ if (!s) {
+ if (infoEl) infoEl.innerHTML = '<span class="es-build-module-desc">Detecting...</span>';
+ return;
+ }
+
+ const badgeClass = s.installed ? 'es-ready' : 'es-not-ready';
+ const badgeText = s.installed ? 'Ready' : 'Not ready';
+
+ if (badgeEl) {
+ badgeEl.className = `es-build-toolchain-badge ${badgeClass}`;
+ badgeEl.textContent = badgeText;
+ } else if (header) {
+ header.insertAdjacentHTML('beforeend', `<span class="es-build-toolchain-badge ${badgeClass}">${badgeText}</span>`);
+ }
+
+ if (infoEl) {
+ infoEl.innerHTML = this.renderToolchainRows(s);
+ }
+ }
+
+ private async handleBrowseEmsdk(): Promise<void> {
+ const fs = getEditorContext().fs;
+ if (!fs) return;
+
+ const selected = await fs.selectDirectory();
+ if (!selected) return;
+
+ try {
+ const { invoke } = await import('@tauri-apps/api/core');
+ await invoke('set_emsdk_path', { path: selected });
+ showSuccessToast('emsdk path set');
+ await this.checkToolchainStatus();
+ } catch (err: any) {
+ showErrorToast(err.toString());
+ }
+ }
+
+ private async handleInstallEmsdk(): Promise<void> {
+ const toastId = showProgressToast('Installing emsdk...');
+ try {
+ const { invoke } = await import('@tauri-apps/api/core');
+ await invoke('install_emsdk');
+ dismissToast(toastId);
+ showSuccessToast('emsdk installed');
+ await this.checkToolchainStatus();
+ } catch (err: any) {
+ dismissToast(toastId);
+ showErrorToast(`Install failed: ${err}`);
+ }
+ }
+
private showAddConfigDialog(): void {
const dialog = document.createElement('div');
dialog.className = 'es-build-add-dialog';
@@ -1156,6 +1365,13 @@ export class BuildSettingsDialog {
}
private async handleBuild(config: BuildConfig): Promise<void> {
+ if (config.engineModules && Object.values(config.engineModules).some(v => v === false)) {
+ if (!this.toolchainStatus_?.installed) {
+ showErrorToast('Toolchain not ready. Custom engine modules require emsdk, CMake and Python.');
+ return;
+ }
+ }
+
const buildBtn = this.overlay_.querySelector('[data-action="build"]') as HTMLButtonElement;
const buildAllBtn = this.overlay_.querySelector('[data-action="build-all"]') as HTMLButtonElement;
@@ -1173,8 +1389,17 @@ export class BuildSettingsDialog {
`Target: ${platformName}`
);
+ const progress = new BuildProgressReporter();
+ progress.onProgress((p) => {
+ const task = p.currentTask || p.phase;
+ updateToast(toastId, {
+ message: task,
+ progress: p.overallProgress,
+ });
+ });
+
try {
- const result = await this.options_.onBuild(config);
+ const result = await this.options_.onBuild(config, { progress });
dismissToast(toastId);
@@ -1576,10 +1801,23 @@ export class BuildSettingsDialog {
private configService_!: BuildConfigService;
private history_!: BuildHistory;
private batchBuilder_!: BatchBuilder;
- private expandedSections_: Set<string> = new Set(['scenes', 'defines', 'platform']);
+ private expandedSections_: Set<string> = new Set(['scenes', 'defines', 'platform', 'engine-modules']);
private keyHandler_: ((e: KeyboardEvent) => void) | null = null;
private dragSourceIndex_ = -1;
private lastBuildOutputFiles_: Map<string, Array<{ path: string; size: number }>> = new Map();
+ private toolchainStatus_: {
+ installed: boolean;
+ emsdk_path: string | null;
+ emscripten_version: string | null;
+ emscripten_ok: boolean;
+ cmake_found: boolean;
+ cmake_version: string | null;
+ cmake_ok: boolean;
+ python_found: boolean;
+ python_version: string | null;
+ python_ok: boolean;
+ } | null = null;
+ private toolchainError_ = false;
}
// =============================================================================
diff --git a/editor/src/builder/EmitterUtils.ts b/editor/src/builder/EmitterUtils.ts
index d52486125..a46684ffe 100644
--- a/editor/src/builder/EmitterUtils.ts
+++ b/editor/src/builder/EmitterUtils.ts
@@ -6,6 +6,7 @@
import * as esbuild from 'esbuild-wasm/esm/browser';
import type { BuildArtifact } from './PlatformEmitter';
import type { BuildContext } from './BuildService';
+import type { EngineModules } from '../types/BuildTypes';
import type { NativeFS } from '../types/NativeFS';
import { findTsFiles, EDITOR_ONLY_DIRS } from '../scripting/ScriptLoader';
import { joinPath } from '../utils/path';
@@ -73,6 +74,32 @@ export function analyzeUsedPlugins(artifact: BuildArtifact): string[] {
return Array.from(plugins);
}
+// =============================================================================
+// Engine Module → Plugin Mapping
+// =============================================================================
+
+const MODULE_PLUGIN_MAP: Record<keyof EngineModules, string[]> = {
+ particles: ['particlePlugin'],
+ tilemap: ['tilemapPlugin'],
+ timeline: ['timelinePlugin'],
+ postprocess: ['postProcessPlugin'],
+ bitmapText: [],
+ spine: [],
+};
+
+export function filterPluginsByModules(plugins: string[], modules?: EngineModules): string[] {
+ if (!modules) return plugins;
+
+ const disabled = new Set<string>();
+ for (const [mod, pluginNames] of Object.entries(MODULE_PLUGIN_MAP)) {
+ if (!modules[mod as keyof EngineModules]) {
+ for (const p of pluginNames) disabled.add(p);
+ }
+ }
+
+ return plugins.filter(p => !disabled.has(p));
+}
+
// =============================================================================
// Defines
// =============================================================================
diff --git a/editor/src/builder/PlayableEmitter.ts b/editor/src/builder/PlayableEmitter.ts
index 22d548829..093f82071 100644
--- a/editor/src/builder/PlayableEmitter.ts
+++ b/editor/src/builder/PlayableEmitter.ts
@@ -15,6 +15,7 @@ import type { NativeFS } from '../types/NativeFS';
import { getAssetMimeType, getAssetTypeEntry, toBuildPath } from 'esengine';
import {
analyzeUsedPlugins,
+ filterPluginsByModules,
collectUserScriptImports,
compileUserScripts,
resolveSceneUUIDs,
@@ -48,7 +49,9 @@ export class PlayableEmitter implements PlatformEmitter {
try {
// 1. Load SDK
progress.setCurrentTask('Loading SDK...', 0);
- const wasmSdk = await this.loadSdk(fs);
+ const wasmSdk = context.customWasm?.jsPath
+ ? await fs.readFile(context.customWasm.jsPath)
+ : await this.loadSdk(fs);
if (!wasmSdk) {
return { success: false, error: "SDK not found. Please run 'scripts/build-web-single.bat' first." };
}
@@ -75,7 +78,8 @@ export class PlayableEmitter implements PlatformEmitter {
// 4. Load spine modules if needed
progress.setCurrentTask('Loading modules...', 25);
const spineModules: Array<{ version: string; js: string; wasmBase64: string }> = [];
- for (const version of artifact.spineVersions) {
+ const spineEnabled = context.config.engineModules?.spine !== false;
+ for (const version of spineEnabled ? artifact.spineVersions : []) {
if (version === '4.2') continue;
if (!fs.getSpineJs) continue;
const spineJs = await fs.getSpineJs(version);
@@ -183,7 +187,10 @@ export class PlayableEmitter implements PlatformEmitter {
const usedPlugins = analyzeUsedPlugins(artifact);
const alwaysPlugins = ['animationPlugin', 'audioPlugin', 'particlePlugin'];
- const allPlugins = [...new Set([...usedPlugins, ...alwaysPlugins])];
+ const allPlugins = filterPluginsByModules(
+ [...new Set([...usedPlugins, ...alwaysPlugins])],
+ context.config.engineModules,
+ );
const pluginImports = allPlugins.join(', ');
const pluginList = allPlugins.join(', ');
diff --git a/editor/src/builder/WeChatEmitter.ts b/editor/src/builder/WeChatEmitter.ts
index 28b1b4470..545667f83 100644
--- a/editor/src/builder/WeChatEmitter.ts
+++ b/editor/src/builder/WeChatEmitter.ts
@@ -241,11 +241,12 @@ export class WeChatEmitter implements PlatformEmitter {
const physicsConfig = generatePhysicsConfig(context);
+ const spineEnabled = context.config.engineModules?.spine !== false;
const gameJs = generateWeChatGameJs({
userCode,
firstSceneName,
allSceneNames,
- spineVersions: [...artifact.spineVersions],
+ spineVersions: spineEnabled ? [...artifact.spineVersions] : [],
hasPhysics: !!context.enablePhysics,
physicsConfig,
runtimeConfig: context.runtimeConfig,
@@ -261,8 +262,21 @@ export class WeChatEmitter implements PlatformEmitter {
context: BuildContext,
artifact: BuildArtifact,
): Promise<void> {
- const engineJs = await fs.getEngineWxgameJs();
- const engineWasm = await fs.getEngineWxgameWasm();
+ let engineJs: string;
+ let engineWasm: Uint8Array;
+
+ if (context.customWasm?.jsPath && context.customWasm?.wasmPath) {
+ const js = await fs.readFile(context.customWasm.jsPath);
+ const wasm = await fs.readBinaryFile(context.customWasm.wasmPath);
+ if (!js || !wasm) {
+ throw new Error('Custom WASM build output not found');
+ }
+ engineJs = js;
+ engineWasm = wasm;
+ } else {
+ engineJs = await fs.getEngineWxgameJs();
+ engineWasm = await fs.getEngineWxgameWasm();
+ }
if (!engineJs || engineJs.length === 0) {
throw new Error(
@@ -278,14 +292,17 @@ export class WeChatEmitter implements PlatformEmitter {
await fs.writeFile(joinPath(outputDir, 'sdk.js'), sdkJs);
}
- 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) {
- const tag = version.replace('.', '');
- await fs.writeFile(joinPath(outputDir, `spine_${tag}.js`), spineJs);
- await fs.writeBinaryFile(joinPath(outputDir, `spine_${tag}.wasm`), spineWasm);
+ const spineEnabled = context.config.engineModules?.spine !== false;
+ if (spineEnabled) {
+ 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) {
+ 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/services/ProjectService.ts b/editor/src/services/ProjectService.ts
index ade99a4f6..85242f1fd 100644
--- a/editor/src/services/ProjectService.ts
+++ b/editor/src/services/ProjectService.ts
@@ -66,8 +66,8 @@ export class ProjectService {
const buildService = new BuildService(this.projectPath_);
showBuildSettingsDialog({
projectPath: this.projectPath_,
- onBuild: async (config) => {
- return await buildService.build(config);
+ onBuild: async (config, options) => {
+ return await buildService.build(config, options);
},
onClose: () => {},
});
diff --git a/editor/src/styles/builder.css b/editor/src/styles/builder.css
index b3f96660c..2c54b569d 100644
--- a/editor/src/styles/builder.css
+++ b/editor/src/styles/builder.css
@@ -261,11 +261,7 @@
flex-shrink: 0;
}
-.es-build-scene-item span {
- flex: 1;
- overflow: hidden;
- text-overflow: ellipsis;
- white-space: nowrap;
+.es-build-scene-item .es-build-scene-path {
color: var(--es-text-primary);
}
@@ -1704,3 +1700,93 @@
opacity: 0.5;
font-style: italic;
}
+
+/* Engine Modules */
+.es-build-module-list {
+ display: flex;
+ flex-direction: column;
+ gap: 2px;
+}
+
+.es-build-module-item {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ padding: 4px 8px;
+ border-radius: 3px;
+ font-size: 12px;
+ transition: background 0.1s;
+}
+
+.es-build-module-item:hover {
+ background: var(--es-bg-hover);
+}
+
+.es-build-module-item label {
+ display: flex;
+ align-items: center;
+ gap: 6px;
+ cursor: pointer;
+ flex-shrink: 0;
+}
+
+.es-build-module-item input[type="checkbox"] {
+ margin: 0;
+ accent-color: var(--es-accent);
+}
+
+.es-build-module-name {
+ font-weight: 500;
+ color: var(--es-text-primary);
+}
+
+.es-build-module-desc {
+ font-size: 11px;
+ color: var(--es-text-secondary);
+ text-align: right;
+}
+
+.es-build-module-core {
+ opacity: 0.6;
+}
+
+.es-build-module-core label {
+ cursor: default;
+}
+
+/* Toolchain */
+.es-build-toolchain-badge {
+ margin-left: auto;
+ font-size: 10px;
+ padding: 2px 6px;
+ border-radius: 10px;
+}
+
+.es-build-toolchain-badge.es-ready {
+ background: rgba(76, 175, 80, 0.15);
+ color: #4caf50;
+}
+
+.es-build-toolchain-badge.es-not-ready {
+ background: rgba(255, 152, 0, 0.15);
+ color: #ff9800;
+}
+
+.es-build-toolchain-info {
+ font-size: 12px;
+ color: var(--es-text-secondary);
+ margin-bottom: 8px;
+}
+
+.es-build-toolchain-row {
+ padding: 2px 0;
+}
+
+.es-build-toolchain-row.es-warning {
+ color: #ff9800;
+}
+
+.es-build-toolchain-actions {
+ display: flex;
+ gap: 8px;
+}
diff --git a/editor/src/types/BuildTypes.ts b/editor/src/types/BuildTypes.ts
index d68145860..87c0b96fd 100644
--- a/editor/src/types/BuildTypes.ts
+++ b/editor/src/types/BuildTypes.ts
@@ -75,6 +75,39 @@ export interface BuildHook {
config: CopyFilesConfig | RunCommandConfig;
}
+// =============================================================================
+// Engine Modules
+// =============================================================================
+
+export interface EngineModules {
+ tilemap: boolean;
+ particles: boolean;
+ timeline: boolean;
+ postprocess: boolean;
+ bitmapText: boolean;
+ spine: boolean;
+}
+
+export function createDefaultEngineModules(): EngineModules {
+ return {
+ tilemap: true,
+ particles: true,
+ timeline: true,
+ postprocess: true,
+ bitmapText: true,
+ spine: true,
+ };
+}
+
+export const ENGINE_MODULE_INFO: Record<keyof EngineModules, { name: string; description: string }> = {
+ tilemap: { name: 'Tilemap', description: 'Tiled map rendering' },
+ particles: { name: 'Particles', description: 'Particle system' },
+ timeline: { name: 'Timeline', description: 'Timeline animation' },
+ postprocess: { name: 'Post Process', description: 'Post-processing effects' },
+ bitmapText: { name: 'Bitmap Text', description: 'Bitmap font rendering' },
+ spine: { name: 'Spine', description: 'Spine skeletal animation' },
+};
+
// =============================================================================
// Build Configuration
// =============================================================================
@@ -87,6 +120,7 @@ export interface BuildConfig {
defines: string[];
additionalAssets?: string[];
hooks?: BuildHook[];
+ engineModules?: EngineModules;
playableSettings?: PlayableSettings;
wechatSettings?: WeChatSettings;
}
diff --git a/src/esengine/bindings/EngineContext.cpp b/src/esengine/bindings/EngineContext.cpp
index 54a9985e7..ce377cd54 100644
--- a/src/esengine/bindings/EngineContext.cpp
+++ b/src/esengine/bindings/EngineContext.cpp
@@ -16,12 +16,18 @@
#include "../renderer/RenderFrame.hpp"
#include "../renderer/ImmediateDraw.hpp"
#include "../renderer/CustomGeometry.hpp"
+#ifdef ES_ENABLE_POSTPROCESS
#include "../renderer/PostProcessPipeline.hpp"
+#endif
#include "../resource/ResourceManager.hpp"
#include "../ecs/TransformSystem.hpp"
#include "../animation/TweenSystem.hpp"
+#ifdef ES_ENABLE_TIMELINE
#include "../animation/TimelineSystem.hpp"
+#endif
+#ifdef ES_ENABLE_PARTICLES
#include "../particle/ParticleSystem.hpp"
+#endif
#ifdef ES_ENABLE_SPINE
#include "../spine/SpineResourceManager.hpp"
#include "../spine/SpineSystem.hpp"
@@ -39,12 +45,18 @@ void EngineContext::setRenderContext(Unique<RenderContext> ctx) { renderContext_
void EngineContext::setRenderFrame(Unique<RenderFrame> frame) { renderFrame_ = std::move(frame); }
void EngineContext::setImmediateDraw(Unique<ImmediateDraw> draw) { immediateDraw_ = std::move(draw); }
void EngineContext::setGeometryManager(Unique<GeometryManager> mgr) { geometryManager_ = std::move(mgr); }
+#ifdef ES_ENABLE_POSTPROCESS
void EngineContext::setPostProcessPipeline(Unique<PostProcessPipeline> pipeline) { postProcessPipeline_ = std::move(pipeline); }
+#endif
void EngineContext::setResourceManager(Unique<resource::ResourceManager> mgr) { resourceManager_ = std::move(mgr); }
void EngineContext::setTransformSystem(Unique<ecs::TransformSystem> sys) { transformSystem_ = std::move(sys); }
void EngineContext::setTweenSystem(Unique<animation::TweenSystem> sys) { tweenSystem_ = std::move(sys); }
+#ifdef ES_ENABLE_TIMELINE
void EngineContext::setTimelineSystem(Unique<animation::TimelineSystem> sys) { timelineSystem_ = std::move(sys); }
+#endif
+#ifdef ES_ENABLE_PARTICLES
void EngineContext::setParticleSystem(Unique<particle::ParticleSystem> sys) { particleSystem_ = std::move(sys); }
+#endif
#ifdef ES_ENABLE_SPINE
void EngineContext::setSpineResourceManager(Unique<spine::SpineResourceManager> mgr) { spineResourceManager_ = std::move(mgr); }
@@ -74,6 +86,12 @@ void EngineContext::shutdown() {
}
#endif
+#ifdef ES_ENABLE_TIMELINE
+ timelineSystem_.reset();
+#endif
+#ifdef ES_ENABLE_PARTICLES
+ particleSystem_.reset();
+#endif
tweenSystem_.reset();
transformSystem_.reset();
if (renderContext_) {
diff --git a/src/esengine/bindings/EngineContext.hpp b/src/esengine/bindings/EngineContext.hpp
index ad7c2922d..ddf00d88e 100644
--- a/src/esengine/bindings/EngineContext.hpp
+++ b/src/esengine/bindings/EngineContext.hpp
@@ -16,8 +16,12 @@
#include <glm/glm.hpp>
#include "../core/Types.hpp"
#include "../animation/TweenSystem.hpp"
+#ifdef ES_ENABLE_TIMELINE
#include "../animation/TimelineSystem.hpp"
+#endif
+#ifdef ES_ENABLE_PARTICLES
#include "../particle/ParticleSystem.hpp"
+#endif
namespace esengine {
@@ -25,7 +29,9 @@ class RenderContext;
class RenderFrame;
class ImmediateDraw;
class GeometryManager;
+#ifdef ES_ENABLE_POSTPROCESS
class PostProcessPipeline;
+#endif
namespace resource {
class ResourceManager;
@@ -64,12 +70,18 @@ public:
RenderFrame* renderFrame() { return renderFrame_.get(); }
ImmediateDraw* immediateDraw() { return immediateDraw_.get(); }
GeometryManager* geometryManager() { return geometryManager_.get(); }
+#ifdef ES_ENABLE_POSTPROCESS
PostProcessPipeline* postProcessPipeline() { return postProcessPipeline_.get(); }
+#endif
resource::ResourceManager* resourceManager() { return resourceManager_.get(); }
ecs::TransformSystem* transformSystem() { return transformSystem_.get(); }
animation::TweenSystem* tweenSystem() { return tweenSystem_.get(); }
+#ifdef ES_ENABLE_TIMELINE
animation::TimelineSystem* timelineSystem() { return timelineSystem_.get(); }
+#endif
+#ifdef ES_ENABLE_PARTICLES
particle::ParticleSystem* particleSystem() { return particleSystem_.get(); }
+#endif
#ifdef ES_ENABLE_SPINE
spine::SpineResourceManager* spineResourceManager() { return spineResourceManager_.get(); }
@@ -109,12 +121,18 @@ public:
void setRenderFrame(Unique<RenderFrame> frame);
void setImmediateDraw(Unique<ImmediateDraw> draw);
void setGeometryManager(Unique<GeometryManager> mgr);
+#ifdef ES_ENABLE_POSTPROCESS
void setPostProcessPipeline(Unique<PostProcessPipeline> pipeline);
+#endif
void setResourceManager(Unique<resource::ResourceManager> mgr);
void setTransformSystem(Unique<ecs::TransformSystem> sys);
void setTweenSystem(Unique<animation::TweenSystem> sys);
+#ifdef ES_ENABLE_TIMELINE
void setTimelineSystem(Unique<animation::TimelineSystem> sys);
+#endif
+#ifdef ES_ENABLE_PARTICLES
void setParticleSystem(Unique<particle::ParticleSystem> sys);
+#endif
#ifdef ES_ENABLE_SPINE
void setSpineResourceManager(Unique<spine::SpineResourceManager> mgr);
@@ -129,12 +147,18 @@ private:
Unique<RenderFrame> renderFrame_;
Unique<ImmediateDraw> immediateDraw_;
Unique<GeometryManager> geometryManager_;
+#ifdef ES_ENABLE_POSTPROCESS
Unique<PostProcessPipeline> postProcessPipeline_;
+#endif
Unique<resource::ResourceManager> resourceManager_;
Unique<ecs::TransformSystem> transformSystem_;
Unique<animation::TweenSystem> tweenSystem_;
+#ifdef ES_ENABLE_TIMELINE
Unique<animation::TimelineSystem> timelineSystem_;
+#endif
+#ifdef ES_ENABLE_PARTICLES
Unique<particle::ParticleSystem> particleSystem_;
+#endif
#ifdef ES_ENABLE_SPINE
Unique<spine::SpineResourceManager> spineResourceManager_;
diff --git a/src/esengine/bindings/PostProcessBindings.cpp b/src/esengine/bindings/PostProcessBindings.cpp
index 3eb746c24..de6621236 100644
--- a/src/esengine/bindings/PostProcessBindings.cpp
+++ b/src/esengine/bindings/PostProcessBindings.cpp
@@ -1,4 +1,5 @@
#ifdef ES_PLATFORM_WEB
+#ifdef ES_ENABLE_POSTPROCESS
#include "PostProcessBindings.hpp"
#include "EngineContext.hpp"
@@ -183,4 +184,5 @@ void postprocess_setScreenUniformVec4(const std::string& passName,
} // namespace esengine
+#endif // ES_ENABLE_POSTPROCESS
#endif // ES_PLATFORM_WEB
diff --git a/src/esengine/bindings/RendererBindings.cpp b/src/esengine/bindings/RendererBindings.cpp
index c0710f65d..9b7858e60 100644
--- a/src/esengine/bindings/RendererBindings.cpp
+++ b/src/esengine/bindings/RendererBindings.cpp
@@ -39,7 +39,9 @@ static EngineContext& ctx() { return EngineContext::instance(); }
#ifdef ES_ENABLE_SPINE
#define g_spineSystem (ctx().spineSystem())
#endif
+#ifdef ES_ENABLE_PARTICLES
#define g_particleSystem (ctx().particleSystem())
+#endif
static u32 checkGLErrors(const char* context) {
if (!g_glErrorCheckEnabled) return 0;
@@ -306,9 +308,11 @@ void renderer_submitUIElements(ecs::Registry& registry) {
(void)registry;
}
+#ifdef ES_ENABLE_BITMAP_TEXT
void renderer_submitBitmapText(ecs::Registry& registry) {
(void)registry;
}
+#endif
void renderer_submitShapes(ecs::Registry& registry) {
(void)registry;
@@ -320,9 +324,11 @@ void renderer_submitSpine(ecs::Registry& registry) {
}
#endif
+#ifdef ES_ENABLE_PARTICLES
void renderer_submitParticles(ecs::Registry& registry) {
(void)registry;
}
+#endif
void renderer_updateTransforms(ecs::Registry& registry) {
ensureTransformsUpdated(registry);
@@ -336,6 +342,7 @@ void renderer_submitAll(ecs::Registry& registry, u32 skipFlags, i32 vpX, i32 vpY
g_renderFrame->collectAll(registry, skipFlags);
}
+#ifdef ES_ENABLE_PARTICLES
void particle_update(ecs::Registry& registry, f32 dt) {
if (!g_particleSystem) return;
g_particleSystem->update(registry, dt);
@@ -363,6 +370,7 @@ u32 particle_getAliveCount(Entity entity) {
if (!g_particleSystem) return 0;
return g_particleSystem->aliveCount(entity);
}
+#endif
void renderer_setStage(i32 stage) {
if (!g_renderFrame) return;
diff --git a/src/esengine/bindings/RendererBindings.hpp b/src/esengine/bindings/RendererBindings.hpp
index f20ab45c5..c2b673f41 100644
--- a/src/esengine/bindings/RendererBindings.hpp
+++ b/src/esengine/bindings/RendererBindings.hpp
@@ -49,7 +49,9 @@ void renderer_flush();
void renderer_end();
void renderer_submitSprites(ecs::Registry& registry);
void renderer_submitUIElements(ecs::Registry& registry);
+#ifdef ES_ENABLE_BITMAP_TEXT
void renderer_submitBitmapText(ecs::Registry& registry);
+#endif
void renderer_submitShapes(ecs::Registry& registry);
#ifdef ES_ENABLE_SPINE
void renderer_submitSpine(ecs::Registry& registry);
@@ -62,14 +64,18 @@ void renderer_submitSpineBatch(
);
void spine_setNeedsReload(ecs::Registry& registry, Entity entity, bool value);
#endif
+#ifdef ES_ENABLE_PARTICLES
void renderer_submitParticles(ecs::Registry& registry);
+#endif
void renderer_updateTransforms(ecs::Registry& registry);
void renderer_submitAll(ecs::Registry& registry, u32 skipFlags, i32 vpX, i32 vpY, i32 vpW, i32 vpH);
+#ifdef ES_ENABLE_PARTICLES
void particle_update(ecs::Registry& registry, f32 dt);
void particle_play(ecs::Registry& registry, Entity entity);
void particle_stop(ecs::Registry& registry, Entity entity);
void particle_reset(ecs::Registry& registry, Entity entity);
u32 particle_getAliveCount(Entity entity);
+#endif
void renderer_setStage(i32 stage);
u32 renderer_createTarget(u32 width, u32 height, i32 flags);
u32 renderer_getTargetDepthTexture(u32 handle);
diff --git a/src/esengine/bindings/ResourceManagerBindings.cpp b/src/esengine/bindings/ResourceManagerBindings.cpp
index 4a7de6195..8ed089169 100644
--- a/src/esengine/bindings/ResourceManagerBindings.cpp
+++ b/src/esengine/bindings/ResourceManagerBindings.cpp
@@ -98,6 +98,7 @@ u32 rm_getTextureGLId(resource::ResourceManager& rm, u32 handleId) {
return tex ? tex->getId() : 0;
}
+#ifdef ES_ENABLE_BITMAP_TEXT
u32 rm_loadBitmapFont(resource::ResourceManager& rm, const std::string& fntContent,
u32 textureHandle, u32 texWidth, u32 texHeight) {
auto handle = rm.createBitmapFont(fntContent,
@@ -137,6 +138,7 @@ emscripten::val rm_measureBitmapText(resource::ResourceManager& rm, u32 fontHand
result.set("height", metrics.height);
return result;
}
+#endif
void rm_setTextureMetadata(resource::ResourceManager& rm, u32 handleId,
f32 left, f32 right, f32 top, f32 bottom) {
diff --git a/src/esengine/bindings/ResourceManagerBindings.hpp b/src/esengine/bindings/ResourceManagerBindings.hpp
index f05746f34..395812db1 100644
--- a/src/esengine/bindings/ResourceManagerBindings.hpp
+++ b/src/esengine/bindings/ResourceManagerBindings.hpp
@@ -27,6 +27,7 @@ void rm_registerTextureWithPath(resource::ResourceManager& rm, u32 handleId, con
void rm_releaseShader(resource::ResourceManager& rm, u32 handleId);
u32 rm_getShaderRefCount(resource::ResourceManager& rm, u32 handleId);
u32 rm_getTextureGLId(resource::ResourceManager& rm, u32 handleId);
+#ifdef ES_ENABLE_BITMAP_TEXT
u32 rm_loadBitmapFont(resource::ResourceManager& rm, const std::string& fntContent,
u32 textureHandle, u32 texWidth, u32 texHeight);
u32 rm_createLabelAtlasFont(resource::ResourceManager& rm, u32 textureHandle,
@@ -36,6 +37,7 @@ void rm_releaseBitmapFont(resource::ResourceManager& rm, u32 handleId);
u32 rm_getBitmapFontRefCount(resource::ResourceManager& rm, u32 handleId);
emscripten::val rm_measureBitmapText(resource::ResourceManager& rm, u32 fontHandle,
const std::string& text, f32 fontSize, f32 spacing);
+#endif
void rm_setTextureMetadata(resource::ResourceManager& rm, u32 handleId,
f32 left, f32 right, f32 top, f32 bottom);
diff --git a/src/esengine/bindings/TilemapBindings.cpp b/src/esengine/bindings/TilemapBindings.cpp
index e5bc9b53d..0458cc050 100644
--- a/src/esengine/bindings/TilemapBindings.cpp
+++ b/src/esengine/bindings/TilemapBindings.cpp
@@ -1,4 +1,5 @@
#ifdef ES_PLATFORM_WEB
+#ifdef ES_ENABLE_TILEMAP
#include "EngineContext.hpp"
#include "../tilemap/TilemapSystem.hpp"
@@ -469,4 +470,5 @@ EMSCRIPTEN_BINDINGS(esengine_tilemap) {
emscripten::function("tiled_getLayerParallaxY", &esengine::tiled_getLayerParallaxY);
}
+#endif // ES_ENABLE_TILEMAP
#endif // ES_PLATFORM_WEB
diff --git a/src/esengine/bindings/TimelineBindings.cpp b/src/esengine/bindings/TimelineBindings.cpp
index 9f73de7d1..a58379c64 100644
--- a/src/esengine/bindings/TimelineBindings.cpp
+++ b/src/esengine/bindings/TimelineBindings.cpp
@@ -1,4 +1,5 @@
#ifdef ES_PLATFORM_WEB
+#ifdef ES_ENABLE_TIMELINE
#include <emscripten.h>
#include <emscripten/bind.h>
@@ -385,4 +386,5 @@ EMSCRIPTEN_BINDINGS(esengine_timeline) {
emscripten::function("_tl_setTrackTarget", &esengine::tl_setTrackTarget);
}
+#endif // ES_ENABLE_TIMELINE
#endif // ES_PLATFORM_WEB
diff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cpp
index 7d0104a02..8e7678f0a 100644
--- a/src/esengine/bindings/WebSDKEntry.cpp
+++ b/src/esengine/bindings/WebSDKEntry.cpp
@@ -20,7 +20,9 @@
#include "RendererBindings.hpp"
#include "ImmediateDrawBindings.hpp"
#include "GeometryBindings.hpp"
+#ifdef ES_ENABLE_POSTPROCESS
#include "PostProcessBindings.hpp"
+#endif
#include "../ecs/UILayoutSystem.hpp"
#include "../ecs/UIHitTestSystem.hpp"
@@ -36,9 +38,13 @@
#include "../renderer/plugins/UIElementPlugin.hpp"
#include "../renderer/plugins/TextPlugin.hpp"
#include "../renderer/plugins/ShapePlugin.hpp"
+#ifdef ES_ENABLE_PARTICLES
#include "../renderer/plugins/ParticlePlugin.hpp"
+#endif
+#ifdef ES_ENABLE_TILEMAP
#include "../renderer/plugins/TilemapRenderPlugin.hpp"
#include "../tilemap/TilemapSystem.hpp"
+#endif
#ifdef ES_ENABLE_SPINE
#include "../renderer/plugins/SpinePlugin.hpp"
#endif
@@ -51,6 +57,9 @@
#include "../ecs/components/Collider.hpp"
#include "../ecs/components/ShapeRenderer.hpp"
#include "../animation/TweenSystem.hpp"
+#ifdef ES_ENABLE_PARTICLES
+#include "../particle/ParticleSystem.hpp"
+#endif
#include "../core/Log.hpp"
#ifdef ES_ENABLE_SPINE
#include "../spine/SpineResourceManager.hpp"
@@ -65,7 +74,9 @@ static_assert(sizeof(void*) == 4, "EM_JS pointer passing assumes wasm32 (4-byte
namespace esengine {
+#ifdef ES_ENABLE_TILEMAP
tilemap::TilemapSystem& getTilemapSystem();
+#endif
static EngineContext& ctx() { return EngineContext::instance(); }
@@ -76,7 +87,9 @@ static EngineContext& ctx() { return EngineContext::instance(); }
#define g_spineResourceManager (ctx().spineResourceManager())
#endif
#define g_renderContext (ctx().renderContext())
+#ifdef ES_ENABLE_PARTICLES
#define g_particleSystem (ctx().particleSystem())
+#endif
EM_JS(void, callMaterialProvider, (int materialId, int outShaderIdPtr, int outBlendModePtr, int outUniformBufPtr, int outUniformCountPtr), {
var fn = Module['materialDataProvider'];
@@ -206,8 +219,12 @@ static void initSubsystems() {
ctx().setTransformSystem(makeUnique<ecs::TransformSystem>());
ctx().setTweenSystem(makeUnique<animation::TweenSystem>());
+#ifdef ES_ENABLE_TIMELINE
ctx().setTimelineSystem(makeUnique<animation::TimelineSystem>());
+#endif
+#ifdef ES_ENABLE_PARTICLES
ctx().setParticleSystem(makeUnique<particle::ParticleSystem>());
+#endif
#ifdef ES_ENABLE_SPINE
auto spineResourceManager = makeUnique<spine::SpineResourceManager>(*g_resourceManager);
@@ -228,11 +245,13 @@ static void initSubsystems() {
renderFrame->addPlugin(std::make_unique<UIElementPlugin>());
renderFrame->addPlugin(std::make_unique<TextPlugin>());
renderFrame->addPlugin(std::make_unique<ShapePlugin>());
+#ifdef ES_ENABLE_TILEMAP
{
auto tilemapPlugin = std::make_unique<TilemapRenderPlugin>();
tilemapPlugin->setTilemapSystem(&getTilemapSystem());
renderFrame->addPlugin(std::move(tilemapPlugin));
}
+#endif
#ifdef ES_ENABLE_SPINE
{
auto spinePlugin = std::make_unique<SpinePlugin>();
@@ -240,11 +259,13 @@ static void initSubsystems() {
renderFrame->addPlugin(std::move(spinePlugin));
}
#endif
+#ifdef ES_ENABLE_PARTICLES
{
auto particlePlugin = std::make_unique<ParticlePlugin>();
particlePlugin->setParticleSystem(ctx().particleSystem());
renderFrame->addPlugin(std::move(particlePlugin));
}
+#endif
renderFrame->init(1280, 720);
ctx().setRenderFrame(std::move(renderFrame));
@@ -491,11 +512,14 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
.function("getTextureGLId", &esengine::rm_getTextureGLId)
.function("setTextureMetadata", &esengine::rm_setTextureMetadata)
.function("registerTextureWithPath", &esengine::rm_registerTextureWithPath)
+#ifdef ES_ENABLE_BITMAP_TEXT
.function("loadBitmapFont", &esengine::rm_loadBitmapFont)
.function("createLabelAtlasFont", &esengine::rm_createLabelAtlasFont)
.function("releaseBitmapFont", &esengine::rm_releaseBitmapFont)
.function("getBitmapFontRefCount", &esengine::rm_getBitmapFontRefCount)
- .function("measureBitmapText", &esengine::rm_measureBitmapText);
+ .function("measureBitmapText", &esengine::rm_measureBitmapText)
+#endif
+ ;
#ifdef ES_ENABLE_SPINE
emscripten::value_object<esengine::SpineBounds>("SpineBounds")
@@ -549,6 +573,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("geometry_release", &esengine::geometry_release);
emscripten::function("geometry_isValid", &esengine::geometry_isValid);
+#ifdef ES_ENABLE_POSTPROCESS
emscripten::function("postprocess_init", &esengine::postprocess_init);
emscripten::function("postprocess_shutdown", &esengine::postprocess_shutdown);
emscripten::function("postprocess_resize", &esengine::postprocess_resize);
@@ -574,6 +599,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("postprocess_clearScreenPasses", &esengine::postprocess_clearScreenPasses);
emscripten::function("postprocess_setScreenUniformFloat", &esengine::postprocess_setScreenUniformFloat);
emscripten::function("postprocess_setScreenUniformVec4", &esengine::postprocess_setScreenUniformVec4);
+#endif
emscripten::function("renderer_init", &esengine::renderer_init);
emscripten::function("renderer_resize", &esengine::renderer_resize);
@@ -583,19 +609,25 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("renderer_end", &esengine::renderer_end);
emscripten::function("renderer_submitSprites", &esengine::renderer_submitSprites);
emscripten::function("renderer_submitUIElements", &esengine::renderer_submitUIElements);
+#ifdef ES_ENABLE_BITMAP_TEXT
emscripten::function("renderer_submitBitmapText", &esengine::renderer_submitBitmapText);
+#endif
emscripten::function("renderer_submitShapes", &esengine::renderer_submitShapes);
#ifdef ES_ENABLE_SPINE
emscripten::function("renderer_submitSpine", &esengine::renderer_submitSpine);
#endif
+#ifdef ES_ENABLE_PARTICLES
emscripten::function("renderer_submitParticles", &esengine::renderer_submitParticles);
+#endif
emscripten::function("renderer_updateTransforms", &esengine::renderer_updateTransforms);
emscripten::function("renderer_submitAll", &esengine::renderer_submitAll);
+#ifdef ES_ENABLE_PARTICLES
emscripten::function("particle_update", &esengine::particle_update);
emscripten::function("particle_play", &esengine::particle_play);
emscripten::function("particle_stop", &esengine::particle_stop);
emscripten::function("particle_reset", &esengine::particle_reset);
emscripten::function("particle_getAliveCount", &esengine::particle_getAliveCount);
+#endif
emscripten::function("renderer_setStage", &esengine::renderer_setStage);
emscripten::function("renderer_createTarget", &esengine::renderer_createTarget);
emscripten::function("renderer_releaseTarget", &esengine::renderer_releaseTarget);
diff --git a/src/esengine/renderer/RenderFrame.cpp b/src/esengine/renderer/RenderFrame.cpp
index 5a243d845..3d5763451 100644
--- a/src/esengine/renderer/RenderFrame.cpp
+++ b/src/esengine/renderer/RenderFrame.cpp
@@ -87,8 +87,10 @@ void RenderFrame::init(u32 width, u32 height) {
state_tracker_.init();
+#ifdef ES_ENABLE_POSTPROCESS
post_process_ = makeUnique<PostProcessPipeline>(context_, resource_manager_);
post_process_->init(width, height);
+#endif
pool_.init();
batch_shader_id_ = initBatchShader();
@@ -113,10 +115,12 @@ void RenderFrame::shutdown() {
plugins_.clear();
pool_.shutdown();
+#ifdef ES_ENABLE_POSTPROCESS
if (post_process_) {
post_process_->shutdown();
post_process_.reset();
}
+#endif
ES_LOG_INFO("RenderFrame shutdown");
}
@@ -125,9 +129,11 @@ void RenderFrame::resize(u32 width, u32 height) {
width_ = width;
height_ = height;
+#ifdef ES_ENABLE_POSTPROCESS
if (post_process_) {
post_process_->resize(width, height);
}
+#endif
}
void RenderFrame::begin(const glm::mat4& view_projection, RenderTargetManager::Handle target) {
@@ -144,10 +150,15 @@ void RenderFrame::begin(const glm::mat4& view_projection, RenderTargetManager::H
draw_list_.clear();
clip_state_.clear();
+#ifdef ES_ENABLE_POSTPROCESS
bool usePostProcess = post_process_ && post_process_->isInitialized() &&
!post_process_->isBypassed() && post_process_->getPassCount() > 0;
+#else
+ bool usePostProcess = false;
+#endif
if (usePostProcess) {
+#ifdef ES_ENABLE_POSTPROCESS
if (target != RenderTargetManager::INVALID_HANDLE) {
auto* rt = target_manager_.get(target);
if (rt) {
@@ -155,6 +166,7 @@ void RenderFrame::begin(const glm::mat4& view_projection, RenderTargetManager::H
}
}
post_process_->begin();
+#endif
} else if (target != RenderTargetManager::INVALID_HANDLE) {
auto* rt = target_manager_.get(target);
if (rt) {
@@ -189,7 +201,9 @@ void RenderFrame::flush() {
case RenderType::Mesh:
case RenderType::ExternalMesh:
stats_.meshes += cmd.entity_count; break;
+#ifdef ES_ENABLE_PARTICLES
case RenderType::Particle: stats_.particles += cmd.entity_count; break;
+#endif
case RenderType::Shape: stats_.shapes += cmd.entity_count; break;
#ifdef ES_ENABLE_SPINE
case RenderType::Spine: stats_.spine += cmd.entity_count; break;
@@ -206,11 +220,17 @@ void RenderFrame::end() {
flush();
}
+#ifdef ES_ENABLE_POSTPROCESS
bool usePostProcess = post_process_ && post_process_->isInitialized() &&
!post_process_->isBypassed() && post_process_->getPassCount() > 0;
+#else
+ bool usePostProcess = false;
+#endif
if (usePostProcess) {
+#ifdef ES_ENABLE_POSTPROCESS
post_process_->end();
+#endif
} else if (current_target_ != RenderTargetManager::INVALID_HANDLE) {
auto* rt = target_manager_.get(current_target_);
if (rt) {
@@ -628,6 +648,7 @@ void RenderFrame::submitTileQuad(
draw_list_.push(cmd);
}
+#ifdef ES_ENABLE_SPINE
void RenderFrame::submitSpineBatch(
const f32* vertices, i32 vertexCount,
const u16* indices, i32 indexCount,
@@ -677,6 +698,7 @@ void RenderFrame::submitSpineBatch(
clip_state_.applyTo(entity, cmd);
draw_list_.push(cmd);
}
+#endif
// ============================================================================
// Plugin Pipeline
diff --git a/src/esengine/renderer/RenderFrame.hpp b/src/esengine/renderer/RenderFrame.hpp
index 640f4e102..86f13bf52 100644
--- a/src/esengine/renderer/RenderFrame.hpp
+++ b/src/esengine/renderer/RenderFrame.hpp
@@ -5,7 +5,9 @@
#include "RenderTarget.hpp"
#include "RenderContext.hpp"
#include "RenderTypePlugin.hpp"
+#ifdef ES_ENABLE_POSTPROCESS
#include "PostProcessPipeline.hpp"
+#endif
#include "FrameCapture.hpp"
#include "StateTracker.hpp"
#include "TransientBufferPool.hpp"
@@ -85,6 +87,7 @@ public:
Entity entity, i32 layer, f32 depth
);
+#ifdef ES_ENABLE_SPINE
void submitSpineBatch(
const f32* vertices, i32 vertexCount,
const u16* indices, i32 indexCount,
@@ -92,11 +95,14 @@ public:
const f32* transform16,
Entity entity, i32 layer, f32 depth
);
+#endif
void setStage(RenderStage stage) { current_stage_ = stage; }
RenderStage getStage() const { return current_stage_; }
+#ifdef ES_ENABLE_POSTPROCESS
PostProcessPipeline* postProcess() { return post_process_.get(); }
+#endif
RenderTargetManager& targetManager() { return target_manager_; }
const Stats& stats() const { return stats_; }
@@ -118,7 +124,9 @@ private:
resource::ResourceManager& resource_manager_;
StateTracker state_tracker_;
+#ifdef ES_ENABLE_POSTPROCESS
Unique<PostProcessPipeline> post_process_;
+#endif
RenderTargetManager target_manager_;
glm::mat4 view_projection_{1.0f};
diff --git a/src/esengine/renderer/RenderItem.hpp b/src/esengine/renderer/RenderItem.hpp
index d24737a6f..ae574b8af 100644
--- a/src/esengine/renderer/RenderItem.hpp
+++ b/src/esengine/renderer/RenderItem.hpp
@@ -20,7 +20,9 @@ enum class RenderType : u8 {
Mesh = 2,
ExternalMesh = 3,
Text = 4,
+#ifdef ES_ENABLE_PARTICLES
Particle = 5,
+#endif
Shape = 6,
UIElement = 7,
};
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
index 5206230e7..c098843ed 100644
--- a/third_party/CMakeLists.txt
+++ b/third_party/CMakeLists.txt
@@ -51,8 +51,10 @@ target_compile_definitions(glm INTERFACE
# cute_tiled - Tiled JSON map parser
# =============================================================================
-add_library(cute_tiled INTERFACE)
-target_include_directories(cute_tiled INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/cute_tiled)
+if(ES_ENABLE_TILEMAP)
+ add_library(cute_tiled INTERFACE)
+ target_include_directories(cute_tiled INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/cute_tiled)
+endif()
# =============================================================================
# Native Platform Dependencies