pixi-pixelate
Version:
draw proper pixelated graphic primitives for pixi.js (i.e., point, line, circle, ellipse, arc, and filled versions)
763 lines (692 loc) • 82.5 kB
JavaScript
'use strict';
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var PIXI = require('pixi.js');
var Angle = require('yy-angle');
/**
* pixi-pixelate: a container to create proper pixelated graphics
*/
var Pixelate = function (_PIXI$Container) {
_inherits(Pixelate, _PIXI$Container);
function Pixelate() {
_classCallCheck(this, Pixelate);
var _this = _possibleConstructorReturn(this, (Pixelate.__proto__ || Object.getPrototypeOf(Pixelate)).call(this));
_this.cursor = { x: 0, y: 0 };
_this.tint = 0xffffff;
_this._lineStyle = { width: 1, tint: 0xffffff, alpha: 1, direction: 'up' };
_this.cache = [];
return _this;
}
/**
* clear all graphics
* @returns {Pixelate}
*/
_createClass(Pixelate, [{
key: 'clear',
value: function clear() {
while (this.children.length) {
this.cache.push(this.children.pop());
}
return this;
}
/**
* texture to use for sprites (defaults to PIXI.Texture.WHITE)
* @type {PIXI.Texture}
*/
}, {
key: 'getPoint',
/**
* creates or gets an old sprite
* @param {number} tint
* @param {number} alpha
* @private
*/
value: function getPoint(tint, alpha) {
var point = void 0;
if (this.cache.length) {
point = this.addChild(this.cache.pop());
} else {
point = this.addChild(new PIXI.Sprite(Pixelate.texture));
}
point.tint = typeof tint === 'undefined' ? this._lineStyle.tint : tint;
point.alpha = typeof alpha === 'undefined' ? this._lineStyle.alpha : alpha;
return point;
}
/**
* draw a list of points
* @param {(number[]|PIXI.Point[]|PIXI.PointLike[])} points
* @param {number} tint
* @param {number} alpha
*/
}, {
key: 'points',
value: function points(_points, tint, alpha) {
if (isNaN(_points[0])) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = _points[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var point = _step.value;
this.point(point.x, point.y, tint, alpha);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
} else {
for (var i = 0; i < _points.length; i += 2) {
this.point(_points[i], _points[i + 1], tint, alpha);
}
}
}
/**
* add a point using lineStyle or provided tint and alpha
* @param {number} x
* @param {number} y
* @param {number} [tint]
* @param {number} [alpha]
* @returns {Pixelate}
*/
}, {
key: 'point',
value: function point(x, y, tint, alpha) {
var point = this.getPoint(tint, alpha);
point.position.set(x, y);
point.width = point.height = 1;
return this;
}
/**
* if lineStyle.width > 1 then use this direction to place the next line; center=alternate up and down
* @typedef {string} LineDirection (up, center, down)
*/
/**
* set linestyle for pixelated layer
* NOTE: width only works for line() for now
* @param {number} width
* @param {number} [tint=0xffffff]
* @param {number} [alpha=1]
* @param {LineDirection} [direction=up] (up, center, down)
* @returns {Pixelate}
*/
}, {
key: 'lineStyle',
value: function lineStyle(width, tint, alpha, direction) {
this._lineStyle.width = width;
this._lineStyle.tint = typeof tint !== 'undefined' ? tint : 0xffffff;
this._lineStyle.alpha = typeof alpha !== 'undefined' ? alpha : 1;
this._lineStyle.direction = direction || 'up';
return this;
}
/**
* move cursor to this location
* @param {number} x
* @param {number} y
* @returns {Pixelate}
*/
}, {
key: 'moveTo',
value: function moveTo(x, y) {
this.cursor.x = x;
this.cursor.y = y;
return this;
}
/**
* draw a pixelated line between two points and move cursor to the second point
* @param {number} x0
* @param {number} y0
* @param {number} x1
* @param {number} y1
* @param {number} [tint]
* @param {number} [alpha]
* @param {number} [lineWidth]
* @param {LineDirection} [lineDirection]
* @returns {Pixelate}
*/
}, {
key: 'line',
value: function line(x0, y0, x1, y1, tint, alpha, lineWidth, lineDirection) {
lineWidth = typeof lineWidth === 'undefined' ? this._lineStyle.width : lineWidth;
lineDirection = lineDirection || this._lineStyle.direction;
if (lineWidth === 1) {
this.drawPoints(this.linePoints(x0, y0, x1, y1), tint, alpha);
} else {
var angle = Angle.angleTwoPoints(x0, y0, x1, y1) + Math.PI / 2 * (lineDirection === 'up' ? -1 : 1);
var cos = Math.cos(angle);
var sin = Math.sin(angle);
var points = [];
if (lineDirection === 'center') {
var half = lineWidth / 2;
points.push(x0 + Math.round(cos * half), y0 + Math.round(sin * half));
points.push(x1 + Math.round(cos * half), y1 + Math.round(sin * half));
points.push(x1 - Math.round(cos * half), y1 - Math.round(sin * half));
points.push(x0 - Math.round(cos * half), y0 - Math.round(sin * half));
} else {
points.push(x0, y0);
points.push(x0 + Math.round(cos * lineWidth), y0 + Math.round(sin * lineWidth));
points.push(x1 + Math.round(cos * lineWidth), y1 + Math.round(sin * lineWidth));
points.push(x1, y1);
}
this.polygonFill(points, tint, alpha, 1);
}
return this;
}
/**
* draw a pixelated line between two points and move cursor to the second point
* based on https://github.com/madbence/node-bresenham/blob/master/index.js
* @private
* @param {number} x0
* @param {number} y0
* @param {number} x1
* @param {number} y1
* @param {number[]} [points]
* @returns {number[]}
*/
}, {
key: 'linePoints',
value: function linePoints(x0, y0, x1, y1, points) {
points = points || [];
points.push([x0, y0]);
var dx = x1 - x0;
var dy = y1 - y0;
var adx = Math.abs(dx);
var ady = Math.abs(dy);
var eps = 0;
var sx = dx > 0 ? 1 : -1;
var sy = dy > 0 ? 1 : -1;
if (adx > ady) {
for (var x = x0, y = y0; sx < 0 ? x >= x1 : x <= x1; x += sx) {
points.push([x, y]);
eps += ady;
if (eps << 1 >= adx) {
y += sy;
eps -= adx;
}
}
} else {
for (var x = x0, y = y0; sy < 0 ? y >= y1 : y <= y1; y += sy) {
points.push([x, y]);
eps += adx;
if (eps << 1 >= ady) {
x += sx;
eps -= ady;
}
}
}
return points;
}
/**
* create a unique array
* from https://stackoverflow.com/a/9229821/1955997
* @private
* @param {Array} a
*/
}, {
key: 'hashUnique',
value: function hashUnique(a) {
var seen = {};
return a.filter(function (item) {
var key = item[0] + '.' + item[1];
return seen.hasOwnProperty(key) ? false : seen[key] = true;
});
}
/**
* draw a set of points, removing duplicates first
* @private
* @param {object[]}
*/
}, {
key: 'drawPoints',
value: function drawPoints(points, tint, alpha) {
points = this.hashUnique(points);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = points[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var point = _step2.value;
this.point(point[0], point[1], tint, alpha);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
}
/**
* draw a pixelated line from the cursor position to this position
* @param {number} x
* @param {number} y
* @returns {Pixelate}
*/
}, {
key: 'lineTo',
value: function lineTo(x, y) {
this.drawPoints(this.linePoints(this.cursor.x, this.cursor.y, x, y));
this.cursor.x = x;
this.cursor.y = y;
return this;
}
/**
* draw a pixelated circle
* from https://en.wikipedia.org/wiki/Midpoint_circle_algorithm
* @param {number} x0
* @param {number} y0
* @param {number} radius
* @param {number} [tint]
* @param {number} [alpha]
* @returns {Pixelate}
*/
}, {
key: 'circle',
value: function circle(x0, y0, radius, tint, alpha) {
var points = [];
var x = radius;
var y = 0;
var decisionOver2 = 1 - x; // Decision criterion divided by 2 evaluated at x=r, y=0
while (x >= y) {
points.push([x + x0, y + y0]);
points.push([y + x0, x + y0]);
points.push([-x + x0, y + y0]);
points.push([-y + x0, x + y0]);
points.push([-x + x0, -y + y0]);
points.push([-y + x0, -x + y0]);
points.push([x + x0, -y + y0]);
points.push([y + x0, -x + y0]);
y++;
if (decisionOver2 <= 0) {
decisionOver2 += 2 * y + 1; // Change in decision criterion for y -> y+1
} else {
x--;
decisionOver2 += 2 * (y - x) + 1; // Change for y -> y+1, x -> x-1
}
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* draw and fill circle
* @param {number} x center
* @param {number} y center
* @param {number} radius
* @param {number} tint
* @param {number} alpha
*/
}, {
key: 'circleFill',
value: function circleFill(x0, y0, radius, tint, alpha) {
var points = [];
var x = radius;
var y = 0;
var decisionOver2 = 1 - x; // Decision criterion divided by 2 evaluated at x=r, y=0
while (x >= y) {
this.rectPoints(-x + x0, y + y0, x * 2 + 1, 1, points);
this.rectPoints(-y + x0, x + y0, y * 2 + 1, 1, points);
this.rectPoints(-x + x0, -y + y0, x * 2 + 1, 1, points);
this.rectPoints(-y + x0, -x + y0, y * 2 + 1, 1, points);
y++;
if (decisionOver2 <= 0) {
decisionOver2 += 2 * y + 1; // Change in decision criterion for y -> y+1
} else {
x--;
decisionOver2 += 2 * (y - x) + 1; // Change for y -> y+1, x -> x-1
}
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* return an array of points for a rect
* @private
* @param {number} x0
* @param {number} y0
* @param {number} width
* @param {number} height
* @param {number[]} [points]
* @returns {object[]}
*/
}, {
key: 'rectPoints',
value: function rectPoints(x0, y0, width, height, points) {
points = points || [];
for (var y = y0; y < y0 + height; y++) {
for (var x = x0; x < x0 + width; x++) {
points.push([x, y]);
}
}
return points;
}
/**
* draw the outline of a rect
* @param {number} x
* @param {number} y
* @param {number} width
* @param {number} height
* @param {number} tint
* @param {number} alpha
* @return {Pixelate}
*/
}, {
key: 'rect',
value: function rect(x, y, width, height, tint, alpha) {
if (width === 1) {
var point = this.getPoint(tint, alpha);
point.position.set(x, y);
point.width = 1;
point.height = height;
} else if (height === 1) {
var _point = this.getPoint(tint, alpha);
_point.position.set(x, y);
_point.width = 1;
_point.height = 1;
} else {
var top = this.getPoint(tint, alpha);
top.position.set(x, y);
top.width = width + 1;
top.height = 1;
var bottom = this.getPoint(tint, alpha);
bottom.position.set(x, y + height);
bottom.width = width + 1;
bottom.height = 1;
var left = this.getPoint(tint, alpha);
left.position.set(x, y + 1);
left.width = 1;
left.height = height - 1;
var right = this.getPoint(tint, alpha);
right.position.set(x + width, y + 1);
right.width = 1;
right.height = height - 1;
}
return this;
}
/**
* draw and fill rectangle
* @param {number} x
* @param {number} y
* @param {number} width
* @param {number} height
* @param {number} [tint]
* @param {number} [alpha]
* @returns {Pixelate}
*/
}, {
key: 'rectFill',
value: function rectFill(x, y, width, height, tint, alpha) {
var point = this.getPoint(tint, alpha);
point.position.set(x, y);
point.width = width + 1;
point.height = height + 1;
return this;
}
/**
* draw a pixelated ellipse
* from http://cfetch.blogspot.tw/2014/01/wap-to-draw-ellipse-using-midpoint.html
* @param {number} xc center
* @param {number} yc center
* @param {number} rx - radius x-axis
* @param {number} ry - radius y-axis
* @param {number} tint
* @param {number} alpha
* @returns {Pixelate}
*/
}, {
key: 'ellipse',
value: function ellipse(xc, yc, rx, ry, tint, alpha) {
var points = [];
var x = 0,
y = ry;
var p = ry * ry - rx * rx * ry + rx * rx / 4;
while (2 * x * ry * ry < 2 * y * rx * rx) {
points.push([xc + x, yc - y]);
points.push([xc - x, yc + y]);
points.push([xc + x, yc + y]);
points.push([xc - x, yc - y]);
if (p < 0) {
x = x + 1;
p = p + 2 * ry * ry * x + ry * ry;
} else {
x = x + 1;
y = y - 1;
p = p + (2 * ry * ry * x + ry * ry) - 2 * rx * rx * y;
}
}
p = (x + 0.5) * (x + 0.5) * ry * ry + (y - 1) * (y - 1) * rx * rx - rx * rx * ry * ry;
while (y >= 0) {
points.push([xc + x, yc - y]);
points.push([xc - x, yc + y]);
points.push([xc + x, yc + y]);
points.push([xc - x, yc - y]);
if (p > 0) {
y = y - 1;
p = p - 2 * rx * rx * y + rx * rx;
} else {
y = y - 1;
x = x + 1;
p = p + 2 * ry * ry * x - 2 * rx * rx * y - rx * rx;
}
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* draw and fill ellipse
* @param {number} xc - x-center
* @param {number} yc - y-center
* @param {number} rx - radius x-axis
* @param {number} ry - radius y-axis
* @param {number} tint
* @returns {Pixelate}
*/
}, {
key: 'ellipseFill',
value: function ellipseFill(xc, yc, rx, ry, tint, alpha) {
var points = [];
var x = 0,
y = ry;
var p = ry * ry - rx * rx * ry + rx * rx / 4;
while (2 * x * ry * ry < 2 * y * rx * rx) {
this.rectPoints(xc - x, yc - y, x * 2 + 1, 1, points);
this.rectPoints(xc - x, yc + y, x * 2 + 1, 1, points);
if (p < 0) {
x = x + 1;
p = p + 2 * ry * ry * x + ry * ry;
} else {
x = x + 1;
y = y - 1;
p = p + (2 * ry * ry * x + ry * ry) - 2 * rx * rx * y;
}
}
p = (x + 0.5) * (x + 0.5) * ry * ry + (y - 1) * (y - 1) * rx * rx - rx * rx * ry * ry;
while (y >= 0) {
this.rectPoints(xc - x, yc - y, x * 2 + 1, 1, points);
this.rectPoints(xc - x, yc + y, x * 2 + 1, 1, points);
if (p > 0) {
y = y - 1;
p = p - 2 * rx * rx * y + rx * rx;
} else {
y = y - 1;
x = x + 1;
p = p + 2 * ry * ry * x - 2 * rx * rx * y - rx * rx;
}
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* draw a pixelated polygon
* @param {number[]} vertices
* @param {number} tint
* @param {number} alpha
* @returns {Pixelate}
*/
}, {
key: 'polygon',
value: function polygon(vertices, tint, alpha) {
var points = [];
for (var i = 2; i < vertices.length; i += 2) {
this.linePoints(vertices[i - 2], vertices[i - 1], vertices[i], vertices[i + 1], points);
}
if (vertices[vertices.length - 2] !== vertices[0] || vertices[vertices.length - 1] !== vertices[1]) {
this.linePoints(vertices[vertices.length - 2], vertices[vertices.length - 1], vertices[0], vertices[1], points);
}
this.drawPoints(points, tint, alpha);
}
/**
* draw and fill pixelated polygon
* @param {number[]} vertices
* @param {number} tint
* @param {number} alpha
* @returns {Pixelate}
*/
}, {
key: 'polygonFill',
value: function polygonFill(vertices, tint, alpha) {
function mod(n, m) {
return (n % m + m) % m;
}
var points = [];
var edges = [],
active = [];
var minY = Infinity,
maxY = 0;
for (var i = 0; i < vertices.length; i += 2) {
var p1 = { x: vertices[i], y: vertices[i + 1] };
var p2 = { x: vertices[mod(i + 2, vertices.length)], y: vertices[mod(i + 3, vertices.length)] };
if (p1.y - p2.y !== 0) {
var edge = {};
edge.p1 = p1;
edge.p2 = p2;
if (p1.y < p2.y) {
edge.minY = p1.y;
edge.minX = p1.x;
} else {
edge.minY = p2.y;
edge.minX = p2.x;
}
minY = edge.minY < minY ? edge.minY : minY;
edge.maxY = Math.max(p1.y, p2.y);
maxY = edge.maxY > maxY ? edge.maxY : maxY;
if (p1.x - p2.x === 0) {
edge.slope = Infinity;
edge.b = p1.x;
} else {
edge.slope = (p1.y - p2.y) / (p1.x - p2.x);
edge.b = p1.y - edge.slope * p1.x;
}
edges.push(edge);
}
}
edges.sort(function (a, b) {
return a.minY - b.minY;
});
for (var y = minY; y <= maxY; y++) {
for (var _i = 0; _i < edges.length; _i++) {
var _edge = edges[_i];
if (_edge.minY === y) {
active.push(_edge);
edges.splice(_i, 1);
_i--;
}
}
for (var _i2 = 0; _i2 < active.length; _i2++) {
var _edge2 = active[_i2];
if (_edge2.maxY < y) {
active.splice(_i2, 1);
_i2--;
} else {
if (_edge2.slope !== Infinity) {
_edge2.x = Math.round((y - _edge2.b) / _edge2.slope);
} else {
_edge2.x = _edge2.b;
}
}
}
if (active.length) {
active.sort(function (a, b) {
return a.x - b.x === 0 ? b.maxY - a.maxY : a.x - b.x;
});
var bit = true,
current = 1;
for (var x = active[0].x; x <= active[active.length - 1].x; x++) {
if (bit) {
points.push([x, y]);
}
if (active[current].x === x) {
if (active[current].maxY !== y) {
bit = !bit;
}
current++;
}
}
} else {
return this;
}
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* draw arc
* @param {number} x0 - x-start
* @param {number} y0 - y-start
* @param {number} radius - radius
* @param {number} start angle (radians)
* @param {number} end angle (radians)
* @param {number} tint
* @param {number} alpha
* @returns {Pixelate}
*/
}, {
key: 'arc',
value: function arc(x0, y0, radius, start, end, tint, alpha) {
var interval = Math.PI / radius / 4;
var points = [];
for (var i = start; i <= end; i += interval) {
points.push([Math.floor(x0 + Math.cos(i) * radius), Math.floor(y0 + Math.sin(i) * radius)]);
}
this.drawPoints(points, tint, alpha);
return this;
}
/**
* empties cache of old sprites
*/
}, {
key: 'flush',
value: function flush() {
this.cache = [];
}
}], [{
key: 'texture',
get: function get() {
return Pixelate._texture;
},
set: function set(value) {
Pixelate._texture = value;
}
}]);
return Pixelate;
}(PIXI.Container);
Pixelate._texture = PIXI.Texture.WHITE;
module.exports = Pixelate;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/pixelate.js"],"names":["PIXI","require","Angle","Pixelate","cursor","x","y","tint","_lineStyle","width","alpha","direction","cache","children","length","push","pop","point","addChild","Sprite","texture","points","isNaN","i","getPoint","position","set","height","x0","y0","x1","y1","lineWidth","lineDirection","drawPoints","linePoints","angle","angleTwoPoints","Math","PI","cos","sin","half","round","polygonFill","dx","dy","adx","abs","ady","eps","sx","sy","a","seen","filter","item","key","hasOwnProperty","hashUnique","radius","decisionOver2","rectPoints","top","bottom","left","right","xc","yc","rx","ry","p","vertices","mod","n","m","edges","active","minY","Infinity","maxY","p1","p2","edge","minX","max","slope","b","sort","splice","bit","current","start","end","interval","floor","_texture","value","Container","Texture","WHITE","module","exports"],"mappings":"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