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, beforeEach, afterEach, vi } from 'vitest';
let generation = 1;
vi.mock('../src/render/renderer', () => ({
deviceGeneration: () => generation,
Renderer: {
createRenderTarget: vi.fn().mockReturnValue(1),
releaseRenderTarget: vi.fn(),
getTargetTexture: vi.fn().mockReturnValue(100),
getTargetDepthTexture: vi.fn().mockReturnValue(200),
begin: vi.fn(),
end: vi.fn(),
},
}));
import { RenderTexture } from '../src/render/renderTexture';
import { Renderer } from '../src/render/renderer';
import { initResourceManager, shutdownResourceManager } from '../src/wasm/resourceManager';
import type { CppResourceManager } from '../src/wasm';
describe('RenderTexture', () => {
beforeEach(() => {
vi.clearAllMocks();
(Renderer.createRenderTarget as ReturnType<typeof vi.fn>).mockReturnValue(1);
(Renderer.getTargetTexture as ReturnType<typeof vi.fn>).mockReturnValue(100);
(Renderer.getTargetDepthTexture as ReturnType<typeof vi.fn>).mockReturnValue(200);
});
describe('create', () => {
it('uses depth=true by default, producing flags=1', () => {
RenderTexture.create({ width: 256, height: 256 });
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(256, 256, 1);
});
it('sets flags=0 when depth=false', () => {
RenderTexture.create({ width: 128, height: 128, depth: false });
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(128, 128, 0);
});
it('sets flags=3 when depth=true and filter=linear', () => {
RenderTexture.create({ width: 64, height: 64, depth: true, filter: 'linear' });
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(64, 64, 3);
});
it('sets flags=2 when depth=false and filter=linear', () => {
RenderTexture.create({ width: 64, height: 64, depth: false, filter: 'linear' });
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(64, 64, 2);
});
it('sets flags=1 when filter=nearest (default depth)', () => {
RenderTexture.create({ width: 64, height: 64, filter: 'nearest' });
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(64, 64, 1);
});
it('returns a RenderTextureHandle with correct fields', () => {
const rt = RenderTexture.create({ width: 512, height: 512 });
expect(rt).toEqual({
_handle: 1,
textureId: 100,
texture: 0,
width: 512,
height: 512,
_depth: true,
_filter: 'nearest',
_generation: generation,
});
});
it('stores depth and filter in handle for resize', () => {
const rt = RenderTexture.create({ width: 64, height: 64, depth: false, filter: 'linear' });
expect(rt._depth).toBe(false);
expect(rt._filter).toBe('linear');
});
it('queries textureId from the created handle', () => {
(Renderer.createRenderTarget as ReturnType<typeof vi.fn>).mockReturnValue(42);
RenderTexture.create({ width: 256, height: 256 });
expect(Renderer.getTargetTexture).toHaveBeenCalledWith(42);
});
});
describe('release', () => {
it('calls releaseRenderTarget with the correct handle', () => {
const rt = RenderTexture.create({ width: 256, height: 256 });
RenderTexture.release(rt);
expect(Renderer.releaseRenderTarget).toHaveBeenCalledWith(rt._handle);
});
it('can be called on different handles', () => {
(Renderer.createRenderTarget as ReturnType<typeof vi.fn>).mockReturnValueOnce(10).mockReturnValueOnce(20);
const rt1 = RenderTexture.create({ width: 64, height: 64 });
const rt2 = RenderTexture.create({ width: 128, height: 128 });
RenderTexture.release(rt1);
RenderTexture.release(rt2);
expect(Renderer.releaseRenderTarget).toHaveBeenCalledWith(10);
expect(Renderer.releaseRenderTarget).toHaveBeenCalledWith(20);
});
});
describe('resize', () => {
it('releases old target then creates a new one', () => {
const callOrder: string[] = [];
(Renderer.releaseRenderTarget as ReturnType<typeof vi.fn>).mockImplementation(() => callOrder.push('release'));
(Renderer.createRenderTarget as ReturnType<typeof vi.fn>).mockImplementation(() => {
callOrder.push('create');
return 2;
});
const rt = { _handle: 1, textureId: 100, texture: 0, width: 256, height: 256, _depth: true, _filter: 'nearest' as const, _generation: generation };
RenderTexture.resize(rt, 512, 512);
expect(callOrder).toEqual(['release', 'create']);
expect(Renderer.releaseRenderTarget).toHaveBeenCalledWith(1);
});
it('returns a new handle with updated dimensions', () => {
(Renderer.createRenderTarget as ReturnType<typeof vi.fn>).mockReturnValue(5);
(Renderer.getTargetTexture as ReturnType<typeof vi.fn>).mockReturnValue(500);
const rt = { _handle: 1, textureId: 100, texture: 0, width: 256, height: 256, _depth: true, _filter: 'nearest' as const, _generation: generation };
const resized = RenderTexture.resize(rt, 1024, 768);
expect(resized).toEqual({
_handle: 5,
textureId: 500,
texture: 0,
width: 1024,
height: 768,
_depth: true,
_filter: 'nearest',
_generation: generation,
});
});
it('preserves depth=false and filter=linear through resize', () => {
const rt = { _handle: 1, textureId: 100, texture: 0, width: 64, height: 64, _depth: false, _filter: 'linear' as const, _generation: generation };
RenderTexture.resize(rt, 128, 128);
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(128, 128, 2);
});
it('preserves depth=true and filter=nearest through resize', () => {
const rt = { _handle: 1, textureId: 100, texture: 0, width: 64, height: 64, _depth: true, _filter: 'nearest' as const, _generation: generation };
RenderTexture.resize(rt, 128, 128);
expect(Renderer.createRenderTarget).toHaveBeenCalledWith(128, 128, 1);
});
});
describe('resize with a live resource manager', () => {
let wrapDeviceTexture: ReturnType<typeof vi.fn>;
let releaseTexture: ReturnType<typeof vi.fn>;
beforeEach(() => {
let nextTexture = 700;
wrapDeviceTexture = vi.fn(() => nextTexture++);
releaseTexture = vi.fn();
initResourceManager({
wrapDeviceTexture,
releaseTexture,
getTextureDimensions: vi.fn(),
} as unknown as CppResourceManager);
});
afterEach(() => {
shutdownResourceManager();
});
it('releases the old texture-table entry on resize', () => {
const rt = RenderTexture.create({ width: 64, height: 64 });
expect(rt.texture).toBe(700);
RenderTexture.resize(rt, 128, 128);
expect(releaseTexture).toHaveBeenCalledWith(700);
});
it('returns a fresh texture handle after resize', () => {
const rt = RenderTexture.create({ width: 64, height: 64 });
const resized = RenderTexture.resize(rt, 128, 128);
expect(resized.texture).toBe(701);
expect(wrapDeviceTexture).toHaveBeenCalledTimes(2);
});
});
describe('begin / end', () => {
it('calls Renderer.begin with viewProjection and handle', () => {
const vp = new Float32Array(16);
const rt = { _handle: 7, textureId: 100, texture: 0, width: 256, height: 256, _depth: true, _filter: 'nearest' as const, _generation: generation };
RenderTexture.begin(rt, vp);
expect(Renderer.begin).toHaveBeenCalledWith(vp, 7);
});
it('calls Renderer.end', () => {
RenderTexture.end();
expect(Renderer.end).toHaveBeenCalled();
});
it('passes arguments in correct order (viewProjection first, handle second)', () => {
const vp = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
const rt = { _handle: 3, textureId: 100, texture: 0, width: 128, height: 128, _depth: true, _filter: 'nearest' as const, _generation: generation };
RenderTexture.begin(rt, vp);
const call = (Renderer.begin as ReturnType<typeof vi.fn>).mock.calls[0];
expect(call[0]).toBe(vp);
expect(call[1]).toBe(3);
});
});
describe('getDepthTexture', () => {
it('proxies to Renderer.getTargetDepthTexture with correct handle', () => {
const rt = { _handle: 9, textureId: 100, texture: 0, width: 256, height: 256, _depth: true, _filter: 'nearest' as const, _generation: generation };
RenderTexture.getDepthTexture(rt);
expect(Renderer.getTargetDepthTexture).toHaveBeenCalledWith(9);
});
it('returns the value from Renderer', () => {
(Renderer.getTargetDepthTexture as ReturnType<typeof vi.fn>).mockReturnValue(999);
const rt = { _handle: 9, textureId: 100, texture: 0, width: 256, height: 256, _depth: true, _filter: 'nearest' as const, _generation: generation };
const result = RenderTexture.getDepthTexture(rt);
expect(result).toBe(999);
});
});
describe('content after a device loss', () => {
it('says its pixels are gone once the device is rebuilt, until they are drawn again', () => {
generation = 1;
const rt = RenderTexture.create({ width: 32, height: 32 });
expect(RenderTexture.contentLost(rt)).toBe(false);
// What a loss leaves: the storage is back, zero-filled, and only
// whoever drew the pixels can put them there.
generation = 2;
expect(RenderTexture.contentLost(rt)).toBe(true);
RenderTexture.contentDrawn(rt);
expect(RenderTexture.contentLost(rt)).toBe(false);
generation = 3;
expect(RenderTexture.contentLost(rt)).toBe(true);
});
it('a target made after the loss is not born lost', () => {
generation = 5;
const rt = RenderTexture.create({ width: 8, height: 8 });
expect(RenderTexture.contentLost(rt)).toBe(false);
});
});
});