LCOV - code coverage report
Current view: top level - packages/viewport3d/src/load3d - ModelExporter.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 9.6 % 52 5
Test Date: 2026-11-17 04:17:53

            Line data    Source code
       1              : import { FBXExporter } from '@comfyorg/fbx-exporter-three'
       2              : import type * as THREE from 'three'
       3              : import { GLTFExporter } from 'three/examples/jsm/exporters/GLTFExporter'
       4              : import { OBJExporter } from 'three/examples/jsm/exporters/OBJExporter'
       5              : import { STLExporter } from 'three/examples/jsm/exporters/STLExporter'
       6              : 
       7              : import { downloadBlob } from './downloadBlob'
       8              : 
       9           24 : export class ModelExporter {
      10              :   static detectFormatFromURL(url: string): string | null {
      11           21 :     try {
      12           21 :       const filenameParam = new URLSearchParams(url.split('?')[1]).get(
      13              :         'filename'
      14              :       )
      15           21 :       if (filenameParam) {
      16              :         const extension = filenameParam.split('.').pop()?.toLowerCase()
      17           21 :         return extension || null
      18              :       }
      19              :     } catch (e) {
      20            0 :       console.error('Error parsing URL:', e)
      21              :     }
      22            0 :     return null
      23              :   }
      24              : 
      25              :   static fbxUnitScaleFor(originalURL?: string | null): number {
      26              :     const sourceFormat = originalURL
      27              :       ? ModelExporter.detectFormatFromURL(originalURL)
      28              :       : null
      29            0 :     return sourceFormat?.toLowerCase() === 'fbx' ? 1 : 100
      30              :   }
      31              : 
      32              :   static canUseDirectURL(url: string | null, format: string): boolean {
      33            0 :     if (!url) return false
      34              : 
      35            0 :     const urlFormat = ModelExporter.detectFormatFromURL(url)
      36            0 :     if (!urlFormat) return false
      37              : 
      38            0 :     return urlFormat.toLowerCase() === format.toLowerCase()
      39              :   }
      40              : 
      41              :   static async downloadFromURL(
      42              :     url: string,
      43              :     desiredFilename: string
      44              :   ): Promise<void> {
      45            0 :     const response = await fetch(url)
      46            0 :     if (!response.ok) {
      47            0 :       throw new Error(`Failed to download file (HTTP ${response.status})`)
      48              :     }
      49              :     const blob = await response.blob()
      50            0 :     downloadBlob(desiredFilename, blob)
      51              :   }
      52              : 
      53              :   static async exportGLB(
      54              :     model: THREE.Object3D,
      55              :     filename: string = 'model.glb',
      56              :     originalURL?: string | null
      57              :   ): Promise<void> {
      58            0 :     if (originalURL && ModelExporter.canUseDirectURL(originalURL, 'glb')) {
      59            0 :       return ModelExporter.downloadFromURL(originalURL, filename)
      60              :     }
      61              : 
      62            0 :     const exporter = new GLTFExporter()
      63              : 
      64            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
      65              : 
      66            0 :     const result = await new Promise<ArrayBuffer>((resolve, reject) => {
      67            0 :       exporter.parse(
      68              :         model,
      69              :         (gltf) => {
      70            0 :           resolve(gltf as ArrayBuffer)
      71              :         },
      72              :         (error) => {
      73            0 :           reject(error)
      74              :         },
      75              :         { binary: true }
      76              :       )
      77              :     })
      78              : 
      79            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
      80              : 
      81            0 :     ModelExporter.saveArrayBuffer(result, filename)
      82              :   }
      83              : 
      84              :   static async exportOBJ(
      85              :     model: THREE.Object3D,
      86              :     filename: string = 'model.obj',
      87              :     originalURL?: string | null
      88              :   ): Promise<void> {
      89            0 :     if (originalURL && ModelExporter.canUseDirectURL(originalURL, 'obj')) {
      90            0 :       return ModelExporter.downloadFromURL(originalURL, filename)
      91              :     }
      92              : 
      93            0 :     const exporter = new OBJExporter()
      94              : 
      95            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
      96              : 
      97            0 :     const result = exporter.parse(model)
      98              : 
      99            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
     100              : 
     101            0 :     ModelExporter.saveString(result, filename)
     102              :   }
     103              : 
     104              :   static async exportFBX(
     105              :     model: THREE.Object3D,
     106              :     filename: string = 'model.fbx',
     107              :     originalURL?: string | null
     108              :   ): Promise<void> {
     109            0 :     if (originalURL && ModelExporter.canUseDirectURL(originalURL, 'fbx')) {
     110            0 :       return ModelExporter.downloadFromURL(originalURL, filename)
     111              :     }
     112              : 
     113            0 :     const exporter = new FBXExporter()
     114              : 
     115            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
     116              : 
     117            0 :     const bytes = await exporter.parseAsync(model, {
     118              :       unitScale: ModelExporter.fbxUnitScaleFor(originalURL)
     119              :     })
     120              : 
     121            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
     122              : 
     123            0 :     ModelExporter.saveArrayBuffer(
     124              :       bytes.buffer.slice(
     125              :         bytes.byteOffset,
     126              :         bytes.byteOffset + bytes.byteLength
     127              :       ) as ArrayBuffer,
     128              :       filename
     129              :     )
     130              :   }
     131              : 
     132              :   static async exportSTL(
     133              :     model: THREE.Object3D,
     134              :     filename: string = 'model.stl',
     135              :     originalURL?: string | null
     136              :   ): Promise<void> {
     137            0 :     if (originalURL && ModelExporter.canUseDirectURL(originalURL, 'stl')) {
     138            0 :       return ModelExporter.downloadFromURL(originalURL, filename)
     139              :     }
     140              : 
     141            0 :     const exporter = new STLExporter()
     142              : 
     143            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
     144              : 
     145            0 :     const result = exporter.parse(model)
     146              : 
     147            0 :     await new Promise((resolve) => setTimeout(resolve, 50))
     148              : 
     149            0 :     ModelExporter.saveString(result, filename)
     150              :   }
     151              : 
     152              :   static async exportDirect(
     153              :     originalURL: string | null | undefined,
     154              :     filename: string,
     155              :     format: string
     156              :   ): Promise<void> {
     157            0 :     if (!originalURL) {
     158            0 :       throw new Error(`No source file available to export as ${format}`)
     159              :     }
     160              : 
     161            0 :     return ModelExporter.downloadFromURL(originalURL, filename)
     162              :   }
     163              : 
     164              :   private static saveArrayBuffer(buffer: ArrayBuffer, filename: string): void {
     165              :     const blob = new Blob([buffer], { type: 'application/octet-stream' })
     166            0 :     downloadBlob(filename, blob)
     167              :   }
     168              : 
     169              :   private static saveString(text: string, filename: string): void {
     170              :     const blob = new Blob([text], { type: 'text/plain' })
     171            0 :     downloadBlob(filename, blob)
     172              :   }
     173              : }
        

Generated by: LCOV version 2.0-1