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 : }
|