@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/core/cache.js

@@ -0,0 +1,558 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+import Texture from '../display/webgl/texture';
+import BaseTexture from '../display/webgl/base_texture';
+import Signal from './signal';
+import Frame from './frame';
+import FrameData from './frame_data';
+import { XMLData, JSONData, JSONDataHash, JSONDataPyxel } from './animation_parser';
+import { TEXTURE_ATLAS_XML_STARLING, TEXTURE_ATLAS_JSON_PYXEL } from './const';
+import { jsonBitmapFont, xmlBitmapFont } from './loader_parser';
+
+export const CANVAS = 1;
+export const IMAGE = 2;
+export const TEXTURE = 3;
+export const SOUND = 4;
+export const TEXT = 5;
+export const PHYSICS = 6;
+export const TILEMAP = 7;
+export const BINARY = 8;
+export const BITMAPDATA = 9;
+export const BITMAPFONT = 10;
+export const JSON = 11;
+export const XML = 12;
+export const VIDEO = 13;
+export const SHADER = 14;
+export const RENDER_TEXTURE = 15;
+
+export default class {
+
+  constructor(game) {
+    this.game = game;
+    this.autoResolveURL = false;
+    this._cache = {
+      canvas: {},
+      image: {},
+      texture: {},
+      sound: {},
+      video: {},
+      text: {},
+      json: {},
+      xml: {},
+      physics: {},
+      tilemap: {},
+      binary: {},
+      bitmapData: {},
+      bitmapFont: {},
+      shader: {},
+      renderTexture: {},
+    };
+    this._urlMap = {};
+    this._urlResolver = new Image();
+    this._urlTemp = null;
+    this.onSoundUnlock = new Signal();
+    this._cacheMap = [];
+    this._cacheMap[CANVAS] = this._cache.canvas;
+    this._cacheMap[IMAGE] = this._cache.image;
+    this._cacheMap[TEXTURE] = this._cache.texture;
+    this._cacheMap[SOUND] = this._cache.sound;
+    this._cacheMap[TEXT] = this._cache.text;
+    this._cacheMap[PHYSICS] = this._cache.physics;
+    this._cacheMap[TILEMAP] = this._cache.tilemap;
+    this._cacheMap[BINARY] = this._cache.binary;
+    this._cacheMap[BITMAPDATA] = this._cache.bitmapData;
+    this._cacheMap[BITMAPFONT] = this._cache.bitmapFont;
+    this._cacheMap[JSON] = this._cache.json;
+    this._cacheMap[XML] = this._cache.xml;
+    this._cacheMap[VIDEO] = this._cache.video;
+    this._cacheMap[SHADER] = this._cache.shader;
+    this._cacheMap[RENDER_TEXTURE] = this._cache.renderTexture;
+    this.addDefaultImage();
+    this.addMissingImage();
+  }
+
+  addDefaultImage() {
+    const img = new Image();
+    img.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgAQMAAABJtOi3AAAAA1BMVEX///+nxBvIAAAAAXRSTlMAQObYZgAAABVJREFUeF7NwIEAAAAAgKD9qdeocAMAoAABm3DkcAAAAABJRU5ErkJggg==';
+    const obj = this.addImage('__default', null, img);
+    obj.base.skipRender = true; // invisible texture
+    window.PhaserRegistry.CACHE_DEFAULT_IMAGE = new Texture(obj.base);
+  }
+
+  addMissingImage() {
+    const img = new Image();
+    img.src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJ9JREFUeNq01ssOwyAMRFG46v//Mt1ESmgh+DFmE2GPOBARKb2NVjo+17PXLD8a1+pl5+A+wSgFygymWYHBb0FtsKhJDdZlncG2IzJ4ayoMDv20wTmSMzClEgbWYNTAkQ0Z+OJ+A/eWnAaR9+oxCF4Os0H8htsMUp+pwcgBBiMNnAwF8GqIgL2hAzaGFFgZauDPKABmowZ4GL369/0rwACp2yA/ttmvsQAAAABJRU5ErkJggg==';
+    const obj = this.addImage('__missing', null, img);
+    window.PhaserRegistry.CACHE_MISSING_IMAGE = new Texture(obj.base);
+  }
+
+  addImage(key, url, data) {
+    if (this.checkImageKey(key)) {
+      this.removeImage(key);
+    }
+    /* if (!data.complete) {
+      console.warn('Cache addImage %s is incomplete', key);
+    } */
+    const img = {
+      key,
+      url,
+      data,
+      base: new BaseTexture(data),
+      frame: new Frame(0, 0, 0, data.width, data.height, key),
+      frameData: new FrameData(),
+    };
+    img.frameData.addFrame(new Frame(0, 0, 0, data.width, data.height, url));
+    this._cache.image[key] = img;
+    this._resolveURL(url, img);
+    return img;
+  }
+
+  addTextureAtlas(key, url, data, atlasData, format) {
+    const obj = {
+      key,
+      url,
+      data,
+      base: new BaseTexture(data),
+    };
+    if (format === TEXTURE_ATLAS_XML_STARLING) {
+      obj.frameData = XMLData(this.game, atlasData, key);
+    } else if (format === TEXTURE_ATLAS_JSON_PYXEL) {
+      obj.frameData = JSONDataPyxel(this.game, atlasData, key);
+    } else if (Array.isArray(atlasData.frames)) {
+      //  Let's just work it out from the frames array
+      obj.frameData = JSONData(this.game, atlasData, key);
+    } else {
+      obj.frameData = JSONDataHash(this.game, atlasData, key);
+    }
+    this._cache.image[key] = obj;
+    this._resolveURL(url, obj);
+  }
+
+  addSound(key, url, data, webAudio = true, audioTag = false) {
+    const decoded = audioTag;
+    this._cache.sound[key] = {
+      url,
+      data,
+      isDecoding: false,
+      decoded,
+      webAudio,
+      audioTag,
+      locked: this.game.sound.touchLocked,
+    };
+    this._resolveURL(url, this._cache.sound[key]);
+  }
+
+  addText(key, url, data) {
+    this._cache.text[key] = { url, data };
+    this._resolveURL(url, this._cache.text[key]);
+  }
+
+  addBinary(key, binaryData) {
+    this._cache.binary[key] = binaryData;
+  }
+
+  addBitmapFont(key, url, data, atlasData, atlasType, xSpacing = 0, ySpacing = 0) {
+    const obj = {
+      url,
+      data,
+      font: null,
+      base: new BaseTexture(data),
+    };
+    if (atlasType === 'json') {
+      obj.font = jsonBitmapFont(atlasData, obj.base, xSpacing, ySpacing);
+    } else {
+      obj.font = xmlBitmapFont(atlasData, obj.base, xSpacing, ySpacing);
+    }
+    this._cache.bitmapFont[key] = obj;
+    this._resolveURL(url, obj);
+  }
+
+  addJSON(key, url, data) {
+    this._cache.json[key] = { url, data };
+    this._resolveURL(url, this._cache.json[key]);
+  }
+
+  addXML(key, url, data) {
+    this._cache.xml[key] = { url, data };
+    this._resolveURL(url, this._cache.xml[key]);
+  }
+
+  // SOUND
+
+  reloadSound(key) {
+    const scope = this;
+    const sound = this.getSound(key);
+    if (sound) {
+      sound.data.src = sound.url;
+      sound.data.addEventListener('canplaythrough', () => scope.reloadSoundComplete(key), false);
+      sound.data.load();
+    }
+  }
+
+  reloadSoundComplete(key) {
+    const sound = this.getSound(key);
+    if (sound) {
+      sound.locked = false;
+      this.onSoundUnlock.dispatch(key);
+    }
+  }
+
+  updateSound(key, property, value) {
+    const sound = this.getSound(key);
+    if (sound) {
+      sound[property] = value;
+    }
+  }
+
+  decodedSound(key, data) {
+    const sound = this.getSound(key);
+    sound.data = data;
+    sound.decoded = true;
+    sound.isDecoding = false;
+  }
+
+  isSoundDecoded(key) {
+    const sound = this.getItem(key, SOUND, 'isSoundDecoded');
+    if (sound) {
+      return sound.decoded;
+    }
+    return null;
+  }
+
+  isSoundReady(key) {
+    const sound = this.getItem(key, SOUND, 'isSoundDecoded');
+    if (sound) {
+      return (sound.decoded && !this.game.sound.touchLocked);
+    }
+    return false;
+  }
+
+  // CHECK
+
+  checkKey(cache, key) {
+    if (this._cacheMap[cache][key]) {
+      return true;
+    }
+    return false;
+  }
+
+  checkURL(url) {
+    if (this._urlMap[this._resolveURL(url)]) {
+      return true;
+    }
+    return false;
+  }
+
+  checkCanvasKey(key) {
+    return this.checkKey(CANVAS, key);
+  }
+
+  checkImageKey(key) {
+    return this.checkKey(IMAGE, key);
+  }
+
+  checkTextureKey(key) {
+    return this.checkKey(TEXTURE, key);
+  }
+
+  checkSoundKey(key) {
+    return this.checkKey(SOUND, key);
+  }
+
+  checkTextKey(key) {
+    return this.checkKey(TEXT, key);
+  }
+
+  checkTilemapKey(key) {
+    return this.checkKey(TILEMAP, key);
+  }
+
+  checkBinaryKey(key) {
+    return this.checkKey(BINARY, key);
+  }
+
+  checkBitmapDataKey(key) {
+    return this.checkKey(BITMAPDATA, key);
+  }
+
+  checkBitmapFontKey(key) {
+    return this.checkKey(BITMAPFONT, key);
+  }
+
+  checkJSONKey(key) {
+    return this.checkKey(JSON, key);
+  }
+
+  checkXMLKey(key) {
+    return this.checkKey(XML, key);
+  }
+
+  // TODO video shader rendertexture physics
+
+  // GET
+
+  getItem(key, cache, method, property = null) {
+    if (this.checkKey(cache, key)) {
+      if (!property) {
+        return this._cacheMap[cache][key];
+      }
+      return this._cacheMap[cache][key][property];
+    }
+    return null;
+  }
+
+  getCanvas(key) {
+    return this.getItem(key, CANVAS, 'getCanvas', 'canvas');
+  }
+
+  getImage(key = '__default', full = false) {
+    let img = this.getItem(key, IMAGE, 'getImage');
+    if (img === null) {
+      img = this.getItem('__missing', IMAGE, 'getImage');
+    }
+    if (full) {
+      return img;
+    }
+    return img.data;
+  }
+
+  getTextureFrame(key) {
+    return this.getItem(key, TEXTURE, 'getTextureFrame', 'frame');
+  }
+
+  getSound(key) {
+    return this.getItem(key, SOUND, 'getSound');
+  }
+
+  getSoundData(key) {
+    return this.getItem(key, SOUND, 'getSoundData', 'data');
+  }
+
+  getText(key) {
+    return this.getItem(key, TEXT, 'getText', 'data');
+  }
+
+  getTilemapData(key) {
+    return this.getItem(key, TILEMAP, 'getTilemapData');
+  }
+
+  getBinary(key) {
+    return this.getItem(key, BINARY, 'getBinary');
+  }
+
+  getBitmapData(key) {
+    return this.getItem(key, BITMAPDATA, 'getBitmapData', 'data');
+  }
+
+  getBitmapFont(key) {
+    return this.getItem(key, BITMAPFONT, 'getBitmapFont');
+  }
+
+  getJSON(key, isClone = false) {
+    const data = this.getItem(key, JSON, 'getJSON', 'data');
+    return isClone ? JSON.parse(JSON.stringify(data)) : data;
+  }
+
+  getXML(key) {
+    return this.getItem(key, XML, 'getXML', 'data');
+  }
+
+  getVideo(key) {
+    return this.getItem(key, VIDEO, 'getVideo');
+  }
+
+  getShader(key) {
+    return this.getItem(key, SHADER, 'getShader', 'data');
+  }
+
+  getRenderTexture(key) {
+    return this.getItem(key, RENDER_TEXTURE, 'getRenderTexture');
+  }
+
+  // FRAME
+
+  getBaseTexture(key, cache = IMAGE) {
+    return this.getItem(key, cache, 'getBaseTexture', 'base');
+  }
+
+  getFrame(key, cache = IMAGE) {
+    return this.getItem(key, cache, 'getFrame', 'frame');
+  }
+
+  getFrameCount(key, cache = IMAGE) {
+    const data = this.getFrameData(key, cache);
+    if (data) {
+      return data.total;
+    }
+    return 0;
+  }
+
+  getFrameData(key, cache = IMAGE) {
+    return this.getItem(key, cache, 'getFrameData', 'frameData');
+  }
+
+  hasFrameData(key, cache = IMAGE) {
+    return (this.getItem(key, cache, '', 'frameData') !== null);
+  }
+
+  updateFrameData(key, frameData, cache = IMAGE) {
+    if (this._cacheMap[cache][key]) {
+      this._cacheMap[cache][key].frameData = frameData;
+    }
+  }
+
+  getFrameByIndex(key, index, cache = IMAGE) {
+    const data = this.getFrameData(key, cache);
+    if (data) {
+      return data.getFrame(index);
+    }
+    return null;
+  }
+
+  getFrameByName(key, name, cache = IMAGE) {
+    const data = this.getFrameData(key, cache);
+    if (data) {
+      return data.getFrameByName(name);
+    }
+    return null;
+  }
+
+  getURL(url) {
+    const resolvedURL = this._resolveURL(url);
+    if (resolvedURL) {
+      return this._urlMap[resolvedURL];
+    }
+    console.warn('Cache invalid url', resolvedURL);
+    return null;
+  }
+
+  getKeys(cache = IMAGE) {
+    const result = [];
+    if (this._cacheMap[cache]) {
+      const keys = Object.keys(this._cacheMap[cache]);
+      for (let i = 0; i < keys.length; i += 1) {
+        const key = keys[i];
+        if (key !== '__default' && key !== '__missing') {
+          result.push(key);
+        }
+      }
+    }
+    return result;
+  }
+
+  // REMOVE
+
+  removeCanvas(key) {
+    delete this._cache.canvas[key];
+  }
+
+  removeImage(key, destroyBaseTexture = true) {
+    const img = this.getImage(key, true);
+    if (destroyBaseTexture && img.base) {
+      img.base.destroy();
+    }
+    delete this._cache.image[key];
+  }
+
+  removeSound(key) {
+    delete this._cache.sound[key];
+  }
+
+  removeText(key) {
+    delete this._cache.text[key];
+  }
+
+  removePhysics(key) {
+    delete this._cache.physics[key];
+  }
+
+  removeTilemap(key) {
+    delete this._cache.tilemap[key];
+  }
+
+  removeBinary(key) {
+    delete this._cache.binary[key];
+  }
+
+  removeBitmapData(key) {
+    delete this._cache.bitmapData[key];
+  }
+
+  removeBitmapFont(key) {
+    delete this._cache.bitmapFont[key];
+  }
+
+  removeJSON(key) {
+    delete this._cache.json[key];
+  }
+
+  removeXML(key) {
+    delete this._cache.xml[key];
+  }
+
+  removeVideo(key) {
+    delete this._cache.video[key];
+  }
+
+  removeShader(key) {
+    delete this._cache.shader[key];
+  }
+
+  removeRenderTexture(key) {
+    delete this._cache.renderTexture[key];
+  }
+
+  removeSpriteSheet(key) {
+    delete this._cache.spriteSheet[key];
+  }
+
+  removeTextureAtlas(key) {
+    delete this._cache.atlas[key];
+  }
+
+  clearGLTextures() {
+    const keys = Object.keys(this._cache.image);
+    for (let i = 0; i < keys.length; i += 1) {
+      const key = keys[i];
+      this._cache.image[key].base._glTextures = [];
+    }
+  }
+
+  _resolveURL(url, data) {
+    if (!this.autoResolveURL) {
+      return null;
+    }
+    this._urlResolver.src = this.game.load.baseURL + url;
+    this._urlTemp = this._urlResolver.src;
+    //  Ensure no request is actually made
+    this._urlResolver.src = '';
+    //  Record the URL to the map
+    if (data) {
+      this._urlMap[this._urlTemp] = data;
+    }
+    return this._urlTemp;
+  }
+
+  destroy() {
+    for (let i = 0; i < this._cacheMap.length; i += 1) {
+      const cache = this._cacheMap[i];
+      const keys = cache ? Object.keys(cache) : [];
+      for (let j = 0; j < keys.length; j += 1) {
+        const key = keys[j];
+        if (key !== '__default' && key !== '__missing') {
+          if (cache[key].destroy) {
+            cache[key].destroy();
+          }
+          delete cache[key];
+        }
+      }
+    }
+    this._urlMap = null;
+    this._urlResolver = null;
+    this._urlTemp = null;
+  }
+
+}

package/src/phaser/core/const.js

@@ -0,0 +1,106 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+// rectangle
+export const TOP_LEFT = 0;
+export const TOP_CENTER = 1;
+export const TOP_RIGHT = 2;
+export const LEFT_TOP = 3;
+export const LEFT_CENTER = 4;
+export const LEFT_BOTTOM = 5;
+export const CENTER = 6;
+export const RIGHT_TOP = 7;
+export const RIGHT_CENTER = 8;
+export const RIGHT_BOTTOM = 9;
+export const BOTTOM_LEFT = 10;
+export const BOTTOM_CENTER = 11;
+export const BOTTOM_RIGHT = 12;
+// scale modes
+export const SCALE_LINEAR = 0;
+export const SCALE_NEAREST = 1;
+// scale manager modes
+export const SCALE_EXACT_FIT = 0;
+export const SCALE_OFF = 1;
+export const SCALE_SHOW_ALL = 2;
+export const SCALE_RESIZE = 3;
+export const SCALE_USER = 4;
+// times
+export const TIME_MINUTE = 60000;
+export const TIME_SECOND = 1000;
+export const TIME_HALF = 500;
+export const TIME_QUARTER = 250;
+// tween statuses
+export const TWEEN_PENDING = 0;
+export const TWEEN_RUNNING = 1;
+export const TWEEN_LOOPED = 2;
+export const TWEEN_COMPLETE = 3;
+// blend modes
+export const BLEND_NORMAL = 0;
+export const BLEND_ADD = 1;
+export const BLEND_MULTIPLY = 2;
+export const BLEND_SCREEN = 3;
+export const BLEND_OVERLAY = 4;
+export const BLEND_DARKEN = 5;
+export const BLEND_LIGHTEN = 6;
+export const BLEND_COLOR_DODGE = 7;
+export const BLEND_COLOR_BURN = 8;
+export const BLEND_HARD_LIGHT = 9;
+export const BLEND_SOFT_LIGHT = 10;
+export const BLEND_DIFFERENCE = 11;
+export const BLEND_EXCLUSION = 12;
+export const BLEND_HUE = 13;
+export const BLEND_SATURATION = 14;
+export const BLEND_COLOR = 15;
+export const BLEND_LUMINOSITY = 16;
+// render modes
+export const RENDER_AUTO = 0;
+export const RENDER_CANVAS = 1;
+export const RENDER_WEBGL = 2;
+export const RENDER_HEADLESS = 3;
+// pointer modes
+export const POINTER_CURSOR = 1;
+export const POINTER_CONTACT = 2;
+// input modes
+export const MOUSE_OVERRIDES_TOUCH = 0;
+export const TOUCH_OVERRIDES_MOUSE = 1;
+export const MOUSE_TOUCH_COMBINE = 2;
+// game objects
+export const GROUP = 7;
+export const SPRITE = 0;
+export const SPRITE_BATCH = 17;
+export const BUTTON = 1;
+export const IMAGE = 2;
+export const GRAPHICS = 3;
+export const TEXT = 4;
+export const BITMAP_TEXT = 6;
+export const TILE_SPRITE = 5;
+export const RENDER_TEXTURE = 8;
+export const FILTER_CANVAS = 14;
+export const FILTER_WEBGL = 15;
+export const POINTER = 19;
+export const GEOM_POLYGON = 12;
+export const GEOM_RECTANGLE = 22;
+export const GEOM_CIRCLE = 21;
+export const GEOM_ELLIPSE = 16;
+export const GEOM_ROUNDED_RECTANGLE = 26;
+export const GEOM_LINE = 23;
+export const GEOM_MATRIX = 24;
+export const GEOM_POINT = 25;
+export const BITMAP_DATA = 13; // deprecated
+export const TILEMAP = 9; // deprecated
+export const TILEMAP_LAYER = 10; // deprecated
+export const EMITTER = 11; // deprecated
+export const RETROFONT = 18; // deprecated
+export const ROPE = 20; // deprecated
+export const CREATURE = 27; // deprecated
+export const VIDEO = 28; // deprecated
+export const PENDING_ATLAS = -1;
+// sprite sheet atlas
+export const TEXTURE_ATLAS_JSON_ARRAY = 0;
+export const TEXTURE_ATLAS_JSON_HASH = 1;
+export const TEXTURE_ATLAS_XML_STARLING = 2;
+export const PHYSICS_LIME_CORONA_JSON = 3;
+export const PHYSICS_PHASER_JSON = 4;
+export const TEXTURE_ATLAS_JSON_PYXEL = 5;