Line data Source code
1 : /**
2 : * Load3D Service - provides access to Load3D instances
3 : *
4 : * This service uses lazy imports to avoid pulling THREE.js into the main bundle.
5 : * The nodeToLoad3dMap is accessed lazily - it will only be available after
6 : * the load3d extension has been loaded.
7 : */
8 : import { toRaw } from 'vue'
9 :
10 : import type Load3d from '@comfyorg/viewport3d/load3d/Load3d'
11 : import {
12 : cacheNodeToLoad3dMap,
13 : getNodeToLoad3dMapSync,
14 : removeLoad3d
15 : } from '@/extensions/core/load3d/load3dInstances'
16 : import type {
17 : AnimationItem,
18 : BackgroundRenderModeType,
19 : CameraType,
20 : MaterialMode,
21 : UpDirection
22 : } from '@comfyorg/viewport3d/load3d/interfaces'
23 : import type { LGraphNode } from '@/lib/litegraph/src/litegraph'
24 : import type { NodeId } from '@comfyorg/graph-model/nodeId'
25 :
26 : // Type for the useLoad3dViewer composable function
27 : // Using explicit type to avoid import() type annotations (lint rule)
28 : type UseLoad3dViewerFn = (node?: LGraphNode) => {
29 : backgroundColor: { value: string }
30 : showGrid: { value: boolean }
31 : cameraType: { value: CameraType }
32 : fov: { value: number }
33 : lightIntensity: { value: number }
34 : backgroundImage: { value: string }
35 : hasBackgroundImage: { value: boolean }
36 : backgroundRenderMode: { value: BackgroundRenderModeType }
37 : upDirection: { value: UpDirection }
38 : materialMode: { value: MaterialMode }
39 : needApplyChanges: { value: boolean }
40 : isPreview: { value: boolean }
41 : isStandaloneMode: { value: boolean }
42 : isSplatModel: { value: boolean }
43 : isPlyModel: { value: boolean }
44 : sourceFormat: { value: string | null }
45 : animations: { value: AnimationItem[] }
46 : playing: { value: boolean }
47 : selectedSpeed: { value: number }
48 : selectedAnimation: { value: number }
49 : animationProgress: { value: number }
50 : animationDuration: { value: number }
51 :
52 : initializeViewer: (containerRef: HTMLElement, source: Load3d) => Promise<void>
53 : initializeStandaloneViewer: (
54 : containerRef: HTMLElement,
55 : modelUrl: string
56 : ) => Promise<void>
57 : cleanup: () => void
58 : handleResize: () => void
59 : handleMouseEnter: () => void
60 : handleMouseLeave: () => void
61 : applyChanges: () => Promise<boolean>
62 : restoreInitialState: () => void
63 : refreshViewport: () => void
64 : exportModel: (format: string) => Promise<void>
65 : handleBackgroundImageUpdate: (file: File | null) => Promise<void>
66 : handleModelDrop: (file: File) => Promise<void>
67 : handleSeek: (progress: number) => void
68 : }
69 :
70 : // Cache for lazy-loaded modules
71 24 : let cachedUseLoad3dViewer: UseLoad3dViewerFn | null = null
72 :
73 : // Async loader for nodeToLoad3dMap - also caches for sync access
74 2 : async function loadNodeToLoad3dMap(): Promise<Map<LGraphNode, Load3d>> {
75 2 : const cached = getNodeToLoad3dMapSync()
76 2 : if (cached) return cached
77 2 : const module = await import('@/extensions/core/load3d/composables/useLoad3d')
78 2 : cacheNodeToLoad3dMap(module.nodeToLoad3dMap)
79 2 : return module.nodeToLoad3dMap
80 : }
81 :
82 0 : async function loadUseLoad3dViewer() {
83 0 : if (!cachedUseLoad3dViewer) {
84 : const module =
85 : await import('@/extensions/core/load3d/composables/useLoad3dViewer')
86 0 : cachedUseLoad3dViewer = module.useLoad3dViewer
87 : }
88 0 : return cachedUseLoad3dViewer
89 : }
90 :
91 : // Type definitions for Load3D node
92 : interface Load3DNode extends LGraphNode {
93 : syncLoad3dConfig?: () => void
94 : }
95 :
96 24 : const viewerInstances = new Map<NodeId, ReturnType<UseLoad3dViewerFn>>()
97 :
98 24 : class Load3dService {
99 : private static instance: Load3dService | undefined
100 :
101 : private constructor() {}
102 :
103 : static getInstance(): Load3dService {
104 19 : if (!Load3dService.instance) {
105 6 : Load3dService.instance = new Load3dService()
106 : }
107 19 : return Load3dService.instance
108 : }
109 :
110 : /**
111 : * Get Load3d instance for a node (synchronous).
112 : * Returns null if the load3d module hasn't been loaded yet.
113 : */
114 : getLoad3d(node: LGraphNode): Load3d | null {
115 12 : const rawNode = toRaw(node)
116 12 : const map = getNodeToLoad3dMapSync()
117 12 : if (!map) return null
118 12 : return map.get(rawNode) || null
119 : }
120 :
121 : /**
122 : * Get Load3d instance for a node (async, loads module if needed).
123 : */
124 : async getLoad3dAsync(node: LGraphNode): Promise<Load3d | null> {
125 2 : const rawNode = toRaw(node)
126 : const map = await loadNodeToLoad3dMap()
127 2 : return map.get(rawNode) || null
128 : }
129 :
130 : clear() {
131 0 : const map = getNodeToLoad3dMapSync()
132 0 : if (!map) return
133 0 : for (const [node] of map) {
134 0 : removeLoad3d(node)
135 : }
136 : }
137 :
138 : /**
139 : * Get or create viewer (async, loads module if needed).
140 : * Use this for initial viewer creation.
141 : */
142 : async getOrCreateViewer(node: LGraphNode) {
143 1 : const nodeId = node.id
144 1 : if (!viewerInstances.has(nodeId)) {
145 0 : const useLoad3dViewer = await loadUseLoad3dViewer()
146 0 : viewerInstances.set(nodeId, useLoad3dViewer(node))
147 : }
148 :
149 1 : return viewerInstances.get(nodeId)
150 : }
151 :
152 : /**
153 : * Get or create viewer (sync version).
154 : * Only works after useLoad3dViewer has been loaded.
155 : * Returns null if module not yet loaded - use async version instead.
156 : */
157 : getOrCreateViewerSync<T extends UseLoad3dViewerFn>(
158 : node: LGraphNode,
159 : useLoad3dViewer: T
160 : ): ReturnType<T> {
161 2 : const nodeId = node.id
162 2 : if (!viewerInstances.has(nodeId)) {
163 2 : viewerInstances.set(nodeId, useLoad3dViewer(node))
164 : }
165 :
166 2 : return viewerInstances.get(nodeId) as ReturnType<T>
167 : }
168 :
169 : removeViewer(node: LGraphNode) {
170 1 : const nodeId = node.id
171 1 : const viewer = viewerInstances.get(nodeId)
172 :
173 1 : if (viewer) {
174 1 : viewer.cleanup()
175 : }
176 :
177 1 : viewerInstances.delete(nodeId)
178 : }
179 :
180 : async handleViewerClose(node: LGraphNode) {
181 1 : const viewer = await useLoad3dService().getOrCreateViewer(node)
182 1 : if (!viewer) return
183 :
184 1 : if (viewer.needApplyChanges.value) {
185 0 : await viewer.applyChanges()
186 :
187 : // Sync configuration back to the node's UI
188 0 : const load3DNode = node as Load3DNode
189 0 : if (load3DNode.syncLoad3dConfig) {
190 0 : load3DNode.syncLoad3dConfig()
191 : }
192 : }
193 :
194 1 : useLoad3dService().removeViewer(node)
195 : }
196 : }
197 :
198 24 : export const useLoad3dService = () => {
199 19 : return Load3dService.getInstance()
200 : }
|