babylon.sceneLoader.js 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732
  1. "use strict";
  2. var BABYLON = BABYLON || {};
  3. (function () {
  4. var loadCubeTexture = function (rootUrl, parsedTexture, scene) {
  5. var texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene);
  6. texture.name = parsedTexture.name;
  7. texture.hasAlpha = parsedTexture.hasAlpha;
  8. texture.level = parsedTexture.level;
  9. texture.coordinatesMode = parsedTexture.coordinatesMode;
  10. return texture;
  11. };
  12. var loadTexture = function (rootUrl, parsedTexture, scene) {
  13. if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
  14. return null;
  15. }
  16. if (parsedTexture.isCube) {
  17. return loadCubeTexture(rootUrl, parsedTexture, scene);
  18. }
  19. var texture;
  20. if (parsedTexture.mirrorPlane) {
  21. texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  22. texture._waitingRenderList = parsedTexture.renderList;
  23. texture.mirrorPlane = BABYLON.Plane.FromArray(parsedTexture.mirrorPlane);
  24. } else if (parsedTexture.isRenderTarget) {
  25. texture = new BABYLON.RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  26. texture._waitingRenderList = parsedTexture.renderList;
  27. } else {
  28. texture = new BABYLON.Texture(rootUrl + parsedTexture.name, scene);
  29. }
  30. texture.name = parsedTexture.name;
  31. texture.hasAlpha = parsedTexture.hasAlpha;
  32. texture.level = parsedTexture.level;
  33. texture.coordinatesIndex = parsedTexture.coordinatesIndex;
  34. texture.coordinatesMode = parsedTexture.coordinatesMode;
  35. texture.uOffset = parsedTexture.uOffset;
  36. texture.vOffset = parsedTexture.vOffset;
  37. texture.uScale = parsedTexture.uScale;
  38. texture.vScale = parsedTexture.vScale;
  39. texture.uAng = parsedTexture.uAng;
  40. texture.vAng = parsedTexture.vAng;
  41. texture.wAng = parsedTexture.wAng;
  42. texture.wrapU = parsedTexture.wrapU;
  43. texture.wrapV = parsedTexture.wrapV;
  44. // Animations
  45. if (parsedTexture.animations) {
  46. for (var animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
  47. var parsedAnimation = parsedTexture.animations[animationIndex];
  48. texture.animations.push(parseAnimation(parsedAnimation));
  49. }
  50. }
  51. return texture;
  52. };
  53. var parseSkeleton = function (parsedSkeleton, scene) {
  54. var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
  55. for (var index = 0; index < parsedSkeleton.bones.length; index++) {
  56. var parsedBone = parsedSkeleton.bones[index];
  57. var parentBone = null;
  58. if (parsedBone.parentBoneIndex > -1) {
  59. parentBone = skeleton.bones[parsedBone.parentBoneIndex];
  60. }
  61. var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
  62. if (parsedBone.animation) {
  63. bone.animations.push(parseAnimation(parsedBone.animation));
  64. }
  65. }
  66. return skeleton;
  67. };
  68. var parseMaterial = function (parsedMaterial, scene, rootUrl) {
  69. var material;
  70. material = new BABYLON.StandardMaterial(parsedMaterial.name, scene);
  71. material.ambientColor = BABYLON.Color3.FromArray(parsedMaterial.ambient);
  72. material.diffuseColor = BABYLON.Color3.FromArray(parsedMaterial.diffuse);
  73. material.specularColor = BABYLON.Color3.FromArray(parsedMaterial.specular);
  74. material.specularPower = parsedMaterial.specularPower;
  75. material.emissiveColor = BABYLON.Color3.FromArray(parsedMaterial.emissive);
  76. material.alpha = parsedMaterial.alpha;
  77. material.id = parsedMaterial.id;
  78. material.backFaceCulling = parsedMaterial.backFaceCulling;
  79. if (parsedMaterial.diffuseTexture) {
  80. material.diffuseTexture = loadTexture(rootUrl, parsedMaterial.diffuseTexture, scene);
  81. }
  82. if (parsedMaterial.ambientTexture) {
  83. material.ambientTexture = loadTexture(rootUrl, parsedMaterial.ambientTexture, scene);
  84. }
  85. if (parsedMaterial.opacityTexture) {
  86. material.opacityTexture = loadTexture(rootUrl, parsedMaterial.opacityTexture, scene);
  87. }
  88. if (parsedMaterial.reflectionTexture) {
  89. material.reflectionTexture = loadTexture(rootUrl, parsedMaterial.reflectionTexture, scene);
  90. }
  91. if (parsedMaterial.emissiveTexture) {
  92. material.emissiveTexture = loadTexture(rootUrl, parsedMaterial.emissiveTexture, scene);
  93. }
  94. if (parsedMaterial.specularTexture) {
  95. material.specularTexture = loadTexture(rootUrl, parsedMaterial.specularTexture, scene);
  96. }
  97. if (parsedMaterial.bumpTexture) {
  98. material.bumpTexture = loadTexture(rootUrl, parsedMaterial.bumpTexture, scene);
  99. }
  100. return material;
  101. };
  102. var parseMaterialById = function (id, parsedData, scene, rootUrl) {
  103. for (var index = 0; index < parsedData.materials.length; index++) {
  104. var parsedMaterial = parsedData.materials[index];
  105. if (parsedMaterial.id === id) {
  106. return parseMaterial(parsedMaterial, scene, rootUrl);
  107. }
  108. }
  109. return null;
  110. };
  111. var parseMultiMaterial = function (parsedMultiMaterial, scene) {
  112. var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
  113. multiMaterial.id = parsedMultiMaterial.id;
  114. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  115. var subMatId = parsedMultiMaterial.materials[matIndex];
  116. if (subMatId) {
  117. multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
  118. } else {
  119. multiMaterial.subMaterials.push(null);
  120. }
  121. }
  122. return multiMaterial;
  123. };
  124. var parseLensFlareSystem = function (parsedLensFlareSystem, scene, rootUrl) {
  125. var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
  126. var lensFlareSystem = new BABYLON.LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
  127. lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
  128. for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
  129. var parsedFlare = parsedLensFlareSystem.flares[index];
  130. var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
  131. }
  132. return lensFlareSystem;
  133. };
  134. var parseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
  135. var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
  136. var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
  137. if (parsedParticleSystem.textureName) {
  138. particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
  139. }
  140. particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
  141. particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
  142. particleSystem.minSize = parsedParticleSystem.minSize;
  143. particleSystem.maxSize = parsedParticleSystem.maxSize;
  144. particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
  145. particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
  146. particleSystem.emitter = emitter;
  147. particleSystem.emitRate = parsedParticleSystem.emitRate;
  148. particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
  149. particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
  150. particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
  151. particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
  152. particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
  153. particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
  154. particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
  155. particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
  156. particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
  157. particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
  158. particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
  159. particleSystem.blendMode = parsedParticleSystem.blendMode;
  160. particleSystem.start();
  161. return particleSystem;
  162. };
  163. var parseShadowGenerator = function (parsedShadowGenerator, scene) {
  164. var light = scene.getLightByID(parsedShadowGenerator.lightId);
  165. var shadowGenerator = new BABYLON.ShadowGenerator(parsedShadowGenerator.mapSize, light);
  166. for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
  167. var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
  168. shadowGenerator.getShadowMap().renderList.push(mesh);
  169. }
  170. shadowGenerator.useVarianceShadowMap = parsedShadowGenerator.useVarianceShadowMap;
  171. return shadowGenerator;
  172. };
  173. var parseAnimation = function (parsedAnimation) {
  174. var animation = new BABYLON.Animation(parsedAnimation.name, parsedAnimation.property, parsedAnimation.framePerSecond, parsedAnimation.dataType, parsedAnimation.loopBehavior);
  175. var dataType = parsedAnimation.dataType;
  176. var keys = [];
  177. for (var index = 0; index < parsedAnimation.keys.length; index++) {
  178. var key = parsedAnimation.keys[index];
  179. var data;
  180. switch (dataType) {
  181. case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
  182. data = key.values[0];
  183. break;
  184. case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
  185. data = BABYLON.Quaternion.FromArray(key.values);
  186. break;
  187. case BABYLON.Animation.ANIMATIONTYPE_MATRIX:
  188. data = BABYLON.Matrix.FromArray(key.values);
  189. break;
  190. case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
  191. default:
  192. data = BABYLON.Vector3.FromArray(key.values);
  193. break;
  194. }
  195. keys.push({
  196. frame: key.frame,
  197. value: data
  198. });
  199. }
  200. animation.setKeys(keys);
  201. return animation;
  202. };
  203. var parseLight = function (parsedLight, scene) {
  204. var light;
  205. switch (parsedLight.type) {
  206. case 0:
  207. light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
  208. break;
  209. case 1:
  210. light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  211. light.position = BABYLON.Vector3.FromArray(parsedLight.position);
  212. break;
  213. case 2:
  214. light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
  215. break;
  216. case 3:
  217. light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  218. light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
  219. break;
  220. }
  221. light.id = parsedLight.id;
  222. if (parsedLight.intensity) {
  223. light.intensity = parsedLight.intensity;
  224. }
  225. light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
  226. light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
  227. };
  228. var parseCamera = function (parsedCamera, scene) {
  229. var camera = new BABYLON.FreeCamera(parsedCamera.name, BABYLON.Vector3.FromArray(parsedCamera.position), scene);
  230. camera.id = parsedCamera.id;
  231. // Parent
  232. if (parsedCamera.parentId) {
  233. camera._waitingParentId = parsedCamera.parentId;
  234. }
  235. // Target
  236. if (parsedCamera.target) {
  237. camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
  238. } else {
  239. camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
  240. }
  241. // Locked target
  242. if (parsedCamera.lockedTargetId) {
  243. camera._waitingLockedTargetId = parsedCamera.lockedTargetId;
  244. }
  245. camera.fov = parsedCamera.fov;
  246. camera.minZ = parsedCamera.minZ;
  247. camera.maxZ = parsedCamera.maxZ;
  248. camera.speed = parsedCamera.speed;
  249. camera.inertia = parsedCamera.inertia;
  250. camera.checkCollisions = parsedCamera.checkCollisions;
  251. camera.applyGravity = parsedCamera.applyGravity;
  252. if (parsedCamera.ellipsoid) {
  253. camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
  254. }
  255. // Animations
  256. if (parsedCamera.animations) {
  257. for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
  258. var parsedAnimation = parsedCamera.animations[animationIndex];
  259. camera.animations.push(parseAnimation(parsedAnimation));
  260. }
  261. }
  262. if (parsedCamera.autoAnimate) {
  263. scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
  264. }
  265. return camera;
  266. };
  267. var parseMesh = function (parsedMesh, scene, rootUrl) {
  268. var mesh = new BABYLON.Mesh(parsedMesh.name, scene);
  269. mesh.id = parsedMesh.id;
  270. mesh.position = BABYLON.Vector3.FromArray(parsedMesh.position);
  271. if (parsedMesh.rotation) {
  272. mesh.rotation = BABYLON.Vector3.FromArray(parsedMesh.rotation);
  273. } else if (parsedMesh.rotationQuaternion) {
  274. mesh.rotationQuaternion = BABYLON.Quaternion.FromArray(parsedMesh.rotationQuaternion);
  275. }
  276. mesh.scaling = BABYLON.Vector3.FromArray(parsedMesh.scaling);
  277. if (parsedMesh.localMatrix) {
  278. mesh.setPivotMatrix(BABYLON.Matrix.FromArray(parsedMesh.localMatrix));
  279. }
  280. mesh.setEnabled(parsedMesh.isEnabled);
  281. mesh.isVisible = parsedMesh.isVisible;
  282. mesh.infiniteDistance = parsedMesh.infiniteDistance;
  283. mesh.receiveShadows = parsedMesh.receiveShadows;
  284. mesh.billboardMode = parsedMesh.billboardMode;
  285. if (parsedMesh.visibility !== undefined) {
  286. mesh.visibility = parsedMesh.visibility;
  287. }
  288. mesh.checkCollisions = parsedMesh.checkCollisions;
  289. // Parent
  290. if (parsedMesh.parentId) {
  291. mesh.parent = scene.getLastEntryByID(parsedMesh.parentId);
  292. }
  293. // Geometry
  294. if (parsedMesh.delayLoadingFile) {
  295. mesh.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
  296. mesh.delayLoadingFile = rootUrl + parsedMesh.delayLoadingFile;
  297. mesh._boundingInfo = new BABYLON.BoundingInfo(BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMinimum), BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMaximum));
  298. mesh._delayInfo = [];
  299. if (parsedMesh.hasUVs) {
  300. mesh._delayInfo.push(BABYLON.VertexBuffer.UVKind);
  301. }
  302. if (parsedMesh.hasUVs2) {
  303. mesh._delayInfo.push(BABYLON.VertexBuffer.UV2Kind);
  304. }
  305. if (parsedMesh.hasColors) {
  306. mesh._delayInfo.push(BABYLON.VertexBuffer.ColorKind);
  307. }
  308. if (parsedMesh.hasMatricesIndices) {
  309. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesIndicesKind);
  310. }
  311. if (parsedMesh.hasMatricesWeights) {
  312. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesWeightsKind);
  313. }
  314. } else {
  315. BABYLON.SceneLoader._ImportGeometry(parsedMesh, mesh);
  316. }
  317. // Material
  318. if (parsedMesh.materialId) {
  319. mesh.setMaterialByID(parsedMesh.materialId);
  320. } else {
  321. mesh.material = null;
  322. }
  323. // Skeleton
  324. if (parsedMesh.skeletonId > -1) {
  325. mesh.skeleton = scene.getLastSkeletonByID(parsedMesh.skeletonId);
  326. }
  327. // Physics
  328. if (parsedMesh.physicsImpostor) {
  329. if (!scene.isPhysicsEnabled()) {
  330. scene.enablePhysics();
  331. }
  332. switch (parsedMesh.physicsImpostor) {
  333. case 1: // BOX
  334. mesh.setPhysicsState({ impostor: BABYLON.PhysicsEngine.BoxImpostor, mass: parsedMesh.physicsMass, friction: parsedMesh.physicsFriction, restitution: parsedMesh.physicsRestitution });
  335. break;
  336. case 2: // SPHERE
  337. mesh.setPhysicsState({ impostor: BABYLON.PhysicsEngine.SphereImpostor, mass: parsedMesh.physicsMass, friction: parsedMesh.physicsFriction, restitution: parsedMesh.physicsRestitution });
  338. break;
  339. }
  340. }
  341. // Animations
  342. if (parsedMesh.animations) {
  343. for (var animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  344. var parsedAnimation = parsedMesh.animations[animationIndex];
  345. mesh.animations.push(parseAnimation(parsedAnimation));
  346. }
  347. }
  348. if (parsedMesh.autoAnimate) {
  349. scene.beginAnimation(mesh, parsedMesh.autoAnimateFrom, parsedMesh.autoAnimateTo, parsedMesh.autoAnimateLoop, 1.0);
  350. }
  351. return mesh;
  352. };
  353. var isDescendantOf = function (mesh, name, hierarchyIds) {
  354. if (mesh.name === name) {
  355. hierarchyIds.push(mesh.id);
  356. return true;
  357. }
  358. if (mesh.parentId && hierarchyIds.indexOf(mesh.parentId) !== -1) {
  359. hierarchyIds.push(mesh.id);
  360. return true;
  361. }
  362. return false;
  363. };
  364. BABYLON.SceneLoader = {
  365. _ImportGeometry: function (parsedGeometry, mesh) {
  366. // Geometry
  367. if (parsedGeometry.positions && parsedGeometry.normals && parsedGeometry.indices) {
  368. mesh.setVerticesData(parsedGeometry.positions, BABYLON.VertexBuffer.PositionKind, false);
  369. mesh.setVerticesData(parsedGeometry.normals, BABYLON.VertexBuffer.NormalKind, false);
  370. if (parsedGeometry.uvs) {
  371. mesh.setVerticesData(parsedGeometry.uvs, BABYLON.VertexBuffer.UVKind, false);
  372. }
  373. if (parsedGeometry.uvs2) {
  374. mesh.setVerticesData(parsedGeometry.uvs2, BABYLON.VertexBuffer.UV2Kind, false);
  375. }
  376. if (parsedGeometry.colors) {
  377. mesh.setVerticesData(parsedGeometry.colors, BABYLON.VertexBuffer.ColorKind, false);
  378. }
  379. if (parsedGeometry.matricesIndices) {
  380. var floatIndices = [];
  381. for (var i = 0; i < parsedGeometry.matricesIndices.length; i++) {
  382. var matricesIndex = parsedGeometry.matricesIndices[i];
  383. floatIndices.push(matricesIndex & 0x000000FF);
  384. floatIndices.push((matricesIndex & 0x0000FF00) >> 8);
  385. floatIndices.push((matricesIndex & 0x00FF0000) >> 16);
  386. floatIndices.push(matricesIndex >> 24);
  387. }
  388. mesh.setVerticesData(floatIndices, BABYLON.VertexBuffer.MatricesIndicesKind, false);
  389. }
  390. if (parsedGeometry.matricesWeights) {
  391. mesh.setVerticesData(parsedGeometry.matricesWeights, BABYLON.VertexBuffer.MatricesWeightsKind, false);
  392. }
  393. mesh.setIndices(parsedGeometry.indices);
  394. }
  395. // SubMeshes
  396. if (parsedGeometry.subMeshes) {
  397. mesh.subMeshes = [];
  398. for (var subIndex = 0; subIndex < parsedGeometry.subMeshes.length; subIndex++) {
  399. var parsedSubMesh = parsedGeometry.subMeshes[subIndex];
  400. var subMesh = new BABYLON.SubMesh(parsedSubMesh.materialIndex, parsedSubMesh.verticesStart, parsedSubMesh.verticesCount, parsedSubMesh.indexStart, parsedSubMesh.indexCount, mesh);
  401. }
  402. }
  403. // Update
  404. mesh.computeWorldMatrix(true);
  405. var scene = mesh.getScene();
  406. if (scene._selectionOctree) {
  407. scene._selectionOctree.addMesh(mesh);
  408. }
  409. },
  410. ImportMesh: function (meshName, rootUrl, sceneFilename, scene, then, progressCallBack) {
  411. // Checking if a manifest file has been set for this scene and if offline mode has been requested
  412. var database = new BABYLON.Database(rootUrl + sceneFilename);
  413. scene.database = database;
  414. BABYLON.Tools.LoadFile(rootUrl + sceneFilename, function (data) {
  415. var parsedData = JSON.parse(data);
  416. // Meshes
  417. var meshes = [];
  418. var particleSystems = [];
  419. var skeletons = [];
  420. var loadedSkeletonsIds = [];
  421. var loadedMaterialsIds = [];
  422. var hierarchyIds = [];
  423. for (var index = 0; index < parsedData.meshes.length; index++) {
  424. var parsedMesh = parsedData.meshes[index];
  425. if (!meshName || isDescendantOf(parsedMesh, meshName, hierarchyIds)) {
  426. // Material ?
  427. if (parsedMesh.materialId) {
  428. var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
  429. if (!materialFound) {
  430. for (var multimatIndex = 0; multimatIndex < parsedData.multiMaterials.length; multimatIndex++) {
  431. var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
  432. if (parsedMultiMaterial.id == parsedMesh.materialId) {
  433. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  434. var subMatId = parsedMultiMaterial.materials[matIndex];
  435. loadedMaterialsIds.push(subMatId);
  436. parseMaterialById(subMatId, parsedData, scene, rootUrl);
  437. }
  438. loadedMaterialsIds.push(parsedMultiMaterial.id);
  439. parseMultiMaterial(parsedMultiMaterial, scene);
  440. materialFound = true;
  441. break;
  442. }
  443. }
  444. }
  445. if (!materialFound) {
  446. loadedMaterialsIds.push(parsedMesh.materialId);
  447. parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
  448. }
  449. }
  450. // Skeleton ?
  451. if (parsedMesh.skeletonId > -1 && scene.skeletons) {
  452. var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
  453. if (!skeletonAlreadyLoaded) {
  454. for (var skeletonIndex = 0; skeletonIndex < parsedData.skeletons.length; skeletonIndex++) {
  455. var parsedSkeleton = parsedData.skeletons[skeletonIndex];
  456. if (parsedSkeleton.id === parsedMesh.skeletonId) {
  457. skeletons.push(parseSkeleton(parsedSkeleton, scene));
  458. loadedSkeletonsIds.push(parsedSkeleton.id);
  459. }
  460. }
  461. }
  462. }
  463. var mesh = parseMesh(parsedMesh, scene, rootUrl);
  464. meshes.push(mesh);
  465. }
  466. }
  467. // Particles
  468. if (parsedData.particleSystems) {
  469. for (var index = 0; index < parsedData.particleSystems.length; index++) {
  470. var parsedParticleSystem = parsedData.particleSystems[index];
  471. if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
  472. particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
  473. }
  474. }
  475. }
  476. if (then) {
  477. then(meshes, particleSystems, skeletons);
  478. }
  479. }, progressCallBack, database);
  480. },
  481. Load: function (rootUrl, sceneFilename, engine, then, progressCallBack) {
  482. function loadSceneFromData(data) {
  483. var parsedData = JSON.parse(data);
  484. var scene = new BABYLON.Scene(engine);
  485. scene.database = database;
  486. // Scene
  487. scene.useDelayedTextureLoading = parsedData.useDelayedTextureLoading;
  488. scene.autoClear = parsedData.autoClear;
  489. scene.clearColor = BABYLON.Color3.FromArray(parsedData.clearColor);
  490. scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
  491. scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
  492. // Fog
  493. if (parsedData.fogMode && parsedData.fogMode !== 0) {
  494. scene.fogMode = parsedData.fogMode;
  495. scene.fogColor = BABYLON.Color3.FromArray(parsedData.fogColor);
  496. scene.fogStart = parsedData.fogStart;
  497. scene.fogEnd = parsedData.fogEnd;
  498. scene.fogDensity = parsedData.fogDensity;
  499. }
  500. // Lights
  501. for (var index = 0; index < parsedData.lights.length; index++) {
  502. var parsedLight = parsedData.lights[index];
  503. parseLight(parsedLight, scene);
  504. }
  505. // Cameras
  506. for (var index = 0; index < parsedData.cameras.length; index++) {
  507. var parsedCamera = parsedData.cameras[index];
  508. parseCamera(parsedCamera, scene);
  509. }
  510. if (parsedData.activeCameraID) {
  511. scene.activeCameraByID(parsedData.activeCameraID);
  512. }
  513. // Materials
  514. if (parsedData.materials) {
  515. for (var index = 0; index < parsedData.materials.length; index++) {
  516. var parsedMaterial = parsedData.materials[index];
  517. parseMaterial(parsedMaterial, scene, rootUrl);
  518. }
  519. }
  520. if (parsedData.multiMaterials) {
  521. for (var index = 0; index < parsedData.multiMaterials.length; index++) {
  522. var parsedMultiMaterial = parsedData.multiMaterials[index];
  523. parseMultiMaterial(parsedMultiMaterial, scene);
  524. }
  525. }
  526. // Skeletons
  527. if (parsedData.skeletons) {
  528. for (var index = 0; index < parsedData.skeletons.length; index++) {
  529. var parsedSkeleton = parsedData.skeletons[index];
  530. parseSkeleton(parsedSkeleton, scene);
  531. }
  532. }
  533. // Meshes
  534. for (var index = 0; index < parsedData.meshes.length; index++) {
  535. var parsedMesh = parsedData.meshes[index];
  536. parseMesh(parsedMesh, scene, rootUrl);
  537. }
  538. // Connecting cameras parents and locked target
  539. for (var index = 0; index < scene.cameras.length; index++) {
  540. var camera = scene.cameras[index];
  541. if (camera._waitingParentId) {
  542. camera.parent = scene.getLastEntryByID(camera._waitingParentId);
  543. delete camera._waitingParentId;
  544. }
  545. if (camera._waitingLockedTargetId) {
  546. camera.lockedTarget = scene.getLastEntryByID(camera._waitingLockedTargetId);
  547. delete camera._waitingLockedTargetId;
  548. }
  549. }
  550. // Particles Systems
  551. if (parsedData.particleSystems) {
  552. for (var index = 0; index < parsedData.particleSystems.length; index++) {
  553. var parsedParticleSystem = parsedData.particleSystems[index];
  554. parseParticleSystem(parsedParticleSystem, scene, rootUrl);
  555. }
  556. }
  557. // Lens flares
  558. if (parsedData.lensFlareSystems) {
  559. for (var index = 0; index < parsedData.lensFlareSystems.length; index++) {
  560. var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
  561. parseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
  562. }
  563. }
  564. // Shadows
  565. if (parsedData.shadowGenerators) {
  566. for (var index = 0; index < parsedData.shadowGenerators.length; index++) {
  567. var parsedShadowGenerator = parsedData.shadowGenerators[index];
  568. parseShadowGenerator(parsedShadowGenerator, scene);
  569. }
  570. }
  571. // Finish
  572. if (then) {
  573. then(scene);
  574. }
  575. };
  576. if (rootUrl.indexOf("file:") === -1) {
  577. // Checking if a manifest file has been set for this scene and if offline mode has been requested
  578. var database = new BABYLON.Database(rootUrl + sceneFilename);
  579. BABYLON.Tools.LoadFile(rootUrl + sceneFilename, loadSceneFromData, progressCallBack, database);
  580. }
  581. // Loading file from disk via input file or drag'n'drop
  582. else {
  583. BABYLON.Tools.ReadFile(sceneFilename, loadSceneFromData, progressCallBack);
  584. }
  585. }
  586. };
  587. })();