@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/geom/util/rectangle.js

@@ -0,0 +1,212 @@
+/**
+ * @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 Rectangle from '../rectangle';
+import Point from '../point';
+
+/**
+ *
+ * @param a
+ * @param dx
+ * @param dy
+ */
+export function inflate(a, dx, dy) {
+  a.x -= dx;
+  a.width += 2 * dx;
+  a.y -= dy;
+  a.height += 2 * dy;
+  return a;
+}
+
+/**
+ *
+ * @param a
+ * @param point
+ */
+export function inflatePoint(a, point) {
+  return inflate(a, point.x, point.y);
+}
+
+/**
+ *
+ * @param a
+ * @param output
+ */
+export function size(a, output = null) {
+  const result = output || new Point();
+  result.setTo(a.width, a.height);
+  return result;
+}
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new Rectangle();
+  result.setTo(input.x, input.y, input.width, input.height);
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param x
+ * @param y
+ */
+export function contains(a, x, y) {
+  if (a.width <= 0 || a.height <= 0) {
+    return false;
+  }
+  return (x >= a.x && x < a.right && y >= a.y && y < a.bottom);
+}
+
+/**
+ *
+ * @param rx
+ * @param ry
+ * @param rw
+ * @param rh
+ * @param x
+ * @param y
+ */
+export function containsRaw(rx, ry, rw, rh, x, y) {
+  return (x >= rx && x < (rx + rw) && y >= ry && y < (ry + rh));
+}
+
+/**
+ *
+ * @param a
+ * @param point
+ */
+export function containsPoint(a, point) {
+  return contains(a, point.x, point.y);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function containsRect(a, b) {
+  if (a.volume > b.volume) {
+    return false;
+  }
+  return (a.x >= b.x && a.y >= b.y && a.right < b.right && a.bottom < b.bottom);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function equals(a, b) {
+  return (a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function sameDimensions(a, b) {
+  return (a.width === b.width && a.height === b.height);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function intersects(a, b) {
+  if (a.width <= 0 || a.height <= 0 || b.width <= 0 || b.height <= 0) {
+    return false;
+  }
+  return !(a.right < b.x || a.bottom < b.y || a.x > b.right || a.y > b.bottom);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function intersection(a, b, output = null) {
+  const result = output || new Rectangle();
+  if (intersects(a, b)) {
+    result.x = Math.max(a.x, b.x);
+    result.y = Math.max(a.y, b.y);
+    result.width = Math.min(a.right, b.right) - result.x;
+    result.height = Math.min(a.bottom, b.bottom) - result.y;
+  }
+  return result;
+}
+
+/**
+ *
+ * @param a
+ * @param left
+ * @param right
+ * @param top
+ * @param bottom
+ * @param tolerance
+ */
+export function intersectsRaw(a, left, right, top, bottom, tolerance = 0) {
+  return !(left > a.right + tolerance || right < a.left - tolerance || top > a.bottom + tolerance || bottom < a.top - tolerance);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param output
+ */
+export function union(a, b, output = null) {
+  const result = output || new Rectangle();
+  return result.setTo(Math.min(a.x, b.x), Math.min(a.y, b.y), Math.max(a.right, b.right) - Math.min(a.left, b.left), Math.max(a.bottom, b.bottom) - Math.min(a.top, b.top));
+}
+
+/**
+ *
+ * @param points
+ * @param output
+ */
+export function aabb(points, output = null) {
+  const result = output || new Rectangle();
+  let xMax = Number.NEGATIVE_INFINITY;
+  let xMin = Number.POSITIVE_INFINITY;
+  let yMax = Number.NEGATIVE_INFINITY;
+  let yMin = Number.POSITIVE_INFINITY;
+  points.forEach((point) => {
+    if (point.x > xMax) {
+      xMax = point.x;
+    }
+    if (point.x < xMin) {
+      xMin = point.x;
+    }
+    if (point.y > yMax) {
+      yMax = point.y;
+    }
+    if (point.y < yMin) {
+      yMin = point.y;
+    }
+  });
+  result.setTo(xMin, yMin, xMax - xMin, yMax - yMin);
+  return result;
+}
+
+/**
+ *
+ */
+export function getEmptyRectangle() {
+  if (!window.PhaserRegistry) {
+    window.PhaserRegistry = {};
+  }
+  if (!window.PhaserRegistry.EMPTY_RECTANGLE) {
+    window.PhaserRegistry.EMPTY_RECTANGLE = new Rectangle();
+  }
+  return window.PhaserRegistry.EMPTY_RECTANGLE;
+}

package/src/phaser/geom/util/rounded_rectangle.js

@@ -0,0 +1,28 @@
+/**
+ * @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 RoundedRectangle from '../rounded_rectangle';
+
+/**
+ *
+ */
+export default function () {
+  return true;
+}
+
+/**
+ *
+ * @param input
+ * @param output
+ */
+export function clone(input, output = null) {
+  const result = output || new RoundedRectangle();
+  result.x = input.x;
+  result.y = input.y;
+  result.width = input.width;
+  result.height = input.height;
+  result.radius = input.radius;
+  return result;
+}

package/src/phaser/util/math.js

@@ -0,0 +1,279 @@
+/**
+ * @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)
+ */
+export const DEG_TO_RAD = Math.PI / 180;
+export const RAD_TO_DEG = 180 / Math.PI;
+export const PI_2 = Math.PI * 2;
+
+/**
+ *
+ * @param hex
+ */
+export function hex2rgb(hex) {
+  return [(hex >> 16 & 0xFF) / 255, (hex >> 8 & 0xFF) / 255, (hex & 0xFF) / 255];
+}
+
+/**
+ *
+ * @param rgb
+ */
+export function rgb2hex(rgb) {
+  return ((rgb[0] * 255 << 16) + (rgb[1] * 255 << 8) + rgb[2] * 255);
+}
+
+/**
+ *
+ * @param value
+ */
+export function getNextPowerOfTwo(value) {
+  // see: https://en.wikipedia.org/wiki/Power_of_two#Fast_algorithm_to_check_if_a_positive_number_is_a_power_of_two
+  if (value > 0 && (value & (value - 1)) === 0) {
+    return value;
+  }
+  let result = 1;
+  while (result < value) {
+    result <<= 1;
+  }
+  return result;
+}
+
+/**
+ *
+ * @param width
+ * @param height
+ */
+export function isPowerOfTwo(width, height) {
+  return (width > 0 && (width & (width - 1)) === 0 && height > 0 && (height & (height - 1)) === 0);
+}
+
+/**
+ *
+ * @param degrees
+ */
+export function degToRad(degrees) {
+  return degrees * DEG_TO_RAD;
+}
+
+/**
+ *
+ * @param radians
+ */
+export function radToDeg(radians) {
+  return radians * RAD_TO_DEG;
+}
+
+/**
+ *
+ * @param min
+ * @param max
+ */
+export function between(min, max) {
+  return Math.floor(Math.random() * (max - min + 1) + min);
+}
+
+/**
+ *
+ * @param input
+ * @param gap
+ * @param start
+ */
+export function snapToCeil(input, gap = 0, start = 0) {
+  if (gap === 0) {
+    return input;
+  }
+  input -= start;
+  input = gap * Math.ceil(input / gap);
+  return start + input;
+}
+
+/**
+ *
+ * @param value
+ * @param min
+ * @param max
+ */
+export function wrap(value, min, max) {
+  const range = max - min;
+  if (range <= 0) {
+    return 0;
+  }
+  let result = (value - min) % range;
+  if (result < 0) {
+    result += range;
+  }
+  return result + min;
+}
+
+/**
+ *
+ * @param p0
+ * @param p1
+ * @param t
+ */
+export function linear(p0, p1, t) {
+  return (p1 - p0) * t + p0;
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ */
+export function difference(a, b) {
+  return Math.abs(a - b);
+}
+
+/**
+ *
+ * @param v
+ * @param k
+ */
+export function linearInterpolation(v, k) {
+  const m = v.length - 1;
+  const f = m * k;
+  const i = Math.floor(f);
+  if (k < 0) {
+    return linear(v[0], v[1], f);
+  }
+  if (k > 1) {
+    return linear(v[m], v[m - 1], m - f);
+  }
+  return linear(v[i], v[i + 1 > m ? m : i + 1], f - i);
+}
+
+/**
+ *
+ * @param x1
+ * @param y1
+ * @param x2
+ * @param y2
+ */
+export function distance(x1, y1, x2, y2) {
+  const dx = x1 - x2;
+  const dy = y1 - y2;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+/**
+ *
+ * @param a
+ * @param b
+ * @param tolerance
+ */
+export function within(a, b, tolerance) {
+  return (Math.abs(a - b) <= tolerance);
+}
+
+/**
+ *
+ * @param a
+ * @param r
+ * @param g
+ * @param b
+ */
+export function getColor32(a, r, g, b) {
+  return a << 24 | r << 16 | g << 8 | b;
+}
+
+/**
+ *
+ * @param r
+ * @param g
+ * @param b
+ */
+export function getColor(r, g, b) {
+  return r << 16 | g << 8 | b;
+}
+
+/**
+ *
+ * @param value
+ * @param out
+ */
+export function hexToColor(value, out) {
+  // Expand shorthand form (e.g. "03F") to full form (e.g. "0033FF")
+  value = value.replace(/^(?:#|0x)?([a-f\d])([a-f\d])([a-f\d])$/i, (m, r, g, b) => r + r + g + g + b + b);
+  const result = /^(?:#|0x)?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(value);
+  if (result) {
+    out.r = parseInt(result[1], 16);
+    out.g = parseInt(result[2], 16);
+    out.b = parseInt(result[3], 16);
+  }
+}
+
+/**
+ *
+ * @param value
+ * @param out
+ */
+export function webToColor(value, out) {
+  const result = /^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*(\d+(?:\.\d+)?))?\s*\)$/.exec(value);
+  if (result) {
+    out.r = parseInt(result[1], 10);
+    out.g = parseInt(result[2], 10);
+    out.b = parseInt(result[3], 10);
+    out.a = result[4] !== undefined ? parseFloat(result[4]) : 1;
+  }
+}
+
+/**
+ *
+ * @param color
+ */
+export function getRGB(color) {
+  if (color > 16777215) {
+    //  The color value has an alpha component
+    return {
+      alpha: color >>> 24,
+      red: color >> 16 & 0xFF,
+      green: color >> 8 & 0xFF,
+      blue: color & 0xFF,
+      a: color >>> 24,
+      r: color >> 16 & 0xFF,
+      g: color >> 8 & 0xFF,
+      b: color & 0xFF,
+    };
+  }
+  return {
+    alpha: 255,
+    red: color >> 16 & 0xFF,
+    green: color >> 8 & 0xFF,
+    blue: color & 0xFF,
+    a: 255,
+    r: color >> 16 & 0xFF,
+    g: color >> 8 & 0xFF,
+    b: color & 0xFF,
+  };
+}
+
+/**
+ *
+ * @param value
+ * @param out
+ */
+export function valueToColor(value, out) {
+  if (typeof value === 'string') {
+    if (value.indexOf('rgb') === 0) {
+      webToColor(value, out);
+    } else {
+      //  `hexToColor` does not support alpha; match `createColor`.
+      out.a = 1;
+      hexToColor(value, out);
+    }
+  } else if (typeof value === 'number') {
+    //  `getRGB` does not take optional object to modify;
+    //  alpha is also adjusted to match `createColor`.
+    const tempColor = getRGB(value);
+    out.r = tempColor.r;
+    out.g = tempColor.g;
+    out.b = tempColor.b;
+    out.a = tempColor.a / 255;
+  }
+  out.rgba = 'rgba(' + out.r.toString() + ',' + out.g.toString() + ',' + out.b.toString() + ',' + out.a.toString() + ')';
+  out.color = getColor(out.r, out.g, out.b);
+  out.color32 = getColor32(out.a * 255, out.r, out.g, out.b);
+  return out;
+
+}

package/src/phaser/util/string.js

@@ -0,0 +1,26 @@
+/**
+ * @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)
+ */
+
+/**
+ *
+ */
+export function generateID() {
+  return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+}
+
+/**
+ *
+ */
+export function generateUUID() {
+  return (`${generateID()}${generateID()}-${generateID()}-4${generateID().substr(0, 3)}-${generateID()}-${generateID()}${generateID()}${generateID()}`).toLowerCase();
+}
+
+/**
+ *
+ */
+export function generateShaderID() {
+  return (`${generateID()}${generateID()}-${generateID()}`).toLowerCase();
+}