babylon.sceneSerializer.js 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728
  1. var BABYLON;
  2. (function (BABYLON) {
  3. var serializeLight = function (light) {
  4. var serializationObject = {};
  5. serializationObject.name = light.name;
  6. serializationObject.id = light.id;
  7. serializationObject.tags = BABYLON.Tags.GetTags(light);
  8. if (light instanceof BABYLON.PointLight) {
  9. serializationObject.type = 0;
  10. serializationObject.position = light.position.asArray();
  11. } else if (light instanceof BABYLON.DirectionalLight) {
  12. serializationObject.type = 1;
  13. var directionalLight = light;
  14. serializationObject.position = directionalLight.position.asArray();
  15. serializationObject.direction = directionalLight.direction.asArray();
  16. } else if (light instanceof BABYLON.SpotLight) {
  17. serializationObject.type = 2;
  18. var spotLight = light;
  19. serializationObject.position = spotLight.position.asArray();
  20. serializationObject.direction = spotLight.position.asArray();
  21. serializationObject.angle = spotLight.angle;
  22. serializationObject.exponent = spotLight.exponent;
  23. } else if (light instanceof BABYLON.HemisphericLight) {
  24. serializationObject.type = 2;
  25. serializationObject.groundColor = light.groundColor.asArray();
  26. }
  27. if (light.intensity) {
  28. serializationObject.intensity = light.intensity;
  29. }
  30. serializationObject.range = light.range;
  31. serializationObject.diffuse = light.diffuse.asArray();
  32. serializationObject.specular = light.specular.asArray();
  33. return serializationObject;
  34. };
  35. var serializeCamera = function (camera) {
  36. var serializationObject = {};
  37. serializationObject.name = camera.name;
  38. serializationObject.tags = BABYLON.Tags.GetTags(camera);
  39. serializationObject.id = camera.id;
  40. serializationObject.position = camera.position.asArray();
  41. // Parent
  42. if (camera.parent) {
  43. serializationObject.parentId = camera.parent.id;
  44. }
  45. // Target
  46. serializationObject.rotation = camera.rotation.asArray();
  47. // Locked target
  48. if (camera.lockedTarget && camera.lockedTarget.id) {
  49. serializationObject.lockedTargetId = camera.lockedTarget.id;
  50. }
  51. serializationObject.fov = camera.fov;
  52. serializationObject.minZ = camera.minZ;
  53. serializationObject.maxZ = camera.maxZ;
  54. serializationObject.speed = camera.speed;
  55. serializationObject.inertia = camera.inertia;
  56. serializationObject.checkCollisions = camera.checkCollisions;
  57. serializationObject.applyGravity = camera.applyGravity;
  58. if (camera.ellipsoid) {
  59. serializationObject.ellipsoid = camera.ellipsoid.asArray();
  60. }
  61. // Animations
  62. appendAnimations(camera, serializationObject);
  63. return serializationObject;
  64. };
  65. var appendAnimations = function (source, destination) {
  66. if (source.animations) {
  67. destination.animations = [];
  68. for (var animationIndex = 0; animationIndex < source.animations.length; animationIndex++) {
  69. var animation = source.animations[animationIndex];
  70. destination.animations.push(serializeAnimation(animation));
  71. }
  72. }
  73. };
  74. var serializeAnimation = function (animation) {
  75. var serializationObject = {};
  76. serializationObject.name = animation.name;
  77. serializationObject.property = animation.targetProperty;
  78. serializationObject.framePerSecond = animation.framePerSecond;
  79. serializationObject.dataType = animation.dataType;
  80. serializationObject.loopBehavior = animation.loopMode;
  81. var dataType = animation.dataType;
  82. serializationObject.keys = [];
  83. var keys = animation.getKeys();
  84. for (var index = 0; index < keys.length; index++) {
  85. var animationKey = keys[index];
  86. var key = {};
  87. key.frame = animationKey.frame;
  88. switch (dataType) {
  89. case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
  90. key.values = [animationKey.value];
  91. break;
  92. case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
  93. case BABYLON.Animation.ANIMATIONTYPE_MATRIX:
  94. case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
  95. key.values = animationKey.value.asArray();
  96. break;
  97. }
  98. serializationObject.keys.push(key);
  99. }
  100. return serializationObject;
  101. };
  102. var serializeMultiMaterial = function (material) {
  103. var serializationObject = {};
  104. serializationObject.name = material.name;
  105. serializationObject.id = material.id;
  106. serializationObject.tags = BABYLON.Tags.GetTags(material);
  107. serializationObject.materials = [];
  108. for (var matIndex = 0; matIndex < material.subMaterials.length; matIndex++) {
  109. var subMat = material.subMaterials[matIndex];
  110. if (subMat) {
  111. serializationObject.materials.push(subMat.id);
  112. } else {
  113. serializationObject.materials.push(null);
  114. }
  115. }
  116. return serializationObject;
  117. };
  118. var serializeMaterial = function (material) {
  119. var serializationObject = {};
  120. serializationObject.name = material.name;
  121. serializationObject.ambient = material.ambientColor.asArray();
  122. serializationObject.diffuse = material.diffuseColor.asArray();
  123. serializationObject.specular = material.specularColor.asArray();
  124. serializationObject.specularPower = material.specularPower;
  125. serializationObject.emissive = material.emissiveColor.asArray();
  126. serializationObject.alpha = material.alpha;
  127. serializationObject.id = material.id;
  128. serializationObject.tags = BABYLON.Tags.GetTags(material);
  129. serializationObject.backFaceCulling = material.backFaceCulling;
  130. if (material.diffuseTexture) {
  131. serializationObject.diffuseTexture = serializeTexture(material.diffuseTexture);
  132. }
  133. if (material.ambientTexture) {
  134. serializationObject.ambientTexture = serializeTexture(material.ambientTexture);
  135. }
  136. if (material.opacityTexture) {
  137. serializationObject.opacityTexture = serializeTexture(material.opacityTexture);
  138. }
  139. if (material.reflectionTexture) {
  140. serializationObject.reflectionTexture = serializeTexture(material.reflectionTexture);
  141. }
  142. if (material.emissiveTexture) {
  143. serializationObject.emissiveTexture = serializeTexture(material.emissiveTexture);
  144. }
  145. if (material.specularTexture) {
  146. serializationObject.specularTexture = serializeTexture(material.specularTexture);
  147. }
  148. if (material.bumpTexture) {
  149. serializationObject.bumpTexture = serializeTexture(material.bumpTexture);
  150. }
  151. return serializationObject;
  152. };
  153. var serializeTexture = function (texture) {
  154. var serializationObject = {};
  155. if (!texture.name) {
  156. return null;
  157. }
  158. if (texture instanceof BABYLON.CubeTexture) {
  159. serializationObject.name = texture.name;
  160. serializationObject.hasAlpha = texture.hasAlpha;
  161. serializationObject.level = texture.level;
  162. serializationObject.coordinatesMode = texture.coordinatesMode;
  163. return serializationObject;
  164. }
  165. if (texture instanceof BABYLON.MirrorTexture) {
  166. var mirrorTexture = texture;
  167. serializationObject.renderTargetSize = mirrorTexture.getRenderSize();
  168. serializationObject.renderList = [];
  169. for (var index = 0; index < mirrorTexture.renderList.length; index++) {
  170. serializationObject.renderList.push(mirrorTexture.renderList[index].id);
  171. }
  172. serializationObject.mirrorPlane = mirrorTexture.mirrorPlane.asArray();
  173. } else if (texture instanceof BABYLON.RenderTargetTexture) {
  174. var renderTargetTexture = texture;
  175. serializationObject.renderTargetSize = renderTargetTexture.getRenderSize();
  176. serializationObject.renderList = [];
  177. for (index = 0; index < renderTargetTexture.renderList.length; index++) {
  178. serializationObject.renderList.push(renderTargetTexture.renderList[index].id);
  179. }
  180. }
  181. serializationObject.name = texture.name;
  182. serializationObject.hasAlpha = texture.hasAlpha;
  183. serializationObject.level = texture.level;
  184. serializationObject.coordinatesIndex = texture.coordinatesIndex;
  185. serializationObject.coordinatesMode = texture.coordinatesMode;
  186. serializationObject.uOffset = texture.uOffset;
  187. serializationObject.vOffset = texture.vOffset;
  188. serializationObject.uScale = texture.uScale;
  189. serializationObject.vScale = texture.vScale;
  190. serializationObject.uAng = texture.uAng;
  191. serializationObject.vAng = texture.vAng;
  192. serializationObject.wAng = texture.wAng;
  193. serializationObject.wrapU = texture.wrapU;
  194. serializationObject.wrapV = texture.wrapV;
  195. // Animations
  196. appendAnimations(texture, serializationObject);
  197. return serializationObject;
  198. };
  199. var serializeSkeleton = function (skeleton) {
  200. var serializationObject = {};
  201. serializationObject.name = skeleton.name;
  202. serializationObject.id = skeleton.id;
  203. serializationObject.bones = [];
  204. for (var index = 0; index < skeleton.bones.length; index++) {
  205. var bone = skeleton.bones[index];
  206. var serializedBone = {
  207. parentBoneIndex: bone.getParent() ? skeleton.bones.indexOf(bone.getParent()) : -1,
  208. name: bone.name,
  209. matrix: bone.getLocalMatrix().toArray()
  210. };
  211. serializationObject.bones.push(serializedBone);
  212. if (bone.animations && bone.animations.length > 0) {
  213. serializedBone.animation = serializeAnimation(bone.animations[0]);
  214. }
  215. }
  216. return serializationObject;
  217. };
  218. var serializeParticleSystem = function (particleSystem) {
  219. var serializationObject = {};
  220. serializationObject.emitterId = particleSystem.emitter.id;
  221. serializationObject.capacity = particleSystem.getCapacity();
  222. if (particleSystem.particleTexture) {
  223. serializationObject.textureName = particleSystem.particleTexture.name;
  224. }
  225. serializationObject.minAngularSpeed = particleSystem.minAngularSpeed;
  226. serializationObject.maxAngularSpeed = particleSystem.maxAngularSpeed;
  227. serializationObject.minSize = particleSystem.minSize;
  228. serializationObject.maxSize = particleSystem.maxSize;
  229. serializationObject.minLifeTime = particleSystem.minLifeTime;
  230. serializationObject.maxLifeTime = particleSystem.maxLifeTime;
  231. serializationObject.emitRate = particleSystem.emitRate;
  232. serializationObject.minEmitBox = particleSystem.minEmitBox.asArray();
  233. serializationObject.maxEmitBox = particleSystem.maxEmitBox.asArray();
  234. serializationObject.gravity = particleSystem.gravity.asArray();
  235. serializationObject.direction1 = particleSystem.direction1.asArray();
  236. serializationObject.direction2 = particleSystem.direction2.asArray();
  237. serializationObject.color1 = particleSystem.color1.asArray();
  238. serializationObject.color2 = particleSystem.color2.asArray();
  239. serializationObject.colorDead = particleSystem.colorDead.asArray();
  240. serializationObject.updateSpeed = particleSystem.updateSpeed;
  241. serializationObject.targetStopDuration = particleSystem.targetStopDuration;
  242. serializationObject.textureMask = particleSystem.textureMask.asArray();
  243. serializationObject.blendMode = particleSystem.blendMode;
  244. return serializationObject;
  245. };
  246. var serializeLensFlareSystem = function (lensFlareSystem) {
  247. var serializationObject = {};
  248. serializationObject.emitterId = lensFlareSystem.getEmitter().id;
  249. serializationObject.borderLimit = lensFlareSystem.borderLimit;
  250. serializationObject.flares = [];
  251. for (var index = 0; index < lensFlareSystem.lensFlares.length; index++) {
  252. var flare = lensFlareSystem.lensFlares[index];
  253. serializationObject.flares.push({
  254. size: flare.size,
  255. position: flare.position,
  256. color: flare.color.asArray(),
  257. textureName: BABYLON.Tools.GetFilename(flare.texture.name)
  258. });
  259. }
  260. return serializationObject;
  261. };
  262. var serializeShadowGenerator = function (light) {
  263. var serializationObject = {};
  264. var shadowGenerator = light.getShadowGenerator();
  265. serializationObject.lightId = light.id;
  266. serializationObject.mapSize = shadowGenerator.getShadowMap().getRenderSize();
  267. serializationObject.useVarianceShadowMap = shadowGenerator.useVarianceShadowMap;
  268. serializationObject.renderList = [];
  269. for (var meshIndex = 0; meshIndex < shadowGenerator.getShadowMap().renderList.length; meshIndex++) {
  270. var mesh = shadowGenerator.getShadowMap().renderList[meshIndex];
  271. serializationObject.renderList.push(mesh.id);
  272. }
  273. return serializationObject;
  274. };
  275. var serializedGeometries = [];
  276. var serializeGeometry = function (geometry, serializationGeometries) {
  277. if (serializedGeometries[geometry.id]) {
  278. return;
  279. }
  280. if (geometry instanceof BABYLON.Geometry.Primitives.Box) {
  281. serializationGeometries.boxes.push(serializeBox(geometry));
  282. } else if (geometry instanceof BABYLON.Geometry.Primitives.Sphere) {
  283. serializationGeometries.spheres.push(serializeSphere(geometry));
  284. } else if (geometry instanceof BABYLON.Geometry.Primitives.Cylinder) {
  285. serializationGeometries.cylinders.push(serializeCylinder(geometry));
  286. } else if (geometry instanceof BABYLON.Geometry.Primitives.Torus) {
  287. serializationGeometries.toruses.push(serializeTorus(geometry));
  288. } else if (geometry instanceof BABYLON.Geometry.Primitives.Ground) {
  289. serializationGeometries.grounds.push(serializeGround(geometry));
  290. } else if (geometry instanceof BABYLON.Geometry.Primitives.Plane) {
  291. serializationGeometries.planes.push(serializePlane(geometry));
  292. } else if (geometry instanceof BABYLON.Geometry.Primitives.TorusKnot) {
  293. serializationGeometries.torusKnots.push(serializeTorusKnot(geometry));
  294. } else if (geometry instanceof BABYLON.Geometry.Primitives._Primitive) {
  295. throw new Error("Unknow primitive type");
  296. } else {
  297. serializationGeometries.vertexData.push(serializeVertexData(geometry));
  298. }
  299. serializedGeometries[geometry.id] = true;
  300. };
  301. var serializeGeometryBase = function (geometry) {
  302. var serializationObject = {};
  303. serializationObject.id = geometry.id;
  304. if (BABYLON.Tags.HasTags(geometry)) {
  305. serializationObject.tags = BABYLON.Tags.GetTags(geometry);
  306. }
  307. return serializationObject;
  308. };
  309. var serializeVertexData = function (vertexData) {
  310. var serializationObject = serializeGeometryBase(vertexData);
  311. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.PositionKind)) {
  312. serializationObject.positions = vertexData.getVerticesData(BABYLON.VertexBuffer.PositionKind);
  313. }
  314. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.NormalKind)) {
  315. serializationObject.normals = vertexData.getVerticesData(BABYLON.VertexBuffer.NormalKind);
  316. }
  317. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.UVKind)) {
  318. serializationObject.uvs = vertexData.getVerticesData(BABYLON.VertexBuffer.UVKind);
  319. }
  320. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.UV2Kind)) {
  321. serializationObject.uvs2 = vertexData.getVerticesData(BABYLON.VertexBuffer.UV2Kind);
  322. }
  323. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.ColorKind)) {
  324. serializationObject.colors = vertexData.getVerticesData(BABYLON.VertexBuffer.ColorKind);
  325. }
  326. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesIndicesKind)) {
  327. serializationObject.matricesIndices = vertexData.getVerticesData(BABYLON.VertexBuffer.MatricesIndicesKind);
  328. serializationObject.matricesIndices._isExpanded = true;
  329. }
  330. if (vertexData.isVerticesDataPresent(BABYLON.VertexBuffer.MatricesWeightsKind)) {
  331. serializationObject.matricesWeights = vertexData.getVerticesData(BABYLON.VertexBuffer.MatricesWeightsKind);
  332. }
  333. serializationObject.indices = vertexData.getIndices();
  334. return serializationObject;
  335. };
  336. var serializePrimitive = function (primitive) {
  337. var serializationObject = serializeGeometryBase(primitive);
  338. serializationObject.canBeRegenerated = primitive.canBeRegenerated();
  339. return serializationObject;
  340. };
  341. var serializeBox = function (box) {
  342. var serializationObject = serializePrimitive(box);
  343. serializationObject.size = box.size;
  344. return serializationObject;
  345. };
  346. var serializeSphere = function (sphere) {
  347. var serializationObject = serializePrimitive(sphere);
  348. serializationObject.segments = sphere.segments;
  349. serializationObject.diameter = sphere.diameter;
  350. return serializationObject;
  351. };
  352. var serializeCylinder = function (cylinder) {
  353. var serializationObject = serializePrimitive(cylinder);
  354. serializationObject.height = cylinder.height;
  355. serializationObject.diameterTop = cylinder.diameterTop;
  356. serializationObject.diameterBottom = cylinder.diameterBottom;
  357. serializationObject.tessellation = cylinder.tessellation;
  358. return serializationObject;
  359. };
  360. var serializeTorus = function (torus) {
  361. var serializationObject = serializePrimitive(torus);
  362. serializationObject.diameter = torus.diameter;
  363. serializationObject.thickness = torus.thickness;
  364. serializationObject.tessellation = torus.tessellation;
  365. return serializationObject;
  366. };
  367. var serializeGround = function (ground) {
  368. var serializationObject = serializePrimitive(ground);
  369. serializationObject.width = ground.width;
  370. serializationObject.height = ground.height;
  371. serializationObject.subdivisions = ground.subdivisions;
  372. return serializationObject;
  373. };
  374. var serializePlane = function (plane) {
  375. var serializationObject = serializePrimitive(plane);
  376. serializationObject.size = plane.size;
  377. return serializationObject;
  378. };
  379. var serializeTorusKnot = function (torusKnot) {
  380. var serializationObject = serializePrimitive(torusKnot);
  381. serializationObject.radius = torusKnot.radius;
  382. serializationObject.tube = torusKnot.tube;
  383. serializationObject.radialSegments = torusKnot.radialSegments;
  384. serializationObject.tubularSegments = torusKnot.tubularSegments;
  385. serializationObject.p = torusKnot.p;
  386. serializationObject.q = torusKnot.q;
  387. return serializationObject;
  388. };
  389. var serializeMesh = function (mesh, serializationScene) {
  390. var serializationObject = {};
  391. serializationObject.name = mesh.name;
  392. serializationObject.id = mesh.id;
  393. if (BABYLON.Tags.HasTags(mesh)) {
  394. serializationObject.tags = BABYLON.Tags.GetTags(mesh);
  395. }
  396. serializationObject.position = mesh.position.asArray();
  397. if (mesh.rotation) {
  398. serializationObject.rotation = mesh.rotation.asArray();
  399. } else if (mesh.rotationQuaternion) {
  400. serializationObject.rotationQuaternion = mesh.rotationQuaternion.asArray();
  401. }
  402. serializationObject.scaling = mesh.scaling.asArray();
  403. serializationObject.localMatrix = mesh.getPivotMatrix().asArray();
  404. serializationObject.isEnabled = mesh.isEnabled();
  405. serializationObject.isVisible = mesh.isVisible;
  406. serializationObject.infiniteDistance = mesh.infiniteDistance;
  407. serializationObject.pickable = mesh.isPickable;
  408. serializationObject.receiveShadows = mesh.receiveShadows;
  409. serializationObject.billboardMode = mesh.billboardMode;
  410. serializationObject.visibility = mesh.visibility;
  411. serializationObject.checkCollisions = mesh.checkCollisions;
  412. // Parent
  413. if (mesh.parent) {
  414. serializationObject.parentId = mesh.parent.id;
  415. }
  416. // Geometry
  417. var geometry = mesh._geometry;
  418. if (geometry) {
  419. var geometryId = geometry.id;
  420. serializationObject.geometryId = geometryId;
  421. if (!mesh.getScene().getGeometryByID(geometryId)) {
  422. // geometry was in the memory but not added to the scene, nevertheless it's better to serialize too be able to reload the mesh with its geometry
  423. serializeGeometry(geometry, serializationScene.geometries);
  424. }
  425. // SubMeshes
  426. serializationObject.subMeshes = [];
  427. for (var subIndex = 0; subIndex < mesh.subMeshes.length; subIndex++) {
  428. var subMesh = mesh.subMeshes[subIndex];
  429. serializationObject.subMeshes.push({
  430. materialIndex: subMesh.materialIndex,
  431. verticesStart: subMesh.verticesStart,
  432. verticesCount: subMesh.verticesCount,
  433. indexStart: subMesh.indexStart,
  434. indexCount: subMesh.indexCount
  435. });
  436. }
  437. }
  438. // Material
  439. if (mesh.material) {
  440. serializationObject.materialId = mesh.material.id;
  441. } else {
  442. mesh.material = null;
  443. }
  444. // Skeleton
  445. if (mesh.skeleton) {
  446. serializationObject.skeletonId = mesh.skeleton.id;
  447. }
  448. // Physics
  449. if (mesh.getPhysicsImpostor() !== BABYLON.PhysicsEngine.NoImpostor) {
  450. serializationObject.physicsMass = mesh.getPhysicsMass();
  451. serializationObject.physicsFriction = mesh.getPhysicsFriction();
  452. serializationObject.physicsRestitution = mesh.getPhysicsRestitution();
  453. switch (mesh.getPhysicsImpostor()) {
  454. case BABYLON.PhysicsEngine.BoxImpostor:
  455. serializationObject.physicsImpostor = 1;
  456. break;
  457. case BABYLON.PhysicsEngine.SphereImpostor:
  458. serializationObject.physicsImpostor = 2;
  459. break;
  460. }
  461. }
  462. // Animations
  463. appendAnimations(mesh, serializationObject);
  464. return serializationObject;
  465. };
  466. var SceneSerializer = (function () {
  467. function SceneSerializer() {
  468. }
  469. SceneSerializer.Serialize = function (scene) {
  470. var serializationObject = {};
  471. // Scene
  472. serializationObject.useDelayedTextureLoading = scene.useDelayedTextureLoading;
  473. serializationObject.autoClear = scene.autoClear;
  474. serializationObject.clearColor = scene.clearColor.asArray();
  475. serializationObject.ambientColor = scene.ambientColor.asArray();
  476. serializationObject.gravity = scene.gravity.asArray();
  477. // Fog
  478. if (scene.fogMode && scene.fogMode !== 0) {
  479. serializationObject.fogMode = scene.fogMode;
  480. serializationObject.fogColor = scene.fogColor.asArray();
  481. serializationObject.fogStart = scene.fogStart;
  482. serializationObject.fogEnd = scene.fogEnd;
  483. serializationObject.fogDensity = scene.fogDensity;
  484. }
  485. // Lights
  486. serializationObject.lights = [];
  487. for (var index = 0; index < scene.lights.length; index++) {
  488. var light = scene.lights[index];
  489. serializationObject.lights.push(serializeLight(light));
  490. }
  491. // Cameras
  492. serializationObject.cameras = [];
  493. for (index = 0; index < scene.cameras.length; index++) {
  494. var camera = scene.cameras[index];
  495. if (camera instanceof BABYLON.FreeCamera) {
  496. serializationObject.cameras.push(serializeCamera(camera));
  497. }
  498. }
  499. if (scene.activeCamera) {
  500. serializationObject.activeCameraID = scene.activeCamera.id;
  501. }
  502. // Materials
  503. serializationObject.materials = [];
  504. serializationObject.multiMaterials = [];
  505. for (index = 0; index < scene.materials.length; index++) {
  506. var material = scene.materials[index];
  507. if (material instanceof BABYLON.StandardMaterial) {
  508. serializationObject.materials.push(serializeMaterial(material));
  509. } else if (material instanceof BABYLON.MultiMaterial) {
  510. serializationObject.multiMaterials.push(serializeMultiMaterial(material));
  511. }
  512. }
  513. // Skeletons
  514. serializationObject.skeletons = [];
  515. for (index = 0; index < scene.skeletons.length; index++) {
  516. serializationObject.skeletons.push(serializeSkeleton(scene.skeletons[index]));
  517. }
  518. // Geometries
  519. serializationObject.geometries = {};
  520. serializationObject.geometries.boxes = [];
  521. serializationObject.geometries.spheres = [];
  522. serializationObject.geometries.cylinders = [];
  523. serializationObject.geometries.toruses = [];
  524. serializationObject.geometries.grounds = [];
  525. serializationObject.geometries.planes = [];
  526. serializationObject.geometries.torusKnots = [];
  527. serializationObject.geometries.vertexData = [];
  528. serializedGeometries = [];
  529. var geometries = scene.getGeometries();
  530. for (var index = 0; index < geometries.length; index++) {
  531. var geometry = geometries[index];
  532. if (geometry.isReady()) {
  533. serializeGeometry(geometry, serializationObject.geometries);
  534. }
  535. }
  536. // Meshes
  537. serializationObject.meshes = [];
  538. for (index = 0; index < scene.meshes.length; index++) {
  539. var mesh = scene.meshes[index];
  540. if (mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_LOADED || mesh.delayLoadState === BABYLON.Engine.DELAYLOADSTATE_NONE) {
  541. serializationObject.meshes.push(serializeMesh(mesh, serializationObject));
  542. }
  543. }
  544. // Particles Systems
  545. serializationObject.particleSystems = [];
  546. for (index = 0; index < scene.particleSystems.length; index++) {
  547. serializationObject.particleSystems.push(serializeParticleSystem(scene.particleSystems[index]));
  548. }
  549. // Lens flares
  550. serializationObject.lensFlareSystems = [];
  551. for (index = 0; index < scene.lensFlareSystems.length; index++) {
  552. serializationObject.lensFlareSystems.push(serializeLensFlareSystem(scene.lensFlareSystems[index]));
  553. }
  554. // Shadows
  555. serializationObject.shadowGenerators = [];
  556. for (index = 0; index < scene.lights.length; index++) {
  557. light = scene.lights[index];
  558. if (light.getShadowGenerator()) {
  559. serializationObject.shadowGenerators.push(serializeShadowGenerator(light));
  560. }
  561. }
  562. return serializationObject;
  563. };
  564. return SceneSerializer;
  565. })();
  566. BABYLON.SceneSerializer = SceneSerializer;
  567. })(BABYLON || (BABYLON = {}));
  568. //# sourceMappingURL=babylon.sceneSerializer.js.map