babylon.glTFFileLoader.js 68 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506
  1. var BABYLON;
  2. (function (BABYLON) {
  3. /**
  4. * Enums
  5. */
  6. (function (EComponentType) {
  7. EComponentType[EComponentType["BYTE"] = 5120] = "BYTE";
  8. EComponentType[EComponentType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
  9. EComponentType[EComponentType["SHORT"] = 5122] = "SHORT";
  10. EComponentType[EComponentType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
  11. EComponentType[EComponentType["FLOAT"] = 5126] = "FLOAT";
  12. })(BABYLON.EComponentType || (BABYLON.EComponentType = {}));
  13. var EComponentType = BABYLON.EComponentType;
  14. (function (EShaderType) {
  15. EShaderType[EShaderType["FRAGMENT"] = 35632] = "FRAGMENT";
  16. EShaderType[EShaderType["VERTEX"] = 35633] = "VERTEX";
  17. })(BABYLON.EShaderType || (BABYLON.EShaderType = {}));
  18. var EShaderType = BABYLON.EShaderType;
  19. (function (EParameterType) {
  20. EParameterType[EParameterType["BYTE"] = 5120] = "BYTE";
  21. EParameterType[EParameterType["UNSIGNED_BYTE"] = 5121] = "UNSIGNED_BYTE";
  22. EParameterType[EParameterType["SHORT"] = 5122] = "SHORT";
  23. EParameterType[EParameterType["UNSIGNED_SHORT"] = 5123] = "UNSIGNED_SHORT";
  24. EParameterType[EParameterType["INT"] = 5124] = "INT";
  25. EParameterType[EParameterType["UNSIGNED_INT"] = 5125] = "UNSIGNED_INT";
  26. EParameterType[EParameterType["FLOAT"] = 5126] = "FLOAT";
  27. EParameterType[EParameterType["FLOAT_VEC2"] = 35664] = "FLOAT_VEC2";
  28. EParameterType[EParameterType["FLOAT_VEC3"] = 35665] = "FLOAT_VEC3";
  29. EParameterType[EParameterType["FLOAT_VEC4"] = 35666] = "FLOAT_VEC4";
  30. EParameterType[EParameterType["INT_VEC2"] = 35667] = "INT_VEC2";
  31. EParameterType[EParameterType["INT_VEC3"] = 35668] = "INT_VEC3";
  32. EParameterType[EParameterType["INT_VEC4"] = 35669] = "INT_VEC4";
  33. EParameterType[EParameterType["BOOL"] = 35670] = "BOOL";
  34. EParameterType[EParameterType["BOOL_VEC2"] = 35671] = "BOOL_VEC2";
  35. EParameterType[EParameterType["BOOL_VEC3"] = 35672] = "BOOL_VEC3";
  36. EParameterType[EParameterType["BOOL_VEC4"] = 35673] = "BOOL_VEC4";
  37. EParameterType[EParameterType["FLOAT_MAT2"] = 35674] = "FLOAT_MAT2";
  38. EParameterType[EParameterType["FLOAT_MAT3"] = 35675] = "FLOAT_MAT3";
  39. EParameterType[EParameterType["FLOAT_MAT4"] = 35676] = "FLOAT_MAT4";
  40. EParameterType[EParameterType["SAMPLER_2D"] = 35678] = "SAMPLER_2D";
  41. })(BABYLON.EParameterType || (BABYLON.EParameterType = {}));
  42. var EParameterType = BABYLON.EParameterType;
  43. (function (ETextureWrapMode) {
  44. ETextureWrapMode[ETextureWrapMode["CLAMP_TO_EDGE"] = 33071] = "CLAMP_TO_EDGE";
  45. ETextureWrapMode[ETextureWrapMode["MIRRORED_REPEAT"] = 33648] = "MIRRORED_REPEAT";
  46. ETextureWrapMode[ETextureWrapMode["REPEAT"] = 10497] = "REPEAT";
  47. })(BABYLON.ETextureWrapMode || (BABYLON.ETextureWrapMode = {}));
  48. var ETextureWrapMode = BABYLON.ETextureWrapMode;
  49. (function (ETextureFilterType) {
  50. ETextureFilterType[ETextureFilterType["NEAREST"] = 9728] = "NEAREST";
  51. ETextureFilterType[ETextureFilterType["LINEAR"] = 9728] = "LINEAR";
  52. ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_NEAREST"] = 9984] = "NEAREST_MIPMAP_NEAREST";
  53. ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_NEAREST"] = 9985] = "LINEAR_MIPMAP_NEAREST";
  54. ETextureFilterType[ETextureFilterType["NEAREST_MIPMAP_LINEAR"] = 9986] = "NEAREST_MIPMAP_LINEAR";
  55. ETextureFilterType[ETextureFilterType["LINEAR_MIPMAP_LINEAR"] = 9987] = "LINEAR_MIPMAP_LINEAR";
  56. })(BABYLON.ETextureFilterType || (BABYLON.ETextureFilterType = {}));
  57. var ETextureFilterType = BABYLON.ETextureFilterType;
  58. (function (ETextureFormat) {
  59. ETextureFormat[ETextureFormat["ALPHA"] = 6406] = "ALPHA";
  60. ETextureFormat[ETextureFormat["RGB"] = 6407] = "RGB";
  61. ETextureFormat[ETextureFormat["RGBA"] = 6408] = "RGBA";
  62. ETextureFormat[ETextureFormat["LUMINANCE"] = 6409] = "LUMINANCE";
  63. ETextureFormat[ETextureFormat["LUMINANCE_ALPHA"] = 6410] = "LUMINANCE_ALPHA";
  64. })(BABYLON.ETextureFormat || (BABYLON.ETextureFormat = {}));
  65. var ETextureFormat = BABYLON.ETextureFormat;
  66. (function (ECullingType) {
  67. ECullingType[ECullingType["FRONT"] = 1028] = "FRONT";
  68. ECullingType[ECullingType["BACK"] = 1029] = "BACK";
  69. ECullingType[ECullingType["FRONT_AND_BACK"] = 1032] = "FRONT_AND_BACK";
  70. })(BABYLON.ECullingType || (BABYLON.ECullingType = {}));
  71. var ECullingType = BABYLON.ECullingType;
  72. (function (EBlendingFunction) {
  73. EBlendingFunction[EBlendingFunction["ZERO"] = 0] = "ZERO";
  74. EBlendingFunction[EBlendingFunction["ONE"] = 1] = "ONE";
  75. EBlendingFunction[EBlendingFunction["SRC_COLOR"] = 768] = "SRC_COLOR";
  76. EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_COLOR"] = 769] = "ONE_MINUS_SRC_COLOR";
  77. EBlendingFunction[EBlendingFunction["DST_COLOR"] = 774] = "DST_COLOR";
  78. EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_COLOR"] = 775] = "ONE_MINUS_DST_COLOR";
  79. EBlendingFunction[EBlendingFunction["SRC_ALPHA"] = 770] = "SRC_ALPHA";
  80. EBlendingFunction[EBlendingFunction["ONE_MINUS_SRC_ALPHA"] = 771] = "ONE_MINUS_SRC_ALPHA";
  81. EBlendingFunction[EBlendingFunction["DST_ALPHA"] = 772] = "DST_ALPHA";
  82. EBlendingFunction[EBlendingFunction["ONE_MINUS_DST_ALPHA"] = 773] = "ONE_MINUS_DST_ALPHA";
  83. EBlendingFunction[EBlendingFunction["CONSTANT_COLOR"] = 32769] = "CONSTANT_COLOR";
  84. EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_COLOR"] = 32770] = "ONE_MINUS_CONSTANT_COLOR";
  85. EBlendingFunction[EBlendingFunction["CONSTANT_ALPHA"] = 32771] = "CONSTANT_ALPHA";
  86. EBlendingFunction[EBlendingFunction["ONE_MINUS_CONSTANT_ALPHA"] = 32772] = "ONE_MINUS_CONSTANT_ALPHA";
  87. EBlendingFunction[EBlendingFunction["SRC_ALPHA_SATURATE"] = 776] = "SRC_ALPHA_SATURATE";
  88. })(BABYLON.EBlendingFunction || (BABYLON.EBlendingFunction = {}));
  89. var EBlendingFunction = BABYLON.EBlendingFunction;
  90. /**
  91. * Tokenizer. Used for shaders compatibility
  92. * Automatically map world, view, projection, worldViewProjection, attributes and so on
  93. */
  94. var ETokenType;
  95. (function (ETokenType) {
  96. ETokenType[ETokenType["IDENTIFIER"] = 1] = "IDENTIFIER";
  97. ETokenType[ETokenType["UNKNOWN"] = 2] = "UNKNOWN";
  98. ETokenType[ETokenType["END_OF_INPUT"] = 3] = "END_OF_INPUT";
  99. })(ETokenType || (ETokenType = {}));
  100. var Tokenizer = (function () {
  101. function Tokenizer(toParse) {
  102. this._pos = 0;
  103. this.isLetterOrDigitPattern = /^[a-zA-Z0-9]+$/;
  104. this._toParse = toParse;
  105. this._maxPos = toParse.length;
  106. }
  107. Tokenizer.prototype.getNextToken = function () {
  108. if (this.isEnd())
  109. return ETokenType.END_OF_INPUT;
  110. this.currentString = this.read();
  111. this.currentToken = ETokenType.UNKNOWN;
  112. if (this.currentString === "_" || this.isLetterOrDigitPattern.test(this.currentString)) {
  113. this.currentToken = ETokenType.IDENTIFIER;
  114. this.currentIdentifier = this.currentString;
  115. while (!this.isEnd() && (this.isLetterOrDigitPattern.test(this.currentString = this.peek()) || this.currentString === "_")) {
  116. this.currentIdentifier += this.currentString;
  117. this.forward();
  118. }
  119. }
  120. return this.currentToken;
  121. };
  122. Tokenizer.prototype.peek = function () {
  123. return this._toParse[this._pos];
  124. };
  125. Tokenizer.prototype.read = function () {
  126. return this._toParse[this._pos++];
  127. };
  128. Tokenizer.prototype.forward = function () {
  129. this._pos++;
  130. };
  131. Tokenizer.prototype.isEnd = function () {
  132. return this._pos >= this._maxPos;
  133. };
  134. return Tokenizer;
  135. })();
  136. /**
  137. * Values
  138. */
  139. var glTFTransforms = ["MODEL", "VIEW", "PROJECTION", "MODELVIEW", "MODELVIEWPROJECTION", "JOINTMATRIX"];
  140. var babylonTransforms = ["world", "view", "projection", "worldView", "worldViewProjection", "mBones"];
  141. var glTFAnimationPaths = ["translation", "rotation", "scale"];
  142. var babylonAnimationPaths = ["position", "rotationQuaternion", "scaling"];
  143. /**
  144. * Parse
  145. */
  146. var parseBuffers = function (parsedBuffers, gltfRuntime) {
  147. for (var buf in parsedBuffers) {
  148. var parsedBuffer = parsedBuffers[buf];
  149. gltfRuntime.buffers[buf] = parsedBuffer;
  150. gltfRuntime.buffersCount++;
  151. }
  152. };
  153. var parseShaders = function (parsedShaders, gltfRuntime) {
  154. for (var sha in parsedShaders) {
  155. var parsedShader = parsedShaders[sha];
  156. gltfRuntime.shaders[sha] = parsedShader;
  157. gltfRuntime.shaderscount++;
  158. }
  159. };
  160. var parseObject = function (parsedObjects, runtimeProperty, gltfRuntime) {
  161. for (var object in parsedObjects) {
  162. var parsedObject = parsedObjects[object];
  163. gltfRuntime[runtimeProperty][object] = parsedObject;
  164. }
  165. };
  166. /**
  167. * Utils
  168. */
  169. var getByteStrideFromType = function (accessor) {
  170. // Needs this function since "byteStride" isn't requiered in glTF format
  171. var type = accessor.type;
  172. switch (type) {
  173. case "VEC2": return 2;
  174. case "VEC3": return 3;
  175. case "VEC4": return 4;
  176. case "MAT2": return 4;
  177. case "MAT3": return 9;
  178. case "MAT4": return 16;
  179. default: return 1;
  180. }
  181. };
  182. var setMatrix = function (scene, source, parameter, uniformName, shaderMaterial) {
  183. var mat = null;
  184. if (parameter.semantic === "MODEL") {
  185. mat = source.getWorldMatrix();
  186. }
  187. else if (parameter.semantic === "PROJECTION") {
  188. mat = scene.getProjectionMatrix();
  189. }
  190. else if (parameter.semantic === "VIEW") {
  191. mat = scene.getViewMatrix();
  192. }
  193. else if (parameter.semantic === "MODELVIEWINVERSETRANSPOSE") {
  194. mat = BABYLON.Matrix.Transpose(source.getWorldMatrix().multiply(scene.getViewMatrix()).invert());
  195. }
  196. else if (parameter.semantic === "MODELVIEW") {
  197. mat = source.getWorldMatrix().multiply(scene.getViewMatrix());
  198. }
  199. else if (parameter.semantic === "MODELVIEWPROJECTION") {
  200. mat = source.getWorldMatrix().multiply(scene.getTransformMatrix());
  201. }
  202. else if (parameter.semantic === "MODELINVERSE") {
  203. mat = source.getWorldMatrix().invert();
  204. }
  205. else if (parameter.semantic === "VIEWINVERSE") {
  206. mat = scene.getViewMatrix().invert();
  207. }
  208. else if (parameter.semantic === "PROJECTIONINVERSE") {
  209. mat = scene.getProjectionMatrix().invert();
  210. }
  211. else if (parameter.semantic === "MODELVIEWINVERSE") {
  212. mat = source.getWorldMatrix().multiply(scene.getViewMatrix()).invert();
  213. }
  214. else if (parameter.semantic === "MODELVIEWPROJECTIONINVERSE") {
  215. mat = source.getWorldMatrix().multiply(scene.getTransformMatrix()).invert();
  216. }
  217. else if (parameter.semantic === "MODELINVERSETRANSPOSE") {
  218. mat = BABYLON.Matrix.Transpose(source.getWorldMatrix().invert());
  219. }
  220. else {
  221. debugger;
  222. }
  223. switch (parameter.type) {
  224. case EParameterType.FLOAT_MAT2:
  225. shaderMaterial.setMatrix2x2(uniformName, BABYLON.Matrix.GetAsMatrix2x2(mat));
  226. break;
  227. case EParameterType.FLOAT_MAT3:
  228. shaderMaterial.setMatrix3x3(uniformName, BABYLON.Matrix.GetAsMatrix3x3(mat));
  229. break;
  230. case EParameterType.FLOAT_MAT4:
  231. shaderMaterial.setMatrix(uniformName, mat);
  232. break;
  233. default: break;
  234. }
  235. };
  236. var setUniform = function (shaderMaterial, uniform, value, type) {
  237. switch (type) {
  238. case EParameterType.FLOAT:
  239. shaderMaterial.setFloat(uniform, value);
  240. return true;
  241. case EParameterType.FLOAT_VEC2:
  242. shaderMaterial.setVector2(uniform, BABYLON.Vector2.FromArray(value));
  243. return true;
  244. case EParameterType.FLOAT_VEC3:
  245. shaderMaterial.setVector3(uniform, BABYLON.Vector3.FromArray(value));
  246. return true;
  247. case EParameterType.FLOAT_VEC4:
  248. shaderMaterial.setVector4(uniform, BABYLON.Vector4.FromArray(value));
  249. return true;
  250. default: return false;
  251. }
  252. };
  253. var getWrapMode = function (mode) {
  254. switch (mode) {
  255. case ETextureWrapMode.CLAMP_TO_EDGE: return BABYLON.Texture.CLAMP_ADDRESSMODE;
  256. case ETextureWrapMode.MIRRORED_REPEAT: return BABYLON.Texture.MIRROR_ADDRESSMODE;
  257. case ETextureWrapMode.REPEAT: return BABYLON.Texture.WRAP_ADDRESSMODE;
  258. default: return BABYLON.Texture.WRAP_ADDRESSMODE;
  259. }
  260. };
  261. var getTextureFilterMode = function (mode) {
  262. switch (mode) {
  263. case ETextureFilterType.LINEAR:
  264. case ETextureFilterType.LINEAR_MIPMAP_NEAREST:
  265. case ETextureFilterType.LINEAR_MIPMAP_LINEAR: return BABYLON.Texture.TRILINEAR_SAMPLINGMODE;
  266. case ETextureFilterType.NEAREST:
  267. case ETextureFilterType.NEAREST_MIPMAP_NEAREST: return BABYLON.Texture.NEAREST_SAMPLINGMODE;
  268. default: return BABYLON.Texture.BILINEAR_SAMPLINGMODE;
  269. }
  270. };
  271. var getBufferFromAccessor = function (gltfRuntime, accessor) {
  272. var bufferView = gltfRuntime.bufferViews[accessor.bufferView];
  273. var arrayBuffer = gltfRuntime.arrayBuffers[bufferView.buffer];
  274. var byteOffset = accessor.byteOffset + bufferView.byteOffset;
  275. var count = accessor.count * getByteStrideFromType(accessor);
  276. switch (accessor.componentType) {
  277. case EComponentType.BYTE: return new Int8Array(arrayBuffer, byteOffset, count);
  278. case EComponentType.UNSIGNED_BYTE: return new Uint8Array(arrayBuffer, byteOffset, count);
  279. case EComponentType.SHORT: return new Int16Array(arrayBuffer, byteOffset, count);
  280. case EComponentType.UNSIGNED_SHORT: return new Uint16Array(arrayBuffer, byteOffset, count);
  281. default: return new Float32Array(arrayBuffer, byteOffset, count);
  282. }
  283. };
  284. var normalizeUVs = function (buffer) {
  285. if (!buffer) {
  286. return;
  287. }
  288. for (var i = 0; i < buffer.length / 2; i++) {
  289. buffer[i * 2 + 1] = 1.0 - buffer[i * 2 + 1];
  290. }
  291. };
  292. var replaceInString = function (str, searchValue, replaceValue) {
  293. while (str.indexOf(searchValue) !== -1) {
  294. str = str.replace(searchValue, replaceValue);
  295. }
  296. return str;
  297. };
  298. var getAttribute = function (attributeParameter) {
  299. if (attributeParameter.semantic === "NORMAL") {
  300. return "normal";
  301. }
  302. else if (attributeParameter.semantic === "POSITION") {
  303. return "position";
  304. }
  305. else if (attributeParameter.semantic === "JOINT") {
  306. return "matricesIndices";
  307. }
  308. else if (attributeParameter.semantic === "WEIGHT") {
  309. return "matricesWeights";
  310. }
  311. else if (attributeParameter.semantic === "COLOR") {
  312. return "color";
  313. }
  314. else if (attributeParameter.semantic.indexOf("TEXCOORD_") !== -1) {
  315. var channel = Number(attributeParameter.semantic.split("_")[1]);
  316. return "uv" + (channel === 0 ? "" : channel + 1);
  317. }
  318. };
  319. var isBase64 = function (uri) {
  320. return uri.length < 5 ? false : uri.substr(0, 5) === "data:";
  321. };
  322. /**
  323. * Returns the animation path (glTF -> Babylon)
  324. */
  325. var getAnimationPath = function (path) {
  326. var index = glTFAnimationPaths.indexOf(path);
  327. if (index !== -1) {
  328. return babylonAnimationPaths[index];
  329. }
  330. return path;
  331. };
  332. /**
  333. * Loads and creates animations
  334. */
  335. var loadAnimations = function (gltfRuntime) {
  336. for (var anim in gltfRuntime.animations) {
  337. var animation = gltfRuntime.animations[anim];
  338. for (var i = 0; i < animation.channels.length; i++) {
  339. // Get parameters and load buffers
  340. var channel = animation.channels[i];
  341. var sampler = animation.samplers[channel.sampler];
  342. if (!sampler) {
  343. continue;
  344. }
  345. var inputData = animation.parameters[sampler.input];
  346. var outputData = animation.parameters[sampler.output];
  347. var bufferInput = getBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[inputData]);
  348. var bufferOutput = getBufferFromAccessor(gltfRuntime, gltfRuntime.accessors[outputData]);
  349. var targetID = channel.target.id;
  350. var targetNode = gltfRuntime.scene.getNodeByID(targetID);
  351. if (targetNode === null) {
  352. BABYLON.Tools.Warn("Creating animation named " + anim + ". But cannot find node named " + targetID + " to attach to");
  353. continue;
  354. }
  355. var isBone = targetNode instanceof BABYLON.Bone;
  356. // Get target path (position, rotation or scaling)
  357. var targetPath = channel.target.path;
  358. var targetPathIndex = glTFAnimationPaths.indexOf(targetPath);
  359. if (targetPathIndex !== -1) {
  360. targetPath = babylonAnimationPaths[targetPathIndex];
  361. }
  362. // Determine animation type
  363. var animationType = BABYLON.Animation.ANIMATIONTYPE_MATRIX;
  364. if (!isBone) {
  365. if (targetPath === "rotationQuaternion") {
  366. animationType = BABYLON.Animation.ANIMATIONTYPE_QUATERNION;
  367. targetNode.rotationQuaternion = new BABYLON.Quaternion();
  368. }
  369. else {
  370. animationType = BABYLON.Animation.ANIMATIONTYPE_VECTOR3;
  371. }
  372. }
  373. // Create animation and key frames
  374. var babylonAnimation = new BABYLON.Animation(anim, isBone ? "_matrix" : targetPath, 1, animationType, BABYLON.Animation.ANIMATIONLOOPMODE_CYCLE);
  375. var keys = [];
  376. var arrayOffset = 0;
  377. // For each frame
  378. for (var j = 0; j < bufferInput.length; j++) {
  379. var value = null;
  380. if (targetPath === "rotationQuaternion") {
  381. //value = Quaternion.RotationAxis(Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]).normalize(), bufferOutput[arrayOffset + 3]);
  382. value = BABYLON.Quaternion.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2], bufferOutput[arrayOffset + 3]]);
  383. arrayOffset += 4;
  384. }
  385. else {
  386. value = BABYLON.Vector3.FromArray([bufferOutput[arrayOffset], bufferOutput[arrayOffset + 1], bufferOutput[arrayOffset + 2]]);
  387. arrayOffset += 3;
  388. }
  389. if (isBone) {
  390. var bone = targetNode;
  391. var translation = BABYLON.Vector3.Zero();
  392. var rotationQuaternion = new BABYLON.Quaternion();
  393. var scaling = BABYLON.Vector3.Zero();
  394. // Warning on decompose
  395. var mat = bone.getBaseMatrix();
  396. mat.decompose(scaling, rotationQuaternion, translation);
  397. if (targetPath === "position") {
  398. translation = value;
  399. }
  400. else if (targetPath === "rotationQuaternion") {
  401. rotationQuaternion = value;
  402. }
  403. else {
  404. scaling = value;
  405. }
  406. value = BABYLON.Matrix.Compose(scaling, rotationQuaternion, translation);
  407. }
  408. keys.push({
  409. frame: bufferInput[j],
  410. value: value
  411. });
  412. }
  413. // Finish
  414. babylonAnimation.setKeys(keys);
  415. targetNode.animations.push(babylonAnimation);
  416. gltfRuntime.scene.beginAnimation(targetNode, 0, bufferInput[bufferInput.length - 1], true, 1.0);
  417. }
  418. }
  419. };
  420. /**
  421. * Returns the bones transformation matrix
  422. */
  423. var configureBoneTransformation = function (node) {
  424. var mat = null;
  425. if (node.translation && node.rotation && node.scale) {
  426. var scale = BABYLON.Vector3.FromArray(node.scale);
  427. var rotation = BABYLON.Quaternion.FromArray(node.rotation);
  428. var position = BABYLON.Vector3.FromArray(node.translation);
  429. mat = BABYLON.Matrix.Compose(scale, rotation, position);
  430. }
  431. else {
  432. mat = BABYLON.Matrix.FromArray(node.matrix);
  433. }
  434. return mat;
  435. };
  436. /**
  437. * Returns the parent bone
  438. */
  439. var getParentBone = function (gltfRuntime, skins, jointName, newSkeleton) {
  440. // Try to find
  441. for (var i = 0; i < newSkeleton.bones.length; i++) {
  442. if (newSkeleton.bones[i].id === jointName) {
  443. return newSkeleton.bones[i];
  444. }
  445. }
  446. // Not found, search in gltf nodes
  447. var nodes = gltfRuntime.nodes;
  448. for (var nde in nodes) {
  449. var node = nodes[nde];
  450. if (!node.jointName) {
  451. continue;
  452. }
  453. var children = node.children;
  454. for (var i = 0; i < children.length; i++) {
  455. var child = gltfRuntime.nodes[children[i]];
  456. if (!child.jointName) {
  457. continue;
  458. }
  459. if (child.jointName === jointName) {
  460. var mat = configureBoneTransformation(node);
  461. var bone = new BABYLON.Bone(node.name, newSkeleton, getParentBone(gltfRuntime, skins, node.jointName, newSkeleton), mat);
  462. bone.id = nde;
  463. return bone;
  464. }
  465. }
  466. }
  467. return null;
  468. };
  469. /**
  470. * Returns the appropriate root node
  471. */
  472. var getNodeToRoot = function (nodesToRoot, id) {
  473. for (var i = 0; i < nodesToRoot.length; i++) {
  474. var nodeToRoot = nodesToRoot[i];
  475. for (var j = 0; j < nodeToRoot.node.children.length; j++) {
  476. var child = nodeToRoot.node.children[j];
  477. if (child === id) {
  478. return nodeToRoot.bone;
  479. }
  480. }
  481. }
  482. return null;
  483. };
  484. /**
  485. * Returns the node with the joint name
  486. */
  487. var getJointNode = function (gltfRuntime, jointName) {
  488. var nodes = gltfRuntime.nodes;
  489. var node = nodes[jointName];
  490. if (node) {
  491. return {
  492. node: node,
  493. id: jointName
  494. };
  495. }
  496. for (var nde in nodes) {
  497. node = nodes[nde];
  498. if (node.jointName === jointName) {
  499. return {
  500. node: node,
  501. id: nde
  502. };
  503. }
  504. }
  505. return null;
  506. };
  507. /**
  508. * Checks if a nodes is in joints
  509. */
  510. var nodeIsInJoints = function (skins, id) {
  511. for (var i = 0; i < skins.jointNames.length; i++) {
  512. if (skins.jointNames[i] === id) {
  513. return true;
  514. }
  515. }
  516. return false;
  517. };
  518. /**
  519. * Fills the nodes to root for bones and builds hierarchy
  520. */
  521. var getNodesToRoot = function (gltfRuntime, newSkeleton, skins, nodesToRoot) {
  522. // Creates nodes for root
  523. for (var nde in gltfRuntime.nodes) {
  524. var node = gltfRuntime.nodes[nde];
  525. var id = nde;
  526. if (!node.jointName || nodeIsInJoints(skins, node.jointName)) {
  527. continue;
  528. }
  529. // Create node to root bone
  530. var mat = configureBoneTransformation(node);
  531. var bone = new BABYLON.Bone(node.name, newSkeleton, null, mat);
  532. bone.id = id;
  533. nodesToRoot.push({ bone: bone, node: node, id: id });
  534. }
  535. // Parenting
  536. for (var i = 0; i < nodesToRoot.length; i++) {
  537. var nodeToRoot = nodesToRoot[i];
  538. var children = nodeToRoot.node.children;
  539. for (var j = 0; j < children.length; j++) {
  540. var child = null;
  541. for (var k = 0; k < nodesToRoot.length; k++) {
  542. if (nodesToRoot[k].id === children[j]) {
  543. child = nodesToRoot[k];
  544. break;
  545. }
  546. }
  547. if (child) {
  548. child.bone._parent = nodeToRoot.bone;
  549. nodeToRoot.bone.children.push(child.bone);
  550. }
  551. }
  552. }
  553. };
  554. /**
  555. * Imports a skeleton
  556. */
  557. var importSkeleton = function (gltfRuntime, skins, mesh, newSkeleton) {
  558. if (!newSkeleton) {
  559. newSkeleton = new BABYLON.Skeleton(skins.name, "", gltfRuntime.scene);
  560. }
  561. if (!skins.babylonSkeleton) {
  562. return newSkeleton;
  563. }
  564. // Matrices
  565. var accessor = gltfRuntime.accessors[skins.inverseBindMatrices];
  566. var buffer = getBufferFromAccessor(gltfRuntime, accessor);
  567. var bindShapeMatrix = BABYLON.Matrix.FromArray(skins.bindShapeMatrix);
  568. newSkeleton._identity = bindShapeMatrix;
  569. // Find the root bones
  570. var nodesToRoot = [];
  571. var nodesToRootToAdd = [];
  572. getNodesToRoot(gltfRuntime, newSkeleton, skins, nodesToRoot);
  573. newSkeleton.bones = [];
  574. // Joints
  575. for (var i = 0; i < skins.jointNames.length; i++) {
  576. var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
  577. var node = jointNode.node;
  578. if (!node) {
  579. BABYLON.Tools.Warn("Joint named " + skins.jointNames[i] + " does not exist");
  580. continue;
  581. }
  582. var id = jointNode.id;
  583. // Check if node already exists
  584. var foundBone = false;
  585. for (var j = 0; j < newSkeleton.bones.length; j++) {
  586. if (newSkeleton.bones[j].id === id) {
  587. foundBone = true;
  588. break;
  589. }
  590. }
  591. if (foundBone) {
  592. continue;
  593. }
  594. // Search for parent bone
  595. var parentBone = null;
  596. for (var j = 0; j < i; j++) {
  597. var joint = getJointNode(gltfRuntime, skins.jointNames[j]).node;
  598. if (!joint) {
  599. BABYLON.Tools.Warn("Joint named " + skins.jointNames[j] + " does not exist when looking for parent");
  600. continue;
  601. }
  602. var children = joint.children;
  603. foundBone = false;
  604. for (var k = 0; k < children.length; k++) {
  605. if (children[k] === id) {
  606. parentBone = getParentBone(gltfRuntime, skins, skins.jointNames[j], newSkeleton);
  607. foundBone = true;
  608. break;
  609. }
  610. }
  611. if (foundBone) {
  612. break;
  613. }
  614. }
  615. // Create bone
  616. var mat = configureBoneTransformation(node);
  617. if (!parentBone) {
  618. parentBone = getNodeToRoot(nodesToRoot, id);
  619. if (parentBone) {
  620. if (nodesToRootToAdd.indexOf(parentBone) === -1) {
  621. nodesToRootToAdd.push(parentBone);
  622. }
  623. }
  624. }
  625. var bone = new BABYLON.Bone(node.name, newSkeleton, parentBone, mat);
  626. bone.id = id;
  627. }
  628. // Polish
  629. var bones = newSkeleton.bones;
  630. newSkeleton.bones = [];
  631. for (var i = 0; i < skins.jointNames.length; i++) {
  632. var jointNode = getJointNode(gltfRuntime, skins.jointNames[i]);
  633. if (!jointNode) {
  634. continue;
  635. }
  636. for (var j = 0; j < bones.length; j++) {
  637. if (bones[j].id === jointNode.id) {
  638. newSkeleton.bones.push(bones[j]);
  639. break;
  640. }
  641. }
  642. }
  643. // Finish
  644. newSkeleton.prepare();
  645. for (var i = 0; i < nodesToRootToAdd.length; i++) {
  646. newSkeleton.bones.push(nodesToRootToAdd[i]);
  647. }
  648. return newSkeleton;
  649. };
  650. /**
  651. * Imports a mesh and its geometries
  652. */
  653. var importMesh = function (gltfRuntime, node, meshes, id, newMesh) {
  654. if (!newMesh) {
  655. newMesh = new BABYLON.Mesh(node.name, gltfRuntime.scene);
  656. newMesh.id = id;
  657. }
  658. if (!node.babylonNode) {
  659. return newMesh;
  660. }
  661. var multiMat = new BABYLON.MultiMaterial("multimat" + id, gltfRuntime.scene);
  662. newMesh.material = multiMat;
  663. var vertexData = new BABYLON.VertexData();
  664. var geometry = new BABYLON.Geometry(id, gltfRuntime.scene, vertexData, false, newMesh);
  665. var verticesStarts = [];
  666. var verticesCounts = [];
  667. var indexStarts = [];
  668. var indexCounts = [];
  669. for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
  670. var meshID = meshes[meshIndex];
  671. var mesh = gltfRuntime.meshes[meshID];
  672. if (!mesh) {
  673. continue;
  674. }
  675. // Positions, normals and UVs
  676. for (var i = 0; i < mesh.primitives.length; i++) {
  677. // Temporary vertex data
  678. var tempVertexData = new BABYLON.VertexData();
  679. var primitive = mesh.primitives[i];
  680. if (primitive.mode !== 4) {
  681. }
  682. var attributes = primitive.attributes;
  683. var accessor = null;
  684. var buffer = null;
  685. // Set positions, normal and uvs
  686. for (var semantic in attributes) {
  687. // Link accessor and buffer view
  688. accessor = gltfRuntime.accessors[attributes[semantic]];
  689. buffer = getBufferFromAccessor(gltfRuntime, accessor);
  690. if (semantic === "NORMAL") {
  691. tempVertexData.normals = [];
  692. for (var j = 0; j < buffer.length; j++) {
  693. tempVertexData.normals.push(buffer[j]);
  694. }
  695. }
  696. else if (semantic === "POSITION") {
  697. tempVertexData.positions = [];
  698. for (var j = 0; j < buffer.length; j++) {
  699. tempVertexData.positions.push(buffer[j]);
  700. }
  701. verticesCounts.push(tempVertexData.positions.length);
  702. }
  703. else if (semantic.indexOf("TEXCOORD_") !== -1) {
  704. var channel = Number(semantic.split("_")[1]);
  705. var uvKind = BABYLON.VertexBuffer.UVKind + (channel === 0 ? "" : (channel + 1));
  706. var uvs = [];
  707. for (var j = 0; j < buffer.length; j++) {
  708. uvs.push(buffer[j]);
  709. }
  710. normalizeUVs(uvs);
  711. tempVertexData.set(uvs, uvKind);
  712. }
  713. else if (semantic === "JOINT") {
  714. tempVertexData.matricesIndices = [];
  715. for (var j = 0; j < buffer.length; j++) {
  716. tempVertexData.matricesIndices.push(buffer[j]);
  717. }
  718. }
  719. else if (semantic === "WEIGHT") {
  720. tempVertexData.matricesWeights = [];
  721. for (var j = 0; j < buffer.length; j++) {
  722. tempVertexData.matricesWeights.push(buffer[j]);
  723. }
  724. }
  725. else if (semantic === "COLOR") {
  726. tempVertexData.colors = [];
  727. for (var j = 0; j < buffer.length; j++) {
  728. tempVertexData.colors.push(buffer[j]);
  729. }
  730. }
  731. }
  732. // Indices
  733. accessor = gltfRuntime.accessors[primitive.indices];
  734. buffer = getBufferFromAccessor(gltfRuntime, accessor);
  735. tempVertexData.indices = [];
  736. for (var j = 0; j < buffer.length; j++) {
  737. tempVertexData.indices.push(buffer[j]);
  738. }
  739. indexCounts.push(buffer.length);
  740. vertexData.merge(tempVertexData);
  741. tempVertexData = undefined;
  742. // Sub material
  743. var material = gltfRuntime.scene.getMaterialByID(primitive.material);
  744. multiMat.subMaterials.push(material === null ? gltfRuntime.scene.defaultMaterial : material);
  745. // Update vertices start and index start
  746. verticesStarts.push(verticesStarts.length === 0 ? 0 : verticesStarts[verticesStarts.length - 1] + verticesCounts[verticesCounts.length - 2]);
  747. indexStarts.push(indexStarts.length === 0 ? 0 : indexStarts[indexStarts.length - 1] + indexCounts[indexCounts.length - 2]);
  748. }
  749. }
  750. // Apply geometry
  751. geometry.setAllVerticesData(vertexData, false);
  752. newMesh.flipFaces(true);
  753. newMesh.computeWorldMatrix(true);
  754. // Apply submeshes
  755. newMesh.subMeshes = [];
  756. var index = 0;
  757. for (var meshIndex = 0; meshIndex < meshes.length; meshIndex++) {
  758. var meshID = meshes[meshIndex];
  759. var mesh = gltfRuntime.meshes[meshID];
  760. if (!mesh) {
  761. continue;
  762. }
  763. for (var i = 0; i < mesh.primitives.length; i++) {
  764. if (mesh.primitives[i].mode !== 4) {
  765. }
  766. var subMesh = new BABYLON.SubMesh(index, verticesStarts[index], verticesCounts[index], indexStarts[index], indexCounts[index], newMesh, newMesh, true);
  767. index++;
  768. }
  769. }
  770. // Finish
  771. return newMesh;
  772. };
  773. /**
  774. * Configure node transformation from position, rotation and scaling
  775. */
  776. var configureNode = function (newNode, position, rotation, scaling) {
  777. if (newNode.position) {
  778. newNode.position = position;
  779. }
  780. if (newNode.rotationQuaternion || newNode.rotation) {
  781. newNode.rotationQuaternion = rotation;
  782. }
  783. if (newNode.scaling) {
  784. newNode.scaling = scaling;
  785. }
  786. };
  787. /**
  788. * Configures node from transformation matrix
  789. */
  790. var configureNodeFromMatrix = function (newNode, node) {
  791. if (node.matrix) {
  792. var position = new BABYLON.Vector3(0, 0, 0);
  793. var rotation = new BABYLON.Quaternion();
  794. var scaling = new BABYLON.Vector3(0, 0, 0);
  795. var mat = BABYLON.Matrix.FromArray(node.matrix);
  796. mat.decompose(scaling, rotation, position);
  797. configureNode(newNode, position, rotation, scaling);
  798. if (newNode instanceof BABYLON.TargetCamera) {
  799. newNode.setTarget(BABYLON.Vector3.Zero());
  800. }
  801. }
  802. else {
  803. //configureNode(newNode, Vector3.FromArray(node.translation), Quaternion.RotationAxis(Vector3.FromArray(node.rotation), node.rotation[3]), Vector3.FromArray(node.scale));
  804. configureNode(newNode, BABYLON.Vector3.FromArray(node.translation), BABYLON.Quaternion.FromArray(node.rotation), BABYLON.Vector3.FromArray(node.scale));
  805. }
  806. };
  807. /**
  808. * Imports a node
  809. */
  810. var importNode = function (gltfRuntime, node, id) {
  811. var lastNode = null;
  812. if (gltfRuntime.importOnlyMeshes && (node.skin || node.meshes)) {
  813. if (gltfRuntime.importMeshesNames.length > 0 && gltfRuntime.importMeshesNames.indexOf(node.name) === -1) {
  814. return null;
  815. }
  816. }
  817. // Meshes
  818. if (node.skin) {
  819. if (node.meshes) {
  820. var skin = gltfRuntime.skins[node.skin];
  821. var newMesh = importMesh(gltfRuntime, node, node.meshes, id, node.babylonNode);
  822. newMesh.skeleton = gltfRuntime.scene.getLastSkeletonByID(node.skin);
  823. if (newMesh.skeleton === null) {
  824. newMesh.skeleton = importSkeleton(gltfRuntime, skin, newMesh, skin.babylonSkeleton);
  825. if (!skin.babylonSkeleton) {
  826. skin.babylonSkeleton = newMesh.skeleton;
  827. }
  828. }
  829. if (newMesh.skeleton !== null) {
  830. newMesh.useBones = true;
  831. }
  832. lastNode = newMesh;
  833. }
  834. }
  835. else if (node.meshes) {
  836. /**
  837. * Improve meshes property
  838. */
  839. var newMesh = importMesh(gltfRuntime, node, node.mesh ? [node.mesh] : node.meshes, id, node.babylonNode);
  840. lastNode = newMesh;
  841. }
  842. else if (node.light && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
  843. var light = gltfRuntime.lights[node.light];
  844. if (light) {
  845. if (light.type === "ambient") {
  846. var ambienLight = light[light.type];
  847. var hemiLight = new BABYLON.HemisphericLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
  848. hemiLight.name = node.name;
  849. if (ambienLight.color) {
  850. hemiLight.diffuse = BABYLON.Color3.FromArray(ambienLight.color);
  851. }
  852. lastNode = hemiLight;
  853. }
  854. else if (light.type === "directional") {
  855. var directionalLight = light[light.type];
  856. var dirLight = new BABYLON.DirectionalLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
  857. dirLight.name = node.name;
  858. if (directionalLight.color) {
  859. dirLight.diffuse = BABYLON.Color3.FromArray(directionalLight.color);
  860. }
  861. lastNode = dirLight;
  862. }
  863. else if (light.type === "point") {
  864. var pointLight = light[light.type];
  865. var ptLight = new BABYLON.PointLight(node.light, BABYLON.Vector3.Zero(), gltfRuntime.scene);
  866. ptLight.name = node.name;
  867. if (pointLight.color) {
  868. ptLight.diffuse = BABYLON.Color3.FromArray(pointLight.color);
  869. }
  870. lastNode = ptLight;
  871. }
  872. else if (light.type === "spot") {
  873. var spotLight = light[light.type];
  874. var spLight = new BABYLON.SpotLight(node.light, BABYLON.Vector3.Zero(), BABYLON.Vector3.Zero(), 0, 0, gltfRuntime.scene);
  875. spLight.name = node.name;
  876. if (spotLight.color) {
  877. spLight.diffuse = BABYLON.Color3.FromArray(spotLight.color);
  878. }
  879. if (spotLight.fallOfAngle) {
  880. spLight.angle = spotLight.fallOfAngle;
  881. }
  882. if (spotLight.fallOffExponent) {
  883. spLight.exponent = spotLight.fallOffExponent;
  884. }
  885. lastNode = spLight;
  886. }
  887. }
  888. }
  889. else if (node.camera && !node.babylonNode && !gltfRuntime.importOnlyMeshes) {
  890. var camera = gltfRuntime.cameras[node.camera];
  891. if (camera) {
  892. if (camera.type === "orthographic") {
  893. var orthographicCamera = camera[camera.type];
  894. var orthoCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene);
  895. orthoCamera.name = node.name;
  896. orthoCamera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;
  897. orthoCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
  898. lastNode = orthoCamera;
  899. }
  900. else if (camera.type === "perspective") {
  901. var perspectiveCamera = camera[camera.type];
  902. var persCamera = new BABYLON.FreeCamera(node.camera, BABYLON.Vector3.Zero(), gltfRuntime.scene);
  903. persCamera.name = node.name;
  904. persCamera.attachControl(gltfRuntime.scene.getEngine().getRenderingCanvas());
  905. if (!perspectiveCamera.aspectRatio) {
  906. perspectiveCamera.aspectRatio = gltfRuntime.scene.getEngine().getRenderWidth() / gltfRuntime.scene.getEngine().getRenderHeight();
  907. }
  908. if (perspectiveCamera.znear && perspectiveCamera.zfar) {
  909. persCamera.maxZ = perspectiveCamera.zfar;
  910. persCamera.minZ = perspectiveCamera.znear;
  911. }
  912. lastNode = persCamera;
  913. }
  914. }
  915. }
  916. // Empty node
  917. if (!node.jointName) {
  918. if (node.babylonNode) {
  919. return node.babylonNode;
  920. }
  921. else if (lastNode === null) {
  922. var dummy = new BABYLON.Mesh(node.name, gltfRuntime.scene);
  923. node.babylonNode = dummy;
  924. lastNode = dummy;
  925. }
  926. }
  927. if (lastNode !== null) {
  928. if (node.matrix) {
  929. configureNodeFromMatrix(lastNode, node);
  930. }
  931. else {
  932. configureNode(lastNode, BABYLON.Vector3.FromArray(node.translation), BABYLON.Quaternion.RotationAxis(BABYLON.Vector3.FromArray(node.rotation).normalize(), node.rotation[3]), BABYLON.Vector3.FromArray(node.scale));
  933. }
  934. lastNode.updateCache(true);
  935. node.babylonNode = lastNode;
  936. }
  937. return lastNode;
  938. };
  939. /**
  940. * Traverses nodes and creates them
  941. */
  942. var traverseNodes = function (gltfRuntime, id, parent, meshIncluded) {
  943. var node = gltfRuntime.nodes[id];
  944. var newNode = null;
  945. if (gltfRuntime.importOnlyMeshes && !meshIncluded) {
  946. if (gltfRuntime.importMeshesNames.indexOf(node.name) !== -1 || gltfRuntime.importMeshesNames.length === 0) {
  947. meshIncluded = true;
  948. }
  949. else {
  950. meshIncluded = false;
  951. }
  952. }
  953. else {
  954. meshIncluded = true;
  955. }
  956. if (!node.jointName && meshIncluded) {
  957. newNode = importNode(gltfRuntime, node, id);
  958. if (newNode !== null) {
  959. newNode.id = id;
  960. newNode.parent = parent;
  961. }
  962. }
  963. for (var i = 0; i < node.children.length; i++) {
  964. traverseNodes(gltfRuntime, node.children[i], newNode, meshIncluded);
  965. }
  966. };
  967. /**
  968. * Buffers loaded, create nodes
  969. */
  970. var onBuffersLoaded = function (gltfRuntime) {
  971. // Nodes
  972. var currentScene = gltfRuntime.currentScene;
  973. for (var i = 0; i < currentScene.nodes.length; i++) {
  974. traverseNodes(gltfRuntime, currentScene.nodes[i], null);
  975. }
  976. // Set animations
  977. loadAnimations(gltfRuntime);
  978. for (var i = 0; i < gltfRuntime.scene.skeletons.length; i++) {
  979. var skeleton = gltfRuntime.scene.skeletons[i];
  980. gltfRuntime.scene.beginAnimation(skeleton, 0, Number.MAX_VALUE, true, 1.0);
  981. }
  982. };
  983. /**
  984. * On a buffer is loaded
  985. */
  986. var onLoadBuffer = function (gltfRuntime, buf) {
  987. return function (data) {
  988. gltfRuntime.loadedBuffers++;
  989. if (!(data instanceof ArrayBuffer)) {
  990. BABYLON.Tools.Error("Buffer named " + buf + " is not an array buffer");
  991. }
  992. else if (data.byteLength != gltfRuntime.buffers[buf].byteLength) {
  993. BABYLON.Tools.Error("Buffer named " + buf + " is length " + data.byteLength + ". Expected: " + gltfRuntime.buffers[buf].byteLength); // Improve error message
  994. }
  995. gltfRuntime.arrayBuffers[buf] = data;
  996. if (gltfRuntime.loadedBuffers === gltfRuntime.buffersCount) {
  997. onBuffersLoaded(gltfRuntime);
  998. }
  999. };
  1000. };
  1001. /**
  1002. * Error when loaded buffer
  1003. */
  1004. var onLoadBufferError = function (gltfRuntime, buf) {
  1005. return function () {
  1006. BABYLON.Tools.Error("Error when loading buffer named " + buf + " located at " + gltfRuntime.buffers[buf].uri);
  1007. };
  1008. };
  1009. /**
  1010. * Decode array buffer from base64
  1011. */
  1012. var decodeArrayBuffer = function (base64) {
  1013. var decodedString = atob(base64);
  1014. var bufferLength = decodedString.length;
  1015. var arraybuffer = new Uint8Array(new ArrayBuffer(bufferLength));
  1016. for (var i = 0; i < bufferLength; i++) {
  1017. arraybuffer[i] = decodedString.charCodeAt(i);
  1018. }
  1019. return arraybuffer.buffer;
  1020. };
  1021. /**
  1022. * Loads buffers (geometries)
  1023. */
  1024. var loadBuffers = function (gltfRuntime) {
  1025. for (var buf in gltfRuntime.buffers) {
  1026. var buffer = gltfRuntime.buffers[buf];
  1027. if (buffer) {
  1028. if (isBase64(buffer.uri)) {
  1029. var arrayBuffer = decodeArrayBuffer(buffer.uri.split(",")[1]);
  1030. onLoadBuffer(gltfRuntime, buf)(arrayBuffer);
  1031. }
  1032. else {
  1033. BABYLON.Tools.LoadFile(gltfRuntime.rootUrl + buffer.uri, onLoadBuffer(gltfRuntime, buf), null, null, true, onLoadBufferError(gltfRuntime, buf));
  1034. }
  1035. }
  1036. else {
  1037. BABYLON.Tools.Error("No buffer named : " + buf);
  1038. }
  1039. }
  1040. };
  1041. /**
  1042. * onBind shaderrs callback to set uniforms and matrices
  1043. */
  1044. var onBindShaderMaterial = function (mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material) {
  1045. for (var unif in unTreatedUniforms) {
  1046. var uniform = unTreatedUniforms[unif];
  1047. var type = uniform.type;
  1048. if (type === EParameterType.FLOAT_MAT2 || type === EParameterType.FLOAT_MAT3 || type === EParameterType.FLOAT_MAT4) {
  1049. if (uniform.semantic && !uniform.source && !uniform.node) {
  1050. setMatrix(gltfRuntime.scene, mesh, uniform, unif, shaderMaterial.getEffect());
  1051. }
  1052. else if (uniform.semantic && (uniform.source || uniform.node)) {
  1053. var source = gltfRuntime.scene.getNodeByName(uniform.source || uniform.node);
  1054. if (source === null) {
  1055. source = gltfRuntime.scene.getNodeByID(uniform.source || uniform.node);
  1056. }
  1057. if (source === null) {
  1058. continue;
  1059. }
  1060. setMatrix(gltfRuntime.scene, source, uniform, unif, shaderMaterial.getEffect());
  1061. }
  1062. }
  1063. else {
  1064. var value = material.values[technique.uniforms[unif]];
  1065. if (!value) {
  1066. continue;
  1067. }
  1068. if (type === EParameterType.SAMPLER_2D) {
  1069. var texture = gltfRuntime.textures[value].babylonTexture;
  1070. if (texture === null) {
  1071. continue;
  1072. }
  1073. shaderMaterial.getEffect().setTexture(unif, texture);
  1074. }
  1075. else {
  1076. setUniform(shaderMaterial.getEffect(), unif, value, type);
  1077. }
  1078. }
  1079. }
  1080. };
  1081. /**
  1082. * Prepare uniforms to send the only one time
  1083. * Loads the appropriate textures
  1084. */
  1085. var prepareShaderMaterialUniforms = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
  1086. var materialValues = material.values;
  1087. var techniqueUniforms = technique.uniforms;
  1088. /**
  1089. * Prepare values here (not matrices)
  1090. */
  1091. for (var unif in unTreatedUniforms) {
  1092. var uniform = unTreatedUniforms[unif];
  1093. var type = uniform.type;
  1094. var value = materialValues[techniqueUniforms[unif]] || uniform.value;
  1095. if (!value) {
  1096. continue;
  1097. }
  1098. // Texture (sampler2D)
  1099. if (type === EParameterType.SAMPLER_2D) {
  1100. var texture = gltfRuntime.textures[value];
  1101. var sampler = gltfRuntime.samplers[texture.sampler];
  1102. if (!texture || !texture.source) {
  1103. continue;
  1104. }
  1105. var source = gltfRuntime.images[texture.source];
  1106. var newTexture = null;
  1107. var createMipMaps = (sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_NEAREST) ||
  1108. (sampler.minFilter === ETextureFilterType.NEAREST_MIPMAP_LINEAR) ||
  1109. (sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_NEAREST) ||
  1110. (sampler.minFilter === ETextureFilterType.LINEAR_MIPMAP_LINEAR);
  1111. var samplingMode = BABYLON.Texture.BILINEAR_SAMPLINGMODE;
  1112. if (isBase64(source.uri)) {
  1113. newTexture = new BABYLON.Texture(source.uri, gltfRuntime.scene, !createMipMaps, true, samplingMode, null, null, source.uri, true);
  1114. }
  1115. else {
  1116. newTexture = new BABYLON.Texture(gltfRuntime.rootUrl + source.uri, gltfRuntime.scene, !createMipMaps, true, samplingMode);
  1117. }
  1118. newTexture.wrapU = getWrapMode(sampler.wrapS);
  1119. newTexture.wrapV = getWrapMode(sampler.wrapT);
  1120. newTexture.name = value;
  1121. texture.babylonTexture = newTexture;
  1122. if (uniform.value) {
  1123. // Static uniform
  1124. shaderMaterial.setTexture(unif, newTexture);
  1125. delete unTreatedUniforms[unif];
  1126. }
  1127. }
  1128. else {
  1129. if (uniform.value && setUniform(shaderMaterial, unif, value, type)) {
  1130. // Static uniform
  1131. delete unTreatedUniforms[unif];
  1132. }
  1133. }
  1134. }
  1135. };
  1136. /**
  1137. * Shader compilation failed
  1138. */
  1139. var onShaderCompileError = function (program, shaderMaterial) {
  1140. return function (effect, error) {
  1141. BABYLON.Tools.Error("Cannot compile program named " + program.name + ". Error: " + error + ". Default material will be applied");
  1142. shaderMaterial.dispose(true);
  1143. };
  1144. };
  1145. /**
  1146. * Shader compilation success
  1147. */
  1148. var onShaderCompileSuccess = function (gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms) {
  1149. return function (_) {
  1150. prepareShaderMaterialUniforms(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
  1151. shaderMaterial.onBind = function (mat, mesh) {
  1152. onBindShaderMaterial(mesh, gltfRuntime, unTreatedUniforms, shaderMaterial, technique, material);
  1153. };
  1154. };
  1155. };
  1156. /**
  1157. * Returns the appropriate uniform if already handled by babylon
  1158. */
  1159. var parseShaderUniforms = function (tokenizer, technique, unTreatedUniforms) {
  1160. for (var unif in technique.uniforms) {
  1161. var uniform = technique.uniforms[unif];
  1162. var uniformParameter = technique.parameters[uniform];
  1163. if (tokenizer.currentIdentifier === unif) {
  1164. if (uniformParameter.semantic && !uniformParameter.source && !uniformParameter.node) {
  1165. var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
  1166. if (transformIndex !== -1) {
  1167. delete unTreatedUniforms[unif];
  1168. return babylonTransforms[transformIndex];
  1169. }
  1170. }
  1171. }
  1172. }
  1173. return tokenizer.currentIdentifier;
  1174. };
  1175. /**
  1176. * All shaders loaded. Create materials one by one
  1177. */
  1178. var onShadersLoaded = function (gltfRuntime) {
  1179. // Create materials
  1180. for (var mat in gltfRuntime.materials) {
  1181. var material = gltfRuntime.materials[mat];
  1182. var technique = gltfRuntime.techniques[material.technique];
  1183. var program = gltfRuntime.programs[technique.program];
  1184. var states = technique.states;
  1185. var vertexShader = BABYLON.Effect.ShadersStore[program.vertexShader + "VertexShader"];
  1186. var pixelShader = BABYLON.Effect.ShadersStore[program.fragmentShader + "PixelShader"];
  1187. var newVertexShader = "";
  1188. var newPixelShader = "";
  1189. var vertexTokenizer = new Tokenizer(vertexShader);
  1190. var pixelTokenizer = new Tokenizer(pixelShader);
  1191. var unTreatedUniforms = {};
  1192. var uniforms = [];
  1193. var attributes = [];
  1194. var samplers = [];
  1195. // Fill uniform, sampler2D and attributes
  1196. for (var unif in technique.uniforms) {
  1197. var uniform = technique.uniforms[unif];
  1198. var uniformParameter = technique.parameters[uniform];
  1199. unTreatedUniforms[unif] = uniformParameter;
  1200. if (uniformParameter.semantic && !uniformParameter.node && !uniformParameter.source) {
  1201. var transformIndex = glTFTransforms.indexOf(uniformParameter.semantic);
  1202. if (transformIndex !== -1) {
  1203. uniforms.push(babylonTransforms[transformIndex]);
  1204. delete unTreatedUniforms[unif];
  1205. }
  1206. else {
  1207. uniforms.push(unif);
  1208. }
  1209. }
  1210. else if (uniformParameter.type === EParameterType.SAMPLER_2D) {
  1211. samplers.push(unif);
  1212. }
  1213. else {
  1214. uniforms.push(unif);
  1215. }
  1216. }
  1217. for (var attr in technique.attributes) {
  1218. var attribute = technique.attributes[attr];
  1219. var attributeParameter = technique.parameters[attribute];
  1220. if (attributeParameter.semantic) {
  1221. attributes.push(getAttribute(attributeParameter));
  1222. }
  1223. }
  1224. // Configure vertex shader
  1225. while (!vertexTokenizer.isEnd() && vertexTokenizer.getNextToken()) {
  1226. var tokenType = vertexTokenizer.currentToken;
  1227. if (tokenType !== ETokenType.IDENTIFIER) {
  1228. newVertexShader += vertexTokenizer.currentString;
  1229. continue;
  1230. }
  1231. var foundAttribute = false;
  1232. for (var attr in technique.attributes) {
  1233. var attribute = technique.attributes[attr];
  1234. var attributeParameter = technique.parameters[attribute];
  1235. if (vertexTokenizer.currentIdentifier === attr && attributeParameter.semantic) {
  1236. newVertexShader += getAttribute(attributeParameter);
  1237. foundAttribute = true;
  1238. break;
  1239. }
  1240. }
  1241. if (foundAttribute) {
  1242. continue;
  1243. }
  1244. newVertexShader += parseShaderUniforms(vertexTokenizer, technique, unTreatedUniforms);
  1245. }
  1246. // Configure pixel shader
  1247. while (!pixelTokenizer.isEnd() && pixelTokenizer.getNextToken()) {
  1248. var tokenType = pixelTokenizer.currentToken;
  1249. if (tokenType !== ETokenType.IDENTIFIER) {
  1250. newPixelShader += pixelTokenizer.currentString;
  1251. continue;
  1252. }
  1253. newPixelShader += parseShaderUniforms(pixelTokenizer, technique, unTreatedUniforms);
  1254. }
  1255. // Create shader material
  1256. var shaderPath = {
  1257. vertex: program.vertexShader,
  1258. fragment: program.fragmentShader
  1259. };
  1260. var options = {
  1261. attributes: attributes,
  1262. uniforms: uniforms,
  1263. samplers: samplers,
  1264. needAlphaBlending: states.functions && states.functions.blendEquationSeparate
  1265. };
  1266. BABYLON.Effect.ShadersStore[program.vertexShader + "VertexShader"] = newVertexShader;
  1267. BABYLON.Effect.ShadersStore[program.fragmentShader + "PixelShader"] = newPixelShader;
  1268. var shaderMaterial = new BABYLON.ShaderMaterial(material.name, gltfRuntime.scene, shaderPath, options);
  1269. shaderMaterial.id = mat;
  1270. shaderMaterial.onError = onShaderCompileError(program, shaderMaterial);
  1271. shaderMaterial.onCompiled = onShaderCompileSuccess(gltfRuntime, shaderMaterial, technique, material, unTreatedUniforms);
  1272. if (states.functions) {
  1273. var functions = states.functions;
  1274. if (functions.cullFace && functions.cullFace[0] !== ECullingType.BACK) {
  1275. shaderMaterial.backFaceCulling = false;
  1276. }
  1277. var blendFunc = functions.blendFuncSeparate;
  1278. if (blendFunc) {
  1279. if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_ALPHA && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
  1280. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_COMBINE;
  1281. }
  1282. else if (blendFunc[0] === EBlendingFunction.ONE && blendFunc[1] === EBlendingFunction.ONE && blendFunc[2] === EBlendingFunction.ZERO && blendFunc[3] === EBlendingFunction.ONE) {
  1283. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ONEONE;
  1284. }
  1285. else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE && blendFunc[2] === EBlendingFunction.ZERO && blendFunc[3] === EBlendingFunction.ONE) {
  1286. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_ADD;
  1287. }
  1288. else if (blendFunc[0] === EBlendingFunction.ZERO && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
  1289. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_SUBTRACT;
  1290. }
  1291. else if (blendFunc[0] === EBlendingFunction.DST_COLOR && blendFunc[1] === EBlendingFunction.ZERO && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
  1292. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MULTIPLY;
  1293. }
  1294. else if (blendFunc[0] === EBlendingFunction.SRC_ALPHA && blendFunc[1] === EBlendingFunction.ONE_MINUS_SRC_COLOR && blendFunc[2] === EBlendingFunction.ONE && blendFunc[3] === EBlendingFunction.ONE) {
  1295. shaderMaterial.alphaMode = BABYLON.Engine.ALPHA_MAXIMIZED;
  1296. }
  1297. }
  1298. }
  1299. }
  1300. // Finish
  1301. loadBuffers(gltfRuntime);
  1302. };
  1303. /**
  1304. * Shader loaded
  1305. */
  1306. var onLoadShader = function (gltfRuntime, sha) {
  1307. return function (data) {
  1308. gltfRuntime.loadedShaders++;
  1309. BABYLON.Effect.ShadersStore[sha + (gltfRuntime.shaders[sha].type === EShaderType.VERTEX ? "VertexShader" : "PixelShader")] = data;
  1310. if (gltfRuntime.loadedShaders === gltfRuntime.shaderscount) {
  1311. onShadersLoaded(gltfRuntime);
  1312. }
  1313. };
  1314. };
  1315. /**
  1316. * Error callback when loading a shader
  1317. */
  1318. var onLoadShaderError = function (gltfRuntime, sha) {
  1319. return function () {
  1320. BABYLON.Tools.Error("Error when loading shader program named " + sha + " located at " + gltfRuntime.shaders[sha].uri);
  1321. };
  1322. };
  1323. /**
  1324. * Load shaders
  1325. */
  1326. var load = function (gltfRuntime) {
  1327. // Begin with shaders
  1328. for (var sha in gltfRuntime.shaders) {
  1329. var shader = gltfRuntime.shaders[sha];
  1330. if (shader) {
  1331. if (isBase64(shader.uri)) {
  1332. var shaderString = atob(shader.uri.split(",")[1]);
  1333. onLoadShader(gltfRuntime, sha)(shaderString);
  1334. }
  1335. else {
  1336. BABYLON.Tools.LoadFile(gltfRuntime.rootUrl + shader.uri, onLoadShader(gltfRuntime, sha), null, null, false, onLoadShaderError(gltfRuntime, sha));
  1337. }
  1338. }
  1339. else {
  1340. BABYLON.Tools.Error("No shader file named " + shader.uri);
  1341. }
  1342. }
  1343. };
  1344. /**
  1345. * glTF File Loader Plugin
  1346. */
  1347. var GLTFFileLoader = (function () {
  1348. function GLTFFileLoader() {
  1349. /**
  1350. * Public members
  1351. */
  1352. this.extensions = ".gltf";
  1353. }
  1354. /**
  1355. * Private members
  1356. */
  1357. // None
  1358. /**
  1359. * Import meshes
  1360. */
  1361. GLTFFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
  1362. var parsedData = JSON.parse(data);
  1363. var gltfRuntime = this._createGlTFRuntime(parsedData, scene, rootUrl);
  1364. gltfRuntime.importOnlyMeshes = true;
  1365. if (meshesNames === "") {
  1366. gltfRuntime.importMeshesNames = [];
  1367. }
  1368. else if (typeof meshesNames === "string") {
  1369. gltfRuntime.importMeshesNames = [meshesNames];
  1370. }
  1371. else if (meshesNames && !(meshesNames instanceof Array)) {
  1372. gltfRuntime.importMeshesNames = [meshesNames];
  1373. }
  1374. else {
  1375. gltfRuntime.importMeshesNames = [];
  1376. BABYLON.Tools.Warn("Argument meshesNames must be of type string or string[]");
  1377. }
  1378. // Create nodes
  1379. this._createNodes(gltfRuntime);
  1380. // Fill arrays of meshes and skeletons
  1381. for (var nde in gltfRuntime.nodes) {
  1382. var node = gltfRuntime.nodes[nde];
  1383. if (node.babylonNode instanceof BABYLON.AbstractMesh) {
  1384. meshes.push(node.babylonNode);
  1385. }
  1386. }
  1387. for (var skl in gltfRuntime.skins) {
  1388. var skin = gltfRuntime.skins[skl];
  1389. if (skin.babylonSkeleton instanceof BABYLON.Skeleton) {
  1390. skeletons.push(skin.babylonSkeleton);
  1391. }
  1392. }
  1393. // Load shaders and buffers to apply
  1394. load(gltfRuntime);
  1395. return true;
  1396. };
  1397. /**
  1398. * Load scene
  1399. */
  1400. GLTFFileLoader.prototype.load = function (scene, data, rootUrl) {
  1401. var parsedData = JSON.parse(data);
  1402. var gltfRuntime = this._createGlTFRuntime(parsedData, scene, rootUrl);
  1403. // Create nodes
  1404. this._createNodes(gltfRuntime);
  1405. // Load shaders and buffers to apply
  1406. load(gltfRuntime);
  1407. // Finish
  1408. return true;
  1409. };
  1410. // Creates nodes before loading buffers and shaders
  1411. GLTFFileLoader.prototype._createNodes = function (gltfRuntime) {
  1412. var currentScene = gltfRuntime.currentScene;
  1413. for (var i = 0; i < currentScene.nodes.length; i++) {
  1414. traverseNodes(gltfRuntime, currentScene.nodes[i], null);
  1415. }
  1416. };
  1417. // Creates the gltfRuntime
  1418. GLTFFileLoader.prototype._createGlTFRuntime = function (parsedData, scene, rootUrl) {
  1419. var gltfRuntime = {
  1420. accessors: {},
  1421. buffers: {},
  1422. bufferViews: {},
  1423. meshes: {},
  1424. lights: {},
  1425. cameras: {},
  1426. nodes: {},
  1427. images: {},
  1428. textures: {},
  1429. shaders: {},
  1430. programs: {},
  1431. samplers: {},
  1432. techniques: {},
  1433. materials: {},
  1434. animations: {},
  1435. skins: {},
  1436. currentScene: {},
  1437. buffersCount: 0,
  1438. shaderscount: 0,
  1439. scene: scene,
  1440. dummyNodes: [],
  1441. loadedBuffers: 0,
  1442. loadedShaders: 0,
  1443. rootUrl: rootUrl,
  1444. importOnlyMeshes: false,
  1445. arrayBuffers: []
  1446. };
  1447. // Parse
  1448. if (parsedData.buffers) {
  1449. parseBuffers(parsedData.buffers, gltfRuntime);
  1450. }
  1451. if (parsedData.bufferViews) {
  1452. parseObject(parsedData.bufferViews, "bufferViews", gltfRuntime);
  1453. }
  1454. if (parsedData.accessors) {
  1455. parseObject(parsedData.accessors, "accessors", gltfRuntime);
  1456. }
  1457. if (parsedData.meshes) {
  1458. parseObject(parsedData.meshes, "meshes", gltfRuntime);
  1459. }
  1460. if (parsedData.lights) {
  1461. parseObject(parsedData.lights, "lights", gltfRuntime);
  1462. }
  1463. if (parsedData.cameras) {
  1464. parseObject(parsedData.cameras, "cameras", gltfRuntime);
  1465. }
  1466. if (parsedData.nodes) {
  1467. parseObject(parsedData.nodes, "nodes", gltfRuntime);
  1468. }
  1469. if (parsedData.images) {
  1470. parseObject(parsedData.images, "images", gltfRuntime);
  1471. }
  1472. if (parsedData.textures) {
  1473. parseObject(parsedData.textures, "textures", gltfRuntime);
  1474. }
  1475. if (parsedData.shaders) {
  1476. parseShaders(parsedData.shaders, gltfRuntime);
  1477. }
  1478. if (parsedData.programs) {
  1479. parseObject(parsedData.programs, "programs", gltfRuntime);
  1480. }
  1481. if (parsedData.samplers) {
  1482. parseObject(parsedData.samplers, "samplers", gltfRuntime);
  1483. }
  1484. if (parsedData.techniques) {
  1485. parseObject(parsedData.techniques, "techniques", gltfRuntime);
  1486. }
  1487. if (parsedData.materials) {
  1488. parseObject(parsedData.materials, "materials", gltfRuntime);
  1489. }
  1490. if (parsedData.animations) {
  1491. parseObject(parsedData.animations, "animations", gltfRuntime);
  1492. }
  1493. if (parsedData.skins) {
  1494. parseObject(parsedData.skins, "skins", gltfRuntime);
  1495. }
  1496. if (parsedData.scene && parsedData.scenes) {
  1497. gltfRuntime.currentScene = parsedData.scenes[parsedData.scene];
  1498. }
  1499. return gltfRuntime;
  1500. };
  1501. return GLTFFileLoader;
  1502. })();
  1503. BABYLON.GLTFFileLoader = GLTFFileLoader;
  1504. ;
  1505. BABYLON.SceneLoader.RegisterPlugin(new GLTFFileLoader());
  1506. })(BABYLON || (BABYLON = {}));