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(render): fill coverage for customDraw, SpriteFilter, textureParams
esengine8053e2132661
diff --git a/sdk/tests/custom-draw.test.ts b/sdk/tests/custom-draw.test.tsnew file mode 100644index 000000000..141ad6cfb--- /dev/null+++ b/sdk/tests/custom-draw.test.ts@@ -0,0 +1,72 @@+/**+ * @file custom-draw.test.ts+ * @brief Draw-callback registry: register/unregister, scene scoping.+ */+import { describe, expect, it, beforeEach } from 'vitest';+import {+ registerDrawCallback,+ unregisterDrawCallback,+ clearDrawCallbacks,+ clearSceneDrawCallbacks,+ getDrawCallbacks,+} from '../src/customDraw';++describe('customDraw callback registry', () => {+ beforeEach(() => {+ clearDrawCallbacks();+ });++ it('registers a callback and returns it via getDrawCallbacks', () => {+ const fn = () => { /* noop */ };+ registerDrawCallback('id-1', fn);+ const all = getDrawCallbacks();+ expect(all.size).toBe(1);+ expect(all.get('id-1')?.fn).toBe(fn);+ expect(all.get('id-1')?.scene).toBe('');+ });++ it('associates a scene name when provided', () => {+ registerDrawCallback('id-1', () => { /* noop */ }, 'level1');+ expect(getDrawCallbacks().get('id-1')?.scene).toBe('level1');+ });++ it('overwrites when re-registering the same id', () => {+ const a = () => { /* noop */ };+ const b = () => { /* noop */ };+ registerDrawCallback('id-1', a);+ registerDrawCallback('id-1', b);+ expect(getDrawCallbacks().get('id-1')?.fn).toBe(b);+ expect(getDrawCallbacks().size).toBe(1);+ });++ it('unregisters by id', () => {+ registerDrawCallback('id-1', () => { /* noop */ });+ registerDrawCallback('id-2', () => { /* noop */ });+ unregisterDrawCallback('id-1');+ const all = getDrawCallbacks();+ expect(all.has('id-1')).toBe(false);+ expect(all.has('id-2')).toBe(true);+ });++ it('clearSceneDrawCallbacks removes only the named scene', () => {+ registerDrawCallback('global', () => { /* noop */ });+ registerDrawCallback('scene-a-1', () => { /* noop */ }, 'sceneA');+ registerDrawCallback('scene-a-2', () => { /* noop */ }, 'sceneA');+ registerDrawCallback('scene-b-1', () => { /* noop */ }, 'sceneB');++ clearSceneDrawCallbacks('sceneA');++ const all = getDrawCallbacks();+ expect(all.has('global')).toBe(true);+ expect(all.has('scene-a-1')).toBe(false);+ expect(all.has('scene-a-2')).toBe(false);+ expect(all.has('scene-b-1')).toBe(true);+ });++ it('clearDrawCallbacks removes everything', () => {+ registerDrawCallback('a', () => { /* noop */ });+ registerDrawCallback('b', () => { /* noop */ }, 'x');+ clearDrawCallbacks();+ expect(getDrawCallbacks().size).toBe(0);+ });+});diff --git a/sdk/tests/sprite-filter.test.ts b/sdk/tests/sprite-filter.test.tsnew file mode 100644index 000000000..73815afae--- /dev/null+++ b/sdk/tests/sprite-filter.test.ts@@ -0,0 +1,157 @@+/**+ * @file sprite-filter.test.ts+ * @brief SpriteFilter creates outline/glow/drop-shadow materials with+ * the expected uniforms seeded on Material.create/setUniform.+ */+import { describe, expect, it, vi, beforeEach } from 'vitest';++const materialCalls: Array<+ | { kind: 'createShader' }+ | { kind: 'create'; shader: number }+ | { kind: 'setUniform'; material: number; name: string; value: unknown }+> = [];++let nextShaderId = 100;+let nextMaterialId = 1000;++vi.mock('../src/material', () => {+ return {+ Material: {+ createShader: vi.fn(() => {+ materialCalls.push({ kind: 'createShader' });+ return nextShaderId++;+ }),+ create: vi.fn((opts: { shader: number }) => {+ materialCalls.push({ kind: 'create', shader: opts.shader });+ return nextMaterialId++;+ }),+ setUniform: vi.fn((material: number, name: string, value: unknown) => {+ materialCalls.push({ kind: 'setUniform', material, name, value });+ }),+ },+ };+});++import { SpriteFilter } from '../src/spriteFilter';++beforeEach(() => {+ materialCalls.length = 0;+});++describe('SpriteFilter.createOutline', () => {+ it('creates a material with a freshly compiled shader, color/width/texelSize uniforms', () => {+ const handle = SpriteFilter.createOutline({+ color: { r: 1, g: 0.5, b: 0.25, a: 0.8 },+ width: 3,+ texelSize: { x: 1 / 256, y: 1 / 256 },+ });++ expect(typeof handle).toBe('number');+ expect(materialCalls.some(c => c.kind === 'createShader')).toBe(true);+ expect(materialCalls.some(c => c.kind === 'create')).toBe(true);++ const setUniforms = materialCalls.filter(+ (c): c is { kind: 'setUniform'; material: number; name: string; value: unknown } =>+ c.kind === 'setUniform',+ );+ const byName = new Map(setUniforms.map(c => [c.name, c.value]));+ expect(byName.get('u_outlineColor')).toEqual([1, 0.5, 0.25, 0.8]);+ expect(byName.get('u_outlineWidth')).toBe(3);+ expect(byName.get('u_texelSize')).toEqual([1 / 256, 1 / 256]);+ });++ it('falls back to documented defaults when options are omitted', () => {+ SpriteFilter.createOutline();+ const byName = new Map(+ materialCalls+ .filter((c): c is { kind: 'setUniform'; material: number; name: string; value: unknown } =>+ c.kind === 'setUniform',+ )+ .map(c => [c.name, c.value]),+ );+ expect(byName.get('u_outlineColor')).toEqual([1, 1, 1, 1]);+ expect(byName.get('u_outlineWidth')).toBe(1.0);+ });+});++describe('SpriteFilter.createGlow', () => {+ it('uses warm default color and wider outline', () => {+ SpriteFilter.createGlow();+ const byName = new Map(+ materialCalls+ .filter((c): c is { kind: 'setUniform'; material: number; name: string; value: unknown } =>+ c.kind === 'setUniform',+ )+ .map(c => [c.name, c.value]),+ );+ const color = byName.get('u_outlineColor') as number[];+ expect(color[0]).toBeCloseTo(1);+ expect(color[1]).toBeCloseTo(0.8);+ expect(color[2]).toBeCloseTo(0.2);+ expect(byName.get('u_outlineWidth')).toBe(2.0);+ });+});++describe('SpriteFilter.createDropShadow', () => {+ it('seeds shadow color, offset, blur, texelSize', () => {+ SpriteFilter.createDropShadow({+ color: { r: 0, g: 0, b: 0, a: 0.4 },+ offsetX: 5,+ offsetY: -2,+ blur: 4,+ });+ const byName = new Map(+ materialCalls+ .filter((c): c is { kind: 'setUniform'; material: number; name: string; value: unknown } =>+ c.kind === 'setUniform',+ )+ .map(c => [c.name, c.value]),+ );+ expect(byName.get('u_shadowColor')).toEqual([0, 0, 0, 0.4]);+ expect(byName.get('u_shadowOffset')).toEqual([5, -2]);+ expect(byName.get('u_shadowBlur')).toBe(4);+ expect(byName.has('u_texelSize')).toBe(true);+ });+});++describe('SpriteFilter mutator helpers', () => {+ it('setOutlineColor forwards to Material.setUniform', () => {+ SpriteFilter.setOutlineColor(42, { r: 1, g: 0, b: 0, a: 1 });+ expect(materialCalls).toContainEqual({+ kind: 'setUniform',+ material: 42,+ name: 'u_outlineColor',+ value: [1, 0, 0, 1],+ });+ });++ it('setOutlineWidth forwards', () => {+ SpriteFilter.setOutlineWidth(42, 7);+ expect(materialCalls).toContainEqual({+ kind: 'setUniform',+ material: 42,+ name: 'u_outlineWidth',+ value: 7,+ });+ });++ it('setShadowOffset forwards (x, y)', () => {+ SpriteFilter.setShadowOffset(42, 3, -1);+ expect(materialCalls).toContainEqual({+ kind: 'setUniform',+ material: 42,+ name: 'u_shadowOffset',+ value: [3, -1],+ });+ });++ it('setShadowBlur forwards', () => {+ SpriteFilter.setShadowBlur(42, 2.5);+ expect(materialCalls).toContainEqual({+ kind: 'setUniform',+ material: 42,+ name: 'u_shadowBlur',+ value: 2.5,+ });+ });+});diff --git a/sdk/tests/texture-params.test.ts b/sdk/tests/texture-params.test.tsnew file mode 100644index 000000000..81d343e61--- /dev/null+++ b/sdk/tests/texture-params.test.ts@@ -0,0 +1,92 @@+/**+ * @file texture-params.test.ts+ * @brief textureParams helpers delegate to Renderer.setTextureParams+ * with the right min/mag/wrap combinations.+ */+import { describe, expect, it, vi } from 'vitest';++const rendererCalls: Array<{+ textureId: number;+ minFilter: number;+ magFilter: number;+ wrapS: number;+ wrapT: number;+}> = [];++vi.mock('../src/renderer', () => ({+ Renderer: {+ setTextureParams: vi.fn((+ textureId: number,+ minFilter: number,+ magFilter: number,+ wrapS: number,+ wrapT: number,+ ) => {+ rendererCalls.push({ textureId, minFilter, magFilter, wrapS, wrapT });+ }),+ },+}));++import {+ TextureFilter,+ TextureWrap,+ setTextureFilter,+ setTextureWrap,+ setTextureParams,+} from '../src/textureParams';++describe('textureParams enums', () => {+ it('maps Nearest/Linear to 0/1', () => {+ expect(TextureFilter.Nearest).toBe(0);+ expect(TextureFilter.Linear).toBe(1);+ });++ it('maps wrap modes: Repeat=0, ClampToEdge=1, MirroredRepeat=2', () => {+ expect(TextureWrap.Repeat).toBe(0);+ expect(TextureWrap.ClampToEdge).toBe(1);+ expect(TextureWrap.MirroredRepeat).toBe(2);+ });+});++describe('setTextureFilter', () => {+ it('uses the given filter for both min and mag and ClampToEdge for both wraps', () => {+ rendererCalls.length = 0;+ setTextureFilter(7, TextureFilter.Nearest);+ expect(rendererCalls).toEqual([{+ textureId: 7,+ minFilter: TextureFilter.Nearest,+ magFilter: TextureFilter.Nearest,+ wrapS: TextureWrap.ClampToEdge,+ wrapT: TextureWrap.ClampToEdge,+ }]);+ });+});++describe('setTextureWrap', () => {+ it('uses Linear for both filters and the given wrap for both axes', () => {+ rendererCalls.length = 0;+ setTextureWrap(11, TextureWrap.MirroredRepeat);+ expect(rendererCalls).toEqual([{+ textureId: 11,+ minFilter: TextureFilter.Linear,+ magFilter: TextureFilter.Linear,+ wrapS: TextureWrap.MirroredRepeat,+ wrapT: TextureWrap.MirroredRepeat,+ }]);+ });+});++describe('setTextureParams', () => {+ it('passes every argument through verbatim', () => {+ rendererCalls.length = 0;+ setTextureParams(99, TextureFilter.Nearest, TextureFilter.Linear,+ TextureWrap.Repeat, TextureWrap.MirroredRepeat);+ expect(rendererCalls).toEqual([{+ textureId: 99,+ minFilter: TextureFilter.Nearest,+ magFilter: TextureFilter.Linear,+ wrapS: TextureWrap.Repeat,+ wrapT: TextureWrap.MirroredRepeat,+ }]);+ });+});