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.
TypeScript 2d-game-engine3d3d-game-engineandroidcppecsgame-editorgame-enginegamedeviostypescriptwebassemblywebglwebgpuwechat-minigame
test: add TDD tests for rendering pipeline core modules
esenginec0076d5281bd
diff --git a/sdk/tests/draw.test.ts b/sdk/tests/draw.test.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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);+ });+ });+});