babylon.babylonFileLoader.js 76 KB

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