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 : }
|