babylon.engine.js 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875
  1. var BABYLON;
  2. (function (BABYLON) {
  3. var _DepthCullingState = (function () {
  4. function _DepthCullingState() {
  5. this._isDepthTestDirty = false;
  6. this._isDepthMaskDirty = false;
  7. this._isDepthFuncDirty = false;
  8. this._isCullFaceDirty = false;
  9. this._isCullDirty = false;
  10. }
  11. Object.defineProperty(_DepthCullingState.prototype, "isDirty", {
  12. get: function () {
  13. return this._isDepthFuncDirty || this._isDepthTestDirty || this._isDepthMaskDirty || this._isCullFaceDirty || this._isCullDirty;
  14. },
  15. enumerable: true,
  16. configurable: true
  17. });
  18. Object.defineProperty(_DepthCullingState.prototype, "cullFace", {
  19. get: function () {
  20. return this._cullFace;
  21. },
  22. set: function (value) {
  23. if (this._cullFace === value) {
  24. return;
  25. }
  26. this._cullFace = value;
  27. this._isCullFaceDirty = true;
  28. },
  29. enumerable: true,
  30. configurable: true
  31. });
  32. Object.defineProperty(_DepthCullingState.prototype, "cull", {
  33. get: function () {
  34. return this._cull;
  35. },
  36. set: function (value) {
  37. if (this._cull === value) {
  38. return;
  39. }
  40. this._cull = value;
  41. this._isCullDirty = true;
  42. },
  43. enumerable: true,
  44. configurable: true
  45. });
  46. Object.defineProperty(_DepthCullingState.prototype, "depthFunc", {
  47. get: function () {
  48. return this._depthFunc;
  49. },
  50. set: function (value) {
  51. if (this._depthFunc === value) {
  52. return;
  53. }
  54. this._depthFunc = value;
  55. this._isDepthFuncDirty = true;
  56. },
  57. enumerable: true,
  58. configurable: true
  59. });
  60. Object.defineProperty(_DepthCullingState.prototype, "depthMask", {
  61. get: function () {
  62. return this._depthMask;
  63. },
  64. set: function (value) {
  65. if (this._depthMask === value) {
  66. return;
  67. }
  68. this._depthMask = value;
  69. this._isDepthMaskDirty = true;
  70. },
  71. enumerable: true,
  72. configurable: true
  73. });
  74. Object.defineProperty(_DepthCullingState.prototype, "depthTest", {
  75. get: function () {
  76. return this._depthTest;
  77. },
  78. set: function (value) {
  79. if (this._depthTest === value) {
  80. return;
  81. }
  82. this._depthTest = value;
  83. this._isDepthTestDirty = true;
  84. },
  85. enumerable: true,
  86. configurable: true
  87. });
  88. _DepthCullingState.prototype.reset = function () {
  89. this._depthMask = true;
  90. this._depthTest = true;
  91. this._depthFunc = null;
  92. this._cull = null;
  93. this._cullFace = null;
  94. this._isDepthTestDirty = true;
  95. this._isDepthMaskDirty = true;
  96. this._isDepthFuncDirty = false;
  97. this._isCullFaceDirty = false;
  98. this._isCullDirty = false;
  99. };
  100. _DepthCullingState.prototype.apply = function (gl) {
  101. if (!this.isDirty) {
  102. return;
  103. }
  104. // Cull
  105. if (this._isCullDirty) {
  106. if (this.cull === true) {
  107. gl.enable(gl.CULL_FACE);
  108. } else if (this.cull === false) {
  109. gl.disable(gl.CULL_FACE);
  110. }
  111. this._isCullDirty = false;
  112. }
  113. // Cull face
  114. if (this._isCullFaceDirty) {
  115. gl.cullFace(this.cullFace);
  116. this._isCullFaceDirty = false;
  117. }
  118. // Depth mask
  119. if (this._isDepthMaskDirty) {
  120. gl.depthMask(this.depthMask);
  121. this._isDepthMaskDirty = false;
  122. }
  123. // Depth test
  124. if (this._isDepthTestDirty) {
  125. if (this.depthTest === true) {
  126. gl.enable(gl.DEPTH_TEST);
  127. } else if (this.depthTest === false) {
  128. gl.disable(gl.DEPTH_TEST);
  129. }
  130. this._isDepthTestDirty = false;
  131. }
  132. // Depth func
  133. if (this._isDepthFuncDirty) {
  134. gl.depthFunc(this.depthFunc);
  135. this._isDepthFuncDirty = false;
  136. }
  137. };
  138. return _DepthCullingState;
  139. })();
  140. BABYLON._DepthCullingState = _DepthCullingState;
  141. var _AlphaState = (function () {
  142. function _AlphaState() {
  143. this._isAlphaBlendDirty = false;
  144. this._isBlendFunctionParametersDirty = false;
  145. this._alphaBlend = false;
  146. this._blendFunctionParameters = new Array(4);
  147. }
  148. Object.defineProperty(_AlphaState.prototype, "isDirty", {
  149. get: function () {
  150. return this._isAlphaBlendDirty || this._isBlendFunctionParametersDirty;
  151. },
  152. enumerable: true,
  153. configurable: true
  154. });
  155. Object.defineProperty(_AlphaState.prototype, "alphaBlend", {
  156. get: function () {
  157. return this._alphaBlend;
  158. },
  159. set: function (value) {
  160. if (this._alphaBlend === value) {
  161. return;
  162. }
  163. this._alphaBlend = value;
  164. this._isAlphaBlendDirty = true;
  165. },
  166. enumerable: true,
  167. configurable: true
  168. });
  169. _AlphaState.prototype.setAlphaBlendFunctionParameters = function (value0, value1, value2, value3) {
  170. if (this._blendFunctionParameters[0] === value0 && this._blendFunctionParameters[1] === value1 && this._blendFunctionParameters[2] === value2 && this._blendFunctionParameters[3] === value3) {
  171. return;
  172. }
  173. this._blendFunctionParameters[0] = value0;
  174. this._blendFunctionParameters[1] = value1;
  175. this._blendFunctionParameters[2] = value2;
  176. this._blendFunctionParameters[3] = value3;
  177. this._isBlendFunctionParametersDirty = true;
  178. };
  179. _AlphaState.prototype.reset = function () {
  180. this._alphaBlend = false;
  181. this._blendFunctionParameters[0] = null;
  182. this._blendFunctionParameters[1] = null;
  183. this._blendFunctionParameters[2] = null;
  184. this._blendFunctionParameters[3] = null;
  185. this._isAlphaBlendDirty = true;
  186. this._isBlendFunctionParametersDirty = false;
  187. };
  188. _AlphaState.prototype.apply = function (gl) {
  189. if (!this.isDirty) {
  190. return;
  191. }
  192. // Alpha blend
  193. if (this._isAlphaBlendDirty) {
  194. if (this._alphaBlend === true) {
  195. gl.enable(gl.BLEND);
  196. } else if (this._alphaBlend === false) {
  197. gl.disable(gl.BLEND);
  198. }
  199. this._isAlphaBlendDirty = false;
  200. }
  201. // Alpha function
  202. if (this._isBlendFunctionParametersDirty) {
  203. gl.blendFuncSeparate(this._blendFunctionParameters[0], this._blendFunctionParameters[1], this._blendFunctionParameters[2], this._blendFunctionParameters[3]);
  204. this._isBlendFunctionParametersDirty = false;
  205. }
  206. };
  207. return _AlphaState;
  208. })();
  209. BABYLON._AlphaState = _AlphaState;
  210. var compileShader = function (gl, source, type, defines) {
  211. var shader = gl.createShader(type === "vertex" ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER);
  212. gl.shaderSource(shader, (defines ? defines + "\n" : "") + source);
  213. gl.compileShader(shader);
  214. if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
  215. throw new Error(gl.getShaderInfoLog(shader));
  216. }
  217. return shader;
  218. };
  219. var getSamplingParameters = function (samplingMode, generateMipMaps, gl) {
  220. var magFilter = gl.NEAREST;
  221. var minFilter = gl.NEAREST;
  222. if (samplingMode === BABYLON.Texture.BILINEAR_SAMPLINGMODE) {
  223. magFilter = gl.LINEAR;
  224. if (generateMipMaps) {
  225. minFilter = gl.LINEAR_MIPMAP_NEAREST;
  226. } else {
  227. minFilter = gl.LINEAR;
  228. }
  229. } else if (samplingMode === BABYLON.Texture.TRILINEAR_SAMPLINGMODE) {
  230. magFilter = gl.LINEAR;
  231. if (generateMipMaps) {
  232. minFilter = gl.LINEAR_MIPMAP_LINEAR;
  233. } else {
  234. minFilter = gl.LINEAR;
  235. }
  236. } else if (samplingMode === BABYLON.Texture.NEAREST_SAMPLINGMODE) {
  237. magFilter = gl.NEAREST;
  238. if (generateMipMaps) {
  239. minFilter = gl.NEAREST_MIPMAP_LINEAR;
  240. } else {
  241. minFilter = gl.NEAREST;
  242. }
  243. }
  244. return {
  245. min: minFilter,
  246. mag: magFilter
  247. };
  248. };
  249. var prepareWebGLTexture = function (texture, gl, scene, width, height, invertY, noMipmap, isCompressed, processFunction, samplingMode) {
  250. if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
  251. var engine = scene.getEngine();
  252. var potWidth = BABYLON.Tools.GetExponantOfTwo(width, engine.getCaps().maxTextureSize);
  253. var potHeight = BABYLON.Tools.GetExponantOfTwo(height, engine.getCaps().maxTextureSize);
  254. gl.bindTexture(gl.TEXTURE_2D, texture);
  255. gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, invertY === undefined ? 1 : (invertY ? 1 : 0));
  256. processFunction(potWidth, potHeight);
  257. var filters = getSamplingParameters(samplingMode, !noMipmap, gl);
  258. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filters.mag);
  259. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filters.min);
  260. if (!noMipmap && !isCompressed) {
  261. gl.generateMipmap(gl.TEXTURE_2D);
  262. }
  263. gl.bindTexture(gl.TEXTURE_2D, null);
  264. engine._activeTexturesCache = [];
  265. texture._baseWidth = width;
  266. texture._baseHeight = height;
  267. texture._width = potWidth;
  268. texture._height = potHeight;
  269. texture.isReady = true;
  270. scene._removePendingData(texture);
  271. };
  272. var partialLoad = function (url, index, loadedImages, scene, onfinish) {
  273. var img;
  274. var onload = function () {
  275. loadedImages[index] = img;
  276. loadedImages._internalCount++;
  277. scene._removePendingData(img);
  278. if (loadedImages._internalCount == 6) {
  279. onfinish(loadedImages);
  280. }
  281. };
  282. var onerror = function () {
  283. scene._removePendingData(img);
  284. };
  285. img = BABYLON.Tools.LoadImage(url, onload, onerror, scene.database);
  286. scene._addPendingData(img);
  287. };
  288. var cascadeLoad = function (rootUrl, scene, onfinish, extensions) {
  289. var loadedImages = [];
  290. loadedImages._internalCount = 0;
  291. for (var index = 0; index < 6; index++) {
  292. partialLoad(rootUrl + extensions[index], index, loadedImages, scene, onfinish);
  293. }
  294. };
  295. var EngineCapabilities = (function () {
  296. function EngineCapabilities() {
  297. }
  298. return EngineCapabilities;
  299. })();
  300. BABYLON.EngineCapabilities = EngineCapabilities;
  301. var Engine = (function () {
  302. function Engine(canvas, antialias, options) {
  303. var _this = this;
  304. // Public members
  305. this.isFullscreen = false;
  306. this.isPointerLock = false;
  307. this.forceWireframe = false;
  308. this.cullBackFaces = true;
  309. this.renderEvenInBackground = true;
  310. this.scenes = new Array();
  311. this._windowIsBackground = false;
  312. this._runningLoop = false;
  313. this._loadingDivBackgroundColor = "black";
  314. // States
  315. this._depthCullingState = new _DepthCullingState();
  316. this._alphaState = new _AlphaState();
  317. // Cache
  318. this._loadedTexturesCache = new Array();
  319. this._activeTexturesCache = new Array();
  320. this._compiledEffects = {};
  321. this._renderingCanvas = canvas;
  322. this._canvasClientRect = this._renderingCanvas.getBoundingClientRect();
  323. options = options || {};
  324. options.antialias = antialias;
  325. try {
  326. this._gl = canvas.getContext("webgl", options) || canvas.getContext("experimental-webgl", options);
  327. } catch (e) {
  328. throw new Error("WebGL not supported");
  329. }
  330. if (!this._gl) {
  331. throw new Error("WebGL not supported");
  332. }
  333. this._onBlur = function () {
  334. _this._windowIsBackground = true;
  335. };
  336. this._onFocus = function () {
  337. _this._windowIsBackground = false;
  338. };
  339. window.addEventListener("blur", this._onBlur);
  340. window.addEventListener("focus", this._onFocus);
  341. // Textures
  342. this._workingCanvas = document.createElement("canvas");
  343. this._workingContext = this._workingCanvas.getContext("2d");
  344. // Viewport
  345. this._hardwareScalingLevel = 1.0 / (window.devicePixelRatio || 1.0);
  346. this.resize();
  347. // Caps
  348. this._caps = new EngineCapabilities();
  349. this._caps.maxTexturesImageUnits = this._gl.getParameter(this._gl.MAX_TEXTURE_IMAGE_UNITS);
  350. this._caps.maxTextureSize = this._gl.getParameter(this._gl.MAX_TEXTURE_SIZE);
  351. this._caps.maxCubemapTextureSize = this._gl.getParameter(this._gl.MAX_CUBE_MAP_TEXTURE_SIZE);
  352. this._caps.maxRenderTextureSize = this._gl.getParameter(this._gl.MAX_RENDERBUFFER_SIZE);
  353. // Extensions
  354. this._caps.standardDerivatives = (this._gl.getExtension('OES_standard_derivatives') !== null);
  355. this._caps.s3tc = this._gl.getExtension('WEBGL_compressed_texture_s3tc');
  356. this._caps.textureFloat = (this._gl.getExtension('OES_texture_float') !== null);
  357. this._caps.textureAnisotropicFilterExtension = this._gl.getExtension('EXT_texture_filter_anisotropic') || this._gl.getExtension('WEBKIT_EXT_texture_filter_anisotropic') || this._gl.getExtension('MOZ_EXT_texture_filter_anisotropic');
  358. this._caps.maxAnisotropy = this._caps.textureAnisotropicFilterExtension ? this._gl.getParameter(this._caps.textureAnisotropicFilterExtension.MAX_TEXTURE_MAX_ANISOTROPY_EXT) : 0;
  359. this._caps.instancedArrays = this._gl.getExtension('ANGLE_instanced_arrays');
  360. // Depth buffer
  361. this.setDepthBuffer(true);
  362. this.setDepthFunctionToLessOrEqual();
  363. this.setDepthWrite(true);
  364. // Fullscreen
  365. this._onFullscreenChange = function () {
  366. if (document.fullscreen !== undefined) {
  367. _this.isFullscreen = document.fullscreen;
  368. } else if (document.mozFullScreen !== undefined) {
  369. _this.isFullscreen = document.mozFullScreen;
  370. } else if (document.webkitIsFullScreen !== undefined) {
  371. _this.isFullscreen = document.webkitIsFullScreen;
  372. } else if (document.msIsFullScreen !== undefined) {
  373. _this.isFullscreen = document.msIsFullScreen;
  374. }
  375. // Pointer lock
  376. if (_this.isFullscreen && _this._pointerLockRequested) {
  377. canvas.requestPointerLock = canvas.requestPointerLock || canvas.msRequestPointerLock || canvas.mozRequestPointerLock || canvas.webkitRequestPointerLock;
  378. if (canvas.requestPointerLock) {
  379. canvas.requestPointerLock();
  380. }
  381. }
  382. };
  383. document.addEventListener("fullscreenchange", this._onFullscreenChange, false);
  384. document.addEventListener("mozfullscreenchange", this._onFullscreenChange, false);
  385. document.addEventListener("webkitfullscreenchange", this._onFullscreenChange, false);
  386. document.addEventListener("msfullscreenchange", this._onFullscreenChange, false);
  387. // Pointer lock
  388. this._onPointerLockChange = function () {
  389. _this.isPointerLock = (document.mozPointerLockElement === canvas || document.webkitPointerLockElement === canvas || document.msPointerLockElement === canvas || document.pointerLockElement === canvas);
  390. };
  391. document.addEventListener("pointerlockchange", this._onPointerLockChange, false);
  392. document.addEventListener("mspointerlockchange", this._onPointerLockChange, false);
  393. document.addEventListener("mozpointerlockchange", this._onPointerLockChange, false);
  394. document.addEventListener("webkitpointerlockchange", this._onPointerLockChange, false);
  395. }
  396. Object.defineProperty(Engine, "ALPHA_DISABLE", {
  397. get: function () {
  398. return Engine._ALPHA_DISABLE;
  399. },
  400. enumerable: true,
  401. configurable: true
  402. });
  403. Object.defineProperty(Engine, "ALPHA_ADD", {
  404. get: function () {
  405. return Engine._ALPHA_ADD;
  406. },
  407. enumerable: true,
  408. configurable: true
  409. });
  410. Object.defineProperty(Engine, "ALPHA_COMBINE", {
  411. get: function () {
  412. return Engine._ALPHA_COMBINE;
  413. },
  414. enumerable: true,
  415. configurable: true
  416. });
  417. Object.defineProperty(Engine, "DELAYLOADSTATE_NONE", {
  418. get: function () {
  419. return Engine._DELAYLOADSTATE_NONE;
  420. },
  421. enumerable: true,
  422. configurable: true
  423. });
  424. Object.defineProperty(Engine, "DELAYLOADSTATE_LOADED", {
  425. get: function () {
  426. return Engine._DELAYLOADSTATE_LOADED;
  427. },
  428. enumerable: true,
  429. configurable: true
  430. });
  431. Object.defineProperty(Engine, "DELAYLOADSTATE_LOADING", {
  432. get: function () {
  433. return Engine._DELAYLOADSTATE_LOADING;
  434. },
  435. enumerable: true,
  436. configurable: true
  437. });
  438. Object.defineProperty(Engine, "DELAYLOADSTATE_NOTLOADED", {
  439. get: function () {
  440. return Engine._DELAYLOADSTATE_NOTLOADED;
  441. },
  442. enumerable: true,
  443. configurable: true
  444. });
  445. Object.defineProperty(Engine, "Version", {
  446. get: function () {
  447. return "2.0.0";
  448. },
  449. enumerable: true,
  450. configurable: true
  451. });
  452. Engine.prototype.getAspectRatio = function (camera) {
  453. var viewport = camera.viewport;
  454. return (this.getRenderWidth() * viewport.width) / (this.getRenderHeight() * viewport.height);
  455. };
  456. Engine.prototype.getRenderWidth = function () {
  457. if (this._currentRenderTarget) {
  458. return this._currentRenderTarget._width;
  459. }
  460. return this._renderingCanvas.width;
  461. };
  462. Engine.prototype.getRenderHeight = function () {
  463. if (this._currentRenderTarget) {
  464. return this._currentRenderTarget._height;
  465. }
  466. return this._renderingCanvas.height;
  467. };
  468. Engine.prototype.getRenderingCanvas = function () {
  469. return this._renderingCanvas;
  470. };
  471. Engine.prototype.getRenderingCanvasClientRect = function () {
  472. return this._renderingCanvas.getBoundingClientRect();
  473. };
  474. Engine.prototype.setHardwareScalingLevel = function (level) {
  475. this._hardwareScalingLevel = level;
  476. this.resize();
  477. };
  478. Engine.prototype.getHardwareScalingLevel = function () {
  479. return this._hardwareScalingLevel;
  480. };
  481. Engine.prototype.getLoadedTexturesCache = function () {
  482. return this._loadedTexturesCache;
  483. };
  484. Engine.prototype.getCaps = function () {
  485. return this._caps;
  486. };
  487. // Methods
  488. Engine.prototype.setDepthFunctionToGreater = function () {
  489. this._depthCullingState.depthFunc = this._gl.GREATER;
  490. };
  491. Engine.prototype.setDepthFunctionToGreaterOrEqual = function () {
  492. this._depthCullingState.depthFunc = this._gl.GEQUAL;
  493. };
  494. Engine.prototype.setDepthFunctionToLess = function () {
  495. this._depthCullingState.depthFunc = this._gl.LESS;
  496. };
  497. Engine.prototype.setDepthFunctionToLessOrEqual = function () {
  498. this._depthCullingState.depthFunc = this._gl.LEQUAL;
  499. };
  500. Engine.prototype.stopRenderLoop = function () {
  501. this._renderFunction = null;
  502. this._runningLoop = false;
  503. };
  504. Engine.prototype._renderLoop = function () {
  505. var _this = this;
  506. var shouldRender = true;
  507. if (!this.renderEvenInBackground && this._windowIsBackground) {
  508. shouldRender = false;
  509. }
  510. if (shouldRender) {
  511. // Start new frame
  512. this.beginFrame();
  513. if (this._renderFunction) {
  514. this._renderFunction();
  515. }
  516. // Present
  517. this.endFrame();
  518. }
  519. if (this._runningLoop) {
  520. // Register new frame
  521. BABYLON.Tools.QueueNewFrame(function () {
  522. _this._renderLoop();
  523. });
  524. }
  525. };
  526. Engine.prototype.runRenderLoop = function (renderFunction) {
  527. var _this = this;
  528. this._runningLoop = true;
  529. this._renderFunction = renderFunction;
  530. BABYLON.Tools.QueueNewFrame(function () {
  531. _this._renderLoop();
  532. });
  533. };
  534. Engine.prototype.switchFullscreen = function (requestPointerLock) {
  535. if (this.isFullscreen) {
  536. BABYLON.Tools.ExitFullscreen();
  537. } else {
  538. this._pointerLockRequested = requestPointerLock;
  539. BABYLON.Tools.RequestFullscreen(this._renderingCanvas);
  540. }
  541. };
  542. Engine.prototype.clear = function (color, backBuffer, depthStencil) {
  543. this.applyStates();
  544. this._gl.clearColor(color.r, color.g, color.b, color.a !== undefined ? color.a : 1.0);
  545. if (this._depthCullingState.depthMask) {
  546. this._gl.clearDepth(1.0);
  547. }
  548. var mode = 0;
  549. if (backBuffer)
  550. mode |= this._gl.COLOR_BUFFER_BIT;
  551. if (depthStencil && this._depthCullingState.depthMask)
  552. mode |= this._gl.DEPTH_BUFFER_BIT;
  553. this._gl.clear(mode);
  554. };
  555. Engine.prototype.setViewport = function (viewport, requiredWidth, requiredHeight) {
  556. var width = requiredWidth || this._renderingCanvas.width;
  557. var height = requiredHeight || this._renderingCanvas.height;
  558. var x = viewport.x || 0;
  559. var y = viewport.y || 0;
  560. this._cachedViewport = viewport;
  561. this._gl.viewport(x * width, y * height, width * viewport.width, height * viewport.height);
  562. };
  563. Engine.prototype.setDirectViewport = function (x, y, width, height) {
  564. this._cachedViewport = null;
  565. this._gl.viewport(x, y, width, height);
  566. };
  567. Engine.prototype.beginFrame = function () {
  568. BABYLON.Tools._MeasureFps();
  569. };
  570. Engine.prototype.endFrame = function () {
  571. this.flushFramebuffer();
  572. };
  573. Engine.prototype.resize = function () {
  574. this.setSize(this._renderingCanvas.clientWidth / this._hardwareScalingLevel, this._renderingCanvas.clientHeight / this._hardwareScalingLevel);
  575. };
  576. Engine.prototype.setSize = function (width, height) {
  577. this._renderingCanvas.width = width;
  578. this._renderingCanvas.height = height;
  579. this._canvasClientRect = this._renderingCanvas.getBoundingClientRect();
  580. };
  581. Engine.prototype.bindFramebuffer = function (texture) {
  582. this._currentRenderTarget = texture;
  583. var gl = this._gl;
  584. gl.bindFramebuffer(gl.FRAMEBUFFER, texture._framebuffer);
  585. this._gl.viewport(0, 0, texture._width, texture._height);
  586. this.wipeCaches();
  587. };
  588. Engine.prototype.unBindFramebuffer = function (texture) {
  589. this._currentRenderTarget = null;
  590. if (texture.generateMipMaps) {
  591. var gl = this._gl;
  592. gl.bindTexture(gl.TEXTURE_2D, texture);
  593. gl.generateMipmap(gl.TEXTURE_2D);
  594. gl.bindTexture(gl.TEXTURE_2D, null);
  595. }
  596. this._gl.bindFramebuffer(this._gl.FRAMEBUFFER, null);
  597. };
  598. Engine.prototype.flushFramebuffer = function () {
  599. this._gl.flush();
  600. };
  601. Engine.prototype.restoreDefaultFramebuffer = function () {
  602. this._gl.bindFramebuffer(this._gl.FRAMEBUFFER, null);
  603. this.setViewport(this._cachedViewport);
  604. this.wipeCaches();
  605. };
  606. // VBOs
  607. Engine.prototype._resetVertexBufferBinding = function () {
  608. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, null);
  609. this._cachedVertexBuffers = null;
  610. };
  611. Engine.prototype.createVertexBuffer = function (vertices) {
  612. var vbo = this._gl.createBuffer();
  613. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, vbo);
  614. this._gl.bufferData(this._gl.ARRAY_BUFFER, new Float32Array(vertices), this._gl.STATIC_DRAW);
  615. this._resetVertexBufferBinding();
  616. vbo.references = 1;
  617. return vbo;
  618. };
  619. Engine.prototype.createDynamicVertexBuffer = function (capacity) {
  620. var vbo = this._gl.createBuffer();
  621. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, vbo);
  622. this._gl.bufferData(this._gl.ARRAY_BUFFER, capacity, this._gl.DYNAMIC_DRAW);
  623. this._resetVertexBufferBinding();
  624. vbo.references = 1;
  625. return vbo;
  626. };
  627. Engine.prototype.updateDynamicVertexBuffer = function (vertexBuffer, vertices, length) {
  628. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, vertexBuffer);
  629. //if (length && length != vertices.length) {
  630. // this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, new Float32Array(vertices, 0, length));
  631. //} else {
  632. if (vertices instanceof Float32Array) {
  633. this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, vertices);
  634. } else {
  635. this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, new Float32Array(vertices));
  636. }
  637. // }
  638. this._resetVertexBufferBinding();
  639. };
  640. Engine.prototype._resetIndexBufferBinding = function () {
  641. this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, null);
  642. this._cachedIndexBuffer = null;
  643. };
  644. Engine.prototype.createIndexBuffer = function (indices) {
  645. var vbo = this._gl.createBuffer();
  646. this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, vbo);
  647. this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), this._gl.STATIC_DRAW);
  648. this._resetIndexBufferBinding();
  649. vbo.references = 1;
  650. return vbo;
  651. };
  652. Engine.prototype.bindBuffers = function (vertexBuffer, indexBuffer, vertexDeclaration, vertexStrideSize, effect) {
  653. if (this._cachedVertexBuffers !== vertexBuffer || this._cachedEffectForVertexBuffers !== effect) {
  654. this._cachedVertexBuffers = vertexBuffer;
  655. this._cachedEffectForVertexBuffers = effect;
  656. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, vertexBuffer);
  657. var offset = 0;
  658. for (var index = 0; index < vertexDeclaration.length; index++) {
  659. var order = effect.getAttributeLocation(index);
  660. if (order >= 0) {
  661. this._gl.vertexAttribPointer(order, vertexDeclaration[index], this._gl.FLOAT, false, vertexStrideSize, offset);
  662. }
  663. offset += vertexDeclaration[index] * 4;
  664. }
  665. }
  666. if (this._cachedIndexBuffer !== indexBuffer) {
  667. this._cachedIndexBuffer = indexBuffer;
  668. this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
  669. }
  670. };
  671. Engine.prototype.bindMultiBuffers = function (vertexBuffers, indexBuffer, effect) {
  672. if (this._cachedVertexBuffers !== vertexBuffers || this._cachedEffectForVertexBuffers !== effect) {
  673. this._cachedVertexBuffers = vertexBuffers;
  674. this._cachedEffectForVertexBuffers = effect;
  675. var attributes = effect.getAttributesNames();
  676. for (var index = 0; index < attributes.length; index++) {
  677. var order = effect.getAttributeLocation(index);
  678. if (order >= 0) {
  679. var vertexBuffer = vertexBuffers[attributes[index]];
  680. if (!vertexBuffer) {
  681. continue;
  682. }
  683. var stride = vertexBuffer.getStrideSize();
  684. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, vertexBuffer.getBuffer());
  685. this._gl.vertexAttribPointer(order, stride, this._gl.FLOAT, false, stride * 4, 0);
  686. }
  687. }
  688. }
  689. if (indexBuffer != null && this._cachedIndexBuffer !== indexBuffer) {
  690. this._cachedIndexBuffer = indexBuffer;
  691. this._gl.bindBuffer(this._gl.ELEMENT_ARRAY_BUFFER, indexBuffer);
  692. }
  693. };
  694. Engine.prototype._releaseBuffer = function (buffer) {
  695. buffer.references--;
  696. if (buffer.references === 0) {
  697. this._gl.deleteBuffer(buffer);
  698. return true;
  699. }
  700. return false;
  701. };
  702. Engine.prototype.createInstancesBuffer = function (capacity) {
  703. var buffer = this._gl.createBuffer();
  704. buffer.capacity = capacity;
  705. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, buffer);
  706. this._gl.bufferData(this._gl.ARRAY_BUFFER, capacity, this._gl.DYNAMIC_DRAW);
  707. return buffer;
  708. };
  709. Engine.prototype.deleteInstancesBuffer = function (buffer) {
  710. this._gl.deleteBuffer(buffer);
  711. };
  712. Engine.prototype.updateAndBindInstancesBuffer = function (instancesBuffer, data, offsetLocations) {
  713. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, instancesBuffer);
  714. this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, data);
  715. for (var index = 0; index < 4; index++) {
  716. var offsetLocation = offsetLocations[index];
  717. this._gl.enableVertexAttribArray(offsetLocation);
  718. this._gl.vertexAttribPointer(offsetLocation, 4, this._gl.FLOAT, false, 64, index * 16);
  719. this._caps.instancedArrays.vertexAttribDivisorANGLE(offsetLocation, 1);
  720. }
  721. };
  722. Engine.prototype.unBindInstancesBuffer = function (instancesBuffer, offsetLocations) {
  723. this._gl.bindBuffer(this._gl.ARRAY_BUFFER, instancesBuffer);
  724. for (var index = 0; index < 4; index++) {
  725. var offsetLocation = offsetLocations[index];
  726. this._gl.disableVertexAttribArray(offsetLocation);
  727. this._caps.instancedArrays.vertexAttribDivisorANGLE(offsetLocation, 0);
  728. }
  729. };
  730. Engine.prototype.applyStates = function () {
  731. this._depthCullingState.apply(this._gl);
  732. this._alphaState.apply(this._gl);
  733. };
  734. Engine.prototype.draw = function (useTriangles, indexStart, indexCount, instancesCount) {
  735. // Apply states
  736. this.applyStates();
  737. // Render
  738. if (instancesCount) {
  739. this._caps.instancedArrays.drawElementsInstancedANGLE(useTriangles ? this._gl.TRIANGLES : this._gl.LINES, indexCount, this._gl.UNSIGNED_SHORT, indexStart * 2, instancesCount);
  740. return;
  741. }
  742. this._gl.drawElements(useTriangles ? this._gl.TRIANGLES : this._gl.LINES, indexCount, this._gl.UNSIGNED_SHORT, indexStart * 2);
  743. };
  744. Engine.prototype.drawPointClouds = function (verticesStart, verticesCount, instancesCount) {
  745. // Apply states
  746. this.applyStates();
  747. if (instancesCount) {
  748. this._caps.instancedArrays.drawArraysInstancedANGLE(this._gl.POINTS, verticesStart, verticesCount, instancesCount);
  749. return;
  750. }
  751. this._gl.drawArrays(this._gl.POINTS, verticesStart, verticesCount);
  752. };
  753. // Shaders
  754. Engine.prototype._releaseEffect = function (effect) {
  755. if (this._compiledEffects[effect._key]) {
  756. delete this._compiledEffects[effect._key];
  757. if (effect.getProgram()) {
  758. this._gl.deleteProgram(effect.getProgram());
  759. }
  760. }
  761. };
  762. Engine.prototype.createEffect = function (baseName, attributesNames, uniformsNames, samplers, defines, fallbacks, onCompiled, onError) {
  763. var vertex = baseName.vertexElement || baseName.vertex || baseName;
  764. var fragment = baseName.fragmentElement || baseName.fragment || baseName;
  765. var name = vertex + "+" + fragment + "@" + defines;
  766. if (this._compiledEffects[name]) {
  767. return this._compiledEffects[name];
  768. }
  769. var effect = new BABYLON.Effect(baseName, attributesNames, uniformsNames, samplers, this, defines, fallbacks, onCompiled, onError);
  770. effect._key = name;
  771. this._compiledEffects[name] = effect;
  772. return effect;
  773. };
  774. Engine.prototype.createEffectForParticles = function (fragmentName, uniformsNames, samplers, defines, fallbacks, onCompiled, onError) {
  775. if (typeof uniformsNames === "undefined") { uniformsNames = []; }
  776. if (typeof samplers === "undefined") { samplers = []; }
  777. if (typeof defines === "undefined") { defines = ""; }
  778. return this.createEffect({
  779. vertex: "particles",
  780. fragmentElement: fragmentName
  781. }, ["position", "color", "options"], ["view", "projection"].concat(uniformsNames), ["diffuseSampler"].concat(samplers), defines, fallbacks, onCompiled, onError);
  782. };
  783. Engine.prototype.createShaderProgram = function (vertexCode, fragmentCode, defines) {
  784. var vertexShader = compileShader(this._gl, vertexCode, "vertex", defines);
  785. var fragmentShader = compileShader(this._gl, fragmentCode, "fragment", defines);
  786. var shaderProgram = this._gl.createProgram();
  787. this._gl.attachShader(shaderProgram, vertexShader);
  788. this._gl.attachShader(shaderProgram, fragmentShader);
  789. this._gl.linkProgram(shaderProgram);
  790. var linked = this._gl.getProgramParameter(shaderProgram, this._gl.LINK_STATUS);
  791. if (!linked) {
  792. var error = this._gl.getProgramInfoLog(shaderProgram);
  793. if (error) {
  794. throw new Error(error);
  795. }
  796. }
  797. this._gl.deleteShader(vertexShader);
  798. this._gl.deleteShader(fragmentShader);
  799. return shaderProgram;
  800. };
  801. Engine.prototype.getUniforms = function (shaderProgram, uniformsNames) {
  802. var results = [];
  803. for (var index = 0; index < uniformsNames.length; index++) {
  804. results.push(this._gl.getUniformLocation(shaderProgram, uniformsNames[index]));
  805. }
  806. return results;
  807. };
  808. Engine.prototype.getAttributes = function (shaderProgram, attributesNames) {
  809. var results = [];
  810. for (var index = 0; index < attributesNames.length; index++) {
  811. try {
  812. results.push(this._gl.getAttribLocation(shaderProgram, attributesNames[index]));
  813. } catch (e) {
  814. results.push(-1);
  815. }
  816. }
  817. return results;
  818. };
  819. Engine.prototype.enableEffect = function (effect) {
  820. if (!effect || !effect.getAttributesCount() || this._currentEffect === effect) {
  821. return;
  822. }
  823. this._vertexAttribArrays = this._vertexAttribArrays || [];
  824. // Use program
  825. this._gl.useProgram(effect.getProgram());
  826. for (var i in this._vertexAttribArrays) {
  827. if (i > this._gl.VERTEX_ATTRIB_ARRAY_ENABLED || !this._vertexAttribArrays[i]) {
  828. continue;
  829. }
  830. this._vertexAttribArrays[i] = false;
  831. this._gl.disableVertexAttribArray(i);
  832. }
  833. var attributesCount = effect.getAttributesCount();
  834. for (var index = 0; index < attributesCount; index++) {
  835. // Attributes
  836. var order = effect.getAttributeLocation(index);
  837. if (order >= 0) {
  838. this._vertexAttribArrays[order] = true;
  839. this._gl.enableVertexAttribArray(order);
  840. }
  841. }
  842. this._currentEffect = effect;
  843. };
  844. Engine.prototype.setArray = function (uniform, array) {
  845. if (!uniform)
  846. return;
  847. this._gl.uniform1fv(uniform, array);
  848. };
  849. Engine.prototype.setMatrices = function (uniform, matrices) {
  850. if (!uniform)
  851. return;
  852. this._gl.uniformMatrix4fv(uniform, false, matrices);
  853. };
  854. Engine.prototype.setMatrix = function (uniform, matrix) {
  855. if (!uniform)
  856. return;
  857. this._gl.uniformMatrix4fv(uniform, false, matrix.toArray());
  858. };
  859. Engine.prototype.setFloat = function (uniform, value) {
  860. if (!uniform)
  861. return;
  862. this._gl.uniform1f(uniform, value);
  863. };
  864. Engine.prototype.setFloat2 = function (uniform, x, y) {
  865. if (!uniform)
  866. return;
  867. this._gl.uniform2f(uniform, x, y);
  868. };
  869. Engine.prototype.setFloat3 = function (uniform, x, y, z) {
  870. if (!uniform)
  871. return;
  872. this._gl.uniform3f(uniform, x, y, z);
  873. };
  874. Engine.prototype.setBool = function (uniform, bool) {
  875. if (!uniform)
  876. return;
  877. this._gl.uniform1i(uniform, bool);
  878. };
  879. Engine.prototype.setFloat4 = function (uniform, x, y, z, w) {
  880. if (!uniform)
  881. return;
  882. this._gl.uniform4f(uniform, x, y, z, w);
  883. };
  884. Engine.prototype.setColor3 = function (uniform, color3) {
  885. if (!uniform)
  886. return;
  887. this._gl.uniform3f(uniform, color3.r, color3.g, color3.b);
  888. };
  889. Engine.prototype.setColor4 = function (uniform, color3, alpha) {
  890. if (!uniform)
  891. return;
  892. this._gl.uniform4f(uniform, color3.r, color3.g, color3.b, alpha);
  893. };
  894. // States
  895. Engine.prototype.setState = function (culling, force) {
  896. // Culling
  897. if (this._depthCullingState.cull !== culling || force) {
  898. if (culling) {
  899. this._depthCullingState.cullFace = this.cullBackFaces ? this._gl.BACK : this._gl.FRONT;
  900. this._depthCullingState.cull = true;
  901. } else {
  902. this._depthCullingState.cull = false;
  903. }
  904. }
  905. };
  906. Engine.prototype.setDepthBuffer = function (enable) {
  907. this._depthCullingState.depthTest = enable;
  908. };
  909. Engine.prototype.getDepthWrite = function () {
  910. return this._depthCullingState.depthMask;
  911. };
  912. Engine.prototype.setDepthWrite = function (enable) {
  913. this._depthCullingState.depthMask = enable;
  914. };
  915. Engine.prototype.setColorWrite = function (enable) {
  916. this._gl.colorMask(enable, enable, enable, enable);
  917. };
  918. Engine.prototype.setAlphaMode = function (mode) {
  919. switch (mode) {
  920. case BABYLON.Engine.ALPHA_DISABLE:
  921. this.setDepthWrite(true);
  922. this._alphaState.alphaBlend = false;
  923. break;
  924. case BABYLON.Engine.ALPHA_COMBINE:
  925. this.setDepthWrite(false);
  926. this._alphaState.setAlphaBlendFunctionParameters(this._gl.SRC_ALPHA, this._gl.ONE_MINUS_SRC_ALPHA, this._gl.ONE, this._gl.ONE);
  927. this._alphaState.alphaBlend = true;
  928. break;
  929. case BABYLON.Engine.ALPHA_ADD:
  930. this.setDepthWrite(false);
  931. this._alphaState.setAlphaBlendFunctionParameters(this._gl.ONE, this._gl.ONE, this._gl.ZERO, this._gl.ONE);
  932. this._alphaState.alphaBlend = true;
  933. break;
  934. }
  935. };
  936. Engine.prototype.setAlphaTesting = function (enable) {
  937. this._alphaTest = enable;
  938. };
  939. Engine.prototype.getAlphaTesting = function () {
  940. return this._alphaTest;
  941. };
  942. // Textures
  943. Engine.prototype.wipeCaches = function () {
  944. this._activeTexturesCache = [];
  945. this._currentEffect = null;
  946. this._depthCullingState.reset();
  947. this._alphaState.reset();
  948. this._cachedVertexBuffers = null;
  949. this._cachedIndexBuffer = null;
  950. this._cachedEffectForVertexBuffers = null;
  951. };
  952. Engine.prototype.setSamplingMode = function (texture, samplingMode) {
  953. var gl = this._gl;
  954. gl.bindTexture(gl.TEXTURE_2D, texture);
  955. var magFilter = gl.NEAREST;
  956. var minFilter = gl.NEAREST;
  957. if (samplingMode === BABYLON.Texture.BILINEAR_SAMPLINGMODE) {
  958. magFilter = gl.LINEAR;
  959. minFilter = gl.LINEAR;
  960. } else if (samplingMode === BABYLON.Texture.TRILINEAR_SAMPLINGMODE) {
  961. magFilter = gl.LINEAR;
  962. minFilter = gl.LINEAR_MIPMAP_LINEAR;
  963. }
  964. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, magFilter);
  965. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, minFilter);
  966. gl.bindTexture(gl.TEXTURE_2D, null);
  967. };
  968. Engine.prototype.createTexture = function (url, noMipmap, invertY, scene, samplingMode, onLoad, onError, buffer) {
  969. var _this = this;
  970. if (typeof samplingMode === "undefined") { samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE; }
  971. if (typeof onLoad === "undefined") { onLoad = null; }
  972. if (typeof onError === "undefined") { onError = null; }
  973. if (typeof buffer === "undefined") { buffer = null; }
  974. var texture = this._gl.createTexture();
  975. var extension;
  976. var fromData = false;
  977. if (url.substr(0, 5) === "data:") {
  978. fromData = true;
  979. }
  980. if (!fromData)
  981. extension = url.substr(url.length - 4, 4).toLowerCase();
  982. else {
  983. var oldUrl = url;
  984. fromData = oldUrl.split(':');
  985. url = oldUrl;
  986. extension = fromData[1].substr(fromData[1].length - 4, 4).toLowerCase();
  987. }
  988. var isDDS = this.getCaps().s3tc && (extension === ".dds");
  989. var isTGA = (extension === ".tga");
  990. scene._addPendingData(texture);
  991. texture.url = url;
  992. texture.noMipmap = noMipmap;
  993. texture.references = 1;
  994. this._loadedTexturesCache.push(texture);
  995. var onerror = function () {
  996. scene._removePendingData(texture);
  997. if (onError) {
  998. onError();
  999. }
  1000. };
  1001. if (isTGA) {
  1002. var callback = function (arrayBuffer) {
  1003. var data = new Uint8Array(arrayBuffer);
  1004. var header = BABYLON.Internals.TGATools.GetTGAHeader(data);
  1005. prepareWebGLTexture(texture, _this._gl, scene, header.width, header.height, invertY, noMipmap, false, function () {
  1006. BABYLON.Internals.TGATools.UploadContent(_this._gl, data);
  1007. if (onLoad) {
  1008. onLoad();
  1009. }
  1010. }, samplingMode);
  1011. };
  1012. if (!(fromData instanceof Array))
  1013. BABYLON.Tools.LoadFile(url, function (arrayBuffer) {
  1014. callback(arrayBuffer);
  1015. }, onerror, scene.database, true);
  1016. else
  1017. callback(buffer);
  1018. } else if (isDDS) {
  1019. callback = function (data) {
  1020. var info = BABYLON.Internals.DDSTools.GetDDSInfo(data);
  1021. var loadMipmap = (info.isRGB || info.isLuminance || info.mipmapCount > 1) && !noMipmap && ((info.width >> (info.mipmapCount - 1)) == 1);
  1022. prepareWebGLTexture(texture, _this._gl, scene, info.width, info.height, invertY, !loadMipmap, info.isFourCC, function () {
  1023. BABYLON.Internals.DDSTools.UploadDDSLevels(_this._gl, _this.getCaps().s3tc, data, info, loadMipmap, 1);
  1024. if (onLoad) {
  1025. onLoad();
  1026. }
  1027. }, samplingMode);
  1028. };
  1029. if (!(fromData instanceof Array))
  1030. BABYLON.Tools.LoadFile(url, function (data) {
  1031. callback(data);
  1032. }, onerror, scene.database, true);
  1033. else
  1034. callback(buffer);
  1035. } else {
  1036. var onload = function (img) {
  1037. prepareWebGLTexture(texture, _this._gl, scene, img.width, img.height, invertY, noMipmap, false, function (potWidth, potHeight) {
  1038. var isPot = (img.width == potWidth && img.height == potHeight);
  1039. if (!isPot) {
  1040. _this._workingCanvas.width = potWidth;
  1041. _this._workingCanvas.height = potHeight;
  1042. _this._workingContext.drawImage(img, 0, 0, img.width, img.height, 0, 0, potWidth, potHeight);
  1043. }
  1044. _this._gl.texImage2D(_this._gl.TEXTURE_2D, 0, _this._gl.RGBA, _this._gl.RGBA, _this._gl.UNSIGNED_BYTE, isPot ? img : _this._workingCanvas);
  1045. if (onLoad) {
  1046. onLoad();
  1047. }
  1048. }, samplingMode);
  1049. };
  1050. if (!(fromData instanceof Array))
  1051. BABYLON.Tools.LoadImage(url, onload, onerror, scene.database);
  1052. else
  1053. BABYLON.Tools.LoadImage(buffer, onload, onerror, scene.database);
  1054. }
  1055. return texture;
  1056. };
  1057. Engine.prototype.createDynamicTexture = function (width, height, generateMipMaps, samplingMode) {
  1058. var texture = this._gl.createTexture();
  1059. width = BABYLON.Tools.GetExponantOfTwo(width, this._caps.maxTextureSize);
  1060. height = BABYLON.Tools.GetExponantOfTwo(height, this._caps.maxTextureSize);
  1061. this._gl.bindTexture(this._gl.TEXTURE_2D, texture);
  1062. var filters = getSamplingParameters(samplingMode, generateMipMaps, this._gl);
  1063. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MAG_FILTER, filters.mag);
  1064. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_MIN_FILTER, filters.min);
  1065. this._gl.bindTexture(this._gl.TEXTURE_2D, null);
  1066. this._activeTexturesCache = [];
  1067. texture._baseWidth = width;
  1068. texture._baseHeight = height;
  1069. texture._width = width;
  1070. texture._height = height;
  1071. texture.isReady = false;
  1072. texture.generateMipMaps = generateMipMaps;
  1073. texture.references = 1;
  1074. this._loadedTexturesCache.push(texture);
  1075. return texture;
  1076. };
  1077. Engine.prototype.updateDynamicTexture = function (texture, canvas, invertY) {
  1078. this._gl.bindTexture(this._gl.TEXTURE_2D, texture);
  1079. this._gl.pixelStorei(this._gl.UNPACK_FLIP_Y_WEBGL, invertY ? 1 : 0);
  1080. this._gl.texImage2D(this._gl.TEXTURE_2D, 0, this._gl.RGBA, this._gl.RGBA, this._gl.UNSIGNED_BYTE, canvas);
  1081. if (texture.generateMipMaps) {
  1082. this._gl.generateMipmap(this._gl.TEXTURE_2D);
  1083. }
  1084. this._gl.bindTexture(this._gl.TEXTURE_2D, null);
  1085. this._activeTexturesCache = [];
  1086. texture.isReady = true;
  1087. };
  1088. Engine.prototype.updateVideoTexture = function (texture, video, invertY) {
  1089. this._gl.bindTexture(this._gl.TEXTURE_2D, texture);
  1090. this._gl.pixelStorei(this._gl.UNPACK_FLIP_Y_WEBGL, invertY ? 0 : 1); // Video are upside down by default
  1091. // Scale the video if it is a NPOT using the current working canvas
  1092. if (video.videoWidth !== texture._width || video.videoHeight !== texture._height) {
  1093. if (!texture._workingCanvas) {
  1094. texture._workingCanvas = document.createElement("canvas");
  1095. texture._workingContext = texture._workingCanvas.getContext("2d");
  1096. texture._workingCanvas.width = texture._width;
  1097. texture._workingCanvas.height = texture._height;
  1098. }
  1099. texture._workingContext.drawImage(video, 0, 0, video.videoWidth, video.videoHeight, 0, 0, texture._width, texture._height);
  1100. this._gl.texImage2D(this._gl.TEXTURE_2D, 0, this._gl.RGBA, this._gl.RGBA, this._gl.UNSIGNED_BYTE, texture._workingCanvas);
  1101. } else {
  1102. this._gl.texImage2D(this._gl.TEXTURE_2D, 0, this._gl.RGBA, this._gl.RGBA, this._gl.UNSIGNED_BYTE, video);
  1103. }
  1104. if (texture.generateMipMaps) {
  1105. this._gl.generateMipmap(this._gl.TEXTURE_2D);
  1106. }
  1107. this._gl.bindTexture(this._gl.TEXTURE_2D, null);
  1108. this._activeTexturesCache = [];
  1109. texture.isReady = true;
  1110. };
  1111. Engine.prototype.createRenderTargetTexture = function (size, options) {
  1112. // old version had a "generateMipMaps" arg instead of options.
  1113. // if options.generateMipMaps is undefined, consider that options itself if the generateMipmaps value
  1114. // in the same way, generateDepthBuffer is defaulted to true
  1115. var generateMipMaps = false;
  1116. var generateDepthBuffer = true;
  1117. var samplingMode = BABYLON.Texture.TRILINEAR_SAMPLINGMODE;
  1118. if (options !== undefined) {
  1119. generateMipMaps = options.generateMipMaps === undefined ? options : options.generateMipmaps;
  1120. generateDepthBuffer = options.generateDepthBuffer === undefined ? true : options.generateDepthBuffer;
  1121. if (options.samplingMode !== undefined) {
  1122. samplingMode = options.samplingMode;
  1123. }
  1124. }
  1125. var gl = this._gl;
  1126. var texture = gl.createTexture();
  1127. gl.bindTexture(gl.TEXTURE_2D, texture);
  1128. var width = size.width || size;
  1129. var height = size.height || size;
  1130. var filters = getSamplingParameters(samplingMode, generateMipMaps, gl);
  1131. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filters.mag);
  1132. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filters.min);
  1133. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
  1134. gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
  1135. gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, width, height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
  1136. var depthBuffer;
  1137. // Create the depth buffer
  1138. if (generateDepthBuffer) {
  1139. depthBuffer = gl.createRenderbuffer();
  1140. gl.bindRenderbuffer(gl.RENDERBUFFER, depthBuffer);
  1141. gl.renderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, width, height);
  1142. }
  1143. // Create the framebuffer
  1144. var framebuffer = gl.createFramebuffer();
  1145. gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer);
  1146. gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);
  1147. if (generateDepthBuffer) {
  1148. gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthBuffer);
  1149. }
  1150. // Unbind
  1151. gl.bindTexture(gl.TEXTURE_2D, null);
  1152. gl.bindRenderbuffer(gl.RENDERBUFFER, null);
  1153. gl.bindFramebuffer(gl.FRAMEBUFFER, null);
  1154. texture._framebuffer = framebuffer;
  1155. if (generateDepthBuffer) {
  1156. texture._depthBuffer = depthBuffer;
  1157. }
  1158. texture._width = width;
  1159. texture._height = height;
  1160. texture.isReady = true;
  1161. texture.generateMipMaps = generateMipMaps;
  1162. texture.references = 1;
  1163. this._activeTexturesCache = [];
  1164. this._loadedTexturesCache.push(texture);
  1165. return texture;
  1166. };
  1167. Engine.prototype.createCubeTexture = function (rootUrl, scene, extensions, noMipmap) {
  1168. var _this = this;
  1169. var gl = this._gl;
  1170. var texture = gl.createTexture();
  1171. texture.isCube = true;
  1172. texture.url = rootUrl;
  1173. texture.references = 1;
  1174. this._loadedTexturesCache.push(texture);
  1175. var extension = rootUrl.substr(rootUrl.length - 4, 4).toLowerCase();
  1176. var isDDS = this.getCaps().s3tc && (extension === ".dds");
  1177. if (isDDS) {
  1178. BABYLON.Tools.LoadFile(rootUrl, function (data) {
  1179. var info = BABYLON.Internals.DDSTools.GetDDSInfo(data);
  1180. var loadMipmap = (info.isRGB || info.isLuminance || info.mipmapCount > 1) && !noMipmap;
  1181. gl.bindTexture(gl.TEXTURE_CUBE_MAP, texture);
  1182. gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
  1183. BABYLON.Internals.DDSTools.UploadDDSLevels(_this._gl, _this.getCaps().s3tc, data, info, loadMipmap, 6);
  1184. if (!noMipmap && !info.isFourCC && info.mipmapCount == 1) {
  1185. gl.generateMipmap(gl.TEXTURE_CUBE_MAP);
  1186. }
  1187. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
  1188. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, loadMipmap ? gl.LINEAR_MIPMAP_LINEAR : gl.LINEAR);
  1189. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
  1190. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
  1191. gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
  1192. _this._activeTexturesCache = [];
  1193. texture._width = info.width;
  1194. texture._height = info.height;
  1195. texture.isReady = true;
  1196. }, null, null, true);
  1197. } else {
  1198. cascadeLoad(rootUrl, scene, function (imgs) {
  1199. var width = BABYLON.Tools.GetExponantOfTwo(imgs[0].width, _this._caps.maxCubemapTextureSize);
  1200. var height = width;
  1201. _this._workingCanvas.width = width;
  1202. _this._workingCanvas.height = height;
  1203. var faces = [
  1204. gl.TEXTURE_CUBE_MAP_POSITIVE_X, gl.TEXTURE_CUBE_MAP_POSITIVE_Y, gl.TEXTURE_CUBE_MAP_POSITIVE_Z,
  1205. gl.TEXTURE_CUBE_MAP_NEGATIVE_X, gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, gl.TEXTURE_CUBE_MAP_NEGATIVE_Z
  1206. ];
  1207. gl.bindTexture(gl.TEXTURE_CUBE_MAP, texture);
  1208. gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 0);
  1209. for (var index = 0; index < faces.length; index++) {
  1210. _this._workingContext.drawImage(imgs[index], 0, 0, imgs[index].width, imgs[index].height, 0, 0, width, height);
  1211. gl.texImage2D(faces[index], 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, _this._workingCanvas);
  1212. }
  1213. if (!noMipmap) {
  1214. gl.generateMipmap(gl.TEXTURE_CUBE_MAP);
  1215. }
  1216. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
  1217. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, noMipmap ? gl.LINEAR : gl.LINEAR_MIPMAP_LINEAR);
  1218. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
  1219. gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
  1220. gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
  1221. _this._activeTexturesCache = [];
  1222. texture._width = width;
  1223. texture._height = height;
  1224. texture.isReady = true;
  1225. }, extensions);
  1226. }
  1227. return texture;
  1228. };
  1229. Engine.prototype._releaseTexture = function (texture) {
  1230. var gl = this._gl;
  1231. if (texture._framebuffer) {
  1232. gl.deleteFramebuffer(texture._framebuffer);
  1233. }
  1234. if (texture._depthBuffer) {
  1235. gl.deleteRenderbuffer(texture._depthBuffer);
  1236. }
  1237. gl.deleteTexture(texture);
  1238. for (var channel = 0; channel < this._caps.maxTexturesImageUnits; channel++) {
  1239. this._gl.activeTexture(this._gl["TEXTURE" + channel]);
  1240. this._gl.bindTexture(this._gl.TEXTURE_2D, null);
  1241. this._gl.bindTexture(this._gl.TEXTURE_CUBE_MAP, null);
  1242. this._activeTexturesCache[channel] = null;
  1243. }
  1244. var index = this._loadedTexturesCache.indexOf(texture);
  1245. if (index !== -1) {
  1246. this._loadedTexturesCache.splice(index, 1);
  1247. }
  1248. };
  1249. Engine.prototype.bindSamplers = function (effect) {
  1250. this._gl.useProgram(effect.getProgram());
  1251. var samplers = effect.getSamplers();
  1252. for (var index = 0; index < samplers.length; index++) {
  1253. var uniform = effect.getUniform(samplers[index]);
  1254. this._gl.uniform1i(uniform, index);
  1255. }
  1256. this._currentEffect = null;
  1257. };
  1258. Engine.prototype._bindTexture = function (channel, texture) {
  1259. this._gl.activeTexture(this._gl["TEXTURE" + channel]);
  1260. this._gl.bindTexture(this._gl.TEXTURE_2D, texture);
  1261. this._activeTexturesCache[channel] = null;
  1262. };
  1263. Engine.prototype.setTextureFromPostProcess = function (channel, postProcess) {
  1264. this._bindTexture(channel, postProcess._textures.data[postProcess._currentRenderTextureInd]);
  1265. };
  1266. Engine.prototype.setTexture = function (channel, texture) {
  1267. if (channel < 0) {
  1268. return;
  1269. }
  1270. // Not ready?
  1271. if (!texture || !texture.isReady()) {
  1272. if (this._activeTexturesCache[channel] != null) {
  1273. this._gl.activeTexture(this._gl["TEXTURE" + channel]);
  1274. this._gl.bindTexture(this._gl.TEXTURE_2D, null);
  1275. this._gl.bindTexture(this._gl.TEXTURE_CUBE_MAP, null);
  1276. this._activeTexturesCache[channel] = null;
  1277. }
  1278. return;
  1279. }
  1280. // Video
  1281. if (texture instanceof BABYLON.VideoTexture) {
  1282. if (texture.update()) {
  1283. this._activeTexturesCache[channel] = null;
  1284. }
  1285. } else if (texture.delayLoadState == BABYLON.Engine.DELAYLOADSTATE_NOTLOADED) {
  1286. texture.delayLoad();
  1287. return;
  1288. }
  1289. if (this._activeTexturesCache[channel] == texture) {
  1290. return;
  1291. }
  1292. this._activeTexturesCache[channel] = texture;
  1293. var internalTexture = texture.getInternalTexture();
  1294. this._gl.activeTexture(this._gl["TEXTURE" + channel]);
  1295. if (internalTexture.isCube) {
  1296. this._gl.bindTexture(this._gl.TEXTURE_CUBE_MAP, internalTexture);
  1297. if (internalTexture._cachedCoordinatesMode !== texture.coordinatesMode) {
  1298. internalTexture._cachedCoordinatesMode = texture.coordinatesMode;
  1299. // CUBIC_MODE and SKYBOX_MODE both require CLAMP_TO_EDGE. All other modes use REPEAT.
  1300. var textureWrapMode = (texture.coordinatesMode !== BABYLON.Texture.CUBIC_MODE && texture.coordinatesMode !== BABYLON.Texture.SKYBOX_MODE) ? this._gl.REPEAT : this._gl.CLAMP_TO_EDGE;
  1301. this._gl.texParameteri(this._gl.TEXTURE_CUBE_MAP, this._gl.TEXTURE_WRAP_S, textureWrapMode);
  1302. this._gl.texParameteri(this._gl.TEXTURE_CUBE_MAP, this._gl.TEXTURE_WRAP_T, textureWrapMode);
  1303. }
  1304. this._setAnisotropicLevel(this._gl.TEXTURE_CUBE_MAP, texture);
  1305. } else {
  1306. this._gl.bindTexture(this._gl.TEXTURE_2D, internalTexture);
  1307. if (internalTexture._cachedWrapU !== texture.wrapU) {
  1308. internalTexture._cachedWrapU = texture.wrapU;
  1309. switch (texture.wrapU) {
  1310. case BABYLON.Texture.WRAP_ADDRESSMODE:
  1311. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_S, this._gl.REPEAT);
  1312. break;
  1313. case BABYLON.Texture.CLAMP_ADDRESSMODE:
  1314. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_S, this._gl.CLAMP_TO_EDGE);
  1315. break;
  1316. case BABYLON.Texture.MIRROR_ADDRESSMODE:
  1317. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_S, this._gl.MIRRORED_REPEAT);
  1318. break;
  1319. }
  1320. }
  1321. if (internalTexture._cachedWrapV !== texture.wrapV) {
  1322. internalTexture._cachedWrapV = texture.wrapV;
  1323. switch (texture.wrapV) {
  1324. case BABYLON.Texture.WRAP_ADDRESSMODE:
  1325. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_T, this._gl.REPEAT);
  1326. break;
  1327. case BABYLON.Texture.CLAMP_ADDRESSMODE:
  1328. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_T, this._gl.CLAMP_TO_EDGE);
  1329. break;
  1330. case BABYLON.Texture.MIRROR_ADDRESSMODE:
  1331. this._gl.texParameteri(this._gl.TEXTURE_2D, this._gl.TEXTURE_WRAP_T, this._gl.MIRRORED_REPEAT);
  1332. break;
  1333. }
  1334. }
  1335. this._setAnisotropicLevel(this._gl.TEXTURE_2D, texture);
  1336. }
  1337. };
  1338. Engine.prototype._setAnisotropicLevel = function (key, texture) {
  1339. var anisotropicFilterExtension = this._caps.textureAnisotropicFilterExtension;
  1340. if (anisotropicFilterExtension && texture._cachedAnisotropicFilteringLevel !== texture.anisotropicFilteringLevel) {
  1341. this._gl.texParameterf(key, anisotropicFilterExtension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(texture.anisotropicFilteringLevel, this._caps.maxAnisotropy));
  1342. texture._cachedAnisotropicFilteringLevel = texture.anisotropicFilteringLevel;
  1343. }
  1344. };
  1345. Engine.prototype.readPixels = function (x, y, width, height) {
  1346. var data = new Uint8Array(height * width * 4);
  1347. this._gl.readPixels(0, 0, width, height, this._gl.RGBA, this._gl.UNSIGNED_BYTE, data);
  1348. return data;
  1349. };
  1350. // Dispose
  1351. Engine.prototype.dispose = function () {
  1352. this.hideLoadingUI();
  1353. this.stopRenderLoop();
  1354. while (this.scenes.length) {
  1355. this.scenes[0].dispose();
  1356. }
  1357. for (var name in this._compiledEffects) {
  1358. this._gl.deleteProgram(this._compiledEffects[name]._program);
  1359. }
  1360. for (var i in this._vertexAttribArrays) {
  1361. if (i > this._gl.VERTEX_ATTRIB_ARRAY_ENABLED || !this._vertexAttribArrays[i]) {
  1362. continue;
  1363. }
  1364. this._gl.disableVertexAttribArray(i);
  1365. }
  1366. // Events
  1367. window.removeEventListener("blur", this._onBlur);
  1368. window.removeEventListener("focus", this._onFocus);
  1369. document.removeEventListener("fullscreenchange", this._onFullscreenChange);
  1370. document.removeEventListener("mozfullscreenchange", this._onFullscreenChange);
  1371. document.removeEventListener("webkitfullscreenchange", this._onFullscreenChange);
  1372. document.removeEventListener("msfullscreenchange", this._onFullscreenChange);
  1373. document.removeEventListener("pointerlockchange", this._onPointerLockChange);
  1374. document.removeEventListener("mspointerlockchange", this._onPointerLockChange);
  1375. document.removeEventListener("mozpointerlockchange", this._onPointerLockChange);
  1376. document.removeEventListener("webkitpointerlockchange", this._onPointerLockChange);
  1377. };
  1378. // Loading screen
  1379. Engine.prototype.displayLoadingUI = function () {
  1380. var _this = this;
  1381. this._loadingDiv = document.createElement("div");
  1382. this._loadingDiv.style.opacity = "0";
  1383. this._loadingDiv.style.transition = "opacity 1.5s ease";
  1384. // Loading text
  1385. this._loadingTextDiv = document.createElement("div");
  1386. this._loadingTextDiv.style.position = "absolute";
  1387. this._loadingTextDiv.style.left = "0";
  1388. this._loadingTextDiv.style.top = "50%";
  1389. this._loadingTextDiv.style.marginTop = "80px";
  1390. this._loadingTextDiv.style.width = "100%";
  1391. this._loadingTextDiv.style.height = "20px";
  1392. this._loadingTextDiv.style.fontFamily = "Arial";
  1393. this._loadingTextDiv.style.fontSize = "14px";
  1394. this._loadingTextDiv.style.color = "white";
  1395. this._loadingTextDiv.style.textAlign = "center";
  1396. this._loadingTextDiv.innerHTML = "Loading";
  1397. this._loadingDiv.appendChild(this._loadingTextDiv);
  1398. // Loading img
  1399. var imgBack = new Image();
  1400. imgBack.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAYAAABw4pVUAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAAYdEVYdFNvZnR3YXJlAHBhaW50Lm5ldCA0LjAuM4zml1AAAARbSURBVHhe7Z09aFNRFMc716kuLrq4FdyLq4Wi4CAoRQcR0UJBUBdRiuLSIYMo6CA4FF2sgw6CFAdFUOpSQYcWO4hD26UQCfXrIQrx/JJzw1OSWq3NPeL/B4Fy+0jg/HO+7j3vpUcI8b/Q39+/49ihfWdPHT94Yf/e3Se3bd263f8lus218TPn6vV6Ya8Wi/MzNRNmj18iusX9W1evmP1/EKNEIVG6CMbG6E3bt+fT++pHha8NoHdT72bLE8NDg7tGU64gLLndV4Wc4m8j/pS+vr4tGB/DT16v3Fyr8dvBe/jbit8BL0AES9LX1iPAz+BR/hFiLVCynj95dPzNy6fv3IZ/k4L3948Sq7FzYGBg4vLFGxitabuOFCbWNKGrMnbiUuo18KaV6tIHv6YtvL9/nOgE31jCktmrY7k6+/zhE4yP4Vf7hiNqh/BWWEl8mzDol4p22Lf7cIdvdUMEvv0Y2S9fE5S1hLzpqTsPkiep//gFGPnR3Yl7GL5p/xYFBrTwM+iXio3GqpwDGL5p/xYNIX7XG8Q6IJRgdIzf1KBBgafII7oMidhyQtVFaMA2Bt7il4huQRhaXphbcR2g4RXqBzKAGHiCCwGFVUAj/m/RTRDj29cvn10I0PZ3LghH5f4CL1EFlQmqqXK3jDDKFxmhQ3Yt6oQseUZGKmMnTpsOqc8o1F9kBOMjQlOLeqEeIyOc6JV6jYLJD/+XyIFvnzdgl9aXRQ5I2qZDK1SpospMqaoqON/wZZGDciLnMMiXRS7IF4hhqMTNTdk7CFu+LHLhR7BQqBvPDJUUQqCGvCMATHUgBmhWNgApmdOda9YpM+VwRYfuyyIXDK8hBlilNerLIheMZCKGwlUAyru6GlwOgPUbRxADdJ9FAChxXY864viyyEXqPxhc0M2TAfAbatSdRyHtXymhByEdRnE3ky+JnHAIhSA0h74kckETmHoQbSgGwJrCIRMEPSRIBCRIMAhZaYhaggQhJXUJEoRU9mofKwh+F22dLRRfEjlJM7w6KQwCoQpBOKTyJZETjmwRxKqtGV8SOSkNOGjKPQppBEgDDkFgpxdBVGkFgaYQQXRIFQSObk0P5ZFIpAZRHXsQ0r0hCluBWKkuvVbYCkQaCdL5ehBScudJP4yY+rLISdps1NBDEJKXMMmoSfggWC4ZQRR17oFYXph7hSiquIKQ+hJGTX1J5MYSPD/GVdNzsgLBwZVCVyAQAkF0ohiI/c1fS6tNXq9UfEnkhudmIQolsS+J3Hh/UtNDzQLhj42VKJFInqLwFYiUU5ToA+HdfI0JevUpQUAIn+vSz2lHIuUV/dJOIHhOY/IWVWGBIHQtzs88s9zyWBuTgcBLzGOmeNnfF/QslSDgMeQW85i3DOQxuipxAkCyZ8SIm4Omp+7MMlCB59j6sKZcMoM4iIEoeI2J9AKxrFobZx0v4vYInuHFS4J1GQRCAGaLEYQXfyMML5XSQgghhBBCCCH+cXp6vgNhKpSKX/XdOAAAAABJRU5ErkJggg==";
  1401. imgBack.style.position = "absolute";
  1402. imgBack.style.left = "50%";
  1403. imgBack.style.top = "50%";
  1404. imgBack.style.marginLeft = "-50px";
  1405. imgBack.style.marginTop = "-50px";
  1406. imgBack.style.transition = "transform 1.0s ease";
  1407. imgBack.style.webkitTransition = "-webkit-transform 1.0s ease";
  1408. var deg = 360;
  1409. var onTransitionEnd = function () {
  1410. deg += 360;
  1411. imgBack.style.transform = "rotateZ(" + deg + "deg)";
  1412. imgBack.style.webkitTransform = "rotateZ(" + deg + "deg)";
  1413. };
  1414. imgBack.addEventListener("transitionend", onTransitionEnd);
  1415. imgBack.addEventListener("webkitTransitionEnd", onTransitionEnd);
  1416. this._loadingDiv.appendChild(imgBack);
  1417. // front image
  1418. var imgFront = new Image();
  1419. imgFront.src = "data:image/png;base64,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";
  1420. imgFront.style.position = "absolute";
  1421. imgFront.style.left = "50%";
  1422. imgFront.style.top = "50%";
  1423. imgFront.style.marginLeft = "-50px";
  1424. imgFront.style.marginTop = "-50px";
  1425. this._loadingDiv.appendChild(imgFront);
  1426. // Resize
  1427. this._resizeLoadingUI = function () {
  1428. var canvasRect = _this.getRenderingCanvasClientRect();
  1429. _this._loadingDiv.style.position = "absolute";
  1430. _this._loadingDiv.style.left = canvasRect.left + "px";
  1431. _this._loadingDiv.style.top = canvasRect.top + "px";
  1432. _this._loadingDiv.style.width = canvasRect.width + "px";
  1433. _this._loadingDiv.style.height = canvasRect.height + "px";
  1434. };
  1435. this._resizeLoadingUI();
  1436. window.addEventListener("resize", this._resizeLoadingUI);
  1437. this._loadingDiv.style.backgroundColor = this._loadingDivBackgroundColor;
  1438. document.body.appendChild(this._loadingDiv);
  1439. setTimeout(function () {
  1440. _this._loadingDiv.style.opacity = "1";
  1441. imgBack.style.transform = "rotateZ(360deg)";
  1442. imgBack.style.webkitTransform = "rotateZ(360deg)";
  1443. }, 0);
  1444. };
  1445. Object.defineProperty(Engine.prototype, "loadingUIText", {
  1446. set: function (text) {
  1447. if (!this._loadingDiv) {
  1448. return;
  1449. }
  1450. this._loadingTextDiv.innerHTML = text;
  1451. },
  1452. enumerable: true,
  1453. configurable: true
  1454. });
  1455. Object.defineProperty(Engine.prototype, "loadingUIBackgroundColor", {
  1456. get: function () {
  1457. return this._loadingDivBackgroundColor;
  1458. },
  1459. set: function (color) {
  1460. this._loadingDivBackgroundColor = color;
  1461. if (!this._loadingDiv) {
  1462. return;
  1463. }
  1464. this._loadingDiv.style.backgroundColor = this._loadingDivBackgroundColor;
  1465. },
  1466. enumerable: true,
  1467. configurable: true
  1468. });
  1469. Engine.prototype.hideLoadingUI = function () {
  1470. var _this = this;
  1471. if (!this._loadingDiv) {
  1472. return;
  1473. }
  1474. var onTransitionEnd = function () {
  1475. if (!_this._loadingDiv) {
  1476. return;
  1477. }
  1478. document.body.removeChild(_this._loadingDiv);
  1479. window.removeEventListener("resize", _this._resizeLoadingUI);
  1480. _this._loadingDiv = null;
  1481. };
  1482. this._loadingDiv.style.opacity = "0";
  1483. this._loadingDiv.addEventListener("transitionend", onTransitionEnd);
  1484. };
  1485. // Statics
  1486. Engine.isSupported = function () {
  1487. try {
  1488. // Avoid creating an unsized context for CocoonJS, since size determined on first creation. Is not resizable
  1489. if (navigator.isCocoonJS) {
  1490. return true;
  1491. }
  1492. var tempcanvas = document.createElement("canvas");
  1493. var gl = tempcanvas.getContext("webgl") || tempcanvas.getContext("experimental-webgl");
  1494. return gl != null && !!window.WebGLRenderingContext;
  1495. } catch (e) {
  1496. return false;
  1497. }
  1498. };
  1499. Engine._ALPHA_DISABLE = 0;
  1500. Engine._ALPHA_ADD = 1;
  1501. Engine._ALPHA_COMBINE = 2;
  1502. Engine._DELAYLOADSTATE_NONE = 0;
  1503. Engine._DELAYLOADSTATE_LOADED = 1;
  1504. Engine._DELAYLOADSTATE_LOADING = 2;
  1505. Engine._DELAYLOADSTATE_NOTLOADED = 4;
  1506. Engine.Epsilon = 0.001;
  1507. Engine.CollisionsEpsilon = 0.001;
  1508. Engine.ShadersRepository = "Babylon/Shaders/";
  1509. return Engine;
  1510. })();
  1511. BABYLON.Engine = Engine;
  1512. })(BABYLON || (BABYLON = {}));
  1513. //# sourceMappingURL=babylon.engine.js.map