@vpmedia/phaser 1.0.1 → 1.0.2

package/src/phaser/display/webgl/util.js

@@ -0,0 +1,74 @@
+/**
+ * @author       Andras Csizmadia <andras@vpmedia.hu>
+ * @author       Richard Davey <rich@photonstorm.com>
+ * @author       Mat Groves http://matgroves.com/ @Doormat23
+ * @copyright    Copyright (c) 2018-present Richard Davey, Photon Storm Ltd., Andras Csizmadia <andras@vpmedia.hu> (www.vpmedia.hu)
+ */
+
+/**
+ *
+ */
+export function initDefaultShaders() {
+}
+
+/**
+ *
+ * @param gl
+ * @param shaderSrc
+ * @param shaderType
+ */
+export function compileShader(gl, shaderSrc, shaderType) {
+  let src = shaderSrc;
+  if (Array.isArray(shaderSrc)) {
+    src = shaderSrc.join('\n');
+  }
+  const shader = gl.createShader(shaderType);
+  gl.shaderSource(shader, src);
+  gl.compileShader(shader);
+  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
+    console.log(gl.getShaderInfoLog(shader));
+    return null;
+  }
+  return shader;
+}
+
+/**
+ *
+ * @param gl
+ * @param shaderSrc
+ */
+export function compileVertexShader(gl, shaderSrc) {
+  return compileShader(gl, shaderSrc, gl.VERTEX_SHADER);
+}
+
+/**
+ *
+ * @param gl
+ * @param shaderSrc
+ */
+export function compileFragmentShader(gl, shaderSrc) {
+  return compileShader(gl, shaderSrc, gl.FRAGMENT_SHADER);
+}
+
+/**
+ *
+ * @param gl
+ * @param vertexSrc
+ * @param fragmentSrc
+ */
+export function compileProgram(gl, vertexSrc, fragmentSrc) {
+  const fragmentShader = compileFragmentShader(gl, fragmentSrc);
+  const vertexShader = compileVertexShader(gl, vertexSrc);
+
+  const shaderProgram = gl.createProgram();
+
+  gl.attachShader(shaderProgram, vertexShader);
+  gl.attachShader(shaderProgram, fragmentShader);
+  gl.linkProgram(shaderProgram);
+
+  if (!gl.getProgramParameter(shaderProgram, gl.LINK_STATUS)) {
+    console.log(gl.getProgramInfoLog(shaderProgram));
+    console.log('Could not initialise shaders');
+  }
+  return shaderProgram;
+}

package/src/phaser/geom/circle.js

@@ -0,0 +1,186 @@
+/**
+ * @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 Point from './point';
+import Rectangle from './rectangle';
+import { distance } from '../util/math';
+import { clone, contains, circumferencePoint } from './util/circle';
+import { GEOM_CIRCLE } from '../core/const';
+
+export default class {
+
+  constructor(x = 0, y = 0, diameter = 0) {
+    this.x = x;
+    this.y = y;
+    this._diameter = diameter;
+    this._radius = 0;
+    if (diameter > 0) {
+      this._radius = diameter * 0.5;
+    }
+    this.type = GEOM_CIRCLE;
+  }
+
+  circumference() {
+    return 2 * (Math.PI * this._radius);
+  }
+
+  random(output = null) {
+    const result = output || new Point();
+    const t = 2 * Math.PI * Math.random();
+    const u = Math.random() + Math.random();
+    const r = (u > 1) ? 2 - u : u;
+    const x = r * Math.cos(t);
+    const y = r * Math.sin(t);
+    result.x = this.x + (x * this.radius);
+    result.y = this.y + (y * this.radius);
+    return result;
+  }
+
+  getBounds() {
+    return new Rectangle(this.x - this.radius, this.y - this.radius, this.diameter, this.diameter);
+  }
+
+  setTo(x, y, diameter) {
+    this.x = x;
+    this.y = y;
+    this._diameter = diameter;
+    this._radius = diameter * 0.5;
+    return this;
+  }
+
+  copyFrom(source) {
+    return this.setTo(source.x, source.y, source.diameter);
+  }
+
+  copyTo(dest) {
+    dest.x = this.x;
+    dest.y = this.y;
+    dest.diameter = this._diameter;
+    return dest;
+  }
+
+  distance(dest, round = false) {
+    const d = distance(this.x, this.y, dest.x, dest.y);
+    return round ? Math.round(d) : d;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+  contains(x, y) {
+    return contains(this, x, y);
+  }
+
+  circumferencePoint(angle, asDegrees, out) {
+    return circumferencePoint(this, angle, asDegrees, out);
+  }
+
+  offset(dx, dy) {
+    this.x += dx;
+    this.y += dy;
+    return this;
+  }
+
+  offsetPoint(point) {
+    return this.offset(point.x, point.y);
+  }
+
+  toString() {
+    return '[{Circle (x=' + this.x + ' y=' + this.y + ' diameter=' + this.diameter + ' radius=' + this.radius + ')}]';
+  }
+
+  get diameter() {
+    return this._diameter;
+  }
+
+  set diameter(value) {
+    if (value > 0) {
+      this._diameter = value;
+      this._radius = value * 0.5;
+    }
+  }
+
+  get radius() {
+    return this._radius;
+  }
+
+  set radius(value) {
+    if (value > 0) {
+      this._radius = value;
+      this._diameter = value * 2;
+    }
+  }
+
+  get left() {
+    return this.x - this._radius;
+  }
+
+  set left(value) {
+    if (value > this.x) {
+      this._radius = 0;
+      this._diameter = 0;
+    } else {
+      this.radius = this.x - value;
+    }
+  }
+
+  get right() {
+    return this.x + this._radius;
+  }
+
+  set right(value) {
+    if (value < this.x) {
+      this._radius = 0;
+      this._diameter = 0;
+    } else {
+      this.radius = value - this.x;
+    }
+  }
+
+  get top() {
+    return this.y - this._radius;
+  }
+
+  set top(value) {
+    if (value > this.y) {
+      this._radius = 0;
+      this._diameter = 0;
+    } else {
+      this.radius = this.y - value;
+    }
+  }
+
+  get bottom() {
+    return this.y + this._radius;
+  }
+
+  set bottom(value) {
+    if (value < this.y) {
+      this._radius = 0;
+      this._diameter = 0;
+    } else {
+      this.radius = value - this.y;
+    }
+  }
+
+  get area() {
+    if (this._radius > 0) {
+      return Math.PI * this._radius * this._radius;
+    }
+    return 0;
+  }
+
+  get empty() {
+    return (this._diameter === 0);
+  }
+
+  set empty(value) {
+    if (value === true) {
+      this.setTo(0, 0, 0);
+    }
+  }
+
+}

package/src/phaser/geom/ellipse.js

@@ -0,0 +1,65 @@
+/**
+ * @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 Point from './point';
+import Rectangle from './rectangle';
+import { contains } from './util/ellipse';
+import { GEOM_ELLIPSE } from '../core/const';
+
+export default class {
+
+  constructor(x = 0, y = 0, width = 0, height = 0) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    this.type = GEOM_ELLIPSE;
+  }
+
+  setTo(x, y, width, height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+    return this;
+  }
+
+  getBounds() {
+    return new Rectangle(this.x - this.width, this.y - this.height, this.width, this.height);
+  }
+
+  copyFrom(source) {
+    return this.setTo(source.x, source.y, source.width, source.height);
+  }
+
+  copyTo(dest) {
+    dest.x = this.x;
+    dest.y = this.y;
+    dest.width = this.width;
+    dest.height = this.height;
+    return dest;
+  }
+
+  contains(x, y) {
+    return contains(this, x, y);
+  }
+
+  random(output = null) {
+    const result = output || new Point();
+    const p = Math.random() * Math.PI * 2;
+    const r = Math.random();
+    result.x = Math.sqrt(r) * Math.cos(p);
+    result.y = Math.sqrt(r) * Math.sin(p);
+    result.x = this.x + (result.x * this.width / 2.0);
+    result.y = this.y + (result.y * this.height / 2.0);
+    return result;
+  }
+
+  toString() {
+    return '[{Ellipse (x=' + this.x + ' y=' + this.y + ' width=' + this.width + ' height=' + this.height + ')}]';
+  }
+
+
+}

package/src/phaser/geom/line.js

@@ -0,0 +1,190 @@
+/**
+ * @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 Point from './point';
+import { clone, intersectsPoints, reflect } from './util/line';
+import { wrap } from '../util/math';
+import { GEOM_LINE } from '../core/const';
+
+export default class {
+
+  constructor(x1 = 0, y1 = 0, x2 = 0, y2 = 0) {
+    this.start = new Point(x1, y1);
+    this.end = new Point(x2, y2);
+    this.type = GEOM_LINE;
+  }
+
+  setTo(x1, y1, x2, y2) {
+    this.start.setTo(x1, y1);
+    this.end.setTo(x2, y2);
+    return this;
+  }
+
+  fromSprite(startSprite, endSprite, useCenter = false) {
+    if (useCenter) {
+      return this.setTo(startSprite.center.x, startSprite.center.y, endSprite.center.x, endSprite.center.y);
+    }
+    return this.setTo(startSprite.x, startSprite.y, endSprite.x, endSprite.y);
+  }
+
+  fromAngle(x, y, angle, length) {
+    this.start.setTo(x, y);
+    this.end.setTo(x + (Math.cos(angle) * length), y + (Math.sin(angle) * length));
+    return this;
+  }
+
+  rotate(angle, asDegrees = false) {
+    const cx = (this.start.x + this.end.x) / 2;
+    const cy = (this.start.y + this.end.y) / 2;
+    this.start.rotate(cx, cy, angle, asDegrees);
+    this.end.rotate(cx, cy, angle, asDegrees);
+    return this;
+  }
+
+  rotateAround(x, y, angle, asDegrees = false) {
+    this.start.rotate(x, y, angle, asDegrees);
+    this.end.rotate(x, y, angle, asDegrees);
+    return this;
+  }
+
+  intersects(line, asSegment, result) {
+    return intersectsPoints(this.start, this.end, line.start, line.end, asSegment, result);
+  }
+
+  reflect(line) {
+    return reflect(this, line);
+  }
+
+  midPoint(output = null) {
+    const result = output || new Point();
+    result.x = (this.start.x + this.end.x) / 2;
+    result.y = (this.start.y + this.end.y) / 2;
+    return result;
+  }
+
+  centerOn(x, y) {
+    const cx = (this.start.x + this.end.x) / 2;
+    const cy = (this.start.y + this.end.y) / 2;
+    const tx = x - cx;
+    const ty = y - cy;
+    this.start.add(tx, ty);
+    this.end.add(tx, ty);
+  }
+
+  pointOnLine(x, y) {
+    return ((x - this.start.x) * (this.end.y - this.start.y) === (this.end.x - this.start.x) * (y - this.start.y));
+  }
+
+  pointOnSegment(x, y) {
+    const xMin = Math.min(this.start.x, this.end.x);
+    const xMax = Math.max(this.start.x, this.end.x);
+    const yMin = Math.min(this.start.y, this.end.y);
+    const yMax = Math.max(this.start.y, this.end.y);
+    return (this.pointOnLine(x, y) && (x >= xMin && x <= xMax) && (y >= yMin && y <= yMax));
+  }
+
+  random(output = null) {
+    const result = output || new Point();
+    const t = Math.random();
+    result.x = this.start.x + t * (this.end.x - this.start.x);
+    result.y = this.start.y + t * (this.end.y - this.start.y);
+    return result;
+  }
+
+  coordinatesOnLine(stepRate = 1, results = []) {
+    let x1 = Math.round(this.start.x);
+    let y1 = Math.round(this.start.y);
+    const x2 = Math.round(this.end.x);
+    const y2 = Math.round(this.end.y);
+    const dx = Math.abs(x2 - x1);
+    const dy = Math.abs(y2 - y1);
+    const sx = (x1 < x2) ? 1 : -1;
+    const sy = (y1 < y2) ? 1 : -1;
+    let err = dx - dy;
+    results.push([x1, y1]);
+    let i = 1;
+    while (!((x1 === x2) && (y1 === y2))) {
+      const e2 = err << 1;
+      if (e2 > -dy) {
+        err -= dy;
+        x1 += sx;
+      }
+      if (e2 < dx) {
+        err += dx;
+        y1 += sy;
+      }
+      if (i % stepRate === 0) {
+        results.push([x1, y1]);
+      }
+      i += 1;
+    }
+    return results;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+  get length() {
+    return Math.sqrt((this.end.x - this.start.x) * (this.end.x - this.start.x) + (this.end.y - this.start.y) * (this.end.y - this.start.y));
+  }
+
+  get angle() {
+    return Math.atan2(this.end.y - this.start.y, this.end.x - this.start.x);
+  }
+
+  get slope() {
+    return (this.end.y - this.start.y) / (this.end.x - this.start.x);
+  }
+
+  get perpSlope() {
+    return -((this.end.x - this.start.x) / (this.end.y - this.start.y));
+  }
+
+  get x() {
+    return Math.min(this.start.x, this.end.x);
+  }
+
+  get y() {
+    return Math.min(this.start.y, this.end.y);
+  }
+
+  get left() {
+    return Math.min(this.start.x, this.end.x);
+  }
+
+  get right() {
+    return Math.max(this.start.x, this.end.x);
+  }
+
+  get top() {
+    return Math.min(this.start.y, this.end.y);
+  }
+
+  get bottom() {
+    return Math.max(this.start.y, this.end.y);
+  }
+
+  get width() {
+    return Math.abs(this.start.x - this.end.x);
+  }
+
+  get height() {
+    return Math.abs(this.start.y - this.end.y);
+  }
+
+  get normalX() {
+    return Math.cos(this.angle - 1.5707963267948966);
+  }
+
+  get normalY() {
+    return Math.sin(this.angle - 1.5707963267948966);
+  }
+
+  get normalAngle() {
+    return wrap(this.angle - 1.5707963267948966, -Math.PI, Math.PI);
+  }
+
+}

package/src/phaser/geom/matrix.js

@@ -0,0 +1,147 @@
+/**
+ * @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 Point from './point';
+import { clone } from './util/matrix';
+import { GEOM_MATRIX } from '../core/const';
+
+export default class {
+
+  constructor(a = 1, b = 0, c = 0, d = 1, tx = 0, ty = 0) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = ty;
+    this.type = GEOM_MATRIX;
+  }
+
+  fromArray(array) {
+    return this.setTo(array[0], array[1], array[3], array[4], array[2], array[5]);
+  }
+
+  setTo(a, b, c, d, tx, ty) {
+    this.a = a;
+    this.b = b;
+    this.c = c;
+    this.d = d;
+    this.tx = tx;
+    this.ty = ty;
+    return this;
+  }
+
+  clone() {
+    return clone(this);
+  }
+
+  copyTo(matrix) {
+    matrix.copyFrom(this);
+    return matrix;
+  }
+
+  copyFrom(matrix) {
+    this.a = matrix.a;
+    this.b = matrix.b;
+    this.c = matrix.c;
+    this.d = matrix.d;
+    this.tx = matrix.tx;
+    this.ty = matrix.ty;
+    return this;
+  }
+
+  toArray(transpose = false, output = null) {
+    const result = output || new Float32Array(9);
+    if (transpose) {
+      result[0] = this.a;
+      result[1] = this.b;
+      result[2] = 0;
+      result[3] = this.c;
+      result[4] = this.d;
+      result[5] = 0;
+      result[6] = this.tx;
+      result[7] = this.ty;
+      result[8] = 1;
+    } else {
+      result[0] = this.a;
+      result[1] = this.c;
+      result[2] = this.tx;
+      result[3] = this.b;
+      result[4] = this.d;
+      result[5] = this.ty;
+      result[6] = 0;
+      result[7] = 0;
+      result[8] = 1;
+    }
+    return result;
+  }
+
+  apply(pos, output = null) {
+    const result = output || new Point();
+    result.x = this.a * pos.x + this.c * pos.y + this.tx;
+    result.y = this.b * pos.x + this.d * pos.y + this.ty;
+    return result;
+  }
+
+  applyInverse(pos, output = null) {
+    const result = output || new Point();
+    const id = 1 / (this.a * this.d + this.c * -this.b);
+    const x = pos.x;
+    const y = pos.y;
+    result.x = this.d * id * x + -this.c * id * y + (this.ty * this.c - this.tx * this.d) * id;
+    result.y = this.a * id * y + -this.b * id * x + (-this.ty * this.a + this.tx * this.b) * id;
+    return result;
+  }
+
+  translate(x, y) {
+    this.tx += x;
+    this.ty += y;
+    return this;
+  }
+
+  scale(x, y) {
+    this.a *= x;
+    this.d *= y;
+    this.c *= x;
+    this.b *= y;
+    this.tx *= x;
+    this.ty *= y;
+    return this;
+  }
+
+  rotate(angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const a1 = this.a;
+    const c1 = this.c;
+    const tx1 = this.tx;
+    this.a = a1 * cos - this.b * sin;
+    this.b = a1 * sin + this.b * cos;
+    this.c = c1 * cos - this.d * sin;
+    this.d = c1 * sin + this.d * cos;
+    this.tx = tx1 * cos - this.ty * sin;
+    this.ty = tx1 * sin + this.ty * cos;
+    return this;
+  }
+
+  append(matrix) {
+    const a1 = this.a;
+    const b1 = this.b;
+    const c1 = this.c;
+    const d1 = this.d;
+    this.a = matrix.a * a1 + matrix.b * c1;
+    this.b = matrix.a * b1 + matrix.b * d1;
+    this.c = matrix.c * a1 + matrix.d * c1;
+    this.d = matrix.c * b1 + matrix.d * d1;
+    this.tx = matrix.tx * a1 + matrix.ty * c1 + this.tx;
+    this.ty = matrix.tx * b1 + matrix.ty * d1 + this.ty;
+    return this;
+  }
+
+  identity() {
+    return this.setTo(1, 0, 0, 1, 0, 0);
+  }
+
+}