From 5669ab9ecec8a2602642ac92d1824366f1f313a5 Mon Sep 17 00:00:00 2001 From: Hu Song Date: Tue, 2 Jul 2024 11:29:49 +0800 Subject: [PATCH] Enable delay initialization of the MeshoptDecoder (#2146) * feat: enable delay initialization of the `MeshoptDecoder` of glTF --- e2e/case/gltf-meshopt.ts | 5 +- packages/loader/src/GLTFLoader.ts | 15 +- .../extensions/EXT_meshopt_compression.ts | 35 +++-- .../src/gltf/extensions/MeshoptDecoder.ts | 135 ++++++++++-------- 4 files changed, 111 insertions(+), 79 deletions(-) diff --git a/e2e/case/gltf-meshopt.ts b/e2e/case/gltf-meshopt.ts index 2f5092e48..de9006aba 100644 --- a/e2e/case/gltf-meshopt.ts +++ b/e2e/case/gltf-meshopt.ts @@ -3,7 +3,7 @@ * @category Animation */ import { OrbitControl } from "@galacean/engine-toolkit"; -import { Camera, DirectLight, GLTFResource, Logger, Vector3, WebGLEngine } from "@galacean/engine"; +import { Camera, DirectLight, GLTFLoader, GLTFResource, Logger, Vector3, WebGLEngine } from "@galacean/engine"; import { initScreenshot, updateForE2E } from "./.mockForE2E"; Logger.enable(); @@ -37,5 +37,8 @@ WebGLEngine.create({ canvas: "canvas" }).then((engine) => { updateForE2E(engine, 100); initScreenshot(engine, camera); + }) + .then(() => { + GLTFLoader.release(); }); }); diff --git a/packages/loader/src/GLTFLoader.ts b/packages/loader/src/GLTFLoader.ts index 9efa784f2..0707d17aa 100644 --- a/packages/loader/src/GLTFLoader.ts +++ b/packages/loader/src/GLTFLoader.ts @@ -10,7 +10,7 @@ import { } from "@galacean/engine-core"; import { GLTFResource } from "./gltf/GLTFResource"; import { GLTFParserContext } from "./gltf/parser"; -import { MeshoptDecoder } from "./gltf/extensions/MeshoptDecoder"; +import { getMeshoptDecoder, ready } from "./gltf/extensions/MeshoptDecoder"; @resourceLoader(AssetType.GLTF, ["gltf", "glb"]) export class GLTFLoader extends Loader { @@ -19,14 +19,19 @@ export class GLTFLoader extends Loader { * @remarks If use loader after releasing, we should release again. */ static release(): void { - MeshoptDecoder.release(); + if (ready) { + getMeshoptDecoder().then((meshoptDecoder) => { + meshoptDecoder.release(); + }); + } } override initialize(_: Engine, configuration: EngineConfiguration): Promise { - const meshOptOptions = configuration.glTF?.meshOpt; + const meshOptOptions = configuration.glTFLoader?.meshOpt ?? configuration.glTF?.meshOpt; if (meshOptOptions) { - MeshoptDecoder.workerCount = meshOptOptions.workerCount; - MeshoptDecoder.useWorkers(); + return getMeshoptDecoder().then((meshoptDecoder) => { + meshoptDecoder.useWorkers(meshOptOptions.workerCount); + }); } return Promise.resolve(); } diff --git a/packages/loader/src/gltf/extensions/EXT_meshopt_compression.ts b/packages/loader/src/gltf/extensions/EXT_meshopt_compression.ts index 058fcf12e..06533440d 100644 --- a/packages/loader/src/gltf/extensions/EXT_meshopt_compression.ts +++ b/packages/loader/src/gltf/extensions/EXT_meshopt_compression.ts @@ -2,18 +2,20 @@ import { registerGLTFExtension } from "../parser/GLTFParser"; import { GLTFParserContext, GLTFParserType } from "../parser/GLTFParserContext"; import { GLTFExtensionMode, GLTFExtensionParser } from "./GLTFExtensionParser"; import { IEXTMeshoptCompressionSchema } from "./GLTFExtensionSchema"; -import { MeshoptDecoder } from "./MeshoptDecoder"; +import { getMeshoptDecoder } from "./MeshoptDecoder"; @registerGLTFExtension("EXT_meshopt_compression", GLTFExtensionMode.CreateAndParse) class EXT_meshopt_compression extends GLTFExtensionParser { override createAndParse(context: GLTFParserContext, schema: IEXTMeshoptCompressionSchema): Promise { return context.get(GLTFParserType.Buffer, schema.buffer).then((arrayBuffer) => { - return MeshoptDecoder.decodeGltfBuffer( - schema.count, - schema.byteStride, - new Uint8Array(arrayBuffer, schema.byteOffset, schema.byteLength), - schema.mode, - schema.filter + return getMeshoptDecoder().then((decoder) => + decoder.decodeGltfBuffer( + schema.count, + schema.byteStride, + new Uint8Array(arrayBuffer, schema.byteOffset, schema.byteLength), + schema.mode, + schema.filter + ) ); }); } @@ -21,12 +23,25 @@ class EXT_meshopt_compression extends GLTFExtensionParser { declare module "@galacean/engine-core" { interface EngineConfiguration { - /** glTF loader options. */ + glTFLoader?: { + /** Meshopt options. If set this option and workCount is great than 0, workers will be created. */ + meshOpt?: { + /** + * Worker count for transcoder. + * @defaultValue 4 + */ + workerCount?: number; + }; + }; + /** @deprecated glTF loader options. */ glTF?: { /** Meshopt options. If set this option and workCount is great than 0, workers will be created. */ meshOpt?: { - /** Worker count for transcoder, default is 4. */ - workerCount: number; + /** + * Worker count for transcoder. + * @defaultValue 4 + */ + workerCount?: number; }; }; } diff --git a/packages/loader/src/gltf/extensions/MeshoptDecoder.ts b/packages/loader/src/gltf/extensions/MeshoptDecoder.ts index 4dddb1701..e0fd7f21e 100644 --- a/packages/loader/src/gltf/extensions/MeshoptDecoder.ts +++ b/packages/loader/src/gltf/extensions/MeshoptDecoder.ts @@ -10,7 +10,15 @@ interface WorkerItem { requests: Record; } -const MeshoptDecoder = (function () { +export let ready: Promise<{ + workerCount: number; + useWorkers: (count?: number) => void; + decodeGltfBuffer: (count, stride, source, mode, filter) => Promise; + release: () => void; +}>; + +export function getMeshoptDecoder() { + if (ready) return ready; const wasm_base = "b9H79Tebbbe8Fv9Gbb9Gvuuuuueu9Giuuub9Geueu9Giuuueuikqbeeedddillviebeoweuec:q;iekr;leDo9TW9T9VV95dbH9F9F939H79T9F9J9H229F9Jt9VV7bb8A9TW79O9V9Wt9F9KW9J9V9KW9wWVtW949c919M9MWVbeY9TW79O9V9Wt9F9KW9J9V9KW69U9KW949c919M9MWVbdE9TW79O9V9Wt9F9KW9J9V9KW69U9KW949tWG91W9U9JWbiL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9p9JtblK9TW79O9V9Wt9F9KW9J9V9KWS9P2tWV9r919HtbvL9TW79O9V9Wt9F9KW9J9V9KWS9P2tWVT949Wbol79IV9Rbrq:P8Yqdbk;3sezu8Jjjjjbcj;eb9Rgv8Kjjjjbc9:hodnadcefal0mbcuhoaiRbbc:Ge9hmbavaialfgrad9Radz1jjjbhwcj;abad9UhoaicefhldnadTmbaoc;WFbGgocjdaocjd6EhDcbhqinaqae9pmeaDaeaq9RaqaDfae6Egkcsfgocl4cifcd4hxdndndndnaoc9WGgmTmbcbhPcehsawcjdfhzalhHinaraH9Rax6midnaraHaxfgl9RcK6mbczhoinawcj;cbfaogifgoc9WfhOdndndndndnaHaic9WfgAco4fRbbaAci4coG4ciGPlbedibkaO9cb83ibaOcwf9cb83ibxikaOalRblalRbbgAco4gCaCciSgCE86bbaocGfalclfaCfgORbbaAcl4ciGgCaCciSgCE86bbaocVfaOaCfgORbbaAcd4ciGgCaCciSgCE86bbaoc7faOaCfgORbbaAciGgAaAciSgAE86bbaoctfaOaAfgARbbalRbegOco4gCaCciSgCE86bbaoc91faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc4faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc93faAaCfgARbbaOciGgOaOciSgOE86bbaoc94faAaOfgARbbalRbdgOco4gCaCciSgCE86bbaoc95faAaCfgARbbaOcl4ciGgCaCciSgCE86bbaoc96faAaCfgARbbaOcd4ciGgCaCciSgCE86bbaoc97faAaCfgARbbaOciGgOaOciSgOE86bbaoc98faAaOfgORbbalRbiglco4gAaAciSgAE86bbaoc99faOaAfgORbbalcl4ciGgAaAciSgAE86bbaoc9:faOaAfgORbbalcd4ciGgAaAciSgAE86bbaocufaOaAfgoRbbalciGglalciSglE86bbaoalfhlxdkaOalRbwalRbbgAcl4gCaCcsSgCE86bbaocGfalcwfaCfgORbbaAcsGgAaAcsSgAE86bbaocVfaOaAfgORbbalRbegAcl4gCaCcsSgCE86bbaoc7faOaCfgORbbaAcsGgAaAcsSgAE86bbaoctfaOaAfgORbbalRbdgAcl4gCaCcsSgCE86bbaoc91faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc4faOaAfgORbbalRbigAcl4gCaCcsSgCE86bbaoc93faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc94faOaAfgORbbalRblgAcl4gCaCcsSgCE86bbaoc95faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc96faOaAfgORbbalRbvgAcl4gCaCcsSgCE86bbaoc97faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc98faOaAfgORbbalRbogAcl4gCaCcsSgCE86bbaoc99faOaCfgORbbaAcsGgAaAcsSgAE86bbaoc9:faOaAfgORbbalRbrglcl4gAaAcsSgAE86bbaocufaOaAfgoRbbalcsGglalcsSglE86bbaoalfhlxekaOal8Pbb83bbaOcwfalcwf8Pbb83bbalczfhlkdnaiam9pmbaiczfhoaral9RcL0mekkaiam6mialTmidnakTmbawaPfRbbhOcbhoazhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkkazcefhzaPcefgPad6hsalhHaPad9hmexvkkcbhlasceGmdxikalaxad2fhCdnakTmbcbhHcehsawcjdfhminaral9Rax6mialTmdalaxfhlawaHfRbbhOcbhoamhiinaiawcj;cbfaofRbbgAce4cbaAceG9R7aOfgO86bbaiadfhiaocefgoak9hmbkamcefhmaHcefgHad6hsaHad9hmbkaChlxikcbhocehsinaral9Rax6mdalTmealaxfhlaocefgoad6hsadao9hmbkaChlxdkcbhlasceGTmekc9:hoxikabaqad2fawcjdfakad2z1jjjb8Aawawcjdfakcufad2fadz1jjjb8Aakaqfhqalmbkc9:hoxekcbc99aral9Radcaadca0ESEhokavcj;ebf8Kjjjjbaok;yzeHu8Jjjjjbc;ae9Rgv8Kjjjjbc9:hodnaeci9UgrcHfal0mbcuhoaiRbbgwc;WeGc;Ge9hmbawcsGgDce0mbavc;abfcFecjez:jjjjb8AavcUf9cu83ibavc8Wf9cu83ibavcyf9cu83ibavcaf9cu83ibavcKf9cu83ibavczf9cu83ibav9cu83iwav9cu83ibaialfc9WfhqaicefgwarfhodnaeTmbcmcsaDceSEhkcbhxcbhmcbhDcbhicbhlindnaoaq9nmbc9:hoxikdndnawRbbgrc;Ve0mbavc;abfalarcl4cu7fcsGcitfgPydlhsaPydbhzdnarcsGgPak9pmbavaiarcu7fcsGcdtfydbaxaPEhraPThPdndnadcd9hmbabaDcetfgHaz87ebaHcdfas87ebaHclfar87ebxekabaDcdtfgHazBdbaHclfasBdbaHcwfarBdbkaxaPfhxavc;abfalcitfgHarBdbaHasBdlavaicdtfarBdbavc;abfalcefcsGglcitfgHazBdbaHarBdlaiaPfhialcefhlxdkdndnaPcsSmbamaPfaPc987fcefhmxekaocefhrao8SbbgPcFeGhHdndnaPcu9mmbarhoxekaocvfhoaHcFbGhHcrhPdninar8SbbgOcFbGaPtaHVhHaOcu9kmearcefhraPcrfgPc8J9hmbxdkkarcefhokaHce4cbaHceG9R7amfhmkdndnadcd9hmbabaDcetfgraz87ebarcdfas87ebarclfam87ebxekabaDcdtfgrazBdbarclfasBdbarcwfamBdbkavc;abfalcitfgramBdbarasBdlavaicdtfamBdbavc;abfalcefcsGglcitfgrazBdbaramBdlaicefhialcefhlxekdnarcpe0mbaxcefgOavaiaqarcsGfRbbgPcl49RcsGcdtfydbaPcz6gHEhravaiaP9RcsGcdtfydbaOaHfgsaPcsGgOEhPaOThOdndnadcd9hmbabaDcetfgzax87ebazcdfar87ebazclfaP87ebxekabaDcdtfgzaxBdbazclfarBdbazcwfaPBdbkavaicdtfaxBdbavc;abfalcitfgzarBdbazaxBdlavaicefgicsGcdtfarBdbavc;abfalcefcsGcitfgzaPBdbazarBdlavaiaHfcsGgicdtfaPBdbavc;abfalcdfcsGglcitfgraxBdbaraPBdlalcefhlaiaOfhiasaOfhxxekaxcbaoRbbgzEgAarc;:eSgrfhsazcsGhCazcl4hXdndnazcs0mbascefhOxekashOavaiaX9RcsGcdtfydbhskdndnaCmbaOcefhxxekaOhxavaiaz9RcsGcdtfydbhOkdndnarTmbaocefhrxekaocdfhrao8SbegHcFeGhPdnaHcu9kmbaocofhAaPcFbGhPcrhodninar8SbbgHcFbGaotaPVhPaHcu9kmearcefhraocrfgoc8J9hmbkaAhrxekarcefhrkaPce4cbaPceG9R7amfgmhAkdndnaXcsSmbarhPxekarcefhPar8SbbgocFeGhHdnaocu9kmbarcvfhsaHcFbGhHcrhodninaP8SbbgrcFbGaotaHVhHarcu9kmeaPcefhPaocrfgoc8J9hmbkashPxekaPcefhPkaHce4cbaHceG9R7amfgmhskdndnaCcsSmbaPhoxekaPcefhoaP8SbbgrcFeGhHdnarcu9kmbaPcvfhOaHcFbGhHcrhrdninao8SbbgPcFbGartaHVhHaPcu9kmeaocefhoarcrfgrc8J9hmbkaOhoxekaocefhokaHce4cbaHceG9R7amfgmhOkdndnadcd9hmbabaDcetfgraA87ebarcdfas87ebarclfaO87ebxekabaDcdtfgraABdbarclfasBdbarcwfaOBdbkavc;abfalcitfgrasBdbaraABdlavaicdtfaABdbavc;abfalcefcsGcitfgraOBdbarasBdlavaicefgicsGcdtfasBdbavc;abfalcdfcsGcitfgraABdbaraOBdlavaiazcz6aXcsSVfgicsGcdtfaOBdbaiaCTaCcsSVfhialcifhlkawcefhwalcsGhlaicsGhiaDcifgDae6mbkkcbc99aoaqSEhokavc;aef8Kjjjjbaok:llevu8Jjjjjbcz9Rhvc9:hodnaecvfal0mbcuhoaiRbbc;:eGc;qe9hmbav9cb83iwaicefhraialfc98fhwdnaeTmbdnadcdSmbcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcdtfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfglBdbaoalBdbaDcefgDae9hmbxdkkcbhDindnaraw6mbc9:skarcefhoar8SbbglcFeGhidndnalcu9mmbaohrxekarcvfhraicFbGhicrhldninao8SbbgdcFbGaltaiVhiadcu9kmeaocefhoalcrfglc8J9hmbxdkkaocefhrkabaDcetfaicd4cbaice4ceG9R7avcwfaiceGcdtVgoydbfgl87ebaoalBdbaDcefgDae9hmbkkcbc99arawSEhokaok:Lvoeue99dud99eud99dndnadcl9hmbaeTmeindndnabcdfgd8Sbb:Yab8Sbbgi:Ygl:l:tabcefgv8Sbbgo:Ygr:l:tgwJbb;:9cawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai86bbdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad86bbdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad86bbabclfhbaecufgembxdkkaeTmbindndnabclfgd8Ueb:Yab8Uebgi:Ygl:l:tabcdfgv8Uebgo:Ygr:l:tgwJb;:FSawawNJbbbbawawJbbbb9GgDEgq:mgkaqaicb9iEalMgwawNakaqaocb9iEarMgqaqNMM:r:vglNJbbbZJbbb:;aDEMgr:lJbbb9p9DTmbar:Ohixekcjjjj94hikadai87ebdndnaqalNJbbbZJbbb:;aqJbbbb9GEMgq:lJbbb9p9DTmbaq:Ohdxekcjjjj94hdkavad87ebdndnawalNJbbbZJbbb:;awJbbbb9GEMgw:lJbbb9p9DTmbaw:Ohdxekcjjjj94hdkabad87ebabcwfhbaecufgembkkk;siliui99iue99dnaeTmbcbhiabhlindndnJ;Zl81Zalcof8UebgvciV:Y:vgoal8Ueb:YNgrJb;:FSNJbbbZJbbb:;arJbbbb9GEMgw:lJbbb9p9DTmbaw:OhDxekcjjjj94hDkalclf8Uebhqalcdf8UebhkabavcefciGaiVcetfaD87ebdndnaoak:YNgwJb;:FSNJbbbZJbbb:;awJbbbb9GEMgx:lJbbb9p9DTmbax:Ohkxekcjjjj94hkkabavcdfciGaiVcetfak87ebdndnaoaq:YNgoJb;:FSNJbbbZJbbb:;aoJbbbb9GEMgx:lJbbb9p9DTmbax:Ohqxekcjjjj94hqkabavcufciGaiVcetfaq87ebdndnJbbjZararN:tawawN:taoaoN:tgrJbbbbarJbbbb9GE:rJb;:FSNJbbbZMgr:lJbbb9p9DTmbar:Ohqxekcjjjj94hqkabavciGaiVcetfaq87ebalcwfhlaiclfhiaecufgembkkk9mbdnadcd4ae2geTmbinababydbgdcwtcw91:Yadce91cjjj;8ifcjjj98G::NUdbabclfhbaecufgembkkk9teiucbcbydj1jjbgeabcifc98GfgbBdj1jjbdndnabZbcztgd9nmbcuhiabad9RcFFifcz4nbcuSmekaehikaik;LeeeudndnaeabVciGTmbabhixekdndnadcz9pmbabhixekabhiinaiaeydbBdbaiclfaeclfydbBdbaicwfaecwfydbBdbaicxfaecxfydbBdbaiczfhiaeczfheadc9Wfgdcs0mbkkadcl6mbinaiaeydbBdbaeclfheaiclfhiadc98fgdci0mbkkdnadTmbinaiaeRbb86bbaicefhiaecefheadcufgdmbkkabk;aeedudndnabciGTmbabhixekaecFeGc:b:c:ew2hldndnadcz9pmbabhixekabhiinaialBdbaicxfalBdbaicwfalBdbaiclfalBdbaiczfhiadc9Wfgdcs0mbkkadcl6mbinaialBdbaiclfhiadc98fgdci0mbkkdnadTmbinaiae86bbaicefhiadcufgdmbkkabkkkebcjwklz9Kbb"; const wasm_simd = @@ -27,10 +35,35 @@ const MeshoptDecoder = (function () { let instance; - const ready = WebAssembly.instantiate(unpack(wasm), {}).then(function (result) { - instance = result.instance; - instance.exports.__wasm_call_ctors(); - }); + ready = WebAssembly.instantiate(unpack(wasm)) + .then(function (result) { + instance = result.instance; + instance.exports.__wasm_call_ctors(); + }) + .then(() => ({ + workerCount: 4, + ready: ready, + useWorkers: function (workerCount?: number) { + this.workerCount = workerCount ?? this.workerCount; + initWorkers(this.workerCount); + }, + decodeGltfBuffer: function (count, stride, source, mode, filter): Promise { + if (this.workerCount > 0 && workers.length === 0) this.useWorkers(); + + if (workers.length > 0) return decodeWorker(count, stride, source, decoders[mode], filters[filter]); + + return ready.then(function () { + const target = new Uint8Array(count * stride); + decode(instance.exports[decoders[mode]], target, count, stride, source, instance.exports[filters[filter]]); + return target; + }); + }, + release() { + for (let i = 0; i < workers.length; i++) { + workers[i].object.terminate(); + } + } + })); function unpack(data) { const result = new Uint8Array(data.length); @@ -106,39 +139,39 @@ const MeshoptDecoder = (function () { ".then(function(result) {instance = result.instance; instance.exports.__wasm_call_ctors();});\n" + "self.onmessage = workerProcess;\n" + `function decode(fun, target, count, size, source, filter) { - const sbrk = instance.exports.sbrk; - const count4 = (count + 3) & ~3; - const tp = sbrk(count4 * size); - const sp = sbrk(source.length); - const heap = new Uint8Array(instance.exports.memory.buffer); - heap.set(source, sp); - const res = fun(tp, count, size, sp, source.length); - if (res == 0 && filter) { - filter(tp, count4, size); - } - target.set(heap.subarray(tp, tp + count * size)); - sbrk(tp - sbrk(0)); - if (res != 0) { - throw new Error("Malformed buffer data: " + res); - } - }\n` + + const sbrk = instance.exports.sbrk; + const count4 = (count + 3) & ~3; + const tp = sbrk(count4 * size); + const sp = sbrk(source.length); + const heap = new Uint8Array(instance.exports.memory.buffer); + heap.set(source, sp); + const res = fun(tp, count, size, sp, source.length); + if (res == 0 && filter) { + filter(tp, count4, size); + } + target.set(heap.subarray(tp, tp + count * size)); + sbrk(tp - sbrk(0)); + if (res != 0) { + throw new Error("Malformed buffer data: " + res); + } + }\n` + `function workerProcess(event) { - ready.then(function () { - const data = event.data; - try { - const target = new Uint8Array(data.count * data.size); - decode(instance.exports[data.mode], target, data.count, data.size, data.source, instance.exports[data.filter]); - self.postMessage({ id: data.id, count: data.count, action: "resolve", value: target }, [target.buffer]); - } catch (error) { - self.postMessage({ - id: data.id, - count: data.count, - action: "reject", - value: error - }); - } - }); - }`; + ready.then(function () { + const data = event.data; + try { + const target = new Uint8Array(data.count * data.size); + decode(instance.exports[data.mode], target, data.count, data.size, data.source, instance.exports[data.filter]); + self.postMessage({ id: data.id, count: data.count, action: "resolve", value: target }, [target.buffer]); + } catch (error) { + self.postMessage({ + id: data.id, + count: data.count, + action: "reject", + value: error + }); + } + }); + }`; const blob = new Blob([source], { type: "text/javascript" }); const url = URL.createObjectURL(blob); @@ -179,29 +212,5 @@ const MeshoptDecoder = (function () { }); } - return { - workerCount: 4, - ready: ready, - useWorkers: function () { - initWorkers(this.workerCount); - }, - decodeGltfBuffer: function (count, stride, source, mode, filter): Promise { - if (this.workerCount > 0 && workers.length === 0) this.useWorkers(); - - if (workers.length > 0) return decodeWorker(count, stride, source, decoders[mode], filters[filter]); - - return ready.then(function () { - const target = new Uint8Array(count * stride); - decode(instance.exports[decoders[mode]], target, count, stride, source, instance.exports[filters[filter]]); - return target; - }); - }, - release() { - for (let i = 0; i < workers.length; i++) { - workers[i].object.terminate(); - } - } - }; -})(); - -export { MeshoptDecoder }; + return ready; +}