diff --git a/src/components/graph/GraphCanvas.vue b/src/components/graph/GraphCanvas.vue index 967b8f00f32..33232ce08a9 100644 --- a/src/components/graph/GraphCanvas.vue +++ b/src/components/graph/GraphCanvas.vue @@ -165,6 +165,7 @@ import WorkflowTabs from '@/components/topbar/WorkflowTabs.vue' import { useChainCallback } from '@/composables/functional/useChainCallback' import { useGroupContextMenu } from '@/composables/graph/useGroupContextMenu' import { installErrorClearingHooks } from '@/composables/graph/useErrorClearingHooks' +import { useViewportCulling } from '@/composables/graph/useViewportCulling' import type { NodeState } from '@/types/nodeState' import { useNodeBadge } from '@/composables/node/useNodeBadge' import { useCanvasDrop } from '@/composables/useCanvasDrop' @@ -189,6 +190,7 @@ import { useCanvasInteractions } from '@/renderer/core/canvas/useCanvasInteracti import { arrangeForLegacyRender } from '@/renderer/core/canvas/litegraph/arrangeForLegacyRender' import { notifyLayoutChanges } from '@/renderer/core/canvas/litegraph/notifyLayoutChanges' import { layoutStore } from '@/renderer/core/layout/store/layoutStore' +import { useTransformSettling } from '@/renderer/core/layout/transform/useTransformSettling' import TransformPane from '@/renderer/core/layout/transform/TransformPane.vue' import type { StartupOutcome } from '@/platform/workflow/persistence/base/draftTypes' import { useFirstRunEntry } from '@/renderer/extensions/firstRunTour/gettingStarted/firstRunEntry' @@ -317,12 +319,34 @@ watch( ) const nodeDataStore = useNodeDataStore() -const allNodes = computed((): NodeState[] => { +const rootGraphId = computed(() => canvasStore.rootGraphId) +const rawNodes = computed((): NodeState[] => { const { rootGraphId } = canvasStore const graphId = canvasStore.currentGraph?.id if (!rootGraphId || graphId === undefined) return [] return nodeDataStore.getGraphNodesFor(rootGraphId, graphId) }) + +const canvasElement = computed(() => canvasStore.canvas?.canvas) +const { isTransforming } = useTransformSettling(canvasElement, { + settleDelay: 256 +}) + +const { mountedNodeIds } = useViewportCulling({ + rawNodes, + rootGraphId, + getViewportSize: () => { + const rect = canvasStore.canvas?.canvas?.getBoundingClientRect() + return { width: rect?.width ?? 0, height: rect?.height ?? 0 } + }, + isTransforming, + canvasElement +}) + +const allNodes = computed(() => + rawNodes.value.filter((node) => mountedNodeIds.value.has(node.id)) +) + function onLinkOverlayReady(el: HTMLCanvasElement) { if (!canvasStore.canvas) return canvasStore.canvas.overlayCanvas = el diff --git a/src/composables/graph/useViewportCulling.test.ts b/src/composables/graph/useViewportCulling.test.ts new file mode 100644 index 00000000000..740ba93165b --- /dev/null +++ b/src/composables/graph/useViewportCulling.test.ts @@ -0,0 +1,270 @@ +import { beforeEach, describe, expect, it, vi } from 'vitest' +import { computed, nextTick, ref } from 'vue' + +import type { NodeId, NodeLayout } from '@/renderer/core/layout/types' +import type { NodeState } from '@/types/nodeState' +import type { UUID } from '@/utils/uuid' + +const mockIsNodeInViewport = vi.fn() +const mockGetNodeLayout = vi.fn() + +vi.mock('@/renderer/core/layout/transform/useTransformState', () => ({ + useTransformState: () => ({ + isNodeInViewport: mockIsNodeInViewport, + camera: { x: 0, y: 0, z: 1 } + }) +})) + +vi.mock('@/renderer/core/layout/store/layoutStore', () => ({ + layoutStore: { + getNodeLayout: (...args: unknown[]) => mockGetNodeLayout(...args), + get nodeGeometryVersion() { + return mockGeometryVersion.value + } + } +})) + +const mockGeometryVersion = ref(0) + +// Must import after mock setup +const { useViewportCulling } = + await import('@/composables/graph/useViewportCulling') + +const ROOT_GRAPH_ID = 'root-graph' as UUID + +function makeNode(id: string): NodeState { + return { + id: id as NodeId, + graphId: ROOT_GRAPH_ID as unknown as NodeState['graphId'], + title: `Node ${id}`, + type: 'test', + mode: 0, + flags: {}, + inputs: [], + outputs: [], + properties: {} + } +} + +let layoutCounter = 0 + +function makeLayout(x: number, y: number, w = 200, h = 100): NodeLayout { + return { + id: `layout-${layoutCounter++}` as NodeId, + position: { x, y }, + size: { width: w, height: h }, + bounds: { x, y, width: w, height: h }, + zIndex: 0, + visible: true + } +} + +/** Wires the getNodeLayout mock to look up layouts from a plain id->layout map. */ +function useLayouts(layouts: Map) { + mockGetNodeLayout.mockImplementation((_graphId: UUID, nodeId: NodeId) => + layouts.get(nodeId as unknown as string) + ) +} + +describe('useViewportCulling', () => { + const isTransforming = ref(false) + const viewport = { width: 1000, height: 600 } + const rootGraphId = computed(() => ROOT_GRAPH_ID) + + beforeEach(() => { + vi.useFakeTimers() + isTransforming.value = false + mockGeometryVersion.value = 0 + mockIsNodeInViewport.mockReturnValue(true) + mockGetNodeLayout.mockReturnValue(undefined) + }) + + it('mounts all nodes when all are visible', () => { + const nodes = [makeNode('1'), makeNode('2'), makeNode('3')] + useLayouts( + new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(300, 100)], + ['3', makeLayout(500, 100)] + ]) + ) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(3) + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(true) + expect(mountedNodeIds.value.has('3')).toBe(true) + }) + + it('culls nodes outside the viewport after debounce', async () => { + const nodes = [makeNode('1'), makeNode('2')] + useLayouts( + new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + ) + + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 2000 && pos[1] < 2000 + ) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + // Node 2 is outside viewport, but hasn't been pruned yet on + // initial mount since it was never in the set to begin with + // and computeVisibleNodeIds runs immediately + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(false) + }) + + it('mounts nodes without layout data', () => { + const nodes = [makeNode('1'), makeNode('2')] + useLayouts( + new Map([ + ['1', makeLayout(100, 100)] + // Node '2' has no layout + ]) + ) + + mockIsNodeInViewport.mockReturnValue(true) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(true) + }) + + it('mounts all nodes when viewport size is zero', () => { + const nodes = [makeNode('1'), makeNode('2')] + useLayouts( + new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + ) + + mockIsNodeInViewport.mockReturnValue(false) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes), + rootGraphId, + getViewportSize: () => ({ width: 0, height: 0 }), + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(2) + }) + + it('delays unmounting nodes that leave the viewport', async () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(300, 100)] + ]) + useLayouts(layouts) + + mockIsNodeInViewport.mockReturnValue(true) + + const rawNodes = ref(nodes) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => rawNodes.value), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(2) + + // Node 2 leaves viewport + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 200 + ) + + // Trigger a refresh by bumping the geometry version + mockGeometryVersion.value++ + await nextTick() + + // Node 2 should still be mounted (debounce hasn't fired) + expect(mountedNodeIds.value.has('2')).toBe(true) + + // After debounce delay, node 2 should be unmounted + await vi.advanceTimersByTimeAsync(300) + + expect(mountedNodeIds.value.has('1')).toBe(true) + expect(mountedNodeIds.value.has('2')).toBe(false) + }) + + it('immediately mounts nodes entering the viewport', async () => { + const nodes = [makeNode('1'), makeNode('2')] + const layouts = new Map([ + ['1', makeLayout(100, 100)], + ['2', makeLayout(5000, 5000)] + ]) + useLayouts(layouts) + + mockIsNodeInViewport.mockImplementation( + (pos: [number, number]) => pos[0] < 2000 + ) + + const rawNodes = ref(nodes) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => rawNodes.value), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.has('2')).toBe(false) + + // Node 2 enters viewport + mockIsNodeInViewport.mockReturnValue(true) + mockGeometryVersion.value++ + await nextTick() + + // Should be immediately mounted without waiting for debounce + expect(mountedNodeIds.value.has('2')).toBe(true) + }) + + it('handles new nodes being added to the graph', async () => { + const nodes = ref([makeNode('1')]) + const layouts = new Map([['1', makeLayout(100, 100)]]) + useLayouts(layouts) + + mockIsNodeInViewport.mockReturnValue(true) + + const { mountedNodeIds } = useViewportCulling({ + rawNodes: computed(() => nodes.value), + rootGraphId, + getViewportSize: () => viewport, + isTransforming + }) + + expect(mountedNodeIds.value.size).toBe(1) + + // Add a new node + nodes.value = [...nodes.value, makeNode('2')] + layouts.set('2', makeLayout(200, 200)) + await nextTick() + + expect(mountedNodeIds.value.has('2')).toBe(true) + }) +}) diff --git a/src/composables/graph/useViewportCulling.ts b/src/composables/graph/useViewportCulling.ts new file mode 100644 index 00000000000..d8b1db6a0b5 --- /dev/null +++ b/src/composables/graph/useViewportCulling.ts @@ -0,0 +1,155 @@ +/** + * Viewport Culling for Vue Node Components + * + * Controls which nodes are mounted as Vue components based on viewport + * visibility. Nodes entering the viewport are mounted immediately; nodes + * leaving are unmounted after a debounce delay to avoid mount/unmount + * churn when nodes oscillate at the viewport edge during panning. + * + * Visibility checks are throttled during active pan/zoom interactions + * to avoid turning culling into a per-frame reactive hotspot. + */ +import { + useDebounceFn, + useEventListener, + useResizeObserver, + useThrottleFn +} from '@vueuse/core' +import { shallowRef, watch } from 'vue' +import type { ComputedRef, Ref } from 'vue' + +import { useTransformState } from '@/renderer/core/layout/transform/useTransformState' +import { layoutStore } from '@/renderer/core/layout/store/layoutStore' +import type { NodeState } from '@/types/nodeState' +import type { UUID } from '@/utils/uuid' + +/** Viewport margin as a fraction of viewport dimensions (0.75 = 75% extra) */ +const VIEWPORT_MARGIN = 0.75 + +/** Delay before unmounting nodes that left the viewport */ +const HIDE_DELAY_MS = 250 + +/** Throttle interval for visibility recomputation during pan/zoom */ +const CULL_THROTTLE_MS = 96 + +interface UseViewportCullingOptions { + rawNodes: ComputedRef + rootGraphId: ComputedRef + getViewportSize: () => { width: number; height: number } + isTransforming: Ref + canvasElement?: Ref +} + +export function useViewportCulling({ + rawNodes, + rootGraphId, + getViewportSize, + isTransforming, + canvasElement +}: UseViewportCullingOptions) { + const { isNodeInViewport } = useTransformState() + const mountedNodeIds = shallowRef(new Set()) + + function computeVisibleNodeIds(): Set { + const viewport = getViewportSize() + const graphId = rootGraphId.value + const visible = new Set() + + if (!viewport.width || !viewport.height || !graphId) { + for (const node of rawNodes.value) visible.add(node.id) + return visible + } + + for (const node of rawNodes.value) { + const layout = layoutStore.getNodeLayout(graphId, node.id) + + if (!layout) { + visible.add(node.id) + continue + } + + if ( + isNodeInViewport( + [layout.position.x, layout.position.y], + [layout.size.width, layout.size.height], + viewport, + VIEWPORT_MARGIN + ) + ) { + visible.add(node.id) + } + } + + return visible + } + + const pruneMountedNodes = useDebounceFn(() => { + mountedNodeIds.value = computeVisibleNodeIds() + }, HIDE_DELAY_MS) + + function refreshMountedNodes() { + const visibleNow = computeVisibleNodeIds() + const current = mountedNodeIds.value + + let hasNewNodes = false + let needsPrune = false + let next = current + + for (const id of visibleNow) { + if (!current.has(id)) { + if (next === current) next = new Set(current) + next.add(id) + hasNewNodes = true + } + } + + for (const id of current) { + if (!visibleNow.has(id)) { + needsPrune = true + break + } + } + + if (hasNewNodes) { + mountedNodeIds.value = next + } + + if (needsPrune) { + void pruneMountedNodes() + } + } + + const refreshThrottled = useThrottleFn(refreshMountedNodes, CULL_THROTTLE_MS) + + watch( + [rawNodes, rootGraphId, () => layoutStore.nodeGeometryVersion], + refreshMountedNodes, + { immediate: true } + ) + + const { camera } = useTransformState() + watch( + () => [camera.x, camera.y, camera.z] as const, + () => { + if (isTransforming.value) { + void refreshThrottled() + } + } + ) + + watch(isTransforming, (moving) => { + if (!moving) { + refreshMountedNodes() + } + }) + + useEventListener(window, 'resize', refreshMountedNodes) + + if (canvasElement) { + useResizeObserver(canvasElement, refreshMountedNodes) + } + + return { + mountedNodeIds + } +} diff --git a/src/renderer/core/layout/transform/useTransformState.ts b/src/renderer/core/layout/transform/useTransformState.ts index 4818db4b5ad..68a0b0c492d 100644 --- a/src/renderer/core/layout/transform/useTransformState.ts +++ b/src/renderer/core/layout/transform/useTransformState.ts @@ -122,11 +122,58 @@ function useTransformStateIndividual() { } } + /** + * Tests whether a node's canvas-space bounding box overlaps the visible + * viewport, expanded by a margin. + * + * Mirrors `transformStyle`'s mapping (screen = (canvas + offset) * scale) + * so a node's on-screen rect is compared directly against the viewport + * dimensions in pixels - no `screenToCanvas` round trip needed. + * + * @param position - Node's [x, y] position in canvas coordinates + * @param size - Node's [width, height] in canvas coordinates + * @param viewport - Visible viewport size in screen pixels + * @param margin - Extra visible area as a fraction of viewport dimensions + * (e.g. 0.75 = 75% extra on each axis), so nodes just outside the strict + * viewport stay mounted and don't pop in in on pan/zoom. + * @returns true if the node's screen-space rect intersects the margined viewport + */ + const isNodeInViewport = ( + position: readonly [number, number], + size: readonly [number, number], + viewport: { width: number; height: number }, + margin = 0 + ): boolean => { + const [x, y] = position + const [width, height] = size + + const screenX = (x + camera.x) * camera.z + const screenY = (y + camera.y) * camera.z + const screenWidth = width * camera.z + const screenHeight = height * camera.z + + const marginX = viewport.width * margin + const marginY = viewport.height * margin + + const minX = -marginX + const minY = -marginY + const maxX = viewport.width + marginX + const maxY = viewport.height + marginY + + return ( + screenX + screenWidth >= minX && + screenX <= maxX && + screenY + screenHeight >= minY && + screenY <= maxY + ) + } + return { camera: readonly(camera), transformStyle, syncWithCanvas, - screenToCanvas + screenToCanvas, + isNodeInViewport } }