@elah/core 0.1.0

package/dist/renderer/gpu/debug/RecordingGl.d.ts

@@ -0,0 +1,88 @@
+export declare class RecordingGl {
+    private readonly _log;
+    private _handleCounter;
+    private _boundProgram;
+    private _boundVao;
+    private _activeTexture;
+    private _boundTextures;
+    get log(): Uint8Array;
+    reset(): void;
+    digest(): Promise<string>;
+    texImage2D(_target: number, _level: number, _internalformat: number, widthOrFormat: number, heightOrType: number, borderOrSource: unknown, format?: number, _type?: number, _source?: unknown): void;
+    drawArrays(mode: number, _first: number, count: number): void;
+    uniformMatrix3fv(location: WebGLUniformLocation | null, _transpose: boolean, value: Float32Array | number[]): void;
+    uniform1f(location: WebGLUniformLocation | null, x: number): void;
+    uniform1i(location: WebGLUniformLocation | null, x: number): void;
+    uniform2f(location: WebGLUniformLocation | null, x: number, y: number): void;
+    clear(_mask: number): void;
+    useProgram(program: WebGLProgram | null): void;
+    bindVertexArray(vao: WebGLVertexArrayObject | null): void;
+    bindTexture(_target: number, texture: WebGLTexture | null): void;
+    texParameteri(_target: number, pname: number, param: number): void;
+    activeTexture(texture: number): void;
+    createProgram(): WebGLProgram;
+    createShader(_type: number): WebGLShader;
+    createTexture(): WebGLTexture;
+    createVertexArray(): WebGLVertexArrayObject;
+    createBuffer(): WebGLBuffer;
+    shaderSource(_shader: WebGLShader, _source: string): void;
+    compileShader(_shader: WebGLShader): void;
+    getShaderParameter(_shader: WebGLShader, _pname: number): unknown;
+    getShaderInfoLog(_shader: WebGLShader): string;
+    attachShader(_program: WebGLProgram, _shader: WebGLShader): void;
+    detachShader(_program: WebGLProgram, _shader: WebGLShader): void;
+    linkProgram(_program: WebGLProgram): void;
+    getProgramParameter(_program: WebGLProgram, _pname: number): unknown;
+    getProgramInfoLog(_program: WebGLProgram): string;
+    deleteShader(_shader: WebGLShader | null): void;
+    deleteProgram(_program: WebGLProgram | null): void;
+    deleteTexture(_texture: WebGLTexture | null): void;
+    deleteVertexArray(_vao: WebGLVertexArrayObject | null): void;
+    deleteBuffer(_buffer: WebGLBuffer | null): void;
+    getUniformLocation(_program: WebGLProgram, name: string): WebGLUniformLocation;
+    getAttribLocation(_program: WebGLProgram, _name: string): number;
+    enableVertexAttribArray(_index: number): void;
+    vertexAttribPointer(_index: number, _size: number, _type: number, _normalized: boolean, _stride: number, _offset: number): void;
+    bindBuffer(_target: number, _buffer: WebGLBuffer | null): void;
+    bufferData(_target: number, _data: unknown, _usage: number): void;
+    viewport(_x: number, _y: number, _width: number, _height: number): void;
+    clearColor(_r: number, _g: number, _b: number, _a: number): void;
+    enable(_cap: number): void;
+    blendFuncSeparate(_srcRGB: number, _dstRGB: number, _srcAlpha: number, _dstAlpha: number): void;
+    getContextAttributes(): WebGLContextAttributes;
+    isContextLost(): boolean;
+    generateMipmap(_target: number): void;
+    pixelStorei(_pname: number, _param: number): void;
+    readonly TEXTURE_2D = 3553;
+    readonly TRIANGLE_STRIP = 5;
+    readonly ARRAY_BUFFER = 34962;
+    readonly STATIC_DRAW = 34996;
+    readonly FLOAT = 5126;
+    readonly UNSIGNED_BYTE = 5121;
+    readonly RGBA = 6408;
+    readonly COLOR_BUFFER_BIT = 16384;
+    readonly VERTEX_SHADER = 35633;
+    readonly FRAGMENT_SHADER = 35632;
+    readonly LINK_STATUS = 35714;
+    readonly COMPILE_STATUS = 35713;
+    readonly TEXTURE0 = 33984;
+    readonly TEXTURE_MIN_FILTER = 10241;
+    readonly TEXTURE_MAG_FILTER = 10240;
+    readonly LINEAR = 9729;
+    readonly TEXTURE_WRAP_S = 10242;
+    readonly TEXTURE_WRAP_T = 10243;
+    readonly CLAMP_TO_EDGE = 33071;
+    readonly BLEND = 3042;
+    readonly ONE = 1;
+    readonly ONE_MINUS_SRC_ALPHA = 771;
+    readonly SRC_ALPHA = 770;
+    readonly UNPACK_FLIP_Y_WEBGL = 37440;
+    private _write;
+    private _writeUint32;
+    private _writeFloat32;
+    private _makeHandle;
+    private _locationId;
+    private readonly _nameMap;
+    private _nameCounter;
+    private _stableNameId;
+}

package/dist/renderer/gpu/debug/RecordingGl.js

@@ -0,0 +1,214 @@
+var Tag;
+(function (Tag) {
+    Tag[Tag["TexImage2D"] = 1] = "TexImage2D";
+    Tag[Tag["DrawArrays"] = 2] = "DrawArrays";
+    Tag[Tag["UniformMatrix3fv"] = 3] = "UniformMatrix3fv";
+    Tag[Tag["Uniform1f"] = 4] = "Uniform1f";
+    Tag[Tag["Uniform1i"] = 5] = "Uniform1i";
+    Tag[Tag["Clear"] = 6] = "Clear";
+    Tag[Tag["UseProgram"] = 7] = "UseProgram";
+    Tag[Tag["BindVertexArray"] = 8] = "BindVertexArray";
+    Tag[Tag["BindTexture"] = 9] = "BindTexture";
+    Tag[Tag["TexParameteri"] = 10] = "TexParameteri";
+})(Tag || (Tag = {}));
+export class RecordingGl {
+    constructor() {
+        this._log = [];
+        this._handleCounter = 1;
+        this._boundProgram = 0;
+        this._boundVao = 0;
+        this._activeTexture = 0;
+        this._boundTextures = new Map();
+        this.TEXTURE_2D = 0x0de1;
+        this.TRIANGLE_STRIP = 0x0005;
+        this.ARRAY_BUFFER = 0x8892;
+        this.STATIC_DRAW = 0x88b4;
+        this.FLOAT = 0x1406;
+        this.UNSIGNED_BYTE = 0x1401;
+        this.RGBA = 0x1908;
+        this.COLOR_BUFFER_BIT = 0x4000;
+        this.VERTEX_SHADER = 0x8b31;
+        this.FRAGMENT_SHADER = 0x8b30;
+        this.LINK_STATUS = 0x8b82;
+        this.COMPILE_STATUS = 0x8b81;
+        this.TEXTURE0 = 0x84c0;
+        this.TEXTURE_MIN_FILTER = 0x2801;
+        this.TEXTURE_MAG_FILTER = 0x2800;
+        this.LINEAR = 0x2601;
+        this.TEXTURE_WRAP_S = 0x2802;
+        this.TEXTURE_WRAP_T = 0x2803;
+        this.CLAMP_TO_EDGE = 0x812f;
+        this.BLEND = 0x0be2;
+        this.ONE = 1;
+        this.ONE_MINUS_SRC_ALPHA = 0x0303;
+        this.SRC_ALPHA = 0x0302;
+        this.UNPACK_FLIP_Y_WEBGL = 0x9240;
+        this._nameMap = new Map();
+        this._nameCounter = 1;
+    }
+    get log() {
+        return new Uint8Array(this._log);
+    }
+    reset() {
+        this._log.length = 0;
+        this._handleCounter = 1;
+        this._boundProgram = 0;
+        this._boundVao = 0;
+        this._activeTexture = 0;
+        this._boundTextures.clear();
+        this._nameMap.clear();
+        this._nameCounter = 1;
+    }
+    async digest() {
+        const bytes = new Uint8Array(this._log);
+        const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
+        return Array.from(new Uint8Array(hashBuffer))
+            .map((b) => b.toString(16).padStart(2, '0'))
+            .join('');
+    }
+    texImage2D(_target, _level, _internalformat, widthOrFormat, heightOrType, borderOrSource, format, _type, _source) {
+        this._write([Tag.TexImage2D]);
+        if (format !== undefined) {
+            this._writeUint32(widthOrFormat);
+            this._writeUint32(heightOrType);
+            this._writeUint32(format);
+        }
+        else {
+            this._writeUint32(widthOrFormat);
+            this._writeUint32(heightOrType);
+            void borderOrSource;
+        }
+    }
+    drawArrays(mode, _first, count) {
+        this._write([Tag.DrawArrays]);
+        this._writeUint32(mode);
+        this._writeUint32(count);
+    }
+    uniformMatrix3fv(location, _transpose, value) {
+        this._write([Tag.UniformMatrix3fv]);
+        this._writeUint32(this._locationId(location));
+        for (const v of value) {
+            this._writeFloat32(v);
+        }
+    }
+    uniform1f(location, x) {
+        this._write([Tag.Uniform1f]);
+        this._writeUint32(this._locationId(location));
+        this._writeFloat32(x);
+    }
+    uniform1i(location, x) {
+        this._write([Tag.Uniform1i]);
+        this._writeUint32(this._locationId(location));
+        this._writeUint32(x);
+    }
+    uniform2f(location, x, y) {
+        this._write([Tag.Uniform1f, 0x02]);
+        this._writeUint32(this._locationId(location));
+        this._writeFloat32(x);
+        this._writeFloat32(y);
+    }
+    clear(_mask) {
+        this._write([Tag.Clear]);
+    }
+    useProgram(program) {
+        this._write([Tag.UseProgram]);
+        this._writeUint32(program ? program._id ?? 0 : 0);
+        this._boundProgram = program ? program._id ?? 0 : 0;
+    }
+    bindVertexArray(vao) {
+        this._write([Tag.BindVertexArray]);
+        this._writeUint32(vao ? vao._id ?? 0 : 0);
+        this._boundVao = vao ? vao._id ?? 0 : 0;
+    }
+    bindTexture(_target, texture) {
+        this._write([Tag.BindTexture]);
+        const id = texture ? texture._id ?? 0 : 0;
+        this._writeUint32(id);
+        this._boundTextures.set(this._activeTexture, id);
+    }
+    texParameteri(_target, pname, param) {
+        this._write([Tag.TexParameteri]);
+        this._writeUint32(pname);
+        this._writeUint32(param);
+    }
+    activeTexture(texture) {
+        this._activeTexture = texture;
+    }
+    createProgram() {
+        return this._makeHandle();
+    }
+    createShader(_type) {
+        return this._makeHandle();
+    }
+    createTexture() {
+        return this._makeHandle();
+    }
+    createVertexArray() {
+        return this._makeHandle();
+    }
+    createBuffer() {
+        return this._makeHandle();
+    }
+    shaderSource(_shader, _source) { }
+    compileShader(_shader) { }
+    getShaderParameter(_shader, _pname) { return true; }
+    getShaderInfoLog(_shader) { return ''; }
+    attachShader(_program, _shader) { }
+    detachShader(_program, _shader) { }
+    linkProgram(_program) { }
+    getProgramParameter(_program, _pname) { return true; }
+    getProgramInfoLog(_program) { return ''; }
+    deleteShader(_shader) { }
+    deleteProgram(_program) { }
+    deleteTexture(_texture) { }
+    deleteVertexArray(_vao) { }
+    deleteBuffer(_buffer) { }
+    getUniformLocation(_program, name) {
+        return { _id: this._stableNameId(name) };
+    }
+    getAttribLocation(_program, _name) { return 0; }
+    enableVertexAttribArray(_index) { }
+    vertexAttribPointer(_index, _size, _type, _normalized, _stride, _offset) { }
+    bindBuffer(_target, _buffer) { }
+    bufferData(_target, _data, _usage) { }
+    viewport(_x, _y, _width, _height) { }
+    clearColor(_r, _g, _b, _a) { }
+    enable(_cap) { }
+    blendFuncSeparate(_srcRGB, _dstRGB, _srcAlpha, _dstAlpha) { }
+    getContextAttributes() { return {}; }
+    isContextLost() { return false; }
+    generateMipmap(_target) { }
+    pixelStorei(_pname, _param) { }
+    _write(bytes) {
+        for (const b of bytes) {
+            this._log.push(b);
+        }
+    }
+    _writeUint32(value) {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setUint32(0, value, false);
+        this._write(Array.from(new Uint8Array(buf)));
+    }
+    _writeFloat32(value) {
+        const buf = new ArrayBuffer(4);
+        new DataView(buf).setFloat32(0, value, false);
+        this._write(Array.from(new Uint8Array(buf)));
+    }
+    _makeHandle() {
+        const id = this._handleCounter++;
+        return { _id: id };
+    }
+    _locationId(location) {
+        if (!location)
+            return 0;
+        return location._id ?? 0;
+    }
+    _stableNameId(name) {
+        let id = this._nameMap.get(name);
+        if (id === undefined) {
+            id = this._nameCounter++;
+            this._nameMap.set(name, id);
+        }
+        return id;
+    }
+}

package/dist/renderer/gpu/debug/playground.d.ts

@@ -0,0 +1,20 @@
+import type { DebugRenderItem, DebugScenario } from './types';
+export interface PlaygroundOptions {
+    stage?: {
+        width: number;
+        height: number;
+    };
+    showOverlay?: boolean;
+    dpr?: number;
+    enableGpuDebug?: boolean;
+}
+export interface PlaygroundHandle {
+    render(items: DebugRenderItem[]): void;
+    resize(cssWidth: number, cssHeight: number, dpr?: number): void;
+    dispose(): void;
+}
+export declare function renderDebugScene(container: HTMLElement, items: DebugRenderItem[], options?: PlaygroundOptions): PlaygroundHandle & (() => void);
+export declare function loadDebugScenario(container: HTMLElement, scenario: DebugScenario, options?: PlaygroundOptions): PlaygroundHandle & (() => void);
+export { loadScenario } from './scenarios';
+export type { DebugRenderItem, DebugScenario } from './types';
+export { DEBUG_STAGE } from './types';

package/dist/renderer/gpu/debug/playground.js

@@ -0,0 +1,64 @@
+import { DebugGpuRenderer } from './DebugGpuRenderer';
+import { DebugOverlay } from './DebugOverlay';
+import { GpuDebugCounters } from './GpuDebugCounters';
+import { installGpuDebugGlobal, uninstallGpuDebugGlobal } from './GpuDebugGlobal';
+import { loadScenario } from './scenarios';
+import { DEBUG_STAGE } from './types';
+export function renderDebugScene(container, items, options = {}) {
+    const stage = options.stage ?? { ...DEBUG_STAGE };
+    const dpr = options.dpr ?? (typeof window !== 'undefined' ? window.devicePixelRatio : 1);
+    const renderer = new DebugGpuRenderer({ stage });
+    renderer.mount(container);
+    const cssWidth = container.clientWidth || stage.width;
+    const cssHeight = container.clientHeight || stage.height;
+    renderer.resize(cssWidth, cssHeight, dpr);
+    renderer.render(items);
+    let currentItems = items;
+    let overlay = null;
+    if (options.showOverlay) {
+        overlay = new DebugOverlay(container, stage);
+        overlay.update(items, 0, stage);
+    }
+    if (options.enableGpuDebug) {
+        installGpuDebugGlobal(() => ({
+            decoderStates: {},
+            cacheSizes: {},
+            textureCount: 0,
+            activeClipIds: currentItems.map((item) => item.id),
+            counters: GpuDebugCounters.snapshot(),
+        }));
+    }
+    let lastFrameTime = typeof performance !== 'undefined' ? performance.now() : 0;
+    const handle = {
+        render(nextItems) {
+            currentItems = nextItems;
+            const now = typeof performance !== 'undefined' ? performance.now() : 0;
+            const dt = now - lastFrameTime;
+            const fps = dt > 0 ? 1000 / dt : 0;
+            lastFrameTime = now;
+            renderer.render(nextItems);
+            overlay?.update(nextItems, fps, stage);
+        },
+        resize(cssW, cssH, nextDpr) {
+            renderer.resize(cssW, cssH, nextDpr ?? dpr);
+            renderer.render(currentItems);
+            overlay?.update(currentItems, 0, stage);
+        },
+        dispose() {
+            overlay?.dispose();
+            overlay = null;
+            if (options.enableGpuDebug) {
+                uninstallGpuDebugGlobal();
+            }
+            renderer.dispose();
+        },
+    };
+    const cleanup = () => handle.dispose();
+    return Object.assign(cleanup, handle);
+}
+export function loadDebugScenario(container, scenario, options = {}) {
+    const items = loadScenario(scenario);
+    return renderDebugScene(container, items, options);
+}
+export { loadScenario } from './scenarios';
+export { DEBUG_STAGE } from './types';

package/dist/renderer/gpu/debug/scenarios.d.ts

@@ -0,0 +1,7 @@
+import { type DebugRenderItem, type DebugScenario } from './types';
+export declare function scenarioA(): DebugRenderItem[];
+export declare function scenarioB(): DebugRenderItem[];
+export declare function scenarioC(): DebugRenderItem[];
+export declare function scenarioD(): DebugRenderItem[];
+export declare function scenarioE(): DebugRenderItem[];
+export declare function loadScenario(scenario: DebugScenario): DebugRenderItem[];

package/dist/renderer/gpu/debug/scenarios.js

@@ -0,0 +1,145 @@
+import { DEBUG_STAGE } from './types';
+const { width: SW, height: SH } = DEBUG_STAGE;
+export function scenarioA() {
+    return [
+        {
+            id: 'a-center',
+            zIndex: 0,
+            color: [0.9, 0.15, 0.15, 1],
+            x: (SW - 400) / 2,
+            y: (SH - 300) / 2,
+            width: 400,
+            height: 300,
+        },
+    ];
+}
+export function scenarioB() {
+    return [
+        {
+            id: 'b-back',
+            zIndex: 0,
+            color: [0.2, 0.4, 0.9, 1],
+            x: 200,
+            y: 150,
+            width: 500,
+            height: 400,
+        },
+        {
+            id: 'b-mid-low',
+            zIndex: 1,
+            color: [0.2, 0.75, 0.3, 1],
+            x: 350,
+            y: 200,
+            width: 500,
+            height: 400,
+        },
+        {
+            id: 'b-mid-high',
+            zIndex: 2,
+            color: [0.9, 0.7, 0.1, 1],
+            x: 500,
+            y: 250,
+            width: 500,
+            height: 400,
+        },
+        {
+            id: 'b-front',
+            zIndex: 3,
+            color: [0.85, 0.2, 0.2, 1],
+            x: 650,
+            y: 300,
+            width: 500,
+            height: 400,
+        },
+    ];
+}
+export function scenarioC() {
+    return [
+        {
+            id: 'c-translate',
+            zIndex: 0,
+            color: [0.2, 0.4, 0.9, 1],
+            x: 80,
+            y: 80,
+            width: 200,
+            height: 150,
+        },
+        {
+            id: 'c-scale',
+            zIndex: 1,
+            color: [0.2, 0.75, 0.3, 1],
+            x: SW / 2 - 150,
+            y: SH / 2 - 100,
+            width: 300,
+            height: 200,
+            rotation: 0,
+        },
+        {
+            id: 'c-rotate',
+            zIndex: 2,
+            color: [0.85, 0.2, 0.85, 1],
+            x: SW - 380,
+            y: SH / 2 - 120,
+            width: 260,
+            height: 240,
+            rotation: Math.PI / 6,
+        },
+    ];
+}
+export function scenarioD() {
+    return [
+        {
+            id: 'd-opaque',
+            zIndex: 0,
+            color: [0.9, 0.15, 0.15, 1],
+            x: 300,
+            y: 180,
+            width: 400,
+            height: 360,
+            opacity: 1.0,
+        },
+        {
+            id: 'd-half',
+            zIndex: 1,
+            color: [0.15, 0.75, 0.25, 1],
+            x: 440,
+            y: 220,
+            width: 400,
+            height: 360,
+            opacity: 0.5,
+        },
+        {
+            id: 'd-quarter',
+            zIndex: 2,
+            color: [0.15, 0.35, 0.9, 1],
+            x: 580,
+            y: 260,
+            width: 400,
+            height: 360,
+            opacity: 0.25,
+        },
+    ];
+}
+export function scenarioE() {
+    return [
+        {
+            id: 'e-fullstage',
+            zIndex: 0,
+            color: [0.1, 0.65, 0.75, 1],
+            x: 0,
+            y: 0,
+            width: SW,
+            height: SH,
+        },
+    ];
+}
+const SCENARIO_FACTORIES = {
+    A: scenarioA,
+    B: scenarioB,
+    C: scenarioC,
+    D: scenarioD,
+    E: scenarioE,
+};
+export function loadScenario(scenario) {
+    return SCENARIO_FACTORIES[scenario]();
+}

package/dist/renderer/gpu/debug/types.d.ts

@@ -0,0 +1,16 @@
+export interface DebugRenderItem {
+    id: string;
+    zIndex: number;
+    color: [number, number, number, number];
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    opacity?: number;
+}
+export type DebugScenario = 'A' | 'B' | 'C' | 'D' | 'E';
+export declare const DEBUG_STAGE: {
+    readonly width: 1280;
+    readonly height: 720;
+};

package/dist/renderer/gpu/debug/types.js

@@ -0,0 +1 @@
+export const DEBUG_STAGE = { width: 1280, height: 720 };

package/dist/renderer/gpu/layers/FrameProbeLayer.d.ts

@@ -0,0 +1,16 @@
+import type { ActiveVideoClip } from '../../../resolver/scene';
+import type { Layer, LayerContext } from './types';
+export declare class FrameProbeLayer implements Layer<ActiveVideoClip> {
+    private _program;
+    private _vao;
+    private _gl;
+    private readonly _resources;
+    acquire(item: ActiveVideoClip, ctx: LayerContext): void;
+    release(itemId: string): void;
+    draw(item: ActiveVideoClip, ctx: LayerContext): void;
+    dispose(): void;
+    notifyContextLost(): void;
+    disposeGL(gl: WebGL2RenderingContext): void;
+    private _paint;
+    private _ensurePipeline;
+}