babylon.glTF1FileLoader.d.ts 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545
  1. declare module BABYLON {
  2. enum GLTFLoaderCoordinateSystemMode {
  3. AUTO = 0,
  4. PASS_THROUGH = 1,
  5. FORCE_RIGHT_HANDED = 2,
  6. }
  7. interface IGLTFLoaderData {
  8. json: Object;
  9. bin: ArrayBufferView;
  10. }
  11. interface IGLTFLoader {
  12. importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void) => void;
  13. loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void) => void;
  14. }
  15. class GLTFFileLoader implements ISceneLoaderPluginAsync {
  16. static CreateGLTFLoaderV1: (parent: GLTFFileLoader) => IGLTFLoader;
  17. static CreateGLTFLoaderV2: (parent: GLTFFileLoader) => IGLTFLoader;
  18. static HomogeneousCoordinates: boolean;
  19. static IncrementalLoading: boolean;
  20. coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
  21. onTextureLoaded: (texture: BaseTexture) => void;
  22. onMaterialLoaded: (material: Material) => void;
  23. /**
  24. * Let the user decides if he needs to process the material (like precompilation) before affecting it to meshes
  25. */
  26. onBeforeMaterialReadyAsync: (material: Material, targetMesh: AbstractMesh, isLOD: boolean, callback: () => void) => void;
  27. /**
  28. * Raised when all LODs are complete (or if there is no LOD and model is complete)
  29. */
  30. onComplete: () => void;
  31. /**
  32. * Raised when first LOD complete (or if there is no LOD and model is complete)
  33. */
  34. onFirstLODComplete: () => void;
  35. name: string;
  36. extensions: ISceneLoaderPluginExtensions;
  37. importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
  38. loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
  39. canDirectLoad(data: string): boolean;
  40. private static _parse(data, onError);
  41. private _getLoader(loaderData, onError);
  42. private static _parseBinary(data, onError);
  43. private static _parseV1(binaryReader, onError);
  44. private static _parseV2(binaryReader, onError);
  45. private static _parseVersion(version);
  46. private static _compareVersion(a, b);
  47. private static _decodeBufferToText(view);
  48. }
  49. }
  50. declare module BABYLON.GLTF1 {
  51. /**
  52. * Enums
  53. */
  54. enum EComponentType {
  55. BYTE = 5120,
  56. UNSIGNED_BYTE = 5121,
  57. SHORT = 5122,
  58. UNSIGNED_SHORT = 5123,
  59. FLOAT = 5126,
  60. }
  61. enum EShaderType {
  62. FRAGMENT = 35632,
  63. VERTEX = 35633,
  64. }
  65. enum EParameterType {
  66. BYTE = 5120,
  67. UNSIGNED_BYTE = 5121,
  68. SHORT = 5122,
  69. UNSIGNED_SHORT = 5123,
  70. INT = 5124,
  71. UNSIGNED_INT = 5125,
  72. FLOAT = 5126,
  73. FLOAT_VEC2 = 35664,
  74. FLOAT_VEC3 = 35665,
  75. FLOAT_VEC4 = 35666,
  76. INT_VEC2 = 35667,
  77. INT_VEC3 = 35668,
  78. INT_VEC4 = 35669,
  79. BOOL = 35670,
  80. BOOL_VEC2 = 35671,
  81. BOOL_VEC3 = 35672,
  82. BOOL_VEC4 = 35673,
  83. FLOAT_MAT2 = 35674,
  84. FLOAT_MAT3 = 35675,
  85. FLOAT_MAT4 = 35676,
  86. SAMPLER_2D = 35678,
  87. }
  88. enum ETextureWrapMode {
  89. CLAMP_TO_EDGE = 33071,
  90. MIRRORED_REPEAT = 33648,
  91. REPEAT = 10497,
  92. }
  93. enum ETextureFilterType {
  94. NEAREST = 9728,
  95. LINEAR = 9728,
  96. NEAREST_MIPMAP_NEAREST = 9984,
  97. LINEAR_MIPMAP_NEAREST = 9985,
  98. NEAREST_MIPMAP_LINEAR = 9986,
  99. LINEAR_MIPMAP_LINEAR = 9987,
  100. }
  101. enum ETextureFormat {
  102. ALPHA = 6406,
  103. RGB = 6407,
  104. RGBA = 6408,
  105. LUMINANCE = 6409,
  106. LUMINANCE_ALPHA = 6410,
  107. }
  108. enum ECullingType {
  109. FRONT = 1028,
  110. BACK = 1029,
  111. FRONT_AND_BACK = 1032,
  112. }
  113. enum EBlendingFunction {
  114. ZERO = 0,
  115. ONE = 1,
  116. SRC_COLOR = 768,
  117. ONE_MINUS_SRC_COLOR = 769,
  118. DST_COLOR = 774,
  119. ONE_MINUS_DST_COLOR = 775,
  120. SRC_ALPHA = 770,
  121. ONE_MINUS_SRC_ALPHA = 771,
  122. DST_ALPHA = 772,
  123. ONE_MINUS_DST_ALPHA = 773,
  124. CONSTANT_COLOR = 32769,
  125. ONE_MINUS_CONSTANT_COLOR = 32770,
  126. CONSTANT_ALPHA = 32771,
  127. ONE_MINUS_CONSTANT_ALPHA = 32772,
  128. SRC_ALPHA_SATURATE = 776,
  129. }
  130. /**
  131. * Interfaces
  132. */
  133. interface IGLTFProperty {
  134. extensions?: Object;
  135. extras?: Object;
  136. }
  137. interface IGLTFChildRootProperty extends IGLTFProperty {
  138. name?: string;
  139. }
  140. interface IGLTFAccessor extends IGLTFChildRootProperty {
  141. bufferView: string;
  142. byteOffset: number;
  143. byteStride: number;
  144. count: number;
  145. type: string;
  146. componentType: EComponentType;
  147. max?: number[];
  148. min?: number[];
  149. name?: string;
  150. }
  151. interface IGLTFBufferView extends IGLTFChildRootProperty {
  152. buffer: string;
  153. byteOffset: number;
  154. byteLength: number;
  155. target?: number;
  156. }
  157. interface IGLTFBuffer extends IGLTFChildRootProperty {
  158. uri: string;
  159. byteLength?: number;
  160. type?: string;
  161. }
  162. interface IGLTFShader extends IGLTFChildRootProperty {
  163. uri: string;
  164. type: EShaderType;
  165. }
  166. interface IGLTFProgram extends IGLTFChildRootProperty {
  167. attributes: string[];
  168. fragmentShader: string;
  169. vertexShader: string;
  170. }
  171. interface IGLTFTechniqueParameter {
  172. type: number;
  173. count?: number;
  174. semantic?: string;
  175. node?: string;
  176. value?: number | boolean | string | Array<any>;
  177. source?: string;
  178. babylonValue?: any;
  179. }
  180. interface IGLTFTechniqueCommonProfile {
  181. lightingModel: string;
  182. texcoordBindings: Object;
  183. parameters?: Array<any>;
  184. }
  185. interface IGLTFTechniqueStatesFunctions {
  186. blendColor?: number[];
  187. blendEquationSeparate?: number[];
  188. blendFuncSeparate?: number[];
  189. colorMask: boolean[];
  190. cullFace: number[];
  191. }
  192. interface IGLTFTechniqueStates {
  193. enable: number[];
  194. functions: IGLTFTechniqueStatesFunctions;
  195. }
  196. interface IGLTFTechnique extends IGLTFChildRootProperty {
  197. parameters: Object;
  198. program: string;
  199. attributes: Object;
  200. uniforms: Object;
  201. states: IGLTFTechniqueStates;
  202. }
  203. interface IGLTFMaterial extends IGLTFChildRootProperty {
  204. technique?: string;
  205. values: string[];
  206. }
  207. interface IGLTFMeshPrimitive extends IGLTFProperty {
  208. attributes: Object;
  209. indices: string;
  210. material: string;
  211. mode?: number;
  212. }
  213. interface IGLTFMesh extends IGLTFChildRootProperty {
  214. primitives: IGLTFMeshPrimitive[];
  215. }
  216. interface IGLTFImage extends IGLTFChildRootProperty {
  217. uri: string;
  218. }
  219. interface IGLTFSampler extends IGLTFChildRootProperty {
  220. magFilter?: number;
  221. minFilter?: number;
  222. wrapS?: number;
  223. wrapT?: number;
  224. }
  225. interface IGLTFTexture extends IGLTFChildRootProperty {
  226. sampler: string;
  227. source: string;
  228. format?: ETextureFormat;
  229. internalFormat?: ETextureFormat;
  230. target?: number;
  231. type?: number;
  232. babylonTexture?: Texture;
  233. }
  234. interface IGLTFAmbienLight {
  235. color?: number[];
  236. }
  237. interface IGLTFDirectionalLight {
  238. color?: number[];
  239. }
  240. interface IGLTFPointLight {
  241. color?: number[];
  242. constantAttenuation?: number;
  243. linearAttenuation?: number;
  244. quadraticAttenuation?: number;
  245. }
  246. interface IGLTFSpotLight {
  247. color?: number[];
  248. constantAttenuation?: number;
  249. fallOfAngle?: number;
  250. fallOffExponent?: number;
  251. linearAttenuation?: number;
  252. quadraticAttenuation?: number;
  253. }
  254. interface IGLTFLight extends IGLTFChildRootProperty {
  255. type: string;
  256. }
  257. interface IGLTFCameraOrthographic {
  258. xmag: number;
  259. ymag: number;
  260. zfar: number;
  261. znear: number;
  262. }
  263. interface IGLTFCameraPerspective {
  264. aspectRatio: number;
  265. yfov: number;
  266. zfar: number;
  267. znear: number;
  268. }
  269. interface IGLTFCamera extends IGLTFChildRootProperty {
  270. type: string;
  271. }
  272. interface IGLTFAnimationChannelTarget {
  273. id: string;
  274. path: string;
  275. }
  276. interface IGLTFAnimationChannel {
  277. sampler: string;
  278. target: IGLTFAnimationChannelTarget;
  279. }
  280. interface IGLTFAnimationSampler {
  281. input: string;
  282. output: string;
  283. interpolation?: string;
  284. }
  285. interface IGLTFAnimation extends IGLTFChildRootProperty {
  286. channels?: IGLTFAnimationChannel[];
  287. parameters?: Object;
  288. samplers?: Object;
  289. }
  290. interface IGLTFNodeInstanceSkin {
  291. skeletons: string[];
  292. skin: string;
  293. meshes: string[];
  294. }
  295. interface IGLTFSkins extends IGLTFChildRootProperty {
  296. bindShapeMatrix: number[];
  297. inverseBindMatrices: string;
  298. jointNames: string[];
  299. babylonSkeleton?: Skeleton;
  300. }
  301. interface IGLTFNode extends IGLTFChildRootProperty {
  302. camera?: string;
  303. children: string[];
  304. skin?: string;
  305. jointName?: string;
  306. light?: string;
  307. matrix: number[];
  308. mesh?: string;
  309. meshes?: string[];
  310. rotation?: number[];
  311. scale?: number[];
  312. translation?: number[];
  313. babylonNode?: Node;
  314. }
  315. interface IGLTFScene extends IGLTFChildRootProperty {
  316. nodes: string[];
  317. }
  318. /**
  319. * Runtime
  320. */
  321. interface IGLTFRuntime {
  322. extensions: Object;
  323. accessors: Object;
  324. buffers: Object;
  325. bufferViews: Object;
  326. meshes: Object;
  327. lights: Object;
  328. cameras: Object;
  329. nodes: Object;
  330. images: Object;
  331. textures: Object;
  332. shaders: Object;
  333. programs: Object;
  334. samplers: Object;
  335. techniques: Object;
  336. materials: Object;
  337. animations: Object;
  338. skins: Object;
  339. currentScene?: Object;
  340. scenes: Object;
  341. extensionsUsed: string[];
  342. extensionsRequired?: string[];
  343. buffersCount: number;
  344. shaderscount: number;
  345. scene: Scene;
  346. rootUrl: string;
  347. loadedBufferCount: number;
  348. loadedBufferViews: {
  349. [name: string]: ArrayBufferView;
  350. };
  351. loadedShaderCount: number;
  352. importOnlyMeshes: boolean;
  353. importMeshesNames?: string[];
  354. dummyNodes: Node[];
  355. }
  356. /**
  357. * Bones
  358. */
  359. interface INodeToRoot {
  360. bone: Bone;
  361. node: IGLTFNode;
  362. id: string;
  363. }
  364. interface IJointNode {
  365. node: IGLTFNode;
  366. id: string;
  367. }
  368. }
  369. declare module BABYLON.GLTF1 {
  370. /**
  371. * Implementation of the base glTF spec
  372. */
  373. class GLTFLoaderBase {
  374. static CreateRuntime(parsedData: any, scene: Scene, rootUrl: string): IGLTFRuntime;
  375. static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
  376. static LoadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): void;
  377. static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
  378. static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): void;
  379. static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
  380. }
  381. /**
  382. * glTF V1 Loader
  383. */
  384. class GLTFLoader implements IGLTFLoader {
  385. static Extensions: {
  386. [name: string]: GLTFLoaderExtension;
  387. };
  388. static RegisterExtension(extension: GLTFLoaderExtension): void;
  389. importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]) => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): boolean;
  390. loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: () => void, onProgress: (event: ProgressEvent) => void, onError: (message: string) => void): void;
  391. private _loadShadersAsync(gltfRuntime, onload);
  392. private _loadBuffersAsync(gltfRuntime, onLoad, onProgress?);
  393. private _createNodes(gltfRuntime);
  394. }
  395. }
  396. declare module BABYLON.GLTF1 {
  397. /**
  398. * Utils functions for GLTF
  399. */
  400. class GLTFUtils {
  401. /**
  402. * Sets the given "parameter" matrix
  403. * @param scene: the {BABYLON.Scene} object
  404. * @param source: the source node where to pick the matrix
  405. * @param parameter: the GLTF technique parameter
  406. * @param uniformName: the name of the shader's uniform
  407. * @param shaderMaterial: the shader material
  408. */
  409. static SetMatrix(scene: Scene, source: Node, parameter: IGLTFTechniqueParameter, uniformName: string, shaderMaterial: ShaderMaterial | Effect): void;
  410. /**
  411. * Sets the given "parameter" matrix
  412. * @param shaderMaterial: the shader material
  413. * @param uniform: the name of the shader's uniform
  414. * @param value: the value of the uniform
  415. * @param type: the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
  416. */
  417. static SetUniform(shaderMaterial: ShaderMaterial | Effect, uniform: string, value: any, type: number): boolean;
  418. /**
  419. * If the uri is a base64 string
  420. * @param uri: the uri to test
  421. */
  422. static IsBase64(uri: string): boolean;
  423. /**
  424. * Decode the base64 uri
  425. * @param uri: the uri to decode
  426. */
  427. static DecodeBase64(uri: string): ArrayBuffer;
  428. /**
  429. * Returns the wrap mode of the texture
  430. * @param mode: the mode value
  431. */
  432. static GetWrapMode(mode: number): number;
  433. /**
  434. * Returns the byte stride giving an accessor
  435. * @param accessor: the GLTF accessor objet
  436. */
  437. static GetByteStrideFromType(accessor: IGLTFAccessor): number;
  438. /**
  439. * Returns the texture filter mode giving a mode value
  440. * @param mode: the filter mode value
  441. */
  442. static GetTextureFilterMode(mode: number): ETextureFilterType;
  443. static GetBufferFromBufferView(gltfRuntime: IGLTFRuntime, bufferView: IGLTFBufferView, byteOffset: number, byteLength: number, componentType: EComponentType): ArrayBufferView;
  444. /**
  445. * Returns a buffer from its accessor
  446. * @param gltfRuntime: the GLTF runtime
  447. * @param accessor: the GLTF accessor
  448. */
  449. static GetBufferFromAccessor(gltfRuntime: IGLTFRuntime, accessor: IGLTFAccessor): any;
  450. /**
  451. * Decodes a buffer view into a string
  452. * @param view: the buffer view
  453. */
  454. static DecodeBufferToText(view: ArrayBufferView): string;
  455. /**
  456. * Returns the default material of gltf. Related to
  457. * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
  458. * @param scene: the Babylon.js scene
  459. */
  460. static GetDefaultMaterial(scene: Scene): ShaderMaterial;
  461. private static _DefaultMaterial;
  462. }
  463. }
  464. declare module BABYLON.GLTF1 {
  465. abstract class GLTFLoaderExtension {
  466. private _name;
  467. constructor(name: string);
  468. readonly name: string;
  469. /**
  470. * Defines an override for loading the runtime
  471. * Return true to stop further extensions from loading the runtime
  472. */
  473. loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void, onError: (message: string) => void): boolean;
  474. /**
  475. * Defines an onverride for creating gltf runtime
  476. * Return true to stop further extensions from creating the runtime
  477. */
  478. loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: (message: string) => void): boolean;
  479. /**
  480. * Defines an override for loading buffers
  481. * Return true to stop further extensions from loading this buffer
  482. */
  483. loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): boolean;
  484. /**
  485. * Defines an override for loading texture buffers
  486. * Return true to stop further extensions from loading this texture data
  487. */
  488. loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
  489. /**
  490. * Defines an override for creating textures
  491. * Return true to stop further extensions from loading this texture
  492. */
  493. createTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): boolean;
  494. /**
  495. * Defines an override for loading shader strings
  496. * Return true to stop further extensions from loading this shader data
  497. */
  498. loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
  499. /**
  500. * Defines an override for loading materials
  501. * Return true to stop further extensions from loading this material
  502. */
  503. loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
  504. static LoadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void, onError: (message: string) => void): void;
  505. static LoadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: (message: string) => void): void;
  506. static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (bufferView: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
  507. static LoadTextureAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
  508. static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderData: string) => void, onError: (message: string) => void): void;
  509. static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
  510. private static LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
  511. private static CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
  512. private static ApplyExtensions(func, defaultFunc);
  513. }
  514. }
  515. declare module BABYLON.GLTF1 {
  516. class GLTFBinaryExtension extends GLTFLoaderExtension {
  517. private _bin;
  518. constructor();
  519. loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void, onError: (message: string) => void): boolean;
  520. loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
  521. loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
  522. loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
  523. }
  524. }
  525. declare module BABYLON.GLTF1 {
  526. class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
  527. constructor();
  528. loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: (message: string) => void): boolean;
  529. loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
  530. private _loadTexture(gltfRuntime, id, material, propertyPath, onError);
  531. }
  532. }