GLTFLoader.js 95 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928
  1. import {
  2. AnimationClip,
  3. Bone,
  4. Box3,
  5. BufferAttribute,
  6. BufferGeometry,
  7. CanvasTexture,
  8. ClampToEdgeWrapping,
  9. Color,
  10. DirectionalLight,
  11. DoubleSide,
  12. FileLoader,
  13. FrontSide,
  14. Group,
  15. ImageBitmapLoader,
  16. InterleavedBuffer,
  17. InterleavedBufferAttribute,
  18. Interpolant,
  19. InterpolateDiscrete,
  20. InterpolateLinear,
  21. Line,
  22. LineBasicMaterial,
  23. LineLoop,
  24. LineSegments,
  25. LinearFilter,
  26. LinearMipmapLinearFilter,
  27. LinearMipmapNearestFilter,
  28. Loader,
  29. LoaderUtils,
  30. Material,
  31. MathUtils,
  32. Matrix4,
  33. Mesh,
  34. MeshBasicMaterial,
  35. MeshPhysicalMaterial,
  36. MeshStandardMaterial,
  37. MirroredRepeatWrapping,
  38. NearestFilter,
  39. NearestMipmapLinearFilter,
  40. NearestMipmapNearestFilter,
  41. NumberKeyframeTrack,
  42. Object3D,
  43. OrthographicCamera,
  44. PerspectiveCamera,
  45. PointLight,
  46. Points,
  47. PointsMaterial,
  48. PropertyBinding,
  49. QuaternionKeyframeTrack,
  50. RGBFormat,
  51. RepeatWrapping,
  52. Skeleton,
  53. SkinnedMesh,
  54. Sphere,
  55. SpotLight,
  56. TangentSpaceNormalMap,
  57. TextureLoader,
  58. TriangleFanDrawMode,
  59. TriangleStripDrawMode,
  60. Vector2,
  61. Vector3,
  62. VectorKeyframeTrack,
  63. sRGBEncoding
  64. } from '../../../build/three.module.js';
  65. var GLTFLoader = ( function () {
  66. function GLTFLoader( manager ) {
  67. Loader.call( this, manager );
  68. this.dracoLoader = null;
  69. this.ktx2Loader = null;
  70. this.meshoptDecoder = null;
  71. this.pluginCallbacks = [];
  72. this.register( function ( parser ) {
  73. return new GLTFMaterialsClearcoatExtension( parser );
  74. } );
  75. this.register( function ( parser ) {
  76. return new GLTFTextureBasisUExtension( parser );
  77. } );
  78. this.register( function ( parser ) {
  79. return new GLTFTextureWebPExtension( parser );
  80. } );
  81. this.register( function ( parser ) {
  82. return new GLTFMaterialsTransmissionExtension( parser );
  83. } );
  84. this.register( function ( parser ) {
  85. return new GLTFLightsExtension( parser );
  86. } );
  87. this.register( function ( parser ) {
  88. return new GLTFMeshoptCompression( parser );
  89. } );
  90. }
  91. GLTFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
  92. constructor: GLTFLoader,
  93. load: function ( url, onLoad, onProgress, onError ) {
  94. var scope = this;
  95. var resourcePath;
  96. if ( this.resourcePath !== '' ) {
  97. resourcePath = this.resourcePath;
  98. } else if ( this.path !== '' ) {
  99. resourcePath = this.path;
  100. } else {
  101. resourcePath = LoaderUtils.extractUrlBase( url );
  102. }
  103. // Tells the LoadingManager to track an extra item, which resolves after
  104. // the model is fully loaded. This means the count of items loaded will
  105. // be incorrect, but ensures manager.onLoad() does not fire early.
  106. this.manager.itemStart( url );
  107. var _onError = function ( e ) {
  108. if ( onError ) {
  109. onError( e );
  110. } else {
  111. console.error( e );
  112. }
  113. scope.manager.itemError( url );
  114. scope.manager.itemEnd( url );
  115. };
  116. var loader = new FileLoader( this.manager );
  117. loader.setPath( this.path );
  118. loader.setResponseType( 'arraybuffer' );
  119. loader.setRequestHeader( this.requestHeader );
  120. loader.setWithCredentials( this.withCredentials );
  121. loader.load( url, function ( data ) {
  122. try {
  123. scope.parse( data, resourcePath, function ( gltf ) {
  124. onLoad( gltf );
  125. scope.manager.itemEnd( url );
  126. }, _onError );
  127. } catch ( e ) {
  128. _onError( e );
  129. }
  130. }, onProgress, _onError );
  131. },
  132. setDRACOLoader: function ( dracoLoader ) {
  133. this.dracoLoader = dracoLoader;
  134. return this;
  135. },
  136. setDDSLoader: function () {
  137. throw new Error(
  138. 'THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".'
  139. );
  140. },
  141. setKTX2Loader: function ( ktx2Loader ) {
  142. this.ktx2Loader = ktx2Loader;
  143. return this;
  144. },
  145. setMeshoptDecoder: function ( meshoptDecoder ) {
  146. this.meshoptDecoder = meshoptDecoder;
  147. return this;
  148. },
  149. register: function ( callback ) {
  150. if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {
  151. this.pluginCallbacks.push( callback );
  152. }
  153. return this;
  154. },
  155. unregister: function ( callback ) {
  156. if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {
  157. this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );
  158. }
  159. return this;
  160. },
  161. parse: function ( data, path, onLoad, onError ) {
  162. var content;
  163. var extensions = {};
  164. var plugins = {};
  165. if ( typeof data === 'string' ) {
  166. content = data;
  167. } else {
  168. var magic = LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
  169. if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
  170. try {
  171. extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
  172. } catch ( error ) {
  173. if ( onError ) onError( error );
  174. return;
  175. }
  176. content = extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content;
  177. } else {
  178. content = LoaderUtils.decodeText( new Uint8Array( data ) );
  179. }
  180. }
  181. var json = JSON.parse( content );
  182. if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
  183. if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
  184. return;
  185. }
  186. var parser = new GLTFParser( json, {
  187. path: path || this.resourcePath || '',
  188. crossOrigin: this.crossOrigin,
  189. requestHeader: this.requestHeader,
  190. manager: this.manager,
  191. ktx2Loader: this.ktx2Loader,
  192. meshoptDecoder: this.meshoptDecoder
  193. } );
  194. parser.fileLoader.setRequestHeader( this.requestHeader );
  195. for ( var i = 0; i < this.pluginCallbacks.length; i ++ ) {
  196. var plugin = this.pluginCallbacks[ i ]( parser );
  197. plugins[ plugin.name ] = plugin;
  198. // Workaround to avoid determining as unknown extension
  199. // in addUnknownExtensionsToUserData().
  200. // Remove this workaround if we move all the existing
  201. // extension handlers to plugin system
  202. extensions[ plugin.name ] = true;
  203. }
  204. if ( json.extensionsUsed ) {
  205. for ( var i = 0; i < json.extensionsUsed.length; ++ i ) {
  206. var extensionName = json.extensionsUsed[ i ];
  207. var extensionsRequired = json.extensionsRequired || [];
  208. switch ( extensionName ) {
  209. case EXTENSIONS.KHR_MATERIALS_UNLIT:
  210. extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
  211. break;
  212. case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
  213. extensions[ extensionName ] = new GLTFMaterialsPbrSpecularGlossinessExtension();
  214. break;
  215. case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
  216. extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
  217. break;
  218. case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
  219. extensions[ extensionName ] = new GLTFTextureTransformExtension();
  220. break;
  221. case EXTENSIONS.KHR_MESH_QUANTIZATION:
  222. extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
  223. break;
  224. default:
  225. if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {
  226. console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
  227. }
  228. }
  229. }
  230. }
  231. parser.setExtensions( extensions );
  232. parser.setPlugins( plugins );
  233. parser.parse( onLoad, onError );
  234. }
  235. } );
  236. /* GLTFREGISTRY */
  237. function GLTFRegistry() {
  238. var objects = {};
  239. return {
  240. get: function ( key ) {
  241. return objects[ key ];
  242. },
  243. add: function ( key, object ) {
  244. objects[ key ] = object;
  245. },
  246. remove: function ( key ) {
  247. delete objects[ key ];
  248. },
  249. removeAll: function () {
  250. objects = {};
  251. }
  252. };
  253. }
  254. /*********************************/
  255. /********** EXTENSIONS ***********/
  256. /*********************************/
  257. var EXTENSIONS = {
  258. KHR_BINARY_GLTF: 'KHR_binary_glTF',
  259. KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
  260. KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
  261. KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
  262. KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
  263. KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
  264. KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
  265. KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
  266. KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
  267. KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
  268. EXT_TEXTURE_WEBP: 'EXT_texture_webp',
  269. EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression'
  270. };
  271. /**
  272. * Punctual Lights Extension
  273. *
  274. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
  275. */
  276. function GLTFLightsExtension( parser ) {
  277. this.parser = parser;
  278. this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
  279. // Object3D instance caches
  280. this.cache = { refs: {}, uses: {} };
  281. }
  282. GLTFLightsExtension.prototype._markDefs = function () {
  283. var parser = this.parser;
  284. var nodeDefs = this.parser.json.nodes || [];
  285. for ( var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
  286. var nodeDef = nodeDefs[ nodeIndex ];
  287. if ( nodeDef.extensions
  288. && nodeDef.extensions[ this.name ]
  289. && nodeDef.extensions[ this.name ].light !== undefined ) {
  290. parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );
  291. }
  292. }
  293. };
  294. GLTFLightsExtension.prototype._loadLight = function ( lightIndex ) {
  295. var parser = this.parser;
  296. var cacheKey = 'light:' + lightIndex;
  297. var dependency = parser.cache.get( cacheKey );
  298. if ( dependency ) return dependency;
  299. var json = parser.json;
  300. var extensions = ( json.extensions && json.extensions[ this.name ] ) || {};
  301. var lightDefs = extensions.lights || [];
  302. var lightDef = lightDefs[ lightIndex ];
  303. var lightNode;
  304. var color = new Color( 0xffffff );
  305. if ( lightDef.color !== undefined ) color.fromArray( lightDef.color );
  306. var range = lightDef.range !== undefined ? lightDef.range : 0;
  307. switch ( lightDef.type ) {
  308. case 'directional':
  309. lightNode = new DirectionalLight( color );
  310. lightNode.target.position.set( 0, 0, - 1 );
  311. lightNode.add( lightNode.target );
  312. break;
  313. case 'point':
  314. lightNode = new PointLight( color );
  315. lightNode.distance = range;
  316. break;
  317. case 'spot':
  318. lightNode = new SpotLight( color );
  319. lightNode.distance = range;
  320. // Handle spotlight properties.
  321. lightDef.spot = lightDef.spot || {};
  322. lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
  323. lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
  324. lightNode.angle = lightDef.spot.outerConeAngle;
  325. lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
  326. lightNode.target.position.set( 0, 0, - 1 );
  327. lightNode.add( lightNode.target );
  328. break;
  329. default:
  330. throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );
  331. }
  332. // Some lights (e.g. spot) default to a position other than the origin. Reset the position
  333. // here, because node-level parsing will only override position if explicitly specified.
  334. lightNode.position.set( 0, 0, 0 );
  335. lightNode.decay = 2;
  336. if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
  337. lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );
  338. dependency = Promise.resolve( lightNode );
  339. parser.cache.add( cacheKey, dependency );
  340. return dependency;
  341. };
  342. GLTFLightsExtension.prototype.createNodeAttachment = function ( nodeIndex ) {
  343. var self = this;
  344. var parser = this.parser;
  345. var json = parser.json;
  346. var nodeDef = json.nodes[ nodeIndex ];
  347. var lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};
  348. var lightIndex = lightDef.light;
  349. if ( lightIndex === undefined ) return null;
  350. return this._loadLight( lightIndex ).then( function ( light ) {
  351. return parser._getNodeRef( self.cache, lightIndex, light );
  352. } );
  353. };
  354. /**
  355. * Unlit Materials Extension
  356. *
  357. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit
  358. */
  359. function GLTFMaterialsUnlitExtension() {
  360. this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
  361. }
  362. GLTFMaterialsUnlitExtension.prototype.getMaterialType = function () {
  363. return MeshBasicMaterial;
  364. };
  365. GLTFMaterialsUnlitExtension.prototype.extendParams = function ( materialParams, materialDef, parser ) {
  366. var pending = [];
  367. materialParams.color = new Color( 1.0, 1.0, 1.0 );
  368. materialParams.opacity = 1.0;
  369. var metallicRoughness = materialDef.pbrMetallicRoughness;
  370. if ( metallicRoughness ) {
  371. if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
  372. var array = metallicRoughness.baseColorFactor;
  373. materialParams.color.fromArray( array );
  374. materialParams.opacity = array[ 3 ];
  375. }
  376. if ( metallicRoughness.baseColorTexture !== undefined ) {
  377. pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
  378. }
  379. }
  380. return Promise.all( pending );
  381. };
  382. /**
  383. * Clearcoat Materials Extension
  384. *
  385. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_clearcoat
  386. */
  387. function GLTFMaterialsClearcoatExtension( parser ) {
  388. this.parser = parser;
  389. this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
  390. }
  391. GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function ( materialIndex ) {
  392. var parser = this.parser;
  393. var materialDef = parser.json.materials[ materialIndex ];
  394. if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
  395. return MeshPhysicalMaterial;
  396. };
  397. GLTFMaterialsClearcoatExtension.prototype.extendMaterialParams = function ( materialIndex, materialParams ) {
  398. var parser = this.parser;
  399. var materialDef = parser.json.materials[ materialIndex ];
  400. if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
  401. return Promise.resolve();
  402. }
  403. var pending = [];
  404. var extension = materialDef.extensions[ this.name ];
  405. if ( extension.clearcoatFactor !== undefined ) {
  406. materialParams.clearcoat = extension.clearcoatFactor;
  407. }
  408. if ( extension.clearcoatTexture !== undefined ) {
  409. pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );
  410. }
  411. if ( extension.clearcoatRoughnessFactor !== undefined ) {
  412. materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
  413. }
  414. if ( extension.clearcoatRoughnessTexture !== undefined ) {
  415. pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );
  416. }
  417. if ( extension.clearcoatNormalTexture !== undefined ) {
  418. pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );
  419. if ( extension.clearcoatNormalTexture.scale !== undefined ) {
  420. var scale = extension.clearcoatNormalTexture.scale;
  421. // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
  422. materialParams.clearcoatNormalScale = new Vector2( scale, -scale );
  423. }
  424. }
  425. return Promise.all( pending );
  426. };
  427. /**
  428. * Transmission Materials Extension
  429. *
  430. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_transmission
  431. * Draft: https://github.com/KhronosGroup/glTF/pull/1698
  432. */
  433. function GLTFMaterialsTransmissionExtension( parser ) {
  434. this.parser = parser;
  435. this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
  436. }
  437. GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function ( materialIndex ) {
  438. var parser = this.parser;
  439. var materialDef = parser.json.materials[ materialIndex ];
  440. if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
  441. return MeshPhysicalMaterial;
  442. };
  443. GLTFMaterialsTransmissionExtension.prototype.extendMaterialParams = function ( materialIndex, materialParams ) {
  444. var parser = this.parser;
  445. var materialDef = parser.json.materials[ materialIndex ];
  446. if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
  447. return Promise.resolve();
  448. }
  449. var pending = [];
  450. var extension = materialDef.extensions[ this.name ];
  451. if ( extension.transmissionFactor !== undefined ) {
  452. materialParams.transmission = extension.transmissionFactor;
  453. }
  454. if ( extension.transmissionTexture !== undefined ) {
  455. pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );
  456. }
  457. return Promise.all( pending );
  458. };
  459. /**
  460. * BasisU Texture Extension
  461. *
  462. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_basisu
  463. */
  464. function GLTFTextureBasisUExtension( parser ) {
  465. this.parser = parser;
  466. this.name = EXTENSIONS.KHR_TEXTURE_BASISU;
  467. }
  468. GLTFTextureBasisUExtension.prototype.loadTexture = function ( textureIndex ) {
  469. var parser = this.parser;
  470. var json = parser.json;
  471. var textureDef = json.textures[ textureIndex ];
  472. if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {
  473. return null;
  474. }
  475. var extension = textureDef.extensions[ this.name ];
  476. var source = json.images[ extension.source ];
  477. var loader = parser.options.ktx2Loader;
  478. if ( ! loader ) {
  479. if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {
  480. throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );
  481. } else {
  482. // Assumes that the extension is optional and that a fallback texture is present
  483. return null;
  484. }
  485. }
  486. return parser.loadTextureImage( textureIndex, source, loader );
  487. };
  488. /**
  489. * WebP Texture Extension
  490. *
  491. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_webp
  492. */
  493. function GLTFTextureWebPExtension( parser ) {
  494. this.parser = parser;
  495. this.name = EXTENSIONS.EXT_TEXTURE_WEBP;
  496. this.isSupported = null;
  497. }
  498. GLTFTextureWebPExtension.prototype.loadTexture = function ( textureIndex ) {
  499. var name = this.name;
  500. var parser = this.parser;
  501. var json = parser.json;
  502. var textureDef = json.textures[ textureIndex ];
  503. if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {
  504. return null;
  505. }
  506. var extension = textureDef.extensions[ name ];
  507. var source = json.images[ extension.source ];
  508. var loader = source.uri ? parser.options.manager.getHandler( source.uri ) : parser.textureLoader;
  509. return this.detectSupport().then( function ( isSupported ) {
  510. if ( isSupported ) return parser.loadTextureImage( textureIndex, source, loader );
  511. if ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) {
  512. throw new Error( 'THREE.GLTFLoader: WebP required by asset but unsupported.' );
  513. }
  514. // Fall back to PNG or JPEG.
  515. return parser.loadTexture( textureIndex );
  516. } );
  517. };
  518. GLTFTextureWebPExtension.prototype.detectSupport = function () {
  519. if ( ! this.isSupported ) {
  520. this.isSupported = new Promise( function ( resolve ) {
  521. var image = new Image();
  522. // Lossy test image. Support for lossy images doesn't guarantee support for all
  523. // WebP images, unfortunately.
  524. image.src = 'data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA';
  525. image.onload = image.onerror = function () {
  526. resolve( image.height === 1 );
  527. };
  528. } );
  529. }
  530. return this.isSupported;
  531. };
  532. /**
  533. * meshopt BufferView Compression Extension
  534. *
  535. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_meshopt_compression
  536. */
  537. function GLTFMeshoptCompression( parser ) {
  538. this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;
  539. this.parser = parser;
  540. }
  541. GLTFMeshoptCompression.prototype.loadBufferView = function ( index ) {
  542. var json = this.parser.json;
  543. var bufferView = json.bufferViews[ index ];
  544. if ( bufferView.extensions && bufferView.extensions[ this.name ] ) {
  545. var extensionDef = bufferView.extensions[ this.name ];
  546. var buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );
  547. var decoder = this.parser.options.meshoptDecoder;
  548. if ( ! decoder || ! decoder.supported ) {
  549. if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {
  550. throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );
  551. } else {
  552. // Assumes that the extension is optional and that fallback buffer data is present
  553. return null;
  554. }
  555. }
  556. return Promise.all( [ buffer, decoder.ready ] ).then( function ( res ) {
  557. var byteOffset = extensionDef.byteOffset || 0;
  558. var byteLength = extensionDef.byteLength || 0;
  559. var count = extensionDef.count;
  560. var stride = extensionDef.byteStride;
  561. var result = new ArrayBuffer( count * stride );
  562. var source = new Uint8Array( res[ 0 ], byteOffset, byteLength );
  563. decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );
  564. return result;
  565. } );
  566. } else {
  567. return null;
  568. }
  569. };
  570. /* BINARY EXTENSION */
  571. var BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
  572. var BINARY_EXTENSION_HEADER_LENGTH = 12;
  573. var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };
  574. function GLTFBinaryExtension( data ) {
  575. this.name = EXTENSIONS.KHR_BINARY_GLTF;
  576. this.content = null;
  577. this.body = null;
  578. var headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
  579. this.header = {
  580. magic: LoaderUtils.decodeText( new Uint8Array( data.slice( 0, 4 ) ) ),
  581. version: headerView.getUint32( 4, true ),
  582. length: headerView.getUint32( 8, true )
  583. };
  584. if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {
  585. throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );
  586. } else if ( this.header.version < 2.0 ) {
  587. throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );
  588. }
  589. var chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
  590. var chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
  591. var chunkIndex = 0;
  592. while ( chunkIndex < chunkContentsLength ) {
  593. var chunkLength = chunkView.getUint32( chunkIndex, true );
  594. chunkIndex += 4;
  595. var chunkType = chunkView.getUint32( chunkIndex, true );
  596. chunkIndex += 4;
  597. if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
  598. var contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
  599. this.content = LoaderUtils.decodeText( contentArray );
  600. } else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
  601. var byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
  602. this.body = data.slice( byteOffset, byteOffset + chunkLength );
  603. }
  604. // Clients must ignore chunks with unknown types.
  605. chunkIndex += chunkLength;
  606. }
  607. if ( this.content === null ) {
  608. throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
  609. }
  610. }
  611. /**
  612. * DRACO Mesh Compression Extension
  613. *
  614. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
  615. */
  616. function GLTFDracoMeshCompressionExtension( json, dracoLoader ) {
  617. if ( ! dracoLoader ) {
  618. throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
  619. }
  620. this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
  621. this.json = json;
  622. this.dracoLoader = dracoLoader;
  623. this.dracoLoader.preload();
  624. }
  625. GLTFDracoMeshCompressionExtension.prototype.decodePrimitive = function ( primitive, parser ) {
  626. var json = this.json;
  627. var dracoLoader = this.dracoLoader;
  628. var bufferViewIndex = primitive.extensions[ this.name ].bufferView;
  629. var gltfAttributeMap = primitive.extensions[ this.name ].attributes;
  630. var threeAttributeMap = {};
  631. var attributeNormalizedMap = {};
  632. var attributeTypeMap = {};
  633. for ( var attributeName in gltfAttributeMap ) {
  634. var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
  635. threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
  636. }
  637. for ( attributeName in primitive.attributes ) {
  638. var threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
  639. if ( gltfAttributeMap[ attributeName ] !== undefined ) {
  640. var accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
  641. var componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
  642. attributeTypeMap[ threeAttributeName ] = componentType;
  643. attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
  644. }
  645. }
  646. return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
  647. return new Promise( function ( resolve ) {
  648. dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
  649. for ( var attributeName in geometry.attributes ) {
  650. var attribute = geometry.attributes[ attributeName ];
  651. var normalized = attributeNormalizedMap[ attributeName ];
  652. if ( normalized !== undefined ) attribute.normalized = normalized;
  653. }
  654. resolve( geometry );
  655. }, threeAttributeMap, attributeTypeMap );
  656. } );
  657. } );
  658. };
  659. /**
  660. * Texture Transform Extension
  661. *
  662. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
  663. */
  664. function GLTFTextureTransformExtension() {
  665. this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
  666. }
  667. GLTFTextureTransformExtension.prototype.extendTexture = function ( texture, transform ) {
  668. texture = texture.clone();
  669. if ( transform.offset !== undefined ) {
  670. texture.offset.fromArray( transform.offset );
  671. }
  672. if ( transform.rotation !== undefined ) {
  673. texture.rotation = transform.rotation;
  674. }
  675. if ( transform.scale !== undefined ) {
  676. texture.repeat.fromArray( transform.scale );
  677. }
  678. if ( transform.texCoord !== undefined ) {
  679. console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
  680. }
  681. texture.needsUpdate = true;
  682. return texture;
  683. };
  684. /**
  685. * Specular-Glossiness Extension
  686. *
  687. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
  688. */
  689. /**
  690. * A sub class of StandardMaterial with some of the functionality
  691. * changed via the `onBeforeCompile` callback
  692. * @pailhead
  693. */
  694. function GLTFMeshStandardSGMaterial( params ) {
  695. MeshStandardMaterial.call( this );
  696. this.isGLTFSpecularGlossinessMaterial = true;
  697. //various chunks that need replacing
  698. var specularMapParsFragmentChunk = [
  699. '#ifdef USE_SPECULARMAP',
  700. ' uniform sampler2D specularMap;',
  701. '#endif'
  702. ].join( '\n' );
  703. var glossinessMapParsFragmentChunk = [
  704. '#ifdef USE_GLOSSINESSMAP',
  705. ' uniform sampler2D glossinessMap;',
  706. '#endif'
  707. ].join( '\n' );
  708. var specularMapFragmentChunk = [
  709. 'vec3 specularFactor = specular;',
  710. '#ifdef USE_SPECULARMAP',
  711. ' vec4 texelSpecular = texture2D( specularMap, vUv );',
  712. ' texelSpecular = sRGBToLinear( texelSpecular );',
  713. ' // reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture',
  714. ' specularFactor *= texelSpecular.rgb;',
  715. '#endif'
  716. ].join( '\n' );
  717. var glossinessMapFragmentChunk = [
  718. 'float glossinessFactor = glossiness;',
  719. '#ifdef USE_GLOSSINESSMAP',
  720. ' vec4 texelGlossiness = texture2D( glossinessMap, vUv );',
  721. ' // reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture',
  722. ' glossinessFactor *= texelGlossiness.a;',
  723. '#endif'
  724. ].join( '\n' );
  725. var lightPhysicalFragmentChunk = [
  726. 'PhysicalMaterial material;',
  727. 'material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );',
  728. 'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );',
  729. 'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );',
  730. 'material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.',
  731. 'material.specularRoughness += geometryRoughness;',
  732. 'material.specularRoughness = min( material.specularRoughness, 1.0 );',
  733. 'material.specularColor = specularFactor;',
  734. ].join( '\n' );
  735. var uniforms = {
  736. specular: { value: new Color().setHex( 0xffffff ) },
  737. glossiness: { value: 1 },
  738. specularMap: { value: null },
  739. glossinessMap: { value: null }
  740. };
  741. this._extraUniforms = uniforms;
  742. this.onBeforeCompile = function ( shader ) {
  743. for ( var uniformName in uniforms ) {
  744. shader.uniforms[ uniformName ] = uniforms[ uniformName ];
  745. }
  746. shader.fragmentShader = shader.fragmentShader
  747. .replace( 'uniform float roughness;', 'uniform vec3 specular;' )
  748. .replace( 'uniform float metalness;', 'uniform float glossiness;' )
  749. .replace( '#include <roughnessmap_pars_fragment>', specularMapParsFragmentChunk )
  750. .replace( '#include <metalnessmap_pars_fragment>', glossinessMapParsFragmentChunk )
  751. .replace( '#include <roughnessmap_fragment>', specularMapFragmentChunk )
  752. .replace( '#include <metalnessmap_fragment>', glossinessMapFragmentChunk )
  753. .replace( '#include <lights_physical_fragment>', lightPhysicalFragmentChunk );
  754. };
  755. Object.defineProperties( this, {
  756. specular: {
  757. get: function () {
  758. return uniforms.specular.value;
  759. },
  760. set: function ( v ) {
  761. uniforms.specular.value = v;
  762. }
  763. },
  764. specularMap: {
  765. get: function () {
  766. return uniforms.specularMap.value;
  767. },
  768. set: function ( v ) {
  769. uniforms.specularMap.value = v;
  770. if ( v ) {
  771. this.defines.USE_SPECULARMAP = ''; // USE_UV is set by the renderer for specular maps
  772. } else {
  773. delete this.defines.USE_SPECULARMAP;
  774. }
  775. }
  776. },
  777. glossiness: {
  778. get: function () {
  779. return uniforms.glossiness.value;
  780. },
  781. set: function ( v ) {
  782. uniforms.glossiness.value = v;
  783. }
  784. },
  785. glossinessMap: {
  786. get: function () {
  787. return uniforms.glossinessMap.value;
  788. },
  789. set: function ( v ) {
  790. uniforms.glossinessMap.value = v;
  791. if ( v ) {
  792. this.defines.USE_GLOSSINESSMAP = '';
  793. this.defines.USE_UV = '';
  794. } else {
  795. delete this.defines.USE_GLOSSINESSMAP;
  796. delete this.defines.USE_UV;
  797. }
  798. }
  799. }
  800. } );
  801. delete this.metalness;
  802. delete this.roughness;
  803. delete this.metalnessMap;
  804. delete this.roughnessMap;
  805. this.setValues( params );
  806. }
  807. GLTFMeshStandardSGMaterial.prototype = Object.create( MeshStandardMaterial.prototype );
  808. GLTFMeshStandardSGMaterial.prototype.constructor = GLTFMeshStandardSGMaterial;
  809. GLTFMeshStandardSGMaterial.prototype.copy = function ( source ) {
  810. MeshStandardMaterial.prototype.copy.call( this, source );
  811. this.specularMap = source.specularMap;
  812. this.specular.copy( source.specular );
  813. this.glossinessMap = source.glossinessMap;
  814. this.glossiness = source.glossiness;
  815. delete this.metalness;
  816. delete this.roughness;
  817. delete this.metalnessMap;
  818. delete this.roughnessMap;
  819. return this;
  820. };
  821. function GLTFMaterialsPbrSpecularGlossinessExtension() {
  822. return {
  823. name: EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS,
  824. specularGlossinessParams: [
  825. 'color',
  826. 'map',
  827. 'lightMap',
  828. 'lightMapIntensity',
  829. 'aoMap',
  830. 'aoMapIntensity',
  831. 'emissive',
  832. 'emissiveIntensity',
  833. 'emissiveMap',
  834. 'bumpMap',
  835. 'bumpScale',
  836. 'normalMap',
  837. 'normalMapType',
  838. 'displacementMap',
  839. 'displacementScale',
  840. 'displacementBias',
  841. 'specularMap',
  842. 'specular',
  843. 'glossinessMap',
  844. 'glossiness',
  845. 'alphaMap',
  846. 'envMap',
  847. 'envMapIntensity',
  848. 'refractionRatio',
  849. ],
  850. getMaterialType: function () {
  851. return GLTFMeshStandardSGMaterial;
  852. },
  853. extendParams: function ( materialParams, materialDef, parser ) {
  854. var pbrSpecularGlossiness = materialDef.extensions[ this.name ];
  855. materialParams.color = new Color( 1.0, 1.0, 1.0 );
  856. materialParams.opacity = 1.0;
  857. var pending = [];
  858. if ( Array.isArray( pbrSpecularGlossiness.diffuseFactor ) ) {
  859. var array = pbrSpecularGlossiness.diffuseFactor;
  860. materialParams.color.fromArray( array );
  861. materialParams.opacity = array[ 3 ];
  862. }
  863. if ( pbrSpecularGlossiness.diffuseTexture !== undefined ) {
  864. pending.push( parser.assignTexture( materialParams, 'map', pbrSpecularGlossiness.diffuseTexture ) );
  865. }
  866. materialParams.emissive = new Color( 0.0, 0.0, 0.0 );
  867. materialParams.glossiness = pbrSpecularGlossiness.glossinessFactor !== undefined ? pbrSpecularGlossiness.glossinessFactor : 1.0;
  868. materialParams.specular = new Color( 1.0, 1.0, 1.0 );
  869. if ( Array.isArray( pbrSpecularGlossiness.specularFactor ) ) {
  870. materialParams.specular.fromArray( pbrSpecularGlossiness.specularFactor );
  871. }
  872. if ( pbrSpecularGlossiness.specularGlossinessTexture !== undefined ) {
  873. var specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
  874. pending.push( parser.assignTexture( materialParams, 'glossinessMap', specGlossMapDef ) );
  875. pending.push( parser.assignTexture( materialParams, 'specularMap', specGlossMapDef ) );
  876. }
  877. return Promise.all( pending );
  878. },
  879. createMaterial: function ( materialParams ) {
  880. var material = new GLTFMeshStandardSGMaterial( materialParams );
  881. material.fog = true;
  882. material.color = materialParams.color;
  883. material.map = materialParams.map === undefined ? null : materialParams.map;
  884. material.lightMap = null;
  885. material.lightMapIntensity = 1.0;
  886. material.aoMap = materialParams.aoMap === undefined ? null : materialParams.aoMap;
  887. material.aoMapIntensity = 1.0;
  888. material.emissive = materialParams.emissive;
  889. material.emissiveIntensity = 1.0;
  890. material.emissiveMap = materialParams.emissiveMap === undefined ? null : materialParams.emissiveMap;
  891. material.bumpMap = materialParams.bumpMap === undefined ? null : materialParams.bumpMap;
  892. material.bumpScale = 1;
  893. material.normalMap = materialParams.normalMap === undefined ? null : materialParams.normalMap;
  894. material.normalMapType = TangentSpaceNormalMap;
  895. if ( materialParams.normalScale ) material.normalScale = materialParams.normalScale;
  896. material.displacementMap = null;
  897. material.displacementScale = 1;
  898. material.displacementBias = 0;
  899. material.specularMap = materialParams.specularMap === undefined ? null : materialParams.specularMap;
  900. material.specular = materialParams.specular;
  901. material.glossinessMap = materialParams.glossinessMap === undefined ? null : materialParams.glossinessMap;
  902. material.glossiness = materialParams.glossiness;
  903. material.alphaMap = null;
  904. material.envMap = materialParams.envMap === undefined ? null : materialParams.envMap;
  905. material.envMapIntensity = 1.0;
  906. material.refractionRatio = 0.98;
  907. return material;
  908. },
  909. };
  910. }
  911. /**
  912. * Mesh Quantization Extension
  913. *
  914. * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization
  915. */
  916. function GLTFMeshQuantizationExtension() {
  917. this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
  918. }
  919. /*********************************/
  920. /********** INTERPOLATION ********/
  921. /*********************************/
  922. // Spline Interpolation
  923. // Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
  924. function GLTFCubicSplineInterpolant( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
  925. Interpolant.call( this, parameterPositions, sampleValues, sampleSize, resultBuffer );
  926. }
  927. GLTFCubicSplineInterpolant.prototype = Object.create( Interpolant.prototype );
  928. GLTFCubicSplineInterpolant.prototype.constructor = GLTFCubicSplineInterpolant;
  929. GLTFCubicSplineInterpolant.prototype.copySampleValue_ = function ( index ) {
  930. // Copies a sample value to the result buffer. See description of glTF
  931. // CUBICSPLINE values layout in interpolate_() function below.
  932. var result = this.resultBuffer,
  933. values = this.sampleValues,
  934. valueSize = this.valueSize,
  935. offset = index * valueSize * 3 + valueSize;
  936. for ( var i = 0; i !== valueSize; i ++ ) {
  937. result[ i ] = values[ offset + i ];
  938. }
  939. return result;
  940. };
  941. GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
  942. GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
  943. GLTFCubicSplineInterpolant.prototype.interpolate_ = function ( i1, t0, t, t1 ) {
  944. var result = this.resultBuffer;
  945. var values = this.sampleValues;
  946. var stride = this.valueSize;
  947. var stride2 = stride * 2;
  948. var stride3 = stride * 3;
  949. var td = t1 - t0;
  950. var p = ( t - t0 ) / td;
  951. var pp = p * p;
  952. var ppp = pp * p;
  953. var offset1 = i1 * stride3;
  954. var offset0 = offset1 - stride3;
  955. var s2 = - 2 * ppp + 3 * pp;
  956. var s3 = ppp - pp;
  957. var s0 = 1 - s2;
  958. var s1 = s3 - pp + p;
  959. // Layout of keyframe output values for CUBICSPLINE animations:
  960. // [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
  961. for ( var i = 0; i !== stride; i ++ ) {
  962. var p0 = values[ offset0 + i + stride ]; // splineVertex_k
  963. var m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
  964. var p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
  965. var m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)
  966. result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
  967. }
  968. return result;
  969. };
  970. /*********************************/
  971. /********** INTERNALS ************/
  972. /*********************************/
  973. /* CONSTANTS */
  974. var WEBGL_CONSTANTS = {
  975. FLOAT: 5126,
  976. //FLOAT_MAT2: 35674,
  977. FLOAT_MAT3: 35675,
  978. FLOAT_MAT4: 35676,
  979. FLOAT_VEC2: 35664,
  980. FLOAT_VEC3: 35665,
  981. FLOAT_VEC4: 35666,
  982. LINEAR: 9729,
  983. REPEAT: 10497,
  984. SAMPLER_2D: 35678,
  985. POINTS: 0,
  986. LINES: 1,
  987. LINE_LOOP: 2,
  988. LINE_STRIP: 3,
  989. TRIANGLES: 4,
  990. TRIANGLE_STRIP: 5,
  991. TRIANGLE_FAN: 6,
  992. UNSIGNED_BYTE: 5121,
  993. UNSIGNED_SHORT: 5123
  994. };
  995. var WEBGL_COMPONENT_TYPES = {
  996. 5120: Int8Array,
  997. 5121: Uint8Array,
  998. 5122: Int16Array,
  999. 5123: Uint16Array,
  1000. 5125: Uint32Array,
  1001. 5126: Float32Array
  1002. };
  1003. var WEBGL_FILTERS = {
  1004. 9728: NearestFilter,
  1005. 9729: LinearFilter,
  1006. 9984: NearestMipmapNearestFilter,
  1007. 9985: LinearMipmapNearestFilter,
  1008. 9986: NearestMipmapLinearFilter,
  1009. 9987: LinearMipmapLinearFilter
  1010. };
  1011. var WEBGL_WRAPPINGS = {
  1012. 33071: ClampToEdgeWrapping,
  1013. 33648: MirroredRepeatWrapping,
  1014. 10497: RepeatWrapping
  1015. };
  1016. var WEBGL_TYPE_SIZES = {
  1017. 'SCALAR': 1,
  1018. 'VEC2': 2,
  1019. 'VEC3': 3,
  1020. 'VEC4': 4,
  1021. 'MAT2': 4,
  1022. 'MAT3': 9,
  1023. 'MAT4': 16
  1024. };
  1025. var ATTRIBUTES = {
  1026. POSITION: 'position',
  1027. NORMAL: 'normal',
  1028. TANGENT: 'tangent',
  1029. TEXCOORD_0: 'uv',
  1030. TEXCOORD_1: 'uv2',
  1031. COLOR_0: 'color',
  1032. WEIGHTS_0: 'skinWeight',
  1033. JOINTS_0: 'skinIndex',
  1034. };
  1035. var PATH_PROPERTIES = {
  1036. scale: 'scale',
  1037. translation: 'position',
  1038. rotation: 'quaternion',
  1039. weights: 'morphTargetInfluences'
  1040. };
  1041. var INTERPOLATION = {
  1042. CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
  1043. // keyframe track will be initialized with a default interpolation type, then modified.
  1044. LINEAR: InterpolateLinear,
  1045. STEP: InterpolateDiscrete
  1046. };
  1047. var ALPHA_MODES = {
  1048. OPAQUE: 'OPAQUE',
  1049. MASK: 'MASK',
  1050. BLEND: 'BLEND'
  1051. };
  1052. /* UTILITY FUNCTIONS */
  1053. function resolveURL( url, path ) {
  1054. // Invalid URL
  1055. if ( typeof url !== 'string' || url === '' ) return '';
  1056. // Host Relative URL
  1057. if ( /^https?:\/\//i.test( path ) && /^\//.test( url ) ) {
  1058. path = path.replace( /(^https?:\/\/[^\/]+).*/i, '$1' );
  1059. }
  1060. // Absolute URL http://,https://,//
  1061. if ( /^(https?:)?\/\//i.test( url ) ) return url;
  1062. // Data URI
  1063. if ( /^data:.*,.*$/i.test( url ) ) return url;
  1064. // Blob URL
  1065. if ( /^blob:.*$/i.test( url ) ) return url;
  1066. // Relative URL
  1067. return path + url;
  1068. }
  1069. /**
  1070. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
  1071. */
  1072. function createDefaultMaterial( cache ) {
  1073. if ( cache[ 'DefaultMaterial' ] === undefined ) {
  1074. cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {
  1075. color: 0xFFFFFF,
  1076. emissive: 0x000000,
  1077. metalness: 1,
  1078. roughness: 1,
  1079. transparent: false,
  1080. depthTest: true,
  1081. side: FrontSide
  1082. } );
  1083. }
  1084. return cache[ 'DefaultMaterial' ];
  1085. }
  1086. function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
  1087. // Add unknown glTF extensions to an object's userData.
  1088. for ( var name in objectDef.extensions ) {
  1089. if ( knownExtensions[ name ] === undefined ) {
  1090. object.userData.gltfExtensions = object.userData.gltfExtensions || {};
  1091. object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
  1092. }
  1093. }
  1094. }
  1095. /**
  1096. * @param {Object3D|Material|BufferGeometry} object
  1097. * @param {GLTF.definition} gltfDef
  1098. */
  1099. function assignExtrasToUserData( object, gltfDef ) {
  1100. if ( gltfDef.extras !== undefined ) {
  1101. if ( typeof gltfDef.extras === 'object' ) {
  1102. Object.assign( object.userData, gltfDef.extras );
  1103. } else {
  1104. console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
  1105. }
  1106. }
  1107. }
  1108. /**
  1109. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
  1110. *
  1111. * @param {BufferGeometry} geometry
  1112. * @param {Array<GLTF.Target>} targets
  1113. * @param {GLTFParser} parser
  1114. * @return {Promise<BufferGeometry>}
  1115. */
  1116. function addMorphTargets( geometry, targets, parser ) {
  1117. var hasMorphPosition = false;
  1118. var hasMorphNormal = false;
  1119. for ( var i = 0, il = targets.length; i < il; i ++ ) {
  1120. var target = targets[ i ];
  1121. if ( target.POSITION !== undefined ) hasMorphPosition = true;
  1122. if ( target.NORMAL !== undefined ) hasMorphNormal = true;
  1123. if ( hasMorphPosition && hasMorphNormal ) break;
  1124. }
  1125. if ( ! hasMorphPosition && ! hasMorphNormal ) return Promise.resolve( geometry );
  1126. var pendingPositionAccessors = [];
  1127. var pendingNormalAccessors = [];
  1128. for ( var i = 0, il = targets.length; i < il; i ++ ) {
  1129. var target = targets[ i ];
  1130. if ( hasMorphPosition ) {
  1131. var pendingAccessor = target.POSITION !== undefined
  1132. ? parser.getDependency( 'accessor', target.POSITION )
  1133. : geometry.attributes.position;
  1134. pendingPositionAccessors.push( pendingAccessor );
  1135. }
  1136. if ( hasMorphNormal ) {
  1137. var pendingAccessor = target.NORMAL !== undefined
  1138. ? parser.getDependency( 'accessor', target.NORMAL )
  1139. : geometry.attributes.normal;
  1140. pendingNormalAccessors.push( pendingAccessor );
  1141. }
  1142. }
  1143. return Promise.all( [
  1144. Promise.all( pendingPositionAccessors ),
  1145. Promise.all( pendingNormalAccessors )
  1146. ] ).then( function ( accessors ) {
  1147. var morphPositions = accessors[ 0 ];
  1148. var morphNormals = accessors[ 1 ];
  1149. if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
  1150. if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
  1151. geometry.morphTargetsRelative = true;
  1152. return geometry;
  1153. } );
  1154. }
  1155. /**
  1156. * @param {Mesh} mesh
  1157. * @param {GLTF.Mesh} meshDef
  1158. */
  1159. function updateMorphTargets( mesh, meshDef ) {
  1160. mesh.updateMorphTargets();
  1161. if ( meshDef.weights !== undefined ) {
  1162. for ( var i = 0, il = meshDef.weights.length; i < il; i ++ ) {
  1163. mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
  1164. }
  1165. }
  1166. // .extras has user-defined data, so check that .extras.targetNames is an array.
  1167. if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
  1168. var targetNames = meshDef.extras.targetNames;
  1169. if ( mesh.morphTargetInfluences.length === targetNames.length ) {
  1170. mesh.morphTargetDictionary = {};
  1171. for ( var i = 0, il = targetNames.length; i < il; i ++ ) {
  1172. mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
  1173. }
  1174. } else {
  1175. console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
  1176. }
  1177. }
  1178. }
  1179. function createPrimitiveKey( primitiveDef ) {
  1180. var dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
  1181. var geometryKey;
  1182. if ( dracoExtension ) {
  1183. geometryKey = 'draco:' + dracoExtension.bufferView
  1184. + ':' + dracoExtension.indices
  1185. + ':' + createAttributesKey( dracoExtension.attributes );
  1186. } else {
  1187. geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
  1188. }
  1189. return geometryKey;
  1190. }
  1191. function createAttributesKey( attributes ) {
  1192. var attributesKey = '';
  1193. var keys = Object.keys( attributes ).sort();
  1194. for ( var i = 0, il = keys.length; i < il; i ++ ) {
  1195. attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
  1196. }
  1197. return attributesKey;
  1198. }
  1199. /* GLTF PARSER */
  1200. function GLTFParser( json, options ) {
  1201. this.json = json || {};
  1202. this.extensions = {};
  1203. this.plugins = {};
  1204. this.options = options || {};
  1205. // loader object cache
  1206. this.cache = new GLTFRegistry();
  1207. // associations between Three.js objects and glTF elements
  1208. this.associations = new Map();
  1209. // BufferGeometry caching
  1210. this.primitiveCache = {};
  1211. // Object3D instance caches
  1212. this.meshCache = { refs: {}, uses: {} };
  1213. this.cameraCache = { refs: {}, uses: {} };
  1214. this.lightCache = { refs: {}, uses: {} };
  1215. // Track node names, to ensure no duplicates
  1216. this.nodeNamesUsed = {};
  1217. // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
  1218. // expensive work of uploading a texture to the GPU off the main thread.
  1219. if ( typeof createImageBitmap !== 'undefined' && /Firefox/.test( navigator.userAgent ) === false ) {
  1220. this.textureLoader = new ImageBitmapLoader( this.options.manager );
  1221. } else {
  1222. this.textureLoader = new TextureLoader( this.options.manager );
  1223. }
  1224. this.textureLoader.setCrossOrigin( this.options.crossOrigin );
  1225. this.textureLoader.setRequestHeader( this.options.requestHeader );
  1226. this.fileLoader = new FileLoader( this.options.manager );
  1227. this.fileLoader.setResponseType( 'arraybuffer' );
  1228. if ( this.options.crossOrigin === 'use-credentials' ) {
  1229. this.fileLoader.setWithCredentials( true );
  1230. }
  1231. }
  1232. GLTFParser.prototype.setExtensions = function ( extensions ) {
  1233. this.extensions = extensions;
  1234. };
  1235. GLTFParser.prototype.setPlugins = function ( plugins ) {
  1236. this.plugins = plugins;
  1237. };
  1238. GLTFParser.prototype.parse = function ( onLoad, onError ) {
  1239. var parser = this;
  1240. var json = this.json;
  1241. var extensions = this.extensions;
  1242. // Clear the loader cache
  1243. this.cache.removeAll();
  1244. // Mark the special nodes/meshes in json for efficient parse
  1245. this._invokeAll( function ( ext ) {
  1246. return ext._markDefs && ext._markDefs();
  1247. } );
  1248. Promise.all( this._invokeAll( function ( ext ) {
  1249. return ext.beforeRoot && ext.beforeRoot();
  1250. } ) ).then( function () {
  1251. return Promise.all( [
  1252. parser.getDependencies( 'scene' ),
  1253. parser.getDependencies( 'animation' ),
  1254. parser.getDependencies( 'camera' ),
  1255. ] );
  1256. } ).then( function ( dependencies ) {
  1257. var result = {
  1258. scene: dependencies[ 0 ][ json.scene || 0 ],
  1259. scenes: dependencies[ 0 ],
  1260. animations: dependencies[ 1 ],
  1261. cameras: dependencies[ 2 ],
  1262. asset: json.asset,
  1263. parser: parser,
  1264. userData: {}
  1265. };
  1266. addUnknownExtensionsToUserData( extensions, result, json );
  1267. assignExtrasToUserData( result, json );
  1268. Promise.all( parser._invokeAll( function ( ext ) {
  1269. return ext.afterRoot && ext.afterRoot( result );
  1270. } ) ).then( function () {
  1271. onLoad( result );
  1272. } );
  1273. } ).catch( onError );
  1274. };
  1275. /**
  1276. * Marks the special nodes/meshes in json for efficient parse.
  1277. */
  1278. GLTFParser.prototype._markDefs = function () {
  1279. var nodeDefs = this.json.nodes || [];
  1280. var skinDefs = this.json.skins || [];
  1281. var meshDefs = this.json.meshes || [];
  1282. // Nothing in the node definition indicates whether it is a Bone or an
  1283. // Object3D. Use the skins' joint references to mark bones.
  1284. for ( var skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
  1285. var joints = skinDefs[ skinIndex ].joints;
  1286. for ( var i = 0, il = joints.length; i < il; i ++ ) {
  1287. nodeDefs[ joints[ i ] ].isBone = true;
  1288. }
  1289. }
  1290. // Iterate over all nodes, marking references to shared resources,
  1291. // as well as skeleton joints.
  1292. for ( var nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
  1293. var nodeDef = nodeDefs[ nodeIndex ];
  1294. if ( nodeDef.mesh !== undefined ) {
  1295. this._addNodeRef( this.meshCache, nodeDef.mesh );
  1296. // Nothing in the mesh definition indicates whether it is
  1297. // a SkinnedMesh or Mesh. Use the node's mesh reference
  1298. // to mark SkinnedMesh if node has skin.
  1299. if ( nodeDef.skin !== undefined ) {
  1300. meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
  1301. }
  1302. }
  1303. if ( nodeDef.camera !== undefined ) {
  1304. this._addNodeRef( this.cameraCache, nodeDef.camera );
  1305. }
  1306. }
  1307. };
  1308. /**
  1309. * Counts references to shared node / Object3D resources. These resources
  1310. * can be reused, or "instantiated", at multiple nodes in the scene
  1311. * hierarchy. Mesh, Camera, and Light instances are instantiated and must
  1312. * be marked. Non-scenegraph resources (like Materials, Geometries, and
  1313. * Textures) can be reused directly and are not marked here.
  1314. *
  1315. * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
  1316. */
  1317. GLTFParser.prototype._addNodeRef = function ( cache, index ) {
  1318. if ( index === undefined ) return;
  1319. if ( cache.refs[ index ] === undefined ) {
  1320. cache.refs[ index ] = cache.uses[ index ] = 0;
  1321. }
  1322. cache.refs[ index ] ++;
  1323. };
  1324. /** Returns a reference to a shared resource, cloning it if necessary. */
  1325. GLTFParser.prototype._getNodeRef = function ( cache, index, object ) {
  1326. if ( cache.refs[ index ] <= 1 ) return object;
  1327. var ref = object.clone();
  1328. ref.name += '_instance_' + ( cache.uses[ index ] ++ );
  1329. return ref;
  1330. };
  1331. GLTFParser.prototype._invokeOne = function ( func ) {
  1332. var extensions = Object.values( this.plugins );
  1333. extensions.push( this );
  1334. for ( var i = 0; i < extensions.length; i ++ ) {
  1335. var result = func( extensions[ i ] );
  1336. if ( result ) return result;
  1337. }
  1338. };
  1339. GLTFParser.prototype._invokeAll = function ( func ) {
  1340. var extensions = Object.values( this.plugins );
  1341. extensions.unshift( this );
  1342. var pending = [];
  1343. for ( var i = 0; i < extensions.length; i ++ ) {
  1344. var result = func( extensions[ i ] );
  1345. if ( result ) pending.push( result );
  1346. }
  1347. return pending;
  1348. };
  1349. /**
  1350. * Requests the specified dependency asynchronously, with caching.
  1351. * @param {string} type
  1352. * @param {number} index
  1353. * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
  1354. */
  1355. GLTFParser.prototype.getDependency = function ( type, index ) {
  1356. var cacheKey = type + ':' + index;
  1357. var dependency = this.cache.get( cacheKey );
  1358. if ( ! dependency ) {
  1359. switch ( type ) {
  1360. case 'scene':
  1361. dependency = this.loadScene( index );
  1362. break;
  1363. case 'node':
  1364. dependency = this.loadNode( index );
  1365. break;
  1366. case 'mesh':
  1367. dependency = this._invokeOne( function ( ext ) {
  1368. return ext.loadMesh && ext.loadMesh( index );
  1369. } );
  1370. break;
  1371. case 'accessor':
  1372. dependency = this.loadAccessor( index );
  1373. break;
  1374. case 'bufferView':
  1375. dependency = this._invokeOne( function ( ext ) {
  1376. return ext.loadBufferView && ext.loadBufferView( index );
  1377. } );
  1378. break;
  1379. case 'buffer':
  1380. dependency = this.loadBuffer( index );
  1381. break;
  1382. case 'material':
  1383. dependency = this._invokeOne( function ( ext ) {
  1384. return ext.loadMaterial && ext.loadMaterial( index );
  1385. } );
  1386. break;
  1387. case 'texture':
  1388. dependency = this._invokeOne( function ( ext ) {
  1389. return ext.loadTexture && ext.loadTexture( index );
  1390. } );
  1391. break;
  1392. case 'skin':
  1393. dependency = this.loadSkin( index );
  1394. break;
  1395. case 'animation':
  1396. dependency = this.loadAnimation( index );
  1397. break;
  1398. case 'camera':
  1399. dependency = this.loadCamera( index );
  1400. break;
  1401. default:
  1402. throw new Error( 'Unknown type: ' + type );
  1403. }
  1404. this.cache.add( cacheKey, dependency );
  1405. }
  1406. return dependency;
  1407. };
  1408. /**
  1409. * Requests all dependencies of the specified type asynchronously, with caching.
  1410. * @param {string} type
  1411. * @return {Promise<Array<Object>>}
  1412. */
  1413. GLTFParser.prototype.getDependencies = function ( type ) {
  1414. var dependencies = this.cache.get( type );
  1415. if ( ! dependencies ) {
  1416. var parser = this;
  1417. var defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
  1418. dependencies = Promise.all( defs.map( function ( def, index ) {
  1419. return parser.getDependency( type, index );
  1420. } ) );
  1421. this.cache.add( type, dependencies );
  1422. }
  1423. return dependencies;
  1424. };
  1425. /**
  1426. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
  1427. * @param {number} bufferIndex
  1428. * @return {Promise<ArrayBuffer>}
  1429. */
  1430. GLTFParser.prototype.loadBuffer = function ( bufferIndex ) {
  1431. var bufferDef = this.json.buffers[ bufferIndex ];
  1432. var loader = this.fileLoader;
  1433. if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
  1434. throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
  1435. }
  1436. // If present, GLB container is required to be the first buffer.
  1437. if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
  1438. return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
  1439. }
  1440. var options = this.options;
  1441. return new Promise( function ( resolve, reject ) {
  1442. loader.load( resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
  1443. reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
  1444. } );
  1445. } );
  1446. };
  1447. /**
  1448. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
  1449. * @param {number} bufferViewIndex
  1450. * @return {Promise<ArrayBuffer>}
  1451. */
  1452. GLTFParser.prototype.loadBufferView = function ( bufferViewIndex ) {
  1453. var bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
  1454. return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
  1455. var byteLength = bufferViewDef.byteLength || 0;
  1456. var byteOffset = bufferViewDef.byteOffset || 0;
  1457. return buffer.slice( byteOffset, byteOffset + byteLength );
  1458. } );
  1459. };
  1460. /**
  1461. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
  1462. * @param {number} accessorIndex
  1463. * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
  1464. */
  1465. GLTFParser.prototype.loadAccessor = function ( accessorIndex ) {
  1466. var parser = this;
  1467. var json = this.json;
  1468. var accessorDef = this.json.accessors[ accessorIndex ];
  1469. if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
  1470. // Ignore empty accessors, which may be used to declare runtime
  1471. // information about attributes coming from another source (e.g. Draco
  1472. // compression extension).
  1473. return Promise.resolve( null );
  1474. }
  1475. var pendingBufferViews = [];
  1476. if ( accessorDef.bufferView !== undefined ) {
  1477. pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
  1478. } else {
  1479. pendingBufferViews.push( null );
  1480. }
  1481. if ( accessorDef.sparse !== undefined ) {
  1482. pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
  1483. pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
  1484. }
  1485. return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
  1486. var bufferView = bufferViews[ 0 ];
  1487. var itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
  1488. var TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
  1489. // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
  1490. var elementBytes = TypedArray.BYTES_PER_ELEMENT;
  1491. var itemBytes = elementBytes * itemSize;
  1492. var byteOffset = accessorDef.byteOffset || 0;
  1493. var byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
  1494. var normalized = accessorDef.normalized === true;
  1495. var array, bufferAttribute;
  1496. // The buffer is not interleaved if the stride is the item size in bytes.
  1497. if ( byteStride && byteStride !== itemBytes ) {
  1498. // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
  1499. // This makes sure that IBA.count reflects accessor.count properly
  1500. var ibSlice = Math.floor( byteOffset / byteStride );
  1501. var ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
  1502. var ib = parser.cache.get( ibCacheKey );
  1503. if ( ! ib ) {
  1504. array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );
  1505. // Integer parameters to IB/IBA are in array elements, not bytes.
  1506. ib = new InterleavedBuffer( array, byteStride / elementBytes );
  1507. parser.cache.add( ibCacheKey, ib );
  1508. }
  1509. bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );
  1510. } else {
  1511. if ( bufferView === null ) {
  1512. array = new TypedArray( accessorDef.count * itemSize );
  1513. } else {
  1514. array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );
  1515. }
  1516. bufferAttribute = new BufferAttribute( array, itemSize, normalized );
  1517. }
  1518. // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
  1519. if ( accessorDef.sparse !== undefined ) {
  1520. var itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
  1521. var TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];
  1522. var byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
  1523. var byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
  1524. var sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
  1525. var sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );
  1526. if ( bufferView !== null ) {
  1527. // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
  1528. bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );
  1529. }
  1530. for ( var i = 0, il = sparseIndices.length; i < il; i ++ ) {
  1531. var index = sparseIndices[ i ];
  1532. bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
  1533. if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
  1534. if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
  1535. if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
  1536. if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );
  1537. }
  1538. }
  1539. return bufferAttribute;
  1540. } );
  1541. };
  1542. /**
  1543. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
  1544. * @param {number} textureIndex
  1545. * @return {Promise<THREE.Texture>}
  1546. */
  1547. GLTFParser.prototype.loadTexture = function ( textureIndex ) {
  1548. var parser = this;
  1549. var json = this.json;
  1550. var options = this.options;
  1551. var textureDef = json.textures[ textureIndex ];
  1552. var textureExtensions = textureDef.extensions || {};
  1553. var source;
  1554. source = json.images[ textureDef.source ];
  1555. var loader;
  1556. if ( source.uri ) {
  1557. loader = options.manager.getHandler( source.uri );
  1558. }
  1559. if ( ! loader ) {
  1560. loader = this.textureLoader;
  1561. }
  1562. return this.loadTextureImage( textureIndex, source, loader );
  1563. };
  1564. GLTFParser.prototype.loadTextureImage = function ( textureIndex, source, loader ) {
  1565. var parser = this;
  1566. var json = this.json;
  1567. var options = this.options;
  1568. var textureDef = json.textures[ textureIndex ];
  1569. var URL = self.URL || self.webkitURL;
  1570. var sourceURI = source.uri;
  1571. var isObjectURL = false;
  1572. var hasAlpha = true;
  1573. if ( source.mimeType === 'image/jpeg' ) hasAlpha = false;
  1574. if ( source.bufferView !== undefined ) {
  1575. // Load binary image data from bufferView, if provided.
  1576. sourceURI = parser.getDependency( 'bufferView', source.bufferView ).then( function ( bufferView ) {
  1577. if ( source.mimeType === 'image/png' ) {
  1578. // Inspect the PNG 'IHDR' chunk to determine whether the image could have an
  1579. // alpha channel. This check is conservative — the image could have an alpha
  1580. // channel with all values == 1, and the indexed type (colorType == 3) only
  1581. // sometimes contains alpha.
  1582. //
  1583. // https://en.wikipedia.org/wiki/Portable_Network_Graphics#File_header
  1584. var colorType = new DataView( bufferView, 25, 1 ).getUint8( 0, false );
  1585. hasAlpha = colorType === 6 || colorType === 4 || colorType === 3;
  1586. }
  1587. isObjectURL = true;
  1588. var blob = new Blob( [ bufferView ], { type: source.mimeType } );
  1589. sourceURI = URL.createObjectURL( blob );
  1590. return sourceURI;
  1591. } );
  1592. } else if ( source.uri === undefined ) {
  1593. throw new Error( 'THREE.GLTFLoader: Image ' + textureIndex + ' is missing URI and bufferView' );
  1594. }
  1595. return Promise.resolve( sourceURI ).then( function ( sourceURI ) {
  1596. return new Promise( function ( resolve, reject ) {
  1597. var onLoad = resolve;
  1598. if ( loader.isImageBitmapLoader === true ) {
  1599. onLoad = function ( imageBitmap ) {
  1600. resolve( new CanvasTexture( imageBitmap ) );
  1601. };
  1602. }
  1603. loader.load( resolveURL( sourceURI, options.path ), onLoad, undefined, reject );
  1604. } );
  1605. } ).then( function ( texture ) {
  1606. // Clean up resources and configure Texture.
  1607. if ( isObjectURL === true ) {
  1608. URL.revokeObjectURL( sourceURI );
  1609. }
  1610. texture.flipY = false;
  1611. if ( textureDef.name ) texture.name = textureDef.name;
  1612. // When there is definitely no alpha channel in the texture, set RGBFormat to save space.
  1613. if ( ! hasAlpha ) texture.format = RGBFormat;
  1614. var samplers = json.samplers || {};
  1615. var sampler = samplers[ textureDef.sampler ] || {};
  1616. texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
  1617. texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
  1618. texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
  1619. texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
  1620. parser.associations.set( texture, {
  1621. type: 'textures',
  1622. index: textureIndex
  1623. } );
  1624. return texture;
  1625. } );
  1626. };
  1627. /**
  1628. * Asynchronously assigns a texture to the given material parameters.
  1629. * @param {Object} materialParams
  1630. * @param {string} mapName
  1631. * @param {Object} mapDef
  1632. * @return {Promise}
  1633. */
  1634. GLTFParser.prototype.assignTexture = function ( materialParams, mapName, mapDef ) {
  1635. var parser = this;
  1636. return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
  1637. // Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
  1638. // However, we will copy UV set 0 to UV set 1 on demand for aoMap
  1639. if ( mapDef.texCoord !== undefined && mapDef.texCoord != 0 && ! ( mapName === 'aoMap' && mapDef.texCoord == 1 ) ) {
  1640. console.warn( 'THREE.GLTFLoader: Custom UV set ' + mapDef.texCoord + ' for texture ' + mapName + ' not yet supported.' );
  1641. }
  1642. if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {
  1643. var transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;
  1644. if ( transform ) {
  1645. var gltfReference = parser.associations.get( texture );
  1646. texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
  1647. parser.associations.set( texture, gltfReference );
  1648. }
  1649. }
  1650. materialParams[ mapName ] = texture;
  1651. } );
  1652. };
  1653. /**
  1654. * Assigns final material to a Mesh, Line, or Points instance. The instance
  1655. * already has a material (generated from the glTF material options alone)
  1656. * but reuse of the same glTF material may require multiple threejs materials
  1657. * to accommodate different primitive types, defines, etc. New materials will
  1658. * be created if necessary, and reused from a cache.
  1659. * @param {Object3D} mesh Mesh, Line, or Points instance.
  1660. */
  1661. GLTFParser.prototype.assignFinalMaterial = function ( mesh ) {
  1662. var geometry = mesh.geometry;
  1663. var material = mesh.material;
  1664. var useVertexTangents = geometry.attributes.tangent !== undefined;
  1665. var useVertexColors = geometry.attributes.color !== undefined;
  1666. var useFlatShading = geometry.attributes.normal === undefined;
  1667. var useSkinning = mesh.isSkinnedMesh === true;
  1668. var useMorphTargets = Object.keys( geometry.morphAttributes ).length > 0;
  1669. var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined;
  1670. if ( mesh.isPoints ) {
  1671. var cacheKey = 'PointsMaterial:' + material.uuid;
  1672. var pointsMaterial = this.cache.get( cacheKey );
  1673. if ( ! pointsMaterial ) {
  1674. pointsMaterial = new PointsMaterial();
  1675. Material.prototype.copy.call( pointsMaterial, material );
  1676. pointsMaterial.color.copy( material.color );
  1677. pointsMaterial.map = material.map;
  1678. pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px
  1679. this.cache.add( cacheKey, pointsMaterial );
  1680. }
  1681. material = pointsMaterial;
  1682. } else if ( mesh.isLine ) {
  1683. var cacheKey = 'LineBasicMaterial:' + material.uuid;
  1684. var lineMaterial = this.cache.get( cacheKey );
  1685. if ( ! lineMaterial ) {
  1686. lineMaterial = new LineBasicMaterial();
  1687. Material.prototype.copy.call( lineMaterial, material );
  1688. lineMaterial.color.copy( material.color );
  1689. this.cache.add( cacheKey, lineMaterial );
  1690. }
  1691. material = lineMaterial;
  1692. }
  1693. // Clone the material if it will be modified
  1694. if ( useVertexTangents || useVertexColors || useFlatShading || useSkinning || useMorphTargets ) {
  1695. var cacheKey = 'ClonedMaterial:' + material.uuid + ':';
  1696. if ( material.isGLTFSpecularGlossinessMaterial ) cacheKey += 'specular-glossiness:';
  1697. if ( useSkinning ) cacheKey += 'skinning:';
  1698. if ( useVertexTangents ) cacheKey += 'vertex-tangents:';
  1699. if ( useVertexColors ) cacheKey += 'vertex-colors:';
  1700. if ( useFlatShading ) cacheKey += 'flat-shading:';
  1701. if ( useMorphTargets ) cacheKey += 'morph-targets:';
  1702. if ( useMorphNormals ) cacheKey += 'morph-normals:';
  1703. var cachedMaterial = this.cache.get( cacheKey );
  1704. if ( ! cachedMaterial ) {
  1705. cachedMaterial = material.clone();
  1706. if ( useSkinning ) cachedMaterial.skinning = true;
  1707. if ( useVertexColors ) cachedMaterial.vertexColors = true;
  1708. if ( useFlatShading ) cachedMaterial.flatShading = true;
  1709. if ( useMorphTargets ) cachedMaterial.morphTargets = true;
  1710. if ( useMorphNormals ) cachedMaterial.morphNormals = true;
  1711. if ( useVertexTangents ) {
  1712. cachedMaterial.vertexTangents = true;
  1713. // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
  1714. if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= -1;
  1715. if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= -1;
  1716. }
  1717. this.cache.add( cacheKey, cachedMaterial );
  1718. this.associations.set( cachedMaterial, this.associations.get( material ) );
  1719. }
  1720. material = cachedMaterial;
  1721. }
  1722. // workarounds for mesh and geometry
  1723. if ( material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined ) {
  1724. geometry.setAttribute( 'uv2', geometry.attributes.uv );
  1725. }
  1726. mesh.material = material;
  1727. };
  1728. GLTFParser.prototype.getMaterialType = function ( /* materialIndex */ ) {
  1729. return MeshStandardMaterial;
  1730. };
  1731. /**
  1732. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
  1733. * @param {number} materialIndex
  1734. * @return {Promise<Material>}
  1735. */
  1736. GLTFParser.prototype.loadMaterial = function ( materialIndex ) {
  1737. var parser = this;
  1738. var json = this.json;
  1739. var extensions = this.extensions;
  1740. var materialDef = json.materials[ materialIndex ];
  1741. var materialType;
  1742. var materialParams = {};
  1743. var materialExtensions = materialDef.extensions || {};
  1744. var pending = [];
  1745. if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ] ) {
  1746. var sgExtension = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ];
  1747. materialType = sgExtension.getMaterialType();
  1748. pending.push( sgExtension.extendParams( materialParams, materialDef, parser ) );
  1749. } else if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {
  1750. var kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
  1751. materialType = kmuExtension.getMaterialType();
  1752. pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );
  1753. } else {
  1754. // Specification:
  1755. // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material
  1756. var metallicRoughness = materialDef.pbrMetallicRoughness || {};
  1757. materialParams.color = new Color( 1.0, 1.0, 1.0 );
  1758. materialParams.opacity = 1.0;
  1759. if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
  1760. var array = metallicRoughness.baseColorFactor;
  1761. materialParams.color.fromArray( array );
  1762. materialParams.opacity = array[ 3 ];
  1763. }
  1764. if ( metallicRoughness.baseColorTexture !== undefined ) {
  1765. pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture ) );
  1766. }
  1767. materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
  1768. materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
  1769. if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {
  1770. pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
  1771. pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );
  1772. }
  1773. materialType = this._invokeOne( function ( ext ) {
  1774. return ext.getMaterialType && ext.getMaterialType( materialIndex );
  1775. } );
  1776. pending.push( Promise.all( this._invokeAll( function ( ext ) {
  1777. return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );
  1778. } ) ) );
  1779. }
  1780. if ( materialDef.doubleSided === true ) {
  1781. materialParams.side = DoubleSide;
  1782. }
  1783. var alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
  1784. if ( alphaMode === ALPHA_MODES.BLEND ) {
  1785. materialParams.transparent = true;
  1786. // See: https://github.com/mrdoob/three.js/issues/17706
  1787. materialParams.depthWrite = false;
  1788. } else {
  1789. materialParams.transparent = false;
  1790. if ( alphaMode === ALPHA_MODES.MASK ) {
  1791. materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
  1792. }
  1793. }
  1794. if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {
  1795. pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );
  1796. // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
  1797. materialParams.normalScale = new Vector2( 1, -1 );
  1798. if ( materialDef.normalTexture.scale !== undefined ) {
  1799. materialParams.normalScale.set( materialDef.normalTexture.scale, -materialDef.normalTexture.scale );
  1800. }
  1801. }
  1802. if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {
  1803. pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );
  1804. if ( materialDef.occlusionTexture.strength !== undefined ) {
  1805. materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
  1806. }
  1807. }
  1808. if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {
  1809. materialParams.emissive = new Color().fromArray( materialDef.emissiveFactor );
  1810. }
  1811. if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {
  1812. pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture ) );
  1813. }
  1814. return Promise.all( pending ).then( function () {
  1815. var material;
  1816. if ( materialType === GLTFMeshStandardSGMaterial ) {
  1817. material = extensions[ EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS ].createMaterial( materialParams );
  1818. } else {
  1819. material = new materialType( materialParams );
  1820. }
  1821. if ( materialDef.name ) material.name = materialDef.name;
  1822. // baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
  1823. if ( material.map ) material.map.encoding = sRGBEncoding;
  1824. if ( material.emissiveMap ) material.emissiveMap.encoding = sRGBEncoding;
  1825. assignExtrasToUserData( material, materialDef );
  1826. parser.associations.set( material, { type: 'materials', index: materialIndex } );
  1827. if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );
  1828. return material;
  1829. } );
  1830. };
  1831. /** When Object3D instances are targeted by animation, they need unique names. */
  1832. GLTFParser.prototype.createUniqueName = function ( originalName ) {
  1833. var sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );
  1834. var name = sanitizedName;
  1835. for ( var i = 1; this.nodeNamesUsed[ name ]; ++ i ) {
  1836. name = sanitizedName + '_' + i;
  1837. }
  1838. this.nodeNamesUsed[ name ] = true;
  1839. return name;
  1840. };
  1841. /**
  1842. * @param {BufferGeometry} geometry
  1843. * @param {GLTF.Primitive} primitiveDef
  1844. * @param {GLTFParser} parser
  1845. */
  1846. function computeBounds( geometry, primitiveDef, parser ) {
  1847. var attributes = primitiveDef.attributes;
  1848. var box = new Box3();
  1849. if ( attributes.POSITION !== undefined ) {
  1850. var accessor = parser.json.accessors[ attributes.POSITION ];
  1851. var min = accessor.min;
  1852. var max = accessor.max;
  1853. // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
  1854. if ( min !== undefined && max !== undefined ) {
  1855. box.set(
  1856. new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),
  1857. new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] ) );
  1858. } else {
  1859. console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
  1860. return;
  1861. }
  1862. } else {
  1863. return;
  1864. }
  1865. var targets = primitiveDef.targets;
  1866. if ( targets !== undefined ) {
  1867. var maxDisplacement = new Vector3();
  1868. var vector = new Vector3();
  1869. for ( var i = 0, il = targets.length; i < il; i ++ ) {
  1870. var target = targets[ i ];
  1871. if ( target.POSITION !== undefined ) {
  1872. var accessor = parser.json.accessors[ target.POSITION ];
  1873. var min = accessor.min;
  1874. var max = accessor.max;
  1875. // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.
  1876. if ( min !== undefined && max !== undefined ) {
  1877. // we need to get max of absolute components because target weight is [-1,1]
  1878. vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );
  1879. vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );
  1880. vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );
  1881. // Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
  1882. // to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
  1883. // are used to implement key-frame animations and as such only two are active at a time - this results in very large
  1884. // boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
  1885. maxDisplacement.max( vector );
  1886. } else {
  1887. console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
  1888. }
  1889. }
  1890. }
  1891. // As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
  1892. box.expandByVector( maxDisplacement );
  1893. }
  1894. geometry.boundingBox = box;
  1895. var sphere = new Sphere();
  1896. box.getCenter( sphere.center );
  1897. sphere.radius = box.min.distanceTo( box.max ) / 2;
  1898. geometry.boundingSphere = sphere;
  1899. }
  1900. /**
  1901. * @param {BufferGeometry} geometry
  1902. * @param {GLTF.Primitive} primitiveDef
  1903. * @param {GLTFParser} parser
  1904. * @return {Promise<BufferGeometry>}
  1905. */
  1906. function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
  1907. var attributes = primitiveDef.attributes;
  1908. var pending = [];
  1909. function assignAttributeAccessor( accessorIndex, attributeName ) {
  1910. return parser.getDependency( 'accessor', accessorIndex )
  1911. .then( function ( accessor ) {
  1912. geometry.setAttribute( attributeName, accessor );
  1913. } );
  1914. }
  1915. for ( var gltfAttributeName in attributes ) {
  1916. var threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
  1917. // Skip attributes already provided by e.g. Draco extension.
  1918. if ( threeAttributeName in geometry.attributes ) continue;
  1919. pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
  1920. }
  1921. if ( primitiveDef.indices !== undefined && ! geometry.index ) {
  1922. var accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
  1923. geometry.setIndex( accessor );
  1924. } );
  1925. pending.push( accessor );
  1926. }
  1927. assignExtrasToUserData( geometry, primitiveDef );
  1928. computeBounds( geometry, primitiveDef, parser );
  1929. return Promise.all( pending ).then( function () {
  1930. return primitiveDef.targets !== undefined
  1931. ? addMorphTargets( geometry, primitiveDef.targets, parser )
  1932. : geometry;
  1933. } );
  1934. }
  1935. /**
  1936. * @param {BufferGeometry} geometry
  1937. * @param {Number} drawMode
  1938. * @return {BufferGeometry}
  1939. */
  1940. function toTrianglesDrawMode( geometry, drawMode ) {
  1941. var index = geometry.getIndex();
  1942. // generate index if not present
  1943. if ( index === null ) {
  1944. var indices = [];
  1945. var position = geometry.getAttribute( 'position' );
  1946. if ( position !== undefined ) {
  1947. for ( var i = 0; i < position.count; i ++ ) {
  1948. indices.push( i );
  1949. }
  1950. geometry.setIndex( indices );
  1951. index = geometry.getIndex();
  1952. } else {
  1953. console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
  1954. return geometry;
  1955. }
  1956. }
  1957. //
  1958. var numberOfTriangles = index.count - 2;
  1959. var newIndices = [];
  1960. if ( drawMode === TriangleFanDrawMode ) {
  1961. // gl.TRIANGLE_FAN
  1962. for ( var i = 1; i <= numberOfTriangles; i ++ ) {
  1963. newIndices.push( index.getX( 0 ) );
  1964. newIndices.push( index.getX( i ) );
  1965. newIndices.push( index.getX( i + 1 ) );
  1966. }
  1967. } else {
  1968. // gl.TRIANGLE_STRIP
  1969. for ( var i = 0; i < numberOfTriangles; i ++ ) {
  1970. if ( i % 2 === 0 ) {
  1971. newIndices.push( index.getX( i ) );
  1972. newIndices.push( index.getX( i + 1 ) );
  1973. newIndices.push( index.getX( i + 2 ) );
  1974. } else {
  1975. newIndices.push( index.getX( i + 2 ) );
  1976. newIndices.push( index.getX( i + 1 ) );
  1977. newIndices.push( index.getX( i ) );
  1978. }
  1979. }
  1980. }
  1981. if ( ( newIndices.length / 3 ) !== numberOfTriangles ) {
  1982. console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
  1983. }
  1984. // build final geometry
  1985. var newGeometry = geometry.clone();
  1986. newGeometry.setIndex( newIndices );
  1987. return newGeometry;
  1988. }
  1989. /**
  1990. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
  1991. *
  1992. * Creates BufferGeometries from primitives.
  1993. *
  1994. * @param {Array<GLTF.Primitive>} primitives
  1995. * @return {Promise<Array<BufferGeometry>>}
  1996. */
  1997. GLTFParser.prototype.loadGeometries = function ( primitives ) {
  1998. var parser = this;
  1999. var extensions = this.extensions;
  2000. var cache = this.primitiveCache;
  2001. function createDracoPrimitive( primitive ) {
  2002. return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
  2003. .decodePrimitive( primitive, parser )
  2004. .then( function ( geometry ) {
  2005. return addPrimitiveAttributes( geometry, primitive, parser );
  2006. } );
  2007. }
  2008. var pending = [];
  2009. for ( var i = 0, il = primitives.length; i < il; i ++ ) {
  2010. var primitive = primitives[ i ];
  2011. var cacheKey = createPrimitiveKey( primitive );
  2012. // See if we've already created this geometry
  2013. var cached = cache[ cacheKey ];
  2014. if ( cached ) {
  2015. // Use the cached geometry if it exists
  2016. pending.push( cached.promise );
  2017. } else {
  2018. var geometryPromise;
  2019. if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {
  2020. // Use DRACO geometry if available
  2021. geometryPromise = createDracoPrimitive( primitive );
  2022. } else {
  2023. // Otherwise create a new geometry
  2024. geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );
  2025. }
  2026. // Cache this geometry
  2027. cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };
  2028. pending.push( geometryPromise );
  2029. }
  2030. }
  2031. return Promise.all( pending );
  2032. };
  2033. /**
  2034. * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
  2035. * @param {number} meshIndex
  2036. * @return {Promise<Group|Mesh|SkinnedMesh>}
  2037. */
  2038. GLTFParser.prototype.loadMesh = function ( meshIndex ) {
  2039. var parser = this;
  2040. var json = this.json;
  2041. var extensions = this.extensions;
  2042. var meshDef = json.meshes[ meshIndex ];
  2043. var primitives = meshDef.primitives;
  2044. var pending = [];
  2045. for ( var i = 0, il = primitives.length; i < il; i ++ ) {
  2046. var material = primitives[ i ].material === undefined
  2047. ? createDefaultMaterial( this.cache )
  2048. : this.getDependency( 'material', primitives[ i ].material );
  2049. pending.push( material );
  2050. }
  2051. pending.push( parser.loadGeometries( primitives ) );
  2052. return Promise.all( pending ).then( function ( results ) {
  2053. var materials = results.slice( 0, results.length - 1 );
  2054. var geometries = results[ results.length - 1 ];
  2055. var meshes = [];
  2056. for ( var i = 0, il = geometries.length; i < il; i ++ ) {
  2057. var geometry = geometries[ i ];
  2058. var primitive = primitives[ i ];
  2059. // 1. create Mesh
  2060. var mesh;
  2061. var material = materials[ i ];
  2062. if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
  2063. primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
  2064. primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
  2065. primitive.mode === undefined ) {
  2066. // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
  2067. mesh = meshDef.isSkinnedMesh === true
  2068. ? new SkinnedMesh( geometry, material )
  2069. : new Mesh( geometry, material );
  2070. if ( mesh.isSkinnedMesh === true && ! mesh.geometry.attributes.skinWeight.normalized ) {
  2071. // we normalize floating point skin weight array to fix malformed assets (see #15319)
  2072. // it's important to skip this for non-float32 data since normalizeSkinWeights assumes non-normalized inputs
  2073. mesh.normalizeSkinWeights();
  2074. }
  2075. if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {
  2076. mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );
  2077. } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {
  2078. mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );
  2079. }
  2080. } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {
  2081. mesh = new LineSegments( geometry, material );
  2082. } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {
  2083. mesh = new Line( geometry, material );
  2084. } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {
  2085. mesh = new LineLoop( geometry, material );
  2086. } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {
  2087. mesh = new Points( geometry, material );
  2088. } else {
  2089. throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );
  2090. }
  2091. if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {
  2092. updateMorphTargets( mesh, meshDef );
  2093. }
  2094. mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );
  2095. assignExtrasToUserData( mesh, meshDef );
  2096. if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );
  2097. parser.assignFinalMaterial( mesh );
  2098. meshes.push( mesh );
  2099. }
  2100. if ( meshes.length === 1 ) {
  2101. return meshes[ 0 ];
  2102. }
  2103. var group = new Group();
  2104. for ( var i = 0, il = meshes.length; i < il; i ++ ) {
  2105. group.add( meshes[ i ] );
  2106. }
  2107. return group;
  2108. } );
  2109. };
  2110. /**
  2111. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
  2112. * @param {number} cameraIndex
  2113. * @return {Promise<THREE.Camera>}
  2114. */
  2115. GLTFParser.prototype.loadCamera = function ( cameraIndex ) {
  2116. var camera;
  2117. var cameraDef = this.json.cameras[ cameraIndex ];
  2118. var params = cameraDef[ cameraDef.type ];
  2119. if ( ! params ) {
  2120. console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
  2121. return;
  2122. }
  2123. if ( cameraDef.type === 'perspective' ) {
  2124. camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );
  2125. } else if ( cameraDef.type === 'orthographic' ) {
  2126. camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );
  2127. }
  2128. if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );
  2129. assignExtrasToUserData( camera, cameraDef );
  2130. return Promise.resolve( camera );
  2131. };
  2132. /**
  2133. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
  2134. * @param {number} skinIndex
  2135. * @return {Promise<Object>}
  2136. */
  2137. GLTFParser.prototype.loadSkin = function ( skinIndex ) {
  2138. var skinDef = this.json.skins[ skinIndex ];
  2139. var skinEntry = { joints: skinDef.joints };
  2140. if ( skinDef.inverseBindMatrices === undefined ) {
  2141. return Promise.resolve( skinEntry );
  2142. }
  2143. return this.getDependency( 'accessor', skinDef.inverseBindMatrices ).then( function ( accessor ) {
  2144. skinEntry.inverseBindMatrices = accessor;
  2145. return skinEntry;
  2146. } );
  2147. };
  2148. /**
  2149. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
  2150. * @param {number} animationIndex
  2151. * @return {Promise<AnimationClip>}
  2152. */
  2153. GLTFParser.prototype.loadAnimation = function ( animationIndex ) {
  2154. var json = this.json;
  2155. var animationDef = json.animations[ animationIndex ];
  2156. var pendingNodes = [];
  2157. var pendingInputAccessors = [];
  2158. var pendingOutputAccessors = [];
  2159. var pendingSamplers = [];
  2160. var pendingTargets = [];
  2161. for ( var i = 0, il = animationDef.channels.length; i < il; i ++ ) {
  2162. var channel = animationDef.channels[ i ];
  2163. var sampler = animationDef.samplers[ channel.sampler ];
  2164. var target = channel.target;
  2165. var name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
  2166. var input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
  2167. var output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
  2168. pendingNodes.push( this.getDependency( 'node', name ) );
  2169. pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
  2170. pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
  2171. pendingSamplers.push( sampler );
  2172. pendingTargets.push( target );
  2173. }
  2174. return Promise.all( [
  2175. Promise.all( pendingNodes ),
  2176. Promise.all( pendingInputAccessors ),
  2177. Promise.all( pendingOutputAccessors ),
  2178. Promise.all( pendingSamplers ),
  2179. Promise.all( pendingTargets )
  2180. ] ).then( function ( dependencies ) {
  2181. var nodes = dependencies[ 0 ];
  2182. var inputAccessors = dependencies[ 1 ];
  2183. var outputAccessors = dependencies[ 2 ];
  2184. var samplers = dependencies[ 3 ];
  2185. var targets = dependencies[ 4 ];
  2186. var tracks = [];
  2187. for ( var i = 0, il = nodes.length; i < il; i ++ ) {
  2188. var node = nodes[ i ];
  2189. var inputAccessor = inputAccessors[ i ];
  2190. var outputAccessor = outputAccessors[ i ];
  2191. var sampler = samplers[ i ];
  2192. var target = targets[ i ];
  2193. if ( node === undefined ) continue;
  2194. node.updateMatrix();
  2195. node.matrixAutoUpdate = true;
  2196. var TypedKeyframeTrack;
  2197. switch ( PATH_PROPERTIES[ target.path ] ) {
  2198. case PATH_PROPERTIES.weights:
  2199. TypedKeyframeTrack = NumberKeyframeTrack;
  2200. break;
  2201. case PATH_PROPERTIES.rotation:
  2202. TypedKeyframeTrack = QuaternionKeyframeTrack;
  2203. break;
  2204. case PATH_PROPERTIES.position:
  2205. case PATH_PROPERTIES.scale:
  2206. default:
  2207. TypedKeyframeTrack = VectorKeyframeTrack;
  2208. break;
  2209. }
  2210. var targetName = node.name ? node.name : node.uuid;
  2211. var interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
  2212. var targetNames = [];
  2213. if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {
  2214. // Node may be a Group (glTF mesh with several primitives) or a Mesh.
  2215. node.traverse( function ( object ) {
  2216. if ( object.isMesh === true && object.morphTargetInfluences ) {
  2217. targetNames.push( object.name ? object.name : object.uuid );
  2218. }
  2219. } );
  2220. } else {
  2221. targetNames.push( targetName );
  2222. }
  2223. var outputArray = outputAccessor.array;
  2224. if ( outputAccessor.normalized ) {
  2225. var scale;
  2226. if ( outputArray.constructor === Int8Array ) {
  2227. scale = 1 / 127;
  2228. } else if ( outputArray.constructor === Uint8Array ) {
  2229. scale = 1 / 255;
  2230. } else if ( outputArray.constructor == Int16Array ) {
  2231. scale = 1 / 32767;
  2232. } else if ( outputArray.constructor === Uint16Array ) {
  2233. scale = 1 / 65535;
  2234. } else {
  2235. throw new Error( 'THREE.GLTFLoader: Unsupported output accessor component type.' );
  2236. }
  2237. var scaled = new Float32Array( outputArray.length );
  2238. for ( var j = 0, jl = outputArray.length; j < jl; j ++ ) {
  2239. scaled[ j ] = outputArray[ j ] * scale;
  2240. }
  2241. outputArray = scaled;
  2242. }
  2243. for ( var j = 0, jl = targetNames.length; j < jl; j ++ ) {
  2244. var track = new TypedKeyframeTrack(
  2245. targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
  2246. inputAccessor.array,
  2247. outputArray,
  2248. interpolation
  2249. );
  2250. // Override interpolation with custom factory method.
  2251. if ( sampler.interpolation === 'CUBICSPLINE' ) {
  2252. track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
  2253. // A CUBICSPLINE keyframe in glTF has three output values for each input value,
  2254. // representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
  2255. // must be divided by three to get the interpolant's sampleSize argument.
  2256. return new GLTFCubicSplineInterpolant( this.times, this.values, this.getValueSize() / 3, result );
  2257. };
  2258. // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
  2259. track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
  2260. }
  2261. tracks.push( track );
  2262. }
  2263. }
  2264. var name = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
  2265. return new AnimationClip( name, undefined, tracks );
  2266. } );
  2267. };
  2268. /**
  2269. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
  2270. * @param {number} nodeIndex
  2271. * @return {Promise<Object3D>}
  2272. */
  2273. GLTFParser.prototype.loadNode = function ( nodeIndex ) {
  2274. var json = this.json;
  2275. var extensions = this.extensions;
  2276. var parser = this;
  2277. var nodeDef = json.nodes[ nodeIndex ];
  2278. // reserve node's name before its dependencies, so the root has the intended name.
  2279. var nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : '';
  2280. return ( function () {
  2281. var pending = [];
  2282. if ( nodeDef.mesh !== undefined ) {
  2283. pending.push( parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {
  2284. var node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );
  2285. // if weights are provided on the node, override weights on the mesh.
  2286. if ( nodeDef.weights !== undefined ) {
  2287. node.traverse( function ( o ) {
  2288. if ( ! o.isMesh ) return;
  2289. for ( var i = 0, il = nodeDef.weights.length; i < il; i ++ ) {
  2290. o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];
  2291. }
  2292. } );
  2293. }
  2294. return node;
  2295. } ) );
  2296. }
  2297. if ( nodeDef.camera !== undefined ) {
  2298. pending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) {
  2299. return parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera );
  2300. } ) );
  2301. }
  2302. parser._invokeAll( function ( ext ) {
  2303. return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );
  2304. } ).forEach( function ( promise ) {
  2305. pending.push( promise );
  2306. } );
  2307. return Promise.all( pending );
  2308. }() ).then( function ( objects ) {
  2309. var node;
  2310. // .isBone isn't in glTF spec. See ._markDefs
  2311. if ( nodeDef.isBone === true ) {
  2312. node = new Bone();
  2313. } else if ( objects.length > 1 ) {
  2314. node = new Group();
  2315. } else if ( objects.length === 1 ) {
  2316. node = objects[ 0 ];
  2317. } else {
  2318. node = new Object3D();
  2319. }
  2320. if ( node !== objects[ 0 ] ) {
  2321. for ( var i = 0, il = objects.length; i < il; i ++ ) {
  2322. node.add( objects[ i ] );
  2323. }
  2324. }
  2325. if ( nodeDef.name ) {
  2326. node.userData.name = nodeDef.name;
  2327. node.name = nodeName;
  2328. }
  2329. assignExtrasToUserData( node, nodeDef );
  2330. if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );
  2331. if ( nodeDef.matrix !== undefined ) {
  2332. var matrix = new Matrix4();
  2333. matrix.fromArray( nodeDef.matrix );
  2334. node.applyMatrix4( matrix );
  2335. } else {
  2336. if ( nodeDef.translation !== undefined ) {
  2337. node.position.fromArray( nodeDef.translation );
  2338. }
  2339. if ( nodeDef.rotation !== undefined ) {
  2340. node.quaternion.fromArray( nodeDef.rotation );
  2341. }
  2342. if ( nodeDef.scale !== undefined ) {
  2343. node.scale.fromArray( nodeDef.scale );
  2344. }
  2345. }
  2346. parser.associations.set( node, { type: 'nodes', index: nodeIndex } );
  2347. return node;
  2348. } );
  2349. };
  2350. /**
  2351. * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
  2352. * @param {number} sceneIndex
  2353. * @return {Promise<Group>}
  2354. */
  2355. GLTFParser.prototype.loadScene = function () {
  2356. // scene node hierachy builder
  2357. function buildNodeHierachy( nodeId, parentObject, json, parser ) {
  2358. var nodeDef = json.nodes[ nodeId ];
  2359. return parser.getDependency( 'node', nodeId ).then( function ( node ) {
  2360. if ( nodeDef.skin === undefined ) return node;
  2361. // build skeleton here as well
  2362. var skinEntry;
  2363. return parser.getDependency( 'skin', nodeDef.skin ).then( function ( skin ) {
  2364. skinEntry = skin;
  2365. var pendingJoints = [];
  2366. for ( var i = 0, il = skinEntry.joints.length; i < il; i ++ ) {
  2367. pendingJoints.push( parser.getDependency( 'node', skinEntry.joints[ i ] ) );
  2368. }
  2369. return Promise.all( pendingJoints );
  2370. } ).then( function ( jointNodes ) {
  2371. node.traverse( function ( mesh ) {
  2372. if ( ! mesh.isMesh ) return;
  2373. var bones = [];
  2374. var boneInverses = [];
  2375. for ( var j = 0, jl = jointNodes.length; j < jl; j ++ ) {
  2376. var jointNode = jointNodes[ j ];
  2377. if ( jointNode ) {
  2378. bones.push( jointNode );
  2379. var mat = new Matrix4();
  2380. if ( skinEntry.inverseBindMatrices !== undefined ) {
  2381. mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );
  2382. }
  2383. boneInverses.push( mat );
  2384. } else {
  2385. console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[ j ] );
  2386. }
  2387. }
  2388. mesh.bind( new Skeleton( bones, boneInverses ), mesh.matrixWorld );
  2389. } );
  2390. return node;
  2391. } );
  2392. } ).then( function ( node ) {
  2393. // build node hierachy
  2394. parentObject.add( node );
  2395. var pending = [];
  2396. if ( nodeDef.children ) {
  2397. var children = nodeDef.children;
  2398. for ( var i = 0, il = children.length; i < il; i ++ ) {
  2399. var child = children[ i ];
  2400. pending.push( buildNodeHierachy( child, node, json, parser ) );
  2401. }
  2402. }
  2403. return Promise.all( pending );
  2404. } );
  2405. }
  2406. return function loadScene( sceneIndex ) {
  2407. var json = this.json;
  2408. var extensions = this.extensions;
  2409. var sceneDef = this.json.scenes[ sceneIndex ];
  2410. var parser = this;
  2411. // Loader returns Group, not Scene.
  2412. // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
  2413. var scene = new Group();
  2414. if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );
  2415. assignExtrasToUserData( scene, sceneDef );
  2416. if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );
  2417. var nodeIds = sceneDef.nodes || [];
  2418. var pending = [];
  2419. for ( var i = 0, il = nodeIds.length; i < il; i ++ ) {
  2420. pending.push( buildNodeHierachy( nodeIds[ i ], scene, json, parser ) );
  2421. }
  2422. return Promise.all( pending ).then( function () {
  2423. return scene;
  2424. } );
  2425. };
  2426. }();
  2427. return GLTFLoader;
  2428. } )();
  2429. export { GLTFLoader };