LCOV - code coverage report
Current view: top level - packages/viewport3d/src/three - sharedWebGLRenderer.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 83.0 % 47 39
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import * as THREE from 'three'
       2              : 
       3              : import type { FxaaResolve } from './highPrecisionOutput'
       4              : import {
       5              :   createFxaaResolve,
       6              :   createHighPrecisionTarget,
       7              :   ensureTargetSize
       8              : } from './highPrecisionOutput'
       9              : 
      10              : export type RendererViewState = {
      11              :   toneMapping: THREE.ToneMapping
      12              :   toneMappingExposure: number
      13              :   outputColorSpace: THREE.ColorSpace
      14              :   clearColor: THREE.Color
      15              :   clearAlpha: number
      16              : }
      17              : 
      18           28 : export function createRendererViewState(): RendererViewState {
      19           28 :   return {
      20              :     toneMapping: THREE.NoToneMapping,
      21              :     toneMappingExposure: 1.0,
      22              :     outputColorSpace: THREE.SRGBColorSpace,
      23              :     clearColor: new THREE.Color(0x000000),
      24              :     clearAlpha: 0
      25              :   }
      26              : }
      27              : 
      28         1002 : export function applyRendererViewState(
      29              :   renderer: THREE.WebGLRenderer,
      30              :   state: RendererViewState
      31              : ): void {
      32         1002 :   renderer.toneMapping = state.toneMapping
      33         1002 :   renderer.toneMappingExposure = state.toneMappingExposure
      34         1002 :   renderer.outputColorSpace = state.outputColorSpace
      35         1002 :   renderer.setClearColor(state.clearColor, state.clearAlpha)
      36              : }
      37              : 
      38              : export type SharedRendererHandle = {
      39              :   renderer: THREE.WebGLRenderer
      40              :   release: () => void
      41              : }
      42              : 
      43           24 : let sharedRenderer: THREE.WebGLRenderer | null = null
      44           24 : let viewCount = 0
      45           24 : let sharedHighPrecisionTarget: THREE.WebGLRenderTarget | null = null
      46           24 : let sharedFxaaResolve: FxaaResolve | null = null
      47              : 
      48           24 : function createSharedRenderer(): THREE.WebGLRenderer {
      49           24 :   const renderer = new THREE.WebGLRenderer({ alpha: true, antialias: true })
      50           24 :   renderer.setPixelRatio(1)
      51           24 :   renderer.setSize(300, 300)
      52           24 :   renderer.autoClear = false
      53           24 :   renderer.outputColorSpace = THREE.SRGBColorSpace
      54           24 :   return renderer
      55              : }
      56              : 
      57           28 : export function acquireSharedRenderer(): SharedRendererHandle {
      58           28 :   sharedRenderer ??= createSharedRenderer()
      59           28 :   viewCount++
      60           28 :   const renderer = sharedRenderer
      61           28 :   let released = false
      62           28 :   return {
      63              :     renderer,
      64              :     release() {
      65            1 :       if (released) return
      66            1 :       released = true
      67            1 :       viewCount--
      68            1 :       if (viewCount > 0 || sharedRenderer !== renderer) return
      69            0 :       sharedRenderer = null
      70            1 :       sharedHighPrecisionTarget?.dispose()
      71            1 :       sharedHighPrecisionTarget = null
      72            1 :       sharedFxaaResolve?.dispose()
      73            1 :       sharedFxaaResolve = null
      74            1 :       renderer.forceContextLoss()
      75            1 :       renderer.domElement.dispatchEvent(
      76              :         new Event('webglcontextlost', { bubbles: true, cancelable: true })
      77              :       )
      78            1 :       renderer.dispose()
      79              :     }
      80              :   }
      81              : }
      82              : 
      83         1151 : export function ensureRendererSize(
      84              :   renderer: THREE.WebGLRenderer,
      85              :   width: number,
      86              :   height: number
      87              : ): void {
      88         1151 :   const size = renderer.getSize(new THREE.Vector2())
      89         1151 :   if (size.width >= width && size.height >= height) return
      90           28 :   renderer.setSize(Math.max(size.width, width), Math.max(size.height, height))
      91              : }
      92              : 
      93            0 : export function ensureSharedHighPrecisionTarget(
      94              :   width: number,
      95              :   height: number
      96              : ): THREE.WebGLRenderTarget {
      97            0 :   sharedHighPrecisionTarget ??= createHighPrecisionTarget()
      98            0 :   ensureTargetSize(sharedHighPrecisionTarget, width, height)
      99            0 :   return sharedHighPrecisionTarget
     100              : }
     101              : 
     102            0 : export function resolveHighPrecisionTarget(
     103              :   renderer: THREE.WebGLRenderer,
     104              :   source: THREE.WebGLRenderTarget,
     105              :   width: number,
     106              :   height: number
     107              : ): void {
     108            0 :   sharedFxaaResolve ??= createFxaaResolve()
     109            0 :   sharedFxaaResolve.render(renderer, source, width, height)
     110              : }
        

Generated by: LCOV version 2.0-1