Line data Source code
1 : import type {
2 : CompactSize,
3 : Point2D,
4 : CompactRect as Rect,
5 : Point2D as Vec2
6 : } from '@comfyorg/shared-frontend-utils/geometry'
7 : import { clamp } from 'es-toolkit'
8 : import { computed, reactive, ref } from 'vue'
9 :
10 : import { BakeRasterCommand, snapshotRaster } from '#/commands/bakeContent'
11 : import { PropCommand } from '#/commands/prop'
12 : import { SetTransformCommand } from '#/commands/setTransform'
13 : import type { Compositor } from '#/compositor'
14 : import { filterTopmost, findNode } from '#/document'
15 : import type { AlphaSampler } from '#/editor/pickOps'
16 : import { pickLayerAt } from '#/editor/pickOps'
17 : import { Dirty } from '#/history'
18 : import type { FillSpec } from '#/fill'
19 : import { fillKind, rasterKind } from '#/kinds/index'
20 : import type { BlendFn } from '#/mode'
21 : import { LAYER_MODES, defaultMode } from '#/mode'
22 : import type { FillData, SceneNode, Transform } from '#/node'
23 : import { placedBounds } from '#/render/bake'
24 : import type { OutsideCanvasPreviewLayer } from '#/render/outsideCanvasPreview'
25 : import { drawOutsideCanvasPreview } from '#/render/outsideCanvasPreview'
26 : import { createSession } from '#/session'
27 : import type { CanvasItem } from '#/tool'
28 : import { canTransformNode } from '#/tools/transformTool'
29 : import { hitHandle, unionBounds } from '#/tools/transformMath'
30 : import { createPanZoom } from '#/viewport/panZoom'
31 :
32 : export type LayerEditorPointerMode = 'pointer' | 'hand'
33 : export type LayerEditorAlignOp =
34 : | 'left'
35 : | 'centerH'
36 : | 'right'
37 : | 'top'
38 : | 'centerV'
39 : | 'bottom'
40 :
41 : export const CANVAS_SIZE_MIN = 64
42 2 : export const CANVAS_SIZE_MAX = 8192
43 :
44 2 : export const DEFAULT_BACKGROUND_COLOR = '#ffffff'
45 :
46 2 : const HEX_COLOR_RE = /^#[0-9a-fA-F]{6}$/
47 :
48 : export interface LayerEditorSessionOptions {
49 : createCompositor?: () => Compositor
50 : loadImage?: (url: string) => Promise<HTMLCanvasElement>
51 : alphaSampler?: AlphaSampler
52 : }
53 :
54 : export interface LayerEditorElements {
55 : viewport: HTMLElement
56 : container: HTMLElement
57 : main: HTMLCanvasElement
58 : overlay: HTMLCanvasElement
59 : }
60 :
61 4 : function loadImageElement(url: string): Promise<HTMLImageElement> {
62 4 : return new Promise((resolve, reject) => {
63 4 : const img = new Image()
64 4 : img.crossOrigin = 'anonymous'
65 4 : img.onload = () => resolve(img)
66 4 : img.onerror = () => reject(new Error(`failed to load image: ${url}`))
67 4 : img.src = url
68 : })
69 : }
70 :
71 4 : async function defaultLoadImage(url: string): Promise<HTMLCanvasElement> {
72 4 : const img = await loadImageElement(url)
73 4 : const canvas = document.createElement('canvas')
74 4 : canvas.width = img.naturalWidth || img.width
75 4 : canvas.height = img.naturalHeight || img.height
76 4 : canvas.getContext('2d')?.drawImage(img, 0, 0)
77 4 : return canvas
78 : }
79 :
80 2 : export function isTextEditingTarget(target: EventTarget | null): boolean {
81 2 : const el = target as HTMLElement | null
82 2 : const tag = el?.tagName
83 2 : return tag === 'INPUT' || tag === 'TEXTAREA' || Boolean(el?.isContentEditable)
84 : }
85 :
86 0 : function sameTransform(a: Transform, b: Transform): boolean {
87 0 : return (
88 : a.x === b.x &&
89 : a.y === b.y &&
90 : a.w === b.w &&
91 : a.h === b.h &&
92 : a.rotation === b.rotation
93 : )
94 : }
95 :
96 0 : function visualBounds(t: Transform): Rect {
97 0 : return t.rotation === 0 ? { x: t.x, y: t.y, w: t.w, h: t.h } : placedBounds(t)
98 : }
99 :
100 0 : function flipCanvasAxis(
101 : src: HTMLCanvasElement,
102 : axis: 'h' | 'v'
103 : ): HTMLCanvasElement | null {
104 0 : const canvas = document.createElement('canvas')
105 0 : canvas.width = src.width
106 0 : canvas.height = src.height
107 0 : const ctx = canvas.getContext('2d')
108 0 : if (!ctx) return null
109 0 : if (axis === 'h') {
110 0 : ctx.translate(src.width, 0)
111 0 : ctx.scale(-1, 1)
112 : } else {
113 0 : ctx.translate(0, src.height)
114 0 : ctx.scale(1, -1)
115 : }
116 0 : ctx.drawImage(src, 0, 0)
117 0 : return canvas
118 : }
119 :
120 : export type LayerEditorSession = ReturnType<typeof useLayerEditorSession>
121 :
122 2 : export function useLayerEditorSession(opts: LayerEditorSessionOptions = {}) {
123 2 : const loadImage = opts.loadImage ?? defaultLoadImage
124 2 : const version = ref(0)
125 2 : const activeNodeId = ref<string | null>(null)
126 2 : const glOk = ref(true)
127 2 : const zoomRatio = ref(1)
128 2 : const spaceDown = ref(false)
129 2 : const hoverCursor = ref('default')
130 2 : const pointerMode = ref<LayerEditorPointerMode>('pointer')
131 2 : const panning = ref(false)
132 :
133 2 : const flipParity = reactive(new Map<string, { h: boolean; v: boolean }>())
134 2 : const inputOrderIds: string[] = []
135 :
136 2 : const session = createSession({
137 : createCompositor: opts.createCompositor,
138 : onChange
139 : })
140 2 : const { editor, compositor } = session
141 2 : glOk.value = session.glOk
142 2 : const content = editor.content
143 :
144 2 : let mainCanvas: HTMLCanvasElement | null = null
145 2 : let overlayCanvas: HTMLCanvasElement | null = null
146 2 : let viewportEl: HTMLElement | null = null
147 2 : let containerEl: HTMLElement | null = null
148 2 : const panZoom = createPanZoom(() =>
149 : viewportEl && containerEl
150 : ? { viewport: viewportEl, container: containerEl }
151 : : null
152 : )
153 2 : panZoom.onChange(() => {
154 6 : zoomRatio.value = panZoom.zoom()
155 : })
156 :
157 2 : const layers = computed<SceneNode[]>(() => {
158 9 : void version.value
159 9 : return [...editor.document().root.children]
160 : })
161 2 : const backgroundLayer = computed<FillData | null>(() => {
162 9 : const first = layers.value[0]
163 9 : return first.kind === 'fill' ? { ...first } : null
164 : })
165 2 : const imageLayers = computed<SceneNode[]>(() =>
166 : layers.value.filter((n) => n.kind !== 'fill')
167 : )
168 2 : const activeNode = computed<SceneNode | null>(() => {
169 9 : void version.value
170 9 : const node = activeNodeId.value ? engineNode(activeNodeId.value) : null
171 9 : return node ? { ...node } : null
172 : })
173 2 : const selectedNodeIds = computed<string[]>(() => {
174 9 : void version.value
175 9 : return editor.selectedNodeIds()
176 : })
177 2 : const canUndo = computed(() => version.value >= 0 && editor.history.canUndo())
178 2 : const canRedo = computed(() => version.value >= 0 && editor.history.canRedo())
179 2 : const selectedContext = computed<'background' | 'layer'>(() => {
180 9 : void version.value
181 9 : const node = activeNodeId.value ? engineNode(activeNodeId.value) : null
182 9 : return node && node.kind !== 'fill' ? 'layer' : 'background'
183 : })
184 2 : const canvasSize = computed<CompactSize>(() => {
185 9 : void version.value
186 9 : const doc = editor.document()
187 9 : return { w: doc.width, h: doc.height }
188 : })
189 :
190 18 : function engineNode(id: string): SceneNode | null {
191 18 : return findNode(editor.document().root, id)?.node ?? null
192 : }
193 :
194 0 : function backgroundNode(): FillData | null {
195 0 : const first = editor.document().root.children[0]
196 0 : return first.kind === 'fill' ? first : null
197 : }
198 :
199 11 : function onChange(): void {
200 11 : version.value += 1
201 11 : activeNodeId.value = editor.activeNodeId()
202 11 : requestRender()
203 : }
204 :
205 11 : function present(): void {
206 11 : if (!mainCanvas) return
207 11 : const { width, height } = editor.document()
208 11 : const resized = mainCanvas.width !== width || mainCanvas.height !== height
209 11 : if (resized) {
210 4 : mainCanvas.width = width
211 4 : mainCanvas.height = height
212 : }
213 11 : const ctx = mainCanvas.getContext('2d')
214 11 : if (!ctx) return
215 11 : if (!glOk.value) {
216 0 : ctx.clearRect(0, 0, width, height)
217 0 : return
218 : }
219 11 : editor.setZoom(Math.max(0.01, panZoom.zoom()))
220 11 : const dmg = editor.takePresentDamage()
221 : const clean = !dmg.full && !dmg.rect
222 11 : if (clean && !resized) return
223 11 : if (dmg.rect && !dmg.full && !resized) {
224 0 : const img = compositor.readback(dmg.rect)
225 0 : ctx.putImageData(
226 : img,
227 : Math.max(0, Math.floor(dmg.rect.x)),
228 : Math.max(0, Math.floor(dmg.rect.y))
229 : )
230 0 : return
231 : }
232 9 : ctx.clearRect(0, 0, width, height)
233 9 : editor.render()
234 9 : ctx.putImageData(compositor.readback(), 0, 0)
235 : }
236 :
237 77 : function drawItem(
238 : ctx: CanvasRenderingContext2D,
239 : item: CanvasItem,
240 : hs: number
241 : ): void {
242 77 : switch (item.type) {
243 : case 'handle':
244 63 : ctx.beginPath()
245 63 : if (item.shape === 'circle')
246 7 : ctx.arc(item.pos.x, item.pos.y, hs, 0, Math.PI * 2)
247 56 : else ctx.rect(item.pos.x - hs, item.pos.y - hs, hs * 2, hs * 2)
248 63 : ctx.fill()
249 63 : ctx.stroke()
250 63 : break
251 : case 'line':
252 7 : ctx.beginPath()
253 7 : ctx.moveTo(item.a.x, item.a.y)
254 7 : ctx.lineTo(item.b.x, item.b.y)
255 7 : ctx.stroke()
256 7 : break
257 : case 'polyline':
258 7 : ctx.beginPath()
259 7 : item.points.forEach((p, i) =>
260 : i ? ctx.lineTo(p.x, p.y) : ctx.moveTo(p.x, p.y)
261 : )
262 7 : if (item.closed) ctx.closePath()
263 7 : if (item.ants) {
264 0 : ctx.save()
265 0 : ctx.strokeStyle = '#000000'
266 0 : ctx.stroke()
267 0 : ctx.strokeStyle = '#ffffff'
268 0 : ctx.setLineDash([hs, hs])
269 0 : ctx.stroke()
270 0 : ctx.restore()
271 : } else {
272 7 : ctx.stroke()
273 : }
274 7 : break
275 : case 'arc':
276 0 : ctx.beginPath()
277 0 : ctx.arc(item.center.x, item.center.y, item.radius, 0, Math.PI * 2)
278 0 : ctx.stroke()
279 0 : break
280 : case 'rect':
281 0 : if (item.ants) {
282 0 : ctx.save()
283 0 : ctx.strokeStyle = '#000000'
284 0 : ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
285 0 : ctx.strokeStyle = '#ffffff'
286 0 : ctx.setLineDash([hs, hs])
287 0 : ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
288 0 : ctx.restore()
289 : } else {
290 0 : ctx.strokeRect(item.rect.x, item.rect.y, item.rect.w, item.rect.h)
291 : }
292 0 : break
293 : case 'preview':
294 0 : ctx.drawImage(
295 : item.canvas,
296 : item.rect.x,
297 : item.rect.y,
298 : item.rect.w,
299 : item.rect.h
300 : )
301 : break
302 : }
303 : }
304 :
305 11 : function selectedOutsideCanvasPreviewLayers(): OutsideCanvasPreviewLayer[] {
306 11 : const selectedIds = new Set(editor.selectedNodeIds())
307 11 : const previewLayers: OutsideCanvasPreviewLayer[] = []
308 11 : for (const node of editor.document().root.children) {
309 23 : if (!selectedIds.has(node.id) || node.kind !== 'raster' || !node.visible)
310 16 : continue
311 23 : const bitmap = content.get(node.contentId)?.canvas
312 23 : if (bitmap)
313 7 : previewLayers.push({
314 : bitmap,
315 : opacity: node.opacity,
316 : transform: node.transform
317 : })
318 : }
319 11 : return previewLayers
320 : }
321 :
322 11 : function drawOverlayCanvas(): void {
323 11 : if (!overlayCanvas || !viewportEl || !containerEl) return
324 11 : const dpr = window.devicePixelRatio || 1
325 11 : const bw = Math.max(1, Math.round(viewportEl.clientWidth * dpr))
326 11 : const bh = Math.max(1, Math.round(viewportEl.clientHeight * dpr))
327 11 : if (overlayCanvas.width !== bw) overlayCanvas.width = bw
328 11 : if (overlayCanvas.height !== bh) overlayCanvas.height = bh
329 11 : editor.buildOverlay()
330 11 : const ctx = overlayCanvas.getContext('2d')
331 11 : if (!ctx) return
332 11 : ctx.setTransform(1, 0, 0, 1, 0, 0)
333 11 : ctx.clearRect(0, 0, bw, bh)
334 11 : const z = Math.max(0.01, panZoom.zoom())
335 11 : ctx.setTransform(
336 : z * dpr,
337 : 0,
338 : 0,
339 : z * dpr,
340 : containerEl.offsetLeft * dpr,
341 : containerEl.offsetTop * dpr
342 : )
343 11 : const { width, height } = editor.document()
344 11 : drawOutsideCanvasPreview(
345 : ctx,
346 : { w: width, h: height },
347 : selectedOutsideCanvasPreviewLayers()
348 : )
349 11 : ctx.lineWidth = 1 / z
350 11 : ctx.strokeStyle = '#3b82f6'
351 11 : ctx.fillStyle = '#ffffff'
352 11 : const hs = 4 / z
353 77 : for (const item of editor.overlay.items) drawItem(ctx, item, hs)
354 : }
355 :
356 2 : let disposed = false
357 2 : let rafId: number | null = null
358 19 : function requestRender(): void {
359 19 : if (disposed) return
360 19 : if (rafId == null)
361 11 : rafId = requestAnimationFrame(() => {
362 11 : rafId = null
363 11 : present()
364 11 : drawOverlayCanvas()
365 : })
366 : }
367 2 : let overlayRafId: number | null = null
368 0 : function requestOverlayRender(): void {
369 0 : if (disposed || rafId != null || overlayRafId != null) return
370 0 : overlayRafId = requestAnimationFrame(() => {
371 0 : overlayRafId = null
372 0 : drawOverlayCanvas()
373 : })
374 : }
375 :
376 2 : editor.setTool('transform')
377 :
378 2 : function setElements(els: LayerEditorElements): void {
379 2 : viewportEl = els.viewport
380 2 : containerEl = els.container
381 2 : mainCanvas = els.main
382 2 : overlayCanvas = els.overlay
383 2 : fitView()
384 : }
385 :
386 6 : function fitView(): void {
387 6 : panZoom.fit(editor.document().width, editor.document().height)
388 6 : requestRender()
389 : }
390 :
391 0 : function setZoom(ratio: number): void {
392 0 : panZoom.setZoom(ratio)
393 0 : requestRender()
394 : }
395 :
396 2 : function addBackgroundLayer(): void {
397 2 : editor.addNode(
398 : fillKind.create({
399 : name: 'Background',
400 : fill: { type: 'solid', color: DEFAULT_BACKGROUND_COLOR },
401 : opacity: 1,
402 : visible: false,
403 : locks: { content: true, position: true, visibility: false }
404 : }),
405 : 0
406 : )
407 : }
408 :
409 2 : async function loadImages(urls: string[], names: string[]): Promise<number> {
410 2 : flipParity.clear()
411 2 : inputOrderIds.length = 0
412 2 : let failed = 0
413 2 : let docWidth = 0
414 2 : let docHeight = 0
415 2 : for (const [i, url] of urls.entries()) {
416 4 : let canvas: HTMLCanvasElement
417 4 : try {
418 4 : canvas = await loadImage(url)
419 : } catch (err) {
420 0 : console.warn('[LayerEditor] failed to load image', url, err)
421 0 : failed += 1
422 0 : continue
423 : }
424 4 : if (disposed) return failed
425 4 : docWidth = Math.max(docWidth, canvas.width)
426 4 : docHeight = Math.max(docHeight, canvas.height)
427 4 : const contentId = content.register(canvas, { uploadedUrl: url })
428 4 : const layer = rasterKind.create({
429 : name: names[i],
430 : contentId,
431 : url,
432 : naturalWidth: canvas.width,
433 : naturalHeight: canvas.height,
434 : transform: {
435 : x: 0,
436 : y: 0,
437 : w: canvas.width,
438 : h: canvas.height,
439 : rotation: 0
440 : }
441 : })
442 4 : editor.addNode(layer)
443 4 : inputOrderIds.push(layer.id)
444 : }
445 2 : if (docWidth > 0 && docHeight > 0) {
446 2 : const width = Math.min(docWidth, CANVAS_SIZE_MAX)
447 2 : const height = Math.min(docHeight, CANVAS_SIZE_MAX)
448 2 : const doc = editor.document()
449 2 : doc.width = width
450 2 : doc.height = height
451 2 : if (glOk.value) compositor.resize(width, height)
452 : }
453 2 : editor.history.clear()
454 2 : fitView()
455 2 : requestRender()
456 2 : return failed
457 : }
458 :
459 0 : function editProp<T>(
460 : label: string,
461 : dirty: number,
462 : get: () => T,
463 : set: (v: T) => void,
464 : value: T,
465 : mergeKey?: string
466 : ): void {
467 0 : const before = get()
468 0 : if (before === value) return
469 0 : set(value)
470 0 : editor.history.push(
471 : new PropCommand(label, dirty, get, set, before, value, mergeKey)
472 : )
473 0 : editor.invalidate()
474 : }
475 :
476 0 : function selectionTargets(id: string): string[] {
477 0 : const sel = editor.selectedNodeIds()
478 0 : return sel.length > 1 && sel.includes(id) ? sel : [id]
479 : }
480 :
481 0 : function batch(
482 : label: string,
483 : ids: string[],
484 : apply: (id: string) => void
485 : ): void {
486 0 : if (ids.length > 1) editor.history.beginGroup(label)
487 0 : for (const tid of ids) apply(tid)
488 0 : if (ids.length > 1) editor.history.endGroup()
489 : }
490 :
491 0 : function setOpacity(id: string, v: number): void {
492 0 : batch('Opacity', selectionTargets(id), (tid) => {
493 0 : const n = engineNode(tid)
494 0 : if (!n) return
495 0 : editProp(
496 : 'Opacity',
497 : Dirty.META,
498 : () => n.opacity,
499 : (x) => (n.opacity = x),
500 : clamp(v, 0, 1),
501 : `opacity:${tid}`
502 : )
503 : })
504 : }
505 :
506 0 : function setBlendMode(id: string, v: BlendFn): void {
507 0 : batch('Blend', selectionTargets(id), (tid) => {
508 0 : const n = engineNode(tid)
509 0 : if (!n) return
510 0 : editProp(
511 : 'Blend',
512 : Dirty.DRAWABLE,
513 : () => n.mode,
514 : (m) => (n.mode = m),
515 : defaultMode(Object.hasOwn(LAYER_MODES, v) ? v : 'normal'),
516 : `blend:${tid}`
517 : )
518 : })
519 : }
520 :
521 0 : function toggleVisible(id: string): void {
522 0 : const n = engineNode(id)
523 0 : if (!n) return
524 0 : editProp(
525 : 'Visibility',
526 : Dirty.META,
527 : () => n.visible,
528 : (x) => (n.visible = x),
529 : !n.visible
530 : )
531 : }
532 :
533 0 : function renameLayer(id: string, name: string): void {
534 0 : const n = engineNode(id)
535 0 : if (!n) return
536 0 : editProp(
537 : 'Rename',
538 : Dirty.META,
539 : () => n.name,
540 : (x) => (n.name = x),
541 : name.trim() || n.name
542 : )
543 : }
544 :
545 0 : function inputLayerIds(): string[] {
546 0 : return [...inputOrderIds]
547 : }
548 :
549 0 : function setLayerOrder(ids: string[]): void {
550 0 : const offset = backgroundLayer.value ? 1 : 0
551 0 : ids.forEach((id, index) => {
552 0 : editor.moveNodeTo(id, undefined, offset + index)
553 : })
554 : }
555 :
556 0 : function moveLayerTo(id: string, toIndex: number): void {
557 0 : const bg = backgroundLayer.value
558 0 : if (bg && (id === bg.id || toIndex < 1)) return
559 0 : editor.moveNodeTo(id, undefined, toIndex)
560 : }
561 :
562 1 : function moveLayer(id: string, dir: 1 | -1): void {
563 1 : const bg = backgroundLayer.value
564 1 : if (bg) {
565 1 : if (id === bg.id) return
566 1 : const index = editor
567 : .document()
568 : .root.children.findIndex((n) => n.id === id)
569 1 : if (dir === -1 && index !== -1 && index <= 1) return
570 : }
571 1 : editor.moveNode(id, dir)
572 : }
573 :
574 2 : function setActiveNode(id: string | null): void {
575 2 : editor.setActiveNode(id)
576 : }
577 :
578 0 : function setSelectedNodes(ids: string[]): void {
579 0 : editor.setSelectedNodes(ids)
580 : }
581 :
582 0 : function selectBackground(): void {
583 0 : const bg = backgroundLayer.value
584 0 : editor.setSelectedNodes(bg ? [bg.id] : [])
585 : }
586 :
587 0 : function setBackgroundColor(hex: string): void {
588 0 : const bg = backgroundNode()
589 0 : if (!bg || !HEX_COLOR_RE.test(hex)) return
590 0 : const color = hex.toLowerCase()
591 0 : if (bg.fill.type === 'solid' && bg.fill.color === color) return
592 0 : editProp<FillSpec>(
593 : 'Background Color',
594 : Dirty.DRAWABLE,
595 : () => bg.fill,
596 : (v) => (bg.fill = v),
597 : { type: 'solid', color },
598 : `bg-color:${bg.id}`
599 : )
600 : }
601 :
602 0 : function setBackgroundOpacity(v: number): void {
603 0 : const bg = backgroundNode()
604 0 : if (!bg) return
605 0 : editProp(
606 : 'Background Opacity',
607 : Dirty.META,
608 : () => bg.opacity,
609 : (x) => (bg.opacity = x),
610 : clamp(v, 0, 1),
611 : `bg-opacity:${bg.id}`
612 : )
613 : }
614 :
615 0 : function setBackgroundVisible(visible: boolean): void {
616 0 : const bg = backgroundNode()
617 0 : if (!bg) return
618 0 : editProp(
619 : 'Background Visibility',
620 : Dirty.META,
621 : () => bg.visible,
622 : (x) => (bg.visible = x),
623 : visible
624 : )
625 : }
626 :
627 0 : function setPointerMode(mode: LayerEditorPointerMode): void {
628 0 : pointerMode.value = mode
629 : }
630 :
631 0 : function shiftLayers(nodes: SceneNode[], dx: number, dy: number): void {
632 0 : if (dx === 0 && dy === 0) return
633 0 : for (const n of nodes) {
634 0 : if (n.kind === 'fill') continue
635 0 : n.transform = {
636 : ...n.transform,
637 : x: n.transform.x + dx,
638 : y: n.transform.y + dy
639 : }
640 0 : if (n.kind === 'group') shiftLayers(n.children, dx, dy)
641 : }
642 : }
643 :
644 0 : function setCanvasSize(w: number, h: number): void {
645 0 : const doc = editor.document()
646 0 : const width = clamp(Math.round(w), CANVAS_SIZE_MIN, CANVAS_SIZE_MAX)
647 0 : const height = clamp(Math.round(h), CANVAS_SIZE_MIN, CANVAS_SIZE_MAX)
648 0 : const before = { w: doc.width, h: doc.height }
649 0 : if (before.w === width && before.h === height) return
650 0 : const apply = (v: CompactSize): void => {
651 0 : const dx = Math.trunc((v.w - doc.width) / 2)
652 0 : const dy = Math.trunc((v.h - doc.height) / 2)
653 0 : doc.width = v.w
654 0 : doc.height = v.h
655 0 : if (glOk.value) compositor.resize(v.w, v.h)
656 0 : shiftLayers(doc.root.children, dx, dy)
657 0 : panZoom.setArtboardSize(v.w, v.h)
658 0 : panZoom.panBy(-dx * panZoom.zoom(), -dy * panZoom.zoom())
659 : }
660 0 : apply({ w: width, h: height })
661 0 : editor.history.push(
662 : new PropCommand(
663 : 'Canvas Size',
664 : Dirty.STRUCTURE,
665 : () => ({ w: doc.width, h: doc.height }),
666 : apply,
667 : before,
668 : { w: width, h: height }
669 : )
670 : )
671 0 : editor.invalidate()
672 : }
673 :
674 0 : function pushLayerTransform(
675 : label: string,
676 : id: string,
677 : patch: Partial<Transform>
678 : ): void {
679 0 : const n = engineNode(id)
680 0 : if (!n || n.locks.position) return
681 0 : const before = { ...n.transform }
682 0 : const after = { ...before, ...patch }
683 0 : if (sameTransform(before, after)) return
684 0 : n.transform = after
685 0 : editor.history.push(new SetTransformCommand(label, n, before, after))
686 0 : editor.invalidate()
687 : }
688 :
689 0 : function setLayerPosition(id: string, x?: number, y?: number): void {
690 0 : const patch: Partial<Transform> = {}
691 0 : if (x !== undefined && Number.isFinite(x)) patch.x = x
692 0 : if (y !== undefined && Number.isFinite(y)) patch.y = y
693 0 : pushLayerTransform('Position', id, patch)
694 : }
695 :
696 0 : function setLayerDimensions(id: string, w?: number, h?: number): void {
697 0 : const patch: Partial<Transform> = {}
698 0 : if (w !== undefined && Number.isFinite(w)) patch.w = Math.max(1, w)
699 0 : if (h !== undefined && Number.isFinite(h)) patch.h = Math.max(1, h)
700 0 : pushLayerTransform('Dimensions', id, patch)
701 : }
702 :
703 0 : function setLayerRotationDeg(id: string, deg: number): void {
704 0 : if (!Number.isFinite(deg)) return
705 0 : pushLayerTransform('Rotation', id, { rotation: (deg * Math.PI) / 180 })
706 : }
707 :
708 0 : function alignLayer(id: string, op: LayerEditorAlignOp): void {
709 0 : const doc = editor.document()
710 0 : batch('Align', selectionTargets(id), (tid) => {
711 0 : const n = engineNode(tid)
712 0 : if (!n || n.locks.position) return
713 0 : const b = visualBounds(n.transform)
714 0 : switch (op) {
715 : case 'left':
716 0 : pushLayerTransform('Align', tid, { x: n.transform.x - b.x })
717 0 : break
718 : case 'centerH':
719 0 : pushLayerTransform('Align', tid, {
720 : x: n.transform.x + ((doc.width - b.w) / 2 - b.x)
721 : })
722 0 : break
723 : case 'right':
724 0 : pushLayerTransform('Align', tid, {
725 : x: n.transform.x + (doc.width - b.w - b.x)
726 : })
727 0 : break
728 : case 'top':
729 0 : pushLayerTransform('Align', tid, { y: n.transform.y - b.y })
730 0 : break
731 : case 'centerV':
732 0 : pushLayerTransform('Align', tid, {
733 : y: n.transform.y + ((doc.height - b.h) / 2 - b.y)
734 : })
735 0 : break
736 : case 'bottom':
737 0 : pushLayerTransform('Align', tid, {
738 : y: n.transform.y + (doc.height - b.h - b.y)
739 : })
740 : break
741 : }
742 : })
743 : }
744 :
745 0 : function flipLayer(id: string, axis: 'h' | 'v'): void {
746 0 : const n = engineNode(id)
747 0 : if (!n || n.kind !== 'raster' || n.locks.content) return
748 0 : const entry = content.get(n.contentId)
749 0 : if (!entry) return
750 0 : const flipped = flipCanvasAxis(entry.canvas, axis)
751 0 : if (!flipped) return
752 0 : const before = snapshotRaster(n)
753 0 : n.contentId = content.register(flipped)
754 0 : n.url = undefined
755 0 : if (n.mask) {
756 0 : const maskEntry = content.get(n.mask.contentId)
757 0 : const flippedMask = maskEntry
758 : ? flipCanvasAxis(maskEntry.canvas, axis)
759 : : null
760 0 : if (flippedMask) {
761 0 : n.mask = {
762 : ...n.mask,
763 : contentId: content.register(flippedMask),
764 : url: undefined
765 : }
766 : }
767 : }
768 0 : const parityBefore = layerFlips(id)
769 0 : const parityAfter =
770 : axis === 'h'
771 : ? { ...parityBefore, h: !parityBefore.h }
772 : : { ...parityBefore, v: !parityBefore.v }
773 0 : const setParity = (p: { h: boolean; v: boolean }): void => {
774 0 : flipParity.set(id, p)
775 : }
776 0 : setParity(parityAfter)
777 0 : editor.history.beginGroup('Flip Layer')
778 0 : editor.history.push(
779 : new BakeRasterCommand('Flip Layer', n, before, snapshotRaster(n), content)
780 : )
781 0 : editor.history.push(
782 : new PropCommand(
783 : 'Flip Layer',
784 : Dirty.META,
785 : () => layerFlips(id),
786 : setParity,
787 : parityBefore,
788 : parityAfter
789 : )
790 : )
791 0 : editor.history.endGroup()
792 0 : editor.invalidate()
793 : }
794 :
795 0 : function layerFlips(id: string): { h: boolean; v: boolean } {
796 0 : return flipParity.get(id) ?? { h: false, v: false }
797 : }
798 :
799 1 : function undo(): void {
800 1 : editor.undo()
801 : }
802 :
803 1 : function redo(): void {
804 1 : editor.redo()
805 : }
806 :
807 0 : function artboardPt(e: PointerEvent): Point2D {
808 0 : return panZoom.screenToArtboard(e.clientX, e.clientY)
809 : }
810 :
811 2 : let panLast = { x: 0, y: 0 }
812 2 : let toolActive = false
813 2 : let pendingMoves: PointerEvent[] = []
814 2 : let moveRaf: number | null = null
815 :
816 0 : function capturePointer(zone: HTMLElement, e: PointerEvent): void {
817 0 : try {
818 0 : zone.setPointerCapture(e.pointerId)
819 : } catch {
820 : void 0
821 : }
822 : }
823 :
824 0 : function selectedTransformTargets(): SceneNode[] {
825 0 : const root = editor.document().root
826 0 : return filterTopmost(root, editor.selectedNodeIds())
827 : .map((id) => findNode(root, id)?.node ?? null)
828 : .filter((n): n is SceneNode => canTransformNode(n))
829 : }
830 :
831 0 : function selectionGizmo(): Transform | null {
832 0 : const targets = selectedTransformTargets()
833 0 : if (!targets.length) return null
834 0 : return targets.length === 1
835 : ? { ...targets[0].transform }
836 : : unionBounds(targets.map((n) => n.transform))
837 : }
838 :
839 0 : function resolvePointerTarget(e: PointerEvent, pt: Vec2): boolean {
840 0 : if (editor.floating()) return true
841 0 : const additive = e.shiftKey || e.ctrlKey || e.metaKey
842 0 : if (!additive) {
843 0 : const gizmo = selectionGizmo()
844 0 : const tol = 8 / Math.max(1e-3, panZoom.zoom())
845 0 : if (gizmo && hitHandle(gizmo, pt, tol)) return true
846 : }
847 0 : const picked = pickLayerAt(
848 : editor.document().root.children,
849 : pt,
850 : content,
851 : opts.alphaSampler
852 : )
853 0 : if (!picked) {
854 0 : if (!additive) editor.setSelectedNodes([])
855 0 : return false
856 : }
857 0 : const sel = editor.selectedNodeIds()
858 0 : if (additive) {
859 0 : editor.setSelectedNodes(
860 : sel.includes(picked.id)
861 : ? sel.filter((sid) => sid !== picked.id)
862 : : [...sel, picked.id]
863 : )
864 0 : } else if (!sel.includes(picked.id)) {
865 0 : editor.setSelectedNodes([picked.id])
866 : }
867 0 : return true
868 : }
869 :
870 0 : function onPointerDown(e: PointerEvent): void {
871 0 : const zone = viewportEl
872 0 : if (!zone) return
873 0 : zone.focus()
874 0 : pendingMoves = []
875 0 : if (
876 : e.button === 1 ||
877 : e.button === 2 ||
878 : (e.button === 0 && (spaceDown.value || pointerMode.value === 'hand'))
879 : ) {
880 0 : panning.value = true
881 0 : panLast = { x: e.offsetX, y: e.offsetY }
882 0 : capturePointer(zone, e)
883 0 : return
884 : }
885 0 : if (e.button !== 0) return
886 0 : if (!resolvePointerTarget(e, artboardPt(e))) return
887 0 : editor.pointerDown(e, artboardPt(e))
888 0 : toolActive = true
889 0 : capturePointer(zone, e)
890 : }
891 :
892 0 : function flushMove(): void {
893 0 : moveRaf = null
894 0 : const events = pendingMoves
895 0 : pendingMoves = []
896 0 : const e = events.at(-1)
897 0 : if (!e) return
898 0 : if (panning.value) {
899 0 : panZoom.panBy(e.offsetX - panLast.x, e.offsetY - panLast.y)
900 0 : panLast = { x: e.offsetX, y: e.offsetY }
901 0 : requestOverlayRender()
902 0 : return
903 : }
904 0 : if (toolActive) {
905 0 : editor.pointerMove(e, artboardPt(e))
906 : } else {
907 0 : hoverCursor.value = editor.cursorAt(artboardPt(e))
908 : }
909 : }
910 :
911 0 : function onPointerMove(e: PointerEvent): void {
912 0 : pendingMoves.push(e)
913 0 : if (moveRaf == null) moveRaf = requestAnimationFrame(flushMove)
914 : }
915 :
916 0 : function endToolGesture(e: PointerEvent): void {
917 0 : editor.pointerUp(e, artboardPt(e))
918 0 : editor.transformApply()
919 0 : toolActive = false
920 : }
921 :
922 0 : function onPointerUp(e: PointerEvent): void {
923 0 : if (moveRaf != null) {
924 0 : cancelAnimationFrame(moveRaf)
925 0 : flushMove()
926 : }
927 0 : if (panning.value) {
928 0 : panning.value = false
929 0 : } else if (toolActive) {
930 0 : endToolGesture(e)
931 : }
932 0 : try {
933 0 : viewportEl?.releasePointerCapture(e.pointerId)
934 : } catch {
935 : void 0
936 : }
937 : }
938 :
939 2 : function onPointerLeave(e: PointerEvent): void {
940 2 : if (toolActive) endToolGesture(e)
941 : }
942 :
943 0 : function onWheel(e: WheelEvent): void {
944 0 : panZoom.handleWheel(e)
945 0 : requestRender()
946 : }
947 :
948 2 : const viewportCursor = computed(() => {
949 2 : if (panning.value) return 'grabbing'
950 2 : if (spaceDown.value || pointerMode.value === 'hand') return 'grab'
951 2 : return hoverCursor.value
952 : })
953 :
954 0 : function onKeyDown(e: KeyboardEvent): void {
955 0 : if (isTextEditingTarget(e.target)) return
956 0 : const ctrl = e.ctrlKey || e.metaKey
957 0 : if (editor.floating()) {
958 0 : if (e.key === 'Enter') {
959 0 : e.preventDefault()
960 0 : editor.anchorFloating()
961 0 : return
962 : }
963 : }
964 0 : if (e.key === 'Enter') {
965 0 : e.preventDefault()
966 0 : editor.transformApply()
967 0 : return
968 : }
969 0 : if (e.code === 'Space') {
970 0 : spaceDown.value = true
971 0 : e.preventDefault()
972 0 : return
973 : }
974 0 : if (ctrl && e.code === 'KeyZ') {
975 0 : e.preventDefault()
976 0 : if (e.shiftKey) redo()
977 0 : else undo()
978 0 : return
979 : }
980 0 : if (ctrl && e.code === 'KeyY') {
981 0 : e.preventDefault()
982 0 : redo()
983 0 : return
984 : }
985 0 : if (ctrl && e.code === 'KeyA') {
986 0 : e.preventDefault()
987 0 : editor.selectAll()
988 0 : return
989 : }
990 0 : if (ctrl && e.code === 'KeyD') {
991 0 : e.preventDefault()
992 0 : editor.selectNone()
993 : }
994 : }
995 :
996 0 : function onKeyUp(e: KeyboardEvent): void {
997 0 : if (e.code === 'Space') spaceDown.value = false
998 : }
999 :
1000 0 : function dispose(): void {
1001 0 : disposed = true
1002 0 : if (rafId != null) cancelAnimationFrame(rafId)
1003 0 : if (overlayRafId != null) cancelAnimationFrame(overlayRafId)
1004 0 : if (moveRaf != null) cancelAnimationFrame(moveRaf)
1005 0 : rafId = null
1006 0 : overlayRafId = null
1007 0 : moveRaf = null
1008 0 : session.dispose()
1009 : }
1010 :
1011 2 : addBackgroundLayer()
1012 2 : editor.history.clear()
1013 :
1014 2 : return {
1015 : editor,
1016 : content,
1017 : compositor,
1018 : panZoom,
1019 : version,
1020 : glOk,
1021 : zoomRatio,
1022 : layers,
1023 : backgroundLayer,
1024 : imageLayers,
1025 : activeNodeId,
1026 : activeNode,
1027 : selectedNodeIds,
1028 : selectedContext,
1029 : canvasSize,
1030 : canUndo,
1031 : canRedo,
1032 : pointerMode,
1033 : viewportCursor,
1034 : setElements,
1035 : fitView,
1036 : setZoom,
1037 : requestRender,
1038 : loadImages,
1039 : setOpacity,
1040 : setBlendMode,
1041 : toggleVisible,
1042 : renameLayer,
1043 : moveLayer,
1044 : moveLayerTo,
1045 : setLayerOrder,
1046 : inputLayerIds,
1047 : setActiveNode,
1048 : setSelectedNodes,
1049 : selectBackground,
1050 : setBackgroundColor,
1051 : setBackgroundOpacity,
1052 : setBackgroundVisible,
1053 : setPointerMode,
1054 : setCanvasSize,
1055 : setLayerPosition,
1056 : setLayerDimensions,
1057 : setLayerRotationDeg,
1058 : alignLayer,
1059 : flipLayer,
1060 : layerFlips,
1061 : undo,
1062 : redo,
1063 : onPointerDown,
1064 : onPointerMove,
1065 : onPointerUp,
1066 : onPointerLeave,
1067 : onWheel,
1068 : onKeyDown,
1069 : onKeyUp,
1070 : dispose
1071 : }
1072 : }
|