babylon.babylonFileLoader.js 67 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263
  1. var BABYLON;
  2. (function (BABYLON) {
  3. var Internals;
  4. (function (Internals) {
  5. var checkColors4 = function (colors, count) {
  6. // Check if color3 was used
  7. if (colors.length === count * 3) {
  8. var colors4 = [];
  9. for (var index = 0; index < colors.length; index += 3) {
  10. var newIndex = (index / 3) * 4;
  11. colors4[newIndex] = colors[index];
  12. colors4[newIndex + 1] = colors[index + 1];
  13. colors4[newIndex + 2] = colors[index + 2];
  14. colors4[newIndex + 3] = 1.0;
  15. }
  16. return colors4;
  17. }
  18. return colors;
  19. };
  20. var loadCubeTexture = function (rootUrl, parsedTexture, scene) {
  21. var texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene);
  22. texture.name = parsedTexture.name;
  23. texture.hasAlpha = parsedTexture.hasAlpha;
  24. texture.level = parsedTexture.level;
  25. texture.coordinatesMode = parsedTexture.coordinatesMode;
  26. return texture;
  27. };
  28. var loadTexture = function (rootUrl, parsedTexture, scene) {
  29. if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
  30. return null;
  31. }
  32. if (parsedTexture.isCube) {
  33. return loadCubeTexture(rootUrl, parsedTexture, scene);
  34. }
  35. var texture;
  36. if (parsedTexture.mirrorPlane) {
  37. texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  38. texture._waitingRenderList = parsedTexture.renderList;
  39. texture.mirrorPlane = BABYLON.Plane.FromArray(parsedTexture.mirrorPlane);
  40. }
  41. else if (parsedTexture.isRenderTarget) {
  42. texture = new BABYLON.RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  43. texture._waitingRenderList = parsedTexture.renderList;
  44. }
  45. else {
  46. texture = new BABYLON.Texture(rootUrl + parsedTexture.name, scene);
  47. }
  48. texture.name = parsedTexture.name;
  49. texture.hasAlpha = parsedTexture.hasAlpha;
  50. texture.getAlphaFromRGB = parsedTexture.getAlphaFromRGB;
  51. texture.level = parsedTexture.level;
  52. texture.coordinatesIndex = parsedTexture.coordinatesIndex;
  53. texture.coordinatesMode = parsedTexture.coordinatesMode;
  54. texture.uOffset = parsedTexture.uOffset;
  55. texture.vOffset = parsedTexture.vOffset;
  56. texture.uScale = parsedTexture.uScale;
  57. texture.vScale = parsedTexture.vScale;
  58. texture.uAng = parsedTexture.uAng;
  59. texture.vAng = parsedTexture.vAng;
  60. texture.wAng = parsedTexture.wAng;
  61. texture.wrapU = parsedTexture.wrapU;
  62. texture.wrapV = parsedTexture.wrapV;
  63. // Animations
  64. if (parsedTexture.animations) {
  65. for (var animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
  66. var parsedAnimation = parsedTexture.animations[animationIndex];
  67. texture.animations.push(parseAnimation(parsedAnimation));
  68. }
  69. }
  70. return texture;
  71. };
  72. var parseSkeleton = function (parsedSkeleton, scene) {
  73. var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
  74. for (var index = 0; index < parsedSkeleton.bones.length; index++) {
  75. var parsedBone = parsedSkeleton.bones[index];
  76. var parentBone = null;
  77. if (parsedBone.parentBoneIndex > -1) {
  78. parentBone = skeleton.bones[parsedBone.parentBoneIndex];
  79. }
  80. var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
  81. if (parsedBone.animation) {
  82. bone.animations.push(parseAnimation(parsedBone.animation));
  83. }
  84. }
  85. return skeleton;
  86. };
  87. var parseFresnelParameters = function (parsedFresnelParameters) {
  88. var fresnelParameters = new BABYLON.FresnelParameters();
  89. fresnelParameters.isEnabled = parsedFresnelParameters.isEnabled;
  90. fresnelParameters.leftColor = BABYLON.Color3.FromArray(parsedFresnelParameters.leftColor);
  91. fresnelParameters.rightColor = BABYLON.Color3.FromArray(parsedFresnelParameters.rightColor);
  92. fresnelParameters.bias = parsedFresnelParameters.bias;
  93. fresnelParameters.power = parsedFresnelParameters.power || 1.0;
  94. return fresnelParameters;
  95. };
  96. var parseMaterial = function (parsedMaterial, scene, rootUrl) {
  97. var material;
  98. material = new BABYLON.StandardMaterial(parsedMaterial.name, scene);
  99. material.ambientColor = BABYLON.Color3.FromArray(parsedMaterial.ambient);
  100. material.diffuseColor = BABYLON.Color3.FromArray(parsedMaterial.diffuse);
  101. material.specularColor = BABYLON.Color3.FromArray(parsedMaterial.specular);
  102. material.specularPower = parsedMaterial.specularPower;
  103. material.emissiveColor = BABYLON.Color3.FromArray(parsedMaterial.emissive);
  104. material.alpha = parsedMaterial.alpha;
  105. material.id = parsedMaterial.id;
  106. BABYLON.Tags.AddTagsTo(material, parsedMaterial.tags);
  107. material.backFaceCulling = parsedMaterial.backFaceCulling;
  108. material.wireframe = parsedMaterial.wireframe;
  109. if (parsedMaterial.diffuseTexture) {
  110. material.diffuseTexture = loadTexture(rootUrl, parsedMaterial.diffuseTexture, scene);
  111. }
  112. if (parsedMaterial.diffuseFresnelParameters) {
  113. material.diffuseFresnelParameters = parseFresnelParameters(parsedMaterial.diffuseFresnelParameters);
  114. }
  115. if (parsedMaterial.ambientTexture) {
  116. material.ambientTexture = loadTexture(rootUrl, parsedMaterial.ambientTexture, scene);
  117. }
  118. if (parsedMaterial.opacityTexture) {
  119. material.opacityTexture = loadTexture(rootUrl, parsedMaterial.opacityTexture, scene);
  120. }
  121. if (parsedMaterial.opacityFresnelParameters) {
  122. material.opacityFresnelParameters = parseFresnelParameters(parsedMaterial.opacityFresnelParameters);
  123. }
  124. if (parsedMaterial.reflectionTexture) {
  125. material.reflectionTexture = loadTexture(rootUrl, parsedMaterial.reflectionTexture, scene);
  126. }
  127. if (parsedMaterial.reflectionFresnelParameters) {
  128. material.reflectionFresnelParameters = parseFresnelParameters(parsedMaterial.reflectionFresnelParameters);
  129. }
  130. if (parsedMaterial.emissiveTexture) {
  131. material.emissiveTexture = loadTexture(rootUrl, parsedMaterial.emissiveTexture, scene);
  132. }
  133. if (parsedMaterial.emissiveFresnelParameters) {
  134. material.emissiveFresnelParameters = parseFresnelParameters(parsedMaterial.emissiveFresnelParameters);
  135. }
  136. if (parsedMaterial.specularTexture) {
  137. material.specularTexture = loadTexture(rootUrl, parsedMaterial.specularTexture, scene);
  138. }
  139. if (parsedMaterial.bumpTexture) {
  140. material.bumpTexture = loadTexture(rootUrl, parsedMaterial.bumpTexture, scene);
  141. }
  142. return material;
  143. };
  144. var parseMaterialById = function (id, parsedData, scene, rootUrl) {
  145. for (var index = 0; index < parsedData.materials.length; index++) {
  146. var parsedMaterial = parsedData.materials[index];
  147. if (parsedMaterial.id === id) {
  148. return parseMaterial(parsedMaterial, scene, rootUrl);
  149. }
  150. }
  151. return null;
  152. };
  153. var parseMultiMaterial = function (parsedMultiMaterial, scene) {
  154. var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
  155. multiMaterial.id = parsedMultiMaterial.id;
  156. BABYLON.Tags.AddTagsTo(multiMaterial, parsedMultiMaterial.tags);
  157. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  158. var subMatId = parsedMultiMaterial.materials[matIndex];
  159. if (subMatId) {
  160. multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
  161. }
  162. else {
  163. multiMaterial.subMaterials.push(null);
  164. }
  165. }
  166. return multiMaterial;
  167. };
  168. var parseLensFlareSystem = function (parsedLensFlareSystem, scene, rootUrl) {
  169. var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
  170. var lensFlareSystem = new BABYLON.LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
  171. lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
  172. for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
  173. var parsedFlare = parsedLensFlareSystem.flares[index];
  174. var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
  175. }
  176. return lensFlareSystem;
  177. };
  178. var parseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
  179. var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
  180. var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
  181. if (parsedParticleSystem.textureName) {
  182. particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
  183. particleSystem.particleTexture.name = parsedParticleSystem.textureName;
  184. }
  185. particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
  186. particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
  187. particleSystem.minSize = parsedParticleSystem.minSize;
  188. particleSystem.maxSize = parsedParticleSystem.maxSize;
  189. particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
  190. particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
  191. particleSystem.emitter = emitter;
  192. particleSystem.emitRate = parsedParticleSystem.emitRate;
  193. particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
  194. particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
  195. particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
  196. particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
  197. particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
  198. particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
  199. particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
  200. particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
  201. particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
  202. particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
  203. particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
  204. particleSystem.blendMode = parsedParticleSystem.blendMode;
  205. particleSystem.start();
  206. return particleSystem;
  207. };
  208. var parseShadowGenerator = function (parsedShadowGenerator, scene) {
  209. var light = scene.getLightByID(parsedShadowGenerator.lightId);
  210. var shadowGenerator = new BABYLON.ShadowGenerator(parsedShadowGenerator.mapSize, light);
  211. for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
  212. var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
  213. shadowGenerator.getShadowMap().renderList.push(mesh);
  214. }
  215. if (parsedShadowGenerator.usePoissonSampling) {
  216. shadowGenerator.usePoissonSampling = true;
  217. }
  218. else if (parsedShadowGenerator.useVarianceShadowMap) {
  219. shadowGenerator.useVarianceShadowMap = true;
  220. }
  221. else if (parsedShadowGenerator.useBlurVarianceShadowMap) {
  222. shadowGenerator.useBlurVarianceShadowMap = true;
  223. if (parsedShadowGenerator.blurScale) {
  224. shadowGenerator.blurScale = parsedShadowGenerator.blurScale;
  225. }
  226. if (parsedShadowGenerator.blurBoxOffset) {
  227. shadowGenerator.blurBoxOffset = parsedShadowGenerator.blurBoxOffset;
  228. }
  229. }
  230. if (parsedShadowGenerator.bias !== undefined) {
  231. shadowGenerator.bias = parsedShadowGenerator.bias;
  232. }
  233. return shadowGenerator;
  234. };
  235. var parseAnimation = function (parsedAnimation) {
  236. var animation = new BABYLON.Animation(parsedAnimation.name, parsedAnimation.property, parsedAnimation.framePerSecond, parsedAnimation.dataType, parsedAnimation.loopBehavior);
  237. var dataType = parsedAnimation.dataType;
  238. var keys = [];
  239. for (var index = 0; index < parsedAnimation.keys.length; index++) {
  240. var key = parsedAnimation.keys[index];
  241. var data;
  242. switch (dataType) {
  243. case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
  244. data = key.values[0];
  245. break;
  246. case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
  247. data = BABYLON.Quaternion.FromArray(key.values);
  248. break;
  249. case BABYLON.Animation.ANIMATIONTYPE_MATRIX:
  250. data = BABYLON.Matrix.FromArray(key.values);
  251. break;
  252. case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
  253. default:
  254. data = BABYLON.Vector3.FromArray(key.values);
  255. break;
  256. }
  257. keys.push({
  258. frame: key.frame,
  259. value: data
  260. });
  261. }
  262. animation.setKeys(keys);
  263. return animation;
  264. };
  265. var parseLight = function (parsedLight, scene) {
  266. var light;
  267. switch (parsedLight.type) {
  268. case 0:
  269. light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
  270. break;
  271. case 1:
  272. light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  273. light.position = BABYLON.Vector3.FromArray(parsedLight.position);
  274. break;
  275. case 2:
  276. light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
  277. break;
  278. case 3:
  279. light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  280. light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
  281. break;
  282. }
  283. light.id = parsedLight.id;
  284. BABYLON.Tags.AddTagsTo(light, parsedLight.tags);
  285. if (parsedLight.intensity !== undefined) {
  286. light.intensity = parsedLight.intensity;
  287. }
  288. if (parsedLight.range) {
  289. light.range = parsedLight.range;
  290. }
  291. light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
  292. light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
  293. if (parsedLight.excludedMeshesIds) {
  294. light._excludedMeshesIds = parsedLight.excludedMeshesIds;
  295. }
  296. // Parent
  297. if (parsedLight.parentId) {
  298. light._waitingParentId = parsedLight.parentId;
  299. }
  300. if (parsedLight.includedOnlyMeshesIds) {
  301. light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
  302. }
  303. // Animations
  304. if (parsedLight.animations) {
  305. for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
  306. var parsedAnimation = parsedLight.animations[animationIndex];
  307. light.animations.push(parseAnimation(parsedAnimation));
  308. }
  309. }
  310. if (parsedLight.autoAnimate) {
  311. scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
  312. }
  313. };
  314. var parseCamera = function (parsedCamera, scene) {
  315. var camera;
  316. var position = BABYLON.Vector3.FromArray(parsedCamera.position);
  317. var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
  318. if (parsedCamera.type === "AnaglyphArcRotateCamera" || parsedCamera.type === "ArcRotateCamera") {
  319. var alpha = parsedCamera.alpha;
  320. var beta = parsedCamera.beta;
  321. var radius = parsedCamera.radius;
  322. if (parsedCamera.type === "AnaglyphArcRotateCamera") {
  323. var eye_space = parsedCamera.eye_space;
  324. camera = new BABYLON.AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, eye_space, scene);
  325. }
  326. else {
  327. camera = new BABYLON.ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
  328. }
  329. }
  330. else if (parsedCamera.type === "AnaglyphFreeCamera") {
  331. eye_space = parsedCamera.eye_space;
  332. camera = new BABYLON.AnaglyphFreeCamera(parsedCamera.name, position, eye_space, scene);
  333. }
  334. else if (parsedCamera.type === "DeviceOrientationCamera") {
  335. camera = new BABYLON.DeviceOrientationCamera(parsedCamera.name, position, scene);
  336. }
  337. else if (parsedCamera.type === "FollowCamera") {
  338. camera = new BABYLON.FollowCamera(parsedCamera.name, position, scene);
  339. camera.heightOffset = parsedCamera.heightOffset;
  340. camera.radius = parsedCamera.radius;
  341. camera.rotationOffset = parsedCamera.rotationOffset;
  342. if (lockedTargetMesh)
  343. camera.target = lockedTargetMesh;
  344. }
  345. else if (parsedCamera.type === "GamepadCamera") {
  346. camera = new BABYLON.GamepadCamera(parsedCamera.name, position, scene);
  347. }
  348. else if (parsedCamera.type === "TouchCamera") {
  349. camera = new BABYLON.TouchCamera(parsedCamera.name, position, scene);
  350. }
  351. else if (parsedCamera.type === "VirtualJoysticksCamera") {
  352. camera = new BABYLON.VirtualJoysticksCamera(parsedCamera.name, position, scene);
  353. }
  354. else if (parsedCamera.type === "WebVRCamera") {
  355. camera = new BABYLON.WebVRFreeCamera(parsedCamera.name, position, scene);
  356. }
  357. else if (parsedCamera.type === "VRDeviceOrientationCamera") {
  358. camera = new BABYLON.VRDeviceOrientationFreeCamera(parsedCamera.name, position, scene);
  359. }
  360. else {
  361. // Free Camera is the default value
  362. camera = new BABYLON.FreeCamera(parsedCamera.name, position, scene);
  363. }
  364. // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
  365. if (lockedTargetMesh && camera instanceof BABYLON.FreeCamera) {
  366. camera.lockedTarget = lockedTargetMesh;
  367. }
  368. camera.id = parsedCamera.id;
  369. BABYLON.Tags.AddTagsTo(camera, parsedCamera.tags);
  370. // Parent
  371. if (parsedCamera.parentId) {
  372. camera._waitingParentId = parsedCamera.parentId;
  373. }
  374. // Target
  375. if (parsedCamera.target) {
  376. if (camera.setTarget) {
  377. camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
  378. }
  379. else {
  380. //For ArcRotate
  381. camera.target = BABYLON.Vector3.FromArray(parsedCamera.target);
  382. }
  383. }
  384. else {
  385. camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
  386. }
  387. camera.fov = parsedCamera.fov;
  388. camera.minZ = parsedCamera.minZ;
  389. camera.maxZ = parsedCamera.maxZ;
  390. camera.speed = parsedCamera.speed;
  391. camera.inertia = parsedCamera.inertia;
  392. camera.checkCollisions = parsedCamera.checkCollisions;
  393. camera.applyGravity = parsedCamera.applyGravity;
  394. if (parsedCamera.ellipsoid) {
  395. camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
  396. }
  397. // Animations
  398. if (parsedCamera.animations) {
  399. for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
  400. var parsedAnimation = parsedCamera.animations[animationIndex];
  401. camera.animations.push(parseAnimation(parsedAnimation));
  402. }
  403. }
  404. if (parsedCamera.autoAnimate) {
  405. scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
  406. }
  407. // Layer Mask
  408. if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
  409. camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
  410. }
  411. else {
  412. camera.layerMask = 0xFFFFFFFF;
  413. }
  414. return camera;
  415. };
  416. var parseGeometry = function (parsedGeometry, scene) {
  417. var id = parsedGeometry.id;
  418. return scene.getGeometryByID(id);
  419. };
  420. var parseBox = function (parsedBox, scene) {
  421. if (parseGeometry(parsedBox, scene)) {
  422. return null; // null since geometry could be something else than a box...
  423. }
  424. var box = new BABYLON.Geometry.Primitives.Box(parsedBox.id, scene, parsedBox.size, parsedBox.canBeRegenerated, null);
  425. BABYLON.Tags.AddTagsTo(box, parsedBox.tags);
  426. scene.pushGeometry(box, true);
  427. return box;
  428. };
  429. var parseSphere = function (parsedSphere, scene) {
  430. if (parseGeometry(parsedSphere, scene)) {
  431. return null; // null since geometry could be something else than a sphere...
  432. }
  433. var sphere = new BABYLON.Geometry.Primitives.Sphere(parsedSphere.id, scene, parsedSphere.segments, parsedSphere.diameter, parsedSphere.canBeRegenerated, null);
  434. BABYLON.Tags.AddTagsTo(sphere, parsedSphere.tags);
  435. scene.pushGeometry(sphere, true);
  436. return sphere;
  437. };
  438. var parseCylinder = function (parsedCylinder, scene) {
  439. if (parseGeometry(parsedCylinder, scene)) {
  440. return null; // null since geometry could be something else than a cylinder...
  441. }
  442. var cylinder = new BABYLON.Geometry.Primitives.Cylinder(parsedCylinder.id, scene, parsedCylinder.height, parsedCylinder.diameterTop, parsedCylinder.diameterBottom, parsedCylinder.tessellation, parsedCylinder.subdivisions, parsedCylinder.canBeRegenerated, null);
  443. BABYLON.Tags.AddTagsTo(cylinder, parsedCylinder.tags);
  444. scene.pushGeometry(cylinder, true);
  445. return cylinder;
  446. };
  447. var parseTorus = function (parsedTorus, scene) {
  448. if (parseGeometry(parsedTorus, scene)) {
  449. return null; // null since geometry could be something else than a torus...
  450. }
  451. var torus = new BABYLON.Geometry.Primitives.Torus(parsedTorus.id, scene, parsedTorus.diameter, parsedTorus.thickness, parsedTorus.tessellation, parsedTorus.canBeRegenerated, null);
  452. BABYLON.Tags.AddTagsTo(torus, parsedTorus.tags);
  453. scene.pushGeometry(torus, true);
  454. return torus;
  455. };
  456. var parseGround = function (parsedGround, scene) {
  457. if (parseGeometry(parsedGround, scene)) {
  458. return null; // null since geometry could be something else than a ground...
  459. }
  460. var ground = new BABYLON.Geometry.Primitives.Ground(parsedGround.id, scene, parsedGround.width, parsedGround.height, parsedGround.subdivisions, parsedGround.canBeRegenerated, null);
  461. BABYLON.Tags.AddTagsTo(ground, parsedGround.tags);
  462. scene.pushGeometry(ground, true);
  463. return ground;
  464. };
  465. var parsePlane = function (parsedPlane, scene) {
  466. if (parseGeometry(parsedPlane, scene)) {
  467. return null; // null since geometry could be something else than a plane...
  468. }
  469. var plane = new BABYLON.Geometry.Primitives.Plane(parsedPlane.id, scene, parsedPlane.size, parsedPlane.canBeRegenerated, null);
  470. BABYLON.Tags.AddTagsTo(plane, parsedPlane.tags);
  471. scene.pushGeometry(plane, true);
  472. return plane;
  473. };
  474. var parseTorusKnot = function (parsedTorusKnot, scene) {
  475. if (parseGeometry(parsedTorusKnot, scene)) {
  476. return null; // null since geometry could be something else than a torusKnot...
  477. }
  478. var torusKnot = new BABYLON.Geometry.Primitives.TorusKnot(parsedTorusKnot.id, scene, parsedTorusKnot.radius, parsedTorusKnot.tube, parsedTorusKnot.radialSegments, parsedTorusKnot.tubularSegments, parsedTorusKnot.p, parsedTorusKnot.q, parsedTorusKnot.canBeRegenerated, null);
  479. BABYLON.Tags.AddTagsTo(torusKnot, parsedTorusKnot.tags);
  480. scene.pushGeometry(torusKnot, true);
  481. return torusKnot;
  482. };
  483. var parseVertexData = function (parsedVertexData, scene, rootUrl) {
  484. if (parseGeometry(parsedVertexData, scene)) {
  485. return null; // null since geometry could be a primitive
  486. }
  487. var geometry = new BABYLON.Geometry(parsedVertexData.id, scene);
  488. BABYLON.Tags.AddTagsTo(geometry, parsedVertexData.tags);
  489. if (parsedVertexData.delayLoadingFile) {
  490. geometry.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
  491. geometry.delayLoadingFile = rootUrl + parsedVertexData.delayLoadingFile;
  492. geometry._boundingInfo = new BABYLON.BoundingInfo(BABYLON.Vector3.FromArray(parsedVertexData.boundingBoxMinimum), BABYLON.Vector3.FromArray(parsedVertexData.boundingBoxMaximum));
  493. geometry._delayInfo = [];
  494. if (parsedVertexData.hasUVs) {
  495. geometry._delayInfo.push(BABYLON.VertexBuffer.UVKind);
  496. }
  497. if (parsedVertexData.hasUVs2) {
  498. geometry._delayInfo.push(BABYLON.VertexBuffer.UV2Kind);
  499. }
  500. if (parsedVertexData.hasColors) {
  501. geometry._delayInfo.push(BABYLON.VertexBuffer.ColorKind);
  502. }
  503. if (parsedVertexData.hasMatricesIndices) {
  504. geometry._delayInfo.push(BABYLON.VertexBuffer.MatricesIndicesKind);
  505. }
  506. if (parsedVertexData.hasMatricesWeights) {
  507. geometry._delayInfo.push(BABYLON.VertexBuffer.MatricesWeightsKind);
  508. }
  509. geometry._delayLoadingFunction = importVertexData;
  510. }
  511. else {
  512. importVertexData(parsedVertexData, geometry);
  513. }
  514. scene.pushGeometry(geometry, true);
  515. return geometry;
  516. };
  517. var parseMesh = function (parsedMesh, scene, rootUrl) {
  518. var mesh = new BABYLON.Mesh(parsedMesh.name, scene);
  519. mesh.id = parsedMesh.id;
  520. BABYLON.Tags.AddTagsTo(mesh, parsedMesh.tags);
  521. mesh.position = BABYLON.Vector3.FromArray(parsedMesh.position);
  522. if (parsedMesh.rotationQuaternion) {
  523. mesh.rotationQuaternion = BABYLON.Quaternion.FromArray(parsedMesh.rotationQuaternion);
  524. }
  525. else if (parsedMesh.rotation) {
  526. mesh.rotation = BABYLON.Vector3.FromArray(parsedMesh.rotation);
  527. }
  528. mesh.scaling = BABYLON.Vector3.FromArray(parsedMesh.scaling);
  529. if (parsedMesh.localMatrix) {
  530. mesh.setPivotMatrix(BABYLON.Matrix.FromArray(parsedMesh.localMatrix));
  531. }
  532. else if (parsedMesh.pivotMatrix) {
  533. mesh.setPivotMatrix(BABYLON.Matrix.FromArray(parsedMesh.pivotMatrix));
  534. }
  535. mesh.setEnabled(parsedMesh.isEnabled);
  536. mesh.isVisible = parsedMesh.isVisible;
  537. mesh.infiniteDistance = parsedMesh.infiniteDistance;
  538. mesh.showBoundingBox = parsedMesh.showBoundingBox;
  539. mesh.showSubMeshesBoundingBox = parsedMesh.showSubMeshesBoundingBox;
  540. if (parsedMesh.applyFog !== undefined) {
  541. mesh.applyFog = parsedMesh.applyFog;
  542. }
  543. if (parsedMesh.pickable !== undefined) {
  544. mesh.isPickable = parsedMesh.pickable;
  545. }
  546. if (parsedMesh.alphaIndex !== undefined) {
  547. mesh.alphaIndex = parsedMesh.alphaIndex;
  548. }
  549. mesh.receiveShadows = parsedMesh.receiveShadows;
  550. mesh.billboardMode = parsedMesh.billboardMode;
  551. if (parsedMesh.visibility !== undefined) {
  552. mesh.visibility = parsedMesh.visibility;
  553. }
  554. mesh.checkCollisions = parsedMesh.checkCollisions;
  555. mesh._shouldGenerateFlatShading = parsedMesh.useFlatShading;
  556. // Parent
  557. if (parsedMesh.parentId) {
  558. mesh._waitingParentId = parsedMesh.parentId;
  559. }
  560. // Actions
  561. if (parsedMesh.actions !== undefined) {
  562. mesh._waitingActions = parsedMesh.actions;
  563. }
  564. // Geometry
  565. mesh.hasVertexAlpha = parsedMesh.hasVertexAlpha;
  566. if (parsedMesh.delayLoadingFile) {
  567. mesh.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
  568. mesh.delayLoadingFile = rootUrl + parsedMesh.delayLoadingFile;
  569. mesh._boundingInfo = new BABYLON.BoundingInfo(BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMinimum), BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMaximum));
  570. if (parsedMesh._binaryInfo) {
  571. mesh._binaryInfo = parsedMesh._binaryInfo;
  572. }
  573. mesh._delayInfo = [];
  574. if (parsedMesh.hasUVs) {
  575. mesh._delayInfo.push(BABYLON.VertexBuffer.UVKind);
  576. }
  577. if (parsedMesh.hasUVs2) {
  578. mesh._delayInfo.push(BABYLON.VertexBuffer.UV2Kind);
  579. }
  580. if (parsedMesh.hasColors) {
  581. mesh._delayInfo.push(BABYLON.VertexBuffer.ColorKind);
  582. }
  583. if (parsedMesh.hasMatricesIndices) {
  584. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesIndicesKind);
  585. }
  586. if (parsedMesh.hasMatricesWeights) {
  587. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesWeightsKind);
  588. }
  589. mesh._delayLoadingFunction = importGeometry;
  590. if (BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental) {
  591. mesh._checkDelayState();
  592. }
  593. }
  594. else {
  595. importGeometry(parsedMesh, mesh);
  596. }
  597. // Material
  598. if (parsedMesh.materialId) {
  599. mesh.setMaterialByID(parsedMesh.materialId);
  600. }
  601. else {
  602. mesh.material = null;
  603. }
  604. // Skeleton
  605. if (parsedMesh.skeletonId > -1) {
  606. mesh.skeleton = scene.getLastSkeletonByID(parsedMesh.skeletonId);
  607. }
  608. // Physics
  609. if (parsedMesh.physicsImpostor) {
  610. if (!scene.isPhysicsEnabled()) {
  611. scene.enablePhysics();
  612. }
  613. mesh.setPhysicsState({ impostor: parsedMesh.physicsImpostor, mass: parsedMesh.physicsMass, friction: parsedMesh.physicsFriction, restitution: parsedMesh.physicsRestitution });
  614. }
  615. // Animations
  616. if (parsedMesh.animations) {
  617. for (var animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  618. var parsedAnimation = parsedMesh.animations[animationIndex];
  619. mesh.animations.push(parseAnimation(parsedAnimation));
  620. }
  621. }
  622. if (parsedMesh.autoAnimate) {
  623. scene.beginAnimation(mesh, parsedMesh.autoAnimateFrom, parsedMesh.autoAnimateTo, parsedMesh.autoAnimateLoop, 1.0);
  624. }
  625. // Layer Mask
  626. if (parsedMesh.layerMask && (!isNaN(parsedMesh.layerMask))) {
  627. mesh.layerMask = Math.abs(parseInt(parsedMesh.layerMask));
  628. }
  629. else {
  630. mesh.layerMask = 0xFFFFFFFF;
  631. }
  632. // Instances
  633. if (parsedMesh.instances) {
  634. for (var index = 0; index < parsedMesh.instances.length; index++) {
  635. var parsedInstance = parsedMesh.instances[index];
  636. var instance = mesh.createInstance(parsedInstance.name);
  637. BABYLON.Tags.AddTagsTo(instance, parsedInstance.tags);
  638. instance.position = BABYLON.Vector3.FromArray(parsedInstance.position);
  639. if (parsedInstance.rotationQuaternion) {
  640. instance.rotationQuaternion = BABYLON.Quaternion.FromArray(parsedInstance.rotationQuaternion);
  641. }
  642. else if (parsedInstance.rotation) {
  643. instance.rotation = BABYLON.Vector3.FromArray(parsedInstance.rotation);
  644. }
  645. instance.scaling = BABYLON.Vector3.FromArray(parsedInstance.scaling);
  646. instance.checkCollisions = mesh.checkCollisions;
  647. if (parsedMesh.animations) {
  648. for (animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  649. parsedAnimation = parsedMesh.animations[animationIndex];
  650. instance.animations.push(parseAnimation(parsedAnimation));
  651. }
  652. }
  653. }
  654. }
  655. return mesh;
  656. };
  657. var parseActions = function (parsedActions, object, scene) {
  658. var actionManager = new BABYLON.ActionManager(scene);
  659. if (object === null)
  660. scene.actionManager = actionManager;
  661. else
  662. object.actionManager = actionManager;
  663. // instanciate a new object
  664. var instanciate = function (name, params) {
  665. var newInstance = Object.create(BABYLON[name].prototype);
  666. newInstance.constructor.apply(newInstance, params);
  667. return newInstance;
  668. };
  669. var parseParameter = function (name, value, target, propertyPath) {
  670. if (propertyPath === null) {
  671. // String, boolean or float
  672. var floatValue = parseFloat(value);
  673. if (value === "true" || value === "false")
  674. return value === "true";
  675. else
  676. return isNaN(floatValue) ? value : floatValue;
  677. }
  678. var effectiveTarget = propertyPath.split(".");
  679. var values = value.split(",");
  680. for (var i = 0; i < effectiveTarget.length; i++) {
  681. target = target[effectiveTarget[i]];
  682. }
  683. // Return appropriate value with its type
  684. if (typeof (target) === "boolean")
  685. return values[0] === "true";
  686. if (typeof (target) === "string")
  687. return values[0];
  688. // Parameters with multiple values such as Vector3 etc.
  689. var split = new Array();
  690. for (var i = 0; i < values.length; i++)
  691. split.push(parseFloat(values[i]));
  692. if (target instanceof BABYLON.Vector3)
  693. return BABYLON.Vector3.FromArray(split);
  694. if (target instanceof BABYLON.Vector4)
  695. return BABYLON.Vector4.FromArray(split);
  696. if (target instanceof BABYLON.Color3)
  697. return BABYLON.Color3.FromArray(split);
  698. if (target instanceof BABYLON.Color4)
  699. return BABYLON.Color4.FromArray(split);
  700. return parseFloat(values[0]);
  701. };
  702. // traverse graph per trigger
  703. var traverse = function (parsedAction, trigger, condition, action, combineArray) {
  704. if (combineArray === void 0) { combineArray = null; }
  705. if (parsedAction.detached)
  706. return;
  707. var parameters = new Array();
  708. var target = null;
  709. var propertyPath = null;
  710. var combine = parsedAction.combine && parsedAction.combine.length > 0;
  711. // Parameters
  712. if (parsedAction.type === 2)
  713. parameters.push(actionManager);
  714. else
  715. parameters.push(trigger);
  716. if (combine) {
  717. var actions = new Array();
  718. for (var j = 0; j < parsedAction.combine.length; j++) {
  719. traverse(parsedAction.combine[j], BABYLON.ActionManager.NothingTrigger, condition, action, actions);
  720. }
  721. parameters.push(actions);
  722. }
  723. else {
  724. for (var i = 0; i < parsedAction.properties.length; i++) {
  725. var value = parsedAction.properties[i].value;
  726. var name = parsedAction.properties[i].name;
  727. var targetType = parsedAction.properties[i].targetType;
  728. if (name === "target")
  729. if (targetType !== null && targetType === "SceneProperties")
  730. value = target = scene;
  731. else
  732. value = target = scene.getNodeByName(value);
  733. else if (name === "parent")
  734. value = scene.getNodeByName(value);
  735. else if (name === "sound")
  736. value = scene.getSoundByName(value);
  737. else if (name !== "propertyPath") {
  738. if (parsedAction.type === 2 && name === "operator")
  739. value = BABYLON.ValueCondition[value];
  740. else
  741. value = parseParameter(name, value, target, name === "value" ? propertyPath : null);
  742. }
  743. else {
  744. propertyPath = value;
  745. }
  746. parameters.push(value);
  747. }
  748. }
  749. if (combineArray === null) {
  750. parameters.push(condition);
  751. }
  752. else {
  753. parameters.push(null);
  754. }
  755. // If interpolate value action
  756. if (parsedAction.name === "InterpolateValueAction") {
  757. var param = parameters[parameters.length - 2];
  758. parameters[parameters.length - 1] = param;
  759. parameters[parameters.length - 2] = condition;
  760. }
  761. // Action or condition(s) and not CombineAction
  762. var newAction = instanciate(parsedAction.name, parameters);
  763. if (combineArray === null) {
  764. if (newAction instanceof BABYLON.Condition) {
  765. condition = newAction;
  766. newAction = action;
  767. }
  768. else {
  769. condition = null;
  770. if (action)
  771. action.then(newAction);
  772. else
  773. actionManager.registerAction(newAction);
  774. }
  775. }
  776. else {
  777. combineArray.push(newAction);
  778. }
  779. for (var i = 0; i < parsedAction.children.length; i++)
  780. traverse(parsedAction.children[i], trigger, condition, newAction, null);
  781. };
  782. for (var i = 0; i < parsedActions.children.length; i++) {
  783. var triggerParams;
  784. var trigger = parsedActions.children[i];
  785. if (trigger.properties.length > 0) {
  786. var param = trigger.properties[0].value;
  787. var value = trigger.properties[0].targetType === null ? param : scene.getMeshByName(param);
  788. triggerParams = { trigger: BABYLON.ActionManager[trigger.name], parameter: value };
  789. }
  790. else
  791. triggerParams = BABYLON.ActionManager[trigger.name];
  792. for (var j = 0; j < trigger.children.length; j++) {
  793. if (!trigger.detached)
  794. traverse(trigger.children[j], triggerParams, null, null);
  795. }
  796. }
  797. };
  798. var parseSound = function (parsedSound, scene, rootUrl) {
  799. var soundName = parsedSound.name;
  800. var soundUrl = rootUrl + soundName;
  801. var options = {
  802. autoplay: parsedSound.autoplay,
  803. loop: parsedSound.loop,
  804. volume: parsedSound.volume,
  805. spatialSound: parsedSound.spatialSound,
  806. maxDistance: parsedSound.maxDistance,
  807. rolloffFactor: parsedSound.rolloffFactor,
  808. refDistance: parsedSound.refDistance,
  809. distanceModel: parsedSound.distanceModel,
  810. playbackRate: parsedSound.playbackRate
  811. };
  812. var newSound = new BABYLON.Sound(soundName, soundUrl, scene, function () {
  813. scene._removePendingData(newSound);
  814. }, options);
  815. scene._addPendingData(newSound);
  816. if (parsedSound.position) {
  817. var soundPosition = BABYLON.Vector3.FromArray(parsedSound.position);
  818. newSound.setPosition(soundPosition);
  819. }
  820. if (parsedSound.isDirectional) {
  821. newSound.setDirectionalCone(parsedSound.coneInnerAngle || 360, parsedSound.coneOuterAngle || 360, parsedSound.coneOuterGain || 0);
  822. if (parsedSound.localDirectionToMesh) {
  823. var localDirectionToMesh = BABYLON.Vector3.FromArray(parsedSound.localDirectionToMesh);
  824. newSound.setLocalDirectionToMesh(localDirectionToMesh);
  825. }
  826. }
  827. if (parsedSound.connectedMeshId) {
  828. var connectedMesh = scene.getMeshByID(parsedSound.connectedMeshId);
  829. if (connectedMesh) {
  830. newSound.attachToMesh(connectedMesh);
  831. }
  832. }
  833. };
  834. var isDescendantOf = function (mesh, names, hierarchyIds) {
  835. names = (names instanceof Array) ? names : [names];
  836. for (var i in names) {
  837. if (mesh.name === names[i]) {
  838. hierarchyIds.push(mesh.id);
  839. return true;
  840. }
  841. }
  842. if (mesh.parentId && hierarchyIds.indexOf(mesh.parentId) !== -1) {
  843. hierarchyIds.push(mesh.id);
  844. return true;
  845. }
  846. return false;
  847. };
  848. var importVertexData = function (parsedVertexData, geometry) {
  849. var vertexData = new BABYLON.VertexData();
  850. // positions
  851. var positions = parsedVertexData.positions;
  852. if (positions) {
  853. vertexData.set(positions, BABYLON.VertexBuffer.PositionKind);
  854. }
  855. // normals
  856. var normals = parsedVertexData.normals;
  857. if (normals) {
  858. vertexData.set(normals, BABYLON.VertexBuffer.NormalKind);
  859. }
  860. // uvs
  861. var uvs = parsedVertexData.uvs;
  862. if (uvs) {
  863. vertexData.set(uvs, BABYLON.VertexBuffer.UVKind);
  864. }
  865. // uv2s
  866. var uv2s = parsedVertexData.uv2s;
  867. if (uv2s) {
  868. vertexData.set(uv2s, BABYLON.VertexBuffer.UV2Kind);
  869. }
  870. // colors
  871. var colors = parsedVertexData.colors;
  872. if (colors) {
  873. vertexData.set(checkColors4(colors, positions.length / 3), BABYLON.VertexBuffer.ColorKind);
  874. }
  875. // matricesIndices
  876. var matricesIndices = parsedVertexData.matricesIndices;
  877. if (matricesIndices) {
  878. vertexData.set(matricesIndices, BABYLON.VertexBuffer.MatricesIndicesKind);
  879. }
  880. // matricesWeights
  881. var matricesWeights = parsedVertexData.matricesWeights;
  882. if (matricesWeights) {
  883. vertexData.set(matricesWeights, BABYLON.VertexBuffer.MatricesWeightsKind);
  884. }
  885. // indices
  886. var indices = parsedVertexData.indices;
  887. if (indices) {
  888. vertexData.indices = indices;
  889. }
  890. geometry.setAllVerticesData(vertexData, parsedVertexData.updatable);
  891. };
  892. var importGeometry = function (parsedGeometry, mesh) {
  893. var scene = mesh.getScene();
  894. // Geometry
  895. var geometryId = parsedGeometry.geometryId;
  896. if (geometryId) {
  897. var geometry = scene.getGeometryByID(geometryId);
  898. if (geometry) {
  899. geometry.applyToMesh(mesh);
  900. }
  901. }
  902. else if (parsedGeometry instanceof ArrayBuffer) {
  903. var binaryInfo = mesh._binaryInfo;
  904. if (binaryInfo.positionsAttrDesc && binaryInfo.positionsAttrDesc.count > 0) {
  905. var positionsData = new Float32Array(parsedGeometry, binaryInfo.positionsAttrDesc.offset, binaryInfo.positionsAttrDesc.count);
  906. mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, positionsData, false);
  907. }
  908. if (binaryInfo.normalsAttrDesc && binaryInfo.normalsAttrDesc.count > 0) {
  909. var normalsData = new Float32Array(parsedGeometry, binaryInfo.normalsAttrDesc.offset, binaryInfo.normalsAttrDesc.count);
  910. mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, normalsData, false);
  911. }
  912. if (binaryInfo.uvsAttrDesc && binaryInfo.uvsAttrDesc.count > 0) {
  913. var uvsData = new Float32Array(parsedGeometry, binaryInfo.uvsAttrDesc.offset, binaryInfo.uvsAttrDesc.count);
  914. mesh.setVerticesData(BABYLON.VertexBuffer.UVKind, uvsData, false);
  915. }
  916. if (binaryInfo.uvs2AttrDesc && binaryInfo.uvs2AttrDesc.count > 0) {
  917. var uvs2Data = new Float32Array(parsedGeometry, binaryInfo.uvs2AttrDesc.offset, binaryInfo.uvs2AttrDesc.count);
  918. mesh.setVerticesData(BABYLON.VertexBuffer.UV2Kind, uvs2Data, false);
  919. }
  920. if (binaryInfo.colorsAttrDesc && binaryInfo.colorsAttrDesc.count > 0) {
  921. var colorsData = new Float32Array(parsedGeometry, binaryInfo.colorsAttrDesc.offset, binaryInfo.colorsAttrDesc.count);
  922. mesh.setVerticesData(BABYLON.VertexBuffer.ColorKind, colorsData, false);
  923. }
  924. if (binaryInfo.matricesIndicesAttrDesc && binaryInfo.matricesIndicesAttrDesc.count > 0) {
  925. var matricesIndicesData = new Int32Array(parsedGeometry, binaryInfo.matricesIndicesAttrDesc.offset, binaryInfo.matricesIndicesAttrDesc.count);
  926. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, matricesIndicesData, false);
  927. }
  928. if (binaryInfo.matricesWeightsAttrDesc && binaryInfo.matricesWeightsAttrDesc.count > 0) {
  929. var matricesWeightsData = new Float32Array(parsedGeometry, binaryInfo.matricesWeightsAttrDesc.offset, binaryInfo.matricesWeightsAttrDesc.count);
  930. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, matricesWeightsData, false);
  931. }
  932. if (binaryInfo.indicesAttrDesc && binaryInfo.indicesAttrDesc.count > 0) {
  933. var indicesData = new Int32Array(parsedGeometry, binaryInfo.indicesAttrDesc.offset, binaryInfo.indicesAttrDesc.count);
  934. mesh.setIndices(indicesData);
  935. }
  936. if (binaryInfo.subMeshesAttrDesc && binaryInfo.subMeshesAttrDesc.count > 0) {
  937. var subMeshesData = new Int32Array(parsedGeometry, binaryInfo.subMeshesAttrDesc.offset, binaryInfo.subMeshesAttrDesc.count * 5);
  938. mesh.subMeshes = [];
  939. for (var i = 0; i < binaryInfo.subMeshesAttrDesc.count; i++) {
  940. var materialIndex = subMeshesData[(i * 5) + 0];
  941. var verticesStart = subMeshesData[(i * 5) + 1];
  942. var verticesCount = subMeshesData[(i * 5) + 2];
  943. var indexStart = subMeshesData[(i * 5) + 3];
  944. var indexCount = subMeshesData[(i * 5) + 4];
  945. var subMesh = new BABYLON.SubMesh(materialIndex, verticesStart, verticesCount, indexStart, indexCount, mesh);
  946. }
  947. }
  948. }
  949. else if (parsedGeometry.positions && parsedGeometry.normals && parsedGeometry.indices) {
  950. mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, parsedGeometry.positions, false);
  951. mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, parsedGeometry.normals, false);
  952. if (parsedGeometry.uvs) {
  953. mesh.setVerticesData(BABYLON.VertexBuffer.UVKind, parsedGeometry.uvs, false);
  954. }
  955. if (parsedGeometry.uvs2) {
  956. mesh.setVerticesData(BABYLON.VertexBuffer.UV2Kind, parsedGeometry.uvs2, false);
  957. }
  958. if (parsedGeometry.colors) {
  959. mesh.setVerticesData(BABYLON.VertexBuffer.ColorKind, checkColors4(parsedGeometry.colors, parsedGeometry.positions.length / 3), false);
  960. }
  961. if (parsedGeometry.matricesIndices) {
  962. if (!parsedGeometry.matricesIndices._isExpanded) {
  963. var floatIndices = [];
  964. for (var i = 0; i < parsedGeometry.matricesIndices.length; i++) {
  965. var matricesIndex = parsedGeometry.matricesIndices[i];
  966. floatIndices.push(matricesIndex & 0x000000FF);
  967. floatIndices.push((matricesIndex & 0x0000FF00) >> 8);
  968. floatIndices.push((matricesIndex & 0x00FF0000) >> 16);
  969. floatIndices.push(matricesIndex >> 24);
  970. }
  971. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, floatIndices, false);
  972. }
  973. else {
  974. delete parsedGeometry.matricesIndices._isExpanded;
  975. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, parsedGeometry.matricesIndices, false);
  976. }
  977. }
  978. if (parsedGeometry.matricesWeights) {
  979. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, parsedGeometry.matricesWeights, false);
  980. }
  981. mesh.setIndices(parsedGeometry.indices);
  982. // SubMeshes
  983. if (parsedGeometry.subMeshes) {
  984. mesh.subMeshes = [];
  985. for (var subIndex = 0; subIndex < parsedGeometry.subMeshes.length; subIndex++) {
  986. var parsedSubMesh = parsedGeometry.subMeshes[subIndex];
  987. var subMesh = new BABYLON.SubMesh(parsedSubMesh.materialIndex, parsedSubMesh.verticesStart, parsedSubMesh.verticesCount, parsedSubMesh.indexStart, parsedSubMesh.indexCount, mesh);
  988. }
  989. }
  990. }
  991. // Flat shading
  992. if (mesh._shouldGenerateFlatShading) {
  993. mesh.convertToFlatShadedMesh();
  994. delete mesh._shouldGenerateFlatShading;
  995. }
  996. // Update
  997. mesh.computeWorldMatrix(true);
  998. // Octree
  999. if (scene._selectionOctree) {
  1000. scene._selectionOctree.addMesh(mesh);
  1001. }
  1002. };
  1003. BABYLON.SceneLoader.RegisterPlugin({
  1004. extensions: ".babylon",
  1005. importMesh: function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
  1006. var parsedData = JSON.parse(data);
  1007. var loadedSkeletonsIds = [];
  1008. var loadedMaterialsIds = [];
  1009. var hierarchyIds = [];
  1010. for (var index = 0; index < parsedData.meshes.length; index++) {
  1011. var parsedMesh = parsedData.meshes[index];
  1012. if (!meshesNames || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
  1013. if (meshesNames instanceof Array) {
  1014. // Remove found mesh name from list.
  1015. delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
  1016. }
  1017. // Material ?
  1018. if (parsedMesh.materialId) {
  1019. var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
  1020. if (!materialFound) {
  1021. for (var multimatIndex = 0; multimatIndex < parsedData.multiMaterials.length; multimatIndex++) {
  1022. var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
  1023. if (parsedMultiMaterial.id == parsedMesh.materialId) {
  1024. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  1025. var subMatId = parsedMultiMaterial.materials[matIndex];
  1026. loadedMaterialsIds.push(subMatId);
  1027. parseMaterialById(subMatId, parsedData, scene, rootUrl);
  1028. }
  1029. loadedMaterialsIds.push(parsedMultiMaterial.id);
  1030. parseMultiMaterial(parsedMultiMaterial, scene);
  1031. materialFound = true;
  1032. break;
  1033. }
  1034. }
  1035. }
  1036. if (!materialFound) {
  1037. loadedMaterialsIds.push(parsedMesh.materialId);
  1038. parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
  1039. }
  1040. }
  1041. // Skeleton ?
  1042. if (parsedMesh.skeletonId > -1 && scene.skeletons) {
  1043. var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
  1044. if (!skeletonAlreadyLoaded) {
  1045. for (var skeletonIndex = 0; skeletonIndex < parsedData.skeletons.length; skeletonIndex++) {
  1046. var parsedSkeleton = parsedData.skeletons[skeletonIndex];
  1047. if (parsedSkeleton.id === parsedMesh.skeletonId) {
  1048. skeletons.push(parseSkeleton(parsedSkeleton, scene));
  1049. loadedSkeletonsIds.push(parsedSkeleton.id);
  1050. }
  1051. }
  1052. }
  1053. }
  1054. var mesh = parseMesh(parsedMesh, scene, rootUrl);
  1055. meshes.push(mesh);
  1056. }
  1057. }
  1058. for (index = 0; index < scene.meshes.length; index++) {
  1059. var currentMesh = scene.meshes[index];
  1060. if (currentMesh._waitingParentId) {
  1061. currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
  1062. currentMesh._waitingParentId = undefined;
  1063. }
  1064. }
  1065. // Particles
  1066. if (parsedData.particleSystems) {
  1067. for (index = 0; index < parsedData.particleSystems.length; index++) {
  1068. var parsedParticleSystem = parsedData.particleSystems[index];
  1069. if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
  1070. particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
  1071. }
  1072. }
  1073. }
  1074. return true;
  1075. },
  1076. load: function (scene, data, rootUrl) {
  1077. var parsedData = JSON.parse(data);
  1078. // Scene
  1079. scene.useDelayedTextureLoading = parsedData.useDelayedTextureLoading && !BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental;
  1080. scene.autoClear = parsedData.autoClear;
  1081. scene.clearColor = BABYLON.Color3.FromArray(parsedData.clearColor);
  1082. scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
  1083. scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
  1084. // Fog
  1085. if (parsedData.fogMode && parsedData.fogMode !== 0) {
  1086. scene.fogMode = parsedData.fogMode;
  1087. scene.fogColor = BABYLON.Color3.FromArray(parsedData.fogColor);
  1088. scene.fogStart = parsedData.fogStart;
  1089. scene.fogEnd = parsedData.fogEnd;
  1090. scene.fogDensity = parsedData.fogDensity;
  1091. }
  1092. for (var index = 0; index < parsedData.lights.length; index++) {
  1093. var parsedLight = parsedData.lights[index];
  1094. parseLight(parsedLight, scene);
  1095. }
  1096. // Materials
  1097. if (parsedData.materials) {
  1098. for (index = 0; index < parsedData.materials.length; index++) {
  1099. var parsedMaterial = parsedData.materials[index];
  1100. parseMaterial(parsedMaterial, scene, rootUrl);
  1101. }
  1102. }
  1103. if (parsedData.multiMaterials) {
  1104. for (index = 0; index < parsedData.multiMaterials.length; index++) {
  1105. var parsedMultiMaterial = parsedData.multiMaterials[index];
  1106. parseMultiMaterial(parsedMultiMaterial, scene);
  1107. }
  1108. }
  1109. // Skeletons
  1110. if (parsedData.skeletons) {
  1111. for (index = 0; index < parsedData.skeletons.length; index++) {
  1112. var parsedSkeleton = parsedData.skeletons[index];
  1113. parseSkeleton(parsedSkeleton, scene);
  1114. }
  1115. }
  1116. // Geometries
  1117. var geometries = parsedData.geometries;
  1118. if (geometries) {
  1119. // Boxes
  1120. var boxes = geometries.boxes;
  1121. if (boxes) {
  1122. for (index = 0; index < boxes.length; index++) {
  1123. var parsedBox = boxes[index];
  1124. parseBox(parsedBox, scene);
  1125. }
  1126. }
  1127. // Spheres
  1128. var spheres = geometries.spheres;
  1129. if (spheres) {
  1130. for (index = 0; index < spheres.length; index++) {
  1131. var parsedSphere = spheres[index];
  1132. parseSphere(parsedSphere, scene);
  1133. }
  1134. }
  1135. // Cylinders
  1136. var cylinders = geometries.cylinders;
  1137. if (cylinders) {
  1138. for (index = 0; index < cylinders.length; index++) {
  1139. var parsedCylinder = cylinders[index];
  1140. parseCylinder(parsedCylinder, scene);
  1141. }
  1142. }
  1143. // Toruses
  1144. var toruses = geometries.toruses;
  1145. if (toruses) {
  1146. for (index = 0; index < toruses.length; index++) {
  1147. var parsedTorus = toruses[index];
  1148. parseTorus(parsedTorus, scene);
  1149. }
  1150. }
  1151. // Grounds
  1152. var grounds = geometries.grounds;
  1153. if (grounds) {
  1154. for (index = 0; index < grounds.length; index++) {
  1155. var parsedGround = grounds[index];
  1156. parseGround(parsedGround, scene);
  1157. }
  1158. }
  1159. // Planes
  1160. var planes = geometries.planes;
  1161. if (planes) {
  1162. for (index = 0; index < planes.length; index++) {
  1163. var parsedPlane = planes[index];
  1164. parsePlane(parsedPlane, scene);
  1165. }
  1166. }
  1167. // TorusKnots
  1168. var torusKnots = geometries.torusKnots;
  1169. if (torusKnots) {
  1170. for (index = 0; index < torusKnots.length; index++) {
  1171. var parsedTorusKnot = torusKnots[index];
  1172. parseTorusKnot(parsedTorusKnot, scene);
  1173. }
  1174. }
  1175. // VertexData
  1176. var vertexData = geometries.vertexData;
  1177. if (vertexData) {
  1178. for (index = 0; index < vertexData.length; index++) {
  1179. var parsedVertexData = vertexData[index];
  1180. parseVertexData(parsedVertexData, scene, rootUrl);
  1181. }
  1182. }
  1183. }
  1184. for (index = 0; index < parsedData.meshes.length; index++) {
  1185. var parsedMesh = parsedData.meshes[index];
  1186. parseMesh(parsedMesh, scene, rootUrl);
  1187. }
  1188. for (index = 0; index < parsedData.cameras.length; index++) {
  1189. var parsedCamera = parsedData.cameras[index];
  1190. parseCamera(parsedCamera, scene);
  1191. }
  1192. if (parsedData.activeCameraID) {
  1193. scene.setActiveCameraByID(parsedData.activeCameraID);
  1194. }
  1195. for (index = 0; index < scene.cameras.length; index++) {
  1196. var camera = scene.cameras[index];
  1197. if (camera._waitingParentId) {
  1198. camera.parent = scene.getLastEntryByID(camera._waitingParentId);
  1199. camera._waitingParentId = undefined;
  1200. }
  1201. }
  1202. for (index = 0; index < scene.lights.length; index++) {
  1203. var light = scene.lights[index];
  1204. if (light._waitingParentId) {
  1205. light.parent = scene.getLastEntryByID(light._waitingParentId);
  1206. light._waitingParentId = undefined;
  1207. }
  1208. }
  1209. // Sounds
  1210. if (parsedData.sounds) {
  1211. for (index = 0; index < parsedData.sounds.length; index++) {
  1212. var parsedSound = parsedData.sounds[index];
  1213. if (BABYLON.Engine.audioEngine.canUseWebAudio) {
  1214. parseSound(parsedSound, scene, rootUrl);
  1215. }
  1216. else {
  1217. var emptySound = new BABYLON.Sound(parsedSound.name, null, scene);
  1218. }
  1219. }
  1220. }
  1221. for (index = 0; index < scene.meshes.length; index++) {
  1222. var mesh = scene.meshes[index];
  1223. if (mesh._waitingParentId) {
  1224. mesh.parent = scene.getLastEntryByID(mesh._waitingParentId);
  1225. mesh._waitingParentId = undefined;
  1226. }
  1227. if (mesh._waitingActions) {
  1228. parseActions(mesh._waitingActions, mesh, scene);
  1229. mesh._waitingActions = undefined;
  1230. }
  1231. }
  1232. // Particles Systems
  1233. if (parsedData.particleSystems) {
  1234. for (index = 0; index < parsedData.particleSystems.length; index++) {
  1235. var parsedParticleSystem = parsedData.particleSystems[index];
  1236. parseParticleSystem(parsedParticleSystem, scene, rootUrl);
  1237. }
  1238. }
  1239. // Lens flares
  1240. if (parsedData.lensFlareSystems) {
  1241. for (index = 0; index < parsedData.lensFlareSystems.length; index++) {
  1242. var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
  1243. parseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
  1244. }
  1245. }
  1246. // Shadows
  1247. if (parsedData.shadowGenerators) {
  1248. for (index = 0; index < parsedData.shadowGenerators.length; index++) {
  1249. var parsedShadowGenerator = parsedData.shadowGenerators[index];
  1250. parseShadowGenerator(parsedShadowGenerator, scene);
  1251. }
  1252. }
  1253. // Actions (scene)
  1254. if (parsedData.actions) {
  1255. parseActions(parsedData.actions, null, scene);
  1256. }
  1257. // Finish
  1258. return true;
  1259. }
  1260. });
  1261. })(Internals = BABYLON.Internals || (BABYLON.Internals = {}));
  1262. })(BABYLON || (BABYLON = {}));
  1263. //# sourceMappingURL=babylon.babylonFileLoader.js.map