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.

10.7 KB
Raw Blame
// 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);
        });
    });
});