playground/src/scenes/sceneRunner.ts - dev - githubmirror/pixijs

playground/src/scenes/sceneRunner.ts
120 строк3 KB
Zyie
fix: stabilize HTMLText visual tests against CI flakiness (#12039)
06 май 2026, 14:50
06 май 2026, 14:500555280
import { Assets, autoDetectRenderer, Container, Graphics, Rectangle, TexturePool } from 'pixi.js';

import type { Renderer, RendererOptions } from 'pixi.js';
import type { TestScene } from '../../../tests/visual/types';
import type { RenderType } from '../types';

async function waitForPendingHTMLText(container: Container, renderer: Renderer): Promise<void>
{
    const promises: Promise<unknown>[] = [];

    const visit = (c: Container): void =>
    {
        if (c.renderPipeId === 'htmlText')
        {
            const gpuData = (c as unknown as {
                _gpuData: Record<number, { texturePromise?: Promise<unknown> }>,
            })._gpuData[renderer.uid];

            if (gpuData?.texturePromise) promises.push(gpuData.texturePromise.catch((): undefined => undefined));
        }

        c.children.forEach(visit);
    };

    visit(container);

    await Promise.all(promises);
}

const defaultRendererOptions = {
    width: 128,
    height: 128,
    backgroundColor: 0x1099bb,
};

const renderTypeSettings: Record<RenderType, Partial<RendererOptions>> = {
    webgpu: {
        preference: 'webgpu',
    } as Partial<RendererOptions>,
    webgl2: {
        preference: 'webgl',
        preferWebGLVersion: 2,
    } as Partial<RendererOptions>,
    webgl1: {
        preference: 'webgl',
        preferWebGLVersion: 1,
    } as Partial<RendererOptions>,
    canvas: {
        preference: 'canvas',
    } as Partial<RendererOptions>,
};

export interface RunResult
{
    canvas: HTMLCanvasElement;
    renderer: Renderer;
}

export async function runScene(
    scene: TestScene,
    rendererType: RenderType,
): Promise<RunResult>
{
    TexturePool.clear();
    Assets.reset();
    await Assets.init({ basePath: '/test-assets/' });

    const options = scene.options ?? {};
    const { width, height } = { ...defaultRendererOptions, ...options };

    const renderer = await autoDetectRenderer({
        ...defaultRendererOptions,
        ...options,
        ...renderTypeSettings[rendererType],
    });

    const stage = new Container();
    const sceneContainer = new Container();

    stage.addChild(new Graphics().rect(0, 0, width, height)).fill(renderer.background.color);
    stage.addChild(sceneContainer);

    await scene.create(sceneContainer, renderer);
    await waitForPendingHTMLText(stage, renderer);

    const canvas = renderer.extract.canvas({
        target: stage,
        frame: new Rectangle(0, 0, width, height),
    }) as HTMLCanvasElement;

    return { canvas, renderer };
}

export function getEnabledRenderers(scene: TestScene): Record<RenderType, boolean>
{
    const defaults: Record<RenderType, boolean> = {
        webgpu: true,
        webgl1: true,
        webgl2: true,
        canvas: true,
    };

    const fromRenderers = Array.isArray(scene.renderers)
        ? scene.renderers.reduce((acc, r) =>
        {
            acc[r] = true;

            return acc;
        }, { webgpu: false, webgl1: false, webgl2: false, canvas: false } as Record<RenderType, boolean>)
        : scene.renderers;

    const fromExclude = scene.excludeRenderers?.reduce((acc, r) =>
    {
        acc[r] = false;

        return acc;
    }, {} as Record<RenderType, boolean>) ?? {};

    return { ...defaults, ...fromRenderers, ...fromExclude };
}