LCOV - code coverage report
Current view: top level - packages/viewport3d/src/load3d - MeshModelAdapter.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 58.9 % 73 43
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import {
       2              :   hasNgonEncoding,
       3              :   isBinaryFbx,
       4              :   matchFbxPolygons,
       5              :   ngonEncodedFaceSizes,
       6              :   readFbxPolygons
       7              : } from '@comfyorg/quad-wireframe-three'
       8              : import * as THREE from 'three'
       9              : import { FBXLoader } from 'three/examples/jsm/loaders/FBXLoader'
      10              : import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'
      11              : import { MTLLoader } from 'three/examples/jsm/loaders/MTLLoader'
      12              : import { STLLoader } from 'three/examples/jsm/loaders/STLLoader'
      13              : import { MtlObjBridge, OBJLoader2Parallel } from 'wwobjloader2'
      14              : // Use pre-bundled worker module (has all dependencies included).
      15              : // The unbundled 'wwobjloader2/worker' has ES imports that fail in production builds.
      16              : import OBJLoader2WorkerUrl from 'wwobjloader2/bundle/worker/module?url'
      17              : 
      18              : import type {
      19              :   ModelAdapter,
      20              :   ModelAdapterCapabilities,
      21              :   ModelLoadContext,
      22              :   ModelLoadResult
      23              : } from './ModelAdapter'
      24              : import { registerFaceSizes } from './quadWireframe/faceSizesRegistry'
      25              : 
      26           24 : export class MeshModelAdapter implements ModelAdapter {
      27              :   readonly kind = 'mesh' as const
      28              :   readonly extensions = ['stl', 'fbx', 'obj', 'gltf', 'glb'] as const
      29              :   readonly capabilities: ModelAdapterCapabilities = {
      30              :     fitToViewer: true,
      31              :     requiresMaterialRebuild: false,
      32              :     gizmoTransform: true,
      33              :     lighting: true,
      34              :     exportable: true,
      35              :     materialModes: ['original', 'clay', 'normal', 'wireframe'],
      36              :     fitTargetSize: 5
      37              :   }
      38              : 
      39              :   private readonly gltfLoader = new GLTFLoader()
      40              :   private readonly mtlLoader = new MTLLoader()
      41              :   private readonly fbxLoader = new FBXLoader()
      42              :   private readonly stlLoader = new STLLoader()
      43              : 
      44              :   async load(
      45              :     ctx: ModelLoadContext,
      46              :     path: string,
      47              :     filename: string,
      48              :     fetchBytes: () => Promise<ArrayBuffer>
      49              :   ): Promise<ModelLoadResult | null> {
      50           19 :     const extension = filename.split('.').pop()?.toLowerCase()
      51           19 :     const object = await (extension === 'stl'
      52              :       ? this.loadSTL(ctx, path, fetchBytes)
      53              :       : extension === 'fbx'
      54              :         ? this.loadFBX(ctx, path, fetchBytes)
      55              :         : extension === 'obj'
      56              :           ? this.loadOBJ(ctx, path, filename, fetchBytes)
      57              :           : extension === 'gltf' || extension === 'glb'
      58              :             ? this.loadGLTF(ctx, path, fetchBytes)
      59              :             : Promise.resolve(null))
      60           19 :     return object ? { object, capabilities: this.capabilities } : null
      61              :   }
      62              : 
      63              :   private async loadSTL(
      64              :     ctx: ModelLoadContext,
      65              :     path: string,
      66              :     fetchBytes: () => Promise<ArrayBuffer>
      67              :   ): Promise<THREE.Object3D> {
      68            0 :     this.stlLoader.setPath(path)
      69            0 :     const geometry = this.stlLoader.parse(await fetchBytes())
      70            0 :     ctx.setOriginalModel(geometry)
      71            0 :     geometry.computeVertexNormals()
      72              : 
      73            0 :     const mesh = new THREE.Mesh(geometry, ctx.standardMaterial)
      74            0 :     const group = new THREE.Group()
      75            0 :     group.add(mesh)
      76            0 :     return group
      77              :   }
      78              : 
      79              :   private async loadFBX(
      80              :     ctx: ModelLoadContext,
      81              :     path: string,
      82              :     fetchBytes: () => Promise<ArrayBuffer>
      83              :   ): Promise<THREE.Object3D> {
      84            0 :     this.fbxLoader.setPath(path)
      85            0 :     const bytes = await fetchBytes()
      86            0 :     const fbxModel = this.fbxLoader.parse(bytes, path)
      87            0 :     ctx.setOriginalModel(fbxModel)
      88              : 
      89            0 :     const polygons = isBinaryFbx(bytes) ? readFbxPolygons(bytes) : []
      90            0 :     fbxModel.traverse((child) => {
      91            0 :       if (child instanceof THREE.Mesh) {
      92            0 :         ctx.registerOriginalMaterial(child, child.material)
      93            0 :         if (child instanceof THREE.SkinnedMesh) {
      94            0 :           child.frustumCulled = false
      95              :         }
      96            0 :         const faceSizes = matchFbxPolygons(polygons, child.geometry)
      97            0 :         if (faceSizes) registerFaceSizes(child.geometry, faceSizes)
      98              :       }
      99              :     })
     100              : 
     101            0 :     return fbxModel
     102              :   }
     103              : 
     104              :   private async loadOBJ(
     105              :     ctx: ModelLoadContext,
     106              :     path: string,
     107              :     filename: string,
     108              :     fetchBytes: () => Promise<ArrayBuffer>
     109              :   ): Promise<THREE.Object3D> {
     110           15 :     const objLoader = new OBJLoader2Parallel()
     111           15 :     objLoader.setWorkerUrl(true, new URL(OBJLoader2WorkerUrl, import.meta.url))
     112           15 :     objLoader.setTerminateWorkerOnLoad(true)
     113           15 :     objLoader.setBaseObject3d(new THREE.Object3D())
     114              : 
     115           15 :     if (ctx.materialMode === 'original') {
     116           15 :       try {
     117           15 :         this.mtlLoader.setPath(path)
     118           15 :         const mtlFileName = filename.replace(/\.obj$/i, '.mtl')
     119           15 :         const materials = await this.mtlLoader.loadAsync(mtlFileName)
     120            0 :         materials.preload()
     121            0 :         const materialsFromMtl =
     122              :           MtlObjBridge.addMaterialsFromMtlLoader(materials)
     123            0 :         objLoader.setMaterials(materialsFromMtl)
     124              :       } catch {
     125           15 :         console.warn(
     126              :           'No MTL file found or error loading it, continuing without materials'
     127              :         )
     128              :       }
     129              :     }
     130              : 
     131           15 :     const model = await this.parseOBJ(objLoader, await fetchBytes())
     132              : 
     133           15 :     model.traverse((child) => {
     134           30 :       if (child instanceof THREE.Mesh) {
     135           15 :         ctx.registerOriginalMaterial(child, child.material)
     136              :       }
     137              :     })
     138              : 
     139           15 :     return model
     140              :   }
     141              : 
     142              :   private parseOBJ(
     143              :     objLoader: OBJLoader2Parallel,
     144              :     bytes: ArrayBuffer
     145              :   ): Promise<THREE.Object3D> {
     146           15 :     return new Promise((resolve, reject) => {
     147           15 :       objLoader.setCallbackOnLoad(resolve)
     148           15 :       objLoader.parse(bytes.slice(0))
     149           15 :       rejectOnWorkerFailure(objLoader, reject)
     150              :     })
     151              :   }
     152              : 
     153              :   private async loadGLTF(
     154              :     ctx: ModelLoadContext,
     155              :     path: string,
     156              :     fetchBytes: () => Promise<ArrayBuffer>
     157              :   ): Promise<THREE.Object3D> {
     158            4 :     this.gltfLoader.setPath(path)
     159            4 :     const gltf = await this.gltfLoader.parseAsync(await fetchBytes(), path)
     160            2 :     ctx.setOriginalModel(gltf)
     161              : 
     162            2 :     gltf.scene.traverse((child) => {
     163            4 :       if (child instanceof THREE.Mesh) {
     164            2 :         if (!child.geometry.hasAttribute('normal')) {
     165            2 :           child.geometry.computeVertexNormals()
     166              :         }
     167            2 :         ctx.registerOriginalMaterial(child, child.material)
     168            2 :         if (child instanceof THREE.SkinnedMesh) {
     169            0 :           child.frustumCulled = false
     170              :         }
     171            2 :         if (hasNgonEncoding(child)) {
     172            0 :           registerFaceSizes(
     173              :             child.geometry,
     174              :             ngonEncodedFaceSizes(child.geometry)
     175              :           )
     176              :         }
     177              :       }
     178              :     })
     179              : 
     180            2 :     return gltf.scene
     181              :   }
     182              : }
     183              : 
     184              : interface ObjLoaderInternals {
     185              :   workerTask?: { getWorker(): Worker | undefined }
     186              : }
     187              : 
     188              : // OBJLoader2Parallel swallows worker failures (it only logs them), which leaves
     189              : // the load promise pending forever. The worker is created synchronously inside
     190              : // parse(), so hook it to surface those failures as rejections.
     191           15 : function rejectOnWorkerFailure(
     192              :   objLoader: OBJLoader2Parallel,
     193              :   reject: (reason: unknown) => void
     194              : ): void {
     195           15 :   const worker = (
     196              :     objLoader as unknown as ObjLoaderInternals
     197              :   ).workerTask?.getWorker()
     198           15 :   if (!worker) return
     199              : 
     200           15 :   const fail = (reason: unknown) => {
     201            0 :     worker.terminate()
     202            0 :     reject(reason)
     203              :   }
     204           15 :   worker.addEventListener('error', (event) =>
     205              :     fail(event.error ?? new Error(event.message))
     206              :   )
     207           15 :   const postMessage = worker.postMessage.bind(worker)
     208           15 :   worker.postMessage = ((message: unknown, transfer: Transferable[]) => {
     209           15 :     try {
     210           15 :       postMessage(message, transfer)
     211              :     } catch (error) {
     212            0 :       fail(error)
     213            0 :       throw error
     214              :     }
     215              :   }) as Worker['postMessage']
     216              : }
        

Generated by: LCOV version 2.0-1