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.

test: add TDD tests for rendering pipeline core modules

esenginec0076d5281bd
diff --git a/sdk/tests/draw.test.ts b/sdk/tests/draw.test.ts
new file mode 100644
index 000000000..5a8bc2b13
--- /dev/null
+++ b/sdk/tests/draw.test.ts
@@ -0,0 +1,736 @@
+vi.mock('../src/material', () => {
+ const materials = new Map();
+ return {
+ Material: {
+ get: vi.fn((id: number) => materials.get(id)),
+ _materials: materials,
+ },
+ isTextureRef: vi.fn(
+ (v: any) => typeof v === 'object' && v !== null && '__textureRef' in v,
+ ),
+ };
+});
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { Draw, initDrawAPI, shutdownDrawAPI, BlendMode } from '../src/draw';
+import { Material, isTextureRef } from '../src/material';
+import type { ESEngineModule } from '../src/wasm';
+
+// =============================================================================
+// Mock WASM module for Draw API
+// =============================================================================
+
+function createDrawMockModule() {
+ let nextAddr = 256;
+ const heapBuffer = new ArrayBuffer(1024 * 1024);
+
+ const mock = {
+ _malloc: vi.fn((size: number) => {
+ const addr = nextAddr;
+ nextAddr += size;
+ return addr;
+ }),
+ _free: vi.fn(),
+ HEAPF32: new Float32Array(heapBuffer),
+
+ draw_begin: vi.fn(),
+ draw_end: vi.fn(),
+ draw_line: vi.fn(),
+ draw_rect: vi.fn(),
+ draw_rectOutline: vi.fn(),
+ draw_circle: vi.fn(),
+ draw_circleOutline: vi.fn(),
+ draw_texture: vi.fn(),
+ draw_textureRotated: vi.fn(),
+ draw_setLayer: vi.fn(),
+ draw_setDepth: vi.fn(),
+ draw_setBlendMode: vi.fn(),
+ draw_setDepthTest: vi.fn(),
+ draw_getDrawCallCount: vi.fn(() => 42),
+ draw_getPrimitiveCount: vi.fn(() => 128),
+ draw_mesh: vi.fn(),
+ draw_meshWithUniforms: vi.fn(),
+ };
+
+ return mock;
+}
+
+type MockModule = ReturnType<typeof createDrawMockModule>;
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('Draw API', () => {
+ let mock: MockModule;
+
+ beforeEach(() => {
+ mock = createDrawMockModule();
+ initDrawAPI(mock as unknown as ESEngineModule);
+ });
+
+ afterEach(() => {
+ shutdownDrawAPI();
+ (Material as any)._materials.clear();
+ });
+
+ // =========================================================================
+ // initDrawAPI / shutdownDrawAPI
+ // =========================================================================
+
+ describe('initDrawAPI', () => {
+ it('should allocate viewProjection, transform, and uniforms buffers', () => {
+ expect(mock._malloc).toHaveBeenCalledTimes(3);
+ expect(mock._malloc).toHaveBeenNthCalledWith(1, 16 * 4);
+ expect(mock._malloc).toHaveBeenNthCalledWith(2, 16 * 4);
+ expect(mock._malloc).toHaveBeenNthCalledWith(3, 256 * 4);
+ });
+ });
+
+ describe('shutdownDrawAPI', () => {
+ it('should free all allocated buffers', () => {
+ shutdownDrawAPI();
+ expect(mock._free).toHaveBeenCalledTimes(3);
+ });
+
+ it('should handle double shutdown gracefully', () => {
+ shutdownDrawAPI();
+ shutdownDrawAPI();
+ expect(mock._free).toHaveBeenCalledTimes(3);
+ });
+ });
+
+ // =========================================================================
+ // Uninitialized guard
+ // =========================================================================
+
+ describe('uninitialized guard', () => {
+ it('should throw when Draw.begin called after shutdown', () => {
+ shutdownDrawAPI();
+ expect(() => Draw.begin(new Float32Array(16))).toThrow(
+ 'Draw API not initialized',
+ );
+ });
+
+ it('should return 0 for getDrawCallCount when uninitialized', () => {
+ shutdownDrawAPI();
+ expect(Draw.getDrawCallCount()).toBe(0);
+ });
+
+ it('should return 0 for getPrimitiveCount when uninitialized', () => {
+ shutdownDrawAPI();
+ expect(Draw.getPrimitiveCount()).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // Draw.begin / Draw.end
+ // =========================================================================
+
+ describe('Draw.begin', () => {
+ it('should copy viewProjection to HEAPF32 and call draw_begin', () => {
+ const vp = new Float32Array(16);
+ for (let i = 0; i < 16; i++) vp[i] = i + 1;
+
+ Draw.begin(vp);
+
+ const vpPtr = mock._malloc.mock.results[0].value;
+ const offset = vpPtr / 4;
+ for (let i = 0; i < 16; i++) {
+ expect(mock.HEAPF32[offset + i]).toBe(i + 1);
+ }
+ expect(mock.draw_begin).toHaveBeenCalledWith(vpPtr);
+ });
+ });
+
+ describe('Draw.end', () => {
+ it('should call draw_end', () => {
+ Draw.end();
+ expect(mock.draw_end).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // Draw.line
+ // =========================================================================
+
+ describe('Draw.line', () => {
+ it('should pass all parameters to draw_line', () => {
+ const from = { x: 1, y: 2 };
+ const to = { x: 3, y: 4 };
+ const color = { r: 0.1, g: 0.2, b: 0.3, a: 0.4 };
+
+ Draw.line(from, to, color, 2.5);
+
+ expect(mock.draw_line).toHaveBeenCalledWith(
+ 1, 2, 3, 4, 0.1, 0.2, 0.3, 0.4, 2.5,
+ );
+ });
+
+ it('should default thickness to 1', () => {
+ Draw.line({ x: 0, y: 0 }, { x: 1, y: 1 }, { r: 1, g: 1, b: 1, a: 1 });
+
+ expect(mock.draw_line).toHaveBeenCalledWith(
+ 0, 0, 1, 1, 1, 1, 1, 1, 1,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.rect
+ // =========================================================================
+
+ describe('Draw.rect', () => {
+ it('should pass all parameters to draw_rect', () => {
+ const pos = { x: 10, y: 20 };
+ const size = { x: 100, y: 200 };
+ const color = { r: 1, g: 0, b: 0, a: 1 };
+
+ Draw.rect(pos, size, color, false);
+
+ expect(mock.draw_rect).toHaveBeenCalledWith(
+ 10, 20, 100, 200, 1, 0, 0, 1, false,
+ );
+ });
+
+ it('should default filled to true', () => {
+ Draw.rect({ x: 0, y: 0 }, { x: 1, y: 1 }, { r: 1, g: 1, b: 1, a: 1 });
+
+ expect(mock.draw_rect).toHaveBeenCalledWith(
+ 0, 0, 1, 1, 1, 1, 1, 1, true,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.rectOutline
+ // =========================================================================
+
+ describe('Draw.rectOutline', () => {
+ it('should pass all parameters to draw_rectOutline', () => {
+ Draw.rectOutline(
+ { x: 5, y: 10 },
+ { x: 50, y: 60 },
+ { r: 0, g: 1, b: 0, a: 0.5 },
+ 3,
+ );
+
+ expect(mock.draw_rectOutline).toHaveBeenCalledWith(
+ 5, 10, 50, 60, 0, 1, 0, 0.5, 3,
+ );
+ });
+
+ it('should default thickness to 1', () => {
+ Draw.rectOutline(
+ { x: 0, y: 0 },
+ { x: 1, y: 1 },
+ { r: 1, g: 1, b: 1, a: 1 },
+ );
+
+ expect(mock.draw_rectOutline).toHaveBeenCalledWith(
+ 0, 0, 1, 1, 1, 1, 1, 1, 1,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.circle
+ // =========================================================================
+
+ describe('Draw.circle', () => {
+ it('should pass all parameters to draw_circle', () => {
+ Draw.circle(
+ { x: 50, y: 50 },
+ 25,
+ { r: 0, g: 0, b: 1, a: 1 },
+ false,
+ 16,
+ );
+
+ expect(mock.draw_circle).toHaveBeenCalledWith(
+ 50, 50, 25, 0, 0, 1, 1, false, 16,
+ );
+ });
+
+ it('should default filled to true and segments to 32', () => {
+ Draw.circle({ x: 0, y: 0 }, 10, { r: 1, g: 1, b: 1, a: 1 });
+
+ expect(mock.draw_circle).toHaveBeenCalledWith(
+ 0, 0, 10, 1, 1, 1, 1, true, 32,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.circleOutline
+ // =========================================================================
+
+ describe('Draw.circleOutline', () => {
+ it('should pass all parameters to draw_circleOutline', () => {
+ Draw.circleOutline(
+ { x: 30, y: 40 },
+ 15,
+ { r: 1, g: 1, b: 0, a: 1 },
+ 2,
+ 24,
+ );
+
+ expect(mock.draw_circleOutline).toHaveBeenCalledWith(
+ 30, 40, 15, 1, 1, 0, 1, 2, 24,
+ );
+ });
+
+ it('should default thickness to 1 and segments to 32', () => {
+ Draw.circleOutline({ x: 0, y: 0 }, 5, { r: 1, g: 1, b: 1, a: 1 });
+
+ expect(mock.draw_circleOutline).toHaveBeenCalledWith(
+ 0, 0, 5, 1, 1, 1, 1, 1, 32,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.texture
+ // =========================================================================
+
+ describe('Draw.texture', () => {
+ it('should pass all parameters to draw_texture', () => {
+ Draw.texture(
+ { x: 100, y: 200 },
+ { x: 64, y: 64 },
+ 7,
+ { r: 0.5, g: 0.5, b: 0.5, a: 0.8 },
+ );
+
+ expect(mock.draw_texture).toHaveBeenCalledWith(
+ 100, 200, 64, 64, 7, 0.5, 0.5, 0.5, 0.8,
+ );
+ });
+
+ it('should default tint to white', () => {
+ Draw.texture({ x: 0, y: 0 }, { x: 32, y: 32 }, 5);
+
+ expect(mock.draw_texture).toHaveBeenCalledWith(
+ 0, 0, 32, 32, 5, 1, 1, 1, 1,
+ );
+ });
+ });
+
+ // =========================================================================
+ // Draw.textureRotated
+ // =========================================================================
+
+ describe('Draw.textureRotated', () => {
+ it('should pass all parameters to draw_textureRotated', () => {
+ Draw.textureRotated(
+ { x: 50, y: 60 },
+ { x: 128, y: 128 },
+ Math.PI / 4,
+ 9,
+ { r: 0.9, g: 0.8, b: 0.7, a: 0.6 },
+ );
+
+ expect(mock.draw_textureRotated).toHaveBeenCalledWith(
+ 50, 60, 128, 128, Math.PI / 4, 9, 0.9, 0.8, 0.7, 0.6,
+ );
+ });
+
+ it('should default tint to white', () => {
+ Draw.textureRotated({ x: 0, y: 0 }, { x: 16, y: 16 }, 1.0, 3);
+
+ expect(mock.draw_textureRotated).toHaveBeenCalledWith(
+ 0, 0, 16, 16, 1.0, 3, 1, 1, 1, 1,
+ );
+ });
+ });
+
+ // =========================================================================
+ // State management
+ // =========================================================================
+
+ describe('state management', () => {
+ it('setLayer should call draw_setLayer', () => {
+ Draw.setLayer(5);
+ expect(mock.draw_setLayer).toHaveBeenCalledWith(5);
+ });
+
+ it('setDepth should call draw_setDepth', () => {
+ Draw.setDepth(0.75);
+ expect(mock.draw_setDepth).toHaveBeenCalledWith(0.75);
+ });
+
+ it('setBlendMode should call draw_setBlendMode', () => {
+ Draw.setBlendMode(BlendMode.Additive);
+ expect(mock.draw_setBlendMode).toHaveBeenCalledWith(BlendMode.Additive);
+ });
+
+ it('setDepthTest should call draw_setDepthTest', () => {
+ Draw.setDepthTest(true);
+ expect(mock.draw_setDepthTest).toHaveBeenCalledWith(true);
+ });
+ });
+
+ // =========================================================================
+ // Statistics
+ // =========================================================================
+
+ describe('statistics', () => {
+ it('getDrawCallCount should return WASM value', () => {
+ expect(Draw.getDrawCallCount()).toBe(42);
+ });
+
+ it('getPrimitiveCount should return WASM value', () => {
+ expect(Draw.getPrimitiveCount()).toBe(128);
+ });
+
+ it('getDrawCallCount should return 0 when uninitialized', () => {
+ shutdownDrawAPI();
+ expect(Draw.getDrawCallCount()).toBe(0);
+ });
+
+ it('getPrimitiveCount should return 0 when uninitialized', () => {
+ shutdownDrawAPI();
+ expect(Draw.getPrimitiveCount()).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // Draw.drawMesh
+ // =========================================================================
+
+ describe('Draw.drawMesh', () => {
+ it('should copy transform to HEAPF32 and call draw_mesh', () => {
+ const transform = new Float32Array(16);
+ for (let i = 0; i < 16; i++) transform[i] = (i + 1) * 0.1;
+
+ const geometry = 1;
+ const shader = 2;
+
+ Draw.drawMesh(geometry as any, shader as any, transform);
+
+ const tPtr = mock._malloc.mock.results[1].value;
+ const offset = tPtr / 4;
+ for (let i = 0; i < 16; i++) {
+ expect(mock.HEAPF32[offset + i]).toBeCloseTo((i + 1) * 0.1);
+ }
+ expect(mock.draw_mesh).toHaveBeenCalledWith(geometry, shader, tPtr);
+ });
+ });
+
+ // =========================================================================
+ // Draw.drawMeshWithMaterial
+ // =========================================================================
+
+ describe('Draw.drawMeshWithMaterial', () => {
+ const transform = new Float32Array(16);
+ const geometry = 1 as any;
+
+ beforeEach(() => {
+ for (let i = 0; i < 16; i++) transform[i] = i;
+ });
+
+ it('should return early when material is invalid', () => {
+ Draw.drawMeshWithMaterial(geometry, 999 as any, transform);
+
+ expect(mock.draw_mesh).not.toHaveBeenCalled();
+ expect(mock.draw_meshWithUniforms).not.toHaveBeenCalled();
+ });
+
+ it('should call drawMesh when material has no uniforms', () => {
+ const materials = (Material as any)._materials;
+ materials.set(1, {
+ shader: 10,
+ uniforms: new Map(),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 1 as any, transform);
+
+ expect(mock.draw_setBlendMode).toHaveBeenCalledWith(BlendMode.Normal);
+ expect(mock.draw_setDepthTest).toHaveBeenCalledWith(false);
+ expect(mock.draw_mesh).toHaveBeenCalled();
+ expect(mock.draw_meshWithUniforms).not.toHaveBeenCalled();
+ });
+
+ it('should set blend mode and depth test from material', () => {
+ const materials = (Material as any)._materials;
+ materials.set(2, {
+ shader: 10,
+ uniforms: new Map(),
+ blendMode: BlendMode.Additive,
+ depthTest: true,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 2 as any, transform);
+
+ expect(mock.draw_setBlendMode).toHaveBeenCalledWith(BlendMode.Additive);
+ expect(mock.draw_setDepthTest).toHaveBeenCalledWith(true);
+ });
+
+ it('should encode number uniform (type 1)', () => {
+ const materials = (Material as any)._materials;
+ materials.set(3, {
+ shader: 10,
+ uniforms: new Map([['u_time', 1.5]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 3 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const args = mock.draw_meshWithUniforms.mock.calls[0];
+ expect(args[0]).toBe(geometry);
+ expect(args[1]).toBe(10);
+
+ const uniformsP = args[3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(1);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(0);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(1.5);
+ expect(args[4]).toBe(3);
+ });
+
+ it('should encode Vec2 uniform (type 2)', () => {
+ const materials = (Material as any)._materials;
+ materials.set(4, {
+ shader: 10,
+ uniforms: new Map([['u_offset', { x: 1.0, y: 2.0 }]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 4 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(2);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(4);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(1.0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(2.0);
+ });
+
+ it('should encode Vec3 uniform (type 3)', () => {
+ const materials = (Material as any)._materials;
+ materials.set(5, {
+ shader: 10,
+ uniforms: new Map([['u_vec0', { x: 1.0, y: 2.0, z: 3.0 }]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 5 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(3);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(10);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(1.0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(2.0);
+ expect(mock.HEAPF32[uOffset + 4]).toBe(3.0);
+ });
+
+ it('should encode Vec4 uniform (type 4)', () => {
+ const materials = (Material as any)._materials;
+ materials.set(6, {
+ shader: 10,
+ uniforms: new Map([['u_color', { x: 1.0, y: 2.0, z: 3.0, w: 4.0 }]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 6 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(4);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(1);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(1.0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(2.0);
+ expect(mock.HEAPF32[uOffset + 4]).toBe(3.0);
+ expect(mock.HEAPF32[uOffset + 5]).toBe(4.0);
+ });
+
+ it('should encode TextureRef uniform (type 10)', () => {
+ const materials = (Material as any)._materials;
+ materials.set(7, {
+ shader: 10,
+ uniforms: new Map([
+ ['u_texture0', { __textureRef: true, textureId: 42, slot: 0 }],
+ ]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 7 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(10);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(14);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(42);
+ });
+
+ it('should encode array uniform', () => {
+ const materials = (Material as any)._materials;
+ materials.set(8, {
+ shader: 10,
+ uniforms: new Map([['u_param0', [1.0, 2.0, 3.0]]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 8 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(3);
+ expect(mock.HEAPF32[uOffset + 1]).toBe(5);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(1.0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(2.0);
+ expect(mock.HEAPF32[uOffset + 4]).toBe(3.0);
+ });
+
+ it('should use cached buffer when not dirty', () => {
+ const materials = (Material as any)._materials;
+ const cachedBuf = new Float32Array([1, 0, 1.5]);
+ materials.set(9, {
+ shader: 10,
+ uniforms: new Map([['u_time', 1.5]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: false,
+ cachedBuffer_: cachedBuf,
+ cachedIdx_: 3,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 9 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const args = mock.draw_meshWithUniforms.mock.calls[0];
+ expect(args[4]).toBe(3);
+ });
+
+ it('should log warning for unknown uniform name', () => {
+ const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+ const materials = (Material as any)._materials;
+ materials.set(10, {
+ shader: 10,
+ uniforms: new Map([['u_unknown_xyz', 1.0]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 10 as any, transform);
+
+ expect(warnSpy).toHaveBeenCalledWith(
+ expect.stringContaining('Unknown uniform name "u_unknown_xyz"'),
+ );
+
+ warnSpy.mockRestore();
+ });
+
+ it('should skip unknown uniform and fall back to draw_mesh when no valid uniforms', () => {
+ vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+ const materials = (Material as any)._materials;
+ materials.set(11, {
+ shader: 10,
+ uniforms: new Map([['u_unknown_only', 1.0]]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 11 as any, transform);
+
+ expect(mock.draw_mesh).toHaveBeenCalled();
+ expect(mock.draw_meshWithUniforms).not.toHaveBeenCalled();
+
+ vi.restoreAllMocks();
+ });
+
+ it('should auto-assign texture slot when slot is undefined', () => {
+ const materials = (Material as any)._materials;
+ materials.set(12, {
+ shader: 10,
+ uniforms: new Map([
+ ['u_texture0', { __textureRef: true, textureId: 100 }],
+ ]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 12 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const uniformsP = mock.draw_meshWithUniforms.mock.calls[0][3];
+ const uOffset = uniformsP / 4;
+ expect(mock.HEAPF32[uOffset]).toBe(10);
+ expect(mock.HEAPF32[uOffset + 2]).toBe(0);
+ expect(mock.HEAPF32[uOffset + 3]).toBe(100);
+ });
+
+ it('should encode multiple uniforms of different types', () => {
+ const materials = (Material as any)._materials;
+ materials.set(13, {
+ shader: 10,
+ uniforms: new Map<string, any>([
+ ['u_time', 2.5],
+ ['u_offset', { x: 1.0, y: 2.0 }],
+ ]),
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ dirty_: true,
+ cachedBuffer_: null,
+ cachedIdx_: 0,
+ });
+
+ Draw.drawMeshWithMaterial(geometry, 13 as any, transform);
+
+ expect(mock.draw_meshWithUniforms).toHaveBeenCalled();
+ const args = mock.draw_meshWithUniforms.mock.calls[0];
+ expect(args[4]).toBe(7);
+ });
+ });
+});
diff --git a/sdk/tests/material.test.ts b/sdk/tests/material.test.ts
new file mode 100644
index 000000000..5b8f755de
--- /dev/null
+++ b/sdk/tests/material.test.ts
@@ -0,0 +1,874 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+ Material,
+ ShaderSources,
+ isTextureRef,
+ initMaterialAPI,
+ shutdownMaterialAPI,
+ registerMaterialCallback,
+} from '../src/material';
+import type {
+ MaterialHandle,
+ ShaderHandle,
+ TextureRef,
+ UniformValue,
+ MaterialAssetData,
+} from '../src/material';
+import type { ESEngineModule } from '../src/wasm';
+import { BlendMode } from '../src/blend';
+
+// =============================================================================
+// Mock WASM module for Material API
+// =============================================================================
+
+function createMaterialMockModule() {
+ const heapBuffer = new ArrayBuffer(1024 * 1024);
+
+ const resourceManager = {
+ createShader: vi.fn().mockReturnValue(1),
+ releaseShader: vi.fn(),
+ };
+
+ const mock = {
+ _malloc: vi.fn((_size: number) => 1024),
+ _free: vi.fn(),
+ HEAPU8: new Uint8Array(heapBuffer),
+ HEAPU32: new Uint32Array(heapBuffer),
+ HEAPF32: new Float32Array(heapBuffer),
+ getResourceManager: vi.fn(() => resourceManager),
+ resourceManager,
+ invalidateMaterialCache: vi.fn(),
+ clearMaterialCache: vi.fn(),
+ materialDataProvider: null as
+ | ((
+ materialId: number,
+ outShaderIdPtr: number,
+ outBlendModePtr: number,
+ outUniformBufferPtr: number,
+ outUniformCountPtr: number,
+ ) => void)
+ | null,
+ };
+
+ return mock;
+}
+
+type MockModule = ReturnType<typeof createMaterialMockModule>;
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('Material API', () => {
+ let mock: MockModule;
+
+ beforeEach(() => {
+ mock = createMaterialMockModule();
+ initMaterialAPI(mock as unknown as ESEngineModule);
+ });
+
+ afterEach(() => {
+ shutdownMaterialAPI();
+ });
+
+ // =========================================================================
+ // initMaterialAPI / shutdownMaterialAPI
+ // =========================================================================
+
+ describe('initMaterialAPI', () => {
+ it('should store resourceManager from module', () => {
+ expect(mock.getResourceManager).toHaveBeenCalled();
+ });
+
+ it('should register material callback', () => {
+ expect(mock.materialDataProvider).toBeTypeOf('function');
+ });
+ });
+
+ describe('shutdownMaterialAPI', () => {
+ it('should free uniform buffer if allocated', () => {
+ const mat = Material.create({ shader: 1 as ShaderHandle });
+ Material.setUniform(mat, 'u_val', 1.0);
+
+ // Trigger callback to allocate uniform buffer
+ if (mock.materialDataProvider) {
+ mock.materialDataProvider(mat, 0, 4, 8, 12);
+ }
+
+ shutdownMaterialAPI();
+ expect(mock._free).toHaveBeenCalled();
+ });
+
+ it('should clear materials map', () => {
+ const mat = Material.create({ shader: 1 as ShaderHandle });
+ shutdownMaterialAPI();
+ expect(Material.isValid(mat)).toBe(false);
+ });
+
+ it('should reset nextMaterialId to 1', () => {
+ Material.create({ shader: 1 as ShaderHandle });
+ Material.create({ shader: 1 as ShaderHandle });
+ shutdownMaterialAPI();
+
+ // Re-init to verify ID reset
+ mock = createMaterialMockModule();
+ initMaterialAPI(mock as unknown as ESEngineModule);
+ const handle = Material.create({ shader: 1 as ShaderHandle });
+ expect(handle).toBe(1);
+ });
+
+ it('should handle double shutdown gracefully', () => {
+ shutdownMaterialAPI();
+ expect(() => shutdownMaterialAPI()).not.toThrow();
+ });
+ });
+
+ // =========================================================================
+ // Shader create/release
+ // =========================================================================
+
+ describe('Material.createShader', () => {
+ it('should proxy to resourceManager.createShader', () => {
+ const handle = Material.createShader('vert', 'frag');
+ expect(handle).toBe(1);
+ expect(mock.resourceManager.createShader).toHaveBeenCalledWith('vert', 'frag');
+ });
+ });
+
+ describe('Material.releaseShader', () => {
+ it('should proxy to resourceManager.releaseShader for valid handle', () => {
+ Material.releaseShader(5 as ShaderHandle);
+ expect(mock.resourceManager.releaseShader).toHaveBeenCalledWith(5);
+ });
+
+ it('should skip release for handle <= 0', () => {
+ Material.releaseShader(0 as ShaderHandle);
+ Material.releaseShader(-1 as ShaderHandle);
+ expect(mock.resourceManager.releaseShader).not.toHaveBeenCalled();
+ });
+ });
+
+ // =========================================================================
+ // Material CRUD
+ // =========================================================================
+
+ describe('Material.create', () => {
+ it('should return incrementing handles starting from 1', () => {
+ // Handle 1 was already consumed by some tests; re-init
+ shutdownMaterialAPI();
+ mock = createMaterialMockModule();
+ initMaterialAPI(mock as unknown as ESEngineModule);
+
+ const h1 = Material.create({ shader: 1 as ShaderHandle });
+ const h2 = Material.create({ shader: 1 as ShaderHandle });
+ const h3 = Material.create({ shader: 1 as ShaderHandle });
+ expect(h1).toBe(1);
+ expect(h2).toBe(2);
+ expect(h3).toBe(3);
+ });
+
+ it('should store material with default values', () => {
+ const h = Material.create({ shader: 42 as ShaderHandle });
+ const data = Material.get(h);
+ expect(data).toBeDefined();
+ expect(data!.shader).toBe(42);
+ expect(data!.blendMode).toBe(BlendMode.Normal);
+ expect(data!.depthTest).toBe(false);
+ expect(data!.dirty_).toBe(true);
+ expect(data!.uniforms.size).toBe(0);
+ });
+
+ it('should accept optional uniforms', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_time: 0.5, u_color: { x: 1, y: 0, z: 0, w: 1 } },
+ });
+ const data = Material.get(h);
+ expect(data!.uniforms.size).toBe(2);
+ expect(data!.uniforms.get('u_time')).toBe(0.5);
+ });
+
+ it('should accept custom blendMode and depthTest', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ blendMode: BlendMode.Additive,
+ depthTest: true,
+ });
+ const data = Material.get(h);
+ expect(data!.blendMode).toBe(BlendMode.Additive);
+ expect(data!.depthTest).toBe(true);
+ });
+ });
+
+ describe('Material.get', () => {
+ it('should return material data for valid handle', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ expect(Material.get(h)).toBeDefined();
+ });
+
+ it('should return undefined for invalid handle', () => {
+ expect(Material.get(999 as MaterialHandle)).toBeUndefined();
+ });
+ });
+
+ describe('Material.isValid', () => {
+ it('should return true for existing material', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ expect(Material.isValid(h)).toBe(true);
+ });
+
+ it('should return false for non-existing material', () => {
+ expect(Material.isValid(999 as MaterialHandle)).toBe(false);
+ });
+
+ it('should return false after release', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ Material.release(h);
+ expect(Material.isValid(h)).toBe(false);
+ });
+ });
+
+ describe('Material.release', () => {
+ it('should delete material and call invalidateMaterialCache', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ Material.release(h);
+ expect(Material.isValid(h)).toBe(false);
+ expect(mock.invalidateMaterialCache).toHaveBeenCalledWith(h);
+ });
+ });
+
+ describe('Material.releaseAll', () => {
+ it('should clear all materials and call clearMaterialCache', () => {
+ const h1 = Material.create({ shader: 1 as ShaderHandle });
+ const h2 = Material.create({ shader: 1 as ShaderHandle });
+ Material.releaseAll();
+ expect(Material.isValid(h1)).toBe(false);
+ expect(Material.isValid(h2)).toBe(false);
+ expect(mock.clearMaterialCache).toHaveBeenCalled();
+ });
+ });
+
+ // =========================================================================
+ // Uniform management
+ // =========================================================================
+
+ describe('Uniform management', () => {
+ it('should set and get uniform value', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ Material.setUniform(h, 'u_time', 3.14);
+ expect(Material.getUniform(h, 'u_time')).toBe(3.14);
+ });
+
+ it('should mark dirty and invalidate cache on setUniform', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ const data = Material.get(h)!;
+ data.dirty_ = false;
+
+ Material.setUniform(h, 'u_val', 1.0);
+ expect(data.dirty_).toBe(true);
+ expect(mock.invalidateMaterialCache).toHaveBeenCalledWith(h);
+ });
+
+ it('should return undefined for non-existing uniform', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ expect(Material.getUniform(h, 'nonexistent')).toBeUndefined();
+ });
+
+ it('should return undefined for invalid material handle', () => {
+ expect(Material.getUniform(999 as MaterialHandle, 'u_val')).toBeUndefined();
+ });
+
+ it('should not throw when setting uniform on invalid handle', () => {
+ expect(() => Material.setUniform(999 as MaterialHandle, 'u_val', 1.0)).not.toThrow();
+ });
+ });
+
+ describe('Material.getUniforms', () => {
+ it('should return a copy of uniforms map', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_a: 1, u_b: 2 },
+ });
+ const uniformsCopy = Material.getUniforms(h);
+ expect(uniformsCopy.size).toBe(2);
+ expect(uniformsCopy.get('u_a')).toBe(1);
+
+ // Modifying copy should not affect original
+ uniformsCopy.set('u_c', 3);
+ expect(Material.getUniforms(h).size).toBe(2);
+ });
+
+ it('should return empty map for invalid handle', () => {
+ const uniforms = Material.getUniforms(999 as MaterialHandle);
+ expect(uniforms.size).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // BlendMode / DepthTest / Shader
+ // =========================================================================
+
+ describe('BlendMode', () => {
+ it('should set and get blend mode', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ Material.setBlendMode(h, BlendMode.Multiply);
+ expect(Material.getBlendMode(h)).toBe(BlendMode.Multiply);
+ });
+
+ it('should call invalidateMaterialCache on setBlendMode', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ mock.invalidateMaterialCache.mockClear();
+ Material.setBlendMode(h, BlendMode.Additive);
+ expect(mock.invalidateMaterialCache).toHaveBeenCalledWith(h);
+ });
+
+ it('should return Normal for invalid handle', () => {
+ expect(Material.getBlendMode(999 as MaterialHandle)).toBe(BlendMode.Normal);
+ });
+ });
+
+ describe('DepthTest', () => {
+ it('should set depth test and invalidate cache', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ mock.invalidateMaterialCache.mockClear();
+ Material.setDepthTest(h, true);
+ const data = Material.get(h)!;
+ expect(data.depthTest).toBe(true);
+ expect(mock.invalidateMaterialCache).toHaveBeenCalledWith(h);
+ });
+ });
+
+ describe('Material.getShader', () => {
+ it('should return shader handle', () => {
+ const h = Material.create({ shader: 42 as ShaderHandle });
+ expect(Material.getShader(h)).toBe(42);
+ });
+
+ it('should return 0 for invalid handle', () => {
+ expect(Material.getShader(999 as MaterialHandle)).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // createFromAsset
+ // =========================================================================
+
+ describe('Material.createFromAsset', () => {
+ it('should parse number properties', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: { u_intensity: 0.75 },
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ expect(Material.getUniform(h, 'u_intensity')).toBe(0.75);
+ });
+
+ it('should parse Color (with "a" key) as Vec4', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: {
+ u_color: { r: 1, g: 0.5, b: 0.25, a: 1 },
+ },
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ const val = Material.getUniform(h, 'u_color') as { x: number; y: number; z: number; w: number };
+ expect(val).toEqual({ x: 1, y: 0.5, z: 0.25, w: 1 });
+ });
+
+ it('should parse Vec4 (with "w" key)', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: {
+ u_rect: { x: 0, y: 1, z: 2, w: 3 },
+ },
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ const val = Material.getUniform(h, 'u_rect') as { x: number; y: number; z: number; w: number };
+ expect(val).toEqual({ x: 0, y: 1, z: 2, w: 3 });
+ });
+
+ it('should parse Vec3 (with "z" key)', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: {
+ u_pos: { x: 1, y: 2, z: 3 },
+ },
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ const val = Material.getUniform(h, 'u_pos') as { x: number; y: number; z: number };
+ expect(val).toEqual({ x: 1, y: 2, z: 3 });
+ });
+
+ it('should parse Vec2 (with "y" key)', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: {
+ u_offset: { x: 5, y: 10 },
+ },
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ const val = Material.getUniform(h, 'u_offset') as { x: number; y: number };
+ expect(val).toEqual({ x: 5, y: 10 });
+ });
+
+ it('should use blendMode and depthTest from asset data', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Screen,
+ depthTest: true,
+ properties: {},
+ };
+ const h = Material.createFromAsset(assetData, 10 as ShaderHandle);
+ expect(Material.getBlendMode(h)).toBe(BlendMode.Screen);
+ expect(Material.get(h)!.depthTest).toBe(true);
+ });
+
+ it('should use provided shaderHandle', () => {
+ const assetData: MaterialAssetData = {
+ version: '1.0',
+ type: 'material',
+ shader: 'test.shader',
+ blendMode: BlendMode.Normal,
+ depthTest: false,
+ properties: {},
+ };
+ const h = Material.createFromAsset(assetData, 77 as ShaderHandle);
+ expect(Material.getShader(h)).toBe(77);
+ });
+ });
+
+ // =========================================================================
+ // createInstance
+ // =========================================================================
+
+ describe('Material.createInstance', () => {
+ it('should copy shader, uniforms, blendMode, depthTest from source', () => {
+ const src = Material.create({
+ shader: 42 as ShaderHandle,
+ uniforms: { u_time: 1.5 },
+ blendMode: BlendMode.Additive,
+ depthTest: true,
+ });
+ const inst = Material.createInstance(src);
+
+ expect(Material.getShader(inst)).toBe(42);
+ expect(Material.getUniform(inst, 'u_time')).toBe(1.5);
+ expect(Material.getBlendMode(inst)).toBe(BlendMode.Additive);
+ expect(Material.get(inst)!.depthTest).toBe(true);
+ });
+
+ it('should create independent instance (modifying instance does not affect source)', () => {
+ const src = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_val: 10 },
+ });
+ const inst = Material.createInstance(src);
+
+ Material.setUniform(inst, 'u_val', 20);
+ expect(Material.getUniform(src, 'u_val')).toBe(10);
+ expect(Material.getUniform(inst, 'u_val')).toBe(20);
+ });
+
+ it('should create independent instance (modifying source does not affect instance)', () => {
+ const src = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_val: 10 },
+ });
+ const inst = Material.createInstance(src);
+
+ Material.setUniform(src, 'u_val', 99);
+ expect(Material.getUniform(inst, 'u_val')).toBe(10);
+ });
+
+ it('should throw for invalid source', () => {
+ expect(() => Material.createInstance(999 as MaterialHandle)).toThrow(
+ 'Invalid source material: 999',
+ );
+ });
+
+ it('should return a new handle different from source', () => {
+ const src = Material.create({ shader: 1 as ShaderHandle });
+ const inst = Material.createInstance(src);
+ expect(inst).not.toBe(src);
+ expect(inst).toBeGreaterThan(src);
+ });
+ });
+
+ // =========================================================================
+ // toAssetData
+ // =========================================================================
+
+ describe('Material.toAssetData', () => {
+ it('should serialize to MaterialAssetData', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_time: 0.5 },
+ blendMode: BlendMode.Multiply,
+ depthTest: true,
+ });
+ const asset = Material.toAssetData(h, 'shaders/custom.shader');
+ expect(asset).toEqual({
+ version: '1.0',
+ type: 'material',
+ shader: 'shaders/custom.shader',
+ blendMode: BlendMode.Multiply,
+ depthTest: true,
+ properties: { u_time: 0.5 },
+ });
+ });
+
+ it('should return null for invalid material', () => {
+ expect(Material.toAssetData(999 as MaterialHandle, 'path')).toBeNull();
+ });
+
+ it('should include all uniforms in properties', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: {
+ u_a: 1,
+ u_b: { x: 1, y: 2 },
+ u_c: { x: 1, y: 2, z: 3 },
+ },
+ });
+ const asset = Material.toAssetData(h, 'test.shader')!;
+ expect(Object.keys(asset.properties)).toHaveLength(3);
+ expect(asset.properties['u_a']).toBe(1);
+ expect(asset.properties['u_b']).toEqual({ x: 1, y: 2 });
+ expect(asset.properties['u_c']).toEqual({ x: 1, y: 2, z: 3 });
+ });
+ });
+
+ // =========================================================================
+ // tex() and isTextureRef
+ // =========================================================================
+
+ describe('Material.tex', () => {
+ it('should return TextureRef with __textureRef flag', () => {
+ const ref = Material.tex(42);
+ expect(ref.__textureRef).toBe(true);
+ expect(ref.textureId).toBe(42);
+ expect(ref.slot).toBeUndefined();
+ });
+
+ it('should accept optional slot', () => {
+ const ref = Material.tex(10, 3);
+ expect(ref.textureId).toBe(10);
+ expect(ref.slot).toBe(3);
+ });
+ });
+
+ describe('isTextureRef', () => {
+ it('should return true for TextureRef objects', () => {
+ expect(isTextureRef(Material.tex(1))).toBe(true);
+ expect(isTextureRef({ __textureRef: true, textureId: 5 } as TextureRef)).toBe(true);
+ });
+
+ it('should return false for numbers', () => {
+ expect(isTextureRef(42)).toBe(false);
+ });
+
+ it('should return false for Vec2', () => {
+ expect(isTextureRef({ x: 1, y: 2 })).toBe(false);
+ });
+
+ it('should return false for Vec3', () => {
+ expect(isTextureRef({ x: 1, y: 2, z: 3 })).toBe(false);
+ });
+
+ it('should return false for Vec4', () => {
+ expect(isTextureRef({ x: 1, y: 2, z: 3, w: 4 })).toBe(false);
+ });
+
+ it('should return false for arrays', () => {
+ expect(isTextureRef([1, 2, 3])).toBe(false);
+ });
+ });
+
+ // =========================================================================
+ // registerMaterialCallback
+ // =========================================================================
+
+ describe('registerMaterialCallback', () => {
+ it('should set materialDataProvider on module', () => {
+ expect(mock.materialDataProvider).toBeTypeOf('function');
+ });
+
+ it('should be idempotent (second call is no-op)', () => {
+ const firstProvider = mock.materialDataProvider;
+ registerMaterialCallback();
+ expect(mock.materialDataProvider).toBe(firstProvider);
+ });
+ });
+
+ // =========================================================================
+ // materialDataProvider callback
+ // =========================================================================
+
+ describe('materialDataProvider callback', () => {
+ it('should write shader and blendMode to outPtrs for valid material', () => {
+ const h = Material.create({
+ shader: 7 as ShaderHandle,
+ blendMode: BlendMode.Additive,
+ });
+
+ const outShader = 256;
+ const outBlend = 260;
+ const outUniBuf = 264;
+ const outUniCount = 268;
+
+ mock.materialDataProvider!(h, outShader, outBlend, outUniBuf, outUniCount);
+
+ expect(mock.HEAPU32[outShader >> 2]).toBe(7);
+ expect(mock.HEAPU32[outBlend >> 2]).toBe(BlendMode.Additive);
+ });
+
+ it('should write zeros for unknown materialId', () => {
+ const outShader = 256;
+ const outBlend = 260;
+ const outUniBuf = 264;
+ const outUniCount = 268;
+
+ mock.materialDataProvider!(999, outShader, outBlend, outUniBuf, outUniCount);
+
+ expect(mock.HEAPU32[outShader >> 2]).toBe(0);
+ expect(mock.HEAPU32[outBlend >> 2]).toBe(0);
+ expect(mock.HEAPU32[outUniBuf >> 2]).toBe(0);
+ expect(mock.HEAPU32[outUniCount >> 2]).toBe(0);
+ });
+
+ it('should serialize uniforms and report count', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_time: 1.0, u_scale: 2.0 },
+ });
+
+ const outShader = 256;
+ const outBlend = 260;
+ const outUniBuf = 264;
+ const outUniCount = 268;
+
+ mock.materialDataProvider!(h, outShader, outBlend, outUniBuf, outUniCount);
+
+ const uniformCount = mock.HEAPU32[outUniCount >> 2];
+ expect(uniformCount).toBe(2);
+ expect(mock.HEAPU32[outUniBuf >> 2]).toBeGreaterThan(0);
+ });
+
+ it('should skip TextureRef uniforms in serialization count', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: {
+ u_time: 1.0,
+ u_tex: Material.tex(5),
+ },
+ });
+
+ const outShader = 256;
+ const outBlend = 260;
+ const outUniBuf = 264;
+ const outUniCount = 268;
+
+ mock.materialDataProvider!(h, outShader, outBlend, outUniBuf, outUniCount);
+
+ const uniformCount = mock.HEAPU32[outUniCount >> 2];
+ expect(uniformCount).toBe(1);
+ });
+ });
+
+ // =========================================================================
+ // serializeUniforms (tested via materialDataProvider callback)
+ // =========================================================================
+
+ describe('serializeUniforms (via callback)', () => {
+ function callProvider(h: MaterialHandle) {
+ const outShader = 256;
+ const outBlend = 260;
+ const outUniBuf = 264;
+ const outUniCount = 268;
+ mock.materialDataProvider!(h, outShader, outBlend, outUniBuf, outUniCount);
+ return {
+ count: mock.HEAPU32[outUniCount >> 2],
+ bufferPtr: mock.HEAPU32[outUniBuf >> 2],
+ };
+ }
+
+ it('should serialize number uniform (type 0)', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { u_val: 42.5 },
+ });
+
+ const { count, bufferPtr } = callProvider(h);
+ expect(count).toBe(1);
+
+ // Read name length
+ const nameLen = mock.HEAPU32[bufferPtr >> 2];
+ expect(nameLen).toBe(5); // "u_val"
+
+ // Read type after padded name
+ const namePadded = Math.ceil(nameLen / 4) * 4;
+ const typeOffset = bufferPtr + 4 + namePadded;
+ const type = mock.HEAPU32[typeOffset >> 2];
+ expect(type).toBe(0); // number type
+
+ // Read first float value
+ const valOffset = typeOffset + 4;
+ expect(mock.HEAPF32[valOffset >> 2]).toBeCloseTo(42.5);
+ });
+
+ it('should serialize Vec2 uniform (type 1)', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { uv: { x: 3, y: 4 } },
+ });
+
+ const { count, bufferPtr } = callProvider(h);
+ expect(count).toBe(1);
+
+ const nameLen = mock.HEAPU32[bufferPtr >> 2];
+ const namePadded = Math.ceil(nameLen / 4) * 4;
+ const typeOffset = bufferPtr + 4 + namePadded;
+ expect(mock.HEAPU32[typeOffset >> 2]).toBe(1);
+
+ const valOffset = typeOffset + 4;
+ expect(mock.HEAPF32[valOffset >> 2]).toBeCloseTo(3);
+ expect(mock.HEAPF32[(valOffset + 4) >> 2]).toBeCloseTo(4);
+ });
+
+ it('should serialize Vec3 uniform (type 2)', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { pos: { x: 1, y: 2, z: 3 } },
+ });
+
+ const { count, bufferPtr } = callProvider(h);
+ expect(count).toBe(1);
+
+ const nameLen = mock.HEAPU32[bufferPtr >> 2];
+ const namePadded = Math.ceil(nameLen / 4) * 4;
+ const typeOffset = bufferPtr + 4 + namePadded;
+ expect(mock.HEAPU32[typeOffset >> 2]).toBe(2);
+
+ const valOffset = typeOffset + 4;
+ expect(mock.HEAPF32[valOffset >> 2]).toBeCloseTo(1);
+ expect(mock.HEAPF32[(valOffset + 4) >> 2]).toBeCloseTo(2);
+ expect(mock.HEAPF32[(valOffset + 8) >> 2]).toBeCloseTo(3);
+ });
+
+ it('should serialize Vec4 uniform (type 3)', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: { col: { x: 0.1, y: 0.2, z: 0.3, w: 0.4 } },
+ });
+
+ const { count, bufferPtr } = callProvider(h);
+ expect(count).toBe(1);
+
+ const nameLen = mock.HEAPU32[bufferPtr >> 2];
+ const namePadded = Math.ceil(nameLen / 4) * 4;
+ const typeOffset = bufferPtr + 4 + namePadded;
+ expect(mock.HEAPU32[typeOffset >> 2]).toBe(3);
+
+ const valOffset = typeOffset + 4;
+ expect(mock.HEAPF32[valOffset >> 2]).toBeCloseTo(0.1);
+ expect(mock.HEAPF32[(valOffset + 4) >> 2]).toBeCloseTo(0.2);
+ expect(mock.HEAPF32[(valOffset + 8) >> 2]).toBeCloseTo(0.3);
+ expect(mock.HEAPF32[(valOffset + 12) >> 2]).toBeCloseTo(0.4);
+ });
+
+ it('should skip TextureRef uniforms', () => {
+ const h = Material.create({
+ shader: 1 as ShaderHandle,
+ uniforms: {
+ u_tex: Material.tex(1),
+ u_val: 5.0,
+ },
+ });
+
+ const { count } = callProvider(h);
+ expect(count).toBe(1);
+ });
+
+ it('should handle material with no uniforms', () => {
+ const h = Material.create({ shader: 1 as ShaderHandle });
+ const { count } = callProvider(h);
+ expect(count).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // ShaderSources constants
+ // =========================================================================
+
+ describe('ShaderSources', () => {
+ it('should have SPRITE_VERTEX containing vertex shader markers', () => {
+ expect(ShaderSources.SPRITE_VERTEX).toContain('#version 300 es');
+ expect(ShaderSources.SPRITE_VERTEX).toContain('a_position');
+ expect(ShaderSources.SPRITE_VERTEX).toContain('gl_Position');
+ });
+
+ it('should have SPRITE_FRAGMENT containing fragment shader markers', () => {
+ expect(ShaderSources.SPRITE_FRAGMENT).toContain('#version 300 es');
+ expect(ShaderSources.SPRITE_FRAGMENT).toContain('u_texture');
+ expect(ShaderSources.SPRITE_FRAGMENT).toContain('fragColor');
+ });
+
+ it('should have COLOR_VERTEX containing vertex shader markers', () => {
+ expect(ShaderSources.COLOR_VERTEX).toContain('#version 300 es');
+ expect(ShaderSources.COLOR_VERTEX).toContain('a_position');
+ expect(ShaderSources.COLOR_VERTEX).toContain('gl_Position');
+ });
+
+ it('should have COLOR_FRAGMENT containing fragment shader markers', () => {
+ expect(ShaderSources.COLOR_FRAGMENT).toContain('#version 300 es');
+ expect(ShaderSources.COLOR_FRAGMENT).toContain('v_color');
+ expect(ShaderSources.COLOR_FRAGMENT).toContain('fragColor');
+ });
+
+ it('should have COLOR_FRAGMENT without texture sampler', () => {
+ expect(ShaderSources.COLOR_FRAGMENT).not.toContain('u_texture');
+ });
+ });
+
+ // =========================================================================
+ // Uninitialized guard
+ // =========================================================================
+
+ describe('uninitialized guard', () => {
+ it('should throw when createShader called without init', () => {
+ shutdownMaterialAPI();
+ expect(() => Material.createShader('v', 'f')).toThrow(
+ 'Material API not initialized',
+ );
+ });
+
+ it('should throw when releaseShader called without init for valid handle', () => {
+ shutdownMaterialAPI();
+ expect(() => Material.releaseShader(1 as ShaderHandle)).toThrow(
+ 'Material API not initialized',
+ );
+ });
+ });
+});
diff --git a/sdk/tests/postprocess.test.ts b/sdk/tests/postprocess.test.ts
new file mode 100644
index 000000000..59be9201d
--- /dev/null
+++ b/sdk/tests/postprocess.test.ts
@@ -0,0 +1,364 @@
+vi.mock('../src/material', () => ({
+ Material: {
+ createShader: vi.fn().mockReturnValue(42),
+ },
+}));
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { PostProcess, initPostProcessAPI, shutdownPostProcessAPI } from '../src/postprocess';
+import { Material } from '../src/material';
+import type { ESEngineModule } from '../src/wasm';
+
+// =============================================================================
+// Mock WASM module for PostProcess API
+// =============================================================================
+
+function createPostProcessMockModule() {
+ const mock = {
+ postprocess_init: vi.fn().mockReturnValue(true),
+ postprocess_shutdown: vi.fn(),
+ postprocess_resize: vi.fn(),
+ postprocess_addPass: vi.fn().mockReturnValue(0),
+ postprocess_removePass: vi.fn(),
+ postprocess_setPassEnabled: vi.fn(),
+ postprocess_isPassEnabled: vi.fn().mockReturnValue(true),
+ postprocess_setUniformFloat: vi.fn(),
+ postprocess_setUniformVec4: vi.fn(),
+ postprocess_begin: vi.fn(),
+ postprocess_end: vi.fn(),
+ postprocess_getPassCount: vi.fn().mockReturnValue(3),
+ postprocess_isInitialized: vi.fn().mockReturnValue(true),
+ postprocess_setBypass: vi.fn(),
+ postprocess_isBypassed: vi.fn().mockReturnValue(false),
+ };
+
+ return mock;
+}
+
+type MockModule = ReturnType<typeof createPostProcessMockModule>;
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('PostProcess API', () => {
+ let mock: MockModule;
+
+ beforeEach(() => {
+ mock = createPostProcessMockModule();
+ initPostProcessAPI(mock as unknown as ESEngineModule);
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ shutdownPostProcessAPI();
+ });
+
+ // =========================================================================
+ // initPostProcessAPI / shutdownPostProcessAPI
+ // =========================================================================
+
+ describe('initPostProcessAPI', () => {
+ it('should set the module without throwing', () => {
+ expect(() => initPostProcessAPI(mock as unknown as ESEngineModule)).not.toThrow();
+ });
+ });
+
+ describe('shutdownPostProcessAPI', () => {
+ it('should call postprocess_shutdown when initialized', () => {
+ mock.postprocess_isInitialized.mockReturnValue(true);
+ shutdownPostProcessAPI();
+ expect(mock.postprocess_shutdown).toHaveBeenCalledOnce();
+ });
+
+ it('should not call postprocess_shutdown when not initialized', () => {
+ mock.postprocess_isInitialized.mockReturnValue(false);
+ shutdownPostProcessAPI();
+ expect(mock.postprocess_shutdown).not.toHaveBeenCalled();
+ });
+
+ it('should handle double shutdown gracefully', () => {
+ mock.postprocess_isInitialized.mockReturnValue(true);
+ shutdownPostProcessAPI();
+ shutdownPostProcessAPI();
+ expect(mock.postprocess_shutdown).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // Uninitialized guard
+ // =========================================================================
+
+ describe('uninitialized guard', () => {
+ it('should return false for isInitialized after shutdown', () => {
+ shutdownPostProcessAPI();
+ expect(PostProcess.isInitialized()).toBe(false);
+ });
+
+ it('should return true for isBypassed after shutdown', () => {
+ shutdownPostProcessAPI();
+ expect(PostProcess.isBypassed()).toBe(true);
+ });
+
+ it('should return false from init after shutdown', () => {
+ shutdownPostProcessAPI();
+ expect(PostProcess.init(800, 600)).toBe(false);
+ });
+
+ it('should return -1 from addPass after shutdown', () => {
+ shutdownPostProcessAPI();
+ expect(PostProcess.addPass('test', 1)).toBe(-1);
+ });
+
+ it('should not throw from begin after shutdown', () => {
+ shutdownPostProcessAPI();
+ expect(() => PostProcess.begin()).not.toThrow();
+ });
+ });
+
+ // =========================================================================
+ // Pipeline lifecycle
+ // =========================================================================
+
+ describe('pipeline lifecycle', () => {
+ it('should call postprocess_init with width and height', () => {
+ PostProcess.init(1920, 1080);
+ expect(mock.postprocess_init).toHaveBeenCalledWith(1920, 1080);
+ });
+
+ it('should return the WASM result from init', () => {
+ mock.postprocess_init.mockReturnValue(true);
+ expect(PostProcess.init(800, 600)).toBe(true);
+
+ mock.postprocess_init.mockReturnValue(false);
+ expect(PostProcess.init(800, 600)).toBe(false);
+ });
+
+ it('should call postprocess_shutdown', () => {
+ PostProcess.shutdown();
+ expect(mock.postprocess_shutdown).toHaveBeenCalledOnce();
+ });
+
+ it('should call postprocess_resize with width and height', () => {
+ PostProcess.resize(1280, 720);
+ expect(mock.postprocess_resize).toHaveBeenCalledWith(1280, 720);
+ });
+ });
+
+ // =========================================================================
+ // Pass management
+ // =========================================================================
+
+ describe('pass management', () => {
+ it('should call postprocess_addPass and return index', () => {
+ mock.postprocess_addPass.mockReturnValue(2);
+ const index = PostProcess.addPass('bloom', 10);
+ expect(mock.postprocess_addPass).toHaveBeenCalledWith('bloom', 10);
+ expect(index).toBe(2);
+ });
+
+ it('should call postprocess_removePass', () => {
+ PostProcess.removePass('bloom');
+ expect(mock.postprocess_removePass).toHaveBeenCalledWith('bloom');
+ });
+
+ it('should call postprocess_setPassEnabled', () => {
+ PostProcess.setEnabled('bloom', true);
+ expect(mock.postprocess_setPassEnabled).toHaveBeenCalledWith('bloom', true);
+
+ PostProcess.setEnabled('bloom', false);
+ expect(mock.postprocess_setPassEnabled).toHaveBeenCalledWith('bloom', false);
+ });
+
+ it('should call postprocess_isPassEnabled and return result', () => {
+ mock.postprocess_isPassEnabled.mockReturnValue(true);
+ expect(PostProcess.isEnabled('bloom')).toBe(true);
+
+ mock.postprocess_isPassEnabled.mockReturnValue(false);
+ expect(PostProcess.isEnabled('bloom')).toBe(false);
+ });
+
+ it('should call postprocess_getPassCount and return count', () => {
+ mock.postprocess_getPassCount.mockReturnValue(5);
+ expect(PostProcess.getPassCount()).toBe(5);
+ });
+ });
+
+ // =========================================================================
+ // Uniform setting
+ // =========================================================================
+
+ describe('uniform setting', () => {
+ it('should call postprocess_setUniformFloat', () => {
+ PostProcess.setUniform('bloom', 'u_intensity', 0.5);
+ expect(mock.postprocess_setUniformFloat).toHaveBeenCalledWith('bloom', 'u_intensity', 0.5);
+ });
+
+ it('should call postprocess_setUniformVec4 with destructured values', () => {
+ PostProcess.setUniformVec4('bloom', 'u_color', { x: 1, y: 0.5, z: 0.25, w: 1 });
+ expect(mock.postprocess_setUniformVec4).toHaveBeenCalledWith('bloom', 'u_color', 1, 0.5, 0.25, 1);
+ });
+ });
+
+ // =========================================================================
+ // Render frame
+ // =========================================================================
+
+ describe('render frame', () => {
+ it('should call postprocess_begin', () => {
+ PostProcess.begin();
+ expect(mock.postprocess_begin).toHaveBeenCalledOnce();
+ });
+
+ it('should call postprocess_end', () => {
+ PostProcess.end();
+ expect(mock.postprocess_end).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // Bypass mode
+ // =========================================================================
+
+ describe('bypass mode', () => {
+ it('should call postprocess_setBypass with true', () => {
+ PostProcess.setBypass(true);
+ expect(mock.postprocess_setBypass).toHaveBeenCalledWith(true);
+ });
+
+ it('should call postprocess_setBypass with false', () => {
+ PostProcess.setBypass(false);
+ expect(mock.postprocess_setBypass).toHaveBeenCalledWith(false);
+ });
+
+ it('should return WASM result from isBypassed', () => {
+ mock.postprocess_isBypassed.mockReturnValue(true);
+ expect(PostProcess.isBypassed()).toBe(true);
+
+ mock.postprocess_isBypassed.mockReturnValue(false);
+ expect(PostProcess.isBypassed()).toBe(false);
+ });
+
+ it('should return true for isBypassed when module is null', () => {
+ shutdownPostProcessAPI();
+ expect(PostProcess.isBypassed()).toBe(true);
+ });
+ });
+
+ // =========================================================================
+ // Built-in effects
+ // =========================================================================
+
+ describe('built-in effects', () => {
+ it('should create blur shader using Material.createShader', () => {
+ const handle = PostProcess.createBlur();
+ expect(Material.createShader).toHaveBeenCalledWith(
+ expect.stringContaining('a_position'),
+ expect.stringContaining('u_intensity'),
+ );
+ expect(handle).toBe(42);
+ });
+
+ it('should create vignette shader using Material.createShader', () => {
+ const handle = PostProcess.createVignette();
+ expect(Material.createShader).toHaveBeenCalledWith(
+ expect.stringContaining('a_position'),
+ expect.stringContaining('u_softness'),
+ );
+ expect(handle).toBe(42);
+ });
+
+ it('should create grayscale shader using Material.createShader', () => {
+ const handle = PostProcess.createGrayscale();
+ expect(Material.createShader).toHaveBeenCalledWith(
+ expect.stringContaining('a_position'),
+ expect.stringContaining('0.299'),
+ );
+ expect(handle).toBe(42);
+ });
+
+ it('should create chromatic aberration shader using Material.createShader', () => {
+ const handle = PostProcess.createChromaticAberration();
+ expect(Material.createShader).toHaveBeenCalledWith(
+ expect.stringContaining('a_position'),
+ expect.stringContaining('u_intensity'),
+ );
+ expect(handle).toBe(42);
+ });
+
+ it('should use the shared POSTPROCESS_VERTEX shader for all effects', () => {
+ PostProcess.createBlur();
+ PostProcess.createVignette();
+ PostProcess.createGrayscale();
+ PostProcess.createChromaticAberration();
+
+ const calls = (Material.createShader as ReturnType<typeof vi.fn>).mock.calls;
+ const vertexShaders = calls.map((c: unknown[]) => c[0]);
+ const firstVertex = vertexShaders[0];
+ for (const vs of vertexShaders) {
+ expect(vs).toBe(firstVertex);
+ }
+ });
+ });
+
+ // =========================================================================
+ // WASM exception safety
+ // =========================================================================
+
+ describe('WASM exception safety', () => {
+ it('should return false when postprocess_init throws', () => {
+ mock.postprocess_init.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.init(800, 600)).toBe(false);
+ });
+
+ it('should return -1 when postprocess_addPass throws', () => {
+ mock.postprocess_addPass.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.addPass('test', 1)).toBe(-1);
+ });
+
+ it('should return 0 when postprocess_getPassCount throws', () => {
+ mock.postprocess_getPassCount.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.getPassCount()).toBe(0);
+ });
+
+ it('should return false when postprocess_isPassEnabled throws', () => {
+ mock.postprocess_isPassEnabled.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.isEnabled('test')).toBe(false);
+ });
+
+ it('should not throw when postprocess_shutdown throws', () => {
+ mock.postprocess_shutdown.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(() => PostProcess.shutdown()).not.toThrow();
+ });
+
+ it('should not throw when postprocess_resize throws', () => {
+ mock.postprocess_resize.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(() => PostProcess.resize(800, 600)).not.toThrow();
+ });
+
+ it('should not throw when postprocess_removePass throws', () => {
+ mock.postprocess_removePass.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(() => PostProcess.removePass('test')).not.toThrow();
+ });
+
+ it('should not throw when postprocess_begin throws', () => {
+ mock.postprocess_begin.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(() => PostProcess.begin()).not.toThrow();
+ });
+
+ it('should not throw when postprocess_end throws', () => {
+ mock.postprocess_end.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(() => PostProcess.end()).not.toThrow();
+ });
+
+ it('should return true when postprocess_isBypassed throws', () => {
+ mock.postprocess_isBypassed.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.isBypassed()).toBe(true);
+ });
+
+ it('should return false when postprocess_isInitialized throws', () => {
+ mock.postprocess_isInitialized.mockImplementation(() => { throw new Error('WASM crash'); });
+ expect(PostProcess.isInitialized()).toBe(false);
+ });
+ });
+});
diff --git a/sdk/tests/renderPipeline.test.ts b/sdk/tests/renderPipeline.test.ts
new file mode 100644
index 000000000..ef291d69d
--- /dev/null
+++ b/sdk/tests/renderPipeline.test.ts
@@ -0,0 +1,436 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('../src/renderer', () => ({
+ Renderer: {
+ init: vi.fn(),
+ resize: vi.fn(),
+ begin: vi.fn(),
+ flush: vi.fn(),
+ end: vi.fn(),
+ submitSprites: vi.fn(),
+ submitBitmapText: vi.fn(),
+ submitSpine: vi.fn(),
+ setStage: vi.fn(),
+ setClearColor: vi.fn(),
+ setViewport: vi.fn(),
+ setScissor: vi.fn(),
+ clearBuffers: vi.fn(),
+ },
+}));
+
+vi.mock('../src/postprocess', () => ({
+ PostProcess: {
+ isInitialized: vi.fn().mockReturnValue(false),
+ getPassCount: vi.fn().mockReturnValue(0),
+ resize: vi.fn(),
+ begin: vi.fn(),
+ end: vi.fn(),
+ },
+}));
+
+vi.mock('../src/draw', () => ({
+ Draw: {
+ begin: vi.fn(),
+ end: vi.fn(),
+ },
+}));
+
+const mockCallbacks = new Map<string, { fn: (elapsed: number) => void; scene: string }>();
+vi.mock('../src/customDraw', () => ({
+ getDrawCallbacks: vi.fn(() => mockCallbacks),
+ unregisterDrawCallback: vi.fn(),
+}));
+
+import { RenderPipeline } from '../src/renderPipeline';
+import { Renderer } from '../src/renderer';
+import { PostProcess } from '../src/postprocess';
+import { Draw } from '../src/draw';
+import { getDrawCallbacks, unregisterDrawCallback } from '../src/customDraw';
+
+describe('RenderPipeline', () => {
+ let pipeline: RenderPipeline;
+ let registry: { _cpp: any };
+ let viewProjection: Float32Array;
+
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mockCallbacks.clear();
+ pipeline = new RenderPipeline();
+ registry = { _cpp: {} as any };
+ viewProjection = new Float32Array(16);
+ });
+
+ describe('property setters', () => {
+ it('stores spineRenderer via setSpineRenderer', () => {
+ const fn = vi.fn();
+ pipeline.setSpineRenderer(fn);
+ expect(pipeline.spineRenderer).toBe(fn);
+ });
+
+ it('returns null for spineRenderer by default', () => {
+ expect(pipeline.spineRenderer).toBeNull();
+ });
+
+ it('allows clearing spineRenderer with null', () => {
+ pipeline.setSpineRenderer(vi.fn());
+ pipeline.setSpineRenderer(null);
+ expect(pipeline.spineRenderer).toBeNull();
+ });
+
+ it('stores maskProcessor via setMaskProcessor', () => {
+ const fn = vi.fn();
+ pipeline.setMaskProcessor(fn);
+ expect(pipeline.maskProcessor).toBe(fn);
+ });
+
+ it('returns null for maskProcessor by default', () => {
+ expect(pipeline.maskProcessor).toBeNull();
+ });
+
+ it('allows clearing maskProcessor with null', () => {
+ pipeline.setMaskProcessor(vi.fn());
+ pipeline.setMaskProcessor(null);
+ expect(pipeline.maskProcessor).toBeNull();
+ });
+
+ it('stores active scenes via setActiveScenes', () => {
+ const scenes = new Set(['scene1', 'scene2']);
+ pipeline.setActiveScenes(scenes);
+ pipeline.render({ registry, viewProjection, width: 100, height: 100, elapsed: 0 });
+ // No direct getter, but we verify indirectly via callback filtering
+ });
+ });
+
+ describe('render() call sequence', () => {
+ it('calls rendering methods in correct order', () => {
+ const callOrder: string[] = [];
+ (Renderer.resize as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('resize'));
+ (Renderer.setViewport as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('setViewport'));
+ (Renderer.clearBuffers as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('clearBuffers'));
+ (Renderer.begin as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('begin'));
+ (Renderer.submitSprites as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitSprites'));
+ (Renderer.submitBitmapText as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitBitmapText'));
+ (Renderer.submitSpine as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitSpine'));
+ (Renderer.flush as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('flush'));
+ (Renderer.end as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('end'));
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+
+ expect(callOrder).toEqual([
+ 'resize', 'setViewport', 'clearBuffers', 'begin',
+ 'submitSprites', 'submitBitmapText', 'submitSpine',
+ 'flush', 'end',
+ ]);
+ });
+
+ it('passes correct arguments to Renderer methods', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+
+ expect(Renderer.resize).toHaveBeenCalledWith(800, 600);
+ expect(Renderer.setViewport).toHaveBeenCalledWith(0, 0, 800, 600);
+ expect(Renderer.clearBuffers).toHaveBeenCalledWith(3);
+ expect(Renderer.begin).toHaveBeenCalledWith(viewProjection);
+ expect(Renderer.submitSprites).toHaveBeenCalledWith(registry);
+ expect(Renderer.submitBitmapText).toHaveBeenCalledWith(registry);
+ expect(Renderer.submitSpine).toHaveBeenCalledWith(registry);
+ });
+ });
+
+ describe('resize detection', () => {
+ it('triggers resize on first render', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ expect(Renderer.resize).toHaveBeenCalledWith(800, 600);
+ });
+
+ it('does not trigger resize on second render with same size', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ vi.clearAllMocks();
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ expect(Renderer.resize).not.toHaveBeenCalled();
+ });
+
+ it('triggers resize again when size changes', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ vi.clearAllMocks();
+ pipeline.render({ registry, viewProjection, width: 1024, height: 768, elapsed: 0 });
+ expect(Renderer.resize).toHaveBeenCalledWith(1024, 768);
+ });
+
+ it('triggers resize when only width changes', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ vi.clearAllMocks();
+ pipeline.render({ registry, viewProjection, width: 1024, height: 600, elapsed: 0 });
+ expect(Renderer.resize).toHaveBeenCalledWith(1024, 600);
+ });
+
+ it('triggers resize when only height changes', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ vi.clearAllMocks();
+ pipeline.render({ registry, viewProjection, width: 800, height: 768, elapsed: 0 });
+ expect(Renderer.resize).toHaveBeenCalledWith(800, 768);
+ });
+
+ it('calls PostProcess.resize when PostProcess is initialized with passes', () => {
+ (PostProcess.isInitialized as ReturnType<typeof vi.fn>).mockReturnValue(true);
+ (PostProcess.getPassCount as ReturnType<typeof vi.fn>).mockReturnValue(2);
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(PostProcess.resize).toHaveBeenCalledWith(800, 600);
+ });
+
+ it('does not call PostProcess.resize when PostProcess is not initialized', () => {
+ (PostProcess.isInitialized as ReturnType<typeof vi.fn>).mockReturnValue(false);
+ (PostProcess.getPassCount as ReturnType<typeof vi.fn>).mockReturnValue(2);
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(PostProcess.resize).not.toHaveBeenCalled();
+ });
+
+ it('does not call PostProcess.resize when pass count is 0', () => {
+ (PostProcess.isInitialized as ReturnType<typeof vi.fn>).mockReturnValue(true);
+ (PostProcess.getPassCount as ReturnType<typeof vi.fn>).mockReturnValue(0);
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(PostProcess.resize).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('spine rendering', () => {
+ it('uses Renderer.submitSpine by default', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+ expect(Renderer.submitSpine).toHaveBeenCalledWith(registry);
+ });
+
+ it('uses custom spineRenderer when set', () => {
+ const customSpine = vi.fn();
+ pipeline.setSpineRenderer(customSpine);
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+
+ expect(customSpine).toHaveBeenCalledWith(registry, 16);
+ expect(Renderer.submitSpine).not.toHaveBeenCalled();
+ });
+
+ it('reverts to Renderer.submitSpine when spineRenderer cleared', () => {
+ const customSpine = vi.fn();
+ pipeline.setSpineRenderer(customSpine);
+ pipeline.setSpineRenderer(null);
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+
+ expect(Renderer.submitSpine).toHaveBeenCalledWith(registry);
+ expect(customSpine).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('mask processing', () => {
+ it('skips mask call when no maskProcessor is set', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ // No maskProcessor means nothing to assert was called - just ensure no error
+ });
+
+ it('calls maskProcessor with correct arguments', () => {
+ const maskFn = vi.fn();
+ pipeline.setMaskProcessor(maskFn);
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(maskFn).toHaveBeenCalledWith(registry._cpp, viewProjection, 0, 0, 800, 600);
+ });
+
+ it('calls maskProcessor before submitSprites', () => {
+ const callOrder: string[] = [];
+ const maskFn = vi.fn(() => callOrder.push('mask'));
+ (Renderer.submitSprites as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitSprites'));
+
+ pipeline.setMaskProcessor(maskFn);
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(callOrder).toEqual(['mask', 'submitSprites']);
+ });
+ });
+
+ describe('custom draw callbacks', () => {
+ it('does not call Draw.begin/end when no callbacks', () => {
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+ expect(Draw.begin).not.toHaveBeenCalled();
+ expect(Draw.end).not.toHaveBeenCalled();
+ });
+
+ it('calls Draw.begin/end and callback when callbacks exist', () => {
+ const cb = vi.fn();
+ mockCallbacks.set('test-cb', { fn: cb, scene: '' });
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 16 });
+
+ expect(Draw.begin).toHaveBeenCalledWith(viewProjection);
+ expect(cb).toHaveBeenCalledWith(16);
+ expect(Draw.end).toHaveBeenCalled();
+ });
+
+ it('calls callbacks in correct order within Draw.begin/end', () => {
+ const callOrder: string[] = [];
+ (Draw.begin as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('Draw.begin'));
+ (Draw.end as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('Draw.end'));
+ mockCallbacks.set('cb1', { fn: () => callOrder.push('cb1'), scene: '' });
+ mockCallbacks.set('cb2', { fn: () => callOrder.push('cb2'), scene: '' });
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(callOrder).toEqual(['Draw.begin', 'cb1', 'cb2', 'Draw.end']);
+ });
+
+ it('filters callbacks by activeScenes', () => {
+ const cb1 = vi.fn();
+ const cb2 = vi.fn();
+ mockCallbacks.set('cb1', { fn: cb1, scene: 'scene-a' });
+ mockCallbacks.set('cb2', { fn: cb2, scene: 'scene-b' });
+
+ pipeline.setActiveScenes(new Set(['scene-a']));
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(cb1).toHaveBeenCalled();
+ expect(cb2).not.toHaveBeenCalled();
+ });
+
+ it('runs callbacks with no scene filter when activeScenes is set', () => {
+ const cb = vi.fn();
+ mockCallbacks.set('cb-no-scene', { fn: cb, scene: '' });
+
+ pipeline.setActiveScenes(new Set(['scene-a']));
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(cb).toHaveBeenCalled();
+ });
+
+ it('runs all callbacks when activeScenes is null', () => {
+ const cb1 = vi.fn();
+ const cb2 = vi.fn();
+ mockCallbacks.set('cb1', { fn: cb1, scene: 'scene-a' });
+ mockCallbacks.set('cb2', { fn: cb2, scene: 'scene-b' });
+
+ pipeline.setActiveScenes(null);
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(cb1).toHaveBeenCalled();
+ expect(cb2).toHaveBeenCalled();
+ });
+
+ it('logs error and unregisters throwing callback', () => {
+ const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+ const error = new Error('test error');
+ mockCallbacks.set('bad-cb', { fn: () => { throw error; }, scene: '' });
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(errorSpy).toHaveBeenCalledWith("[CustomDraw] callback 'bad-cb' error:", error);
+ expect(unregisterDrawCallback).toHaveBeenCalledWith('bad-cb');
+ errorSpy.mockRestore();
+ });
+
+ it('continues executing other callbacks after one throws', () => {
+ const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+ const goodCb = vi.fn();
+ mockCallbacks.set('bad-cb', { fn: () => { throw new Error('fail'); }, scene: '' });
+ mockCallbacks.set('good-cb', { fn: goodCb, scene: '' });
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(goodCb).toHaveBeenCalled();
+ expect(unregisterDrawCallback).toHaveBeenCalledWith('bad-cb');
+ errorSpy.mockRestore();
+ });
+
+ it('still calls Draw.end even when callback throws', () => {
+ vi.spyOn(console, 'error').mockImplementation(() => {});
+ mockCallbacks.set('bad-cb', { fn: () => { throw new Error('fail'); }, scene: '' });
+
+ pipeline.render({ registry, viewProjection, width: 800, height: 600, elapsed: 0 });
+
+ expect(Draw.end).toHaveBeenCalled();
+ vi.restoreAllMocks();
+ });
+ });
+
+ describe('renderCamera()', () => {
+ const viewportPixels = { x: 10, y: 20, w: 400, h: 300 };
+
+ it('sets viewport with viewportPixels', () => {
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 0 });
+ expect(Renderer.setViewport).toHaveBeenCalledWith(10, 20, 400, 300);
+ });
+
+ it('sets scissor with viewportPixels then resets', () => {
+ const callOrder: [string, ...any[]][] = [];
+ (Renderer.setScissor as ReturnType<typeof vi.fn>).mockImplementation((...args: any[]) => {
+ callOrder.push(['setScissor', ...args]);
+ });
+
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 0 });
+
+ expect(callOrder).toEqual([
+ ['setScissor', 10, 20, 400, 300, true],
+ ['setScissor', 0, 0, 0, 0, false],
+ ]);
+ });
+
+ it('uses clearFlags parameter for clearBuffers', () => {
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 1, elapsed: 0 });
+ expect(Renderer.clearBuffers).toHaveBeenCalledWith(1);
+ });
+
+ it('does not trigger resize', () => {
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 0 });
+ expect(Renderer.resize).not.toHaveBeenCalled();
+ });
+
+ it('follows same rendering sequence as render() after setup', () => {
+ const callOrder: string[] = [];
+ (Renderer.setViewport as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('setViewport'));
+ (Renderer.setScissor as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('setScissor'));
+ (Renderer.clearBuffers as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('clearBuffers'));
+ (Renderer.begin as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('begin'));
+ (Renderer.submitSprites as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitSprites'));
+ (Renderer.submitBitmapText as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitBitmapText'));
+ (Renderer.submitSpine as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('submitSpine'));
+ (Renderer.flush as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('flush'));
+ (Renderer.end as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('end'));
+
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 0 });
+
+ expect(callOrder).toEqual([
+ 'setViewport', 'setScissor', 'clearBuffers', 'setScissor',
+ 'begin', 'submitSprites', 'submitBitmapText', 'submitSpine',
+ 'flush', 'end',
+ ]);
+ });
+
+ it('calls custom spineRenderer in renderCamera', () => {
+ const customSpine = vi.fn();
+ pipeline.setSpineRenderer(customSpine);
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 16 });
+
+ expect(customSpine).toHaveBeenCalledWith(registry, 16);
+ expect(Renderer.submitSpine).not.toHaveBeenCalled();
+ });
+
+ it('calls maskProcessor with viewport params in renderCamera', () => {
+ const maskFn = vi.fn();
+ pipeline.setMaskProcessor(maskFn);
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 0 });
+
+ expect(maskFn).toHaveBeenCalledWith(registry._cpp, viewProjection, 10, 20, 400, 300);
+ });
+
+ it('executes draw callbacks in renderCamera', () => {
+ const cb = vi.fn();
+ mockCallbacks.set('cam-cb', { fn: cb, scene: '' });
+
+ pipeline.renderCamera({ registry, viewProjection, viewportPixels, clearFlags: 3, elapsed: 16 });
+
+ expect(Draw.begin).toHaveBeenCalledWith(viewProjection);
+ expect(cb).toHaveBeenCalledWith(16);
+ expect(Draw.end).toHaveBeenCalled();
+ });
+ });
+});
diff --git a/sdk/tests/renderer.test.ts b/sdk/tests/renderer.test.ts
new file mode 100644
index 000000000..703873efa
--- /dev/null
+++ b/sdk/tests/renderer.test.ts
@@ -0,0 +1,433 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import {
+ Renderer,
+ RenderStage,
+ initRendererAPI,
+ shutdownRendererAPI,
+} from '../src/renderer';
+import type { RenderStats } from '../src/renderer';
+import type { ESEngineModule } from '../src/wasm';
+
+// =============================================================================
+// Mock WASM module for Renderer API
+// =============================================================================
+
+function createRendererMockModule() {
+ const heapBuffer = new ArrayBuffer(1024 * 1024);
+
+ const mock = {
+ _malloc: vi.fn((size: number) => size),
+ _free: vi.fn(),
+ HEAPF32: new Float32Array(heapBuffer),
+
+ renderer_init: vi.fn(),
+ renderer_resize: vi.fn(),
+ renderer_begin: vi.fn(),
+ renderer_flush: vi.fn(),
+ renderer_end: vi.fn(),
+
+ renderer_submitSprites: vi.fn(),
+ renderer_submitBitmapText: vi.fn(),
+ renderer_submitSpine: vi.fn(),
+
+ renderer_createTarget: vi.fn(() => 42),
+ renderer_releaseTarget: vi.fn(),
+ renderer_getTargetTexture: vi.fn(() => 100),
+ renderer_getTargetDepthTexture: vi.fn(() => 200),
+
+ renderer_setClearColor: vi.fn(),
+ renderer_setViewport: vi.fn(),
+ renderer_setScissor: vi.fn(),
+ renderer_clearBuffers: vi.fn(),
+ renderer_setStage: vi.fn(),
+
+ renderer_getDrawCalls: vi.fn(() => 10),
+ renderer_getTriangles: vi.fn(() => 500),
+ renderer_getSprites: vi.fn(() => 25),
+ renderer_getText: vi.fn(() => 5),
+ renderer_getSpine: vi.fn(() => 3),
+ renderer_getMeshes: vi.fn(() => 8),
+ renderer_getCulled: vi.fn(() => 12),
+
+ getResourceManager: vi.fn(() => ({
+ measureBitmapText: vi.fn(() => ({ width: 120, height: 30 })),
+ })),
+ };
+
+ return mock;
+}
+
+type MockModule = ReturnType<typeof createRendererMockModule>;
+
+// =============================================================================
+// Tests
+// =============================================================================
+
+describe('Renderer API', () => {
+ let mock: MockModule;
+
+ beforeEach(() => {
+ mock = createRendererMockModule();
+ initRendererAPI(mock as unknown as ESEngineModule);
+ });
+
+ afterEach(() => {
+ shutdownRendererAPI();
+ });
+
+ // =========================================================================
+ // initRendererAPI / shutdownRendererAPI
+ // =========================================================================
+
+ describe('initRendererAPI', () => {
+ it('should allocate viewProjection buffer (16 * 4 = 64 bytes)', () => {
+ expect(mock._malloc).toHaveBeenCalledTimes(1);
+ expect(mock._malloc).toHaveBeenCalledWith(64);
+ });
+ });
+
+ describe('shutdownRendererAPI', () => {
+ it('should free viewProjection buffer', () => {
+ shutdownRendererAPI();
+ expect(mock._free).toHaveBeenCalledTimes(1);
+ });
+
+ it('should handle double shutdown gracefully', () => {
+ shutdownRendererAPI();
+ shutdownRendererAPI();
+ expect(mock._free).toHaveBeenCalledTimes(1);
+ });
+ });
+
+ // =========================================================================
+ // Uninitialized guard
+ // =========================================================================
+
+ describe('uninitialized guard', () => {
+ beforeEach(() => {
+ shutdownRendererAPI();
+ });
+
+ it('should return silently from begin when uninitialized', () => {
+ const vp = new Float32Array(16);
+ expect(() => Renderer.begin(vp)).not.toThrow();
+ expect(mock.renderer_begin).not.toHaveBeenCalled();
+ });
+
+ it('should return all-zero stats when uninitialized', () => {
+ const stats = Renderer.getStats();
+ expect(stats).toEqual({
+ drawCalls: 0,
+ triangles: 0,
+ sprites: 0,
+ text: 0,
+ spine: 0,
+ meshes: 0,
+ culled: 0,
+ });
+ });
+
+ it('should return zero-size from measureBitmapText when uninitialized', () => {
+ const result = Renderer.measureBitmapText(1, 'hello', 16, 0);
+ expect(result).toEqual({ width: 0, height: 0 });
+ });
+
+ it('should no-op submitSprites when uninitialized', () => {
+ Renderer.submitSprites({ _cpp: 1 as any });
+ expect(mock.renderer_submitSprites).not.toHaveBeenCalled();
+ });
+
+ it('should no-op submitBitmapText when uninitialized', () => {
+ Renderer.submitBitmapText({ _cpp: 1 as any });
+ expect(mock.renderer_submitBitmapText).not.toHaveBeenCalled();
+ });
+
+ it('should no-op submitSpine when uninitialized', () => {
+ Renderer.submitSpine({ _cpp: 1 as any });
+ expect(mock.renderer_submitSpine).not.toHaveBeenCalled();
+ });
+ });
+
+ // =========================================================================
+ // Renderer.init
+ // =========================================================================
+
+ describe('Renderer.init', () => {
+ it('should call renderer_init with width and height', () => {
+ Renderer.init(800, 600);
+ expect(mock.renderer_init).toHaveBeenCalledWith(800, 600);
+ });
+ });
+
+ // =========================================================================
+ // Renderer.resize
+ // =========================================================================
+
+ describe('Renderer.resize', () => {
+ it('should call renderer_resize with width and height', () => {
+ Renderer.resize(1024, 768);
+ expect(mock.renderer_resize).toHaveBeenCalledWith(1024, 768);
+ });
+ });
+
+ // =========================================================================
+ // Renderer.begin
+ // =========================================================================
+
+ describe('Renderer.begin', () => {
+ it('should copy viewProjection to HEAPF32 and call renderer_begin', () => {
+ const vp = new Float32Array(16);
+ for (let i = 0; i < 16; i++) vp[i] = i + 1;
+
+ Renderer.begin(vp);
+
+ const ptr = 64;
+ const offset = ptr / 4;
+ for (let i = 0; i < 16; i++) {
+ expect(mock.HEAPF32[offset + i]).toBe(i + 1);
+ }
+ expect(mock.renderer_begin).toHaveBeenCalledWith(ptr, 0);
+ });
+
+ it('should default target to 0 when not specified', () => {
+ Renderer.begin(new Float32Array(16));
+ expect(mock.renderer_begin).toHaveBeenCalledWith(expect.any(Number), 0);
+ });
+
+ it('should pass target when specified', () => {
+ Renderer.begin(new Float32Array(16), 5);
+ expect(mock.renderer_begin).toHaveBeenCalledWith(expect.any(Number), 5);
+ });
+ });
+
+ // =========================================================================
+ // Renderer.flush
+ // =========================================================================
+
+ describe('Renderer.flush', () => {
+ it('should call renderer_flush', () => {
+ Renderer.flush();
+ expect(mock.renderer_flush).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // Renderer.end
+ // =========================================================================
+
+ describe('Renderer.end', () => {
+ it('should call renderer_end', () => {
+ Renderer.end();
+ expect(mock.renderer_end).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // Renderer.submitSprites
+ // =========================================================================
+
+ describe('Renderer.submitSprites', () => {
+ it('should call renderer_submitSprites with registry._cpp', () => {
+ const registry = { _cpp: 99 as any };
+ Renderer.submitSprites(registry);
+ expect(mock.renderer_submitSprites).toHaveBeenCalledWith(99);
+ });
+ });
+
+ // =========================================================================
+ // Renderer.submitBitmapText
+ // =========================================================================
+
+ describe('Renderer.submitBitmapText', () => {
+ it('should call renderer_submitBitmapText with registry._cpp', () => {
+ const registry = { _cpp: 77 as any };
+ Renderer.submitBitmapText(registry);
+ expect(mock.renderer_submitBitmapText).toHaveBeenCalledWith(77);
+ });
+ });
+
+ // =========================================================================
+ // Renderer.submitSpine
+ // =========================================================================
+
+ describe('Renderer.submitSpine', () => {
+ it('should call renderer_submitSpine with registry._cpp', () => {
+ const registry = { _cpp: 55 as any };
+ Renderer.submitSpine(registry);
+ expect(mock.renderer_submitSpine).toHaveBeenCalledWith(55);
+ });
+ });
+
+ // =========================================================================
+ // RenderTarget lifecycle
+ // =========================================================================
+
+ describe('RenderTarget lifecycle', () => {
+ it('should create render target and return handle from WASM', () => {
+ const handle = Renderer.createRenderTarget(256, 256);
+ expect(handle).toBe(42);
+ expect(mock.renderer_createTarget).toHaveBeenCalledWith(256, 256, 1);
+ });
+
+ it('should default flags to 1', () => {
+ Renderer.createRenderTarget(128, 128);
+ expect(mock.renderer_createTarget).toHaveBeenCalledWith(128, 128, 1);
+ });
+
+ it('should pass custom flags', () => {
+ Renderer.createRenderTarget(128, 128, 3);
+ expect(mock.renderer_createTarget).toHaveBeenCalledWith(128, 128, 3);
+ });
+
+ it('should release render target', () => {
+ const handle = Renderer.createRenderTarget(256, 256);
+ Renderer.releaseRenderTarget(handle);
+ expect(mock.renderer_releaseTarget).toHaveBeenCalledWith(handle);
+ });
+
+ it('should get target texture', () => {
+ const tex = Renderer.getTargetTexture(42);
+ expect(tex).toBe(100);
+ expect(mock.renderer_getTargetTexture).toHaveBeenCalledWith(42);
+ });
+
+ it('should get target depth texture', () => {
+ const depthTex = Renderer.getTargetDepthTexture(42);
+ expect(depthTex).toBe(200);
+ expect(mock.renderer_getTargetDepthTexture).toHaveBeenCalledWith(42);
+ });
+
+ it('should return 0 for createRenderTarget when uninitialized', () => {
+ shutdownRendererAPI();
+ expect(Renderer.createRenderTarget(256, 256)).toBe(0);
+ });
+
+ it('should return 0 for getTargetTexture when uninitialized', () => {
+ shutdownRendererAPI();
+ expect(Renderer.getTargetTexture(1)).toBe(0);
+ });
+
+ it('should return 0 for getTargetDepthTexture when uninitialized', () => {
+ shutdownRendererAPI();
+ expect(Renderer.getTargetDepthTexture(1)).toBe(0);
+ });
+ });
+
+ // =========================================================================
+ // Rendering state
+ // =========================================================================
+
+ describe('Rendering state', () => {
+ it('should call renderer_setClearColor', () => {
+ Renderer.setClearColor(0.1, 0.2, 0.3, 1.0);
+ expect(mock.renderer_setClearColor).toHaveBeenCalledWith(0.1, 0.2, 0.3, 1.0);
+ });
+
+ it('should call renderer_setViewport', () => {
+ Renderer.setViewport(0, 0, 800, 600);
+ expect(mock.renderer_setViewport).toHaveBeenCalledWith(0, 0, 800, 600);
+ });
+
+ it('should call renderer_setScissor', () => {
+ Renderer.setScissor(10, 20, 100, 200, true);
+ expect(mock.renderer_setScissor).toHaveBeenCalledWith(10, 20, 100, 200, true);
+ });
+
+ it('should call renderer_clearBuffers', () => {
+ Renderer.clearBuffers(7);
+ expect(mock.renderer_clearBuffers).toHaveBeenCalledWith(7);
+ });
+
+ it('should call renderer_setStage', () => {
+ Renderer.setStage(RenderStage.Transparent);
+ expect(mock.renderer_setStage).toHaveBeenCalledWith(RenderStage.Transparent);
+ });
+ });
+
+ // =========================================================================
+ // RenderStage enum
+ // =========================================================================
+
+ describe('RenderStage enum', () => {
+ it('should have correct values', () => {
+ expect(RenderStage.Background).toBe(0);
+ expect(RenderStage.Opaque).toBe(1);
+ expect(RenderStage.Transparent).toBe(2);
+ expect(RenderStage.Overlay).toBe(3);
+ });
+ });
+
+ // =========================================================================
+ // getStats
+ // =========================================================================
+
+ describe('Renderer.getStats', () => {
+ it('should aggregate stats from WASM calls', () => {
+ const stats = Renderer.getStats();
+ expect(stats).toEqual({
+ drawCalls: 10,
+ triangles: 500,
+ sprites: 25,
+ text: 5,
+ spine: 3,
+ meshes: 8,
+ culled: 12,
+ });
+ });
+
+ it('should call all stat getter functions', () => {
+ Renderer.getStats();
+ expect(mock.renderer_getDrawCalls).toHaveBeenCalledOnce();
+ expect(mock.renderer_getTriangles).toHaveBeenCalledOnce();
+ expect(mock.renderer_getSprites).toHaveBeenCalledOnce();
+ expect(mock.renderer_getText).toHaveBeenCalledOnce();
+ expect(mock.renderer_getSpine).toHaveBeenCalledOnce();
+ expect(mock.renderer_getMeshes).toHaveBeenCalledOnce();
+ expect(mock.renderer_getCulled).toHaveBeenCalledOnce();
+ });
+ });
+
+ // =========================================================================
+ // measureBitmapText
+ // =========================================================================
+
+ describe('Renderer.measureBitmapText', () => {
+ it('should proxy to getResourceManager().measureBitmapText()', () => {
+ const result = Renderer.measureBitmapText(1, 'hello', 16, 0);
+ expect(result).toEqual({ width: 120, height: 30 });
+ expect(mock.getResourceManager).toHaveBeenCalledOnce();
+ });
+
+ it('should pass all arguments to measureBitmapText', () => {
+ Renderer.measureBitmapText(7, 'test', 24, 2);
+ const rm = mock.getResourceManager.mock.results[0].value;
+ expect(rm.measureBitmapText).toHaveBeenCalledWith(7, 'test', 24, 2);
+ });
+ });
+
+ // =========================================================================
+ // HEAPF32 viewProjection copy
+ // =========================================================================
+
+ describe('HEAPF32 viewProjection copy', () => {
+ it('should write Float32Array values at correct offset', () => {
+ const vp = new Float32Array([
+ 1, 0, 0, 0,
+ 0, 1, 0, 0,
+ 0, 0, 1, 0,
+ 10, 20, 0, 1,
+ ]);
+
+ Renderer.begin(vp);
+
+ const ptr = 64;
+ const offset = ptr / 4;
+ expect(mock.HEAPF32[offset + 0]).toBe(1);
+ expect(mock.HEAPF32[offset + 5]).toBe(1);
+ expect(mock.HEAPF32[offset + 10]).toBe(1);
+ expect(mock.HEAPF32[offset + 12]).toBe(10);
+ expect(mock.HEAPF32[offset + 13]).toBe(20);
+ expect(mock.HEAPF32[offset + 15]).toBe(1);
+ });
+ });
+});