babylon.babylonFileLoader.ts 51 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279
  1. module BABYLON.Internals {
  2. var loadCubeTexture = (rootUrl, parsedTexture, scene) => {
  3. var texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene);
  4. texture.name = parsedTexture.name;
  5. texture.hasAlpha = parsedTexture.hasAlpha;
  6. texture.level = parsedTexture.level;
  7. texture.coordinatesMode = parsedTexture.coordinatesMode;
  8. return texture;
  9. };
  10. var loadTexture = (rootUrl, parsedTexture, scene) => {
  11. if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
  12. return null;
  13. }
  14. if (parsedTexture.isCube) {
  15. return loadCubeTexture(rootUrl, parsedTexture, scene);
  16. }
  17. var texture;
  18. if (parsedTexture.mirrorPlane) {
  19. texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  20. texture._waitingRenderList = parsedTexture.renderList;
  21. texture.mirrorPlane = BABYLON.Plane.FromArray(parsedTexture.mirrorPlane);
  22. } else if (parsedTexture.isRenderTarget) {
  23. texture = new BABYLON.RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  24. texture._waitingRenderList = parsedTexture.renderList;
  25. } else {
  26. texture = new BABYLON.Texture(rootUrl + parsedTexture.name, scene);
  27. }
  28. texture.name = parsedTexture.name;
  29. texture.hasAlpha = parsedTexture.hasAlpha;
  30. texture.getAlphaFromRGB = parsedTexture.getAlphaFromRGB;
  31. texture.level = parsedTexture.level;
  32. texture.coordinatesIndex = parsedTexture.coordinatesIndex;
  33. texture.coordinatesMode = parsedTexture.coordinatesMode;
  34. texture.uOffset = parsedTexture.uOffset;
  35. texture.vOffset = parsedTexture.vOffset;
  36. texture.uScale = parsedTexture.uScale;
  37. texture.vScale = parsedTexture.vScale;
  38. texture.uAng = parsedTexture.uAng;
  39. texture.vAng = parsedTexture.vAng;
  40. texture.wAng = parsedTexture.wAng;
  41. texture.wrapU = parsedTexture.wrapU;
  42. texture.wrapV = parsedTexture.wrapV;
  43. // Animations
  44. if (parsedTexture.animations) {
  45. for (var animationIndex = 0; animationIndex < parsedTexture.animations.length; animationIndex++) {
  46. var parsedAnimation = parsedTexture.animations[animationIndex];
  47. texture.animations.push(parseAnimation(parsedAnimation));
  48. }
  49. }
  50. return texture;
  51. };
  52. var parseSkeleton = (parsedSkeleton, scene) => {
  53. var skeleton = new BABYLON.Skeleton(parsedSkeleton.name, parsedSkeleton.id, scene);
  54. for (var index = 0; index < parsedSkeleton.bones.length; index++) {
  55. var parsedBone = parsedSkeleton.bones[index];
  56. var parentBone = null;
  57. if (parsedBone.parentBoneIndex > -1) {
  58. parentBone = skeleton.bones[parsedBone.parentBoneIndex];
  59. }
  60. var bone = new BABYLON.Bone(parsedBone.name, skeleton, parentBone, BABYLON.Matrix.FromArray(parsedBone.matrix));
  61. if (parsedBone.animation) {
  62. bone.animations.push(parseAnimation(parsedBone.animation));
  63. }
  64. }
  65. return skeleton;
  66. };
  67. var parseFresnelParameters = (parsedFresnelParameters) => {
  68. var fresnelParameters = new BABYLON.FresnelParameters();
  69. fresnelParameters.isEnabled = parsedFresnelParameters.isEnabled;
  70. fresnelParameters.leftColor = BABYLON.Color3.FromArray(parsedFresnelParameters.leftColor);
  71. fresnelParameters.rightColor = BABYLON.Color3.FromArray(parsedFresnelParameters.rightColor);
  72. fresnelParameters.bias = parsedFresnelParameters.bias;
  73. fresnelParameters.power = parsedFresnelParameters.power || 1.0;
  74. return fresnelParameters;
  75. }
  76. var parseMaterial = (parsedMaterial, scene, rootUrl) => {
  77. var material;
  78. material = new BABYLON.StandardMaterial(parsedMaterial.name, scene);
  79. material.ambientColor = BABYLON.Color3.FromArray(parsedMaterial.ambient);
  80. material.diffuseColor = BABYLON.Color3.FromArray(parsedMaterial.diffuse);
  81. material.specularColor = BABYLON.Color3.FromArray(parsedMaterial.specular);
  82. material.specularPower = parsedMaterial.specularPower;
  83. material.emissiveColor = BABYLON.Color3.FromArray(parsedMaterial.emissive);
  84. material.alpha = parsedMaterial.alpha;
  85. material.id = parsedMaterial.id;
  86. BABYLON.Tags.AddTagsTo(material, parsedMaterial.tags);
  87. material.backFaceCulling = parsedMaterial.backFaceCulling;
  88. material.wireframe = parsedMaterial.wireframe;
  89. if (parsedMaterial.diffuseTexture) {
  90. material.diffuseTexture = loadTexture(rootUrl, parsedMaterial.diffuseTexture, scene);
  91. }
  92. if (parsedMaterial.diffuseFresnelParameters) {
  93. material.diffuseFresnelParameters = parseFresnelParameters(parsedMaterial.diffuseFresnelParameters);
  94. }
  95. if (parsedMaterial.ambientTexture) {
  96. material.ambientTexture = loadTexture(rootUrl, parsedMaterial.ambientTexture, scene);
  97. }
  98. if (parsedMaterial.opacityTexture) {
  99. material.opacityTexture = loadTexture(rootUrl, parsedMaterial.opacityTexture, scene);
  100. }
  101. if (parsedMaterial.opacityFresnelParameters) {
  102. material.opacityFresnelParameters = parseFresnelParameters(parsedMaterial.opacityFresnelParameters);
  103. }
  104. if (parsedMaterial.reflectionTexture) {
  105. material.reflectionTexture = loadTexture(rootUrl, parsedMaterial.reflectionTexture, scene);
  106. }
  107. if (parsedMaterial.reflectionFresnelParameters) {
  108. material.reflectionFresnelParameters = parseFresnelParameters(parsedMaterial.reflectionFresnelParameters);
  109. }
  110. if (parsedMaterial.emissiveTexture) {
  111. material.emissiveTexture = loadTexture(rootUrl, parsedMaterial.emissiveTexture, scene);
  112. }
  113. if (parsedMaterial.emissiveFresnelParameters) {
  114. material.emissiveFresnelParameters = parseFresnelParameters(parsedMaterial.emissiveFresnelParameters);
  115. }
  116. if (parsedMaterial.specularTexture) {
  117. material.specularTexture = loadTexture(rootUrl, parsedMaterial.specularTexture, scene);
  118. }
  119. if (parsedMaterial.bumpTexture) {
  120. material.bumpTexture = loadTexture(rootUrl, parsedMaterial.bumpTexture, scene);
  121. }
  122. return material;
  123. };
  124. var parseMaterialById = (id, parsedData, scene, rootUrl) => {
  125. for (var index = 0; index < parsedData.materials.length; index++) {
  126. var parsedMaterial = parsedData.materials[index];
  127. if (parsedMaterial.id === id) {
  128. return parseMaterial(parsedMaterial, scene, rootUrl);
  129. }
  130. }
  131. return null;
  132. };
  133. var parseMultiMaterial = (parsedMultiMaterial, scene) => {
  134. var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
  135. multiMaterial.id = parsedMultiMaterial.id;
  136. BABYLON.Tags.AddTagsTo(multiMaterial, parsedMultiMaterial.tags);
  137. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  138. var subMatId = parsedMultiMaterial.materials[matIndex];
  139. if (subMatId) {
  140. multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
  141. } else {
  142. multiMaterial.subMaterials.push(null);
  143. }
  144. }
  145. return multiMaterial;
  146. };
  147. var parseLensFlareSystem = (parsedLensFlareSystem, scene, rootUrl) => {
  148. var emitter = scene.getLastEntryByID(parsedLensFlareSystem.emitterId);
  149. var lensFlareSystem = new BABYLON.LensFlareSystem("lensFlareSystem#" + parsedLensFlareSystem.emitterId, emitter, scene);
  150. lensFlareSystem.borderLimit = parsedLensFlareSystem.borderLimit;
  151. for (var index = 0; index < parsedLensFlareSystem.flares.length; index++) {
  152. var parsedFlare = parsedLensFlareSystem.flares[index];
  153. var flare = new BABYLON.LensFlare(parsedFlare.size, parsedFlare.position, BABYLON.Color3.FromArray(parsedFlare.color), rootUrl + parsedFlare.textureName, lensFlareSystem);
  154. }
  155. return lensFlareSystem;
  156. };
  157. var parseParticleSystem = (parsedParticleSystem, scene, rootUrl) => {
  158. var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
  159. var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
  160. if (parsedParticleSystem.textureName) {
  161. particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
  162. particleSystem.particleTexture.name = parsedParticleSystem.textureName;
  163. }
  164. particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
  165. particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
  166. particleSystem.minSize = parsedParticleSystem.minSize;
  167. particleSystem.maxSize = parsedParticleSystem.maxSize;
  168. particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
  169. particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
  170. particleSystem.emitter = emitter;
  171. particleSystem.emitRate = parsedParticleSystem.emitRate;
  172. particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
  173. particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
  174. particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
  175. particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
  176. particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
  177. particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
  178. particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
  179. particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
  180. particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
  181. particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
  182. particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
  183. particleSystem.blendMode = parsedParticleSystem.blendMode;
  184. particleSystem.start();
  185. return particleSystem;
  186. };
  187. var parseShadowGenerator = (parsedShadowGenerator, scene) => {
  188. var light = scene.getLightByID(parsedShadowGenerator.lightId);
  189. var shadowGenerator = new BABYLON.ShadowGenerator(parsedShadowGenerator.mapSize, light);
  190. for (var meshIndex = 0; meshIndex < parsedShadowGenerator.renderList.length; meshIndex++) {
  191. var mesh = scene.getMeshByID(parsedShadowGenerator.renderList[meshIndex]);
  192. shadowGenerator.getShadowMap().renderList.push(mesh);
  193. }
  194. if (parsedShadowGenerator.usePoissonSampling) {
  195. shadowGenerator.usePoissonSampling = true;
  196. } else {
  197. shadowGenerator.useVarianceShadowMap = parsedShadowGenerator.useVarianceShadowMap;
  198. }
  199. return shadowGenerator;
  200. };
  201. var parseAnimation = parsedAnimation => {
  202. var animation = new BABYLON.Animation(parsedAnimation.name, parsedAnimation.property, parsedAnimation.framePerSecond, parsedAnimation.dataType, parsedAnimation.loopBehavior);
  203. var dataType = parsedAnimation.dataType;
  204. var keys = [];
  205. for (var index = 0; index < parsedAnimation.keys.length; index++) {
  206. var key = parsedAnimation.keys[index];
  207. var data;
  208. switch (dataType) {
  209. case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
  210. data = key.values[0];
  211. break;
  212. case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
  213. data = BABYLON.Quaternion.FromArray(key.values);
  214. break;
  215. case BABYLON.Animation.ANIMATIONTYPE_MATRIX:
  216. data = BABYLON.Matrix.FromArray(key.values);
  217. break;
  218. case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
  219. default:
  220. data = BABYLON.Vector3.FromArray(key.values);
  221. break;
  222. }
  223. keys.push({
  224. frame: key.frame,
  225. value: data
  226. });
  227. }
  228. animation.setKeys(keys);
  229. return animation;
  230. };
  231. var parseLight = (parsedLight, scene) => {
  232. var light;
  233. switch (parsedLight.type) {
  234. case 0:
  235. light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), scene);
  236. break;
  237. case 1:
  238. light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  239. light.position = BABYLON.Vector3.FromArray(parsedLight.position);
  240. break;
  241. case 2:
  242. light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.position), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
  243. break;
  244. case 3:
  245. light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.direction), scene);
  246. light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
  247. break;
  248. }
  249. light.id = parsedLight.id;
  250. BABYLON.Tags.AddTagsTo(light, parsedLight.tags);
  251. if (parsedLight.intensity !== undefined) {
  252. light.intensity = parsedLight.intensity;
  253. }
  254. if (parsedLight.range) {
  255. light.range = parsedLight.range;
  256. }
  257. light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
  258. light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
  259. if (parsedLight.excludedMeshesIds) {
  260. light._excludedMeshesIds = parsedLight.excludedMeshesIds;
  261. }
  262. // Parent
  263. if (parsedLight.parentId) {
  264. light._waitingParentId = parsedLight.parentId;
  265. }
  266. // Parent
  267. if (parsedLight.parentId) {
  268. light._waitingParentId = parsedLight.parentId;
  269. }
  270. if (parsedLight.includedOnlyMeshesIds) {
  271. light._includedOnlyMeshesIds = parsedLight.includedOnlyMeshesIds;
  272. }
  273. // Animations
  274. if (parsedLight.animations) {
  275. for (var animationIndex = 0; animationIndex < parsedLight.animations.length; animationIndex++) {
  276. var parsedAnimation = parsedLight.animations[animationIndex];
  277. light.animations.push(parseAnimation(parsedAnimation));
  278. }
  279. }
  280. if (parsedLight.autoAnimate) {
  281. scene.beginAnimation(light, parsedLight.autoAnimateFrom, parsedLight.autoAnimateTo, parsedLight.autoAnimateLoop, 1.0);
  282. }
  283. };
  284. var parseCamera = (parsedCamera, scene: Scene) => {
  285. var camera;
  286. var position = Vector3.FromArray(parsedCamera.position);
  287. var lockedTargetMesh = (parsedCamera.lockedTargetId) ? scene.getLastMeshByID(parsedCamera.lockedTargetId) : null;
  288. if (parsedCamera.type === "AnaglyphArcRotateCamera" || parsedCamera.type === "ArcRotateCamera") {
  289. var alpha = parsedCamera.alpha;
  290. var beta = parsedCamera.beta;
  291. var radius = parsedCamera.radius;
  292. if (parsedCamera.type === "AnaglyphArcRotateCamera") {
  293. var eye_space = parsedCamera.eye_space;
  294. camera = new AnaglyphArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, eye_space, scene);
  295. } else {
  296. camera = new ArcRotateCamera(parsedCamera.name, alpha, beta, radius, lockedTargetMesh, scene);
  297. }
  298. } else if (parsedCamera.type === "AnaglyphFreeCamera") {
  299. var eye_space = parsedCamera.eye_space;
  300. camera = new AnaglyphFreeCamera(parsedCamera.name, position, eye_space, scene);
  301. } else if (parsedCamera.type === "DeviceOrientationCamera") {
  302. camera = new DeviceOrientationCamera(parsedCamera.name, position, scene);
  303. } else if (parsedCamera.type === "FollowCamera") {
  304. camera = new FollowCamera(parsedCamera.name, position, scene);
  305. camera.heightOffset = parsedCamera.heightOffset;
  306. camera.radius = parsedCamera.radius;
  307. camera.rotationOffset = parsedCamera.rotationOffset;
  308. if (lockedTargetMesh)
  309. (<FollowCamera>camera).target = lockedTargetMesh;
  310. } else if (parsedCamera.type === "GamepadCamera") {
  311. camera = new GamepadCamera(parsedCamera.name, position, scene);
  312. } else if (parsedCamera.type === "OculusCamera") {
  313. camera = new OculusCamera(parsedCamera.name, position, scene);
  314. } else if (parsedCamera.type === "TouchCamera") {
  315. camera = new TouchCamera(parsedCamera.name, position, scene);
  316. } else if (parsedCamera.type === "VirtualJoysticksCamera") {
  317. camera = new VirtualJoysticksCamera(parsedCamera.name, position, scene);
  318. } else if (parsedCamera.type === "WebVRCamera") {
  319. camera = new WebVRCamera(parsedCamera.name, position, scene);
  320. } else if (parsedCamera.type === "VRDeviceOrientationCamera") {
  321. camera = new VRDeviceOrientationCamera(parsedCamera.name, position, scene);
  322. } else {
  323. // Free Camera is the default value
  324. camera = new FreeCamera(parsedCamera.name, position, scene);
  325. }
  326. // Test for lockedTargetMesh & FreeCamera outside of if-else-if nest, since things like GamepadCamera extend FreeCamera
  327. if (lockedTargetMesh && camera instanceof FreeCamera) {
  328. (<FreeCamera>camera).lockedTarget = lockedTargetMesh;
  329. }
  330. camera.id = parsedCamera.id;
  331. BABYLON.Tags.AddTagsTo(camera, parsedCamera.tags);
  332. // Parent
  333. if (parsedCamera.parentId) {
  334. camera._waitingParentId = parsedCamera.parentId;
  335. }
  336. // Target
  337. if (parsedCamera.target) {
  338. camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
  339. } else {
  340. camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
  341. }
  342. camera.fov = parsedCamera.fov;
  343. camera.minZ = parsedCamera.minZ;
  344. camera.maxZ = parsedCamera.maxZ;
  345. camera.speed = parsedCamera.speed;
  346. camera.inertia = parsedCamera.inertia;
  347. camera.checkCollisions = parsedCamera.checkCollisions;
  348. camera.applyGravity = parsedCamera.applyGravity;
  349. if (parsedCamera.ellipsoid) {
  350. camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
  351. }
  352. // Animations
  353. if (parsedCamera.animations) {
  354. for (var animationIndex = 0; animationIndex < parsedCamera.animations.length; animationIndex++) {
  355. var parsedAnimation = parsedCamera.animations[animationIndex];
  356. camera.animations.push(parseAnimation(parsedAnimation));
  357. }
  358. }
  359. if (parsedCamera.autoAnimate) {
  360. scene.beginAnimation(camera, parsedCamera.autoAnimateFrom, parsedCamera.autoAnimateTo, parsedCamera.autoAnimateLoop, 1.0);
  361. }
  362. // Layer Mask
  363. if (parsedCamera.layerMask && (!isNaN(parsedCamera.layerMask))) {
  364. camera.layerMask = Math.abs(parseInt(parsedCamera.layerMask));
  365. } else {
  366. camera.layerMask = 0xFFFFFFFF;
  367. }
  368. return camera;
  369. };
  370. var parseGeometry = (parsedGeometry, scene) => {
  371. var id = parsedGeometry.id;
  372. return scene.getGeometryByID(id);
  373. };
  374. var parseBox = (parsedBox, scene) => {
  375. if (parseGeometry(parsedBox, scene)) {
  376. return null; // null since geometry could be something else than a box...
  377. }
  378. var box = new BABYLON.Geometry.Primitives.Box(parsedBox.id, scene, parsedBox.size, parsedBox.canBeRegenerated, null);
  379. BABYLON.Tags.AddTagsTo(box, parsedBox.tags);
  380. scene.pushGeometry(box, true);
  381. return box;
  382. };
  383. var parseSphere = (parsedSphere, scene) => {
  384. if (parseGeometry(parsedSphere, scene)) {
  385. return null; // null since geometry could be something else than a sphere...
  386. }
  387. var sphere = new BABYLON.Geometry.Primitives.Sphere(parsedSphere.id, scene, parsedSphere.segments, parsedSphere.diameter, parsedSphere.canBeRegenerated, null);
  388. BABYLON.Tags.AddTagsTo(sphere, parsedSphere.tags);
  389. scene.pushGeometry(sphere, true);
  390. return sphere;
  391. };
  392. var parseCylinder = (parsedCylinder, scene) => {
  393. if (parseGeometry(parsedCylinder, scene)) {
  394. return null; // null since geometry could be something else than a cylinder...
  395. }
  396. var cylinder = new BABYLON.Geometry.Primitives.Cylinder(parsedCylinder.id, scene, parsedCylinder.height, parsedCylinder.diameterTop, parsedCylinder.diameterBottom, parsedCylinder.tessellation, parsedCylinder.subdivisions, parsedCylinder.canBeRegenerated, null);
  397. BABYLON.Tags.AddTagsTo(cylinder, parsedCylinder.tags);
  398. scene.pushGeometry(cylinder, true);
  399. return cylinder;
  400. };
  401. var parseTorus = (parsedTorus, scene) => {
  402. if (parseGeometry(parsedTorus, scene)) {
  403. return null; // null since geometry could be something else than a torus...
  404. }
  405. var torus = new BABYLON.Geometry.Primitives.Torus(parsedTorus.id, scene, parsedTorus.diameter, parsedTorus.thickness, parsedTorus.tessellation, parsedTorus.canBeRegenerated, null);
  406. BABYLON.Tags.AddTagsTo(torus, parsedTorus.tags);
  407. scene.pushGeometry(torus, true);
  408. return torus;
  409. };
  410. var parseGround = (parsedGround, scene) => {
  411. if (parseGeometry(parsedGround, scene)) {
  412. return null; // null since geometry could be something else than a ground...
  413. }
  414. var ground = new BABYLON.Geometry.Primitives.Ground(parsedGround.id, scene, parsedGround.width, parsedGround.height, parsedGround.subdivisions, parsedGround.canBeRegenerated, null);
  415. BABYLON.Tags.AddTagsTo(ground, parsedGround.tags);
  416. scene.pushGeometry(ground, true);
  417. return ground;
  418. };
  419. var parsePlane = (parsedPlane, scene) => {
  420. if (parseGeometry(parsedPlane, scene)) {
  421. return null; // null since geometry could be something else than a plane...
  422. }
  423. var plane = new BABYLON.Geometry.Primitives.Plane(parsedPlane.id, scene, parsedPlane.size, parsedPlane.canBeRegenerated, null);
  424. BABYLON.Tags.AddTagsTo(plane, parsedPlane.tags);
  425. scene.pushGeometry(plane, true);
  426. return plane;
  427. };
  428. var parseTorusKnot = (parsedTorusKnot, scene) => {
  429. if (parseGeometry(parsedTorusKnot, scene)) {
  430. return null; // null since geometry could be something else than a torusKnot...
  431. }
  432. 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);
  433. BABYLON.Tags.AddTagsTo(torusKnot, parsedTorusKnot.tags);
  434. scene.pushGeometry(torusKnot, true);
  435. return torusKnot;
  436. };
  437. var parseVertexData = (parsedVertexData, scene, rootUrl) => {
  438. if (parseGeometry(parsedVertexData, scene)) {
  439. return null; // null since geometry could be a primitive
  440. }
  441. var geometry = new BABYLON.Geometry(parsedVertexData.id, scene);
  442. BABYLON.Tags.AddTagsTo(geometry, parsedVertexData.tags);
  443. if (parsedVertexData.delayLoadingFile) {
  444. geometry.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
  445. geometry.delayLoadingFile = rootUrl + parsedVertexData.delayLoadingFile;
  446. geometry._boundingInfo = new BABYLON.BoundingInfo(BABYLON.Vector3.FromArray(parsedVertexData.boundingBoxMinimum), BABYLON.Vector3.FromArray(parsedVertexData.boundingBoxMaximum));
  447. geometry._delayInfo = [];
  448. if (parsedVertexData.hasUVs) {
  449. geometry._delayInfo.push(BABYLON.VertexBuffer.UVKind);
  450. }
  451. if (parsedVertexData.hasUVs2) {
  452. geometry._delayInfo.push(BABYLON.VertexBuffer.UV2Kind);
  453. }
  454. if (parsedVertexData.hasColors) {
  455. geometry._delayInfo.push(BABYLON.VertexBuffer.ColorKind);
  456. }
  457. if (parsedVertexData.hasMatricesIndices) {
  458. geometry._delayInfo.push(BABYLON.VertexBuffer.MatricesIndicesKind);
  459. }
  460. if (parsedVertexData.hasMatricesWeights) {
  461. geometry._delayInfo.push(BABYLON.VertexBuffer.MatricesWeightsKind);
  462. }
  463. geometry._delayLoadingFunction = importVertexData;
  464. } else {
  465. importVertexData(parsedVertexData, geometry);
  466. }
  467. scene.pushGeometry(geometry, true);
  468. return geometry;
  469. };
  470. var parseMesh = (parsedMesh, scene, rootUrl) => {
  471. var mesh = new BABYLON.Mesh(parsedMesh.name, scene);
  472. mesh.id = parsedMesh.id;
  473. BABYLON.Tags.AddTagsTo(mesh, parsedMesh.tags);
  474. mesh.position = BABYLON.Vector3.FromArray(parsedMesh.position);
  475. if (parsedMesh.rotationQuaternion) {
  476. mesh.rotationQuaternion = BABYLON.Quaternion.FromArray(parsedMesh.rotationQuaternion);
  477. } else if (parsedMesh.rotation) {
  478. mesh.rotation = BABYLON.Vector3.FromArray(parsedMesh.rotation);
  479. }
  480. mesh.scaling = BABYLON.Vector3.FromArray(parsedMesh.scaling);
  481. if (parsedMesh.localMatrix) {
  482. mesh.setPivotMatrix(BABYLON.Matrix.FromArray(parsedMesh.localMatrix));
  483. } else if (parsedMesh.pivotMatrix) {
  484. mesh.setPivotMatrix(BABYLON.Matrix.FromArray(parsedMesh.pivotMatrix));
  485. }
  486. mesh.setEnabled(parsedMesh.isEnabled);
  487. mesh.isVisible = parsedMesh.isVisible;
  488. mesh.infiniteDistance = parsedMesh.infiniteDistance;
  489. mesh.showBoundingBox = parsedMesh.showBoundingBox;
  490. mesh.showSubMeshesBoundingBox = parsedMesh.showSubMeshesBoundingBox;
  491. if (parsedMesh.pickable !== undefined) {
  492. mesh.isPickable = parsedMesh.pickable;
  493. }
  494. mesh.receiveShadows = parsedMesh.receiveShadows;
  495. mesh.billboardMode = parsedMesh.billboardMode;
  496. if (parsedMesh.visibility !== undefined) {
  497. mesh.visibility = parsedMesh.visibility;
  498. }
  499. mesh.checkCollisions = parsedMesh.checkCollisions;
  500. mesh._shouldGenerateFlatShading = parsedMesh.useFlatShading;
  501. // Parent
  502. if (parsedMesh.parentId) {
  503. mesh._waitingParentId = parsedMesh.parentId;
  504. }
  505. // Geometry
  506. if (parsedMesh.delayLoadingFile) {
  507. mesh.delayLoadState = BABYLON.Engine.DELAYLOADSTATE_NOTLOADED;
  508. mesh.delayLoadingFile = rootUrl + parsedMesh.delayLoadingFile;
  509. mesh._boundingInfo = new BABYLON.BoundingInfo(BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMinimum), BABYLON.Vector3.FromArray(parsedMesh.boundingBoxMaximum));
  510. if (parsedMesh._binaryInfo) {
  511. mesh._binaryInfo = parsedMesh._binaryInfo;
  512. }
  513. mesh._delayInfo = [];
  514. if (parsedMesh.hasUVs) {
  515. mesh._delayInfo.push(BABYLON.VertexBuffer.UVKind);
  516. }
  517. if (parsedMesh.hasUVs2) {
  518. mesh._delayInfo.push(BABYLON.VertexBuffer.UV2Kind);
  519. }
  520. if (parsedMesh.hasColors) {
  521. mesh._delayInfo.push(BABYLON.VertexBuffer.ColorKind);
  522. }
  523. if (parsedMesh.hasMatricesIndices) {
  524. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesIndicesKind);
  525. }
  526. if (parsedMesh.hasMatricesWeights) {
  527. mesh._delayInfo.push(BABYLON.VertexBuffer.MatricesWeightsKind);
  528. }
  529. mesh._delayLoadingFunction = importGeometry;
  530. if (BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental) {
  531. mesh._checkDelayState();
  532. }
  533. } else {
  534. importGeometry(parsedMesh, mesh);
  535. }
  536. // Material
  537. if (parsedMesh.materialId) {
  538. mesh.setMaterialByID(parsedMesh.materialId);
  539. } else {
  540. mesh.material = null;
  541. }
  542. // Skeleton
  543. if (parsedMesh.skeletonId > -1) {
  544. mesh.skeleton = scene.getLastSkeletonByID(parsedMesh.skeletonId);
  545. }
  546. // Physics
  547. if (parsedMesh.physicsImpostor) {
  548. if (!scene.isPhysicsEnabled()) {
  549. scene.enablePhysics();
  550. }
  551. mesh.setPhysicsState({ impostor: parsedMesh.physicsImpostor, mass: parsedMesh.physicsMass, friction: parsedMesh.physicsFriction, restitution: parsedMesh.physicsRestitution });
  552. }
  553. // Animations
  554. if (parsedMesh.animations) {
  555. for (var animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  556. var parsedAnimation = parsedMesh.animations[animationIndex];
  557. mesh.animations.push(parseAnimation(parsedAnimation));
  558. }
  559. }
  560. if (parsedMesh.autoAnimate) {
  561. scene.beginAnimation(mesh, parsedMesh.autoAnimateFrom, parsedMesh.autoAnimateTo, parsedMesh.autoAnimateLoop, 1.0);
  562. }
  563. // Layer Mask
  564. if (parsedMesh.layerMask && (!isNaN(parsedMesh.layerMask))) {
  565. mesh.layerMask = Math.abs(parseInt(parsedMesh.layerMask));
  566. } else {
  567. mesh.layerMask = 0xFFFFFFFF;
  568. }
  569. // Instances
  570. if (parsedMesh.instances) {
  571. for (var index = 0; index < parsedMesh.instances.length; index++) {
  572. var parsedInstance = parsedMesh.instances[index];
  573. var instance = mesh.createInstance(parsedInstance.name);
  574. BABYLON.Tags.AddTagsTo(instance, parsedInstance.tags);
  575. instance.position = BABYLON.Vector3.FromArray(parsedInstance.position);
  576. if (parsedInstance.rotationQuaternion) {
  577. instance.rotationQuaternion = BABYLON.Quaternion.FromArray(parsedInstance.rotationQuaternion);
  578. } else if (parsedInstance.rotation) {
  579. instance.rotation = BABYLON.Vector3.FromArray(parsedInstance.rotation);
  580. }
  581. instance.scaling = BABYLON.Vector3.FromArray(parsedInstance.scaling);
  582. instance.checkCollisions = mesh.checkCollisions;
  583. if (parsedMesh.animations) {
  584. for (animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  585. parsedAnimation = parsedMesh.animations[animationIndex];
  586. instance.animations.push(parseAnimation(parsedAnimation));
  587. }
  588. }
  589. }
  590. }
  591. return mesh;
  592. };
  593. var isDescendantOf = (mesh, names, hierarchyIds) => {
  594. names = (names instanceof Array) ? names : [names];
  595. for (var i in names) {
  596. if (mesh.name === names[i]) {
  597. hierarchyIds.push(mesh.id);
  598. return true;
  599. }
  600. }
  601. if (mesh.parentId && hierarchyIds.indexOf(mesh.parentId) !== -1) {
  602. hierarchyIds.push(mesh.id);
  603. return true;
  604. }
  605. return false;
  606. };
  607. var importVertexData = (parsedVertexData, geometry) => {
  608. var vertexData = new BABYLON.VertexData();
  609. // positions
  610. var positions = parsedVertexData.positions;
  611. if (positions) {
  612. vertexData.set(positions, BABYLON.VertexBuffer.PositionKind);
  613. }
  614. // normals
  615. var normals = parsedVertexData.normals;
  616. if (normals) {
  617. vertexData.set(normals, BABYLON.VertexBuffer.NormalKind);
  618. }
  619. // uvs
  620. var uvs = parsedVertexData.uvs;
  621. if (uvs) {
  622. vertexData.set(uvs, BABYLON.VertexBuffer.UVKind);
  623. }
  624. // uv2s
  625. var uv2s = parsedVertexData.uv2s;
  626. if (uv2s) {
  627. vertexData.set(uv2s, BABYLON.VertexBuffer.UV2Kind);
  628. }
  629. // colors
  630. var colors = parsedVertexData.colors;
  631. if (colors) {
  632. vertexData.set(colors, BABYLON.VertexBuffer.ColorKind);
  633. }
  634. // matricesIndices
  635. var matricesIndices = parsedVertexData.matricesIndices;
  636. if (matricesIndices) {
  637. vertexData.set(matricesIndices, BABYLON.VertexBuffer.MatricesIndicesKind);
  638. }
  639. // matricesWeights
  640. var matricesWeights = parsedVertexData.matricesWeights;
  641. if (matricesWeights) {
  642. vertexData.set(matricesWeights, BABYLON.VertexBuffer.MatricesWeightsKind);
  643. }
  644. // indices
  645. var indices = parsedVertexData.indices;
  646. if (indices) {
  647. vertexData.indices = indices;
  648. }
  649. geometry.setAllVerticesData(vertexData, parsedVertexData.updatable);
  650. };
  651. var importGeometry = (parsedGeometry, mesh) => {
  652. var scene = mesh.getScene();
  653. // Geometry
  654. var geometryId = parsedGeometry.geometryId;
  655. if (geometryId) {
  656. var geometry = scene.getGeometryByID(geometryId);
  657. if (geometry) {
  658. geometry.applyToMesh(mesh);
  659. }
  660. } else if (parsedGeometry instanceof ArrayBuffer) {
  661. var binaryInfo = mesh._binaryInfo;
  662. if (binaryInfo.positionsAttrDesc && binaryInfo.positionsAttrDesc.count > 0) {
  663. var positionsData = new Float32Array(parsedGeometry, binaryInfo.positionsAttrDesc.offset, binaryInfo.positionsAttrDesc.count);
  664. mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, positionsData, false);
  665. }
  666. if (binaryInfo.normalsAttrDesc && binaryInfo.normalsAttrDesc.count > 0) {
  667. var normalsData = new Float32Array(parsedGeometry, binaryInfo.normalsAttrDesc.offset, binaryInfo.normalsAttrDesc.count);
  668. mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, normalsData, false);
  669. }
  670. if (binaryInfo.uvsAttrDesc && binaryInfo.uvsAttrDesc.count > 0) {
  671. var uvsData = new Float32Array(parsedGeometry, binaryInfo.uvsAttrDesc.offset, binaryInfo.uvsAttrDesc.count);
  672. mesh.setVerticesData(BABYLON.VertexBuffer.UVKind, uvsData, false);
  673. }
  674. if (binaryInfo.uvs2AttrDesc && binaryInfo.uvs2AttrDesc.count > 0) {
  675. var uvs2Data = new Float32Array(parsedGeometry, binaryInfo.uvs2AttrDesc.offset, binaryInfo.uvs2AttrDesc.count);
  676. mesh.setVerticesData(BABYLON.VertexBuffer.UV2Kind, uvs2Data, false);
  677. }
  678. if (binaryInfo.colorsAttrDesc && binaryInfo.colorsAttrDesc.count > 0) {
  679. var colorsData = new Float32Array(parsedGeometry, binaryInfo.colorsAttrDesc.offset, binaryInfo.colorsAttrDesc.count);
  680. mesh.setVerticesData(BABYLON.VertexBuffer.ColorKind, colorsData, false);
  681. }
  682. if (binaryInfo.matricesIndicesAttrDesc && binaryInfo.matricesIndicesAttrDesc.count > 0) {
  683. var matricesIndicesData = new Int32Array(parsedGeometry, binaryInfo.matricesIndicesAttrDesc.offset, binaryInfo.matricesIndicesAttrDesc.count);
  684. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, matricesIndicesData, false);
  685. }
  686. if (binaryInfo.matricesWeightsAttrDesc && binaryInfo.matricesWeightsAttrDesc.count > 0) {
  687. var matricesWeightsData = new Float32Array(parsedGeometry, binaryInfo.matricesWeightsAttrDesc.offset, binaryInfo.matricesWeightsAttrDesc.count);
  688. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, matricesWeightsData, false);
  689. }
  690. if (binaryInfo.indicesAttrDesc && binaryInfo.indicesAttrDesc.count > 0) {
  691. var indicesData = new Int32Array(parsedGeometry, binaryInfo.indicesAttrDesc.offset, binaryInfo.indicesAttrDesc.count);
  692. mesh.setIndices(indicesData);
  693. }
  694. if (binaryInfo.subMeshesAttrDesc && binaryInfo.subMeshesAttrDesc.count > 0) {
  695. var subMeshesData = new Int32Array(parsedGeometry, binaryInfo.subMeshesAttrDesc.offset, binaryInfo.subMeshesAttrDesc.count * 5);
  696. mesh.subMeshes = [];
  697. for (var i = 0; i < binaryInfo.subMeshesAttrDesc.count; i++) {
  698. var materialIndex = subMeshesData[(i * 5) + 0];
  699. var verticesStart = subMeshesData[(i * 5) + 1];
  700. var verticesCount = subMeshesData[(i * 5) + 2];
  701. var indexStart = subMeshesData[(i * 5) + 3];
  702. var indexCount = subMeshesData[(i * 5) + 4];
  703. var subMesh = new BABYLON.SubMesh(materialIndex, verticesStart, verticesCount, indexStart, indexCount, mesh);
  704. }
  705. }
  706. } else if (parsedGeometry.positions && parsedGeometry.normals && parsedGeometry.indices) {
  707. mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, parsedGeometry.positions, false);
  708. mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, parsedGeometry.normals, false);
  709. if (parsedGeometry.uvs) {
  710. mesh.setVerticesData(BABYLON.VertexBuffer.UVKind, parsedGeometry.uvs, false);
  711. }
  712. if (parsedGeometry.uvs2) {
  713. mesh.setVerticesData(BABYLON.VertexBuffer.UV2Kind, parsedGeometry.uvs2, false);
  714. }
  715. if (parsedGeometry.colors) {
  716. mesh.setVerticesData(BABYLON.VertexBuffer.ColorKind, parsedGeometry.colors, false);
  717. }
  718. if (parsedGeometry.matricesIndices) {
  719. if (!parsedGeometry.matricesIndices._isExpanded) {
  720. var floatIndices = [];
  721. for (var i = 0; i < parsedGeometry.matricesIndices.length; i++) {
  722. var matricesIndex = parsedGeometry.matricesIndices[i];
  723. floatIndices.push(matricesIndex & 0x000000FF);
  724. floatIndices.push((matricesIndex & 0x0000FF00) >> 8);
  725. floatIndices.push((matricesIndex & 0x00FF0000) >> 16);
  726. floatIndices.push(matricesIndex >> 24);
  727. }
  728. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, floatIndices, false);
  729. } else {
  730. delete parsedGeometry.matricesIndices._isExpanded;
  731. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind, parsedGeometry.matricesIndices, false);
  732. }
  733. }
  734. if (parsedGeometry.matricesWeights) {
  735. mesh.setVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind, parsedGeometry.matricesWeights, false);
  736. }
  737. mesh.setIndices(parsedGeometry.indices);
  738. // SubMeshes
  739. if (parsedGeometry.subMeshes) {
  740. mesh.subMeshes = [];
  741. for (var subIndex = 0; subIndex < parsedGeometry.subMeshes.length; subIndex++) {
  742. var parsedSubMesh = parsedGeometry.subMeshes[subIndex];
  743. var subMesh = new BABYLON.SubMesh(parsedSubMesh.materialIndex, parsedSubMesh.verticesStart, parsedSubMesh.verticesCount, parsedSubMesh.indexStart, parsedSubMesh.indexCount, mesh);
  744. }
  745. }
  746. }
  747. // Flat shading
  748. if (mesh._shouldGenerateFlatShading) {
  749. mesh.convertToFlatShadedMesh();
  750. delete mesh._shouldGenerateFlatShading;
  751. }
  752. // Update
  753. mesh.computeWorldMatrix(true);
  754. // Octree
  755. if (scene._selectionOctree) {
  756. scene._selectionOctree.addMesh(mesh);
  757. }
  758. };
  759. BABYLON.SceneLoader.RegisterPlugin({
  760. extensions: ".babylon",
  761. importMesh: (meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: AbstractMesh[], particleSystems: ParticleSystem[], skeletons: Skeleton[]): boolean => {
  762. var parsedData = JSON.parse(data);
  763. var loadedSkeletonsIds = [];
  764. var loadedMaterialsIds = [];
  765. var hierarchyIds = [];
  766. for (var index = 0; index < parsedData.meshes.length; index++) {
  767. var parsedMesh = parsedData.meshes[index];
  768. if (!meshesNames || isDescendantOf(parsedMesh, meshesNames, hierarchyIds)) {
  769. if (meshesNames instanceof Array) {
  770. // Remove found mesh name from list.
  771. delete meshesNames[meshesNames.indexOf(parsedMesh.name)];
  772. }
  773. // Material ?
  774. if (parsedMesh.materialId) {
  775. var materialFound = (loadedMaterialsIds.indexOf(parsedMesh.materialId) !== -1);
  776. if (!materialFound) {
  777. for (var multimatIndex = 0; multimatIndex < parsedData.multiMaterials.length; multimatIndex++) {
  778. var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
  779. if (parsedMultiMaterial.id == parsedMesh.materialId) {
  780. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  781. var subMatId = parsedMultiMaterial.materials[matIndex];
  782. loadedMaterialsIds.push(subMatId);
  783. parseMaterialById(subMatId, parsedData, scene, rootUrl);
  784. }
  785. loadedMaterialsIds.push(parsedMultiMaterial.id);
  786. parseMultiMaterial(parsedMultiMaterial, scene);
  787. materialFound = true;
  788. break;
  789. }
  790. }
  791. }
  792. if (!materialFound) {
  793. loadedMaterialsIds.push(parsedMesh.materialId);
  794. parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
  795. }
  796. }
  797. // Skeleton ?
  798. if (parsedMesh.skeletonId > -1 && scene.skeletons) {
  799. var skeletonAlreadyLoaded = (loadedSkeletonsIds.indexOf(parsedMesh.skeletonId) > -1);
  800. if (!skeletonAlreadyLoaded) {
  801. for (var skeletonIndex = 0; skeletonIndex < parsedData.skeletons.length; skeletonIndex++) {
  802. var parsedSkeleton = parsedData.skeletons[skeletonIndex];
  803. if (parsedSkeleton.id === parsedMesh.skeletonId) {
  804. skeletons.push(parseSkeleton(parsedSkeleton, scene));
  805. loadedSkeletonsIds.push(parsedSkeleton.id);
  806. }
  807. }
  808. }
  809. }
  810. var mesh = parseMesh(parsedMesh, scene, rootUrl);
  811. meshes.push(mesh);
  812. }
  813. }
  814. // Connecting parents
  815. for (index = 0; index < scene.meshes.length; index++) {
  816. var currentMesh = scene.meshes[index];
  817. if (currentMesh._waitingParentId) {
  818. currentMesh.parent = scene.getLastEntryByID(currentMesh._waitingParentId);
  819. currentMesh._waitingParentId = undefined;
  820. }
  821. }
  822. // Particles
  823. if (parsedData.particleSystems) {
  824. for (index = 0; index < parsedData.particleSystems.length; index++) {
  825. var parsedParticleSystem = parsedData.particleSystems[index];
  826. if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
  827. particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
  828. }
  829. }
  830. }
  831. return true;
  832. },
  833. load: (scene: Scene, data: string, rootUrl: string): boolean => {
  834. var parsedData = JSON.parse(data);
  835. // Scene
  836. scene.useDelayedTextureLoading = parsedData.useDelayedTextureLoading && !BABYLON.SceneLoader.ForceFullSceneLoadingForIncremental;
  837. scene.autoClear = parsedData.autoClear;
  838. scene.clearColor = BABYLON.Color3.FromArray(parsedData.clearColor);
  839. scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
  840. scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
  841. // Fog
  842. if (parsedData.fogMode && parsedData.fogMode !== 0) {
  843. scene.fogMode = parsedData.fogMode;
  844. scene.fogColor = BABYLON.Color3.FromArray(parsedData.fogColor);
  845. scene.fogStart = parsedData.fogStart;
  846. scene.fogEnd = parsedData.fogEnd;
  847. scene.fogDensity = parsedData.fogDensity;
  848. }
  849. // Lights
  850. for (var index = 0; index < parsedData.lights.length; index++) {
  851. var parsedLight = parsedData.lights[index];
  852. parseLight(parsedLight, scene);
  853. }
  854. // Materials
  855. if (parsedData.materials) {
  856. for (index = 0; index < parsedData.materials.length; index++) {
  857. var parsedMaterial = parsedData.materials[index];
  858. parseMaterial(parsedMaterial, scene, rootUrl);
  859. }
  860. }
  861. if (parsedData.multiMaterials) {
  862. for (index = 0; index < parsedData.multiMaterials.length; index++) {
  863. var parsedMultiMaterial = parsedData.multiMaterials[index];
  864. parseMultiMaterial(parsedMultiMaterial, scene);
  865. }
  866. }
  867. // Skeletons
  868. if (parsedData.skeletons) {
  869. for (index = 0; index < parsedData.skeletons.length; index++) {
  870. var parsedSkeleton = parsedData.skeletons[index];
  871. parseSkeleton(parsedSkeleton, scene);
  872. }
  873. }
  874. // Geometries
  875. var geometries = parsedData.geometries;
  876. if (geometries) {
  877. // Boxes
  878. var boxes = geometries.boxes;
  879. if (boxes) {
  880. for (index = 0; index < boxes.length; index++) {
  881. var parsedBox = boxes[index];
  882. parseBox(parsedBox, scene);
  883. }
  884. }
  885. // Spheres
  886. var spheres = geometries.spheres;
  887. if (spheres) {
  888. for (index = 0; index < spheres.length; index++) {
  889. var parsedSphere = spheres[index];
  890. parseSphere(parsedSphere, scene);
  891. }
  892. }
  893. // Cylinders
  894. var cylinders = geometries.cylinders;
  895. if (cylinders) {
  896. for (index = 0; index < cylinders.length; index++) {
  897. var parsedCylinder = cylinders[index];
  898. parseCylinder(parsedCylinder, scene);
  899. }
  900. }
  901. // Toruses
  902. var toruses = geometries.toruses;
  903. if (toruses) {
  904. for (index = 0; index < toruses.length; index++) {
  905. var parsedTorus = toruses[index];
  906. parseTorus(parsedTorus, scene);
  907. }
  908. }
  909. // Grounds
  910. var grounds = geometries.grounds;
  911. if (grounds) {
  912. for (index = 0; index < grounds.length; index++) {
  913. var parsedGround = grounds[index];
  914. parseGround(parsedGround, scene);
  915. }
  916. }
  917. // Planes
  918. var planes = geometries.planes;
  919. if (planes) {
  920. for (index = 0; index < planes.length; index++) {
  921. var parsedPlane = planes[index];
  922. parsePlane(parsedPlane, scene);
  923. }
  924. }
  925. // TorusKnots
  926. var torusKnots = geometries.torusKnots;
  927. if (torusKnots) {
  928. for (index = 0; index < torusKnots.length; index++) {
  929. var parsedTorusKnot = torusKnots[index];
  930. parseTorusKnot(parsedTorusKnot, scene);
  931. }
  932. }
  933. // VertexData
  934. var vertexData = geometries.vertexData;
  935. if (vertexData) {
  936. for (index = 0; index < vertexData.length; index++) {
  937. var parsedVertexData = vertexData[index];
  938. parseVertexData(parsedVertexData, scene, rootUrl);
  939. }
  940. }
  941. }
  942. // Meshes
  943. for (index = 0; index < parsedData.meshes.length; index++) {
  944. var parsedMesh = parsedData.meshes[index];
  945. parseMesh(parsedMesh, scene, rootUrl);
  946. }
  947. // Cameras
  948. for (index = 0; index < parsedData.cameras.length; index++) {
  949. var parsedCamera = parsedData.cameras[index];
  950. parseCamera(parsedCamera, scene);
  951. }
  952. if (parsedData.activeCameraID) {
  953. scene.setActiveCameraByID(parsedData.activeCameraID);
  954. }
  955. // Connecting parents
  956. for (index = 0; index < scene.cameras.length; index++) {
  957. var camera = scene.cameras[index];
  958. if (camera._waitingParentId) {
  959. camera.parent = scene.getLastEntryByID(camera._waitingParentId);
  960. camera._waitingParentId = undefined;
  961. }
  962. }
  963. for (index = 0; index < scene.lights.length; index++) {
  964. var light = scene.lights[index];
  965. if (light._waitingParentId) {
  966. light.parent = scene.getLastEntryByID(light._waitingParentId);
  967. light._waitingParentId = undefined;
  968. }
  969. }
  970. for (index = 0; index < scene.lights.length; index++) {
  971. var light = scene.lights[index];
  972. if (light._waitingParentId) {
  973. light.parent = scene.getLastEntryByID(light._waitingParentId);
  974. light._waitingParentId = undefined;
  975. }
  976. }
  977. for (index = 0; index < scene.meshes.length; index++) {
  978. var mesh = scene.meshes[index];
  979. if (mesh._waitingParentId) {
  980. mesh.parent = scene.getLastEntryByID(mesh._waitingParentId);
  981. mesh._waitingParentId = undefined;
  982. }
  983. }
  984. // Particles Systems
  985. if (parsedData.particleSystems) {
  986. for (index = 0; index < parsedData.particleSystems.length; index++) {
  987. var parsedParticleSystem = parsedData.particleSystems[index];
  988. parseParticleSystem(parsedParticleSystem, scene, rootUrl);
  989. }
  990. }
  991. // Lens flares
  992. if (parsedData.lensFlareSystems) {
  993. for (index = 0; index < parsedData.lensFlareSystems.length; index++) {
  994. var parsedLensFlareSystem = parsedData.lensFlareSystems[index];
  995. parseLensFlareSystem(parsedLensFlareSystem, scene, rootUrl);
  996. }
  997. }
  998. // Shadows
  999. if (parsedData.shadowGenerators) {
  1000. for (index = 0; index < parsedData.shadowGenerators.length; index++) {
  1001. var parsedShadowGenerator = parsedData.shadowGenerators[index];
  1002. parseShadowGenerator(parsedShadowGenerator, scene);
  1003. }
  1004. }
  1005. // Finish
  1006. return true;
  1007. }
  1008. });
  1009. }