Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

test(render): fill coverage for customDraw, SpriteFilter, textureParams

esengine8053e2132661
diff --git a/sdk/tests/custom-draw.test.ts b/sdk/tests/custom-draw.test.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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,
+ }]);
+ });
+});