stats-gl 3.8.0 → 4.0.1

package/dist/stats-gl.d.ts

@@ -1,28 +1,4 @@
-declare class Panel {
-    canvas: HTMLCanvasElement;
-    context: CanvasRenderingContext2D | null;
-    name: string;
-    fg: string;
-    bg: string;
-    gradient: CanvasGradient | null;
-    id: number;
-    PR: number;
-    WIDTH: number;
-    HEIGHT: number;
-    TEXT_X: number;
-    TEXT_Y: number;
-    GRAPH_X: number;
-    GRAPH_Y: number;
-    GRAPH_WIDTH: number;
-    GRAPH_HEIGHT: number;
-    constructor(name: string, fg: string, bg: string);
-    private createGradient;
-    initializeCanvas(): void;
-    update(value: number, maxValue: number, decimals?: number): void;
-    updateGraph(valueGraph: number, maxGraph: number): void;
-}
-
-interface StatsOptions {
+interface StatsCoreOptions {
     trackGPU?: boolean;
     trackCPT?: boolean;
     trackHz?: boolean;
@@ -32,9 +8,9 @@ interface StatsOptions {
     samplesLog?: number;
     samplesGraph?: number;
     precision?: number;
-    minimal?: boolean;
-    horizontal?: boolean;
-    mode?: number;
+}
+interface QueryInfo {
+    query: WebGLQuery;
 }
 interface AverageData {
     logs: number[];
@@ -48,11 +24,14 @@ interface InfoData {
         timestamp: number;
     };
 }
-declare class Stats {
-    dom: HTMLDivElement;
-    mode: number;
-    horizontal: boolean;
-    minimal: boolean;
+interface StatsData {
+    fps: number;
+    cpu: number;
+    gpu: number;
+    gpuCompute: number;
+    isWorker?: boolean;
+}
+declare class StatsCore {
     trackGPU: boolean;
     trackHz: boolean;
     trackFPS: boolean;
@@ -65,64 +44,349 @@ declare class Stats {
     gl: WebGL2RenderingContext | null;
     ext: any | null;
     info?: InfoData;
-    private activeQuery;
-    private gpuQueries;
-    private threeRendererPatched;
-    private beginTime;
-    private prevCpuTime;
-    private frameTimes;
-    private renderCount;
-    private totalCpuDuration;
-    private totalGpuDuration;
-    private totalGpuDurationCompute;
+    gpuDevice: GPUDevice | null;
+    gpuBackend: any | null;
+    renderer: any | null;
+    protected activeQuery: WebGLQuery | null;
+    protected gpuQueries: QueryInfo[];
+    protected threeRendererPatched: boolean;
+    protected webgpuNative: boolean;
+    protected gpuQuerySet: GPUQuerySet | null;
+    protected gpuResolveBuffer: GPUBuffer | null;
+    protected gpuReadBuffers: GPUBuffer[];
+    protected gpuWriteBufferIndex: number;
+    protected gpuFrameCount: number;
+    protected pendingResolve: Promise<number> | null;
+    protected beginTime: number;
+    protected prevCpuTime: number;
+    protected frameTimes: number[];
+    protected renderCount: number;
+    protected totalCpuDuration: number;
+    protected totalGpuDuration: number;
+    protected totalGpuDurationCompute: number;
+    averageFps: AverageData;
+    averageCpu: AverageData;
+    averageGpu: AverageData;
+    averageGpuCompute: AverageData;
+    protected prevGraphTime: number;
+    protected prevTextTime: number;
+    constructor({ trackGPU, trackCPT, trackHz, trackFPS, logsPerSecond, graphsPerSecond, samplesLog, samplesGraph, precision }?: StatsCoreOptions);
+    init(canvasOrGL: WebGL2RenderingContext | HTMLCanvasElement | OffscreenCanvas | GPUDevice | any): Promise<void>;
+    protected handleNativeWebGPU(device: any): boolean;
+    protected initializeWebGPUTiming(): void;
+    protected handleThreeRenderer(renderer: any): boolean;
+    protected handleWebGPURenderer(renderer: any): Promise<boolean>;
+    protected onWebGPUTimestampSupported(): void;
+    protected initializeWebGL(canvasOrGL: WebGL2RenderingContext | HTMLCanvasElement | OffscreenCanvas): boolean;
+    protected initializeGPUTracking(): void;
+    protected onGPUTrackingInitialized(): void;
+    /**
+     * Get timestampWrites configuration for WebGPU render pass.
+     * Use this when creating your render pass descriptor.
+     * @returns timestampWrites object or undefined if not tracking GPU
+     */
+    getTimestampWrites(): GPURenderPassTimestampWrites | undefined;
+    begin(encoder?: GPUCommandEncoder): void;
+    end(encoder?: GPUCommandEncoder): void;
+    /**
+     * Resolve WebGPU timestamp queries. Call this after queue.submit().
+     * Returns a promise that resolves to the GPU duration in milliseconds.
+     */
+    resolveTimestampsAsync(): Promise<number>;
+    private _resolveTimestamps;
+    protected processGpuQueries(): void;
+    protected processWebGPUTimestamps(): void;
+    protected beginProfiling(marker: string): void;
+    protected endProfiling(startMarker: string | PerformanceMeasureOptions | undefined, endMarker: string | undefined, measureName: string): void;
+    protected calculateFps(): number;
+    protected updateAverages(): void;
+    protected addToAverage(value: number, averageArray: {
+        logs: any;
+        graph: any;
+    }): void;
+    protected resetCounters(): void;
+    getData(): StatsData;
+    protected patchThreeWebGPU(renderer: any): void;
+    protected patchThreeRenderer(renderer: any): void;
+    /**
+     * Dispose of all resources. Call when done using the stats instance.
+     */
+    dispose(): void;
+}
+
+declare class Panel {
+    canvas: HTMLCanvasElement;
+    context: CanvasRenderingContext2D | null;
+    name: string;
+    fg: string;
+    bg: string;
+    gradient: CanvasGradient | null;
+    id: number;
+    PR: number;
+    WIDTH: number;
+    HEIGHT: number;
+    TEXT_X: number;
+    TEXT_Y: number;
+    GRAPH_X: number;
+    GRAPH_Y: number;
+    GRAPH_WIDTH: number;
+    GRAPH_HEIGHT: number;
+    constructor(name: string, fg: string, bg: string);
+    private createGradient;
+    initializeCanvas(): void;
+    update(value: number, maxValue: number, decimals?: number, suffix?: string): void;
+    updateGraph(valueGraph: number, maxGraph: number): void;
+}
+
+declare class PanelTexture extends Panel {
+    private currentBitmap;
+    private sourceAspect;
+    constructor(name: string);
+    initializeCanvas(): void;
+    private drawLabelOverlay;
+    /**
+     * Set the source texture aspect ratio for proper display
+     * @param width - Source texture width
+     * @param height - Source texture height
+     */
+    setSourceSize(width: number, height: number): void;
+    updateTexture(bitmap: ImageBitmap): void;
+    setLabel(label: string): void;
+    update(_value: number, _maxValue: number, _decimals?: number, _suffix?: string): void;
+    updateGraph(_valueGraph: number, _maxGraph: number): void;
+    /**
+     * Dispose of resources
+     */
+    dispose(): void;
+}
+
+declare class TextureCaptureWebGL {
+    private gl;
+    private previewFbo;
+    private previewTexture;
+    private pixels;
+    private flippedPixels;
+    private previewWidth;
+    private previewHeight;
+    constructor(gl: WebGL2RenderingContext, width?: number, height?: number);
+    /**
+     * Resize preview dimensions
+     */
+    resize(width: number, height: number): void;
+    private initResources;
+    capture(source: WebGLFramebuffer | null, sourceWidth: number, sourceHeight: number, _sourceId?: string): Promise<ImageBitmap | null>;
+    private flipY;
+    removeSource(_sourceId: string): void;
+    dispose(): void;
+}
+declare class TextureCaptureWebGPU {
+    private device;
+    private previewTexture;
+    private stagingBuffer;
+    private blitPipeline;
+    private sampler;
+    private bindGroupLayout;
+    private initialized;
+    private previewWidth;
+    private previewHeight;
+    private pixelsBuffer;
+    constructor(device: GPUDevice, width?: number, height?: number);
+    /**
+     * Resize preview dimensions
+     */
+    resize(width: number, height: number): void;
+    private createSizeResources;
+    private initResources;
+    capture(source: GPUTexture): Promise<ImageBitmap | null>;
+    dispose(): void;
+}
+interface ThreeTextureSource {
+    isWebGLRenderTarget?: boolean;
+    __webglFramebuffer?: WebGLFramebuffer;
+    width?: number;
+    height?: number;
+    isRenderTarget?: boolean;
+    texture?: {
+        isTexture?: boolean;
+    };
+}
+
+interface StatsProfilerOptions extends StatsCoreOptions {
+}
+declare class StatsProfiler extends StatsCore {
+    private textureCaptureWebGL;
+    private textureCaptureWebGPU;
+    constructor(options?: StatsProfilerOptions);
+    update(): void;
+    getData(): StatsData;
+    /**
+     * Capture a texture/render target to ImageBitmap for transfer to main thread
+     * @param source - Three.js RenderTarget, GPUTexture, or WebGLFramebuffer with dimensions
+     * @param sourceId - Unique identifier for this texture source (for per-source PBO buffering)
+     * @returns ImageBitmap suitable for postMessage transfer
+     */
+    captureTexture(source: ThreeTextureSource | {
+        framebuffer: WebGLFramebuffer;
+        width: number;
+        height: number;
+    } | any, sourceId?: string): Promise<ImageBitmap | null>;
+    /**
+     * Dispose texture capture resources
+     */
+    disposeTextureCapture(): void;
+    /**
+     * Dispose of all resources
+     */
+    dispose(): void;
+}
+
+/**
+ * TSL Node capture utilities for stats-gl
+ *
+ * For WebGPU TSL node capture with proper Node integration, use the addon:
+ *   import { statsGL } from 'stats-gl/addons/StatsGLNode.js';
+ *
+ * This file provides a simpler capture system that doesn't require
+ * extending Three.js Node class.
+ */
+interface StatsGLNodeData {
+    canvas: HTMLCanvasElement | OffscreenCanvas;
+    canvasTarget: any;
+    quad: any;
+    material: any;
+    node: any;
+}
+/**
+ * Manages TSL node capture for stats-gl (used internally)
+ */
+declare class StatsGLCapture {
+    nodes: Map<string, StatsGLNodeData>;
+    width: number;
+    height: number;
+    private THREE;
+    constructor(THREE: any, width?: number, height?: number);
+    /**
+     * Update capture dimensions (e.g., on resize)
+     */
+    resize(width: number, height: number): void;
+    register(name: string, targetNode: any): StatsGLNodeData;
+    capture(name: string, renderer: any): Promise<ImageBitmap | null>;
+    remove(name: string): void;
+    /**
+     * Dispose all capture resources
+     */
+    dispose(): void;
+}
+
+interface StatsOptions extends StatsCoreOptions {
+    minimal?: boolean;
+    horizontal?: boolean;
+    mode?: number;
+}
+declare class Stats extends StatsCore {
+    dom: HTMLDivElement;
+    mode: number;
+    horizontal: boolean;
+    minimal: boolean;
     private _panelId;
     private fpsPanel;
     private msPanel;
     private gpuPanel;
     private gpuPanelCompute;
     private vsyncPanel;
-    averageFps: AverageData;
-    averageCpu: AverageData;
-    averageGpu: AverageData;
-    averageGpuCompute: AverageData;
+    private workerCpuPanel;
+    texturePanels: Map<string, PanelTexture>;
+    private texturePanelRow;
+    private textureCaptureWebGL;
+    private textureCaptureWebGPU;
+    private textureSourcesWebGL;
+    private textureSourcesWebGPU;
+    private texturePreviewWidth;
+    private texturePreviewHeight;
+    private lastRendererWidth;
+    private lastRendererHeight;
+    private textureUpdatePending;
     private updateCounter;
-    private prevGraphTime;
     private lastMin;
     private lastMax;
     private lastValue;
-    private prevTextTime;
     private readonly VSYNC_RATES;
     private detectedVSync;
     private frameTimeHistory;
     private readonly HISTORY_SIZE;
     private readonly VSYNC_THRESHOLD;
     private lastFrameTime;
+    private externalData;
+    private hasNewExternalData;
+    private isWorker;
+    private averageWorkerCpu;
     static Panel: typeof Panel;
+    static PanelTexture: typeof PanelTexture;
     constructor({ trackGPU, trackCPT, trackHz, trackFPS, logsPerSecond, graphsPerSecond, samplesLog, samplesGraph, precision, minimal, horizontal, mode }?: StatsOptions);
     private initializeDOM;
     private setupEventListeners;
     private handleClick;
     private handleResize;
-    init(canvasOrGL: WebGL2RenderingContext | HTMLCanvasElement | OffscreenCanvas | any): Promise<void>;
-    private handleThreeRenderer;
-    private handleWebGPURenderer;
-    private initializeWebGPUPanels;
-    private initializeWebGL;
-    private initializeGPUTracking;
-    begin(): void;
-    end(): void;
+    /**
+     * Compute and update texture preview dimensions based on renderer aspect ratio
+     */
+    private updateTexturePreviewDimensions;
+    protected onWebGPUTimestampSupported(): void;
+    protected onGPUTrackingInitialized(): void;
+    setData(data: StatsData): void;
     update(): void;
-    private processWebGPUTimestamps;
-    private resetCounters;
+    private updateFromExternalData;
+    private updateFromInternalData;
+    private renderPanels;
+    protected resetCounters(): void;
     resizePanel(panel: Panel): void;
     addPanel(panel: Panel): Panel;
     showPanel(id: number): void;
-    processGpuQueries(): void;
+    /**
+     * Add a new texture preview panel
+     * @param name - Label for the texture panel
+     * @returns The created PanelTexture instance
+     */
+    addTexturePanel(name: string): PanelTexture;
+    /**
+     * Set texture source for a panel (Three.js render target)
+     * Auto-detects WebGL/WebGPU and extracts native handles
+     * @param name - Panel name
+     * @param source - Three.js RenderTarget or native texture
+     */
+    setTexture(name: string, source: ThreeTextureSource | any): void;
+    /**
+     * Set WebGL framebuffer source with explicit dimensions
+     * @param name - Panel name
+     * @param framebuffer - WebGL framebuffer
+     * @param width - Texture width
+     * @param height - Texture height
+     */
+    setTextureWebGL(name: string, framebuffer: WebGLFramebuffer, width: number, height: number): void;
+    /**
+     * Set texture from ImageBitmap (for worker mode)
+     * @param name - Panel name
+     * @param bitmap - ImageBitmap transferred from worker
+     * @param sourceWidth - Optional source texture width for aspect ratio
+     * @param sourceHeight - Optional source texture height for aspect ratio
+     */
+    setTextureBitmap(name: string, bitmap: ImageBitmap, sourceWidth?: number, sourceHeight?: number): void;
+    /**
+     * Remove a texture panel
+     * @param name - Panel name to remove
+     */
+    removeTexturePanel(name: string): void;
+    /**
+     * Capture and update all texture panels
+     * Called automatically during renderPanels at graphsPerSecond rate
+     */
+    private updateTexturePanels;
+    /**
+     * Capture StatsGL nodes registered by the addon
+     */
+    private captureStatsGLNodes;
     private detectVSync;
-    endInternal(): number;
     private updatePanelComponents;
-    private beginProfiling;
-    private endProfiling;
     updatePanel(panel: {
         update: any;
         updateGraph: any;
@@ -131,14 +395,11 @@ declare class Stats {
         logs: number[];
         graph: number[];
     }, precision?: number): void;
-    private updateAverages;
-    addToAverage(value: number, averageArray: {
-        logs: any;
-        graph: any;
-    }): void;
     get domElement(): HTMLDivElement;
-    patchThreeWebGPU(renderer: any): void;
-    patchThreeRenderer(renderer: any): void;
+    /**
+     * Dispose of all resources. Call when done using Stats.
+     */
+    dispose(): void;
 }
 
-export { Stats as default };
+export { PanelTexture, StatsData, StatsGLCapture, StatsProfiler, TextureCaptureWebGL, TextureCaptureWebGPU, Stats as default };

package/dist/statsGLNode.cjs

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class StatsGLCapture {
+  constructor(THREE, width = 90, height = 48) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.width = 90;
+    this.height = 48;
+    this.THREE = THREE;
+    this.width = width;
+    this.height = height;
+  }
+  /**
+   * Update capture dimensions (e.g., on resize)
+   */
+  resize(width, height) {
+    var _a, _b;
+    this.width = width;
+    this.height = height;
+    for (const [name, data] of this.nodes) {
+      if (data.canvas instanceof HTMLCanvasElement) {
+        data.canvas.width = width;
+        data.canvas.height = height;
+      } else if (data.canvas instanceof OffscreenCanvas) {
+        const newCanvas = new OffscreenCanvas(width, height);
+        data.canvas = newCanvas;
+        (_b = (_a = data.canvasTarget).setCanvas) == null ? void 0 : _b.call(_a, newCanvas);
+      }
+      data.canvasTarget.setSize(width, height);
+    }
+  }
+  register(name, targetNode) {
+    if (this.nodes.has(name))
+      return this.nodes.get(name);
+    const { CanvasTarget, NodeMaterial, QuadMesh, NoToneMapping, LinearSRGBColorSpace } = this.THREE;
+    const { renderOutput, vec3, vec4 } = this.THREE;
+    const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(this.width, this.height) : document.createElement("canvas");
+    if (canvas instanceof HTMLCanvasElement) {
+      canvas.width = this.width;
+      canvas.height = this.height;
+    }
+    const canvasTarget = new CanvasTarget(canvas);
+    canvasTarget.setSize(this.width, this.height);
+    const material = new NodeMaterial();
+    material.outputNode = renderOutput(
+      vec4(vec3(targetNode), 1),
+      NoToneMapping,
+      LinearSRGBColorSpace
+    );
+    const quad = new QuadMesh(material);
+    const data = { canvas, canvasTarget, quad, material, node: targetNode };
+    this.nodes.set(name, data);
+    return data;
+  }
+  async capture(name, renderer) {
+    const data = this.nodes.get(name);
+    if (!data)
+      return null;
+    try {
+      data.quad.render(renderer, data.canvasTarget);
+      return await createImageBitmap(data.canvas);
+    } catch (e) {
+      return null;
+    }
+  }
+  remove(name) {
+    const data = this.nodes.get(name);
+    if (data) {
+      if (data.material && data.material.dispose) {
+        data.material.dispose();
+      }
+      if (data.canvas instanceof HTMLCanvasElement && data.canvas.parentNode) {
+        data.canvas.parentNode.removeChild(data.canvas);
+      }
+      this.nodes.delete(name);
+    }
+  }
+  /**
+   * Dispose all capture resources
+   */
+  dispose() {
+    const names = Array.from(this.nodes.keys());
+    for (const name of names) {
+      this.remove(name);
+    }
+    this.nodes.clear();
+  }
+}
+exports.StatsGLCapture = StatsGLCapture;
+//# sourceMappingURL=statsGLNode.cjs.map

package/dist/statsGLNode.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"statsGLNode.cjs","sources":["../lib/statsGLNode.ts"],"sourcesContent":null,"names":[],"mappings":";;AAqBO,MAAM,eAAe;AAAA,EAM1B,YAAY,OAAY,QAAQ,IAAI,SAAS,IAAI;AALjD,SAAA,4BAA0C;AAClC,SAAA,QAAA;AACC,SAAA,SAAA;AAIP,SAAK,QAAQ;AACb,SAAK,QAAQ;AACb,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,OAAe,QAAsB;;AAC1C,SAAK,QAAQ;AACb,SAAK,SAAS;AAGd,eAAW,CAAC,MAAM,IAAI,KAAK,KAAK,OAAO;AACjC,UAAA,KAAK,kBAAkB,mBAAmB;AAC5C,aAAK,OAAO,QAAQ;AACpB,aAAK,OAAO,SAAS;AAAA,MAAA,WACZ,KAAK,kBAAkB,iBAAiB;AAEjD,cAAM,YAAY,IAAI,gBAAgB,OAAO,MAAM;AACnD,aAAK,SAAS;AACT,yBAAA,cAAa,cAAb,4BAAyB;AAAA,MAChC;AACK,WAAA,aAAa,QAAQ,OAAO,MAAM;AAAA,IACzC;AAAA,EACF;AAAA,EAEA,SAAS,MAAc,YAAkC;AACnD,QAAA,KAAK,MAAM,IAAI,IAAI;AAAU,aAAA,KAAK,MAAM,IAAI,IAAI;AAEpD,UAAM,EAAE,cAAc,cAAc,UAAU,eAAe,yBAAyB,KAAK;AAC3F,UAAM,EAAE,cAAc,MAAM,KAAA,IAAS,KAAK;AAE1C,UAAM,SAAS,OAAO,oBAAoB,cACtC,IAAI,gBAAgB,KAAK,OAAO,KAAK,MAAM,IAC3C,SAAS,cAAc,QAAQ;AACnC,QAAI,kBAAkB,mBAAmB;AACvC,aAAO,QAAQ,KAAK;AACpB,aAAO,SAAS,KAAK;AAAA,IACvB;AAEM,UAAA,eAAe,IAAI,aAAa,MAAM;AAC5C,iBAAa,QAAQ,KAAK,OAAO,KAAK,MAAM;AAEtC,UAAA,WAAW,IAAI;AACrB,aAAS,aAAa;AAAA,MACpB,KAAK,KAAK,UAAU,GAAG,CAAC;AAAA,MACxB;AAAA,MACA;AAAA,IAAA;AAGI,UAAA,OAAO,IAAI,SAAS,QAAQ;AAClC,UAAM,OAAwB,EAAE,QAAQ,cAAc,MAAM,UAAU,MAAM;AACvE,SAAA,MAAM,IAAI,MAAM,IAAI;AAClB,WAAA;AAAA,EACT;AAAA,EAEA,MAAM,QAAQ,MAAc,UAA4C;AACtE,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC;AAAa,aAAA;AAEd,QAAA;AACF,WAAK,KAAK,OAAO,UAAU,KAAK,YAAY;AACrC,aAAA,MAAM,kBAAkB,KAAK,MAAM;AAAA,aACnC,GAAG;AACH,aAAA;AAAA,IACT;AAAA,EACF;AAAA,EAEA,OAAO,MAAoB;AACzB,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,MAAM;AAER,UAAI,KAAK,YAAY,KAAK,SAAS,SAAS;AAC1C,aAAK,SAAS;MAChB;AAEA,UAAI,KAAK,kBAAkB,qBAAqB,KAAK,OAAO,YAAY;AACtE,aAAK,OAAO,WAAW,YAAY,KAAK,MAAM;AAAA,MAChD;AACK,WAAA,MAAM,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AAEd,UAAM,QAAQ,MAAM,KAAK,KAAK,MAAM,MAAM;AAC1C,eAAW,QAAQ,OAAO;AACxB,WAAK,OAAO,IAAI;AAAA,IAClB;AACA,SAAK,MAAM;EACb;AACF;;"}

package/dist/statsGLNode.js

@@ -0,0 +1,89 @@
+class StatsGLCapture {
+  constructor(THREE, width = 90, height = 48) {
+    this.nodes = /* @__PURE__ */ new Map();
+    this.width = 90;
+    this.height = 48;
+    this.THREE = THREE;
+    this.width = width;
+    this.height = height;
+  }
+  /**
+   * Update capture dimensions (e.g., on resize)
+   */
+  resize(width, height) {
+    var _a, _b;
+    this.width = width;
+    this.height = height;
+    for (const [name, data] of this.nodes) {
+      if (data.canvas instanceof HTMLCanvasElement) {
+        data.canvas.width = width;
+        data.canvas.height = height;
+      } else if (data.canvas instanceof OffscreenCanvas) {
+        const newCanvas = new OffscreenCanvas(width, height);
+        data.canvas = newCanvas;
+        (_b = (_a = data.canvasTarget).setCanvas) == null ? void 0 : _b.call(_a, newCanvas);
+      }
+      data.canvasTarget.setSize(width, height);
+    }
+  }
+  register(name, targetNode) {
+    if (this.nodes.has(name))
+      return this.nodes.get(name);
+    const { CanvasTarget, NodeMaterial, QuadMesh, NoToneMapping, LinearSRGBColorSpace } = this.THREE;
+    const { renderOutput, vec3, vec4 } = this.THREE;
+    const canvas = typeof OffscreenCanvas !== "undefined" ? new OffscreenCanvas(this.width, this.height) : document.createElement("canvas");
+    if (canvas instanceof HTMLCanvasElement) {
+      canvas.width = this.width;
+      canvas.height = this.height;
+    }
+    const canvasTarget = new CanvasTarget(canvas);
+    canvasTarget.setSize(this.width, this.height);
+    const material = new NodeMaterial();
+    material.outputNode = renderOutput(
+      vec4(vec3(targetNode), 1),
+      NoToneMapping,
+      LinearSRGBColorSpace
+    );
+    const quad = new QuadMesh(material);
+    const data = { canvas, canvasTarget, quad, material, node: targetNode };
+    this.nodes.set(name, data);
+    return data;
+  }
+  async capture(name, renderer) {
+    const data = this.nodes.get(name);
+    if (!data)
+      return null;
+    try {
+      data.quad.render(renderer, data.canvasTarget);
+      return await createImageBitmap(data.canvas);
+    } catch (e) {
+      return null;
+    }
+  }
+  remove(name) {
+    const data = this.nodes.get(name);
+    if (data) {
+      if (data.material && data.material.dispose) {
+        data.material.dispose();
+      }
+      if (data.canvas instanceof HTMLCanvasElement && data.canvas.parentNode) {
+        data.canvas.parentNode.removeChild(data.canvas);
+      }
+      this.nodes.delete(name);
+    }
+  }
+  /**
+   * Dispose all capture resources
+   */
+  dispose() {
+    const names = Array.from(this.nodes.keys());
+    for (const name of names) {
+      this.remove(name);
+    }
+    this.nodes.clear();
+  }
+}
+export {
+  StatsGLCapture
+};
+//# sourceMappingURL=statsGLNode.js.map

package/dist/statsGLNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statsGLNode.js","sources":["../lib/statsGLNode.ts"],"sourcesContent":null,"names":[],"mappings":"AAqBO,MAAM,eAAe;AAAA,EAM1B,YAAY,OAAY,QAAQ,IAAI,SAAS,IAAI;AALjD,SAAA,4BAA0C;AAClC,SAAA,QAAA;AACC,SAAA,SAAA;AAIP,SAAK,QAAQ;AACb,SAAK,QAAQ;AACb,SAAK,SAAS;AAAA,EAChB;AAAA;AAAA;AAAA;AAAA,EAKA,OAAO,OAAe,QAAsB;AAfvC;AAgBH,SAAK,QAAQ;AACb,SAAK,SAAS;AAGd,eAAW,CAAC,MAAM,IAAI,KAAK,KAAK,OAAO;AACjC,UAAA,KAAK,kBAAkB,mBAAmB;AAC5C,aAAK,OAAO,QAAQ;AACpB,aAAK,OAAO,SAAS;AAAA,MAAA,WACZ,KAAK,kBAAkB,iBAAiB;AAEjD,cAAM,YAAY,IAAI,gBAAgB,OAAO,MAAM;AACnD,aAAK,SAAS;AACT,yBAAA,cAAa,cAAb,4BAAyB;AAAA,MAChC;AACK,WAAA,aAAa,QAAQ,OAAO,MAAM;AAAA,IACzC;AAAA,EACF;AAAA,EAEA,SAAS,MAAc,YAAkC;AACnD,QAAA,KAAK,MAAM,IAAI,IAAI;AAAU,aAAA,KAAK,MAAM,IAAI,IAAI;AAEpD,UAAM,EAAE,cAAc,cAAc,UAAU,eAAe,yBAAyB,KAAK;AAC3F,UAAM,EAAE,cAAc,MAAM,KAAA,IAAS,KAAK;AAE1C,UAAM,SAAS,OAAO,oBAAoB,cACtC,IAAI,gBAAgB,KAAK,OAAO,KAAK,MAAM,IAC3C,SAAS,cAAc,QAAQ;AACnC,QAAI,kBAAkB,mBAAmB;AACvC,aAAO,QAAQ,KAAK;AACpB,aAAO,SAAS,KAAK;AAAA,IACvB;AAEM,UAAA,eAAe,IAAI,aAAa,MAAM;AAC5C,iBAAa,QAAQ,KAAK,OAAO,KAAK,MAAM;AAEtC,UAAA,WAAW,IAAI;AACrB,aAAS,aAAa;AAAA,MACpB,KAAK,KAAK,UAAU,GAAG,CAAC;AAAA,MACxB;AAAA,MACA;AAAA,IAAA;AAGI,UAAA,OAAO,IAAI,SAAS,QAAQ;AAClC,UAAM,OAAwB,EAAE,QAAQ,cAAc,MAAM,UAAU,MAAM;AACvE,SAAA,MAAM,IAAI,MAAM,IAAI;AAClB,WAAA;AAAA,EACT;AAAA,EAEA,MAAM,QAAQ,MAAc,UAA4C;AACtE,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,CAAC;AAAa,aAAA;AAEd,QAAA;AACF,WAAK,KAAK,OAAO,UAAU,KAAK,YAAY;AACrC,aAAA,MAAM,kBAAkB,KAAK,MAAM;AAAA,aACnC,GAAG;AACH,aAAA;AAAA,IACT;AAAA,EACF;AAAA,EAEA,OAAO,MAAoB;AACzB,UAAM,OAAO,KAAK,MAAM,IAAI,IAAI;AAChC,QAAI,MAAM;AAER,UAAI,KAAK,YAAY,KAAK,SAAS,SAAS;AAC1C,aAAK,SAAS;MAChB;AAEA,UAAI,KAAK,kBAAkB,qBAAqB,KAAK,OAAO,YAAY;AACtE,aAAK,OAAO,WAAW,YAAY,KAAK,MAAM;AAAA,MAChD;AACK,WAAA,MAAM,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA,EAKA,UAAgB;AAEd,UAAM,QAAQ,MAAM,KAAK,KAAK,MAAM,MAAM;AAC1C,eAAW,QAAQ,OAAO;AACxB,WAAK,OAAO,IAAI;AAAA,IAClB;AACA,SAAK,MAAM;EACb;AACF;"}