LCOV - code coverage report
Current view: top level - packages/viewport3d/src/three - RendererView.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 93.8 % 48 45
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type * as THREE from 'three'
       2              : 
       3              : import type {
       4              :   RendererViewState,
       5              :   SharedRendererHandle
       6              : } from './sharedWebGLRenderer'
       7              : import {
       8              :   acquireSharedRenderer,
       9              :   applyRendererViewState,
      10              :   createRendererViewState,
      11              :   ensureRendererSize,
      12              :   ensureSharedHighPrecisionTarget,
      13              :   resolveHighPrecisionTarget
      14              : } from './sharedWebGLRenderer'
      15              : 
      16           24 : export class RendererView {
      17              :   readonly renderer: THREE.WebGLRenderer
      18              :   readonly canvas: HTMLCanvasElement
      19              :   readonly state: RendererViewState = createRendererViewState()
      20              : 
      21              :   width = 1
      22              :   height = 1
      23              : 
      24              :   private readonly context: CanvasRenderingContext2D
      25              :   private readonly handle: SharedRendererHandle
      26              :   private resizeObserver: ResizeObserver | null = null
      27              :   private outputTarget: THREE.WebGLRenderTarget | null = null
      28              :   private outputWidth = 1
      29              :   private outputHeight = 1
      30              : 
      31              :   constructor(container: HTMLElement) {
      32           28 :     this.canvas = document.createElement('canvas')
      33           28 :     this.canvas.classList.add(
      34              :       'absolute',
      35              :       'inset-0',
      36              :       'h-full',
      37              :       'w-full',
      38              :       'outline-none'
      39              :     )
      40           28 :     const context = this.canvas.getContext('2d')
      41           28 :     if (!context) {
      42            0 :       throw new Error('Failed to create 2D context for 3D view')
      43              :     }
      44           28 :     this.context = context
      45              : 
      46           28 :     this.handle = acquireSharedRenderer()
      47           28 :     this.renderer = this.handle.renderer
      48           28 :     container.appendChild(this.canvas)
      49              :   }
      50              : 
      51              :   setSize(width: number, height: number): void {
      52          149 :     this.width = Math.max(1, Math.round(width))
      53          149 :     this.height = Math.max(1, Math.round(height))
      54          149 :     if (this.canvas.width !== this.width) this.canvas.width = this.width
      55          149 :     if (this.canvas.height !== this.height) this.canvas.height = this.height
      56          149 :     ensureRendererSize(this.renderer, this.width, this.height)
      57              :   }
      58              : 
      59              :   beginRender(highPrecision = false): void {
      60         1002 :     ensureRendererSize(this.renderer, this.width, this.height)
      61         1002 :     applyRendererViewState(this.renderer, this.state)
      62         1002 :     this.bindOutput(
      63              :       highPrecision
      64              :         ? ensureSharedHighPrecisionTarget(this.width, this.height)
      65              :         : null,
      66              :       this.width,
      67              :       this.height
      68              :     )
      69              :   }
      70              : 
      71              :   bindOutput(
      72              :     target: THREE.WebGLRenderTarget | null,
      73              :     width: number,
      74              :     height: number
      75              :   ): void {
      76         1014 :     this.outputTarget = target
      77         1014 :     this.outputWidth = width
      78         1014 :     this.outputHeight = height
      79         1014 :     if (target) target.texture.colorSpace = this.state.outputColorSpace
      80         1014 :     this.renderer.setRenderTarget(target)
      81         1014 :     this.setViewport(0, 0, width, height)
      82         1014 :     this.setScissor(0, 0, width, height)
      83         1014 :     this.setScissorTest(false)
      84              :   }
      85              : 
      86              :   resolveOutput(): void {
      87         1008 :     if (!this.outputTarget) return
      88            0 :     resolveHighPrecisionTarget(
      89              :       this.renderer,
      90              :       this.outputTarget,
      91              :       this.outputWidth,
      92              :       this.outputHeight
      93              :     )
      94            0 :     this.outputTarget = null
      95              :   }
      96              : 
      97              :   setViewport(x: number, y: number, width: number, height: number): void {
      98         5935 :     this.renderer.setViewport(x, y, width, height)
      99         5935 :     this.outputTarget?.viewport.set(x, y, width, height)
     100              :   }
     101              : 
     102              :   getViewport(target: THREE.Vector4): THREE.Vector4 {
     103          999 :     return this.renderer.getViewport(target)
     104              :   }
     105              : 
     106              :   setScissor(x: number, y: number, width: number, height: number): void {
     107         3937 :     this.renderer.setScissor(x, y, width, height)
     108         3937 :     this.outputTarget?.scissor.set(x, y, width, height)
     109              :   }
     110              : 
     111              :   setScissorTest(enabled: boolean): void {
     112         3012 :     this.renderer.setScissorTest(enabled)
     113         3012 :     if (this.outputTarget) this.outputTarget.scissorTest = enabled
     114              :   }
     115              : 
     116              :   blit(): void {
     117          999 :     this.resolveOutput()
     118          999 :     const source = this.renderer.domElement
     119          999 :     this.context.globalCompositeOperation = 'copy'
     120          999 :     this.context.drawImage(
     121              :       source,
     122              :       0,
     123              :       source.height - this.height,
     124              :       this.width,
     125              :       this.height,
     126              :       0,
     127              :       0,
     128              :       this.width,
     129              :       this.height
     130              :     )
     131              :   }
     132              : 
     133              :   observeResize(target: Element, onResize: () => void): void {
     134           27 :     if (typeof ResizeObserver === 'undefined') return
     135           27 :     this.resizeObserver?.disconnect()
     136           27 :     this.resizeObserver = new ResizeObserver(() => onResize())
     137           27 :     this.resizeObserver.observe(target)
     138              :   }
     139              : 
     140              :   dispose(): void {
     141            1 :     this.resizeObserver?.disconnect()
     142            1 :     this.resizeObserver = null
     143            1 :     this.canvas.remove()
     144            1 :     this.handle.release()
     145              :   }
     146              : }
        

Generated by: LCOV version 2.0-1