babylon.sceneLoader.js 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461
  1. var BABYLON = BABYLON || {};
  2. (function () {
  3. var loadCubeTexture = function (rootUrl, parsedTexture, scene) {
  4. var texture = new BABYLON.CubeTexture(rootUrl + parsedTexture.name, scene);
  5. texture.name = parsedTexture.name;
  6. texture.hasAlpha = parsedTexture.hasAlpha;
  7. texture.level = parsedTexture.level;
  8. texture.coordinatesMode = parsedTexture.coordinatesMode;
  9. return texture;
  10. };
  11. var loadTexture = function (rootUrl, parsedTexture, scene) {
  12. if (!parsedTexture.name && !parsedTexture.isRenderTarget) {
  13. return null;
  14. }
  15. if (parsedTexture.isCube) {
  16. return loadCubeTexture(rootUrl, parsedTexture, scene);
  17. }
  18. var texture;
  19. if (parsedTexture.mirrorPlane) {
  20. texture = new BABYLON.MirrorTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  21. texture._waitingRenderList = parsedTexture.renderList;
  22. texture.mirrorPlane = BABYLON.Plane.FromArray(parsedTexture.mirrorPlane);
  23. } else if (parsedTexture.isRenderTarget) {
  24. texture = new BABYLON.RenderTargetTexture(parsedTexture.name, parsedTexture.renderTargetSize, scene);
  25. texture._waitingRenderList = parsedTexture.renderList;
  26. } else {
  27. texture = new BABYLON.Texture(rootUrl + parsedTexture.name, scene);
  28. }
  29. texture.name = parsedTexture.name;
  30. texture.hasAlpha = parsedTexture.hasAlpha;
  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 parseMaterial = function (parsedMaterial, scene, rootUrl) {
  53. var material;
  54. material = new BABYLON.StandardMaterial(parsedMaterial.name, scene);
  55. material.ambientColor = BABYLON.Color3.FromArray(parsedMaterial.ambient);
  56. material.diffuseColor = BABYLON.Color3.FromArray(parsedMaterial.diffuse);
  57. material.specularColor = BABYLON.Color3.FromArray(parsedMaterial.specular);
  58. material.specularPower = parsedMaterial.specularPower;
  59. material.emissiveColor = BABYLON.Color3.FromArray(parsedMaterial.emissive);
  60. material.alpha = parsedMaterial.alpha;
  61. material.id = parsedMaterial.id;
  62. material.backFaceCulling = parsedMaterial.backFaceCulling;
  63. if (parsedMaterial.diffuseTexture) {
  64. material.diffuseTexture = loadTexture(rootUrl, parsedMaterial.diffuseTexture, scene);
  65. }
  66. if (parsedMaterial.ambientTexture) {
  67. material.ambientTexture = loadTexture(rootUrl, parsedMaterial.ambientTexture, scene);
  68. }
  69. if (parsedMaterial.opacityTexture) {
  70. material.opacityTexture = loadTexture(rootUrl, parsedMaterial.opacityTexture, scene);
  71. }
  72. if (parsedMaterial.reflectionTexture) {
  73. material.reflectionTexture = loadTexture(rootUrl, parsedMaterial.reflectionTexture, scene);
  74. }
  75. if (parsedMaterial.emissiveTexture) {
  76. material.emissiveTexture = loadTexture(rootUrl, parsedMaterial.emissiveTexture, scene);
  77. }
  78. if (parsedMaterial.specularTexture) {
  79. material.specularTexture = loadTexture(rootUrl, parsedMaterial.specularTexture, scene);
  80. }
  81. return material;
  82. };
  83. var parseMaterialById = function (id, parsedData, scene, rootUrl) {
  84. for (var index = 0; index < parsedData.materials.length; index++) {
  85. var parsedMaterial = parsedData.materials[index];
  86. if (parsedMaterial.id === id) {
  87. return parseMaterial(parsedMaterial, scene, rootUrl);
  88. }
  89. }
  90. return null;
  91. };
  92. var parseMultiMaterial = function (parsedMultiMaterial, scene) {
  93. var multiMaterial = new BABYLON.MultiMaterial(parsedMultiMaterial.name, scene);
  94. multiMaterial.id = parsedMultiMaterial.id;
  95. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  96. var subMatId = parsedMultiMaterial.materials[matIndex];
  97. if (subMatId) {
  98. multiMaterial.subMaterials.push(scene.getMaterialByID(subMatId));
  99. } else {
  100. multiMaterial.subMaterials.push(null);
  101. }
  102. }
  103. return multiMaterial;
  104. };
  105. var parseParticleSystem = function (parsedParticleSystem, scene, rootUrl) {
  106. var emitter = scene.getLastMeshByID(parsedParticleSystem.emitterId);
  107. var particleSystem = new BABYLON.ParticleSystem("particles#" + emitter.name, parsedParticleSystem.capacity, scene);
  108. if (parsedParticleSystem.textureName) {
  109. particleSystem.particleTexture = new BABYLON.Texture(rootUrl + parsedParticleSystem.textureName, scene);
  110. }
  111. particleSystem.minAngularSpeed = parsedParticleSystem.minAngularSpeed;
  112. particleSystem.maxAngularSpeed = parsedParticleSystem.maxAngularSpeed;
  113. particleSystem.minSize = parsedParticleSystem.minSize;
  114. particleSystem.maxSize = parsedParticleSystem.maxSize;
  115. particleSystem.minLifeTime = parsedParticleSystem.minLifeTime;
  116. particleSystem.maxLifeTime = parsedParticleSystem.maxLifeTime;
  117. particleSystem.emitter = emitter;
  118. particleSystem.emitRate = parsedParticleSystem.emitRate;
  119. particleSystem.minEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.minEmitBox);
  120. particleSystem.maxEmitBox = BABYLON.Vector3.FromArray(parsedParticleSystem.maxEmitBox);
  121. particleSystem.gravity = BABYLON.Vector3.FromArray(parsedParticleSystem.gravity);
  122. particleSystem.direction1 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction1);
  123. particleSystem.direction2 = BABYLON.Vector3.FromArray(parsedParticleSystem.direction2);
  124. particleSystem.color1 = BABYLON.Color4.FromArray(parsedParticleSystem.color1);
  125. particleSystem.color2 = BABYLON.Color4.FromArray(parsedParticleSystem.color2);
  126. particleSystem.colorDead = BABYLON.Color4.FromArray(parsedParticleSystem.colorDead);
  127. particleSystem.deadAlpha = parsedParticleSystem.deadAlpha;
  128. particleSystem.updateSpeed = parsedParticleSystem.updateSpeed;
  129. particleSystem.targetStopDuration = parsedParticleSystem.targetStopFrame;
  130. particleSystem.textureMask = BABYLON.Color4.FromArray(parsedParticleSystem.textureMask);
  131. particleSystem.blendMode = parsedParticleSystem.blendMode;
  132. particleSystem.start();
  133. return particleSystem;
  134. };
  135. var parseAnimation = function (parsedAnimation) {
  136. var animation = new BABYLON.Animation(parsedAnimation.name, parsedAnimation.property, parsedAnimation.framePerSecond, parsedAnimation.dataType, parsedAnimation.loopBehavior);
  137. var dataType = parsedAnimation.dataType;
  138. var keys = [];
  139. for (var index = 0; index < parsedAnimation.keys.length; index++) {
  140. var key = parsedAnimation.keys[index];
  141. var data;
  142. switch (dataType) {
  143. case BABYLON.Animation.ANIMATIONTYPE_FLOAT:
  144. data = key.values[0];
  145. break;
  146. case BABYLON.Animation.ANIMATIONTYPE_QUATERNION:
  147. data = BABYLON.Quaternion.FromArray(key.values);
  148. break;
  149. case BABYLON.Animation.ANIMATIONTYPE_VECTOR3:
  150. default:
  151. data = BABYLON.Vector3.FromArray(key.values);
  152. break;
  153. }
  154. keys.push({
  155. frame: key.frame,
  156. value: data
  157. });
  158. }
  159. animation.setKeys(keys);
  160. return animation;
  161. };
  162. var parseLight = function(parsedLight, scene) {
  163. var light;
  164. switch (parsedLight.type) {
  165. case 0:
  166. light = new BABYLON.PointLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.data), scene);
  167. break;
  168. case 1:
  169. light = new BABYLON.DirectionalLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.data), scene);
  170. break;
  171. case 2:
  172. light = new BABYLON.SpotLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.data), BABYLON.Vector3.FromArray(parsedLight.direction), parsedLight.angle, parsedLight.exponent, scene);
  173. break;
  174. case 3:
  175. light = new BABYLON.HemisphericLight(parsedLight.name, BABYLON.Vector3.FromArray(parsedLight.data), scene);
  176. light.groundColor = BABYLON.Color3.FromArray(parsedLight.groundColor);
  177. break;
  178. }
  179. light.id = parsedLight.id;
  180. if (parsedLight.intensity) {
  181. light.intensity = parsedLight.intensity;
  182. }
  183. light.diffuse = BABYLON.Color3.FromArray(parsedLight.diffuse);
  184. light.specular = BABYLON.Color3.FromArray(parsedLight.specular);
  185. };
  186. var parseMesh = function (parsedMesh, scene) {
  187. var declaration = null;
  188. switch (parsedMesh.uvCount) {
  189. case 0:
  190. declaration = [3, 3];
  191. break;
  192. case 1:
  193. declaration = [3, 3, 2];
  194. break;
  195. case 2:
  196. declaration = [3, 3, 2, 2];
  197. break;
  198. }
  199. var mesh = new BABYLON.Mesh(parsedMesh.name, declaration, scene);
  200. mesh.id = parsedMesh.id;
  201. mesh.position = BABYLON.Vector3.FromArray(parsedMesh.position);
  202. mesh.rotation = BABYLON.Vector3.FromArray(parsedMesh.rotation);
  203. mesh.scaling = BABYLON.Vector3.FromArray(parsedMesh.scaling);
  204. mesh.setEnabled(parsedMesh.isEnabled);
  205. mesh.isVisible = parsedMesh.isVisible;
  206. mesh.billboardMode = parsedMesh.billboardMode;
  207. if (parsedMesh.visibility !== undefined) {
  208. mesh.visibility = parsedMesh.visibility;
  209. }
  210. mesh.checkCollisions = parsedMesh.checkCollisions;
  211. if (parsedMesh.vertices && parsedMesh.indices) {
  212. mesh.setVertices(parsedMesh.vertices, parsedMesh.uvCount);
  213. mesh.setIndices(parsedMesh.indices);
  214. }
  215. if (parsedMesh.parentId) {
  216. mesh.parent = scene.getLastMeshByID(parsedMesh.parentId);
  217. }
  218. if (parsedMesh.materialId) {
  219. mesh.setMaterialByID(parsedMesh.materialId);
  220. } else {
  221. mesh.material = null;
  222. }
  223. // SubMeshes
  224. if (parsedMesh.subMeshes) {
  225. mesh.subMeshes = [];
  226. for (var subIndex = 0; subIndex < parsedMesh.subMeshes.length; subIndex++) {
  227. var parsedSubMesh = parsedMesh.subMeshes[subIndex];
  228. var subMesh = new BABYLON.SubMesh(parsedSubMesh.materialIndex, parsedSubMesh.verticesStart, parsedSubMesh.verticesCount, parsedSubMesh.indexStart, parsedSubMesh.indexCount, mesh);
  229. }
  230. }
  231. // Animations
  232. if (parsedMesh.animations) {
  233. for (var animationIndex = 0; animationIndex < parsedMesh.animations.length; animationIndex++) {
  234. var parsedAnimation = parsedMesh.animations[animationIndex];
  235. mesh.animations.push(parseAnimation(parsedAnimation));
  236. }
  237. }
  238. if (parsedMesh.autoAnimate) {
  239. scene.beginAnimation(mesh, parsedMesh.autoAnimateFrom, parsedMesh.autoAnimateTo, parsedMesh.autoAnimateLoop, 1.0);
  240. }
  241. return mesh;
  242. };
  243. var isDescendantOf = function (mesh, name, hierarchyIds) {
  244. if (mesh.name === name) {
  245. hierarchyIds.push(mesh.id);
  246. return true;
  247. }
  248. if (mesh.parentId && hierarchyIds.indexOf(mesh.parentId) !== -1) {
  249. hierarchyIds.push(mesh.id);
  250. return true;
  251. }
  252. return false;
  253. };
  254. BABYLON.SceneLoader = {
  255. ImportMesh: function (meshName, rootUrl, sceneFilename, scene, then) {
  256. BABYLON.Tools.LoadFile(rootUrl + sceneFilename, function (data) {
  257. var parsedData = JSON.parse(data);
  258. // Meshes
  259. var meshes = [];
  260. var particleSystems = [];
  261. var hierarchyIds = [];
  262. for (var index = 0; index < parsedData.meshes.length; index++) {
  263. var parsedMesh = parsedData.meshes[index];
  264. if (!meshName || isDescendantOf(parsedMesh, meshName, hierarchyIds)) {
  265. // Material ?
  266. if (parsedMesh.materialId) {
  267. var materialFound = (scene.getMaterialByID(parsedMesh.materialId) !== null);
  268. if (!materialFound) {
  269. for (var multimatIndex = 0; multimatIndex < parsedData.multiMaterials.length; multimatIndex++) {
  270. var parsedMultiMaterial = parsedData.multiMaterials[multimatIndex];
  271. if (parsedMultiMaterial.id == parsedMesh.materialId) {
  272. for (var matIndex = 0; matIndex < parsedMultiMaterial.materials.length; matIndex++) {
  273. var subMatId = parsedMultiMaterial.materials[matIndex];
  274. parseMaterialById(subMatId, parsedData, scene, rootUrl);
  275. }
  276. parseMultiMaterial(parsedMultiMaterial, scene);
  277. materialFound = true;
  278. break;
  279. }
  280. }
  281. }
  282. if (!materialFound) {
  283. parseMaterialById(parsedMesh.materialId, parsedData, scene, rootUrl);
  284. }
  285. }
  286. meshes.push(parseMesh(parsedMesh, scene));
  287. }
  288. }
  289. // Particles
  290. if (parsedData.particleSystems) {
  291. for (var index = 0; index < parsedData.particleSystems.length; index++) {
  292. var parsedParticleSystem = parsedData.particleSystems[index];
  293. if (hierarchyIds.indexOf(parsedParticleSystem.emitterId) !== -1) {
  294. particleSystems.push(parseParticleSystem(parsedParticleSystem, scene, rootUrl));
  295. }
  296. }
  297. }
  298. if (then) {
  299. then(meshes, particleSystems);
  300. }
  301. });
  302. },
  303. Load: function (rootUrl, sceneFilename, engine, then, progressCallBack) {
  304. BABYLON.Tools.LoadFile(rootUrl + sceneFilename, function (data) {
  305. var parsedData = JSON.parse(data);
  306. var scene = new BABYLON.Scene(engine);
  307. // Scene
  308. scene.autoClear = parsedData.autoClear;
  309. scene.clearColor = BABYLON.Color3.FromArray(parsedData.clearColor);
  310. scene.ambientColor = BABYLON.Color3.FromArray(parsedData.ambientColor);
  311. scene.gravity = BABYLON.Vector3.FromArray(parsedData.gravity);
  312. // Lights
  313. for (var index = 0; index < parsedData.lights.length; index++) {
  314. var parsedLight = parsedData.lights[index];
  315. parseLight(parsedLight, scene);
  316. }
  317. // Cameras
  318. for (var index = 0; index < parsedData.cameras.length; index++) {
  319. var parsedCamera = parsedData.cameras[index];
  320. var camera = new BABYLON.FreeCamera(parsedCamera.name, BABYLON.Vector3.FromArray(parsedCamera.position), scene);
  321. camera.id = parsedCamera.id;
  322. if (parsedCamera.target) {
  323. camera.setTarget(BABYLON.Vector3.FromArray(parsedCamera.target));
  324. } else {
  325. camera.rotation = BABYLON.Vector3.FromArray(parsedCamera.rotation);
  326. }
  327. camera.fov = parsedCamera.fov;
  328. camera.minZ = parsedCamera.minZ;
  329. camera.maxZ = parsedCamera.maxZ;
  330. camera.speed = parsedCamera.speed;
  331. camera.inertia = parsedCamera.inertia;
  332. camera.checkCollisions = parsedCamera.checkCollisions;
  333. camera.applyGravity = parsedCamera.applyGravity;
  334. if (parsedCamera.ellipsoid) {
  335. camera.ellipsoid = BABYLON.Vector3.FromArray(parsedCamera.ellipsoid);
  336. }
  337. }
  338. if (parsedData.activeCameraID) {
  339. scene.activeCameraByID(parsedData.activeCameraID);
  340. }
  341. // Materials
  342. if (parsedData.materials) {
  343. for (var index = 0; index < parsedData.materials.length; index++) {
  344. var parsedMaterial = parsedData.materials[index];
  345. parseMaterial(parsedMaterial, scene, rootUrl);
  346. }
  347. }
  348. if (parsedData.multiMaterials) {
  349. for (var index = 0; index < parsedData.multiMaterials.length; index++) {
  350. var parsedMultiMaterial = parsedData.multiMaterials[index];
  351. parseMultiMaterial(parsedMultiMaterial, scene);
  352. }
  353. }
  354. // Meshes
  355. for (var index = 0; index < parsedData.meshes.length; index++) {
  356. var parsedMesh = parsedData.meshes[index];
  357. parseMesh(parsedMesh, scene);
  358. }
  359. // Particles Systems
  360. if (parsedData.particleSystems) {
  361. for (var index = 0; index < parsedData.particleSystems.length; index++) {
  362. var parsedParticleSystem = parsedData.particleSystems[index];
  363. parseParticleSystem(parsedParticleSystem, scene, rootUrl);
  364. }
  365. }
  366. // Finish
  367. if (then) {
  368. then(scene);
  369. }
  370. }, progressCallBack);
  371. }
  372. };
  373. })();