LCOV - code coverage report
Current view: top level - packages/layer-editor/src/render - renderStack.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 50.0 % 104 52
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import type {
       2              :   Compositor,
       3              :   CompositeInput,
       4              :   FBOHandle,
       5              :   NodeTexture
       6              : } from '#/compositor'
       7              : import type { ContentStore } from '#/content'
       8              : import type { Document } from '#/document'
       9              : import { resolveMode } from '#/mode'
      10              : import type { GroupData, SceneNode, Transform } from '#/node'
      11              : import type { CompactRect as Rect } from '@comfyorg/shared-frontend-utils/geometry'
      12              : import type { RenderNodeCtx } from '#/nodeKind'
      13              : import { getNodeKind } from '#/nodeKind'
      14              : import type { Bitmap } from './place'
      15              : import { placeBitmap } from './place'
      16              : 
      17              : export interface PlacedEntry {
      18              :   stamp: string
      19              :   canvas: HTMLCanvasElement
      20              : }
      21              : 
      22              : export interface PreviewOverride {
      23              :   canvas: HTMLCanvasElement
      24              :   version: number
      25              :   rects?: Rect[] | null
      26              : }
      27              : 
      28              : export interface RenderDeps {
      29              :   content: ContentStore
      30              :   compositor: Compositor
      31              :   devicePixelRatio?: number
      32              :   overrides?: Map<string, PreviewOverride>
      33              :   placedCache?: Map<string, PlacedEntry>
      34              : }
      35              : 
      36              : export interface BuiltInputs {
      37              :   inputs: CompositeInput[]
      38              :   cleanup: () => void
      39              : }
      40              : 
      41           24 : function transformStamp(t: Transform): string {
      42           24 :   return `${t.x},${t.y},${t.w},${t.h},${t.rotation}`
      43              : }
      44              : 
      45           18 : function makePlaced(deps: RenderDeps, region: Rect, used: Set<string>) {
      46           18 :   return (
      47              :     cacheKey: string,
      48              :     contentStamp: string,
      49              :     bitmap: Bitmap,
      50              :     transform: Transform,
      51              :     linear = false
      52              :   ): NodeTexture | null => {
      53           24 :     const stamp = `${contentStamp}|${transformStamp(transform)}|${region.w}x${region.h}`
      54           24 :     const cache = deps.placedCache
      55           24 :     if (!cache) {
      56            0 :       const canvas = placeBitmap(bitmap, transform, region.w, region.h)
      57            0 :       return canvas
      58              :         ? { source: canvas, rect: region, linear, key: stamp }
      59              :         : null
      60              :     }
      61           24 :     used.add(cacheKey)
      62           24 :     const entry = cache.get(cacheKey)
      63           24 :     if (entry && entry.stamp === stamp) {
      64           16 :       return { source: entry.canvas, rect: region, linear, key: stamp }
      65              :     }
      66           24 :     const canvas = placeBitmap(
      67              :       bitmap,
      68              :       transform,
      69              :       region.w,
      70              :       region.h,
      71              :       entry?.canvas
      72              :     )
      73           24 :     if (!canvas) return null
      74            8 :     cache.set(cacheKey, { stamp, canvas })
      75            8 :     return { source: canvas, rect: region, linear, key: stamp }
      76              :   }
      77              : }
      78              : 
      79              : type PlacedFn = ReturnType<typeof makePlaced>
      80              : 
      81           24 : function renderMaskTexture(
      82              :   node: SceneNode,
      83              :   region: Rect,
      84              :   deps: RenderDeps,
      85              :   placed: PlacedFn,
      86              :   used: Set<string>
      87              : ): NodeTexture | undefined {
      88           24 :   const m = node.mask
      89           24 :   if (!m || !m.enabled) return undefined
      90           24 :   const tf =
      91              :     node.transform.w > 0 && node.transform.h > 0
      92              :       ? node.transform
      93              :       : { x: 0, y: 0, w: region.w, h: region.h, rotation: 0 }
      94           24 :   const override = deps.overrides?.get(`mask:${node.id}`)
      95           24 :   if (override) {
      96            0 :     return (
      97              :       renderPreviewTexture(
      98              :         `preview:mask:${node.id}`,
      99              :         override,
     100              :         tf,
     101              :         region,
     102              :         deps,
     103              :         used,
     104              :         true
     105              :       ) ?? undefined
     106              :     )
     107              :   }
     108           24 :   const bitmap = deps.content.get(m.contentId)?.canvas
     109           24 :   if (!bitmap) return undefined
     110           24 :   return placed(`mask:${node.id}`, m.contentId, bitmap, tf, true) ?? undefined
     111              : }
     112              : 
     113           24 : function renderLeafTexture(
     114              :   node: SceneNode,
     115              :   ctx: RenderNodeCtx,
     116              :   deps: RenderDeps,
     117              :   used: Set<string>
     118              : ): NodeTexture | null {
     119           24 :   const override = deps.overrides?.get(`content:${node.id}`)
     120           24 :   if (override) {
     121            0 :     const texture = renderPreviewTexture(
     122              :       `preview:content:${node.id}`,
     123              :       override,
     124              :       node.transform,
     125              :       ctx.region,
     126              :       deps,
     127              :       used,
     128              :       false
     129              :     )
     130            0 :     if (texture) return texture
     131              :   }
     132           24 :   return getNodeKind(node.kind).renderNode(node, ctx)
     133              : }
     134              : 
     135            0 : function renderPreviewTexture(
     136              :   cacheKey: string,
     137              :   override: PreviewOverride,
     138              :   transform: Transform,
     139              :   region: Rect,
     140              :   deps: RenderDeps,
     141              :   used: Set<string>,
     142              :   linear: boolean
     143              : ): NodeTexture | null {
     144            0 :   const cache = deps.placedCache
     145            0 :   if (!cache) {
     146            0 :     const canvas = placeBitmap(
     147              :       override.canvas,
     148              :       transform,
     149              :       region.w,
     150              :       region.h,
     151              :       undefined,
     152              :       null,
     153              :       true
     154              :     )
     155            0 :     return canvas ? { source: canvas, rect: region, linear } : null
     156              :   }
     157            0 :   used.add(cacheKey)
     158            0 :   const meta = `${transformStamp(transform)}|${region.w}x${region.h}`
     159            0 :   const stamp = `v${override.version}|${meta}`
     160            0 :   const entry = cache.get(cacheKey)
     161            0 :   if (entry && entry.stamp === stamp) {
     162            0 :     return {
     163              :       source: entry.canvas,
     164              :       rect: region,
     165              :       linear,
     166              :       key: cacheKey,
     167              :       version: override.version
     168              :     }
     169              :   }
     170            0 :   const prevVersion = entry
     171              :     ? Number(/^v(\d+)\|/.exec(entry.stamp)?.at(1) ?? NaN)
     172              :     : NaN
     173            0 :   const partial =
     174              :     entry &&
     175              :     entry.stamp.endsWith(`|${meta}`) &&
     176              :     prevVersion === override.version - 1
     177              :       ? (override.rects ?? null)
     178              :       : null
     179            0 :   let canvas: HTMLCanvasElement | null
     180            0 :   if (partial && entry) {
     181            0 :     canvas = entry.canvas
     182            0 :     for (const r of partial) {
     183            0 :       canvas = placeBitmap(
     184              :         override.canvas,
     185              :         transform,
     186              :         region.w,
     187              :         region.h,
     188              :         canvas,
     189              :         r,
     190              :         true
     191              :       )
     192            0 :       if (!canvas) break
     193              :     }
     194              :   } else {
     195            0 :     canvas = placeBitmap(
     196              :       override.canvas,
     197              :       transform,
     198              :       region.w,
     199              :       region.h,
     200              :       entry?.canvas,
     201              :       null,
     202              :       true
     203              :     )
     204              :   }
     205            0 :   if (!canvas) return null
     206            0 :   cache.set(cacheKey, { stamp, canvas })
     207            0 :   return {
     208              :     source: canvas,
     209              :     rect: region,
     210              :     linear,
     211              :     key: cacheKey,
     212              :     version: override.version,
     213              :     dirtyRects: partial ?? undefined
     214              :   }
     215              : }
     216              : 
     217           18 : function buildInputs(
     218              :   group: GroupData,
     219              :   doc: Document,
     220              :   deps: RenderDeps,
     221              :   used: Set<string>
     222              : ): BuiltInputs {
     223           18 :   const region: Rect = { x: 0, y: 0, w: doc.width, h: doc.height }
     224           18 :   const inputs: CompositeInput[] = []
     225           18 :   const cleanups: Array<() => void> = []
     226           18 :   const placed = makePlaced(deps, region, used)
     227           18 :   const ctx: RenderNodeCtx = {
     228              :     compositor: deps.compositor,
     229              :     content: deps.content,
     230              :     renderChild: () => null,
     231              :     placed,
     232              :     region,
     233              :     devicePixelRatio: deps.devicePixelRatio ?? 1
     234              :   }
     235              : 
     236           18 :   try {
     237           18 :     for (const node of group.children) {
     238           42 :       if (!node.visible || node.opacity <= 0) continue
     239              : 
     240           42 :       if (node.kind === 'group') {
     241            0 :         const g = node
     242            0 :         const sub = buildInputs(g, doc, deps, used)
     243            0 :         if (g.passThrough) {
     244            0 :           inputs.push(...sub.inputs)
     245            0 :           cleanups.push(sub.cleanup)
     246            0 :           continue
     247              :         }
     248            0 :         let handle: FBOHandle
     249            0 :         try {
     250            0 :           handle = deps.compositor.allocTarget(doc.width, doc.height)
     251              :         } catch (err) {
     252            0 :           sub.cleanup()
     253            0 :           throw err
     254              :         }
     255            0 :         try {
     256            0 :           deps.compositor.composite(sub.inputs, handle)
     257              :         } catch (err) {
     258            0 :           deps.compositor.freeTarget(handle)
     259            0 :           sub.cleanup()
     260            0 :           throw err
     261              :         }
     262            0 :         sub.cleanup()
     263            0 :         cleanups.push(() => deps.compositor.freeTarget(handle))
     264            0 :         const groupTexture = deps.compositor.targetTexture(handle)
     265            0 :         if (groupTexture) {
     266            0 :           inputs.push({
     267              :             texture: { source: groupTexture, rect: region, linear: true },
     268              :             opacity: node.opacity,
     269              :             mode: resolveMode(node.mode),
     270              :             mask: renderMaskTexture(node, region, deps, placed, used)
     271              :           })
     272              :         }
     273            0 :         continue
     274              :       }
     275              : 
     276           24 :       const texture = renderLeafTexture(node, ctx, deps, used)
     277           42 :       if (!texture) continue
     278           24 :       inputs.push({
     279              :         texture,
     280              :         opacity: node.opacity,
     281              :         mode: resolveMode(node.mode),
     282              :         mask: renderMaskTexture(node, region, deps, placed, used)
     283              :       })
     284              :     }
     285              :   } catch (err) {
     286            0 :     cleanups.forEach((fn) => fn())
     287            0 :     throw err
     288              :   }
     289              : 
     290           18 :   return { inputs, cleanup: () => cleanups.forEach((fn) => fn()) }
     291              : }
     292              : 
     293              : export function buildDocumentInputs(
     294              :   doc: Document,
     295              :   deps: RenderDeps
     296              : ): BuiltInputs {
     297              :   return buildInputs(doc.root, doc, deps, new Set())
     298              : }
     299              : 
     300           18 : export function renderDocument(
     301              :   doc: Document,
     302              :   deps: RenderDeps,
     303              :   extra?: CompositeInput[],
     304              :   region?: Rect | null
     305              : ): void {
     306           18 :   deps.compositor.beginFrame?.()
     307           18 :   const used = new Set<string>()
     308           18 :   const { inputs, cleanup } = buildInputs(doc.root, doc, deps, used)
     309           18 :   try {
     310           18 :     deps.compositor.composite(
     311              :       extra?.length ? [...inputs, ...extra] : inputs,
     312              :       null,
     313              :       region ?? undefined
     314              :     )
     315              :   } finally {
     316           18 :     cleanup()
     317              :   }
     318           18 :   if (deps.placedCache) {
     319           18 :     for (const key of Array.from(deps.placedCache.keys())) {
     320           24 :       if (!used.has(key)) deps.placedCache.delete(key)
     321              :     }
     322              :   }
     323              : }
        

Generated by: LCOV version 2.0-1