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.

fix(render): a skeleton posed by DragonBones had no door to come through without Spine

esengineb73898e92d1c
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f2808298c..950482c5d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,23 @@ published separately; it ships inside the editor.
### Changed
+- **A skeleton can be drawn with a material.** `SpineAnimation.material` and
+ `DragonBonesAnimation.material` were authorable and unread: a skeleton always
+ drew with the built-in batch shader. Both now resolve the same way a `Sprite`'s
+ material does — its program, blend mode, depth flags and cull, plus its
+ `#pragma param` values — because posed geometry arrives in the very same batch
+ vertex format a sprite does. The material is read from the entity per frame, not
+ mirrored into the runtime, so writing the field takes effect on the next frame.
+ `ParticleEmitter.material` is still unread and still declared as a gap: a
+ particle is drawn from an instanced vertex source, and nothing compiles a
+ material for that one yet.
+
+- **Render stats count skeletal triangles, not "spine" ones.** `RenderStats.spine`
+ is `RenderStats.skeletal`, and the wasm export behind it is `renderer_getSkeletal`
+ — DragonBones geometry was always counted there too. Two dead exports went with
+ it: `renderer_submitSpine` (an empty function) and `renderer_submitSpineBatch`
+ (no caller since spine moved to side modules).
+
- **The lit material domains lose the plane from their names too.**
`#pragma domain Lit2D` is `Lit` and `Unlit2D` is `Unlit`. `Lit` was never the
flat half of anything either: a 3D mesh, its PBR shading, its environment
@@ -115,6 +132,16 @@ published separately; it ships inside the editor.
### Fixed
+- **A build with DragonBones but no Spine had no way to draw a skeleton.** The
+ binding every skeletal runtime submits its posed geometry through was compiled
+ only when `ES_ENABLE_SPINE` was on — so with Spine off, DragonBones handed its
+ vertices to an export that was not there and drew nothing, silently. The core
+ links neither runtime (each is a standalone side module), so that door is now
+ always open, and a new gate `check-sidemodule-gates` refuses any side module's
+ build option that decides how the core compiles. No released build is affected:
+ every shipping configuration has Spine on. The one that does not — CMake's
+ `esengine-core` — has never been built.
+
- **A component that describes a region of world is drawn, and a gate says so.**
`NavAgent`'s routing width, `ParticleForceField`'s reach, `ShadowCaster2D`'s
occluder box and `PostProcessVolume`'s graded region were all authorable numbers
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 344a87b7c..a5801c19c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -8,7 +8,10 @@ set(CMAKE_CXX_EXTENSIONS OFF)
option(ES_BUILD_WEB "Build for Web/Emscripten" OFF)
option(ES_BUILD_WXGAME "Build for WeChat MiniGame" OFF)
option(ES_BUILD_TESTS "Build tests" ON)
-option(ES_ENABLE_SPINE "Enable Spine animation support" ON)
+# Which spine{NN}.wasm side modules to build. The core links no spine code and no
+# longer compiles differently for it: posed geometry from ANY skeletal runtime
+# comes through renderer_submitSkeletalBatchByEntity, which is always there.
+option(ES_ENABLE_SPINE "Build the Spine runtime side modules" ON)
# OFF by default: only the DragonBones side module turns it on, and nothing in the
# main engine links it (see third_party/CMakeLists.txt).
option(ES_ENABLE_DRAGONBONES "Build the DragonBones runtime (side module only)" OFF)
@@ -261,13 +264,6 @@ if(ES_ENABLE_BITMAP_TEXT)
target_compile_definitions(esengine PUBLIC ES_ENABLE_BITMAP_TEXT)
endif()
-if(ES_ENABLE_SPINE)
- # Core links no spine runtime — spine is fully side-module (spine{NN}.wasm).
- # ES_ENABLE_SPINE still gates the renderer's spine RenderItem plumbing and the
- # side-module mesh-submit binding (renderer_submitSpineBatch).
- target_compile_definitions(esengine PUBLIC ES_ENABLE_SPINE)
-endif()
-
# ESEngine is a web-only engine: it targets Emscripten (WebGL2 / GLES3) and ships
# as wasm for web, WeChat MiniGame, and the Tauri desktop shell. There is no native
# GPU/runtime build. (The header-only / MockGfxDevice unit tests under tests/ still
diff --git a/sdk/etc/dragonbones.api.md b/sdk/etc/dragonbones.api.md
index 5e7a95117..beb99cbf0 100644
--- a/sdk/etc/dragonbones.api.md
+++ b/sdk/etc/dragonbones.api.md
@@ -53,7 +53,7 @@ setEnabled: (entity: Entity, enabled: boolean) => void
setEntityProps: (entity: Entity, props: Partial<Pick<EntityInfo, "skeletonScale" | "flipX" | "flipY" | "layer" | "playing">> & { timeScale?: number; color?: { r: number; g: number; b: number; a: number; }; }) => void
setTimeScale: (entity: Entity, scale: number) => void
stop: (entity: Entity, animation?: string) => void
-submitMeshes: (core: SkeletalSubmitCore, registry: unknown) => void
+submitMeshes: (core: SkeletalSubmitCore, registry: unknown, materialOf?: SkeletalMaterialOf) => void
updateAnimations: (dt: number) => void
static new (controller: DragonBonesModuleController): DragonBonesManager
static prototype: DragonBonesManager
diff --git a/sdk/etc/index.api.md b/sdk/etc/index.api.md
index a32742ba0..7d3b80d89 100644
--- a/sdk/etc/index.api.md
+++ b/sdk/etc/index.api.md
@@ -3339,7 +3339,7 @@ fps: number
frameTimeMs: number
meshes: number
phaseTimings: Map<string, number>
-spine: number
+skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
@@ -6276,7 +6276,7 @@ Transparent = 2
culled: number
drawCalls: number
meshes: number
-spine: number
+skeletal: number
sprites: number
text: number
triangles: number
diff --git a/sdk/etc/index.native.api.md b/sdk/etc/index.native.api.md
index 68b98fa50..a2a19533b 100644
--- a/sdk/etc/index.native.api.md
+++ b/sdk/etc/index.native.api.md
@@ -3347,7 +3347,7 @@ fps: number
frameTimeMs: number
meshes: number
phaseTimings: Map<string, number>
-spine: number
+skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
@@ -6469,7 +6469,7 @@ Transparent = 2
culled: number
drawCalls: number
meshes: number
-spine: number
+skeletal: number
sprites: number
text: number
triangles: number
diff --git a/sdk/etc/index.node.api.md b/sdk/etc/index.node.api.md
index 04aba0f45..ed2f8c0ee 100644
--- a/sdk/etc/index.node.api.md
+++ b/sdk/etc/index.node.api.md
@@ -3334,7 +3334,7 @@ fps: number
frameTimeMs: number
meshes: number
phaseTimings: Map<string, number>
-spine: number
+skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
@@ -6271,7 +6271,7 @@ Transparent = 2
culled: number
drawCalls: number
meshes: number
-spine: number
+skeletal: number
sprites: number
text: number
triangles: number
diff --git a/sdk/etc/minigame.api.md b/sdk/etc/minigame.api.md
index 9903215dd..52b1c1dfe 100644
--- a/sdk/etc/minigame.api.md
+++ b/sdk/etc/minigame.api.md
@@ -3334,7 +3334,7 @@ fps: number
frameTimeMs: number
meshes: number
phaseTimings: Map<string, number>
-spine: number
+skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
@@ -6516,7 +6516,7 @@ Transparent = 2
culled: number
drawCalls: number
meshes: number
-spine: number
+skeletal: number
sprites: number
text: number
triangles: number
diff --git a/sdk/etc/spine.api.md b/sdk/etc/spine.api.md
index b5d3ee913..66468adcc 100644
--- a/sdk/etc/spine.api.md
+++ b/sdk/etc/spine.api.md
@@ -16,7 +16,7 @@ collectAllEvents: () => { entity: Entity; raw: RawSpineEvent; }[]
controller: SpineModuleController
enableEvents: (entity: Entity) => void
entityCount: number
-extractAndSubmitMeshes: (core: NonNullable<EngineApi>, registry: CppRegistry) => void
+extractAndSubmitMeshes: (core: NonNullable<EngineApi>, registry: CppRegistry, materialOf?: SkeletalMaterialOf) => void
getAnimations: (entity: Entity) => string[]
getBounds: (entity: Entity) => { x: number; y: number; width: number; height: number; } | null
getPathConstraintMix: (entity: Entity, name: string) => PathMixData | null
@@ -130,7 +130,7 @@ setSlotColor: (entity: Entity, slotName: string, r: number, g: number, b: number
setTrackAlpha: (entity: Entity, track: number, alpha: number) => void
setTransformConstraintMix: (entity: Entity, name: string, mix: TransformMixData) => boolean
shutdown: () => void
-submitMeshes: (registry: CppRegistry) => void
+submitMeshes: (registry: CppRegistry, materialOf?: SkeletalMaterialOf) => void
updateAnimations: (dt: number) => void
static detectVersion: (data: Uint8Array) => SpineVersion | null
static detectVersionJson: (json: string) => SpineVersion | null
diff --git a/sdk/etc/wasm.api.md b/sdk/etc/wasm.api.md
index 2256c1c63..e40403180 100644
--- a/sdk/etc/wasm.api.md
+++ b/sdk/etc/wasm.api.md
@@ -375,11 +375,11 @@ renderer_getPreviewHeight: () => number
renderer_getPreviewPtr: () => number
renderer_getPreviewSize: () => number
renderer_getPreviewWidth: () => number
+renderer_getSkeletal: (() => number) | undefined
renderer_getSnapshotHeight: () => number
renderer_getSnapshotPtr: () => number
renderer_getSnapshotSize: () => number
renderer_getSnapshotWidth: () => number
-renderer_getSpine: (() => number) | undefined
renderer_getSprites: () => number
renderer_getTargetDepthTexture: (handle: number) => number
renderer_getTargetTexture: (handle: number) => number
@@ -412,9 +412,7 @@ renderer_submitAll: (registry: CppRegistry, skipFlags: number, vpX: number, vpY:
renderer_submitBitmapText: (registry: CppRegistry) => void
renderer_submitParticles: ((registry: CppRegistry) => void) | undefined
renderer_submitShapes: ((registry: CppRegistry) => void) | undefined
-renderer_submitSkeletalBatchByEntity: ((registry: CppRegistry, verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, entity: number, skelScale: number, flipX: boolean, flipY: boolean, layer: number, depth: number) => void) | undefined
-renderer_submitSpine: ((registry: CppRegistry) => void) | undefined
-renderer_submitSpineBatch: ((verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, transformPtr: number, entity: number, layer: number, depth: number) => void) | undefined
+renderer_submitSkeletalBatchByEntity: ((registry: CppRegistry, verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, entity: number, skelScale: number, flipX: boolean, flipY: boolean, layer: number, depth: number, materialId: number) => void) | undefined
renderer_submitSprites: (registry: CppRegistry) => void
renderer_submitTextBatch: ((verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, transformPtr: number, entity: number, layer: number, depth: number, sdf: number, cullBit: number) => void) | undefined
renderer_submitUIElements: (registry: CppRegistry) => void
diff --git a/sdk/etc/wechat.api.md b/sdk/etc/wechat.api.md
index be9750522..15e30e913 100644
--- a/sdk/etc/wechat.api.md
+++ b/sdk/etc/wechat.api.md
@@ -3334,7 +3334,7 @@ fps: number
frameTimeMs: number
meshes: number
phaseTimings: Map<string, number>
-spine: number
+skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
@@ -6278,7 +6278,7 @@ Transparent = 2
culled: number
drawCalls: number
meshes: number
-spine: number
+skeletal: number
sprites: number
text: number
triangles: number
diff --git a/sdk/src/dragonbones/DragonBonesManager.ts b/sdk/src/dragonbones/DragonBonesManager.ts
index 2bdb2412a..593f21d04 100644
--- a/sdk/src/dragonbones/DragonBonesManager.ts
+++ b/sdk/src/dragonbones/DragonBonesManager.ts
@@ -16,7 +16,7 @@
* honest fallback for a caller that cannot say when two are the same.
*/
import type { Entity } from '../types';
-import { submitEntityMeshes, type SkeletalSubmitCore } from '../skeletal/submitMeshes';
+import { submitEntityMeshes, type SkeletalMaterialOf, type SkeletalSubmitCore } from '../skeletal/submitMeshes';
import type { SkeletalBounds } from '../skeletal/types';
import { DragonBonesModuleController } from './DragonBonesController';
import { log } from '../util/logger';
@@ -230,13 +230,13 @@ export class DragonBonesManager {
}
}
- submitMeshes(core: SkeletalSubmitCore, registry: unknown): void {
+ submitMeshes(core: SkeletalSubmitCore, registry: unknown, materialOf?: SkeletalMaterialOf): void {
for (const [entity, info] of this.entities_) {
if (this.disabled_.has(entity)) continue;
// False means the core cannot take geometry at all, so asking again for
// the next entity would only repeat the same check.
const accepted = submitEntityMeshes(core, registry, entity, info, cb =>
- this.controller_.forEachMeshBatch(info.instanceId, cb));
+ this.controller_.forEachMeshBatch(info.instanceId, cb), materialOf);
if (!accepted) return;
}
}
diff --git a/sdk/src/dragonbones/DragonBonesPlugin.ts b/sdk/src/dragonbones/DragonBonesPlugin.ts
index c225f651f..af74b80fa 100644
--- a/sdk/src/dragonbones/DragonBonesPlugin.ts
+++ b/sdk/src/dragonbones/DragonBonesPlugin.ts
@@ -98,7 +98,8 @@ export class DragonBonesPlugin implements Plugin {
this.submitWired_ = true;
const core = engineApi(app);
app.pipeline?.addPreFlushCallback(registry => {
- if (core) this.manager_?.submitMeshes(core, registry._cpp);
+ if (core) this.manager_?.submitMeshes(core, registry._cpp, (e) =>
+ (app.world.tryGet(e, DragonBonesAnimation)?.material as number | undefined) ?? 0);
});
}
diff --git a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
index f186e1510..4bce31bcb 100644
--- a/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
+++ b/sdk/src/ecs/bridge/nativeEngineApi.generated.ts
@@ -136,10 +136,10 @@ export interface NativeEngineApi {
renderer_getPreviewHeight?(): number;
renderer_getPreviewSize?(): number;
renderer_getPreviewWidth?(): number;
+ renderer_getSkeletal?(): number;
renderer_getSnapshotHeight?(): number;
renderer_getSnapshotSize?(): number;
renderer_getSnapshotWidth?(): number;
- renderer_getSpine?(): number;
renderer_getSprites?(): number;
renderer_getTargetDepthTexture?(handle: number): number;
renderer_getTargetTexture?(handle: number): number;
@@ -172,9 +172,7 @@ export interface NativeEngineApi {
renderer_submitBitmapText?(registry: unknown): void;
renderer_submitParticles?(registry: unknown): void;
renderer_submitShapes?(registry: unknown): void;
- renderer_submitSkeletalBatchByEntity?(registry: unknown, verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, entity: number, skelScale: number, flipX: boolean, flipY: boolean, layer: number, depth: number): void;
- renderer_submitSpine?(registry: unknown): void;
- renderer_submitSpineBatch?(verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, transformPtr: number, entity: number, layer: number, depth: number): void;
+ renderer_submitSkeletalBatchByEntity?(registry: unknown, verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, blendMode: number, entity: number, skelScale: number, flipX: boolean, flipY: boolean, layer: number, depth: number, materialId: number): void;
renderer_submitSprites?(registry: unknown): void;
renderer_submitTextBatch?(verticesPtr: number, vertexCount: number, indicesPtr: number, indexCount: number, textureId: number, transformPtr: number, entity: number, layer: number, depth: number, sdf: number, cullBit: number): void;
renderer_submitUIElements?(registry: unknown): void;
@@ -388,10 +386,10 @@ export function createNativeEngineApi(
bind('renderer_getPreviewHeight', 'es_renderer_getPreviewHeight', false);
bind('renderer_getPreviewSize', 'es_renderer_getPreviewSize', false);
bind('renderer_getPreviewWidth', 'es_renderer_getPreviewWidth', false);
+ bind('renderer_getSkeletal', 'es_renderer_getSkeletal', false);
bind('renderer_getSnapshotHeight', 'es_renderer_getSnapshotHeight', false);
bind('renderer_getSnapshotSize', 'es_renderer_getSnapshotSize', false);
bind('renderer_getSnapshotWidth', 'es_renderer_getSnapshotWidth', false);
- bind('renderer_getSpine', 'es_renderer_getSpine', false);
bind('renderer_getSprites', 'es_renderer_getSprites', false);
bind('renderer_getTargetDepthTexture', 'es_renderer_getTargetDepthTexture', false);
bind('renderer_getTargetTexture', 'es_renderer_getTargetTexture', false);
@@ -425,8 +423,6 @@ export function createNativeEngineApi(
bind('renderer_submitParticles', 'es_renderer_submitParticles', true);
bind('renderer_submitShapes', 'es_renderer_submitShapes', true);
bind('renderer_submitSkeletalBatchByEntity', 'es_renderer_submitSkeletalBatchByEntity', true);
- bind('renderer_submitSpine', 'es_renderer_submitSpine', true);
- bind('renderer_submitSpineBatch', 'es_renderer_submitSpineBatch', false);
bind('renderer_submitSprites', 'es_renderer_submitSprites', true);
bind('renderer_submitTextBatch', 'es_renderer_submitTextBatch', false);
bind('renderer_submitUIElements', 'es_renderer_submitUIElements', true);
diff --git a/sdk/src/ecs/bridge/nativeRenderer.ts b/sdk/src/ecs/bridge/nativeRenderer.ts
index afa5a8365..4381a468a 100644
--- a/sdk/src/ecs/bridge/nativeRenderer.ts
+++ b/sdk/src/ecs/bridge/nativeRenderer.ts
@@ -97,7 +97,7 @@ export function createNativeRendererBackend(
triangles: read(RENDERER_STATS_BINDINGS.triangles),
sprites: read(RENDERER_STATS_BINDINGS.sprites),
text: read(RENDERER_STATS_BINDINGS.text),
- spine: 0, // the spine module has no native counterpart yet
+ skeletal: 0, // the skeletal runtimes have no native counterpart yet
meshes: read(RENDERER_STATS_BINDINGS.meshes),
culled: read(RENDERER_STATS_BINDINGS.culled),
};
diff --git a/sdk/src/render/renderer.ts b/sdk/src/render/renderer.ts
index b93740198..8c6a1e62a 100644
--- a/sdk/src/render/renderer.ts
+++ b/sdk/src/render/renderer.ts
@@ -29,7 +29,8 @@ export interface RenderStats {
triangles: number;
sprites: number;
text: number;
- spine: number;
+ /// Triangles posed by a skeletal runtime — Spine and DragonBones both count here.
+ skeletal: number;
meshes: number;
culled: number;
}
@@ -66,7 +67,7 @@ export interface RendererBackend {
getStats(): RenderStats;
}
-const NO_STATS: RenderStats = { drawCalls: 0, triangles: 0, sprites: 0, text: 0, spine: 0, meshes: 0, culled: 0 };
+const NO_STATS: RenderStats = { drawCalls: 0, triangles: 0, sprites: 0, text: 0, skeletal: 0, meshes: 0, culled: 0 };
const bridge = new CoreApiBridge('renderer');
let module: ESEngineModule | null = null;
@@ -127,7 +128,7 @@ function wasmBackend(m: ESEngineModule): RendererBackend {
triangles: m.renderer_getTriangles(),
sprites: m.renderer_getSprites(),
text: m.renderer_getText(),
- spine: m.renderer_getSpine?.() ?? 0,
+ skeletal: m.renderer_getSkeletal?.() ?? 0,
meshes: m.renderer_getMeshes(),
culled: m.renderer_getCulled(),
}),
diff --git a/sdk/src/skeletal/submitMeshes.ts b/sdk/src/skeletal/submitMeshes.ts
index 1d9d55bbf..ffe8f7d11 100644
--- a/sdk/src/skeletal/submitMeshes.ts
+++ b/sdk/src/skeletal/submitMeshes.ts
@@ -26,6 +26,14 @@ export interface SkeletalSubmitProps {
layer: number;
}
+/**
+ * The material a skeleton is drawn with, as the engine knows it (0 = none).
+ * Read per frame from the entity's own component rather than mirrored into the
+ * manager: a material handle is whatever the component says this frame, and a
+ * copy kept beside the pose would answer with the previous one.
+ */
+export type SkeletalMaterialOf = (entity: Entity) => number;
+
/** The slice of the engine core this needs. */
export interface SkeletalSubmitCore {
renderer_submitSkeletalBatchByEntity?(
@@ -34,7 +42,7 @@ export interface SkeletalSubmitCore {
indicesPtr: number, indexCount: number,
textureId: number, blendMode: number,
entity: number, skeletonScale: number, flipX: boolean, flipY: boolean,
- layer: number, depth: number,
+ layer: number, depth: number, materialId: number,
): void;
_malloc?(size: number): number;
_free?(ptr: number): void;
@@ -56,12 +64,14 @@ export function submitEntityMeshes(
entity: Entity,
props: SkeletalSubmitProps,
walk: MeshBatchWalker,
+ materialOf?: SkeletalMaterialOf,
): boolean {
const submit = core.renderer_submitSkeletalBatchByEntity;
const heap = core.HEAPU8;
if (!submit || !heap || !core._malloc || !core._free) return false;
const allocator = { _malloc: core._malloc, _free: core._free };
+ const materialId = materialOf?.(entity) ?? 0;
withScratch(allocator, alloc => {
walk((vertBytes, idxBytes, vertexCount, indexCount, textureId, blendMode) => {
const dstVert = alloc(vertBytes.byteLength);
@@ -71,7 +81,7 @@ export function submitEntityMeshes(
submit.call(core, registry,
dstVert, vertexCount, dstIdx, indexCount,
textureId, blendMode, entity as number,
- props.skeletonScale, props.flipX, props.flipY, props.layer, 0);
+ props.skeletonScale, props.flipX, props.flipY, props.layer, 0, materialId);
});
});
return true;
diff --git a/sdk/src/spine/ModuleBackend.ts b/sdk/src/spine/ModuleBackend.ts
index bbd390c3c..55b298850 100644
--- a/sdk/src/spine/ModuleBackend.ts
+++ b/sdk/src/spine/ModuleBackend.ts
@@ -6,7 +6,7 @@ import type { EngineApi } from '../ecs/bridge/engineApi';
import type { SpineModuleController } from './SpineController';
import type { RawSpineEvent, ConstraintList, TransformMixData, PathMixData } from './SpineController';
import { log } from '../util/logger';
-import { submitEntityMeshes } from '../skeletal/submitMeshes';
+import { submitEntityMeshes, type SkeletalMaterialOf } from '../skeletal/submitMeshes';
interface EntityInfo {
skelHandle: number;
@@ -237,7 +237,8 @@ export class ModuleBackend {
/** @param core whichever engine core is present (see ecs/engineApi.ts) — the
* batches cross through its heap, which is wasm linear memory on the web and the
* host arena on a device. */
- extractAndSubmitMeshes(core: NonNullable<EngineApi>, registry: CppRegistry): void {
+ extractAndSubmitMeshes(core: NonNullable<EngineApi>, registry: CppRegistry,
+ materialOf?: SkeletalMaterialOf): void {
for (const [entity, info] of this.entities_) {
if (this.disabledEntities_.has(entity)) continue;
// Shared with every skeletal runtime (skeletal/submitMeshes): the core's
@@ -245,7 +246,7 @@ export class ModuleBackend {
// what posed them. A false means the core cannot take geometry at all,
// so there is no point asking again for the next entity.
const accepted = submitEntityMeshes(core, registry, entity, info, cb =>
- this.controller_.forEachMeshBatch(info.instanceId, cb));
+ this.controller_.forEachMeshBatch(info.instanceId, cb), materialOf);
if (!accepted) return;
}
}
diff --git a/sdk/src/spine/SpineManager.ts b/sdk/src/spine/SpineManager.ts
index b3fbee20c..beab9896d 100644
--- a/sdk/src/spine/SpineManager.ts
+++ b/sdk/src/spine/SpineManager.ts
@@ -3,6 +3,7 @@
import type { EngineApi } from '../ecs/bridge/engineApi';
import type { ESEngineModule, CppRegistry } from '../wasm';
import type { Entity } from '../types';
+import type { SkeletalMaterialOf } from '../skeletal/submitMeshes';
import type { RawSpineEvent, ConstraintList, TransformMixData, PathMixData } from './SpineController';
import type { SpineModuleFactory } from './SpineModuleLoader';
import { wrapSpineModule } from './SpineModuleLoader';
@@ -101,9 +102,9 @@ export class SpineManager {
}
}
- submitMeshes(registry: CppRegistry): void {
+ submitMeshes(registry: CppRegistry, materialOf?: SkeletalMaterialOf): void {
for (const backend of this.backends_.values()) {
- backend.extractAndSubmitMeshes(this.coreModule_, registry);
+ backend.extractAndSubmitMeshes(this.coreModule_, registry, materialOf);
}
}
diff --git a/sdk/src/spine/SpinePlugin.ts b/sdk/src/spine/SpinePlugin.ts
index 2dfd9157f..f2867a85c 100644
--- a/sdk/src/spine/SpinePlugin.ts
+++ b/sdk/src/spine/SpinePlugin.ts
@@ -96,7 +96,8 @@ export class SpinePlugin implements Plugin {
if (this.submitWired_) return;
this.submitWired_ = true;
app.pipeline?.addPreFlushCallback((registry) => {
- this.spineManager_?.submitMeshes(registry._cpp);
+ this.spineManager_?.submitMeshes(registry._cpp, (e: Entity) =>
+ (app.world.tryGet(e, SpineAnimation)?.material as number | undefined) ?? 0);
});
}
diff --git a/sdk/src/stats.ts b/sdk/src/stats.ts
index e5767d425..6d4066074 100644
--- a/sdk/src/stats.ts
+++ b/sdk/src/stats.ts
@@ -16,7 +16,7 @@ export interface FrameStats {
triangles: number;
sprites: number;
text: number;
- spine: number;
+ skeletal: number;
meshes: number;
culled: number;
}
@@ -32,7 +32,7 @@ export function defaultFrameStats(): FrameStats {
triangles: 0,
sprites: 0,
text: 0,
- spine: 0,
+ skeletal: 0,
meshes: 0,
culled: 0,
};
@@ -206,7 +206,7 @@ export class StatsPlugin implements Plugin {
stats.triangles = renderStats.triangles;
stats.sprites = renderStats.sprites;
stats.text = renderStats.text;
- stats.spine = renderStats.spine;
+ stats.skeletal = renderStats.skeletal;
stats.meshes = renderStats.meshes;
stats.culled = renderStats.culled;
diff --git a/sdk/src/wasm.ts b/sdk/src/wasm.ts
index 5fb725c87..304b49512 100644
--- a/sdk/src/wasm.ts
+++ b/sdk/src/wasm.ts
@@ -295,20 +295,17 @@ export interface ESEngineModule {
ui_getRenderOrder?(registry: CppRegistry, entity: number): number;
ui_getCullBit?(registry: CppRegistry, entity: number): number;
- renderer_submitSpineBatch?(
- verticesPtr: number, vertexCount: number,
- indicesPtr: number, indexCount: number,
- textureId: number, blendMode: number,
- transformPtr: number,
- entity: number, layer: number, depth: number
- ): void;
+ /**
+ * Geometry posed by a skeletal runtime (Spine, DragonBones): x,y,u,v,r,g,b,a per
+ * vertex, drawn as `entity`'s, with `materialId` resolved as a Sprite's is.
+ */
renderer_submitSkeletalBatchByEntity?(
registry: CppRegistry,
verticesPtr: number, vertexCount: number,
indicesPtr: number, indexCount: number,
textureId: number, blendMode: number,
entity: number, skelScale: number, flipX: boolean, flipY: boolean,
- layer: number, depth: number
+ layer: number, depth: number, materialId: number
): void;
/**
* Submit pre-laid-out glyph quads. Vertex format x,y,u,v,r,g,b,a; `sdf` (1/0)
@@ -442,7 +439,6 @@ export interface ESEngineModule {
renderer_submitUIElements(registry: CppRegistry): void;
renderer_submitBitmapText(registry: CppRegistry): void;
renderer_submitShapes?(registry: CppRegistry): void;
- renderer_submitSpine?(registry: CppRegistry): void;
renderer_submitParticles?(registry: CppRegistry): void;
renderer_submitAll(registry: CppRegistry, skipFlags: number, vpX: number, vpY: number, vpW: number, vpH: number): void;
particle_update?(registry: CppRegistry, dt: number): void;
@@ -491,7 +487,7 @@ export interface ESEngineModule {
renderer_getTriangles(): number;
renderer_getSprites(): number;
renderer_getText(): number;
- renderer_getSpine?(): number;
+ renderer_getSkeletal?(): number;
renderer_getMeshes(): number;
renderer_getCulled(): number;
/** Last frame's GPU time (ms) via EXT_disjoint_timer_query, or -1 if unavailable. */
diff --git a/sdk/tests/renderer.test.ts b/sdk/tests/renderer.test.ts
index e847ebeee..ddeea60f9 100644
--- a/sdk/tests/renderer.test.ts
+++ b/sdk/tests/renderer.test.ts
@@ -50,7 +50,7 @@ function createRendererMockModule() {
renderer_getTriangles: vi.fn(() => 500),
renderer_getSprites: vi.fn(() => 25),
renderer_getText: vi.fn(() => 5),
- renderer_getSpine: vi.fn(() => 3),
+ renderer_getSkeletal: vi.fn(() => 3),
renderer_getMeshes: vi.fn(() => 8),
renderer_getCulled: vi.fn(() => 12),
@@ -127,7 +127,7 @@ describe('Renderer API', () => {
triangles: 0,
sprites: 0,
text: 0,
- spine: 0,
+ skeletal: 0,
meshes: 0,
culled: 0,
});
@@ -372,7 +372,7 @@ describe('Renderer API', () => {
triangles: 500,
sprites: 25,
text: 5,
- spine: 3,
+ skeletal: 3,
meshes: 8,
culled: 12,
});
@@ -384,7 +384,7 @@ describe('Renderer API', () => {
expect(mock.renderer_getTriangles).toHaveBeenCalledOnce();
expect(mock.renderer_getSprites).toHaveBeenCalledOnce();
expect(mock.renderer_getText).toHaveBeenCalledOnce();
- expect(mock.renderer_getSpine).toHaveBeenCalledOnce();
+ expect(mock.renderer_getSkeletal).toHaveBeenCalledOnce();
expect(mock.renderer_getMeshes).toHaveBeenCalledOnce();
expect(mock.renderer_getCulled).toHaveBeenCalledOnce();
});
diff --git a/sdk/tests/skeletal-submit.test.ts b/sdk/tests/skeletal-submit.test.ts
new file mode 100644
index 000000000..1904a4287
--- /dev/null
+++ b/sdk/tests/skeletal-submit.test.ts
@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file skeletal-submit.test.ts
+ * @brief What reaches the engine when a skeletal runtime hands over a pose.
+ *
+ * One door serves Spine and DragonBones alike, so a field dropped on
+ * the way through is dropped for both. The material is the one that has
+ * to be read per entity and per frame — a skeleton is not asked which
+ * material it was posed with, its entity is.
+ */
+import { describe, it, expect, vi } from 'vitest';
+import { submitEntityMeshes, type SkeletalSubmitCore } from '../src/skeletal/submitMeshes';
+import type { Entity } from '../src/types';
+
+const PROPS = { skeletonScale: 1, flipX: false, flipY: false, layer: 0 };
+
+/** A core that records every submit, with a heap big enough for the copies. */
+function mockCore() {
+ const submits: number[][] = [];
+ let next = 64;
+ const core: SkeletalSubmitCore = {
+ renderer_submitSkeletalBatchByEntity: vi.fn((..._args: unknown[]) => {
+ submits.push(_args.slice(1) as number[]);
+ }) as unknown as SkeletalSubmitCore['renderer_submitSkeletalBatchByEntity'],
+ _malloc: (size: number) => { const p = next; next += size; return p; },
+ _free: () => {},
+ HEAPU8: new Uint8Array(4096),
+ };
+ return { core, submits };
+}
+
+/** One batch of two vertices, in the 8-float layout the engine reads. */
+const oneBatch = (cb: (v: Uint8Array, i: Uint8Array, vc: number, ic: number, tex: number, blend: number) => void) => {
+ cb(new Uint8Array(new Float32Array(16).buffer), new Uint8Array(new Uint16Array([0, 1, 2]).buffer), 2, 3, 7, 1);
+};
+
+describe('handing a posed skeleton to the engine', () => {
+ it('submits no material when the caller names none', () => {
+ const { core, submits } = mockCore();
+ expect(submitEntityMeshes(core, {}, 5 as Entity, PROPS, oneBatch)).toBe(true);
+ expect(submits).toHaveLength(1);
+ expect(submits[0]!.at(-1)).toBe(0);
+ });
+
+ it('carries the entity\'s material through to the batch', () => {
+ const { core, submits } = mockCore();
+ submitEntityMeshes(core, {}, 5 as Entity, PROPS, oneBatch, () => 42);
+ expect(submits[0]!.at(-1)).toBe(42);
+ });
+
+ it('asks for the material of the entity being submitted', () => {
+ const { core } = mockCore();
+ const materialOf = vi.fn(() => 9);
+ submitEntityMeshes(core, {}, 11 as Entity, PROPS, oneBatch, materialOf);
+ expect(materialOf).toHaveBeenCalledWith(11);
+ });
+
+ it('reports a core that cannot take geometry, so the caller stops asking', () => {
+ const { core } = mockCore();
+ const noSubmit = { ...core, renderer_submitSkeletalBatchByEntity: undefined };
+ expect(submitEntityMeshes(noSubmit, {}, 5 as Entity, PROPS, oneBatch)).toBe(false);
+ });
+});
diff --git a/sdk/tests/stats.test.ts b/sdk/tests/stats.test.ts
index 1c08da16c..4b8236a45 100644
--- a/sdk/tests/stats.test.ts
+++ b/sdk/tests/stats.test.ts
@@ -149,7 +149,7 @@ describe('defaultFrameStats', () => {
expect(stats.triangles).toBe(0);
expect(stats.sprites).toBe(0);
expect(stats.text).toBe(0);
- expect(stats.spine).toBe(0);
+ expect(stats.skeletal).toBe(0);
expect(stats.meshes).toBe(0);
expect(stats.culled).toBe(0);
});
@@ -579,7 +579,7 @@ await app.tick(1 / 60);
it('should copy all render stats fields', async () => {
const mockStats: rendererModule.RenderStats = {
drawCalls: 42, triangles: 8400, sprites: 100,
- text: 12, spine: 3, meshes: 5, culled: 7,
+ text: 12, skeletal: 3, meshes: 5, culled: 7,
};
vi.spyOn(rendererModule.Renderer, 'getStats').mockReturnValue(mockStats);
@@ -592,7 +592,7 @@ await app.tick(1 / 60);
expect(stats.triangles).toBe(8400);
expect(stats.sprites).toBe(100);
expect(stats.text).toBe(12);
- expect(stats.spine).toBe(3);
+ expect(stats.skeletal).toBe(3);
expect(stats.meshes).toBe(5);
expect(stats.culled).toBe(7);
});
@@ -600,11 +600,11 @@ await app.tick(1 / 60);
it('should update render stats each tick', async () => {
const tick1: rendererModule.RenderStats = {
drawCalls: 10, triangles: 2000, sprites: 50,
- text: 5, spine: 1, meshes: 2, culled: 3,
+ text: 5, skeletal: 1, meshes: 2, culled: 3,
};
const tick2: rendererModule.RenderStats = {
drawCalls: 20, triangles: 4000, sprites: 80,
- text: 8, spine: 2, meshes: 4, culled: 6,
+ text: 8, skeletal: 2, meshes: 4, culled: 6,
};
const spy = vi.spyOn(rendererModule.Renderer, 'getStats');
@@ -626,7 +626,7 @@ await app.tick(1 / 60);
expect(stats.triangles).toBe(4000);
expect(stats.sprites).toBe(80);
expect(stats.text).toBe(8);
- expect(stats.spine).toBe(2);
+ expect(stats.skeletal).toBe(2);
expect(stats.meshes).toBe(4);
expect(stats.culled).toBe(6);
});
@@ -641,7 +641,7 @@ await app.tick(1 / 60);
expect(stats.triangles).toBe(0);
expect(stats.sprites).toBe(0);
expect(stats.text).toBe(0);
- expect(stats.spine).toBe(0);
+ expect(stats.skeletal).toBe(0);
expect(stats.meshes).toBe(0);
expect(stats.culled).toBe(0);
});
@@ -698,7 +698,7 @@ describe('StatsOverlay', () => {
systemTimings: new Map(),
phaseTimings: new Map(),
drawCalls: 0, triangles: 0, sprites: 0,
- text: 0, spine: 0, meshes: 0, culled: 0,
+ text: 0, skeletal: 0, meshes: 0, culled: 0,
...overrides,
};
}
diff --git a/src/esengine/bindings/RendererBindings.cpp b/src/esengine/bindings/RendererBindings.cpp
index 0c984efcf..5dee24535 100644
--- a/src/esengine/bindings/RendererBindings.cpp
+++ b/src/esengine/bindings/RendererBindings.cpp
@@ -76,36 +76,16 @@ static u32 checkGLErrors(const char* context) {
return errorCount;
}
-// Spine renders fully through the side modules now: the SDK SpineManager
-// computes meshes in spine{NN}.wasm and submits each batch here. The old native
-// spine_* accessors (driven by a core spine-cpp runtime) are gone.
-#ifdef ES_ENABLE_SPINE
-void renderer_submitSpineBatch(
- uintptr_t verticesPtr, i32 vertexCount,
- uintptr_t indicesPtr, i32 indexCount,
- u32 textureId, i32 blendMode,
- uintptr_t transformPtr,
- u32 entity, i32 layer, f32 depth
-) {
- if (!g_initialized || !g_renderFrame) return;
- if (vertexCount < 0 || indexCount < 0) return;
- // Spine vertex format is x,y,u,v,r,g,b,a (8 floats per vertex).
- auto* vertices = boundarySpan<f32>(verticesPtr, static_cast<u64>(vertexCount) * 8, "renderer_submitSpineBatch.vertices");
- auto* indices = boundarySpan<u16>(indicesPtr, static_cast<u64>(indexCount), "renderer_submitSpineBatch.indices");
- auto* transform = boundarySpan<f32>(transformPtr, 16, "renderer_submitSpineBatch.transform");
- if (!vertices || !indices || !transform) return;
- g_renderFrame->submitSpineBatch(
- vertices, vertexCount, indices, indexCount,
- textureId, blendMode, transform, Entity::fromRaw(entity), layer, depth);
-}
-
+// Geometry posed by a skeletal runtime — Spine and DragonBones both come through
+// here. Ungated on purpose: the core links neither, so neither runtime's build
+// option may decide whether this door exists.
void renderer_submitSkeletalBatchByEntity(
ecs::Registry& registry,
uintptr_t verticesPtr, i32 vertexCount,
uintptr_t indicesPtr, i32 indexCount,
u32 textureId, i32 blendMode,
u32 entity, f32 skelScale, bool flipX, bool flipY,
- i32 layer, f32 depth
+ i32 layer, f32 depth, u32 materialId
) {
if (!g_initialized || !g_renderFrame) return;
const Entity ent = Entity::fromRaw(entity);
@@ -125,16 +105,15 @@ void renderer_submitSkeletalBatchByEntity(
* glm::scale(glm::mat4(1.0f), s);
if (vertexCount < 0 || indexCount < 0) return;
+ // Skeletal vertex format is x,y,u,v,r,g,b,a (8 floats per vertex).
auto* vertices = boundarySpan<f32>(verticesPtr, static_cast<u64>(vertexCount) * 8, "renderer_submitSkeletalBatchByEntity.vertices");
auto* indices = boundarySpan<u16>(indicesPtr, static_cast<u64>(indexCount), "renderer_submitSkeletalBatchByEntity.indices");
if (!vertices || !indices) return;
- g_renderFrame->submitSpineBatch(
+ g_renderFrame->submitSkeletalBatch(
vertices, vertexCount, indices, indexCount,
- textureId, blendMode, &model[0][0], ent, layer, depth);
+ textureId, blendMode, &model[0][0], ent, layer, depth, materialId);
}
-#endif
-
// TS lays out glyph quads against the dynamic SDF atlas and
// submits them here (ungated — text is core, unlike spine).
void renderer_submitTextBatch(
@@ -544,11 +523,6 @@ void renderer_submitShapes(ecs::Registry& registry) {
(void)registry;
}
-#ifdef ES_ENABLE_SPINE
-void renderer_submitSpine(ecs::Registry& registry) {
- (void)registry;
-}
-#endif
#ifdef ES_ENABLE_PARTICLES
void renderer_submitParticles(ecs::Registry& registry) {
@@ -738,12 +712,10 @@ u32 renderer_getSprites() {
return g_renderFrame->stats().sprites;
}
-#ifdef ES_ENABLE_SPINE
-u32 renderer_getSpine() {
+u32 renderer_getSkeletal() {
if (!g_renderFrame) return 0;
- return g_renderFrame->stats().spine;
+ return g_renderFrame->stats().skeletal;
}
-#endif
u32 renderer_getText() {
if (!g_renderFrame) return 0;
diff --git a/src/esengine/bindings/RendererBindings.hpp b/src/esengine/bindings/RendererBindings.hpp
index 37a79301b..95337f380 100644
--- a/src/esengine/bindings/RendererBindings.hpp
+++ b/src/esengine/bindings/RendererBindings.hpp
@@ -38,24 +38,16 @@ void renderer_submitUIElements(ecs::Registry& registry);
void renderer_submitBitmapText(ecs::Registry& registry);
#endif
void renderer_submitShapes(ecs::Registry& registry);
-#ifdef ES_ENABLE_SPINE
-void renderer_submitSpine(ecs::Registry& registry);
-void renderer_submitSpineBatch(
- uintptr_t verticesPtr, i32 vertexCount,
- uintptr_t indicesPtr, i32 indexCount,
- u32 textureId, i32 blendMode,
- uintptr_t transformPtr,
- u32 entity, i32 layer, f32 depth
-);
+/// Geometry posed by a skeletal runtime (Spine, DragonBones): x,y,u,v,r,g,b,a per
+/// vertex, drawn as @p entity's, with its material resolved as a Sprite's is.
void renderer_submitSkeletalBatchByEntity(
ecs::Registry& registry,
uintptr_t verticesPtr, i32 vertexCount,
uintptr_t indicesPtr, i32 indexCount,
u32 textureId, i32 blendMode,
u32 entity, f32 skelScale, bool flipX, bool flipY,
- i32 layer, f32 depth
+ i32 layer, f32 depth, u32 materialId
);
-#endif
void renderer_submitTextBatch(
uintptr_t verticesPtr, i32 vertexCount,
uintptr_t indicesPtr, i32 indexCount,
@@ -130,9 +122,7 @@ emscripten::val meshRenderer_localBounds(ecs::Registry& registry, u32 entity);
#endif
u32 renderer_getTriangles();
u32 renderer_getSprites();
-#ifdef ES_ENABLE_SPINE
-u32 renderer_getSpine();
-#endif
+u32 renderer_getSkeletal();
u32 renderer_getText();
u32 renderer_getMeshes();
u32 renderer_getCulled();
diff --git a/src/esengine/bindings/WebSDKEntry.cpp b/src/esengine/bindings/WebSDKEntry.cpp
index 0ffd96ae4..5c9a8a545 100644
--- a/src/esengine/bindings/WebSDKEntry.cpp
+++ b/src/esengine/bindings/WebSDKEntry.cpp
@@ -514,12 +514,9 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
#endif
;
-#ifdef ES_ENABLE_SPINE
- // Spine renders via the side modules — only the mesh-submit bindings the
- // SDK SpineManager calls remain. Native spine_* / spine_native_* are gone.
- emscripten::function("renderer_submitSpineBatch", &esengine::renderer_submitSpineBatch);
+ // Every skeletal runtime is a side module; this is the one door their posed
+ // geometry comes through, so it belongs to neither of their build flags.
emscripten::function("renderer_submitSkeletalBatchByEntity", &esengine::renderer_submitSkeletalBatchByEntity);
-#endif
emscripten::function("renderer_submitTextBatch", &esengine::renderer_submitTextBatch);
emscripten::function("meshRenderer_setGeometry", &esengine::meshRenderer_setGeometry);
emscripten::function("mesh_create", &esengine::mesh_create);
@@ -644,9 +641,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
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
@@ -673,9 +668,7 @@ EMSCRIPTEN_BINDINGS(esengine_renderer) {
emscripten::function("renderer_getLiveObjects", &esengine::renderer_getLiveObjects);
emscripten::function("renderer_getTriangles", &esengine::renderer_getTriangles);
emscripten::function("renderer_getSprites", &esengine::renderer_getSprites);
-#ifdef ES_ENABLE_SPINE
- emscripten::function("renderer_getSpine", &esengine::renderer_getSpine);
-#endif
+ emscripten::function("renderer_getSkeletal", &esengine::renderer_getSkeletal);
emscripten::function("renderer_getText", &esengine::renderer_getText);
emscripten::function("renderer_getMeshes", &esengine::renderer_getMeshes);
emscripten::function("renderer_getCulled", &esengine::renderer_getCulled);
diff --git a/src/esengine/renderer/draw/RenderItem.hpp b/src/esengine/renderer/draw/RenderItem.hpp
index 1ae58b1d9..7a3cc5a14 100644
--- a/src/esengine/renderer/draw/RenderItem.hpp
+++ b/src/esengine/renderer/draw/RenderItem.hpp
@@ -16,9 +16,9 @@ struct ScissorRect {
enum class RenderType : u8 {
Sprite = 0,
-#ifdef ES_ENABLE_SPINE
- Spine = 1,
-#endif
+ /// Posed geometry from a skeletal runtime — Spine or DragonBones. Neither is
+ /// linked here: both are side modules that hand over batch vertices.
+ Skeletal = 1,
Mesh = 2,
ExternalMesh = 3,
Text = 4,
diff --git a/src/esengine/renderer/frame/RenderFrame.cpp b/src/esengine/renderer/frame/RenderFrame.cpp
index dbbb7c45f..431b687a2 100644
--- a/src/esengine/renderer/frame/RenderFrame.cpp
+++ b/src/esengine/renderer/frame/RenderFrame.cpp
@@ -392,9 +392,7 @@ void RenderFrame::flush() {
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;
-#endif
+ case RenderType::Skeletal: stats_.skeletal += cmd.entity_count; break;
default: break;
}
}
diff --git a/src/esengine/renderer/frame/RenderFrame.hpp b/src/esengine/renderer/frame/RenderFrame.hpp
index bbdf714f7..0c867c2b0 100644
--- a/src/esengine/renderer/frame/RenderFrame.hpp
+++ b/src/esengine/renderer/frame/RenderFrame.hpp
@@ -88,9 +88,7 @@ public:
u32 draw_calls = 0;
u32 triangles = 0;
u32 sprites = 0;
-#ifdef ES_ENABLE_SPINE
- u32 spine = 0;
-#endif
+ u32 skeletal = 0;
u32 meshes = 0;
u32 text = 0;
u32 particles = 0;
@@ -173,15 +171,19 @@ public:
Entity entity, i32 layer, f32 depth, bool sdf, u32 cullBit = 0
);
-#ifdef ES_ENABLE_SPINE
- void submitSpineBatch(
+ /**
+ * @brief Batch vertices posed by a skeletal runtime, drawn as one entity's geometry.
+ * @details Serves every such runtime — Spine and DragonBones both arrive here — and
+ * links none of them: what crosses is x,y,u,v,r,g,b,a per vertex. @p materialId
+ * is the entity's material, resolved the way a Sprite's is (0 = the batch shader).
+ */
+ void submitSkeletalBatch(
const f32* vertices, i32 vertexCount,
const u16* indices, i32 indexCount,
u32 textureId, i32 blendMode,
const f32* transform16,
- Entity entity, i32 layer, f32 depth
+ Entity entity, i32 layer, f32 depth, u32 materialId = 0
);
-#endif
void setStage(RenderStage stage) { current_stage_ = stage; }
RenderStage getStage() const { return current_stage_; }
diff --git a/src/esengine/renderer/frame/RenderFrameSubmit.cpp b/src/esengine/renderer/frame/RenderFrameSubmit.cpp
index f0a268955..c1283ce75 100644
--- a/src/esengine/renderer/frame/RenderFrameSubmit.cpp
+++ b/src/esengine/renderer/frame/RenderFrameSubmit.cpp
@@ -3,6 +3,7 @@
#include "./RenderFrame.hpp"
#include "../draw/BatchBuilder.hpp"
#include "../draw/BatchVertex.hpp"
+#include "./RenderContext.hpp"
#include <glm/gtc/type_ptr.hpp>
@@ -79,13 +80,12 @@ void RenderFrame::submitTextBatch(
});
}
-#ifdef ES_ENABLE_SPINE
-void RenderFrame::submitSpineBatch(
+void RenderFrame::submitSkeletalBatch(
const f32* vertices, i32 vertexCount,
const u16* indices, i32 indexCount,
u32 textureId, i32 blendMode,
const f32* transform16,
- Entity entity, i32 layer, f32 depth
+ Entity entity, i32 layer, f32 depth, u32 materialId
) {
if (vertexCount <= 0 || indexCount <= 0) return;
@@ -106,8 +106,7 @@ void RenderFrame::submitSpineBatch(
dst[i] = { {worldPos.x, worldPos.y, worldPos.z}, pc, {v[2], v[3]} };
}
- pushBatchCommand(pool_, draw_list_, clip_state_, vOff, static_cast<u32>(vertexCount), indices,
- static_cast<u32>(indexCount), BatchDrawKey{
+ BatchDrawKey key{
.stage = current_stage_,
.layer = layer,
.shaderId = batch_shader_id_,
@@ -115,9 +114,24 @@ void RenderFrame::submitSpineBatch(
.textureId = textureId,
.depth = depth,
.entity = entity,
- .type = RenderType::Spine,
- });
+ .type = RenderType::Skeletal,
+ };
+ // The same resolution a Sprite gets: a material owns shading fully, and a
+ // handle nothing registered falls back to the batch shader rather than
+ // binding a program that was never built.
+ if (materialId != 0) {
+ if (const MaterialRecord* m = context_.materials().find(materialId)) {
+ key.shaderId = (m->shader != 0) ? m->shader : batch_shader_id_;
+ key.blend = m->blend;
+ key.materialId = materialId;
+ key.depthTest = m->depthTest;
+ key.depthWrite = m->depthWrite;
+ key.cull = static_cast<u8>(m->cull);
+ }
+ }
+
+ pushBatchCommand(pool_, draw_list_, clip_state_, vOff, static_cast<u32>(vertexCount), indices,
+ static_cast<u32>(indexCount), key);
}
-#endif
} // namespace esengine
diff --git a/tools/check-component-fields.mjs b/tools/check-component-fields.mjs
index f95d3c92f..997672407 100644
--- a/tools/check-component-fields.mjs
+++ b/tools/check-component-fields.mjs
@@ -35,11 +35,10 @@ const DECLARED_GAPS = {
'CacheAsBitmap.dirty': 'see CacheAsBitmap.enabled',
'CacheAsBitmap.width': 'see CacheAsBitmap.enabled',
'CacheAsBitmap.height': 'see CacheAsBitmap.enabled',
- 'ParticleEmitter.material': 'only the mesh path resolves a material into a program'
- + ' (MaterialStore::meshProgram); particles, spine and dragonbones draw with their'
- + ' own built-in shader and never consult the table',
- 'SpineAnimation.material': 'see ParticleEmitter.material',
- 'DragonBonesAnimation.material': 'see ParticleEmitter.material',
+ 'ParticleEmitter.material': 'a particle is drawn from an instanced vertex source,'
+ + ' and a material is compiled per vertex source (MaterialStore::meshProgram takes'
+ + ' the mesh ones) — nothing compiles the instanced variant, so the table has no'
+ + ' program to hand back',
};
const components = JSON.parse(
diff --git a/tools/check-sidemodule-gates.mjs b/tools/check-sidemodule-gates.mjs
new file mode 100644
index 000000000..789d3a15e
--- /dev/null
+++ b/tools/check-sidemodule-gates.mjs
@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file check-sidemodule-gates.mjs
+ * @brief A side module's build option must not decide how the core compiles.
+ * @details The core links none of these runtimes, so a door one of them opens is
+ * one every other runtime of its kind comes through.
+ *
+ * Run: node tools/check-sidemodule-gates.mjs (exit 1 on violation)
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+
+const ROOT = 'src/esengine';
+
+/** Options that select which side modules to build — never how the core compiles. */
+const SIDE_MODULE_FLAGS = [
+ 'ES_ENABLE_SPINE',
+ 'ES_ENABLE_DRAGONBONES',
+ 'ES_ENABLE_BOX2D',
+ 'ES_ENABLE_JOLT',
+ 'ES_ENABLE_BASIS',
+];
+
+// A module's own translation units compile only when its option is on, so they
+// have nothing to ask — but they are its code, not the core's, and are skipped
+// rather than judged.
+const MODULE_SOURCES = 'src/esengine/bindings/modules/';
+
+const SOURCE_EXT = /\.(cpp|cc|cxx|hpp|hxx|h)$/;
+
+function walk(dir, out = []) {
+ for (const entry of readdirSync(dir)) {
+ const p = join(dir, entry);
+ if (statSync(p).isDirectory()) walk(p, out);
+ else if (SOURCE_EXT.test(entry)) out.push(p);
+ }
+ return out;
+}
+
+const pattern = new RegExp(`\\b(${SIDE_MODULE_FLAGS.join('|')})\\b`);
+const violations = [];
+for (const file of walk(ROOT)) {
+ const rel = file.replace(/\\/g, '/');
+ if (rel.startsWith(MODULE_SOURCES)) continue;
+ readFileSync(file, 'utf8').split('\n').forEach((line, i) => {
+ if (pattern.test(line)) violations.push(` ${rel}:${i + 1}: ${line.trim()}`);
+ });
+}
+
+if (violations.length > 0) {
+ console.error('A side module\'s build option is deciding how the core compiles:\n');
+ console.error(violations.join('\n'));
+ console.error('\nThe core links none of these runtimes. What they hand it — geometry,'
+ + ' a physics world, a transcoded texture — arrives through a door that is'
+ + ' always there, so every runtime of that kind can come through it.');
+ process.exit(1);
+}
+
+console.log(`check-sidemodule-gates: the core compiles one way; ${SIDE_MODULE_FLAGS.length}`
+ + ' side-module option(s) decide only what is built beside it.');
diff --git a/tools/gates.mjs b/tools/gates.mjs
index 179100bc1..6805ef562 100644
--- a/tools/gates.mjs
+++ b/tools/gates.mjs
@@ -31,6 +31,7 @@ export const GATES = [
{ id: 'tsc-sdk', run: 'pnpm --filter ./sdk exec tsc --noEmit' },
{ id: 'gl-boundary', run: 'node tools/check-gl-boundary.mjs' },
{ id: 'draw-command-boundary', run: 'node tools/check-draw-command-boundary.mjs' },
+ { id: 'sidemodule-gates', run: 'node tools/check-sidemodule-gates.mjs' },
{
id: 'native-bindings',
run: 'node tools/check-native-bindings.mjs',