LCOV - code coverage report
Current view: top level - src/extensions/core/load3d - load3dWidgets.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 61.5 % 109 67
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { defineAsyncComponent } from 'vue'
       2              : import type { Component } from 'vue'
       3              : 
       4              : import { useToast } from '@/components/ui/toast/toastStore'
       5              : import { useNodeDragAndDrop } from '@/composables/node/useNodeDragAndDrop'
       6              : import { isViewMode } from '@/extensions/core/load3d/cameraAngle/widgetBridge'
       7              : import Load3dUtils from '@/extensions/core/load3d/Load3dUtils'
       8              : import { reportLoadModelOutcome } from '@/extensions/core/load3d/reportLoadModelOutcome'
       9              : import { recordModelChange } from '@/extensions/core/load3d/recordModelChange'
      10              : import { isSupportedModelFilename } from '@/extensions/core/load3d/supportedModelFile'
      11              : import { t } from '@/i18n'
      12              : import { reportError } from '@comfyorg/telemetry/reportError'
      13              : import type { LGraphNode } from '@/lib/litegraph/src/LGraphNode'
      14              : import type { IComboWidget, IStringWidget } from '@comfyorg/graph-model/widgets'
      15              : import type { ResultItem } from '@comfyorg/api-client/executionTypes'
      16              : import type { CustomInputSpec } from '@comfyorg/object-info-parser/schemas/nodeDefSchemaV2'
      17              : import { api } from '@/scripts/api'
      18              : import { ComponentWidgetImpl, addWidget } from '@/scripts/domWidget'
      19              : import type { CustomComfyWidgetConstructor } from '@/types/comfy'
      20              : import { createAnnotatedPath } from '@/utils/createAnnotatedPath'
      21              : import { addToComboValues } from '@/utils/litegraphUtil'
      22              : import { CAMERA_ANGLE_VIEW_WIDGET_NAME } from '@comfyorg/viewport3d/cameraAngle/types'
      23              : import type { CameraAngleViewMode } from '@comfyorg/viewport3d/cameraAngle/types'
      24              : import {
      25              :   LOAD3D_NONE_MODEL,
      26              :   SUPPORTED_EXTENSIONS_ACCEPT
      27              : } from '@comfyorg/viewport3d/load3d/constants'
      28              : 
      29         2355 : const Load3D = defineAsyncComponent(
      30              :   () => import('@/extensions/core/load3d/components/Load3D.vue')
      31              : )
      32         2355 : const Load3DAdvanced = defineAsyncComponent(
      33              :   () => import('@/extensions/core/load3d/components/Load3DAdvanced.vue')
      34              : )
      35         2355 : const CameraInfo = defineAsyncComponent(
      36              :   () => import('@/extensions/core/load3d/components/cameraInfo/CameraInfo.vue')
      37              : )
      38         2355 : const CameraAngle = defineAsyncComponent(
      39              :   () =>
      40              :     import('@/extensions/core/load3d/components/cameraAngle/CameraAngle.vue')
      41              : )
      42              : 
      43         2355 : const VIEWPORT_STATE_NODES = new Set([
      44              :   'Preview3DAdvanced',
      45              :   'Save3DAdvanced',
      46              :   'PreviewGaussianSplat',
      47              :   'PreviewPointCloud',
      48              :   'SaveGaussianSplat',
      49              :   'SavePointCloud'
      50              : ])
      51              : 
      52            6 : function resourceSubfolder(node: LGraphNode) {
      53            6 :   const resourceFolder = String(node.properties['Resource Folder'] ?? '').trim()
      54            6 :   return resourceFolder ? `3d/${resourceFolder}` : '3d'
      55              : }
      56              : 
      57            6 : async function handleModelUpload(file: File, node: LGraphNode) {
      58            6 :   const modelWidget = node.widgets?.find((w) => w.name === 'model_file') as
      59              :     | IStringWidget
      60              :     | undefined
      61              : 
      62            6 :   try {
      63            6 :     const uploadPath = await Load3dUtils.uploadFile(
      64              :       file,
      65              :       resourceSubfolder(node)
      66              :     )
      67              : 
      68            6 :     if (!uploadPath) {
      69            0 :       useToast().warning(t('toastMessages.fileUploadFailed'))
      70            0 :       return
      71              :     }
      72              : 
      73            6 :     const modelUrl = api.apiURL(
      74              :       Load3dUtils.getResourceURL(
      75              :         ...Load3dUtils.splitFilePath(uploadPath),
      76              :         'input'
      77              :       )
      78              :     )
      79              : 
      80            6 :     const { useLoad3d, markLoad3dSceneDirty } =
      81              :       await import('@/extensions/core/load3d/composables/useLoad3d')
      82              : 
      83            6 :     useLoad3d(node).waitForLoad3d(async (load3d) => {
      84            6 :       try {
      85            6 :         reportLoadModelOutcome(await load3d.loadModel(modelUrl))
      86              :       } catch {
      87            0 :         useToast().warning(t('toastMessages.failedToLoadModel'))
      88              :       }
      89              :     })
      90              : 
      91            6 :     if (modelWidget) {
      92            6 :       if (!modelWidget.options.values?.includes(uploadPath)) {
      93            6 :         modelWidget.options.values?.push(uploadPath)
      94              :       }
      95              : 
      96            6 :       modelWidget.value = uploadPath
      97            6 :       recordModelChange()
      98              :     }
      99              : 
     100            6 :     markLoad3dSceneDirty(node)
     101              :   } catch (error) {
     102            0 :     console.error('Model upload failed:', error)
     103            0 :     useToast().warning(t('toastMessages.fileUploadFailed'))
     104              :   }
     105              : }
     106              : 
     107            0 : async function handleResourcesUpload(files: FileList, node: LGraphNode) {
     108            0 :   if (!files.length) return
     109              : 
     110            0 :   try {
     111            0 :     await Load3dUtils.uploadMultipleFiles(files, resourceSubfolder(node))
     112            0 :     const { markLoad3dSceneDirty } =
     113              :       await import('@/extensions/core/load3d/composables/useLoad3d')
     114            0 :     markLoad3dSceneDirty(node)
     115              :   } catch (error) {
     116            0 :     console.error('Extra resources upload failed:', error)
     117            0 :     useToast().warning(t('toastMessages.extraResourcesUploadFailed'))
     118              :   }
     119              : }
     120              : 
     121            1 : async function clearModel(node: LGraphNode) {
     122            1 :   try {
     123            1 :     const { markLoad3dSceneDirty } =
     124              :       await import('@/extensions/core/load3d/composables/useLoad3d')
     125            1 :     const modelWidget = node.widgets?.find((w) => w.name === 'model_file')
     126            1 :     if (modelWidget) {
     127            1 :       modelWidget.value = LOAD3D_NONE_MODEL
     128            1 :       recordModelChange()
     129              :     }
     130            1 :     markLoad3dSceneDirty(node)
     131              :   } catch (error) {
     132            0 :     reportError(error, {
     133              :       errorType: 'error_loading_3d_extensions',
     134              :       surface: 'graph'
     135              :     })
     136              :   }
     137              : }
     138              : 
     139            0 : function selectModelAsset(item: ResultItem, node: LGraphNode) {
     140            0 :   if (!isSupportedModelFilename(item.filename ?? '')) {
     141            0 :     useToast().warning(t('load3d.unsupportedFileType'))
     142            0 :     return
     143              :   }
     144              : 
     145            0 :   const modelWidget = node.widgets?.find((w) => w.name === 'model_file') as
     146              :     | IComboWidget
     147              :     | undefined
     148            0 :   if (!modelWidget) return
     149              : 
     150            0 :   const modelPath = createAnnotatedPath(item)
     151            0 :   addToComboValues(modelWidget, modelPath)
     152            0 :   modelWidget.value = modelPath
     153            0 :   recordModelChange()
     154              : }
     155              : 
     156           22 : function addModelDragAndDrop(node: LGraphNode) {
     157           22 :   useNodeDragAndDrop(node, {
     158              :     fileFilter: (file) => isSupportedModelFilename(file.name),
     159              :     onDrop: async ([file]) => {
     160            0 :       await handleModelUpload(file, node)
     161            0 :       return [file]
     162              :     },
     163              :     onResultItemDrop: (item) => selectModelAsset(item, node)
     164              :   })
     165              : }
     166              : 
     167           44 : function createFileInput(accept: string, multiple: boolean): HTMLInputElement {
     168           44 :   const input = document.createElement('input')
     169           44 :   input.type = 'file'
     170           44 :   input.accept = accept
     171           44 :   input.multiple = multiple
     172           44 :   input.style.display = 'none'
     173           44 :   return input
     174              : }
     175              : 
     176           22 : function addModelFileButtons(node: LGraphNode) {
     177           22 :   const fileInput = createFileInput(SUPPORTED_EXTENSIONS_ACCEPT, false)
     178           22 :   node.properties['Resource Folder'] = ''
     179           22 :   fileInput.onchange = async () => {
     180            6 :     const file = fileInput.files?.item(0)
     181            6 :     if (file) await handleModelUpload(file, node)
     182              :   }
     183           22 :   node.addWidget('button', 'upload 3d model', 'upload3dmodel', () => {
     184            6 :     fileInput.click()
     185              :   })
     186              : 
     187           22 :   const resourcesInput = createFileInput('*', true)
     188           22 :   resourcesInput.onchange = async () => {
     189            0 :     await handleResourcesUpload(resourcesInput.files!, node)
     190            0 :     resourcesInput.value = ''
     191              :   }
     192           22 :   node.addWidget(
     193              :     'button',
     194              :     'upload extra resources',
     195              :     'uploadExtraResources',
     196              :     () => {
     197            0 :       resourcesInput.click()
     198              :     }
     199              :   )
     200              : 
     201           22 :   node.addWidget('button', 'clear', 'clear', () => {
     202            1 :     void clearModel(node)
     203              :   })
     204              : }
     205              : 
     206           26 : function addViewportWidget(
     207              :   node: LGraphNode,
     208              :   component: Component,
     209              :   inputSpec: CustomInputSpec,
     210              :   type: string
     211              : ) {
     212           26 :   const widget = new ComponentWidgetImpl({
     213              :     node,
     214              :     name: inputSpec.name,
     215              :     component,
     216              :     inputSpec,
     217              :     options: { hideInPanel: true }
     218              :   })
     219           26 :   widget.type = type
     220           26 :   addWidget(node, widget)
     221           26 :   return { widget }
     222              : }
     223              : 
     224              : /** Widget constructors for the 3D node types, available before the 3D extensions load. */
     225         2355 : export const load3dWidgets: Record<string, CustomComfyWidgetConstructor> = {
     226              :   LOAD_3D(node) {
     227           22 :     const { comfyClass } = node.constructor
     228           22 :     const name =
     229              :       comfyClass && VIEWPORT_STATE_NODES.has(comfyClass)
     230              :         ? 'viewport_state'
     231              :         : 'image'
     232           22 :     if (node.widgets?.some((w) => w.name === 'model_file')) {
     233           22 :       addModelFileButtons(node)
     234           22 :       addModelDragAndDrop(node)
     235              :     }
     236           22 :     return addViewportWidget(
     237              :       node,
     238              :       Load3D,
     239              :       { name, type: 'Load3D', isPreview: false },
     240              :       'load3D'
     241              :     )
     242              :   },
     243              : 
     244              :   PREVIEW_3D(node) {
     245            4 :     return addViewportWidget(
     246              :       node,
     247              :       Load3D,
     248              :       { name: 'image', type: 'Preview3D', isPreview: true },
     249              :       'load3D'
     250              :     )
     251              :   },
     252              : 
     253              :   LOAD_3D_ADVANCED(node) {
     254            0 :     addModelDragAndDrop(node)
     255            0 :     return addViewportWidget(
     256              :       node,
     257              :       Load3DAdvanced,
     258              :       { name: 'viewport_state', type: 'LOAD_3D_ADVANCED', isPreview: false },
     259              :       'load3DAdvanced'
     260              :     )
     261              :   },
     262              : 
     263              :   CAMERA_INFO_STATE(node) {
     264            0 :     const widget = new ComponentWidgetImpl({
     265              :       node,
     266              :       name: 'camera_info_state',
     267              :       component: CameraInfo,
     268              :       inputSpec: {
     269              :         name: 'camera_info_state',
     270              :         type: 'CAMERA_INFO_STATE',
     271              :         isPreview: false
     272              :       },
     273              :       options: { serialize: false, hideInPanel: true }
     274              :     })
     275            0 :     widget.type = 'cameraInfo'
     276            0 :     widget.serialize = false
     277            0 :     addWidget(node, widget)
     278            0 :     return { widget }
     279              :   },
     280              : 
     281              :   CAMERA_ANGLE_VIEW(node) {
     282            0 :     let viewMode: CameraAngleViewMode = 'camera'
     283            0 :     const widget = new ComponentWidgetImpl<string | object>({
     284              :       node,
     285              :       name: CAMERA_ANGLE_VIEW_WIDGET_NAME,
     286              :       component: CameraAngle,
     287              :       inputSpec: {
     288              :         name: CAMERA_ANGLE_VIEW_WIDGET_NAME,
     289              :         type: 'CAMERA_ANGLE_VIEW',
     290              :         isPreview: false
     291              :       },
     292              :       options: {
     293              :         serialize: false,
     294              :         hideInPanel: true,
     295              :         getValue: () => viewMode,
     296              :         setValue: (value) => {
     297            0 :           if (isViewMode(value)) viewMode = value
     298              :         }
     299              :       }
     300              :     })
     301            0 :     widget.type = 'cameraAngle'
     302            0 :     addWidget(node, widget)
     303            0 :     return { widget }
     304              :   }
     305              : }
        

Generated by: LCOV version 2.0-1