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
// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
import { describe, it, expect, vi, beforeEach } from 'vitest';
vi.mock('../src/render/material', () => ({
Material: {
createFromAsset: vi.fn().mockReturnValue(11),
setUniform: vi.fn(),
tex: vi.fn((handle: number) => ({ kind: 'tex', handle })),
compileShader: vi.fn().mockReturnValue(7),
noteProgram: vi.fn(),
releaseShader: vi.fn(),
release: vi.fn(),
},
}));
import { MaterialAssetLoader } from '../src/asset/loaders/MaterialAssetLoader';
import { MaterialShaderAssetLoader } from '../src/asset/loaders/MaterialShaderAssetLoader';
import { Material } from '../src/render/material';
import type { LoadContext } from '../src/asset/AssetLoader';
const MAT_PATH = 'assets/materials/foo.esmaterial';
const TEX_REF = 'missing.png';
function withShaderSource(ctx: LoadContext): LoadContext {
const loader = new MaterialShaderAssetLoader();
ctx.acquireAsset = vi.fn(async (_type: string, path: string) => {
const value = await loader.load(path, ctx);
return { key: path, generation: 1, value, release: () => loader.unload(value), retain: () => null };
}) as LoadContext['acquireAsset'];
return ctx;
}
function makeCtx(): LoadContext {
const materialJson = JSON.stringify({
type: 'material',
shader: 'fx.esshader',
properties: { mainTex: TEX_REF },
});
return withShaderSource({
catalog: { getBuildPath: (p: string) => p },
loadText: vi.fn(async (p: string) => (p.endsWith('.esmaterial') ? materialJson : '// shader src')),
acquireTexture: vi.fn().mockRejectedValue(new Error('404 not found')),
} as unknown as LoadContext);
}
describe('MaterialAssetLoader texture failure', () => {
beforeEach(() => {
vi.clearAllMocks();
(Material.createFromAsset as ReturnType<typeof vi.fn>).mockReturnValue(11);
(Material.compileShader as ReturnType<typeof vi.fn>).mockReturnValue(7);
});
it('still resolves the material and leaves the param unbound', async () => {
const loader = new MaterialAssetLoader();
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
const result = await loader.load(MAT_PATH, makeCtx());
expect(result.handle).toBe(11);
expect(Material.setUniform).not.toHaveBeenCalled();
warnSpy.mockRestore();
});
it('warns with the material path and the texture path', async () => {
const loader = new MaterialAssetLoader();
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
await loader.load(MAT_PATH, makeCtx());
const combined = warnSpy.mock.calls.map(c => String(c[0])).join('\n');
expect(combined).toContain(MAT_PATH);
expect(combined).toContain('assets/materials/missing.png');
warnSpy.mockRestore();
});
});
describe('MaterialAssetLoader says what a half-loaded material is missing', () => {
beforeEach(() => {
vi.clearAllMocks();
(Material.createFromAsset as ReturnType<typeof vi.fn>).mockReturnValue(11);
(Material.compileShader as ReturnType<typeof vi.fn>).mockReturnValue(7);
});
it('reports a texture that would not load, against the material, by param name', async () => {
const loader = new MaterialAssetLoader();
const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
const ctx = makeCtx();
const noted = vi.fn();
ctx.noteAssetProblems = noted;
await loader.load(MAT_PATH, ctx);
expect(noted).toHaveBeenCalledTimes(1);
const [asset, problems] = noted.mock.calls[0] as [string, string[]];
expect(asset).toBe(MAT_PATH);
expect(problems).toHaveLength(1);
expect(problems[0]).toMatch(/^mainTex: the texture "assets\/materials\/missing\.png" did not load \(404 not found\)/);
warnSpy.mockRestore();
});
});
describe('MaterialAssetLoader ownership on unload', () => {
beforeEach(() => {
vi.clearAllMocks();
(Material.createFromAsset as ReturnType<typeof vi.fn>).mockReturnValue(11);
(Material.compileShader as ReturnType<typeof vi.fn>).mockReturnValue(7);
});
function makeCtxWithTexture() {
const materialJson = JSON.stringify({
type: 'material', shader: 'fx.esshader', properties: { mainTex: TEX_REF },
});
const released: Array<{ key: string; generation: number }> = [];
let generation = 0;
const ctx = {
catalog: { getBuildPath: (p: string) => p },
loadText: vi.fn(async (p: string) => (p.endsWith('.esmaterial') ? materialJson : '// shader src')),
acquireTexture: vi.fn(async (path: string) => {
const lease = {
key: `texture:${path}`, generation: ++generation, value: { handle: 42 },
release: () => released.push({ key: lease.key, generation: lease.generation }),
};
return lease;
}),
} as unknown as LoadContext;
return { ctx: withShaderSource(ctx), released };
}
it('destroys what it made and gives back nothing it acquired', async () => {
// The era that acquired it gives it back; releasing here frees it twice.
// That it DOES come back is asserted in asset-dependencies.test.ts.
const loader = new MaterialAssetLoader();
const { ctx, released } = makeCtxWithTexture();
const result = await loader.load(MAT_PATH, ctx);
expect(Material.setUniform).toHaveBeenCalled();
loader.unload(result);
expect(released, 'the loader released a receipt it does not own').toEqual([]);
expect(Material.release).toHaveBeenCalledWith(11);
});
});
describe('MaterialAssetLoader built-in shader ref', () => {
beforeEach(() => {
vi.clearAllMocks();
(Material.createFromAsset as ReturnType<typeof vi.fn>).mockReturnValue(11);
(Material.compileShader as ReturnType<typeof vi.fn>).mockReturnValue(7);
});
function ctxFor(shader: string): LoadContext {
const materialJson = JSON.stringify({ type: 'material', shader, properties: {} });
return withShaderSource({
catalog: { getBuildPath: (p: string) => p },
// Only the material is ever read — a built-in shader has no file.
loadText: vi.fn(async () => materialJson),
loadTexture: vi.fn(),
} as unknown as LoadContext);
}
it('compiles a `builtin:<id>` shader from its in-code template, reading no shader file', async () => {
const loader = new MaterialAssetLoader();
const ctx = ctxFor('builtin:sprite-unlit');
const result = await loader.load(MAT_PATH, ctx);
expect(result.shaderHandle).toBe(7);
expect(ctx.loadText).toHaveBeenCalledTimes(1); // the material, never a shader file
const compiledSrc = (Material.compileShader as ReturnType<typeof vi.fn>).mock.calls[0][0] as string;
expect(compiledSrc).toContain('#pragma shader "Sprite Unlit"');
});
it('throws on an unknown built-in shader id', async () => {
const loader = new MaterialAssetLoader();
await expect(loader.load(MAT_PATH, ctxFor('builtin:does-not-exist'))).rejects.toThrow(/Unknown built-in shader/);
});
});